tools/perf/util/parse-events.y

   1 %pure-parser
   2 %name-prefix "parse_events_"
   3 %parse-param {void *_data}
   4 %parse-param {void *scanner}
   5 %lex-param {void* scanner}
   6
   7 %{
   8
   9 #define YYDEBUG 1
  10
  11 #include <linux/compiler.h>
  12 #include <linux/list.h>
  13 #include "types.h"
  14 #include "util.h"
  15 #include "parse-events.h"
  16 #include "parse-events-bison.h"
  17
  18 extern int parse_events_lex (YYSTYPE* lvalp, void* scanner);
  19
  20 #define ABORT_ON(val) \
  21 do { \
  22         if (val) \
  23                 YYABORT; \
  24 } while (0)
  25
  26 %}
  27
  28 %token PE_START_EVENTS PE_START_TERMS
  29 %token PE_VALUE PE_VALUE_SYM_HW PE_VALUE_SYM_SW PE_RAW PE_TERM
  30 %token PE_NAME
  31 %token PE_MODIFIER_EVENT PE_MODIFIER_BP
  32 %token PE_NAME_CACHE_TYPE PE_NAME_CACHE_OP_RESULT
  33 %token PE_PREFIX_MEM PE_PREFIX_RAW PE_PREFIX_GROUP
  34 %token PE_ERROR
  35 %type <num> PE_VALUE
  36 %type <num> PE_VALUE_SYM_HW
  37 %type <num> PE_VALUE_SYM_SW
  38 %type <num> PE_RAW
  39 %type <num> PE_TERM
  40 %type <str> PE_NAME
  41 %type <str> PE_NAME_CACHE_TYPE
  42 %type <str> PE_NAME_CACHE_OP_RESULT
  43 %type <str> PE_MODIFIER_EVENT
  44 %type <str> PE_MODIFIER_BP
  45 %type <num> value_sym
  46 %type <head> event_config
  47 %type <term> event_term
  48 %type <head> event_pmu
  49 %type <head> event_legacy_symbol
  50 %type <head> event_legacy_cache
  51 %type <head> event_legacy_mem
  52 %type <head> event_legacy_tracepoint
  53 %type <head> event_legacy_numeric
  54 %type <head> event_legacy_raw
  55 %type <head> event_def
  56 %type <head> event
  57 %type <head> events
  58 %type <head> group_def
  59 %type <head> group
  60 %type <head> groups
  61
  62 %union
  63 {
  64         char *str;
  65         u64 num;
  66         struct list_head *head;
  67         struct parse_events__term *term;
  68 }
  69 %%
  70
  71 start:
  72 PE_START_EVENTS start_events
  73 |
  74 PE_START_TERMS  start_terms
  75
  76 start_events: groups
  77 {
  78         struct parse_events_data__events *data = _data;
  79
  80         parse_events_update_lists($1, &data->list);
  81 }
  82
  83 groups:
  84 groups ',' group
  85 {
  86         struct list_head *list  = $1;
  87         struct list_head *group = $3;
  88
  89         parse_events_update_lists(group, list);
  90         $$ = list;
  91 }
  92 |
  93 groups ',' event
  94 {
  95         struct list_head *list  = $1;
  96         struct list_head *event = $3;
  97
  98         parse_events_update_lists(event, list);
  99         $$ = list;
 100 }
 101 |
 102 group
 103 |
 104 event
 105
 106 group:
 107 group_def ':' PE_MODIFIER_EVENT
 108 {
 109         struct list_head *list = $1;
 110
 111         ABORT_ON(parse_events__modifier_group(list, $3));
 112         $$ = list;
 113 }
 114 |
 115 group_def
 116
 117 group_def:
 118 PE_NAME '{' events '}'
 119 {
 120         struct list_head *list = $3;
 121
 122         parse_events__group($1, list);
 123         $$ = list;
 124 }
 125 |
 126 '{' events '}'
 127 {
 128         struct list_head *list = $2;
 129
 130         parse_events__group(NULL, list);
 131         $$ = list;
 132 }
 133
 134 events:
 135 events ',' event
 136 {
 137         struct list_head *event = $3;
 138         struct list_head *list  = $1;
 139
 140         parse_events_update_lists(event, list);
 141         $$ = list;
 142 }
 143 |
 144 event
 145
 146 event:
 147 event_def PE_MODIFIER_EVENT
 148 {
 149         struct list_head *list = $1;
 150
 151         /*
 152          * Apply modifier on all events added by single event definition
 153          * (there could be more events added for multiple tracepoint
 154          * definitions via '*?'.
 155          */
 156         ABORT_ON(parse_events__modifier_event(list, $2));
 157         $$ = list;
 158 }
 159 |
 160 event_def
 161
 162 event_def: event_pmu |
 163            event_legacy_symbol |
 164            event_legacy_cache sep_dc |
 165            event_legacy_mem |
 166            event_legacy_tracepoint sep_dc |
 167            event_legacy_numeric sep_dc |
 168            event_legacy_raw sep_dc
 169
 170 event_pmu:
 171 PE_NAME '/' event_config '/'
 172 {
 173         struct parse_events_data__events *data = _data;
 174         struct list_head *list = NULL;
 175
 176         ABORT_ON(parse_events_add_pmu(&list, &data->idx, $1, $3));
 177         parse_events__free_terms($3);
 178         $$ = list;
 179 }
 180
 181 value_sym:
 182 PE_VALUE_SYM_HW
 183 |
 184 PE_VALUE_SYM_SW
 185
 186 event_legacy_symbol:
 187 value_sym '/' event_config '/'
 188 {
 189         struct parse_events_data__events *data = _data;
 190         struct list_head *list = NULL;
 191         int type = $1 >> 16;
 192         int config = $1 & 255;
 193
 194         ABORT_ON(parse_events_add_numeric(&list, &data->idx,
 195                                           type, config, $3));
 196         parse_events__free_terms($3);
 197         $$ = list;
 198 }
 199 |
 200 value_sym sep_slash_dc
 201 {
 202         struct parse_events_data__events *data = _data;
 203         struct list_head *list = NULL;
 204         int type = $1 >> 16;
 205         int config = $1 & 255;
 206
 207         ABORT_ON(parse_events_add_numeric(&list, &data->idx,
 208                                           type, config, NULL));
 209         $$ = list;
 210 }
 211
 212 event_legacy_cache:
 213 PE_NAME_CACHE_TYPE '-' PE_NAME_CACHE_OP_RESULT '-' PE_NAME_CACHE_OP_RESULT
 214 {
 215         struct parse_events_data__events *data = _data;
 216         struct list_head *list = NULL;
 217
 218         ABORT_ON(parse_events_add_cache(&list, &data->idx, $1, $3, $5));
 219         $$ = list;
 220 }
 221 |
 222 PE_NAME_CACHE_TYPE '-' PE_NAME_CACHE_OP_RESULT
 223 {
 224         struct parse_events_data__events *data = _data;
 225         struct list_head *list = NULL;
 226
 227         ABORT_ON(parse_events_add_cache(&list, &data->idx, $1, $3, NULL));
 228         $$ = list;
 229 }
 230 |
 231 PE_NAME_CACHE_TYPE
 232 {
 233         struct parse_events_data__events *data = _data;
 234         struct list_head *list = NULL;
 235
 236         ABORT_ON(parse_events_add_cache(&list, &data->idx, $1, NULL, NULL));
 237         $$ = list;
 238 }
 239
 240 event_legacy_mem:
 241 PE_PREFIX_MEM PE_VALUE ':' PE_MODIFIER_BP sep_dc
 242 {
 243         struct parse_events_data__events *data = _data;
 244         struct list_head *list = NULL;
 245
 246         ABORT_ON(parse_events_add_breakpoint(&list, &data->idx,
 247                                              (void *) $2, $4));
 248         $$ = list;
 249 }
 250 |
 251 PE_PREFIX_MEM PE_VALUE sep_dc
 252 {
 253         struct parse_events_data__events *data = _data;
 254         struct list_head *list = NULL;
 255
 256         ABORT_ON(parse_events_add_breakpoint(&list, &data->idx,
 257                                              (void *) $2, NULL));
 258         $$ = list;
 259 }
 260
 261 event_legacy_tracepoint:
 262 PE_NAME ':' PE_NAME
 263 {
 264         struct parse_events_data__events *data = _data;
 265         struct list_head *list = NULL;
 266
 267         ABORT_ON(parse_events_add_tracepoint(&list, &data->idx, $1, $3));
 268         $$ = list;
 269 }
 270
 271 event_legacy_numeric:
 272 PE_VALUE ':' PE_VALUE
 273 {
 274         struct parse_events_data__events *data = _data;
 275         struct list_head *list = NULL;
 276
 277         ABORT_ON(parse_events_add_numeric(&list, &data->idx, (u32)$1, $3, NULL));
 278         $$ = list;
 279 }
 280
 281 event_legacy_raw:
 282 PE_RAW
 283 {
 284         struct parse_events_data__events *data = _data;
 285         struct list_head *list = NULL;
 286
 287         ABORT_ON(parse_events_add_numeric(&list, &data->idx,
 288                                           PERF_TYPE_RAW, $1, NULL));
 289         $$ = list;
 290 }
 291
 292 start_terms: event_config
 293 {
 294         struct parse_events_data__terms *data = _data;
 295         data->terms = $1;
 296 }
 297
 298 event_config:
 299 event_config ',' event_term
 300 {
 301         struct list_head *head = $1;
 302         struct parse_events__term *term = $3;
 303
 304         ABORT_ON(!head);
 305         list_add_tail(&term->list, head);
 306         $$ = $1;
 307 }
 308 |
 309 event_term
 310 {
 311         struct list_head *head = malloc(sizeof(*head));
 312         struct parse_events__term *term = $1;
 313
 314         ABORT_ON(!head);
 315         INIT_LIST_HEAD(head);
 316         list_add_tail(&term->list, head);
 317         $$ = head;
 318 }
 319
 320 event_term:
 321 PE_NAME '=' PE_NAME
 322 {
 323         struct parse_events__term *term;
 324
 325         ABORT_ON(parse_events__term_str(&term, PARSE_EVENTS__TERM_TYPE_USER,
 326                                         $1, $3));
 327         $$ = term;
 328 }
 329 |
 330 PE_NAME '=' PE_VALUE
 331 {
 332         struct parse_events__term *term;
 333
 334         ABORT_ON(parse_events__term_num(&term, PARSE_EVENTS__TERM_TYPE_USER,
 335                                         $1, $3));
 336         $$ = term;
 337 }
 338 |
 339 PE_NAME
 340 {
 341         struct parse_events__term *term;
 342
 343         ABORT_ON(parse_events__term_num(&term, PARSE_EVENTS__TERM_TYPE_USER,
 344                                         $1, 1));
 345         $$ = term;
 346 }
 347 |
 348 PE_TERM '=' PE_NAME
 349 {
 350         struct parse_events__term *term;
 351
 352         ABORT_ON(parse_events__term_str(&term, (int)$1, NULL, $3));
 353         $$ = term;
 354 }
 355 |
 356 PE_TERM '=' PE_VALUE
 357 {
 358         struct parse_events__term *term;
 359
 360         ABORT_ON(parse_events__term_num(&term, (int)$1, NULL, $3));
 361         $$ = term;
 362 }
 363 |
 364 PE_TERM
 365 {
 366         struct parse_events__term *term;
 367
 368         ABORT_ON(parse_events__term_num(&term, (int)$1, NULL, 1));
 369         $$ = term;
 370 }
 371
 372 sep_dc: ':' |
 373
 374 sep_slash_dc: '/' | ':' |
 375
 376 %%
 377
 378 void parse_events_error(void *data __used, void *scanner __used,
 379                         char const *msg __used)
 380 {
 381 }