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