Implement pointer type

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

diff --git a/include/side/endian.h b/include/side/endian.h
index 2824ba7464a746599d97cc11c73d9924760171ee..a9680cac6f33c84d6ac5812fa3b1d2d10d4c8df9 100644 (file)
--- a/include/side/endian.h
+++ b/include/side/endian.h
@@ -29,6 +29,7 @@
 #ifndef _SIDE_ENDIAN_H
 #define _SIDE_ENDIAN_H
 
+#include <side/macros.h>
 #include <math.h>
 
 #if (defined(__linux__) || defined(__CYGWIN__))
@@ -77,4 +78,10 @@ void side_bswap_128p(char *p)
 }
 #endif
 
+#if SIDE_BITS_PER_LONG == 64
+# define side_bswap_pointer(x) side_bswap_64(x)
+#else
+# define side_bswap_pointer(x) side_bswap_32(x)
+#endif
+
 #endif /* _SIDE_ENDIAN_H */

diff --git a/include/side/trace.h b/include/side/trace.h
index 49b62cb9cceacd5fdc59821ab15c4e39d0d7ff73..7f6f04e9fb1aab4e5f68d46b10869b19aace4d73 100644 (file)
--- a/include/side/trace.h
+++ b/include/side/trace.h
@@ -45,6 +45,7 @@ enum side_type {
        SIDE_TYPE_S32,
        SIDE_TYPE_S64,
        SIDE_TYPE_BYTE,
+       SIDE_TYPE_POINTER,
        SIDE_TYPE_FLOAT_BINARY16,
        SIDE_TYPE_FLOAT_BINARY32,
        SIDE_TYPE_FLOAT_BINARY64,
@@ -66,6 +67,7 @@ enum side_type {
        SIDE_TYPE_ARRAY_S32,
        SIDE_TYPE_ARRAY_S64,
        SIDE_TYPE_ARRAY_BYTE,
+       SIDE_TYPE_ARRAY_POINTER,
 
        SIDE_TYPE_VLA_U8,
        SIDE_TYPE_VLA_U16,
@@ -76,6 +78,7 @@ enum side_type {
        SIDE_TYPE_VLA_S32,
        SIDE_TYPE_VLA_S64,
        SIDE_TYPE_VLA_BYTE,
+       SIDE_TYPE_VLA_POINTER,
 
        /* Enumeration types */
        SIDE_TYPE_ENUM,
@@ -98,6 +101,7 @@ enum side_dynamic_type {
        SIDE_DYNAMIC_TYPE_S32,
        SIDE_DYNAMIC_TYPE_S64,
        SIDE_DYNAMIC_TYPE_BYTE,
+       SIDE_DYNAMIC_TYPE_POINTER,
        SIDE_DYNAMIC_TYPE_FLOAT_BINARY16,
        SIDE_DYNAMIC_TYPE_FLOAT_BINARY32,
        SIDE_DYNAMIC_TYPE_FLOAT_BINARY64,
@@ -122,6 +126,7 @@ enum side_attr_type {
        SIDE_ATTR_TYPE_S16,
        SIDE_ATTR_TYPE_S32,
        SIDE_ATTR_TYPE_S64,
+       SIDE_ATTR_TYPE_POINTER,
        SIDE_ATTR_TYPE_FLOAT_BINARY16,
        SIDE_ATTR_TYPE_FLOAT_BINARY32,
        SIDE_ATTR_TYPE_FLOAT_BINARY64,
@@ -193,6 +198,7 @@ struct side_attr_value {
                int16_t side_s16;
                int32_t side_s32;
                int64_t side_s64;
+               uintptr_t side_pointer;
 #if __HAVE_FLOAT16
                _Float16 side_float_binary16;
 #endif
@@ -346,6 +352,7 @@ struct side_arg_dynamic_vec {
                                int32_t side_s32;
                                int64_t side_s64;
                                uint8_t side_byte;
+                               uintptr_t side_pointer;
 #if __HAVE_FLOAT16
                                _Float16 side_float_binary16;
 #endif
@@ -413,6 +420,7 @@ struct side_arg_vec {
                int32_t side_s32;
                int64_t side_s64;
                uint8_t side_byte;
+               uintptr_t side_pointer;
 #if __HAVE_FLOAT16
                _Float16 side_float_binary16;
 #endif
@@ -491,6 +499,7 @@ struct side_tracer_dynamic_vla_visitor_ctx {
 #define side_attr_s16(_val)            { .type = SIDE_ATTR_TYPE_S16, .u = { .side_s16 = (_val) } }
 #define side_attr_s32(_val)            { .type = SIDE_ATTR_TYPE_S32, .u = { .side_s32 = (_val) } }
 #define side_attr_s64(_val)            { .type = SIDE_ATTR_TYPE_S64, .u = { .side_s64 = (_val) } }
+#define side_attr_pointer(_val)                { .type = SIDE_ATTR_TYPE_POINTER, .u = { .side_pointer = (uintptr_t) (_val) } }
 #define side_attr_float_binary16(_val) { .type = SIDE_ATTR_TYPE_FLOAT_BINARY16, .u = { .side_float_binary16 = (_val) } }
 #define side_attr_float_binary32(_val) { .type = SIDE_ATTR_TYPE_FLOAT_BINARY32, .u = { .side_float_binary32 = (_val) } }
 #define side_attr_float_binary64(_val) { .type = SIDE_ATTR_TYPE_FLOAT_BINARY64, .u = { .side_float_binary64 = (_val) } }
@@ -528,6 +537,7 @@ struct side_tracer_dynamic_vla_visitor_ctx {
 #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_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, 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))
 #define side_type_float_binary32(_attr)                        _side_type_basic(SIDE_TYPE_FLOAT_BINARY32, SIDE_TYPE_FLOAT_WORD_ORDER_HOST, SIDE_PARAM(_attr))
 #define side_type_float_binary64(_attr)                        _side_type_basic(SIDE_TYPE_FLOAT_BINARY64, SIDE_TYPE_FLOAT_WORD_ORDER_HOST, SIDE_PARAM(_attr))
@@ -545,6 +555,7 @@ struct side_tracer_dynamic_vla_visitor_ctx {
 #define side_field_s32(_name, _attr)                   _side_field(_name, side_type_s32(SIDE_PARAM(_attr)))
 #define side_field_s64(_name, _attr)                   _side_field(_name, side_type_s64(SIDE_PARAM(_attr)))
 #define side_field_byte(_name, _attr)                  _side_field(_name, side_type_byte(SIDE_PARAM(_attr)))
+#define side_field_pointer(_name, _attr)               _side_field(_name, side_type_pointer(SIDE_PARAM(_attr)))
 #define side_field_float_binary16(_name, _attr)                _side_field(_name, side_type_float_binary16(SIDE_PARAM(_attr)))
 #define side_field_float_binary32(_name, _attr)                _side_field(_name, side_type_float_binary32(SIDE_PARAM(_attr)))
 #define side_field_float_binary64(_name, _attr)                _side_field(_name, side_type_float_binary64(SIDE_PARAM(_attr)))
@@ -559,6 +570,7 @@ struct side_tracer_dynamic_vla_visitor_ctx {
 #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_pointer_le(_attr)                    _side_type_basic(SIDE_TYPE_POINTER, 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))
 #define side_type_float_binary64_le(_attr)             _side_type_basic(SIDE_TYPE_FLOAT_BINARY64, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
@@ -570,6 +582,7 @@ struct side_tracer_dynamic_vla_visitor_ctx {
 #define side_field_s16_le(_name, _attr)                        _side_field(_name, side_type_s16_le(SIDE_PARAM(_attr)))
 #define side_field_s32_le(_name, _attr)                        _side_field(_name, side_type_s32_le(SIDE_PARAM(_attr)))
 #define side_field_s64_le(_name, _attr)                        _side_field(_name, side_type_s64_le(SIDE_PARAM(_attr)))
+#define side_field_pointer_le(_name, _attr)            _side_field(_name, side_type_pointer_le(SIDE_PARAM(_attr)))
 #define side_field_float_binary16_le(_name, _attr)     _side_field(_name, side_type_float_binary16_le(SIDE_PARAM(_attr)))
 #define side_field_float_binary32_le(_name, _attr)     _side_field(_name, side_type_float_binary32_le(SIDE_PARAM(_attr)))
 #define side_field_float_binary64_le(_name, _attr)     _side_field(_name, side_type_float_binary64_le(SIDE_PARAM(_attr)))
@@ -582,6 +595,7 @@ struct side_tracer_dynamic_vla_visitor_ctx {
 #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_pointer_be(_attr)                    _side_type_basic(SIDE_TYPE_POINTER, 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))
 #define side_type_float_binary64_be(_attr)             _side_type_basic(SIDE_TYPE_FLOAT_BINARY64, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
@@ -593,6 +607,7 @@ struct side_tracer_dynamic_vla_visitor_ctx {
 #define side_field_s16_be(_name, _attr)                        _side_field(_name, side_type_s16_be(SIDE_PARAM(_attr)))
 #define side_field_s32_be(_name, _attr)                        _side_field(_name, side_type_s32_be(SIDE_PARAM(_attr)))
 #define side_field_s64_be(_name, _attr)                        _side_field(_name, side_type_s64_be(SIDE_PARAM(_attr)))
+#define side_field_pointer_be(_name, _attr)            _side_field(_name, side_type_pointer_be(SIDE_PARAM(_attr)))
 #define side_field_float_binary16_be(_name, _attr)     _side_field(_name, side_type_float_binary16_be(SIDE_PARAM(_attr)))
 #define side_field_float_binary32_be(_name, _attr)     _side_field(_name, side_type_float_binary32_be(SIDE_PARAM(_attr)))
 #define side_field_float_binary64_be(_name, _attr)     _side_field(_name, side_type_float_binary64_be(SIDE_PARAM(_attr)))
@@ -711,6 +726,7 @@ struct side_tracer_dynamic_vla_visitor_ctx {
 #define side_arg_s32(_val)             { .type = SIDE_TYPE_S32, .u = { .side_s32 = (_val) } }
 #define side_arg_s64(_val)             { .type = SIDE_TYPE_S64, .u = { .side_s64 = (_val) } }
 #define side_arg_byte(_val)            { .type = SIDE_TYPE_BYTE, .u = { .side_byte = (_val) } }
+#define side_arg_pointer(_val)         { .type = SIDE_TYPE_POINTER, .u = { .side_pointer = (uintptr_t) (_val) } }
 #define side_arg_enum_bitmap8(_val)    { .type = SIDE_TYPE_ENUM_BITMAP8, .u = { .side_u8 = (_val) } }
 #define side_arg_enum_bitmap16(_val)   { .type = SIDE_TYPE_ENUM_BITMAP16, .u = { .side_u16 = (_val) } }
 #define side_arg_enum_bitmap32(_val)   { .type = SIDE_TYPE_ENUM_BITMAP32, .u = { .side_u32 = (_val) } }
@@ -737,6 +753,7 @@ struct side_tracer_dynamic_vla_visitor_ctx {
 #define side_arg_array_s32(_ptr)       { .type = SIDE_TYPE_ARRAY_S32, .u = { .side_array_fixint = (_ptr) } }
 #define side_arg_array_s64(_ptr)       { .type = SIDE_TYPE_ARRAY_S64, .u = { .side_array_fixint = (_ptr) } }
 #define side_arg_array_byte(_ptr)      { .type = SIDE_TYPE_ARRAY_BYTE, .u = { .side_array_fixint = (_ptr) } }
+#define side_arg_array_pointer(_ptr)   { .type = SIDE_TYPE_ARRAY_POINTER, .u = { .side_array_fixint = (_ptr) } }
 
 #define side_arg_vla_u8(_ptr, _length) { .type = SIDE_TYPE_VLA_U8, .u = { .side_vla_fixint = { .p = (_ptr), .length = (_length) } }
 #define side_arg_vla_u16(_ptr, _length)        { .type = SIDE_TYPE_VLA_U16, .u = { .side_vla_fixint = { .p = (_ptr), .length = (_length) } } }
@@ -747,6 +764,7 @@ struct side_tracer_dynamic_vla_visitor_ctx {
 #define side_arg_vla_s32(_ptr, _length)        { .type = SIDE_TYPE_VLA_S32, .u = { .side_vla_fixint = { .p = (_ptr), .length = (_length) } } }
 #define side_arg_vla_s64(_ptr, _length)        { .type = SIDE_TYPE_VLA_S64, .u = { .side_vla_fixint = { .p = (_ptr), .length = (_length) } } }
 #define side_arg_vla_byte(_ptr, _length) { .type = SIDE_TYPE_VLA_BYTE, .u = { .side_vla_fixint = { .p = (_ptr), .length = (_length) } } }
+#define side_arg_vla_pointer(_ptr, _length) { .type = SIDE_TYPE_VLA_POINTER, .u = { .side_vla_fixint = { .p = (_ptr), .length = (_length) } } }
 
 #define side_arg_dynamic(_dynamic_arg_type) \
        { \
@@ -927,6 +945,20 @@ struct side_tracer_dynamic_vla_visitor_ctx {
                        }, \
                }, \
        }
+#define _side_arg_dynamic_pointer(_val, _byte_order, _attr) \
+       { \
+               .dynamic_type = SIDE_DYNAMIC_TYPE_POINTER, \
+               .u = { \
+                       .side_basic = { \
+                               .attr = _attr, \
+                               .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
+                               .byte_order = _byte_order, \
+                               .u = { \
+                                       .side_pointer = (uintptr_t) (_val), \
+                               }, \
+                       }, \
+               }, \
+       }
 #define _side_arg_dynamic_float_binary16(_val, _byte_order, _attr) \
        { \
                .dynamic_type = SIDE_DYNAMIC_TYPE_FLOAT_BINARY16, \
@@ -991,6 +1023,7 @@ struct side_tracer_dynamic_vla_visitor_ctx {
 #define side_arg_dynamic_s16(_val, _attr)              _side_arg_dynamic_s16(_val, SIDE_TYPE_BYTE_ORDER_HOST, SIDE_PARAM(_attr))
 #define side_arg_dynamic_s32(_val, _attr)              _side_arg_dynamic_s32(_val, SIDE_TYPE_BYTE_ORDER_HOST, SIDE_PARAM(_attr))
 #define side_arg_dynamic_s64(_val, _attr)              _side_arg_dynamic_s64(_val, SIDE_TYPE_BYTE_ORDER_HOST, SIDE_PARAM(_attr))
+#define side_arg_dynamic_pointer(_val, _attr)          _side_arg_dynamic_pointer(_val, SIDE_TYPE_BYTE_ORDER_HOST, SIDE_PARAM(_attr))
 #define side_arg_dynamic_float_binary16(_val, _attr)   _side_arg_dynamic_float_binary16(_val, SIDE_TYPE_FLOAT_WORD_ORDER_HOST, SIDE_PARAM(_attr))
 #define side_arg_dynamic_float_binary32(_val, _attr)   _side_arg_dynamic_float_binary32(_val, SIDE_TYPE_FLOAT_WORD_ORDER_HOST, SIDE_PARAM(_attr))
 #define side_arg_dynamic_float_binary64(_val, _attr)   _side_arg_dynamic_float_binary64(_val, SIDE_TYPE_FLOAT_WORD_ORDER_HOST, SIDE_PARAM(_attr))
@@ -1003,6 +1036,7 @@ struct side_tracer_dynamic_vla_visitor_ctx {
 #define side_arg_dynamic_s16_le(_val, _attr)                   _side_arg_dynamic_s16(_val, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
 #define side_arg_dynamic_s32_le(_val, _attr)                   _side_arg_dynamic_s32(_val, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
 #define side_arg_dynamic_s64_le(_val, _attr)                   _side_arg_dynamic_s64(_val, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
+#define side_arg_dynamic_pointer_le(_val, _attr)               _side_arg_dynamic_pointer(_val, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
 #define side_arg_dynamic_float_binary16_le(_val, _attr)                _side_arg_dynamic_float_binary16(_val, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
 #define side_arg_dynamic_float_binary32_le(_val, _attr)                _side_arg_dynamic_float_binary32(_val, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
 #define side_arg_dynamic_float_binary64_le(_val, _attr)                _side_arg_dynamic_float_binary64(_val, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
@@ -1015,6 +1049,7 @@ struct side_tracer_dynamic_vla_visitor_ctx {
 #define side_arg_dynamic_s16_be(_val, _attr)                   _side_arg_dynamic_s16(_val, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
 #define side_arg_dynamic_s32_be(_val, _attr)                   _side_arg_dynamic_s32(_val, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
 #define side_arg_dynamic_s64_be(_val, _attr)                   _side_arg_dynamic_s64(_val, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
+#define side_arg_dynamic_pointer_be(_val, _attr)               _side_arg_dynamic_pointer(_val, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
 #define side_arg_dynamic_float_binary16_be(_val, _attr)                _side_arg_dynamic_float_binary16(_val, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
 #define side_arg_dynamic_float_binary32_be(_val, _attr)                _side_arg_dynamic_float_binary32(_val, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
 #define side_arg_dynamic_float_binary64_be(_val, _attr)                _side_arg_dynamic_float_binary64(_val, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))

diff --git a/src/test.c b/src/test.c
index 959959a494a35117a534b366e6d2e2bfd5767712..68d2d8088ee0530eecd0cb66ceb4e3eed49d3af3 100644 (file)
--- a/src/test.c
+++ b/src/test.c
@@ -18,6 +18,7 @@ side_static_event(my_provider_event, "myprovider", "myevent", SIDE_LOGLEVEL_DEBU
        side_field_list(
                side_field_u32("abc", side_attr_list()),
                side_field_s64("def", side_attr_list()),
+               side_field_pointer("ptr", side_attr_list()),
                side_field_dynamic("dynamic", side_attr_list()),
        ),
        side_attr_list()
@@ -29,8 +30,14 @@ void test_fields(void)
        uint32_t uw = 42;
        int64_t sdw = -500;
 
-       side_event(my_provider_event, side_arg_list(side_arg_u32(uw), side_arg_s64(sdw),
-               side_arg_dynamic(side_arg_dynamic_string("zzz", side_attr_list()))));
+       side_event(my_provider_event,
+               side_arg_list(
+                       side_arg_u32(uw),
+                       side_arg_s64(sdw),
+                       side_arg_pointer((void *) 0x1),
+                       side_arg_dynamic(side_arg_dynamic_string("zzz", side_attr_list())),
+               )
+       );
 }
 
 side_hidden_event(my_provider_event_hidden, "myprovider", "myeventhidden", SIDE_LOGLEVEL_DEBUG,

diff --git a/src/tracer.c b/src/tracer.c
index 7d52be34d9c5da1363e2bc1b5cd218991e1192bf..7afef3594949d2337e4ded6ecd1739922fd20d03 100644 (file)
--- a/src/tracer.c
+++ b/src/tracer.c
@@ -44,6 +44,7 @@ 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:
+        case SIDE_TYPE_POINTER:
                if (type_desc->u.side_basic.byte_order != SIDE_TYPE_BYTE_ORDER_HOST)
                        return true;
                else
@@ -78,6 +79,7 @@ bool dynamic_type_to_host_reverse_bo(const struct side_arg_dynamic_vec *item)
         case SIDE_DYNAMIC_TYPE_S16:
         case SIDE_DYNAMIC_TYPE_S32:
         case SIDE_DYNAMIC_TYPE_S64:
+        case SIDE_DYNAMIC_TYPE_POINTER:
                if (item->u.side_basic.byte_order != SIDE_TYPE_BYTE_ORDER_HOST)
                        return true;
                else
@@ -130,6 +132,9 @@ void tracer_print_attr_type(const char *separator, const struct side_attr *attr)
        case SIDE_ATTR_TYPE_S64:
                printf("%" PRId64, attr->value.u.side_s64);
                break;
+       case SIDE_ATTR_TYPE_POINTER:
+               printf("0x%" PRIxPTR, attr->value.u.side_pointer);
+               break;
        case SIDE_ATTR_TYPE_FLOAT_BINARY16:
 #if __HAVE_FLOAT16
                printf("%g", (double) attr->value.u.side_float_binary16);
@@ -456,6 +461,7 @@ void tracer_print_type(const struct side_type_description *type_desc, const stru
                case SIDE_TYPE_ARRAY_S16:
                case SIDE_TYPE_ARRAY_S32:
                case SIDE_TYPE_ARRAY_S64:
+               case SIDE_TYPE_ARRAY_POINTER:
                case SIDE_TYPE_ARRAY_BYTE:
                case SIDE_TYPE_ARRAY:
                        break;
@@ -477,6 +483,7 @@ void tracer_print_type(const struct side_type_description *type_desc, const stru
                case SIDE_TYPE_VLA_S32:
                case SIDE_TYPE_VLA_S64:
                case SIDE_TYPE_VLA_BYTE:
+               case SIDE_TYPE_VLA_POINTER:
                case SIDE_TYPE_VLA:
                        break;
                default:
@@ -614,6 +621,17 @@ void tracer_print_type(const struct side_type_description *type_desc, const stru
                printf("%" PRId64, v);
                break;
        }
+       case SIDE_TYPE_POINTER:
+       {
+               uintptr_t v;
+
+               v = item->u.side_pointer;
+               if (type_to_host_reverse_bo(type_desc))
+                       v = side_bswap_pointer(v);
+               tracer_print_basic_type_header(type_desc);
+               printf("0x%" PRIxPTR, v);
+               break;
+       }
        case SIDE_TYPE_BYTE:
                tracer_print_basic_type_header(type_desc);
                printf("0x%" PRIx8, item->u.side_byte);
@@ -732,6 +750,7 @@ void tracer_print_type(const struct side_type_description *type_desc, const stru
        case SIDE_TYPE_ARRAY_S32:
        case SIDE_TYPE_ARRAY_S64:
        case SIDE_TYPE_ARRAY_BYTE:
+       case SIDE_TYPE_ARRAY_POINTER:
                tracer_print_array_fixint(type_desc, item);
                break;
        case SIDE_TYPE_VLA_U8:
@@ -743,6 +762,7 @@ void tracer_print_type(const struct side_type_description *type_desc, const stru
        case SIDE_TYPE_VLA_S32:
        case SIDE_TYPE_VLA_S64:
        case SIDE_TYPE_VLA_BYTE:
+       case SIDE_TYPE_VLA_POINTER:
                tracer_print_vla_fixint(type_desc, item);
                break;
        case SIDE_TYPE_DYNAMIC:
@@ -916,6 +936,10 @@ void tracer_print_array_fixint(const struct side_type_description *type_desc, co
                if (elem_type->type != SIDE_TYPE_BYTE)
                        goto type_error;
                break;
+       case SIDE_TYPE_ARRAY_POINTER:
+               if (elem_type->type != SIDE_TYPE_POINTER)
+                       goto type_error;
+               break;
        default:
                goto type_error;
        }
@@ -955,6 +979,9 @@ void tracer_print_array_fixint(const struct side_type_description *type_desc, co
                case SIDE_TYPE_BYTE:
                        sav_elem.u.side_byte = ((const uint8_t *) p)[i];
                        break;
+               case SIDE_TYPE_POINTER:
+                       sav_elem.u.side_pointer = ((const uintptr_t *) p)[i];
+                       break;
 
                default:
                        fprintf(stderr, "ERROR: Unexpected type\n");
@@ -1020,6 +1047,10 @@ void tracer_print_vla_fixint(const struct side_type_description *type_desc, cons
                if (elem_type->type != SIDE_TYPE_BYTE)
                        goto type_error;
                break;
+       case SIDE_TYPE_VLA_POINTER:
+               if (elem_type->type != SIDE_TYPE_POINTER)
+                       goto type_error;
+               break;
        default:
                goto type_error;
        }
@@ -1059,6 +1090,9 @@ void tracer_print_vla_fixint(const struct side_type_description *type_desc, cons
                case SIDE_TYPE_BYTE:
                        sav_elem.u.side_byte = ((const uint8_t *) p)[i];
                        break;
+               case SIDE_TYPE_POINTER:
+                       sav_elem.u.side_pointer = ((const uintptr_t *) p)[i];
+                       break;
 
                default:
                        fprintf(stderr, "ERROR: Unexpected type\n");
@@ -1301,6 +1335,17 @@ void tracer_print_dynamic(const struct side_arg_dynamic_vec *item)
                tracer_print_dynamic_basic_type_header(item);
                printf("0x%" PRIx8, item->u.side_basic.u.side_byte);
                break;
+       case SIDE_DYNAMIC_TYPE_POINTER:
+       {
+               uintptr_t v;
+
+               v = item->u.side_basic.u.side_pointer;
+               if (dynamic_type_to_host_reverse_bo(item))
+                       v = side_bswap_pointer(v);
+               tracer_print_dynamic_basic_type_header(item);
+               printf("0x%" PRIxPTR, v);
+               break;
+       }
 
        case SIDE_DYNAMIC_TYPE_FLOAT_BINARY16:
        {