1 /* SPDX-License-Identifier: MIT
3 * lttng-bytecode-specialize.c
5 * LTTng modules bytecode code specializer.
7 * Copyright (C) 2010-2016 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
10 #include <linux/slab.h>
11 #include <wrapper/compiler_attributes.h>
13 #include <lttng/lttng-bytecode.h>
14 #include <lttng/align.h>
15 #include <lttng/events-internal.h>
17 static ssize_t
bytecode_reserve_data(struct bytecode_runtime
*runtime
,
18 size_t align
, size_t len
)
21 size_t padding
= offset_align(runtime
->data_len
, align
);
22 size_t new_len
= runtime
->data_len
+ padding
+ len
;
23 size_t new_alloc_len
= new_len
;
24 size_t old_alloc_len
= runtime
->data_alloc_len
;
26 if (new_len
> INTERPRETER_MAX_DATA_LEN
)
29 if (new_alloc_len
> old_alloc_len
) {
33 max_t(size_t, 1U << get_count_order(new_alloc_len
), old_alloc_len
<< 1);
34 newptr
= krealloc(runtime
->data
, new_alloc_len
, GFP_KERNEL
);
37 runtime
->data
= newptr
;
38 /* We zero directly the memory from start of allocation. */
39 memset(&runtime
->data
[old_alloc_len
], 0, new_alloc_len
- old_alloc_len
);
40 runtime
->data_alloc_len
= new_alloc_len
;
42 runtime
->data_len
+= padding
;
43 ret
= runtime
->data_len
;
44 runtime
->data_len
+= len
;
48 static ssize_t
bytecode_push_data(struct bytecode_runtime
*runtime
,
49 const void *p
, size_t align
, size_t len
)
53 offset
= bytecode_reserve_data(runtime
, align
, len
);
56 memcpy(&runtime
->data
[offset
], p
, len
);
60 static int specialize_load_field(struct vstack_entry
*stack_top
,
65 switch (stack_top
->load
.type
) {
68 case LOAD_ROOT_CONTEXT
:
69 case LOAD_ROOT_APP_CONTEXT
:
70 case LOAD_ROOT_PAYLOAD
:
72 dbg_printk("Bytecode warning: cannot load root, missing field name.\n");
76 switch (stack_top
->load
.object_type
) {
78 dbg_printk("op load field s8\n");
79 stack_top
->type
= REG_S64
;
80 if (!stack_top
->load
.user
)
81 insn
->op
= BYTECODE_OP_LOAD_FIELD_S8
;
84 dbg_printk("op load field s16\n");
85 stack_top
->type
= REG_S64
;
86 if (!stack_top
->load
.rev_bo
&& !stack_top
->load
.user
)
87 insn
->op
= BYTECODE_OP_LOAD_FIELD_S16
;
90 dbg_printk("op load field s32\n");
91 stack_top
->type
= REG_S64
;
92 if (!stack_top
->load
.rev_bo
&& !stack_top
->load
.user
)
93 insn
->op
= BYTECODE_OP_LOAD_FIELD_S32
;
96 dbg_printk("op load field s64\n");
97 stack_top
->type
= REG_S64
;
98 if (!stack_top
->load
.rev_bo
&& !stack_top
->load
.user
)
99 insn
->op
= BYTECODE_OP_LOAD_FIELD_S64
;
101 case OBJECT_TYPE_SIGNED_ENUM
:
102 dbg_printk("op load field signed enumeration\n");
103 if (stack_top
->load
.user
) {
104 printk(KERN_WARNING
"LTTng: bytecode: user enum unsupported\n");
108 stack_top
->type
= REG_S64
;
111 dbg_printk("op load field u8\n");
112 stack_top
->type
= REG_S64
;
113 if (!stack_top
->load
.user
)
114 insn
->op
= BYTECODE_OP_LOAD_FIELD_U8
;
116 case OBJECT_TYPE_U16
:
117 dbg_printk("op load field u16\n");
118 stack_top
->type
= REG_S64
;
119 if (!stack_top
->load
.rev_bo
&& !stack_top
->load
.user
)
120 insn
->op
= BYTECODE_OP_LOAD_FIELD_U16
;
122 case OBJECT_TYPE_U32
:
123 dbg_printk("op load field u32\n");
124 stack_top
->type
= REG_S64
;
125 if (!stack_top
->load
.rev_bo
&& !stack_top
->load
.user
)
126 insn
->op
= BYTECODE_OP_LOAD_FIELD_U32
;
128 case OBJECT_TYPE_U64
:
129 dbg_printk("op load field u64\n");
130 stack_top
->type
= REG_S64
;
131 if (!stack_top
->load
.rev_bo
&& !stack_top
->load
.user
)
132 insn
->op
= BYTECODE_OP_LOAD_FIELD_U64
;
134 case OBJECT_TYPE_UNSIGNED_ENUM
:
135 dbg_printk("op load field unsigned enumeration\n");
136 if (stack_top
->load
.user
) {
137 printk(KERN_WARNING
"LTTng: bytecode: user enum unsupported\n");
141 stack_top
->type
= REG_U64
;
143 case OBJECT_TYPE_DOUBLE
:
144 printk(KERN_WARNING
"LTTng: bytecode: Double type unsupported\n\n");
147 case OBJECT_TYPE_STRING
:
148 dbg_printk("op load field string\n");
149 stack_top
->type
= REG_STRING
;
150 if (!stack_top
->load
.user
)
151 insn
->op
= BYTECODE_OP_LOAD_FIELD_STRING
;
153 case OBJECT_TYPE_STRING_SEQUENCE
:
154 dbg_printk("op load field string sequence\n");
155 stack_top
->type
= REG_STRING
;
156 if (!stack_top
->load
.user
)
157 insn
->op
= BYTECODE_OP_LOAD_FIELD_SEQUENCE
;
159 case OBJECT_TYPE_DYNAMIC
:
162 case OBJECT_TYPE_SEQUENCE
:
163 case OBJECT_TYPE_ARRAY
:
164 case OBJECT_TYPE_STRUCT
:
165 case OBJECT_TYPE_VARIANT
:
166 printk(KERN_WARNING
"LTTng: bytecode: Sequences, arrays, struct and variant cannot be loaded (nested types).\n");
176 static int specialize_get_index_object_type(enum object_type
*otype
,
177 int signedness
, uint32_t elem_len
)
182 *otype
= OBJECT_TYPE_S8
;
184 *otype
= OBJECT_TYPE_U8
;
188 *otype
= OBJECT_TYPE_S16
;
190 *otype
= OBJECT_TYPE_U16
;
194 *otype
= OBJECT_TYPE_S32
;
196 *otype
= OBJECT_TYPE_U32
;
200 *otype
= OBJECT_TYPE_S64
;
202 *otype
= OBJECT_TYPE_U64
;
210 static int specialize_get_index(struct bytecode_runtime
*runtime
,
211 struct load_op
*insn
, uint64_t index
,
212 struct vstack_entry
*stack_top
,
216 struct bytecode_get_index_data gid
;
219 memset(&gid
, 0, sizeof(gid
));
220 switch (stack_top
->load
.type
) {
222 switch (stack_top
->load
.object_type
) {
223 case OBJECT_TYPE_ARRAY
:
225 const struct lttng_kernel_event_field
*field
;
226 const struct lttng_kernel_type_array
*array_type
;
227 const struct lttng_kernel_type_integer
*integer_type
;
228 uint32_t elem_len
, num_elems
;
231 field
= stack_top
->load
.field
;
232 array_type
= lttng_kernel_get_type_array(field
->type
);
233 if (!lttng_kernel_type_is_bytewise_integer(array_type
->elem_type
)) {
237 integer_type
= lttng_kernel_get_type_integer(array_type
->elem_type
);
238 num_elems
= array_type
->length
;
239 elem_len
= integer_type
->size
;
240 signedness
= integer_type
->signedness
;
241 if (index
>= num_elems
) {
245 ret
= specialize_get_index_object_type(&stack_top
->load
.object_type
,
246 signedness
, elem_len
);
249 gid
.offset
= index
* (elem_len
/ CHAR_BIT
);
250 gid
.array_len
= num_elems
* (elem_len
/ CHAR_BIT
);
251 gid
.elem
.type
= stack_top
->load
.object_type
;
252 gid
.elem
.len
= elem_len
;
253 stack_top
->load
.rev_bo
= gid
.elem
.rev_bo
= integer_type
->reverse_byte_order
;
254 stack_top
->load
.user
= gid
.elem
.user
= integer_type
->user
;
257 case OBJECT_TYPE_SEQUENCE
:
259 const struct lttng_kernel_event_field
*field
;
260 const struct lttng_kernel_type_sequence
*sequence_type
;
261 const struct lttng_kernel_type_integer
*integer_type
;
265 field
= stack_top
->load
.field
;
266 sequence_type
= lttng_kernel_get_type_sequence(field
->type
);
267 if (!lttng_kernel_type_is_bytewise_integer(sequence_type
->elem_type
)) {
271 integer_type
= lttng_kernel_get_type_integer(sequence_type
->elem_type
);
272 elem_len
= integer_type
->size
;
273 signedness
= integer_type
->signedness
;
274 ret
= specialize_get_index_object_type(&stack_top
->load
.object_type
,
275 signedness
, elem_len
);
278 gid
.offset
= index
* (elem_len
/ CHAR_BIT
);
279 gid
.elem
.type
= stack_top
->load
.object_type
;
280 gid
.elem
.len
= elem_len
;
281 stack_top
->load
.rev_bo
= gid
.elem
.rev_bo
= integer_type
->reverse_byte_order
;
282 stack_top
->load
.user
= gid
.elem
.user
= integer_type
->user
;
285 case OBJECT_TYPE_STRUCT
:
286 /* Only generated by the specialize phase. */
287 case OBJECT_TYPE_VARIANT
:
290 printk(KERN_WARNING
"LTTng: bytecode: Unexpected get index type %d",
291 (int) stack_top
->load
.object_type
);
296 case LOAD_ROOT_CONTEXT
:
297 case LOAD_ROOT_APP_CONTEXT
:
298 case LOAD_ROOT_PAYLOAD
:
299 printk(KERN_WARNING
"LTTng: bytecode: Index lookup for root field not implemented yet.\n");
303 data_offset
= bytecode_push_data(runtime
, &gid
,
304 __alignof__(gid
), sizeof(gid
));
305 if (data_offset
< 0) {
311 ((struct get_index_u16
*) insn
->data
)->index
= data_offset
;
314 ((struct get_index_u64
*) insn
->data
)->index
= data_offset
;
327 static int specialize_context_lookup_name(struct lttng_kernel_ctx
*ctx
,
328 struct bytecode_runtime
*bytecode
,
329 struct load_op
*insn
)
334 offset
= ((struct get_symbol
*) insn
->data
)->offset
;
335 name
= bytecode
->p
.bc
->bc
.data
+ bytecode
->p
.bc
->bc
.reloc_offset
+ offset
;
336 return lttng_kernel_get_context_index(ctx
, name
);
339 static int specialize_load_object(const struct lttng_kernel_event_field
*field
,
340 struct vstack_load
*load
, bool is_context
)
342 load
->type
= LOAD_OBJECT
;
344 switch (field
->type
->type
) {
345 case lttng_kernel_type_integer
:
347 const struct lttng_kernel_type_integer
*integer_type
= lttng_kernel_get_type_integer(field
->type
);
349 if (integer_type
->signedness
)
350 load
->object_type
= OBJECT_TYPE_S64
;
352 load
->object_type
= OBJECT_TYPE_U64
;
353 load
->rev_bo
= integer_type
->reverse_byte_order
;
354 load
->user
= integer_type
->user
;
357 case lttng_kernel_type_enum
:
359 const struct lttng_kernel_type_enum
*enum_type
= lttng_kernel_get_type_enum(field
->type
);
360 const struct lttng_kernel_type_integer
*integer_type
= lttng_kernel_get_type_integer(enum_type
->container_type
);
362 if (integer_type
->signedness
)
363 load
->object_type
= OBJECT_TYPE_SIGNED_ENUM
;
365 load
->object_type
= OBJECT_TYPE_UNSIGNED_ENUM
;
366 load
->rev_bo
= integer_type
->reverse_byte_order
;
367 load
->user
= integer_type
->user
;
370 case lttng_kernel_type_array
:
372 const struct lttng_kernel_type_array
*array_type
= lttng_kernel_get_type_array(field
->type
);
373 const struct lttng_kernel_type_integer
*integer_type
;
375 if (!lttng_kernel_type_is_bytewise_integer(array_type
->elem_type
)) {
376 printk(KERN_WARNING
"LTTng: bytecode: Array nesting only supports integer types.\n");
379 integer_type
= lttng_kernel_get_type_integer(array_type
->elem_type
);
381 load
->object_type
= OBJECT_TYPE_STRING
;
382 load
->user
= integer_type
->user
;
384 if (array_type
->encoding
== lttng_kernel_string_encoding_none
) {
385 load
->object_type
= OBJECT_TYPE_ARRAY
;
388 load
->object_type
= OBJECT_TYPE_STRING_SEQUENCE
;
389 load
->user
= integer_type
->user
;
394 case lttng_kernel_type_sequence
:
396 const struct lttng_kernel_type_sequence
*sequence_type
= lttng_kernel_get_type_sequence(field
->type
);
397 const struct lttng_kernel_type_integer
*integer_type
;
399 if (!lttng_kernel_type_is_bytewise_integer(sequence_type
->elem_type
)) {
400 printk(KERN_WARNING
"LTTng: bytecode: Sequence nesting only supports integer types.\n");
403 integer_type
= lttng_kernel_get_type_integer(sequence_type
->elem_type
);
405 load
->object_type
= OBJECT_TYPE_STRING
;
406 load
->user
= integer_type
->user
;
408 if (sequence_type
->encoding
== lttng_kernel_string_encoding_none
) {
409 load
->object_type
= OBJECT_TYPE_SEQUENCE
;
412 load
->object_type
= OBJECT_TYPE_STRING_SEQUENCE
;
413 load
->user
= integer_type
->user
;
418 case lttng_kernel_type_string
:
420 const struct lttng_kernel_type_string
*string_type
= lttng_kernel_get_type_string(field
->type
);
422 load
->object_type
= OBJECT_TYPE_STRING
;
423 load
->user
= string_type
->user
;
426 case lttng_kernel_type_struct
:
427 printk(KERN_WARNING
"LTTng: bytecode: Structure type cannot be loaded.\n");
429 case lttng_kernel_type_variant
:
430 printk(KERN_WARNING
"LTTng: bytecode: Variant type cannot be loaded.\n");
433 printk(KERN_WARNING
"LTTng: bytecode: Unknown type: %d", (int) field
->type
->type
);
439 static int specialize_context_lookup(struct lttng_kernel_ctx
*ctx
,
440 struct bytecode_runtime
*runtime
,
441 struct load_op
*insn
,
442 struct vstack_load
*load
)
445 const struct lttng_kernel_ctx_field
*ctx_field
;
446 const struct lttng_kernel_event_field
*field
;
447 struct bytecode_get_index_data gid
;
450 idx
= specialize_context_lookup_name(ctx
, runtime
, insn
);
454 ctx_field
= <tng_static_ctx
->fields
[idx
];
455 field
= ctx_field
->event_field
;
456 ret
= specialize_load_object(field
, load
, true);
459 /* Specialize each get_symbol into a get_index. */
460 insn
->op
= BYTECODE_OP_GET_INDEX_U16
;
461 memset(&gid
, 0, sizeof(gid
));
463 gid
.elem
.type
= load
->object_type
;
464 gid
.elem
.rev_bo
= load
->rev_bo
;
465 gid
.elem
.user
= load
->user
;
467 data_offset
= bytecode_push_data(runtime
, &gid
,
468 __alignof__(gid
), sizeof(gid
));
469 if (data_offset
< 0) {
472 ((struct get_index_u16
*) insn
->data
)->index
= data_offset
;
476 static int specialize_payload_lookup(const struct lttng_kernel_event_desc
*event_desc
,
477 struct bytecode_runtime
*runtime
,
478 struct load_op
*insn
,
479 struct vstack_load
*load
)
483 unsigned int i
, nr_fields
;
485 uint32_t field_offset
= 0;
486 const struct lttng_kernel_event_field
*field
;
488 struct bytecode_get_index_data gid
;
491 nr_fields
= event_desc
->tp_class
->nr_fields
;
492 offset
= ((struct get_symbol
*) insn
->data
)->offset
;
493 name
= runtime
->p
.bc
->bc
.data
+ runtime
->p
.bc
->bc
.reloc_offset
+ offset
;
494 for (i
= 0; i
< nr_fields
; i
++) {
495 field
= event_desc
->tp_class
->fields
[i
];
496 if (field
->nofilter
) {
499 if (!strcmp(field
->name
, name
)) {
503 /* compute field offset on stack */
504 switch (field
->type
->type
) {
505 case lttng_kernel_type_integer
:
506 case lttng_kernel_type_enum
:
507 field_offset
+= sizeof(int64_t);
509 case lttng_kernel_type_array
:
510 case lttng_kernel_type_sequence
:
511 field_offset
+= sizeof(unsigned long);
512 field_offset
+= sizeof(void *);
514 case lttng_kernel_type_string
:
515 field_offset
+= sizeof(void *);
527 ret
= specialize_load_object(field
, load
, false);
531 /* Specialize each get_symbol into a get_index. */
532 insn
->op
= BYTECODE_OP_GET_INDEX_U16
;
533 memset(&gid
, 0, sizeof(gid
));
534 gid
.offset
= field_offset
;
535 gid
.elem
.type
= load
->object_type
;
536 gid
.elem
.rev_bo
= load
->rev_bo
;
537 gid
.elem
.user
= load
->user
;
539 data_offset
= bytecode_push_data(runtime
, &gid
,
540 __alignof__(gid
), sizeof(gid
));
541 if (data_offset
< 0) {
545 ((struct get_index_u16
*) insn
->data
)->index
= data_offset
;
551 int lttng_bytecode_specialize(const struct lttng_kernel_event_desc
*event_desc
,
552 struct bytecode_runtime
*bytecode
)
554 void *pc
, *next_pc
, *start_pc
;
556 struct vstack _stack
;
557 struct vstack
*stack
= &_stack
;
558 struct lttng_kernel_ctx
*ctx
= bytecode
->p
.ctx
;
562 start_pc
= &bytecode
->code
[0];
563 for (pc
= next_pc
= start_pc
; pc
- start_pc
< bytecode
->len
;
565 switch (*(bytecode_opcode_t
*) pc
) {
566 case BYTECODE_OP_UNKNOWN
:
568 printk(KERN_WARNING
"LTTng: bytecode: unknown bytecode op %u\n",
569 (unsigned int) *(bytecode_opcode_t
*) pc
);
573 case BYTECODE_OP_RETURN
:
574 case BYTECODE_OP_RETURN_S64
:
579 case BYTECODE_OP_MUL
:
580 case BYTECODE_OP_DIV
:
581 case BYTECODE_OP_MOD
:
582 case BYTECODE_OP_PLUS
:
583 case BYTECODE_OP_MINUS
:
584 printk(KERN_WARNING
"LTTng: bytecode: unknown bytecode op %u\n",
585 (unsigned int) *(bytecode_opcode_t
*) pc
);
591 struct binary_op
*insn
= (struct binary_op
*) pc
;
593 switch(vstack_ax(stack
)->type
) {
595 printk(KERN_WARNING
"LTTng: bytecode: unknown register type\n");
600 if (vstack_bx(stack
)->type
== REG_STAR_GLOB_STRING
)
601 insn
->op
= BYTECODE_OP_EQ_STAR_GLOB_STRING
;
603 insn
->op
= BYTECODE_OP_EQ_STRING
;
605 case REG_STAR_GLOB_STRING
:
606 insn
->op
= BYTECODE_OP_EQ_STAR_GLOB_STRING
;
609 if (vstack_bx(stack
)->type
== REG_S64
)
610 insn
->op
= BYTECODE_OP_EQ_S64
;
612 insn
->op
= BYTECODE_OP_EQ_DOUBLE_S64
;
615 if (vstack_bx(stack
)->type
== REG_S64
)
616 insn
->op
= BYTECODE_OP_EQ_S64_DOUBLE
;
618 insn
->op
= BYTECODE_OP_EQ_DOUBLE
;
622 if (vstack_pop(stack
)) {
626 vstack_ax(stack
)->type
= REG_S64
;
627 next_pc
+= sizeof(struct binary_op
);
633 struct binary_op
*insn
= (struct binary_op
*) pc
;
635 switch(vstack_ax(stack
)->type
) {
637 printk(KERN_WARNING
"LTTng: bytecode: unknown register type\n");
642 if (vstack_bx(stack
)->type
== REG_STAR_GLOB_STRING
)
643 insn
->op
= BYTECODE_OP_NE_STAR_GLOB_STRING
;
645 insn
->op
= BYTECODE_OP_NE_STRING
;
647 case REG_STAR_GLOB_STRING
:
648 insn
->op
= BYTECODE_OP_NE_STAR_GLOB_STRING
;
651 if (vstack_bx(stack
)->type
== REG_S64
)
652 insn
->op
= BYTECODE_OP_NE_S64
;
654 insn
->op
= BYTECODE_OP_NE_DOUBLE_S64
;
657 if (vstack_bx(stack
)->type
== REG_S64
)
658 insn
->op
= BYTECODE_OP_NE_S64_DOUBLE
;
660 insn
->op
= BYTECODE_OP_NE_DOUBLE
;
664 if (vstack_pop(stack
)) {
668 vstack_ax(stack
)->type
= REG_S64
;
669 next_pc
+= sizeof(struct binary_op
);
675 struct binary_op
*insn
= (struct binary_op
*) pc
;
677 switch(vstack_ax(stack
)->type
) {
679 printk(KERN_WARNING
"LTTng: bytecode: unknown register type\n");
683 case REG_STAR_GLOB_STRING
:
684 printk(KERN_WARNING
"LTTng: bytecode: invalid register type for '>' binary operator\n");
688 insn
->op
= BYTECODE_OP_GT_STRING
;
691 if (vstack_bx(stack
)->type
== REG_S64
)
692 insn
->op
= BYTECODE_OP_GT_S64
;
694 insn
->op
= BYTECODE_OP_GT_DOUBLE_S64
;
697 if (vstack_bx(stack
)->type
== REG_S64
)
698 insn
->op
= BYTECODE_OP_GT_S64_DOUBLE
;
700 insn
->op
= BYTECODE_OP_GT_DOUBLE
;
704 if (vstack_pop(stack
)) {
708 vstack_ax(stack
)->type
= REG_S64
;
709 next_pc
+= sizeof(struct binary_op
);
715 struct binary_op
*insn
= (struct binary_op
*) pc
;
717 switch(vstack_ax(stack
)->type
) {
719 printk(KERN_WARNING
"LTTng: bytecode: unknown register type\n");
723 case REG_STAR_GLOB_STRING
:
724 printk(KERN_WARNING
"LTTng: bytecode: invalid register type for '<' binary operator\n");
728 insn
->op
= BYTECODE_OP_LT_STRING
;
731 if (vstack_bx(stack
)->type
== REG_S64
)
732 insn
->op
= BYTECODE_OP_LT_S64
;
734 insn
->op
= BYTECODE_OP_LT_DOUBLE_S64
;
737 if (vstack_bx(stack
)->type
== REG_S64
)
738 insn
->op
= BYTECODE_OP_LT_S64_DOUBLE
;
740 insn
->op
= BYTECODE_OP_LT_DOUBLE
;
744 if (vstack_pop(stack
)) {
748 vstack_ax(stack
)->type
= REG_S64
;
749 next_pc
+= sizeof(struct binary_op
);
755 struct binary_op
*insn
= (struct binary_op
*) pc
;
757 switch(vstack_ax(stack
)->type
) {
759 printk(KERN_WARNING
"LTTng: bytecode: unknown register type\n");
763 case REG_STAR_GLOB_STRING
:
764 printk(KERN_WARNING
"LTTng: bytecode: invalid register type for '>=' binary operator\n");
768 insn
->op
= BYTECODE_OP_GE_STRING
;
771 if (vstack_bx(stack
)->type
== REG_S64
)
772 insn
->op
= BYTECODE_OP_GE_S64
;
774 insn
->op
= BYTECODE_OP_GE_DOUBLE_S64
;
777 if (vstack_bx(stack
)->type
== REG_S64
)
778 insn
->op
= BYTECODE_OP_GE_S64_DOUBLE
;
780 insn
->op
= BYTECODE_OP_GE_DOUBLE
;
784 if (vstack_pop(stack
)) {
788 vstack_ax(stack
)->type
= REG_S64
;
789 next_pc
+= sizeof(struct binary_op
);
794 struct binary_op
*insn
= (struct binary_op
*) pc
;
796 switch(vstack_ax(stack
)->type
) {
798 printk(KERN_WARNING
"LTTng: bytecode: unknown register type\n");
802 case REG_STAR_GLOB_STRING
:
803 printk(KERN_WARNING
"LTTng: bytecode: invalid register type for '<=' binary operator\n");
807 insn
->op
= BYTECODE_OP_LE_STRING
;
810 if (vstack_bx(stack
)->type
== REG_S64
)
811 insn
->op
= BYTECODE_OP_LE_S64
;
813 insn
->op
= BYTECODE_OP_LE_DOUBLE_S64
;
816 if (vstack_bx(stack
)->type
== REG_S64
)
817 insn
->op
= BYTECODE_OP_LE_S64_DOUBLE
;
819 insn
->op
= BYTECODE_OP_LE_DOUBLE
;
822 vstack_ax(stack
)->type
= REG_S64
;
823 next_pc
+= sizeof(struct binary_op
);
827 case BYTECODE_OP_EQ_STRING
:
828 case BYTECODE_OP_NE_STRING
:
829 case BYTECODE_OP_GT_STRING
:
830 case BYTECODE_OP_LT_STRING
:
831 case BYTECODE_OP_GE_STRING
:
832 case BYTECODE_OP_LE_STRING
:
833 case BYTECODE_OP_EQ_STAR_GLOB_STRING
:
834 case BYTECODE_OP_NE_STAR_GLOB_STRING
:
835 case BYTECODE_OP_EQ_S64
:
836 case BYTECODE_OP_NE_S64
:
837 case BYTECODE_OP_GT_S64
:
838 case BYTECODE_OP_LT_S64
:
839 case BYTECODE_OP_GE_S64
:
840 case BYTECODE_OP_LE_S64
:
841 case BYTECODE_OP_EQ_DOUBLE
:
842 case BYTECODE_OP_NE_DOUBLE
:
843 case BYTECODE_OP_GT_DOUBLE
:
844 case BYTECODE_OP_LT_DOUBLE
:
845 case BYTECODE_OP_GE_DOUBLE
:
846 case BYTECODE_OP_LE_DOUBLE
:
847 case BYTECODE_OP_EQ_DOUBLE_S64
:
848 case BYTECODE_OP_NE_DOUBLE_S64
:
849 case BYTECODE_OP_GT_DOUBLE_S64
:
850 case BYTECODE_OP_LT_DOUBLE_S64
:
851 case BYTECODE_OP_GE_DOUBLE_S64
:
852 case BYTECODE_OP_LE_DOUBLE_S64
:
853 case BYTECODE_OP_EQ_S64_DOUBLE
:
854 case BYTECODE_OP_NE_S64_DOUBLE
:
855 case BYTECODE_OP_GT_S64_DOUBLE
:
856 case BYTECODE_OP_LT_S64_DOUBLE
:
857 case BYTECODE_OP_GE_S64_DOUBLE
:
858 case BYTECODE_OP_LE_S64_DOUBLE
:
859 case BYTECODE_OP_BIT_RSHIFT
:
860 case BYTECODE_OP_BIT_LSHIFT
:
861 case BYTECODE_OP_BIT_AND
:
862 case BYTECODE_OP_BIT_OR
:
863 case BYTECODE_OP_BIT_XOR
:
866 if (vstack_pop(stack
)) {
870 vstack_ax(stack
)->type
= REG_S64
;
871 next_pc
+= sizeof(struct binary_op
);
876 case BYTECODE_OP_UNARY_PLUS
:
878 struct unary_op
*insn
= (struct unary_op
*) pc
;
880 switch(vstack_ax(stack
)->type
) {
882 printk(KERN_WARNING
"LTTng: bytecode: unknown register type\n");
887 insn
->op
= BYTECODE_OP_UNARY_PLUS_S64
;
890 insn
->op
= BYTECODE_OP_UNARY_PLUS_DOUBLE
;
894 next_pc
+= sizeof(struct unary_op
);
898 case BYTECODE_OP_UNARY_MINUS
:
900 struct unary_op
*insn
= (struct unary_op
*) pc
;
902 switch(vstack_ax(stack
)->type
) {
904 printk(KERN_WARNING
"LTTng: bytecode: unknown register type\n");
909 insn
->op
= BYTECODE_OP_UNARY_MINUS_S64
;
912 insn
->op
= BYTECODE_OP_UNARY_MINUS_DOUBLE
;
916 next_pc
+= sizeof(struct unary_op
);
920 case BYTECODE_OP_UNARY_NOT
:
922 struct unary_op
*insn
= (struct unary_op
*) pc
;
924 switch(vstack_ax(stack
)->type
) {
926 printk(KERN_WARNING
"LTTng: bytecode: unknown register type\n");
931 insn
->op
= BYTECODE_OP_UNARY_NOT_S64
;
934 insn
->op
= BYTECODE_OP_UNARY_NOT_DOUBLE
;
938 next_pc
+= sizeof(struct unary_op
);
942 case BYTECODE_OP_UNARY_BIT_NOT
:
945 next_pc
+= sizeof(struct unary_op
);
949 case BYTECODE_OP_UNARY_PLUS_S64
:
950 case BYTECODE_OP_UNARY_MINUS_S64
:
951 case BYTECODE_OP_UNARY_NOT_S64
:
952 case BYTECODE_OP_UNARY_PLUS_DOUBLE
:
953 case BYTECODE_OP_UNARY_MINUS_DOUBLE
:
954 case BYTECODE_OP_UNARY_NOT_DOUBLE
:
957 next_pc
+= sizeof(struct unary_op
);
962 case BYTECODE_OP_AND
:
965 /* Continue to next instruction */
966 /* Pop 1 when jump not taken */
967 if (vstack_pop(stack
)) {
971 next_pc
+= sizeof(struct logical_op
);
976 case BYTECODE_OP_LOAD_FIELD_REF
:
978 printk(KERN_WARNING
"LTTng: bytecode: Unknown field ref type\n");
982 /* get context ref */
983 case BYTECODE_OP_GET_CONTEXT_REF
:
985 printk(KERN_WARNING
"LTTng: bytecode: Unknown get context ref type\n");
989 case BYTECODE_OP_LOAD_FIELD_REF_STRING
:
990 case BYTECODE_OP_LOAD_FIELD_REF_SEQUENCE
:
991 case BYTECODE_OP_GET_CONTEXT_REF_STRING
:
992 case BYTECODE_OP_LOAD_FIELD_REF_USER_STRING
:
993 case BYTECODE_OP_LOAD_FIELD_REF_USER_SEQUENCE
:
995 if (vstack_push(stack
)) {
999 vstack_ax(stack
)->type
= REG_STRING
;
1000 next_pc
+= sizeof(struct load_op
) + sizeof(struct field_ref
);
1003 case BYTECODE_OP_LOAD_FIELD_REF_S64
:
1004 case BYTECODE_OP_GET_CONTEXT_REF_S64
:
1006 if (vstack_push(stack
)) {
1010 vstack_ax(stack
)->type
= REG_S64
;
1011 next_pc
+= sizeof(struct load_op
) + sizeof(struct field_ref
);
1014 case BYTECODE_OP_LOAD_FIELD_REF_DOUBLE
:
1015 case BYTECODE_OP_GET_CONTEXT_REF_DOUBLE
:
1017 if (vstack_push(stack
)) {
1021 vstack_ax(stack
)->type
= REG_DOUBLE
;
1022 next_pc
+= sizeof(struct load_op
) + sizeof(struct field_ref
);
1026 /* load from immediate operand */
1027 case BYTECODE_OP_LOAD_STRING
:
1029 struct load_op
*insn
= (struct load_op
*) pc
;
1031 if (vstack_push(stack
)) {
1035 vstack_ax(stack
)->type
= REG_STRING
;
1036 next_pc
+= sizeof(struct load_op
) + strlen(insn
->data
) + 1;
1040 case BYTECODE_OP_LOAD_STAR_GLOB_STRING
:
1042 struct load_op
*insn
= (struct load_op
*) pc
;
1044 if (vstack_push(stack
)) {
1048 vstack_ax(stack
)->type
= REG_STAR_GLOB_STRING
;
1049 next_pc
+= sizeof(struct load_op
) + strlen(insn
->data
) + 1;
1053 case BYTECODE_OP_LOAD_S64
:
1055 if (vstack_push(stack
)) {
1059 vstack_ax(stack
)->type
= REG_S64
;
1060 next_pc
+= sizeof(struct load_op
)
1061 + sizeof(struct literal_numeric
);
1065 case BYTECODE_OP_LOAD_DOUBLE
:
1067 if (vstack_push(stack
)) {
1071 vstack_ax(stack
)->type
= REG_DOUBLE
;
1072 next_pc
+= sizeof(struct load_op
)
1073 + sizeof(struct literal_double
);
1078 case BYTECODE_OP_CAST_TO_S64
:
1080 struct cast_op
*insn
= (struct cast_op
*) pc
;
1082 switch (vstack_ax(stack
)->type
) {
1084 printk(KERN_WARNING
"LTTng: bytecode: unknown register type\n");
1089 case REG_STAR_GLOB_STRING
:
1090 printk(KERN_WARNING
"LTTng: bytecode: Cast op can only be applied to numeric or floating point registers\n");
1094 insn
->op
= BYTECODE_OP_CAST_NOP
;
1097 insn
->op
= BYTECODE_OP_CAST_DOUBLE_TO_S64
;
1101 vstack_ax(stack
)->type
= REG_S64
;
1102 next_pc
+= sizeof(struct cast_op
);
1105 case BYTECODE_OP_CAST_DOUBLE_TO_S64
:
1108 vstack_ax(stack
)->type
= REG_S64
;
1109 next_pc
+= sizeof(struct cast_op
);
1112 case BYTECODE_OP_CAST_NOP
:
1114 next_pc
+= sizeof(struct cast_op
);
1119 * Instructions for recursive traversal through composed types.
1121 case BYTECODE_OP_GET_CONTEXT_ROOT
:
1123 if (vstack_push(stack
)) {
1127 vstack_ax(stack
)->type
= REG_PTR
;
1128 vstack_ax(stack
)->load
.type
= LOAD_ROOT_CONTEXT
;
1129 next_pc
+= sizeof(struct load_op
);
1132 case BYTECODE_OP_GET_APP_CONTEXT_ROOT
:
1134 if (vstack_push(stack
)) {
1138 vstack_ax(stack
)->type
= REG_PTR
;
1139 vstack_ax(stack
)->load
.type
= LOAD_ROOT_APP_CONTEXT
;
1140 next_pc
+= sizeof(struct load_op
);
1143 case BYTECODE_OP_GET_PAYLOAD_ROOT
:
1145 if (vstack_push(stack
)) {
1149 vstack_ax(stack
)->type
= REG_PTR
;
1150 vstack_ax(stack
)->load
.type
= LOAD_ROOT_PAYLOAD
;
1151 next_pc
+= sizeof(struct load_op
);
1155 case BYTECODE_OP_LOAD_FIELD
:
1157 struct load_op
*insn
= (struct load_op
*) pc
;
1159 WARN_ON_ONCE(vstack_ax(stack
)->type
!= REG_PTR
);
1161 ret
= specialize_load_field(vstack_ax(stack
), insn
);
1165 next_pc
+= sizeof(struct load_op
);
1169 case BYTECODE_OP_LOAD_FIELD_S8
:
1170 case BYTECODE_OP_LOAD_FIELD_S16
:
1171 case BYTECODE_OP_LOAD_FIELD_S32
:
1172 case BYTECODE_OP_LOAD_FIELD_S64
:
1173 case BYTECODE_OP_LOAD_FIELD_U8
:
1174 case BYTECODE_OP_LOAD_FIELD_U16
:
1175 case BYTECODE_OP_LOAD_FIELD_U32
:
1176 case BYTECODE_OP_LOAD_FIELD_U64
:
1179 vstack_ax(stack
)->type
= REG_S64
;
1180 next_pc
+= sizeof(struct load_op
);
1184 case BYTECODE_OP_LOAD_FIELD_STRING
:
1185 case BYTECODE_OP_LOAD_FIELD_SEQUENCE
:
1188 vstack_ax(stack
)->type
= REG_STRING
;
1189 next_pc
+= sizeof(struct load_op
);
1193 case BYTECODE_OP_LOAD_FIELD_DOUBLE
:
1196 vstack_ax(stack
)->type
= REG_DOUBLE
;
1197 next_pc
+= sizeof(struct load_op
);
1201 case BYTECODE_OP_GET_SYMBOL
:
1203 struct load_op
*insn
= (struct load_op
*) pc
;
1205 dbg_printk("op get symbol\n");
1206 switch (vstack_ax(stack
)->load
.type
) {
1208 printk(KERN_WARNING
"LTTng: bytecode: Nested fields not implemented yet.\n");
1211 case LOAD_ROOT_CONTEXT
:
1212 /* Lookup context field. */
1213 ret
= specialize_context_lookup(ctx
, bytecode
, insn
,
1214 &vstack_ax(stack
)->load
);
1218 case LOAD_ROOT_APP_CONTEXT
:
1221 case LOAD_ROOT_PAYLOAD
:
1222 /* Lookup event payload field. */
1223 ret
= specialize_payload_lookup(event_desc
,
1225 &vstack_ax(stack
)->load
);
1230 next_pc
+= sizeof(struct load_op
) + sizeof(struct get_symbol
);
1234 case BYTECODE_OP_GET_SYMBOL_FIELD
:
1236 /* Always generated by specialize phase. */
1241 case BYTECODE_OP_GET_INDEX_U16
:
1243 struct load_op
*insn
= (struct load_op
*) pc
;
1244 struct get_index_u16
*index
= (struct get_index_u16
*) insn
->data
;
1246 dbg_printk("op get index u16\n");
1248 ret
= specialize_get_index(bytecode
, insn
, index
->index
,
1249 vstack_ax(stack
), sizeof(*index
));
1252 next_pc
+= sizeof(struct load_op
) + sizeof(struct get_index_u16
);
1256 case BYTECODE_OP_GET_INDEX_U64
:
1258 struct load_op
*insn
= (struct load_op
*) pc
;
1259 struct get_index_u64
*index
= (struct get_index_u64
*) insn
->data
;
1261 dbg_printk("op get index u64\n");
1263 ret
= specialize_get_index(bytecode
, insn
, index
->index
,
1264 vstack_ax(stack
), sizeof(*index
));
1267 next_pc
+= sizeof(struct load_op
) + sizeof(struct get_index_u64
);