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: Arnaldo Carvalho de Melo <acme@redhat.com>

diff --git a/tools/perf/tests/bpf.c b/tools/perf/tests/bpf.c
index 45ad248e6ccdfb7bab78b1c12a8da286a7867bd2..34c22cdf4d5d9a7c9322f5593fb877bd5b8aff08 100644 (file)
--- a/tools/perf/tests/bpf.c
+++ b/tools/perf/tests/bpf.c
@@ -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);
 

diff --git a/tools/perf/util/parse-events.c b/tools/perf/util/parse-events.c
index d4fcf048aa9ec618f4395d53c93181f60df2d9dc..f44aeba51d1fa08d102d43caae0bff9ca3576399 100644 (file)
--- a/tools/perf/util/parse-events.c
+++ b/tools/perf/util/parse-events.c
@@ -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;

diff --git a/tools/perf/util/parse-events.h b/tools/perf/util/parse-events.h
index 2a36179378940b9b18131e19d18d8e9e6b6a64fb..635135125111231c9f61e2971133c7f4a188eeee 100644 (file)
--- a/tools/perf/util/parse-events.h
+++ b/tools/perf/util/parse-events.h
@@ -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,

diff --git a/tools/perf/util/parse-events.y b/tools/perf/util/parse-events.y
index 4b37546e491449f7aed09e9471a69b83f3621d12..e81a20ea8d7df1d2c7d8313279daa834eda88415 100644 (file)
--- a/tools/perf/util/parse-events.y
+++ b/tools/perf/util/parse-events.y
@@ -1,5 +1,5 @@
 %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");
 }