Loading...
1/* Simple expression parser */
2%{
3#include "util.h"
4#include "util/debug.h"
5#define IN_EXPR_Y 1
6#include "expr.h"
7#include "smt.h"
8#include <string.h>
9
10#define MAXIDLEN 256
11%}
12
13%pure-parser
14%parse-param { double *final_val }
15%parse-param { struct parse_ctx *ctx }
16%parse-param { const char **pp }
17%lex-param { const char **pp }
18
19%union {
20 double num;
21 char id[MAXIDLEN+1];
22}
23
24%token <num> NUMBER
25%token <id> ID
26%token MIN MAX IF ELSE SMT_ON
27%left MIN MAX IF
28%left '|'
29%left '^'
30%left '&'
31%left '-' '+'
32%left '*' '/' '%'
33%left NEG NOT
34%type <num> expr if_expr
35
36%{
37static int expr__lex(YYSTYPE *res, const char **pp);
38
39static void expr__error(double *final_val __maybe_unused,
40 struct parse_ctx *ctx __maybe_unused,
41 const char **pp __maybe_unused,
42 const char *s)
43{
44 pr_debug("%s\n", s);
45}
46
47static int lookup_id(struct parse_ctx *ctx, char *id, double *val)
48{
49 int i;
50
51 for (i = 0; i < ctx->num_ids; i++) {
52 if (!strcasecmp(ctx->ids[i].name, id)) {
53 *val = ctx->ids[i].val;
54 return 0;
55 }
56 }
57 return -1;
58}
59
60%}
61%%
62
63all_expr: if_expr { *final_val = $1; }
64 ;
65
66if_expr:
67 expr IF expr ELSE expr { $$ = $3 ? $1 : $5; }
68 | expr
69 ;
70
71expr: NUMBER
72 | ID { if (lookup_id(ctx, $1, &$$) < 0) {
73 pr_debug("%s not found\n", $1);
74 YYABORT;
75 }
76 }
77 | expr '|' expr { $$ = (long)$1 | (long)$3; }
78 | expr '&' expr { $$ = (long)$1 & (long)$3; }
79 | expr '^' expr { $$ = (long)$1 ^ (long)$3; }
80 | expr '+' expr { $$ = $1 + $3; }
81 | expr '-' expr { $$ = $1 - $3; }
82 | expr '*' expr { $$ = $1 * $3; }
83 | expr '/' expr { if ($3 == 0) YYABORT; $$ = $1 / $3; }
84 | expr '%' expr { if ((long)$3 == 0) YYABORT; $$ = (long)$1 % (long)$3; }
85 | '-' expr %prec NEG { $$ = -$2; }
86 | '(' if_expr ')' { $$ = $2; }
87 | MIN '(' expr ',' expr ')' { $$ = $3 < $5 ? $3 : $5; }
88 | MAX '(' expr ',' expr ')' { $$ = $3 > $5 ? $3 : $5; }
89 | SMT_ON { $$ = smt_on() > 0; }
90 ;
91
92%%
93
94static int expr__symbol(YYSTYPE *res, const char *p, const char **pp)
95{
96 char *dst = res->id;
97 const char *s = p;
98
99 if (*p == '#')
100 *dst++ = *p++;
101
102 while (isalnum(*p) || *p == '_' || *p == '.' || *p == ':' || *p == '@' || *p == '\\') {
103 if (p - s >= MAXIDLEN)
104 return -1;
105 /*
106 * Allow @ instead of / to be able to specify pmu/event/ without
107 * conflicts with normal division.
108 */
109 if (*p == '@')
110 *dst++ = '/';
111 else if (*p == '\\')
112 *dst++ = *++p;
113 else
114 *dst++ = *p;
115 p++;
116 }
117 *dst = 0;
118 *pp = p;
119 dst = res->id;
120 switch (dst[0]) {
121 case 'm':
122 if (!strcmp(dst, "min"))
123 return MIN;
124 if (!strcmp(dst, "max"))
125 return MAX;
126 break;
127 case 'i':
128 if (!strcmp(dst, "if"))
129 return IF;
130 break;
131 case 'e':
132 if (!strcmp(dst, "else"))
133 return ELSE;
134 break;
135 case '#':
136 if (!strcasecmp(dst, "#smt_on"))
137 return SMT_ON;
138 break;
139 }
140 return ID;
141}
142
143static int expr__lex(YYSTYPE *res, const char **pp)
144{
145 int tok;
146 const char *s;
147 const char *p = *pp;
148
149 while (isspace(*p))
150 p++;
151 s = p;
152 switch (*p++) {
153 case '#':
154 case 'a' ... 'z':
155 case 'A' ... 'Z':
156 return expr__symbol(res, p - 1, pp);
157 case '0' ... '9': case '.':
158 res->num = strtod(s, (char **)&p);
159 tok = NUMBER;
160 break;
161 default:
162 tok = *s;
163 break;
164 }
165 *pp = p;
166 return tok;
167}
168
169/* Caller must make sure id is allocated */
170void expr__add_id(struct parse_ctx *ctx, const char *name, double val)
171{
172 int idx;
173 assert(ctx->num_ids < MAX_PARSE_ID);
174 idx = ctx->num_ids++;
175 ctx->ids[idx].name = name;
176 ctx->ids[idx].val = val;
177}
178
179void expr__ctx_init(struct parse_ctx *ctx)
180{
181 ctx->num_ids = 0;
182}
183
184static bool already_seen(const char *val, const char *one, const char **other,
185 int num_other)
186{
187 int i;
188
189 if (one && !strcasecmp(one, val))
190 return true;
191 for (i = 0; i < num_other; i++)
192 if (!strcasecmp(other[i], val))
193 return true;
194 return false;
195}
196
197int expr__find_other(const char *p, const char *one, const char ***other,
198 int *num_otherp)
199{
200 const char *orig = p;
201 int err = -1;
202 int num_other;
203
204 *other = malloc((EXPR_MAX_OTHER + 1) * sizeof(char *));
205 if (!*other)
206 return -1;
207
208 num_other = 0;
209 for (;;) {
210 YYSTYPE val;
211 int tok = expr__lex(&val, &p);
212 if (tok == 0) {
213 err = 0;
214 break;
215 }
216 if (tok == ID && !already_seen(val.id, one, *other, num_other)) {
217 if (num_other >= EXPR_MAX_OTHER - 1) {
218 pr_debug("Too many extra events in %s\n", orig);
219 break;
220 }
221 (*other)[num_other] = strdup(val.id);
222 if (!(*other)[num_other])
223 return -1;
224 num_other++;
225 }
226 }
227 (*other)[num_other] = NULL;
228 *num_otherp = num_other;
229 if (err) {
230 *num_otherp = 0;
231 free(*other);
232 *other = NULL;
233 }
234 return err;
235}
1/* Simple expression parser */
2%{
3#ifndef NDEBUG
4#define YYDEBUG 1
5#endif
6#include <assert.h>
7#include <math.h>
8#include <stdlib.h>
9#include "util/debug.h"
10#define IN_EXPR_Y 1
11#include "expr.h"
12#include "expr-bison.h"
13int expr_lex(YYSTYPE * yylval_param , void *yyscanner);
14%}
15
16%define api.pure full
17
18%parse-param { double *final_val }
19%parse-param { struct expr_parse_ctx *ctx }
20%parse-param { bool compute_ids }
21%parse-param {void *scanner}
22%lex-param {void* scanner}
23
24%union {
25 double num;
26 char *str;
27 struct ids {
28 /*
29 * When creating ids, holds the working set of event ids. NULL
30 * implies the set is empty.
31 */
32 struct hashmap *ids;
33 /*
34 * The metric value. When not creating ids this is the value
35 * read from a counter, a constant or some computed value. When
36 * creating ids the value is either a constant or BOTTOM. NAN is
37 * used as the special BOTTOM value, representing a "set of all
38 * values" case.
39 */
40 double val;
41 } ids;
42}
43
44%token ID NUMBER MIN MAX IF ELSE LITERAL D_RATIO SOURCE_COUNT HAS_EVENT STRCMP_CPUID_STR EXPR_ERROR
45%left MIN MAX IF
46%left '|'
47%left '^'
48%left '&'
49%left '<' '>'
50%left '-' '+'
51%left '*' '/' '%'
52%left NEG NOT
53%type <num> NUMBER LITERAL
54%type <str> ID
55%destructor { free ($$); } <str>
56%type <ids> expr if_expr
57%destructor { ids__free($$.ids); } <ids>
58
59%{
60static void expr_error(double *final_val __maybe_unused,
61 struct expr_parse_ctx *ctx __maybe_unused,
62 bool compute_ids __maybe_unused,
63 void *scanner __maybe_unused,
64 const char *s)
65{
66 pr_debug("%s\n", s);
67}
68
69/*
70 * During compute ids, the special "bottom" value uses NAN to represent the set
71 * of all values. NAN is selected as it isn't a useful constant value.
72 */
73#define BOTTOM NAN
74
75/* During computing ids, does val represent a constant (non-BOTTOM) value? */
76static bool is_const(double val)
77{
78 return isfinite(val);
79}
80
81static struct ids union_expr(struct ids ids1, struct ids ids2)
82{
83 struct ids result = {
84 .val = BOTTOM,
85 .ids = ids__union(ids1.ids, ids2.ids),
86 };
87 return result;
88}
89
90static struct ids handle_id(struct expr_parse_ctx *ctx, char *id,
91 bool compute_ids, bool source_count)
92{
93 struct ids result;
94
95 if (!compute_ids) {
96 /*
97 * Compute the event's value from ID. If the ID isn't known then
98 * it isn't used to compute the formula so set to NAN.
99 */
100 struct expr_id_data *data;
101
102 result.val = NAN;
103 if (expr__resolve_id(ctx, id, &data) == 0) {
104 result.val = source_count
105 ? expr_id_data__source_count(data)
106 : expr_id_data__value(data);
107 }
108 result.ids = NULL;
109 free(id);
110 } else {
111 /*
112 * Set the value to BOTTOM to show that any value is possible
113 * when the event is computed. Create a set of just the ID.
114 */
115 result.val = BOTTOM;
116 result.ids = ids__new();
117 if (!result.ids || ids__insert(result.ids, id)) {
118 pr_err("Error creating IDs for '%s'", id);
119 free(id);
120 }
121 }
122 return result;
123}
124
125/*
126 * If we're not computing ids or $1 and $3 are constants, compute the new
127 * constant value using OP. Its invariant that there are no ids. If computing
128 * ids for non-constants union the set of IDs that must be computed.
129 */
130#define BINARY_OP(RESULT, OP, LHS, RHS) \
131 if (!compute_ids || (is_const(LHS.val) && is_const(RHS.val))) { \
132 assert(LHS.ids == NULL); \
133 assert(RHS.ids == NULL); \
134 if (isnan(LHS.val) || isnan(RHS.val)) { \
135 RESULT.val = NAN; \
136 } else { \
137 RESULT.val = LHS.val OP RHS.val; \
138 } \
139 RESULT.ids = NULL; \
140 } else { \
141 RESULT = union_expr(LHS, RHS); \
142 }
143
144%}
145%%
146
147start: if_expr
148{
149 if (compute_ids)
150 ctx->ids = ids__union($1.ids, ctx->ids);
151
152 if (final_val)
153 *final_val = $1.val;
154}
155;
156
157if_expr: expr IF expr ELSE if_expr
158{
159 if (fpclassify($3.val) == FP_ZERO) {
160 /*
161 * The IF expression evaluated to 0 so treat as false, take the
162 * ELSE and discard everything else.
163 */
164 $$.val = $5.val;
165 $$.ids = $5.ids;
166 ids__free($1.ids);
167 ids__free($3.ids);
168 } else if (!compute_ids || is_const($3.val)) {
169 /*
170 * If ids aren't computed then treat the expression as true. If
171 * ids are being computed and the IF expr is a non-zero
172 * constant, then also evaluate the true case.
173 */
174 $$.val = $1.val;
175 $$.ids = $1.ids;
176 ids__free($3.ids);
177 ids__free($5.ids);
178 } else if ($1.val == $5.val) {
179 /*
180 * LHS == RHS, so both are an identical constant. No need to
181 * evaluate any events.
182 */
183 $$.val = $1.val;
184 $$.ids = NULL;
185 ids__free($1.ids);
186 ids__free($3.ids);
187 ids__free($5.ids);
188 } else {
189 /*
190 * Value is either the LHS or RHS and we need the IF expression
191 * to compute it.
192 */
193 $$ = union_expr($1, union_expr($3, $5));
194 }
195}
196| expr
197;
198
199expr: NUMBER
200{
201 $$.val = $1;
202 $$.ids = NULL;
203}
204| ID { $$ = handle_id(ctx, $1, compute_ids, /*source_count=*/false); }
205| SOURCE_COUNT '(' ID ')' { $$ = handle_id(ctx, $3, compute_ids, /*source_count=*/true); }
206| HAS_EVENT '(' ID ')'
207{
208 $$.val = expr__has_event(ctx, compute_ids, $3);
209 $$.ids = NULL;
210 free($3);
211}
212| STRCMP_CPUID_STR '(' ID ')'
213{
214 $$.val = expr__strcmp_cpuid_str(ctx, compute_ids, $3);
215 $$.ids = NULL;
216 free($3);
217}
218| expr '|' expr
219{
220 if (is_const($1.val) && is_const($3.val)) {
221 assert($1.ids == NULL);
222 assert($3.ids == NULL);
223 $$.ids = NULL;
224 $$.val = (fpclassify($1.val) == FP_ZERO && fpclassify($3.val) == FP_ZERO) ? 0 : 1;
225 } else if (is_const($1.val)) {
226 assert($1.ids == NULL);
227 if (fpclassify($1.val) == FP_ZERO) {
228 $$ = $3;
229 } else {
230 $$.val = 1;
231 $$.ids = NULL;
232 ids__free($3.ids);
233 }
234 } else if (is_const($3.val)) {
235 assert($3.ids == NULL);
236 if (fpclassify($3.val) == FP_ZERO) {
237 $$ = $1;
238 } else {
239 $$.val = 1;
240 $$.ids = NULL;
241 ids__free($1.ids);
242 }
243 } else {
244 $$ = union_expr($1, $3);
245 }
246}
247| expr '&' expr
248{
249 if (is_const($1.val) && is_const($3.val)) {
250 assert($1.ids == NULL);
251 assert($3.ids == NULL);
252 $$.val = (fpclassify($1.val) != FP_ZERO && fpclassify($3.val) != FP_ZERO) ? 1 : 0;
253 $$.ids = NULL;
254 } else if (is_const($1.val)) {
255 assert($1.ids == NULL);
256 if (fpclassify($1.val) != FP_ZERO) {
257 $$ = $3;
258 } else {
259 $$.val = 0;
260 $$.ids = NULL;
261 ids__free($3.ids);
262 }
263 } else if (is_const($3.val)) {
264 assert($3.ids == NULL);
265 if (fpclassify($3.val) != FP_ZERO) {
266 $$ = $1;
267 } else {
268 $$.val = 0;
269 $$.ids = NULL;
270 ids__free($1.ids);
271 }
272 } else {
273 $$ = union_expr($1, $3);
274 }
275}
276| expr '^' expr
277{
278 if (is_const($1.val) && is_const($3.val)) {
279 assert($1.ids == NULL);
280 assert($3.ids == NULL);
281 $$.val = (fpclassify($1.val) == FP_ZERO) != (fpclassify($3.val) == FP_ZERO) ? 1 : 0;
282 $$.ids = NULL;
283 } else {
284 $$ = union_expr($1, $3);
285 }
286}
287| expr '<' expr { BINARY_OP($$, <, $1, $3); }
288| expr '>' expr { BINARY_OP($$, >, $1, $3); }
289| expr '+' expr { BINARY_OP($$, +, $1, $3); }
290| expr '-' expr { BINARY_OP($$, -, $1, $3); }
291| expr '*' expr { BINARY_OP($$, *, $1, $3); }
292| expr '/' expr
293{
294 if (fpclassify($3.val) == FP_ZERO) {
295 pr_debug("division by zero\n");
296 assert($3.ids == NULL);
297 if (compute_ids)
298 ids__free($1.ids);
299 $$.val = NAN;
300 $$.ids = NULL;
301 } else if (!compute_ids || (is_const($1.val) && is_const($3.val))) {
302 assert($1.ids == NULL);
303 assert($3.ids == NULL);
304 $$.val = $1.val / $3.val;
305 $$.ids = NULL;
306 } else {
307 /* LHS and/or RHS need computing from event IDs so union. */
308 $$ = union_expr($1, $3);
309 }
310}
311| expr '%' expr
312{
313 if (fpclassify($3.val) == FP_ZERO) {
314 pr_debug("division by zero\n");
315 YYABORT;
316 } else if (!compute_ids || (is_const($1.val) && is_const($3.val))) {
317 assert($1.ids == NULL);
318 assert($3.ids == NULL);
319 $$.val = (long)$1.val % (long)$3.val;
320 $$.ids = NULL;
321 } else {
322 /* LHS and/or RHS need computing from event IDs so union. */
323 $$ = union_expr($1, $3);
324 }
325}
326| D_RATIO '(' expr ',' expr ')'
327{
328 if (fpclassify($5.val) == FP_ZERO) {
329 /*
330 * Division by constant zero always yields zero and no events
331 * are necessary.
332 */
333 assert($5.ids == NULL);
334 $$.val = 0.0;
335 $$.ids = NULL;
336 ids__free($3.ids);
337 } else if (!compute_ids || (is_const($3.val) && is_const($5.val))) {
338 assert($3.ids == NULL);
339 assert($5.ids == NULL);
340 $$.val = $3.val / $5.val;
341 $$.ids = NULL;
342 } else {
343 /* LHS and/or RHS need computing from event IDs so union. */
344 $$ = union_expr($3, $5);
345 }
346}
347| '-' expr %prec NEG
348{
349 $$.val = -$2.val;
350 $$.ids = $2.ids;
351}
352| '(' if_expr ')'
353{
354 $$ = $2;
355}
356| MIN '(' expr ',' expr ')'
357{
358 if (!compute_ids) {
359 $$.val = $3.val < $5.val ? $3.val : $5.val;
360 $$.ids = NULL;
361 } else {
362 $$ = union_expr($3, $5);
363 }
364}
365| MAX '(' expr ',' expr ')'
366{
367 if (!compute_ids) {
368 $$.val = $3.val > $5.val ? $3.val : $5.val;
369 $$.ids = NULL;
370 } else {
371 $$ = union_expr($3, $5);
372 }
373}
374| LITERAL
375{
376 $$.val = $1;
377 $$.ids = NULL;
378}
379;
380
381%%