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