Nested scatter-gather array/struct

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

diff --git a/include/side/trace.h b/include/side/trace.h
index 69b165f7496b37965219e7172bb65f530ed7fb65..3f826d0bc84d6eac8a8cddc201ea0ecb7a49124d 100644 (file)
--- a/include/side/trace.h
+++ b/include/side/trace.h
@@ -340,13 +340,24 @@ struct side_type_sg_integer {
        uint16_t offset_bits;           /* bits */
 } SIDE_PACKED;
 
+struct side_type_sg_struct {
+       const struct side_type_struct *type;
+       uint32_t size;                  /* bytes */
+} SIDE_PACKED;
+
+enum side_type_sg_access_mode {
+       SIDE_TYPE_SG_ACCESS_ADDRESS,
+       SIDE_TYPE_SG_ACCESS_POINTER,
+};
+
 struct side_type_sg {
        uint64_t offset;        /* bytes */
+       uint8_t access_mode;    /* enum side_type_sg_access_mode */
        union {
                struct side_type_sg_integer side_integer;
                struct side_type_float side_float;
                struct side_type_array side_array;
-               const struct side_type_struct *side_struct;
+               struct side_type_sg_struct side_struct;
        } SIDE_PACKED u;
 } SIDE_PACKED;
 
@@ -851,12 +862,14 @@ struct side_event_description {
 
 /* Scatter-gather fields */
 
-#define _side_type_sg_integer(_type, _signedness, _byte_order, _offset, _integer_size_bits, _offset_bits, _len_bits, _attr) \
+#define _side_type_sg_integer(_type, _signedness, _byte_order, _offset, \
+               _integer_size_bits, _offset_bits, _len_bits, _access_mode, _attr) \
        { \
                .type = _type, \
                .u = { \
                        .side_sg = { \
                                .offset = _offset, \
+                               .access_mode = _access_mode, \
                                .u = { \
                                        .side_integer = { \
                                                .type = { \
@@ -874,48 +887,49 @@ struct side_event_description {
                }, \
        }
 
-#define side_type_sg_unsigned_integer(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, _attr) \
+#define side_type_sg_unsigned_integer(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, _attr) \
        _side_type_sg_integer(SIDE_TYPE_SG_UNSIGNED_INT, false,  SIDE_TYPE_BYTE_ORDER_HOST, \
-                       _integer_offset, _integer_size_bits, _offset_bits, _len_bits, SIDE_PARAM(_attr))
-#define side_type_sg_signed_integer(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, _attr) \
+                       _integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, SIDE_PARAM(_attr))
+#define side_type_sg_signed_integer(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, _attr) \
        _side_type_sg_integer(SIDE_TYPE_SG_SIGNED_INT, true, SIDE_TYPE_BYTE_ORDER_HOST, \
-                       _integer_offset, _integer_size_bits, _offset_bits, _len_bits, SIDE_PARAM(_attr))
+                       _integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, SIDE_PARAM(_attr))
 
-#define side_type_sg_unsigned_integer_le(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, _attr) \
+#define side_type_sg_unsigned_integer_le(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, _attr) \
        _side_type_sg_integer(SIDE_TYPE_SG_UNSIGNED_INT, false,  SIDE_TYPE_BYTE_ORDER_LE, \
-                       _integer_offset, _integer_size_bits, _offset_bits, _len_bits, SIDE_PARAM(_attr))
-#define side_type_sg_signed_integer_le(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, _attr) \
+                       _integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, SIDE_PARAM(_attr))
+#define side_type_sg_signed_integer_le(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, _attr) \
        _side_type_sg_integer(SIDE_TYPE_SG_SIGNED_INT, true, SIDE_TYPE_BYTE_ORDER_LE, \
-                       _integer_offset, _integer_size_bits, _offset_bits, _len_bits, SIDE_PARAM(_attr))
+                       _integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, SIDE_PARAM(_attr))
 
-#define side_type_sg_unsigned_integer_be(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, _attr) \
+#define side_type_sg_unsigned_integer_be(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, _attr) \
        _side_type_sg_integer(SIDE_TYPE_SG_UNSIGNED_INT, false,  SIDE_TYPE_BYTE_ORDER_BE, \
-                       _integer_offset, _integer_size_bits, _offset_bits, _len_bits, SIDE_PARAM(_attr))
-#define side_type_sg_signed_integer_be(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, _attr) \
+                       _integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, SIDE_PARAM(_attr))
+#define side_type_sg_signed_integer_be(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, _attr) \
        _side_type_sg_integer(SIDE_TYPE_SG_SIGNED_INT, true, SIDE_TYPE_BYTE_ORDER_BE, \
-                       _integer_offset, _integer_size_bits, _offset_bits, _len_bits, SIDE_PARAM(_attr))
+                       _integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, SIDE_PARAM(_attr))
 
