[mirror_ubuntu-artful-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 void 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
%token PE_ARRAY_ALL PE_ARRAY_RANGE
%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 <head> opt_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
%type <array> array
%type <array> array_term
%type <array> array_terms

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

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 opt_event_config
{
	struct parse_events_evlist *data = _data;
	struct list_head *list;

	ALLOC_LIST(list);
	ABORT_ON(parse_events_add_pmu(data, list, $1, $2));
	parse_events_terms__delete($2);
	$$ = 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_terms__delete(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_terms__delete(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_terms__delete($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 opt_event_config
{
	struct parse_events_evlist *data = _data;
	struct parse_events_error *error = data->error;
	struct list_head *list;

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

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

	ALLOC_LIST(list);
	ABORT_ON(parse_events_add_cache(list, &data->idx, $1, NULL, NULL, error, $2));
	parse_events_terms__delete($2);
	$$ = 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 opt_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, $2))
		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 opt_event_config
{
	struct parse_events_evlist *data = _data;
	struct list_head *list;

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

event_legacy_raw:
PE_RAW opt_event_config
{
	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, $2));
	parse_events_terms__delete($2);
	$$ = list;
}

event_bpf_file:
PE_BPF_OBJECT opt_event_config
{
	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, $2));
	parse_events_terms__delete($2);
	$$ = list;
}
|
PE_BPF_SOURCE opt_event_config
{
	struct parse_events_evlist *data = _data;
	struct list_head *list;

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

opt_event_config:
'/' event_config '/'
{
	$$ = $2;
}
|
'/' '/'
{
	$$ = NULL;
}
|
{
	$$ = NULL;
}

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;
}
|
PE_NAME array '=' PE_NAME
{
	struct parse_events_term *term;
	int i;

	ABORT_ON(parse_events_term__str(&term, PARSE_EVENTS__TERM_TYPE_USER,
					$1, $4, &@1, &@4));

	term->array = $2;
	$$ = term;
}
|
PE_NAME array '=' PE_VALUE
{
	struct parse_events_term *term;

	ABORT_ON(parse_events_term__num(&term, PARSE_EVENTS__TERM_TYPE_USER,
					$1, $4, &@1, &@4));
	term->array = $2;
	$$ = term;
}

array:
'[' array_terms ']'
{
	$$ = $2;
}
|
PE_ARRAY_ALL
{
	$$.nr_ranges = 0;
	$$.ranges = NULL;
}

array_terms:
array_terms ',' array_term
{
	struct parse_events_array new_array;

	new_array.nr_ranges = $1.nr_ranges + $3.nr_ranges;
	new_array.ranges = malloc(sizeof(new_array.ranges[0]) *
				  new_array.nr_ranges);
	ABORT_ON(!new_array.ranges);
	memcpy(&new_array.ranges[0], $1.ranges,
	       $1.nr_ranges * sizeof(new_array.ranges[0]));
	memcpy(&new_array.ranges[$1.nr_ranges], $3.ranges,
	       $3.nr_ranges * sizeof(new_array.ranges[0]));
	free($1.ranges);
	free($3.ranges);
	$$ = new_array;
}
|
array_term

array_term:
PE_VALUE
{
	struct parse_events_array array;

	array.nr_ranges = 1;
	array.ranges = malloc(sizeof(array.ranges[0]));
	ABORT_ON(!array.ranges);
	array.ranges[0].start = $1;
	array.ranges[0].length = 1;
	$$ = array;
}
|
PE_VALUE PE_ARRAY_RANGE PE_VALUE
{
	struct parse_events_array array;

	ABORT_ON($3 < $1);
	array.nr_ranges = 1;
	array.ranges = malloc(sizeof(array.ranges[0]));
	ABORT_ON(!array.ranges);
	array.ranges[0].start = $1;
	array.ranges[0].length = $3 - $1 + 1;
	$$ = array;
}

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