Implement std.integer.base (display base 2, 8, 10, 16)

Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>

diff --git a/src/test.c b/src/test.c
index eaf42c3a2f4caa64815b217f2ed0f0aeeb1f6f1c..582203993b32233a45595ada6163b36d7d80e2ac 100644 (file)
--- a/src/test.c
+++ b/src/test.c
@@ -1404,6 +1404,85 @@ void test_endian(void)
        );
 }
 
+side_static_event(my_provider_event_base, "myprovider", "myevent_base", SIDE_LOGLEVEL_DEBUG,
+       side_field_list(
+               side_field_u8("u8base2", side_attr_list(side_attr("std.integer.base", side_attr_u8(2)))),
+               side_field_u8("u8base8", side_attr_list(side_attr("std.integer.base", side_attr_u8(8)))),
+               side_field_u8("u8base10", side_attr_list(side_attr("std.integer.base", side_attr_u8(10)))),
+               side_field_u8("u8base16", side_attr_list(side_attr("std.integer.base", side_attr_u8(16)))),
+               side_field_u16("u16base2", side_attr_list(side_attr("std.integer.base", side_attr_u8(2)))),
+               side_field_u16("u16base8", side_attr_list(side_attr("std.integer.base", side_attr_u8(8)))),
+               side_field_u16("u16base10", side_attr_list(side_attr("std.integer.base", side_attr_u8(10)))),
+               side_field_u16("u16base16", side_attr_list(side_attr("std.integer.base", side_attr_u8(16)))),
+               side_field_u32("u32base2", side_attr_list(side_attr("std.integer.base", side_attr_u8(2)))),
+               side_field_u32("u32base8", side_attr_list(side_attr("std.integer.base", side_attr_u8(8)))),
+               side_field_u32("u32base10", side_attr_list(side_attr("std.integer.base", side_attr_u8(10)))),
+               side_field_u32("u32base16", side_attr_list(side_attr("std.integer.base", side_attr_u8(16)))),
+               side_field_u64("u64base2", side_attr_list(side_attr("std.integer.base", side_attr_u8(2)))),
+               side_field_u64("u64base8", side_attr_list(side_attr("std.integer.base", side_attr_u8(8)))),
+               side_field_u64("u64base10", side_attr_list(side_attr("std.integer.base", side_attr_u8(10)))),
+               side_field_u64("u64base16", side_attr_list(side_attr("std.integer.base", side_attr_u8(16)))),
+               side_field_s8("s8base2", side_attr_list(side_attr("std.integer.base", side_attr_u8(2)))),
+               side_field_s8("s8base8", side_attr_list(side_attr("std.integer.base", side_attr_u8(8)))),
+               side_field_s8("s8base10", side_attr_list(side_attr("std.integer.base", side_attr_u8(10)))),
+               side_field_s8("s8base16", side_attr_list(side_attr("std.integer.base", side_attr_u8(16)))),
+               side_field_s16("s16base2", side_attr_list(side_attr("std.integer.base", side_attr_u8(2)))),
+               side_field_s16("s16base8", side_attr_list(side_attr("std.integer.base", side_attr_u8(8)))),
+               side_field_s16("s16base10", side_attr_list(side_attr("std.integer.base", side_attr_u8(10)))),
+               side_field_s16("s16base16", side_attr_list(side_attr("std.integer.base", side_attr_u8(16)))),
+               side_field_s32("s32base2", side_attr_list(side_attr("std.integer.base", side_attr_u8(2)))),
+               side_field_s32("s32base8", side_attr_list(side_attr("std.integer.base", side_attr_u8(8)))),
+               side_field_s32("s32base10", side_attr_list(side_attr("std.integer.base", side_attr_u8(10)))),
+               side_field_s32("s32base16", side_attr_list(side_attr("std.integer.base", side_attr_u8(16)))),
+               side_field_s64("s64base2", side_attr_list(side_attr("std.integer.base", side_attr_u8(2)))),
+               side_field_s64("s64base8", side_attr_list(side_attr("std.integer.base", side_attr_u8(8)))),
+               side_field_s64("s64base10", side_attr_list(side_attr("std.integer.base", side_attr_u8(10)))),
+               side_field_s64("s64base16", side_attr_list(side_attr("std.integer.base", side_attr_u8(16)))),
+       ),
+       side_attr_list()
+);
+
+static
+void test_base(void)
+{
+       side_event(my_provider_event_base,
+               side_arg_list(
+                       side_arg_u8(55),
+                       side_arg_u8(55),
+                       side_arg_u8(55),
+                       side_arg_u8(55),
+                       side_arg_u16(55),
+                       side_arg_u16(55),
+                       side_arg_u16(55),
+                       side_arg_u16(55),
+                       side_arg_u32(55),
+                       side_arg_u32(55),
+                       side_arg_u32(55),
+                       side_arg_u32(55),
+                       side_arg_u64(55),
+                       side_arg_u64(55),
+                       side_arg_u64(55),
+                       side_arg_u64(55),
+                       side_arg_s8(-55),
+                       side_arg_s8(-55),
+                       side_arg_s8(-55),
+                       side_arg_s8(-55),
+                       side_arg_s16(-55),
+                       side_arg_s16(-55),
+                       side_arg_s16(-55),
+                       side_arg_s16(-55),
+                       side_arg_s32(-55),
+                       side_arg_s32(-55),
+                       side_arg_s32(-55),
+                       side_arg_s32(-55),
+                       side_arg_s64(-55),
+                       side_arg_s64(-55),
+                       side_arg_s64(-55),
+                       side_arg_s64(-55),
+               )
+       );
+}
+
 int main()
 {
        test_fields();
@@ -1443,5 +1522,6 @@ int main()
        test_blob();
        test_fmt_string();
        test_endian();
+       test_base();
        return 0;
 }

