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