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

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

%{

#define YYDEBUG 1

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

void parse_events_error(YYLTYPE *loc, void *parse_state, void *scanner, char const *msg);

#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_state *parse_state)
{
	/* Count groups only have more than 1 members */
	if (!list_is_last(list->next, list))
		parse_state->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
%token PE_DRV_CFG_TERM
%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 <str> PE_DRV_CFG_TERM
%type <num> value_sym
%type <head> event_config
%type <head> opt_event_config
%type <head> opt_pmu_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_state *parse_state = _parse_state;

	parse_events_update_lists($1, &parse_state->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, _parse_state);
	parse_events__set_leader($1, list, _parse_state);
	$$ = list;
}
|
'{' events '}'
{
	struct list_head *list = $2;

	inc_group_count(list, _parse_state);
	parse_events__set_leader(NULL, list, _parse_state);
	$$ = 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_pmu_config
{
	struct parse_events_state *parse_state = _parse_state;
	struct parse_events_error *error = parse_state->error;
	struct list_head *list, *orig_terms, *terms;

	if (parse_events_copy_term_list($2, &orig_terms))
		YYABORT;

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

	ALLOC_LIST(list);
	if (parse_events_add_pmu(_parse_state, list, $1, $2, false, false)) {
		struct perf_pmu *pmu = NULL;
		int ok = 0;
		char *pattern;

		if (asprintf(&pattern, "%s*", $1) < 0)
			YYABORT;

		while ((pmu = perf_pmu__scan(pmu)) != NULL) {
			char *name = pmu->name;

			if (!strncmp(name, "uncore_", 7) &&
			    strncmp($1, "uncore_", 7))
				name += 7;
			if (!fnmatch(pattern, name, 0)) {
				if (parse_events_copy_term_list(orig_terms, &terms)) {
					free(pattern);
					YYABORT;
				}
				if (!parse_events_add_pmu(_parse_state, list, pmu->name, terms, true, false))
					ok++;
				parse_events_terms__delete(terms);
			}
		}

		free(pattern);

		if (!ok)
			YYABORT;
	}
	parse_events_terms__delete($2);
	parse_events_terms__delete(orig_terms);
	$$ = list;
}
|
PE_KERNEL_PMU_EVENT sep_dc
{
	struct list_head *list;

	if (parse_events_multi_pmu_add(_parse_state, $1, &list) < 0)
		YYABORT;
	$$ = list;
}
|
PE_PMU_EVENT_PRE '-' PE_PMU_EVENT_SUF sep_dc
{
	struct list_head *list;
	char pmu_name[128];

	snprintf(&pmu_name, 128, "%s-%s", $1, $3);
	if (parse_events_multi_pmu_add(_parse_state, pmu_name, &list) < 0)
		YYABORT;
	$$ = list;
}

value_sym:
PE_VALUE_SYM_HW
|
PE_VALUE_SYM_SW

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

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

	ALLOC_LIST(list);
	ABORT_ON(parse_events_add_numeric(_parse_state, 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_state *parse_state = _parse_state;
	struct parse_events_error *error = parse_state->error;
	struct list_head *list;

	ALLOC_LIST(list);
	ABORT_ON(parse_events_add_cache(list, &parse_state->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_state *parse_state = _parse_state;
	struct parse_events_error *error = parse_state->error;
	struct list_head *list;

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

	ALLOC_LIST(list);
	ABORT_ON(parse_events_add_cache(list, &parse_state->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_state *parse_state = _parse_state;
	struct list_head *list;

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

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

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

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

event_legacy_tracepoint:
tracepoint_name opt_event_config
{
	struct parse_events_state *parse_state = _parse_state;
	struct parse_events_error *error = parse_state->error;
	struct list_head *list;

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

	if (parse_events_add_tracepoint(list, &parse_state->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 list_head *list;

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

event_legacy_raw:
PE_RAW opt_event_config
{
	struct list_head *list;

	ALLOC_LIST(list);
	ABORT_ON(parse_events_add_numeric(_parse_state, list, PERF_TYPE_RAW, $1, $2));
	parse_events_terms__delete($2);
	$$ = list;
}

event_bpf_file:
PE_BPF_OBJECT opt_event_config
{
	struct parse_events_state *parse_state = _parse_state;
	struct parse_events_error *error = parse_state->error;
	struct list_head *list;

	ALLOC_LIST(list);
	ABORT_ON(parse_events_load_bpf(parse_state, list, $1, false, $2));
	parse_events_terms__delete($2);
	$$ = list;
}
|
PE_BPF_SOURCE opt_event_config
{
	struct list_head *list;

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

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

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

start_terms: event_config
{
	struct parse_events_state *parse_state = _parse_state;
	parse_state->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, false, &@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, true, &@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, false, &@1, &@3));
	$$ = term;
}
|
PE_TERM
{
	struct parse_events_term *term;

	ABORT_ON(parse_events_term__num(&term, (int)$1, NULL, 1, true, &@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, false, &@1, &@4));
	term->array = $2;
	$$ = term;
}
|
PE_DRV_CFG_TERM
{
	struct parse_events_term *term;

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