diff --git a/src/tracer.c b/src/tracer.c
index 478685c85f408ed6e5f75f32f396f24dc68e27c9..ad7c393a932250454aee497437630def1e2d4f2a 100644 (file)
--- a/src/tracer.c
+++ b/src/tracer.c
@@ -8,9 +8,17 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <stdbool.h>
+#include <string.h>
 
 #include <side/trace.h>
 
+enum tracer_display_base {
+       TRACER_DISPLAY_BASE_2,
+       TRACER_DISPLAY_BASE_8,
+       TRACER_DISPLAY_BASE_10,
+       TRACER_DISPLAY_BASE_16,
+};
+
 static struct side_tracer_handle *tracer_handle;
 
 static
@@ -30,6 +38,72 @@ void tracer_print_dynamic(const struct side_arg_dynamic_vec *dynamic_item);
 static
 void tracer_print_type(const struct side_type_description *type_desc, const struct side_arg_vec *item);
 
+static
+int64_t get_attr_integer_value(const struct side_attr *attr)
+{
+       int64_t val;
+
+       switch (attr->value.type) {
+       case SIDE_ATTR_TYPE_U8:
+               val = attr->value.u.side_u8;
+               break;
+       case SIDE_ATTR_TYPE_U16:
+               val = attr->value.u.side_u16;
+               break;
+       case SIDE_ATTR_TYPE_U32:
+               val = attr->value.u.side_u32;
+               break;
+       case SIDE_ATTR_TYPE_U64:
+               val = attr->value.u.side_u64;
+               break;
+       case SIDE_ATTR_TYPE_S8:
+               val = attr->value.u.side_s8;
+               break;
+       case SIDE_ATTR_TYPE_S16:
+               val = attr->value.u.side_s16;
+               break;
+       case SIDE_ATTR_TYPE_S32:
+               val = attr->value.u.side_s32;
+               break;
+       case SIDE_ATTR_TYPE_S64:
+               val = attr->value.u.side_s64;
+               break;
+       default:
+               fprintf(stderr, "Unexpected attribute type\n");
+               abort();
+       }
+       return val;
+}
+
+static
+enum tracer_display_base get_attr_display_base(const struct side_attr *_attr, uint32_t nr_attr)
+{
+       uint32_t i;
+
+       for (i = 0; i < nr_attr; i++) {
+               const struct side_attr *attr = &_attr[i];
+
+               if (!strcmp(attr->key, "std.integer.base")) {
+                       int64_t val = get_attr_integer_value(attr);
+
+                       switch (val) {
+                       case 2:
+                               return TRACER_DISPLAY_BASE_2;
+                       case 8:
+                               return TRACER_DISPLAY_BASE_8;
+                       case 10:
+                               return TRACER_DISPLAY_BASE_10;
+                       case 16:
+                               return TRACER_DISPLAY_BASE_16;
+                       default:
+                               fprintf(stderr, "Unexpected integer display base: %" PRId64 "\n", val);
+                               abort();
+                       }
+               }
+       }
+       return TRACER_DISPLAY_BASE_10;  /* Default */
+}
+
 static
 bool type_to_host_reverse_bo(const struct side_type_description *type_desc)
 {
@@ -442,6 +516,19 @@ match:
        printf(" ]");
 }
 
