[mirror_ubuntu-zesty-kernel.git] / tools / perf / util / parse-events.y

%pure-parser
%parse-param {void *_data}
%parse-param {void *scanner}
%lex-param {void* scanner}
%locations

%{

#define YYDEBUG 1

#include <linux/compiler.h>
#include <linux/list.h>
#include <linux/types.h>
#include "util.h"
#include "parse-events.h"
#include "parse-events-bison.h"

#define ABORT_ON(val) \
do { \
	if (val) \
		YYABORT; \
} while (0)

#define ALLOC_LIST(list) \
do { \
	list = malloc(sizeof(*list)); \
	ABORT_ON(!list);              \
	INIT_LIST_HEAD(list);         \
} while (0)

static inc_group_count(struct list_head *list,
		       struct parse_events_evlist *data)
{
	/* Count groups only have more than 1 members */
	if (!list_is_last(list->next, list))
		data->nr_groups++;
}

%}

%token PE_START_EVENTS PE_START_TERMS
%token PE_VALUE PE_VALUE_SYM_HW PE_VALUE_SYM_SW PE_RAW PE_TERM
%token PE_EVENT_NAME
%token PE_NAME
%token PE_BPF_OBJECT PE_BPF_SOURCE
%token PE_MODIFIER_EVENT PE_MODIFIER_BP
%token PE_NAME_CACHE_TYPE PE_NAME_CACHE_OP_RESULT
%token PE_PREFIX_MEM PE_PREFIX_RAW PE_PREFIX_GROUP
%token PE_ERROR
%token PE_PMU_EVENT_PRE PE_PMU_EVENT_SUF PE_KERNEL_PMU_EVENT
%type <num> PE_VALUE
%type <num> PE_VALUE_SYM_HW
%type <num> PE_VALUE_SYM_SW
%type <num> PE_RAW
%type <num> PE_TERM
%type <str> PE_NAME
%type <str> PE_BPF_OBJECT
%type <str> PE_BPF_SOURCE
%type <str> PE_NAME_CACHE_TYPE
%type <str> PE_NAME_CACHE_OP_RESULT
%type <str> PE_MODIFIER_EVENT
%type <str> PE_MODIFIER_BP
%type <str> PE_EVENT_NAME
%type <str> PE_PMU_EVENT_PRE PE_PMU_EVENT_SUF PE_KERNEL_PMU_EVENT
%type <num> value_sym
%type <head> event_config
%type <term> event_term
%type <head> event_pmu
%type <head> event_legacy_symbol
%type <head> event_legacy_cache
%type <head> event_legacy_mem
%type <head> event_legacy_tracepoint
%type <tracepoint_name> tracepoint_name
%type <head> event_legacy_numeric
%type <head> event_legacy_raw
%type <head> event_bpf_file
%type <head> event_def
%type <head> event_mod
%type <head> event_name
%type <head> event
%type <head> events
%type <head> group_def
%type <head> group
%type <head> groups

%union
{
	char *str;
	u64 num;
	struct list_head *head;
	struct parse_events_term *term;
	struct tracepoint_name {
		char *sys;
		char *event;
	} tracepoint_name;
}
%%

start:
PE_START_EVENTS start_events
|
PE_START_TERMS  start_terms

start_events: groups
{
	struct parse_events_evlist *data = _data;

	parse_events_update_lists($1, &data->list);
}

groups:
groups ',' group
{
	struct list_head *list  = $1;
	struct list_head *group = $3;

	parse_events_update_lists(group, list);
	$$ = list;
}
|
groups ',' event
{
	struct list_head *list  = $1;
	struct list_head *event = $3;

	parse_events_update_lists(event, list);
	$$ = list;
}
|
group
|
event

group:
group_def ':' PE_MODIFIER_EVENT
{
	struct list_head *list = $1;

	ABORT_ON(parse_events__modifier_group(list, $3));
	$$ = list;
}
|
group_def

group_def:
PE_NAME '{' events '}'
{
	struct list_head *list = $3;

	inc_group_count(list, _data);
	parse_events__set_leader($1, list);
	$$ = list;
}
|
'{' events '}'
{
	struct list_head *list = $2;

	inc_group_count(list, _data);
	parse_events__set_leader(NULL, list);
	$$ = list;
}

events:
events ',' event
{
	struct list_head *event = $3;
	struct list_head *list  = $1;

	parse_events_update_lists(event, list);
	$$ = list;
}
|
event

event: event_mod

event_mod:
event_name PE_MODIFIER_EVENT
{
	struct list_head *list = $1;

	/*
	 * Apply modifier on all events added by single event definition
	 * (there could be more events added for multiple tracepoint
	 * definitions via '*?'.
	 */
	ABORT_ON(parse_events__modifier_event(list, $2, false));
	$$ = list;
}
|
event_name

event_name:
PE_EVENT_NAME event_def
{
	ABORT_ON(parse_events_name($2, $1));
	free($1);
	$$ = $2;
}
|
event_def

