tools/perf/util/parse-events.y

   1 %define api.pure full
   2 %parse-param {void *_parse_state}
   3 %parse-param {void *scanner}
   4 %lex-param {void* scanner}
   5 %locations
   6
   7 %{
   8
   9 #define YYDEBUG 1
  10
  11 #include <errno.h>
  12 #include <fnmatch.h>
  13 #include <stdio.h>
  14 #include <linux/compiler.h>
  15 #include <linux/types.h>
  16 #include <linux/zalloc.h>
  17 #include "pmu.h"
  18 #include "pmus.h"
  19 #include "evsel.h"
  20 #include "parse-events.h"
  21 #include "parse-events-bison.h"
  22
  23 int parse_events_lex(YYSTYPE * yylval_param, YYLTYPE * yylloc_param , void *yyscanner);
  24 void parse_events_error(YYLTYPE *loc, void *parse_state, void *scanner, char const *msg);
  25
  26 #define PE_ABORT(val) \
  27 do { \
  28         if (val == -ENOMEM) \
  29                 YYNOMEM; \
  30         YYABORT; \
  31 } while (0)
  32
  33 static struct list_head* alloc_list(void)
  34 {
  35         struct list_head *list;
  36
  37         list = malloc(sizeof(*list));
  38         if (!list)
  39                 return NULL;
  40
  41         INIT_LIST_HEAD(list);
  42         return list;
  43 }
  44
  45 static void free_list_evsel(struct list_head* list_evsel)
  46 {
  47         struct evsel *evsel, *tmp;
  48
  49         list_for_each_entry_safe(evsel, tmp, list_evsel, core.node) {
  50                 list_del_init(&evsel->core.node);
  51                 evsel__delete(evsel);
  52         }
  53         free(list_evsel);
  54 }
  55
  56 %}
  57
  58 %token PE_START_EVENTS PE_START_TERMS
  59 %token PE_VALUE PE_VALUE_SYM_HW PE_VALUE_SYM_SW PE_TERM
  60 %token PE_VALUE_SYM_TOOL
  61 %token PE_EVENT_NAME
  62 %token PE_RAW PE_NAME
  63 %token PE_MODIFIER_EVENT PE_MODIFIER_BP PE_BP_COLON PE_BP_SLASH
  64 %token PE_LEGACY_CACHE
  65 %token PE_PREFIX_MEM
  66 %token PE_ERROR
  67 %token PE_DRV_CFG_TERM
  68 %token PE_TERM_HW
  69 %type <num> PE_VALUE
  70 %type <num> PE_VALUE_SYM_HW
  71 %type <num> PE_VALUE_SYM_SW
  72 %type <num> PE_VALUE_SYM_TOOL
  73 %type <num> PE_TERM
  74 %type <num> value_sym
  75 %type <str> PE_RAW
  76 %type <str> PE_NAME
  77 %type <str> PE_LEGACY_CACHE
  78 %type <str> PE_MODIFIER_EVENT
  79 %type <str> PE_MODIFIER_BP
  80 %type <str> PE_EVENT_NAME
  81 %type <str> PE_DRV_CFG_TERM
  82 %type <str> name_or_raw name_or_legacy
  83 %destructor { free ($$); } <str>
  84 %type <term> event_term
  85 %destructor { parse_events_term__delete ($$); } <term>
  86 %type <list_terms> event_config
  87 %type <list_terms> opt_event_config
  88 %type <list_terms> opt_pmu_config
  89 %destructor { parse_events_terms__delete ($$); } <list_terms>
  90 %type <list_evsel> event_pmu
  91 %type <list_evsel> event_legacy_symbol
  92 %type <list_evsel> event_legacy_cache
  93 %type <list_evsel> event_legacy_mem
  94 %type <list_evsel> event_legacy_tracepoint
  95 %type <list_evsel> event_legacy_numeric
  96 %type <list_evsel> event_legacy_raw
  97 %type <list_evsel> event_def
  98 %type <list_evsel> event_mod
  99 %type <list_evsel> event_name
 100 %type <list_evsel> event
 101 %type <list_evsel> events
 102 %type <list_evsel> group_def
 103 %type <list_evsel> group
 104 %type <list_evsel> groups
 105 %destructor { free_list_evsel ($$); } <list_evsel>
 106 %type <tracepoint_name> tracepoint_name
 107 %type <hardware_term> PE_TERM_HW
 108 %destructor { free ($$.str); } <hardware_term>
 109
 110 %union
 111 {
 112         char *str;
 113         u64 num;
 114         struct list_head *list_evsel;
 115         struct list_head *list_terms;
 116         struct parse_events_term *term;
 117         struct tracepoint_name {
 118                 char *sys;
 119                 char *event;
 120         } tracepoint_name;
 121         struct hardware_term {
 122                 char *str;
 123                 u64 num;
 124         } hardware_term;
 125 }
 126 %%
 127
 128 start:
 129 PE_START_EVENTS start_events
 130 |
 131 PE_START_TERMS  start_terms
 132
 133 start_events: groups
 134 {
 135         struct parse_events_state *parse_state = _parse_state;
 136
 137         /* frees $1 */
 138         parse_events_update_lists($1, &parse_state->list);
 139 }
 140
 141 groups:
 142 groups ',' group
 143 {
 144         struct list_head *list  = $1;
 145         struct list_head *group = $3;
 146
 147         /* frees $3 */
 148         parse_events_update_lists(group, list);
 149         $$ = list;
 150 }
 151 |
 152 groups ',' event
 153 {
 154         struct list_head *list  = $1;
 155         struct list_head *event = $3;
 156
 157         /* frees $3 */
 158         parse_events_update_lists(event, list);
 159         $$ = list;
 160 }
 161 |
 162 group
 163 |
 164 event
 165
 166 group:
 167 group_def ':' PE_MODIFIER_EVENT
 168 {
 169         struct list_head *list = $1;
 170         int err;
 171
 172         err = parse_events__modifier_group(list, $3);
 173         free($3);
 174         if (err) {
 175                 struct parse_events_state *parse_state = _parse_state;
 176                 struct parse_events_error *error = parse_state->error;
 177
 178                 parse_events_error__handle(error, @3.first_column,
 179                                            strdup("Bad modifier"), NULL);
 180                 free_list_evsel(list);
 181                 YYABORT;
 182         }
 183         $$ = list;
 184 }
 185 |
 186 group_def
 187
 188 group_def:
 189 PE_NAME '{' events '}'
 190 {
 191         struct list_head *list = $3;
 192
 193         /* Takes ownership of $1. */
 194         parse_events__set_leader($1, list);
 195         $$ = list;
 196 }
 197 |
 198 '{' events '}'
 199 {
 200         struct list_head *list = $2;
 201
 202         parse_events__set_leader(NULL, list);
 203         $$ = list;
 204 }
 205
 206 events:
 207 events ',' event
 208 {
 209         struct list_head *event = $3;
 210         struct list_head *list  = $1;
 211
 212         /* frees $3 */
 213         parse_events_update_lists(event, list);
 214         $$ = list;
 215 }
 216 |
 217 event
 218
 219 event: event_mod
 220
 221 event_mod:
 222 event_name PE_MODIFIER_EVENT
 223 {
 224         struct list_head *list = $1;
 225         int err;
 226
 227         /*
 228          * Apply modifier on all events added by single event definition
 229          * (there could be more events added for multiple tracepoint
 230          * definitions via '*?'.
 231          */
 232         err = parse_events__modifier_event(list, $2, false);
 233         free($2);
 234         if (err) {
 235                 struct parse_events_state *parse_state = _parse_state;
 236                 struct parse_events_error *error = parse_state->error;
 237
 238                 parse_events_error__handle(error, @2.first_column,
 239                                            strdup("Bad modifier"), NULL);
 240                 free_list_evsel(list);
 241                 YYABORT;
 242         }
 243         $$ = list;
 244 }
 245 |
 246 event_name
 247
 248 event_name:
 249 PE_EVENT_NAME event_def
 250 {
 251         int err;
 252
 253         err = parse_events_name($2, $1);
 254         free($1);
 255         if (err) {
 256                 free_list_evsel($2);
 257                 YYNOMEM;
 258         }
 259         $$ = $2;
 260 }
 261 |
 262 event_def
 263
 264 event_def: event_pmu |
 265            event_legacy_symbol |
 266            event_legacy_cache sep_dc |
 267            event_legacy_mem sep_dc |
 268            event_legacy_tracepoint sep_dc |
 269            event_legacy_numeric sep_dc |
 270            event_legacy_raw sep_dc
 271
 272 event_pmu:
 273 PE_NAME opt_pmu_config
 274 {
 275         struct parse_events_state *parse_state = _parse_state;
 276         struct list_head *list = NULL, *orig_terms = NULL, *terms= NULL;
 277         char *pattern = NULL;
 278
 279 #define CLEANUP                                         \
 280         do {                                            \
 281                 parse_events_terms__delete($2);         \
 282                 parse_events_terms__delete(orig_terms); \
 283                 free(list);                             \
 284                 free($1);                               \
 285                 free(pattern);                          \
 286         } while(0)
 287
 288         if (parse_events_copy_term_list($2, &orig_terms)) {
 289                 CLEANUP;
 290                 YYNOMEM;
 291         }
 292
 293         list = alloc_list();
 294         if (!list) {
 295                 CLEANUP;
 296                 YYNOMEM;
 297         }
 298         /* Attempt to add to list assuming $1 is a PMU name. */
 299         if (parse_events_add_pmu(parse_state, list, $1, $2, /*auto_merge_stats=*/false, &@1)) {
 300                 struct perf_pmu *pmu = NULL;
 301                 int ok = 0;
 302
 303                 /* Failure to add, try wildcard expansion of $1 as a PMU name. */
 304                 if (asprintf(&pattern, "%s*", $1) < 0) {
 305                         CLEANUP;
 306                         YYNOMEM;
 307                 }
 308
 309                 while ((pmu = perf_pmus__scan(pmu)) != NULL) {
 310                         const char *name = pmu->name;
 311
 312                         if (parse_events__filter_pmu(parse_state, pmu))
 313                                 continue;
 314
 315                         if (!strncmp(name, "uncore_", 7) &&
 316                             strncmp($1, "uncore_", 7))
 317                                 name += 7;
 318                         if (!perf_pmu__match(pattern, name, $1) ||
 319                             !perf_pmu__match(pattern, pmu->alias_name, $1)) {
 320                                 bool auto_merge_stats = perf_pmu__auto_merge_stats(pmu);
 321
 322                                 if (parse_events_copy_term_list(orig_terms, &terms)) {
 323                                         CLEANUP;
 324                                         YYNOMEM;
 325                                 }
 326                                 if (!parse_events_add_pmu(parse_state, list, pmu->name, terms,
 327                                                           auto_merge_stats, &@1)) {
 328                                         ok++;
 329                                         parse_state->wild_card_pmus = true;
 330                                 }
 331                                 parse_events_terms__delete(terms);
 332                         }
 333                 }
 334
 335                 if (!ok) {
 336                         /* Failure to add, assume $1 is an event name. */
 337                         zfree(&list);
 338                         ok = !parse_events_multi_pmu_add(parse_state, $1, $2, &list, &@1);
 339                         $2 = NULL;
 340                 }
 341                 if (!ok) {
 342                         struct parse_events_error *error = parse_state->error;
 343                         char *help;
 344
 345                         if (asprintf(&help, "Unable to find PMU or event on a PMU of '%s'", $1) < 0)
 346                                 help = NULL;
 347                         parse_events_error__handle(error, @1.first_column,
 348                                                    strdup("Bad event or PMU"),
 349                                                    help);
 350                         CLEANUP;
 351                         YYABORT;
 352                 }
 353         }
 354         $$ = list;
 355         list = NULL;
 356         CLEANUP;
 357 #undef CLEANUP
 358 }
 359 |
 360 PE_NAME sep_dc
 361 {
 362         struct list_head *list;
 363         int err;
 364
 365         err = parse_events_multi_pmu_add(_parse_state, $1, NULL, &list, &@1);
 366         if (err < 0) {
 367                 struct parse_events_state *parse_state = _parse_state;
 368                 struct parse_events_error *error = parse_state->error;
 369                 char *help;
 370
 371                 if (asprintf(&help, "Unable to find event on a PMU of '%s'", $1) < 0)
 372                         help = NULL;
 373                 parse_events_error__handle(error, @1.first_column, strdup("Bad event name"), help);
 374                 free($1);
 375                 PE_ABORT(err);
 376         }
 377         free($1);
 378         $$ = list;
 379 }
 380
 381 value_sym:
 382 PE_VALUE_SYM_HW
 383 |
 384 PE_VALUE_SYM_SW
 385
 386 event_legacy_symbol:
 387 value_sym '/' event_config '/'
 388 {
 389         struct list_head *list;
 390         int type = $1 >> 16;
 391         int config = $1 & 255;
 392         int err;
 393         bool wildcard = (type == PERF_TYPE_HARDWARE || type == PERF_TYPE_HW_CACHE);
 394
 395         list = alloc_list();
 396         if (!list)
 397                 YYNOMEM;
 398         err = parse_events_add_numeric(_parse_state, list, type, config, $3, wildcard);
 399         parse_events_terms__delete($3);
 400         if (err) {
 401                 free_list_evsel(list);
 402                 PE_ABORT(err);
 403         }
 404         $$ = list;
 405 }
 406 |
 407 value_sym sep_slash_slash_dc
 408 {
 409         struct list_head *list;
 410         int type = $1 >> 16;
 411         int config = $1 & 255;
 412         bool wildcard = (type == PERF_TYPE_HARDWARE || type == PERF_TYPE_HW_CACHE);
 413         int err;
 414
 415         list = alloc_list();
 416         if (!list)
 417                 YYNOMEM;
 418         err = parse_events_add_numeric(_parse_state, list, type, config, /*head_config=*/NULL, wildcard);
 419         if (err)
 420                 PE_ABORT(err);
 421         $$ = list;
 422 }
 423 |
 424 PE_VALUE_SYM_TOOL sep_slash_slash_dc
 425 {
 426         struct list_head *list;
 427         int err;
 428
 429         list = alloc_list();
 430         if (!list)
 431                 YYNOMEM;
 432         err = parse_events_add_tool(_parse_state, list, $1);
 433         if (err)
 434                 YYNOMEM;
 435         $$ = list;
 436 }
 437
 438 event_legacy_cache:
 439 PE_LEGACY_CACHE opt_event_config
 440 {
 441         struct parse_events_state *parse_state = _parse_state;
 442         struct list_head *list;
 443         int err;
 444
 445         list = alloc_list();
 446         if (!list)
 447                 YYNOMEM;
 448
 449         err = parse_events_add_cache(list, &parse_state->idx, $1, parse_state, $2);
 450
 451         parse_events_terms__delete($2);
 452         free($1);
 453         if (err) {
 454                 free_list_evsel(list);
 455                 PE_ABORT(err);
 456         }
 457         $$ = list;
 458 }
 459
 460 event_legacy_mem:
 461 PE_PREFIX_MEM PE_VALUE PE_BP_SLASH PE_VALUE PE_BP_COLON PE_MODIFIER_BP opt_event_config
 462 {
 463         struct list_head *list;
 464         int err;
 465
 466         list = alloc_list();
 467         if (!list)
 468                 YYNOMEM;
 469
 470         err = parse_events_add_breakpoint(_parse_state, list,
 471                                           $2, $6, $4, $7);
 472         parse_events_terms__delete($7);
 473         free($6);
 474         if (err) {
 475                 free(list);
 476                 PE_ABORT(err);
 477         }
 478         $$ = list;
 479 }
 480 |
 481 PE_PREFIX_MEM PE_VALUE PE_BP_SLASH PE_VALUE opt_event_config
 482 {
 483         struct list_head *list;
 484         int err;
 485
 486         list = alloc_list();
 487         if (!list)
 488                 YYNOMEM;
 489
 490         err = parse_events_add_breakpoint(_parse_state, list,
 491                                           $2, NULL, $4, $5);
 492         parse_events_terms__delete($5);
 493         if (err) {
 494                 free(list);
 495                 PE_ABORT(err);
 496         }
 497         $$ = list;
 498 }
 499 |
 500 PE_PREFIX_MEM PE_VALUE PE_BP_COLON PE_MODIFIER_BP opt_event_config
 501 {
 502         struct list_head *list;
 503         int err;
 504
 505         list = alloc_list();
 506         if (!list)
 507                 YYNOMEM;
 508
 509         err = parse_events_add_breakpoint(_parse_state, list,
 510                                           $2, $4, 0, $5);
 511         parse_events_terms__delete($5);
 512         free($4);
 513         if (err) {
 514                 free(list);
 515                 PE_ABORT(err);
 516         }
 517         $$ = list;
 518 }
 519 |
 520 PE_PREFIX_MEM PE_VALUE opt_event_config
 521 {
 522         struct list_head *list;
 523         int err;
 524
 525         list = alloc_list();
 526         if (!list)
 527                 YYNOMEM;
 528         err = parse_events_add_breakpoint(_parse_state, list,
 529                                           $2, NULL, 0, $3);
 530         parse_events_terms__delete($3);
 531         if (err) {
 532                 free(list);
 533                 PE_ABORT(err);
 534         }
 535         $$ = list;
 536 }
 537
 538 event_legacy_tracepoint:
 539 tracepoint_name opt_event_config
 540 {
 541         struct parse_events_state *parse_state = _parse_state;
 542         struct parse_events_error *error = parse_state->error;
 543         struct list_head *list;
 544         int err;
 545
 546         list = alloc_list();
 547         if (!list)
 548                 YYNOMEM;
 549         if (error)
 550                 error->idx = @1.first_column;
 551
 552         err = parse_events_add_tracepoint(list, &parse_state->idx, $1.sys, $1.event,
 553                                         error, $2, &@1);
 554
 555         parse_events_terms__delete($2);
 556         free($1.sys);
 557         free($1.event);
 558         if (err) {
 559                 free(list);
 560                 PE_ABORT(err);
 561         }
 562         $$ = list;
 563 }
 564
 565 tracepoint_name:
 566 PE_NAME ':' PE_NAME
 567 {
 568         struct tracepoint_name tracepoint = {$1, $3};
 569
 570         $$ = tracepoint;
 571 }
 572
 573 event_legacy_numeric:
 574 PE_VALUE ':' PE_VALUE opt_event_config
 575 {
 576         struct list_head *list;
 577         int err;
 578
 579         list = alloc_list();
 580         if (!list)
 581                 YYNOMEM;
 582         err = parse_events_add_numeric(_parse_state, list, (u32)$1, $3, $4,
 583                                        /*wildcard=*/false);
 584         parse_events_terms__delete($4);
 585         if (err) {
 586                 free(list);
 587                 PE_ABORT(err);
 588         }
 589         $$ = list;
 590 }
 591
 592 event_legacy_raw:
 593 PE_RAW opt_event_config
 594 {
 595         struct list_head *list;
 596         int err;
 597         u64 num;
 598
 599         list = alloc_list();
 600         if (!list)
 601                 YYNOMEM;
 602         errno = 0;
 603         num = strtoull($1 + 1, NULL, 16);
 604         /* Given the lexer will only give [a-fA-F0-9]+ a failure here should be impossible. */
 605         if (errno)
 606                 YYABORT;
 607         free($1);
 608         err = parse_events_add_numeric(_parse_state, list, PERF_TYPE_RAW, num, $2,
 609                                        /*wildcard=*/false);
 610         parse_events_terms__delete($2);
 611         if (err) {
 612                 free(list);
 613                 PE_ABORT(err);
 614         }
 615         $$ = list;
 616 }
 617
 618 opt_event_config:
 619 '/' event_config '/'
 620 {
 621         $$ = $2;
 622 }
 623 |
 624 '/' '/'
 625 {
 626         $$ = NULL;
 627 }
 628 |
 629 {
 630         $$ = NULL;
 631 }
 632
 633 opt_pmu_config:
 634 '/' event_config '/'
 635 {
 636         $$ = $2;
 637 }
 638 |
 639 '/' '/'
 640 {
 641         $$ = NULL;
 642 }
 643
 644 start_terms: event_config
 645 {
 646         struct parse_events_state *parse_state = _parse_state;
 647         if (parse_state->terms) {
 648                 parse_events_terms__delete ($1);
 649                 YYABORT;
 650         }
 651         parse_state->terms = $1;
 652 }
 653
 654 event_config:
 655 event_config ',' event_term
 656 {
 657         struct list_head *head = $1;
 658         struct parse_events_term *term = $3;
 659
 660         if (!head) {
 661                 parse_events_term__delete(term);
 662                 YYABORT;
 663         }
 664         list_add_tail(&term->list, head);
 665         $$ = $1;
 666 }
 667 |
 668 event_term
 669 {
 670         struct list_head *head = malloc(sizeof(*head));
 671         struct parse_events_term *term = $1;
 672
 673         if (!head)
 674                 YYNOMEM;
 675         INIT_LIST_HEAD(head);
 676         list_add_tail(&term->list, head);
 677         $$ = head;
 678 }
 679
 680 name_or_raw: PE_RAW | PE_NAME | PE_LEGACY_CACHE
 681
 682 name_or_legacy: PE_NAME | PE_LEGACY_CACHE
 683
 684 event_term:
 685 PE_RAW
 686 {
 687         struct parse_events_term *term;
 688         int err = parse_events_term__str(&term, PARSE_EVENTS__TERM_TYPE_RAW,
 689                                          strdup("raw"), $1, &@1, &@1);
 690
 691         if (err) {
 692                 free($1);
 693                 PE_ABORT(err);
 694         }
 695         $$ = term;
 696 }
 697 |
 698 name_or_raw '=' name_or_legacy
 699 {
 700         struct parse_events_term *term;
 701         int err = parse_events_term__str(&term, PARSE_EVENTS__TERM_TYPE_USER, $1, $3, &@1, &@3);
 702
 703         if (err) {
 704                 free($1);
 705                 free($3);
 706                 PE_ABORT(err);
 707         }
 708         $$ = term;
 709 }
 710 |
 711 name_or_raw '=' PE_VALUE
 712 {
 713         struct parse_events_term *term;
 714         int err = parse_events_term__num(&term, PARSE_EVENTS__TERM_TYPE_USER,
 715                                          $1, $3, /*novalue=*/false, &@1, &@3);
 716
 717         if (err) {
 718                 free($1);
 719                 PE_ABORT(err);
 720         }
 721         $$ = term;
 722 }
 723 |
 724 name_or_raw '=' PE_TERM_HW
 725 {
 726         struct parse_events_term *term;
 727         int err = parse_events_term__str(&term, PARSE_EVENTS__TERM_TYPE_USER,
 728                                          $1, $3.str, &@1, &@3);
 729
 730         if (err) {
 731                 free($1);
 732                 free($3.str);
 733                 PE_ABORT(err);
 734         }
 735         $$ = term;
 736 }
 737 |
 738 PE_LEGACY_CACHE
 739 {
 740         struct parse_events_term *term;
 741         int err = parse_events_term__num(&term, PARSE_EVENTS__TERM_TYPE_LEGACY_CACHE,
 742                                          $1, /*num=*/1, /*novalue=*/true, &@1, /*loc_val=*/NULL);
 743
 744         if (err) {
 745                 free($1);
 746                 PE_ABORT(err);
 747         }
 748         $$ = term;
 749 }
 750 |
 751 PE_NAME
 752 {
 753         struct parse_events_term *term;
 754         int err = parse_events_term__num(&term, PARSE_EVENTS__TERM_TYPE_USER,
 755                                          $1, /*num=*/1, /*novalue=*/true, &@1, /*loc_val=*/NULL);
 756
 757         if (err) {
 758                 free($1);
 759                 PE_ABORT(err);
 760         }
 761         $$ = term;
 762 }
 763 |
 764 PE_TERM_HW
 765 {
 766         struct parse_events_term *term;
 767         int err = parse_events_term__num(&term, PARSE_EVENTS__TERM_TYPE_HARDWARE,
 768                                          $1.str, $1.num & 255, /*novalue=*/false,
 769                                          &@1, /*loc_val=*/NULL);
 770
 771         if (err) {
 772                 free($1.str);
 773                 PE_ABORT(err);
 774         }
 775         $$ = term;
 776 }
 777 |
 778 PE_TERM '=' name_or_legacy
 779 {
 780         struct parse_events_term *term;
 781         int err = parse_events_term__str(&term, (enum parse_events__term_type)$1,
 782                                         /*config=*/NULL, $3, &@1, &@3);
 783
 784         if (err) {
 785                 free($3);
 786                 PE_ABORT(err);
 787         }
 788         $$ = term;
 789 }
 790 |
 791 PE_TERM '=' PE_TERM_HW
 792 {
 793         struct parse_events_term *term;
 794         int err = parse_events_term__str(&term, (enum parse_events__term_type)$1,
 795                                          /*config=*/NULL, $3.str, &@1, &@3);
 796
 797         if (err) {
 798                 free($3.str);
 799                 PE_ABORT(err);
 800         }
 801         $$ = term;
 802 }
 803 |
 804 PE_TERM '=' PE_TERM
 805 {
 806         struct parse_events_term *term;
 807         int err = parse_events_term__term(&term,
 808                                           (enum parse_events__term_type)$1,
 809                                           (enum parse_events__term_type)$3,
 810                                           &@1, &@3);
 811
 812         if (err)
 813                 PE_ABORT(err);
 814
 815         $$ = term;
 816 }
 817 |
 818 PE_TERM '=' PE_VALUE
 819 {
 820         struct parse_events_term *term;
 821         int err = parse_events_term__num(&term, (enum parse_events__term_type)$1,
 822                                          /*config=*/NULL, $3, /*novalue=*/false, &@1, &@3);
 823
 824         if (err)
 825                 PE_ABORT(err);
 826
 827         $$ = term;
 828 }
 829 |
 830 PE_TERM
 831 {
 832         struct parse_events_term *term;
 833         int err = parse_events_term__num(&term, (enum parse_events__term_type)$1,
 834                                         /*config=*/NULL, /*num=*/1, /*novalue=*/true,
 835                                         &@1, /*loc_val=*/NULL);
 836
 837         if (err)
 838                 PE_ABORT(err);
 839
 840         $$ = term;
 841 }
 842 |
 843 PE_DRV_CFG_TERM
 844 {
 845         struct parse_events_term *term;
 846         char *config = strdup($1);
 847         int err;
 848
 849         if (!config)
 850                 YYNOMEM;
 851         err = parse_events_term__str(&term, PARSE_EVENTS__TERM_TYPE_DRV_CFG, config, $1, &@1, NULL);
 852         if (err) {
 853                 free($1);
 854                 free(config);
 855                 PE_ABORT(err);
 856         }
 857         $$ = term;
 858 }
 859
 860 sep_dc: ':' |
 861
 862 sep_slash_slash_dc: '/' '/' | ':' |
 863
 864 %%
 865
 866 void parse_events_error(YYLTYPE *loc, void *parse_state,
 867                         void *scanner __maybe_unused,
 868                         char const *msg __maybe_unused)
 869 {
 870         parse_events_evlist_error(parse_state, loc->last_column, "parser error");
 871 }