Refactor enum bitmap

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

diff --git a/include/side/trace.h b/include/side/trace.h
index bc5fa940ab2e5a698034f6fd240126e59eca85ca..ff9a23e097e8f731a635a2eb8cd9c56742d1a1d0 100644 (file)
--- a/include/side/trace.h
+++ b/include/side/trace.h
@@ -77,14 +77,7 @@ enum side_type {
 
        /* Enumeration types */
        SIDE_TYPE_ENUM,
-
-       SIDE_TYPE_ENUM_BITMAP8,
-       SIDE_TYPE_ENUM_BITMAP16,
-       SIDE_TYPE_ENUM_BITMAP32,
-       SIDE_TYPE_ENUM_BITMAP64,
-
-       SIDE_TYPE_ENUM_BITMAP_ARRAY,
-       SIDE_TYPE_ENUM_BITMAP_VLA,
+       SIDE_TYPE_ENUM_BITMAP,
 
        /* Dynamic type */
        SIDE_TYPE_DYNAMIC,
@@ -260,17 +253,10 @@ struct side_type_description {
                        const struct side_type_description *elem_type;
                        const struct side_enum_mappings *mappings;
                } side_enum;
-
-               const struct side_enum_bitmap_mappings *side_enum_bitmap_mappings;
                struct {
                        const struct side_type_description *elem_type;
                        const struct side_enum_bitmap_mappings *mappings;
-                       uint32_t length;
-               } side_enum_bitmap_array;
-               struct {
-                       const struct side_type_description *elem_type;
-                       const struct side_enum_bitmap_mappings *mappings;
-               } side_enum_bitmap_vla;
+               } side_enum_bitmap;
        } u;
 };
 
@@ -550,59 +536,18 @@ struct side_tracer_dynamic_vla_visitor_ctx {
 #define side_field_enum(_name, _elem_type, _mappings) \
        _side_field(_name, side_type_enum(SIDE_PARAM(_elem_type), SIDE_PARAM(_mappings)))
 
-#define side_type_enum_bitmap(_type, _mappings) \
-       { \
-               .type = _type, \
-               .u = { \
-                       .side_enum_bitmap_mappings = _mappings, \
-               }, \
-       }
-#define side_type_enum_bitmap8(_mappings) \
-       side_type_enum_bitmap(SIDE_TYPE_ENUM_BITMAP8, SIDE_PARAM(_mappings))
-#define side_type_enum_bitmap16(_mappings) \
-       side_type_enum_bitmap(SIDE_TYPE_ENUM_BITMAP16, SIDE_PARAM(_mappings))
-#define side_type_enum_bitmap32(_mappings) \
-       side_type_enum_bitmap(SIDE_TYPE_ENUM_BITMAP32, SIDE_PARAM(_mappings))
-#define side_type_enum_bitmap64(_mappings) \
-       side_type_enum_bitmap(SIDE_TYPE_ENUM_BITMAP64, SIDE_PARAM(_mappings))
-
-#define _side_field_enum_bitmap(_name, _type)  _side_field(_name, SIDE_PARAM(_type))
-
-#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_enum_bitmap_array(_mappings, _elem_type, _length) \
-       { \
-               .type = SIDE_TYPE_ENUM_BITMAP_ARRAY, \
-               .u = { \
-                       .side_enum_bitmap_array = { \
-                               .elem_type = _elem_type, \
-                               .mappings = _mappings, \
-                               .length = _length, \
-                       }, \
-               }, \
-       }
-#define side_field_enum_bitmap_array(_name, _mappings, _elem_type, _length) \
-       _side_field(_name, side_type_enum_bitmap_array(SIDE_PARAM(_mappings), SIDE_PARAM(_elem_type), _length))
-
-#define side_type_enum_bitmap_vla(_mappings, _elem_type) \
+#define side_type_enum_bitmap(_elem_type, _mappings) \
        { \
-               .type = SIDE_TYPE_ENUM_BITMAP_VLA, \
+               .type = SIDE_TYPE_ENUM_BITMAP, \
                .u = { \
-                       .side_enum_bitmap_vla = { \
+                       .side_enum_bitmap = { \
                                .elem_type = _elem_type, \
                                .mappings = _mappings, \
                        }, \
                }, \
        }
-#define side_field_enum_bitmap_vla(_name, _mappings, _elem_type) \
-       _side_field(_name, side_type_enum_bitmap_vla(SIDE_PARAM(_mappings), SIDE_PARAM(_elem_type)))
+#define side_field_enum_bitmap(_name, _elem_type, _mappings) \
+       _side_field(_name, side_type_enum_bitmap(SIDE_PARAM(_elem_type), SIDE_PARAM(_mappings)))
 
 #define side_type_struct(_struct) \
        { \

diff --git a/src/test.c b/src/test.c
index 7f9aabda15c2305da447624800f3465e4f933d54..d5b61cce68bc32c47d0e59f1683e0141d68723e8 100644 (file)
--- a/src/test.c
+++ b/src/test.c
@@ -1025,18 +1025,20 @@ static side_define_enum_bitmap(myenum_bitmap,
 
 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_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_field_enum_bitmap_array("bit_159", &myenum_bitmap,
-                       side_elem(side_type_u32(side_attr_list())), 5),
-               side_field_enum_bitmap_vla("bit_159", &myenum_bitmap,
-                       side_elem(side_type_u32(side_attr_list()))),
+               side_field_enum_bitmap("bit_0", side_elem(side_type_u32(side_attr_list())), &myenum_bitmap),
+               side_field_enum_bitmap("bit_1", side_elem(side_type_u32(side_attr_list())), &myenum_bitmap),
+               side_field_enum_bitmap("bit_2", side_elem(side_type_u8(side_attr_list())), &myenum_bitmap),
+               side_field_enum_bitmap("bit_3", side_elem(side_type_u8(side_attr_list())), &myenum_bitmap),
+               side_field_enum_bitmap("bit_30", side_elem(side_type_u32(side_attr_list())), &myenum_bitmap),
+               side_field_enum_bitmap("bit_31", side_elem(side_type_u32(side_attr_list())), &myenum_bitmap),
+               side_field_enum_bitmap("bit_63", side_elem(side_type_u64(side_attr_list())), &myenum_bitmap),
+               side_field_enum_bitmap("bits_1+63", side_elem(side_type_u64(side_attr_list())), &myenum_bitmap),
+               side_field_enum_bitmap("bit_159",
+                       side_elem(side_type_array(side_elem(side_type_u32(side_attr_list())), 5, side_attr_list())),
+                       &myenum_bitmap),
+               side_field_enum_bitmap("bit_159",
+                       side_elem(side_type_vla(side_elem(side_type_u32(side_attr_list())), side_attr_list())),
+                       &myenum_bitmap),
        ),
        side_attr_list()
 );
@@ -1057,16 +1059,16 @@ void test_enum_bitmap(void)
                );
                side_event_call(my_provider_event_enum_bitmap,
                        side_arg_list(
-                               side_arg_enum_bitmap32(1 << 0),
-                               side_arg_enum_bitmap32(1 << 1),
-                               side_arg_enum_bitmap8(1 << 2),
-                               side_arg_enum_bitmap8(1 << 3),
-                               side_arg_enum_bitmap32(1 << 30),
-                               side_arg_enum_bitmap32(1 << 31),
-                               side_arg_enum_bitmap64(1ULL << 63),
-                               side_arg_enum_bitmap64((1ULL << 1) | (1ULL << 63)),
-                               side_arg_enum_bitmap_array(&myarray),
-                               side_arg_enum_bitmap_vla(&myarray),
+                               side_arg_u32(1 << 0),
+                               side_arg_u32(1 << 1),
+                               side_arg_u8(1 << 2),
+                               side_arg_u8(1 << 3),
+                               side_arg_u32(1 << 30),
+                               side_arg_u32(1 << 31),
+                               side_arg_u64(1ULL << 63),
+                               side_arg_u64((1ULL << 1) | (1ULL << 63)),
+                               side_arg_array(&myarray),
+                               side_arg_vla(&myarray),
                        )
                );
        }