event_def: event_pmu |
	   event_legacy_symbol |
	   event_legacy_cache sep_dc |
	   event_legacy_mem |
	   event_legacy_tracepoint sep_dc |
	   event_legacy_numeric sep_dc |
	   event_legacy_raw sep_dc |
	   event_bpf_file

event_pmu:
PE_NAME '/' event_config '/'
{
	struct parse_events_evlist *data = _data;
	struct list_head *list;

	ALLOC_LIST(list);
	ABORT_ON(parse_events_add_pmu(data, list, $1, $3));
	parse_events__free_terms($3);
	$$ = list;
}
|
PE_NAME '/' '/'
{
	struct parse_events_evlist *data = _data;
	struct list_head *list;

	ALLOC_LIST(list);
	ABORT_ON(parse_events_add_pmu(data, list, $1, NULL));
	$$ = list;
}
|
PE_KERNEL_PMU_EVENT sep_dc
{
	struct parse_events_evlist *data = _data;
	struct list_head *head;
	struct parse_events_term *term;
	struct list_head *list;

	ALLOC_LIST(head);
	ABORT_ON(parse_events_term__num(&term, PARSE_EVENTS__TERM_TYPE_USER,
					$1, 1, &@1, NULL));
	list_add_tail(&term->list, head);

	ALLOC_LIST(list);
	ABORT_ON(parse_events_add_pmu(data, list, "cpu", head));
	parse_events__free_terms(head);
	$$ = list;
}
|
PE_PMU_EVENT_PRE '-' PE_PMU_EVENT_SUF sep_dc
{
	struct parse_events_evlist *data = _data;
	struct list_head *head;
	struct parse_events_term *term;
	struct list_head *list;
	char pmu_name[128];
	snprintf(&pmu_name, 128, "%s-%s", $1, $3);

	ALLOC_LIST(head);
	ABORT_ON(parse_events_term__num(&term, PARSE_EVENTS__TERM_TYPE_USER,
					&pmu_name, 1, &@1, NULL));
	list_add_tail(&term->list, head);

	ALLOC_LIST(list);
	ABORT_ON(parse_events_add_pmu(data, list, "cpu", head));
	parse_events__free_terms(head);
	$$ = list;
}

value_sym:
PE_VALUE_SYM_HW
|
PE_VALUE_SYM_SW

event_legacy_symbol:
value_sym '/' event_config '/'
{
	struct parse_events_evlist *data = _data;
	struct list_head *list;
	int type = $1 >> 16;
	int config = $1 & 255;

	ALLOC_LIST(list);
	ABORT_ON(parse_events_add_numeric(data, list, type, config, $3));
	parse_events__free_terms($3);
	$$ = list;
}
|
value_sym sep_slash_dc
{
	struct parse_events_evlist *data = _data;
	struct list_head *list;
	int type = $1 >> 16;
	int config = $1 & 255;

	ALLOC_LIST(list);
	ABORT_ON(parse_events_add_numeric(data, list, type, config, NULL));
	$$ = list;
}

event_legacy_cache:
PE_NAME_CACHE_TYPE '-' PE_NAME_CACHE_OP_RESULT '-' PE_NAME_CACHE_OP_RESULT
{
	struct parse_events_evlist *data = _data;
	struct list_head *list;

	ALLOC_LIST(list);
	ABORT_ON(parse_events_add_cache(list, &data->idx, $1, $3, $5));
	$$ = list;
}
|
PE_NAME_CACHE_TYPE '-' PE_NAME_CACHE_OP_RESULT
{
	struct parse_events_evlist *data = _data;
	struct list_head *list;

	ALLOC_LIST(list);
	ABORT_ON(parse_events_add_cache(list, &data->idx, $1, $3, NULL));
	$$ = list;
}
|
PE_NAME_CACHE_TYPE
{
	struct parse_events_evlist *data = _data;
	struct list_head *list;

	ALLOC_LIST(list);
	ABORT_ON(parse_events_add_cache(list, &data->idx, $1, NULL, NULL));
	$$ = list;
}

event_legacy_mem:
PE_PREFIX_MEM PE_VALUE '/' PE_VALUE ':' PE_MODIFIER_BP sep_dc
{
	struct parse_events_evlist *data = _data;
	struct list_head *list;

	ALLOC_LIST(list);
	ABORT_ON(parse_events_add_breakpoint(list, &data->idx,
					     (void *) $2, $6, $4));
	$$ = list;
}
|
PE_PREFIX_MEM PE_VALUE '/' PE_VALUE sep_dc
{
	struct parse_events_evlist *data = _data;
	struct list_head *list;

	ALLOC_LIST(list);
	ABORT_ON(parse_events_add_breakpoint(list, &data->idx,
					     (void *) $2, NULL, $4));
	$$ = list;
}
|
PE_PREFIX_MEM PE_VALUE ':' PE_MODIFIER_BP sep_dc
{
	struct parse_events_evlist *data = _data;
	struct list_head *list;

	ALLOC_LIST(list);
	ABORT_ON(parse_events_add_breakpoint(list, &data->idx,
					     (void *) $2, $4, 0));
	$$ = list;
}
|
PE_PREFIX_MEM PE_VALUE sep_dc
{
	struct parse_events_evlist *data = _data;
	struct list_head *list;

	ALLOC_LIST(list);
	ABORT_ON(parse_events_add_breakpoint(list, &data->idx,
					     (void *) $2, NULL, 0));
	$$ = list;
}

