Commit | Line | Data |
---|---|---|
89812fc8 | 1 | |
ac20de6f ZY |
2 | %option reentrant |
3 | %option bison-bridge | |
89812fc8 | 4 | %option prefix="parse_events_" |
08d2f762 | 5 | %option stack |
6297d423 JO |
6 | %option bison-locations |
7 | %option yylineno | |
89812fc8 JO |
8 | |
9 | %{ | |
10 | #include <errno.h> | |
11 | #include "../perf.h" | |
8f707d84 | 12 | #include "parse-events.h" |
e571e029 | 13 | #include "parse-events-bison.h" |
89812fc8 | 14 | |
ac20de6f ZY |
15 | char *parse_events_get_text(yyscan_t yyscanner); |
16 | YYSTYPE *parse_events_get_lval(yyscan_t yyscanner); | |
17 | ||
18 | static int __value(YYSTYPE *yylval, char *str, int base, int token) | |
89812fc8 | 19 | { |
b527bab5 | 20 | u64 num; |
89812fc8 JO |
21 | |
22 | errno = 0; | |
b527bab5 | 23 | num = strtoull(str, NULL, base); |
89812fc8 JO |
24 | if (errno) |
25 | return PE_ERROR; | |
26 | ||
ac20de6f | 27 | yylval->num = num; |
89812fc8 JO |
28 | return token; |
29 | } | |
30 | ||
ac20de6f | 31 | static int value(yyscan_t scanner, int base) |
89812fc8 | 32 | { |
ac20de6f ZY |
33 | YYSTYPE *yylval = parse_events_get_lval(scanner); |
34 | char *text = parse_events_get_text(scanner); | |
35 | ||
36 | return __value(yylval, text, base, PE_VALUE); | |
89812fc8 JO |
37 | } |
38 | ||
ac20de6f | 39 | static int raw(yyscan_t scanner) |
89812fc8 | 40 | { |
ac20de6f ZY |
41 | YYSTYPE *yylval = parse_events_get_lval(scanner); |
42 | char *text = parse_events_get_text(scanner); | |
43 | ||
44 | return __value(yylval, text + 1, 16, PE_RAW); | |
89812fc8 JO |
45 | } |
46 | ||
ac20de6f | 47 | static int str(yyscan_t scanner, int token) |
89812fc8 | 48 | { |
ac20de6f ZY |
49 | YYSTYPE *yylval = parse_events_get_lval(scanner); |
50 | char *text = parse_events_get_text(scanner); | |
51 | ||
52 | yylval->str = strdup(text); | |
89812fc8 JO |
53 | return token; |
54 | } | |
55 | ||
6297d423 JO |
56 | #define REWIND(__alloc) \ |
57 | do { \ | |
58 | YYSTYPE *__yylval = parse_events_get_lval(yyscanner); \ | |
59 | char *text = parse_events_get_text(yyscanner); \ | |
60 | \ | |
61 | if (__alloc) \ | |
62 | __yylval->str = strdup(text); \ | |
63 | \ | |
64 | yycolumn -= strlen(text); \ | |
65 | yyless(0); \ | |
66 | } while (0) | |
67 | ||
ba32a451 KL |
68 | static int pmu_str_check(yyscan_t scanner) |
69 | { | |
70 | YYSTYPE *yylval = parse_events_get_lval(scanner); | |
71 | char *text = parse_events_get_text(scanner); | |
72 | ||
73 | yylval->str = strdup(text); | |
74 | switch (perf_pmu__parse_check(text)) { | |
75 | case PMU_EVENT_SYMBOL_PREFIX: | |
76 | return PE_PMU_EVENT_PRE; | |
77 | case PMU_EVENT_SYMBOL_SUFFIX: | |
78 | return PE_PMU_EVENT_SUF; | |
79 | case PMU_EVENT_SYMBOL: | |
80 | return PE_KERNEL_PMU_EVENT; | |
81 | default: | |
82 | return PE_NAME; | |
83 | } | |
84 | } | |
85 | ||
ac20de6f | 86 | static int sym(yyscan_t scanner, int type, int config) |
89812fc8 | 87 | { |
ac20de6f ZY |
88 | YYSTYPE *yylval = parse_events_get_lval(scanner); |
89 | ||
90 | yylval->num = (type << 16) + config; | |
cf3506dc | 91 | return type == PERF_TYPE_HARDWARE ? PE_VALUE_SYM_HW : PE_VALUE_SYM_SW; |
89812fc8 JO |
92 | } |
93 | ||
ac20de6f | 94 | static int term(yyscan_t scanner, int type) |
8f707d84 | 95 | { |
ac20de6f ZY |
96 | YYSTYPE *yylval = parse_events_get_lval(scanner); |
97 | ||
98 | yylval->num = type; | |
8f707d84 JO |
99 | return PE_TERM; |
100 | } | |
101 | ||
6297d423 JO |
102 | #define YY_USER_ACTION \ |
103 | do { \ | |
104 | yylloc->last_column = yylloc->first_column; \ | |
105 | yylloc->first_column = yycolumn; \ | |
106 | yycolumn += yyleng; \ | |
107 | } while (0); | |
108 | ||
89812fc8 JO |
109 | %} |
110 | ||
08d2f762 | 111 | %x mem |
ac2ba9f3 RR |
112 | %s config |
113 | %x event | |
e571e029 | 114 | %x array |
ac2ba9f3 RR |
115 | |
116 | group [^,{}/]*[{][^}]*[}][^,{}/]* | |
117 | event_pmu [^,{}/]+[/][^/]*[/][^,{}/]* | |
118 | event [^,{}/]+ | |
84c86ca1 | 119 | bpf_object .*\.(o|bpf) |
d509db04 | 120 | bpf_source .*\.c |
08d2f762 | 121 | |
89812fc8 JO |
122 | num_dec [0-9]+ |
123 | num_hex 0x[a-fA-F0-9]+ | |
124 | num_raw_hex [a-fA-F0-9]+ | |
5b021ddf | 125 | name [a-zA-Z_*?][a-zA-Z0-9_*?.]* |
a34f3be7 | 126 | name_minus [a-zA-Z_*?][a-zA-Z0-9\-_*?.:]* |
e9a7c414 | 127 | /* If you add a modifier you need to update check_modifier() */ |
7f94af7a | 128 | modifier_event [ukhpPGHSDI]+ |
7582732f | 129 | modifier_bp [rwx]{1,3} |
89812fc8 JO |
130 | |
131 | %% | |
90e2b22d JO |
132 | |
133 | %{ | |
134 | { | |
135 | int start_token; | |
136 | ||
ac2ba9f3 RR |
137 | start_token = parse_events_get_extra(yyscanner); |
138 | ||
139 | if (start_token == PE_START_TERMS) | |
140 | BEGIN(config); | |
141 | else if (start_token == PE_START_EVENTS) | |
142 | BEGIN(event); | |
143 | ||
90e2b22d JO |
144 | if (start_token) { |
145 | parse_events_set_extra(NULL, yyscanner); | |
6297d423 JO |
146 | /* |
147 | * The flex parser does not init locations variable | |
148 | * via the scan_string interface, so we need do the | |
149 | * init in here. | |
150 | */ | |
151 | yycolumn = 0; | |
90e2b22d JO |
152 | return start_token; |
153 | } | |
154 | } | |
155 | %} | |
156 | ||
ac2ba9f3 RR |
157 | <event>{ |
158 | ||
159 | {group} { | |
6297d423 JO |
160 | BEGIN(INITIAL); |
161 | REWIND(0); | |
ac2ba9f3 RR |
162 | } |
163 | ||
164 | {event_pmu} | | |
84c86ca1 | 165 | {bpf_object} | |
d509db04 | 166 | {bpf_source} | |
ac2ba9f3 | 167 | {event} { |
6297d423 JO |
168 | BEGIN(INITIAL); |
169 | REWIND(1); | |
ac2ba9f3 RR |
170 | return PE_EVENT_NAME; |
171 | } | |
172 | ||
ac2ba9f3 | 173 | <<EOF>> { |
6297d423 JO |
174 | BEGIN(INITIAL); |
175 | REWIND(0); | |
ac2ba9f3 RR |
176 | } |
177 | ||
178 | } | |
179 | ||
e571e029 WN |
180 | <array>{ |
181 | "]" { BEGIN(config); return ']'; } | |
182 | {num_dec} { return value(yyscanner, 10); } | |
183 | {num_hex} { return value(yyscanner, 16); } | |
184 | , { return ','; } | |
185 | "\.\.\." { return PE_ARRAY_RANGE; } | |
186 | } | |
187 | ||
82004223 | 188 | <config>{ |
e64b020b | 189 | /* |
17cb5f84 | 190 | * Please update config_term_names when new static term is added. |
e64b020b | 191 | */ |
82004223 JO |
192 | config { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_CONFIG); } |
193 | config1 { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_CONFIG1); } | |
194 | config2 { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_CONFIG2); } | |
195 | name { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_NAME); } | |
196 | period { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD); } | |
09af2a55 | 197 | freq { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_SAMPLE_FREQ); } |
82004223 | 198 | branch_type { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE); } |
32067712 | 199 | time { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_TIME); } |
d457c963 KL |
200 | call-graph { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_CALLGRAPH); } |
201 | stack-size { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_STACKSIZE); } | |
792d48b4 | 202 | max-stack { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_MAX_STACK); } |
374ce938 WN |
203 | inherit { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_INHERIT); } |
204 | no-inherit { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_NOINHERIT); } | |
626a6b78 WN |
205 | overwrite { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_OVERWRITE); } |
206 | no-overwrite { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_NOOVERWRITE); } | |
82004223 JO |
207 | , { return ','; } |
208 | "/" { BEGIN(INITIAL); return '/'; } | |
209 | {name_minus} { return str(yyscanner, PE_NAME); } | |
e571e029 WN |
210 | \[all\] { return PE_ARRAY_ALL; } |
211 | "[" { BEGIN(array); return '['; } | |
82004223 JO |
212 | } |
213 | ||
214 | <mem>{ | |
215 | {modifier_bp} { return str(yyscanner, PE_MODIFIER_BP); } | |
216 | : { return ':'; } | |
3741eb9f | 217 | "/" { return '/'; } |
82004223 JO |
218 | {num_dec} { return value(yyscanner, 10); } |
219 | {num_hex} { return value(yyscanner, 16); } | |
220 | /* | |
221 | * We need to separate 'mem:' scanner part, in order to get specific | |
222 | * modifier bits parsed out. Otherwise we would need to handle PE_NAME | |
223 | * and we'd need to parse it manually. During the escape from <mem> | |
224 | * state we need to put the escaping char back, so we dont miss it. | |
225 | */ | |
226 | . { unput(*yytext); BEGIN(INITIAL); } | |
227 | /* | |
228 | * We destroy the scanner after reaching EOF, | |
229 | * but anyway just to be sure get back to INIT state. | |
230 | */ | |
231 | <<EOF>> { BEGIN(INITIAL); } | |
232 | } | |
233 | ||
ac20de6f ZY |
234 | cpu-cycles|cycles { return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_CPU_CYCLES); } |
235 | stalled-cycles-frontend|idle-cycles-frontend { return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_STALLED_CYCLES_FRONTEND); } | |
236 | stalled-cycles-backend|idle-cycles-backend { return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_STALLED_CYCLES_BACKEND); } | |
237 | instructions { return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_INSTRUCTIONS); } | |
238 | cache-references { return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_CACHE_REFERENCES); } | |
239 | cache-misses { return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_CACHE_MISSES); } | |
240 | branch-instructions|branches { return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_BRANCH_INSTRUCTIONS); } | |
241 | branch-misses { return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_BRANCH_MISSES); } | |
242 | bus-cycles { return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_BUS_CYCLES); } | |
243 | ref-cycles { return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_REF_CPU_CYCLES); } | |
244 | cpu-clock { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_CPU_CLOCK); } | |
245 | task-clock { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_TASK_CLOCK); } | |
246 | page-faults|faults { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_PAGE_FAULTS); } | |
247 | minor-faults { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_PAGE_FAULTS_MIN); } | |
248 | major-faults { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_PAGE_FAULTS_MAJ); } | |
249 | context-switches|cs { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_CONTEXT_SWITCHES); } | |
250 | cpu-migrations|migrations { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_CPU_MIGRATIONS); } | |
251 | alignment-faults { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_ALIGNMENT_FAULTS); } | |
252 | emulation-faults { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_EMULATION_FAULTS); } | |
d22d1a2a | 253 | dummy { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_DUMMY); } |
03e0a7df | 254 | bpf-output { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_BPF_OUTPUT); } |
89812fc8 | 255 | |
ba32a451 KL |
256 | /* |
257 | * We have to handle the kernel PMU event cycles-ct/cycles-t/mem-loads/mem-stores separately. | |
258 | * Because the prefix cycles is mixed up with cpu-cycles. | |
259 | * loads and stores are mixed up with cache event | |
260 | */ | |
261 | cycles-ct { return str(yyscanner, PE_KERNEL_PMU_EVENT); } | |
262 | cycles-t { return str(yyscanner, PE_KERNEL_PMU_EVENT); } | |
263 | mem-loads { return str(yyscanner, PE_KERNEL_PMU_EVENT); } | |
264 | mem-stores { return str(yyscanner, PE_KERNEL_PMU_EVENT); } | |
44b1e60a | 265 | topdown-[a-z-]+ { return str(yyscanner, PE_KERNEL_PMU_EVENT); } |
ba32a451 | 266 | |
89812fc8 JO |
267 | L1-dcache|l1-d|l1d|L1-data | |
268 | L1-icache|l1-i|l1i|L1-instruction | | |
269 | LLC|L2 | | |
270 | dTLB|d-tlb|Data-TLB | | |
271 | iTLB|i-tlb|Instruction-TLB | | |
272 | branch|branches|bpu|btb|bpc | | |
ac20de6f | 273 | node { return str(yyscanner, PE_NAME_CACHE_TYPE); } |
89812fc8 JO |
274 | |
275 | load|loads|read | | |
276 | store|stores|write | | |
277 | prefetch|prefetches | | |
278 | speculative-read|speculative-load | | |
279 | refs|Reference|ops|access | | |
ac20de6f | 280 | misses|miss { return str(yyscanner, PE_NAME_CACHE_OP_RESULT); } |
89812fc8 | 281 | |
08d2f762 | 282 | mem: { BEGIN(mem); return PE_PREFIX_MEM; } |
ac20de6f ZY |
283 | r{num_raw_hex} { return raw(yyscanner); } |
284 | {num_dec} { return value(yyscanner, 10); } | |
285 | {num_hex} { return value(yyscanner, 16); } | |
89812fc8 | 286 | |
ac20de6f | 287 | {modifier_event} { return str(yyscanner, PE_MODIFIER_EVENT); } |
84c86ca1 | 288 | {bpf_object} { return str(yyscanner, PE_BPF_OBJECT); } |
d509db04 | 289 | {bpf_source} { return str(yyscanner, PE_BPF_SOURCE); } |
ba32a451 | 290 | {name} { return pmu_str_check(yyscanner); } |
ac2ba9f3 | 291 | "/" { BEGIN(config); return '/'; } |
89812fc8 | 292 | - { return '-'; } |
ac2ba9f3 | 293 | , { BEGIN(event); return ','; } |
89812fc8 | 294 | : { return ':'; } |
ac2ba9f3 | 295 | "{" { BEGIN(event); return '{'; } |
89efb029 | 296 | "}" { return '}'; } |
89812fc8 | 297 | = { return '='; } |
8c5f0a84 | 298 | \n { } |
82004223 | 299 | . { } |
08d2f762 | 300 | |
89812fc8 JO |
301 | %% |
302 | ||
1d037ca1 | 303 | int parse_events_wrap(void *scanner __maybe_unused) |
89812fc8 JO |
304 | { |
305 | return 1; | |
306 | } |