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