event_legacy_tracepoint:
tracepoint_name
{
	struct parse_events_evlist *data = _data;
	struct parse_events_error *error = data->error;
	struct list_head *list;

	ALLOC_LIST(list);
	if (error)
		error->idx = @1.first_column;

	if (parse_events_add_tracepoint(list, &data->idx, $1.sys, $1.event,
					error, NULL))
		return -1;

	$$ = list;
}
|
tracepoint_name '/' event_config '/'
{
	struct parse_events_evlist *data = _data;
	struct parse_events_error *error = data->error;
	struct list_head *list;

	ALLOC_LIST(list);
	if (error)
		error->idx = @1.first_column;

	if (parse_events_add_tracepoint(list, &data->idx, $1.sys, $1.event,
					error, $3))
		return -1;

	$$ = list;
}

tracepoint_name:
PE_NAME '-' PE_NAME ':' PE_NAME
{
	char sys_name[128];
	struct tracepoint_name tracepoint;

	snprintf(&sys_name, 128, "%s-%s", $1, $3);
	tracepoint.sys = &sys_name;
	tracepoint.event = $5;

	$$ = tracepoint;
}
|
PE_NAME ':' PE_NAME
{
	struct tracepoint_name tracepoint = {$1, $3};

	$$ = tracepoint;
}

event_legacy_numeric:
PE_VALUE ':' PE_VALUE
{
	struct parse_events_evlist *data = _data;
	struct list_head *list;

	ALLOC_LIST(list);
	ABORT_ON(parse_events_add_numeric(data, list, (u32)$1, $3, NULL));
	$$ = list;
}

event_legacy_raw:
PE_RAW
{
	struct parse_events_evlist *data = _data;
	struct list_head *list;

	ALLOC_LIST(list);
	ABORT_ON(parse_events_add_numeric(data, list, PERF_TYPE_RAW, $1, NULL));
	$$ = list;
}

event_bpf_file:
PE_BPF_OBJECT
{
	struct parse_events_evlist *data = _data;
	struct parse_events_error *error = data->error;
	struct list_head *list;

	ALLOC_LIST(list);
	ABORT_ON(parse_events_load_bpf(data, list, $1, false));
	$$ = list;
}
|
PE_BPF_SOURCE
{
	struct parse_events_evlist *data = _data;
	struct list_head *list;

	ALLOC_LIST(list);
	ABORT_ON(parse_events_load_bpf(data, list, $1, true));
	$$ = list;
}

start_terms: event_config
{
	struct parse_events_terms *data = _data;
	data->terms = $1;
}

event_config:
event_config ',' event_term
{
	struct list_head *head = $1;
	struct parse_events_term *term = $3;

	ABORT_ON(!head);
	list_add_tail(&term->list, head);
	$$ = $1;
}
|
event_term
{
	struct list_head *head = malloc(sizeof(*head));
	struct parse_events_term *term = $1;

	ABORT_ON(!head);
	INIT_LIST_HEAD(head);
	list_add_tail(&term->list, head);
	$$ = head;
}

event_term:
PE_NAME '=' PE_NAME
{
	struct parse_events_term *term;

	ABORT_ON(parse_events_term__str(&term, PARSE_EVENTS__TERM_TYPE_USER,
					$1, $3, &@1, &@3));
	$$ = term;
}
|
PE_NAME '=' PE_VALUE
{
	struct parse_events_term *term;

	ABORT_ON(parse_events_term__num(&term, PARSE_EVENTS__TERM_TYPE_USER,
					$1, $3, &@1, &@3));
	$$ = term;
}
|
PE_NAME '=' PE_VALUE_SYM_HW
{
	struct parse_events_term *term;
	int config = $3 & 255;

	ABORT_ON(parse_events_term__sym_hw(&term, $1, config));
	$$ = term;
}
|
PE_NAME
{
	struct parse_events_term *term;

	ABORT_ON(parse_events_term__num(&term, PARSE_EVENTS__TERM_TYPE_USER,
					$1, 1, &@1, NULL));
	$$ = term;
}
|
PE_VALUE_SYM_HW
{
	struct parse_events_term *term;
	int config = $1 & 255;

	ABORT_ON(parse_events_term__sym_hw(&term, NULL, config));
	$$ = term;
}
|
PE_TERM '=' PE_NAME
{
	struct parse_events_term *term;

	ABORT_ON(parse_events_term__str(&term, (int)$1, NULL, $3, &@1, &@3));
	$$ = term;
}
|
PE_TERM '=' PE_VALUE
{
	struct parse_events_term *term;

	ABORT_ON(parse_events_term__num(&term, (int)$1, NULL, $3, &@1, &@3));
	$$ = term;
}
|
PE_TERM
{
	struct parse_events_term *term;

	ABORT_ON(parse_events_term__num(&term, (int)$1, NULL, 1, &@1, NULL));
	$$ = term;
}

