projects / libside.git / blob
? search:


b892872608cff0631690e1bc593c546f07da47ea
[libside.git] / src / tracer.c
1 // SPDX-License-Identifier: MIT
2 /*
3 * Copyright 2022 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
4 */
5
6 #include <stdint.h>
7 #include <inttypes.h>
8 #include <stdlib.h>
9 #include <stdio.h>
10 #include <stdbool.h>
11 #include <string.h>
12 #include <iconv.h>
13
14 #include <side/trace.h>
15
16 enum tracer_display_base {
17 TRACER_DISPLAY_BASE_2,
18 TRACER_DISPLAY_BASE_8,
19 TRACER_DISPLAY_BASE_10,
20 TRACER_DISPLAY_BASE_16,
21 };
22
23 union int64_value {
24 uint64_t u;
25 int64_t s;
26 };
27
28 static struct side_tracer_handle *tracer_handle;
29
30 static
31 void tracer_print_struct(const struct side_type *type_desc, const struct side_arg_vec *side_arg_vec);
32 static
33 void tracer_print_array(const struct side_type *type_desc, const struct side_arg_vec *side_arg_vec);
34 static
35 void tracer_print_vla(const struct side_type *type_desc, const struct side_arg_vec *side_arg_vec);
36 static
37 void tracer_print_vla_visitor(const struct side_type *type_desc, void *app_ctx);
38 static
39 void tracer_print_dynamic(const struct side_arg *dynamic_item);
40 static
41 uint32_t tracer_print_gather_bool_type(const struct side_type_gather *type_gather, const void *_ptr);
42 static
43 uint32_t tracer_print_gather_byte_type(const struct side_type_gather *type_gather, const void *_ptr);
44 static
45 uint32_t tracer_print_gather_integer_type(const struct side_type_gather *type_gather, const void *_ptr,
46 enum tracer_display_base default_base);
47 static
48 uint32_t tracer_print_gather_float_type(const struct side_type_gather *type_gather, const void *_ptr);
49 static
50 uint32_t tracer_print_gather_string_type(const struct side_type_gather *type_gather, const void *_ptr);
51 static
52 uint32_t tracer_print_gather_enum_type(const struct side_type_gather *type_gather, const void *_ptr);
53 static
54 uint32_t tracer_print_gather_struct(const struct side_type_gather *type_gather, const void *_ptr);
55 static
56 uint32_t tracer_print_gather_array(const struct side_type_gather *type_gather, const void *_ptr);
57 static
58 uint32_t tracer_print_gather_vla(const struct side_type_gather *type_gather, const void *_ptr,
59 const void *_length_ptr);
60 static
61 void tracer_print_type(const struct side_type *type_desc, const struct side_arg *item);
62
63 static
64 void tracer_convert_string_to_utf8(const void *p, uint8_t unit_size, enum side_type_label_byte_order byte_order,
65 size_t *strlen_with_null,
66 char **output_str)
67 {
68 size_t ret, inbytesleft = 0, outbytesleft, bufsize;
69 const char *str = p, *fromcode;
70 char *inbuf = (char *) p, *outbuf, *buf;
71 iconv_t cd;
72
73 switch (unit_size) {
74 case 1:
75 if (strlen_with_null)
76 *strlen_with_null = strlen(str) + 1;
77 *output_str = (char *) str;
78 return;
79 case 2:
80 {
81 const uint16_t *p16 = p;
82
83 switch (byte_order) {
84 case SIDE_TYPE_BYTE_ORDER_LE:
85 {
86 fromcode = "UTF-16LE";
87 break;
88 }
89 case SIDE_TYPE_BYTE_ORDER_BE:
90 {
91 fromcode = "UTF-16BE";
92 break;
93 }
94 default:
95 fprintf(stderr, "Unknown byte order\n");
96 abort();
97 }
98 for (; *p16; p16++)
99 inbytesleft += 2;
100 /*
101 * Worse case is U+FFFF UTF-16 (2 bytes) converting to
102 * { ef, bf, bf } UTF-8 (3 bytes).
103 */
104 bufsize = inbytesleft / 2 * 3 + 1;
105 break;
106 }
107 case 4:
108 {
109 const uint32_t *p32 = p;
110
111 switch (byte_order) {
112 case SIDE_TYPE_BYTE_ORDER_LE:
113 {
114 fromcode = "UTF-32LE";
115 break;
116 }
117 case SIDE_TYPE_BYTE_ORDER_BE:
118 {
119 fromcode = "UTF-32BE";
120 break;
121 }
122 default:
123 fprintf(stderr, "Unknown byte order\n");
124 abort();
125 }
126 for (; *p32; p32++)
127 inbytesleft += 4;
128 /*
129 * Each 4-byte UTF-32 character converts to at most a
130 * 4-byte UTF-8 character.
131 */
132 bufsize = inbytesleft + 1;
133 break;
134 }
135 default:
136 fprintf(stderr, "Unknown string unit size %" PRIu8 "\n", unit_size);
137 abort();
138 }
139
140 cd = iconv_open("UTF8", fromcode);
141 if (cd == (iconv_t) -1) {
142 perror("iconv_open");
143 abort();
144 }
145 buf = malloc(bufsize);
146 if (!buf) {
147 abort();
148 }
149 outbuf = (char *) buf;
150 outbytesleft = bufsize;
151 ret = iconv(cd, &inbuf, &inbytesleft, &outbuf, &outbytesleft);
152 if (ret == (size_t) -1) {
153 perror("iconv");
154 abort();
155 }
156 if (inbytesleft) {
157 fprintf(stderr, "Buffer too small to convert string input\n");
158 abort();
159 }
160 (*outbuf++) = '\0';
161 if (iconv_close(cd) == -1) {
162 perror("iconv_close");
163 abort();
164 }
165 if (strlen_with_null)
166 *strlen_with_null = outbuf - buf;
167 *output_str = buf;
168 }
169
170 static
171 void tracer_print_string(const void *p, uint8_t unit_size, enum side_type_label_byte_order byte_order,
172 size_t *strlen_with_null)
173 {
174 char *output_str = NULL;
175
176 tracer_convert_string_to_utf8(p, unit_size, byte_order, strlen_with_null, &output_str);
177 printf("\"%s\"", output_str);
178 if (output_str != p)
179 free(output_str);
180 }
181
182 static
183 int64_t get_attr_integer_value(const struct side_attr *attr)
184 {
185 int64_t val;
186
187 switch (attr->value.type) {
188 case SIDE_ATTR_TYPE_U8:
189 val = attr->value.u.integer_value.side_u8;
190 break;
191 case SIDE_ATTR_TYPE_U16:
192 val = attr->value.u.integer_value.side_u16;
193 break;
194 case SIDE_ATTR_TYPE_U32:
195 val = attr->value.u.integer_value.side_u32;
196 break;
197 case SIDE_ATTR_TYPE_U64:
198 val = attr->value.u.integer_value.side_u64;
199 break;
200 case SIDE_ATTR_TYPE_S8:
201 val = attr->value.u.integer_value.side_s8;
202 break;
203 case SIDE_ATTR_TYPE_S16:
204 val = attr->value.u.integer_value.side_s16;
205 break;
206 case SIDE_ATTR_TYPE_S32:
207 val = attr->value.u.integer_value.side_s32;
208 break;
209 case SIDE_ATTR_TYPE_S64:
210 val = attr->value.u.integer_value.side_s64;
211 break;
212 default:
213 fprintf(stderr, "Unexpected attribute type\n");
214 abort();
215 }
216 return val;
217 }
218
219 static
220 enum tracer_display_base get_attr_display_base(const struct side_attr *_attr, uint32_t nr_attr,
221 enum tracer_display_base default_base)
222 {
223 uint32_t i;
224
225 for (i = 0; i < nr_attr; i++) {
226 const struct side_attr *attr = &_attr[i];
227 char *utf8_str = NULL;
228 bool cmp;
229
230 tracer_convert_string_to_utf8(attr->key.p, attr->key.unit_size,
231 attr->key.byte_order, NULL, &utf8_str);
232 cmp = strcmp(utf8_str, "std.integer.base");
233 if (utf8_str != attr->key.p)
234 free(utf8_str);
235 if (!cmp) {
236 int64_t val = get_attr_integer_value(attr);
237
238 switch (val) {
239 case 2:
240 return TRACER_DISPLAY_BASE_2;
241 case 8:
242 return TRACER_DISPLAY_BASE_8;
243 case 10:
244 return TRACER_DISPLAY_BASE_10;
245 case 16:
246 return TRACER_DISPLAY_BASE_16;
247 default:
248 fprintf(stderr, "Unexpected integer display base: %" PRId64 "\n", val);
249 abort();
250 }
251 }
252 }
253 return default_base; /* Default */
254 }
255
256 static
257 void tracer_print_attr_type(const char *separator, const struct side_attr *attr)
258 {
259 char *utf8_str = NULL;
260
261 tracer_convert_string_to_utf8(attr->key.p, attr->key.unit_size,
262 attr->key.byte_order, NULL, &utf8_str);
263 printf("{ key%s \"%s\", value%s ", separator, utf8_str, separator);
264 if (utf8_str != attr->key.p)
265 free(utf8_str);
266 switch (attr->value.type) {
267 case SIDE_ATTR_TYPE_BOOL:
268 printf("%s", attr->value.u.bool_value ? "true" : "false");
269 break;
270 case SIDE_ATTR_TYPE_U8:
271 printf("%" PRIu8, attr->value.u.integer_value.side_u8);
272 break;
273 case SIDE_ATTR_TYPE_U16:
274 printf("%" PRIu16, attr->value.u.integer_value.side_u16);
275 break;
276 case SIDE_ATTR_TYPE_U32:
277 printf("%" PRIu32, attr->value.u.integer_value.side_u32);
278 break;
279 case SIDE_ATTR_TYPE_U64:
280 printf("%" PRIu64, attr->value.u.integer_value.side_u64);
281 break;
282 case SIDE_ATTR_TYPE_S8:
283 printf("%" PRId8, attr->value.u.integer_value.side_s8);
284 break;
285 case SIDE_ATTR_TYPE_S16:
286 printf("%" PRId16, attr->value.u.integer_value.side_s16);
287 break;
288 case SIDE_ATTR_TYPE_S32:
289 printf("%" PRId32, attr->value.u.integer_value.side_s32);
290 break;
291 case SIDE_ATTR_TYPE_S64:
292 printf("%" PRId64, attr->value.u.integer_value.side_s64);
293 break;
294 case SIDE_ATTR_TYPE_FLOAT_BINARY16:
295 #if __HAVE_FLOAT16
296 printf("%g", (double) attr->value.u.float_value.side_float_binary16);
297 break;
298 #else
299 fprintf(stderr, "ERROR: Unsupported binary16 float type\n");
300 abort();
301 #endif
302 case SIDE_ATTR_TYPE_FLOAT_BINARY32:
303 #if __HAVE_FLOAT32
304 printf("%g", (double) attr->value.u.float_value.side_float_binary32);
305 break;
306 #else
307 fprintf(stderr, "ERROR: Unsupported binary32 float type\n");
308 abort();
309 #endif
310 case SIDE_ATTR_TYPE_FLOAT_BINARY64:
311 #if __HAVE_FLOAT64
312 printf("%g", (double) attr->value.u.float_value.side_float_binary64);
313 break;
314 #else
315 fprintf(stderr, "ERROR: Unsupported binary64 float type\n");
316 abort();
317 #endif
318 case SIDE_ATTR_TYPE_FLOAT_BINARY128:
319 #if __HAVE_FLOAT128
320 printf("%Lg", (long double) attr->value.u.float_value.side_float_binary128);
321 break;
322 #else
323 fprintf(stderr, "ERROR: Unsupported binary128 float type\n");
324 abort();
325 #endif
326 case SIDE_ATTR_TYPE_STRING_UTF8:
327 tracer_print_string((const void *)(uintptr_t) attr->value.u.string_value,
328 1, SIDE_TYPE_BYTE_ORDER_HOST, NULL);
329 break;
330 case SIDE_ATTR_TYPE_STRING_UTF16:
331 tracer_print_string((const void *)(uintptr_t) attr->value.u.string_value,
332 2, SIDE_TYPE_BYTE_ORDER_HOST, NULL);
333 break;
334 case SIDE_ATTR_TYPE_STRING_UTF32:
335 tracer_print_string((const void *)(uintptr_t) attr->value.u.string_value,
336 4, SIDE_TYPE_BYTE_ORDER_HOST, NULL);
337 break;
338 default:
339 fprintf(stderr, "ERROR: <UNKNOWN ATTRIBUTE TYPE>");
340 abort();
341 }
342 printf(" }");
343 }
344
345 static
346 void print_attributes(const char *prefix_str, const char *separator,
347 const struct side_attr *attr, uint32_t nr_attr)
348 {
349 uint32_t i;
350
351 if (!nr_attr)
352 return;
353 printf("%s%s [ ", prefix_str, separator);
354 for (i = 0; i < nr_attr; i++) {
355 printf("%s", i ? ", " : "");
356 tracer_print_attr_type(separator, &attr[i]);
357 }
358 printf(" ]");
359 }
360
361 static
362 union int64_value tracer_load_integer_value(const struct side_type_integer *type_integer,
363 const union side_integer_value *value,
364 uint16_t offset_bits, uint16_t *_len_bits)
365 {
366 union int64_value v64;
367 uint16_t len_bits;
368 bool reverse_bo;
369
370 if (!type_integer->len_bits)
371 len_bits = type_integer->integer_size * CHAR_BIT;
372 else
373 len_bits = type_integer->len_bits;
374 if (len_bits + offset_bits > type_integer->integer_size * CHAR_BIT)
375 abort();
376 reverse_bo = type_integer->byte_order != SIDE_TYPE_BYTE_ORDER_HOST;
377 switch (type_integer->integer_size) {
378 case 1:
379 if (type_integer->signedness)
380 v64.s = value->side_s8;
381 else
382 v64.u = value->side_u8;
383 break;
384 case 2:
385 if (type_integer->signedness) {
386 int16_t side_s16;
387
388 side_s16 = value->side_s16;
389 if (reverse_bo)
390 side_s16 = side_bswap_16(side_s16);
391 v64.s = side_s16;
392 } else {
393 uint16_t side_u16;
394
395 side_u16 = value->side_u16;
396 if (reverse_bo)
397 side_u16 = side_bswap_16(side_u16);
398 v64.u = side_u16;
399 }
400 break;
401 case 4:
402 if (type_integer->signedness) {
403 int32_t side_s32;
404
405 side_s32 = value->side_s32;
406 if (reverse_bo)
407 side_s32 = side_bswap_32(side_s32);
408 v64.s = side_s32;
409 } else {
410 uint32_t side_u32;
411
412 side_u32 = value->side_u32;
413 if (reverse_bo)
414 side_u32 = side_bswap_32(side_u32);
415 v64.u = side_u32;
416 }
417 break;
418 case 8:
419 if (type_integer->signedness) {
420 int64_t side_s64;
421
422 side_s64 = value->side_s64;
423 if (reverse_bo)
424 side_s64 = side_bswap_64(side_s64);
425 v64.s = side_s64;
426 } else {
427 uint64_t side_u64;
428
429 side_u64 = value->side_u64;
430 if (reverse_bo)
431 side_u64 = side_bswap_64(side_u64);
432 v64.u = side_u64;
433 }
434 break;
435 default:
436 abort();
437 }
438 v64.u >>= offset_bits;
439 if (len_bits < 64) {
440 v64.u &= (1ULL << len_bits) - 1;
441 if (type_integer->signedness) {
442 /* Sign-extend. */
443 if (v64.u & (1ULL << (len_bits - 1)))
444 v64.u |= ~((1ULL << len_bits) - 1);
445 }
446 }
447 if (_len_bits)
448 *_len_bits = len_bits;
449 return v64;
450 }
451
452 static
453 void print_enum_labels(const struct side_enum_mappings *mappings, union int64_value v64)
454 {
455 uint32_t i, print_count = 0;
456
457 printf(", labels: [ ");
458 for (i = 0; i < mappings->nr_mappings; i++) {
459 const struct side_enum_mapping *mapping = &mappings->mappings[i];
460
461 if (mapping->range_end < mapping->range_begin) {
462 fprintf(stderr, "ERROR: Unexpected enum range: %" PRIu64 "-%" PRIu64 "\n",
463 mapping->range_begin, mapping->range_end);
464 abort();
465 }
466 if (v64.s >= mapping->range_begin && v64.s <= mapping->range_end) {
467 printf("%s", print_count++ ? ", " : "");
468 printf("\"%s\"", mapping->label);
469 }
470 }
471 if (!print_count)
472 printf("<NO LABEL>");
473 printf(" ]");
474 }
475
476 static
477 void tracer_print_enum(const struct side_type *type_desc, const struct side_arg *item)
478 {
479 const struct side_enum_mappings *mappings = type_desc->u.side_enum.mappings;
480 const struct side_type *elem_type = type_desc->u.side_enum.elem_type;
481 union int64_value v64;
482
483 if (elem_type->type != item->type) {
484 fprintf(stderr, "ERROR: Unexpected enum element type\n");
485 abort();
486 }
487 v64 = tracer_load_integer_value(&elem_type->u.side_integer,
488 &item->u.side_static.integer_value, 0, NULL);
489 print_attributes("attr", ":", mappings->attr, mappings->nr_attr);
490 printf("%s", mappings->nr_attr ? ", " : "");
491 tracer_print_type(elem_type, item);
492 print_enum_labels(mappings, v64);
493 }
494
495 static
496 uint32_t elem_type_to_stride(const struct side_type *elem_type)
497 {
498 uint32_t stride_bit;
499
500 switch (elem_type->type) {
501 case SIDE_TYPE_BYTE:
502 stride_bit = 8;
503 break;
504
505 case SIDE_TYPE_U8:
506 case SIDE_TYPE_U16:
507 case SIDE_TYPE_U32:
508 case SIDE_TYPE_U64:
509 case SIDE_TYPE_S8:
510 case SIDE_TYPE_S16:
511 case SIDE_TYPE_S32:
512 case SIDE_TYPE_S64:
513 return elem_type->u.side_integer.integer_size * CHAR_BIT;
514 default:
515 fprintf(stderr, "ERROR: Unexpected enum bitmap element type\n");
516 abort();
517 }
518 return stride_bit;
519 }
520
521 static
522 void tracer_print_enum_bitmap(const struct side_type *type_desc,
523 const struct side_arg *item)
524 {
525 const struct side_enum_bitmap_mappings *side_enum_mappings = type_desc->u.side_enum_bitmap.mappings;
526 const struct side_type *enum_elem_type = type_desc->u.side_enum_bitmap.elem_type, *elem_type;
527 uint32_t i, print_count = 0, stride_bit, nr_items;
528 const struct side_arg *array_item;
529
530 switch (enum_elem_type->type) {
531 case SIDE_TYPE_U8: /* Fall-through */
532 case SIDE_TYPE_BYTE: /* Fall-through */
533 case SIDE_TYPE_U16: /* Fall-through */
534 case SIDE_TYPE_U32: /* Fall-through */
535 case SIDE_TYPE_U64: /* Fall-through */
536 case SIDE_TYPE_S8: /* Fall-through */
537 case SIDE_TYPE_S16: /* Fall-through */
538 case SIDE_TYPE_S32: /* Fall-through */
539 case SIDE_TYPE_S64:
540 elem_type = enum_elem_type;
541 array_item = item;
542 nr_items = 1;
543 break;
544 case SIDE_TYPE_ARRAY:
545 elem_type = enum_elem_type->u.side_array.elem_type;
546 array_item = item->u.side_static.side_array->sav;
547 nr_items = type_desc->u.side_array.length;
548 break;
549 case SIDE_TYPE_VLA:
550 elem_type = enum_elem_type->u.side_vla.elem_type;
551 array_item = item->u.side_static.side_vla->sav;
552 nr_items = item->u.side_static.side_vla->len;
553 break;
554 default:
555 fprintf(stderr, "ERROR: Unexpected enum element type\n");
556 abort();
557 }
558 stride_bit = elem_type_to_stride(elem_type);
559
560 print_attributes("attr", ":", side_enum_mappings->attr, side_enum_mappings->nr_attr);
561 printf("%s", side_enum_mappings->nr_attr ? ", " : "");
562 printf("labels: [ ");
563 for (i = 0; i < side_enum_mappings->nr_mappings; i++) {
564 const struct side_enum_bitmap_mapping *mapping = &side_enum_mappings->mappings[i];
565 bool match = false;
566 uint64_t bit;
567
568 if (mapping->range_end < mapping->range_begin) {
569 fprintf(stderr, "ERROR: Unexpected enum bitmap range: %" PRIu64 "-%" PRIu64 "\n",
570 mapping->range_begin, mapping->range_end);
571 abort();
572 }
573 for (bit = mapping->range_begin; bit <= mapping->range_end; bit++) {
574 if (bit > (nr_items * stride_bit) - 1)
575 break;
576 if (elem_type->type == SIDE_TYPE_BYTE) {
577 uint8_t v = array_item[bit / 8].u.side_static.byte_value;
578 if (v & (1ULL << (bit % 8))) {
579 match = true;
580 goto match;
581 }
582 } else {
583 union int64_value v64;
584
585 v64 = tracer_load_integer_value(&elem_type->u.side_integer,
586 &array_item[bit / stride_bit].u.side_static.integer_value,
587 0, NULL);
588 if (v64.u & (1ULL << (bit % stride_bit))) {
589 match = true;
590 goto match;
591 }
592 }
593 }
594 match:
595 if (match) {
596 printf("%s", print_count++ ? ", " : "");
597 printf("\"%s\"", mapping->label);
598 }
599 }
600 if (!print_count)
601 printf("<NO LABEL>");
602 printf(" ]");
603 }
604
605 static
606 void print_integer_binary(uint64_t v, int bits)
607 {
608 int i;
609
610 printf("0b");
611 v <<= 64 - bits;
612 for (i = 0; i < bits; i++) {
613 printf("%c", v & (1ULL << 63) ? '1' : '0');
614 v <<= 1;
615 }
616 }
617
618 static
619 void tracer_print_type_header(const char *separator,
620 const struct side_attr *attr, uint32_t nr_attr)
621 {
622 print_attributes("attr", separator, attr, nr_attr);
623 printf("%s", nr_attr ? ", " : "");
624 printf("value%s ", separator);
625 }
626
627 static
628 void tracer_print_type_bool(const char *separator,
629 const struct side_type_bool *type_bool,
630 const union side_bool_value *value,
631 uint16_t offset_bits)
632 {
633 uint32_t len_bits;
634 bool reverse_bo;
635 uint64_t v;
636
637 if (!type_bool->len_bits)
638 len_bits = type_bool->bool_size * CHAR_BIT;
639 else
640 len_bits = type_bool->len_bits;
641 if (len_bits + offset_bits > type_bool->bool_size * CHAR_BIT)
642 abort();
643 reverse_bo = type_bool->byte_order != SIDE_TYPE_BYTE_ORDER_HOST;
644 switch (type_bool->bool_size) {
645 case 1:
646 v = value->side_bool8;
647 break;
648 case 2:
649 {
650 uint16_t side_u16;
651
652 side_u16 = value->side_bool16;
653 if (reverse_bo)
654 side_u16 = side_bswap_16(side_u16);
655 v = side_u16;
656 break;
657 }
658 case 4:
659 {
660 uint32_t side_u32;
661
662 side_u32 = value->side_bool32;
663 if (reverse_bo)
664 side_u32 = side_bswap_32(side_u32);
665 v = side_u32;
666 break;
667 }
668 case 8:
669 {
670 uint64_t side_u64;
671
672 side_u64 = value->side_bool64;
673 if (reverse_bo)
674 side_u64 = side_bswap_64(side_u64);
675 v = side_u64;
676 break;
677 }
678 default:
679 abort();
680 }
681 v >>= offset_bits;
682 if (len_bits < 64)
683 v &= (1ULL << len_bits) - 1;
684 tracer_print_type_header(separator, type_bool->attr, type_bool->nr_attr);
685 printf("%s", v ? "true" : "false");
686 }
687
688 static
689 void tracer_print_type_integer(const char *separator,
690 const struct side_type_integer *type_integer,
691 const union side_integer_value *value,
692 uint16_t offset_bits,
693 enum tracer_display_base default_base)
694 {
695 enum tracer_display_base base;
696 union int64_value v64;
697 uint16_t len_bits;
698
699 v64 = tracer_load_integer_value(type_integer, value, offset_bits, &len_bits);
700 tracer_print_type_header(separator, type_integer->attr, type_integer->nr_attr);
701 base = get_attr_display_base(type_integer->attr, type_integer->nr_attr, default_base);
702 switch (base) {
703 case TRACER_DISPLAY_BASE_2:
704 print_integer_binary(v64.u, len_bits);
705 break;
706 case TRACER_DISPLAY_BASE_8:
707 /* Clear sign bits beyond len_bits */
708 if (len_bits < 64)
709 v64.u &= (1ULL << len_bits) - 1;
710 printf("0%" PRIo64, v64.u);
711 break;
712 case TRACER_DISPLAY_BASE_10:
713 if (type_integer->signedness)
714 printf("%" PRId64, v64.s);
715 else
716 printf("%" PRIu64, v64.u);
717 break;
718 case TRACER_DISPLAY_BASE_16:
719 /* Clear sign bits beyond len_bits */
720 if (len_bits < 64)
721 v64.u &= (1ULL << len_bits) - 1;
722 printf("0x%" PRIx64, v64.u);
723 break;
724 default:
725 abort();
726 }
727 }
728
729 static
730 void tracer_print_type_float(const char *separator,
731 const struct side_type_float *type_float,
732 const union side_float_value *value)
733 {
734 bool reverse_bo;
735
736 tracer_print_type_header(separator, type_float->attr, type_float->nr_attr);
737 reverse_bo = type_float->byte_order != SIDE_TYPE_FLOAT_WORD_ORDER_HOST;
738 switch (type_float->float_size) {
739 case 2:
740 {
741 #if __HAVE_FLOAT16
742 union {
743 _Float16 f;
744 uint16_t u;
745 } float16 = {
746 .f = value->side_float_binary16,
747 };
748
749 if (reverse_bo)
750 float16.u = side_bswap_16(float16.u);
751 printf("%g", (double) float16.f);
752 break;
753 #else
754 fprintf(stderr, "ERROR: Unsupported binary16 float type\n");
755 abort();
756 #endif
757 }
758 case 4:
759 {
760 #if __HAVE_FLOAT32
761 union {
762 _Float32 f;
763 uint32_t u;
764 } float32 = {
765 .f = value->side_float_binary32,
766 };
767
768 if (reverse_bo)
769 float32.u = side_bswap_32(float32.u);
770 printf("%g", (double) float32.f);
771 break;
772 #else
773 fprintf(stderr, "ERROR: Unsupported binary32 float type\n");
774 abort();
775 #endif
776 }
777 case 8:
778 {
779 #if __HAVE_FLOAT64
780 union {
781 _Float64 f;
782 uint64_t u;
783 } float64 = {
784 .f = value->side_float_binary64,
785 };
786
787 if (reverse_bo)
788 float64.u = side_bswap_64(float64.u);
789 printf("%g", (double) float64.f);
790 break;
791 #else
792 fprintf(stderr, "ERROR: Unsupported binary64 float type\n");
793 abort();
794 #endif
795 }
796 case 16:
797 {
798 #if __HAVE_FLOAT128
799 union {
800 _Float128 f;
801 char arr[16];
802 } float128 = {
803 .f = value->side_float_binary128,
804 };
805
806 if (reverse_bo)
807 side_bswap_128p(float128.arr);
808 printf("%Lg", (long double) float128.f);
809 break;
810 #else
811 fprintf(stderr, "ERROR: Unsupported binary128 float type\n");
812 abort();
813 #endif
814 }
815 default:
816 fprintf(stderr, "ERROR: Unknown float size\n");
817 abort();
818 }
819 }
820
821 static
822 void tracer_print_type(const struct side_type *type_desc, const struct side_arg *item)
823 {
824 enum side_type_label type;
825
826 switch (type_desc->type) {
827 case SIDE_TYPE_ENUM:
828 switch (item->type) {
829 case SIDE_TYPE_U8:
830 case SIDE_TYPE_U16:
831 case SIDE_TYPE_U32:
832 case SIDE_TYPE_U64:
833 case SIDE_TYPE_S8:
834 case SIDE_TYPE_S16:
835 case SIDE_TYPE_S32:
836 case SIDE_TYPE_S64:
837 break;
838 default:
839 fprintf(stderr, "ERROR: type mismatch between description and arguments\n");
840 abort();
841 break;
842 }
843 break;
844
845 case SIDE_TYPE_ENUM_BITMAP:
846 switch (item->type) {
847 case SIDE_TYPE_U8:
848 case SIDE_TYPE_BYTE:
849 case SIDE_TYPE_U16:
850 case SIDE_TYPE_U32:
851 case SIDE_TYPE_U64:
852 case SIDE_TYPE_ARRAY:
853 case SIDE_TYPE_VLA:
854 break;
855 default:
856 fprintf(stderr, "ERROR: type mismatch between description and arguments\n");
857 abort();
858 break;
859 }
860 break;
861
862 case SIDE_TYPE_GATHER_ENUM:
863 switch (item->type) {
864 case SIDE_TYPE_GATHER_INTEGER:
865 break;
866 default:
867 fprintf(stderr, "ERROR: type mismatch between description and arguments\n");
868 abort();
869 break;
870 }
871 break;
872
873 case SIDE_TYPE_DYNAMIC:
874 switch (item->type) {
875 case SIDE_TYPE_DYNAMIC_NULL:
876 case SIDE_TYPE_DYNAMIC_BOOL:
877 case SIDE_TYPE_DYNAMIC_INTEGER:
878 case SIDE_TYPE_DYNAMIC_BYTE:
879 case SIDE_TYPE_DYNAMIC_POINTER:
880 case SIDE_TYPE_DYNAMIC_FLOAT:
881 case SIDE_TYPE_DYNAMIC_STRING:
882 case SIDE_TYPE_DYNAMIC_STRUCT:
883 case SIDE_TYPE_DYNAMIC_STRUCT_VISITOR:
884 case SIDE_TYPE_DYNAMIC_VLA:
885 case SIDE_TYPE_DYNAMIC_VLA_VISITOR:
886 break;
887 default:
888 fprintf(stderr, "ERROR: Unexpected dynamic type\n");
889 abort();
890 break;
891 }
892 break;
893
894 default:
895 if (type_desc->type != item->type) {
896 fprintf(stderr, "ERROR: type mismatch between description and arguments\n");
897 abort();
898 }
899 break;
900 }
901
902 if (type_desc->type == SIDE_TYPE_ENUM || type_desc->type == SIDE_TYPE_ENUM_BITMAP ||
903 type_desc->type == SIDE_TYPE_GATHER_ENUM)
904 type = (enum side_type_label) type_desc->type;
905 else
906 type = (enum side_type_label) item->type;
907
908 printf("{ ");
909 switch (type) {
910 /* Stack-copy basic types */
911 case SIDE_TYPE_NULL:
912 tracer_print_type_header(":", type_desc->u.side_null.attr, type_desc->u.side_null.nr_attr);
913 printf("<NULL TYPE>");
914 break;
915
916 case SIDE_TYPE_BOOL:
917 tracer_print_type_bool(":", &type_desc->u.side_bool, &item->u.side_static.bool_value, 0);
918 break;
919
920 case SIDE_TYPE_U8:
921 case SIDE_TYPE_U16:
922 case SIDE_TYPE_U32:
923 case SIDE_TYPE_U64:
924 case SIDE_TYPE_S8:
925 case SIDE_TYPE_S16:
926 case SIDE_TYPE_S32:
927 case SIDE_TYPE_S64:
928 tracer_print_type_integer(":", &type_desc->u.side_integer, &item->u.side_static.integer_value, 0,
929 TRACER_DISPLAY_BASE_10);
930 break;
931
932 case SIDE_TYPE_BYTE:
933 tracer_print_type_header(":", type_desc->u.side_byte.attr, type_desc->u.side_byte.nr_attr);
934 printf("0x%" PRIx8, item->u.side_static.byte_value);
935 break;
936
937 case SIDE_TYPE_POINTER:
938 tracer_print_type_integer(":", &type_desc->u.side_integer, &item->u.side_static.integer_value, 0,
939 TRACER_DISPLAY_BASE_16);
940 break;
941
942 case SIDE_TYPE_FLOAT_BINARY16:
943 case SIDE_TYPE_FLOAT_BINARY32:
944 case SIDE_TYPE_FLOAT_BINARY64:
945 case SIDE_TYPE_FLOAT_BINARY128:
946 tracer_print_type_float(":", &type_desc->u.side_float, &item->u.side_static.float_value);
947 break;
948
949 case SIDE_TYPE_STRING_UTF8:
950 case SIDE_TYPE_STRING_UTF16:
951 case SIDE_TYPE_STRING_UTF32:
952 tracer_print_type_header(":", type_desc->u.side_string.attr, type_desc->u.side_string.nr_attr);
953 tracer_print_string((const void *)(uintptr_t) item->u.side_static.string_value,
954 type_desc->u.side_string.unit_size, type_desc->u.side_string.byte_order, NULL);
955 break;
956
957 /* Stack-copy compound types */
958 case SIDE_TYPE_STRUCT:
959 tracer_print_struct(type_desc, item->u.side_static.side_struct);
960 break;
961 case SIDE_TYPE_ARRAY:
962 tracer_print_array(type_desc, item->u.side_static.side_array);
963 break;
964 case SIDE_TYPE_VLA:
965 tracer_print_vla(type_desc, item->u.side_static.side_vla);
966 break;
967 case SIDE_TYPE_VLA_VISITOR:
968 tracer_print_vla_visitor(type_desc, item->u.side_static.side_vla_app_visitor_ctx);
969 break;
970
971 /* Stack-copy enumeration types */
972 case SIDE_TYPE_ENUM:
973 tracer_print_enum(type_desc, item);
974 break;
975 case SIDE_TYPE_ENUM_BITMAP:
976 tracer_print_enum_bitmap(type_desc, item);
977 break;
978
979 /* Gather basic types */
980 case SIDE_TYPE_GATHER_BOOL:
981 (void) tracer_print_gather_bool_type(&type_desc->u.side_gather, item->u.side_static.side_bool_gather_ptr);
982 break;
983 case SIDE_TYPE_GATHER_INTEGER:
984 (void) tracer_print_gather_integer_type(&type_desc->u.side_gather, item->u.side_static.side_integer_gather_ptr,
985 TRACER_DISPLAY_BASE_10);
986 break;
987 case SIDE_TYPE_GATHER_BYTE:
988 (void) tracer_print_gather_byte_type(&type_desc->u.side_gather, item->u.side_static.side_byte_gather_ptr);
989 break;
990 case SIDE_TYPE_GATHER_POINTER:
991 (void) tracer_print_gather_integer_type(&type_desc->u.side_gather, item->u.side_static.side_integer_gather_ptr,
992 TRACER_DISPLAY_BASE_16);
993 break;
994 case SIDE_TYPE_GATHER_FLOAT:
995 (void) tracer_print_gather_float_type(&type_desc->u.side_gather, item->u.side_static.side_float_gather_ptr);
996 break;
997 case SIDE_TYPE_GATHER_STRING:
998 (void) tracer_print_gather_string_type(&type_desc->u.side_gather, item->u.side_static.side_string_gather_ptr);
999 break;
1000
1001 /* Gather compound type */
1002 case SIDE_TYPE_GATHER_STRUCT:
1003 (void) tracer_print_gather_struct(&type_desc->u.side_gather, item->u.side_static.side_struct_gather_ptr);
1004 break;
1005 case SIDE_TYPE_GATHER_ARRAY:
1006 (void) tracer_print_gather_array(&type_desc->u.side_gather, item->u.side_static.side_array_gather_ptr);
1007 break;
1008 case SIDE_TYPE_GATHER_VLA:
1009 (void) tracer_print_gather_vla(&type_desc->u.side_gather, item->u.side_static.side_vla_gather.ptr,
1010 item->u.side_static.side_vla_gather.length_ptr);
1011 break;
1012
1013 /* Gather enumeration types */
1014 case SIDE_TYPE_GATHER_ENUM:
1015 (void) tracer_print_gather_enum_type(&type_desc->u.side_gather, item->u.side_static.side_integer_gather_ptr);
1016 break;
1017
1018 /* Dynamic basic types */
1019 case SIDE_TYPE_DYNAMIC_NULL:
1020 case SIDE_TYPE_DYNAMIC_BOOL:
1021 case SIDE_TYPE_DYNAMIC_INTEGER:
1022 case SIDE_TYPE_DYNAMIC_BYTE:
1023 case SIDE_TYPE_DYNAMIC_POINTER:
1024 case SIDE_TYPE_DYNAMIC_FLOAT:
1025 case SIDE_TYPE_DYNAMIC_STRING:
1026
1027 /* Dynamic compound types */
1028 case SIDE_TYPE_DYNAMIC_STRUCT:
1029 case SIDE_TYPE_DYNAMIC_STRUCT_VISITOR:
1030 case SIDE_TYPE_DYNAMIC_VLA:
1031 case SIDE_TYPE_DYNAMIC_VLA_VISITOR:
1032 tracer_print_dynamic(item);
1033 break;
1034 default:
1035 fprintf(stderr, "<UNKNOWN TYPE>\n");
1036 abort();
1037 }
1038 printf(" }");
1039 }
1040
1041 static
1042 void tracer_print_field(const struct side_event_field *item_desc, const struct side_arg *item)
1043 {
1044 printf("%s: ", item_desc->field_name);
1045 tracer_print_type(&item_desc->side_type, item);
1046 }
1047
1048 static
1049 void tracer_print_struct(const struct side_type *type_desc, const struct side_arg_vec *side_arg_vec)
1050 {
1051 const struct side_arg *sav = side_arg_vec->sav;
1052 uint32_t i, side_sav_len = side_arg_vec->len;
1053
1054 if (type_desc->u.side_struct->nr_fields != side_sav_len) {
1055 fprintf(stderr, "ERROR: number of fields mismatch between description and arguments of structure\n");
1056 abort();
1057 }
1058 print_attributes("attr", ":", type_desc->u.side_struct->attr, type_desc->u.side_struct->nr_attr);
1059 printf("%s", type_desc->u.side_struct->nr_attr ? ", " : "");
1060 printf("fields: { ");
1061 for (i = 0; i < side_sav_len; i++) {
1062 printf("%s", i ? ", " : "");
1063 tracer_print_field(&type_desc->u.side_struct->fields[i], &sav[i]);
1064 }
1065 printf(" }");
1066 }
1067
1068 static
1069 void tracer_print_array(const struct side_type *type_desc, const struct side_arg_vec *side_arg_vec)
1070 {
1071 const struct side_arg *sav = side_arg_vec->sav;
1072 uint32_t i, side_sav_len = side_arg_vec->len;
1073
1074 if (type_desc->u.side_array.length != side_sav_len) {
1075 fprintf(stderr, "ERROR: length mismatch between description and arguments of array\n");
1076 abort();
1077 }
1078 print_attributes("attr", ":", type_desc->u.side_array.attr, type_desc->u.side_array.nr_attr);
1079 printf("%s", type_desc->u.side_array.nr_attr ? ", " : "");
1080 printf("elements: ");
1081 printf("[ ");
1082 for (i = 0; i < side_sav_len; i++) {
1083 printf("%s", i ? ", " : "");
1084 tracer_print_type(type_desc->u.side_array.elem_type, &sav[i]);
1085 }
1086 printf(" ]");
1087 }
1088
1089 static
1090 void tracer_print_vla(const struct side_type *type_desc, const struct side_arg_vec *side_arg_vec)
1091 {
1092 const struct side_arg *sav = side_arg_vec->sav;
1093 uint32_t i, side_sav_len = side_arg_vec->len;
1094
1095 print_attributes("attr", ":", type_desc->u.side_vla.attr, type_desc->u.side_vla.nr_attr);
1096 printf("%s", type_desc->u.side_vla.nr_attr ? ", " : "");
1097 printf("elements: ");
1098 printf("[ ");
1099 for (i = 0; i < side_sav_len; i++) {
1100 printf("%s", i ? ", " : "");
1101 tracer_print_type(type_desc->u.side_vla.elem_type, &sav[i]);
1102 }
1103 printf(" ]");
1104 }
1105
1106 static
1107 const char *tracer_gather_access(enum side_type_gather_access_mode access_mode, const char *ptr)
1108 {
1109 switch (access_mode) {
1110 case SIDE_TYPE_GATHER_ACCESS_DIRECT:
1111 return ptr;
1112 case SIDE_TYPE_GATHER_ACCESS_POINTER:
1113 /* Dereference pointer */
1114 memcpy(&ptr, ptr, sizeof(ptr));
1115 return ptr;
1116 default:
1117 abort();
1118 }
1119 }
1120
1121 static
1122 uint32_t tracer_gather_size(enum side_type_gather_access_mode access_mode, uint32_t len)
1123 {
1124 switch (access_mode) {
1125 case SIDE_TYPE_GATHER_ACCESS_DIRECT:
1126 return len;
1127 case SIDE_TYPE_GATHER_ACCESS_POINTER:
1128 return sizeof(void *);
1129 default:
1130 abort();
1131 }
1132 }
1133
1134 static
1135 union int64_value tracer_load_gather_integer_value(const struct side_type_gather_integer *side_integer,
1136 const void *_ptr)
1137 {
1138 enum side_type_gather_access_mode access_mode =
1139 (enum side_type_gather_access_mode) side_integer->access_mode;
1140 uint32_t integer_size_bytes = side_integer->type.integer_size;
1141 const char *ptr = (const char *) _ptr;
1142 union side_integer_value value;
1143
1144 ptr = tracer_gather_access(access_mode, ptr + side_integer->offset);
1145 memcpy(&value, ptr, integer_size_bytes);
1146 return tracer_load_integer_value(&side_integer->type, &value,
1147 side_integer->offset_bits, NULL);
1148 }
1149
1150 static
1151 uint32_t tracer_print_gather_bool_type(const struct side_type_gather *type_gather, const void *_ptr)
1152 {
1153 enum side_type_gather_access_mode access_mode =
1154 (enum side_type_gather_access_mode) type_gather->u.side_bool.access_mode;
1155 uint32_t bool_size_bytes = type_gather->u.side_bool.type.bool_size;
1156 const char *ptr = (const char *) _ptr;
1157 union side_bool_value value;
1158
1159 switch (bool_size_bytes) {
1160 case 1:
1161 case 2:
1162 case 4:
1163 case 8:
1164 break;
1165 default:
1166 abort();
1167 }
1168 ptr = tracer_gather_access(access_mode, ptr + type_gather->u.side_bool.offset);
1169 memcpy(&value, ptr, bool_size_bytes);
1170 tracer_print_type_bool(":", &type_gather->u.side_bool.type, &value,
1171 type_gather->u.side_bool.offset_bits);
1172 return tracer_gather_size(access_mode, bool_size_bytes);
1173 }
1174
1175 static
1176 uint32_t tracer_print_gather_byte_type(const struct side_type_gather *type_gather, const void *_ptr)
1177 {
1178 enum side_type_gather_access_mode access_mode =
1179 (enum side_type_gather_access_mode) type_gather->u.side_byte.access_mode;
1180 const char *ptr = (const char *) _ptr;
1181 uint8_t value;
1182
1183 ptr = tracer_gather_access(access_mode, ptr + type_gather->u.side_byte.offset);
1184 memcpy(&value, ptr, 1);
1185 tracer_print_type_header(":", type_gather->u.side_byte.type.attr,
1186 type_gather->u.side_byte.type.nr_attr);
1187 printf("0x%" PRIx8, value);
1188 return tracer_gather_size(access_mode, 1);
1189 }
1190
1191 static
1192 uint32_t tracer_print_gather_integer_type(const struct side_type_gather *type_gather, const void *_ptr,
1193 enum tracer_display_base default_base)
1194 {
1195 enum side_type_gather_access_mode access_mode =
1196 (enum side_type_gather_access_mode) type_gather->u.side_integer.access_mode;
1197 uint32_t integer_size_bytes = type_gather->u.side_integer.type.integer_size;
1198 const char *ptr = (const char *) _ptr;
1199 union side_integer_value value;
1200
1201 switch (integer_size_bytes) {
1202 case 1:
1203 case 2:
1204 case 4:
1205 case 8:
1206 break;
1207 default:
1208 abort();
1209 }
1210 ptr = tracer_gather_access(access_mode, ptr + type_gather->u.side_integer.offset);
1211 memcpy(&value, ptr, integer_size_bytes);
1212 tracer_print_type_integer(":", &type_gather->u.side_integer.type, &value,
1213 type_gather->u.side_integer.offset_bits, default_base);
1214 return tracer_gather_size(access_mode, integer_size_bytes);
1215 }
1216
1217 static
1218 uint32_t tracer_print_gather_float_type(const struct side_type_gather *type_gather, const void *_ptr)
1219 {
1220 enum side_type_gather_access_mode access_mode =
1221 (enum side_type_gather_access_mode) type_gather->u.side_float.access_mode;
1222 uint32_t float_size_bytes = type_gather->u.side_float.type.float_size;
1223 const char *ptr = (const char *) _ptr;
1224 union side_float_value value;
1225
1226 switch (float_size_bytes) {
1227 case 2:
1228 case 4:
1229 case 8:
1230 case 16:
1231 break;
1232 default:
1233 abort();
1234 }
1235 ptr = tracer_gather_access(access_mode, ptr + type_gather->u.side_float.offset);
1236 memcpy(&value, ptr, float_size_bytes);
1237 tracer_print_type_float(":", &type_gather->u.side_float.type, &value);
1238 return tracer_gather_size(access_mode, float_size_bytes);
1239 }
1240
1241 static
1242 uint32_t tracer_print_gather_string_type(const struct side_type_gather *type_gather, const void *_ptr)
1243 {
1244 enum side_type_gather_access_mode access_mode =
1245 (enum side_type_gather_access_mode) type_gather->u.side_string.access_mode;
1246 const char *ptr = (const char *) _ptr;
1247 size_t string_len;
1248
1249 ptr = tracer_gather_access(access_mode, ptr + type_gather->u.side_string.offset);
1250 tracer_print_type_header(":", type_gather->u.side_string.type.attr,
1251 type_gather->u.side_string.type.nr_attr);
1252 if (ptr) {
1253 tracer_print_string(ptr, type_gather->u.side_string.type.unit_size,
1254 type_gather->u.side_string.type.byte_order, &string_len);
1255 } else {
1256 printf("<NULL>");
1257 string_len = type_gather->u.side_string.type.unit_size;
1258 }
1259 return tracer_gather_size(access_mode, string_len);
1260 }
1261
1262 static
1263 uint32_t tracer_print_gather_type(const struct side_type *type_desc, const void *ptr)
1264 {
1265 uint32_t len;
1266
1267 printf("{ ");
1268 switch (type_desc->type) {
1269 /* Gather basic types */
1270 case SIDE_TYPE_GATHER_BOOL:
1271 len = tracer_print_gather_bool_type(&type_desc->u.side_gather, ptr);
1272 break;
1273 case SIDE_TYPE_GATHER_INTEGER:
1274 len = tracer_print_gather_integer_type(&type_desc->u.side_gather, ptr,
1275 TRACER_DISPLAY_BASE_10);
1276 break;
1277 case SIDE_TYPE_GATHER_BYTE:
1278 len = tracer_print_gather_byte_type(&type_desc->u.side_gather, ptr);
1279 break;
1280 case SIDE_TYPE_GATHER_POINTER:
1281 len = tracer_print_gather_integer_type(&type_desc->u.side_gather, ptr,
1282 TRACER_DISPLAY_BASE_16);
1283 break;
1284 case SIDE_TYPE_GATHER_FLOAT:
1285 len = tracer_print_gather_float_type(&type_desc->u.side_gather, ptr);
1286 break;
1287 case SIDE_TYPE_GATHER_STRING:
1288 len = tracer_print_gather_string_type(&type_desc->u.side_gather, ptr);
1289 break;
1290
1291 /* Gather enum types */
1292 case SIDE_TYPE_GATHER_ENUM:
1293 len = tracer_print_gather_enum_type(&type_desc->u.side_gather, ptr);
1294 break;
1295
1296 /* Gather compound types */
1297 case SIDE_TYPE_GATHER_STRUCT:
1298 len = tracer_print_gather_struct(&type_desc->u.side_gather, ptr);
1299 break;
1300 case SIDE_TYPE_GATHER_ARRAY:
1301 len = tracer_print_gather_array(&type_desc->u.side_gather, ptr);
1302 break;
1303 case SIDE_TYPE_GATHER_VLA:
1304 len = tracer_print_gather_vla(&type_desc->u.side_gather, ptr, ptr);
1305 break;
1306 default:
1307 fprintf(stderr, "<UNKNOWN GATHER TYPE>");
1308 abort();
1309 }
1310 printf(" }");
1311 return len;
1312 }
1313
1314 static
1315 uint32_t tracer_print_gather_enum_type(const struct side_type_gather *type_gather, const void *_ptr)
1316 {
1317 const struct side_enum_mappings *mappings = type_gather->u.side_enum.mappings;
1318 const struct side_type *enum_elem_type = type_gather->u.side_enum.elem_type;
1319 const struct side_type_gather_integer *side_integer = &enum_elem_type->u.side_gather.u.side_integer;
1320 enum side_type_gather_access_mode access_mode =
1321 (enum side_type_gather_access_mode) side_integer->access_mode;
1322 uint32_t integer_size_bytes = side_integer->type.integer_size;
1323 const char *ptr = (const char *) _ptr;
1324 union side_integer_value value;
1325 union int64_value v64;
1326
1327 switch (integer_size_bytes) {
1328 case 1:
1329 case 2:
1330 case 4:
1331 case 8:
1332 break;
1333 default:
1334 abort();
1335 }
1336 ptr = tracer_gather_access(access_mode, ptr + side_integer->offset);
1337 memcpy(&value, ptr, integer_size_bytes);
1338 v64 = tracer_load_gather_integer_value(side_integer, &value);
1339 print_attributes("attr", ":", mappings->attr, mappings->nr_attr);
1340 printf("%s", mappings->nr_attr ? ", " : "");
1341 tracer_print_gather_type(enum_elem_type, ptr);
1342 print_enum_labels(mappings, v64);
1343 return tracer_gather_size(access_mode, integer_size_bytes);
1344 }
1345
1346 static
1347 void tracer_print_gather_field(const struct side_event_field *field, const void *ptr)
1348 {
1349 printf("%s: ", field->field_name);
1350 (void) tracer_print_gather_type(&field->side_type, ptr);
1351 }
1352
1353 static
1354 uint32_t tracer_print_gather_struct(const struct side_type_gather *type_gather, const void *_ptr)
1355 {
1356 enum side_type_gather_access_mode access_mode =
1357 (enum side_type_gather_access_mode) type_gather->u.side_struct.access_mode;
1358 const char *ptr = (const char *) _ptr;
1359 uint32_t i;
1360
1361 ptr = tracer_gather_access(access_mode, ptr + type_gather->u.side_struct.offset);
1362 print_attributes("attr", ":", type_gather->u.side_struct.type->attr, type_gather->u.side_struct.type->nr_attr);
1363 printf("%s", type_gather->u.side_struct.type->nr_attr ? ", " : "");
1364 printf("fields: { ");
1365 for (i = 0; i < type_gather->u.side_struct.type->nr_fields; i++) {
1366 printf("%s", i ? ", " : "");
1367 tracer_print_gather_field(&type_gather->u.side_struct.type->fields[i], ptr);
1368 }
1369 printf(" }");
1370 return tracer_gather_size(access_mode, type_gather->u.side_struct.size);
1371 }
1372
1373 static
1374 uint32_t tracer_print_gather_array(const struct side_type_gather *type_gather, const void *_ptr)
1375 {
1376 enum side_type_gather_access_mode access_mode =
1377 (enum side_type_gather_access_mode) type_gather->u.side_array.access_mode;
1378 const char *ptr = (const char *) _ptr, *orig_ptr;
1379 uint32_t i;
1380
1381 ptr = tracer_gather_access(access_mode, ptr + type_gather->u.side_array.offset);
1382 orig_ptr = ptr;
1383 print_attributes("attr", ":", type_gather->u.side_array.type.attr, type_gather->u.side_array.type.nr_attr);
1384 printf("%s", type_gather->u.side_array.type.nr_attr ? ", " : "");
1385 printf("elements: ");
1386 printf("[ ");
1387 for (i = 0; i < type_gather->u.side_array.type.length; i++) {
1388 switch (type_gather->u.side_array.type.elem_type->type) {
1389 case SIDE_TYPE_GATHER_VLA:
1390 fprintf(stderr, "<gather VLA only supported within gather structures>\n");
1391 abort();
1392 default:
1393 break;
1394 }
1395 printf("%s", i ? ", " : "");
1396 ptr += tracer_print_gather_type(type_gather->u.side_array.type.elem_type, ptr);
1397 }
1398 printf(" ]");
1399 return tracer_gather_size(access_mode, ptr - orig_ptr);
1400 }
1401
1402 static
1403 uint32_t tracer_print_gather_vla(const struct side_type_gather *type_gather, const void *_ptr,
1404 const void *_length_ptr)
1405 {
1406 enum side_type_gather_access_mode access_mode =
1407 (enum side_type_gather_access_mode) type_gather->u.side_vla.access_mode;
1408 const char *ptr = (const char *) _ptr, *orig_ptr;
1409 const char *length_ptr = (const char *) _length_ptr;
1410 union int64_value v64;
1411 uint32_t i, length;
1412
1413 /* Access length */
1414 switch (type_gather->u.side_vla.length_type->type) {
1415 case SIDE_TYPE_GATHER_INTEGER:
1416 break;
1417 default:
1418 fprintf(stderr, "<gather VLA expects integer gather length type>\n");
1419 abort();
1420 }
1421 v64 = tracer_load_gather_integer_value(&type_gather->u.side_vla.length_type->u.side_gather.u.side_integer,
1422 length_ptr);
1423 length = (uint32_t) v64.u;
1424 ptr = tracer_gather_access(access_mode, ptr + type_gather->u.side_vla.offset);
1425 orig_ptr = ptr;
1426 print_attributes("attr", ":", type_gather->u.side_vla.type.attr, type_gather->u.side_vla.type.nr_attr);
1427 printf("%s", type_gather->u.side_vla.type.nr_attr ? ", " : "");
1428 printf("elements: ");
1429 printf("[ ");
1430 for (i = 0; i < length; i++) {
1431 switch (type_gather->u.side_vla.type.elem_type->type) {
1432 case SIDE_TYPE_GATHER_VLA:
1433 fprintf(stderr, "<gather VLA only supported within gather structures>\n");
1434 abort();
1435 default:
1436 break;
1437 }
1438 printf("%s", i ? ", " : "");
1439 ptr += tracer_print_gather_type(type_gather->u.side_vla.type.elem_type, ptr);
1440 }
1441 printf(" ]");
1442 return tracer_gather_size(access_mode, ptr - orig_ptr);
1443 }
1444
1445 struct tracer_visitor_priv {
1446 const struct side_type *elem_type;
1447 int i;
1448 };
1449
1450 static
1451 enum side_visitor_status tracer_write_elem_cb(const struct side_tracer_visitor_ctx *tracer_ctx,
1452 const struct side_arg *elem)
1453 {
1454 struct tracer_visitor_priv *tracer_priv = (struct tracer_visitor_priv *) tracer_ctx->priv;
1455
1456 printf("%s", tracer_priv->i++ ? ", " : "");
1457 tracer_print_type(tracer_priv->elem_type, elem);
1458 return SIDE_VISITOR_STATUS_OK;
1459 }
1460
1461 static
1462 void tracer_print_vla_visitor(const struct side_type *type_desc, void *app_ctx)
1463 {
1464 enum side_visitor_status status;
1465 struct tracer_visitor_priv tracer_priv = {
1466 .elem_type = type_desc->u.side_vla_visitor.elem_type,
1467 .i = 0,
1468 };
1469 const struct side_tracer_visitor_ctx tracer_ctx = {
1470 .write_elem = tracer_write_elem_cb,
1471 .priv = &tracer_priv,
1472 };
1473
1474 print_attributes("attr", ":", type_desc->u.side_vla_visitor.attr, type_desc->u.side_vla_visitor.nr_attr);
1475 printf("%s", type_desc->u.side_vla_visitor.nr_attr ? ", " : "");
1476 printf("elements: ");
1477 printf("[ ");
1478 status = type_desc->u.side_vla_visitor.visitor(&tracer_ctx, app_ctx);
1479 switch (status) {
1480 case SIDE_VISITOR_STATUS_OK:
1481 break;
1482 case SIDE_VISITOR_STATUS_ERROR:
1483 fprintf(stderr, "ERROR: Visitor error\n");
1484 abort();
1485 }
1486 printf(" ]");
1487 }
1488
1489 static
1490 void tracer_print_dynamic_struct(const struct side_arg_dynamic_struct *dynamic_struct)
1491 {
1492 const struct side_arg_dynamic_field *fields = dynamic_struct->fields;
1493 uint32_t i, len = dynamic_struct->len;
1494
1495 print_attributes("attr", "::", dynamic_struct->attr, dynamic_struct->nr_attr);
1496 printf("%s", dynamic_struct->nr_attr ? ", " : "");
1497 printf("fields:: ");
1498 printf("[ ");
1499 for (i = 0; i < len; i++) {
1500 printf("%s", i ? ", " : "");
1501 printf("%s:: ", fields[i].field_name);
1502 tracer_print_dynamic(&fields[i].elem);
1503 }
1504 printf(" ]");
1505 }
1506
1507 struct tracer_dynamic_struct_visitor_priv {
1508 int i;
1509 };
1510
1511 static
1512 enum side_visitor_status tracer_dynamic_struct_write_elem_cb(
1513 const struct side_tracer_dynamic_struct_visitor_ctx *tracer_ctx,
1514 const struct side_arg_dynamic_field *dynamic_field)
1515 {
1516 struct tracer_dynamic_struct_visitor_priv *tracer_priv =
1517 (struct tracer_dynamic_struct_visitor_priv *) tracer_ctx->priv;
1518
1519 printf("%s", tracer_priv->i++ ? ", " : "");
1520 printf("%s:: ", dynamic_field->field_name);
1521 tracer_print_dynamic(&dynamic_field->elem);
1522 return SIDE_VISITOR_STATUS_OK;
1523 }
1524
1525 static
1526 void tracer_print_dynamic_struct_visitor(const struct side_arg *item)
1527 {
1528 enum side_visitor_status status;
1529 struct tracer_dynamic_struct_visitor_priv tracer_priv = {
1530 .i = 0,
1531 };
1532 const struct side_tracer_dynamic_struct_visitor_ctx tracer_ctx = {
1533 .write_field = tracer_dynamic_struct_write_elem_cb,
1534 .priv = &tracer_priv,
1535 };
1536 void *app_ctx = item->u.side_dynamic.side_dynamic_struct_visitor.app_ctx;
1537
1538 print_attributes("attr", "::", item->u.side_dynamic.side_dynamic_struct_visitor.attr, item->u.side_dynamic.side_dynamic_struct_visitor.nr_attr);
1539 printf("%s", item->u.side_dynamic.side_dynamic_struct_visitor.nr_attr ? ", " : "");
1540 printf("fields:: ");
1541 printf("[ ");
1542 status = item->u.side_dynamic.side_dynamic_struct_visitor.visitor(&tracer_ctx, app_ctx);
1543 switch (status) {
1544 case SIDE_VISITOR_STATUS_OK:
1545 break;
1546 case SIDE_VISITOR_STATUS_ERROR:
1547 fprintf(stderr, "ERROR: Visitor error\n");
1548 abort();
1549 }
1550 printf(" ]");
1551 }
1552
1553 static
1554 void tracer_print_dynamic_vla(const struct side_arg_dynamic_vla *vla)
1555 {
1556 const struct side_arg *sav = vla->sav;
1557 uint32_t i, side_sav_len = vla->len;
1558
1559 print_attributes("attr", "::", vla->attr, vla->nr_attr);
1560 printf("%s", vla->nr_attr ? ", " : "");
1561 printf("elements:: ");
1562 printf("[ ");
1563 for (i = 0; i < side_sav_len; i++) {
1564 printf("%s", i ? ", " : "");
1565 tracer_print_dynamic(&sav[i]);
1566 }
1567 printf(" ]");
1568 }
1569
1570 struct tracer_dynamic_vla_visitor_priv {
1571 int i;
1572 };
1573
1574 static
1575 enum side_visitor_status tracer_dynamic_vla_write_elem_cb(
1576 const struct side_tracer_visitor_ctx *tracer_ctx,
1577 const struct side_arg *elem)
1578 {
1579 struct tracer_dynamic_vla_visitor_priv *tracer_priv =
1580 (struct tracer_dynamic_vla_visitor_priv *) tracer_ctx->priv;
1581
1582 printf("%s", tracer_priv->i++ ? ", " : "");
1583 tracer_print_dynamic(elem);
1584 return SIDE_VISITOR_STATUS_OK;
1585 }
1586
1587 static
1588 void tracer_print_dynamic_vla_visitor(const struct side_arg *item)
1589 {
1590 enum side_visitor_status status;
1591 struct tracer_dynamic_vla_visitor_priv tracer_priv = {
1592 .i = 0,
1593 };
1594 const struct side_tracer_visitor_ctx tracer_ctx = {
1595 .write_elem = tracer_dynamic_vla_write_elem_cb,
1596 .priv = &tracer_priv,
1597 };
1598 void *app_ctx = item->u.side_dynamic.side_dynamic_vla_visitor.app_ctx;
1599
1600 print_attributes("attr", "::", item->u.side_dynamic.side_dynamic_vla_visitor.attr, item->u.side_dynamic.side_dynamic_vla_visitor.nr_attr);
1601 printf("%s", item->u.side_dynamic.side_dynamic_vla_visitor.nr_attr ? ", " : "");
1602 printf("elements:: ");
1603 printf("[ ");
1604 status = item->u.side_dynamic.side_dynamic_vla_visitor.visitor(&tracer_ctx, app_ctx);
1605 switch (status) {
1606 case SIDE_VISITOR_STATUS_OK:
1607 break;
1608 case SIDE_VISITOR_STATUS_ERROR:
1609 fprintf(stderr, "ERROR: Visitor error\n");
1610 abort();
1611 }
1612 printf(" ]");
1613 }
1614
1615 static
1616 void tracer_print_dynamic(const struct side_arg *item)
1617 {
1618 printf("{ ");
1619 switch (item->type) {
1620 /* Dynamic basic types */
1621 case SIDE_TYPE_DYNAMIC_NULL:
1622 tracer_print_type_header("::", item->u.side_dynamic.side_null.attr, item->u.side_dynamic.side_null.nr_attr);
1623 printf("<NULL TYPE>");
1624 break;
1625 case SIDE_TYPE_DYNAMIC_BOOL:
1626 tracer_print_type_bool("::", &item->u.side_dynamic.side_bool.type, &item->u.side_dynamic.side_bool.value, 0);
1627 break;
1628 case SIDE_TYPE_DYNAMIC_INTEGER:
1629 tracer_print_type_integer("::", &item->u.side_dynamic.side_integer.type, &item->u.side_dynamic.side_integer.value, 0,
1630 TRACER_DISPLAY_BASE_10);
1631 break;
1632 case SIDE_TYPE_DYNAMIC_BYTE:
1633 tracer_print_type_header("::", item->u.side_dynamic.side_byte.type.attr, item->u.side_dynamic.side_byte.type.nr_attr);
1634 printf("0x%" PRIx8, item->u.side_dynamic.side_byte.value);
1635 break;
1636 case SIDE_TYPE_DYNAMIC_POINTER:
1637 tracer_print_type_integer("::", &item->u.side_dynamic.side_integer.type, &item->u.side_dynamic.side_integer.value, 0,
1638 TRACER_DISPLAY_BASE_16);
1639 break;
1640 case SIDE_TYPE_DYNAMIC_FLOAT:
1641 tracer_print_type_float("::", &item->u.side_dynamic.side_float.type,
1642 &item->u.side_dynamic.side_float.value);
1643 break;
1644 case SIDE_TYPE_DYNAMIC_STRING:
1645 tracer_print_type_header("::", item->u.side_dynamic.side_string.type.attr, item->u.side_dynamic.side_string.type.nr_attr);
1646 tracer_print_string((const char *)(uintptr_t) item->u.side_dynamic.side_string.value,
1647 item->u.side_dynamic.side_string.type.unit_size,
1648 item->u.side_dynamic.side_string.type.byte_order, NULL);
1649 break;
1650
1651 /* Dynamic compound types */
1652 case SIDE_TYPE_DYNAMIC_STRUCT:
1653 tracer_print_dynamic_struct(item->u.side_dynamic.side_dynamic_struct);
1654 break;
1655 case SIDE_TYPE_DYNAMIC_STRUCT_VISITOR:
1656 tracer_print_dynamic_struct_visitor(item);
1657 break;
1658 case SIDE_TYPE_DYNAMIC_VLA:
1659 tracer_print_dynamic_vla(item->u.side_dynamic.side_dynamic_vla);
1660 break;
1661 case SIDE_TYPE_DYNAMIC_VLA_VISITOR:
1662 tracer_print_dynamic_vla_visitor(item);
1663 break;
1664 default:
1665 fprintf(stderr, "<UNKNOWN TYPE>\n");
1666 abort();
1667 }
1668 printf(" }");
1669 }
1670
1671 static
1672 void tracer_print_static_fields(const struct side_event_description *desc,
1673 const struct side_arg_vec *side_arg_vec,
1674 uint32_t *nr_items)
1675 {
1676 const struct side_arg *sav = side_arg_vec->sav;
1677 uint32_t i, side_sav_len = side_arg_vec->len;
1678
1679 printf("provider: %s, event: %s", desc->provider_name, desc->event_name);
1680 if (desc->nr_fields != side_sav_len) {
1681 fprintf(stderr, "ERROR: number of fields mismatch between description and arguments\n");
1682 abort();
1683 }
1684 print_attributes(", attr", ":", desc->attr, desc->nr_attr);
1685 printf("%s", side_sav_len ? ", fields: [ " : "");
1686 for (i = 0; i < side_sav_len; i++) {
1687 printf("%s", i ? ", " : "");
1688 tracer_print_field(&desc->fields[i], &sav[i]);
1689 }
1690 if (nr_items)
1691 *nr_items = i;
1692 if (side_sav_len)
1693 printf(" ]");
1694 }
1695
1696 void tracer_call(const struct side_event_description *desc,
1697 const struct side_arg_vec *side_arg_vec,
1698 void *priv __attribute__((unused)))
1699 {
1700 uint32_t nr_fields = 0;
1701
1702 tracer_print_static_fields(desc, side_arg_vec, &nr_fields);
1703 printf("\n");
1704 }
1705
1706 void tracer_call_variadic(const struct side_event_description *desc,
1707 const struct side_arg_vec *side_arg_vec,
1708 const struct side_arg_dynamic_struct *var_struct,
1709 void *priv __attribute__((unused)))
1710 {
1711 uint32_t nr_fields = 0, i, var_struct_len = var_struct->len;
1712
1713 tracer_print_static_fields(desc, side_arg_vec, &nr_fields);
1714
1715 if (side_unlikely(!(desc->flags & SIDE_EVENT_FLAG_VARIADIC))) {
1716 fprintf(stderr, "ERROR: unexpected non-variadic event description\n");
1717 abort();
1718 }
1719 print_attributes(", attr ", "::", var_struct->attr, var_struct->nr_attr);
1720 printf("%s", var_struct_len ? ", fields:: [ " : "");
1721 for (i = 0; i < var_struct_len; i++, nr_fields++) {
1722 printf("%s", i ? ", " : "");
1723 printf("%s:: ", var_struct->fields[i].field_name);
1724 tracer_print_dynamic(&var_struct->fields[i].elem);
1725 }
1726 if (i)
1727 printf(" ]");
1728 printf("\n");
1729 }
1730
1731 void tracer_event_notification(enum side_tracer_notification notif,
1732 struct side_event_description **events, uint32_t nr_events, void *priv)
1733 {
1734 uint32_t i;
1735 int ret;
1736
1737 printf("----------------------------------------------------------\n");
1738 printf("Tracer notified of events %s\n",
1739 notif == SIDE_TRACER_NOTIFICATION_INSERT_EVENTS ? "inserted" : "removed");
1740 for (i = 0; i < nr_events; i++) {
1741 struct side_event_description *event = events[i];
1742
1743 /* Skip NULL pointers */
1744 if (!event)
1745 continue;
1746 printf("provider: %s, event: %s\n",
1747 event->provider_name, event->event_name);
1748 if (notif == SIDE_TRACER_NOTIFICATION_INSERT_EVENTS) {
1749 if (event->flags & SIDE_EVENT_FLAG_VARIADIC) {
1750 ret = side_tracer_callback_variadic_register(event, tracer_call_variadic, NULL);
1751 if (ret)
1752 abort();
1753 } else {
1754 ret = side_tracer_callback_register(event, tracer_call, NULL);
1755 if (ret)
1756 abort();
1757 }
1758 } else {
1759 if (event->flags & SIDE_EVENT_FLAG_VARIADIC) {
1760 ret = side_tracer_callback_variadic_unregister(event, tracer_call_variadic, NULL);
1761 if (ret)
1762 abort();
1763 } else {
1764 ret = side_tracer_callback_unregister(event, tracer_call, NULL);
1765 if (ret)
1766 abort();
1767 }
1768 }
1769 }
1770 printf("----------------------------------------------------------\n");
1771 }
1772
1773 static __attribute__((constructor))
1774 void tracer_init(void);
1775 static
1776 void tracer_init(void)
1777 {
1778 tracer_handle = side_tracer_event_notification_register(tracer_event_notification, NULL);
1779 if (!tracer_handle)
1780 abort();
1781 }
1782
1783 static __attribute__((destructor))
1784 void tracer_exit(void);
1785 static
1786 void tracer_exit(void)
1787 {
1788 side_tracer_event_notification_unregister(tracer_handle);
1789 }
Software Instrumentation Dynamically Enabled
This page took 0.062853 seconds and 3 git commands to generate.