-#define side_field_sg_unsigned_integer(_name, _integer_offset, _integer_size_bits, _offset_bits, _len_bits, _attr) \
-       _side_field(_name, side_type_sg_unsigned_integer(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, SIDE_PARAM(_attr)))
-#define side_field_sg_signed_integer(_name, _integer_offset, _integer_size_bits, _offset_bits, _len_bits, _attr) \
-       _side_field(_name, side_type_sg_signed_integer(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, SIDE_PARAM(_attr)))
+#define side_field_sg_unsigned_integer(_name, _integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, _attr) \
+       _side_field(_name, side_type_sg_unsigned_integer(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, SIDE_PARAM(_attr)))
+#define side_field_sg_signed_integer(_name, _integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, _attr) \
+       _side_field(_name, side_type_sg_signed_integer(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, SIDE_PARAM(_attr)))
 
-#define side_field_sg_unsigned_integer_le(_name, _integer_offset, _integer_size_bits, _offset_bits, _len_bits, _attr) \
-       _side_field(_name, side_type_sg_unsigned_integer_le(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, SIDE_PARAM(_attr)))
-#define side_field_sg_signed_integer_le(_name, _integer_offset, _integer_size_bits, _offset_bits, _len_bits, _attr) \
-       _side_field(_name, side_type_sg_signed_integer_le(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, SIDE_PARAM(_attr)))
+#define side_field_sg_unsigned_integer_le(_name, _integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, _attr) \
+       _side_field(_name, side_type_sg_unsigned_integer_le(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, SIDE_PARAM(_attr)))
+#define side_field_sg_signed_integer_le(_name, _integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, _attr) \
+       _side_field(_name, side_type_sg_signed_integer_le(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, SIDE_PARAM(_attr)))
 
-#define side_field_sg_unsigned_integer_be(_name, _integer_offset, _integer_size_bits, _offset_bits, _len_bits, _attr) \
-       _side_field(_name, side_type_sg_unsigned_integer_be(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, SIDE_PARAM(_attr)))
-#define side_field_sg_signed_integer_be(_name, _integer_offset, _integer_size_bits, _offset_bits, _len_bits, _attr) \
-       _side_field(_name, side_type_sg_signed_integer_be(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, SIDE_PARAM(_attr)))
+#define side_field_sg_unsigned_integer_be(_name, _integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, _attr) \
+       _side_field(_name, side_type_sg_unsigned_integer_be(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, SIDE_PARAM(_attr)))
+#define side_field_sg_signed_integer_be(_name, _integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, _attr) \
+       _side_field(_name, side_type_sg_signed_integer_be(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, SIDE_PARAM(_attr)))
 
