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