Express integer/float/bool size in bytes

0-bit length means use all bits within size.

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

diff --git a/include/side/macros.h b/include/side/macros.h
index f477c47dbf841dc51180a08da10c77e7722872d3..796b708200a573a37aed0aab5562b1690f46467f 100644 (file)
--- a/include/side/macros.h
+++ b/include/side/macros.h
@@ -44,8 +44,8 @@
                (type *)((char *)__ptr - offsetof(type, member));       \
        })
 
-#define side_struct_field_sizeof_bit(_struct, _field) \
-       (sizeof(((_struct * )NULL)->_field) * CHAR_BIT)
+#define side_struct_field_sizeof(_struct, _field) \
+       sizeof(((_struct * )NULL)->_field)
 
 #if defined(__SIZEOF_LONG__)
 #define SIDE_BITS_PER_LONG     (__SIZEOF_LONG__ * 8)

diff --git a/include/side/trace.h b/include/side/trace.h
index 8f4f239b3fe15f713424a5d3f1dc88099b79811b..3708c8c6cd814a64382c7653bd0ba38d5d9faa58 100644 (file)
--- a/include/side/trace.h
+++ b/include/side/trace.h
@@ -288,8 +288,8 @@ 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 */
+       uint16_t bool_size;             /* bytes */
+       uint16_t len_bits;              /* bits. 0 for (bool_size * CHAR_BITS) */
        uint8_t byte_order;             /* enum side_type_label_byte_order */
 } SIDE_PACKED;
 
