tools/perf/util/parse-events.l

   1
   2 %option prefix="parse_events_"
   3
   4 %{
   5 #include <errno.h>
   6 #include "../perf.h"
   7 #include "parse-events-bison.h"
   8
   9 static int __value(char *str, int base, int token)
  10 {
  11         long num;
  12
  13         errno = 0;
  14         num = strtoul(str, NULL, base);
  15         if (errno)
  16                 return PE_ERROR;
  17
  18         parse_events_lval.num = num;
  19         return token;
  20 }
  21
  22 static int value(int base)
  23 {
  24         return __value(parse_events_text, base, PE_VALUE);
  25 }
  26
  27 static int raw(void)
  28 {
  29         return __value(parse_events_text + 1, 16, PE_RAW);
  30 }
  31
  32 static int str(int token)
  33 {
  34         parse_events_lval.str = strdup(parse_events_text);
  35         return token;
  36 }
  37
  38 static int sym(int type, int config)
  39 {
  40         parse_events_lval.num = (type << 16) + config;
  41         return PE_VALUE_SYM;
  42 }
  43
  44 %}
  45
  46 num_dec         [0-9]+
  47 num_hex         0x[a-fA-F0-9]+
  48 num_raw_hex     [a-fA-F0-9]+
  49 name            [a-zA-Z_*?][a-zA-Z0-9_*?]*
  50 modifier_event  [ukhp]{1,5}
  51 modifier_bp     [rwx]
  52
  53 %%
  54 cpu-cycles|cycles                               { return sym(PERF_TYPE_HARDWARE, PERF_COUNT_HW_CPU_CYCLES); }
  55 stalled-cycles-frontend|idle-cycles-frontend    { return sym(PERF_TYPE_HARDWARE, PERF_COUNT_HW_STALLED_CYCLES_FRONTEND); }
  56 stalled-cycles-backend|idle-cycles-backend      { return sym(PERF_TYPE_HARDWARE, PERF_COUNT_HW_STALLED_CYCLES_BACKEND); }
  57 instructions                                    { return sym(PERF_TYPE_HARDWARE, PERF_COUNT_HW_INSTRUCTIONS); }
  58 cache-references                                { return sym(PERF_TYPE_HARDWARE, PERF_COUNT_HW_CACHE_REFERENCES); }
  59 cache-misses                                    { return sym(PERF_TYPE_HARDWARE, PERF_COUNT_HW_CACHE_MISSES); }
  60 branch-instructions|branches                    { return sym(PERF_TYPE_HARDWARE, PERF_COUNT_HW_BRANCH_INSTRUCTIONS); }
  61 branch-misses                                   { return sym(PERF_TYPE_HARDWARE, PERF_COUNT_HW_BRANCH_MISSES); }
  62 bus-cycles                                      { return sym(PERF_TYPE_HARDWARE, PERF_COUNT_HW_BUS_CYCLES); }
  63 cpu-clock                                       { return sym(PERF_TYPE_SOFTWARE, PERF_COUNT_SW_CPU_CLOCK); }
  64 task-clock                                      { return sym(PERF_TYPE_SOFTWARE, PERF_COUNT_SW_TASK_CLOCK); }
  65 page-faults|faults                              { return sym(PERF_TYPE_SOFTWARE, PERF_COUNT_SW_PAGE_FAULTS); }
  66 minor-faults                                    { return sym(PERF_TYPE_SOFTWARE, PERF_COUNT_SW_PAGE_FAULTS_MIN); }
  67 major-faults                                    { return sym(PERF_TYPE_SOFTWARE, PERF_COUNT_SW_PAGE_FAULTS_MAJ); }
  68 context-switches|cs                             { return sym(PERF_TYPE_SOFTWARE, PERF_COUNT_SW_CONTEXT_SWITCHES); }
  69 cpu-migrations|migrations                       { return sym(PERF_TYPE_SOFTWARE, PERF_COUNT_SW_CPU_MIGRATIONS); }
  70 alignment-faults                                { return sym(PERF_TYPE_SOFTWARE, PERF_COUNT_SW_ALIGNMENT_FAULTS); }
  71 emulation-faults                                { return sym(PERF_TYPE_SOFTWARE, PERF_COUNT_SW_EMULATION_FAULTS); }
  72
  73 L1-dcache|l1-d|l1d|L1-data              |
  74 L1-icache|l1-i|l1i|L1-instruction       |
  75 LLC|L2                                  |
  76 dTLB|d-tlb|Data-TLB                     |
  77 iTLB|i-tlb|Instruction-TLB              |
  78 branch|branches|bpu|btb|bpc             |
  79 node                                    { return str(PE_NAME_CACHE_TYPE); }
  80
  81 load|loads|read                         |
  82 store|stores|write                      |
  83 prefetch|prefetches                     |
  84 speculative-read|speculative-load       |
  85 refs|Reference|ops|access               |
  86 misses|miss                             { return str(PE_NAME_CACHE_OP_RESULT); }
  87
  88 mem:                    { return PE_PREFIX_MEM; }
  89 r{num_raw_hex}          { return raw(); }
  90 {num_dec}               { return value(10); }
  91 {num_hex}               { return value(16); }
  92
  93 {modifier_event}        { return str(PE_MODIFIER_EVENT); }
  94 {modifier_bp}           { return str(PE_MODIFIER_BP); }
  95 {name}                  { return str(PE_NAME); }
  96 "/"                     { return '/'; }
  97 -                       { return '-'; }
  98 ,                       { return ','; }
  99 :                       { return ':'; }
 100 =                       { return '='; }
 101
 102 %%
 103
 104 int parse_events_wrap(void)
 105 {
 106         return 1;
 107 }