Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 5d9cdc11 authored by Arnaldo Carvalho de Melo's avatar Arnaldo Carvalho de Melo
Browse files

perf events parse: Rename parse_events_parse arguments 

Calling them just "data" is too vague, call it 'perf_state', to make it
clearer, for instance, when looking at patch hunks.

Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Jiri Olsa <jolsa@kernel.org>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Wang Nan <wangnan0@huawei.com>
Link: http://lkml.kernel.org/n/tip-rnhk5yb05wem77rjpclrh7so@git.kernel.org


Signed-off-by: default avatarArnaldo Carvalho de Melo <acme@redhat.com>
parent d17d0878

tools/perf/tests/bpf.c

+8 −8
Original line number Diff line number Diff line
@@ -124,16 +124,16 @@ static int do_test(struct bpf_object *obj, int (*func)(void), 
	struct perf_evlist *evlist;

	int i, ret = TEST_FAIL, err = 0, count = 0;



	struct parse_events_state parse_evlist;

	struct parse_events_state parse_state;

	struct parse_events_error parse_error;



	bzero(&parse_error, sizeof(parse_error));

	bzero(&parse_evlist, sizeof(parse_evlist));

	parse_evlist.error = &parse_error;

	INIT_LIST_HEAD(&parse_evlist.list);

	bzero(&parse_state, sizeof(parse_state));

	parse_state.error = &parse_error;

	INIT_LIST_HEAD(&parse_state.list);



	err = parse_events_load_bpf_obj(&parse_evlist, &parse_evlist.list, obj, NULL);

	if (err || list_empty(&parse_evlist.list)) {

	err = parse_events_load_bpf_obj(&parse_state, &parse_state.list, obj, NULL);

	if (err || list_empty(&parse_state.list)) {

		pr_debug("Failed to add events selected by BPF\n");

		return TEST_FAIL;

	}
@@ -155,8 +155,8 @@ static int do_test(struct bpf_object *obj, int (*func)(void), 
		goto out_delete_evlist;

	}



	perf_evlist__splice_list_tail(evlist, &parse_evlist.list);

	evlist->nr_groups = parse_evlist.nr_groups;

	perf_evlist__splice_list_tail(evlist, &parse_state.list);

	evlist->nr_groups = parse_state.nr_groups;



	perf_evlist__config(evlist, &opts, NULL);

tools/perf/util/parse-events.c

+46 −46
Original line number Diff line number Diff line
@@ -34,7 +34,7 @@ 
#ifdef PARSER_DEBUG

extern int parse_events_debug;

#endif

int parse_events_parse(void *data, void *scanner);

int parse_events_parse(void *parse_state, void *scanner);

static int get_config_terms(struct list_head *head_config,

			    struct list_head *head_terms __maybe_unused);
@@ -589,7 +589,7 @@ static int add_tracepoint_multi_sys(struct list_head *list, int *idx, 
}



struct __add_bpf_event_param {

	struct parse_events_state *data;

	struct parse_events_state *parse_state;

	struct list_head *list;

	struct list_head *head_config;

};
@@ -599,7 +599,7 @@ static int add_bpf_event(const char *group, const char *event, int fd, 
{

	LIST_HEAD(new_evsels);

	struct __add_bpf_event_param *param = _param;

	struct parse_events_state *parse_state = param->data;

	struct parse_events_state *parse_state = param->parse_state;

	struct list_head *list = param->list;

	struct perf_evsel *pos;

	int err;
@@ -632,14 +632,14 @@ static int add_bpf_event(const char *group, const char *event, int fd, 
	return 0;

}



int parse_events_load_bpf_obj(struct parse_events_state *data,

int parse_events_load_bpf_obj(struct parse_events_state *parse_state,

			      struct list_head *list,

			      struct bpf_object *obj,

			      struct list_head *head_config)

{

	int err;

	char errbuf[BUFSIZ];

	struct __add_bpf_event_param param = {data, list, head_config};

	struct __add_bpf_event_param param = {parse_state, list, head_config};

	static bool registered_unprobe_atexit = false;



	if (IS_ERR(obj) || !obj) {
@@ -680,13 +680,13 @@ int parse_events_load_bpf_obj(struct parse_events_state *data, 


	return 0;

errout:

	data->error->help = strdup("(add -v to see detail)");

	data->error->str = strdup(errbuf);

	parse_state->error->help = strdup("(add -v to see detail)");

	parse_state->error->str = strdup(errbuf);

	return err;

}



static int

parse_events_config_bpf(struct parse_events_state *data,

parse_events_config_bpf(struct parse_events_state *parse_state,

			struct bpf_object *obj,

			struct list_head *head_config)

{
@@ -705,28 +705,28 @@ parse_events_config_bpf(struct parse_events_state *data, 
				 "Invalid config term for BPF object");

			errbuf[BUFSIZ - 1] = '\0';



			data->error->idx = term->err_term;

			data->error->str = strdup(errbuf);

			parse_state->error->idx = term->err_term;

			parse_state->error->str = strdup(errbuf);

			return -EINVAL;

		}



		err = bpf__config_obj(obj, term, data->evlist, &error_pos);

		err = bpf__config_obj(obj, term, parse_state->evlist, &error_pos);

		if (err) {

			bpf__strerror_config_obj(obj, term, data->evlist,

			bpf__strerror_config_obj(obj, term, parse_state->evlist,

						 &error_pos, err, errbuf,

						 sizeof(errbuf));

			data->error->help = strdup(

			parse_state->error->help = strdup(

"Hint:\tValid config terms:\n"

"     \tmap:[<arraymap>].value<indices>=[value]\n"

"     \tmap:[<eventmap>].event<indices>=[event]\n"

"\n"

"     \twhere <indices> is something like [0,3...5] or [all]\n"

"     \t(add -v to see detail)");

			data->error->str = strdup(errbuf);

			parse_state->error->str = strdup(errbuf);

			if (err == -BPF_LOADER_ERRNO__OBJCONF_MAP_VALUE)

				data->error->idx = term->err_val;

				parse_state->error->idx = term->err_val;

			else

				data->error->idx = term->err_term + error_pos;

				parse_state->error->idx = term->err_term + error_pos;

			return err;

		}

	}
@@ -762,7 +762,7 @@ split_bpf_config_terms(struct list_head *evt_head_config, 
			list_move_tail(&term->list, obj_head_config);

}



int parse_events_load_bpf(struct parse_events_state *data,

int parse_events_load_bpf(struct parse_events_state *parse_state,

			  struct list_head *list,

			  char *bpf_file_name,

			  bool source,
@@ -790,15 +790,15 @@ int parse_events_load_bpf(struct parse_events_state *data, 
						   -err, errbuf,

						   sizeof(errbuf));



		data->error->help = strdup("(add -v to see detail)");

		data->error->str = strdup(errbuf);

		parse_state->error->help = strdup("(add -v to see detail)");

		parse_state->error->str = strdup(errbuf);

		return err;

	}



	err = parse_events_load_bpf_obj(data, list, obj, head_config);

	err = parse_events_load_bpf_obj(parse_state, list, obj, head_config);

	if (err)

		return err;

	err = parse_events_config_bpf(data, obj, &obj_head_config);

	err = parse_events_config_bpf(parse_state, obj, &obj_head_config);



	/*

	 * Caller doesn't know anything about obj_head_config,
@@ -1184,7 +1184,7 @@ int parse_events_add_tracepoint(struct list_head *list, int *idx, 
					    err, head_config);

}



int parse_events_add_numeric(struct parse_events_state *data,

int parse_events_add_numeric(struct parse_events_state *parse_state,

			     struct list_head *list,

			     u32 type, u64 config,

			     struct list_head *head_config)
@@ -1197,7 +1197,7 @@ int parse_events_add_numeric(struct parse_events_state *data, 
	attr.config = config;



	if (head_config) {

		if (config_attr(&attr, head_config, data->error,

		if (config_attr(&attr, head_config, parse_state->error,

				config_term_common))

			return -EINVAL;
@@ -1205,11 +1205,11 @@ int parse_events_add_numeric(struct parse_events_state *data, 
			return -ENOMEM;

	}



	return add_event(list, &data->idx, &attr,

	return add_event(list, &parse_state->idx, &attr,

			 get_config_name(head_config), &config_terms);

}



int parse_events_add_pmu(struct parse_events_state *data,

int parse_events_add_pmu(struct parse_events_state *parse_state,

			 struct list_head *list, char *name,

			 struct list_head *head_config)

{
@@ -1232,7 +1232,7 @@ int parse_events_add_pmu(struct parse_events_state *data, 


	if (!head_config) {

		attr.type = pmu->type;

		evsel = __add_event(list, &data->idx, &attr, NULL, pmu->cpus, NULL);

		evsel = __add_event(list, &parse_state->idx, &attr, NULL, pmu->cpus, NULL);

		return evsel ? 0 : -ENOMEM;

	}
@@ -1243,16 +1243,16 @@ int parse_events_add_pmu(struct parse_events_state *data, 
	 * Configure hardcoded terms first, no need to check

	 * return value when called with fail == 0 ;)

	 */

	if (config_attr(&attr, head_config, data->error, config_term_pmu))

	if (config_attr(&attr, head_config, parse_state->error, config_term_pmu))

		return -EINVAL;



	if (get_config_terms(head_config, &config_terms))

		return -ENOMEM;



	if (perf_pmu__config(pmu, &attr, head_config, data->error))

	if (perf_pmu__config(pmu, &attr, head_config, parse_state->error))

		return -EINVAL;



	evsel = __add_event(list, &data->idx, &attr,

	evsel = __add_event(list, &parse_state->idx, &attr,

			    get_config_name(head_config), pmu->cpus,

			    &config_terms);

	if (evsel) {
@@ -1267,7 +1267,7 @@ int parse_events_add_pmu(struct parse_events_state *data, 
	return evsel ? 0 : -ENOMEM;

}



int parse_events_multi_pmu_add(struct parse_events_state *data,

int parse_events_multi_pmu_add(struct parse_events_state *parse_state,

			       char *str, struct list_head **listp)

{

	struct list_head *head;
@@ -1296,7 +1296,7 @@ int parse_events_multi_pmu_add(struct parse_events_state *data, 
					return -1;

				list_add_tail(&term->list, head);



				if (!parse_events_add_pmu(data, list,

				if (!parse_events_add_pmu(parse_state, list,

						  pmu->name, head)) {

					pr_debug("%s -> %s/%s/\n", str,

						 pmu->name, alias->str);
@@ -1628,7 +1628,7 @@ perf_pmu__parse_check(const char *name) 
	return r ? r->type : PMU_EVENT_SYMBOL_ERR;

}



static int parse_events__scanner(const char *str, void *data, int start_token)

static int parse_events__scanner(const char *str, void *parse_state, int start_token)

{

	YY_BUFFER_STATE buffer;

	void *scanner;
@@ -1643,7 +1643,7 @@ static int parse_events__scanner(const char *str, void *data, int start_token) 
#ifdef PARSER_DEBUG

	parse_events_debug = 1;

#endif

	ret = parse_events_parse(data, scanner);

	ret = parse_events_parse(parse_state, scanner);



	parse_events__flush_buffer(buffer, scanner);

	parse_events__delete_buffer(buffer, scanner);
@@ -1656,45 +1656,45 @@ static int parse_events__scanner(const char *str, void *data, int start_token) 
 */

int parse_events_terms(struct list_head *terms, const char *str)

{

	struct parse_events_state data = {

	struct parse_events_state parse_state = {

		.terms = NULL,

	};

	int ret;



	ret = parse_events__scanner(str, &data, PE_START_TERMS);

	ret = parse_events__scanner(str, &parse_state, PE_START_TERMS);

	if (!ret) {

		list_splice(data.terms, terms);

		zfree(&data.terms);

		list_splice(parse_state.terms, terms);

		zfree(&parse_state.terms);

		return 0;

	}



	parse_events_terms__delete(data.terms);

	parse_events_terms__delete(parse_state.terms);

	return ret;

}



int parse_events(struct perf_evlist *evlist, const char *str,

		 struct parse_events_error *err)

{

	struct parse_events_state data = {

		.list   = LIST_HEAD_INIT(data.list),

	struct parse_events_state parse_state = {

		.list   = LIST_HEAD_INIT(parse_state.list),

		.idx    = evlist->nr_entries,

		.error  = err,

		.evlist = evlist,

	};

	int ret;



	ret = parse_events__scanner(str, &data, PE_START_EVENTS);

	ret = parse_events__scanner(str, &parse_state, PE_START_EVENTS);

	perf_pmu__parse_cleanup();

	if (!ret) {

		struct perf_evsel *last;



		if (list_empty(&data.list)) {

		if (list_empty(&parse_state.list)) {

			WARN_ONCE(true, "WARNING: event parser found nothing");

			return -1;

		}



		perf_evlist__splice_list_tail(evlist, &data.list);

		evlist->nr_groups += data.nr_groups;

		perf_evlist__splice_list_tail(evlist, &parse_state.list);

		evlist->nr_groups += parse_state.nr_groups;

		last = perf_evlist__last(evlist);

		last->cmdline_group_boundary = true;
@@ -2520,10 +2520,10 @@ void parse_events__clear_array(struct parse_events_array *a) 
	zfree(&a->ranges);

}



void parse_events_evlist_error(struct parse_events_state *data,

void parse_events_evlist_error(struct parse_events_state *parse_state,

			       int idx, const char *str)

{

	struct parse_events_error *err = data->error;

	struct parse_events_error *err = parse_state->error;



	if (!err)

		return;

tools/perf/util/parse-events.h

+6 −6
Original line number Diff line number Diff line
@@ -140,18 +140,18 @@ int parse_events_add_tracepoint(struct list_head *list, int *idx, 
				const char *sys, const char *event,

				struct parse_events_error *error,

				struct list_head *head_config);

int parse_events_load_bpf(struct parse_events_state *data,

int parse_events_load_bpf(struct parse_events_state *parse_state,

			  struct list_head *list,

			  char *bpf_file_name,

			  bool source,

			  struct list_head *head_config);

/* Provide this function for perf test */

struct bpf_object;

int parse_events_load_bpf_obj(struct parse_events_state *data,

int parse_events_load_bpf_obj(struct parse_events_state *parse_state,

			      struct list_head *list,

			      struct bpf_object *obj,

			      struct list_head *head_config);

int parse_events_add_numeric(struct parse_events_state *data,

int parse_events_add_numeric(struct parse_events_state *parse_state,

			     struct list_head *list,

			     u32 type, u64 config,

			     struct list_head *head_config);
@@ -161,11 +161,11 @@ int parse_events_add_cache(struct list_head *list, int *idx, 
			   struct list_head *head_config);

int parse_events_add_breakpoint(struct list_head *list, int *idx,

				void *ptr, char *type, u64 len);

int parse_events_add_pmu(struct parse_events_state *data,

int parse_events_add_pmu(struct parse_events_state *parse_state,

			 struct list_head *list, char *name,

			 struct list_head *head_config);



int parse_events_multi_pmu_add(struct parse_events_state *data,

int parse_events_multi_pmu_add(struct parse_events_state *parse_state,

			       char *str,

			       struct list_head **listp);
@@ -177,7 +177,7 @@ perf_pmu__parse_check(const char *name); 
void parse_events__set_leader(char *name, struct list_head *list);

void parse_events_update_lists(struct list_head *list_event,

			       struct list_head *list_all);

void parse_events_evlist_error(struct parse_events_state *data,

void parse_events_evlist_error(struct parse_events_state *parse_state,

			       int idx, const char *str);



void print_events(const char *event_glob, bool name_only, bool quiet,

tools/perf/util/parse-events.y

+44 −44
Original line number Diff line number Diff line 
%pure-parser

%parse-param {void *_data}

%parse-param {void *_parse_state}

%parse-param {void *scanner}

%lex-param {void* scanner}

%locations
@@ -17,7 +17,7 @@ 
#include "parse-events.h"

#include "parse-events-bison.h"



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

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



#define ABORT_ON(val) \

do { \
@@ -33,11 +33,11 @@ do { \ 
} while (0)



static void inc_group_count(struct list_head *list,

		       struct parse_events_state *data)

		       struct parse_events_state *parse_state)

{

	/* Count groups only have more than 1 members */

	if (!list_is_last(list->next, list))

		data->nr_groups++;

		parse_state->nr_groups++;

}



%}
@@ -115,9 +115,9 @@ PE_START_TERMS start_terms 


start_events: groups

{

	struct parse_events_state *data = _data;

	struct parse_events_state *parse_state = _parse_state;



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

	parse_events_update_lists($1, &parse_state->list);

}



groups:
@@ -159,7 +159,7 @@ PE_NAME '{' events '}' 
{

	struct list_head *list = $3;



	inc_group_count(list, _data);

	inc_group_count(list, _parse_state);

	parse_events__set_leader($1, list);

	$$ = list;

}
@@ -168,7 +168,7 @@ PE_NAME '{' events '}' 
{

	struct list_head *list = $2;



	inc_group_count(list, _data);

	inc_group_count(list, _parse_state);

	parse_events__set_leader(NULL, list);

	$$ = list;

}
@@ -231,7 +231,7 @@ PE_NAME opt_event_config 
		YYABORT;



	ALLOC_LIST(list);

	if (parse_events_add_pmu(_data, list, $1, $2)) {

	if (parse_events_add_pmu(_parse_state, list, $1, $2)) {

		struct perf_pmu *pmu = NULL;

		int ok = 0;
@@ -244,7 +244,7 @@ PE_NAME opt_event_config 
			if (!strncmp($1, name, strlen($1))) {

				if (parse_events_copy_term_list(orig_terms, &terms))

					YYABORT;

				if (!parse_events_add_pmu(_data, list, pmu->name, terms))

				if (!parse_events_add_pmu(_parse_state, list, pmu->name, terms))

					ok++;

				parse_events_terms__delete(terms);

			}
@@ -261,7 +261,7 @@ PE_KERNEL_PMU_EVENT sep_dc 
{

	struct list_head *list;



	if (parse_events_multi_pmu_add(_data, $1, &list) < 0)

	if (parse_events_multi_pmu_add(_parse_state, $1, &list) < 0)

		YYABORT;

	$$ = list;

}
@@ -272,7 +272,7 @@ PE_PMU_EVENT_PRE '-' PE_PMU_EVENT_SUF sep_dc 
	char pmu_name[128];



	snprintf(&pmu_name, 128, "%s-%s", $1, $3);

	if (parse_events_multi_pmu_add(_data, pmu_name, &list) < 0)

	if (parse_events_multi_pmu_add(_parse_state, pmu_name, &list) < 0)

		YYABORT;

	$$ = list;

}
@@ -290,7 +290,7 @@ value_sym '/' event_config '/' 
	int config = $1 & 255;



	ALLOC_LIST(list);

	ABORT_ON(parse_events_add_numeric(_data, list, type, config, $3));

	ABORT_ON(parse_events_add_numeric(_parse_state, list, type, config, $3));

	parse_events_terms__delete($3);

	$$ = list;

}
@@ -302,43 +302,43 @@ value_sym sep_slash_dc 
	int config = $1 & 255;



	ALLOC_LIST(list);

	ABORT_ON(parse_events_add_numeric(_data, list, type, config, NULL));

	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 *data = _data;

	struct parse_events_error *error = data->error;

	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, &data->idx, $1, $3, $5, error, $6));

	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 *data = _data;

	struct parse_events_error *error = data->error;

	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, &data->idx, $1, $3, NULL, error, $4));

	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 *data = _data;

	struct parse_events_error *error = data->error;

	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, &data->idx, $1, NULL, NULL, error, $2));

	ABORT_ON(parse_events_add_cache(list, &parse_state->idx, $1, NULL, NULL, error, $2));

	parse_events_terms__delete($2);

	$$ = list;

}
@@ -346,44 +346,44 @@ PE_NAME_CACHE_TYPE opt_event_config 
event_legacy_mem:

PE_PREFIX_MEM PE_VALUE '/' PE_VALUE ':' PE_MODIFIER_BP sep_dc

{

	struct parse_events_state *data = _data;

	struct parse_events_state *parse_state = _parse_state;

	struct list_head *list;



	ALLOC_LIST(list);

	ABORT_ON(parse_events_add_breakpoint(list, &data->idx,

	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 *data = _data;

	struct parse_events_state *parse_state = _parse_state;

	struct list_head *list;



	ALLOC_LIST(list);

	ABORT_ON(parse_events_add_breakpoint(list, &data->idx,

	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 *data = _data;

	struct parse_events_state *parse_state = _parse_state;

	struct list_head *list;



	ALLOC_LIST(list);

	ABORT_ON(parse_events_add_breakpoint(list, &data->idx,

	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 *data = _data;

	struct parse_events_state *parse_state = _parse_state;

	struct list_head *list;



	ALLOC_LIST(list);

	ABORT_ON(parse_events_add_breakpoint(list, &data->idx,

	ABORT_ON(parse_events_add_breakpoint(list, &parse_state->idx,

					     (void *) $2, NULL, 0));

	$$ = list;

}
@@ -391,15 +391,15 @@ PE_PREFIX_MEM PE_VALUE sep_dc 
event_legacy_tracepoint:

tracepoint_name opt_event_config

{

	struct parse_events_state *data = _data;

	struct parse_events_error *error = data->error;

	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, &data->idx, $1.sys, $1.event,

	if (parse_events_add_tracepoint(list, &parse_state->idx, $1.sys, $1.event,

					error, $2))

		return -1;
@@ -432,7 +432,7 @@ PE_VALUE ':' PE_VALUE opt_event_config 
	struct list_head *list;



	ALLOC_LIST(list);

	ABORT_ON(parse_events_add_numeric(_data, list, (u32)$1, $3, $4));

	ABORT_ON(parse_events_add_numeric(_parse_state, list, (u32)$1, $3, $4));

	parse_events_terms__delete($4);

	$$ = list;

}
@@ -443,7 +443,7 @@ PE_RAW opt_event_config 
	struct list_head *list;



	ALLOC_LIST(list);

	ABORT_ON(parse_events_add_numeric(_data, list, PERF_TYPE_RAW, $1, $2));

	ABORT_ON(parse_events_add_numeric(_parse_state, list, PERF_TYPE_RAW, $1, $2));

	parse_events_terms__delete($2);

	$$ = list;

}
@@ -451,12 +451,12 @@ PE_RAW opt_event_config 
event_bpf_file:

PE_BPF_OBJECT opt_event_config

{

	struct parse_events_state *data = _data;

	struct parse_events_error *error = data->error;

	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(data, list, $1, false, $2));

	ABORT_ON(parse_events_load_bpf(parse_state, list, $1, false, $2));

	parse_events_terms__delete($2);

	$$ = list;

}
@@ -466,7 +466,7 @@ PE_BPF_SOURCE opt_event_config 
	struct list_head *list;



	ALLOC_LIST(list);

	ABORT_ON(parse_events_load_bpf(_data, list, $1, true, $2));

	ABORT_ON(parse_events_load_bpf(_parse_state, list, $1, true, $2));

	parse_events_terms__delete($2);

	$$ = list;

}
@@ -488,8 +488,8 @@ opt_event_config: 


start_terms: event_config

{

	struct parse_events_state *data = _data;

	data->terms = $1;

	struct parse_events_state *parse_state = _parse_state;

	parse_state->terms = $1;

}



event_config:
@@ -679,9 +679,9 @@ sep_slash_dc: '/' | ':' | 


%%



void parse_events_error(YYLTYPE *loc, void *data,

void parse_events_error(YYLTYPE *loc, void *parse_state,

			void *scanner __maybe_unused,

			char const *msg __maybe_unused)

{

	parse_events_evlist_error(data, loc->last_column, "parser error");

	parse_events_evlist_error(parse_state, loc->last_column, "parser error");

}