projects / lttng-ust.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
bytecode: Add `OBJECT_TYPE_{UN,}SIGNED_ENUM` type
[lttng-ust.git] / liblttng-ust / lttng-bytecode-interpreter.c
1 /*
2 * lttng-bytecode-interpreter.c
3 *
4 * LTTng UST bytecode interpreter.
5 *
6 * Copyright (C) 2010-2016 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
7 *
8 * Permission is hereby granted, free of charge, to any person obtaining a copy
9 * of this software and associated documentation files (the "Software"), to deal
10 * in the Software without restriction, including without limitation the rights
11 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
12 * copies of the Software, and to permit persons to whom the Software is
13 * furnished to do so, subject to the following conditions:
14 *
15 * The above copyright notice and this permission notice shall be included in
16 * all copies or substantial portions of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
21 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
23 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
24 * SOFTWARE.
25 */
26
27 #define _LGPL_SOURCE
28 #include <stddef.h>
29 #include <stdint.h>
30 #include <urcu-pointer.h>
31 #include <byteswap.h>
32
33 #include <lttng/ust-endian.h>
34 #include <lttng/ust-events.h>
35
36 #include "lttng-bytecode.h"
37 #include "string-utils.h"
38
39
40 /*
41 * -1: wildcard found.
42 * -2: unknown escape char.
43 * 0: normal char.
44 */
45
46 static
47 int parse_char(const char **p)
48 {
49 switch (**p) {
50 case '\\':
51 (*p)++;
52 switch (**p) {
53 case '\\':
54 case '*':
55 return 0;
56 default:
57 return -2;
58 }
59 case '*':
60 return -1;
61 default:
62 return 0;
63 }
64 }
65
66 /*
67 * Returns SIZE_MAX if the string is null-terminated, or the number of
68 * characters if not.
69 */
70 static
71 size_t get_str_or_seq_len(const struct estack_entry *entry)
72 {
73 return entry->u.s.seq_len;
74 }
75
76 static
77 int stack_star_glob_match(struct estack *stack, int top, const char *cmp_type)
78 {
79 const char *pattern;
80 const char *candidate;
81 size_t pattern_len;
82 size_t candidate_len;
83
84 /* Find out which side is the pattern vs. the candidate. */
85 if (estack_ax(stack, top)->u.s.literal_type == ESTACK_STRING_LITERAL_TYPE_STAR_GLOB) {
86 pattern = estack_ax(stack, top)->u.s.str;
87 pattern_len = get_str_or_seq_len(estack_ax(stack, top));
88 candidate = estack_bx(stack, top)->u.s.str;
89 candidate_len = get_str_or_seq_len(estack_bx(stack, top));
90 } else {
91 pattern = estack_bx(stack, top)->u.s.str;
92 pattern_len = get_str_or_seq_len(estack_bx(stack, top));
93 candidate = estack_ax(stack, top)->u.s.str;
94 candidate_len = get_str_or_seq_len(estack_ax(stack, top));
95 }
96
97 /* Perform the match. Returns 0 when the result is true. */
98 return !strutils_star_glob_match(pattern, pattern_len, candidate,
99 candidate_len);
100 }
101
102 static
103 int stack_strcmp(struct estack *stack, int top, const char *cmp_type)
104 {
105 const char *p = estack_bx(stack, top)->u.s.str, *q = estack_ax(stack, top)->u.s.str;
106 int ret;
107 int diff;
108
109 for (;;) {
110 int escaped_r0 = 0;
111
112 if (unlikely(p - estack_bx(stack, top)->u.s.str >= estack_bx(stack, top)->u.s.seq_len || *p == '\0')) {
113 if (q - estack_ax(stack, top)->u.s.str >= estack_ax(stack, top)->u.s.seq_len || *q == '\0') {
114 return 0;
115 } else {
116 if (estack_ax(stack, top)->u.s.literal_type ==
117 ESTACK_STRING_LITERAL_TYPE_PLAIN) {
118 ret = parse_char(&q);
119 if (ret == -1)
120 return 0;
121 }
122 return -1;
123 }
124 }
125 if (unlikely(q - estack_ax(stack, top)->u.s.str >= estack_ax(stack, top)->u.s.seq_len || *q == '\0')) {
126 if (estack_bx(stack, top)->u.s.literal_type ==
127 ESTACK_STRING_LITERAL_TYPE_PLAIN) {
128 ret = parse_char(&p);
129 if (ret == -1)
130 return 0;
131 }
132 return 1;
133 }
134 if (estack_bx(stack, top)->u.s.literal_type ==
135 ESTACK_STRING_LITERAL_TYPE_PLAIN) {
136 ret = parse_char(&p);
137 if (ret == -1) {
138 return 0;
139 } else if (ret == -2) {
140 escaped_r0 = 1;
141 }
142 /* else compare both char */
143 }
144 if (estack_ax(stack, top)->u.s.literal_type ==
145 ESTACK_STRING_LITERAL_TYPE_PLAIN) {
146 ret = parse_char(&q);
147 if (ret == -1) {
148 return 0;
149 } else if (ret == -2) {
150 if (!escaped_r0)
151 return -1;
152 } else {
153 if (escaped_r0)
154 return 1;
155 }
156 } else {
157 if (escaped_r0)
158 return 1;
159 }
160 diff = *p - *q;
161 if (diff != 0)
162 break;
163 p++;
164 q++;
165 }
166 return diff;
167 }
168
169 uint64_t lttng_bytecode_filter_interpret_false(void *filter_data,
170 const char *filter_stack_data)
171 {
172 return LTTNG_INTERPRETER_DISCARD;
173 }
174
175 #ifdef INTERPRETER_USE_SWITCH
176
177 /*
178 * Fallback for compilers that do not support taking address of labels.
179 */
180
181 #define START_OP \
182 start_pc = &bytecode->data[0]; \
183 for (pc = next_pc = start_pc; pc - start_pc < bytecode->len; \
184 pc = next_pc) { \
185 dbg_printf("Executing op %s (%u)\n", \
186 print_op((unsigned int) *(bytecode_opcode_t *) pc), \
187 (unsigned int) *(bytecode_opcode_t *) pc); \
188 switch (*(bytecode_opcode_t *) pc) {
189
190 #define OP(name) jump_target_##name: __attribute__((unused)); \
191 case name
192
193 #define PO break
194
195 #define END_OP } \
196 }
197
198 #define JUMP_TO(name) \
199 goto jump_target_##name
200
201 #else
202
203 /*
204 * Dispatch-table based interpreter.
205 */
206
207 #define START_OP \
208 start_pc = &bytecode->code[0]; \
209 pc = next_pc = start_pc; \
210 if (unlikely(pc - start_pc >= bytecode->len)) \
211 goto end; \
212 goto *dispatch[*(bytecode_opcode_t *) pc];
213
214 #define OP(name) \
215 LABEL_##name
216
217 #define PO \
218 pc = next_pc; \
219 goto *dispatch[*(bytecode_opcode_t *) pc];
220
221 #define END_OP
222
223 #define JUMP_TO(name) \
224 goto LABEL_##name
225
226 #endif
227
228 #define IS_INTEGER_REGISTER(reg_type) \
229 (reg_type == REG_U64 || reg_type == REG_S64)
230
231 static int context_get_index(struct lttng_ctx *ctx,
232 struct load_ptr *ptr,
233 uint32_t idx)
234 {
235
236 struct lttng_ctx_field *ctx_field;
237 struct lttng_event_field *field;
238 struct lttng_ctx_value v;
239
240 ctx_field = &ctx->fields[idx];
241 field = &ctx_field->event_field;
242 ptr->type = LOAD_OBJECT;
243 ptr->field = field;
244
245 switch (field->type.atype) {
246 case atype_integer:
247 ctx_field->get_value(ctx_field, &v);
248 if (field->type.u.integer.signedness) {
249 ptr->object_type = OBJECT_TYPE_S64;
250 ptr->u.s64 = v.u.s64;
251 ptr->ptr = &ptr->u.s64;
252 } else {
253 ptr->object_type = OBJECT_TYPE_U64;
254 ptr->u.u64 = v.u.s64; /* Cast. */
255 ptr->ptr = &ptr->u.u64;
256 }
257 break;
258 case atype_enum: /* Fall-through */
259 case atype_enum_nestable:
260 {
261 const struct lttng_integer_type *itype;
262
263 if (field->type.atype == atype_enum) {
264 itype = &field->type.u.legacy.basic.enumeration.container_type;
265 } else {
266 itype = &field->type.u.enum_nestable.container_type->u.integer;
267 }
268 ctx_field->get_value(ctx_field, &v);
269 if (itype->signedness) {
270 ptr->object_type = OBJECT_TYPE_SIGNED_ENUM;
271 ptr->u.s64 = v.u.s64;
272 ptr->ptr = &ptr->u.s64;
273 } else {
274 ptr->object_type = OBJECT_TYPE_UNSIGNED_ENUM;
275 ptr->u.u64 = v.u.s64; /* Cast. */
276 ptr->ptr = &ptr->u.u64;
277 }
278 break;
279 }
280 case atype_array:
281 if (field->type.u.legacy.array.elem_type.atype != atype_integer) {
282 ERR("Array nesting only supports integer types.");
283 return -EINVAL;
284 }
285 if (field->type.u.legacy.array.elem_type.u.basic.integer.encoding == lttng_encode_none) {
286 ERR("Only string arrays are supported for contexts.");
287 return -EINVAL;
288 }
289 ptr->object_type = OBJECT_TYPE_STRING;
290 ctx_field->get_value(ctx_field, &v);
291 ptr->ptr = v.u.str;
292 break;
293 case atype_array_nestable:
294 if (field->type.u.array_nestable.elem_type->atype != atype_integer) {
295 ERR("Array nesting only supports integer types.");
296 return -EINVAL;
297 }
298 if (field->type.u.array_nestable.elem_type->u.integer.encoding == lttng_encode_none) {
299 ERR("Only string arrays are supported for contexts.");
300 return -EINVAL;
301 }
302 ptr->object_type = OBJECT_TYPE_STRING;
303 ctx_field->get_value(ctx_field, &v);
304 ptr->ptr = v.u.str;
305 break;
306 case atype_sequence:
307 if (field->type.u.legacy.sequence.elem_type.atype != atype_integer) {
308 ERR("Sequence nesting only supports integer types.");
309 return -EINVAL;
310 }
311 if (field->type.u.legacy.sequence.elem_type.u.basic.integer.encoding == lttng_encode_none) {
312 ERR("Only string sequences are supported for contexts.");
313 return -EINVAL;
314 }
315 ptr->object_type = OBJECT_TYPE_STRING;
316 ctx_field->get_value(ctx_field, &v);
317 ptr->ptr = v.u.str;
318 break;
319 case atype_sequence_nestable:
320 if (field->type.u.sequence_nestable.elem_type->atype != atype_integer) {
321 ERR("Sequence nesting only supports integer types.");
322 return -EINVAL;
323 }
324 if (field->type.u.sequence_nestable.elem_type->u.integer.encoding == lttng_encode_none) {
325 ERR("Only string sequences are supported for contexts.");
326 return -EINVAL;
327 }
328 ptr->object_type = OBJECT_TYPE_STRING;
329 ctx_field->get_value(ctx_field, &v);
330 ptr->ptr = v.u.str;
331 break;
332 case atype_string:
333 ptr->object_type = OBJECT_TYPE_STRING;
334 ctx_field->get_value(ctx_field, &v);
335 ptr->ptr = v.u.str;
336 break;
337 case atype_float:
338 ptr->object_type = OBJECT_TYPE_DOUBLE;
339 ctx_field->get_value(ctx_field, &v);
340 ptr->u.d = v.u.d;
341 ptr->ptr = &ptr->u.d;
342 break;
343 case atype_dynamic:
344 ctx_field->get_value(ctx_field, &v);
345 switch (v.sel) {
346 case LTTNG_UST_DYNAMIC_TYPE_NONE:
347 return -EINVAL;
348 case LTTNG_UST_DYNAMIC_TYPE_S64:
349 ptr->object_type = OBJECT_TYPE_S64;
350 ptr->u.s64 = v.u.s64;
351 ptr->ptr = &ptr->u.s64;
352 dbg_printf("context get index dynamic s64 %" PRIi64 "\n", ptr->u.s64);
353 break;
354 case LTTNG_UST_DYNAMIC_TYPE_DOUBLE:
355 ptr->object_type = OBJECT_TYPE_DOUBLE;
356 ptr->u.d = v.u.d;
357 ptr->ptr = &ptr->u.d;
358 dbg_printf("context get index dynamic double %g\n", ptr->u.d);
359 break;
360 case LTTNG_UST_DYNAMIC_TYPE_STRING:
361 ptr->object_type = OBJECT_TYPE_STRING;
362 ptr->ptr = v.u.str;
363 dbg_printf("context get index dynamic string %s\n", (const char *) ptr->ptr);
364 break;
365 default:
366 dbg_printf("Interpreter warning: unknown dynamic type (%d).\n", (int) v.sel);
367 return -EINVAL;
368 }
369 break;
370 case atype_struct:
371 ERR("Structure type cannot be loaded.");
372 return -EINVAL;
373 default:
374 ERR("Unknown type: %d", (int) field->type.atype);
375 return -EINVAL;
376 }
377 return 0;
378 }
379
380 static int dynamic_get_index(struct lttng_ctx *ctx,
381 struct bytecode_runtime *runtime,
382 uint64_t index, struct estack_entry *stack_top)
383 {
384 int ret;
385 const struct bytecode_get_index_data *gid;
386
387 gid = (const struct bytecode_get_index_data *) &runtime->data[index];
388 switch (stack_top->u.ptr.type) {
389 case LOAD_OBJECT:
390 switch (stack_top->u.ptr.object_type) {
391 case OBJECT_TYPE_ARRAY:
392 {
393 const char *ptr;
394
395 assert(gid->offset < gid->array_len);
396 /* Skip count (unsigned long) */
397 ptr = *(const char **) (stack_top->u.ptr.ptr + sizeof(unsigned long));
398 ptr = ptr + gid->offset;
399 stack_top->u.ptr.ptr = ptr;
400 stack_top->u.ptr.object_type = gid->elem.type;
401 stack_top->u.ptr.rev_bo = gid->elem.rev_bo;
402 assert(stack_top->u.ptr.field->type.atype == atype_array ||
403 stack_top->u.ptr.field->type.atype == atype_array_nestable);
404 stack_top->u.ptr.field = NULL;
405 break;
406 }
407 case OBJECT_TYPE_SEQUENCE:
408 {
409 const char *ptr;
410 size_t ptr_seq_len;
411
412 ptr = *(const char **) (stack_top->u.ptr.ptr + sizeof(unsigned long));
413 ptr_seq_len = *(unsigned long *) stack_top->u.ptr.ptr;
414 if (gid->offset >= gid->elem.len * ptr_seq_len) {
415 ret = -EINVAL;
416 goto end;
417 }
418 ptr = ptr + gid->offset;
419 stack_top->u.ptr.ptr = ptr;
420 stack_top->u.ptr.object_type = gid->elem.type;
421 stack_top->u.ptr.rev_bo = gid->elem.rev_bo;
422 assert(stack_top->u.ptr.field->type.atype == atype_sequence ||
423 stack_top->u.ptr.field->type.atype == atype_sequence_nestable);
424 stack_top->u.ptr.field = NULL;
425 break;
426 }
427 case OBJECT_TYPE_STRUCT:
428 ERR("Nested structures are not supported yet.");
429 ret = -EINVAL;
430 goto end;
431 case OBJECT_TYPE_VARIANT:
432 default:
433 ERR("Unexpected get index type %d",
434 (int) stack_top->u.ptr.object_type);
435 ret = -EINVAL;
436 goto end;
437 }
438 break;
439 case LOAD_ROOT_CONTEXT:
440 case LOAD_ROOT_APP_CONTEXT: /* Fall-through */
441 {
442 ret = context_get_index(ctx,
443 &stack_top->u.ptr,
444 gid->ctx_index);
445 if (ret) {
446 goto end;
447 }
448 break;
449 }
450 case LOAD_ROOT_PAYLOAD:
451 stack_top->u.ptr.ptr += gid->offset;
452 if (gid->elem.type == OBJECT_TYPE_STRING)
453 stack_top->u.ptr.ptr = *(const char * const *) stack_top->u.ptr.ptr;
454 stack_top->u.ptr.object_type = gid->elem.type;
455 stack_top->u.ptr.type = LOAD_OBJECT;
456 stack_top->u.ptr.field = gid->field;
457 stack_top->u.ptr.rev_bo = gid->elem.rev_bo;
458 break;
459 }
460
461 stack_top->type = REG_PTR;
462
463 return 0;
464
465 end:
466 return ret;
467 }
468
469 static int dynamic_load_field(struct estack_entry *stack_top)
470 {
471 int ret;
472
473 switch (stack_top->u.ptr.type) {
474 case LOAD_OBJECT:
475 break;
476 case LOAD_ROOT_CONTEXT:
477 case LOAD_ROOT_APP_CONTEXT:
478 case LOAD_ROOT_PAYLOAD:
479 default:
480 dbg_printf("Interpreter warning: cannot load root, missing field name.\n");
481 ret = -EINVAL;
482 goto end;
483 }
484 switch (stack_top->u.ptr.object_type) {
485 case OBJECT_TYPE_S8:
486 dbg_printf("op load field s8\n");
487 stack_top->u.v = *(int8_t *) stack_top->u.ptr.ptr;
488 stack_top->type = REG_S64;
489 break;
490 case OBJECT_TYPE_S16:
491 {
492 int16_t tmp;
493
494 dbg_printf("op load field s16\n");
495 tmp = *(int16_t *) stack_top->u.ptr.ptr;
496 if (stack_top->u.ptr.rev_bo)
497 tmp = bswap_16(tmp);
498 stack_top->u.v = tmp;
499 stack_top->type = REG_S64;
500 break;
501 }
502 case OBJECT_TYPE_S32:
503 {
504 int32_t tmp;
505
506 dbg_printf("op load field s32\n");
507 tmp = *(int32_t *) stack_top->u.ptr.ptr;
508 if (stack_top->u.ptr.rev_bo)
509 tmp = bswap_32(tmp);
510 stack_top->u.v = tmp;
511 stack_top->type = REG_S64;
512 break;
513 }
514 case OBJECT_TYPE_S64:
515 {
516 int64_t tmp;
517
518 dbg_printf("op load field s64\n");
519 tmp = *(int64_t *) stack_top->u.ptr.ptr;
520 if (stack_top->u.ptr.rev_bo)
521 tmp = bswap_64(tmp);
522 stack_top->u.v = tmp;
523 stack_top->type = REG_S64;
524 break;
525 }
526 case OBJECT_TYPE_SIGNED_ENUM:
527 {
528 int64_t tmp;
529
530 dbg_printf("op load field signed enumeration\n");
531 tmp = *(int64_t *) stack_top->u.ptr.ptr;
532 if (stack_top->u.ptr.rev_bo)
533 tmp = bswap_64(tmp);
534 stack_top->u.v = tmp;
535 stack_top->type = REG_S64;
536 break;
537 }
538 case OBJECT_TYPE_U8:
539 dbg_printf("op load field u8\n");
540 stack_top->u.v = *(uint8_t *) stack_top->u.ptr.ptr;
541 stack_top->type = REG_U64;
542 break;
543 case OBJECT_TYPE_U16:
544 {
545 uint16_t tmp;
546
547 dbg_printf("op load field u16\n");
548 tmp = *(uint16_t *) stack_top->u.ptr.ptr;
549 if (stack_top->u.ptr.rev_bo)
550 tmp = bswap_16(tmp);
551 stack_top->u.v = tmp;
552 stack_top->type = REG_U64;
553 break;
554 }
555 case OBJECT_TYPE_U32:
556 {
557 uint32_t tmp;
558
559 dbg_printf("op load field u32\n");
560 tmp = *(uint32_t *) stack_top->u.ptr.ptr;
561 if (stack_top->u.ptr.rev_bo)
562 tmp = bswap_32(tmp);
563 stack_top->u.v = tmp;
564 stack_top->type = REG_U64;
565 break;
566 }
567 case OBJECT_TYPE_U64:
568 {
569 uint64_t tmp;
570
571 dbg_printf("op load field u64\n");
572 tmp = *(uint64_t *) stack_top->u.ptr.ptr;
573 if (stack_top->u.ptr.rev_bo)
574 tmp = bswap_64(tmp);
575 stack_top->u.v = tmp;
576 stack_top->type = REG_U64;
577 break;
578 }
579 case OBJECT_TYPE_UNSIGNED_ENUM:
580 {
581 uint64_t tmp;
582
583 dbg_printf("op load field unsigned enumeration\n");
584 tmp = *(uint64_t *) stack_top->u.ptr.ptr;
585 if (stack_top->u.ptr.rev_bo)
586 tmp = bswap_64(tmp);
587 stack_top->u.v = tmp;
588 stack_top->type = REG_U64;
589 break;
590 }
591 case OBJECT_TYPE_DOUBLE:
592 memcpy(&stack_top->u.d,
593 stack_top->u.ptr.ptr,
594 sizeof(struct literal_double));
595 stack_top->type = REG_DOUBLE;
596 break;
597 case OBJECT_TYPE_STRING:
598 {
599 const char *str;
600
601 dbg_printf("op load field string\n");
602 str = (const char *) stack_top->u.ptr.ptr;
603 stack_top->u.s.str = str;
604 if (unlikely(!stack_top->u.s.str)) {
605 dbg_printf("Interpreter warning: loading a NULL string.\n");
606 ret = -EINVAL;
607 goto end;
608 }
609 stack_top->u.s.seq_len = SIZE_MAX;
610 stack_top->u.s.literal_type =
611 ESTACK_STRING_LITERAL_TYPE_NONE;
612 stack_top->type = REG_STRING;
613 break;
614 }
615 case OBJECT_TYPE_STRING_SEQUENCE:
616 {
617 const char *ptr;
618
619 dbg_printf("op load field string sequence\n");
620 ptr = stack_top->u.ptr.ptr;
621 stack_top->u.s.seq_len = *(unsigned long *) ptr;
622 stack_top->u.s.str = *(const char **) (ptr + sizeof(unsigned long));
623 stack_top->type = REG_STRING;
624 if (unlikely(!stack_top->u.s.str)) {
625 dbg_printf("Interpreter warning: loading a NULL sequence.\n");
626 ret = -EINVAL;
627 goto end;
628 }
629 stack_top->u.s.literal_type =
630 ESTACK_STRING_LITERAL_TYPE_NONE;
631 break;
632 }
633 case OBJECT_TYPE_DYNAMIC:
634 /*
635 * Dynamic types in context are looked up
636 * by context get index.
637 */
638 ret = -EINVAL;
639 goto end;
640 case OBJECT_TYPE_SEQUENCE:
641 case OBJECT_TYPE_ARRAY:
642 case OBJECT_TYPE_STRUCT:
643 case OBJECT_TYPE_VARIANT:
644 ERR("Sequences, arrays, struct and variant cannot be loaded (nested types).");
645 ret = -EINVAL;
646 goto end;
647 }
648 return 0;
649
650 end:
651 return ret;
652 }
653
654 static
655 int lttng_bytecode_interpret_format_output(struct estack_entry *ax,
656 struct lttng_interpreter_output *output)
657 {
658 int ret;
659
660 again:
661 switch (ax->type) {
662 case REG_S64:
663 output->type = LTTNG_INTERPRETER_TYPE_S64;
664 output->u.s = ax->u.v;
665 break;
666 case REG_U64:
667 output->type = LTTNG_INTERPRETER_TYPE_U64;
668 output->u.u = (uint64_t) ax->u.v;
669 break;
670 case REG_DOUBLE:
671 output->type = LTTNG_INTERPRETER_TYPE_DOUBLE;
672 output->u.d = ax->u.d;
673 break;
674 case REG_STRING:
675 output->type = LTTNG_INTERPRETER_TYPE_STRING;
676 output->u.str.str = ax->u.s.str;
677 output->u.str.len = ax->u.s.seq_len;
678 break;
679 case REG_PTR:
680 switch (ax->u.ptr.object_type) {
681 case OBJECT_TYPE_S8:
682 case OBJECT_TYPE_S16:
683 case OBJECT_TYPE_S32:
684 case OBJECT_TYPE_S64:
685 case OBJECT_TYPE_U8:
686 case OBJECT_TYPE_U16:
687 case OBJECT_TYPE_U32:
688 case OBJECT_TYPE_U64:
689 case OBJECT_TYPE_DOUBLE:
690 case OBJECT_TYPE_STRING:
691 case OBJECT_TYPE_STRING_SEQUENCE:
692 ret = dynamic_load_field(ax);
693 if (ret)
694 return ret;
695 /* Retry after loading ptr into stack top. */
696 goto again;
697 case OBJECT_TYPE_SEQUENCE:
698 output->type = LTTNG_INTERPRETER_TYPE_SEQUENCE;
699 output->u.sequence.ptr = *(const char **) (ax->u.ptr.ptr + sizeof(unsigned long));
700 output->u.sequence.nr_elem = *(unsigned long *) ax->u.ptr.ptr;
701 output->u.sequence.nested_type = ax->u.ptr.field->type.u.sequence_nestable.elem_type;
702 break;
703 case OBJECT_TYPE_ARRAY:
704 /* Skip count (unsigned long) */
705 output->type = LTTNG_INTERPRETER_TYPE_SEQUENCE;
706 output->u.sequence.ptr = *(const char **) (ax->u.ptr.ptr + sizeof(unsigned long));
707 output->u.sequence.nr_elem = ax->u.ptr.field->type.u.array_nestable.length;
708 output->u.sequence.nested_type = ax->u.ptr.field->type.u.array_nestable.elem_type;
709 break;
710 case OBJECT_TYPE_SIGNED_ENUM:
711 ret = dynamic_load_field(ax);
712 if (ret)
713 return ret;
714 output->type = LTTNG_INTERPRETER_TYPE_SIGNED_ENUM;
715 output->u.s = ax->u.v;
716 break;
717 case OBJECT_TYPE_UNSIGNED_ENUM:
718 ret = dynamic_load_field(ax);
719 if (ret)
720 return ret;
721 output->type = LTTNG_INTERPRETER_TYPE_UNSIGNED_ENUM;
722 output->u.u = ax->u.v;
723 break;
724 case OBJECT_TYPE_STRUCT:
725 case OBJECT_TYPE_VARIANT:
726 default:
727 return -EINVAL;
728 }
729
730 break;
731 case REG_STAR_GLOB_STRING:
732 case REG_UNKNOWN:
733 default:
734 return -EINVAL;
735 }
736
737 return LTTNG_INTERPRETER_RECORD_FLAG;
738 }
739
740 /*
741 * Return 0 (discard), or raise the 0x1 flag (log event).
742 * Currently, other flags are kept for future extensions and have no
743 * effect.
744 */
745 static
746 uint64_t bytecode_interpret(void *interpreter_data,
747 const char *interpreter_stack_data,
748 struct lttng_interpreter_output *output)
749 {
750 struct bytecode_runtime *bytecode = interpreter_data;
751 struct lttng_ctx *ctx = rcu_dereference(*bytecode->p.pctx);
752 void *pc, *next_pc, *start_pc;
753 int ret = -EINVAL;
754 uint64_t retval = 0;
755 struct estack _stack;
756 struct estack *stack = &_stack;
757 register int64_t ax = 0, bx = 0;
758 register enum entry_type ax_t = REG_UNKNOWN, bx_t = REG_UNKNOWN;
759 register int top = INTERPRETER_STACK_EMPTY;
760 #ifndef INTERPRETER_USE_SWITCH
761 static void *dispatch[NR_BYTECODE_OPS] = {
762 [ BYTECODE_OP_UNKNOWN ] = &&LABEL_BYTECODE_OP_UNKNOWN,
763
764 [ BYTECODE_OP_RETURN ] = &&LABEL_BYTECODE_OP_RETURN,
765
766 /* binary */
767 [ BYTECODE_OP_MUL ] = &&LABEL_BYTECODE_OP_MUL,
768 [ BYTECODE_OP_DIV ] = &&LABEL_BYTECODE_OP_DIV,
769 [ BYTECODE_OP_MOD ] = &&LABEL_BYTECODE_OP_MOD,
770 [ BYTECODE_OP_PLUS ] = &&LABEL_BYTECODE_OP_PLUS,
771 [ BYTECODE_OP_MINUS ] = &&LABEL_BYTECODE_OP_MINUS,
772 [ BYTECODE_OP_BIT_RSHIFT ] = &&LABEL_BYTECODE_OP_BIT_RSHIFT,
773 [ BYTECODE_OP_BIT_LSHIFT ] = &&LABEL_BYTECODE_OP_BIT_LSHIFT,
774 [ BYTECODE_OP_BIT_AND ] = &&LABEL_BYTECODE_OP_BIT_AND,
775 [ BYTECODE_OP_BIT_OR ] = &&LABEL_BYTECODE_OP_BIT_OR,
776 [ BYTECODE_OP_BIT_XOR ] = &&LABEL_BYTECODE_OP_BIT_XOR,
777
778 /* binary comparators */
779 [ BYTECODE_OP_EQ ] = &&LABEL_BYTECODE_OP_EQ,
780 [ BYTECODE_OP_NE ] = &&LABEL_BYTECODE_OP_NE,
781 [ BYTECODE_OP_GT ] = &&LABEL_BYTECODE_OP_GT,
782 [ BYTECODE_OP_LT ] = &&LABEL_BYTECODE_OP_LT,
783 [ BYTECODE_OP_GE ] = &&LABEL_BYTECODE_OP_GE,
784 [ BYTECODE_OP_LE ] = &&LABEL_BYTECODE_OP_LE,
785
786 /* string binary comparator */
787 [ BYTECODE_OP_EQ_STRING ] = &&LABEL_BYTECODE_OP_EQ_STRING,
788 [ BYTECODE_OP_NE_STRING ] = &&LABEL_BYTECODE_OP_NE_STRING,
789 [ BYTECODE_OP_GT_STRING ] = &&LABEL_BYTECODE_OP_GT_STRING,
790 [ BYTECODE_OP_LT_STRING ] = &&LABEL_BYTECODE_OP_LT_STRING,
791 [ BYTECODE_OP_GE_STRING ] = &&LABEL_BYTECODE_OP_GE_STRING,
792 [ BYTECODE_OP_LE_STRING ] = &&LABEL_BYTECODE_OP_LE_STRING,
793
794 /* globbing pattern binary comparator */
795 [ BYTECODE_OP_EQ_STAR_GLOB_STRING ] = &&LABEL_BYTECODE_OP_EQ_STAR_GLOB_STRING,
796 [ BYTECODE_OP_NE_STAR_GLOB_STRING ] = &&LABEL_BYTECODE_OP_NE_STAR_GLOB_STRING,
797
798 /* s64 binary comparator */
799 [ BYTECODE_OP_EQ_S64 ] = &&LABEL_BYTECODE_OP_EQ_S64,
800 [ BYTECODE_OP_NE_S64 ] = &&LABEL_BYTECODE_OP_NE_S64,
801 [ BYTECODE_OP_GT_S64 ] = &&LABEL_BYTECODE_OP_GT_S64,
802 [ BYTECODE_OP_LT_S64 ] = &&LABEL_BYTECODE_OP_LT_S64,
803 [ BYTECODE_OP_GE_S64 ] = &&LABEL_BYTECODE_OP_GE_S64,
804 [ BYTECODE_OP_LE_S64 ] = &&LABEL_BYTECODE_OP_LE_S64,
805
806 /* double binary comparator */
807 [ BYTECODE_OP_EQ_DOUBLE ] = &&LABEL_BYTECODE_OP_EQ_DOUBLE,
808 [ BYTECODE_OP_NE_DOUBLE ] = &&LABEL_BYTECODE_OP_NE_DOUBLE,
809 [ BYTECODE_OP_GT_DOUBLE ] = &&LABEL_BYTECODE_OP_GT_DOUBLE,
810 [ BYTECODE_OP_LT_DOUBLE ] = &&LABEL_BYTECODE_OP_LT_DOUBLE,
811 [ BYTECODE_OP_GE_DOUBLE ] = &&LABEL_BYTECODE_OP_GE_DOUBLE,
812 [ BYTECODE_OP_LE_DOUBLE ] = &&LABEL_BYTECODE_OP_LE_DOUBLE,
813
814 /* Mixed S64-double binary comparators */
815 [ BYTECODE_OP_EQ_DOUBLE_S64 ] = &&LABEL_BYTECODE_OP_EQ_DOUBLE_S64,
816 [ BYTECODE_OP_NE_DOUBLE_S64 ] = &&LABEL_BYTECODE_OP_NE_DOUBLE_S64,
817 [ BYTECODE_OP_GT_DOUBLE_S64 ] = &&LABEL_BYTECODE_OP_GT_DOUBLE_S64,
818 [ BYTECODE_OP_LT_DOUBLE_S64 ] = &&LABEL_BYTECODE_OP_LT_DOUBLE_S64,
819 [ BYTECODE_OP_GE_DOUBLE_S64 ] = &&LABEL_BYTECODE_OP_GE_DOUBLE_S64,
820 [ BYTECODE_OP_LE_DOUBLE_S64 ] = &&LABEL_BYTECODE_OP_LE_DOUBLE_S64,
821
822 [ BYTECODE_OP_EQ_S64_DOUBLE ] = &&LABEL_BYTECODE_OP_EQ_S64_DOUBLE,
823 [ BYTECODE_OP_NE_S64_DOUBLE ] = &&LABEL_BYTECODE_OP_NE_S64_DOUBLE,
824 [ BYTECODE_OP_GT_S64_DOUBLE ] = &&LABEL_BYTECODE_OP_GT_S64_DOUBLE,
825 [ BYTECODE_OP_LT_S64_DOUBLE ] = &&LABEL_BYTECODE_OP_LT_S64_DOUBLE,
826 [ BYTECODE_OP_GE_S64_DOUBLE ] = &&LABEL_BYTECODE_OP_GE_S64_DOUBLE,
827 [ BYTECODE_OP_LE_S64_DOUBLE ] = &&LABEL_BYTECODE_OP_LE_S64_DOUBLE,
828
829 /* unary */
830 [ BYTECODE_OP_UNARY_PLUS ] = &&LABEL_BYTECODE_OP_UNARY_PLUS,
831 [ BYTECODE_OP_UNARY_MINUS ] = &&LABEL_BYTECODE_OP_UNARY_MINUS,
832 [ BYTECODE_OP_UNARY_NOT ] = &&LABEL_BYTECODE_OP_UNARY_NOT,
833 [ BYTECODE_OP_UNARY_PLUS_S64 ] = &&LABEL_BYTECODE_OP_UNARY_PLUS_S64,
834 [ BYTECODE_OP_UNARY_MINUS_S64 ] = &&LABEL_BYTECODE_OP_UNARY_MINUS_S64,
835 [ BYTECODE_OP_UNARY_NOT_S64 ] = &&LABEL_BYTECODE_OP_UNARY_NOT_S64,
836 [ BYTECODE_OP_UNARY_PLUS_DOUBLE ] = &&LABEL_BYTECODE_OP_UNARY_PLUS_DOUBLE,
837 [ BYTECODE_OP_UNARY_MINUS_DOUBLE ] = &&LABEL_BYTECODE_OP_UNARY_MINUS_DOUBLE,
838 [ BYTECODE_OP_UNARY_NOT_DOUBLE ] = &&LABEL_BYTECODE_OP_UNARY_NOT_DOUBLE,
839
840 /* logical */
841 [ BYTECODE_OP_AND ] = &&LABEL_BYTECODE_OP_AND,
842 [ BYTECODE_OP_OR ] = &&LABEL_BYTECODE_OP_OR,
843
844 /* load field ref */
845 [ BYTECODE_OP_LOAD_FIELD_REF ] = &&LABEL_BYTECODE_OP_LOAD_FIELD_REF,
846 [ BYTECODE_OP_LOAD_FIELD_REF_STRING ] = &&LABEL_BYTECODE_OP_LOAD_FIELD_REF_STRING,
847 [ BYTECODE_OP_LOAD_FIELD_REF_SEQUENCE ] = &&LABEL_BYTECODE_OP_LOAD_FIELD_REF_SEQUENCE,
848 [ BYTECODE_OP_LOAD_FIELD_REF_S64 ] = &&LABEL_BYTECODE_OP_LOAD_FIELD_REF_S64,
849 [ BYTECODE_OP_LOAD_FIELD_REF_DOUBLE ] = &&LABEL_BYTECODE_OP_LOAD_FIELD_REF_DOUBLE,
850
851 /* load from immediate operand */
852 [ BYTECODE_OP_LOAD_STRING ] = &&LABEL_BYTECODE_OP_LOAD_STRING,
853 [ BYTECODE_OP_LOAD_STAR_GLOB_STRING ] = &&LABEL_BYTECODE_OP_LOAD_STAR_GLOB_STRING,
854 [ BYTECODE_OP_LOAD_S64 ] = &&LABEL_BYTECODE_OP_LOAD_S64,
855 [ BYTECODE_OP_LOAD_DOUBLE ] = &&LABEL_BYTECODE_OP_LOAD_DOUBLE,
856
857 /* cast */
858 [ BYTECODE_OP_CAST_TO_S64 ] = &&LABEL_BYTECODE_OP_CAST_TO_S64,
859 [ BYTECODE_OP_CAST_DOUBLE_TO_S64 ] = &&LABEL_BYTECODE_OP_CAST_DOUBLE_TO_S64,
860 [ BYTECODE_OP_CAST_NOP ] = &&LABEL_BYTECODE_OP_CAST_NOP,
861
862 /* get context ref */
863 [ BYTECODE_OP_GET_CONTEXT_REF ] = &&LABEL_BYTECODE_OP_GET_CONTEXT_REF,
864 [ BYTECODE_OP_GET_CONTEXT_REF_STRING ] = &&LABEL_BYTECODE_OP_GET_CONTEXT_REF_STRING,
865 [ BYTECODE_OP_GET_CONTEXT_REF_S64 ] = &&LABEL_BYTECODE_OP_GET_CONTEXT_REF_S64,
866 [ BYTECODE_OP_GET_CONTEXT_REF_DOUBLE ] = &&LABEL_BYTECODE_OP_GET_CONTEXT_REF_DOUBLE,
867
868 /* Instructions for recursive traversal through composed types. */
869 [ BYTECODE_OP_GET_CONTEXT_ROOT ] = &&LABEL_BYTECODE_OP_GET_CONTEXT_ROOT,
870 [ BYTECODE_OP_GET_APP_CONTEXT_ROOT ] = &&LABEL_BYTECODE_OP_GET_APP_CONTEXT_ROOT,
871 [ BYTECODE_OP_GET_PAYLOAD_ROOT ] = &&LABEL_BYTECODE_OP_GET_PAYLOAD_ROOT,
872
873 [ BYTECODE_OP_GET_SYMBOL ] = &&LABEL_BYTECODE_OP_GET_SYMBOL,
874 [ BYTECODE_OP_GET_SYMBOL_FIELD ] = &&LABEL_BYTECODE_OP_GET_SYMBOL_FIELD,
875 [ BYTECODE_OP_GET_INDEX_U16 ] = &&LABEL_BYTECODE_OP_GET_INDEX_U16,
876 [ BYTECODE_OP_GET_INDEX_U64 ] = &&LABEL_BYTECODE_OP_GET_INDEX_U64,
877
878 [ BYTECODE_OP_LOAD_FIELD ] = &&LABEL_BYTECODE_OP_LOAD_FIELD,
879 [ BYTECODE_OP_LOAD_FIELD_S8 ] = &&LABEL_BYTECODE_OP_LOAD_FIELD_S8,
880 [ BYTECODE_OP_LOAD_FIELD_S16 ] = &&LABEL_BYTECODE_OP_LOAD_FIELD_S16,
881 [ BYTECODE_OP_LOAD_FIELD_S32 ] = &&LABEL_BYTECODE_OP_LOAD_FIELD_S32,
882 [ BYTECODE_OP_LOAD_FIELD_S64 ] = &&LABEL_BYTECODE_OP_LOAD_FIELD_S64,
883 [ BYTECODE_OP_LOAD_FIELD_U8 ] = &&LABEL_BYTECODE_OP_LOAD_FIELD_U8,
884 [ BYTECODE_OP_LOAD_FIELD_U16 ] = &&LABEL_BYTECODE_OP_LOAD_FIELD_U16,
885 [ BYTECODE_OP_LOAD_FIELD_U32 ] = &&LABEL_BYTECODE_OP_LOAD_FIELD_U32,
886 [ BYTECODE_OP_LOAD_FIELD_U64 ] = &&LABEL_BYTECODE_OP_LOAD_FIELD_U64,
887 [ BYTECODE_OP_LOAD_FIELD_STRING ] = &&LABEL_BYTECODE_OP_LOAD_FIELD_STRING,
888 [ BYTECODE_OP_LOAD_FIELD_SEQUENCE ] = &&LABEL_BYTECODE_OP_LOAD_FIELD_SEQUENCE,
889 [ BYTECODE_OP_LOAD_FIELD_DOUBLE ] = &&LABEL_BYTECODE_OP_LOAD_FIELD_DOUBLE,
890
891 [ BYTECODE_OP_UNARY_BIT_NOT ] = &&LABEL_BYTECODE_OP_UNARY_BIT_NOT,
892
893 [ BYTECODE_OP_RETURN_S64 ] = &&LABEL_BYTECODE_OP_RETURN_S64,
894 };
895 #endif /* #ifndef INTERPRETER_USE_SWITCH */
896
897 START_OP
898
899 OP(BYTECODE_OP_UNKNOWN):
900 OP(BYTECODE_OP_LOAD_FIELD_REF):
901 #ifdef INTERPRETER_USE_SWITCH
902 default:
903 #endif /* INTERPRETER_USE_SWITCH */
904 ERR("unknown bytecode op %u",
905 (unsigned int) *(bytecode_opcode_t *) pc);
906 ret = -EINVAL;
907 goto end;
908
909 OP(BYTECODE_OP_RETURN):
910 /* LTTNG_INTERPRETER_DISCARD or LTTNG_INTERPRETER_RECORD_FLAG */
911 /* Handle dynamic typing. */
912 switch (estack_ax_t) {
913 case REG_S64:
914 case REG_U64:
915 retval = !!estack_ax_v;
916 break;
917 case REG_DOUBLE:
918 case REG_STRING:
919 case REG_PTR:
920 if (!output) {
921 ret = -EINVAL;
922 goto end;
923 }
924 retval = 0;
925 break;
926 case REG_STAR_GLOB_STRING:
927 case REG_UNKNOWN:
928 default:
929 ret = -EINVAL;
930 goto end;
931 }
932 ret = 0;
933 goto end;
934
935 OP(BYTECODE_OP_RETURN_S64):
936 /* LTTNG_INTERPRETER_DISCARD or LTTNG_INTERPRETER_RECORD_FLAG */
937 retval = !!estack_ax_v;
938 ret = 0;
939 goto end;
940
941 /* binary */
942 OP(BYTECODE_OP_MUL):
943 OP(BYTECODE_OP_DIV):
944 OP(BYTECODE_OP_MOD):
945 OP(BYTECODE_OP_PLUS):
946 OP(BYTECODE_OP_MINUS):
947 ERR("unsupported bytecode op %u",
948 (unsigned int) *(bytecode_opcode_t *) pc);
949 ret = -EINVAL;
950 goto end;
951
952 OP(BYTECODE_OP_EQ):
953 {
954 /* Dynamic typing. */
955 switch (estack_ax_t) {
956 case REG_S64: /* Fall-through */
957 case REG_U64:
958 switch (estack_bx_t) {
959 case REG_S64: /* Fall-through */
960 case REG_U64:
961 JUMP_TO(BYTECODE_OP_EQ_S64);
962 case REG_DOUBLE:
963 JUMP_TO(BYTECODE_OP_EQ_DOUBLE_S64);
964 case REG_STRING: /* Fall-through */
965 case REG_STAR_GLOB_STRING:
966 ret = -EINVAL;
967 goto end;
968 default:
969 ERR("Unknown interpreter register type (%d)",
970 (int) estack_bx_t);
971 ret = -EINVAL;
972 goto end;
973 }
974 break;
975 case REG_DOUBLE:
976 switch (estack_bx_t) {
977 case REG_S64: /* Fall-through */
978 case REG_U64:
979 JUMP_TO(BYTECODE_OP_EQ_S64_DOUBLE);
980 case REG_DOUBLE:
981 JUMP_TO(BYTECODE_OP_EQ_DOUBLE);
982 case REG_STRING: /* Fall-through */
983 case REG_STAR_GLOB_STRING:
984 ret = -EINVAL;
985 goto end;
986 default:
987 ERR("Unknown interpreter register type (%d)",
988 (int) estack_bx_t);
989 ret = -EINVAL;
990 goto end;
991 }
992 break;
993 case REG_STRING:
994 switch (estack_bx_t) {
995 case REG_S64: /* Fall-through */
996 case REG_U64: /* Fall-through */
997 case REG_DOUBLE:
998 ret = -EINVAL;
999 goto end;
1000 case REG_STRING:
1001 JUMP_TO(BYTECODE_OP_EQ_STRING);
1002 case REG_STAR_GLOB_STRING:
1003 JUMP_TO(BYTECODE_OP_EQ_STAR_GLOB_STRING);
1004 default:
1005 ERR("Unknown interpreter register type (%d)",
1006 (int) estack_bx_t);
1007 ret = -EINVAL;
1008 goto end;
1009 }
1010 break;
1011 case REG_STAR_GLOB_STRING:
1012 switch (estack_bx_t) {
1013 case REG_S64: /* Fall-through */
1014 case REG_U64: /* Fall-through */
1015 case REG_DOUBLE:
1016 ret = -EINVAL;
1017 goto end;
1018 case REG_STRING:
1019 JUMP_TO(BYTECODE_OP_EQ_STAR_GLOB_STRING);
1020 case REG_STAR_GLOB_STRING:
1021 ret = -EINVAL;
1022 goto end;
1023 default:
1024 ERR("Unknown interpreter register type (%d)",
1025 (int) estack_bx_t);
1026 ret = -EINVAL;
1027 goto end;
1028 }
1029 break;
1030 default:
1031 ERR("Unknown interpreter register type (%d)",
1032 (int) estack_ax_t);
1033 ret = -EINVAL;
1034 goto end;
1035 }
1036 }
1037 OP(BYTECODE_OP_NE):
1038 {
1039 /* Dynamic typing. */
1040 switch (estack_ax_t) {
1041 case REG_S64: /* Fall-through */
1042 case REG_U64:
1043 switch (estack_bx_t) {
1044 case REG_S64: /* Fall-through */
1045 case REG_U64:
1046 JUMP_TO(BYTECODE_OP_NE_S64);
1047 case REG_DOUBLE:
1048 JUMP_TO(BYTECODE_OP_NE_DOUBLE_S64);
1049 case REG_STRING: /* Fall-through */
1050 case REG_STAR_GLOB_STRING:
1051 ret = -EINVAL;
1052 goto end;
1053 default:
1054 ERR("Unknown interpreter register type (%d)",
1055 (int) estack_bx_t);
1056 ret = -EINVAL;
1057 goto end;
1058 }
1059 break;
1060 case REG_DOUBLE:
1061 switch (estack_bx_t) {
1062 case REG_S64: /* Fall-through */
1063 case REG_U64:
1064 JUMP_TO(BYTECODE_OP_NE_S64_DOUBLE);
1065 case REG_DOUBLE:
1066 JUMP_TO(BYTECODE_OP_NE_DOUBLE);
1067 case REG_STRING: /* Fall-through */
1068 case REG_STAR_GLOB_STRING:
1069 ret = -EINVAL;
1070 goto end;
1071 default:
1072 ERR("Unknown interpreter register type (%d)",
1073 (int) estack_bx_t);
1074 ret = -EINVAL;
1075 goto end;
1076 }
1077 break;
1078 case REG_STRING:
1079 switch (estack_bx_t) {
1080 case REG_S64: /* Fall-through */
1081 case REG_U64:
1082 case REG_DOUBLE:
1083 ret = -EINVAL;
1084 goto end;
1085 case REG_STRING:
1086 JUMP_TO(BYTECODE_OP_NE_STRING);
1087 case REG_STAR_GLOB_STRING:
1088 JUMP_TO(BYTECODE_OP_NE_STAR_GLOB_STRING);
1089 default:
1090 ERR("Unknown interpreter register type (%d)",
1091 (int) estack_bx_t);
1092 ret = -EINVAL;
1093 goto end;
1094 }
1095 break;
1096 case REG_STAR_GLOB_STRING:
1097 switch (estack_bx_t) {
1098 case REG_S64: /* Fall-through */
1099 case REG_U64:
1100 case REG_DOUBLE:
1101 ret = -EINVAL;
1102 goto end;
1103 case REG_STRING:
1104 JUMP_TO(BYTECODE_OP_NE_STAR_GLOB_STRING);
1105 case REG_STAR_GLOB_STRING:
1106 ret = -EINVAL;
1107 goto end;
1108 default:
1109 ERR("Unknown interpreter register type (%d)",
1110 (int) estack_bx_t);
1111 ret = -EINVAL;
1112 goto end;
1113 }
1114 break;
1115 default:
1116 ERR("Unknown interpreter register type (%d)",
1117 (int) estack_ax_t);
1118 ret = -EINVAL;
1119 goto end;
1120 }
1121 }
1122 OP(BYTECODE_OP_GT):
1123 {
1124 /* Dynamic typing. */
1125 switch (estack_ax_t) {
1126 case REG_S64: /* Fall-through */
1127 case REG_U64:
1128 switch (estack_bx_t) {
1129 case REG_S64: /* Fall-through */
1130 case REG_U64:
1131 JUMP_TO(BYTECODE_OP_GT_S64);
1132 case REG_DOUBLE:
1133 JUMP_TO(BYTECODE_OP_GT_DOUBLE_S64);
1134 case REG_STRING: /* Fall-through */
1135 case REG_STAR_GLOB_STRING:
1136 ret = -EINVAL;
1137 goto end;
1138 default:
1139 ERR("Unknown interpreter register type (%d)",
1140 (int) estack_bx_t);
1141 ret = -EINVAL;
1142 goto end;
1143 }
1144 break;
1145 case REG_DOUBLE:
1146 switch (estack_bx_t) {
1147 case REG_S64: /* Fall-through */
1148 case REG_U64:
1149 JUMP_TO(BYTECODE_OP_GT_S64_DOUBLE);
1150 case REG_DOUBLE:
1151 JUMP_TO(BYTECODE_OP_GT_DOUBLE);
1152 case REG_STRING: /* Fall-through */
1153 case REG_STAR_GLOB_STRING:
1154 ret = -EINVAL;
1155 goto end;
1156 default:
1157 ERR("Unknown interpreter register type (%d)",
1158 (int) estack_bx_t);
1159 ret = -EINVAL;
1160 goto end;
1161 }
1162 break;
1163 case REG_STRING:
1164 switch (estack_bx_t) {
1165 case REG_S64: /* Fall-through */
1166 case REG_U64: /* Fall-through */
1167 case REG_DOUBLE: /* Fall-through */
1168 case REG_STAR_GLOB_STRING:
1169 ret = -EINVAL;
1170 goto end;
1171 case REG_STRING:
1172 JUMP_TO(BYTECODE_OP_GT_STRING);
1173 default:
1174 ERR("Unknown interpreter register type (%d)",
1175 (int) estack_bx_t);
1176 ret = -EINVAL;
1177 goto end;
1178 }
1179 break;
1180 default:
1181 ERR("Unknown interpreter register type (%d)",
1182 (int) estack_ax_t);
1183 ret = -EINVAL;
1184 goto end;
1185 }
1186 }
1187 OP(BYTECODE_OP_LT):
1188 {
1189 /* Dynamic typing. */
1190 switch (estack_ax_t) {
1191 case REG_S64: /* Fall-through */
1192 case REG_U64:
1193 switch (estack_bx_t) {
1194 case REG_S64: /* Fall-through */
1195 case REG_U64:
1196 JUMP_TO(BYTECODE_OP_LT_S64);
1197 case REG_DOUBLE:
1198 JUMP_TO(BYTECODE_OP_LT_DOUBLE_S64);
1199 case REG_STRING: /* Fall-through */
1200 case REG_STAR_GLOB_STRING:
1201 ret = -EINVAL;
1202 goto end;
1203 default:
1204 ERR("Unknown interpreter register type (%d)",
1205 (int) estack_bx_t);
1206 ret = -EINVAL;
1207 goto end;
1208 }
1209 break;
1210 case REG_DOUBLE:
1211 switch (estack_bx_t) {
1212 case REG_S64: /* Fall-through */
1213 case REG_U64:
1214 JUMP_TO(BYTECODE_OP_LT_S64_DOUBLE);
1215 case REG_DOUBLE:
1216 JUMP_TO(BYTECODE_OP_LT_DOUBLE);
1217 case REG_STRING: /* Fall-through */
1218 case REG_STAR_GLOB_STRING:
1219 ret = -EINVAL;
1220 goto end;
1221 default:
1222 ERR("Unknown interpreter register type (%d)",
1223 (int) estack_bx_t);
1224 ret = -EINVAL;
1225 goto end;
1226 }
1227 break;
1228 case REG_STRING:
1229 switch (estack_bx_t) {
1230 case REG_S64: /* Fall-through */
1231 case REG_U64: /* Fall-through */
1232 case REG_DOUBLE: /* Fall-through */
1233 case REG_STAR_GLOB_STRING:
1234 ret = -EINVAL;
1235 goto end;
1236 case REG_STRING:
1237 JUMP_TO(BYTECODE_OP_LT_STRING);
1238 default:
1239 ERR("Unknown interpreter register type (%d)",
1240 (int) estack_bx_t);
1241 ret = -EINVAL;
1242 goto end;
1243 }
1244 break;
1245 default:
1246 ERR("Unknown interpreter register type (%d)",
1247 (int) estack_ax_t);
1248 ret = -EINVAL;
1249 goto end;
1250 }
1251 }
1252 OP(BYTECODE_OP_GE):
1253 {
1254 /* Dynamic typing. */
1255 switch (estack_ax_t) {
1256 case REG_S64: /* Fall-through */
1257 case REG_U64:
1258 switch (estack_bx_t) {
1259 case REG_S64: /* Fall-through */
1260 case REG_U64:
1261 JUMP_TO(BYTECODE_OP_GE_S64);
1262 case REG_DOUBLE:
1263 JUMP_TO(BYTECODE_OP_GE_DOUBLE_S64);
1264 case REG_STRING: /* Fall-through */
1265 case REG_STAR_GLOB_STRING:
1266 ret = -EINVAL;
1267 goto end;
1268 default:
1269 ERR("Unknown interpreter register type (%d)",
1270 (int) estack_bx_t);
1271 ret = -EINVAL;
1272 goto end;
1273 }
1274 break;
1275 case REG_DOUBLE:
1276 switch (estack_bx_t) {
1277 case REG_S64: /* Fall-through */
1278 case REG_U64:
1279 JUMP_TO(BYTECODE_OP_GE_S64_DOUBLE);
1280 case REG_DOUBLE:
1281 JUMP_TO(BYTECODE_OP_GE_DOUBLE);
1282 case REG_STRING: /* Fall-through */
1283 case REG_STAR_GLOB_STRING:
1284 ret = -EINVAL;
1285 goto end;
1286 default:
1287 ERR("Unknown interpreter register type (%d)",
1288 (int) estack_bx_t);
1289 ret = -EINVAL;
1290 goto end;
1291 }
1292 break;
1293 case REG_STRING:
1294 switch (estack_bx_t) {
1295 case REG_S64: /* Fall-through */
1296 case REG_U64: /* Fall-through */
1297 case REG_DOUBLE: /* Fall-through */
1298 case REG_STAR_GLOB_STRING:
1299 ret = -EINVAL;
1300 goto end;
1301 case REG_STRING:
1302 JUMP_TO(BYTECODE_OP_GE_STRING);
1303 default:
1304 ERR("Unknown interpreter register type (%d)",
1305 (int) estack_bx_t);
1306 ret = -EINVAL;
1307 goto end;
1308 }
1309 break;
1310 default:
1311 ERR("Unknown interpreter register type (%d)",
1312 (int) estack_ax_t);
1313 ret = -EINVAL;
1314 goto end;
1315 }
1316 }
1317 OP(BYTECODE_OP_LE):
1318 {
1319 /* Dynamic typing. */
1320 switch (estack_ax_t) {
1321 case REG_S64: /* Fall-through */
1322 case REG_U64:
1323 switch (estack_bx_t) {
1324 case REG_S64: /* Fall-through */
1325 case REG_U64:
1326 JUMP_TO(BYTECODE_OP_LE_S64);
1327 case REG_DOUBLE:
1328 JUMP_TO(BYTECODE_OP_LE_DOUBLE_S64);
1329 case REG_STRING: /* Fall-through */
1330 case REG_STAR_GLOB_STRING:
1331 ret = -EINVAL;
1332 goto end;
1333 default:
1334 ERR("Unknown interpreter register type (%d)",
1335 (int) estack_bx_t);
1336 ret = -EINVAL;
1337 goto end;
1338 }
1339 break;
1340 case REG_DOUBLE:
1341 switch (estack_bx_t) {
1342 case REG_S64: /* Fall-through */
1343 case REG_U64:
1344 JUMP_TO(BYTECODE_OP_LE_S64_DOUBLE);
1345 case REG_DOUBLE:
1346 JUMP_TO(BYTECODE_OP_LE_DOUBLE);
1347 case REG_STRING: /* Fall-through */
1348 case REG_STAR_GLOB_STRING:
1349 ret = -EINVAL;
1350 goto end;
1351 default:
1352 ERR("Unknown interpreter register type (%d)",
1353 (int) estack_bx_t);
1354 ret = -EINVAL;
1355 goto end;
1356 }
1357 break;
1358 case REG_STRING:
1359 switch (estack_bx_t) {
1360 case REG_S64: /* Fall-through */
1361 case REG_U64: /* Fall-through */
1362 case REG_DOUBLE: /* Fall-through */
1363 case REG_STAR_GLOB_STRING:
1364 ret = -EINVAL;
1365 goto end;
1366 case REG_STRING:
1367 JUMP_TO(BYTECODE_OP_LE_STRING);
1368 default:
1369 ERR("Unknown interpreter register type (%d)",
1370 (int) estack_bx_t);
1371 ret = -EINVAL;
1372 goto end;
1373 }
1374 break;
1375 default:
1376 ERR("Unknown interpreter register type (%d)",
1377 (int) estack_ax_t);
1378 ret = -EINVAL;
1379 goto end;
1380 }
1381 }
1382
1383 OP(BYTECODE_OP_EQ_STRING):
1384 {
1385 int res;
1386
1387 res = (stack_strcmp(stack, top, "==") == 0);
1388 estack_pop(stack, top, ax, bx, ax_t, bx_t);
1389 estack_ax_v = res;
1390 estack_ax_t = REG_S64;
1391 next_pc += sizeof(struct binary_op);
1392 PO;
1393 }
1394 OP(BYTECODE_OP_NE_STRING):
1395 {
1396 int res;
1397
1398 res = (stack_strcmp(stack, top, "!=") != 0);
1399 estack_pop(stack, top, ax, bx, ax_t, bx_t);
1400 estack_ax_v = res;
1401 estack_ax_t = REG_S64;
1402 next_pc += sizeof(struct binary_op);
1403 PO;
1404 }
1405 OP(BYTECODE_OP_GT_STRING):
1406 {
1407 int res;
1408
1409 res = (stack_strcmp(stack, top, ">") > 0);
1410 estack_pop(stack, top, ax, bx, ax_t, bx_t);
1411 estack_ax_v = res;
1412 estack_ax_t = REG_S64;
1413 next_pc += sizeof(struct binary_op);
1414 PO;
1415 }
1416 OP(BYTECODE_OP_LT_STRING):
1417 {
1418 int res;
1419
1420 res = (stack_strcmp(stack, top, "<") < 0);
1421 estack_pop(stack, top, ax, bx, ax_t, bx_t);
1422 estack_ax_v = res;
1423 estack_ax_t = REG_S64;
1424 next_pc += sizeof(struct binary_op);
1425 PO;
1426 }
1427 OP(BYTECODE_OP_GE_STRING):
1428 {
1429 int res;
1430
1431 res = (stack_strcmp(stack, top, ">=") >= 0);
1432 estack_pop(stack, top, ax, bx, ax_t, bx_t);
1433 estack_ax_v = res;
1434 estack_ax_t = REG_S64;
1435 next_pc += sizeof(struct binary_op);
1436 PO;
1437 }
1438 OP(BYTECODE_OP_LE_STRING):
1439 {
1440 int res;
1441
1442 res = (stack_strcmp(stack, top, "<=") <= 0);
1443 estack_pop(stack, top, ax, bx, ax_t, bx_t);
1444 estack_ax_v = res;
1445 estack_ax_t = REG_S64;
1446 next_pc += sizeof(struct binary_op);
1447 PO;
1448 }
1449
1450 OP(BYTECODE_OP_EQ_STAR_GLOB_STRING):
1451 {
1452 int res;
1453
1454 res = (stack_star_glob_match(stack, top, "==") == 0);
1455 estack_pop(stack, top, ax, bx, ax_t, bx_t);
1456 estack_ax_v = res;
1457 estack_ax_t = REG_S64;
1458 next_pc += sizeof(struct binary_op);
1459 PO;
1460 }
1461 OP(BYTECODE_OP_NE_STAR_GLOB_STRING):
1462 {
1463 int res;
1464
1465 res = (stack_star_glob_match(stack, top, "!=") != 0);
1466 estack_pop(stack, top, ax, bx, ax_t, bx_t);
1467 estack_ax_v = res;
1468 estack_ax_t = REG_S64;
1469 next_pc += sizeof(struct binary_op);
1470 PO;
1471 }
1472
1473 OP(BYTECODE_OP_EQ_S64):
1474 {
1475 int res;
1476
1477 res = (estack_bx_v == estack_ax_v);
1478 estack_pop(stack, top, ax, bx, ax_t, bx_t);
1479 estack_ax_v = res;
1480 estack_ax_t = REG_S64;
1481 next_pc += sizeof(struct binary_op);
1482 PO;
1483 }
1484 OP(BYTECODE_OP_NE_S64):
1485 {
1486 int res;
1487
1488 res = (estack_bx_v != estack_ax_v);
1489 estack_pop(stack, top, ax, bx, ax_t, bx_t);
1490 estack_ax_v = res;
1491 estack_ax_t = REG_S64;
1492 next_pc += sizeof(struct binary_op);
1493 PO;
1494 }
1495 OP(BYTECODE_OP_GT_S64):
1496 {
1497 int res;
1498
1499 res = (estack_bx_v > estack_ax_v);
1500 estack_pop(stack, top, ax, bx, ax_t, bx_t);
1501 estack_ax_v = res;
1502 estack_ax_t = REG_S64;
1503 next_pc += sizeof(struct binary_op);
1504 PO;
1505 }
1506 OP(BYTECODE_OP_LT_S64):
1507 {
1508 int res;
1509
1510 res = (estack_bx_v < estack_ax_v);
1511 estack_pop(stack, top, ax, bx, ax_t, bx_t);
1512 estack_ax_v = res;
1513 estack_ax_t = REG_S64;
1514 next_pc += sizeof(struct binary_op);
1515 PO;
1516 }
1517 OP(BYTECODE_OP_GE_S64):
1518 {
1519 int res;
1520
1521 res = (estack_bx_v >= estack_ax_v);
1522 estack_pop(stack, top, ax, bx, ax_t, bx_t);
1523 estack_ax_v = res;
1524 estack_ax_t = REG_S64;
1525 next_pc += sizeof(struct binary_op);
1526 PO;
1527 }
1528 OP(BYTECODE_OP_LE_S64):
1529 {
1530 int res;
1531
1532 res = (estack_bx_v <= estack_ax_v);
1533 estack_pop(stack, top, ax, bx, ax_t, bx_t);
1534 estack_ax_v = res;
1535 estack_ax_t = REG_S64;
1536 next_pc += sizeof(struct binary_op);
1537 PO;
1538 }
1539
1540 OP(BYTECODE_OP_EQ_DOUBLE):
1541 {
1542 int res;
1543
1544 res = (estack_bx(stack, top)->u.d == estack_ax(stack, top)->u.d);
1545 estack_pop(stack, top, ax, bx, ax_t, bx_t);
1546 estack_ax_v = res;
1547 estack_ax_t = REG_S64;
1548 next_pc += sizeof(struct binary_op);
1549 PO;
1550 }
1551 OP(BYTECODE_OP_NE_DOUBLE):
1552 {
1553 int res;
1554
1555 res = (estack_bx(stack, top)->u.d != estack_ax(stack, top)->u.d);
1556 estack_pop(stack, top, ax, bx, ax_t, bx_t);
1557 estack_ax_v = res;
1558 estack_ax_t = REG_S64;
1559 next_pc += sizeof(struct binary_op);
1560 PO;
1561 }
1562 OP(BYTECODE_OP_GT_DOUBLE):
1563 {
1564 int res;
1565
1566 res = (estack_bx(stack, top)->u.d > estack_ax(stack, top)->u.d);
1567 estack_pop(stack, top, ax, bx, ax_t, bx_t);
1568 estack_ax_v = res;
1569 estack_ax_t = REG_S64;
1570 next_pc += sizeof(struct binary_op);
1571 PO;
1572 }
1573 OP(BYTECODE_OP_LT_DOUBLE):
1574 {
1575 int res;
1576
1577 res = (estack_bx(stack, top)->u.d < estack_ax(stack, top)->u.d);
1578 estack_pop(stack, top, ax, bx, ax_t, bx_t);
1579 estack_ax_v = res;
1580 estack_ax_t = REG_S64;
1581 next_pc += sizeof(struct binary_op);
1582 PO;
1583 }
1584 OP(BYTECODE_OP_GE_DOUBLE):
1585 {
1586 int res;
1587
1588 res = (estack_bx(stack, top)->u.d >= estack_ax(stack, top)->u.d);
1589 estack_pop(stack, top, ax, bx, ax_t, bx_t);
1590 estack_ax_v = res;
1591 estack_ax_t = REG_S64;
1592 next_pc += sizeof(struct binary_op);
1593 PO;
1594 }
1595 OP(BYTECODE_OP_LE_DOUBLE):
1596 {
1597 int res;
1598
1599 res = (estack_bx(stack, top)->u.d <= estack_ax(stack, top)->u.d);
1600 estack_pop(stack, top, ax, bx, ax_t, bx_t);
1601 estack_ax_v = res;
1602 estack_ax_t = REG_S64;
1603 next_pc += sizeof(struct binary_op);
1604 PO;
1605 }
1606
1607 /* Mixed S64-double binary comparators */
1608 OP(BYTECODE_OP_EQ_DOUBLE_S64):
1609 {
1610 int res;
1611
1612 res = (estack_bx(stack, top)->u.d == estack_ax_v);
1613 estack_pop(stack, top, ax, bx, ax_t, bx_t);
1614 estack_ax_v = res;
1615 estack_ax_t = REG_S64;
1616 next_pc += sizeof(struct binary_op);
1617 PO;
1618 }
1619 OP(BYTECODE_OP_NE_DOUBLE_S64):
1620 {
1621 int res;
1622
1623 res = (estack_bx(stack, top)->u.d != estack_ax_v);
1624 estack_pop(stack, top, ax, bx, ax_t, bx_t);
1625 estack_ax_v = res;
1626 estack_ax_t = REG_S64;
1627 next_pc += sizeof(struct binary_op);
1628 PO;
1629 }
1630 OP(BYTECODE_OP_GT_DOUBLE_S64):
1631 {
1632 int res;
1633
1634 res = (estack_bx(stack, top)->u.d > estack_ax_v);
1635 estack_pop(stack, top, ax, bx, ax_t, bx_t);
1636 estack_ax_v = res;
1637 estack_ax_t = REG_S64;
1638 next_pc += sizeof(struct binary_op);
1639 PO;
1640 }
1641 OP(BYTECODE_OP_LT_DOUBLE_S64):
1642 {
1643 int res;
1644
1645 res = (estack_bx(stack, top)->u.d < estack_ax_v);
1646 estack_pop(stack, top, ax, bx, ax_t, bx_t);
1647 estack_ax_v = res;
1648 estack_ax_t = REG_S64;
1649 next_pc += sizeof(struct binary_op);
1650 PO;
1651 }
1652 OP(BYTECODE_OP_GE_DOUBLE_S64):
1653 {
1654 int res;
1655
1656 res = (estack_bx(stack, top)->u.d >= estack_ax_v);
1657 estack_pop(stack, top, ax, bx, ax_t, bx_t);
1658 estack_ax_v = res;
1659 estack_ax_t = REG_S64;
1660 next_pc += sizeof(struct binary_op);
1661 PO;
1662 }
1663 OP(BYTECODE_OP_LE_DOUBLE_S64):
1664 {
1665 int res;
1666
1667 res = (estack_bx(stack, top)->u.d <= estack_ax_v);
1668 estack_pop(stack, top, ax, bx, ax_t, bx_t);
1669 estack_ax_v = res;
1670 estack_ax_t = REG_S64;
1671 next_pc += sizeof(struct binary_op);
1672 PO;
1673 }
1674
1675 OP(BYTECODE_OP_EQ_S64_DOUBLE):
1676 {
1677 int res;
1678
1679 res = (estack_bx_v == estack_ax(stack, top)->u.d);
1680 estack_pop(stack, top, ax, bx, ax_t, bx_t);
1681 estack_ax_v = res;
1682 estack_ax_t = REG_S64;
1683 next_pc += sizeof(struct binary_op);
1684 PO;
1685 }
1686 OP(BYTECODE_OP_NE_S64_DOUBLE):
1687 {
1688 int res;
1689
1690 res = (estack_bx_v != estack_ax(stack, top)->u.d);
1691 estack_pop(stack, top, ax, bx, ax_t, bx_t);
1692 estack_ax_v = res;
1693 estack_ax_t = REG_S64;
1694 next_pc += sizeof(struct binary_op);
1695 PO;
1696 }
1697 OP(BYTECODE_OP_GT_S64_DOUBLE):
1698 {
1699 int res;
1700
1701 res = (estack_bx_v > estack_ax(stack, top)->u.d);
1702 estack_pop(stack, top, ax, bx, ax_t, bx_t);
1703 estack_ax_v = res;
1704 estack_ax_t = REG_S64;
1705 next_pc += sizeof(struct binary_op);
1706 PO;
1707 }
1708 OP(BYTECODE_OP_LT_S64_DOUBLE):
1709 {
1710 int res;
1711
1712 res = (estack_bx_v < estack_ax(stack, top)->u.d);
1713 estack_pop(stack, top, ax, bx, ax_t, bx_t);
1714 estack_ax_v = res;
1715 estack_ax_t = REG_S64;
1716 next_pc += sizeof(struct binary_op);
1717 PO;
1718 }
1719 OP(BYTECODE_OP_GE_S64_DOUBLE):
1720 {
1721 int res;
1722
1723 res = (estack_bx_v >= estack_ax(stack, top)->u.d);
1724 estack_pop(stack, top, ax, bx, ax_t, bx_t);
1725 estack_ax_v = res;
1726 estack_ax_t = REG_S64;
1727 next_pc += sizeof(struct binary_op);
1728 PO;
1729 }
1730 OP(BYTECODE_OP_LE_S64_DOUBLE):
1731 {
1732 int res;
1733
1734 res = (estack_bx_v <= estack_ax(stack, top)->u.d);
1735 estack_pop(stack, top, ax, bx, ax_t, bx_t);
1736 estack_ax_v = res;
1737 estack_ax_t = REG_S64;
1738 next_pc += sizeof(struct binary_op);
1739 PO;
1740 }
1741 OP(BYTECODE_OP_BIT_RSHIFT):
1742 {
1743 int64_t res;
1744
1745 if (!IS_INTEGER_REGISTER(estack_ax_t) || !IS_INTEGER_REGISTER(estack_bx_t)) {
1746 ret = -EINVAL;
1747 goto end;
1748 }
1749
1750 /* Catch undefined behavior. */
1751 if (caa_unlikely(estack_ax_v < 0 || estack_ax_v >= 64)) {
1752 ret = -EINVAL;
1753 goto end;
1754 }
1755 res = ((uint64_t) estack_bx_v >> (uint32_t) estack_ax_v);
1756 estack_pop(stack, top, ax, bx, ax_t, bx_t);
1757 estack_ax_v = res;
1758 estack_ax_t = REG_U64;
1759 next_pc += sizeof(struct binary_op);
1760 PO;
1761 }
1762 OP(BYTECODE_OP_BIT_LSHIFT):
1763 {
1764 int64_t res;
1765
1766 if (!IS_INTEGER_REGISTER(estack_ax_t) || !IS_INTEGER_REGISTER(estack_bx_t)) {
1767 ret = -EINVAL;
1768 goto end;
1769 }
1770
1771 /* Catch undefined behavior. */
1772 if (caa_unlikely(estack_ax_v < 0 || estack_ax_v >= 64)) {
1773 ret = -EINVAL;
1774 goto end;
1775 }
1776 res = ((uint64_t) estack_bx_v << (uint32_t) estack_ax_v);
1777 estack_pop(stack, top, ax, bx, ax_t, bx_t);
1778 estack_ax_v = res;
1779 estack_ax_t = REG_U64;
1780 next_pc += sizeof(struct binary_op);
1781 PO;
1782 }
1783 OP(BYTECODE_OP_BIT_AND):
1784 {
1785 int64_t res;
1786
1787 if (!IS_INTEGER_REGISTER(estack_ax_t) || !IS_INTEGER_REGISTER(estack_bx_t)) {
1788 ret = -EINVAL;
1789 goto end;
1790 }
1791
1792 res = ((uint64_t) estack_bx_v & (uint64_t) estack_ax_v);
1793 estack_pop(stack, top, ax, bx, ax_t, bx_t);
1794 estack_ax_v = res;
1795 estack_ax_t = REG_U64;
1796 next_pc += sizeof(struct binary_op);
1797 PO;
1798 }
1799 OP(BYTECODE_OP_BIT_OR):
1800 {
1801 int64_t res;
1802
1803 if (!IS_INTEGER_REGISTER(estack_ax_t) || !IS_INTEGER_REGISTER(estack_bx_t)) {
1804 ret = -EINVAL;
1805 goto end;
1806 }
1807
1808 res = ((uint64_t) estack_bx_v | (uint64_t) estack_ax_v);
1809 estack_pop(stack, top, ax, bx, ax_t, bx_t);
1810 estack_ax_v = res;
1811 estack_ax_t = REG_U64;
1812 next_pc += sizeof(struct binary_op);
1813 PO;
1814 }
1815 OP(BYTECODE_OP_BIT_XOR):
1816 {
1817 int64_t res;
1818
1819 if (!IS_INTEGER_REGISTER(estack_ax_t) || !IS_INTEGER_REGISTER(estack_bx_t)) {
1820 ret = -EINVAL;
1821 goto end;
1822 }
1823
1824 res = ((uint64_t) estack_bx_v ^ (uint64_t) estack_ax_v);
1825 estack_pop(stack, top, ax, bx, ax_t, bx_t);
1826 estack_ax_v = res;
1827 estack_ax_t = REG_U64;
1828 next_pc += sizeof(struct binary_op);
1829 PO;
1830 }
1831
1832 /* unary */
1833 OP(BYTECODE_OP_UNARY_PLUS):
1834 {
1835 /* Dynamic typing. */
1836 switch (estack_ax_t) {
1837 case REG_S64: /* Fall-through. */
1838 case REG_U64:
1839 JUMP_TO(BYTECODE_OP_UNARY_PLUS_S64);
1840 case REG_DOUBLE:
1841 JUMP_TO(BYTECODE_OP_UNARY_PLUS_DOUBLE);
1842 case REG_STRING: /* Fall-through */
1843 case REG_STAR_GLOB_STRING:
1844 ret = -EINVAL;
1845 goto end;
1846 default:
1847 ERR("Unknown interpreter register type (%d)",
1848 (int) estack_ax_t);
1849 ret = -EINVAL;
1850 goto end;
1851 }
1852 }
1853 OP(BYTECODE_OP_UNARY_MINUS):
1854 {
1855 /* Dynamic typing. */
1856 switch (estack_ax_t) {
1857 case REG_S64: /* Fall-through. */
1858 case REG_U64:
1859 JUMP_TO(BYTECODE_OP_UNARY_MINUS_S64);
1860 case REG_DOUBLE:
1861 JUMP_TO(BYTECODE_OP_UNARY_MINUS_DOUBLE);
1862 case REG_STRING: /* Fall-through */
1863 case REG_STAR_GLOB_STRING:
1864 ret = -EINVAL;
1865 goto end;
1866 default:
1867 ERR("Unknown interpreter register type (%d)",
1868 (int) estack_ax_t);
1869 ret = -EINVAL;
1870 goto end;
1871 }
1872 }
1873 OP(BYTECODE_OP_UNARY_NOT):
1874 {
1875 /* Dynamic typing. */
1876 switch (estack_ax_t) {
1877 case REG_S64: /* Fall-through. */
1878 case REG_U64:
1879 JUMP_TO(BYTECODE_OP_UNARY_NOT_S64);
1880 case REG_DOUBLE:
1881 JUMP_TO(BYTECODE_OP_UNARY_NOT_DOUBLE);
1882 case REG_STRING: /* Fall-through */
1883 case REG_STAR_GLOB_STRING:
1884 ret = -EINVAL;
1885 goto end;
1886 default:
1887 ERR("Unknown interpreter register type (%d)",
1888 (int) estack_ax_t);
1889 ret = -EINVAL;
1890 goto end;
1891 }
1892 next_pc += sizeof(struct unary_op);
1893 PO;
1894 }
1895
1896 OP(BYTECODE_OP_UNARY_BIT_NOT):
1897 {
1898 /* Dynamic typing. */
1899 if (!IS_INTEGER_REGISTER(estack_ax_t)) {
1900 ret = -EINVAL;
1901 goto end;
1902 }
1903
1904 estack_ax_v = ~(uint64_t) estack_ax_v;
1905 estack_ax_t = REG_U64;
1906 next_pc += sizeof(struct unary_op);
1907 PO;
1908 }
1909
1910 OP(BYTECODE_OP_UNARY_PLUS_S64):
1911 OP(BYTECODE_OP_UNARY_PLUS_DOUBLE):
1912 {
1913 next_pc += sizeof(struct unary_op);
1914 PO;
1915 }
1916 OP(BYTECODE_OP_UNARY_MINUS_S64):
1917 {
1918 estack_ax_v = -estack_ax_v;
1919 next_pc += sizeof(struct unary_op);
1920 PO;
1921 }
1922 OP(BYTECODE_OP_UNARY_MINUS_DOUBLE):
1923 {
1924 estack_ax(stack, top)->u.d = -estack_ax(stack, top)->u.d;
1925 next_pc += sizeof(struct unary_op);
1926 PO;
1927 }
1928 OP(BYTECODE_OP_UNARY_NOT_S64):
1929 {
1930 estack_ax_v = !estack_ax_v;
1931 estack_ax_t = REG_S64;
1932 next_pc += sizeof(struct unary_op);
1933 PO;
1934 }
1935 OP(BYTECODE_OP_UNARY_NOT_DOUBLE):
1936 {
1937 estack_ax_v = !estack_ax(stack, top)->u.d;
1938 estack_ax_t = REG_S64;
1939 next_pc += sizeof(struct unary_op);
1940 PO;
1941 }
1942
1943 /* logical */
1944 OP(BYTECODE_OP_AND):
1945 {
1946 struct logical_op *insn = (struct logical_op *) pc;
1947
1948 if (estack_ax_t != REG_S64 && estack_ax_t != REG_U64) {
1949 ret = -EINVAL;
1950 goto end;
1951 }
1952 /* If AX is 0, skip and evaluate to 0 */
1953 if (unlikely(estack_ax_v == 0)) {
1954 dbg_printf("Jumping to bytecode offset %u\n",
1955 (unsigned int) insn->skip_offset);
1956 next_pc = start_pc + insn->skip_offset;
1957 } else {
1958 /* Pop 1 when jump not taken */
1959 estack_pop(stack, top, ax, bx, ax_t, bx_t);
1960 next_pc += sizeof(struct logical_op);
1961 }
1962 PO;
1963 }
1964 OP(BYTECODE_OP_OR):
1965 {
1966 struct logical_op *insn = (struct logical_op *) pc;
1967
1968 if (estack_ax_t != REG_S64 && estack_ax_t != REG_U64) {
1969 ret = -EINVAL;
1970 goto end;
1971 }
1972 /* If AX is nonzero, skip and evaluate to 1 */
1973 if (unlikely(estack_ax_v != 0)) {
1974 estack_ax_v = 1;
1975 dbg_printf("Jumping to bytecode offset %u\n",
1976 (unsigned int) insn->skip_offset);
1977 next_pc = start_pc + insn->skip_offset;
1978 } else {
1979 /* Pop 1 when jump not taken */
1980 estack_pop(stack, top, ax, bx, ax_t, bx_t);
1981 next_pc += sizeof(struct logical_op);
1982 }
1983 PO;
1984 }
1985
1986
1987 /* load field ref */
1988 OP(BYTECODE_OP_LOAD_FIELD_REF_STRING):
1989 {
1990 struct load_op *insn = (struct load_op *) pc;
1991 struct field_ref *ref = (struct field_ref *) insn->data;
1992
1993 dbg_printf("load field ref offset %u type string\n",
1994 ref->offset);
1995 estack_push(stack, top, ax, bx, ax_t, bx_t);
1996 estack_ax(stack, top)->u.s.str =
1997 *(const char * const *) &interpreter_stack_data[ref->offset];
1998 if (unlikely(!estack_ax(stack, top)->u.s.str)) {
1999 dbg_printf("Interpreter warning: loading a NULL string.\n");
2000 ret = -EINVAL;
2001 goto end;
2002 }
2003 estack_ax(stack, top)->u.s.seq_len = SIZE_MAX;
2004 estack_ax(stack, top)->u.s.literal_type =
2005 ESTACK_STRING_LITERAL_TYPE_NONE;
2006 estack_ax_t = REG_STRING;
2007 dbg_printf("ref load string %s\n", estack_ax(stack, top)->u.s.str);
2008 next_pc += sizeof(struct load_op) + sizeof(struct field_ref);
2009 PO;
2010 }
2011
2012 OP(BYTECODE_OP_LOAD_FIELD_REF_SEQUENCE):
2013 {
2014 struct load_op *insn = (struct load_op *) pc;
2015 struct field_ref *ref = (struct field_ref *) insn->data;
2016
2017 dbg_printf("load field ref offset %u type sequence\n",
2018 ref->offset);
2019 estack_push(stack, top, ax, bx, ax_t, bx_t);
2020 estack_ax(stack, top)->u.s.seq_len =
2021 *(unsigned long *) &interpreter_stack_data[ref->offset];
2022 estack_ax(stack, top)->u.s.str =
2023 *(const char **) (&interpreter_stack_data[ref->offset
2024 + sizeof(unsigned long)]);
2025 estack_ax_t = REG_STRING;
2026 if (unlikely(!estack_ax(stack, top)->u.s.str)) {
2027 dbg_printf("Interpreter warning: loading a NULL sequence.\n");
2028 ret = -EINVAL;
2029 goto end;
2030 }
2031 estack_ax(stack, top)->u.s.literal_type =
2032 ESTACK_STRING_LITERAL_TYPE_NONE;
2033 next_pc += sizeof(struct load_op) + sizeof(struct field_ref);
2034 PO;
2035 }
2036
2037 OP(BYTECODE_OP_LOAD_FIELD_REF_S64):
2038 {
2039 struct load_op *insn = (struct load_op *) pc;
2040 struct field_ref *ref = (struct field_ref *) insn->data;
2041
2042 dbg_printf("load field ref offset %u type s64\n",
2043 ref->offset);
2044 estack_push(stack, top, ax, bx, ax_t, bx_t);
2045 estack_ax_v =
2046 ((struct literal_numeric *) &interpreter_stack_data[ref->offset])->v;
2047 estack_ax_t = REG_S64;
2048 dbg_printf("ref load s64 %" PRIi64 "\n", estack_ax_v);
2049 next_pc += sizeof(struct load_op) + sizeof(struct field_ref);
2050 PO;
2051 }
2052
2053 OP(BYTECODE_OP_LOAD_FIELD_REF_DOUBLE):
2054 {
2055 struct load_op *insn = (struct load_op *) pc;
2056 struct field_ref *ref = (struct field_ref *) insn->data;
2057
2058 dbg_printf("load field ref offset %u type double\n",
2059 ref->offset);
2060 estack_push(stack, top, ax, bx, ax_t, bx_t);
2061 memcpy(&estack_ax(stack, top)->u.d, &interpreter_stack_data[ref->offset],
2062 sizeof(struct literal_double));
2063 estack_ax_t = REG_DOUBLE;
2064 dbg_printf("ref load double %g\n", estack_ax(stack, top)->u.d);
2065 next_pc += sizeof(struct load_op) + sizeof(struct field_ref);
2066 PO;
2067 }
2068
2069 /* load from immediate operand */
2070 OP(BYTECODE_OP_LOAD_STRING):
2071 {
2072 struct load_op *insn = (struct load_op *) pc;
2073
2074 dbg_printf("load string %s\n", insn->data);
2075 estack_push(stack, top, ax, bx, ax_t, bx_t);
2076 estack_ax(stack, top)->u.s.str = insn->data;
2077 estack_ax(stack, top)->u.s.seq_len = SIZE_MAX;
2078 estack_ax(stack, top)->u.s.literal_type =
2079 ESTACK_STRING_LITERAL_TYPE_PLAIN;
2080 estack_ax_t = REG_STRING;
2081 next_pc += sizeof(struct load_op) + strlen(insn->data) + 1;
2082 PO;
2083 }
2084
2085 OP(BYTECODE_OP_LOAD_STAR_GLOB_STRING):
2086 {
2087 struct load_op *insn = (struct load_op *) pc;
2088
2089 dbg_printf("load globbing pattern %s\n", insn->data);
2090 estack_push(stack, top, ax, bx, ax_t, bx_t);
2091 estack_ax(stack, top)->u.s.str = insn->data;
2092 estack_ax(stack, top)->u.s.seq_len = SIZE_MAX;
2093 estack_ax(stack, top)->u.s.literal_type =
2094 ESTACK_STRING_LITERAL_TYPE_STAR_GLOB;
2095 estack_ax_t = REG_STAR_GLOB_STRING;
2096 next_pc += sizeof(struct load_op) + strlen(insn->data) + 1;
2097 PO;
2098 }
2099
2100 OP(BYTECODE_OP_LOAD_S64):
2101 {
2102 struct load_op *insn = (struct load_op *) pc;
2103
2104 estack_push(stack, top, ax, bx, ax_t, bx_t);
2105 estack_ax_v = ((struct literal_numeric *) insn->data)->v;
2106 estack_ax_t = REG_S64;
2107 dbg_printf("load s64 %" PRIi64 "\n", estack_ax_v);
2108 next_pc += sizeof(struct load_op)
2109 + sizeof(struct literal_numeric);
2110 PO;
2111 }
2112
2113 OP(BYTECODE_OP_LOAD_DOUBLE):
2114 {
2115 struct load_op *insn = (struct load_op *) pc;
2116
2117 estack_push(stack, top, ax, bx, ax_t, bx_t);
2118 memcpy(&estack_ax(stack, top)->u.d, insn->data,
2119 sizeof(struct literal_double));
2120 estack_ax_t = REG_DOUBLE;
2121 dbg_printf("load double %g\n", estack_ax(stack, top)->u.d);
2122 next_pc += sizeof(struct load_op)
2123 + sizeof(struct literal_double);
2124 PO;
2125 }
2126
2127 /* cast */
2128 OP(BYTECODE_OP_CAST_TO_S64):
2129 {
2130 /* Dynamic typing. */
2131 switch (estack_ax_t) {
2132 case REG_S64:
2133 JUMP_TO(BYTECODE_OP_CAST_NOP);
2134 case REG_DOUBLE:
2135 JUMP_TO(BYTECODE_OP_CAST_DOUBLE_TO_S64);
2136 case REG_U64:
2137 estack_ax_t = REG_S64;
2138 next_pc += sizeof(struct cast_op);
2139 case REG_STRING: /* Fall-through */
2140 case REG_STAR_GLOB_STRING:
2141 ret = -EINVAL;
2142 goto end;
2143 default:
2144 ERR("Unknown interpreter register type (%d)",
2145 (int) estack_ax_t);
2146 ret = -EINVAL;
2147 goto end;
2148 }
2149 }
2150
2151 OP(BYTECODE_OP_CAST_DOUBLE_TO_S64):
2152 {
2153 estack_ax_v = (int64_t) estack_ax(stack, top)->u.d;
2154 estack_ax_t = REG_S64;
2155 next_pc += sizeof(struct cast_op);
2156 PO;
2157 }
2158
2159 OP(BYTECODE_OP_CAST_NOP):
2160 {
2161 next_pc += sizeof(struct cast_op);
2162 PO;
2163 }
2164
2165 /* get context ref */
2166 OP(BYTECODE_OP_GET_CONTEXT_REF):
2167 {
2168 struct load_op *insn = (struct load_op *) pc;
2169 struct field_ref *ref = (struct field_ref *) insn->data;
2170 struct lttng_ctx_field *ctx_field;
2171 struct lttng_ctx_value v;
2172
2173 dbg_printf("get context ref offset %u type dynamic\n",
2174 ref->offset);
2175 ctx_field = &ctx->fields[ref->offset];
2176 ctx_field->get_value(ctx_field, &v);
2177 estack_push(stack, top, ax, bx, ax_t, bx_t);
2178 switch (v.sel) {
2179 case LTTNG_UST_DYNAMIC_TYPE_NONE:
2180 ret = -EINVAL;
2181 goto end;
2182 case LTTNG_UST_DYNAMIC_TYPE_S64:
2183 estack_ax_v = v.u.s64;
2184 estack_ax_t = REG_S64;
2185 dbg_printf("ref get context dynamic s64 %" PRIi64 "\n", estack_ax_v);
2186 break;
2187 case LTTNG_UST_DYNAMIC_TYPE_DOUBLE:
2188 estack_ax(stack, top)->u.d = v.u.d;
2189 estack_ax_t = REG_DOUBLE;
2190 dbg_printf("ref get context dynamic double %g\n", estack_ax(stack, top)->u.d);
2191 break;
2192 case LTTNG_UST_DYNAMIC_TYPE_STRING:
2193 estack_ax(stack, top)->u.s.str = v.u.str;
2194 if (unlikely(!estack_ax(stack, top)->u.s.str)) {
2195 dbg_printf("Interpreter warning: loading a NULL string.\n");
2196 ret = -EINVAL;
2197 goto end;
2198 }
2199 estack_ax(stack, top)->u.s.seq_len = SIZE_MAX;
2200 estack_ax(stack, top)->u.s.literal_type =
2201 ESTACK_STRING_LITERAL_TYPE_NONE;
2202 dbg_printf("ref get context dynamic string %s\n", estack_ax(stack, top)->u.s.str);
2203 estack_ax_t = REG_STRING;
2204 break;
2205 default:
2206 dbg_printf("Interpreter warning: unknown dynamic type (%d).\n", (int) v.sel);
2207 ret = -EINVAL;
2208 goto end;
2209 }
2210 next_pc += sizeof(struct load_op) + sizeof(struct field_ref);
2211 PO;
2212 }
2213
2214 OP(BYTECODE_OP_GET_CONTEXT_REF_STRING):
2215 {
2216 struct load_op *insn = (struct load_op *) pc;
2217 struct field_ref *ref = (struct field_ref *) insn->data;
2218 struct lttng_ctx_field *ctx_field;
2219 struct lttng_ctx_value v;
2220
2221 dbg_printf("get context ref offset %u type string\n",
2222 ref->offset);
2223 ctx_field = &ctx->fields[ref->offset];
2224 ctx_field->get_value(ctx_field, &v);
2225 estack_push(stack, top, ax, bx, ax_t, bx_t);
2226 estack_ax(stack, top)->u.s.str = v.u.str;
2227 if (unlikely(!estack_ax(stack, top)->u.s.str)) {
2228 dbg_printf("Interpreter warning: loading a NULL string.\n");
2229 ret = -EINVAL;
2230 goto end;
2231 }
2232 estack_ax(stack, top)->u.s.seq_len = SIZE_MAX;
2233 estack_ax(stack, top)->u.s.literal_type =
2234 ESTACK_STRING_LITERAL_TYPE_NONE;
2235 estack_ax_t = REG_STRING;
2236 dbg_printf("ref get context string %s\n", estack_ax(stack, top)->u.s.str);
2237 next_pc += sizeof(struct load_op) + sizeof(struct field_ref);
2238 PO;
2239 }
2240
2241 OP(BYTECODE_OP_GET_CONTEXT_REF_S64):
2242 {
2243 struct load_op *insn = (struct load_op *) pc;
2244 struct field_ref *ref = (struct field_ref *) insn->data;
2245 struct lttng_ctx_field *ctx_field;
2246 struct lttng_ctx_value v;
2247
2248 dbg_printf("get context ref offset %u type s64\n",
2249 ref->offset);
2250 ctx_field = &ctx->fields[ref->offset];
2251 ctx_field->get_value(ctx_field, &v);
2252 estack_push(stack, top, ax, bx, ax_t, bx_t);
2253 estack_ax_v = v.u.s64;
2254 estack_ax_t = REG_S64;
2255 dbg_printf("ref get context s64 %" PRIi64 "\n", estack_ax_v);
2256 next_pc += sizeof(struct load_op) + sizeof(struct field_ref);
2257 PO;
2258 }
2259
2260 OP(BYTECODE_OP_GET_CONTEXT_REF_DOUBLE):
2261 {
2262 struct load_op *insn = (struct load_op *) pc;
2263 struct field_ref *ref = (struct field_ref *) insn->data;
2264 struct lttng_ctx_field *ctx_field;
2265 struct lttng_ctx_value v;
2266
2267 dbg_printf("get context ref offset %u type double\n",
2268 ref->offset);
2269 ctx_field = &ctx->fields[ref->offset];
2270 ctx_field->get_value(ctx_field, &v);
2271 estack_push(stack, top, ax, bx, ax_t, bx_t);
2272 memcpy(&estack_ax(stack, top)->u.d, &v.u.d, sizeof(struct literal_double));
2273 estack_ax_t = REG_DOUBLE;
2274 dbg_printf("ref get context double %g\n", estack_ax(stack, top)->u.d);
2275 next_pc += sizeof(struct load_op) + sizeof(struct field_ref);
2276 PO;
2277 }
2278
2279 OP(BYTECODE_OP_GET_CONTEXT_ROOT):
2280 {
2281 dbg_printf("op get context root\n");
2282 estack_push(stack, top, ax, bx, ax_t, bx_t);
2283 estack_ax(stack, top)->u.ptr.type = LOAD_ROOT_CONTEXT;
2284 /* "field" only needed for variants. */
2285 estack_ax(stack, top)->u.ptr.field = NULL;
2286 estack_ax_t = REG_PTR;
2287 next_pc += sizeof(struct load_op);
2288 PO;
2289 }
2290
2291 OP(BYTECODE_OP_GET_APP_CONTEXT_ROOT):
2292 {
2293 dbg_printf("op get app context root\n");
2294 estack_push(stack, top, ax, bx, ax_t, bx_t);
2295 estack_ax(stack, top)->u.ptr.type = LOAD_ROOT_APP_CONTEXT;
2296 /* "field" only needed for variants. */
2297 estack_ax(stack, top)->u.ptr.field = NULL;
2298 estack_ax_t = REG_PTR;
2299 next_pc += sizeof(struct load_op);
2300 PO;
2301 }
2302
2303 OP(BYTECODE_OP_GET_PAYLOAD_ROOT):
2304 {
2305 dbg_printf("op get app payload root\n");
2306 estack_push(stack, top, ax, bx, ax_t, bx_t);
2307 estack_ax(stack, top)->u.ptr.type = LOAD_ROOT_PAYLOAD;
2308 estack_ax(stack, top)->u.ptr.ptr = interpreter_stack_data;
2309 /* "field" only needed for variants. */
2310 estack_ax(stack, top)->u.ptr.field = NULL;
2311 estack_ax_t = REG_PTR;
2312 next_pc += sizeof(struct load_op);
2313 PO;
2314 }
2315
2316 OP(BYTECODE_OP_GET_SYMBOL):
2317 {
2318 dbg_printf("op get symbol\n");
2319 switch (estack_ax(stack, top)->u.ptr.type) {
2320 case LOAD_OBJECT:
2321 ERR("Nested fields not implemented yet.");
2322 ret = -EINVAL;
2323 goto end;
2324 case LOAD_ROOT_CONTEXT:
2325 case LOAD_ROOT_APP_CONTEXT:
2326 case LOAD_ROOT_PAYLOAD:
2327 /*
2328 * symbol lookup is performed by
2329 * specialization.
2330 */
2331 ret = -EINVAL;
2332 goto end;
2333 }
2334 next_pc += sizeof(struct load_op) + sizeof(struct get_symbol);
2335 PO;
2336 }
2337
2338 OP(BYTECODE_OP_GET_SYMBOL_FIELD):
2339 {
2340 /*
2341 * Used for first variant encountered in a
2342 * traversal. Variants are not implemented yet.
2343 */
2344 ret = -EINVAL;
2345 goto end;
2346 }
2347
2348 OP(BYTECODE_OP_GET_INDEX_U16):
2349 {
2350 struct load_op *insn = (struct load_op *) pc;
2351 struct get_index_u16 *index = (struct get_index_u16 *) insn->data;
2352
2353 dbg_printf("op get index u16\n");
2354 ret = dynamic_get_index(ctx, bytecode, index->index, estack_ax(stack, top));
2355 if (ret)
2356 goto end;
2357 estack_ax_v = estack_ax(stack, top)->u.v;
2358 estack_ax_t = estack_ax(stack, top)->type;
2359 next_pc += sizeof(struct load_op) + sizeof(struct get_index_u16);
2360 PO;
2361 }
2362
2363 OP(BYTECODE_OP_GET_INDEX_U64):
2364 {
2365 struct load_op *insn = (struct load_op *) pc;
2366 struct get_index_u64 *index = (struct get_index_u64 *) insn->data;
2367
2368 dbg_printf("op get index u64\n");
2369 ret = dynamic_get_index(ctx, bytecode, index->index, estack_ax(stack, top));
2370 if (ret)
2371 goto end;
2372 estack_ax_v = estack_ax(stack, top)->u.v;
2373 estack_ax_t = estack_ax(stack, top)->type;
2374 next_pc += sizeof(struct load_op) + sizeof(struct get_index_u64);
2375 PO;
2376 }
2377
2378 OP(BYTECODE_OP_LOAD_FIELD):
2379 {
2380 dbg_printf("op load field\n");
2381 ret = dynamic_load_field(estack_ax(stack, top));
2382 if (ret)
2383 goto end;
2384 estack_ax_v = estack_ax(stack, top)->u.v;
2385 estack_ax_t = estack_ax(stack, top)->type;
2386 next_pc += sizeof(struct load_op);
2387 PO;
2388 }
2389
2390 OP(BYTECODE_OP_LOAD_FIELD_S8):
2391 {
2392 dbg_printf("op load field s8\n");
2393
2394 estack_ax_v = *(int8_t *) estack_ax(stack, top)->u.ptr.ptr;
2395 estack_ax_t = REG_S64;
2396 next_pc += sizeof(struct load_op);
2397 PO;
2398 }
2399 OP(BYTECODE_OP_LOAD_FIELD_S16):
2400 {
2401 dbg_printf("op load field s16\n");
2402
2403 estack_ax_v = *(int16_t *) estack_ax(stack, top)->u.ptr.ptr;
2404 estack_ax_t = REG_S64;
2405 next_pc += sizeof(struct load_op);
2406 PO;
2407 }
2408 OP(BYTECODE_OP_LOAD_FIELD_S32):
2409 {
2410 dbg_printf("op load field s32\n");
2411
2412 estack_ax_v = *(int32_t *) estack_ax(stack, top)->u.ptr.ptr;
2413 estack_ax_t = REG_S64;
2414 next_pc += sizeof(struct load_op);
2415 PO;
2416 }
2417 OP(BYTECODE_OP_LOAD_FIELD_S64):
2418 {
2419 dbg_printf("op load field s64\n");
2420
2421 estack_ax_v = *(int64_t *) estack_ax(stack, top)->u.ptr.ptr;
2422 estack_ax_t = REG_S64;
2423 next_pc += sizeof(struct load_op);
2424 PO;
2425 }
2426 OP(BYTECODE_OP_LOAD_FIELD_U8):
2427 {
2428 dbg_printf("op load field u8\n");
2429
2430 estack_ax_v = *(uint8_t *) estack_ax(stack, top)->u.ptr.ptr;
2431 estack_ax_t = REG_U64;
2432 next_pc += sizeof(struct load_op);
2433 PO;
2434 }
2435 OP(BYTECODE_OP_LOAD_FIELD_U16):
2436 {
2437 dbg_printf("op load field u16\n");
2438
2439 estack_ax_v = *(uint16_t *) estack_ax(stack, top)->u.ptr.ptr;
2440 estack_ax_t = REG_U64;
2441 next_pc += sizeof(struct load_op);
2442 PO;
2443 }
2444 OP(BYTECODE_OP_LOAD_FIELD_U32):
2445 {
2446 dbg_printf("op load field u32\n");
2447
2448 estack_ax_v = *(uint32_t *) estack_ax(stack, top)->u.ptr.ptr;
2449 estack_ax_t = REG_U64;
2450 next_pc += sizeof(struct load_op);
2451 PO;
2452 }
2453 OP(BYTECODE_OP_LOAD_FIELD_U64):
2454 {
2455 dbg_printf("op load field u64\n");
2456
2457 estack_ax_v = *(uint64_t *) estack_ax(stack, top)->u.ptr.ptr;
2458 estack_ax_t = REG_U64;
2459 next_pc += sizeof(struct load_op);
2460 PO;
2461 }
2462 OP(BYTECODE_OP_LOAD_FIELD_DOUBLE):
2463 {
2464 dbg_printf("op load field double\n");
2465
2466 memcpy(&estack_ax(stack, top)->u.d,
2467 estack_ax(stack, top)->u.ptr.ptr,
2468 sizeof(struct literal_double));
2469 estack_ax(stack, top)->type = REG_DOUBLE;
2470 next_pc += sizeof(struct load_op);
2471 PO;
2472 }
2473
2474 OP(BYTECODE_OP_LOAD_FIELD_STRING):
2475 {
2476 const char *str;
2477
2478 dbg_printf("op load field string\n");
2479 str = (const char *) estack_ax(stack, top)->u.ptr.ptr;
2480 estack_ax(stack, top)->u.s.str = str;
2481 if (unlikely(!estack_ax(stack, top)->u.s.str)) {
2482 dbg_printf("Interpreter warning: loading a NULL string.\n");
2483 ret = -EINVAL;
2484 goto end;
2485 }
2486 estack_ax(stack, top)->u.s.seq_len = SIZE_MAX;
2487 estack_ax(stack, top)->u.s.literal_type =
2488 ESTACK_STRING_LITERAL_TYPE_NONE;
2489 estack_ax(stack, top)->type = REG_STRING;
2490 next_pc += sizeof(struct load_op);
2491 PO;
2492 }
2493
2494 OP(BYTECODE_OP_LOAD_FIELD_SEQUENCE):
2495 {
2496 const char *ptr;
2497
2498 dbg_printf("op load field string sequence\n");
2499 ptr = estack_ax(stack, top)->u.ptr.ptr;
2500 estack_ax(stack, top)->u.s.seq_len = *(unsigned long *) ptr;
2501 estack_ax(stack, top)->u.s.str = *(const char **) (ptr + sizeof(unsigned long));
2502 estack_ax(stack, top)->type = REG_STRING;
2503 if (unlikely(!estack_ax(stack, top)->u.s.str)) {
2504 dbg_printf("Interpreter warning: loading a NULL sequence.\n");
2505 ret = -EINVAL;
2506 goto end;
2507 }
2508 estack_ax(stack, top)->u.s.literal_type =
2509 ESTACK_STRING_LITERAL_TYPE_NONE;
2510 next_pc += sizeof(struct load_op);
2511 PO;
2512 }
2513
2514 END_OP
2515 end:
2516 /* Return _DISCARD on error. */
2517 if (ret)
2518 return LTTNG_INTERPRETER_DISCARD;
2519
2520 if (output) {
2521 return lttng_bytecode_interpret_format_output(estack_ax(stack, top),
2522 output);
2523 }
2524
2525 return retval;
2526 }
2527
2528 uint64_t lttng_bytecode_filter_interpret(void *filter_data,
2529 const char *filter_stack_data)
2530 {
2531 return bytecode_interpret(filter_data, filter_stack_data, NULL);
2532 }
2533
2534 #undef START_OP
2535 #undef OP
2536 #undef PO
2537 #undef END_OP
LTTng 2.0 Userspace Tracer
This page took 0.130654 seconds and 4 git commands to generate.