sep_dc: ':' |

sep_slash_dc: '/' | ':' |

%%

void parse_events_error(YYLTYPE *loc, void *data,
			void *scanner __maybe_unused,
			char const *msg __maybe_unused)
{
	parse_events_evlist_error(data, loc->last_column, "parser error");
}
Commit	Line	Data
ac20de6f	1	%pure-parser
46010ab2	2	%parse-param {void *_data}
ac20de6f ZY	3	%parse-param {void *scanner}
ac20de6f ZY	4	%lex-param {void* scanner}
6297d423	5	%locations
89812fc8 JO	6
	7	%{
	8
	9	#define YYDEBUG 1
	10
	11	#include <linux/compiler.h>
	12	#include <linux/list.h>
d944c4ee	13	#include <linux/types.h>
89812fc8 JO	14	#include "util.h"
89812fc8 JO	15	#include "parse-events.h"
ac20de6f	16	#include "parse-events-bison.h"
89812fc8	17
89812fc8 JO	18	#define ABORT_ON(val) \
	19	do { \
	20	if (val) \
	21	YYABORT; \
	22	} while (0)
	23
c5cd8ac0 DA	24	#define ALLOC_LIST(list) \
	25	do { \
	26	list = malloc(sizeof(*list)); \
	27	ABORT_ON(!list); \
	28	INIT_LIST_HEAD(list); \
	29	} while (0)
	30
97f63e4a NK	31	static inc_group_count(struct list_head *list,
	32	struct parse_events_evlist *data)
	33	{
	34	/* Count groups only have more than 1 members */
	35	if (!list_is_last(list->next, list))
	36	data->nr_groups++;
	37	}
	38
89812fc8 JO	39	%}
89812fc8 JO	40
90e2b22d	41	%token PE_START_EVENTS PE_START_TERMS
cf3506dc	42	%token PE_VALUE PE_VALUE_SYM_HW PE_VALUE_SYM_SW PE_RAW PE_TERM
ac2ba9f3	43	%token PE_EVENT_NAME
89812fc8	44	%token PE_NAME
d509db04	45	%token PE_BPF_OBJECT PE_BPF_SOURCE
89812fc8 JO	46	%token PE_MODIFIER_EVENT PE_MODIFIER_BP
89812fc8 JO	47	%token PE_NAME_CACHE_TYPE PE_NAME_CACHE_OP_RESULT
89efb029	48	%token PE_PREFIX_MEM PE_PREFIX_RAW PE_PREFIX_GROUP
89812fc8	49	%token PE_ERROR
ba32a451	50	%token PE_PMU_EVENT_PRE PE_PMU_EVENT_SUF PE_KERNEL_PMU_EVENT
89812fc8	51	%type <num> PE_VALUE
cf3506dc JO	52	%type <num> PE_VALUE_SYM_HW
cf3506dc JO	53	%type <num> PE_VALUE_SYM_SW
89812fc8	54	%type <num> PE_RAW
8f707d84	55	%type <num> PE_TERM
89812fc8	56	%type <str> PE_NAME
84c86ca1	57	%type <str> PE_BPF_OBJECT
d509db04	58	%type <str> PE_BPF_SOURCE
89812fc8 JO	59	%type <str> PE_NAME_CACHE_TYPE
	60	%type <str> PE_NAME_CACHE_OP_RESULT
	61	%type <str> PE_MODIFIER_EVENT
	62	%type <str> PE_MODIFIER_BP
ac2ba9f3	63	%type <str> PE_EVENT_NAME
ba32a451	64	%type <str> PE_PMU_EVENT_PRE PE_PMU_EVENT_SUF PE_KERNEL_PMU_EVENT
cf3506dc	65	%type <num> value_sym
8f707d84 JO	66	%type <head> event_config
8f707d84 JO	67	%type <term> event_term
b847cbdc JO	68	%type <head> event_pmu
	69	%type <head> event_legacy_symbol
	70	%type <head> event_legacy_cache
	71	%type <head> event_legacy_mem
	72	%type <head> event_legacy_tracepoint
865582c3	73	%type <tracepoint_name> tracepoint_name
b847cbdc JO	74	%type <head> event_legacy_numeric
b847cbdc JO	75	%type <head> event_legacy_raw
84c86ca1	76	%type <head> event_bpf_file
b847cbdc	77	%type <head> event_def
ac2ba9f3 RR	78	%type <head> event_mod
ac2ba9f3 RR	79	%type <head> event_name
89efb029 JO	80	%type <head> event
	81	%type <head> events
	82	%type <head> group_def
	83	%type <head> group
	84	%type <head> groups
