projects / lttng-ust.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Filtering: add support for star-only globbing patterns
[lttng-ust.git] / liblttng-ust / lttng-filter-specialize.c
CommitLineData
97b58163
MD		 1/*
2 * lttng-filter-specialize.c
3 *
4 * LTTng UST filter code specializer.
5 *
7e50015d 6 * Copyright (C) 2010-2016 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
97b58163 7 *
7e50015d
MD		 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:
97b58163 14 *
7e50015d
MD		 15 * The above copyright notice and this permission notice shall be included in
16 * all copies or substantial portions of the Software.
97b58163 17 *
7e50015d
MD		 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.
97b58163
MD		 25 */
26
3fbec7dc 27#define _LGPL_SOURCE
97b58163
MD		 28#include "lttng-filter.h"
29
30int lttng_filter_specialize_bytecode(struct bytecode_runtime *bytecode)
31{
32 void *pc, *next_pc, *start_pc;
33 int ret = -EINVAL;
0305960f
MD		 34 struct vstack _stack;
35 struct vstack *stack = &_stack;
97b58163 36
0305960f 37 vstack_init(stack);
97b58163
MD		 38
39 start_pc = &bytecode->data[0];
40 for (pc = next_pc = start_pc; pc - start_pc < bytecode->len;
41 pc = next_pc) {
42 switch (*(filter_opcode_t *) pc) {
43 case FILTER_OP_UNKNOWN:
44 default:
45 ERR("unknown bytecode op %u\n",
46 (unsigned int) *(filter_opcode_t *) pc);
47 ret = -EINVAL;
48 goto end;
49
50 case FILTER_OP_RETURN:
51 ret = 0;
52 goto end;
53
54 /* binary */
55 case FILTER_OP_MUL:
56 case FILTER_OP_DIV:
57 case FILTER_OP_MOD:
58 case FILTER_OP_PLUS:
59 case FILTER_OP_MINUS:
60 case FILTER_OP_RSHIFT:
61 case FILTER_OP_LSHIFT:
62 case FILTER_OP_BIN_AND:
63 case FILTER_OP_BIN_OR:
64 case FILTER_OP_BIN_XOR:
65 ERR("unsupported bytecode op %u\n",
66 (unsigned int) *(filter_opcode_t *) pc);
67 ret = -EINVAL;
68 goto end;
69
70 case FILTER_OP_EQ:
71 {
72 struct binary_op *insn = (struct binary_op *) pc;
73
0305960f 74 switch(vstack_ax(stack)->type) {
97b58163
MD		 75 default:
76 ERR("unknown register type\n");
77 ret = -EINVAL;
78 goto end;
79
80 case REG_STRING:
53569322
MD		 81 if (vstack_bx(stack)->type == REG_UNKNOWN)
82 break;
3151a51d
PP		 83 if (vstack_bx(stack)->type == REG_STAR_GLOB_STRING)
84 insn->op = FILTER_OP_EQ_STAR_GLOB_STRING;
85 else
86 insn->op = FILTER_OP_EQ_STRING;
87 break;
88 case REG_STAR_GLOB_STRING:
89 if (vstack_bx(stack)->type == REG_UNKNOWN)
90 break;
91 insn->op = FILTER_OP_EQ_STAR_GLOB_STRING;
97b58163
MD		 92 break;
93 case REG_S64:
53569322
MD		 94 if (vstack_bx(stack)->type == REG_UNKNOWN)
95 break;
0305960f 96 if (vstack_bx(stack)->type == REG_S64)
97b58163
MD		 97 insn->op = FILTER_OP_EQ_S64;
98 else
dbea82ec 99 insn->op = FILTER_OP_EQ_DOUBLE_S64;
97b58163
MD		 100 break;
101 case REG_DOUBLE:
53569322
MD		 102 if (vstack_bx(stack)->type == REG_UNKNOWN)
103 break;
dbea82ec
MD		 104 if (vstack_bx(stack)->type == REG_S64)
105 insn->op = FILTER_OP_EQ_S64_DOUBLE;
106 else
107 insn->op = FILTER_OP_EQ_DOUBLE;
97b58163 108 break;
53569322
MD		 109 case REG_UNKNOWN:
110 break; /* Dynamic typing. */
97b58163 111 }
0305960f
MD		 112 /* Pop 2, push 1 */
113 if (vstack_pop(stack)) {
114 ret = -EINVAL;
115 goto end;
116 }
117 vstack_ax(stack)->type = REG_S64;
97b58163
MD		 118 next_pc += sizeof(struct binary_op);
119 break;
120 }
121
122 case FILTER_OP_NE:
123 {
124 struct binary_op *insn = (struct binary_op *) pc;
125
0305960f 126 switch(vstack_ax(stack)->type) {
97b58163
MD		 127 default:
128 ERR("unknown register type\n");
129 ret = -EINVAL;
130 goto end;
131
132 case REG_STRING:
53569322
MD		 133 if (vstack_bx(stack)->type == REG_UNKNOWN)
134 break;
3151a51d
PP		 135 if (vstack_bx(stack)->type == REG_STAR_GLOB_STRING)
136 insn->op = FILTER_OP_NE_STAR_GLOB_STRING;
137 else
138 insn->op = FILTER_OP_NE_STRING;
139 break;
140 case REG_STAR_GLOB_STRING:
141 if (vstack_bx(stack)->type == REG_UNKNOWN)
142 break;
143 insn->op = FILTER_OP_NE_STAR_GLOB_STRING;
97b58163
MD		 144 break;
145 case REG_S64:
53569322
MD		 146 if (vstack_bx(stack)->type == REG_UNKNOWN)
147 break;
0305960f 148 if (vstack_bx(stack)->type == REG_S64)
97b58163
MD		 149 insn->op = FILTER_OP_NE_S64;
150 else
dbea82ec 151 insn->op = FILTER_OP_NE_DOUBLE_S64;
97b58163
MD		 152 break;
153 case REG_DOUBLE:
53569322
MD		 154 if (vstack_bx(stack)->type == REG_UNKNOWN)
155 break;
dbea82ec
MD		 156 if (vstack_bx(stack)->type == REG_S64)
157 insn->op = FILTER_OP_NE_S64_DOUBLE;
158 else
159 insn->op = FILTER_OP_NE_DOUBLE;
97b58163 160 break;
53569322
MD		 161 case REG_UNKNOWN:
162 break; /* Dynamic typing. */
97b58163 163 }
0305960f
MD		 164 /* Pop 2, push 1 */
165 if (vstack_pop(stack)) {
166 ret = -EINVAL;
167 goto end;
168 }
169 vstack_ax(stack)->type = REG_S64;
97b58163
MD		 170 next_pc += sizeof(struct binary_op);
171 break;
172 }
173
174 case FILTER_OP_GT:
175 {
176 struct binary_op *insn = (struct binary_op *) pc;
177
0305960f 178 switch(vstack_ax(stack)->type) {
97b58163
MD		 179 default:
180 ERR("unknown register type\n");
181 ret = -EINVAL;
182 goto end;
183
3151a51d
PP		 184 case REG_STAR_GLOB_STRING:
185 ERR("invalid register type for > binary operator\n");
186 ret = -EINVAL;
187 goto end;
97b58163 188 case REG_STRING:
53569322
MD		 189 if (vstack_bx(stack)->type == REG_UNKNOWN)
190 break;
97b58163
MD		 191 insn->op = FILTER_OP_GT_STRING;
192 break;
193 case REG_S64:
53569322
MD		 194 if (vstack_bx(stack)->type == REG_UNKNOWN)
195 break;
0305960f 196 if (vstack_bx(stack)->type == REG_S64)
97b58163
MD		 197 insn->op = FILTER_OP_GT_S64;
198 else
dbea82ec 199 insn->op = FILTER_OP_GT_DOUBLE_S64;
97b58163
MD		 200 break;
201 case REG_DOUBLE:
53569322
MD		 202 if (vstack_bx(stack)->type == REG_UNKNOWN)
203 break;
dbea82ec
MD		 204 if (vstack_bx(stack)->type == REG_S64)
205 insn->op = FILTER_OP_GT_S64_DOUBLE;
206 else
207 insn->op = FILTER_OP_GT_DOUBLE;
97b58163 208 break;
53569322
MD		 209 case REG_UNKNOWN:
210 break; /* Dynamic typing. */
97b58163 211 }
0305960f
MD		 212 /* Pop 2, push 1 */
213 if (vstack_pop(stack)) {
214 ret = -EINVAL;
215 goto end;
216 }
217 vstack_ax(stack)->type = REG_S64;
97b58163
MD		 218 next_pc += sizeof(struct binary_op);
219 break;
220 }
221
222 case FILTER_OP_LT:
223 {
224 struct binary_op *insn = (struct binary_op *) pc;
225
0305960f 226 switch(vstack_ax(stack)->type) {
97b58163
MD		 227 default:
228 ERR("unknown register type\n");
229 ret = -EINVAL;
230 goto end;
231
3151a51d
PP		 232 case REG_STAR_GLOB_STRING:
233 ERR("invalid register type for < binary operator\n");
234 ret = -EINVAL;
235 goto end;
97b58163 236 case REG_STRING:
53569322
MD		 237 if (vstack_bx(stack)->type == REG_UNKNOWN)
238 break;
97b58163
MD		 239 insn->op = FILTER_OP_LT_STRING;
240 break;
241 case REG_S64:
53569322
MD		 242 if (vstack_bx(stack)->type == REG_UNKNOWN)
243 break;
0305960f 244 if (vstack_bx(stack)->type == REG_S64)
97b58163
MD		 245 insn->op = FILTER_OP_LT_S64;
246 else
dbea82ec 247 insn->op = FILTER_OP_LT_DOUBLE_S64;
97b58163
MD		 248 break;
249 case REG_DOUBLE:
53569322
MD		 250 if (vstack_bx(stack)->type == REG_UNKNOWN)
251 break;
dbea82ec
MD		 252 if (vstack_bx(stack)->type == REG_S64)
253 insn->op = FILTER_OP_LT_S64_DOUBLE;
254 else
255 insn->op = FILTER_OP_LT_DOUBLE;
97b58163 256 break;
53569322
MD		 257 case REG_UNKNOWN:
258 break; /* Dynamic typing. */
97b58163 259 }
0305960f
MD		 260 /* Pop 2, push 1 */
261 if (vstack_pop(stack)) {
262 ret = -EINVAL;
263 goto end;
264 }
265 vstack_ax(stack)->type = REG_S64;
97b58163
MD		 266 next_pc += sizeof(struct binary_op);
267 break;
268 }
269
270 case FILTER_OP_GE:
271 {
272 struct binary_op *insn = (struct binary_op *) pc;
273
0305960f 274 switch(vstack_ax(stack)->type) {
97b58163
MD		 275 default:
276 ERR("unknown register type\n");
277 ret = -EINVAL;
278 goto end;
279
3151a51d
PP		 280 case REG_STAR_GLOB_STRING:
281 ERR("invalid register type for >= binary operator\n");
282 ret = -EINVAL;
283 goto end;
97b58163 284 case REG_STRING:
53569322
MD		 285 if (vstack_bx(stack)->type == REG_UNKNOWN)
286 break;
97b58163
MD		 287 insn->op = FILTER_OP_GE_STRING;
288 break;
289 case REG_S64:
53569322
MD		 290 if (vstack_bx(stack)->type == REG_UNKNOWN)
291 break;
0305960f 292 if (vstack_bx(stack)->type == REG_S64)
97b58163
MD		 293 insn->op = FILTER_OP_GE_S64;
294 else
dbea82ec 295 insn->op = FILTER_OP_GE_DOUBLE_S64;
97b58163
MD		 296 break;
297 case REG_DOUBLE:
53569322
MD		 298 if (vstack_bx(stack)->type == REG_UNKNOWN)
299 break;
dbea82ec
MD		 300 if (vstack_bx(stack)->type == REG_S64)
301 insn->op = FILTER_OP_GE_S64_DOUBLE;
302 else
303 insn->op = FILTER_OP_GE_DOUBLE;
97b58163 304 break;
53569322
MD		 305 case REG_UNKNOWN:
306 break; /* Dynamic typing. */
97b58163 307 }
0305960f
MD		 308 /* Pop 2, push 1 */
309 if (vstack_pop(stack)) {
310 ret = -EINVAL;
311 goto end;
312 }
313 vstack_ax(stack)->type = REG_S64;
97b58163
MD		 314 next_pc += sizeof(struct binary_op);
315 break;
316 }
317 case FILTER_OP_LE:
318 {
319 struct binary_op *insn = (struct binary_op *) pc;
320
0305960f 321 switch(vstack_ax(stack)->type) {
97b58163
MD		 322 default:
323 ERR("unknown register type\n");
324 ret = -EINVAL;
325 goto end;
326
3151a51d
PP		 327 case REG_STAR_GLOB_STRING:
328 ERR("invalid register type for <= binary operator\n");
329 ret = -EINVAL;
330 goto end;
97b58163 331 case REG_STRING:
53569322
MD		 332 if (vstack_bx(stack)->type == REG_UNKNOWN)
333 break;
97b58163
MD		 334 insn->op = FILTER_OP_LE_STRING;
335 break;
336 case REG_S64:
53569322
MD		 337 if (vstack_bx(stack)->type == REG_UNKNOWN)
338 break;
0305960f 339 if (vstack_bx(stack)->type == REG_S64)
97b58163
MD		 340 insn->op = FILTER_OP_LE_S64;
341 else
dbea82ec 342 insn->op = FILTER_OP_LE_DOUBLE_S64;
97b58163
MD		 343 break;
344 case REG_DOUBLE:
53569322
MD		 345 if (vstack_bx(stack)->type == REG_UNKNOWN)
346 break;
dbea82ec
MD		 347 if (vstack_bx(stack)->type == REG_S64)
348 insn->op = FILTER_OP_LE_S64_DOUBLE;
349 else
350 insn->op = FILTER_OP_LE_DOUBLE;
97b58163 351 break;
53569322
MD		 352 case REG_UNKNOWN:
353 break; /* Dynamic typing. */
97b58163 354 }
0305960f 355 vstack_ax(stack)->type = REG_S64;
97b58163
MD		 356 next_pc += sizeof(struct binary_op);
357 break;
358 }
359
360 case FILTER_OP_EQ_STRING:
361 case FILTER_OP_NE_STRING:
362 case FILTER_OP_GT_STRING:
363 case FILTER_OP_LT_STRING:
364 case FILTER_OP_GE_STRING:
365 case FILTER_OP_LE_STRING:
3151a51d
PP		 366 case FILTER_OP_EQ_STAR_GLOB_STRING:
367 case FILTER_OP_NE_STAR_GLOB_STRING:
97b58163
MD		 368 case FILTER_OP_EQ_S64:
369 case FILTER_OP_NE_S64:
370 case FILTER_OP_GT_S64:
371 case FILTER_OP_LT_S64:
372 case FILTER_OP_GE_S64:
373 case FILTER_OP_LE_S64:
374 case FILTER_OP_EQ_DOUBLE:
375 case FILTER_OP_NE_DOUBLE:
376 case FILTER_OP_GT_DOUBLE:
377 case FILTER_OP_LT_DOUBLE:
378 case FILTER_OP_GE_DOUBLE:
379 case FILTER_OP_LE_DOUBLE:
dbea82ec
MD		 380 case FILTER_OP_EQ_DOUBLE_S64:
381 case FILTER_OP_NE_DOUBLE_S64:
382 case FILTER_OP_GT_DOUBLE_S64:
383 case FILTER_OP_LT_DOUBLE_S64:
384 case FILTER_OP_GE_DOUBLE_S64:
385 case FILTER_OP_LE_DOUBLE_S64:
386 case FILTER_OP_EQ_S64_DOUBLE:
387 case FILTER_OP_NE_S64_DOUBLE:
388 case FILTER_OP_GT_S64_DOUBLE:
389 case FILTER_OP_LT_S64_DOUBLE:
390 case FILTER_OP_GE_S64_DOUBLE:
391 case FILTER_OP_LE_S64_DOUBLE:
97b58163 392 {
0305960f
MD		 393 /* Pop 2, push 1 */
394 if (vstack_pop(stack)) {
395 ret = -EINVAL;
396 goto end;
397 }
398 vstack_ax(stack)->type = REG_S64;
97b58163
MD		 399 next_pc += sizeof(struct binary_op);
400 break;
401 }
402
403 /* unary */
404 case FILTER_OP_UNARY_PLUS:
405 {
406 struct unary_op *insn = (struct unary_op *) pc;
407
0305960f 408 switch(vstack_ax(stack)->type) {
97b58163
MD		 409 default:
410 ERR("unknown register type\n");
411 ret = -EINVAL;
412 goto end;
413
414 case REG_S64:
415 insn->op = FILTER_OP_UNARY_PLUS_S64;
416 break;
417 case REG_DOUBLE:
418 insn->op = FILTER_OP_UNARY_PLUS_DOUBLE;
419 break;
53569322
MD		 420 case REG_UNKNOWN: /* Dynamic typing. */
421 break;
97b58163 422 }
0305960f 423 /* Pop 1, push 1 */
97b58163
MD		 424 next_pc += sizeof(struct unary_op);
425 break;
426 }
427
428 case FILTER_OP_UNARY_MINUS:
429 {
430 struct unary_op *insn = (struct unary_op *) pc;
431
0305960f 432 switch(vstack_ax(stack)->type) {
97b58163
MD		 433 default:
434 ERR("unknown register type\n");
435 ret = -EINVAL;
436 goto end;
437
438 case REG_S64:
439 insn->op = FILTER_OP_UNARY_MINUS_S64;
440 break;
441 case REG_DOUBLE:
442 insn->op = FILTER_OP_UNARY_MINUS_DOUBLE;
443 break;
53569322
MD		 444 case REG_UNKNOWN: /* Dynamic typing. */
445 break;
97b58163 446 }
0305960f 447 /* Pop 1, push 1 */
97b58163
MD		 448 next_pc += sizeof(struct unary_op);
449 break;
450 }
451
452 case FILTER_OP_UNARY_NOT:
453 {
454 struct unary_op *insn = (struct unary_op *) pc;
455
0305960f 456 switch(vstack_ax(stack)->type) {
97b58163
MD		 457 default:
458 ERR("unknown register type\n");
459 ret = -EINVAL;
460 goto end;
461
462 case REG_S64:
463 insn->op = FILTER_OP_UNARY_NOT_S64;
464 break;
465 case REG_DOUBLE:
466 insn->op = FILTER_OP_UNARY_NOT_DOUBLE;
467 break;
53569322
MD		 468 case REG_UNKNOWN: /* Dynamic typing. */
469 break;
97b58163 470 }
0305960f 471 /* Pop 1, push 1 */
97b58163
MD		 472 next_pc += sizeof(struct unary_op);
473 break;
474 }
475
476 case FILTER_OP_UNARY_PLUS_S64:
477 case FILTER_OP_UNARY_MINUS_S64:
478 case FILTER_OP_UNARY_NOT_S64:
479 case FILTER_OP_UNARY_PLUS_DOUBLE:
480 case FILTER_OP_UNARY_MINUS_DOUBLE:
481 case FILTER_OP_UNARY_NOT_DOUBLE:
482 {
0305960f 483 /* Pop 1, push 1 */
97b58163
MD		 484 next_pc += sizeof(struct unary_op);
485 break;
486 }
487
488 /* logical */
489 case FILTER_OP_AND:
490 case FILTER_OP_OR:
491 {
b9f4cd79
MD		 492 /* Continue to next instruction */
493 /* Pop 1 when jump not taken */
494 if (vstack_pop(stack)) {
495 ret = -EINVAL;
496 goto end;
497 }
97b58163
MD		 498 next_pc += sizeof(struct logical_op);
499 break;
500 }
501
77aa5901 502 /* load field ref */
97b58163
MD		 503 case FILTER_OP_LOAD_FIELD_REF:
504 {
505 ERR("Unknown field ref type\n");
506 ret = -EINVAL;
507 goto end;
508 }
77aa5901
MD		 509 /* get context ref */
510 case FILTER_OP_GET_CONTEXT_REF:
511 {
53569322
MD		 512 if (vstack_push(stack)) {
513 ret = -EINVAL;
514 goto end;
515 }
516 vstack_ax(stack)->type = REG_UNKNOWN;
517 next_pc += sizeof(struct load_op) + sizeof(struct field_ref);
518 break;
77aa5901 519 }
97b58163
MD		 520 case FILTER_OP_LOAD_FIELD_REF_STRING:
521 case FILTER_OP_LOAD_FIELD_REF_SEQUENCE:
77aa5901 522 case FILTER_OP_GET_CONTEXT_REF_STRING:
97b58163 523 {
0305960f
MD		 524 if (vstack_push(stack)) {
525 ret = -EINVAL;
526 goto end;
527 }
528 vstack_ax(stack)->type = REG_STRING;
97b58163
MD		 529 next_pc += sizeof(struct load_op) + sizeof(struct field_ref);
530 break;
531 }
532 case FILTER_OP_LOAD_FIELD_REF_S64:
77aa5901 533 case FILTER_OP_GET_CONTEXT_REF_S64:
97b58163 534 {
0305960f
MD		 535 if (vstack_push(stack)) {
536 ret = -EINVAL;
537 goto end;
538 }
539 vstack_ax(stack)->type = REG_S64;
97b58163
MD		 540 next_pc += sizeof(struct load_op) + sizeof(struct field_ref);
541 break;
542 }
543 case FILTER_OP_LOAD_FIELD_REF_DOUBLE:
77aa5901 544 case FILTER_OP_GET_CONTEXT_REF_DOUBLE:
97b58163 545 {
0305960f
MD		 546 if (vstack_push(stack)) {
547 ret = -EINVAL;
548 goto end;
549 }
550 vstack_ax(stack)->type = REG_DOUBLE;
97b58163
MD		 551 next_pc += sizeof(struct load_op) + sizeof(struct field_ref);
552 break;
553 }
554
77aa5901 555 /* load from immediate operand */
97b58163
MD		 556 case FILTER_OP_LOAD_STRING:
557 {
558 struct load_op *insn = (struct load_op *) pc;
559
0305960f
MD		 560 if (vstack_push(stack)) {
561 ret = -EINVAL;
562 goto end;
563 }
564 vstack_ax(stack)->type = REG_STRING;
97b58163
MD		 565 next_pc += sizeof(struct load_op) + strlen(insn->data) + 1;
566 break;
567 }
568
3151a51d
PP		 569 case FILTER_OP_LOAD_STAR_GLOB_STRING:
570 {
571 struct load_op *insn = (struct load_op *) pc;
572
573 if (vstack_push(stack)) {
574 ret = -EINVAL;
575 goto end;
576 }
577 vstack_ax(stack)->type = REG_STAR_GLOB_STRING;
578 next_pc += sizeof(struct load_op) + strlen(insn->data) + 1;
579 break;
580 }
581
97b58163
MD		 582 case FILTER_OP_LOAD_S64:
583 {
0305960f
MD		 584 if (vstack_push(stack)) {
585 ret = -EINVAL;
586 goto end;
587 }
588 vstack_ax(stack)->type = REG_S64;
97b58163
MD		 589 next_pc += sizeof(struct load_op)
590 + sizeof(struct literal_numeric);
591 break;
592 }
593
594 case FILTER_OP_LOAD_DOUBLE:
595 {
0305960f
MD		 596 if (vstack_push(stack)) {
597 ret = -EINVAL;
598 goto end;
599 }
600 vstack_ax(stack)->type = REG_DOUBLE;
97b58163
MD		 601 next_pc += sizeof(struct load_op)
602 + sizeof(struct literal_double);
603 break;
604 }
605
606 /* cast */
607 case FILTER_OP_CAST_TO_S64:
608 {
609 struct cast_op *insn = (struct cast_op *) pc;
610
0305960f 611 switch (vstack_ax(stack)->type) {
97b58163
MD		 612 default:
613 ERR("unknown register type\n");
614 ret = -EINVAL;
615 goto end;
616
617 case REG_STRING:
3151a51d 618 case REG_STAR_GLOB_STRING:
97b58163
MD		 619 ERR("Cast op can only be applied to numeric or floating point registers\n");
620 ret = -EINVAL;
621 goto end;
622 case REG_S64:
623 insn->op = FILTER_OP_CAST_NOP;
624 break;
625 case REG_DOUBLE:
626 insn->op = FILTER_OP_CAST_DOUBLE_TO_S64;
627 break;
53569322
MD		 628 case REG_UNKNOWN:
629 break;
97b58163 630 }
0305960f
MD		 631 /* Pop 1, push 1 */
632 vstack_ax(stack)->type = REG_S64;
97b58163
MD		 633 next_pc += sizeof(struct cast_op);
634 break;
635 }
636 case FILTER_OP_CAST_DOUBLE_TO_S64:
637 {
0305960f
MD		 638 /* Pop 1, push 1 */
639 vstack_ax(stack)->type = REG_S64;
97b58163
MD		 640 next_pc += sizeof(struct cast_op);
641 break;
642 }
643 case FILTER_OP_CAST_NOP:
644 {
645 next_pc += sizeof(struct cast_op);
646 break;
647 }
648
97b58163
MD		 649 }
650 }
651end:
652 return ret;
653}
LTTng 2.0 Userspace Tracer
This page took 0.057648 seconds and 4 git commands to generate.