tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
1
2%option reentrant
3%option bison-bridge
4%option prefix="parse_events_"
5%option stack
6
7%{
8#include <errno.h>
9#include "../perf.h"
10#include "parse-events-bison.h"
11#include "parse-events.h"
12
13char *parse_events_get_text(yyscan_t yyscanner);
14YYSTYPE *parse_events_get_lval(yyscan_t yyscanner);
15
16static int __value(YYSTYPE *yylval, char *str, int base, int token)
17{
18 u64 num;
19
20 errno = 0;
21 num = strtoull(str, NULL, base);
22 if (errno)
23 return PE_ERROR;
24
25 yylval->num = num;
26 return token;
27}
28
29static int value(yyscan_t scanner, int base)
30{
31 YYSTYPE *yylval = parse_events_get_lval(scanner);
32 char *text = parse_events_get_text(scanner);
33
34 return __value(yylval, text, base, PE_VALUE);
35}
36
37static int raw(yyscan_t scanner)
38{
39 YYSTYPE *yylval = parse_events_get_lval(scanner);
40 char *text = parse_events_get_text(scanner);
41
42 return __value(yylval, text + 1, 16, PE_RAW);
43}
44
45static int str(yyscan_t scanner, int token)
46{
47 YYSTYPE *yylval = parse_events_get_lval(scanner);
48 char *text = parse_events_get_text(scanner);
49
50 yylval->str = strdup(text);
51 return token;
52}
53
54static int sym(yyscan_t scanner, int type, int config)
55{
56 YYSTYPE *yylval = parse_events_get_lval(scanner);
57
58 yylval->num = (type << 16) + config;
59 return type == PERF_TYPE_HARDWARE ? PE_VALUE_SYM_HW : PE_VALUE_SYM_SW;
60}
61
62static int term(yyscan_t scanner, int type)
63{
64 YYSTYPE *yylval = parse_events_get_lval(scanner);
65
66 yylval->num = type;
67 return PE_TERM;
68}
69
70%}
71
72%x mem
73%s config
74%x event
75
76group [^,{}/]*[{][^}]*[}][^,{}/]*
77event_pmu [^,{}/]+[/][^/]*[/][^,{}/]*
78event [^,{}/]+
79
80num_dec [0-9]+
81num_hex 0x[a-fA-F0-9]+
82num_raw_hex [a-fA-F0-9]+
83name [a-zA-Z_*?][a-zA-Z0-9_*?]*
84name_minus [a-zA-Z_*?][a-zA-Z0-9\-_*?]*
85/* If you add a modifier you need to update check_modifier() */
86modifier_event [ukhpGHSD]+
87modifier_bp [rwx]{1,3}
88
89%%
90
91%{
92 {
93 int start_token;
94
95 start_token = parse_events_get_extra(yyscanner);
96
97 if (start_token == PE_START_TERMS)
98 BEGIN(config);
99 else if (start_token == PE_START_EVENTS)
100 BEGIN(event);
101
102 if (start_token) {
103 parse_events_set_extra(NULL, yyscanner);
104 return start_token;
105 }
106 }
107%}
108
109<event>{
110
111{group} {
112 BEGIN(INITIAL); yyless(0);
113 }
114
115{event_pmu} |
116{event} {
117 str(yyscanner, PE_EVENT_NAME);
118 BEGIN(INITIAL); yyless(0);
119 return PE_EVENT_NAME;
120 }
121
122. |
123<<EOF>> {
124 BEGIN(INITIAL); yyless(0);
125 }
126
127}
128
129<config>{
130config { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_CONFIG); }
131config1 { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_CONFIG1); }
132config2 { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_CONFIG2); }
133name { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_NAME); }
134period { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD); }
135branch_type { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE); }
136, { return ','; }
137"/" { BEGIN(INITIAL); return '/'; }
138{name_minus} { return str(yyscanner, PE_NAME); }
139}
140
141<mem>{
142{modifier_bp} { return str(yyscanner, PE_MODIFIER_BP); }
143: { return ':'; }
144{num_dec} { return value(yyscanner, 10); }
145{num_hex} { return value(yyscanner, 16); }
146 /*
147 * We need to separate 'mem:' scanner part, in order to get specific
148 * modifier bits parsed out. Otherwise we would need to handle PE_NAME
149 * and we'd need to parse it manually. During the escape from <mem>
150 * state we need to put the escaping char back, so we dont miss it.
151 */
152. { unput(*yytext); BEGIN(INITIAL); }
153 /*
154 * We destroy the scanner after reaching EOF,
155 * but anyway just to be sure get back to INIT state.
156 */
157<<EOF>> { BEGIN(INITIAL); }
158}
159
160cpu-cycles|cycles { return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_CPU_CYCLES); }
161stalled-cycles-frontend|idle-cycles-frontend { return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_STALLED_CYCLES_FRONTEND); }
162stalled-cycles-backend|idle-cycles-backend { return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_STALLED_CYCLES_BACKEND); }
163instructions { return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_INSTRUCTIONS); }
164cache-references { return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_CACHE_REFERENCES); }
165cache-misses { return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_CACHE_MISSES); }
166branch-instructions|branches { return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_BRANCH_INSTRUCTIONS); }
167branch-misses { return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_BRANCH_MISSES); }
168bus-cycles { return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_BUS_CYCLES); }
169ref-cycles { return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_REF_CPU_CYCLES); }
170cpu-clock { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_CPU_CLOCK); }
171task-clock { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_TASK_CLOCK); }
172page-faults|faults { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_PAGE_FAULTS); }
173minor-faults { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_PAGE_FAULTS_MIN); }
174major-faults { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_PAGE_FAULTS_MAJ); }
175context-switches|cs { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_CONTEXT_SWITCHES); }
176cpu-migrations|migrations { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_CPU_MIGRATIONS); }
177alignment-faults { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_ALIGNMENT_FAULTS); }
178emulation-faults { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_EMULATION_FAULTS); }
179dummy { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_DUMMY); }
180
181L1-dcache|l1-d|l1d|L1-data |
182L1-icache|l1-i|l1i|L1-instruction |
183LLC|L2 |
184dTLB|d-tlb|Data-TLB |
185iTLB|i-tlb|Instruction-TLB |
186branch|branches|bpu|btb|bpc |
187node { return str(yyscanner, PE_NAME_CACHE_TYPE); }
188
189load|loads|read |
190store|stores|write |
191prefetch|prefetches |
192speculative-read|speculative-load |
193refs|Reference|ops|access |
194misses|miss { return str(yyscanner, PE_NAME_CACHE_OP_RESULT); }
195
196mem: { BEGIN(mem); return PE_PREFIX_MEM; }
197r{num_raw_hex} { return raw(yyscanner); }
198{num_dec} { return value(yyscanner, 10); }
199{num_hex} { return value(yyscanner, 16); }
200
201{modifier_event} { return str(yyscanner, PE_MODIFIER_EVENT); }
202{name} { return str(yyscanner, PE_NAME); }
203"/" { BEGIN(config); return '/'; }
204- { return '-'; }
205, { BEGIN(event); return ','; }
206: { return ':'; }
207"{" { BEGIN(event); return '{'; }
208"}" { return '}'; }
209= { return '='; }
210\n { }
211. { }
212
213%%
214
215int parse_events_wrap(void *scanner __maybe_unused)
216{
217 return 1;
218}