89812fc8 JO	85
	86	%union
	87	{
	88	char *str;
b527bab5	89	u64 num;
8f707d84	90	struct list_head *head;
6cee6cd3	91	struct parse_events_term *term;
865582c3 HK	92	struct tracepoint_name {
	93	char *sys;
	94	char *event;
	95	} tracepoint_name;
89812fc8 JO	96	}
	97	%%
	98
90e2b22d	99	start:
89efb029	100	PE_START_EVENTS start_events
90e2b22d	101	\|
89efb029 JO	102	PE_START_TERMS start_terms
	103
	104	start_events: groups
	105	{
23b6339b	106	struct parse_events_evlist *data = _data;
89efb029 JO	107
	108	parse_events_update_lists($1, &data->list);
	109	}
	110
	111	groups:
	112	groups ',' group
	113	{
	114	struct list_head *list = $1;
	115	struct list_head *group = $3;
	116
	117	parse_events_update_lists(group, list);
	118	$$ = list;
	119	}
	120	\|
	121	groups ',' event
	122	{
	123	struct list_head *list = $1;
	124	struct list_head *event = $3;
	125
	126	parse_events_update_lists(event, list);
	127	$$ = list;
	128	}
	129	\|
	130	group
	131	\|
	132	event
	133
	134	group:
	135	group_def ':' PE_MODIFIER_EVENT
	136	{
	137	struct list_head *list = $1;
	138
	139	ABORT_ON(parse_events__modifier_group(list, $3));
	140	$$ = list;
	141	}
	142	\|
	143	group_def
	144
	145	group_def:
	146	PE_NAME '{' events '}'
	147	{
	148	struct list_head *list = $3;
	149
97f63e4a	150	inc_group_count(list, _data);
63dab225	151	parse_events__set_leader($1, list);
89efb029 JO	152	$$ = list;
	153	}
	154	\|
	155	'{' events '}'
	156	{
	157	struct list_head *list = $2;
	158
97f63e4a	159	inc_group_count(list, _data);
63dab225	160	parse_events__set_leader(NULL, list);
89efb029 JO	161	$$ = list;
89efb029 JO	162	}
90e2b22d	163
89812fc8	164	events:
89efb029 JO	165	events ',' event
	166	{
	167	struct list_head *event = $3;
	168	struct list_head *list = $1;
	169
	170	parse_events_update_lists(event, list);
	171	$$ = list;
	172	}
	173	\|
	174	event
89812fc8	175
ac2ba9f3 RR	176	event: event_mod
	177
	178	event_mod:
	179	event_name PE_MODIFIER_EVENT
89812fc8	180	{
89efb029	181	struct list_head *list = $1;
46010ab2	182
5d7be90e JO	183	/*
	184	* Apply modifier on all events added by single event definition
	185	* (there could be more events added for multiple tracepoint
	186	* definitions via '*?'.
	187	*/
f5b1135b	188	ABORT_ON(parse_events__modifier_event(list, $2, false));
89efb029	189	$$ = list;
89812fc8 JO	190	}
89812fc8 JO	191	\|
ac2ba9f3 RR	192	event_name
	193
	194	event_name:
	195	PE_EVENT_NAME event_def
	196	{
	197	ABORT_ON(parse_events_name($2, $1));
	198	free($1);
	199	$$ = $2;
	200	}
	201	\|
89812fc8 JO	202	event_def
89812fc8 JO	203
5f537a26 JO	204	event_def: event_pmu \|
5f537a26 JO	205	event_legacy_symbol \|
89812fc8 JO	206	event_legacy_cache sep_dc \|
	207	event_legacy_mem \|
	208	event_legacy_tracepoint sep_dc \|
	209	event_legacy_numeric sep_dc \|