-#define _side_type_sg_float(_byte_order, _offset, _float_size_bits, _attr) \
+#define _side_type_sg_float(_byte_order, _offset, _float_size_bits, _access_mode, _attr) \
        { \
                .type = SIDE_TYPE_SG_FLOAT, \
                .u = { \
                        .side_sg = { \
                                .offset = _offset, \
+                               .access_mode = _access_mode, \
                                .u = { \
                                        .side_float = { \
                                                .attr = _attr, \
@@ -928,41 +942,46 @@ struct side_event_description {
                }, \
        }
 
-#define side_type_sg_float(_offset, _float_size_bits, _attr) \
-       _side_type_sg_float(SIDE_TYPE_FLOAT_WORD_ORDER_HOST, _offset, _float_size_bits, _attr)
-#define side_type_sg_float_le(_offset, _float_size_bits, _attr) \
-       _side_type_sg_float(SIDE_TYPE_BYTE_ORDER_LE, _offset, _float_size_bits, _attr)
-#define side_type_sg_float_be(_offset, _float_size_bits, _attr) \
-       _side_type_sg_float(SIDE_TYPE_BYTE_ORDER_BE, _offset, _float_size_bits, _attr)
-
-#define side_field_sg_float(_name, _offset, _float_size_bits, _attr) \
-       _side_field(_name, side_type_sg_float(_offset, _float_size_bits, _attr))
-#define side_field_sg_float_le(_name, _offset, _float_size_bits, _attr) \
-       _side_field(_name, side_type_sg_float_le(_offset, _float_size_bits, _attr))
-#define side_field_sg_float_be(_name, _offset, _float_size_bits, _attr) \
-       _side_field(_name, side_type_sg_float_be(_offset, _float_size_bits, _attr))
-
-#define side_type_sg_struct(_struct_sg, _offset) \
+#define side_type_sg_float(_offset, _float_size_bits, _access_mode, _attr) \
+       _side_type_sg_float(SIDE_TYPE_FLOAT_WORD_ORDER_HOST, _offset, _float_size_bits, _access_mode, _attr)
+#define side_type_sg_float_le(_offset, _float_size_bits, _access_mode, _attr) \
+       _side_type_sg_float(SIDE_TYPE_BYTE_ORDER_LE, _offset, _float_size_bits, _access_mode, _attr)
+#define side_type_sg_float_be(_offset, _float_size_bits, _access_mode, _attr) \
+       _side_type_sg_float(SIDE_TYPE_BYTE_ORDER_BE, _offset, _float_size_bits, _access_mode, _attr)
+
+#define side_field_sg_float(_name, _offset, _float_size_bits, _access_mode, _attr) \
+       _side_field(_name, side_type_sg_float(_offset, _float_size_bits, _access_mode, _attr))
+#define side_field_sg_float_le(_name, _offset, _float_size_bits, _access_mode, _attr) \
+       _side_field(_name, side_type_sg_float_le(_offset, _float_size_bits, _access_mode, _attr))
+#define side_field_sg_float_be(_name, _offset, _float_size_bits, _access_mode, _attr) \
+       _side_field(_name, side_type_sg_float_be(_offset, _float_size_bits, _access_mode, _attr))
+
+#define side_type_sg_struct(_struct_sg, _offset, _size, _access_mode) \
        { \
                .type = SIDE_TYPE_SG_STRUCT, \
                .u = { \
                        .side_sg = { \
                                .offset = _offset, \
+                               .access_mode = _access_mode, \
                                .u = { \
-                                       .side_struct = _struct_sg, \
+                                       .side_struct = { \
+                                               .type = _struct_sg, \
+                                               .size = _size, \
+                                       }, \
                                }, \
                        }, \
                }, \
        }
-#define side_field_sg_struct(_name, _struct_sg, _offset) \
-       _side_field(_name, side_type_sg_struct(SIDE_PARAM(_struct_sg), _offset))
+#define side_field_sg_struct(_name, _struct_sg, _offset, _size, _access_mode) \
+       _side_field(_name, side_type_sg_struct(SIDE_PARAM(_struct_sg), _offset, _size, _access_mode))
 
-#define side_type_sg_array(_elem_type_sg, _length, _offset, _attr) \
+#define side_type_sg_array(_elem_type_sg, _length, _offset, _access_mode, _attr) \
        { \
                .type = SIDE_TYPE_SG_ARRAY, \
                .u = { \
                        .side_sg = { \
                                .offset = _offset, \
+                               .access_mode = _access_mode, \
                                .u = { \
                                        .side_array = { \
                                                .elem_type = _elem_type_sg, \
@@ -974,8 +993,8 @@ struct side_event_description {
                        }, \
                }, \
        }
-#define side_field_sg_array(_name, _elem_type, _length, _offset, _attr) \
-       _side_field(_name, side_type_sg_array(SIDE_PARAM(_elem_type), _length, _offset, SIDE_PARAM(_attr)))
+#define side_field_sg_array(_name, _elem_type, _length, _offset, _access_mode, _attr) \
+       _side_field(_name, side_type_sg_array(SIDE_PARAM(_elem_type), _length, _offset, _access_mode, SIDE_PARAM(_attr)))
 
 #define side_elem(...) \
        SIDE_COMPOUND_LITERAL(const struct side_type, __VA_ARGS__)

diff --git a/src/test.c b/src/test.c
index fd0a6ee13ae6e739e970aa579e5feaac2854057d..c614d954dc9cd74ab8b5375e128c4a87d1ae1bc5 100644 (file)
--- a/src/test.c
+++ b/src/test.c
@@ -1479,51 +1479,52 @@ static side_define_struct(mystructsgdef,
        side_field_list(
                side_field_sg_unsigned_integer("a", offsetof(struct test, a),
                        side_struct_field_sizeof_bit(struct test, a), 0,
-                       side_struct_field_sizeof_bit(struct test, a), side_attr_list()),
+                       side_struct_field_sizeof_bit(struct test, a), SIDE_TYPE_SG_ACCESS_ADDRESS, side_attr_list()),
                side_field_sg_signed_integer("d", offsetof(struct test, d),
                        side_struct_field_sizeof_bit(struct test, d), 0,
-                       side_struct_field_sizeof_bit(struct test, d), side_attr_list()),
+                       side_struct_field_sizeof_bit(struct test, d), SIDE_TYPE_SG_ACCESS_ADDRESS, side_attr_list()),
                side_field_sg_unsigned_integer("e", offsetof(struct test, e),
                        side_struct_field_sizeof_bit(struct test, e), 8, 4,
-                       side_attr_list(side_attr("std.integer.base", side_attr_u8(16)))),
+                       SIDE_TYPE_SG_ACCESS_ADDRESS, side_attr_list(side_attr("std.integer.base", side_attr_u8(16)))),
                side_field_sg_signed_integer("f", offsetof(struct test, f),
                        side_struct_field_sizeof_bit(struct test, f), 1, 4,
-                       side_attr_list(side_attr("std.integer.base", side_attr_u8(10)))),
+                       SIDE_TYPE_SG_ACCESS_ADDRESS, side_attr_list(side_attr("std.integer.base", side_attr_u8(10)))),
                side_field_sg_signed_integer("g", offsetof(struct test, g),
                        side_struct_field_sizeof_bit(struct test, g), 11, 4,
-                       side_attr_list(side_attr("std.integer.base", side_attr_u8(10)))),
+                       SIDE_TYPE_SG_ACCESS_ADDRESS, side_attr_list(side_attr("std.integer.base", side_attr_u8(10)))),
                side_field_sg_signed_integer("h", offsetof(struct test, h),
                        side_struct_field_sizeof_bit(struct test, h), 1, 31,
-                       side_attr_list(side_attr("std.integer.base", side_attr_u8(10)))),
+                       SIDE_TYPE_SG_ACCESS_ADDRESS, side_attr_list(side_attr("std.integer.base", side_attr_u8(10)))),
                side_field_sg_signed_integer("i", offsetof(struct test, i),
                        side_struct_field_sizeof_bit(struct test, i), 33, 20,
-                       side_attr_list(side_attr("std.integer.base", side_attr_u8(10)))),
+                       SIDE_TYPE_SG_ACCESS_ADDRESS, side_attr_list(side_attr("std.integer.base", side_attr_u8(10)))),
                side_field_sg_signed_integer("j", offsetof(struct test, j),
                        side_struct_field_sizeof_bit(struct test, j), 63, 1,
-                       side_attr_list(side_attr("std.integer.base", side_attr_u8(10)))),
-               side_field_sg_signed_integer("k", offsetof(struct test, k),
+                       SIDE_TYPE_SG_ACCESS_ADDRESS, side_attr_list(side_attr("std.integer.base", side_attr_u8(10)))),
+               side_field_sg_signed_integer("k", offsetof(struct test, k), 
                        side_struct_field_sizeof_bit(struct test, k), 1, 63,
-                       side_attr_list(side_attr("std.integer.base", side_attr_u8(10)))),
+                       SIDE_TYPE_SG_ACCESS_ADDRESS, side_attr_list(side_attr("std.integer.base", side_attr_u8(10)))),
                side_field_sg_unsigned_integer_le("test", offsetof(struct test, test),
                        side_struct_field_sizeof_bit(struct test, test), 0, 64,
-                       side_attr_list(side_attr("std.integer.base", side_attr_u8(16)))),
+                       SIDE_TYPE_SG_ACCESS_ADDRESS, side_attr_list(side_attr("std.integer.base", side_attr_u8(16)))),
                side_field_sg_unsigned_integer_le("test_le", offsetof(struct test, test),
                        side_struct_field_sizeof_bit(struct test, test), 0, 64,
-                       side_attr_list(side_attr("std.integer.base", side_attr_u8(16)))),
+                       SIDE_TYPE_SG_ACCESS_ADDRESS, side_attr_list(side_attr("std.integer.base", side_attr_u8(16)))),
                side_field_sg_unsigned_integer_be("test_be", offsetof(struct test, test),
                        side_struct_field_sizeof_bit(struct test, test), 0, 64,
-                       side_attr_list(side_attr("std.integer.base", side_attr_u8(16)))),
+                       SIDE_TYPE_SG_ACCESS_ADDRESS, side_attr_list(side_attr("std.integer.base", side_attr_u8(16)))),
        ),
        side_attr_list()
 );
 
 side_static_event(my_provider_event_structsg, "myprovider", "myeventstructsg", SIDE_LOGLEVEL_DEBUG,
        side_field_list(
-               side_field_sg_struct("structsg", &mystructsgdef, 0),
-               side_field_sg_signed_integer("intsg", 0, 32, 0, 32,
+               side_field_sg_struct("structsg", &mystructsgdef, 0, sizeof(struct test),
+                               SIDE_TYPE_SG_ACCESS_POINTER),
+               side_field_sg_signed_integer("intsg", 0, 32, 0, 32, SIDE_TYPE_SG_ACCESS_ADDRESS,
                        side_attr_list(side_attr("std.integer.base", side_attr_u8(10)))),
 #if __HAVE_FLOAT32
-               side_field_sg_float("f32", 0, 32, side_attr_list()),
+               side_field_sg_float("f32", 0, 32, SIDE_TYPE_SG_ACCESS_ADDRESS, side_attr_list()),
 #endif
        ),
        side_attr_list()
@@ -1581,7 +1582,7 @@ static side_define_struct(mystructsgnest2,
        side_field_list(
                side_field_sg_unsigned_integer("c", offsetof(struct testnest2, c),
                        side_struct_field_sizeof_bit(struct testnest2, c), 0,
-                       side_struct_field_sizeof_bit(struct testnest2, c), side_attr_list()),
+                       side_struct_field_sizeof_bit(struct testnest2, c), SIDE_TYPE_SG_ACCESS_ADDRESS, side_attr_list()),
        ),
        side_attr_list()
 );
@@ -1590,9 +1591,10 @@ static side_define_struct(mystructsgnest1,
        side_field_list(
                side_field_sg_unsigned_integer("b", offsetof(struct testnest1, b),
                        side_struct_field_sizeof_bit(struct testnest1, b), 0,
-                       side_struct_field_sizeof_bit(struct testnest1, b), side_attr_list()),
+                       side_struct_field_sizeof_bit(struct testnest1, b), SIDE_TYPE_SG_ACCESS_ADDRESS, side_attr_list()),
                side_field_sg_struct("nest2", &mystructsgnest2,
-                       offsetof(struct testnest1, nest)),
+                       offsetof(struct testnest1, nest), sizeof(struct testnest2),
+                       SIDE_TYPE_SG_ACCESS_POINTER),
        ),
        side_attr_list()
 );
