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