diff --git a/src/tracer.c b/src/tracer.c
index 3dc3fde885b2564321952defbf9bacdf28136cae..b9380730e47f25cf24ab1c7d146326e3dbd26ebb 100644 (file)
--- a/src/tracer.c
+++ b/src/tracer.c
@@ -180,37 +180,31 @@ void print_enum(const struct side_type_description *type_desc, const struct side
 }
 
 static
-uint32_t enum_type_to_stride(const struct side_type_description *type_desc)
+uint32_t enum_elem_type_to_stride(const struct side_type_description *elem_type)
 {
        uint32_t stride_bit;
 
-       switch (type_desc->type) {
-       case SIDE_TYPE_ENUM_BITMAP8:
+       switch (elem_type->type) {
        case SIDE_TYPE_U8:
        case SIDE_TYPE_S8:
                stride_bit = 8;
                break;
-       case SIDE_TYPE_ENUM_BITMAP16:
        case SIDE_TYPE_U16:
        case SIDE_TYPE_S16:
                stride_bit = 16;
                break;
-       case SIDE_TYPE_ENUM_BITMAP32:
        case SIDE_TYPE_U32:
        case SIDE_TYPE_S32:
                stride_bit = 32;
                break;
-       case SIDE_TYPE_ENUM_BITMAP64:
        case SIDE_TYPE_U64:
        case SIDE_TYPE_S64:
                stride_bit = 64;
                break;
-       case SIDE_TYPE_ENUM_BITMAP_ARRAY:
-               stride_bit = enum_type_to_stride(type_desc->u.side_enum_bitmap_array.elem_type);
-               break;
-       case SIDE_TYPE_ENUM_BITMAP_VLA:
-               stride_bit = enum_type_to_stride(type_desc->u.side_enum_bitmap_vla.elem_type);
-               break;
+       case SIDE_TYPE_ARRAY:
+               return enum_elem_type_to_stride(elem_type->u.side_array.elem_type);
+       case SIDE_TYPE_VLA:
+               return enum_elem_type_to_stride(elem_type->u.side_vla.elem_type);
        default:
                abort();
        }
@@ -221,33 +215,36 @@ static
 void print_enum_bitmap(const struct side_type_description *type_desc,
                const struct side_arg_vec *item)
 {
-       const struct side_enum_bitmap_mappings *side_enum_mappings;
+       const struct side_type_description *elem_type = type_desc->u.side_enum_bitmap.elem_type;
+       const struct side_enum_bitmap_mappings *side_enum_mappings = type_desc->u.side_enum_bitmap.mappings;
        int i, print_count = 0;
        uint32_t stride_bit, nr_items;
        const struct side_arg_vec *array_item;
 
-       stride_bit = enum_type_to_stride(type_desc);
+       stride_bit = enum_elem_type_to_stride(elem_type);
 
-       switch (type_desc->type) {
-       case SIDE_TYPE_ENUM_BITMAP8:    /* Fall-through */
-       case SIDE_TYPE_ENUM_BITMAP16:   /* Fall-through */
-       case SIDE_TYPE_ENUM_BITMAP32:   /* Fall-through */
-       case SIDE_TYPE_ENUM_BITMAP64:
+       switch (elem_type->type) {
+       case SIDE_TYPE_U8:              /* Fall-through */
+       case SIDE_TYPE_U16:             /* Fall-through */
+       case SIDE_TYPE_U32:             /* Fall-through */
+       case SIDE_TYPE_U64:             /* Fall-through */
+       case SIDE_TYPE_S8:              /* Fall-through */
+       case SIDE_TYPE_S16:             /* Fall-through */
+       case SIDE_TYPE_S32:             /* Fall-through */
+       case SIDE_TYPE_S64:
                array_item = item;
                nr_items = 1;
-               side_enum_mappings = type_desc->u.side_enum_bitmap_mappings;
                break;
-       case SIDE_TYPE_ENUM_BITMAP_ARRAY:
-               nr_items = type_desc->u.side_enum_bitmap_array.length;
+       case SIDE_TYPE_ARRAY:
                array_item = item->u.side_array->sav;
-               side_enum_mappings = type_desc->u.side_enum_bitmap_array.mappings;
+               nr_items = type_desc->u.side_array.length;
                break;
-       case SIDE_TYPE_ENUM_BITMAP_VLA:
-               nr_items = item->u.side_vla->len;
+       case SIDE_TYPE_VLA:
                array_item = item->u.side_vla->sav;
-               side_enum_mappings = type_desc->u.side_enum_bitmap_vla.mappings;
+               nr_items = item->u.side_vla->len;
                break;
        default:
+               printf("ERROR: Unexpected enum element type\n");
                abort();
        }
 
@@ -370,9 +367,17 @@ void tracer_print_type(const struct side_type_description *type_desc, const stru
        case SIDE_TYPE_S16:
        case SIDE_TYPE_S32:
        case SIDE_TYPE_S64:
-               if (type_desc->type != item->type && type_desc->type != SIDE_TYPE_ENUM) {
-                       printf("ERROR: type mismatch between description and arguments\n");
-                       abort();
+       case SIDE_TYPE_ARRAY:
+       case SIDE_TYPE_VLA:
+               switch (type_desc->type) {
+               case SIDE_TYPE_ENUM:            /* Fall-through */
+               case SIDE_TYPE_ENUM_BITMAP:
+                       break;
+               default:
+                       if (type_desc->type != item->type) {
+                               printf("ERROR: type mismatch between description and arguments\n");
+                               abort();
+                       }
                }
                break;
 
@@ -384,8 +389,8 @@ void tracer_print_type(const struct side_type_description *type_desc, const stru
                break;
        }
 
-       if (type_desc->type == SIDE_TYPE_ENUM)
-               type = SIDE_TYPE_ENUM;
+       if (type_desc->type == SIDE_TYPE_ENUM || type_desc->type == SIDE_TYPE_ENUM_BITMAP)
+               type = type_desc->type;
        else
                type = item->type;
 
@@ -436,12 +441,7 @@ void tracer_print_type(const struct side_type_description *type_desc, const stru
                print_enum(type_desc, item);
                break;
 
-       case SIDE_TYPE_ENUM_BITMAP8:    /* Fall-through */
-       case SIDE_TYPE_ENUM_BITMAP16:   /* Fall-through */
-       case SIDE_TYPE_ENUM_BITMAP32:   /* Fall-through */
-       case SIDE_TYPE_ENUM_BITMAP64:
-       case SIDE_TYPE_ENUM_BITMAP_ARRAY:
-       case SIDE_TYPE_ENUM_BITMAP_VLA:
+       case SIDE_TYPE_ENUM_BITMAP:
                print_enum_bitmap(type_desc, item);
                break;