+static
+void print_integer_binary(uint64_t v, int bits)
+{
+       int i;
+
+       printf("0b");
+       v <<= 64 - bits;
+       for (i = 0; i < bits; i++) {
+               printf("%c", v & (1ULL << 63) ? '1' : '0');
+               v <<= 1;
+       }
+}
+
 static
 void tracer_print_basic_type_header(const struct side_type_description *type_desc)
 {
@@ -454,6 +541,7 @@ static
 void tracer_print_type(const struct side_type_description *type_desc, const struct side_arg_vec *item)
 {
        enum side_type type;
+       enum tracer_display_base base = TRACER_DISPLAY_BASE_10;
 
        switch (type_desc->type) {
        case SIDE_TYPE_ARRAY:
@@ -548,6 +636,22 @@ void tracer_print_type(const struct side_type_description *type_desc, const stru
        else
                type = item->type;
 
+       switch (type) {
+       case SIDE_TYPE_U8:
+       case SIDE_TYPE_U16:
+       case SIDE_TYPE_U32:
+       case SIDE_TYPE_U64:
+       case SIDE_TYPE_S8:
+       case SIDE_TYPE_S16:
+       case SIDE_TYPE_S32:
+       case SIDE_TYPE_S64:
+               base = get_attr_display_base(type_desc->u.side_basic.attr,
+                               type_desc->u.side_basic.nr_attr);
+               break;
+       default:
+               break;
+       }
+
        printf("{ ");
        switch (type) {
        case SIDE_TYPE_BOOL:
@@ -555,9 +659,29 @@ void tracer_print_type(const struct side_type_description *type_desc, const stru
                printf("%s", item->u.side_bool ? "true" : "false");
                break;
        case SIDE_TYPE_U8:
+       {
+               uint8_t v;
+
+               v = item->u.side_u8;
                tracer_print_basic_type_header(type_desc);
-               printf("%" PRIu8, item->u.side_u8);
+               switch (base) {
+               case TRACER_DISPLAY_BASE_2:
+                       print_integer_binary(v, 8);
+                       break;
+               case TRACER_DISPLAY_BASE_8:
+                       printf("0%" PRIo8, v);
+                       break;
+               case TRACER_DISPLAY_BASE_10:
+                       printf("%" PRIu8, v);
+                       break;
+               case TRACER_DISPLAY_BASE_16:
+                       printf("0x%" PRIx8, v);
+                       break;
+               default:
+                       abort();
+               }
                break;
+       }
        case SIDE_TYPE_U16:
        {
                uint16_t v;
@@ -566,7 +690,22 @@ void tracer_print_type(const struct side_type_description *type_desc, const stru
                if (type_to_host_reverse_bo(type_desc))
                        v = side_bswap_16(v);
                tracer_print_basic_type_header(type_desc);
-               printf("%" PRIu16, v);
+               switch (base) {
+               case TRACER_DISPLAY_BASE_2:
+                       print_integer_binary(v, 16);
+                       break;
+               case TRACER_DISPLAY_BASE_8:
+                       printf("0%" PRIo16, v);
+                       break;
+               case TRACER_DISPLAY_BASE_10:
+                       printf("%" PRIu16, v);
+                       break;
+               case TRACER_DISPLAY_BASE_16:
+                       printf("0x%" PRIx16, v);
+                       break;
+               default:
+                       abort();
+               }
                break;
        }
        case SIDE_TYPE_U32:
@@ -577,7 +716,22 @@ void tracer_print_type(const struct side_type_description *type_desc, const stru
                if (type_to_host_reverse_bo(type_desc))
                        v = side_bswap_32(v);
                tracer_print_basic_type_header(type_desc);
-               printf("%" PRIu32, v);
+               switch (base) {
+               case TRACER_DISPLAY_BASE_2:
+                       print_integer_binary(v, 32);
+                       break;
+               case TRACER_DISPLAY_BASE_8:
+                       printf("0%" PRIo32, v);
+                       break;
+               case TRACER_DISPLAY_BASE_10:
+                       printf("%" PRIu32, v);
+                       break;
+               case TRACER_DISPLAY_BASE_16:
+                       printf("0x%" PRIx32, v);
+                       break;
+               default:
+                       abort();
+               }
                break;
        }
        case SIDE_TYPE_U64:
@@ -588,13 +742,48 @@ void tracer_print_type(const struct side_type_description *type_desc, const stru
                if (type_to_host_reverse_bo(type_desc))
                        v = side_bswap_64(v);
                tracer_print_basic_type_header(type_desc);
-               printf("%" PRIu64, v);
+               switch (base) {
+               case TRACER_DISPLAY_BASE_2:
+                       print_integer_binary(v, 64);
+                       break;
+               case TRACER_DISPLAY_BASE_8:
+                       printf("0%" PRIo64, v);
+                       break;
+               case TRACER_DISPLAY_BASE_10:
+                       printf("%" PRIu64, v);
+                       break;
+               case TRACER_DISPLAY_BASE_16:
+                       printf("0x%" PRIx64, v);
+                       break;
+               default:
+                       abort();
+               }
                break;
        }
        case SIDE_TYPE_S8:
+       {
+               int8_t v;
+
+               v = item->u.side_s8;
                tracer_print_basic_type_header(type_desc);
-               printf("%" PRId8, item->u.side_s8);
+               switch (base) {
+               case TRACER_DISPLAY_BASE_2:
+                       print_integer_binary(v, 8);
+                       break;
+               case TRACER_DISPLAY_BASE_8:
+                       printf("0%" PRIo8, v);
+                       break;
+               case TRACER_DISPLAY_BASE_10:
+                       printf("%" PRId8, v);
+                       break;
+               case TRACER_DISPLAY_BASE_16:
+                       printf("0x%" PRIx8, v);
+                       break;
+               default:
+                       abort();
+               }
                break;
+       }
        case SIDE_TYPE_S16:
        {
                int16_t v;
@@ -603,7 +792,22 @@ void tracer_print_type(const struct side_type_description *type_desc, const stru
                if (type_to_host_reverse_bo(type_desc))
                        v = side_bswap_16(v);
                tracer_print_basic_type_header(type_desc);
-               printf("%" PRId16, v);
+               switch (base) {
+               case TRACER_DISPLAY_BASE_2:
+                       print_integer_binary(v, 16);
+                       break;
+               case TRACER_DISPLAY_BASE_8:
+                       printf("0%" PRIo16, v);
+                       break;
+               case TRACER_DISPLAY_BASE_10:
+                       printf("%" PRId16, v);
+                       break;
+               case TRACER_DISPLAY_BASE_16:
+                       printf("0x%" PRIx16, v);
+                       break;
+               default:
+                       abort();
+               }
                break;
        }
        case SIDE_TYPE_S32:
@@ -614,7 +818,22 @@ void tracer_print_type(const struct side_type_description *type_desc, const stru
                if (type_to_host_reverse_bo(type_desc))
                        v = side_bswap_32(v);
                tracer_print_basic_type_header(type_desc);
-               printf("%" PRId32, v);
+               switch (base) {
+               case TRACER_DISPLAY_BASE_2:
+                       print_integer_binary(v, 32);
+                       break;
+               case TRACER_DISPLAY_BASE_8:
+                       printf("0%" PRIo32, v);
+                       break;
+               case TRACER_DISPLAY_BASE_10:
+                       printf("%" PRId32, v);
+                       break;
+               case TRACER_DISPLAY_BASE_16:
+                       printf("0x%" PRIx32, v);
+                       break;
+               default:
+                       abort();
+               }
                break;
        }
        case SIDE_TYPE_S64:
@@ -625,7 +844,22 @@ void tracer_print_type(const struct side_type_description *type_desc, const stru
                if (type_to_host_reverse_bo(type_desc))
                        v = side_bswap_64(v);
                tracer_print_basic_type_header(type_desc);
-               printf("%" PRId64, v);
+               switch (base) {
+               case TRACER_DISPLAY_BASE_2:
+                       print_integer_binary(v, 64);
+                       break;
+               case TRACER_DISPLAY_BASE_8:
+                       printf("0%" PRIo64, v);
+                       break;
+               case TRACER_DISPLAY_BASE_10:
+                       printf("%" PRId64, v);
+                       break;
+               case TRACER_DISPLAY_BASE_16:
+                       printf("0x%" PRIx64, v);
+                       break;
+               default:
+                       abort();
+               }
                break;
        }
        case SIDE_TYPE_POINTER32:
@@ -1279,6 +1513,25 @@ void tracer_print_dynamic_basic_type_header(const struct side_arg_dynamic_vec *i
 static
 void tracer_print_dynamic(const struct side_arg_dynamic_vec *item)
 {
+       enum tracer_display_base base = TRACER_DISPLAY_BASE_10;
+
+       switch (item->dynamic_type) {
+       case SIDE_DYNAMIC_TYPE_U8:
+       case SIDE_DYNAMIC_TYPE_U16:
+       case SIDE_DYNAMIC_TYPE_U32:
+       case SIDE_DYNAMIC_TYPE_U64:
+       case SIDE_DYNAMIC_TYPE_S8:
+       case SIDE_DYNAMIC_TYPE_S16:
+       case SIDE_DYNAMIC_TYPE_S32:
+       case SIDE_DYNAMIC_TYPE_S64:
+               base = get_attr_display_base(item->u.side_basic.attr,
+                               item->u.side_basic.nr_attr);
+               break;
+       default:
+               break;
+       }
+
+
        printf("{ ");
        switch (item->dynamic_type) {
        case SIDE_DYNAMIC_TYPE_NULL:
@@ -1290,9 +1543,29 @@ void tracer_print_dynamic(const struct side_arg_dynamic_vec *item)
                printf("%s", item->u.side_basic.u.side_bool ? "true" : "false");
                break;
        case SIDE_DYNAMIC_TYPE_U8:
+       {
+               uint8_t v;
+
+               v = item->u.side_basic.u.side_u8;
                tracer_print_dynamic_basic_type_header(item);
-               printf("%" PRIu8, item->u.side_basic.u.side_u8);
+               switch (base) {
+               case TRACER_DISPLAY_BASE_2:
+                       print_integer_binary(v, 8);
+                       break;
+               case TRACER_DISPLAY_BASE_8:
+                       printf("0%" PRIo8, v);
+                       break;
+               case TRACER_DISPLAY_BASE_10:
+                       printf("%" PRIu8, v);
+                       break;
+               case TRACER_DISPLAY_BASE_16:
+                       printf("0x%" PRIx8, v);
+                       break;
+               default:
+                       abort();
+               }
                break;
+       }
        case SIDE_DYNAMIC_TYPE_U16:
        {
                uint16_t v;
@@ -1301,7 +1574,22 @@ void tracer_print_dynamic(const struct side_arg_dynamic_vec *item)
                if (dynamic_type_to_host_reverse_bo(item))
                        v = side_bswap_16(v);
                tracer_print_dynamic_basic_type_header(item);
-               printf("%" PRIu16, v);
+               switch (base) {
+               case TRACER_DISPLAY_BASE_2:
+                       print_integer_binary(v, 16);
+                       break;
+               case TRACER_DISPLAY_BASE_8:
+                       printf("0%" PRIo16, v);
+                       break;
+               case TRACER_DISPLAY_BASE_10:
+                       printf("%" PRIu16, v);
+                       break;
+               case TRACER_DISPLAY_BASE_16:
+                       printf("0x%" PRIx16, v);
+                       break;
+               default:
+                       abort();
+               }
                break;
        }
        case SIDE_DYNAMIC_TYPE_U32:
@@ -1312,7 +1600,22 @@ void tracer_print_dynamic(const struct side_arg_dynamic_vec *item)
                if (dynamic_type_to_host_reverse_bo(item))
                        v = side_bswap_32(v);
                tracer_print_dynamic_basic_type_header(item);
-               printf("%" PRIu32, v);
+               switch (base) {
+               case TRACER_DISPLAY_BASE_2:
+                       print_integer_binary(v, 32);
+                       break;
+               case TRACER_DISPLAY_BASE_8:
+                       printf("0%" PRIo32, v);
+                       break;
+               case TRACER_DISPLAY_BASE_10:
+                       printf("%" PRIu32, v);
+                       break;
+               case TRACER_DISPLAY_BASE_16:
+                       printf("0x%" PRIx32, v);
+                       break;
+               default:
+                       abort();
+               }
                break;
        }
        case SIDE_DYNAMIC_TYPE_U64:
@@ -1323,13 +1626,48 @@ void tracer_print_dynamic(const struct side_arg_dynamic_vec *item)
                if (dynamic_type_to_host_reverse_bo(item))
                        v = side_bswap_64(v);
                tracer_print_dynamic_basic_type_header(item);
-               printf("%" PRIu64, v);
+               switch (base) {
+               case TRACER_DISPLAY_BASE_2:
+                       print_integer_binary(v, 64);
+                       break;
+               case TRACER_DISPLAY_BASE_8:
+                       printf("0%" PRIo64, v);
+                       break;
+               case TRACER_DISPLAY_BASE_10:
+                       printf("%" PRIu64, v);
+                       break;
+               case TRACER_DISPLAY_BASE_16:
+                       printf("0x%" PRIx64, v);
+                       break;
+               default:
+                       abort();
+               }
                break;
        }
        case SIDE_DYNAMIC_TYPE_S8:
+       {
+               int8_t v;
+
+               v = item->u.side_basic.u.side_s8;
                tracer_print_dynamic_basic_type_header(item);
-               printf("%" PRId8, item->u.side_basic.u.side_s8);
+               switch (base) {
+               case TRACER_DISPLAY_BASE_2:
+                       print_integer_binary(v, 8);
+                       break;
+               case TRACER_DISPLAY_BASE_8:
+                       printf("0%" PRIo8, v);
+                       break;
+               case TRACER_DISPLAY_BASE_10:
+                       printf("%" PRId8, v);
+                       break;
+               case TRACER_DISPLAY_BASE_16:
+                       printf("0x%" PRIx8, v);
+                       break;
+               default:
+                       abort();
+               }
                break;
+       }
        case SIDE_DYNAMIC_TYPE_S16:
        {
                int16_t v;
@@ -1338,7 +1676,22 @@ void tracer_print_dynamic(const struct side_arg_dynamic_vec *item)
                if (dynamic_type_to_host_reverse_bo(item))
                        v = side_bswap_16(v);
                tracer_print_dynamic_basic_type_header(item);
-               printf("%" PRId16, v);
+               switch (base) {
+               case TRACER_DISPLAY_BASE_2:
+                       print_integer_binary(v, 16);
+                       break;
+               case TRACER_DISPLAY_BASE_8:
+                       printf("0%" PRIo16, v);
+                       break;
+               case TRACER_DISPLAY_BASE_10:
+                       printf("%" PRId16, v);
+                       break;
+               case TRACER_DISPLAY_BASE_16:
+                       printf("0x%" PRIx16, v);
+                       break;
+               default:
+                       abort();
+               }
                break;
        }
        case SIDE_DYNAMIC_TYPE_S32:
@@ -1349,7 +1702,22 @@ void tracer_print_dynamic(const struct side_arg_dynamic_vec *item)
                if (dynamic_type_to_host_reverse_bo(item))
                        v = side_bswap_32(v);
                tracer_print_dynamic_basic_type_header(item);
-               printf("%" PRId32, v);
+               switch (base) {
+               case TRACER_DISPLAY_BASE_2:
+                       print_integer_binary(v, 32);
+                       break;
+               case TRACER_DISPLAY_BASE_8:
+                       printf("0%" PRIo32, v);
+                       break;
+               case TRACER_DISPLAY_BASE_10:
+                       printf("%" PRId32, v);
+                       break;
+               case TRACER_DISPLAY_BASE_16:
+                       printf("0x%" PRIx32, v);
+                       break;
+               default:
+                       abort();
+               }
                break;
        }
        case SIDE_DYNAMIC_TYPE_S64:
@@ -1360,7 +1728,22 @@ void tracer_print_dynamic(const struct side_arg_dynamic_vec *item)
                if (dynamic_type_to_host_reverse_bo(item))
                        v = side_bswap_64(v);
                tracer_print_dynamic_basic_type_header(item);
-               printf("%" PRId64, v);
+               switch (base) {
+               case TRACER_DISPLAY_BASE_2:
+                       print_integer_binary(v, 64);
+                       break;
+               case TRACER_DISPLAY_BASE_8:
+                       printf("0%" PRIo64, v);
+                       break;
+               case TRACER_DISPLAY_BASE_10:
+                       printf("%" PRId64, v);
+                       break;
+               case TRACER_DISPLAY_BASE_16:
+                       printf("0x%" PRIx64, v);
+                       break;
+               default:
+                       abort();
+               }
                break;
        }
        case SIDE_DYNAMIC_TYPE_BYTE: