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