projects / lttng-modules.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Introduce struct lttng_kernel_tracepoint_class, enum probe_desc field
[lttng-modules.git] / src / lttng-bytecode-specialize.c
CommitLineData
9f36eaed
MJ		 1/* SPDX-License-Identifier: MIT
2 *
80c2a69a 3 * lttng-bytecode-specialize.c
07dfc1d0 4 *
80c2a69a 5 * LTTng modules bytecode code specializer.
07dfc1d0 6 *
bbf3aef5 7 * Copyright (C) 2010-2016 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
07dfc1d0
MD		 8 */
9
3834b99f 10#include <linux/slab.h>
80c2a69a 11#include <lttng/lttng-bytecode.h>
a071f25d 12#include <lttng/align.h>
437d5aa5 13#include <lttng/events-internal.h>
07dfc1d0 14
3834b99f
MD		 15static ssize_t bytecode_reserve_data(struct bytecode_runtime *runtime,
16 size_t align, size_t len)
17{
18 ssize_t ret;
19 size_t padding = offset_align(runtime->data_len, align);
20 size_t new_len = runtime->data_len + padding + len;
21 size_t new_alloc_len = new_len;
22 size_t old_alloc_len = runtime->data_alloc_len;
23
80c2a69a 24 if (new_len > INTERPRETER_MAX_DATA_LEN)
3834b99f
MD		 25 return -EINVAL;
26
27 if (new_alloc_len > old_alloc_len) {
28 char *newptr;
29
30 new_alloc_len =
31 max_t(size_t, 1U << get_count_order(new_alloc_len), old_alloc_len << 1);
32 newptr = krealloc(runtime->data, new_alloc_len, GFP_KERNEL);
33 if (!newptr)
34 return -ENOMEM;
35 runtime->data = newptr;
36 /* We zero directly the memory from start of allocation. */
37 memset(&runtime->data[old_alloc_len], 0, new_alloc_len - old_alloc_len);
38 runtime->data_alloc_len = new_alloc_len;
39 }
40 runtime->data_len += padding;
41 ret = runtime->data_len;
42 runtime->data_len += len;
43 return ret;
44}
45
46static ssize_t bytecode_push_data(struct bytecode_runtime *runtime,
47 const void *p, size_t align, size_t len)
48{
49 ssize_t offset;
50
51 offset = bytecode_reserve_data(runtime, align, len);
52 if (offset < 0)
53 return -ENOMEM;
54 memcpy(&runtime->data[offset], p, len);
55 return offset;
56}
57
58static int specialize_load_field(struct vstack_entry *stack_top,
59 struct load_op *insn)
60{
61 int ret;
62
63 switch (stack_top->load.type) {
64 case LOAD_OBJECT:
65 break;
66 case LOAD_ROOT_CONTEXT:
67 case LOAD_ROOT_APP_CONTEXT:
68 case LOAD_ROOT_PAYLOAD:
69 default:
80c2a69a 70 dbg_printk("Bytecode warning: cannot load root, missing field name.\n");
3834b99f
MD		 71 ret = -EINVAL;
72 goto end;
73 }
74 switch (stack_top->load.object_type) {
75 case OBJECT_TYPE_S8:
76 dbg_printk("op load field s8\n");
77 stack_top->type = REG_S64;
78 if (!stack_top->load.rev_bo)
80c2a69a 79 insn->op = BYTECODE_OP_LOAD_FIELD_S8;
3834b99f
MD		 80 break;
81 case OBJECT_TYPE_S16:
82 dbg_printk("op load field s16\n");
83 stack_top->type = REG_S64;
84 if (!stack_top->load.rev_bo)
80c2a69a 85 insn->op = BYTECODE_OP_LOAD_FIELD_S16;
3834b99f
MD		 86 break;
87 case OBJECT_TYPE_S32:
88 dbg_printk("op load field s32\n");
89 stack_top->type = REG_S64;
90 if (!stack_top->load.rev_bo)
80c2a69a 91 insn->op = BYTECODE_OP_LOAD_FIELD_S32;
3834b99f
MD		 92 break;
93 case OBJECT_TYPE_S64:
94 dbg_printk("op load field s64\n");
95 stack_top->type = REG_S64;
96 if (!stack_top->load.rev_bo)
80c2a69a 97 insn->op = BYTECODE_OP_LOAD_FIELD_S64;
3834b99f 98 break;
29a574c3
FD		 99 case OBJECT_TYPE_SIGNED_ENUM:
100 dbg_printk("op load field signed enumeration\n");
101 stack_top->type = REG_PTR;
102 break;
3834b99f
MD		 103 case OBJECT_TYPE_U8:
104 dbg_printk("op load field u8\n");
105 stack_top->type = REG_S64;
80c2a69a 106 insn->op = BYTECODE_OP_LOAD_FIELD_U8;
3834b99f
MD		 107 break;
108 case OBJECT_TYPE_U16:
109 dbg_printk("op load field u16\n");
110 stack_top->type = REG_S64;
111 if (!stack_top->load.rev_bo)
80c2a69a 112 insn->op = BYTECODE_OP_LOAD_FIELD_U16;
3834b99f
MD		 113 break;
114 case OBJECT_TYPE_U32:
115 dbg_printk("op load field u32\n");
116 stack_top->type = REG_S64;
117 if (!stack_top->load.rev_bo)
80c2a69a 118 insn->op = BYTECODE_OP_LOAD_FIELD_U32;
3834b99f
MD		 119 break;
120 case OBJECT_TYPE_U64:
121 dbg_printk("op load field u64\n");
122 stack_top->type = REG_S64;
123 if (!stack_top->load.rev_bo)
80c2a69a 124 insn->op = BYTECODE_OP_LOAD_FIELD_U64;
3834b99f 125 break;
29a574c3
FD		 126 case OBJECT_TYPE_UNSIGNED_ENUM:
127 dbg_printk("op load field unsigned enumeration\n");
128 stack_top->type = REG_PTR;
129 break;
3834b99f 130 case OBJECT_TYPE_DOUBLE:
80c2a69a 131 printk(KERN_WARNING "LTTng: bytecode: Double type unsupported\n\n");
3834b99f
MD		 132 ret = -EINVAL;
133 goto end;
134 case OBJECT_TYPE_STRING:
135 dbg_printk("op load field string\n");
136 stack_top->type = REG_STRING;
80c2a69a 137 insn->op = BYTECODE_OP_LOAD_FIELD_STRING;
3834b99f
MD		 138 break;
139 case OBJECT_TYPE_STRING_SEQUENCE:
140 dbg_printk("op load field string sequence\n");
141 stack_top->type = REG_STRING;
80c2a69a 142 insn->op = BYTECODE_OP_LOAD_FIELD_SEQUENCE;
3834b99f
MD		 143 break;
144 case OBJECT_TYPE_DYNAMIC:
145 ret = -EINVAL;
146 goto end;
147 case OBJECT_TYPE_SEQUENCE:
148 case OBJECT_TYPE_ARRAY:
149 case OBJECT_TYPE_STRUCT:
150 case OBJECT_TYPE_VARIANT:
80c2a69a 151 printk(KERN_WARNING "LTTng: bytecode: Sequences, arrays, struct and variant cannot be loaded (nested types).\n");
3834b99f
MD		 152 ret = -EINVAL;
153 goto end;
154 }
155 return 0;
156
157end:
158 return ret;
159}
160
161static int specialize_get_index_object_type(enum object_type *otype,
162 int signedness, uint32_t elem_len)
163{
164 switch (elem_len) {
165 case 8:
166 if (signedness)
167 *otype = OBJECT_TYPE_S8;
168 else
169 *otype = OBJECT_TYPE_U8;
170 break;
171 case 16:
172 if (signedness)
173 *otype = OBJECT_TYPE_S16;
174 else
175 *otype = OBJECT_TYPE_U16;
176 break;
177 case 32:
178 if (signedness)
179 *otype = OBJECT_TYPE_S32;
180 else
181 *otype = OBJECT_TYPE_U32;
182 break;
183 case 64:
184 if (signedness)
185 *otype = OBJECT_TYPE_S64;
186 else
187 *otype = OBJECT_TYPE_U64;
188 break;
189 default:
190 return -EINVAL;
191 }
192 return 0;
193}
194
195static int specialize_get_index(struct bytecode_runtime *runtime,
196 struct load_op *insn, uint64_t index,
197 struct vstack_entry *stack_top,
198 int idx_len)
199{
200 int ret;
80c2a69a 201 struct bytecode_get_index_data gid;
3834b99f
MD		 202 ssize_t data_offset;
203
204 memset(&gid, 0, sizeof(gid));
205 switch (stack_top->load.type) {
206 case LOAD_OBJECT:
207 switch (stack_top->load.object_type) {
208 case OBJECT_TYPE_ARRAY:
209 {
437d5aa5
MD		 210 const struct lttng_kernel_event_field *field;
211 const struct lttng_kernel_type_array *array_type;
212 const struct lttng_kernel_type_integer *integer_type;
3834b99f
MD		 213 uint32_t elem_len, num_elems;
214 int signedness;
215
216 field = stack_top->load.field;
437d5aa5
MD		 217 array_type = lttng_kernel_get_type_array(field->type);
218 if (!lttng_kernel_type_is_bytewise_integer(array_type->elem_type)) {
ceabb767
MD		 219 ret = -EINVAL;
220 goto end;
221 }
437d5aa5
MD		 222 integer_type = lttng_kernel_get_type_integer(array_type->elem_type);
223 num_elems = array_type->length;
ceabb767
MD		 224 elem_len = integer_type->size;
225 signedness = integer_type->signedness;
3834b99f
MD		 226 if (index >= num_elems) {
227 ret = -EINVAL;
228 goto end;
229 }
230 ret = specialize_get_index_object_type(&stack_top->load.object_type,
231 signedness, elem_len);
232 if (ret)
233 goto end;
234 gid.offset = index * (elem_len / CHAR_BIT);
235 gid.array_len = num_elems * (elem_len / CHAR_BIT);
236 gid.elem.type = stack_top->load.object_type;
237 gid.elem.len = elem_len;
ceabb767 238 if (integer_type->reverse_byte_order)
3834b99f
MD		 239 gid.elem.rev_bo = true;
240 stack_top->load.rev_bo = gid.elem.rev_bo;
241 break;
242 }
243 case OBJECT_TYPE_SEQUENCE:
244 {
437d5aa5
MD		 245 const struct lttng_kernel_event_field *field;
246 const struct lttng_kernel_type_sequence *sequence_type;
247 const struct lttng_kernel_type_integer *integer_type;
3834b99f
MD		 248 uint32_t elem_len;
249 int signedness;
250
251 field = stack_top->load.field;
437d5aa5
MD		 252 sequence_type = lttng_kernel_get_type_sequence(field->type);
253 if (!lttng_kernel_type_is_bytewise_integer(sequence_type->elem_type)) {
ceabb767
MD		 254 ret = -EINVAL;
255 goto end;
256 }
437d5aa5 257 integer_type = lttng_kernel_get_type_integer(sequence_type->elem_type);
ceabb767
MD		 258 elem_len = integer_type->size;
259 signedness = integer_type->signedness;
3834b99f
MD		 260 ret = specialize_get_index_object_type(&stack_top->load.object_type,
261 signedness, elem_len);
262 if (ret)
263 goto end;
264 gid.offset = index * (elem_len / CHAR_BIT);
265 gid.elem.type = stack_top->load.object_type;
266 gid.elem.len = elem_len;
ceabb767 267 if (integer_type->reverse_byte_order)
3834b99f
MD		 268 gid.elem.rev_bo = true;
269 stack_top->load.rev_bo = gid.elem.rev_bo;
270 break;
271 }
272 case OBJECT_TYPE_STRUCT:
273 /* Only generated by the specialize phase. */
274 case OBJECT_TYPE_VARIANT: /* Fall-through */
275 default:
80c2a69a 276 printk(KERN_WARNING "LTTng: bytecode: Unexpected get index type %d",
3834b99f
MD		 277 (int) stack_top->load.object_type);
278 ret = -EINVAL;
279 goto end;
280 }
281 break;
282 case LOAD_ROOT_CONTEXT:
283 case LOAD_ROOT_APP_CONTEXT:
284 case LOAD_ROOT_PAYLOAD:
80c2a69a 285 printk(KERN_WARNING "LTTng: bytecode: Index lookup for root field not implemented yet.\n");
3834b99f
MD		 286 ret = -EINVAL;
287 goto end;
288 }
289 data_offset = bytecode_push_data(runtime, &gid,
290 __alignof__(gid), sizeof(gid));
291 if (data_offset < 0) {
292 ret = -EINVAL;
293 goto end;
294 }
295 switch (idx_len) {
296 case 2:
297 ((struct get_index_u16 *) insn->data)->index = data_offset;
298 break;
299 case 8:
300 ((struct get_index_u64 *) insn->data)->index = data_offset;
301 break;
302 default:
303 ret = -EINVAL;
304 goto end;
305 }
306
307 return 0;
308
309end:
310 return ret;
311}
312
437d5aa5 313static int specialize_context_lookup_name(struct lttng_kernel_ctx *ctx,
2dfda770 314 struct bytecode_runtime *bytecode,
3834b99f
MD		 315 struct load_op *insn)
316{
317 uint16_t offset;
318 const char *name;
319
320 offset = ((struct get_symbol *) insn->data)->offset;
321 name = bytecode->p.bc->bc.data + bytecode->p.bc->bc.reloc_offset + offset;
437d5aa5 322 return lttng_kernel_get_context_index(ctx, name);
3834b99f
MD		 323}
324
437d5aa5 325static int specialize_load_object(const struct lttng_kernel_event_field *field,
3834b99f
MD		 326 struct vstack_load *load, bool is_context)
327{
328 load->type = LOAD_OBJECT;
1242217a 329
437d5aa5 330 switch (field->type->type) {
12bb2edb 331 case lttng_kernel_type_integer:
437d5aa5 332 if (lttng_kernel_get_type_integer(field->type)->signedness)
3834b99f
MD		 333 load->object_type = OBJECT_TYPE_S64;
334 else
335 load->object_type = OBJECT_TYPE_U64;
336 load->rev_bo = false;
337 break;
437d5aa5 338 case lttng_kernel_type_enum:
3834b99f 339 {
437d5aa5
MD		 340 const struct lttng_kernel_type_enum *enum_type = lttng_kernel_get_type_enum(field->type);
341 const struct lttng_kernel_type_integer *integer_type = lttng_kernel_get_type_integer(enum_type->container_type);
3834b99f 342
437d5aa5 343 if (integer_type->signedness)
29a574c3 344 load->object_type = OBJECT_TYPE_SIGNED_ENUM;
3834b99f 345 else
29a574c3 346 load->object_type = OBJECT_TYPE_UNSIGNED_ENUM;
3834b99f
MD		 347 load->rev_bo = false;
348 break;
349 }
437d5aa5
MD		 350 case lttng_kernel_type_array:
351 {
352 const struct lttng_kernel_type_array *array_type = lttng_kernel_get_type_array(field->type);
353
354 if (!lttng_kernel_type_is_bytewise_integer(array_type->elem_type)) {
80c2a69a 355 printk(KERN_WARNING "LTTng: bytecode: Array nesting only supports integer types.\n");
3834b99f
MD		 356 return -EINVAL;
357 }
358 if (is_context) {
359 load->object_type = OBJECT_TYPE_STRING;
360 } else {
437d5aa5 361 if (array_type->encoding == lttng_kernel_string_encoding_none) {
3834b99f
MD		 362 load->object_type = OBJECT_TYPE_ARRAY;
363 load->field = field;
364 } else {
365 load->object_type = OBJECT_TYPE_STRING_SEQUENCE;
366 }
367 }
368 break;
437d5aa5
MD		 369 }
370 case lttng_kernel_type_sequence:
371 {
372 const struct lttng_kernel_type_sequence *sequence_type = lttng_kernel_get_type_sequence(field->type);
373
374 if (!lttng_kernel_type_is_bytewise_integer(sequence_type->elem_type)) {
80c2a69a 375 printk(KERN_WARNING "LTTng: bytecode: Sequence nesting only supports integer types.\n");
3834b99f
MD		 376 return -EINVAL;
377 }
378 if (is_context) {
379 load->object_type = OBJECT_TYPE_STRING;
380 } else {
437d5aa5 381 if (sequence_type->encoding == lttng_kernel_string_encoding_none) {
3834b99f
MD		 382 load->object_type = OBJECT_TYPE_SEQUENCE;
383 load->field = field;
384 } else {
385 load->object_type = OBJECT_TYPE_STRING_SEQUENCE;
386 }
387 }
388 break;
437d5aa5 389 }
12bb2edb 390 case lttng_kernel_type_string:
3834b99f
MD		 391 load->object_type = OBJECT_TYPE_STRING;
392 break;
437d5aa5 393 case lttng_kernel_type_struct:
80c2a69a 394 printk(KERN_WARNING "LTTng: bytecode: Structure type cannot be loaded.\n");
3834b99f 395 return -EINVAL;
437d5aa5 396 case lttng_kernel_type_variant:
80c2a69a 397 printk(KERN_WARNING "LTTng: bytecode: Variant type cannot be loaded.\n");
ceabb767 398 return -EINVAL;
3834b99f 399 default:
437d5aa5 400 printk(KERN_WARNING "LTTng: bytecode: Unknown type: %d", (int) field->type->type);
3834b99f
MD		 401 return -EINVAL;
402 }
403 return 0;
404}
405
437d5aa5 406static int specialize_context_lookup(struct lttng_kernel_ctx *ctx,
2dfda770 407 struct bytecode_runtime *runtime,
3834b99f
MD		 408 struct load_op *insn,
409 struct vstack_load *load)
410{
411 int idx, ret;
437d5aa5
MD		 412 const struct lttng_kernel_ctx_field *ctx_field;
413 const struct lttng_kernel_event_field *field;
80c2a69a 414 struct bytecode_get_index_data gid;
3834b99f
MD		 415 ssize_t data_offset;
416
2dfda770 417 idx = specialize_context_lookup_name(ctx, runtime, insn);
3834b99f
MD		 418 if (idx < 0) {
419 return -ENOENT;
420 }
421 ctx_field = &lttng_static_ctx->fields[idx];
437d5aa5 422 field = ctx_field->event_field;
3834b99f
MD		 423 ret = specialize_load_object(field, load, true);
424 if (ret)
425 return ret;
426 /* Specialize each get_symbol into a get_index. */
80c2a69a 427 insn->op = BYTECODE_OP_GET_INDEX_U16;
3834b99f
MD		 428 memset(&gid, 0, sizeof(gid));
429 gid.ctx_index = idx;
430 gid.elem.type = load->object_type;
60e8b0d6 431 gid.elem.rev_bo = load->rev_bo;
03cb0cdd 432 gid.field = field;
3834b99f
MD		 433 data_offset = bytecode_push_data(runtime, &gid,
434 __alignof__(gid), sizeof(gid));
435 if (data_offset < 0) {
436 return -EINVAL;
437 }
438 ((struct get_index_u16 *) insn->data)->index = data_offset;
439 return 0;
440}
441
437d5aa5 442static int specialize_payload_lookup(const struct lttng_kernel_event_desc *event_desc,
3834b99f
MD		 443 struct bytecode_runtime *runtime,
444 struct load_op *insn,
445 struct vstack_load *load)
446{
447 const char *name;
448 uint16_t offset;
3834b99f
MD		 449 unsigned int i, nr_fields;
450 bool found = false;
451 uint32_t field_offset = 0;
437d5aa5 452 const struct lttng_kernel_event_field *field;
3834b99f 453 int ret;
80c2a69a 454 struct bytecode_get_index_data gid;
3834b99f
MD		 455 ssize_t data_offset;
456
6c8c025b 457 nr_fields = event_desc->tp_class->nr_fields;
3834b99f
MD		 458 offset = ((struct get_symbol *) insn->data)->offset;
459 name = runtime->p.bc->bc.data + runtime->p.bc->bc.reloc_offset + offset;
460 for (i = 0; i < nr_fields; i++) {
6c8c025b 461 field = event_desc->tp_class->fields[i];
ceabb767
MD		 462 if (field->nofilter) {
463 continue;
464 }
3834b99f
MD		 465 if (!strcmp(field->name, name)) {
466 found = true;
467 break;
468 }
469 /* compute field offset on stack */
437d5aa5 470 switch (field->type->type) {
12bb2edb 471 case lttng_kernel_type_integer:
437d5aa5 472 case lttng_kernel_type_enum:
3834b99f
MD		 473 field_offset += sizeof(int64_t);
474 break;
437d5aa5
MD		 475 case lttng_kernel_type_array:
476 case lttng_kernel_type_sequence:
3834b99f
MD		 477 field_offset += sizeof(unsigned long);
478 field_offset += sizeof(void *);
479 break;
12bb2edb 480 case lttng_kernel_type_string:
3834b99f
MD		 481 field_offset += sizeof(void *);
482 break;
483 default:
484 ret = -EINVAL;
485 goto end;
486 }
487 }
488 if (!found) {
489 ret = -EINVAL;
490 goto end;
491 }
492
493 ret = specialize_load_object(field, load, false);
494 if (ret)
495 goto end;
496
497 /* Specialize each get_symbol into a get_index. */
80c2a69a 498 insn->op = BYTECODE_OP_GET_INDEX_U16;
3834b99f
MD		 499 memset(&gid, 0, sizeof(gid));
500 gid.offset = field_offset;
501 gid.elem.type = load->object_type;
60e8b0d6 502 gid.elem.rev_bo = load->rev_bo;
03cb0cdd 503 gid.field = field;
3834b99f
MD		 504 data_offset = bytecode_push_data(runtime, &gid,
505 __alignof__(gid), sizeof(gid));
506 if (data_offset < 0) {
507 ret = -EINVAL;
508 goto end;
509 }
510 ((struct get_index_u16 *) insn->data)->index = data_offset;
511 ret = 0;
512end:
513 return ret;
514}
515
437d5aa5 516int lttng_bytecode_specialize(const struct lttng_kernel_event_desc *event_desc,
3834b99f 517 struct bytecode_runtime *bytecode)
07dfc1d0
MD		 518{
519 void *pc, *next_pc, *start_pc;
520 int ret = -EINVAL;
521 struct vstack _stack;
522 struct vstack *stack = &_stack;
437d5aa5 523 struct lttng_kernel_ctx *ctx = bytecode->p.ctx;
07dfc1d0
MD		 524
525 vstack_init(stack);
526
3834b99f 527 start_pc = &bytecode->code[0];
07dfc1d0
MD		 528 for (pc = next_pc = start_pc; pc - start_pc < bytecode->len;
529 pc = next_pc) {
80c2a69a
FD		 530 switch (*(bytecode_opcode_t *) pc) {
531 case BYTECODE_OP_UNKNOWN:
07dfc1d0 532 default:
80c2a69a
FD		 533 printk(KERN_WARNING "LTTng: bytecode: unknown bytecode op %u\n",
534 (unsigned int) *(bytecode_opcode_t *) pc);
07dfc1d0
MD		 535 ret = -EINVAL;
536 goto end;
537
80c2a69a
FD		 538 case BYTECODE_OP_RETURN:
539 case BYTECODE_OP_RETURN_S64:
07dfc1d0
MD		 540 ret = 0;
541 goto end;
542
543 /* binary */
80c2a69a
FD		 544 case BYTECODE_OP_MUL:
545 case BYTECODE_OP_DIV:
546 case BYTECODE_OP_MOD:
547 case BYTECODE_OP_PLUS:
548 case BYTECODE_OP_MINUS:
549 printk(KERN_WARNING "LTTng: bytecode: unknown bytecode op %u\n",
550 (unsigned int) *(bytecode_opcode_t *) pc);
07dfc1d0
MD		 551 ret = -EINVAL;
552 goto end;
553
80c2a69a 554 case BYTECODE_OP_EQ:
07dfc1d0
MD		 555 {
556 struct binary_op *insn = (struct binary_op *) pc;
557
558 switch(vstack_ax(stack)->type) {
559 default:
80c2a69a 560 printk(KERN_WARNING "LTTng: bytecode: unknown register type\n");
07dfc1d0
MD		 561 ret = -EINVAL;
562 goto end;
563
564 case REG_STRING:
02aca193 565 if (vstack_bx(stack)->type == REG_STAR_GLOB_STRING)
80c2a69a 566 insn->op = BYTECODE_OP_EQ_STAR_GLOB_STRING;
02aca193 567 else
80c2a69a 568 insn->op = BYTECODE_OP_EQ_STRING;
02aca193
PP		 569 break;
570 case REG_STAR_GLOB_STRING:
80c2a69a 571 insn->op = BYTECODE_OP_EQ_STAR_GLOB_STRING;
07dfc1d0
MD		 572 break;
573 case REG_S64:
574 if (vstack_bx(stack)->type == REG_S64)
80c2a69a 575 insn->op = BYTECODE_OP_EQ_S64;
07dfc1d0 576 else
80c2a69a 577 insn->op = BYTECODE_OP_EQ_DOUBLE_S64;
07dfc1d0
MD		 578 break;
579 case REG_DOUBLE:
580 if (vstack_bx(stack)->type == REG_S64)
80c2a69a 581 insn->op = BYTECODE_OP_EQ_S64_DOUBLE;
07dfc1d0 582 else
80c2a69a 583 insn->op = BYTECODE_OP_EQ_DOUBLE;
07dfc1d0
MD		 584 break;
585 }
586 /* Pop 2, push 1 */
587 if (vstack_pop(stack)) {
588 ret = -EINVAL;
589 goto end;
590 }
591 vstack_ax(stack)->type = REG_S64;
592 next_pc += sizeof(struct binary_op);
593 break;
594 }
595
80c2a69a 596 case BYTECODE_OP_NE:
07dfc1d0
MD		 597 {
598 struct binary_op *insn = (struct binary_op *) pc;
599
600 switch(vstack_ax(stack)->type) {
601 default:
80c2a69a 602 printk(KERN_WARNING "LTTng: bytecode: unknown register type\n");
07dfc1d0
MD		 603 ret = -EINVAL;
604 goto end;
605
606 case REG_STRING:
02aca193 607 if (vstack_bx(stack)->type == REG_STAR_GLOB_STRING)
80c2a69a 608 insn->op = BYTECODE_OP_NE_STAR_GLOB_STRING;
02aca193 609 else
80c2a69a 610 insn->op = BYTECODE_OP_NE_STRING;
02aca193
PP		 611 break;
612 case REG_STAR_GLOB_STRING:
80c2a69a 613 insn->op = BYTECODE_OP_NE_STAR_GLOB_STRING;
07dfc1d0
MD		 614 break;
615 case REG_S64:
616 if (vstack_bx(stack)->type == REG_S64)
80c2a69a 617 insn->op = BYTECODE_OP_NE_S64;
07dfc1d0 618 else
80c2a69a 619 insn->op = BYTECODE_OP_NE_DOUBLE_S64;
07dfc1d0
MD		 620 break;
621 case REG_DOUBLE:
622 if (vstack_bx(stack)->type == REG_S64)
80c2a69a 623 insn->op = BYTECODE_OP_NE_S64_DOUBLE;
07dfc1d0 624 else
80c2a69a 625 insn->op = BYTECODE_OP_NE_DOUBLE;
07dfc1d0
MD		 626 break;
627 }
628 /* Pop 2, push 1 */
629 if (vstack_pop(stack)) {
630 ret = -EINVAL;
631 goto end;
632 }
633 vstack_ax(stack)->type = REG_S64;
634 next_pc += sizeof(struct binary_op);
635 break;
636 }
637
80c2a69a 638 case BYTECODE_OP_GT:
07dfc1d0
MD		 639 {
640 struct binary_op *insn = (struct binary_op *) pc;
641
642 switch(vstack_ax(stack)->type) {
643 default:
80c2a69a 644 printk(KERN_WARNING "LTTng: bytecode: unknown register type\n");
07dfc1d0
MD		 645 ret = -EINVAL;
646 goto end;
647
02aca193 648 case REG_STAR_GLOB_STRING:
80c2a69a 649 printk(KERN_WARNING "LTTng: bytecode: invalid register type for '>' binary operator\n");
02aca193
PP		 650 ret = -EINVAL;
651 goto end;
07dfc1d0 652 case REG_STRING:
80c2a69a 653 insn->op = BYTECODE_OP_GT_STRING;
07dfc1d0
MD		 654 break;
655 case REG_S64:
656 if (vstack_bx(stack)->type == REG_S64)
80c2a69a 657 insn->op = BYTECODE_OP_GT_S64;
07dfc1d0 658 else
80c2a69a 659 insn->op = BYTECODE_OP_GT_DOUBLE_S64;
07dfc1d0
MD		 660 break;
661 case REG_DOUBLE:
662 if (vstack_bx(stack)->type == REG_S64)
80c2a69a 663 insn->op = BYTECODE_OP_GT_S64_DOUBLE;
07dfc1d0 664 else
80c2a69a 665 insn->op = BYTECODE_OP_GT_DOUBLE;
07dfc1d0
MD		 666 break;
667 }
668 /* Pop 2, push 1 */
669 if (vstack_pop(stack)) {
670 ret = -EINVAL;
671 goto end;
672 }
673 vstack_ax(stack)->type = REG_S64;
674 next_pc += sizeof(struct binary_op);
675 break;
676 }
677
80c2a69a 678 case BYTECODE_OP_LT:
07dfc1d0
MD		 679 {
680 struct binary_op *insn = (struct binary_op *) pc;
681
682 switch(vstack_ax(stack)->type) {
683 default:
80c2a69a 684 printk(KERN_WARNING "LTTng: bytecode: unknown register type\n");
07dfc1d0
MD		 685 ret = -EINVAL;
686 goto end;
687
02aca193 688 case REG_STAR_GLOB_STRING:
80c2a69a 689 printk(KERN_WARNING "LTTng: bytecode: invalid register type for '<' binary operator\n");
02aca193
PP		 690 ret = -EINVAL;
691 goto end;
07dfc1d0 692 case REG_STRING:
80c2a69a 693 insn->op = BYTECODE_OP_LT_STRING;
07dfc1d0
MD		 694 break;
695 case REG_S64:
696 if (vstack_bx(stack)->type == REG_S64)
80c2a69a 697 insn->op = BYTECODE_OP_LT_S64;
07dfc1d0 698 else
80c2a69a 699 insn->op = BYTECODE_OP_LT_DOUBLE_S64;
07dfc1d0
MD		 700 break;
701 case REG_DOUBLE:
702 if (vstack_bx(stack)->type == REG_S64)
80c2a69a 703 insn->op = BYTECODE_OP_LT_S64_DOUBLE;
07dfc1d0 704 else
80c2a69a 705 insn->op = BYTECODE_OP_LT_DOUBLE;
07dfc1d0
MD		 706 break;
707 }
708 /* Pop 2, push 1 */
709 if (vstack_pop(stack)) {
710 ret = -EINVAL;
711 goto end;
712 }
713 vstack_ax(stack)->type = REG_S64;
714 next_pc += sizeof(struct binary_op);
715 break;
716 }
717
80c2a69a 718 case BYTECODE_OP_GE:
07dfc1d0
MD		 719 {
720 struct binary_op *insn = (struct binary_op *) pc;
721
722 switch(vstack_ax(stack)->type) {
723 default:
80c2a69a 724 printk(KERN_WARNING "LTTng: bytecode: unknown register type\n");
07dfc1d0
MD		 725 ret = -EINVAL;
726 goto end;
727
02aca193 728 case REG_STAR_GLOB_STRING:
80c2a69a 729 printk(KERN_WARNING "LTTng: bytecode: invalid register type for '>=' binary operator\n");
02aca193
PP		 730 ret = -EINVAL;
731 goto end;
07dfc1d0 732 case REG_STRING:
80c2a69a 733 insn->op = BYTECODE_OP_GE_STRING;
07dfc1d0
MD		 734 break;
735 case REG_S64:
736 if (vstack_bx(stack)->type == REG_S64)
80c2a69a 737 insn->op = BYTECODE_OP_GE_S64;
07dfc1d0 738 else
80c2a69a 739 insn->op = BYTECODE_OP_GE_DOUBLE_S64;
07dfc1d0
MD		 740 break;
741 case REG_DOUBLE:
742 if (vstack_bx(stack)->type == REG_S64)
80c2a69a 743 insn->op = BYTECODE_OP_GE_S64_DOUBLE;
07dfc1d0 744 else
80c2a69a 745 insn->op = BYTECODE_OP_GE_DOUBLE;
07dfc1d0
MD		 746 break;
747 }
748 /* Pop 2, push 1 */
749 if (vstack_pop(stack)) {
750 ret = -EINVAL;
751 goto end;
752 }
753 vstack_ax(stack)->type = REG_S64;
754 next_pc += sizeof(struct binary_op);
755 break;
756 }
80c2a69a 757 case BYTECODE_OP_LE:
07dfc1d0
MD		 758 {
759 struct binary_op *insn = (struct binary_op *) pc;
760
761 switch(vstack_ax(stack)->type) {
762 default:
80c2a69a 763 printk(KERN_WARNING "LTTng: bytecode: unknown register type\n");
07dfc1d0
MD		 764 ret = -EINVAL;
765 goto end;
766
02aca193 767 case REG_STAR_GLOB_STRING:
80c2a69a 768 printk(KERN_WARNING "LTTng: bytecode: invalid register type for '<=' binary operator\n");
02aca193
PP		 769 ret = -EINVAL;
770 goto end;
07dfc1d0 771 case REG_STRING:
80c2a69a 772 insn->op = BYTECODE_OP_LE_STRING;
07dfc1d0
MD		 773 break;
774 case REG_S64:
775 if (vstack_bx(stack)->type == REG_S64)
80c2a69a 776 insn->op = BYTECODE_OP_LE_S64;
07dfc1d0 777 else
80c2a69a 778 insn->op = BYTECODE_OP_LE_DOUBLE_S64;
07dfc1d0
MD		 779 break;
780 case REG_DOUBLE:
781 if (vstack_bx(stack)->type == REG_S64)
80c2a69a 782 insn->op = BYTECODE_OP_LE_S64_DOUBLE;
07dfc1d0 783 else
80c2a69a 784 insn->op = BYTECODE_OP_LE_DOUBLE;
07dfc1d0
MD		 785 break;
786 }
787 vstack_ax(stack)->type = REG_S64;
788 next_pc += sizeof(struct binary_op);
789 break;
790 }
791
80c2a69a
FD		 792 case BYTECODE_OP_EQ_STRING:
793 case BYTECODE_OP_NE_STRING:
794 case BYTECODE_OP_GT_STRING:
795 case BYTECODE_OP_LT_STRING:
796 case BYTECODE_OP_GE_STRING:
797 case BYTECODE_OP_LE_STRING:
798 case BYTECODE_OP_EQ_STAR_GLOB_STRING:
799 case BYTECODE_OP_NE_STAR_GLOB_STRING:
800 case BYTECODE_OP_EQ_S64:
801 case BYTECODE_OP_NE_S64:
802 case BYTECODE_OP_GT_S64:
803 case BYTECODE_OP_LT_S64:
804 case BYTECODE_OP_GE_S64:
805 case BYTECODE_OP_LE_S64:
806 case BYTECODE_OP_EQ_DOUBLE:
807 case BYTECODE_OP_NE_DOUBLE:
808 case BYTECODE_OP_GT_DOUBLE:
809 case BYTECODE_OP_LT_DOUBLE:
810 case BYTECODE_OP_GE_DOUBLE:
811 case BYTECODE_OP_LE_DOUBLE:
812 case BYTECODE_OP_EQ_DOUBLE_S64:
813 case BYTECODE_OP_NE_DOUBLE_S64:
814 case BYTECODE_OP_GT_DOUBLE_S64:
815 case BYTECODE_OP_LT_DOUBLE_S64:
816 case BYTECODE_OP_GE_DOUBLE_S64:
817 case BYTECODE_OP_LE_DOUBLE_S64:
818 case BYTECODE_OP_EQ_S64_DOUBLE:
819 case BYTECODE_OP_NE_S64_DOUBLE:
820 case BYTECODE_OP_GT_S64_DOUBLE:
821 case BYTECODE_OP_LT_S64_DOUBLE:
822 case BYTECODE_OP_GE_S64_DOUBLE:
823 case BYTECODE_OP_LE_S64_DOUBLE:
824 case BYTECODE_OP_BIT_RSHIFT:
825 case BYTECODE_OP_BIT_LSHIFT:
826 case BYTECODE_OP_BIT_AND:
827 case BYTECODE_OP_BIT_OR:
828 case BYTECODE_OP_BIT_XOR:
07dfc1d0
MD		 829 {
830 /* Pop 2, push 1 */
831 if (vstack_pop(stack)) {
832 ret = -EINVAL;
833 goto end;
834 }
835 vstack_ax(stack)->type = REG_S64;
836 next_pc += sizeof(struct binary_op);
837 break;
838 }
839
840 /* unary */
80c2a69a 841 case BYTECODE_OP_UNARY_PLUS:
07dfc1d0
MD		 842 {
843 struct unary_op *insn = (struct unary_op *) pc;
844
845 switch(vstack_ax(stack)->type) {
846 default:
80c2a69a 847 printk(KERN_WARNING "LTTng: bytecode: unknown register type\n");
07dfc1d0
MD		 848 ret = -EINVAL;
849 goto end;
850
851 case REG_S64:
80c2a69a 852 insn->op = BYTECODE_OP_UNARY_PLUS_S64;
07dfc1d0
MD		 853 break;
854 case REG_DOUBLE:
80c2a69a 855 insn->op = BYTECODE_OP_UNARY_PLUS_DOUBLE;
07dfc1d0
MD		 856 break;
857 }
858 /* Pop 1, push 1 */
859 next_pc += sizeof(struct unary_op);
860 break;
861 }
862
80c2a69a 863 case BYTECODE_OP_UNARY_MINUS:
07dfc1d0
MD		 864 {
865 struct unary_op *insn = (struct unary_op *) pc;
866
867 switch(vstack_ax(stack)->type) {
868 default:
80c2a69a 869 printk(KERN_WARNING "LTTng: bytecode: unknown register type\n");
07dfc1d0
MD		 870 ret = -EINVAL;
871 goto end;
872
873 case REG_S64:
80c2a69a 874 insn->op = BYTECODE_OP_UNARY_MINUS_S64;
07dfc1d0
MD		 875 break;
876 case REG_DOUBLE:
80c2a69a 877 insn->op = BYTECODE_OP_UNARY_MINUS_DOUBLE;
07dfc1d0
MD		 878 break;
879 }
880 /* Pop 1, push 1 */
881 next_pc += sizeof(struct unary_op);
882 break;
883 }
884
80c2a69a 885 case BYTECODE_OP_UNARY_NOT:
07dfc1d0
MD		 886 {
887 struct unary_op *insn = (struct unary_op *) pc;
888
889 switch(vstack_ax(stack)->type) {
890 default:
80c2a69a 891 printk(KERN_WARNING "LTTng: bytecode: unknown register type\n");
07dfc1d0
MD		 892 ret = -EINVAL;
893 goto end;
894
895 case REG_S64:
80c2a69a 896 insn->op = BYTECODE_OP_UNARY_NOT_S64;
07dfc1d0
MD		 897 break;
898 case REG_DOUBLE:
80c2a69a 899 insn->op = BYTECODE_OP_UNARY_NOT_DOUBLE;
07dfc1d0
MD		 900 break;
901 }
902 /* Pop 1, push 1 */
903 next_pc += sizeof(struct unary_op);
904 break;
905 }
906
80c2a69a 907 case BYTECODE_OP_UNARY_BIT_NOT:
e16c054b
MD		 908 {
909 /* Pop 1, push 1 */
910 next_pc += sizeof(struct unary_op);
911 break;
912 }
913
80c2a69a
FD		 914 case BYTECODE_OP_UNARY_PLUS_S64:
915 case BYTECODE_OP_UNARY_MINUS_S64:
916 case BYTECODE_OP_UNARY_NOT_S64:
917 case BYTECODE_OP_UNARY_PLUS_DOUBLE:
918 case BYTECODE_OP_UNARY_MINUS_DOUBLE:
919 case BYTECODE_OP_UNARY_NOT_DOUBLE:
07dfc1d0
MD		 920 {
921 /* Pop 1, push 1 */
922 next_pc += sizeof(struct unary_op);
923 break;
924 }
925
926 /* logical */
80c2a69a
FD		 927 case BYTECODE_OP_AND:
928 case BYTECODE_OP_OR:
07dfc1d0
MD		 929 {
930 /* Continue to next instruction */
931 /* Pop 1 when jump not taken */
932 if (vstack_pop(stack)) {
933 ret = -EINVAL;
934 goto end;
935 }
936 next_pc += sizeof(struct logical_op);
937 break;
938 }
939
940 /* load field ref */
80c2a69a 941 case BYTECODE_OP_LOAD_FIELD_REF:
07dfc1d0 942 {
80c2a69a 943 printk(KERN_WARNING "LTTng: bytecode: Unknown field ref type\n");
07dfc1d0
MD		 944 ret = -EINVAL;
945 goto end;
946 }
947 /* get context ref */
80c2a69a 948 case BYTECODE_OP_GET_CONTEXT_REF:
07dfc1d0 949 {
80c2a69a 950 printk(KERN_WARNING "LTTng: bytecode: Unknown get context ref type\n");
07dfc1d0
MD		 951 ret = -EINVAL;
952 goto end;
953 }
80c2a69a
FD		 954 case BYTECODE_OP_LOAD_FIELD_REF_STRING:
955 case BYTECODE_OP_LOAD_FIELD_REF_SEQUENCE:
956 case BYTECODE_OP_GET_CONTEXT_REF_STRING:
957 case BYTECODE_OP_LOAD_FIELD_REF_USER_STRING:
958 case BYTECODE_OP_LOAD_FIELD_REF_USER_SEQUENCE:
07dfc1d0
MD		 959 {
960 if (vstack_push(stack)) {
961 ret = -EINVAL;
962 goto end;
963 }
964 vstack_ax(stack)->type = REG_STRING;
965 next_pc += sizeof(struct load_op) + sizeof(struct field_ref);
966 break;
967 }
80c2a69a
FD		 968 case BYTECODE_OP_LOAD_FIELD_REF_S64:
969 case BYTECODE_OP_GET_CONTEXT_REF_S64:
07dfc1d0
MD		 970 {
971 if (vstack_push(stack)) {
972 ret = -EINVAL;
973 goto end;
974 }
975 vstack_ax(stack)->type = REG_S64;
976 next_pc += sizeof(struct load_op) + sizeof(struct field_ref);
977 break;
978 }
80c2a69a
FD		 979 case BYTECODE_OP_LOAD_FIELD_REF_DOUBLE:
980 case BYTECODE_OP_GET_CONTEXT_REF_DOUBLE:
07dfc1d0
MD		 981 {
982 if (vstack_push(stack)) {
983 ret = -EINVAL;
984 goto end;
985 }
986 vstack_ax(stack)->type = REG_DOUBLE;
987 next_pc += sizeof(struct load_op) + sizeof(struct field_ref);
988 break;
989 }
990
991 /* load from immediate operand */
80c2a69a 992 case BYTECODE_OP_LOAD_STRING:
07dfc1d0
MD		 993 {
994 struct load_op *insn = (struct load_op *) pc;
995
996 if (vstack_push(stack)) {
997 ret = -EINVAL;
998 goto end;
999 }
1000 vstack_ax(stack)->type = REG_STRING;
1001 next_pc += sizeof(struct load_op) + strlen(insn->data) + 1;
1002 break;
1003 }
1004
80c2a69a 1005 case BYTECODE_OP_LOAD_STAR_GLOB_STRING:
02aca193
PP		 1006 {
1007 struct load_op *insn = (struct load_op *) pc;
1008
1009 if (vstack_push(stack)) {
1010 ret = -EINVAL;
1011 goto end;
1012 }
1013 vstack_ax(stack)->type = REG_STAR_GLOB_STRING;
1014 next_pc += sizeof(struct load_op) + strlen(insn->data) + 1;
1015 break;
1016 }
1017
80c2a69a 1018 case BYTECODE_OP_LOAD_S64:
07dfc1d0
MD		 1019 {
1020 if (vstack_push(stack)) {
1021 ret = -EINVAL;
1022 goto end;
1023 }
1024 vstack_ax(stack)->type = REG_S64;
1025 next_pc += sizeof(struct load_op)
1026 + sizeof(struct literal_numeric);
1027 break;
1028 }
1029
80c2a69a 1030 case BYTECODE_OP_LOAD_DOUBLE:
07dfc1d0
MD		 1031 {
1032 if (vstack_push(stack)) {
1033 ret = -EINVAL;
1034 goto end;
1035 }
1036 vstack_ax(stack)->type = REG_DOUBLE;
1037 next_pc += sizeof(struct load_op)
1038 + sizeof(struct literal_double);
1039 break;
1040 }
1041
1042 /* cast */
80c2a69a 1043 case BYTECODE_OP_CAST_TO_S64:
07dfc1d0
MD		 1044 {
1045 struct cast_op *insn = (struct cast_op *) pc;
1046
1047 switch (vstack_ax(stack)->type) {
1048 default:
80c2a69a 1049 printk(KERN_WARNING "LTTng: bytecode: unknown register type\n");
07dfc1d0
MD		 1050 ret = -EINVAL;
1051 goto end;
1052
1053 case REG_STRING:
02aca193 1054 case REG_STAR_GLOB_STRING:
80c2a69a 1055 printk(KERN_WARNING "LTTng: bytecode: Cast op can only be applied to numeric or floating point registers\n");
07dfc1d0
MD		 1056 ret = -EINVAL;
1057 goto end;
1058 case REG_S64:
80c2a69a 1059 insn->op = BYTECODE_OP_CAST_NOP;
07dfc1d0
MD		 1060 break;
1061 case REG_DOUBLE:
80c2a69a 1062 insn->op = BYTECODE_OP_CAST_DOUBLE_TO_S64;
07dfc1d0
MD		 1063 break;
1064 }
1065 /* Pop 1, push 1 */
1066 vstack_ax(stack)->type = REG_S64;
1067 next_pc += sizeof(struct cast_op);
1068 break;
1069 }
80c2a69a 1070 case BYTECODE_OP_CAST_DOUBLE_TO_S64:
07dfc1d0
MD		 1071 {
1072 /* Pop 1, push 1 */
1073 vstack_ax(stack)->type = REG_S64;
1074 next_pc += sizeof(struct cast_op);
1075 break;
1076 }
80c2a69a 1077 case BYTECODE_OP_CAST_NOP:
07dfc1d0
MD		 1078 {
1079 next_pc += sizeof(struct cast_op);
1080 break;
1081 }
1082
3834b99f
MD		 1083 /*
1084 * Instructions for recursive traversal through composed types.
1085 */
80c2a69a 1086 case BYTECODE_OP_GET_CONTEXT_ROOT:
3834b99f
MD		 1087 {
1088 if (vstack_push(stack)) {
1089 ret = -EINVAL;
1090 goto end;
1091 }
1092 vstack_ax(stack)->type = REG_PTR;
1093 vstack_ax(stack)->load.type = LOAD_ROOT_CONTEXT;
1094 next_pc += sizeof(struct load_op);
1095 break;
1096 }
80c2a69a 1097 case BYTECODE_OP_GET_APP_CONTEXT_ROOT:
3834b99f
MD		 1098 {
1099 if (vstack_push(stack)) {
1100 ret = -EINVAL;
1101 goto end;
1102 }
1103 vstack_ax(stack)->type = REG_PTR;
1104 vstack_ax(stack)->load.type = LOAD_ROOT_APP_CONTEXT;
1105 next_pc += sizeof(struct load_op);
1106 break;
1107 }
80c2a69a 1108 case BYTECODE_OP_GET_PAYLOAD_ROOT:
3834b99f
MD		 1109 {
1110 if (vstack_push(stack)) {
1111 ret = -EINVAL;
1112 goto end;
1113 }
1114 vstack_ax(stack)->type = REG_PTR;
1115 vstack_ax(stack)->load.type = LOAD_ROOT_PAYLOAD;
1116 next_pc += sizeof(struct load_op);
1117 break;
1118 }
1119
80c2a69a 1120 case BYTECODE_OP_LOAD_FIELD:
3834b99f
MD		 1121 {
1122 struct load_op *insn = (struct load_op *) pc;
1123
1124 WARN_ON_ONCE(vstack_ax(stack)->type != REG_PTR);
1125 /* Pop 1, push 1 */
1126 ret = specialize_load_field(vstack_ax(stack), insn);
1127 if (ret)
1128 goto end;
1129
1130 next_pc += sizeof(struct load_op);
1131 break;
1132 }
1133
80c2a69a
FD		 1134 case BYTECODE_OP_LOAD_FIELD_S8:
1135 case BYTECODE_OP_LOAD_FIELD_S16:
1136 case BYTECODE_OP_LOAD_FIELD_S32:
1137 case BYTECODE_OP_LOAD_FIELD_S64:
1138 case BYTECODE_OP_LOAD_FIELD_U8:
1139 case BYTECODE_OP_LOAD_FIELD_U16:
1140 case BYTECODE_OP_LOAD_FIELD_U32:
1141 case BYTECODE_OP_LOAD_FIELD_U64:
3834b99f
MD		 1142 {
1143 /* Pop 1, push 1 */
1144 vstack_ax(stack)->type = REG_S64;
1145 next_pc += sizeof(struct load_op);
1146 break;
1147 }
1148
80c2a69a
FD		 1149 case BYTECODE_OP_LOAD_FIELD_STRING:
1150 case BYTECODE_OP_LOAD_FIELD_SEQUENCE:
3834b99f
MD		 1151 {
1152 /* Pop 1, push 1 */
1153 vstack_ax(stack)->type = REG_STRING;
1154 next_pc += sizeof(struct load_op);
1155 break;
1156 }
1157
80c2a69a 1158 case BYTECODE_OP_LOAD_FIELD_DOUBLE:
3834b99f
MD		 1159 {
1160 /* Pop 1, push 1 */
1161 vstack_ax(stack)->type = REG_DOUBLE;
1162 next_pc += sizeof(struct load_op);
1163 break;
1164 }
1165
80c2a69a 1166 case BYTECODE_OP_GET_SYMBOL:
3834b99f
MD		 1167 {
1168 struct load_op *insn = (struct load_op *) pc;
1169
1170 dbg_printk("op get symbol\n");
1171 switch (vstack_ax(stack)->load.type) {
1172 case LOAD_OBJECT:
80c2a69a 1173 printk(KERN_WARNING "LTTng: bytecode: Nested fields not implemented yet.\n");
3834b99f
MD		 1174 ret = -EINVAL;
1175 goto end;
1176 case LOAD_ROOT_CONTEXT:
1177 /* Lookup context field. */
2dfda770 1178 ret = specialize_context_lookup(ctx, bytecode, insn,
3834b99f
MD		 1179 &vstack_ax(stack)->load);
1180 if (ret)
1181 goto end;
1182 break;
1183 case LOAD_ROOT_APP_CONTEXT:
1184 ret = -EINVAL;
1185 goto end;
1186 case LOAD_ROOT_PAYLOAD:
1187 /* Lookup event payload field. */
2dfda770 1188 ret = specialize_payload_lookup(event_desc,
3834b99f
MD		 1189 bytecode, insn,
1190 &vstack_ax(stack)->load);
1191 if (ret)
1192 goto end;
1193 break;
1194 }
1195 next_pc += sizeof(struct load_op) + sizeof(struct get_symbol);
1196 break;
1197 }
1198
80c2a69a 1199 case BYTECODE_OP_GET_SYMBOL_FIELD:
3834b99f
MD		 1200 {
1201 /* Always generated by specialize phase. */
1202 ret = -EINVAL;
1203 goto end;
1204 }
1205
80c2a69a 1206 case BYTECODE_OP_GET_INDEX_U16:
3834b99f
MD		 1207 {
1208 struct load_op *insn = (struct load_op *) pc;
1209 struct get_index_u16 *index = (struct get_index_u16 *) insn->data;
1210
1211 dbg_printk("op get index u16\n");
1212 /* Pop 1, push 1 */
1213 ret = specialize_get_index(bytecode, insn, index->index,
1214 vstack_ax(stack), sizeof(*index));
1215 if (ret)
1216 goto end;
1217 next_pc += sizeof(struct load_op) + sizeof(struct get_index_u16);
1218 break;
1219 }
1220
80c2a69a 1221 case BYTECODE_OP_GET_INDEX_U64:
3834b99f
MD		 1222 {
1223 struct load_op *insn = (struct load_op *) pc;
1224 struct get_index_u64 *index = (struct get_index_u64 *) insn->data;
1225
1226 dbg_printk("op get index u64\n");
1227 /* Pop 1, push 1 */
1228 ret = specialize_get_index(bytecode, insn, index->index,
1229 vstack_ax(stack), sizeof(*index));
1230 if (ret)
1231 goto end;
1232 next_pc += sizeof(struct load_op) + sizeof(struct get_index_u64);
1233 break;
1234 }
1235
07dfc1d0
MD		 1236 }
1237 }
1238end:
1239 return ret;
1240}
LTTng 2.0/0.x modules
This page took 0.100432 seconds and 4 git commands to generate.