2 * filter-visitor-generate-bytecode.c
4 * LTTng filter bytecode generation
6 * Copyright 2012 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
8 * This library is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU Lesser General Public License, version 2.1 only,
10 * as published by the Free Software Foundation.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public License
18 * along with this library; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 #include "filter-bytecode.h"
27 #include "filter-ir.h"
28 #include "filter-ast.h"
31 #define max_t(type, a, b) ((type) ((a) > (b) ? (a) : (b)))
34 //#define INIT_ALLOC_SIZE PAGE_SIZE
35 #define INIT_ALLOC_SIZE 4
38 int recursive_visit_gen_bytecode(struct filter_parser_ctx
*ctx
,
42 int bytecode_init(struct lttng_filter_bytecode_alloc
**fb
)
44 *fb
= calloc(sizeof(struct lttng_filter_bytecode_alloc
) + INIT_ALLOC_SIZE
, 1);
48 (*fb
)->alloc_len
= INIT_ALLOC_SIZE
;
54 int32_t bytecode_reserve(struct lttng_filter_bytecode_alloc
**fb
, uint32_t align
, uint32_t len
)
57 uint32_t padding
= offset_align((*fb
)->b
.len
, align
);
59 if ((*fb
)->b
.len
+ padding
+ len
> (*fb
)->alloc_len
) {
61 max_t(uint32_t, (*fb
)->b
.len
+ padding
+ len
,
62 (*fb
)->alloc_len
<< 1);
63 uint32_t old_len
= (*fb
)->alloc_len
;
67 *fb
= realloc(*fb
, sizeof(struct lttng_filter_bytecode_alloc
) + new_len
);
70 memset(&(*fb
)->b
.data
[old_len
], 0, new_len
- old_len
);
71 (*fb
)->alloc_len
= new_len
;
73 (*fb
)->b
.len
+= padding
;
80 int bytecode_push(struct lttng_filter_bytecode_alloc
**fb
, const void *data
,
81 uint32_t align
, uint32_t len
)
85 offset
= bytecode_reserve(fb
, align
, len
);
88 memcpy(&(*fb
)->b
.data
[offset
], data
, len
);
93 int bytecode_push_logical(struct lttng_filter_bytecode_alloc
**fb
,
94 struct logical_op
*data
,
95 uint32_t align
, uint32_t len
,
96 uint16_t *skip_offset
)
100 offset
= bytecode_reserve(fb
, align
, len
);
103 memcpy(&(*fb
)->b
.data
[offset
], data
, len
);
105 (void *) &((struct logical_op
*) &(*fb
)->b
.data
[offset
])->skip_offset
106 - (void *) &(*fb
)->b
.data
[0];
111 int bytecode_patch(struct lttng_filter_bytecode_alloc
**fb
,
116 if (offset
>= (*fb
)->b
.len
) {
119 memcpy(&(*fb
)->b
.data
[offset
], data
, len
);
124 int visit_node_root(struct filter_parser_ctx
*ctx
, struct ir_op
*node
)
127 struct return_op insn
;
130 ret
= recursive_visit_gen_bytecode(ctx
, node
->u
.root
.child
);
134 /* Generate end of bytecode instruction */
135 insn
.op
= FILTER_OP_RETURN
;
136 return bytecode_push(&ctx
->bytecode
, &insn
, 1, sizeof(insn
));
140 enum filter_register
reg_sel(struct ir_op
*node
)
142 switch (node
->side
) {
143 case IR_SIDE_UNKNOWN
:
145 fprintf(stderr
, "[error] Unknown node side in %s\n",
156 int visit_node_load(struct filter_parser_ctx
*ctx
, struct ir_op
*node
)
160 switch (node
->data_type
) {
161 case IR_DATA_UNKNOWN
:
163 fprintf(stderr
, "[error] Unknown data type in %s\n",
169 struct load_op
*insn
;
170 uint32_t insn_len
= sizeof(struct load_op
)
171 + strlen(node
->u
.load
.u
.string
) + 1;
173 insn
= calloc(insn_len
, 1);
176 insn
->op
= FILTER_OP_LOAD_STRING
;
177 insn
->reg
= reg_sel(node
);
178 if (insn
->reg
== REG_ERROR
)
180 strcpy(insn
->data
, node
->u
.load
.u
.string
);
181 ret
= bytecode_push(&ctx
->bytecode
, insn
, 1, insn_len
);
185 case IR_DATA_NUMERIC
:
187 struct load_op
*insn
;
188 uint32_t insn_len
= sizeof(struct load_op
)
189 + sizeof(struct literal_numeric
);
191 insn
= calloc(insn_len
, 1);
194 insn
->op
= FILTER_OP_LOAD_S64
;
195 insn
->reg
= reg_sel(node
);
196 if (insn
->reg
== REG_ERROR
)
198 *(int64_t *) insn
->data
= node
->u
.load
.u
.num
;
199 ret
= bytecode_push(&ctx
->bytecode
, insn
, 1, insn_len
);
205 struct load_op
*insn
;
206 uint32_t insn_len
= sizeof(struct load_op
)
207 + sizeof(struct literal_double
);
209 insn
= calloc(insn_len
, 1);
212 insn
->op
= FILTER_OP_LOAD_DOUBLE
;
213 insn
->reg
= reg_sel(node
);
214 if (insn
->reg
== REG_ERROR
)
216 *(double *) insn
->data
= node
->u
.load
.u
.flt
;
217 ret
= bytecode_push(&ctx
->bytecode
, insn
, 1, insn_len
);
221 case IR_DATA_FIELD_REF
:
223 struct load_op
*insn
;
224 uint32_t insn_len
= sizeof(struct load_op
)
225 + sizeof(struct field_ref
);
226 struct field_ref ref_offset
;
227 uint16_t reloc_offset
;
229 insn
= calloc(insn_len
, 1);
232 insn
->op
= FILTER_OP_LOAD_FIELD_REF
;
233 insn
->reg
= reg_sel(node
);
234 ref_offset
.offset
= (uint16_t) -1U;
235 memcpy(insn
->data
, &ref_offset
, sizeof(ref_offset
));
236 if (insn
->reg
== REG_ERROR
)
238 /* reloc_offset points to struct field_ref */
239 reloc_offset
= bytecode_get_len(&ctx
->bytecode
->b
);
240 reloc_offset
+= sizeof(struct load_op
);
241 ret
= bytecode_push(&ctx
->bytecode
, insn
, 1, insn_len
);
247 ret
= bytecode_push(&ctx
->bytecode_reloc
, &reloc_offset
,
248 1, sizeof(reloc_offset
));
253 ret
= bytecode_push(&ctx
->bytecode_reloc
, node
->u
.load
.u
.ref
,
254 1, strlen(node
->u
.load
.u
.ref
) + 1);
262 int visit_node_unary(struct filter_parser_ctx
*ctx
, struct ir_op
*node
)
265 struct unary_op insn
;
268 ret
= recursive_visit_gen_bytecode(ctx
, node
->u
.unary
.child
);
272 /* Generate end of bytecode instruction */
273 switch (node
->u
.unary
.type
) {
274 case AST_UNARY_UNKNOWN
:
276 fprintf(stderr
, "[error] Unknown unary node type in %s\n",
282 case AST_UNARY_MINUS
:
283 insn
.op
= FILTER_OP_UNARY_MINUS
;
284 insn
.reg
= reg_sel(node
);
285 if (insn
.reg
== REG_ERROR
)
287 return bytecode_push(&ctx
->bytecode
, &insn
, 1, sizeof(insn
));
289 insn
.op
= FILTER_OP_UNARY_NOT
;
290 insn
.reg
= reg_sel(node
);
291 if (insn
.reg
== REG_ERROR
)
293 return bytecode_push(&ctx
->bytecode
, &insn
, 1, sizeof(insn
));
298 * Binary comparator nesting is disallowed. This allows fitting into
302 int visit_node_binary(struct filter_parser_ctx
*ctx
, struct ir_op
*node
)
305 struct binary_op insn
;
308 ret
= recursive_visit_gen_bytecode(ctx
, node
->u
.binary
.left
);
311 ret
= recursive_visit_gen_bytecode(ctx
, node
->u
.binary
.right
);
315 switch (node
->u
.binary
.type
) {
318 fprintf(stderr
, "[error] Unknown unary node type in %s\n",
324 fprintf(stderr
, "[error] Unexpected logical node type in %s\n",
329 insn
.op
= FILTER_OP_MUL
;
332 insn
.op
= FILTER_OP_DIV
;
335 insn
.op
= FILTER_OP_MOD
;
338 insn
.op
= FILTER_OP_PLUS
;
341 insn
.op
= FILTER_OP_MINUS
;
344 insn
.op
= FILTER_OP_RSHIFT
;
347 insn
.op
= FILTER_OP_LSHIFT
;
350 insn
.op
= FILTER_OP_BIN_AND
;
353 insn
.op
= FILTER_OP_BIN_OR
;
356 insn
.op
= FILTER_OP_BIN_XOR
;
360 insn
.op
= FILTER_OP_EQ
;
363 insn
.op
= FILTER_OP_NE
;
366 insn
.op
= FILTER_OP_GT
;
369 insn
.op
= FILTER_OP_LT
;
372 insn
.op
= FILTER_OP_GE
;
375 insn
.op
= FILTER_OP_LE
;
378 return bytecode_push(&ctx
->bytecode
, &insn
, 1, sizeof(insn
));
382 int visit_node_logical(struct filter_parser_ctx
*ctx
, struct ir_op
*node
)
385 struct logical_op insn
;
386 uint16_t skip_offset_loc
;
389 /* Visit left child */
390 ret
= recursive_visit_gen_bytecode(ctx
, node
->u
.binary
.left
);
393 switch (node
->u
.logical
.type
) {
395 fprintf(stderr
, "[error] Unknown node type in %s\n",
400 insn
.op
= FILTER_OP_AND
;
403 insn
.op
= FILTER_OP_OR
;
406 insn
.skip_offset
= (uint16_t) -1UL; /* Temporary */
407 ret
= bytecode_push_logical(&ctx
->bytecode
, &insn
, 1, sizeof(insn
),
411 /* Visit right child */
412 ret
= recursive_visit_gen_bytecode(ctx
, node
->u
.binary
.right
);
415 /* We now know where the logical op can skip. */
416 target_loc
= (uint16_t) bytecode_get_len(&ctx
->bytecode
->b
);
417 ret
= bytecode_patch(&ctx
->bytecode
,
418 &target_loc
, /* Offset to jump to */
419 skip_offset_loc
, /* Where to patch */
425 * Postorder traversal of the tree. We need the children result before
426 * we can evaluate the parent.
429 int recursive_visit_gen_bytecode(struct filter_parser_ctx
*ctx
,
435 fprintf(stderr
, "[error] Unknown node type in %s\n",
440 return visit_node_root(ctx
, node
);
442 return visit_node_load(ctx
, node
);
444 return visit_node_unary(ctx
, node
);
446 return visit_node_binary(ctx
, node
);
448 return visit_node_logical(ctx
, node
);
452 void filter_bytecode_free(struct filter_parser_ctx
*ctx
)
455 ctx
->bytecode
= NULL
;
456 free(ctx
->bytecode_reloc
);
457 ctx
->bytecode_reloc
= NULL
;
460 int filter_visitor_bytecode_generate(struct filter_parser_ctx
*ctx
)
464 ret
= bytecode_init(&ctx
->bytecode
);
467 ret
= bytecode_init(&ctx
->bytecode_reloc
);
470 ret
= recursive_visit_gen_bytecode(ctx
, ctx
->ir_root
);
474 /* Finally, append symbol table to bytecode */
475 ctx
->bytecode
->b
.reloc_table_offset
= bytecode_get_len(&ctx
->bytecode
->b
);
476 return bytecode_push(&ctx
->bytecode
, ctx
->bytecode_reloc
->b
.data
,
477 1, bytecode_get_len(&ctx
->bytecode_reloc
->b
));
480 filter_bytecode_free(ctx
);