84c86ca1 WN	210	event_legacy_raw sep_dc \|
84c86ca1 WN	211	event_bpf_file
89812fc8	212
5f537a26 JO	213	event_pmu:
	214	PE_NAME '/' event_config '/'
	215	{
23b6339b	216	struct parse_events_evlist *data = _data;
c5cd8ac0	217	struct list_head *list;
b847cbdc	218
c5cd8ac0	219	ALLOC_LIST(list);
36adec85	220	ABORT_ON(parse_events_add_pmu(data, list, $1, $3));
5f537a26	221	parse_events__free_terms($3);
b847cbdc	222	$$ = list;
5f537a26	223	}
ad962273 AH	224	\|
	225	PE_NAME '/' '/'
	226	{
	227	struct parse_events_evlist *data = _data;
	228	struct list_head *list;
	229
	230	ALLOC_LIST(list);
36adec85	231	ABORT_ON(parse_events_add_pmu(data, list, $1, NULL));
ad962273 AH	232	$$ = list;
ad962273 AH	233	}
ba32a451 KL	234	\|
	235	PE_KERNEL_PMU_EVENT sep_dc
	236	{
	237	struct parse_events_evlist *data = _data;
	238	struct list_head *head;
	239	struct parse_events_term *term;
	240	struct list_head *list;
	241
	242	ALLOC_LIST(head);
	243	ABORT_ON(parse_events_term__num(&term, PARSE_EVENTS__TERM_TYPE_USER,
cecf3a2e	244	$1, 1, &@1, NULL));
ba32a451 KL	245	list_add_tail(&term->list, head);
	246
	247	ALLOC_LIST(list);
36adec85	248	ABORT_ON(parse_events_add_pmu(data, list, "cpu", head));
ba32a451 KL	249	parse_events__free_terms(head);
	250	$$ = list;
	251	}
	252	\|
	253	PE_PMU_EVENT_PRE '-' PE_PMU_EVENT_SUF sep_dc
	254	{
	255	struct parse_events_evlist *data = _data;
	256	struct list_head *head;
	257	struct parse_events_term *term;
	258	struct list_head *list;
	259	char pmu_name[128];
	260	snprintf(&pmu_name, 128, "%s-%s", $1, $3);
	261
	262	ALLOC_LIST(head);
	263	ABORT_ON(parse_events_term__num(&term, PARSE_EVENTS__TERM_TYPE_USER,
cecf3a2e	264	&pmu_name, 1, &@1, NULL));
ba32a451 KL	265	list_add_tail(&term->list, head);
	266
	267	ALLOC_LIST(list);
5ad4da43	268	ABORT_ON(parse_events_add_pmu(data, list, "cpu", head));
ba32a451 KL	269	parse_events__free_terms(head);
	270	$$ = list;
	271	}
5f537a26	272
cf3506dc JO	273	value_sym:
	274	PE_VALUE_SYM_HW
	275	\|
	276	PE_VALUE_SYM_SW
	277
89812fc8	278	event_legacy_symbol:
cf3506dc	279	value_sym '/' event_config '/'
89812fc8	280	{
23b6339b	281	struct parse_events_evlist *data = _data;
c5cd8ac0	282	struct list_head *list;
89812fc8 JO	283	int type = $1 >> 16;
	284	int config = $1 & 255;
	285
c5cd8ac0	286	ALLOC_LIST(list);
87d650be	287	ABORT_ON(parse_events_add_numeric(data, list, type, config, $3));
8f707d84	288	parse_events__free_terms($3);
b847cbdc	289	$$ = list;
8f707d84 JO	290	}
8f707d84 JO	291	\|
cf3506dc	292	value_sym sep_slash_dc
8f707d84	293	{
23b6339b	294	struct parse_events_evlist *data = _data;
c5cd8ac0	295	struct list_head *list;
8f707d84 JO	296	int type = $1 >> 16;
	297	int config = $1 & 255;
	298
c5cd8ac0	299	ALLOC_LIST(list);
87d650be	300	ABORT_ON(parse_events_add_numeric(data, list, type, config, NULL));
b847cbdc	301	$$ = list;
89812fc8 JO	302	}
	303
	304	event_legacy_cache:
	305	PE_NAME_CACHE_TYPE '-' PE_NAME_CACHE_OP_RESULT '-' PE_NAME_CACHE_OP_RESULT
	306	{
23b6339b	307	struct parse_events_evlist *data = _data;
c5cd8ac0	308	struct list_head *list;
b847cbdc	309
c5cd8ac0 DA	310	ALLOC_LIST(list);
c5cd8ac0 DA	311	ABORT_ON(parse_events_add_cache(list, &data->idx, $1, $3, $5));
b847cbdc	312	$$ = list;
89812fc8 JO	313	}
	314	\|
	315	PE_NAME_CACHE_TYPE '-' PE_NAME_CACHE_OP_RESULT
	316	{
23b6339b	317	struct parse_events_evlist *data = _data;
c5cd8ac0	318	struct list_head *list;
b847cbdc	319
c5cd8ac0 DA	320	ALLOC_LIST(list);
c5cd8ac0 DA	321	ABORT_ON(parse_events_add_cache(list, &data->idx, $1, $3, NULL));
b847cbdc	322	$$ = list;
89812fc8 JO	323	}
	324	\|
	325	PE_NAME_CACHE_TYPE
	326	{
23b6339b	327	struct parse_events_evlist *data = _data;
c5cd8ac0	328	struct list_head *list;
b847cbdc	329
c5cd8ac0 DA	330	ALLOC_LIST(list);
c5cd8ac0 DA	331	ABORT_ON(parse_events_add_cache(list, &data->idx, $1, NULL, NULL));
b847cbdc	332	$$ = list;
89812fc8 JO	333	}
	334
	335	event_legacy_mem:
3741eb9f JS	336	PE_PREFIX_MEM PE_VALUE '/' PE_VALUE ':' PE_MODIFIER_BP sep_dc
	337	{
	338	struct parse_events_evlist *data = _data;
	339	struct list_head *list;
	340
	341	ALLOC_LIST(list);
	342	ABORT_ON(parse_events_add_breakpoint(list, &data->idx,
	343	(void *) $2, $6, $4));
	344	$$ = list;
	345	}
	346	\|
	347	PE_PREFIX_MEM PE_VALUE '/' PE_VALUE sep_dc
	348	{
	349	struct parse_events_evlist *data = _data;
	350	struct list_head *list;
	351
	352	ALLOC_LIST(list);
	353	ABORT_ON(parse_events_add_breakpoint(list, &data->idx,
	354	(void *) $2, NULL, $4));
	355	$$ = list;
	356	}
	357	\|
