Refactor type system integer types

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

diff --git a/include/side/trace.h b/include/side/trace.h
index 989810f662e5e958ba77f5bb29588d037102a540..504c53925998bc8962135047420fa2d94bf5ba35 100644 (file)
--- a/include/side/trace.h
+++ b/include/side/trace.h
@@ -294,6 +294,15 @@ struct side_type_struct_sg {
        const struct side_attr *attr;
 };
 
+struct side_type_integer {
+       const struct side_attr *attr;
+       uint32_t nr_attr;
+       uint8_t signedness;             /* true/false */
+       uint8_t byte_order;             /* enum side_type_byte_order */
+       uint8_t integer_size_bits;      /* bits */
+       uint8_t len_bits;               /* bits */
+};
+
 struct side_type_description {
        uint32_t type;  /* enum side_type */
        union {
@@ -301,9 +310,11 @@ struct side_type_description {
                struct {
                        const struct side_attr *attr;
                        uint32_t nr_attr;
-                       uint32_t byte_order;    /* enum side_type_byte_order */
+                       uint32_t byte_order;            /* enum side_type_byte_order */
                } side_basic;
 
+               struct side_type_integer side_integer;
+
                /* Compound types */
                struct {
                        const struct side_type_description *elem_type;
@@ -449,8 +460,7 @@ struct side_arg_dynamic_event_struct {
 struct side_arg_vec {
        enum side_type type;
        union {
-               /* Basic types */
-               uint8_t side_bool;
+               /* Integer types */
                uint8_t side_u8;
                uint16_t side_u16;
                uint32_t side_u32;
@@ -459,6 +469,9 @@ struct side_arg_vec {
                int16_t side_s16;
                int32_t side_s32;
                int64_t side_s64;
+
+               /* Basic types */
+               uint8_t side_bool;
                uint8_t side_byte;
 #if __HAVE_FLOAT16
                _Float16 side_float_binary16;
@@ -576,6 +589,21 @@ struct side_tracer_dynamic_vla_visitor_ctx {
                }, \
        }
 
+#define _side_type_integer(_type, _signedness, _byte_order, _integer_size_bits, _len_bits, _attr) \
+       { \
+               .type = _type, \
+               .u = { \
+                       .side_integer = { \
+                               .attr = _attr, \
+                               .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
+                               .signedness = _signedness, \
+                               .byte_order = _byte_order, \
+                               .integer_size_bits = _integer_size_bits, \
+                               .len_bits = _len_bits, \
+                       }, \
+               }, \
+       }
+
 #define _side_field(_name, _type) \
        { \
                .field_name = _name, \
@@ -584,14 +612,14 @@ struct side_tracer_dynamic_vla_visitor_ctx {
 
 /* Host endian */
 #define side_type_bool(_attr)                          _side_type_basic(SIDE_TYPE_BOOL, SIDE_TYPE_BYTE_ORDER_HOST, SIDE_PARAM(_attr))
-#define side_type_u8(_attr)                            _side_type_basic(SIDE_TYPE_U8, SIDE_TYPE_BYTE_ORDER_HOST, SIDE_PARAM(_attr))
-#define side_type_u16(_attr)                           _side_type_basic(SIDE_TYPE_U16, SIDE_TYPE_BYTE_ORDER_HOST, SIDE_PARAM(_attr))
-#define side_type_u32(_attr)                           _side_type_basic(SIDE_TYPE_U32, SIDE_TYPE_BYTE_ORDER_HOST, SIDE_PARAM(_attr))
-#define side_type_u64(_attr)                           _side_type_basic(SIDE_TYPE_U64, SIDE_TYPE_BYTE_ORDER_HOST, SIDE_PARAM(_attr))
-#define side_type_s8(_attr)                            _side_type_basic(SIDE_TYPE_S8, SIDE_TYPE_BYTE_ORDER_HOST, SIDE_PARAM(_attr))
-#define side_type_s16(_attr)                           _side_type_basic(SIDE_TYPE_S16, SIDE_TYPE_BYTE_ORDER_HOST, SIDE_PARAM(_attr))
-#define side_type_s32(_attr)                           _side_type_basic(SIDE_TYPE_S32, SIDE_TYPE_BYTE_ORDER_HOST, SIDE_PARAM(_attr))
-#define side_type_s64(_attr)                           _side_type_basic(SIDE_TYPE_S64, SIDE_TYPE_BYTE_ORDER_HOST, SIDE_PARAM(_attr))
+#define side_type_u8(_attr)                            _side_type_integer(SIDE_TYPE_U8, false, SIDE_TYPE_BYTE_ORDER_HOST, 8, 8, SIDE_PARAM(_attr))
+#define side_type_u16(_attr)                           _side_type_integer(SIDE_TYPE_U16, false, SIDE_TYPE_BYTE_ORDER_HOST, 16, 16, SIDE_PARAM(_attr))
+#define side_type_u32(_attr)                           _side_type_integer(SIDE_TYPE_U32, false, SIDE_TYPE_BYTE_ORDER_HOST, 32, 32, SIDE_PARAM(_attr))
+#define side_type_u64(_attr)                           _side_type_integer(SIDE_TYPE_U64, false, SIDE_TYPE_BYTE_ORDER_HOST, 64, 64, SIDE_PARAM(_attr))
+#define side_type_s8(_attr)                            _side_type_integer(SIDE_TYPE_S8, true, SIDE_TYPE_BYTE_ORDER_HOST, 8, 8, SIDE_PARAM(_attr))
+#define side_type_s16(_attr)                           _side_type_integer(SIDE_TYPE_S16, true, SIDE_TYPE_BYTE_ORDER_HOST, 16, 16, SIDE_PARAM(_attr))
+#define side_type_s32(_attr)                           _side_type_integer(SIDE_TYPE_S32, true, SIDE_TYPE_BYTE_ORDER_HOST, 32, 32, SIDE_PARAM(_attr))
+#define side_type_s64(_attr)                           _side_type_integer(SIDE_TYPE_S64, true, SIDE_TYPE_BYTE_ORDER_HOST, 64, 64, SIDE_PARAM(_attr))
 #define side_type_byte(_attr)                          _side_type_basic(SIDE_TYPE_BYTE, SIDE_TYPE_BYTE_ORDER_HOST, SIDE_PARAM(_attr))
 #define side_type_pointer(_attr)                       _side_type_basic(SIDE_TYPE_POINTER_HOST, SIDE_TYPE_BYTE_ORDER_HOST, SIDE_PARAM(_attr))
 #define side_type_float_binary16(_attr)                        _side_type_basic(SIDE_TYPE_FLOAT_BINARY16, SIDE_TYPE_FLOAT_WORD_ORDER_HOST, SIDE_PARAM(_attr))
@@ -620,12 +648,12 @@ struct side_tracer_dynamic_vla_visitor_ctx {
 #define side_field_dynamic(_name, _attr)               _side_field(_name, side_type_dynamic(SIDE_PARAM(_attr)))
 
 /* Little endian */
-#define side_type_u16_le(_attr)                                _side_type_basic(SIDE_TYPE_U16, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
-#define side_type_u32_le(_attr)                                _side_type_basic(SIDE_TYPE_U32, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
-#define side_type_u64_le(_attr)                                _side_type_basic(SIDE_TYPE_U64, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
-#define side_type_s16_le(_attr)                                _side_type_basic(SIDE_TYPE_S16, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
-#define side_type_s32_le(_attr)                                _side_type_basic(SIDE_TYPE_S32, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
-#define side_type_s64_le(_attr)                                _side_type_basic(SIDE_TYPE_S64, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
+#define side_type_u16_le(_attr)                                _side_type_integer(SIDE_TYPE_U16, false, SIDE_TYPE_BYTE_ORDER_LE, 16, 16, SIDE_PARAM(_attr))
+#define side_type_u32_le(_attr)                                _side_type_integer(SIDE_TYPE_U32, false, SIDE_TYPE_BYTE_ORDER_LE, 32, 32, SIDE_PARAM(_attr))
+#define side_type_u64_le(_attr)                                _side_type_integer(SIDE_TYPE_U64, false, SIDE_TYPE_BYTE_ORDER_LE, 64, 64, SIDE_PARAM(_attr))
+#define side_type_s16_le(_attr)                                _side_type_integer(SIDE_TYPE_S16, true, SIDE_TYPE_BYTE_ORDER_LE, 16, 16, SIDE_PARAM(_attr))
+#define side_type_s32_le(_attr)                                _side_type_integer(SIDE_TYPE_S32, true, SIDE_TYPE_BYTE_ORDER_LE, 32, 32, SIDE_PARAM(_attr))
+#define side_type_s64_le(_attr)                                _side_type_integer(SIDE_TYPE_S64, true, SIDE_TYPE_BYTE_ORDER_LE, 64, 64, SIDE_PARAM(_attr))
 #define side_type_pointer_le(_attr)                    _side_type_basic(SIDE_TYPE_POINTER_HOST, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
 #define side_type_float_binary16_le(_attr)             _side_type_basic(SIDE_TYPE_FLOAT_BINARY16, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
 #define side_type_float_binary32_le(_attr)             _side_type_basic(SIDE_TYPE_FLOAT_BINARY32, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
@@ -645,12 +673,12 @@ struct side_tracer_dynamic_vla_visitor_ctx {
 #define side_field_float_binary128_le(_name, _attr)    _side_field(_name, side_type_float_binary128_le(SIDE_PARAM(_attr)))
 
 /* Big endian */
-#define side_type_u16_be(_attr)                                _side_type_basic(SIDE_TYPE_U16, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
-#define side_type_u32_be(_attr)                                _side_type_basic(SIDE_TYPE_U32, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
-#define side_type_u64_be(_attr)                                _side_type_basic(SIDE_TYPE_U64, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
-#define side_type_s16_be(_attr)                                _side_type_basic(SIDE_TYPE_S16, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
-#define side_type_s32_be(_attr)                                _side_type_basic(SIDE_TYPE_S32, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
-#define side_type_s64_be(_attr)                                _side_type_basic(SIDE_TYPE_S64, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
+#define side_type_u16_be(_attr)                                _side_type_integer(SIDE_TYPE_U16, false, SIDE_TYPE_BYTE_ORDER_BE, 16, 16, SIDE_PARAM(_attr))
+#define side_type_u32_be(_attr)                                _side_type_integer(SIDE_TYPE_U32, false, SIDE_TYPE_BYTE_ORDER_BE, 32, 32, SIDE_PARAM(_attr))
+#define side_type_u64_be(_attr)                                _side_type_integer(SIDE_TYPE_U64, false, SIDE_TYPE_BYTE_ORDER_BE, 64, 64, SIDE_PARAM(_attr))
+#define side_type_s16_be(_attr)                                _side_type_integer(SIDE_TYPE_S16, false, SIDE_TYPE_BYTE_ORDER_BE, 16, 16, SIDE_PARAM(_attr))
+#define side_type_s32_be(_attr)                                _side_type_integer(SIDE_TYPE_S32, false, SIDE_TYPE_BYTE_ORDER_BE, 32, 32, SIDE_PARAM(_attr))
+#define side_type_s64_be(_attr)                                _side_type_integer(SIDE_TYPE_S64, false, SIDE_TYPE_BYTE_ORDER_BE, 64, 64, SIDE_PARAM(_attr))
 #define side_type_pointer_be(_attr)                    _side_type_basic(SIDE_TYPE_POINTER_HOST, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
 #define side_type_float_binary16_be(_attr)             _side_type_basic(SIDE_TYPE_FLOAT_BINARY16, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
 #define side_type_float_binary32_be(_attr)             _side_type_basic(SIDE_TYPE_FLOAT_BINARY32, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))

diff --git a/src/tracer.c b/src/tracer.c
index 0709ebba0a267a28f94e36c4c8f8a4649f05177f..f4aa70c1e227e9475d72cb2e155bd15406128819 100644 (file)
--- a/src/tracer.c
+++ b/src/tracer.c
@@ -120,6 +120,11 @@ bool type_to_host_reverse_bo(const struct side_type_description *type_desc)
         case SIDE_TYPE_S16:
         case SIDE_TYPE_S32:
         case SIDE_TYPE_S64:
+               if (type_desc->u.side_integer.byte_order != SIDE_TYPE_BYTE_ORDER_HOST)
+                       return true;
+               else
+                       return false;
+               break;
         case SIDE_TYPE_POINTER32:
         case SIDE_TYPE_POINTER64:
                if (type_desc->u.side_basic.byte_order != SIDE_TYPE_BYTE_ORDER_HOST)
@@ -556,11 +561,124 @@ void tracer_print_basic_type_header(const struct side_type_description *type_des
        printf("value: ");
 }
 
+static
+void tracer_print_type_integer(enum side_type type, const struct side_type_description *type_desc, const struct side_arg_vec *item)
+{
+       enum tracer_display_base base;
+       union {
+               uint64_t v_unsigned;
+               int64_t v_signed;
+       } v;
+
+       if (!type_desc->u.side_integer.len_bits ||
+                       type_desc->u.side_integer.len_bits > type_desc->u.side_integer.integer_size_bits)
+               abort();
+       base = get_attr_display_base(type_desc->u.side_integer.attr,
+                       type_desc->u.side_integer.nr_attr);
+       switch (type) {
+       case SIDE_TYPE_U8:
+               v.v_unsigned = item->u.side_u8;
+               break;
+       case SIDE_TYPE_U16:
+       {
+               uint16_t side_u16;
+
+               side_u16 = item->u.side_u16;
+               if (type_to_host_reverse_bo(type_desc))
+                       side_u16 = side_bswap_16(side_u16);
+               v.v_unsigned = side_u16;
+               break;
+       }
+       case SIDE_TYPE_U32:
+       {
+               uint32_t side_u32;
+
+               side_u32 = item->u.side_u32;
+               if (type_to_host_reverse_bo(type_desc))
+                       side_u32 = side_bswap_32(side_u32);
+               v.v_unsigned = side_u32;
+               break;
+       }
+       case SIDE_TYPE_U64:
+       {
+               uint64_t side_u64;
+
+               side_u64 = item->u.side_u64;
+               if (type_to_host_reverse_bo(type_desc))
+                       side_u64 = side_bswap_64(side_u64);
+               v.v_unsigned = side_u64;
+               break;
+       }
+       case SIDE_TYPE_S8:
+               v.v_signed = item->u.side_s8;
+               break;
+       case SIDE_TYPE_S16:
+       {
+               int16_t side_s16;
+
+               side_s16 = item->u.side_s16;
+               if (type_to_host_reverse_bo(type_desc))
+                       side_s16 = side_bswap_16(side_s16);
+               v.v_unsigned = side_s16;
+               break;
+       }
+       case SIDE_TYPE_S32:
+       {
+               int32_t side_s32;
+
+               side_s32 = item->u.side_s32;
+               if (type_to_host_reverse_bo(type_desc))
+                       side_s32 = side_bswap_32(side_s32);
+               v.v_unsigned = side_s32;
+               break;
+       }
+       case SIDE_TYPE_S64:
+       {
+               int64_t side_s64;
+
+               side_s64 = item->u.side_s64;
+               if (type_to_host_reverse_bo(type_desc))
+                       side_s64 = side_bswap_64(side_s64);
+               v.v_unsigned = side_s64;
+               break;
+       }
+       default:
+               abort();
+       }
+       if (type_desc->u.side_integer.len_bits < 64)
+               v.v_unsigned &= (1ULL << type_desc->u.side_integer.len_bits) - 1;
+       tracer_print_basic_type_header(type_desc);
+       switch (base) {
+       case TRACER_DISPLAY_BASE_2:
+               print_integer_binary(v.v_unsigned, type_desc->u.side_integer.len_bits);
+               break;
+       case TRACER_DISPLAY_BASE_8:
+               printf("0%" PRIo64, v.v_unsigned);
+               break;
+       case TRACER_DISPLAY_BASE_10:
+               if (type_desc->u.side_integer.signedness) {
+                       /* Sign-extend. */
+                       if (type_desc->u.side_integer.len_bits < 64) {
+                               if (v.v_unsigned & (1ULL << (type_desc->u.side_integer.len_bits - 1)))
+                                       v.v_unsigned |= ~((1ULL << type_desc->u.side_integer.len_bits) - 1);
+                       }
+                       printf("%" PRId64, v.v_signed);
+               } else {
+                       printf("%" PRIu64, v.v_unsigned);
+               }
+               break;
+       case TRACER_DISPLAY_BASE_16:
+               printf("0x%" PRIx64, v.v_unsigned);
+               break;
+       default:
+               abort();
+       }
+}
+
 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:
@@ -655,232 +773,24 @@ 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:
                tracer_print_basic_type_header(type_desc);
                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);
-               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_U8:
        case SIDE_TYPE_U16:
-       {
-               uint16_t v;
-
-               v = item->u.side_u16;
-               if (type_to_host_reverse_bo(type_desc))
-                       v = side_bswap_16(v);
-               tracer_print_basic_type_header(type_desc);
-               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:
-       {
-               uint32_t v;
-
-               v = item->u.side_u32;
-               if (type_to_host_reverse_bo(type_desc))
-                       v = side_bswap_32(v);
-               tracer_print_basic_type_header(type_desc);
-               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:
-       {
-               uint64_t v;
-
-               v = item->u.side_u64;
-               if (type_to_host_reverse_bo(type_desc))
-                       v = side_bswap_64(v);
-               tracer_print_basic_type_header(type_desc);
-               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);
-               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;
-
-               v = item->u.side_s16;
-               if (type_to_host_reverse_bo(type_desc))
-                       v = side_bswap_16(v);
-               tracer_print_basic_type_header(type_desc);
-               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:
-       {
-               int32_t v;
-
-               v = item->u.side_s32;
-               if (type_to_host_reverse_bo(type_desc))
-                       v = side_bswap_32(v);
-               tracer_print_basic_type_header(type_desc);
-               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:
-       {
-               int64_t v;
-
-               v = item->u.side_s64;
-               if (type_to_host_reverse_bo(type_desc))
-                       v = side_bswap_64(v);
-               tracer_print_basic_type_header(type_desc);
-               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();
-               }
+               tracer_print_type_integer(type, type_desc, item);
                break;
-       }
+
        case SIDE_TYPE_POINTER32:
        {
                uint32_t v;