Implement gather bool

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

diff --git a/include/side/trace.h b/include/side/trace.h
index d4727dac4c75ad9798d7f6132317de2baf2f844a..4c978d1b4ef9d92da33a14f9029f5c5f43b9255b 100644 (file)
--- a/include/side/trace.h
+++ b/include/side/trace.h
@@ -142,6 +142,7 @@ enum side_type_label {
        SIDE_TYPE_DYNAMIC,
 
        /* Gather basic types */
+       SIDE_TYPE_GATHER_BOOL,
        SIDE_TYPE_GATHER_UNSIGNED_INT,
        SIDE_TYPE_GATHER_SIGNED_INT,
        SIDE_TYPE_GATHER_BYTE,
@@ -304,6 +305,9 @@ struct side_type_null {
 struct side_type_bool {
        const struct side_attr *attr;
        uint32_t nr_attr;
+       uint16_t bool_size_bits;        /* bits */
+       uint16_t len_bits;              /* bits */
+       uint8_t byte_order;             /* enum side_type_label_byte_order */
 } SIDE_PACKED;
 
 struct side_type_byte {
@@ -395,6 +399,13 @@ struct side_type_enum_bitmap {
        const struct side_type *elem_type;
 } SIDE_PACKED;
 
+struct side_type_gather_bool {
+       uint64_t offset;        /* bytes */
+       uint8_t access_mode;    /* enum side_type_gather_access_mode */
+       struct side_type_bool type;
+       uint16_t offset_bits;   /* bits */
+} SIDE_PACKED;
+
 struct side_type_gather_byte {
        uint64_t offset;        /* bytes */
        uint8_t access_mode;    /* enum side_type_gather_access_mode */
@@ -437,6 +448,7 @@ struct side_type_gather_vla {
 
 struct side_type_gather {
        union {
+               struct side_type_gather_bool side_bool;
                struct side_type_gather_byte side_byte;
                struct side_type_gather_integer side_integer;
                struct side_type_gather_float side_float;
@@ -514,6 +526,7 @@ struct side_arg_static {
        } SIDE_PACKED side_vla_fixint;
 
        /* Gather basic types */
+       void *side_bool_gather_ptr;
        void *side_byte_gather_ptr;
        void *side_integer_gather_ptr;
        void *side_float_gather_ptr;
@@ -751,6 +764,9 @@ struct side_event_description {
                        .side_bool = { \
                                .attr = _attr, \
                                .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
+                               .bool_size_bits = 8, \
+                               .len_bits = 1, \
+                               .byte_order = SIDE_TYPE_BYTE_ORDER_HOST, \
                        }, \
                }, \
        }
@@ -1021,6 +1037,42 @@ struct side_event_description {
 #define side_field_gather_byte(_name, _offset, _access_mode, _attr) \
        _side_field(_name, side_type_gather_byte(_offset, _access_mode, SIDE_PARAM(_attr)))
 
+#define _side_type_gather_bool(_byte_order, _offset, _bool_size_bits, _offset_bits, _len_bits, _access_mode, _attr) \
+       { \
+               .type = SIDE_TYPE_GATHER_BOOL, \
+               .u = { \
+                       .side_gather = { \
+                               .u = { \
+                                       .side_bool = { \
+                                               .offset = _offset, \
+                                               .access_mode = _access_mode, \
+                                               .type = { \
+                                                       .attr = _attr, \
+                                                       .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
+                                                       .bool_size_bits = _bool_size_bits, \
+                                                       .len_bits = _len_bits, \
+                                                       .byte_order = _byte_order, \
+                                               }, \
+                                               .offset_bits = _offset_bits, \
+                                       }, \
+                               }, \
+                       }, \
+               }, \
+       }
+#define side_type_gather_bool(_offset, _bool_size_bits, _offset_bits, _len_bits, _access_mode, _attr) \
+       _side_type_gather_bool(SIDE_TYPE_BYTE_ORDER_HOST, _offset, _bool_size_bits, _offset_bits, _len_bits, _access_mode, _attr)
+#define side_type_gather_bool_le(_offset, _bool_size_bits, _offset_bits, _len_bits, _access_mode, _attr) \
+       _side_type_gather_bool(SIDE_TYPE_BYTE_ORDER_LE, _offset, _bool_size_bits, _offset_bits, _len_bits, _access_mode, _attr)
+#define side_type_gather_bool_be(_offset, _bool_size_bits, _offset_bits, _len_bits, _access_mode, _attr) \
+       _side_type_gather_bool(SIDE_TYPE_BYTE_ORDER_BE, _offset, _bool_size_bits, _offset_bits, _len_bits, _access_mode, _attr)
+
+#define side_field_gather_bool(_name, _offset, _bool_size_bits, _offset_bits, _len_bits, _access_mode, _attr) \
+       _side_field(_name, side_type_gather_bool(_offset, _bool_size_bits, _offset_bits, _len_bits, _access_mode, SIDE_PARAM(_attr)))
+#define side_field_gather_bool_le(_name, _offset, _bool_size_bits, _offset_bits, _len_bits, _access_mode, _attr) \
+       _side_field(_name, side_type_gather_bool_le(_offset, _bool_size_bits, _offset_bits, _len_bits, _access_mode, SIDE_PARAM(_attr)))
+#define side_field_gather_bool_be(_name, _offset, _bool_size_bits, _offset_bits, _len_bits, _access_mode, _attr) \
+       _side_field(_name, side_type_gather_bool_be(_offset, _bool_size_bits, _offset_bits, _len_bits, _access_mode, SIDE_PARAM(_attr)))
+
 #define _side_type_gather_integer(_type, _signedness, _byte_order, _offset, \
                _integer_size_bits, _offset_bits, _len_bits, _access_mode, _attr) \
        { \
@@ -1247,6 +1299,7 @@ struct side_event_description {
 
 /* Gather field arguments */
 
+#define side_arg_gather_bool(_ptr)             { .type = SIDE_TYPE_GATHER_BOOL, .u = { .side_static = { .side_bool_gather_ptr = (_ptr) } } }
 #define side_arg_gather_byte(_ptr)             { .type = SIDE_TYPE_GATHER_BYTE, .u = { .side_static = { .side_byte_gather_ptr = (_ptr) } } }
 #define side_arg_gather_unsigned_integer(_ptr) { .type = SIDE_TYPE_GATHER_UNSIGNED_INT, .u = { .side_static = { .side_integer_gather_ptr = (_ptr) } } }
 #define side_arg_gather_signed_integer(_ptr)   { .type = SIDE_TYPE_GATHER_SIGNED_INT, .u = { .side_static = { .side_integer_gather_ptr = (_ptr) } } }
@@ -1279,6 +1332,9 @@ struct side_event_description {
                                        .type = { \
                                                .attr = _attr, \
                                                .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
+                                               .bool_size_bits = sizeof(uint8_t) * CHAR_BIT, \
+                                               .len_bits = 1, \
+                                               .byte_order = SIDE_TYPE_BYTE_ORDER_HOST, \
                                        }, \
                                        .value = !!(_val), \
                                }, \

diff --git a/src/test.c b/src/test.c
index a0feae943e9186f44431daeae94120ba5ace451b..e493032356025cacc7c3950ff4141bf51d9a77a8 100644 (file)
--- a/src/test.c
+++ b/src/test.c
@@ -2009,6 +2009,52 @@ void test_gather_byte(void)
        }
 }
 
+#define ARRAYBOOLLEN 4
+static bool arraybool[ARRAYBOOLLEN] = { false, true, false, true };
+
+side_static_event(my_provider_event_gatherbool,
+       "myprovider", "myeventgatherbool", SIDE_LOGLEVEL_DEBUG,
+       side_field_list(
+               side_field_gather_bool("v1_true", 0, sizeof(bool) * CHAR_BIT,
+                               0, sizeof(bool) * CHAR_BIT,
+                               SIDE_TYPE_GATHER_ACCESS_DIRECT, side_attr_list()),
+               side_field_gather_bool("v2_false", 0, sizeof(bool) * CHAR_BIT,
+                               0, sizeof(bool) * CHAR_BIT,
+                               SIDE_TYPE_GATHER_ACCESS_DIRECT, side_attr_list()),
+               side_field_gather_bool("v3_true", 0, sizeof(uint16_t) * CHAR_BIT,
+                               1, 1, SIDE_TYPE_GATHER_ACCESS_DIRECT, side_attr_list()),
+               side_field_gather_bool("v4_false", 0, sizeof(uint16_t) * CHAR_BIT,
+                               1, 1, SIDE_TYPE_GATHER_ACCESS_DIRECT, side_attr_list()),
+               side_field_gather_array("arraybool",
+                       side_elem(side_type_gather_bool(0, sizeof(bool) * CHAR_BIT,
+                               0, sizeof(bool) * CHAR_BIT, SIDE_TYPE_GATHER_ACCESS_DIRECT, side_attr_list())),
+                       ARRAYBOOLLEN, 0, SIDE_TYPE_GATHER_ACCESS_DIRECT, side_attr_list()
+               ),
+       ),
+       side_attr_list()
+);
+
+static
+void test_gather_bool(void)
+{
+       side_event_cond(my_provider_event_structgatherarray) {
+               bool v1 = true;
+               bool v2 = false;
+               uint16_t v3 = 1U << 1;
+               uint16_t v4 = 1U << 2;
+
+               side_event_call(my_provider_event_gatherbool,
+                       side_arg_list(
+                               side_arg_gather_bool(&v1),
+                               side_arg_gather_bool(&v2),
+                               side_arg_gather_bool(&v3),
+                               side_arg_gather_bool(&v4),
+                               side_arg_gather_array(arraybool),
+                       )
+               );
+       }
+}
+
 int main()
 {
        test_fields();
@@ -2057,5 +2103,6 @@ int main()
        test_gather_vla();
        test_gather_vla_flex();
        test_gather_byte();
+       test_gather_bool();
        return 0;
 }

diff --git a/src/tracer.c b/src/tracer.c
index 8ddcc1f6c37dcb9ed4630577905c287dfd3dca23..ed7d3420595357ffdb44889cd438286f39f640e3 100644 (file)
--- a/src/tracer.c
+++ b/src/tracer.c
@@ -36,6 +36,8 @@ void tracer_print_vla_fixint(const struct side_type *type_desc, const struct sid
 static
 void tracer_print_dynamic(const struct side_arg *dynamic_item);
 static
+uint32_t tracer_print_gather_bool_type(const struct side_type_gather *type_gather, const void *_ptr);
+static
 uint32_t tracer_print_gather_byte_type(const struct side_type_gather *type_gather, const void *_ptr);
 static
 uint32_t tracer_print_gather_integer_type(const struct side_type_gather *type_gather, const void *_ptr);
@@ -515,6 +517,63 @@ void tracer_print_type_header(const char *separator,
        printf("value%s ", separator);
 }
 
+static
+void tracer_print_type_bool(const char *separator,
+               const struct side_type_bool *type_bool,
+               const union side_integer_value *value,
+               uint16_t offset_bits)
+{
+       bool reverse_bo;
+       uint64_t v;
+
+       if (!type_bool->len_bits ||
+                       type_bool->len_bits + offset_bits > type_bool->bool_size_bits)
+               abort();
+       reverse_bo = type_bool->byte_order != SIDE_TYPE_BYTE_ORDER_HOST;
+       switch (type_bool->bool_size_bits) {
+       case 8:
+               v = value->side_u8;
+               break;
+       case 16:
+       {
+               uint16_t side_u16;
+
+               side_u16 = value->side_u16;
+               if (reverse_bo)
+                       side_u16 = side_bswap_16(side_u16);
+               v = side_u16;
+               break;
+       }
+       case 32:
+       {
+               uint32_t side_u32;
+
+               side_u32 = value->side_u32;
+               if (reverse_bo)
+                       side_u32 = side_bswap_32(side_u32);
+               v = side_u32;
+               break;
+       }
+       case 64:
+       {
+               uint64_t side_u64;
+
+               side_u64 = value->side_u64;
+               if (reverse_bo)
+                       side_u64 = side_bswap_64(side_u64);
+               v = side_u64;
+               break;
+       }
+       default:
+               abort();
+       }
+       v >>= offset_bits;
+       if (type_bool->len_bits < 64)
+               v &= (1ULL << type_bool->len_bits) - 1;
+       tracer_print_type_header(separator, type_bool->attr, type_bool->nr_attr);
+       printf("%s", v ? "true" : "false");
+}
+
 static
 void tracer_print_type_integer(const char *separator,
                const struct side_type_integer *type_integer,
@@ -859,9 +918,13 @@ void tracer_print_type(const struct side_type *type_desc, const struct side_arg
                break;
 
        case SIDE_TYPE_BOOL:
-               tracer_print_type_header(":", type_desc->u.side_bool.attr, type_desc->u.side_bool.nr_attr);
-               printf("%s", item->u.side_static.bool_value ? "true" : "false");
+       {
+               union side_integer_value value = {
+                       .side_u8 = item->u.side_static.bool_value,
+               };
+               tracer_print_type_bool(":", &type_desc->u.side_bool, &value, 0);
                break;
+       }
 
        case SIDE_TYPE_U8:
        case SIDE_TYPE_U16:
@@ -918,6 +981,9 @@ void tracer_print_type(const struct side_type *type_desc, const struct side_arg
                (void) tracer_print_gather_vla(&type_desc->u.side_gather, item->u.side_static.side_vla_gather.ptr,
                                item->u.side_static.side_vla_gather.length_ptr);
                break;
+       case SIDE_TYPE_GATHER_BOOL:
+               (void) tracer_print_gather_bool_type(&type_desc->u.side_gather, item->u.side_static.side_bool_gather_ptr);
+               break;
        case SIDE_TYPE_GATHER_BYTE:
                (void) tracer_print_gather_byte_type(&type_desc->u.side_gather, item->u.side_static.side_byte_gather_ptr);
                break;
@@ -1113,6 +1179,30 @@ uint64_t tracer_load_gather_integer_type(const struct side_type_gather *type_gat
        }
 }
 
+static
+uint32_t tracer_print_gather_bool_type(const struct side_type_gather *type_gather, const void *_ptr)
+{
+       enum side_type_gather_access_mode access_mode = type_gather->u.side_bool.access_mode;
+       uint32_t bool_size_bytes = type_gather->u.side_bool.type.bool_size_bits >> 3;
+       const char *ptr = (const char *) _ptr;
+       union side_integer_value value;
+
+       switch (type_gather->u.side_bool.type.bool_size_bits) {
+       case 8:
+       case 16:
+       case 32:
+       case 64:
+               break;
+       default:
+               abort();
+       }
+       ptr = tracer_gather_access(access_mode, ptr + type_gather->u.side_bool.offset);
+       memcpy(&value, ptr, bool_size_bytes);
+       tracer_print_type_bool(":", &type_gather->u.side_bool.type, &value,
+                       type_gather->u.side_bool.offset_bits);
+       return tracer_gather_size(access_mode, bool_size_bytes);
+}
+
 static
 uint32_t tracer_print_gather_byte_type(const struct side_type_gather *type_gather, const void *_ptr)
 {
@@ -1182,6 +1272,9 @@ uint32_t tracer_print_gather_type(const struct side_type *type_desc, const void
 
        printf("{ ");
        switch (type_desc->type) {
+       case SIDE_TYPE_GATHER_BOOL:
+               len = tracer_print_gather_bool_type(&type_desc->u.side_gather, ptr);
+               break;
        case SIDE_TYPE_GATHER_BYTE:
                len = tracer_print_gather_byte_type(&type_desc->u.side_gather, ptr);
                break;
@@ -1715,9 +1808,13 @@ void tracer_print_dynamic(const struct side_arg *item)
                printf("<NULL TYPE>");
                break;
        case SIDE_TYPE_DYNAMIC_BOOL:
-               tracer_print_type_header("::", item->u.side_dynamic.side_bool.type.attr, item->u.side_dynamic.side_bool.type.nr_attr);
-               printf("%s", item->u.side_dynamic.side_bool.value ? "true" : "false");
+       {
+               union side_integer_value value = {
+                       .side_u8 = item->u.side_dynamic.side_bool.value,
+               };
+               tracer_print_type_bool("::", &item->u.side_dynamic.side_bool.type, &value, 0);
                break;
+       }
        case SIDE_TYPE_DYNAMIC_U8:
        case SIDE_TYPE_DYNAMIC_U16:
        case SIDE_TYPE_DYNAMIC_U32: