SIDE_TYPE_DYNAMIC,
/* Gather basic types */
+ SIDE_TYPE_GATHER_BOOL,
SIDE_TYPE_GATHER_UNSIGNED_INT,
SIDE_TYPE_GATHER_SIGNED_INT,
SIDE_TYPE_GATHER_BYTE,
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 {
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 */
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;
} 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;
.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, \
}, \
}, \
}
#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) \
{ \
/* 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) } } }
.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), \
}, \
}
}
+#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();
test_gather_vla();
test_gather_vla_flex();
test_gather_byte();
+ test_gather_bool();
return 0;
}
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);
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,
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:
(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;
}
}
+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)
{
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;
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: