src/tracer.c

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