@@ -306,8 +306,8 @@ struct side_type_string {
 struct side_type_integer {
        const struct side_attr *attr;
        uint32_t nr_attr;
-       uint16_t integer_size_bits;     /* bits */
-       uint16_t len_bits;              /* bits */
+       uint16_t integer_size;          /* bytes */
+       uint16_t len_bits;              /* bits. 0 for (integer_size * CHAR_BITS) */
        uint8_t signedness;             /* true/false */
        uint8_t byte_order;             /* enum side_type_label_byte_order */
 } SIDE_PACKED;
@@ -315,7 +315,7 @@ struct side_type_integer {
 struct side_type_float {
        const struct side_attr *attr;
        uint32_t nr_attr;
-       uint16_t float_size_bits;       /* bits */
+       uint16_t float_size;            /* bytes */
        uint8_t byte_order;             /* enum side_type_label_byte_order */
 } SIDE_PACKED;
 
@@ -742,8 +742,8 @@ struct side_event_description {
                        .side_bool = { \
                                .attr = _attr, \
                                .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
-                               .bool_size_bits = 8, \
-                               .len_bits = 1, \
+                               .bool_size = sizeof(uint8_t), \
+                               .len_bits = 0, \
                                .byte_order = SIDE_TYPE_BYTE_ORDER_HOST, \
                        }, \
                }, \
@@ -776,14 +776,14 @@ struct side_event_description {
                .type = SIDE_TYPE_DYNAMIC, \
        }
 
-#define _side_type_integer(_type, _signedness, _byte_order, _integer_size_bits, _len_bits, _attr) \
+#define _side_type_integer(_type, _signedness, _byte_order, _integer_size, _len_bits, _attr) \
        { \
                .type = _type, \
                .u = { \
                        .side_integer = { \
                                .attr = _attr, \
                                .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
-                               .integer_size_bits = _integer_size_bits, \
+                               .integer_size = _integer_size, \
                                .len_bits = _len_bits, \
                                .signedness = _signedness, \
                                .byte_order = _byte_order, \
@@ -791,14 +791,14 @@ struct side_event_description {
                }, \
        }
 
-#define _side_type_float(_type, _byte_order, _float_size_bits, _attr) \
+#define _side_type_float(_type, _byte_order, _float_size, _attr) \
        { \
                .type = _type, \
                .u = { \
                        .side_float = { \
                                .attr = _attr, \
                                .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
-                               .float_size_bits = _float_size_bits, \
+                               .float_size = _float_size, \
                                .byte_order = _byte_order, \
                        }, \
                }, \
@@ -811,20 +811,19 @@ struct side_event_description {
        }
 
 /* Host endian */
-#define side_type_u8(_attr)                            _side_type_integer(SIDE_TYPE_U8, false, SIDE_TYPE_BYTE_ORDER_HOST, 8, 8, SIDE_PARAM(_attr))
-#define side_type_u16(_attr)                           _side_type_integer(SIDE_TYPE_U16, false, SIDE_TYPE_BYTE_ORDER_HOST, 16, 16, SIDE_PARAM(_attr))
-#define side_type_u32(_attr)                           _side_type_integer(SIDE_TYPE_U32, false, SIDE_TYPE_BYTE_ORDER_HOST, 32, 32, SIDE_PARAM(_attr))
-#define side_type_u64(_attr)                           _side_type_integer(SIDE_TYPE_U64, false, SIDE_TYPE_BYTE_ORDER_HOST, 64, 64, SIDE_PARAM(_attr))
-#define side_type_s8(_attr)                            _side_type_integer(SIDE_TYPE_S8, true, SIDE_TYPE_BYTE_ORDER_HOST, 8, 8, SIDE_PARAM(_attr))
-#define side_type_s16(_attr)                           _side_type_integer(SIDE_TYPE_S16, true, SIDE_TYPE_BYTE_ORDER_HOST, 16, 16, SIDE_PARAM(_attr))
-#define side_type_s32(_attr)                           _side_type_integer(SIDE_TYPE_S32, true, SIDE_TYPE_BYTE_ORDER_HOST, 32, 32, SIDE_PARAM(_attr))
-#define side_type_s64(_attr)                           _side_type_integer(SIDE_TYPE_S64, true, SIDE_TYPE_BYTE_ORDER_HOST, 64, 64, SIDE_PARAM(_attr))
-#define side_type_pointer(_attr)                       _side_type_integer(SIDE_TYPE_POINTER_HOST, false, SIDE_TYPE_BYTE_ORDER_HOST, SIDE_BITS_PER_LONG, \
-                                                                       SIDE_BITS_PER_LONG, SIDE_PARAM(_attr))
-#define side_type_float_binary16(_attr)                        _side_type_float(SIDE_TYPE_FLOAT_BINARY16, SIDE_TYPE_FLOAT_WORD_ORDER_HOST, 16, SIDE_PARAM(_attr))
-#define side_type_float_binary32(_attr)                        _side_type_float(SIDE_TYPE_FLOAT_BINARY32, SIDE_TYPE_FLOAT_WORD_ORDER_HOST, 32, SIDE_PARAM(_attr))
-#define side_type_float_binary64(_attr)                        _side_type_float(SIDE_TYPE_FLOAT_BINARY64, SIDE_TYPE_FLOAT_WORD_ORDER_HOST, 64, SIDE_PARAM(_attr))
-#define side_type_float_binary128(_attr)               _side_type_float(SIDE_TYPE_FLOAT_BINARY128, SIDE_TYPE_FLOAT_WORD_ORDER_HOST, 128, SIDE_PARAM(_attr))
+#define side_type_u8(_attr)                            _side_type_integer(SIDE_TYPE_U8, false, SIDE_TYPE_BYTE_ORDER_HOST, sizeof(uint8_t), 0, SIDE_PARAM(_attr))
+#define side_type_u16(_attr)                           _side_type_integer(SIDE_TYPE_U16, false, SIDE_TYPE_BYTE_ORDER_HOST, sizeof(uint16_t), 0, SIDE_PARAM(_attr))
+#define side_type_u32(_attr)                           _side_type_integer(SIDE_TYPE_U32, false, SIDE_TYPE_BYTE_ORDER_HOST, sizeof(uint32_t), 0, SIDE_PARAM(_attr))
+#define side_type_u64(_attr)                           _side_type_integer(SIDE_TYPE_U64, false, SIDE_TYPE_BYTE_ORDER_HOST, sizeof(uint64_t), 0, SIDE_PARAM(_attr))
+#define side_type_s8(_attr)                            _side_type_integer(SIDE_TYPE_S8, true, SIDE_TYPE_BYTE_ORDER_HOST, sizeof(int8_t), 0, SIDE_PARAM(_attr))
+#define side_type_s16(_attr)                           _side_type_integer(SIDE_TYPE_S16, true, SIDE_TYPE_BYTE_ORDER_HOST, sizeof(int16_t), 0, SIDE_PARAM(_attr))
+#define side_type_s32(_attr)                           _side_type_integer(SIDE_TYPE_S32, true, SIDE_TYPE_BYTE_ORDER_HOST, sizeof(int32_t), 0, SIDE_PARAM(_attr))
+#define side_type_s64(_attr)                           _side_type_integer(SIDE_TYPE_S64, true, SIDE_TYPE_BYTE_ORDER_HOST, sizeof(int64_t), 0, SIDE_PARAM(_attr))
+#define side_type_pointer(_attr)                       _side_type_integer(SIDE_TYPE_POINTER_HOST, false, SIDE_TYPE_BYTE_ORDER_HOST, sizeof(uintptr_t), 0, SIDE_PARAM(_attr))
+#define side_type_float_binary16(_attr)                        _side_type_float(SIDE_TYPE_FLOAT_BINARY16, SIDE_TYPE_FLOAT_WORD_ORDER_HOST, sizeof(_Float16), SIDE_PARAM(_attr))
+#define side_type_float_binary32(_attr)                        _side_type_float(SIDE_TYPE_FLOAT_BINARY32, SIDE_TYPE_FLOAT_WORD_ORDER_HOST, sizeof(_Float32), SIDE_PARAM(_attr))
+#define side_type_float_binary64(_attr)                        _side_type_float(SIDE_TYPE_FLOAT_BINARY64, SIDE_TYPE_FLOAT_WORD_ORDER_HOST, sizeof(_Float64), SIDE_PARAM(_attr))
+#define side_type_float_binary128(_attr)               _side_type_float(SIDE_TYPE_FLOAT_BINARY128, SIDE_TYPE_FLOAT_WORD_ORDER_HOST, sizeof(_Float128), SIDE_PARAM(_attr))
 
 #define side_field_null(_name, _attr)                  _side_field(_name, side_type_null(SIDE_PARAM(_attr)))
 #define side_field_bool(_name, _attr)                  _side_field(_name, side_type_bool(SIDE_PARAM(_attr)))
@@ -846,18 +845,17 @@ struct side_event_description {
 #define side_field_dynamic(_name)                      _side_field(_name, side_type_dynamic())
 
 /* Little endian */
-#define side_type_u16_le(_attr)                                _side_type_integer(SIDE_TYPE_U16, false, SIDE_TYPE_BYTE_ORDER_LE, 16, 16, SIDE_PARAM(_attr))
-#define side_type_u32_le(_attr)                                _side_type_integer(SIDE_TYPE_U32, false, SIDE_TYPE_BYTE_ORDER_LE, 32, 32, SIDE_PARAM(_attr))
-#define side_type_u64_le(_attr)                                _side_type_integer(SIDE_TYPE_U64, false, SIDE_TYPE_BYTE_ORDER_LE, 64, 64, SIDE_PARAM(_attr))
-#define side_type_s16_le(_attr)                                _side_type_integer(SIDE_TYPE_S16, true, SIDE_TYPE_BYTE_ORDER_LE, 16, 16, SIDE_PARAM(_attr))
-#define side_type_s32_le(_attr)                                _side_type_integer(SIDE_TYPE_S32, true, SIDE_TYPE_BYTE_ORDER_LE, 32, 32, SIDE_PARAM(_attr))
-#define side_type_s64_le(_attr)                                _side_type_integer(SIDE_TYPE_S64, true, SIDE_TYPE_BYTE_ORDER_LE, 64, 64, SIDE_PARAM(_attr))
-#define side_type_pointer_le(_attr)                    _side_type_integer(SIDE_TYPE_POINTER_HOST, false, SIDE_TYPE_BYTE_ORDER_LE, SIDE_BITS_PER_LONG, \
-                                                                       SIDE_BITS_PER_LONG, SIDE_PARAM(_attr))
-#define side_type_float_binary16_le(_attr)             _side_type_float(SIDE_TYPE_FLOAT_BINARY16, SIDE_TYPE_BYTE_ORDER_LE, 16, SIDE_PARAM(_attr))
-#define side_type_float_binary32_le(_attr)             _side_type_float(SIDE_TYPE_FLOAT_BINARY32, SIDE_TYPE_BYTE_ORDER_LE, 32, SIDE_PARAM(_attr))
-#define side_type_float_binary64_le(_attr)             _side_type_float(SIDE_TYPE_FLOAT_BINARY64, SIDE_TYPE_BYTE_ORDER_LE, 64, SIDE_PARAM(_attr))
-#define side_type_float_binary128_le(_attr)            _side_type_float(SIDE_TYPE_FLOAT_BINARY128, SIDE_TYPE_BYTE_ORDER_LE, 128, SIDE_PARAM(_attr))
+#define side_type_u16_le(_attr)                                _side_type_integer(SIDE_TYPE_U16, false, SIDE_TYPE_BYTE_ORDER_LE, sizeof(uint16_t), 0, SIDE_PARAM(_attr))
+#define side_type_u32_le(_attr)                                _side_type_integer(SIDE_TYPE_U32, false, SIDE_TYPE_BYTE_ORDER_LE, sizeof(uint32_t), 0, SIDE_PARAM(_attr))
+#define side_type_u64_le(_attr)                                _side_type_integer(SIDE_TYPE_U64, false, SIDE_TYPE_BYTE_ORDER_LE, sizeof(uint64_t), 0, SIDE_PARAM(_attr))
+#define side_type_s16_le(_attr)                                _side_type_integer(SIDE_TYPE_S16, true, SIDE_TYPE_BYTE_ORDER_LE, sizeof(int16_t), 0, SIDE_PARAM(_attr))
+#define side_type_s32_le(_attr)                                _side_type_integer(SIDE_TYPE_S32, true, SIDE_TYPE_BYTE_ORDER_LE, sizeof(int32_t), 0, SIDE_PARAM(_attr))
+#define side_type_s64_le(_attr)                                _side_type_integer(SIDE_TYPE_S64, true, SIDE_TYPE_BYTE_ORDER_LE, sizeof(int64_t), 0, SIDE_PARAM(_attr))
+#define side_type_pointer_le(_attr)                    _side_type_integer(SIDE_TYPE_POINTER_HOST, false, SIDE_TYPE_BYTE_ORDER_LE, sizeof(uintptr_t), 0, SIDE_PARAM(_attr))
+#define side_type_float_binary16_le(_attr)             _side_type_float(SIDE_TYPE_FLOAT_BINARY16, SIDE_TYPE_BYTE_ORDER_LE, sizeof(_Float16), SIDE_PARAM(_attr))
+#define side_type_float_binary32_le(_attr)             _side_type_float(SIDE_TYPE_FLOAT_BINARY32, SIDE_TYPE_BYTE_ORDER_LE, sizeof(_Float32), SIDE_PARAM(_attr))
+#define side_type_float_binary64_le(_attr)             _side_type_float(SIDE_TYPE_FLOAT_BINARY64, SIDE_TYPE_BYTE_ORDER_LE, sizeof(_Float64), SIDE_PARAM(_attr))
+#define side_type_float_binary128_le(_attr)            _side_type_float(SIDE_TYPE_FLOAT_BINARY128, SIDE_TYPE_BYTE_ORDER_LE, sizeof(_Float128), SIDE_PARAM(_attr))
 
 #define side_field_u16_le(_name, _attr)                        _side_field(_name, side_type_u16_le(SIDE_PARAM(_attr)))
 #define side_field_u32_le(_name, _attr)                        _side_field(_name, side_type_u32_le(SIDE_PARAM(_attr)))
@@ -872,18 +870,18 @@ struct side_event_description {
 #define side_field_float_binary128_le(_name, _attr)    _side_field(_name, side_type_float_binary128_le(SIDE_PARAM(_attr)))
 
 /* Big endian */
-#define side_type_u16_be(_attr)                                _side_type_integer(SIDE_TYPE_U16, false, SIDE_TYPE_BYTE_ORDER_BE, 16, 16, SIDE_PARAM(_attr))
-#define side_type_u32_be(_attr)                                _side_type_integer(SIDE_TYPE_U32, false, SIDE_TYPE_BYTE_ORDER_BE, 32, 32, SIDE_PARAM(_attr))
-#define side_type_u64_be(_attr)                                _side_type_integer(SIDE_TYPE_U64, false, SIDE_TYPE_BYTE_ORDER_BE, 64, 64, SIDE_PARAM(_attr))
-#define side_type_s16_be(_attr)                                _side_type_integer(SIDE_TYPE_S16, false, SIDE_TYPE_BYTE_ORDER_BE, 16, 16, SIDE_PARAM(_attr))
-#define side_type_s32_be(_attr)                                _side_type_integer(SIDE_TYPE_S32, false, SIDE_TYPE_BYTE_ORDER_BE, 32, 32, SIDE_PARAM(_attr))
-#define side_type_s64_be(_attr)                                _side_type_integer(SIDE_TYPE_S64, false, SIDE_TYPE_BYTE_ORDER_BE, 64, 64, SIDE_PARAM(_attr))
+#define side_type_u16_be(_attr)                                _side_type_integer(SIDE_TYPE_U16, false, SIDE_TYPE_BYTE_ORDER_BE, sizeof(uint16_t), 0, SIDE_PARAM(_attr))
+#define side_type_u32_be(_attr)                                _side_type_integer(SIDE_TYPE_U32, false, SIDE_TYPE_BYTE_ORDER_BE, sizeof(uint32_t), 0, SIDE_PARAM(_attr))
+#define side_type_u64_be(_attr)                                _side_type_integer(SIDE_TYPE_U64, false, SIDE_TYPE_BYTE_ORDER_BE, sizeof(uint64_t), 0, SIDE_PARAM(_attr))
+#define side_type_s16_be(_attr)                                _side_type_integer(SIDE_TYPE_S16, false, SIDE_TYPE_BYTE_ORDER_BE, sizeof(int16_t), 0, SIDE_PARAM(_attr))
+#define side_type_s32_be(_attr)                                _side_type_integer(SIDE_TYPE_S32, false, SIDE_TYPE_BYTE_ORDER_BE, sizeof(int32_t), 0, SIDE_PARAM(_attr))
+#define side_type_s64_be(_attr)                                _side_type_integer(SIDE_TYPE_S64, false, SIDE_TYPE_BYTE_ORDER_BE, sizeof(int64_t), 0, SIDE_PARAM(_attr))
 #define side_type_pointer_be(_attr)                    _side_type_integer(SIDE_TYPE_POINTER_HOST, false, SIDE_TYPE_BYTE_ORDER_BE, SIDE_BITS_PER_LONG, \
                                                                        SIDE_BITS_PER_LONG, SIDE_PARAM(_attr))
-#define side_type_float_binary16_be(_attr)             _side_type_float(SIDE_TYPE_FLOAT_BINARY16, SIDE_TYPE_BYTE_ORDER_BE, 16, SIDE_PARAM(_attr))
-#define side_type_float_binary32_be(_attr)             _side_type_float(SIDE_TYPE_FLOAT_BINARY32, SIDE_TYPE_BYTE_ORDER_BE, 32, SIDE_PARAM(_attr))
-#define side_type_float_binary64_be(_attr)             _side_type_float(SIDE_TYPE_FLOAT_BINARY64, SIDE_TYPE_BYTE_ORDER_BE, 64, SIDE_PARAM(_attr))
-#define side_type_float_binary128_be(_attr)            _side_type_float(SIDE_TYPE_FLOAT_BINARY128, SIDE_TYPE_BYTE_ORDER_BE, 128, SIDE_PARAM(_attr))
+#define side_type_float_binary16_be(_attr)             _side_type_float(SIDE_TYPE_FLOAT_BINARY16, SIDE_TYPE_BYTE_ORDER_BE, sizeof(_Float16), SIDE_PARAM(_attr))
+#define side_type_float_binary32_be(_attr)             _side_type_float(SIDE_TYPE_FLOAT_BINARY32, SIDE_TYPE_BYTE_ORDER_BE, sizeof(_Float32), SIDE_PARAM(_attr))
+#define side_type_float_binary64_be(_attr)             _side_type_float(SIDE_TYPE_FLOAT_BINARY64, SIDE_TYPE_BYTE_ORDER_BE, sizeof(_Float64), SIDE_PARAM(_attr))
+#define side_type_float_binary128_be(_attr)            _side_type_float(SIDE_TYPE_FLOAT_BINARY128, SIDE_TYPE_BYTE_ORDER_BE, sizeof(_Float128), SIDE_PARAM(_attr))
 
 #define side_field_u16_be(_name, _attr)                        _side_field(_name, side_type_u16_be(SIDE_PARAM(_attr)))
 #define side_field_u32_be(_name, _attr)                        _side_field(_name, side_type_u32_be(SIDE_PARAM(_attr)))
@@ -1015,7 +1013,7 @@ 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) \
+#define _side_type_gather_bool(_byte_order, _offset, _bool_size, _offset_bits, _len_bits, _access_mode, _attr) \
        { \
                .type = SIDE_TYPE_GATHER_BOOL, \
                .u = { \
@@ -1027,7 +1025,7 @@ struct side_event_description {
                                                .type = { \
                                                        .attr = _attr, \
                                                        .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
-                                                       .bool_size_bits = _bool_size_bits, \
+                                                       .bool_size = _bool_size, \
                                                        .len_bits = _len_bits, \
                                                        .byte_order = _byte_order, \
                                                }, \
@@ -1037,22 +1035,22 @@ struct side_event_description {
                        }, \
                }, \
        }
-#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_bool(_offset, _bool_size, _offset_bits, _len_bits, _access_mode, _attr) \
+       _side_type_gather_bool(SIDE_TYPE_BYTE_ORDER_HOST, _offset, _bool_size, _offset_bits, _len_bits, _access_mode, _attr)
+#define side_type_gather_bool_le(_offset, _bool_size, _offset_bits, _len_bits, _access_mode, _attr) \
+       _side_type_gather_bool(SIDE_TYPE_BYTE_ORDER_LE, _offset, _bool_size, _offset_bits, _len_bits, _access_mode, _attr)
+#define side_type_gather_bool_be(_offset, _bool_size, _offset_bits, _len_bits, _access_mode, _attr) \
+       _side_type_gather_bool(SIDE_TYPE_BYTE_ORDER_BE, _offset, _bool_size, _offset_bits, _len_bits, _access_mode, _attr)
+
+#define side_field_gather_bool(_name, _offset, _bool_size, _offset_bits, _len_bits, _access_mode, _attr) \
+       _side_field(_name, side_type_gather_bool(_offset, _bool_size, _offset_bits, _len_bits, _access_mode, SIDE_PARAM(_attr)))
+#define side_field_gather_bool_le(_name, _offset, _bool_size, _offset_bits, _len_bits, _access_mode, _attr) \
+       _side_field(_name, side_type_gather_bool_le(_offset, _bool_size, _offset_bits, _len_bits, _access_mode, SIDE_PARAM(_attr)))
+#define side_field_gather_bool_be(_name, _offset, _bool_size, _offset_bits, _len_bits, _access_mode, _attr) \
+       _side_field(_name, side_type_gather_bool_be(_offset, _bool_size, _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) \
+               _integer_size, _offset_bits, _len_bits, _access_mode, _attr) \
        { \
                .type = _type, \
                .u = { \
@@ -1064,7 +1062,7 @@ struct side_event_description {
                                                .type = { \
                                                        .attr = _attr, \
                                                        .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
-                                                       .integer_size_bits = _integer_size_bits, \
+                                                       .integer_size = _integer_size, \
                                                        .len_bits = _len_bits, \
                                                        .signedness = _signedness, \
                                                        .byte_order = _byte_order, \
@@ -1076,43 +1074,43 @@ struct side_event_description {
                }, \
        }
 
-#define side_type_gather_unsigned_integer(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, _attr) \
+#define side_type_gather_unsigned_integer(_integer_offset, _integer_size, _offset_bits, _len_bits, _access_mode, _attr) \
        _side_type_gather_integer(SIDE_TYPE_GATHER_UNSIGNED_INT, false,  SIDE_TYPE_BYTE_ORDER_HOST, \
-                       _integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, SIDE_PARAM(_attr))
-#define side_type_gather_signed_integer(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, _attr) \
+                       _integer_offset, _integer_size, _offset_bits, _len_bits, _access_mode, SIDE_PARAM(_attr))
+#define side_type_gather_signed_integer(_integer_offset, _integer_size, _offset_bits, _len_bits, _access_mode, _attr) \
        _side_type_gather_integer(SIDE_TYPE_GATHER_SIGNED_INT, true, SIDE_TYPE_BYTE_ORDER_HOST, \
-                       _integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, SIDE_PARAM(_attr))
+                       _integer_offset, _integer_size, _offset_bits, _len_bits, _access_mode, SIDE_PARAM(_attr))
 
-#define side_type_gather_unsigned_integer_le(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, _attr) \
+#define side_type_gather_unsigned_integer_le(_integer_offset, _integer_size, _offset_bits, _len_bits, _access_mode, _attr) \
        _side_type_gather_integer(SIDE_TYPE_GATHER_UNSIGNED_INT, false,  SIDE_TYPE_BYTE_ORDER_LE, \
-                       _integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, SIDE_PARAM(_attr))
-#define side_type_gather_signed_integer_le(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, _attr) \
+                       _integer_offset, _integer_size, _offset_bits, _len_bits, _access_mode, SIDE_PARAM(_attr))
+#define side_type_gather_signed_integer_le(_integer_offset, _integer_size, _offset_bits, _len_bits, _access_mode, _attr) \
        _side_type_gather_integer(SIDE_TYPE_GATHER_SIGNED_INT, true, SIDE_TYPE_BYTE_ORDER_LE, \
-                       _integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, SIDE_PARAM(_attr))
+                       _integer_offset, _integer_size, _offset_bits, _len_bits, _access_mode, SIDE_PARAM(_attr))
 
-#define side_type_gather_unsigned_integer_be(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, _attr) \
+#define side_type_gather_unsigned_integer_be(_integer_offset, _integer_size, _offset_bits, _len_bits, _access_mode, _attr) \
        _side_type_gather_integer(SIDE_TYPE_GATHER_UNSIGNED_INT, false,  SIDE_TYPE_BYTE_ORDER_BE, \
-                       _integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, SIDE_PARAM(_attr))
-#define side_type_gather_signed_integer_be(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, _attr) \
+                       _integer_offset, _integer_size, _offset_bits, _len_bits, _access_mode, SIDE_PARAM(_attr))
+#define side_type_gather_signed_integer_be(_integer_offset, _integer_size, _offset_bits, _len_bits, _access_mode, _attr) \
        _side_type_gather_integer(SIDE_TYPE_GATHER_SIGNED_INT, true, SIDE_TYPE_BYTE_ORDER_BE, \
-                       _integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, SIDE_PARAM(_attr))
+                       _integer_offset, _integer_size, _offset_bits, _len_bits, _access_mode, SIDE_PARAM(_attr))
 
-#define side_field_gather_unsigned_integer(_name, _integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, _attr) \
-       _side_field(_name, side_type_gather_unsigned_integer(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, SIDE_PARAM(_attr)))
-#define side_field_gather_signed_integer(_name, _integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, _attr) \
-       _side_field(_name, side_type_gather_signed_integer(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, SIDE_PARAM(_attr)))
+#define side_field_gather_unsigned_integer(_name, _integer_offset, _integer_size, _offset_bits, _len_bits, _access_mode, _attr) \
+       _side_field(_name, side_type_gather_unsigned_integer(_integer_offset, _integer_size, _offset_bits, _len_bits, _access_mode, SIDE_PARAM(_attr)))
+#define side_field_gather_signed_integer(_name, _integer_offset, _integer_size, _offset_bits, _len_bits, _access_mode, _attr) \
+       _side_field(_name, side_type_gather_signed_integer(_integer_offset, _integer_size, _offset_bits, _len_bits, _access_mode, SIDE_PARAM(_attr)))
 
-#define side_field_gather_unsigned_integer_le(_name, _integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, _attr) \
-       _side_field(_name, side_type_gather_unsigned_integer_le(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, SIDE_PARAM(_attr)))
-#define side_field_gather_signed_integer_le(_name, _integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, _attr) \
-       _side_field(_name, side_type_gather_signed_integer_le(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, SIDE_PARAM(_attr)))
+#define side_field_gather_unsigned_integer_le(_name, _integer_offset, _integer_size, _offset_bits, _len_bits, _access_mode, _attr) \
+       _side_field(_name, side_type_gather_unsigned_integer_le(_integer_offset, _integer_size, _offset_bits, _len_bits, _access_mode, SIDE_PARAM(_attr)))
+#define side_field_gather_signed_integer_le(_name, _integer_offset, _integer_size, _offset_bits, _len_bits, _access_mode, _attr) \
+       _side_field(_name, side_type_gather_signed_integer_le(_integer_offset, _integer_size, _offset_bits, _len_bits, _access_mode, SIDE_PARAM(_attr)))
 
-#define side_field_gather_unsigned_integer_be(_name, _integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, _attr) \
-       _side_field(_name, side_type_gather_unsigned_integer_be(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, SIDE_PARAM(_attr)))
-#define side_field_gather_signed_integer_be(_name, _integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, _attr) \
-       _side_field(_name, side_type_gather_signed_integer_be(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, SIDE_PARAM(_attr)))
+#define side_field_gather_unsigned_integer_be(_name, _integer_offset, _integer_size, _offset_bits, _len_bits, _access_mode, _attr) \
+       _side_field(_name, side_type_gather_unsigned_integer_be(_integer_offset, _integer_size, _offset_bits, _len_bits, _access_mode, SIDE_PARAM(_attr)))
+#define side_field_gather_signed_integer_be(_name, _integer_offset, _integer_size, _offset_bits, _len_bits, _access_mode, _attr) \
+       _side_field(_name, side_type_gather_signed_integer_be(_integer_offset, _integer_size, _offset_bits, _len_bits, _access_mode, SIDE_PARAM(_attr)))
 
-#define _side_type_gather_float(_byte_order, _offset, _float_size_bits, _access_mode, _attr) \
+#define _side_type_gather_float(_byte_order, _offset, _float_size, _access_mode, _attr) \
        { \
                .type = SIDE_TYPE_GATHER_FLOAT, \
                .u = { \
@@ -1124,7 +1122,7 @@ struct side_event_description {
                                                .type = { \
                                                        .attr = _attr, \
                                                        .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
-                                                       .float_size_bits = _float_size_bits, \
+                                                       .float_size = _float_size, \
                                                        .byte_order = _byte_order, \
                                                }, \
                                        }, \
@@ -1133,19 +1131,19 @@ struct side_event_description {
                }, \
        }
 
-#define side_type_gather_float(_offset, _float_size_bits, _access_mode, _attr) \
-       _side_type_gather_float(SIDE_TYPE_FLOAT_WORD_ORDER_HOST, _offset, _float_size_bits, _access_mode, _attr)
-#define side_type_gather_float_le(_offset, _float_size_bits, _access_mode, _attr) \
-       _side_type_gather_float(SIDE_TYPE_BYTE_ORDER_LE, _offset, _float_size_bits, _access_mode, _attr)
-#define side_type_gather_float_be(_offset, _float_size_bits, _access_mode, _attr) \
-       _side_type_gather_float(SIDE_TYPE_BYTE_ORDER_BE, _offset, _float_size_bits, _access_mode, _attr)
+#define side_type_gather_float(_offset, _float_size, _access_mode, _attr) \
+       _side_type_gather_float(SIDE_TYPE_FLOAT_WORD_ORDER_HOST, _offset, _float_size, _access_mode, _attr)
+#define side_type_gather_float_le(_offset, _float_size, _access_mode, _attr) \
+       _side_type_gather_float(SIDE_TYPE_BYTE_ORDER_LE, _offset, _float_size, _access_mode, _attr)
+#define side_type_gather_float_be(_offset, _float_size, _access_mode, _attr) \
+       _side_type_gather_float(SIDE_TYPE_BYTE_ORDER_BE, _offset, _float_size, _access_mode, _attr)
 
-#define side_field_gather_float(_name, _offset, _float_size_bits, _access_mode, _attr) \
-       _side_field(_name, side_type_gather_float(_offset, _float_size_bits, _access_mode, _attr))
-#define side_field_gather_float_le(_name, _offset, _float_size_bits, _access_mode, _attr) \
-       _side_field(_name, side_type_gather_float_le(_offset, _float_size_bits, _access_mode, _attr))
-#define side_field_gather_float_be(_name, _offset, _float_size_bits, _access_mode, _attr) \
-       _side_field(_name, side_type_gather_float_be(_offset, _float_size_bits, _access_mode, _attr))
+#define side_field_gather_float(_name, _offset, _float_size, _access_mode, _attr) \
+       _side_field(_name, side_type_gather_float(_offset, _float_size, _access_mode, _attr))
+#define side_field_gather_float_le(_name, _offset, _float_size, _access_mode, _attr) \
+       _side_field(_name, side_type_gather_float_le(_offset, _float_size, _access_mode, _attr))
+#define side_field_gather_float_be(_name, _offset, _float_size, _access_mode, _attr) \
+       _side_field(_name, side_type_gather_float_be(_offset, _float_size, _access_mode, _attr))
 
 #define side_type_gather_struct(_struct_gather, _offset, _size, _access_mode) \
        { \
@@ -1288,8 +1286,8 @@ 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, \
+                                               .bool_size = sizeof(uint8_t), \
+                                               .len_bits = 0, \
                                                .byte_order = SIDE_TYPE_BYTE_ORDER_HOST, \
                                        }, \
                                        .value = { \
@@ -1331,7 +1329,7 @@ struct side_event_description {
                }, \
        }
 
-#define _side_arg_dynamic_integer(_field, _val, _type, _signedness, _byte_order, _integer_size_bits, _len_bits, _attr) \
+#define _side_arg_dynamic_integer(_field, _val, _type, _signedness, _byte_order, _integer_size, _len_bits, _attr) \
        { \
                .type = _type, \
                .u = { \
@@ -1340,7 +1338,7 @@ struct side_event_description {
                                        .type = { \
                                                .attr = _attr, \
                                                .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
-                                               .integer_size_bits = _integer_size_bits, \
+                                               .integer_size = _integer_size, \
                                                .len_bits = _len_bits, \
                                                .signedness = _signedness, \
                                                .byte_order = _byte_order, \
@@ -1354,29 +1352,29 @@ struct side_event_description {
        }
 
 #define side_arg_dynamic_u8(_val, _attr) \
-       _side_arg_dynamic_integer(.side_u8, _val, SIDE_TYPE_DYNAMIC_U8, false, SIDE_TYPE_BYTE_ORDER_HOST, 8, 8, SIDE_PARAM(_attr))
+       _side_arg_dynamic_integer(.side_u8, _val, SIDE_TYPE_DYNAMIC_U8, false, SIDE_TYPE_BYTE_ORDER_HOST, sizeof(uint8_t), 0, SIDE_PARAM(_attr))
 #define side_arg_dynamic_s8(_val, _attr) \
-       _side_arg_dynamic_integer(.side_s8, _val, SIDE_TYPE_DYNAMIC_S8, true, SIDE_TYPE_BYTE_ORDER_HOST, 8, 8, SIDE_PARAM(_attr))
+       _side_arg_dynamic_integer(.side_s8, _val, SIDE_TYPE_DYNAMIC_S8, true, SIDE_TYPE_BYTE_ORDER_HOST, sizeof(int8_t), 0, SIDE_PARAM(_attr))
 
 #define _side_arg_dynamic_u16(_val, _byte_order, _attr) \
-       _side_arg_dynamic_integer(.side_u16, _val, SIDE_TYPE_DYNAMIC_U16, false, _byte_order, 16, 16, SIDE_PARAM(_attr))
+       _side_arg_dynamic_integer(.side_u16, _val, SIDE_TYPE_DYNAMIC_U16, false, _byte_order, sizeof(uint16_t), 0, SIDE_PARAM(_attr))
 #define _side_arg_dynamic_u32(_val, _byte_order, _attr) \
-       _side_arg_dynamic_integer(.side_u32, _val, SIDE_TYPE_DYNAMIC_U32, false, _byte_order, 32, 32, SIDE_PARAM(_attr))
+       _side_arg_dynamic_integer(.side_u32, _val, SIDE_TYPE_DYNAMIC_U32, false, _byte_order, sizeof(uint32_t), 0, SIDE_PARAM(_attr))
 #define _side_arg_dynamic_u64(_val, _byte_order, _attr) \
-       _side_arg_dynamic_integer(.side_u64, _val, SIDE_TYPE_DYNAMIC_U64, false, _byte_order, 64, 64, SIDE_PARAM(_attr))
+       _side_arg_dynamic_integer(.side_u64, _val, SIDE_TYPE_DYNAMIC_U64, false, _byte_order, sizeof(uint64_t), 0, SIDE_PARAM(_attr))
 
 #define _side_arg_dynamic_s16(_val, _byte_order, _attr) \
-       _side_arg_dynamic_integer(.side_s16, _val, SIDE_TYPE_DYNAMIC_S16, true, _byte_order, 16, 16, SIDE_PARAM(_attr))
+       _side_arg_dynamic_integer(.side_s16, _val, SIDE_TYPE_DYNAMIC_S16, true, _byte_order, sizeof(int16_t), 0, SIDE_PARAM(_attr))
 #define _side_arg_dynamic_s32(_val, _byte_order, _attr) \
-       _side_arg_dynamic_integer(.side_s32, _val, SIDE_TYPE_DYNAMIC_S32, true, _byte_order, 32, 32, SIDE_PARAM(_attr))
+       _side_arg_dynamic_integer(.side_s32, _val, SIDE_TYPE_DYNAMIC_S32, true, _byte_order, sizeof(int32_t), 0, SIDE_PARAM(_attr))
 #define _side_arg_dynamic_s64(_val, _byte_order, _attr) \
-       _side_arg_dynamic_integer(.side_s64, _val, SIDE_TYPE_DYNAMIC_S64, true, _byte_order, 64, 64, SIDE_PARAM(_attr))
+       _side_arg_dynamic_integer(.side_s64, _val, SIDE_TYPE_DYNAMIC_S64, true, _byte_order, sizeof(int64_t), 0, SIDE_PARAM(_attr))
 
 #define _side_arg_dynamic_pointer(_val, _byte_order, _attr) \
        _side_arg_dynamic_integer(SIDE_PTR_HOST, (uintptr_t) (_val), SIDE_TYPE_DYNAMIC_POINTER_HOST, false, _byte_order, \
-                       SIDE_BITS_PER_LONG, SIDE_BITS_PER_LONG, SIDE_PARAM(_attr))
+                       sizeof(uintptr_t), 0, SIDE_PARAM(_attr))
 
-#define _side_arg_dynamic_float(_field, _val, _type, _byte_order, _float_size_bits, _attr) \
+#define _side_arg_dynamic_float(_field, _val, _type, _byte_order, _float_size, _attr) \
        { \
                .type = _type, \
                .u = { \
@@ -1385,7 +1383,7 @@ struct side_event_description {
                                        .type = { \
                                                .attr = _attr, \
                                                .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
-                                               .float_size_bits = _float_size_bits, \
+                                               .float_size = _float_size, \
                                                .byte_order = _byte_order, \
                                        }, \
                                        .value = { \
@@ -1397,13 +1395,13 @@ struct side_event_description {
        }
 
 #define _side_arg_dynamic_float_binary16(_val, _byte_order, _attr) \
-       _side_arg_dynamic_float(.side_float_binary16, _val, SIDE_TYPE_DYNAMIC_FLOAT_BINARY16, _byte_order, 16, SIDE_PARAM(_attr))
+       _side_arg_dynamic_float(.side_float_binary16, _val, SIDE_TYPE_DYNAMIC_FLOAT_BINARY16, _byte_order, sizeof(_Float16), SIDE_PARAM(_attr))
 #define _side_arg_dynamic_float_binary32(_val, _byte_order, _attr) \
-       _side_arg_dynamic_float(.side_float_binary32, _val, SIDE_TYPE_DYNAMIC_FLOAT_BINARY32, _byte_order, 32, SIDE_PARAM(_attr))
+       _side_arg_dynamic_float(.side_float_binary32, _val, SIDE_TYPE_DYNAMIC_FLOAT_BINARY32, _byte_order, sizeof(_Float32), SIDE_PARAM(_attr))
 #define _side_arg_dynamic_float_binary64(_val, _byte_order, _attr) \
-       _side_arg_dynamic_float(.side_float_binary64, _val, SIDE_TYPE_DYNAMIC_FLOAT_BINARY64, _byte_order, 64, SIDE_PARAM(_attr))
+       _side_arg_dynamic_float(.side_float_binary64, _val, SIDE_TYPE_DYNAMIC_FLOAT_BINARY64, _byte_order, sizeof(_Float64), SIDE_PARAM(_attr))
 #define _side_arg_dynamic_float_binary128(_val, _byte_order, _attr) \
-       _side_arg_dynamic_float(.side_float_binary128, _val, SIDE_TYPE_DYNAMIC_FLOAT_BINARY128, _byte_order, 128, SIDE_PARAM(_attr))
+       _side_arg_dynamic_float(.side_float_binary128, _val, SIDE_TYPE_DYNAMIC_FLOAT_BINARY128, _byte_order, sizeof(_Float128), SIDE_PARAM(_attr))
 
 /* Host endian */
 #define side_arg_dynamic_u16(_val, _attr)              _side_arg_dynamic_u16(_val, SIDE_TYPE_BYTE_ORDER_HOST, SIDE_PARAM(_attr))

diff --git a/src/test.c b/src/test.c
index c29ddc3251588758430fd5b457213963fc27e74b..470713e84a79c1b0875414264b6919cc28893c40 100644 (file)
--- a/src/test.c
+++ b/src/test.c
@@ -1438,40 +1438,40 @@ struct test {
 static side_define_struct(mystructgatherdef,
        side_field_list(
                side_field_gather_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_TYPE_GATHER_ACCESS_DIRECT, side_attr_list()),
+                       side_struct_field_sizeof(struct test, a), 0, 0,
+                       SIDE_TYPE_GATHER_ACCESS_DIRECT, side_attr_list()),
                side_field_gather_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_TYPE_GATHER_ACCESS_DIRECT, side_attr_list()),
+                       side_struct_field_sizeof(struct test, d), 0, 0,
+                       SIDE_TYPE_GATHER_ACCESS_DIRECT, side_attr_list()),
                side_field_gather_unsigned_integer("e", offsetof(struct test, e),
-                       side_struct_field_sizeof_bit(struct test, e), 8, 4,
+                       side_struct_field_sizeof(struct test, e), 8, 4,
                        SIDE_TYPE_GATHER_ACCESS_DIRECT, side_attr_list(side_attr("std.integer.base", side_attr_u8(16)))),
                side_field_gather_signed_integer("f", offsetof(struct test, f),
-                       side_struct_field_sizeof_bit(struct test, f), 1, 4,
+                       side_struct_field_sizeof(struct test, f), 1, 4,
                        SIDE_TYPE_GATHER_ACCESS_DIRECT, side_attr_list(side_attr("std.integer.base", side_attr_u8(10)))),
                side_field_gather_signed_integer("g", offsetof(struct test, g),
-                       side_struct_field_sizeof_bit(struct test, g), 11, 4,
+                       side_struct_field_sizeof(struct test, g), 11, 4,
                        SIDE_TYPE_GATHER_ACCESS_DIRECT, side_attr_list(side_attr("std.integer.base", side_attr_u8(10)))),
                side_field_gather_signed_integer("h", offsetof(struct test, h),
-                       side_struct_field_sizeof_bit(struct test, h), 1, 31,
+                       side_struct_field_sizeof(struct test, h), 1, 31,
                        SIDE_TYPE_GATHER_ACCESS_DIRECT, side_attr_list(side_attr("std.integer.base", side_attr_u8(10)))),
                side_field_gather_signed_integer("i", offsetof(struct test, i),
-                       side_struct_field_sizeof_bit(struct test, i), 33, 20,
+                       side_struct_field_sizeof(struct test, i), 33, 20,
                        SIDE_TYPE_GATHER_ACCESS_DIRECT, side_attr_list(side_attr("std.integer.base", side_attr_u8(10)))),
                side_field_gather_signed_integer("j", offsetof(struct test, j),
-                       side_struct_field_sizeof_bit(struct test, j), 63, 1,
+                       side_struct_field_sizeof(struct test, j), 63, 1,
                        SIDE_TYPE_GATHER_ACCESS_DIRECT, side_attr_list(side_attr("std.integer.base", side_attr_u8(10)))),
                side_field_gather_signed_integer("k", offsetof(struct test, k), 
-                       side_struct_field_sizeof_bit(struct test, k), 1, 63,
+                       side_struct_field_sizeof(struct test, k), 1, 63,
                        SIDE_TYPE_GATHER_ACCESS_DIRECT, side_attr_list(side_attr("std.integer.base", side_attr_u8(10)))),
                side_field_gather_unsigned_integer_le("test", offsetof(struct test, test),
-                       side_struct_field_sizeof_bit(struct test, test), 0, 64,
+                       side_struct_field_sizeof(struct test, test), 0, 64,
                        SIDE_TYPE_GATHER_ACCESS_DIRECT, side_attr_list(side_attr("std.integer.base", side_attr_u8(16)))),
                side_field_gather_unsigned_integer_le("test_le", offsetof(struct test, test),
-                       side_struct_field_sizeof_bit(struct test, test), 0, 64,
+                       side_struct_field_sizeof(struct test, test), 0, 64,
                        SIDE_TYPE_GATHER_ACCESS_DIRECT, side_attr_list(side_attr("std.integer.base", side_attr_u8(16)))),
                side_field_gather_unsigned_integer_be("test_be", offsetof(struct test, test),
-                       side_struct_field_sizeof_bit(struct test, test), 0, 64,
+                       side_struct_field_sizeof(struct test, test), 0, 64,
                        SIDE_TYPE_GATHER_ACCESS_DIRECT, side_attr_list(side_attr("std.integer.base", side_attr_u8(16)))),
        ),
        side_attr_list()
@@ -1481,10 +1481,10 @@ side_static_event(my_provider_event_structgather, "myprovider", "myeventstructga
        side_field_list(
                side_field_gather_struct("structgather", &mystructgatherdef, 0, sizeof(struct test),
                                SIDE_TYPE_GATHER_ACCESS_DIRECT),
-               side_field_gather_signed_integer("intgather", 0, 32, 0, 32, SIDE_TYPE_GATHER_ACCESS_DIRECT,
+               side_field_gather_signed_integer("intgather", 0, sizeof(int32_t), 0, 0, SIDE_TYPE_GATHER_ACCESS_DIRECT,
                        side_attr_list(side_attr("std.integer.base", side_attr_u8(10)))),
 #if __HAVE_FLOAT32
-               side_field_gather_float("f32", 0, 32, SIDE_TYPE_GATHER_ACCESS_DIRECT, side_attr_list()),
+               side_field_gather_float("f32", 0, sizeof(_Float32), SIDE_TYPE_GATHER_ACCESS_DIRECT, side_attr_list()),
 #endif
        ),
        side_attr_list()
@@ -1541,8 +1541,8 @@ struct testnest0 {
 static side_define_struct(mystructgathernest2,
        side_field_list(
                side_field_gather_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_TYPE_GATHER_ACCESS_DIRECT, side_attr_list()),
+                       side_struct_field_sizeof(struct testnest2, c), 0, 0,
+                       SIDE_TYPE_GATHER_ACCESS_DIRECT, side_attr_list()),
        ),
        side_attr_list()
 );
@@ -1550,8 +1550,8 @@ static side_define_struct(mystructgathernest2,
 static side_define_struct(mystructgathernest1,
        side_field_list(
                side_field_gather_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_TYPE_GATHER_ACCESS_DIRECT, side_attr_list()),
+                       side_struct_field_sizeof(struct testnest1, b), 0, 0,
+                       SIDE_TYPE_GATHER_ACCESS_DIRECT, side_attr_list()),
                side_field_gather_struct("nest2", &mystructgathernest2,
                        offsetof(struct testnest1, nest), sizeof(struct testnest2),
                        SIDE_TYPE_GATHER_ACCESS_POINTER),
@@ -1562,8 +1562,8 @@ static side_define_struct(mystructgathernest1,
 static side_define_struct(mystructgathernest0,
        side_field_list(
                side_field_gather_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_TYPE_GATHER_ACCESS_DIRECT, side_attr_list()),
+                       side_struct_field_sizeof(struct testnest0, a), 0, 0,
+                       SIDE_TYPE_GATHER_ACCESS_DIRECT, side_attr_list()),
                side_field_gather_struct("nest1", &mystructgathernest1,
                        offsetof(struct testnest0, nest), sizeof(struct testnest1),
                        SIDE_TYPE_GATHER_ACCESS_POINTER),
@@ -1621,22 +1621,22 @@ struct testfloat {
 static side_define_struct(mystructgatherfloat,
        side_field_list(
 #if __HAVE_FLOAT16
-               side_field_gather_float("f16", offsetof(struct testfloat, f16), 16,
+               side_field_gather_float("f16", offsetof(struct testfloat, f16), side_struct_field_sizeof(struct testfloat, f16),
                        SIDE_TYPE_GATHER_ACCESS_DIRECT,
                        side_attr_list()),
 #endif
 #if __HAVE_FLOAT32
-               side_field_gather_float("f32", offsetof(struct testfloat, f32), 32,
+               side_field_gather_float("f32", offsetof(struct testfloat, f32), side_struct_field_sizeof(struct testfloat, f32),
                        SIDE_TYPE_GATHER_ACCESS_DIRECT,
                        side_attr_list()),
 #endif
 #if __HAVE_FLOAT64
-               side_field_gather_float("f64", offsetof(struct testfloat, f64), 64,
+               side_field_gather_float("f64", offsetof(struct testfloat, f64), side_struct_field_sizeof(struct testfloat, f64),
                        SIDE_TYPE_GATHER_ACCESS_DIRECT,
                        side_attr_list()),
 #endif
 #if __HAVE_FLOAT128
-               side_field_gather_float("f128", offsetof(struct testfloat, f128), 128,
+               side_field_gather_float("f128", offsetof(struct testfloat, f128), side_struct_field_sizeof(struct testfloat, f128),
                        SIDE_TYPE_GATHER_ACCESS_DIRECT,
                        side_attr_list()),
 #endif
@@ -1691,7 +1691,7 @@ struct testarray {
 static side_define_struct(mystructgatherarray,
        side_field_list(
                side_field_gather_array("array",
-                       side_elem(side_type_gather_unsigned_integer(0, 32, 0, 32, SIDE_TYPE_GATHER_ACCESS_DIRECT, side_attr_list())),
+                       side_elem(side_type_gather_unsigned_integer(0, sizeof(uint32_t), 0, 0, SIDE_TYPE_GATHER_ACCESS_DIRECT, side_attr_list())),
                        SIDE_ARRAY_SIZE(mygatherarray),
                        offsetof(struct testarray, ptr),
                        SIDE_TYPE_GATHER_ACCESS_POINTER,
@@ -1706,7 +1706,7 @@ side_static_event(my_provider_event_structgatherarray,
                side_field_gather_struct("structgatherarray", &mystructgatherarray, 0,
                                sizeof(struct testarray), SIDE_TYPE_GATHER_ACCESS_DIRECT),
                side_field_gather_array("array2",
-                       side_elem(side_type_gather_unsigned_integer(0, 16, 0, 16, SIDE_TYPE_GATHER_ACCESS_DIRECT, side_attr_list())),
+                       side_elem(side_type_gather_unsigned_integer(0, sizeof(uint16_t), 0, 0, SIDE_TYPE_GATHER_ACCESS_DIRECT, side_attr_list())),
                        SIDE_ARRAY_SIZE(mygatherarray2), 0,
                        SIDE_TYPE_GATHER_ACCESS_DIRECT,
                        side_attr_list()
@@ -1747,12 +1747,11 @@ struct testgatherstructnest0 {
 static side_define_struct(mystructgatherstructnest1,
        side_field_list(
                side_field_gather_signed_integer("b", offsetof(struct testgatherstructnest1, b),
-                       side_struct_field_sizeof_bit(struct testgatherstructnest1, b), 0,
-                       side_struct_field_sizeof_bit(struct testgatherstructnest1, b),
+                       side_struct_field_sizeof(struct testgatherstructnest1, b), 0, 0,
                        SIDE_TYPE_GATHER_ACCESS_DIRECT, side_attr_list()),
                side_field_gather_array("c",
                        side_elem(
-                               side_type_gather_signed_integer(0, 32, 0, 32, 
+                               side_type_gather_signed_integer(0, sizeof(uint32_t), 0, 0, 
                                        SIDE_TYPE_GATHER_ACCESS_DIRECT, side_attr_list()),
                        ),
                        TESTSGNESTARRAY_LEN,
@@ -1766,8 +1765,7 @@ static side_define_struct(mystructgatherstructnest1,
 static side_define_struct(mystructgatherstructnest0,
        side_field_list(
                side_field_gather_signed_integer("a", offsetof(struct testgatherstructnest0, a),
-                       side_struct_field_sizeof_bit(struct testgatherstructnest0, a), 0,
-                       side_struct_field_sizeof_bit(struct testgatherstructnest0, a),
+                       side_struct_field_sizeof(struct testgatherstructnest0, a), 0, 0,
                        SIDE_TYPE_GATHER_ACCESS_DIRECT, side_attr_list()),
                side_field_gather_struct("structnest0", &mystructgatherstructnest1,
                        offsetof(struct testgatherstructnest0, nest),
@@ -1838,16 +1836,15 @@ struct testgathervla {
 static side_define_struct(mystructgathervla,
        side_field_list(
                side_field_gather_signed_integer("a", offsetof(struct testgathervla, a),
-                       side_struct_field_sizeof_bit(struct testgathervla, a), 0,
-                       side_struct_field_sizeof_bit(struct testgathervla, a),
+                       side_struct_field_sizeof(struct testgathervla, a), 0, 0,
                        SIDE_TYPE_GATHER_ACCESS_DIRECT, side_attr_list()
                ),
                side_field_gather_vla("nestvla",
-                       side_elem(side_type_gather_unsigned_integer(0, 32, 0, 32, SIDE_TYPE_GATHER_ACCESS_DIRECT, side_attr_list())),
+                       side_elem(side_type_gather_unsigned_integer(0, sizeof(uint32_t), 0, 0, SIDE_TYPE_GATHER_ACCESS_DIRECT, side_attr_list())),
                        offsetof(struct testgathervla, p),
                        SIDE_TYPE_GATHER_ACCESS_POINTER,
                        side_length(side_type_gather_unsigned_integer(offsetof(struct testgathervla, len),
-                                       16, 0, 16, SIDE_TYPE_GATHER_ACCESS_DIRECT, side_attr_list())),
+                                       sizeof(uint16_t), 0, 0, SIDE_TYPE_GATHER_ACCESS_DIRECT, side_attr_list())),
                        side_attr_list()
                ),
        ),
@@ -1860,9 +1857,9 @@ side_static_event(my_provider_event_gathervla,
                side_field_gather_struct("structgathervla", &mystructgathervla, 0,
                                sizeof(struct testgathervla), SIDE_TYPE_GATHER_ACCESS_DIRECT),
                side_field_gather_vla("vla",
-                       side_elem(side_type_gather_unsigned_integer(0, 32, 0, 32, SIDE_TYPE_GATHER_ACCESS_DIRECT, side_attr_list())),
+                       side_elem(side_type_gather_unsigned_integer(0, sizeof(uint32_t), 0, 0, SIDE_TYPE_GATHER_ACCESS_DIRECT, side_attr_list())),
                        0, SIDE_TYPE_GATHER_ACCESS_DIRECT,
-                       side_length(side_type_gather_unsigned_integer(0, 16, 0, 16, SIDE_TYPE_GATHER_ACCESS_DIRECT, side_attr_list())),
+                       side_length(side_type_gather_unsigned_integer(0, sizeof(uint16_t), 0, 0, SIDE_TYPE_GATHER_ACCESS_DIRECT, side_attr_list())),
                        side_attr_list()
                ),
        ),
@@ -1897,11 +1894,11 @@ struct testgathervlaflex {
 static side_define_struct(mystructgathervlaflex,
        side_field_list(
                side_field_gather_vla("vlaflex",
-                       side_elem(side_type_gather_unsigned_integer(0, 64, 0, 64, SIDE_TYPE_GATHER_ACCESS_DIRECT, side_attr_list())),
+                       side_elem(side_type_gather_unsigned_integer(0, sizeof(uint64_t), 0, 0, SIDE_TYPE_GATHER_ACCESS_DIRECT, side_attr_list())),
                        offsetof(struct testgathervlaflex, array),
                        SIDE_TYPE_GATHER_ACCESS_DIRECT,
                        side_length(side_type_gather_unsigned_integer(offsetof(struct testgathervlaflex, len),
-                                       8, 0, 8, SIDE_TYPE_GATHER_ACCESS_DIRECT, side_attr_list())),
+                                       side_struct_field_sizeof(struct testgathervlaflex, len), 0, 0, SIDE_TYPE_GATHER_ACCESS_DIRECT, side_attr_list())),
                        side_attr_list()
                ),
        ),
@@ -1975,19 +1972,17 @@ 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_field_gather_bool("v1_true", 0, sizeof(bool), 0, 0,
+                               SIDE_TYPE_GATHER_ACCESS_DIRECT, side_attr_list()),
+               side_field_gather_bool("v2_false", 0, sizeof(bool), 0, 0,
+                               SIDE_TYPE_GATHER_ACCESS_DIRECT, side_attr_list()),
+               side_field_gather_bool("v3_true", 0, sizeof(uint16_t), 1, 1,
                                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_field_gather_bool("v4_false", 0, sizeof(uint16_t), 1, 1,
                                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())),
+                       side_elem(side_type_gather_bool(0, sizeof(bool), 0, 0,
+                               SIDE_TYPE_GATHER_ACCESS_DIRECT, side_attr_list())),
                        ARRAYBOOLLEN, 0, SIDE_TYPE_GATHER_ACCESS_DIRECT, side_attr_list()
                ),
        ),

diff --git a/src/tracer.c b/src/tracer.c
index ea4d5a183ea29663494e924519566f130e9194bb..9ae6d94751f23a78ee3e3cee7967acff54aabb6c 100644 (file)
--- a/src/tracer.c
+++ b/src/tracer.c
@@ -519,18 +519,22 @@ void tracer_print_type_bool(const char *separator,
                const union side_bool_value *value,
                uint16_t offset_bits)
 {
+       uint32_t len_bits;
        bool reverse_bo;
        uint64_t v;
 
-       if (!type_bool->len_bits ||
-                       type_bool->len_bits + offset_bits > type_bool->bool_size_bits)
+       if (!type_bool->len_bits)
+               len_bits = type_bool->bool_size * CHAR_BIT;
+       else
+               len_bits = type_bool->len_bits;
+       if (len_bits + offset_bits > type_bool->bool_size * CHAR_BIT)
                abort();
        reverse_bo = type_bool->byte_order != SIDE_TYPE_BYTE_ORDER_HOST;
-       switch (type_bool->bool_size_bits) {
-       case 8:
+       switch (type_bool->bool_size) {
+       case 1:
                v = value->side_bool8;
                break;
-       case 16:
+       case 2:
        {
                uint16_t side_u16;
 
@@ -540,7 +544,7 @@ void tracer_print_type_bool(const char *separator,
                v = side_u16;
                break;
        }
-       case 32:
+       case 4:
        {
                uint32_t side_u32;
 
@@ -550,7 +554,7 @@ void tracer_print_type_bool(const char *separator,
                v = side_u32;
                break;
        }
-       case 64:
+       case 8:
        {
                uint64_t side_u64;
 
@@ -564,8 +568,8 @@ void tracer_print_type_bool(const char *separator,
                abort();
        }
        v >>= offset_bits;
-       if (type_bool->len_bits < 64)
-               v &= (1ULL << type_bool->len_bits) - 1;
+       if (len_bits < 64)
+               v &= (1ULL << len_bits) - 1;
        tracer_print_type_header(separator, type_bool->attr, type_bool->nr_attr);
        printf("%s", v ? "true" : "false");
 }
@@ -578,27 +582,31 @@ void tracer_print_type_integer(const char *separator,
                enum tracer_display_base default_base)
 {
        enum tracer_display_base base;
+       uint32_t len_bits;
        bool reverse_bo;
        union {
                uint64_t v_unsigned;
                int64_t v_signed;
        } v;
 
-       if (!type_integer->len_bits ||
-                       type_integer->len_bits + offset_bits > type_integer->integer_size_bits)
+       if (!type_integer->len_bits)
+               len_bits = type_integer->integer_size * CHAR_BIT;
+       else
+               len_bits = type_integer->len_bits;
+       if (len_bits + offset_bits > type_integer->integer_size * CHAR_BIT)
                abort();
        reverse_bo = type_integer->byte_order != SIDE_TYPE_BYTE_ORDER_HOST;
        base = get_attr_display_base(type_integer->attr,
                        type_integer->nr_attr,
                        default_base);
-       switch (type_integer->integer_size_bits) {
-       case 8:
+       switch (type_integer->integer_size) {
+       case 1:
                if (type_integer->signedness)
                        v.v_signed = value->side_s8;
                else
                        v.v_unsigned = value->side_u8;
                break;
-       case 16:
+       case 2:
                if (type_integer->signedness) {
                        int16_t side_s16;
 
@@ -615,7 +623,7 @@ void tracer_print_type_integer(const char *separator,
                        v.v_unsigned = side_u16;
                }
                break;
-       case 32:
+       case 4:
                if (type_integer->signedness) {
                        int32_t side_s32;
 
@@ -632,7 +640,7 @@ void tracer_print_type_integer(const char *separator,
                        v.v_unsigned = side_u32;
                }
                break;
-       case 64:
+       case 8:
                if (type_integer->signedness) {
                        int64_t side_s64;
 
@@ -653,12 +661,12 @@ void tracer_print_type_integer(const char *separator,
                abort();
        }
        v.v_unsigned >>= offset_bits;
-       if (type_integer->len_bits < 64)
-               v.v_unsigned &= (1ULL << type_integer->len_bits) - 1;
+       if (len_bits < 64)
+               v.v_unsigned &= (1ULL << len_bits) - 1;
        tracer_print_type_header(separator, type_integer->attr, type_integer->nr_attr);
        switch (base) {
        case TRACER_DISPLAY_BASE_2:
-               print_integer_binary(v.v_unsigned, type_integer->len_bits);
+               print_integer_binary(v.v_unsigned, len_bits);
                break;
        case TRACER_DISPLAY_BASE_8:
                printf("0%" PRIo64, v.v_unsigned);
@@ -666,9 +674,9 @@ void tracer_print_type_integer(const char *separator,
        case TRACER_DISPLAY_BASE_10:
                if (type_integer->signedness) {
                        /* Sign-extend. */
-                       if (type_integer->len_bits < 64) {
-                               if (v.v_unsigned & (1ULL << (type_integer->len_bits - 1)))
-                                       v.v_unsigned |= ~((1ULL << type_integer->len_bits) - 1);
+                       if (len_bits < 64) {
+                               if (v.v_unsigned & (1ULL << (len_bits - 1)))
+                                       v.v_unsigned |= ~((1ULL << len_bits) - 1);
                        }
                        printf("%" PRId64, v.v_signed);
                } else {
@@ -692,8 +700,8 @@ void tracer_print_type_float(const char *separator,
 
        reverse_bo = type_float->byte_order != SIDE_TYPE_FLOAT_WORD_ORDER_HOST;
        tracer_print_type_header(separator, type_float->attr, type_float->nr_attr);
-       switch (type_float->float_size_bits) {
-       case 16:
+       switch (type_float->float_size) {
+       case 2:
        {
 #if __HAVE_FLOAT16
                union {
@@ -713,7 +721,7 @@ void tracer_print_type_float(const char *separator,
                abort();
 #endif
        }
-       case 32:
+       case 4:
        {
 #if __HAVE_FLOAT32
                union {
@@ -732,7 +740,7 @@ void tracer_print_type_float(const char *separator,
                abort();
 #endif
        }
-       case 64:
+       case 8:
        {
 #if __HAVE_FLOAT64
                union {
@@ -751,7 +759,7 @@ void tracer_print_type_float(const char *separator,
                abort();
 #endif
        }
-       case 128:
+       case 16:
        {
 #if __HAVE_FLOAT128
                union {
@@ -1080,20 +1088,20 @@ static
 uint64_t tracer_load_gather_integer_type(const struct side_type_gather *type_gather, const void *_ptr)
 {
        enum side_type_gather_access_mode access_mode = type_gather->u.side_integer.access_mode;
-       uint32_t integer_size_bytes = type_gather->u.side_integer.type.integer_size_bits >> 3;
+       uint32_t integer_size_bytes = type_gather->u.side_integer.type.integer_size;
        const char *ptr = (const char *) _ptr;
        union side_integer_value value;
 
        ptr = tracer_gather_access(access_mode, ptr + type_gather->u.side_integer.offset);
        memcpy(&value, ptr, integer_size_bytes);
-       switch (type_gather->u.side_integer.type.integer_size_bits) {
-       case 8:
+       switch (type_gather->u.side_integer.type.integer_size) {
+       case 1:
                return (uint64_t) value.side_u8;
-       case 16:
+       case 2:
                return (uint64_t) value.side_u16;
-       case 32:
+       case 4:
                return (uint64_t) value.side_u32;
-       case 64:
+       case 8:
                return (uint64_t) value.side_u64;
        default:
                abort();
@@ -1104,15 +1112,15 @@ 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;
+       uint32_t bool_size_bytes = type_gather->u.side_bool.type.bool_size;
        const char *ptr = (const char *) _ptr;
        union side_bool_value value;
 
-       switch (type_gather->u.side_bool.type.bool_size_bits) {
+       switch (bool_size_bytes) {
+       case 1:
+       case 2:
+       case 4:
        case 8:
-       case 16:
-       case 32:
-       case 64:
                break;
        default:
                abort();
@@ -1143,15 +1151,15 @@ static
 uint32_t tracer_print_gather_integer_type(const struct side_type_gather *type_gather, const void *_ptr)
 {
        enum side_type_gather_access_mode access_mode = type_gather->u.side_integer.access_mode;
-       uint32_t integer_size_bytes = type_gather->u.side_integer.type.integer_size_bits >> 3;
+       uint32_t integer_size_bytes = type_gather->u.side_integer.type.integer_size;
        const char *ptr = (const char *) _ptr;
        union side_integer_value value;
 
-       switch (type_gather->u.side_integer.type.integer_size_bits) {
+       switch (integer_size_bytes) {
+       case 1:
+       case 2:
+       case 4:
        case 8:
-       case 16:
-       case 32:
-       case 64:
                break;
        default:
                abort();
@@ -1167,15 +1175,15 @@ static
 uint32_t tracer_print_gather_float_type(const struct side_type_gather *type_gather, const void *_ptr)
 {
        enum side_type_gather_access_mode access_mode = type_gather->u.side_float.access_mode;
-       uint32_t float_size_bytes = type_gather->u.side_float.type.float_size_bits >> 3;
+       uint32_t float_size_bytes = type_gather->u.side_float.type.float_size;
        const char *ptr = (const char *) _ptr;
        union side_float_value value;
 
-       switch (type_gather->u.side_float.type.float_size_bits) {
+       switch (float_size_bytes) {
+       case 2:
+       case 4:
+       case 8:
        case 16:
-       case 32:
-       case 64:
-       case 128:
                break;
        default:
                abort();