@@ -1601,9 +1603,10 @@ static side_define_struct(mystructsgnest0,
        side_field_list(
                side_field_sg_unsigned_integer("a", offsetof(struct testnest0, a),
                        side_struct_field_sizeof_bit(struct testnest0, a), 0,
-                       side_struct_field_sizeof_bit(struct testnest0, a), side_attr_list()),
+                       side_struct_field_sizeof_bit(struct testnest0, a), SIDE_TYPE_SG_ACCESS_ADDRESS, side_attr_list()),
                side_field_sg_struct("nest1", &mystructsgnest1,
-                       offsetof(struct testnest0, nest)),
+                       offsetof(struct testnest0, nest), sizeof(struct testnest1),
+                       SIDE_TYPE_SG_ACCESS_POINTER),
        ),
        side_attr_list()
 );
@@ -1611,13 +1614,14 @@ static side_define_struct(mystructsgnest0,
 side_static_event(my_provider_event_structsg_nest,
        "myprovider", "myeventstructsgnest", SIDE_LOGLEVEL_DEBUG,
        side_field_list(
-               side_field_sg_struct("nest0", &mystructsgnest0, 0),
+               side_field_sg_struct("nest0", &mystructsgnest0, 0,
+                       sizeof(struct testnest0), SIDE_TYPE_SG_ACCESS_POINTER),
        ),
        side_attr_list()
 );
 
 static
-void test_struct_sg_nest(void)
+void test_struct_sg_nest_ptr(void)
 {
        side_event_cond(my_provider_event_structsg_nest) {
                struct testnest2 mystruct2 = {
@@ -1658,18 +1662,22 @@ static side_define_struct(mystructsgfloat,
        side_field_list(
 #if __HAVE_FLOAT16
                side_field_sg_float("f16", offsetof(struct testfloat, f16), 16,
+                       SIDE_TYPE_SG_ACCESS_ADDRESS,
                        side_attr_list()),
 #endif
 #if __HAVE_FLOAT32
                side_field_sg_float("f32", offsetof(struct testfloat, f32), 32,
+                       SIDE_TYPE_SG_ACCESS_ADDRESS,
                        side_attr_list()),
 #endif
 #if __HAVE_FLOAT64
                side_field_sg_float("f64", offsetof(struct testfloat, f64), 64,
+                       SIDE_TYPE_SG_ACCESS_ADDRESS,
                        side_attr_list()),
 #endif
 #if __HAVE_FLOAT128
                side_field_sg_float("f128", offsetof(struct testfloat, f128), 128,
+                       SIDE_TYPE_SG_ACCESS_ADDRESS,
                        side_attr_list()),
 #endif
        ),
@@ -1679,7 +1687,8 @@ static side_define_struct(mystructsgfloat,
 side_static_event(my_provider_event_structsgfloat,
        "myprovider", "myeventstructsgfloat", SIDE_LOGLEVEL_DEBUG,
        side_field_list(
-               side_field_sg_struct("structsgfloat", &mystructsgfloat, 0),
+               side_field_sg_struct("structsgfloat", &mystructsgfloat, 0,
+                       sizeof(struct testfloat), SIDE_TYPE_SG_ACCESS_POINTER),
        ),
        side_attr_list()
 );
@@ -1722,9 +1731,10 @@ struct testarray {
 static side_define_struct(mystructsgarray,
        side_field_list(
                side_field_sg_array("array",
-                       side_elem(side_type_sg_unsigned_integer(0, 32, 0, 32, side_attr_list())),
+                       side_elem(side_type_sg_unsigned_integer(0, 32, 0, 32, SIDE_TYPE_SG_ACCESS_ADDRESS, side_attr_list())),
                        SIDE_ARRAY_SIZE(mysgarray),
                        offsetof(struct testarray, ptr),
+                       SIDE_TYPE_SG_ACCESS_POINTER,
                        side_attr_list()),
        ),
        side_attr_list()
@@ -1733,10 +1743,12 @@ static side_define_struct(mystructsgarray,
 side_static_event(my_provider_event_structsgarray,
        "myprovider", "myeventstructsgarray", SIDE_LOGLEVEL_DEBUG,
        side_field_list(
-               side_field_sg_struct("structsgarray", &mystructsgarray, 0),
+               side_field_sg_struct("structsgarray", &mystructsgarray, 0,
+                               sizeof(struct testarray), SIDE_TYPE_SG_ACCESS_POINTER),
                side_field_sg_array("array2",
-                       side_elem(side_type_sg_unsigned_integer(0, 16, 0, 16, side_attr_list())),
+                       side_elem(side_type_sg_unsigned_integer(0, 16, 0, 16, SIDE_TYPE_SG_ACCESS_ADDRESS, side_attr_list())),
                        SIDE_ARRAY_SIZE(mysgarray2), 0,
+                       SIDE_TYPE_SG_ACCESS_POINTER,
                        side_attr_list()
                ),
        ),
@@ -1760,6 +1772,101 @@ void test_array_sg(void)
        }
 }
 
+#define TESTSGNESTARRAY_LEN 4
+struct testsgstructnest1 {
+       int b;
+       int c[TESTSGNESTARRAY_LEN];
+};
+
+struct testsgstructnest0 {
+       struct testsgstructnest1 nest;
+       struct testsgstructnest1 nestarray[2];
+       int a;
+};
+
+
+static side_define_struct(mystructsgstructnest1,
+       side_field_list(
+               side_field_sg_signed_integer("b", offsetof(struct testsgstructnest1, b),
+                       side_struct_field_sizeof_bit(struct testsgstructnest1, b), 0,
+                       side_struct_field_sizeof_bit(struct testsgstructnest1, b),
+                       SIDE_TYPE_SG_ACCESS_ADDRESS, side_attr_list()),
+               side_field_sg_array("c",
+                       side_elem(
+                               side_type_sg_signed_integer(0, 32, 0, 32, 
+                                       SIDE_TYPE_SG_ACCESS_ADDRESS, side_attr_list()),
+                       ),
+                       TESTSGNESTARRAY_LEN,
+                       offsetof(struct testsgstructnest1, c),
+                       SIDE_TYPE_SG_ACCESS_ADDRESS,
+                       side_attr_list()),
+       ),
+       side_attr_list()
+);
+
+static side_define_struct(mystructsgstructnest0,
+       side_field_list(
+               side_field_sg_signed_integer("a", offsetof(struct testsgstructnest0, a),
+                       side_struct_field_sizeof_bit(struct testsgstructnest0, a), 0,
+                       side_struct_field_sizeof_bit(struct testsgstructnest0, a),
+                       SIDE_TYPE_SG_ACCESS_ADDRESS, side_attr_list()),
+               side_field_sg_struct("structnest0", &mystructsgstructnest1,
+                       offsetof(struct testsgstructnest0, nest),
+                       sizeof(struct testsgstructnest1),
+                       SIDE_TYPE_SG_ACCESS_ADDRESS),
+               side_field_sg_array("nestarray",
+                       side_elem(
+                               side_type_sg_struct(&mystructsgstructnest1,
+                                       0,
+                                       sizeof(struct testsgstructnest1),
+                                       SIDE_TYPE_SG_ACCESS_ADDRESS),
+                       ),
+                       2,
+                       offsetof(struct testsgstructnest0, nestarray),
+                       SIDE_TYPE_SG_ACCESS_ADDRESS,
+                       side_attr_list()),
+       ),
+       side_attr_list()
+);
+
+side_static_event(my_provider_event_sgstructnest,
+       "myprovider", "myeventsgstructnest", SIDE_LOGLEVEL_DEBUG,
+       side_field_list(
+               side_field_sg_struct("structsg", &mystructsgstructnest0, 0,
+                               sizeof(struct testsgstructnest0), SIDE_TYPE_SG_ACCESS_POINTER),
+       ),
+       side_attr_list()
+);
+
+static
+void test_sg_structnest(void)
+{
+       side_event_cond(my_provider_event_sgstructnest) {
+               struct testsgstructnest0 mystruct = {
+                       .nest = {
+                               .b = 66,
+                               .c = { 0, 1, 2, 3 },
+                       },
+                       .nestarray = {
+                               [0] = {
+                                       .b = 77,
+                                       .c = { 11, 12, 13, 14 },
+                               },
+                               [1] = {
+                                       .b = 88,
+                                       .c = { 15, 16, 17, 18 },
+                               },
+                       },
+                       .a = 55,
+               };
+               side_event_call(my_provider_event_sgstructnest,
+                       side_arg_list(
+                               side_arg_sg_struct(&mystruct),
+                       )
+               );
+       }
+}
+
 int main()
 {
        test_fields();
@@ -1801,8 +1908,9 @@ int main()
        test_endian();
        test_base();
        test_struct_sg();
-       test_struct_sg_nest();
+       test_struct_sg_nest_ptr();
        test_struct_sg_float();
        test_array_sg();
+       test_sg_structnest();
        return 0;
 }

diff --git a/src/tracer.c b/src/tracer.c
index b071ee0fbc569091f55e442a0c903c3c1ac53e45..6ea3bf82c869125c3fa6bda215176e1afa823b8f 100644 (file)
--- a/src/tracer.c
+++ b/src/tracer.c
@@ -1049,6 +1049,34 @@ void tracer_print_vla(const struct side_type *type_desc, const struct side_arg_v
        printf(" ]");
 }
 
+static
+const char *tracer_sg_access(const struct side_type_sg *type_sg, const char *ptr)
+{
+       switch (type_sg->access_mode) {
+       case SIDE_TYPE_SG_ACCESS_ADDRESS:
+               return ptr;
+       case SIDE_TYPE_SG_ACCESS_POINTER:
+               /* Dereference pointer */
+               memcpy(&ptr, ptr, sizeof(ptr));
+               return ptr;
+       default:
+               abort();
+       }
+}
+
+static
+uint32_t tracer_sg_size(const struct side_type_sg *type_sg, uint32_t len)
+{
+       switch (type_sg->access_mode) {
+       case SIDE_TYPE_SG_ACCESS_ADDRESS:
+               return len;
+       case SIDE_TYPE_SG_ACCESS_POINTER:
+               return sizeof(void *);
+       default:
+               abort();
+       }
+}
+
 static
 uint32_t tracer_print_sg_integer_type(const struct side_type_sg *type_sg, const void *_ptr)
 {
@@ -1065,10 +1093,11 @@ uint32_t tracer_print_sg_integer_type(const struct side_type_sg *type_sg, const
        default:
                abort();
        }
-       memcpy(&value, ptr + type_sg->offset, integer_size_bytes);
+       ptr = tracer_sg_access(type_sg, ptr + type_sg->offset);
+       memcpy(&value, ptr, integer_size_bytes);
        tracer_print_type_integer(":", &type_sg->u.side_integer.type, &value,
                        type_sg->u.side_integer.offset_bits, TRACER_DISPLAY_BASE_10);
-       return integer_size_bytes;
+       return tracer_sg_size(type_sg, integer_size_bytes);
 }
 
 static
@@ -1087,13 +1116,14 @@ uint32_t tracer_print_sg_float_type(const struct side_type_sg *type_sg, const vo
        default:
                abort();
        }
-       memcpy(&value, ptr + type_sg->offset, float_size_bytes);
+       ptr = tracer_sg_access(type_sg, ptr + type_sg->offset);
+       memcpy(&value, ptr, float_size_bytes);
        tracer_print_type_float(":", &type_sg->u.side_float, &value);
-       return float_size_bytes;
+       return tracer_sg_size(type_sg, float_size_bytes);
 }
 
 static
-uint32_t tracer_print_sg_type(const struct side_type *type_desc, void *ptr)
+uint32_t tracer_print_sg_type(const struct side_type *type_desc, const void *ptr)
 {
        uint32_t len;
 
@@ -1121,7 +1151,7 @@ uint32_t tracer_print_sg_type(const struct side_type *type_desc, void *ptr)
 }
 
 static
-void tracer_print_sg_field(const struct side_event_field *field, void *ptr)
+void tracer_print_sg_field(const struct side_event_field *field, const void *ptr)
 {
        printf("%s: ", field->field_name);
        (void) tracer_print_sg_type(&field->side_type, ptr);
@@ -1130,28 +1160,29 @@ void tracer_print_sg_field(const struct side_event_field *field, void *ptr)
 static
 uint32_t tracer_print_sg_struct(const struct side_type_sg *type_sg, const void *_ptr)
 {
-       char *ptr = (char *) _ptr;
+       const char *ptr = (const char *) _ptr;
        uint32_t i;
 
-       memcpy(&ptr, ptr + type_sg->offset, sizeof(ptr));
-       print_attributes("attr", ":", type_sg->u.side_struct->attr, type_sg->u.side_struct->nr_attr);
-       printf("%s", type_sg->u.side_struct->nr_attr ? ", " : "");
+       ptr = tracer_sg_access(type_sg, ptr + type_sg->offset);
+       print_attributes("attr", ":", type_sg->u.side_struct.type->attr, type_sg->u.side_struct.type->nr_attr);
+       printf("%s", type_sg->u.side_struct.type->nr_attr ? ", " : "");
        printf("fields: { ");
-       for (i = 0; i < type_sg->u.side_struct->nr_fields; i++) {
+       for (i = 0; i < type_sg->u.side_struct.type->nr_fields; i++) {
                printf("%s", i ? ", " : "");
-               tracer_print_sg_field(&type_sg->u.side_struct->fields[i], ptr);
+               tracer_print_sg_field(&type_sg->u.side_struct.type->fields[i], ptr);
        }
        printf(" }");
-       return sizeof(void *);
+       return tracer_sg_size(type_sg, type_sg->u.side_struct.size);
 }
 
 static
 uint32_t tracer_print_sg_array(const struct side_type_sg *type_sg, const void *_ptr)
 {
-       char *ptr = (char *) _ptr;
+       const char *ptr = (const char *) _ptr, *orig_ptr;
        uint32_t i;
 
-       memcpy(&ptr, ptr + type_sg->offset, sizeof(ptr));
+       ptr = tracer_sg_access(type_sg, ptr + type_sg->offset);
+       orig_ptr = ptr;
        print_attributes("attr", ":", type_sg->u.side_array.attr, type_sg->u.side_array.nr_attr);
        printf("%s", type_sg->u.side_array.nr_attr ? ", " : "");
        printf("elements: ");
@@ -1161,7 +1192,7 @@ uint32_t tracer_print_sg_array(const struct side_type_sg *type_sg, const void *_
                ptr += tracer_print_sg_type(type_sg->u.side_array.elem_type, ptr);
        }
        printf(" ]");
-       return sizeof(void *);
+       return tracer_sg_size(type_sg, ptr - orig_ptr);
 }
 
 struct tracer_visitor_priv {