89812fc8 JO	358	PE_PREFIX_MEM PE_VALUE ':' PE_MODIFIER_BP sep_dc
89812fc8 JO	359	{
23b6339b	360	struct parse_events_evlist *data = _data;
c5cd8ac0	361	struct list_head *list;
b847cbdc	362
c5cd8ac0 DA	363	ALLOC_LIST(list);
c5cd8ac0 DA	364	ABORT_ON(parse_events_add_breakpoint(list, &data->idx,
3741eb9f	365	(void *) $2, $4, 0));
b847cbdc	366	$$ = list;
89812fc8 JO	367	}
	368	\|
	369	PE_PREFIX_MEM PE_VALUE sep_dc
	370	{
23b6339b	371	struct parse_events_evlist *data = _data;
c5cd8ac0	372	struct list_head *list;
b847cbdc	373
c5cd8ac0 DA	374	ALLOC_LIST(list);
c5cd8ac0 DA	375	ABORT_ON(parse_events_add_breakpoint(list, &data->idx,
3741eb9f	376	(void *) $2, NULL, 0));
b847cbdc	377	$$ = list;
89812fc8 JO	378	}
	379
	380	event_legacy_tracepoint:
865582c3	381	tracepoint_name
2b9032e0 AY	382	{
2b9032e0 AY	383	struct parse_events_evlist *data = _data;
19658171	384	struct parse_events_error *error = data->error;
2b9032e0	385	struct list_head *list;
2b9032e0 AY	386
2b9032e0 AY	387	ALLOC_LIST(list);
e637d177 HK	388	if (error)
	389	error->idx = @1.first_column;
	390
865582c3	391	if (parse_events_add_tracepoint(list, &data->idx, $1.sys, $1.event,
e637d177	392	error, NULL))
19658171	393	return -1;
e637d177 HK	394
	395	$$ = list;
	396	}
	397	\|
	398	tracepoint_name '/' event_config '/'
	399	{
	400	struct parse_events_evlist *data = _data;
	401	struct parse_events_error *error = data->error;
	402	struct list_head *list;
	403
	404	ALLOC_LIST(list);
	405	if (error)
	406	error->idx = @1.first_column;
	407
	408	if (parse_events_add_tracepoint(list, &data->idx, $1.sys, $1.event,
	409	error, $3))
	410	return -1;
	411
2b9032e0 AY	412	$$ = list;
2b9032e0 AY	413	}
865582c3 HK	414
	415	tracepoint_name:
	416	PE_NAME '-' PE_NAME ':' PE_NAME
	417	{
	418	char sys_name[128];
	419	struct tracepoint_name tracepoint;
	420
	421	snprintf(&sys_name, 128, "%s-%s", $1, $3);
	422	tracepoint.sys = &sys_name;
	423	tracepoint.event = $5;
	424
	425	$$ = tracepoint;
	426	}
2b9032e0	427	\|
89812fc8 JO	428	PE_NAME ':' PE_NAME
89812fc8 JO	429	{
865582c3	430	struct tracepoint_name tracepoint = {$1, $3};
b847cbdc	431
865582c3	432	$$ = tracepoint;
89812fc8 JO	433	}
	434
	435	event_legacy_numeric:
	436	PE_VALUE ':' PE_VALUE
	437	{
23b6339b	438	struct parse_events_evlist *data = _data;
c5cd8ac0	439	struct list_head *list;
b847cbdc	440
c5cd8ac0	441	ALLOC_LIST(list);
87d650be	442	ABORT_ON(parse_events_add_numeric(data, list, (u32)$1, $3, NULL));
b847cbdc	443	$$ = list;
89812fc8 JO	444	}
	445
	446	event_legacy_raw:
	447	PE_RAW
	448	{
23b6339b	449	struct parse_events_evlist *data = _data;
c5cd8ac0	450	struct list_head *list;
b847cbdc	451
c5cd8ac0	452	ALLOC_LIST(list);
87d650be	453	ABORT_ON(parse_events_add_numeric(data, list, PERF_TYPE_RAW, $1, NULL));
b847cbdc	454	$$ = list;
8f707d84 JO	455	}
8f707d84 JO	456
84c86ca1 WN	457	event_bpf_file:
	458	PE_BPF_OBJECT
	459	{
	460	struct parse_events_evlist *data = _data;
	461	struct parse_events_error *error = data->error;
	462	struct list_head *list;
	463
	464	ALLOC_LIST(list);
d509db04 WN	465	ABORT_ON(parse_events_load_bpf(data, list, $1, false));
	466	$$ = list;
	467	}
	468	\|
	469	PE_BPF_SOURCE
	470	{
	471	struct parse_events_evlist *data = _data;
	472	struct list_head *list;
	473
	474	ALLOC_LIST(list);
	475	ABORT_ON(parse_events_load_bpf(data, list, $1, true));
84c86ca1 WN	476	$$ = list;
	477	}
	478
