Move attributes to specific types

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

diff --git a/include/side/trace.h b/include/side/trace.h
index 439159979a279736c7d8b6918e7ec9c4a5c40d45..a50f9f976183d07c1fd03f19417a62bb51b8da16 100644 (file)
--- a/include/side/trace.h
+++ b/include/side/trace.h
@@ -213,7 +213,9 @@ struct side_enum_mapping {
 
 struct side_enum_mappings {
        const struct side_enum_mapping *mappings;
+       const struct side_attr *attr;
        uint32_t nr_mappings;
+       uint32_t nr_attr;
 };
 
 struct side_enum_bitmap_mapping {
@@ -224,7 +226,9 @@ struct side_enum_bitmap_mapping {
 
 struct side_enum_bitmap_mappings {
        const struct side_enum_bitmap_mapping *mappings;
+       const struct side_attr *attr;
        uint32_t nr_mappings;
+       uint32_t nr_attr;
 };
 
 struct side_type_struct {
@@ -236,21 +240,29 @@ struct side_type_struct {
 
 struct side_type_description {
        uint32_t type;  /* enum side_type */
-       uint32_t nr_attr;
-       const struct side_attr *attr;
        union {
-               const struct side_type_struct *side_struct;
                struct {
-                       uint32_t length;
+                       const struct side_attr *attr;
+                       uint32_t nr_attr;
+               } side_basic;
+               struct {
                        const struct side_type_description *elem_type;
+                       const struct side_attr *attr;
+                       uint32_t length;
+                       uint32_t nr_attr;
                } side_array;
                struct {
                        const struct side_type_description *elem_type;
+                       const struct side_attr *attr;
+                       uint32_t nr_attr;
                } side_vla;
                struct {
                        const struct side_type_description *elem_type;
                        side_visitor visitor;
+                       const struct side_attr *attr;
+                       uint32_t nr_attr;
                } side_vla_visitor;
+               const struct side_type_struct *side_struct;
                const struct side_enum_mappings *side_enum_mappings;
                const struct side_enum_bitmap_mappings *side_enum_bitmap_mappings;
        } u;
@@ -439,29 +451,33 @@ struct side_tracer_dynamic_vla_visitor_ctx {
 #define side_attr_list(...) \
        SIDE_COMPOUND_LITERAL(const struct side_attr, __VA_ARGS__)
 
-#define _side_type(_type, _attr) \
+#define _side_type_basic(_type, _attr) \
        { \
                .type = _type, \
-               .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
-               .attr = _attr, \
+               .u = { \
+                       .side_basic = { \
+                               .attr = _attr, \
+                               .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
+                       }, \
+               }, \
        }
 
-#define side_type_bool(_attr)                          _side_type(SIDE_TYPE_BOOL, SIDE_PARAM(_attr))
-#define side_type_u8(_attr)                            _side_type(SIDE_TYPE_U8, SIDE_PARAM(_attr))
-#define side_type_u16(_attr)                           _side_type(SIDE_TYPE_U16, SIDE_PARAM(_attr))
-#define side_type_u32(_attr)                           _side_type(SIDE_TYPE_U32, SIDE_PARAM(_attr))
-#define side_type_u64(_attr)                           _side_type(SIDE_TYPE_U64, SIDE_PARAM(_attr))
-#define side_type_s8(_attr)                            _side_type(SIDE_TYPE_S8, SIDE_PARAM(_attr))
-#define side_type_s16(_attr)                           _side_type(SIDE_TYPE_S16, SIDE_PARAM(_attr))
-#define side_type_s32(_attr)                           _side_type(SIDE_TYPE_S32, SIDE_PARAM(_attr))
-#define side_type_s64(_attr)                           _side_type(SIDE_TYPE_S64, SIDE_PARAM(_attr))
-#define side_type_blob(_attr)                          _side_type(SIDE_TYPE_BLOB, SIDE_PARAM(_attr))
-#define side_type_float_binary16(_attr)                        _side_type(SIDE_TYPE_FLOAT_BINARY16, SIDE_PARAM(_attr))
-#define side_type_float_binary32(_attr)                        _side_type(SIDE_TYPE_FLOAT_BINARY32, SIDE_PARAM(_attr))
-#define side_type_float_binary64(_attr)                        _side_type(SIDE_TYPE_FLOAT_BINARY64, SIDE_PARAM(_attr))
-#define side_type_float_binary128(_attr)               _side_type(SIDE_TYPE_FLOAT_BINARY128, SIDE_PARAM(_attr))
-#define side_type_string(_attr)                                _side_type(SIDE_TYPE_STRING, SIDE_PARAM(_attr))
-#define side_type_dynamic(_attr)                       _side_type(SIDE_TYPE_DYNAMIC, SIDE_PARAM(_attr))
+#define side_type_bool(_attr)                          _side_type_basic(SIDE_TYPE_BOOL, SIDE_PARAM(_attr))
+#define side_type_u8(_attr)                            _side_type_basic(SIDE_TYPE_U8, SIDE_PARAM(_attr))
+#define side_type_u16(_attr)                           _side_type_basic(SIDE_TYPE_U16, SIDE_PARAM(_attr))
+#define side_type_u32(_attr)                           _side_type_basic(SIDE_TYPE_U32, SIDE_PARAM(_attr))
+#define side_type_u64(_attr)                           _side_type_basic(SIDE_TYPE_U64, SIDE_PARAM(_attr))
+#define side_type_s8(_attr)                            _side_type_basic(SIDE_TYPE_S8, SIDE_PARAM(_attr))
+#define side_type_s16(_attr)                           _side_type_basic(SIDE_TYPE_S16, SIDE_PARAM(_attr))
+#define side_type_s32(_attr)                           _side_type_basic(SIDE_TYPE_S32, SIDE_PARAM(_attr))
+#define side_type_s64(_attr)                           _side_type_basic(SIDE_TYPE_S64, SIDE_PARAM(_attr))
+#define side_type_blob(_attr)                          _side_type_basic(SIDE_TYPE_BLOB, SIDE_PARAM(_attr))
+#define side_type_float_binary16(_attr)                        _side_type_basic(SIDE_TYPE_FLOAT_BINARY16, SIDE_PARAM(_attr))
+#define side_type_float_binary32(_attr)                        _side_type_basic(SIDE_TYPE_FLOAT_BINARY32, SIDE_PARAM(_attr))
+#define side_type_float_binary64(_attr)                        _side_type_basic(SIDE_TYPE_FLOAT_BINARY64, SIDE_PARAM(_attr))
+#define side_type_float_binary128(_attr)               _side_type_basic(SIDE_TYPE_FLOAT_BINARY128, SIDE_PARAM(_attr))
+#define side_type_string(_attr)                                _side_type_basic(SIDE_TYPE_STRING, SIDE_PARAM(_attr))
+#define side_type_dynamic(_attr)                       _side_type_basic(SIDE_TYPE_DYNAMIC, SIDE_PARAM(_attr))
 
 #define _side_field(_name, _type) \
        { \
@@ -486,61 +502,55 @@ struct side_tracer_dynamic_vla_visitor_ctx {
 #define side_field_string(_name, _attr)                        _side_field(_name, side_type_string(SIDE_PARAM(_attr)))
 #define side_field_dynamic(_name, _attr)               _side_field(_name, side_type_dynamic(SIDE_PARAM(_attr)))
 
-#define side_type_enum(_type, _mappings, _attr) \
+#define side_type_enum(_type, _mappings) \
        { \
                .type = _type, \
-               .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
-               .attr = _attr, \
                .u = { \
                        .side_enum_mappings = _mappings, \
                }, \
        }
-#define _side_field_enum(_name, _type, _mappings, _attr) \
-       _side_field(_name, side_type_enum(_type, SIDE_PARAM(_mappings), SIDE_PARAM(_attr)))
-
-#define side_field_enum_u8(_name, _mappings, _attr) \
-       _side_field_enum(_name, SIDE_TYPE_ENUM_U8, SIDE_PARAM(_mappings), SIDE_PARAM(_attr))
-#define side_field_enum_u16(_name, _mappings, _attr) \
-       _side_field_enum(_name, SIDE_TYPE_ENUM_U16, SIDE_PARAM(_mappings), SIDE_PARAM(_attr))
-#define side_field_enum_u32(_name, _mappings, _attr) \
-       _side_field_enum(_name, SIDE_TYPE_ENUM_U32, SIDE_PARAM(_mappings), SIDE_PARAM(_attr))
-#define side_field_enum_u64(_name, _mappings, _attr) \
-       _side_field_enum(_name, SIDE_TYPE_ENUM_U64, SIDE_PARAM(_mappings), SIDE_PARAM(_attr))
-#define side_field_enum_s8(_name, _mappings, _attr) \
-       _side_field_enum(_name, SIDE_TYPE_ENUM_S8, SIDE_PARAM(_mappings), SIDE_PARAM(_attr))
-#define side_field_enum_s16(_name, _mappings, _attr) \
-       _side_field_enum(_name, SIDE_TYPE_ENUM_S16, SIDE_PARAM(_mappings), SIDE_PARAM(_attr))
-#define side_field_enum_s32(_name, _mappings, _attr) \
-       _side_field_enum(_name, SIDE_TYPE_ENUM_S32, SIDE_PARAM(_mappings), SIDE_PARAM(_attr))
-#define side_field_enum_s64(_name, _mappings, _attr) \
-       _side_field_enum(_name, SIDE_TYPE_ENUM_S64, SIDE_PARAM(_mappings), SIDE_PARAM(_attr))
-
-#define side_type_enum_bitmap(_type, _mappings, _attr) \
+#define _side_field_enum(_name, _type, _mappings) \
+       _side_field(_name, side_type_enum(_type, SIDE_PARAM(_mappings)))
+
+#define side_field_enum_u8(_name, _mappings) \
+       _side_field_enum(_name, SIDE_TYPE_ENUM_U8, SIDE_PARAM(_mappings))
+#define side_field_enum_u16(_name, _mappings) \
+       _side_field_enum(_name, SIDE_TYPE_ENUM_U16, SIDE_PARAM(_mappings))
+#define side_field_enum_u32(_name, _mappings) \
+       _side_field_enum(_name, SIDE_TYPE_ENUM_U32, SIDE_PARAM(_mappings))
+#define side_field_enum_u64(_name, _mappings) \
+       _side_field_enum(_name, SIDE_TYPE_ENUM_U64, SIDE_PARAM(_mappings))
+#define side_field_enum_s8(_name, _mappings) \
+       _side_field_enum(_name, SIDE_TYPE_ENUM_S8, SIDE_PARAM(_mappings))
+#define side_field_enum_s16(_name, _mappings) \
+       _side_field_enum(_name, SIDE_TYPE_ENUM_S16, SIDE_PARAM(_mappings))
+#define side_field_enum_s32(_name, _mappings) \
+       _side_field_enum(_name, SIDE_TYPE_ENUM_S32, SIDE_PARAM(_mappings))
+#define side_field_enum_s64(_name, _mappings) \
+       _side_field_enum(_name, SIDE_TYPE_ENUM_S64, SIDE_PARAM(_mappings))
+
+#define side_type_enum_bitmap(_type, _mappings) \
        { \
                .type = _type, \
-               .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
-               .attr = _attr, \
                .u = { \
                        .side_enum_bitmap_mappings = _mappings, \
                }, \
        }
-#define _side_field_enum_bitmap(_name, _type, _mappings, _attr) \
-       _side_field(_name, side_type_enum_bitmap(_type, SIDE_PARAM(_mappings), SIDE_PARAM(_attr)))
-
-#define side_field_enum_bitmap8(_name, _mappings, _attr) \
-       _side_field_enum_bitmap(_name, SIDE_TYPE_ENUM_BITMAP8, SIDE_PARAM(_mappings), SIDE_PARAM(_attr))
-#define side_field_enum_bitmap16(_name, _mappings, _attr) \
-       _side_field_enum_bitmap(_name, SIDE_TYPE_ENUM_BITMAP16, SIDE_PARAM(_mappings), SIDE_PARAM(_attr))
-#define side_field_enum_bitmap32(_name, _mappings, _attr) \
-       _side_field_enum_bitmap(_name, SIDE_TYPE_ENUM_BITMAP32, SIDE_PARAM(_mappings), SIDE_PARAM(_attr))
-#define side_field_enum_bitmap64(_name, _mappings, _attr) \
-       _side_field_enum_bitmap(_name, SIDE_TYPE_ENUM_BITMAP64, SIDE_PARAM(_mappings), SIDE_PARAM(_attr))
+#define _side_field_enum_bitmap(_name, _type, _mappings) \
+       _side_field(_name, side_type_enum_bitmap(_type, SIDE_PARAM(_mappings)))
+
+#define side_field_enum_bitmap8(_name, _mappings) \
+       _side_field_enum_bitmap(_name, SIDE_TYPE_ENUM_BITMAP8, SIDE_PARAM(_mappings))
+#define side_field_enum_bitmap16(_name, _mappings) \
+       _side_field_enum_bitmap(_name, SIDE_TYPE_ENUM_BITMAP16, SIDE_PARAM(_mappings))
+#define side_field_enum_bitmap32(_name, _mappings) \
+       _side_field_enum_bitmap(_name, SIDE_TYPE_ENUM_BITMAP32, SIDE_PARAM(_mappings))
+#define side_field_enum_bitmap64(_name, _mappings) \
+       _side_field_enum_bitmap(_name, SIDE_TYPE_ENUM_BITMAP64, SIDE_PARAM(_mappings))
 
 #define side_type_struct(_struct) \
        { \
                .type = SIDE_TYPE_STRUCT, \
-               .nr_attr = 0, \
-               .attr = NULL, \
                .u = { \
                        .side_struct = _struct, \
                }, \
@@ -566,12 +576,12 @@ struct side_tracer_dynamic_vla_visitor_ctx {
 #define side_type_array(_elem_type, _length, _attr) \
        { \
                .type = SIDE_TYPE_ARRAY, \
-               .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
-               .attr = _attr, \
                .u = { \
                        .side_array = { \
-                               .length = _length, \
                                .elem_type = _elem_type, \
+                               .attr = _attr, \
+                               .length = _length, \
+                               .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
                        }, \
                }, \
        }
@@ -581,11 +591,11 @@ struct side_tracer_dynamic_vla_visitor_ctx {
 #define side_type_vla(_elem_type, _attr) \
        { \
                .type = SIDE_TYPE_VLA, \
-               .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
-               .attr = _attr, \
                .u = { \
                        .side_vla = { \
                                .elem_type = _elem_type, \
+                               .attr = _attr, \
+                               .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
                        }, \
                }, \
        }
@@ -595,12 +605,12 @@ struct side_tracer_dynamic_vla_visitor_ctx {
 #define side_type_vla_visitor(_elem_type, _visitor, _attr) \
        { \
                .type = SIDE_TYPE_VLA_VISITOR, \
-               .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
-               .attr = _attr, \
                .u = { \
                        .side_vla_visitor = { \
                                .elem_type = SIDE_PARAM(_elem_type), \
                                .visitor = _visitor, \
+                               .attr = _attr, \
+                               .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
                        }, \
                }, \
        }
@@ -946,10 +956,12 @@ struct side_tracer_dynamic_vla_visitor_ctx {
        side_event_cond(_desc) \
                side_event_call_variadic(_desc, SIDE_PARAM(_sav), SIDE_PARAM(_var))
 
-#define side_define_enum(_identifier, _mappings) \
+#define side_define_enum(_identifier, _mappings, _attr) \
        const struct side_enum_mappings _identifier = { \
                .mappings = _mappings, \
+               .attr = _attr, \
                .nr_mappings = SIDE_ARRAY_SIZE(SIDE_PARAM(_mappings)), \
+               .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
        }
 
 #define side_enum_mapping_list(...) \
@@ -969,10 +981,12 @@ struct side_tracer_dynamic_vla_visitor_ctx {
                .label = _label, \
        }
 
-#define side_define_enum_bitmap(_identifier, _mappings) \
+#define side_define_enum_bitmap(_identifier, _mappings, _attr) \
        const struct side_enum_bitmap_mappings _identifier = { \
                .mappings = _mappings, \
+               .attr = _attr, \
                .nr_mappings = SIDE_ARRAY_SIZE(SIDE_PARAM(_mappings)), \
+               .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
        }
 
 #define side_enum_bitmap_mapping_list(...) \

diff --git a/src/test.c b/src/test.c
index e8abc9ad9ff27722e4ecdc864ff359badaff4894..2e9484ddae85b06c73c72597bafd44029f1710d6 100644 (file)
--- a/src/test.c
+++ b/src/test.c
@@ -957,15 +957,16 @@ static side_define_enum(myenum,
                side_enum_mapping_range("100-200", 100, 200),
                side_enum_mapping_value("200", 200),
                side_enum_mapping_value("300", 300),
-       )
+       ),
+       side_attr_list()
 );
 
 static side_define_event(my_provider_event_enum, "myprovider", "myeventenum", SIDE_LOGLEVEL_DEBUG,
        side_field_list(
-               side_field_enum_u32("5", &myenum, side_attr_list()),
-               side_field_enum_u64("400", &myenum, side_attr_list()),
-               side_field_enum_u8("200", &myenum, side_attr_list()),
-               side_field_enum_s8("-100", &myenum, side_attr_list()),
+               side_field_enum_u32("5", &myenum),
+               side_field_enum_u64("400", &myenum),
+               side_field_enum_u8("200", &myenum),
+               side_field_enum_s8("-100", &myenum),
        ),
        side_attr_list()
 );
@@ -993,19 +994,20 @@ static side_define_enum_bitmap(myenum_bitmap,
                side_enum_bitmap_mapping_value("3", 3),
                side_enum_bitmap_mapping_value("30", 30),
                side_enum_bitmap_mapping_value("63", 63),
-       )
+       ),
+       side_attr_list()
 );
 
 static side_define_event(my_provider_event_enum_bitmap, "myprovider", "myeventenumbitmap", SIDE_LOGLEVEL_DEBUG,
        side_field_list(
-               side_field_enum_bitmap32("bit_0", &myenum_bitmap, side_attr_list()),
-               side_field_enum_bitmap32("bit_1", &myenum_bitmap, side_attr_list()),
-               side_field_enum_bitmap8("bit_2", &myenum_bitmap, side_attr_list()),
-               side_field_enum_bitmap8("bit_3", &myenum_bitmap, side_attr_list()),
-               side_field_enum_bitmap32("bit_30", &myenum_bitmap, side_attr_list()),
-               side_field_enum_bitmap32("bit_31", &myenum_bitmap, side_attr_list()),
-               side_field_enum_bitmap64("bit_63", &myenum_bitmap, side_attr_list()),
-               side_field_enum_bitmap64("bits_1+63", &myenum_bitmap, side_attr_list()),
+               side_field_enum_bitmap32("bit_0", &myenum_bitmap),
+               side_field_enum_bitmap32("bit_1", &myenum_bitmap),
+               side_field_enum_bitmap8("bit_2", &myenum_bitmap),
+               side_field_enum_bitmap8("bit_3", &myenum_bitmap),
+               side_field_enum_bitmap32("bit_30", &myenum_bitmap),
+               side_field_enum_bitmap32("bit_31", &myenum_bitmap),
+               side_field_enum_bitmap64("bit_63", &myenum_bitmap),
+               side_field_enum_bitmap64("bits_1+63", &myenum_bitmap),
        ),
        side_attr_list()
 );

diff --git a/src/tracer.c b/src/tracer.c
index afbabd028161b02bc5f7920188850ef7bc3d72d0..3d73620d79e8c99b0f57dece83d5efbc8b0d9cf0 100644 (file)
--- a/src/tracer.c
+++ b/src/tracer.c
@@ -120,6 +120,8 @@ void print_enum(const struct side_enum_mappings *side_enum_mappings, int64_t val
 {
        int i, print_count = 0;
 
+       print_attributes("attr: ", side_enum_mappings->attr, side_enum_mappings->nr_attr);
+       printf("%s", side_enum_mappings->nr_attr ? ", " : "");
        printf("value: %" PRId64 ", labels: [ ", value);
        for (i = 0; i < side_enum_mappings->nr_mappings; i++) {
                const struct side_enum_mapping *mapping = &side_enum_mappings->mappings[i];
@@ -144,6 +146,8 @@ void print_enum_bitmap(const struct side_enum_bitmap_mappings *side_enum_mapping
 {
        int i, print_count = 0;
 
+       print_attributes("attr: ", side_enum_mappings->attr, side_enum_mappings->nr_attr);
+       printf("%s", side_enum_mappings->nr_attr ? ", " : "");
        printf("value: 0x%" PRIx64 ", labels: [ ", value);
        for (i = 0; i < side_enum_mappings->nr_mappings; i++) {
                const struct side_enum_bitmap_mapping *mapping = &side_enum_mappings->mappings[i];
@@ -213,46 +217,64 @@ void tracer_print_type(const struct side_type_description *type_desc, const stru
                break;
        }
        printf("{ ");
-       print_attributes("attr: ", type_desc->attr, type_desc->nr_attr);
-       printf("%s", type_desc->nr_attr ? ", " : "");
        switch (item->type) {
        case SIDE_TYPE_BOOL:
+               print_attributes("attr: ", type_desc->u.side_basic.attr, type_desc->u.side_basic.nr_attr);
+               printf("%s", type_desc->u.side_basic.nr_attr ? ", " : "");
                printf("value: ");
                printf("%s", item->u.side_bool ? "true" : "false");
                break;
        case SIDE_TYPE_U8:
+               print_attributes("attr: ", type_desc->u.side_basic.attr, type_desc->u.side_basic.nr_attr);
+               printf("%s", type_desc->u.side_basic.nr_attr ? ", " : "");
                printf("value: ");
                printf("%" PRIu8, item->u.side_u8);
                break;
        case SIDE_TYPE_U16:
+               print_attributes("attr: ", type_desc->u.side_basic.attr, type_desc->u.side_basic.nr_attr);
+               printf("%s", type_desc->u.side_basic.nr_attr ? ", " : "");
                printf("value: ");
                printf("%" PRIu16, item->u.side_u16);
                break;
        case SIDE_TYPE_U32:
+               print_attributes("attr: ", type_desc->u.side_basic.attr, type_desc->u.side_basic.nr_attr);
+               printf("%s", type_desc->u.side_basic.nr_attr ? ", " : "");
                printf("value: ");
                printf("%" PRIu32, item->u.side_u32);
                break;
        case SIDE_TYPE_U64:
+               print_attributes("attr: ", type_desc->u.side_basic.attr, type_desc->u.side_basic.nr_attr);
+               printf("%s", type_desc->u.side_basic.nr_attr ? ", " : "");
                printf("value: ");
                printf("%" PRIu64, item->u.side_u64);
                break;
        case SIDE_TYPE_S8:
+               print_attributes("attr: ", type_desc->u.side_basic.attr, type_desc->u.side_basic.nr_attr);
+               printf("%s", type_desc->u.side_basic.nr_attr ? ", " : "");
                printf("value: ");
                printf("%" PRId8, item->u.side_s8);
                break;
        case SIDE_TYPE_S16:
+               print_attributes("attr: ", type_desc->u.side_basic.attr, type_desc->u.side_basic.nr_attr);
+               printf("%s", type_desc->u.side_basic.nr_attr ? ", " : "");
                printf("value: ");
                printf("%" PRId16, item->u.side_s16);
                break;
        case SIDE_TYPE_S32:
+               print_attributes("attr: ", type_desc->u.side_basic.attr, type_desc->u.side_basic.nr_attr);
+               printf("%s", type_desc->u.side_basic.nr_attr ? ", " : "");
                printf("value: ");
                printf("%" PRId32, item->u.side_s32);
                break;
        case SIDE_TYPE_S64:
+               print_attributes("attr: ", type_desc->u.side_basic.attr, type_desc->u.side_basic.nr_attr);
+               printf("%s", type_desc->u.side_basic.nr_attr ? ", " : "");
                printf("value: ");
                printf("%" PRId64, item->u.side_s64);
                break;
        case SIDE_TYPE_BLOB:
+               print_attributes("attr: ", type_desc->u.side_basic.attr, type_desc->u.side_basic.nr_attr);
+               printf("%s", type_desc->u.side_basic.nr_attr ? ", " : "");
                printf("value: ");
                printf("0x%" PRIx8, item->u.side_blob);
                break;
@@ -308,6 +330,8 @@ void tracer_print_type(const struct side_type_description *type_desc, const stru
                break;
 
        case SIDE_TYPE_FLOAT_BINARY16:
+               print_attributes("attr: ", type_desc->u.side_basic.attr, type_desc->u.side_basic.nr_attr);
+               printf("%s", type_desc->u.side_basic.nr_attr ? ", " : "");
                printf("value: ");
 #if __HAVE_FLOAT16
                printf("%g", (double) item->u.side_float_binary16);
@@ -317,6 +341,8 @@ void tracer_print_type(const struct side_type_description *type_desc, const stru
                abort();
 #endif
        case SIDE_TYPE_FLOAT_BINARY32:
+               print_attributes("attr: ", type_desc->u.side_basic.attr, type_desc->u.side_basic.nr_attr);
+               printf("%s", type_desc->u.side_basic.nr_attr ? ", " : "");
                printf("value: ");
 #if __HAVE_FLOAT32
                printf("%g", (double) item->u.side_float_binary32);
@@ -326,6 +352,8 @@ void tracer_print_type(const struct side_type_description *type_desc, const stru
                abort();
 #endif
        case SIDE_TYPE_FLOAT_BINARY64:
+               print_attributes("attr: ", type_desc->u.side_basic.attr, type_desc->u.side_basic.nr_attr);
+               printf("%s", type_desc->u.side_basic.nr_attr ? ", " : "");
                printf("value: ");
 #if __HAVE_FLOAT64
                printf("%g", (double) item->u.side_float_binary64);
@@ -335,6 +363,8 @@ void tracer_print_type(const struct side_type_description *type_desc, const stru
                abort();
 #endif
        case SIDE_TYPE_FLOAT_BINARY128:
+               print_attributes("attr: ", type_desc->u.side_basic.attr, type_desc->u.side_basic.nr_attr);
+               printf("%s", type_desc->u.side_basic.nr_attr ? ", " : "");
                printf("value: ");
 #if __HAVE_FLOAT128
                printf("%Lg", (long double) item->u.side_float_binary128);
@@ -344,6 +374,8 @@ void tracer_print_type(const struct side_type_description *type_desc, const stru
                abort();
 #endif
        case SIDE_TYPE_STRING:
+               print_attributes("attr: ", type_desc->u.side_basic.attr, type_desc->u.side_basic.nr_attr);
+               printf("%s", type_desc->u.side_basic.nr_attr ? ", " : "");
                printf("value: ");
                printf("\"%s\"", item->u.string);
                break;
@@ -382,6 +414,8 @@ void tracer_print_type(const struct side_type_description *type_desc, const stru
                tracer_print_vla_fixint(type_desc, item);
                break;
        case SIDE_TYPE_DYNAMIC:
+               print_attributes("attr: ", type_desc->u.side_basic.attr, type_desc->u.side_basic.nr_attr);
+               printf("%s", type_desc->u.side_basic.nr_attr ? ", " : "");
                printf("element: ");
                tracer_print_dynamic(&item->u.dynamic);
                break;
@@ -410,7 +444,6 @@ void tracer_print_struct(const struct side_type_description *type_desc, const st
                printf("ERROR: number of fields mismatch between description and arguments of structure\n");
                abort();
        }
-       printf("{ ");
        print_attributes("attr: ", type_desc->u.side_struct->attr, type_desc->u.side_struct->nr_attr);
        printf("%s", type_desc->u.side_struct->nr_attr ? ", " : "");
        printf("fields: { ");
@@ -418,7 +451,7 @@ void tracer_print_struct(const struct side_type_description *type_desc, const st
                printf("%s", i ? ", " : "");
                tracer_print_field(&type_desc->u.side_struct->fields[i], &sav[i]);
        }
-       printf(" } }");
+       printf(" }");
 }
 
 static
@@ -432,6 +465,8 @@ void tracer_print_array(const struct side_type_description *type_desc, const str
                printf("ERROR: length mismatch between description and arguments of array\n");
                abort();
        }
+       print_attributes("attr: ", type_desc->u.side_array.attr, type_desc->u.side_array.nr_attr);
+       printf("%s", type_desc->u.side_array.nr_attr ? ", " : "");
        printf("elements: ");
        printf("[ ");
        for (i = 0; i < side_sav_len; i++) {
@@ -448,6 +483,8 @@ void tracer_print_vla(const struct side_type_description *type_desc, const struc
        uint32_t side_sav_len = sav_desc->len;
        int i;
 
+       print_attributes("attr: ", type_desc->u.side_vla.attr, type_desc->u.side_vla.nr_attr);
+       printf("%s", type_desc->u.side_vla.nr_attr ? ", " : "");
        printf("elements: ");
        printf("[ ");
        for (i = 0; i < side_sav_len; i++) {
@@ -486,6 +523,8 @@ void tracer_print_vla_visitor(const struct side_type_description *type_desc, voi
                .priv = &tracer_priv,
        };
 
+       print_attributes("attr: ", type_desc->u.side_vla_visitor.attr, type_desc->u.side_vla_visitor.nr_attr);
+       printf("%s", type_desc->u.side_vla_visitor.nr_attr ? ", " : "");
        printf("elements: ");
        printf("[ ");
        status = type_desc->u.side_vla_visitor.visitor(&tracer_ctx, app_ctx);
@@ -507,6 +546,8 @@ void tracer_print_array_fixint(const struct side_type_description *type_desc, co
        enum side_type side_type;
        int i;
 
+       print_attributes("attr: ", type_desc->u.side_array.attr, type_desc->u.side_array.nr_attr);
+       printf("%s", type_desc->u.side_array.nr_attr ? ", " : "");
        printf("elements: ");
        switch (item->type) {
        case SIDE_TYPE_ARRAY_U8:
@@ -609,6 +650,8 @@ void tracer_print_vla_fixint(const struct side_type_description *type_desc, cons
        enum side_type side_type;
        int i;
 
+       print_attributes("attr: ", type_desc->u.side_vla.attr, type_desc->u.side_vla.nr_attr);
+       printf("%s", type_desc->u.side_vla.nr_attr ? ", " : "");
        printf("elements: ");
        switch (item->type) {
        case SIDE_TYPE_VLA_U8: