projects / lttng-tools.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
port: FreeBSD has no ENODATA, alias it to ENOATTR
[lttng-tools.git] / src / common / filter / filter-visitor-generate-bytecode.c
CommitLineData
953192ba
MD		 1/*
2 * filter-visitor-generate-bytecode.c
3 *
4 * LTTng filter bytecode generation
5 *
ab5be9fa 6 * Copyright 2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
953192ba 7 *
ab5be9fa 8 * SPDX-License-Identifier: LGPL-2.1-only
953192ba 9 *
953192ba
MD		 10 */
11
12#include <stdlib.h>
13#include <string.h>
46820c8b 14#include <common/align.h>
edf4b93e 15#include <common/compat/errno.h>
afc5df03 16#include <common/compat/string.h>
46820c8b 17
953192ba
MD		 18#include "filter-bytecode.h"
19#include "filter-ir.h"
20#include "filter-ast.h"
21
a187da1a
DG		 22#include <common/macros.h>
23
953192ba
MD		 24#ifndef max_t
25#define max_t(type, a, b) ((type) ((a) > (b) ? (a) : (b)))
26#endif
27
953192ba
MD		 28#define INIT_ALLOC_SIZE 4
29
30static
31int recursive_visit_gen_bytecode(struct filter_parser_ctx *ctx,
32 struct ir_op *node);
33
01a204f0
CB		 34static inline int get_count_order(unsigned int count)
35{
36 int order;
37
afc5df03 38 order = lttng_fls(count) - 1;
01a204f0
CB		 39 if (count & (count - 1))
40 order++;
41 return order;
42}
43
953192ba 44static
53a80697 45int bytecode_init(struct lttng_filter_bytecode_alloc **fb)
953192ba 46{
1029587a
MD		 47 uint32_t alloc_len;
48
49 alloc_len = sizeof(struct lttng_filter_bytecode_alloc) + INIT_ALLOC_SIZE;
50 *fb = calloc(alloc_len, 1);
953192ba
MD		 51 if (!*fb) {
52 return -ENOMEM;
53 } else {
1029587a 54 (*fb)->alloc_len = alloc_len;
953192ba
MD		 55 return 0;
56 }
57}
58
59static
53a80697 60int32_t bytecode_reserve(struct lttng_filter_bytecode_alloc **fb, uint32_t align, uint32_t len)
953192ba
MD		 61{
62 int32_t ret;
63 uint32_t padding = offset_align((*fb)->b.len, align);
ec96a8f6 64 uint32_t new_len = (*fb)->b.len + padding + len;
1029587a 65 uint32_t new_alloc_len = sizeof(struct lttng_filter_bytecode_alloc) + new_len;
ec96a8f6 66 uint32_t old_alloc_len = (*fb)->alloc_len;
953192ba 67
ec96a8f6 68 if (new_len > LTTNG_FILTER_MAX_LEN)
5ddb0a08
CB		 69 return -EINVAL;
70
ec96a8f6 71 if (new_alloc_len > old_alloc_len) {
d0b96690
DG		 72 struct lttng_filter_bytecode_alloc *newptr;
73
ec96a8f6
MD		 74 new_alloc_len =
75 max_t(uint32_t, 1U << get_count_order(new_alloc_len), old_alloc_len << 1);
d0b96690
DG		 76 newptr = realloc(*fb, new_alloc_len);
77 if (!newptr)
953192ba 78 return -ENOMEM;
d0b96690 79 *fb = newptr;
1029587a 80 /* We zero directly the memory from start of allocation. */
ec96a8f6
MD		 81 memset(&((char *) *fb)[old_alloc_len], 0, new_alloc_len - old_alloc_len);
82 (*fb)->alloc_len = new_alloc_len;
953192ba
MD		 83 }
84 (*fb)->b.len += padding;
85 ret = (*fb)->b.len;
86 (*fb)->b.len += len;
87 return ret;
88}
89
90static
53a80697 91int bytecode_push(struct lttng_filter_bytecode_alloc **fb, const void *data,
953192ba
MD		 92 uint32_t align, uint32_t len)
93{
94 int32_t offset;
95
96 offset = bytecode_reserve(fb, align, len);
97 if (offset < 0)
98 return offset;
99 memcpy(&(*fb)->b.data[offset], data, len);
100 return 0;
101}
102
103static
53a80697 104int bytecode_push_logical(struct lttng_filter_bytecode_alloc **fb,
953192ba
MD		 105 struct logical_op *data,
106 uint32_t align, uint32_t len,
107 uint16_t *skip_offset)
108{
109 int32_t offset;
110
111 offset = bytecode_reserve(fb, align, len);
112 if (offset < 0)
113 return offset;
114 memcpy(&(*fb)->b.data[offset], data, len);
115 *skip_offset =
116 (void *) &((struct logical_op *) &(*fb)->b.data[offset])->skip_offset
117 - (void *) &(*fb)->b.data[0];
118 return 0;
119}
120
121static
53a80697 122int bytecode_patch(struct lttng_filter_bytecode_alloc **fb,
953192ba
MD		 123 const void *data,
124 uint16_t offset,
125 uint32_t len)
126{
127 if (offset >= (*fb)->b.len) {
128 return -EINVAL;
129 }
130 memcpy(&(*fb)->b.data[offset], data, len);
131 return 0;
132}
133
134static
135int visit_node_root(struct filter_parser_ctx *ctx, struct ir_op *node)
136{
137 int ret;
138 struct return_op insn;
139
140 /* Visit child */
141 ret = recursive_visit_gen_bytecode(ctx, node->u.root.child);
142 if (ret)
143 return ret;
144
145 /* Generate end of bytecode instruction */
146 insn.op = FILTER_OP_RETURN;
147 return bytecode_push(&ctx->bytecode, &insn, 1, sizeof(insn));
148}
149
016dbbb4
MD		 150static
151int append_str(char **s, const char *append)
152{
153 char *old = *s;
154 char *new;
155 size_t oldlen = (old == NULL) ? 0 : strlen(old);
156 size_t appendlen = strlen(append);
157
158 new = calloc(oldlen + appendlen + 1, 1);
159 if (!new) {
160 return -ENOMEM;
161 }
162 if (oldlen) {
163 strcpy(new, old);
164 }
165 strcat(new, append);
166 *s = new;
167 free(old);
168 return 0;
169}
170
171/*
172 * 1: match
173 * 0: no match
174 * < 0: error
175 */
176static
177int load_expression_legacy_match(const struct ir_load_expression *exp,
178 enum filter_op *op_type,
179 char **symbol)
180{
181 const struct ir_load_expression_op *op;
182 bool need_dot = false;
183
184 op = exp->child;
185 switch (op->type) {
186 case IR_LOAD_EXPRESSION_GET_CONTEXT_ROOT:
187 *op_type = FILTER_OP_GET_CONTEXT_REF;
188 if (append_str(symbol, "$ctx.")) {
189 return -ENOMEM;
190 }
191 need_dot = false;
192 break;
193 case IR_LOAD_EXPRESSION_GET_APP_CONTEXT_ROOT:
194 *op_type = FILTER_OP_GET_CONTEXT_REF;
195 if (append_str(symbol, "$app.")) {
196 return -ENOMEM;
197 }
198 need_dot = false;
199 break;
200 case IR_LOAD_EXPRESSION_GET_PAYLOAD_ROOT:
201 *op_type = FILTER_OP_LOAD_FIELD_REF;
202 need_dot = false;
203 break;
204
205 case IR_LOAD_EXPRESSION_GET_SYMBOL:
206 case IR_LOAD_EXPRESSION_GET_INDEX:
207 case IR_LOAD_EXPRESSION_LOAD_FIELD:
208 default:
209 return 0; /* no match */
210 }
211
212 for (;;) {
213 op = op->next;
214 if (!op) {
215 return 0; /* no match */
216 }
217 switch (op->type) {
218 case IR_LOAD_EXPRESSION_LOAD_FIELD:
219 goto end;
220 case IR_LOAD_EXPRESSION_GET_SYMBOL:
221 if (need_dot && append_str(symbol, ".")) {
222 return -ENOMEM;
223 }
224 if (append_str(symbol, op->u.symbol)) {
225 return -ENOMEM;
226 }
227 break;
228 default:
229 return 0; /* no match */
230 }
231 need_dot = true;
232 }
233end:
234 return 1; /* Legacy match */
235}
236
237/*
238 * 1: legacy match
239 * 0: no legacy match
240 * < 0: error
241 */
242static
243int visit_node_load_expression_legacy(struct filter_parser_ctx *ctx,
244 const struct ir_load_expression *exp,
245 const struct ir_load_expression_op *op)
246{
247 struct load_op *insn = NULL;
248 uint32_t insn_len = sizeof(struct load_op)
249 + sizeof(struct field_ref);
250 struct field_ref ref_offset;
251 uint32_t reloc_offset_u32;
252 uint16_t reloc_offset;
253 enum filter_op op_type;
254 char *symbol = NULL;
255 int ret;
256
257 ret = load_expression_legacy_match(exp, &op_type, &symbol);
258 if (ret <= 0) {
259 goto end;
260 }
261 insn = calloc(insn_len, 1);
262 if (!insn) {
263 ret = -ENOMEM;
264 goto end;
265 }
266 insn->op = op_type;
267 ref_offset.offset = (uint16_t) -1U;
268 memcpy(insn->data, &ref_offset, sizeof(ref_offset));
269 /* reloc_offset points to struct load_op */
270 reloc_offset_u32 = bytecode_get_len(&ctx->bytecode->b);
271 if (reloc_offset_u32 > LTTNG_FILTER_MAX_LEN - 1) {
272 ret = -EINVAL;
273 goto end;
274 }
275 reloc_offset = (uint16_t) reloc_offset_u32;
276 ret = bytecode_push(&ctx->bytecode, insn, 1, insn_len);
277 if (ret) {
278 goto end;
279 }
280 /* append reloc */
281 ret = bytecode_push(&ctx->bytecode_reloc, &reloc_offset,
282 1, sizeof(reloc_offset));
283 if (ret) {
284 goto end;
285 }
286 ret = bytecode_push(&ctx->bytecode_reloc, symbol,
287 1, strlen(symbol) + 1);
73e38068
JG		 288 if (ret) {
289 goto end;
290 }
016dbbb4
MD		 291 ret = 1; /* legacy */
292end:
293 free(insn);
294 free(symbol);
295 return ret;
296}
297
bff988fa
MD		 298static
299int visit_node_load_expression(struct filter_parser_ctx *ctx,
300 const struct ir_op *node)
301{
302 struct ir_load_expression *exp;
303 struct ir_load_expression_op *op;
016dbbb4 304 int ret;
bff988fa
MD		 305
306 exp = node->u.load.u.expression;
307 if (!exp) {
308 return -EINVAL;
309 }
310 op = exp->child;
311 if (!op) {
312 return -EINVAL;
313 }
016dbbb4 314
b4bc01f7
MD		 315 /*
316 * TODO: if we remove legacy load for application contexts, we
317 * need to update session bytecode parser as well.
318 */
016dbbb4
MD		 319 ret = visit_node_load_expression_legacy(ctx, exp, op);
320 if (ret < 0) {
321 return ret;
322 }
323 if (ret > 0) {
324 return 0; /* legacy */
325 }
326
bff988fa
MD		 327 for (; op != NULL; op = op->next) {
328 switch (op->type) {
329 case IR_LOAD_EXPRESSION_GET_CONTEXT_ROOT:
330 {
331 struct load_op *insn;
332 uint32_t insn_len = sizeof(struct load_op);
333 int ret;
334
335 insn = calloc(insn_len, 1);
336 if (!insn)
337 return -ENOMEM;
338 insn->op = FILTER_OP_GET_CONTEXT_ROOT;
339 ret = bytecode_push(&ctx->bytecode, insn, 1, insn_len);
340 free(insn);
341 if (ret) {
342 return ret;
343 }
344 break;
345 }
346 case IR_LOAD_EXPRESSION_GET_APP_CONTEXT_ROOT:
347 {
348 struct load_op *insn;
349 uint32_t insn_len = sizeof(struct load_op);
350 int ret;
351
352 insn = calloc(insn_len, 1);
353 if (!insn)
354 return -ENOMEM;
355 insn->op = FILTER_OP_GET_APP_CONTEXT_ROOT;
356 ret = bytecode_push(&ctx->bytecode, insn, 1, insn_len);
357 free(insn);
358 if (ret) {
359 return ret;
360 }
361 break;
362 }
363 case IR_LOAD_EXPRESSION_GET_PAYLOAD_ROOT:
364 {
365 struct load_op *insn;
366 uint32_t insn_len = sizeof(struct load_op);
367 int ret;
368
369 insn = calloc(insn_len, 1);
370 if (!insn)
371 return -ENOMEM;
372 insn->op = FILTER_OP_GET_PAYLOAD_ROOT;
373 ret = bytecode_push(&ctx->bytecode, insn, 1, insn_len);
374 free(insn);
375 if (ret) {
376 return ret;
377 }
378 break;
379 }
380 case IR_LOAD_EXPRESSION_GET_SYMBOL:
381 {
382 struct load_op *insn;
383 uint32_t insn_len = sizeof(struct load_op)
384 + sizeof(struct get_symbol);
385 struct get_symbol symbol_offset;
386 uint32_t reloc_offset_u32;
387 uint16_t reloc_offset;
388 uint32_t bytecode_reloc_offset_u32;
389 int ret;
390
391 insn = calloc(insn_len, 1);
392 if (!insn)
393 return -ENOMEM;
394 insn->op = FILTER_OP_GET_SYMBOL;
395 bytecode_reloc_offset_u32 =
396 bytecode_get_len(&ctx->bytecode_reloc->b)
397 + sizeof(reloc_offset);
398 symbol_offset.offset =
399 (uint16_t) bytecode_reloc_offset_u32;
400 memcpy(insn->data, &symbol_offset,
401 sizeof(symbol_offset));
402 /* reloc_offset points to struct load_op */
403 reloc_offset_u32 = bytecode_get_len(&ctx->bytecode->b);
404 if (reloc_offset_u32 > LTTNG_FILTER_MAX_LEN - 1) {
405 free(insn);
406 return -EINVAL;
407 }
408 reloc_offset = (uint16_t) reloc_offset_u32;
409 ret = bytecode_push(&ctx->bytecode, insn, 1, insn_len);
410 if (ret) {
411 free(insn);
412 return ret;
413 }
414 /* append reloc */
415 ret = bytecode_push(&ctx->bytecode_reloc, &reloc_offset,
416 1, sizeof(reloc_offset));
417 if (ret) {
418 free(insn);
419 return ret;
420 }
421 ret = bytecode_push(&ctx->bytecode_reloc,
422 op->u.symbol,
423 1, strlen(op->u.symbol) + 1);
424 free(insn);
425 if (ret) {
426 return ret;
427 }
428 break;
429 }
430 case IR_LOAD_EXPRESSION_GET_INDEX:
431 {
432 struct load_op *insn;
433 uint32_t insn_len = sizeof(struct load_op)
434 + sizeof(struct get_index_u64);
435 struct get_index_u64 index;
436 int ret;
437
438 insn = calloc(insn_len, 1);
439 if (!insn)
440 return -ENOMEM;
441 insn->op = FILTER_OP_GET_INDEX_U64;
442 index.index = op->u.index;
443 memcpy(insn->data, &index, sizeof(index));
444 ret = bytecode_push(&ctx->bytecode, insn, 1, insn_len);
445 free(insn);
446 if (ret) {
447 return ret;
448 }
449 break;
450 }
451 case IR_LOAD_EXPRESSION_LOAD_FIELD:
452 {
453 struct load_op *insn;
454 uint32_t insn_len = sizeof(struct load_op);
455 int ret;
456
457 insn = calloc(insn_len, 1);
458 if (!insn)
459 return -ENOMEM;
460 insn->op = FILTER_OP_LOAD_FIELD;
461 ret = bytecode_push(&ctx->bytecode, insn, 1, insn_len);
462 free(insn);
463 if (ret) {
464 return ret;
465 }
466 break;
467 }
468 }
469 }
470 return 0;
471}
472
953192ba
MD		 473static
474int visit_node_load(struct filter_parser_ctx *ctx, struct ir_op *node)
475{
476 int ret;
477
478 switch (node->data_type) {
479 case IR_DATA_UNKNOWN:
480 default:
481 fprintf(stderr, "[error] Unknown data type in %s\n",
482 __func__);
483 return -EINVAL;
484
485 case IR_DATA_STRING:
486 {
487 struct load_op *insn;
488 uint32_t insn_len = sizeof(struct load_op)
9f449915 489 + strlen(node->u.load.u.string.value) + 1;
953192ba
MD		 490
491 insn = calloc(insn_len, 1);
492 if (!insn)
493 return -ENOMEM;
9f449915
PP		 494
495 switch (node->u.load.u.string.type) {
496 case IR_LOAD_STRING_TYPE_GLOB_STAR:
497 /*
498 * We explicitly tell the interpreter here that
499 * this load is a full star globbing pattern so
500 * that the appropriate matching function can be
501 * called. Also, see comment below.
502 */
503 insn->op = FILTER_OP_LOAD_STAR_GLOB_STRING;
504 break;
505 default:
506 /*
507 * This is the "legacy" string, which includes
508 * star globbing patterns with a star only at
509 * the end. Both "plain" and "star at the end"
510 * literal strings are handled at the same place
511 * by the tracer's filter bytecode interpreter,
512 * whereas full star globbing patterns (stars
513 * can be anywhere in the string) is a special
514 * case.
515 */
516 insn->op = FILTER_OP_LOAD_STRING;
517 break;
518 }
519
520 strcpy(insn->data, node->u.load.u.string.value);
953192ba
MD		 521 ret = bytecode_push(&ctx->bytecode, insn, 1, insn_len);
522 free(insn);
523 return ret;
524 }
525 case IR_DATA_NUMERIC:
526 {
527 struct load_op *insn;
528 uint32_t insn_len = sizeof(struct load_op)
529 + sizeof(struct literal_numeric);
530
531 insn = calloc(insn_len, 1);
532 if (!insn)
533 return -ENOMEM;
534 insn->op = FILTER_OP_LOAD_S64;
58d494e4 535 memcpy(insn->data, &node->u.load.u.num, sizeof(int64_t));
953192ba
MD		 536 ret = bytecode_push(&ctx->bytecode, insn, 1, insn_len);
537 free(insn);
538 return ret;
539 }
e90d8561
MD		 540 case IR_DATA_FLOAT:
541 {
542 struct load_op *insn;
543 uint32_t insn_len = sizeof(struct load_op)
544 + sizeof(struct literal_double);
545
546 insn = calloc(insn_len, 1);
547 if (!insn)
548 return -ENOMEM;
549 insn->op = FILTER_OP_LOAD_DOUBLE;
58d494e4 550 memcpy(insn->data, &node->u.load.u.flt, sizeof(double));
e90d8561
MD		 551 ret = bytecode_push(&ctx->bytecode, insn, 1, insn_len);
552 free(insn);
553 return ret;
554 }
bff988fa
MD		 555 case IR_DATA_EXPRESSION:
556 return visit_node_load_expression(ctx, node);
953192ba
MD		 557 }
558}
559
560static
561int visit_node_unary(struct filter_parser_ctx *ctx, struct ir_op *node)
562{
563 int ret;
564 struct unary_op insn;
565
566 /* Visit child */
567 ret = recursive_visit_gen_bytecode(ctx, node->u.unary.child);
568 if (ret)
569 return ret;
570
571 /* Generate end of bytecode instruction */
572 switch (node->u.unary.type) {
573 case AST_UNARY_UNKNOWN:
574 default:
575 fprintf(stderr, "[error] Unknown unary node type in %s\n",
576 __func__);
577 return -EINVAL;
578 case AST_UNARY_PLUS:
579 /* Nothing to do. */
580 return 0;
581 case AST_UNARY_MINUS:
582 insn.op = FILTER_OP_UNARY_MINUS;
953192ba
MD		 583 return bytecode_push(&ctx->bytecode, &insn, 1, sizeof(insn));
584 case AST_UNARY_NOT:
585 insn.op = FILTER_OP_UNARY_NOT;
953192ba 586 return bytecode_push(&ctx->bytecode, &insn, 1, sizeof(insn));
116d3c01
MD		 587 case AST_UNARY_BIT_NOT:
588 insn.op = FILTER_OP_UNARY_BIT_NOT;
589 return bytecode_push(&ctx->bytecode, &insn, 1, sizeof(insn));
953192ba
MD		 590 }
591}
592
593/*
594 * Binary comparator nesting is disallowed. This allows fitting into
595 * only 2 registers.
596 */
597static
598int visit_node_binary(struct filter_parser_ctx *ctx, struct ir_op *node)
599{
600 int ret;
601 struct binary_op insn;
602
603 /* Visit child */
604 ret = recursive_visit_gen_bytecode(ctx, node->u.binary.left);
605 if (ret)
606 return ret;
607 ret = recursive_visit_gen_bytecode(ctx, node->u.binary.right);
608 if (ret)
609 return ret;
610
611 switch (node->u.binary.type) {
612 case AST_OP_UNKNOWN:
613 default:
614 fprintf(stderr, "[error] Unknown unary node type in %s\n",
615 __func__);
616 return -EINVAL;
617
618 case AST_OP_AND:
619 case AST_OP_OR:
620 fprintf(stderr, "[error] Unexpected logical node type in %s\n",
621 __func__);
622 return -EINVAL;
623
624 case AST_OP_MUL:
625 insn.op = FILTER_OP_MUL;
626 break;
627 case AST_OP_DIV:
628 insn.op = FILTER_OP_DIV;
629 break;
630 case AST_OP_MOD:
631 insn.op = FILTER_OP_MOD;
632 break;
633 case AST_OP_PLUS:
634 insn.op = FILTER_OP_PLUS;
635 break;
636 case AST_OP_MINUS:
637 insn.op = FILTER_OP_MINUS;
638 break;
116d3c01
MD		 639 case AST_OP_BIT_RSHIFT:
640 insn.op = FILTER_OP_BIT_RSHIFT;
953192ba 641 break;
116d3c01
MD		 642 case AST_OP_BIT_LSHIFT:
643 insn.op = FILTER_OP_BIT_LSHIFT;
953192ba 644 break;
bff988fa
MD		 645 case AST_OP_BIT_AND:
646 insn.op = FILTER_OP_BIT_AND;
953192ba 647 break;
bff988fa
MD		 648 case AST_OP_BIT_OR:
649 insn.op = FILTER_OP_BIT_OR;
953192ba 650 break;
bff988fa
MD		 651 case AST_OP_BIT_XOR:
652 insn.op = FILTER_OP_BIT_XOR;
953192ba
MD		 653 break;
654
655 case AST_OP_EQ:
656 insn.op = FILTER_OP_EQ;
657 break;
658 case AST_OP_NE:
659 insn.op = FILTER_OP_NE;
660 break;
661 case AST_OP_GT:
662 insn.op = FILTER_OP_GT;
663 break;
664 case AST_OP_LT:
665 insn.op = FILTER_OP_LT;
666 break;
667 case AST_OP_GE:
668 insn.op = FILTER_OP_GE;
669 break;
670 case AST_OP_LE:
671 insn.op = FILTER_OP_LE;
672 break;
673 }
674 return bytecode_push(&ctx->bytecode, &insn, 1, sizeof(insn));
675}
676
8cf9540a
MD		 677/*
678 * A logical op always return a s64 (1 or 0).
679 */
953192ba
MD		 680static
681int visit_node_logical(struct filter_parser_ctx *ctx, struct ir_op *node)
682{
683 int ret;
684 struct logical_op insn;
685 uint16_t skip_offset_loc;
686 uint16_t target_loc;
687
688 /* Visit left child */
689 ret = recursive_visit_gen_bytecode(ctx, node->u.binary.left);
690 if (ret)
691 return ret;
8cf9540a 692 /* Cast to s64 if float or field ref */
586dc72f 693 if ((node->u.binary.left->data_type == IR_DATA_FIELD_REF
661dfdd1 694 || node->u.binary.left->data_type == IR_DATA_GET_CONTEXT_REF
bff988fa 695 || node->u.binary.left->data_type == IR_DATA_EXPRESSION)
8cf9540a
MD		 696 || node->u.binary.left->data_type == IR_DATA_FLOAT) {
697 struct cast_op cast_insn;
698
586dc72f 699 if (node->u.binary.left->data_type == IR_DATA_FIELD_REF
661dfdd1 700 || node->u.binary.left->data_type == IR_DATA_GET_CONTEXT_REF
bff988fa 701 || node->u.binary.left->data_type == IR_DATA_EXPRESSION) {
29fefef8
MD		 702 cast_insn.op = FILTER_OP_CAST_TO_S64;
703 } else {
704 cast_insn.op = FILTER_OP_CAST_DOUBLE_TO_S64;
705 }
8cf9540a
MD		 706 ret = bytecode_push(&ctx->bytecode, &cast_insn,
707 1, sizeof(cast_insn));
708 if (ret)
709 return ret;
710 }
953192ba
MD		 711 switch (node->u.logical.type) {
712 default:
713 fprintf(stderr, "[error] Unknown node type in %s\n",
714 __func__);
715 return -EINVAL;
716
717 case AST_OP_AND:
718 insn.op = FILTER_OP_AND;
719 break;
720 case AST_OP_OR:
721 insn.op = FILTER_OP_OR;
722 break;
723 }
724 insn.skip_offset = (uint16_t) -1UL; /* Temporary */
725 ret = bytecode_push_logical(&ctx->bytecode, &insn, 1, sizeof(insn),
726 &skip_offset_loc);
727 if (ret)
728 return ret;
729 /* Visit right child */
730 ret = recursive_visit_gen_bytecode(ctx, node->u.binary.right);
731 if (ret)
732 return ret;
8cf9540a 733 /* Cast to s64 if float or field ref */
586dc72f 734 if ((node->u.binary.right->data_type == IR_DATA_FIELD_REF
661dfdd1 735 || node->u.binary.right->data_type == IR_DATA_GET_CONTEXT_REF
bff988fa 736 || node->u.binary.right->data_type == IR_DATA_EXPRESSION)
8cf9540a
MD		 737 || node->u.binary.right->data_type == IR_DATA_FLOAT) {
738 struct cast_op cast_insn;
739
586dc72f 740 if (node->u.binary.right->data_type == IR_DATA_FIELD_REF
661dfdd1 741 || node->u.binary.right->data_type == IR_DATA_GET_CONTEXT_REF
bff988fa 742 || node->u.binary.right->data_type == IR_DATA_EXPRESSION) {
29fefef8
MD		 743 cast_insn.op = FILTER_OP_CAST_TO_S64;
744 } else {
745 cast_insn.op = FILTER_OP_CAST_DOUBLE_TO_S64;
746 }
8cf9540a
MD		 747 ret = bytecode_push(&ctx->bytecode, &cast_insn,
748 1, sizeof(cast_insn));
749 if (ret)
750 return ret;
751 }
953192ba
MD		 752 /* We now know where the logical op can skip. */
753 target_loc = (uint16_t) bytecode_get_len(&ctx->bytecode->b);
754 ret = bytecode_patch(&ctx->bytecode,
755 &target_loc, /* Offset to jump to */
756 skip_offset_loc, /* Where to patch */
757 sizeof(uint16_t));
758 return ret;
759}
760
761/*
762 * Postorder traversal of the tree. We need the children result before
763 * we can evaluate the parent.
764 */
765static
766int recursive_visit_gen_bytecode(struct filter_parser_ctx *ctx,
767 struct ir_op *node)
768{
769 switch (node->op) {
770 case IR_OP_UNKNOWN:
771 default:
772 fprintf(stderr, "[error] Unknown node type in %s\n",
773 __func__);
774 return -EINVAL;
775
776 case IR_OP_ROOT:
777 return visit_node_root(ctx, node);
778 case IR_OP_LOAD:
779 return visit_node_load(ctx, node);
780 case IR_OP_UNARY:
781 return visit_node_unary(ctx, node);
782 case IR_OP_BINARY:
783 return visit_node_binary(ctx, node);
784 case IR_OP_LOGICAL:
785 return visit_node_logical(ctx, node);
786 }
787}
788
a187da1a 789LTTNG_HIDDEN
953192ba
MD		 790void filter_bytecode_free(struct filter_parser_ctx *ctx)
791{
7ca1dc6f
DG		 792 if (!ctx) {
793 return;
794 }
795
3f0c8837
DG		 796 if (ctx->bytecode) {
797 free(ctx->bytecode);
798 ctx->bytecode = NULL;
799 }
800
801 if (ctx->bytecode_reloc) {
802 free(ctx->bytecode_reloc);
803 ctx->bytecode_reloc = NULL;
804 }
953192ba
MD		 805}
806
a187da1a 807LTTNG_HIDDEN
953192ba
MD		 808int filter_visitor_bytecode_generate(struct filter_parser_ctx *ctx)
809{
810 int ret;
811
812 ret = bytecode_init(&ctx->bytecode);
813 if (ret)
814 return ret;
815 ret = bytecode_init(&ctx->bytecode_reloc);
816 if (ret)
817 goto error;
818 ret = recursive_visit_gen_bytecode(ctx, ctx->ir_root);
819 if (ret)
820 goto error;
821
822 /* Finally, append symbol table to bytecode */
823 ctx->bytecode->b.reloc_table_offset = bytecode_get_len(&ctx->bytecode->b);
824 return bytecode_push(&ctx->bytecode, ctx->bytecode_reloc->b.data,
825 1, bytecode_get_len(&ctx->bytecode_reloc->b));
826
827error:
828 filter_bytecode_free(ctx);
829 return ret;
830}
LTTng 2.0 tools and control repository
This page took 0.079792 seconds and 4 git commands to generate.