projects / libside.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Revert "Rename "libside" to "libtgif""
[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 13
67337c4a 14#include <side/trace.h>
f611d0c3 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
67337c4a 28static struct side_tracer_handle *tracer_handle;
1e8aec23 29
f611d0c3 30static
67337c4a 31void tracer_print_struct(const struct side_type *type_desc, const struct side_arg_vec *side_arg_vec);
f611d0c3 32static
67337c4a 33void tracer_print_array(const struct side_type *type_desc, const struct side_arg_vec *side_arg_vec);
f611d0c3 34static
67337c4a 35void tracer_print_vla(const struct side_type *type_desc, const struct side_arg_vec *side_arg_vec);
f611d0c3 36static
67337c4a 37void tracer_print_vla_visitor(const struct side_type *type_desc, void *app_ctx);
ba845af5 38static
67337c4a 39void tracer_print_dynamic(const struct side_arg *dynamic_item);
d8be25de 40static
67337c4a 41uint32_t tracer_print_gather_bool_type(const struct side_type_gather *type_gather, const void *_ptr);
8ad2f385 42static
67337c4a 43uint32_t tracer_print_gather_byte_type(const struct side_type_gather *type_gather, const void *_ptr);
d9359cfa 44static
67337c4a 45uint32_t tracer_print_gather_integer_type(const struct side_type_gather *type_gather, const void *_ptr,
4e1b0e0e 46 enum tracer_display_base default_base);
d9359cfa 47static
67337c4a 48uint32_t tracer_print_gather_float_type(const struct side_type_gather *type_gather, const void *_ptr);
d9359cfa 49static
67337c4a 50uint32_t tracer_print_gather_string_type(const struct side_type_gather *type_gather, const void *_ptr);
7d34edfc 51static
67337c4a 52uint32_t tracer_print_gather_enum_type(const struct side_type_gather *type_gather, const void *_ptr);
0519cb86 53static
67337c4a 54uint32_t tracer_print_gather_struct(const struct side_type_gather *type_gather, const void *_ptr);
d69918cc 55static
67337c4a 56uint32_t tracer_print_gather_array(const struct side_type_gather *type_gather, const void *_ptr);
d9359cfa 57static
67337c4a 58uint32_t tracer_print_gather_vla(const struct side_type_gather *type_gather, const void *_ptr,
80429681 59 const void *_length_ptr);
65b8734a 60static
67337c4a 61void tracer_print_type(const struct side_type *type_desc, const struct side_arg *item);
f611d0c3 62
52990f65 63static
67337c4a 64void tracer_convert_string_to_utf8(const void *p, uint8_t unit_size, enum side_type_label_byte_order byte_order,
9ceac3e2
MD		 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) {
67337c4a 84 case SIDE_TYPE_BYTE_ORDER_LE:
52990f65
MD		 85 {
86 fromcode = "UTF-16LE";
87 break;
88 }
67337c4a 89 case SIDE_TYPE_BYTE_ORDER_BE:
52990f65
MD		 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) {
67337c4a 112 case SIDE_TYPE_BYTE_ORDER_LE:
52990f65
MD		 113 {
114 fromcode = "UTF-32LE";
115 break;
116 }
67337c4a 117 case SIDE_TYPE_BYTE_ORDER_BE:
52990f65
MD		 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
67337c4a 171void tracer_print_string(const void *p, uint8_t unit_size, enum side_type_label_byte_order byte_order,
9ceac3e2
MD		 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 182static
67337c4a 183int64_t get_attr_integer_value(const struct side_attr *attr)
1d9c515c
MD		 184{
185 int64_t val;
186
187 switch (attr->value.type) {
67337c4a
MD		 188 case SIDE_ATTR_TYPE_U8:
189 val = attr->value.u.integer_value.side_u8;
1d9c515c 190 break;
67337c4a
MD		 191 case SIDE_ATTR_TYPE_U16:
192 val = attr->value.u.integer_value.side_u16;
1d9c515c 193 break;
67337c4a
MD		 194 case SIDE_ATTR_TYPE_U32:
195 val = attr->value.u.integer_value.side_u32;
1d9c515c 196 break;
67337c4a
MD		 197 case SIDE_ATTR_TYPE_U64:
198 val = attr->value.u.integer_value.side_u64;
1d9c515c 199 break;
67337c4a
MD		 200 case SIDE_ATTR_TYPE_S8:
201 val = attr->value.u.integer_value.side_s8;
1d9c515c 202 break;
67337c4a
MD		 203 case SIDE_ATTR_TYPE_S16:
204 val = attr->value.u.integer_value.side_s16;
1d9c515c 205 break;
67337c4a
MD		 206 case SIDE_ATTR_TYPE_S32:
207 val = attr->value.u.integer_value.side_s32;
1d9c515c 208 break;
67337c4a
MD		 209 case SIDE_ATTR_TYPE_S64:
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
67337c4a 220enum tracer_display_base get_attr_display_base(const struct side_attr *_attr, uint32_t nr_attr,
f0dafd60 221 enum tracer_display_base default_base)
1d9c515c
MD		 222{
223 uint32_t i;
224
225 for (i = 0; i < nr_attr; i++) {
67337c4a 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
67337c4a 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 266 switch (attr->value.type) {
67337c4a 267 case SIDE_ATTR_TYPE_BOOL:
5f82db91 268 printf("%s", attr->value.u.bool_value ? "true" : "false");
bc3c89b3 269 break;
67337c4a
MD		 270 case SIDE_ATTR_TYPE_U8:
271 printf("%" PRIu8, attr->value.u.integer_value.side_u8);
bc3c89b3 272 break;
67337c4a
MD		 273 case SIDE_ATTR_TYPE_U16:
274 printf("%" PRIu16, attr->value.u.integer_value.side_u16);
bc3c89b3 275 break;
67337c4a
MD		 276 case SIDE_ATTR_TYPE_U32:
277 printf("%" PRIu32, attr->value.u.integer_value.side_u32);
bc3c89b3 278 break;
67337c4a
MD		 279 case SIDE_ATTR_TYPE_U64:
280 printf("%" PRIu64, attr->value.u.integer_value.side_u64);
bc3c89b3 281 break;
67337c4a
MD		 282 case SIDE_ATTR_TYPE_S8:
283 printf("%" PRId8, attr->value.u.integer_value.side_s8);
bc3c89b3 284 break;
67337c4a
MD		 285 case SIDE_ATTR_TYPE_S16:
286 printf("%" PRId16, attr->value.u.integer_value.side_s16);
bc3c89b3 287 break;
67337c4a
MD		 288 case SIDE_ATTR_TYPE_S32:
289 printf("%" PRId32, attr->value.u.integer_value.side_s32);
bc3c89b3 290 break;
67337c4a
MD		 291 case SIDE_ATTR_TYPE_S64:
292 printf("%" PRId64, attr->value.u.integer_value.side_s64);
bc3c89b3 293 break;
67337c4a 294 case SIDE_ATTR_TYPE_FLOAT_BINARY16:
bc3c89b3 295#if __HAVE_FLOAT16
67337c4a 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
67337c4a 302 case SIDE_ATTR_TYPE_FLOAT_BINARY32:
bc3c89b3 303#if __HAVE_FLOAT32
67337c4a 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
67337c4a 310 case SIDE_ATTR_TYPE_FLOAT_BINARY64:
bc3c89b3 311#if __HAVE_FLOAT64
67337c4a 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
67337c4a 318 case SIDE_ATTR_TYPE_FLOAT_BINARY128:
bc3c89b3 319#if __HAVE_FLOAT128
67337c4a 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
67337c4a 326 case SIDE_ATTR_TYPE_STRING:
ab8a626e
MD		 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 339void print_attributes(const char *prefix_str, const char *separator,
67337c4a 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
67337c4a
MD		 355union int64_value tracer_load_integer_value(const struct side_type_integer *type_integer,
356 const union side_integer_value *value,
f6a2a8ed 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();
67337c4a 369 reverse_bo = type_integer->byte_order != SIDE_TYPE_BYTE_ORDER_HOST;
f6a2a8ed
MD		 370 switch (type_integer->integer_size) {
371 case 1:
372 if (type_integer->signedness)
67337c4a 373 v64.s = value->side_s8;
f6a2a8ed 374 else
67337c4a 375 v64.u = value->side_u8;
d8be25de 376 break;
f6a2a8ed
MD		 377 case 2:
378 if (type_integer->signedness) {
67337c4a 379 int16_t side_s16;
8bdd5c12 380
67337c4a 381 side_s16 = value->side_s16;
f6a2a8ed 382 if (reverse_bo)
67337c4a
MD		 383 side_s16 = side_bswap_16(side_s16);
384 v64.s = side_s16;
f6a2a8ed 385 } else {
67337c4a 386 uint16_t side_u16;
8bdd5c12 387
67337c4a 388 side_u16 = value->side_u16;
f6a2a8ed 389 if (reverse_bo)
67337c4a
MD		 390 side_u16 = side_bswap_16(side_u16);
391 v64.u = side_u16;
f6a2a8ed 392 }
d8be25de 393 break;
f6a2a8ed
MD		 394 case 4:
395 if (type_integer->signedness) {
67337c4a 396 int32_t side_s32;
8bdd5c12 397
67337c4a 398 side_s32 = value->side_s32;
f6a2a8ed 399 if (reverse_bo)
67337c4a
MD		 400 side_s32 = side_bswap_32(side_s32);
401 v64.s = side_s32;
f6a2a8ed 402 } else {
67337c4a 403 uint32_t side_u32;
8bdd5c12 404
67337c4a 405 side_u32 = value->side_u32;
f6a2a8ed 406 if (reverse_bo)
67337c4a
MD		 407 side_u32 = side_bswap_32(side_u32);
408 v64.u = side_u32;
f6a2a8ed 409 }
d8be25de 410 break;
f6a2a8ed
MD		 411 case 8:
412 if (type_integer->signedness) {
67337c4a 413 int64_t side_s64;
8bdd5c12 414
67337c4a 415 side_s64 = value->side_s64;
f6a2a8ed 416 if (reverse_bo)
67337c4a
MD		 417 side_s64 = side_bswap_64(side_s64);
418 v64.s = side_s64;
f6a2a8ed 419 } else {
67337c4a 420 uint64_t side_u64;
8bdd5c12 421
67337c4a 422 side_u64 = value->side_u64;
f6a2a8ed 423 if (reverse_bo)
67337c4a
MD		 424 side_u64 = side_bswap_64(side_u64);
425 v64.u = side_u64;
f6a2a8ed 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
67337c4a 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++) {
67337c4a 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 469static
67337c4a 470void tracer_print_enum(const struct side_type *type_desc, const struct side_arg *item)
f6a2a8ed 471{
67337c4a
MD		 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;
f6a2a8ed
MD		 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 }
67337c4a
MD		 480 v64 = tracer_load_integer_value(&elem_type->u.side_integer,
481 &item->u.side_static.integer_value, 0, NULL);
f6a2a8ed
MD		 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
67337c4a 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) {
67337c4a 494 case SIDE_TYPE_BYTE:
af6aa6e1
MD		 495 stride_bit = 8;
496 break;
8625d674 497
67337c4a
MD		 498 case SIDE_TYPE_U8:
499 case SIDE_TYPE_U16:
500 case SIDE_TYPE_U32:
501 case SIDE_TYPE_U64:
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
67337c4a
MD		 515void tracer_print_enum_bitmap(const struct side_type *type_desc,
516 const struct side_arg *item)
af6aa6e1 517{
67337c4a
MD		 518 const struct side_enum_bitmap_mappings *side_enum_mappings = type_desc->u.side_enum_bitmap.mappings;
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;
67337c4a 521 const struct side_arg *array_item;
af6aa6e1 522
7f8e7e97 523 switch (enum_elem_type->type) {
67337c4a
MD		 524 case SIDE_TYPE_U8: /* Fall-through */
525 case SIDE_TYPE_BYTE: /* Fall-through */
526 case SIDE_TYPE_U16: /* Fall-through */
527 case SIDE_TYPE_U32: /* Fall-through */
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;
67337c4a
MD		 537 case SIDE_TYPE_ARRAY:
538 elem_type = enum_elem_type->u.side_array.elem_type;
539 array_item = item->u.side_static.side_array->sav;
540 nr_items = type_desc->u.side_array.length;
af6aa6e1 541 break;
67337c4a
MD		 542 case SIDE_TYPE_VLA:
543 elem_type = enum_elem_type->u.side_vla.elem_type;
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
67337c4a
MD		 553 print_attributes("attr", ":", side_enum_mappings->attr, side_enum_mappings->nr_attr);
554 printf("%s", side_enum_mappings->nr_attr ? ", " : "");
af6aa6e1 555 printf("labels: [ ");
67337c4a
MD		 556 for (i = 0; i < side_enum_mappings->nr_mappings; i++) {
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;
67337c4a
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
67337c4a
MD		 578 v64 = tracer_load_integer_value(&elem_type->u.side_integer,
579 &array_item[bit / stride_bit].u.side_static.integer_value,
7f8e7e97
MD		 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 612void tracer_print_type_header(const char *separator,
67337c4a 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,
67337c4a
MD		 622 const struct side_type_bool *type_bool,
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 635 abort();
67337c4a 636 reverse_bo = type_bool->byte_order != SIDE_TYPE_BYTE_ORDER_HOST;
88bab79c
MD		 637 switch (type_bool->bool_size) {
638 case 1:
67337c4a 639 v = value->side_bool8;
8ad2f385 640 break;
88bab79c 641 case 2:
8ad2f385 642 {
67337c4a 643 uint16_t side_u16;
8ad2f385 644
67337c4a 645 side_u16 = value->side_bool16;
8ad2f385 646 if (reverse_bo)
67337c4a
MD		 647 side_u16 = side_bswap_16(side_u16);
648 v = side_u16;
8ad2f385
MD		 649 break;
650 }
88bab79c 651 case 4:
8ad2f385 652 {
67337c4a 653 uint32_t side_u32;
8ad2f385 654
67337c4a 655 side_u32 = value->side_bool32;
8ad2f385 656 if (reverse_bo)
67337c4a
MD		 657 side_u32 = side_bswap_32(side_u32);
658 v = side_u32;
8ad2f385
MD		 659 break;
660 }
88bab79c 661 case 8:
8ad2f385 662 {
67337c4a 663 uint64_t side_u64;
8ad2f385 664
67337c4a 665 side_u64 = value->side_bool64;
8ad2f385 666 if (reverse_bo)
67337c4a
MD		 667 side_u64 = side_bswap_64(side_u64);
668 v = side_u64;
8ad2f385
MD		 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,
67337c4a
MD		 683 const struct side_type_integer *type_integer,
684 const union side_integer_value *value,
4f5e1b67
MD		 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,
67337c4a
MD		 724 const struct side_type_float *type_float,
725 const union side_float_value *value)
3aa7ca5e
MD		 726{
727 bool reverse_bo;
728
3aa7ca5e 729 tracer_print_type_header(separator, type_float->attr, type_float->nr_attr);
67337c4a 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 = {
67337c4a 739 .f = value->side_float_binary16,
3aa7ca5e
MD		 740 };
741
742 if (reverse_bo)
67337c4a 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 = {
67337c4a 758 .f = value->side_float_binary32,
3aa7ca5e
MD		 759 };
760
761 if (reverse_bo)
67337c4a 762 float32.u = side_bswap_32(float32.u);
3aa7ca5e
MD		 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 = {
67337c4a 777 .f = value->side_float_binary64,
3aa7ca5e
MD		 778 };
779
780 if (reverse_bo)
67337c4a 781 float64.u = side_bswap_64(float64.u);
3aa7ca5e
MD		 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 = {
67337c4a 796 .f = value->side_float_binary128,
3aa7ca5e
MD		 797 };
798
799 if (reverse_bo)
67337c4a 800 side_bswap_128p(float128.arr);
3aa7ca5e
MD		 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
67337c4a 815void tracer_print_type(const struct side_type *type_desc, const struct side_arg *item)
f611d0c3 816{
67337c4a 817 enum side_type_label type;
d8be25de 818
45392033 819 switch (type_desc->type) {
67337c4a 820 case SIDE_TYPE_ENUM:
45392033 821 switch (item->type) {
67337c4a
MD		 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
67337c4a 838 case SIDE_TYPE_ENUM_BITMAP:
45392033 839 switch (item->type) {
67337c4a
MD		 840 case SIDE_TYPE_U8:
841 case SIDE_TYPE_BYTE:
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:
45392033
MD		 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
67337c4a 855 case SIDE_TYPE_GATHER_ENUM:
0519cb86 856 switch (item->type) {
67337c4a 857 case SIDE_TYPE_GATHER_INTEGER:
0519cb86
MD		 858 break;
859 default:
860 fprintf(stderr, "ERROR: type mismatch between description and arguments\n");
861 abort();
862 break;
863 }
864 break;
865
67337c4a 866 case SIDE_TYPE_DYNAMIC:
66de373e 867 switch (item->type) {
67337c4a
MD		 868 case SIDE_TYPE_DYNAMIC_NULL:
869 case SIDE_TYPE_DYNAMIC_BOOL:
870 case SIDE_TYPE_DYNAMIC_INTEGER:
871 case SIDE_TYPE_DYNAMIC_BYTE:
872 case SIDE_TYPE_DYNAMIC_POINTER:
873 case SIDE_TYPE_DYNAMIC_FLOAT:
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:
66de373e
MD		 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
67337c4a
MD		 895 if (type_desc->type == SIDE_TYPE_ENUM || type_desc->type == SIDE_TYPE_ENUM_BITMAP ||
896 type_desc->type == SIDE_TYPE_GATHER_ENUM)
897 type = (enum side_type_label) type_desc->type;
d8be25de 898 else
67337c4a 899 type = (enum side_type_label) item->type;
d8be25de 900
a848763d 901 printf("{ ");
d8be25de 902 switch (type) {
55fb50b7 903 /* Stack-copy basic types */
67337c4a
MD		 904 case SIDE_TYPE_NULL:
905 tracer_print_type_header(":", type_desc->u.side_null.attr, type_desc->u.side_null.nr_attr);
9b641221
MD		 906 printf("<NULL TYPE>");
907 break;
908
67337c4a
MD		 909 case SIDE_TYPE_BOOL:
910 tracer_print_type_bool(":", &type_desc->u.side_bool, &item->u.side_static.bool_value, 0);
4f40d951 911 break;
1d9c515c 912
67337c4a
MD		 913 case SIDE_TYPE_U8:
914 case SIDE_TYPE_U16:
915 case SIDE_TYPE_U32:
916 case SIDE_TYPE_U64:
917 case SIDE_TYPE_S8:
918 case SIDE_TYPE_S16:
919 case SIDE_TYPE_S32:
920 case SIDE_TYPE_S64:
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
67337c4a
MD		 925 case SIDE_TYPE_BYTE:
926 tracer_print_type_header(":", type_desc->u.side_byte.attr, type_desc->u.side_byte.nr_attr);
927 printf("0x%" PRIx8, item->u.side_static.byte_value);
7aec0d09 928 break;
79f677ba 929
67337c4a
MD		 930 case SIDE_TYPE_POINTER:
931 tracer_print_type_integer(":", &type_desc->u.side_integer, &item->u.side_static.integer_value, 0,
55fb50b7 932 TRACER_DISPLAY_BASE_16);
ea32e5fc
MD		 933 break;
934
67337c4a
MD		 935 case SIDE_TYPE_FLOAT_BINARY16:
936 case SIDE_TYPE_FLOAT_BINARY32:
937 case SIDE_TYPE_FLOAT_BINARY64:
938 case SIDE_TYPE_FLOAT_BINARY128:
939 tracer_print_type_float(":", &type_desc->u.side_float, &item->u.side_static.float_value);
fb25b355 940 break;
3aa7ca5e 941
67337c4a
MD		 942 case SIDE_TYPE_STRING_UTF8:
943 case SIDE_TYPE_STRING_UTF16:
944 case SIDE_TYPE_STRING_UTF32:
945 tracer_print_type_header(":", type_desc->u.side_string.attr, type_desc->u.side_string.nr_attr);
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 */
67337c4a
MD		 951 case SIDE_TYPE_STRUCT:
952 tracer_print_struct(type_desc, item->u.side_static.side_struct);
f611d0c3 953 break;
67337c4a
MD		 954 case SIDE_TYPE_ARRAY:
955 tracer_print_array(type_desc, item->u.side_static.side_array);
d9359cfa 956 break;
67337c4a
MD		 957 case SIDE_TYPE_VLA:
958 tracer_print_vla(type_desc, item->u.side_static.side_vla);
33956c71 959 break;
67337c4a
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 */
67337c4a 965 case SIDE_TYPE_ENUM:
f6a2a8ed 966 tracer_print_enum(type_desc, item);
55fb50b7 967 break;
67337c4a 968 case SIDE_TYPE_ENUM_BITMAP:
7f8e7e97 969 tracer_print_enum_bitmap(type_desc, item);
55fb50b7
MD		 970 break;
971
972 /* Gather basic types */
67337c4a
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);
8ad2f385 975 break;
67337c4a
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,
55fb50b7
MD		 978 TRACER_DISPLAY_BASE_10);
979 break;
67337c4a
MD		 980 case SIDE_TYPE_GATHER_BYTE:
981 (void) tracer_print_gather_byte_type(&type_desc->u.side_gather, item->u.side_static.side_byte_gather_ptr);
d69918cc 982 break;
67337c4a
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,
4e1b0e0e
MD		 985 TRACER_DISPLAY_BASE_16);
986 break;
67337c4a
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;
67337c4a
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);
7d34edfc 992 break;
55fb50b7
MD		 993
994 /* Gather compound type */
67337c4a
MD		 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;
67337c4a
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;
67337c4a
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 1006 /* Gather enumeration types */
67337c4a
MD		 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);
0519cb86
MD		 1009 break;
1010
55fb50b7 1011 /* Dynamic basic types */
67337c4a
MD		 1012 case SIDE_TYPE_DYNAMIC_NULL:
1013 case SIDE_TYPE_DYNAMIC_BOOL:
1014 case SIDE_TYPE_DYNAMIC_INTEGER:
1015 case SIDE_TYPE_DYNAMIC_BYTE:
1016 case SIDE_TYPE_DYNAMIC_POINTER:
1017 case SIDE_TYPE_DYNAMIC_FLOAT:
1018 case SIDE_TYPE_DYNAMIC_STRING:
55fb50b7
MD		 1019
1020 /* Dynamic compound types */
67337c4a
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:
66de373e 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
67337c4a 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);
67337c4a 1038 tracer_print_type(&item_desc->side_type, item);
f611d0c3
MD		 1039}
1040
1041static
67337c4a 1042void tracer_print_struct(const struct side_type *type_desc, const struct side_arg_vec *side_arg_vec)
f611d0c3 1043{
67337c4a
MD		 1044 const struct side_arg *sav = side_arg_vec->sav;
1045 uint32_t i, side_sav_len = side_arg_vec->len;
f611d0c3 1046
67337c4a 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 }
67337c4a
MD		 1051 print_attributes("attr", ":", type_desc->u.side_struct->attr, type_desc->u.side_struct->nr_attr);
1052 printf("%s", type_desc->u.side_struct->nr_attr ? ", " : "");
73b2b0c2 1053 printf("fields: { ");
67337c4a 1054 for (i = 0; i < side_sav_len; i++) {
f611d0c3 1055 printf("%s", i ? ", " : "");
67337c4a 1056 tracer_print_field(&type_desc->u.side_struct->fields[i], &sav[i]);
f611d0c3 1057 }
d4328528 1058 printf(" }");
f611d0c3
MD		 1059}
1060
7a1cb105 1061static
67337c4a 1062void tracer_print_array(const struct side_type *type_desc, const struct side_arg_vec *side_arg_vec)
d9359cfa 1063{
67337c4a
MD		 1064 const struct side_arg *sav = side_arg_vec->sav;
1065 uint32_t i, side_sav_len = side_arg_vec->len;
d9359cfa 1066
67337c4a 1067 if (type_desc->u.side_array.length != side_sav_len) {
d9359cfa
MD		 1068 fprintf(stderr, "ERROR: length mismatch between description and arguments of array\n");
1069 abort();
1070 }
67337c4a
MD		 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 ? ", " : "");
d9359cfa
MD		 1073 printf("elements: ");
1074 printf("[ ");
67337c4a 1075 for (i = 0; i < side_sav_len; i++) {
d9359cfa 1076 printf("%s", i ? ", " : "");
67337c4a 1077 tracer_print_type(type_desc->u.side_array.elem_type, &sav[i]);
d9359cfa
MD		 1078 }
1079 printf(" ]");
1080}
1081
1082static
67337c4a 1083void tracer_print_vla(const struct side_type *type_desc, const struct side_arg_vec *side_arg_vec)
d9359cfa 1084{
67337c4a
MD		 1085 const struct side_arg *sav = side_arg_vec->sav;
1086 uint32_t i, side_sav_len = side_arg_vec->len;
d9359cfa 1087
67337c4a
MD		 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 ? ", " : "");
d9359cfa
MD		 1090 printf("elements: ");
1091 printf("[ ");
67337c4a 1092 for (i = 0; i < side_sav_len; i++) {
d9359cfa 1093 printf("%s", i ? ", " : "");
67337c4a 1094 tracer_print_type(type_desc->u.side_vla.elem_type, &sav[i]);
d9359cfa
MD		 1095 }
1096 printf(" ]");
1097}
1098
dd7947bf 1099static
67337c4a 1100const char *tracer_gather_access(enum side_type_gather_access_mode access_mode, const char *ptr)
dd7947bf 1101{
65b8734a 1102 switch (access_mode) {
67337c4a 1103 case SIDE_TYPE_GATHER_ACCESS_DIRECT:
dd7947bf 1104 return ptr;
67337c4a 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
67337c4a 1115uint32_t tracer_gather_size(enum side_type_gather_access_mode access_mode, uint32_t len)
dd7947bf 1116{
65b8734a 1117 switch (access_mode) {
67337c4a 1118 case SIDE_TYPE_GATHER_ACCESS_DIRECT:
dd7947bf 1119 return len;
67337c4a 1120 case SIDE_TYPE_GATHER_ACCESS_POINTER:
dd7947bf
MD		 1121 return sizeof(void *);
1122 default:
1123 abort();
1124 }
1125}
1126
d9359cfa 1127static
67337c4a 1128union int64_value tracer_load_gather_integer_value(const struct side_type_gather_integer *side_integer,
0519cb86 1129 const void *_ptr)
7a1cb105 1130{
67337c4a
MD		 1131 enum side_type_gather_access_mode access_mode =
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;
67337c4a 1135 union side_integer_value value;
65b8734a 1136
67337c4a 1137 ptr = tracer_gather_access(access_mode, ptr + side_integer->offset);
65b8734a 1138 memcpy(&value, ptr, integer_size_bytes);
67337c4a
MD		 1139 return tracer_load_integer_value(&side_integer->type, &value,
1140 side_integer->offset_bits, NULL);
65b8734a
MD		 1141}
1142
8ad2f385 1143static
67337c4a 1144uint32_t tracer_print_gather_bool_type(const struct side_type_gather *type_gather, const void *_ptr)
8ad2f385 1145{
67337c4a
MD		 1146 enum side_type_gather_access_mode access_mode =
1147 (enum side_type_gather_access_mode) type_gather->u.side_bool.access_mode;
1148 uint32_t bool_size_bytes = type_gather->u.side_bool.type.bool_size;
8ad2f385 1149 const char *ptr = (const char *) _ptr;
67337c4a 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 }
67337c4a 1161 ptr = tracer_gather_access(access_mode, ptr + type_gather->u.side_bool.offset);
8ad2f385 1162 memcpy(&value, ptr, bool_size_bytes);
67337c4a
MD		 1163 tracer_print_type_bool(":", &type_gather->u.side_bool.type, &value,
1164 type_gather->u.side_bool.offset_bits);
8ad2f385
MD		 1165 return tracer_gather_size(access_mode, bool_size_bytes);
1166}
1167
d69918cc 1168static
67337c4a 1169uint32_t tracer_print_gather_byte_type(const struct side_type_gather *type_gather, const void *_ptr)
d69918cc 1170{
67337c4a
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
67337c4a 1176 ptr = tracer_gather_access(access_mode, ptr + type_gather->u.side_byte.offset);
d69918cc 1177 memcpy(&value, ptr, 1);
67337c4a
MD		 1178 tracer_print_type_header(":", type_gather->u.side_byte.type.attr,
1179 type_gather->u.side_byte.type.nr_attr);
d69918cc
MD		 1180 printf("0x%" PRIx8, value);
1181 return tracer_gather_size(access_mode, 1);
1182}
1183
65b8734a 1184static
67337c4a 1185uint32_t tracer_print_gather_integer_type(const struct side_type_gather *type_gather, const void *_ptr,
4e1b0e0e 1186 enum tracer_display_base default_base)
65b8734a 1187{
67337c4a
MD		 1188 enum side_type_gather_access_mode access_mode =
1189 (enum side_type_gather_access_mode) type_gather->u.side_integer.access_mode;
1190 uint32_t integer_size_bytes = type_gather->u.side_integer.type.integer_size;
65b8734a 1191 const char *ptr = (const char *) _ptr;
67337c4a 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 }
67337c4a 1203 ptr = tracer_gather_access(access_mode, ptr + type_gather->u.side_integer.offset);
dd7947bf 1204 memcpy(&value, ptr, integer_size_bytes);
67337c4a
MD		 1205 tracer_print_type_integer(":", &type_gather->u.side_integer.type, &value,
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
67337c4a 1211uint32_t tracer_print_gather_float_type(const struct side_type_gather *type_gather, const void *_ptr)
905f68e3 1212{
67337c4a
MD		 1213 enum side_type_gather_access_mode access_mode =
1214 (enum side_type_gather_access_mode) type_gather->u.side_float.access_mode;
1215 uint32_t float_size_bytes = type_gather->u.side_float.type.float_size;
905f68e3 1216 const char *ptr = (const char *) _ptr;
67337c4a 1217 union side_float_value value;
905f68e3 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 }
67337c4a 1228 ptr = tracer_gather_access(access_mode, ptr + type_gather->u.side_float.offset);
dd7947bf 1229 memcpy(&value, ptr, float_size_bytes);
67337c4a 1230 tracer_print_type_float(":", &type_gather->u.side_float.type, &value);
d41cb7ee 1231 return tracer_gather_size(access_mode, float_size_bytes);
905f68e3
MD		 1232}
1233
7d34edfc 1234static
67337c4a 1235uint32_t tracer_print_gather_string_type(const struct side_type_gather *type_gather, const void *_ptr)
7d34edfc 1236{
67337c4a
MD		 1237 enum side_type_gather_access_mode access_mode =
1238 (enum side_type_gather_access_mode) type_gather->u.side_string.access_mode;
7d34edfc
MD		 1239 const char *ptr = (const char *) _ptr;
1240 size_t string_len;
1241
67337c4a
MD		 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);
7d34edfc 1245 if (ptr) {
67337c4a
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>");
67337c4a 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
67337c4a 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 */
67337c4a
MD		 1263 case SIDE_TYPE_GATHER_BOOL:
1264 len = tracer_print_gather_bool_type(&type_desc->u.side_gather, ptr);
8ad2f385 1265 break;
67337c4a
MD		 1266 case SIDE_TYPE_GATHER_INTEGER:
1267 len = tracer_print_gather_integer_type(&type_desc->u.side_gather, ptr,
55fb50b7
MD		 1268 TRACER_DISPLAY_BASE_10);
1269 break;
67337c4a
MD		 1270 case SIDE_TYPE_GATHER_BYTE:
1271 len = tracer_print_gather_byte_type(&type_desc->u.side_gather, ptr);
d69918cc 1272 break;
67337c4a
MD		 1273 case SIDE_TYPE_GATHER_POINTER:
1274 len = tracer_print_gather_integer_type(&type_desc->u.side_gather, ptr,
4e1b0e0e
MD		 1275 TRACER_DISPLAY_BASE_16);
1276 break;
67337c4a
MD		 1277 case SIDE_TYPE_GATHER_FLOAT:
1278 len = tracer_print_gather_float_type(&type_desc->u.side_gather, ptr);
33956c71 1279 break;
67337c4a
MD		 1280 case SIDE_TYPE_GATHER_STRING:
1281 len = tracer_print_gather_string_type(&type_desc->u.side_gather, ptr);
7d34edfc 1282 break;
55fb50b7 1283
0519cb86 1284 /* Gather enum types */
67337c4a
MD		 1285 case SIDE_TYPE_GATHER_ENUM:
1286 len = tracer_print_gather_enum_type(&type_desc->u.side_gather, ptr);
0519cb86
MD		 1287 break;
1288
55fb50b7 1289 /* Gather compound types */
67337c4a
MD		 1290 case SIDE_TYPE_GATHER_STRUCT:
1291 len = tracer_print_gather_struct(&type_desc->u.side_gather, ptr);
d9359cfa 1292 break;
67337c4a
MD		 1293 case SIDE_TYPE_GATHER_ARRAY:
1294 len = tracer_print_gather_array(&type_desc->u.side_gather, ptr);
9b641221 1295 break;
67337c4a
MD		 1296 case SIDE_TYPE_GATHER_VLA:
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 1307static
67337c4a 1308uint32_t tracer_print_gather_enum_type(const struct side_type_gather *type_gather, const void *_ptr)
0519cb86 1309{
67337c4a
MD		 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;
0519cb86 1316 const char *ptr = (const char *) _ptr;
67337c4a 1317 union side_integer_value value;
0519cb86
MD		 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 }
67337c4a 1329 ptr = tracer_gather_access(access_mode, ptr + side_integer->offset);
0519cb86 1330 memcpy(&value, ptr, integer_size_bytes);
67337c4a 1331 v64 = tracer_load_gather_integer_value(side_integer, &value);
0519cb86
MD		 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
67337c4a 1340void tracer_print_gather_field(const struct side_event_field *field, const void *ptr)
7a1cb105 1341{
33956c71 1342 printf("%s: ", field->field_name);
67337c4a 1343 (void) tracer_print_gather_type(&field->side_type, ptr);
7a1cb105
MD		 1344}
1345
1346static
67337c4a 1347uint32_t tracer_print_gather_struct(const struct side_type_gather *type_gather, const void *_ptr)
7a1cb105 1348{
67337c4a
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
67337c4a
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: { ");
67337c4a 1358 for (i = 0; i < type_gather->u.side_struct.type->nr_fields; i++) {
7a1cb105 1359 printf("%s", i ? ", " : "");
67337c4a 1360 tracer_print_gather_field(&type_gather->u.side_struct.type->fields[i], ptr);
7a1cb105
MD		 1361 }
1362 printf(" }");
67337c4a 1363 return tracer_gather_size(access_mode, type_gather->u.side_struct.size);
7a1cb105
MD		 1364}
1365
f611d0c3 1366static
67337c4a 1367uint32_t tracer_print_gather_array(const struct side_type_gather *type_gather, const void *_ptr)
f611d0c3 1368{
67337c4a
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
67337c4a 1374 ptr = tracer_gather_access(access_mode, ptr + type_gather->u.side_array.offset);
65b8734a 1375 orig_ptr = ptr;
67337c4a
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("[ ");
67337c4a
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:
d41cb7ee 1383 fprintf(stderr, "<gather VLA only supported within gather structures>\n");
65b8734a
MD		 1384 abort();
1385 default:
1386 break;
1387 }
1388 printf("%s", i ? ", " : "");
67337c4a 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
67337c4a 1396uint32_t tracer_print_gather_vla(const struct side_type_gather *type_gather, const void *_ptr,
80429681 1397 const void *_length_ptr)
65b8734a 1398{
67337c4a
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 */
67337c4a
MD		 1407 switch (type_gather->u.side_vla.length_type->type) {
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 }
67337c4a 1414 v64 = tracer_load_gather_integer_value(&type_gather->u.side_vla.length_type->u.side_gather.u.side_integer,
0519cb86 1415 length_ptr);
4f5e1b67 1416 length = (uint32_t) v64.u;
67337c4a 1417 ptr = tracer_gather_access(access_mode, ptr + type_gather->u.side_vla.offset);
dd7947bf 1418 orig_ptr = ptr;
67337c4a
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++) {
67337c4a
MD		 1424 switch (type_gather->u.side_vla.type.elem_type->type) {
1425 case SIDE_TYPE_GATHER_VLA:
d41cb7ee 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 ? ", " : "");
67337c4a 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 {
67337c4a 1439 const struct side_type *elem_type;
352a4b77
MD		 1440 int i;
1441};
1442
1443static
67337c4a
MD		 1444enum side_visitor_status tracer_write_elem_cb(const struct side_tracer_visitor_ctx *tracer_ctx,
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);
67337c4a 1451 return SIDE_VISITOR_STATUS_OK;
352a4b77
MD		 1452}
1453
f611d0c3 1454static
67337c4a 1455void tracer_print_vla_visitor(const struct side_type *type_desc, void *app_ctx)
f611d0c3 1456{
67337c4a 1457 enum side_visitor_status status;
352a4b77 1458 struct tracer_visitor_priv tracer_priv = {
67337c4a 1459 .elem_type = type_desc->u.side_vla_visitor.elem_type,
352a4b77
MD		 1460 .i = 0,
1461 };
67337c4a 1462 const struct side_tracer_visitor_ctx tracer_ctx = {
352a4b77
MD		 1463 .write_elem = tracer_write_elem_cb,
1464 .priv = &tracer_priv,
1465 };
f611d0c3 1466
67337c4a
MD		 1467 print_attributes("attr", ":", type_desc->u.side_vla_visitor.attr, type_desc->u.side_vla_visitor.nr_attr);
1468 printf("%s", type_desc->u.side_vla_visitor.nr_attr ? ", " : "");
20574104 1469 printf("elements: ");
352a4b77 1470 printf("[ ");
67337c4a 1471 status = type_desc->u.side_vla_visitor.visitor(&tracer_ctx, app_ctx);
352a4b77 1472 switch (status) {
67337c4a 1473 case SIDE_VISITOR_STATUS_OK:
352a4b77 1474 break;
67337c4a 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
67337c4a 1483void tracer_print_dynamic_struct(const struct side_arg_dynamic_struct *dynamic_struct)
a2e2357e 1484{
67337c4a 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
67337c4a
MD		 1505enum side_visitor_status tracer_dynamic_struct_write_elem_cb(
1506 const struct side_tracer_dynamic_struct_visitor_ctx *tracer_ctx,
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);
67337c4a 1515 return SIDE_VISITOR_STATUS_OK;
2b359235
MD		 1516}
1517
a2e2357e 1518static
67337c4a 1519void tracer_print_dynamic_struct_visitor(const struct side_arg *item)
a2e2357e 1520{
67337c4a 1521 enum side_visitor_status status;
2b359235
MD		 1522 struct tracer_dynamic_struct_visitor_priv tracer_priv = {
1523 .i = 0,
1524 };
67337c4a 1525 const struct side_tracer_dynamic_struct_visitor_ctx tracer_ctx = {
2b359235
MD		 1526 .write_field = tracer_dynamic_struct_write_elem_cb,
1527 .priv = &tracer_priv,
1528 };
67337c4a 1529 void *app_ctx = item->u.side_dynamic.side_dynamic_struct_visitor.app_ctx;
2b359235 1530
67337c4a
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("[ ");
67337c4a 1535 status = item->u.side_dynamic.side_dynamic_struct_visitor.visitor(&tracer_ctx, app_ctx);
2b359235 1536 switch (status) {
67337c4a 1537 case SIDE_VISITOR_STATUS_OK:
2b359235 1538 break;
67337c4a 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
67337c4a 1547void tracer_print_dynamic_vla(const struct side_arg_dynamic_vla *vla)
a2e2357e 1548{
67337c4a
MD		 1549 const struct side_arg *sav = vla->sav;
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 1555 printf("[ ");
67337c4a 1556 for (i = 0; i < side_sav_len; i++) {
a2e2357e
MD		 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
67337c4a
MD		 1568enum side_visitor_status tracer_dynamic_vla_write_elem_cb(
1569 const struct side_tracer_visitor_ctx *tracer_ctx,
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);
67337c4a 1577 return SIDE_VISITOR_STATUS_OK;
8ceca0cd
MD		 1578}
1579
a2e2357e 1580static
67337c4a 1581void tracer_print_dynamic_vla_visitor(const struct side_arg *item)
a2e2357e 1582{
67337c4a 1583 enum side_visitor_status status;
8ceca0cd
MD		 1584 struct tracer_dynamic_vla_visitor_priv tracer_priv = {
1585 .i = 0,
1586 };
67337c4a 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 };
67337c4a 1591 void *app_ctx = item->u.side_dynamic.side_dynamic_vla_visitor.app_ctx;
8ceca0cd 1592
67337c4a
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("[ ");
67337c4a 1597 status = item->u.side_dynamic.side_dynamic_vla_visitor.visitor(&tracer_ctx, app_ctx);
8ceca0cd 1598 switch (status) {
67337c4a 1599 case SIDE_VISITOR_STATUS_OK:
8ceca0cd 1600 break;
67337c4a 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
67337c4a 1609void tracer_print_dynamic(const struct side_arg *item)
a2e2357e 1610{
808bd9bf 1611 printf("{ ");
66de373e 1612 switch (item->type) {
55fb50b7 1613 /* Dynamic basic types */
67337c4a
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;
67337c4a
MD		 1618 case SIDE_TYPE_DYNAMIC_BOOL:
1619 tracer_print_type_bool("::", &item->u.side_dynamic.side_bool.type, &item->u.side_dynamic.side_bool.value, 0);
66de373e 1620 break;
67337c4a
MD		 1621 case SIDE_TYPE_DYNAMIC_INTEGER:
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;
67337c4a
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;
67337c4a
MD		 1629 case SIDE_TYPE_DYNAMIC_POINTER:
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;
67337c4a
MD		 1633 case SIDE_TYPE_DYNAMIC_FLOAT:
1634 tracer_print_type_float("::", &item->u.side_dynamic.side_float.type,
1635 &item->u.side_dynamic.side_float.value);
fb25b355 1636 break;
67337c4a
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);
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 */
67337c4a
MD		 1645 case SIDE_TYPE_DYNAMIC_STRUCT:
1646 tracer_print_dynamic_struct(item->u.side_dynamic.side_dynamic_struct);
a2e2357e 1647 break;
67337c4a 1648 case SIDE_TYPE_DYNAMIC_STRUCT_VISITOR:
c208889e 1649 tracer_print_dynamic_struct_visitor(item);
a2e2357e 1650 break;
67337c4a
MD		 1651 case SIDE_TYPE_DYNAMIC_VLA:
1652 tracer_print_dynamic_vla(item->u.side_dynamic.side_dynamic_vla);
a2e2357e 1653 break;
67337c4a 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 1664static
67337c4a
MD		 1665void tracer_print_static_fields(const struct side_event_description *desc,
1666 const struct side_arg_vec *side_arg_vec,
e65f9ce5 1667 uint32_t *nr_items)
f611d0c3 1668{
67337c4a
MD		 1669 const struct side_arg *sav = side_arg_vec->sav;
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);
67337c4a 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);
67337c4a
MD		 1678 printf("%s", side_sav_len ? ", fields: [ " : "");
1679 for (i = 0; i < side_sav_len; i++) {
f611d0c3
MD		 1680 printf("%s", i ? ", " : "");
1681 tracer_print_field(&desc->fields[i], &sav[i]);
1682 }
68f8cfbe
MD		 1683 if (nr_items)
1684 *nr_items = i;
67337c4a 1685 if (side_sav_len)
c7d338e2 1686 printf(" ]");
68f8cfbe
MD		 1687}
1688
9365e936 1689static
67337c4a
MD		 1690void tracer_call(const struct side_event_description *desc,
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
67337c4a 1696 tracer_print_static_fields(desc, side_arg_vec, &nr_fields);
f611d0c3
MD		 1697 printf("\n");
1698}
19fa6aa2 1699
9365e936 1700static
67337c4a
MD		 1701void tracer_call_variadic(const struct side_event_description *desc,
1702 const struct side_arg_vec *side_arg_vec,
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
67337c4a 1708 tracer_print_static_fields(desc, side_arg_vec, &nr_fields);
68f8cfbe 1709
67337c4a 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
67337c4a
MD		 1727void tracer_event_notification(enum side_tracer_notification notif,
1728 struct side_event_description **events, uint32_t nr_events,
9365e936 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",
67337c4a 1736 notif == SIDE_TRACER_NOTIFICATION_INSERT_EVENTS ? "inserted" : "removed");
1e8aec23 1737 for (i = 0; i < nr_events; i++) {
67337c4a 1738 struct side_event_description *event = events[i];
1e8aec23
MD		 1739
1740 /* Skip NULL pointers */
1741 if (!event)
1742 continue;
1743 printf("provider: %s, event: %s\n",
1744 event->provider_name, event->event_name);
67337c4a
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);
314c22c3
MD		 1748 if (ret)
1749 abort();
1750 } else {
67337c4a 1751 ret = side_tracer_callback_register(event, tracer_call, NULL);
314c22c3
MD		 1752 if (ret)
1753 abort();
1754 }
1755 } else {
67337c4a
MD		 1756 if (event->flags & SIDE_EVENT_FLAG_VARIADIC) {
1757 ret = side_tracer_callback_variadic_unregister(event, tracer_call_variadic, NULL);
314c22c3
MD		 1758 if (ret)
1759 abort();
1760 } else {
67337c4a 1761 ret = side_tracer_callback_unregister(event, tracer_call, NULL);
314c22c3
MD		 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{
67337c4a 1775 tracer_handle = side_tracer_event_notification_register(tracer_event_notification, NULL);
1e8aec23
MD		 1776 if (!tracer_handle)
1777 abort();
1778}
1779
1780static __attribute__((destructor))
1781void tracer_exit(void);
1782static
1783void tracer_exit(void)
1784{
67337c4a 1785 side_tracer_event_notification_unregister(tracer_handle);
1e8aec23 1786}
Software Instrumentation Dynamically Enabled
This page took 0.128625 seconds and 4 git commands to generate.