89efb029	479	start_terms: event_config
90e2b22d	480	{
23b6339b	481	struct parse_events_terms *data = _data;
90e2b22d JO	482	data->terms = $1;
	483	}
	484
8f707d84 JO	485	event_config:
	486	event_config ',' event_term
	487	{
	488	struct list_head *head = $1;
6cee6cd3	489	struct parse_events_term *term = $3;
8f707d84 JO	490
	491	ABORT_ON(!head);
	492	list_add_tail(&term->list, head);
	493	$$ = $1;
	494	}
	495	\|
	496	event_term
	497	{
	498	struct list_head head = malloc(sizeof(head));
6cee6cd3	499	struct parse_events_term *term = $1;
8f707d84 JO	500
	501	ABORT_ON(!head);
	502	INIT_LIST_HEAD(head);
	503	list_add_tail(&term->list, head);
	504	$$ = head;
	505	}
	506
	507	event_term:
	508	PE_NAME '=' PE_NAME
	509	{
6cee6cd3	510	struct parse_events_term *term;
8f707d84	511
6cee6cd3	512	ABORT_ON(parse_events_term__str(&term, PARSE_EVENTS__TERM_TYPE_USER,
cecf3a2e	513	$1, $3, &@1, &@3));
8f707d84 JO	514	$$ = term;
	515	}
	516	\|
	517	PE_NAME '=' PE_VALUE
	518	{
6cee6cd3	519	struct parse_events_term *term;
8f707d84	520
6cee6cd3	521	ABORT_ON(parse_events_term__num(&term, PARSE_EVENTS__TERM_TYPE_USER,
cecf3a2e	522	$1, $3, &@1, &@3));
8f707d84 JO	523	$$ = term;
	524	}
	525	\|
1d33d6dc JO	526	PE_NAME '=' PE_VALUE_SYM_HW
1d33d6dc JO	527	{
6cee6cd3	528	struct parse_events_term *term;
1d33d6dc JO	529	int config = $3 & 255;
1d33d6dc JO	530
6cee6cd3	531	ABORT_ON(parse_events_term__sym_hw(&term, $1, config));
1d33d6dc JO	532	$$ = term;
	533	}
	534	\|
8f707d84 JO	535	PE_NAME
8f707d84 JO	536	{
6cee6cd3	537	struct parse_events_term *term;
8f707d84	538
6cee6cd3	539	ABORT_ON(parse_events_term__num(&term, PARSE_EVENTS__TERM_TYPE_USER,
cecf3a2e	540	$1, 1, &@1, NULL));
8f707d84 JO	541	$$ = term;
	542	}
	543	\|
1d33d6dc JO	544	PE_VALUE_SYM_HW
1d33d6dc JO	545	{
6cee6cd3	546	struct parse_events_term *term;
1d33d6dc JO	547	int config = $1 & 255;
1d33d6dc JO	548
6cee6cd3	549	ABORT_ON(parse_events_term__sym_hw(&term, NULL, config));
1d33d6dc JO	550	$$ = term;
	551	}
	552	\|
6b5fc39b JO	553	PE_TERM '=' PE_NAME
6b5fc39b JO	554	{
6cee6cd3	555	struct parse_events_term *term;
6b5fc39b	556
cecf3a2e	557	ABORT_ON(parse_events_term__str(&term, (int)$1, NULL, $3, &@1, &@3));
6b5fc39b JO	558	$$ = term;
	559	}
	560	\|
8f707d84 JO	561	PE_TERM '=' PE_VALUE
8f707d84 JO	562	{
6cee6cd3	563	struct parse_events_term *term;
8f707d84	564
cecf3a2e	565	ABORT_ON(parse_events_term__num(&term, (int)$1, NULL, $3, &@1, &@3));
8f707d84 JO	566	$$ = term;
	567	}
	568	\|
	569	PE_TERM
	570	{
6cee6cd3	571	struct parse_events_term *term;
8f707d84	572
cecf3a2e	573	ABORT_ON(parse_events_term__num(&term, (int)$1, NULL, 1, &@1, NULL));
8f707d84	574	$$ = term;
89812fc8 JO	575	}
	576
	577	sep_dc: ':' \|
	578
8f707d84 JO	579	sep_slash_dc: '/' \| ':' \|
8f707d84 JO	580
89812fc8 JO	581	%%
89812fc8 JO	582
6297d423 JO	583	void parse_events_error(YYLTYPE loc, void data,
6297d423 JO	584	void *scanner __maybe_unused,
1d037ca1	585	char const *msg __maybe_unused)
89812fc8	586	{
6297d423	587	parse_events_evlist_error(data, loc->last_column, "parser error");
89812fc8	588	}