[deliverable/linux.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_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_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 <head> event_legacy_numeric
%type <head> event_legacy_raw
%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;
}
%%

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_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(list, &data->idx, "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:
PE_NAME '-' PE_NAME ':' PE_NAME
{
	struct parse_events_evlist *data = _data;
	struct list_head *list;
	char sys_name[128];
	snprintf(&sys_name, 128, "%s-%s", $1, $3);

	ALLOC_LIST(list);
	ABORT_ON(parse_events_add_tracepoint(list, &data->idx, &sys_name, $5));
	$$ = list;
}
|
PE_NAME ':' PE_NAME
{
	struct parse_events_evlist *data = _data;
	struct list_head *list;

	ALLOC_LIST(list);
	if (parse_events_add_tracepoint(list, &data->idx, $1, $3)) {
		struct parse_events_error *error = data->error;

		if (error) {
			error->idx = @1.first_column;
			error->str = strdup("unknown tracepoint");
		}
		return -1;
	}
	$$ = list;
}

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;
}

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