SIDE_TYPE_DYNAMIC,
- /* Scatter-gather types */
- SIDE_TYPE_SG_UNSIGNED_INT,
- SIDE_TYPE_SG_SIGNED_INT,
- SIDE_TYPE_SG_FLOAT,
- SIDE_TYPE_SG_STRUCT,
- SIDE_TYPE_SG_ARRAY,
- SIDE_TYPE_SG_VLA,
+ /* Gather types */
+ SIDE_TYPE_GATHER_UNSIGNED_INT,
+ SIDE_TYPE_GATHER_SIGNED_INT,
+ SIDE_TYPE_GATHER_FLOAT,
+ SIDE_TYPE_GATHER_STRUCT,
+ SIDE_TYPE_GATHER_ARRAY,
+ SIDE_TYPE_GATHER_VLA,
/* Dynamic types */
SIDE_TYPE_DYNAMIC_NULL,
const struct side_type *elem_type;
} SIDE_PACKED;
-struct side_type_sg_integer {
+struct side_type_gather_integer {
uint64_t offset; /* bytes */
- uint8_t access_mode; /* enum side_type_sg_access_mode */
+ uint8_t access_mode; /* enum side_type_gather_access_mode */
struct side_type_integer type;
uint16_t offset_bits; /* bits */
} SIDE_PACKED;
-struct side_type_sg_float {
+struct side_type_gather_float {
uint64_t offset; /* bytes */
- uint8_t access_mode; /* enum side_type_sg_access_mode */
+ uint8_t access_mode; /* enum side_type_gather_access_mode */
struct side_type_float type;
} SIDE_PACKED;
-struct side_type_sg_struct {
+struct side_type_gather_struct {
uint64_t offset; /* bytes */
- uint8_t access_mode; /* enum side_type_sg_access_mode */
+ uint8_t access_mode; /* enum side_type_gather_access_mode */
const struct side_type_struct *type;
uint32_t size; /* bytes */
} SIDE_PACKED;
-struct side_type_sg_array {
+struct side_type_gather_array {
uint64_t offset; /* bytes */
- uint8_t access_mode; /* enum side_type_sg_access_mode */
+ uint8_t access_mode; /* enum side_type_gather_access_mode */
struct side_type_array type;
} SIDE_PACKED;
-struct side_type_sg_vla {
+struct side_type_gather_vla {
const struct side_type *length_type; /* side_length() */
uint64_t offset; /* bytes */
- uint8_t access_mode; /* enum side_type_sg_access_mode */
+ uint8_t access_mode; /* enum side_type_gather_access_mode */
struct side_type_vla type;
} SIDE_PACKED;
-enum side_type_sg_access_mode {
- SIDE_TYPE_SG_ACCESS_ADDRESS,
- SIDE_TYPE_SG_ACCESS_POINTER,
+enum side_type_gather_access_mode {
+ SIDE_TYPE_GATHER_ACCESS_ADDRESS,
+ SIDE_TYPE_GATHER_ACCESS_POINTER,
};
-struct side_type_sg {
+struct side_type_gather {
union {
- struct side_type_sg_integer side_integer;
- struct side_type_sg_float side_float;
- struct side_type_sg_array side_array;
- struct side_type_sg_vla side_vla;
- struct side_type_sg_struct side_struct;
+ struct side_type_gather_integer side_integer;
+ struct side_type_gather_float side_float;
+ struct side_type_gather_array side_array;
+ struct side_type_gather_vla side_vla;
+ struct side_type_gather_struct side_struct;
} SIDE_PACKED u;
} SIDE_PACKED;
struct side_type_enum side_enum;
struct side_type_enum_bitmap side_enum_bitmap;
- /* Scatter-gather types */
- struct side_type_sg side_sg;
+ /* Gather types */
+ struct side_type_gather side_gather;
} SIDE_PACKED u;
} SIDE_PACKED;
uint32_t length;
} SIDE_PACKED side_vla_fixint;
- /* Scatter-gather */
- void *side_integer_sg_ptr;
- void *side_float_sg_ptr;
- void *side_array_sg_ptr;
- void *side_struct_sg_ptr;
+ /* Gather types */
+ void *side_integer_gather_ptr;
+ void *side_float_gather_ptr;
+ void *side_array_gather_ptr;
+ void *side_struct_gather_ptr;
struct {
void *ptr;
void *length_ptr;
- } SIDE_PACKED side_vla_sg;
+ } SIDE_PACKED side_vla_gather;
} SIDE_PACKED;
struct side_arg_dynamic_vla {
#define side_field_vla_visitor(_name, _elem_type, _visitor, _attr) \
_side_field(_name, side_type_vla_visitor(SIDE_PARAM(_elem_type), _visitor, SIDE_PARAM(_attr)))
-/* Scatter-gather fields */
+/* Gather fields */
-#define _side_type_sg_integer(_type, _signedness, _byte_order, _offset, \
+#define _side_type_gather_integer(_type, _signedness, _byte_order, _offset, \
_integer_size_bits, _offset_bits, _len_bits, _access_mode, _attr) \
{ \
.type = _type, \
.u = { \
- .side_sg = { \
+ .side_gather = { \
.u = { \
.side_integer = { \
.offset = _offset, \
}, \
}
-#define side_type_sg_unsigned_integer(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, _attr) \
- _side_type_sg_integer(SIDE_TYPE_SG_UNSIGNED_INT, false, SIDE_TYPE_BYTE_ORDER_HOST, \
+#define side_type_gather_unsigned_integer(_integer_offset, _integer_size_bits, _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_sg_signed_integer(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, _attr) \
- _side_type_sg_integer(SIDE_TYPE_SG_SIGNED_INT, true, SIDE_TYPE_BYTE_ORDER_HOST, \
+#define side_type_gather_signed_integer(_integer_offset, _integer_size_bits, _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))
-#define side_type_sg_unsigned_integer_le(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, _attr) \
- _side_type_sg_integer(SIDE_TYPE_SG_UNSIGNED_INT, false, SIDE_TYPE_BYTE_ORDER_LE, \
+#define side_type_gather_unsigned_integer_le(_integer_offset, _integer_size_bits, _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_sg_signed_integer_le(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, _attr) \
- _side_type_sg_integer(SIDE_TYPE_SG_SIGNED_INT, true, SIDE_TYPE_BYTE_ORDER_LE, \
+#define side_type_gather_signed_integer_le(_integer_offset, _integer_size_bits, _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))
-#define side_type_sg_unsigned_integer_be(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, _attr) \
- _side_type_sg_integer(SIDE_TYPE_SG_UNSIGNED_INT, false, SIDE_TYPE_BYTE_ORDER_BE, \
+#define side_type_gather_unsigned_integer_be(_integer_offset, _integer_size_bits, _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_sg_signed_integer_be(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, _attr) \
- _side_type_sg_integer(SIDE_TYPE_SG_SIGNED_INT, true, SIDE_TYPE_BYTE_ORDER_BE, \
+#define side_type_gather_signed_integer_be(_integer_offset, _integer_size_bits, _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))
-#define side_field_sg_unsigned_integer(_name, _integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, _attr) \
- _side_field(_name, side_type_sg_unsigned_integer(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, SIDE_PARAM(_attr)))
-#define side_field_sg_signed_integer(_name, _integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, _attr) \
- _side_field(_name, side_type_sg_signed_integer(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, SIDE_PARAM(_attr)))
+#define side_field_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_sg_unsigned_integer_le(_name, _integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, _attr) \
- _side_field(_name, side_type_sg_unsigned_integer_le(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, SIDE_PARAM(_attr)))
-#define side_field_sg_signed_integer_le(_name, _integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, _attr) \
- _side_field(_name, side_type_sg_signed_integer_le(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, SIDE_PARAM(_attr)))
+#define side_field_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_sg_unsigned_integer_be(_name, _integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, _attr) \
- _side_field(_name, side_type_sg_unsigned_integer_be(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, SIDE_PARAM(_attr)))
-#define side_field_sg_signed_integer_be(_name, _integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, _attr) \
- _side_field(_name, side_type_sg_signed_integer_be(_integer_offset, _integer_size_bits, _offset_bits, _len_bits, _access_mode, SIDE_PARAM(_attr)))
+#define side_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_type_sg_float(_byte_order, _offset, _float_size_bits, _access_mode, _attr) \
+#define _side_type_gather_float(_byte_order, _offset, _float_size_bits, _access_mode, _attr) \
{ \
- .type = SIDE_TYPE_SG_FLOAT, \
+ .type = SIDE_TYPE_GATHER_FLOAT, \
.u = { \
- .side_sg = { \
+ .side_gather = { \
.u = { \
.side_float = { \
.offset = _offset, \
}, \
}
-#define side_type_sg_float(_offset, _float_size_bits, _access_mode, _attr) \
- _side_type_sg_float(SIDE_TYPE_FLOAT_WORD_ORDER_HOST, _offset, _float_size_bits, _access_mode, _attr)
-#define side_type_sg_float_le(_offset, _float_size_bits, _access_mode, _attr) \
- _side_type_sg_float(SIDE_TYPE_BYTE_ORDER_LE, _offset, _float_size_bits, _access_mode, _attr)
-#define side_type_sg_float_be(_offset, _float_size_bits, _access_mode, _attr) \
- _side_type_sg_float(SIDE_TYPE_BYTE_ORDER_BE, _offset, _float_size_bits, _access_mode, _attr)
-
-#define side_field_sg_float(_name, _offset, _float_size_bits, _access_mode, _attr) \
- _side_field(_name, side_type_sg_float(_offset, _float_size_bits, _access_mode, _attr))
-#define side_field_sg_float_le(_name, _offset, _float_size_bits, _access_mode, _attr) \
- _side_field(_name, side_type_sg_float_le(_offset, _float_size_bits, _access_mode, _attr))
-#define side_field_sg_float_be(_name, _offset, _float_size_bits, _access_mode, _attr) \
- _side_field(_name, side_type_sg_float_be(_offset, _float_size_bits, _access_mode, _attr))
-
-#define side_type_sg_struct(_struct_sg, _offset, _size, _access_mode) \
+#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_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_type_gather_struct(_struct_gather, _offset, _size, _access_mode) \
{ \
- .type = SIDE_TYPE_SG_STRUCT, \
+ .type = SIDE_TYPE_GATHER_STRUCT, \
.u = { \
- .side_sg = { \
+ .side_gather = { \
.u = { \
.side_struct = { \
.offset = _offset, \
.access_mode = _access_mode, \
- .type = _struct_sg, \
+ .type = _struct_gather, \
.size = _size, \
}, \
}, \
}, \
}, \
}
-#define side_field_sg_struct(_name, _struct_sg, _offset, _size, _access_mode) \
- _side_field(_name, side_type_sg_struct(SIDE_PARAM(_struct_sg), _offset, _size, _access_mode))
+#define side_field_gather_struct(_name, _struct_gather, _offset, _size, _access_mode) \
+ _side_field(_name, side_type_gather_struct(SIDE_PARAM(_struct_gather), _offset, _size, _access_mode))
-#define side_type_sg_array(_elem_type_sg, _length, _offset, _access_mode, _attr) \
+#define side_type_gather_array(_elem_type_gather, _length, _offset, _access_mode, _attr) \
{ \
- .type = SIDE_TYPE_SG_ARRAY, \
+ .type = SIDE_TYPE_GATHER_ARRAY, \
.u = { \
- .side_sg = { \
+ .side_gather = { \
.u = { \
.side_array = { \
.offset = _offset, \
.access_mode = _access_mode, \
.type = { \
- .elem_type = _elem_type_sg, \
+ .elem_type = _elem_type_gather, \
.attr = _attr, \
.length = _length, \
.nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
}, \
}, \
}
-#define side_field_sg_array(_name, _elem_type, _length, _offset, _access_mode, _attr) \
- _side_field(_name, side_type_sg_array(SIDE_PARAM(_elem_type), _length, _offset, _access_mode, SIDE_PARAM(_attr)))
+#define side_field_gather_array(_name, _elem_type, _length, _offset, _access_mode, _attr) \
+ _side_field(_name, side_type_gather_array(SIDE_PARAM(_elem_type), _length, _offset, _access_mode, SIDE_PARAM(_attr)))
-#define side_type_sg_vla(_elem_type_sg, _offset, _access_mode, _length_type_sg, _attr) \
+#define side_type_gather_vla(_elem_type_gather, _offset, _access_mode, _length_type_gather, _attr) \
{ \
- .type = SIDE_TYPE_SG_VLA, \
+ .type = SIDE_TYPE_GATHER_VLA, \
.u = { \
- .side_sg = { \
+ .side_gather = { \
.u = { \
.side_vla = { \
.offset = _offset, \
.access_mode = _access_mode, \
.type = { \
- .elem_type = _elem_type_sg, \
+ .elem_type = _elem_type_gather, \
.attr = _attr, \
.nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
}, \
- .length_type = _length_type_sg, \
+ .length_type = _length_type_gather, \
}, \
}, \
}, \
}, \
}
-#define side_field_sg_vla(_name, _elem_type_sg, _offset, _access_mode, _length_type_sg, _attr) \
- _side_field(_name, side_type_sg_vla(SIDE_PARAM(_elem_type_sg), _offset, _access_mode, SIDE_PARAM(_length_type_sg), SIDE_PARAM(_attr)))
+#define side_field_gather_vla(_name, _elem_type_gather, _offset, _access_mode, _length_type_gather, _attr) \
+ _side_field(_name, side_type_gather_vla(SIDE_PARAM(_elem_type_gather), _offset, _access_mode, SIDE_PARAM(_length_type_gather), SIDE_PARAM(_attr)))
#define side_elem(...) \
SIDE_COMPOUND_LITERAL(const struct side_type, __VA_ARGS__)
#define side_arg_vla_byte(_ptr, _length) { .type = SIDE_TYPE_VLA_BYTE, .u = { .side_static = { .side_vla_fixint = { .p = (_ptr), .length = (_length) } } } }
#define side_arg_vla_pointer(_ptr, _length) { .type = SIDE_TYPE_VLA_POINTER_HOST, .u = { .side_static = { .side_vla_fixint = { .p = (_ptr), .length = (_length) } } } }
-/* Scatter-gather field arguments */
-#define side_arg_sg_unsigned_integer(_ptr) { .type = SIDE_TYPE_SG_UNSIGNED_INT, .u = { .side_static = { .side_integer_sg_ptr = (_ptr) } } }
-#define side_arg_sg_signed_integer(_ptr) { .type = SIDE_TYPE_SG_SIGNED_INT, .u = { .side_static = { .side_integer_sg_ptr = (_ptr) } } }
-#define side_arg_sg_float(_ptr) { .type = SIDE_TYPE_SG_FLOAT, .u = { .side_static = { .side_float_sg_ptr = (_ptr) } } }
-#define side_arg_sg_struct(_ptr) { .type = SIDE_TYPE_SG_STRUCT, .u = { .side_static = { .side_struct_sg_ptr = (_ptr) } } }
-#define side_arg_sg_array(_ptr) { .type = SIDE_TYPE_SG_ARRAY, .u = { .side_static = { .side_array_sg_ptr = (_ptr) } } }
-#define side_arg_sg_vla(_ptr, _length_ptr) { .type = SIDE_TYPE_SG_VLA, .u = { .side_static = { .side_vla_sg = { .ptr = (_ptr), .length_ptr = (_length_ptr) } } } }
+/* Gather field arguments */
+#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) } } }
+#define side_arg_gather_float(_ptr) { .type = SIDE_TYPE_GATHER_FLOAT, .u = { .side_static = { .side_float_gather_ptr = (_ptr) } } }
+#define side_arg_gather_struct(_ptr) { .type = SIDE_TYPE_GATHER_STRUCT, .u = { .side_static = { .side_struct_gather_ptr = (_ptr) } } }
+#define side_arg_gather_array(_ptr) { .type = SIDE_TYPE_GATHER_ARRAY, .u = { .side_static = { .side_array_gather_ptr = (_ptr) } } }
+#define side_arg_gather_vla(_ptr, _length_ptr) { .type = SIDE_TYPE_GATHER_VLA, .u = { .side_static = { .side_vla_gather = { .ptr = (_ptr), .length_ptr = (_length_ptr) } } } }
/* Dynamic field arguments */
uint64_t test;
};
-static side_define_struct(mystructsgdef,
+static side_define_struct(mystructgatherdef,
side_field_list(
- side_field_sg_unsigned_integer("a", offsetof(struct test, a),
+ 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_SG_ACCESS_ADDRESS, side_attr_list()),
- side_field_sg_signed_integer("d", offsetof(struct test, d),
+ side_struct_field_sizeof_bit(struct test, a), SIDE_TYPE_GATHER_ACCESS_ADDRESS, 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_SG_ACCESS_ADDRESS, side_attr_list()),
- side_field_sg_unsigned_integer("e", offsetof(struct test, e),
+ side_struct_field_sizeof_bit(struct test, d), SIDE_TYPE_GATHER_ACCESS_ADDRESS, side_attr_list()),
+ side_field_gather_unsigned_integer("e", offsetof(struct test, e),
side_struct_field_sizeof_bit(struct test, e), 8, 4,
- SIDE_TYPE_SG_ACCESS_ADDRESS, side_attr_list(side_attr("std.integer.base", side_attr_u8(16)))),
- side_field_sg_signed_integer("f", offsetof(struct test, f),
+ SIDE_TYPE_GATHER_ACCESS_ADDRESS, 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_TYPE_SG_ACCESS_ADDRESS, side_attr_list(side_attr("std.integer.base", side_attr_u8(10)))),
- side_field_sg_signed_integer("g", offsetof(struct test, g),
+ SIDE_TYPE_GATHER_ACCESS_ADDRESS, 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_TYPE_SG_ACCESS_ADDRESS, side_attr_list(side_attr("std.integer.base", side_attr_u8(10)))),
- side_field_sg_signed_integer("h", offsetof(struct test, h),
+ SIDE_TYPE_GATHER_ACCESS_ADDRESS, 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_TYPE_SG_ACCESS_ADDRESS, side_attr_list(side_attr("std.integer.base", side_attr_u8(10)))),
- side_field_sg_signed_integer("i", offsetof(struct test, i),
+ SIDE_TYPE_GATHER_ACCESS_ADDRESS, 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_TYPE_SG_ACCESS_ADDRESS, side_attr_list(side_attr("std.integer.base", side_attr_u8(10)))),
- side_field_sg_signed_integer("j", offsetof(struct test, j),
+ SIDE_TYPE_GATHER_ACCESS_ADDRESS, 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_TYPE_SG_ACCESS_ADDRESS, side_attr_list(side_attr("std.integer.base", side_attr_u8(10)))),
- side_field_sg_signed_integer("k", offsetof(struct test, k),
+ SIDE_TYPE_GATHER_ACCESS_ADDRESS, 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_TYPE_SG_ACCESS_ADDRESS, side_attr_list(side_attr("std.integer.base", side_attr_u8(10)))),
- side_field_sg_unsigned_integer_le("test", offsetof(struct test, test),
+ SIDE_TYPE_GATHER_ACCESS_ADDRESS, 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_TYPE_SG_ACCESS_ADDRESS, side_attr_list(side_attr("std.integer.base", side_attr_u8(16)))),
- side_field_sg_unsigned_integer_le("test_le", offsetof(struct test, test),
+ SIDE_TYPE_GATHER_ACCESS_ADDRESS, 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_TYPE_SG_ACCESS_ADDRESS, side_attr_list(side_attr("std.integer.base", side_attr_u8(16)))),
- side_field_sg_unsigned_integer_be("test_be", offsetof(struct test, test),
+ SIDE_TYPE_GATHER_ACCESS_ADDRESS, 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_TYPE_SG_ACCESS_ADDRESS, side_attr_list(side_attr("std.integer.base", side_attr_u8(16)))),
+ SIDE_TYPE_GATHER_ACCESS_ADDRESS, side_attr_list(side_attr("std.integer.base", side_attr_u8(16)))),
),
side_attr_list()
);
-side_static_event(my_provider_event_structsg, "myprovider", "myeventstructsg", SIDE_LOGLEVEL_DEBUG,
+side_static_event(my_provider_event_structgather, "myprovider", "myeventstructgather", SIDE_LOGLEVEL_DEBUG,
side_field_list(
- side_field_sg_struct("structsg", &mystructsgdef, 0, sizeof(struct test),
- SIDE_TYPE_SG_ACCESS_POINTER),
- side_field_sg_signed_integer("intsg", 0, 32, 0, 32, SIDE_TYPE_SG_ACCESS_ADDRESS,
+ side_field_gather_struct("structgather", &mystructgatherdef, 0, sizeof(struct test),
+ SIDE_TYPE_GATHER_ACCESS_POINTER),
+ side_field_gather_signed_integer("intgather", 0, 32, 0, 32, SIDE_TYPE_GATHER_ACCESS_ADDRESS,
side_attr_list(side_attr("std.integer.base", side_attr_u8(10)))),
#if __HAVE_FLOAT32
- side_field_sg_float("f32", 0, 32, SIDE_TYPE_SG_ACCESS_ADDRESS, side_attr_list()),
+ side_field_gather_float("f32", 0, 32, SIDE_TYPE_GATHER_ACCESS_ADDRESS, side_attr_list()),
#endif
),
side_attr_list()
);
static
-void test_struct_sg(void)
+void test_struct_gather(void)
{
- side_event_cond(my_provider_event_structsg) {
+ side_event_cond(my_provider_event_structgather) {
struct test mystruct = {
.a = 55,
.b = 123,
#if __HAVE_FLOAT32
_Float32 f32 = 1.1;
#endif
- side_event_call(my_provider_event_structsg,
+ side_event_call(my_provider_event_structgather,
side_arg_list(
- side_arg_sg_struct(&mystruct),
- side_arg_sg_signed_integer(&val),
+ side_arg_gather_struct(&mystruct),
+ side_arg_gather_signed_integer(&val),
#if __HAVE_FLOAT32
- side_arg_sg_float(&f32),
+ side_arg_gather_float(&f32),
#endif
)
);
struct testnest1 *nest;
};
-static side_define_struct(mystructsgnest2,
+static side_define_struct(mystructgathernest2,
side_field_list(
- side_field_sg_unsigned_integer("c", offsetof(struct testnest2, c),
+ 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_SG_ACCESS_ADDRESS, side_attr_list()),
+ side_struct_field_sizeof_bit(struct testnest2, c), SIDE_TYPE_GATHER_ACCESS_ADDRESS, side_attr_list()),
),
side_attr_list()
);
-static side_define_struct(mystructsgnest1,
+static side_define_struct(mystructgathernest1,
side_field_list(
- side_field_sg_unsigned_integer("b", offsetof(struct testnest1, b),
+ 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_SG_ACCESS_ADDRESS, side_attr_list()),
- side_field_sg_struct("nest2", &mystructsgnest2,
+ side_struct_field_sizeof_bit(struct testnest1, b), SIDE_TYPE_GATHER_ACCESS_ADDRESS, side_attr_list()),
+ side_field_gather_struct("nest2", &mystructgathernest2,
offsetof(struct testnest1, nest), sizeof(struct testnest2),
- SIDE_TYPE_SG_ACCESS_POINTER),
+ SIDE_TYPE_GATHER_ACCESS_POINTER),
),
side_attr_list()
);
-static side_define_struct(mystructsgnest0,
+static side_define_struct(mystructgathernest0,
side_field_list(
- side_field_sg_unsigned_integer("a", offsetof(struct testnest0, a),
+ 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_SG_ACCESS_ADDRESS, side_attr_list()),
- side_field_sg_struct("nest1", &mystructsgnest1,
+ side_struct_field_sizeof_bit(struct testnest0, a), SIDE_TYPE_GATHER_ACCESS_ADDRESS, side_attr_list()),
+ side_field_gather_struct("nest1", &mystructgathernest1,
offsetof(struct testnest0, nest), sizeof(struct testnest1),
- SIDE_TYPE_SG_ACCESS_POINTER),
+ SIDE_TYPE_GATHER_ACCESS_POINTER),
),
side_attr_list()
);
-side_static_event(my_provider_event_structsg_nest,
- "myprovider", "myeventstructsgnest", SIDE_LOGLEVEL_DEBUG,
+side_static_event(my_provider_event_structgather_nest,
+ "myprovider", "myeventstructgathernest", SIDE_LOGLEVEL_DEBUG,
side_field_list(
- side_field_sg_struct("nest0", &mystructsgnest0, 0,
- sizeof(struct testnest0), SIDE_TYPE_SG_ACCESS_POINTER),
+ side_field_gather_struct("nest0", &mystructgathernest0, 0,
+ sizeof(struct testnest0), SIDE_TYPE_GATHER_ACCESS_POINTER),
),
side_attr_list()
);
static
-void test_struct_sg_nest_ptr(void)
+void test_struct_gather_nest_ptr(void)
{
- side_event_cond(my_provider_event_structsg_nest) {
+ side_event_cond(my_provider_event_structgather_nest) {
struct testnest2 mystruct2 = {
.c = 77,
};
.a = 55,
.nest = &mystruct1,
};
- side_event_call(my_provider_event_structsg_nest,
+ side_event_call(my_provider_event_structgather_nest,
side_arg_list(
- side_arg_sg_struct(&mystruct),
+ side_arg_gather_struct(&mystruct),
)
);
}
#endif
};
-static side_define_struct(mystructsgfloat,
+static side_define_struct(mystructgatherfloat,
side_field_list(
#if __HAVE_FLOAT16
- side_field_sg_float("f16", offsetof(struct testfloat, f16), 16,
- SIDE_TYPE_SG_ACCESS_ADDRESS,
+ side_field_gather_float("f16", offsetof(struct testfloat, f16), 16,
+ SIDE_TYPE_GATHER_ACCESS_ADDRESS,
side_attr_list()),
#endif
#if __HAVE_FLOAT32
- side_field_sg_float("f32", offsetof(struct testfloat, f32), 32,
- SIDE_TYPE_SG_ACCESS_ADDRESS,
+ side_field_gather_float("f32", offsetof(struct testfloat, f32), 32,
+ SIDE_TYPE_GATHER_ACCESS_ADDRESS,
side_attr_list()),
#endif
#if __HAVE_FLOAT64
- side_field_sg_float("f64", offsetof(struct testfloat, f64), 64,
- SIDE_TYPE_SG_ACCESS_ADDRESS,
+ side_field_gather_float("f64", offsetof(struct testfloat, f64), 64,
+ SIDE_TYPE_GATHER_ACCESS_ADDRESS,
side_attr_list()),
#endif
#if __HAVE_FLOAT128
- side_field_sg_float("f128", offsetof(struct testfloat, f128), 128,
- SIDE_TYPE_SG_ACCESS_ADDRESS,
+ side_field_gather_float("f128", offsetof(struct testfloat, f128), 128,
+ SIDE_TYPE_GATHER_ACCESS_ADDRESS,
side_attr_list()),
#endif
),
side_attr_list()
);
-side_static_event(my_provider_event_structsgfloat,
- "myprovider", "myeventstructsgfloat", SIDE_LOGLEVEL_DEBUG,
+side_static_event(my_provider_event_structgatherfloat,
+ "myprovider", "myeventstructgatherfloat", SIDE_LOGLEVEL_DEBUG,
side_field_list(
- side_field_sg_struct("structsgfloat", &mystructsgfloat, 0,
- sizeof(struct testfloat), SIDE_TYPE_SG_ACCESS_POINTER),
+ side_field_gather_struct("structgatherfloat", &mystructgatherfloat, 0,
+ sizeof(struct testfloat), SIDE_TYPE_GATHER_ACCESS_POINTER),
),
side_attr_list()
);
static
-void test_struct_sg_float(void)
+void test_struct_gather_float(void)
{
- side_event_cond(my_provider_event_structsgfloat) {
+ side_event_cond(my_provider_event_structgatherfloat) {
struct testfloat mystruct = {
#if __HAVE_FLOAT16
.f16 = 1.1,
.f128 = 4.4,
#endif
};
- side_event_call(my_provider_event_structsgfloat,
+ side_event_call(my_provider_event_structgatherfloat,
side_arg_list(
- side_arg_sg_struct(&mystruct),
+ side_arg_gather_struct(&mystruct),
)
);
}
}
-uint32_t mysgarray[] = { 1, 2, 3, 4, 5 };
+uint32_t mygatherarray[] = { 1, 2, 3, 4, 5 };
-uint16_t mysgarray2[] = { 6, 7, 8, 9 };
+uint16_t mygatherarray2[] = { 6, 7, 8, 9 };
struct testarray {
int a;
uint32_t *ptr;
};
-static side_define_struct(mystructsgarray,
+static side_define_struct(mystructgatherarray,
side_field_list(
- side_field_sg_array("array",
- side_elem(side_type_sg_unsigned_integer(0, 32, 0, 32, SIDE_TYPE_SG_ACCESS_ADDRESS, side_attr_list())),
- SIDE_ARRAY_SIZE(mysgarray),
+ side_field_gather_array("array",
+ side_elem(side_type_gather_unsigned_integer(0, 32, 0, 32, SIDE_TYPE_GATHER_ACCESS_ADDRESS, side_attr_list())),
+ SIDE_ARRAY_SIZE(mygatherarray),
offsetof(struct testarray, ptr),
- SIDE_TYPE_SG_ACCESS_POINTER,
+ SIDE_TYPE_GATHER_ACCESS_POINTER,
side_attr_list()),
),
side_attr_list()
);
-side_static_event(my_provider_event_structsgarray,
- "myprovider", "myeventstructsgarray", SIDE_LOGLEVEL_DEBUG,
+side_static_event(my_provider_event_structgatherarray,
+ "myprovider", "myeventstructgatherarray", SIDE_LOGLEVEL_DEBUG,
side_field_list(
- side_field_sg_struct("structsgarray", &mystructsgarray, 0,
- sizeof(struct testarray), SIDE_TYPE_SG_ACCESS_POINTER),
- side_field_sg_array("array2",
- side_elem(side_type_sg_unsigned_integer(0, 16, 0, 16, SIDE_TYPE_SG_ACCESS_ADDRESS, side_attr_list())),
- SIDE_ARRAY_SIZE(mysgarray2), 0,
- SIDE_TYPE_SG_ACCESS_POINTER,
+ side_field_gather_struct("structgatherarray", &mystructgatherarray, 0,
+ sizeof(struct testarray), SIDE_TYPE_GATHER_ACCESS_POINTER),
+ side_field_gather_array("array2",
+ side_elem(side_type_gather_unsigned_integer(0, 16, 0, 16, SIDE_TYPE_GATHER_ACCESS_ADDRESS, side_attr_list())),
+ SIDE_ARRAY_SIZE(mygatherarray2), 0,
+ SIDE_TYPE_GATHER_ACCESS_POINTER,
side_attr_list()
),
),
);
static
-void test_array_sg(void)
+void test_array_gather(void)
{
- side_event_cond(my_provider_event_structsgarray) {
+ side_event_cond(my_provider_event_structgatherarray) {
struct testarray mystruct = {
.a = 55,
- .ptr = mysgarray,
+ .ptr = mygatherarray,
};
- side_event_call(my_provider_event_structsgarray,
+ side_event_call(my_provider_event_structgatherarray,
side_arg_list(
- side_arg_sg_struct(&mystruct),
- side_arg_sg_array(&mysgarray2),
+ side_arg_gather_struct(&mystruct),
+ side_arg_gather_array(&mygatherarray2),
)
);
}
}
#define TESTSGNESTARRAY_LEN 4
-struct testsgstructnest1 {
+struct testgatherstructnest1 {
int b;
int c[TESTSGNESTARRAY_LEN];
};
-struct testsgstructnest0 {
- struct testsgstructnest1 nest;
- struct testsgstructnest1 nestarray[2];
+struct testgatherstructnest0 {
+ struct testgatherstructnest1 nest;
+ struct testgatherstructnest1 nestarray[2];
int a;
};
-static side_define_struct(mystructsgstructnest1,
+static side_define_struct(mystructgatherstructnest1,
side_field_list(
- side_field_sg_signed_integer("b", offsetof(struct testsgstructnest1, b),
- side_struct_field_sizeof_bit(struct testsgstructnest1, b), 0,
- side_struct_field_sizeof_bit(struct testsgstructnest1, b),
- SIDE_TYPE_SG_ACCESS_ADDRESS, side_attr_list()),
- side_field_sg_array("c",
+ side_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_TYPE_GATHER_ACCESS_ADDRESS, side_attr_list()),
+ side_field_gather_array("c",
side_elem(
- side_type_sg_signed_integer(0, 32, 0, 32,
- SIDE_TYPE_SG_ACCESS_ADDRESS, side_attr_list()),
+ side_type_gather_signed_integer(0, 32, 0, 32,
+ SIDE_TYPE_GATHER_ACCESS_ADDRESS, side_attr_list()),
),
TESTSGNESTARRAY_LEN,
- offsetof(struct testsgstructnest1, c),
- SIDE_TYPE_SG_ACCESS_ADDRESS,
+ offsetof(struct testgatherstructnest1, c),
+ SIDE_TYPE_GATHER_ACCESS_ADDRESS,
side_attr_list()),
),
side_attr_list()
);
-static side_define_struct(mystructsgstructnest0,
+static side_define_struct(mystructgatherstructnest0,
side_field_list(
- side_field_sg_signed_integer("a", offsetof(struct testsgstructnest0, a),
- side_struct_field_sizeof_bit(struct testsgstructnest0, a), 0,
- side_struct_field_sizeof_bit(struct testsgstructnest0, a),
- SIDE_TYPE_SG_ACCESS_ADDRESS, side_attr_list()),
- side_field_sg_struct("structnest0", &mystructsgstructnest1,
- offsetof(struct testsgstructnest0, nest),
- sizeof(struct testsgstructnest1),
- SIDE_TYPE_SG_ACCESS_ADDRESS),
- side_field_sg_array("nestarray",
+ side_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_TYPE_GATHER_ACCESS_ADDRESS, side_attr_list()),
+ side_field_gather_struct("structnest0", &mystructgatherstructnest1,
+ offsetof(struct testgatherstructnest0, nest),
+ sizeof(struct testgatherstructnest1),
+ SIDE_TYPE_GATHER_ACCESS_ADDRESS),
+ side_field_gather_array("nestarray",
side_elem(
- side_type_sg_struct(&mystructsgstructnest1,
+ side_type_gather_struct(&mystructgatherstructnest1,
0,
- sizeof(struct testsgstructnest1),
- SIDE_TYPE_SG_ACCESS_ADDRESS),
+ sizeof(struct testgatherstructnest1),
+ SIDE_TYPE_GATHER_ACCESS_ADDRESS),
),
2,
- offsetof(struct testsgstructnest0, nestarray),
- SIDE_TYPE_SG_ACCESS_ADDRESS,
+ offsetof(struct testgatherstructnest0, nestarray),
+ SIDE_TYPE_GATHER_ACCESS_ADDRESS,
side_attr_list()),
),
side_attr_list()
);
-side_static_event(my_provider_event_sgstructnest,
- "myprovider", "myeventsgstructnest", SIDE_LOGLEVEL_DEBUG,
+side_static_event(my_provider_event_gatherstructnest,
+ "myprovider", "myeventgatherstructnest", SIDE_LOGLEVEL_DEBUG,
side_field_list(
- side_field_sg_struct("structsg", &mystructsgstructnest0, 0,
- sizeof(struct testsgstructnest0), SIDE_TYPE_SG_ACCESS_POINTER),
+ side_field_gather_struct("structgather", &mystructgatherstructnest0, 0,
+ sizeof(struct testgatherstructnest0), SIDE_TYPE_GATHER_ACCESS_POINTER),
),
side_attr_list()
);
static
-void test_sg_structnest(void)
+void test_gather_structnest(void)
{
- side_event_cond(my_provider_event_sgstructnest) {
- struct testsgstructnest0 mystruct = {
+ side_event_cond(my_provider_event_gatherstructnest) {
+ struct testgatherstructnest0 mystruct = {
.nest = {
.b = 66,
.c = { 0, 1, 2, 3 },
},
.a = 55,
};
- side_event_call(my_provider_event_sgstructnest,
+ side_event_call(my_provider_event_gatherstructnest,
side_arg_list(
- side_arg_sg_struct(&mystruct),
+ side_arg_gather_struct(&mystruct),
)
);
}
}
-uint32_t sgvla[] = { 1, 2, 3, 4 };
+uint32_t gathervla[] = { 1, 2, 3, 4 };
-struct testsgvla {
+struct testgathervla {
int a;
uint16_t len;
uint32_t *p;
};
-static side_define_struct(mystructsgvla,
+static side_define_struct(mystructgathervla,
side_field_list(
- side_field_sg_signed_integer("a", offsetof(struct testsgvla, a),
- side_struct_field_sizeof_bit(struct testsgvla, a), 0,
- side_struct_field_sizeof_bit(struct testsgvla, a),
- SIDE_TYPE_SG_ACCESS_ADDRESS, side_attr_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_TYPE_GATHER_ACCESS_ADDRESS, side_attr_list()
),
- side_field_sg_vla("nestvla",
- side_elem(side_type_sg_unsigned_integer(0, 32, 0, 32, SIDE_TYPE_SG_ACCESS_ADDRESS, side_attr_list())),
- offsetof(struct testsgvla, p),
- SIDE_TYPE_SG_ACCESS_POINTER,
- side_length(side_type_sg_unsigned_integer(offsetof(struct testsgvla, len),
- 16, 0, 16, SIDE_TYPE_SG_ACCESS_ADDRESS, side_attr_list())),
+ side_field_gather_vla("nestvla",
+ side_elem(side_type_gather_unsigned_integer(0, 32, 0, 32, SIDE_TYPE_GATHER_ACCESS_ADDRESS, 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_ADDRESS, side_attr_list())),
side_attr_list()
),
),
side_attr_list()
);
-side_static_event(my_provider_event_sgvla,
- "myprovider", "myeventsgvla", SIDE_LOGLEVEL_DEBUG,
+side_static_event(my_provider_event_gathervla,
+ "myprovider", "myeventgathervla", SIDE_LOGLEVEL_DEBUG,
side_field_list(
- side_field_sg_struct("structsgvla", &mystructsgvla, 0,
- sizeof(struct testsgvla), SIDE_TYPE_SG_ACCESS_POINTER),
+ side_field_gather_struct("structgathervla", &mystructgathervla, 0,
+ sizeof(struct testgathervla), SIDE_TYPE_GATHER_ACCESS_POINTER),
),
side_attr_list()
);
static
-void test_sg_vla(void)
+void test_gather_vla(void)
{
- side_event_cond(my_provider_event_sgvla) {
- struct testsgvla mystruct = {
+ side_event_cond(my_provider_event_gathervla) {
+ struct testgathervla mystruct = {
.a = 55,
- .len = SIDE_ARRAY_SIZE(sgvla),
- .p = sgvla,
+ .len = SIDE_ARRAY_SIZE(gathervla),
+ .p = gathervla,
};
- side_event_call(my_provider_event_sgvla,
+ side_event_call(my_provider_event_gathervla,
side_arg_list(
- side_arg_sg_struct(&mystruct),
+ side_arg_gather_struct(&mystruct),
)
);
}
}
-struct testsgvlaflex {
+struct testgathervlaflex {
uint8_t len;
uint32_t otherfield;
uint64_t array[];
};
-static side_define_struct(mystructsgvlaflex,
+static side_define_struct(mystructgathervlaflex,
side_field_list(
- side_field_sg_vla("vlaflex",
- side_elem(side_type_sg_unsigned_integer(0, 64, 0, 64, SIDE_TYPE_SG_ACCESS_ADDRESS, side_attr_list())),
- offsetof(struct testsgvlaflex, array),
- SIDE_TYPE_SG_ACCESS_ADDRESS,
- side_length(side_type_sg_unsigned_integer(offsetof(struct testsgvlaflex, len),
- 8, 0, 8, SIDE_TYPE_SG_ACCESS_ADDRESS, side_attr_list())),
+ side_field_gather_vla("vlaflex",
+ side_elem(side_type_gather_unsigned_integer(0, 64, 0, 64, SIDE_TYPE_GATHER_ACCESS_ADDRESS, side_attr_list())),
+ offsetof(struct testgathervlaflex, array),
+ SIDE_TYPE_GATHER_ACCESS_ADDRESS,
+ side_length(side_type_gather_unsigned_integer(offsetof(struct testgathervlaflex, len),
+ 8, 0, 8, SIDE_TYPE_GATHER_ACCESS_ADDRESS, side_attr_list())),
side_attr_list()
),
),
side_attr_list()
);
-side_static_event(my_provider_event_sgvlaflex,
- "myprovider", "myeventsgvlaflex", SIDE_LOGLEVEL_DEBUG,
+side_static_event(my_provider_event_gathervlaflex,
+ "myprovider", "myeventgathervlaflex", SIDE_LOGLEVEL_DEBUG,
side_field_list(
- side_field_sg_struct("structsgvlaflex", &mystructsgvlaflex, 0,
- sizeof(struct testsgvlaflex), SIDE_TYPE_SG_ACCESS_POINTER),
+ side_field_gather_struct("structgathervlaflex", &mystructgathervlaflex, 0,
+ sizeof(struct testgathervlaflex), SIDE_TYPE_GATHER_ACCESS_POINTER),
),
side_attr_list()
);
#define VLAFLEXLEN 6
static
-void test_sg_vla_flex(void)
+void test_gather_vla_flex(void)
{
- side_event_cond(my_provider_event_sgvlaflex) {
- struct testsgvlaflex *mystruct = malloc(sizeof(*mystruct) + VLAFLEXLEN + sizeof(uint64_t));
+ side_event_cond(my_provider_event_gathervlaflex) {
+ struct testgathervlaflex *mystruct = malloc(sizeof(*mystruct) + VLAFLEXLEN + sizeof(uint64_t));
mystruct->len = VLAFLEXLEN;
mystruct->otherfield = 0;
mystruct->array[3] = 4;
mystruct->array[4] = 5;
mystruct->array[5] = 6;
- side_event_call(my_provider_event_sgvlaflex,
+ side_event_call(my_provider_event_gathervlaflex,
side_arg_list(
- side_arg_sg_struct(mystruct),
+ side_arg_gather_struct(mystruct),
)
);
free(mystruct);
test_fmt_string();
test_endian();
test_base();
- test_struct_sg();
- test_struct_sg_nest_ptr();
- test_struct_sg_float();
- test_array_sg();
- test_sg_structnest();
- test_sg_vla();
- test_sg_vla_flex();
+ test_struct_gather();
+ test_struct_gather_nest_ptr();
+ test_struct_gather_float();
+ test_array_gather();
+ test_gather_structnest();
+ test_gather_vla();
+ test_gather_vla_flex();
return 0;
}
static
void tracer_print_dynamic(const struct side_arg *dynamic_item);
static
-uint32_t tracer_print_sg_struct(const struct side_type_sg *type_sg, const void *_ptr);
+uint32_t tracer_print_gather_struct(const struct side_type_gather *type_gather, const void *_ptr);
static
-uint32_t tracer_print_sg_integer_type(const struct side_type_sg *type_sg, const void *_ptr);
+uint32_t tracer_print_gather_integer_type(const struct side_type_gather *type_gather, const void *_ptr);
static
-uint32_t tracer_print_sg_float_type(const struct side_type_sg *type_sg, const void *_ptr);
+uint32_t tracer_print_gather_float_type(const struct side_type_gather *type_gather, const void *_ptr);
static
-uint32_t tracer_print_sg_array(const struct side_type_sg *type_sg, const void *_ptr);
+uint32_t tracer_print_gather_array(const struct side_type_gather *type_gather, const void *_ptr);
static
-uint32_t tracer_print_sg_vla(const struct side_type_sg *type_sg, const void *_ptr);
+uint32_t tracer_print_gather_vla(const struct side_type_gather *type_gather, const void *_ptr);
static
void tracer_print_type(const struct side_type *type_desc, const struct side_arg *item);
case SIDE_TYPE_STRUCT:
tracer_print_struct(type_desc, item->u.side_static.side_struct);
break;
- case SIDE_TYPE_SG_STRUCT:
- (void) tracer_print_sg_struct(&type_desc->u.side_sg, &item->u.side_static.side_struct_sg_ptr);
+ case SIDE_TYPE_GATHER_STRUCT:
+ (void) tracer_print_gather_struct(&type_desc->u.side_gather, &item->u.side_static.side_struct_gather_ptr);
break;
- case SIDE_TYPE_SG_ARRAY:
- (void) tracer_print_sg_array(&type_desc->u.side_sg, &item->u.side_static.side_array_sg_ptr);
+ case SIDE_TYPE_GATHER_ARRAY:
+ (void) tracer_print_gather_array(&type_desc->u.side_gather, &item->u.side_static.side_array_gather_ptr);
break;
- case SIDE_TYPE_SG_UNSIGNED_INT:
- case SIDE_TYPE_SG_SIGNED_INT:
- (void) tracer_print_sg_integer_type(&type_desc->u.side_sg, item->u.side_static.side_integer_sg_ptr);
+ case SIDE_TYPE_GATHER_UNSIGNED_INT:
+ case SIDE_TYPE_GATHER_SIGNED_INT:
+ (void) tracer_print_gather_integer_type(&type_desc->u.side_gather, item->u.side_static.side_integer_gather_ptr);
break;
- case SIDE_TYPE_SG_FLOAT:
- (void) tracer_print_sg_float_type(&type_desc->u.side_sg, item->u.side_static.side_float_sg_ptr);
+ case SIDE_TYPE_GATHER_FLOAT:
+ (void) tracer_print_gather_float_type(&type_desc->u.side_gather, item->u.side_static.side_float_gather_ptr);
break;
case SIDE_TYPE_ARRAY:
tracer_print_array(type_desc, item->u.side_static.side_array);
case SIDE_TYPE_DYNAMIC_VLA_VISITOR:
tracer_print_dynamic(item);
break;
- case SIDE_TYPE_SG_VLA:
- fprintf(stderr, "<scatter-gather VLA only supported within scatter-gather structures>\n");
+ case SIDE_TYPE_GATHER_VLA:
+ fprintf(stderr, "<gather VLA only supported within gather structures>\n");
abort();
default:
fprintf(stderr, "<UNKNOWN TYPE>");
}
static
-const char *tracer_sg_access(enum side_type_sg_access_mode access_mode, const char *ptr)
+const char *tracer_gather_access(enum side_type_gather_access_mode access_mode, const char *ptr)
{
switch (access_mode) {
- case SIDE_TYPE_SG_ACCESS_ADDRESS:
+ case SIDE_TYPE_GATHER_ACCESS_ADDRESS:
return ptr;
- case SIDE_TYPE_SG_ACCESS_POINTER:
+ case SIDE_TYPE_GATHER_ACCESS_POINTER:
/* Dereference pointer */
memcpy(&ptr, ptr, sizeof(ptr));
return ptr;
}
static
-uint32_t tracer_sg_size(enum side_type_sg_access_mode access_mode, uint32_t len)
+uint32_t tracer_gather_size(enum side_type_gather_access_mode access_mode, uint32_t len)
{
switch (access_mode) {
- case SIDE_TYPE_SG_ACCESS_ADDRESS:
+ case SIDE_TYPE_GATHER_ACCESS_ADDRESS:
return len;
- case SIDE_TYPE_SG_ACCESS_POINTER:
+ case SIDE_TYPE_GATHER_ACCESS_POINTER:
return sizeof(void *);
default:
abort();
}
static
-uint64_t tracer_load_sg_integer_type(const struct side_type_sg *type_sg, const void *_ptr)
+uint64_t tracer_load_gather_integer_type(const struct side_type_gather *type_gather, const void *_ptr)
{
- enum side_type_sg_access_mode access_mode = type_sg->u.side_integer.access_mode;
- uint32_t integer_size_bytes = type_sg->u.side_integer.type.integer_size_bits >> 3;
+ 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;
const char *ptr = (const char *) _ptr;
union side_integer_value value;
- ptr = tracer_sg_access(access_mode, ptr + type_sg->u.side_integer.offset);
+ ptr = tracer_gather_access(access_mode, ptr + type_gather->u.side_integer.offset);
memcpy(&value, ptr, integer_size_bytes);
- switch (type_sg->u.side_integer.type.integer_size_bits) {
+ switch (type_gather->u.side_integer.type.integer_size_bits) {
case 8:
return (uint64_t) value.side_u8;
case 16:
}
static
-uint32_t tracer_print_sg_integer_type(const struct side_type_sg *type_sg, const void *_ptr)
+uint32_t tracer_print_gather_integer_type(const struct side_type_gather *type_gather, const void *_ptr)
{
- enum side_type_sg_access_mode access_mode = type_sg->u.side_integer.access_mode;
- uint32_t integer_size_bytes = type_sg->u.side_integer.type.integer_size_bits >> 3;
+ 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;
const char *ptr = (const char *) _ptr;
union side_integer_value value;
- switch (type_sg->u.side_integer.type.integer_size_bits) {
+ switch (type_gather->u.side_integer.type.integer_size_bits) {
case 8:
case 16:
case 32:
default:
abort();
}
- ptr = tracer_sg_access(access_mode, ptr + type_sg->u.side_integer.offset);
+ ptr = tracer_gather_access(access_mode, ptr + type_gather->u.side_integer.offset);
memcpy(&value, ptr, integer_size_bytes);
- tracer_print_type_integer(":", &type_sg->u.side_integer.type, &value,
- type_sg->u.side_integer.offset_bits, TRACER_DISPLAY_BASE_10);
- return tracer_sg_size(access_mode, integer_size_bytes);
+ tracer_print_type_integer(":", &type_gather->u.side_integer.type, &value,
+ type_gather->u.side_integer.offset_bits, TRACER_DISPLAY_BASE_10);
+ return tracer_gather_size(access_mode, integer_size_bytes);
}
static
-uint32_t tracer_print_sg_float_type(const struct side_type_sg *type_sg, const void *_ptr)
+uint32_t tracer_print_gather_float_type(const struct side_type_gather *type_gather, const void *_ptr)
{
- enum side_type_sg_access_mode access_mode = type_sg->u.side_float.access_mode;
- uint32_t float_size_bytes = type_sg->u.side_float.type.float_size_bits >> 3;
+ 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;
const char *ptr = (const char *) _ptr;
union side_float_value value;
- switch (type_sg->u.side_float.type.float_size_bits) {
+ switch (type_gather->u.side_float.type.float_size_bits) {
case 16:
case 32:
case 64:
default:
abort();
}
- ptr = tracer_sg_access(access_mode, ptr + type_sg->u.side_float.offset);
+ ptr = tracer_gather_access(access_mode, ptr + type_gather->u.side_float.offset);
memcpy(&value, ptr, float_size_bytes);
- tracer_print_type_float(":", &type_sg->u.side_float.type, &value);
- return tracer_sg_size(access_mode, float_size_bytes);
+ tracer_print_type_float(":", &type_gather->u.side_float.type, &value);
+ return tracer_gather_size(access_mode, float_size_bytes);
}
static
-uint32_t tracer_print_sg_type(const struct side_type *type_desc, const void *ptr)
+uint32_t tracer_print_gather_type(const struct side_type *type_desc, const void *ptr)
{
uint32_t len;
printf("{ ");
switch (type_desc->type) {
- case SIDE_TYPE_SG_UNSIGNED_INT:
- case SIDE_TYPE_SG_SIGNED_INT:
- len = tracer_print_sg_integer_type(&type_desc->u.side_sg, ptr);
+ case SIDE_TYPE_GATHER_UNSIGNED_INT:
+ case SIDE_TYPE_GATHER_SIGNED_INT:
+ len = tracer_print_gather_integer_type(&type_desc->u.side_gather, ptr);
break;
- case SIDE_TYPE_SG_FLOAT:
- len = tracer_print_sg_float_type(&type_desc->u.side_sg, ptr);
+ case SIDE_TYPE_GATHER_FLOAT:
+ len = tracer_print_gather_float_type(&type_desc->u.side_gather, ptr);
break;
- case SIDE_TYPE_SG_STRUCT:
- len = tracer_print_sg_struct(&type_desc->u.side_sg, ptr);
+ case SIDE_TYPE_GATHER_STRUCT:
+ len = tracer_print_gather_struct(&type_desc->u.side_gather, ptr);
break;
- case SIDE_TYPE_SG_ARRAY:
- len = tracer_print_sg_array(&type_desc->u.side_sg, ptr);
+ case SIDE_TYPE_GATHER_ARRAY:
+ len = tracer_print_gather_array(&type_desc->u.side_gather, ptr);
break;
- case SIDE_TYPE_SG_VLA:
- len = tracer_print_sg_vla(&type_desc->u.side_sg, ptr);
+ case SIDE_TYPE_GATHER_VLA:
+ len = tracer_print_gather_vla(&type_desc->u.side_gather, ptr);
break;
default:
- fprintf(stderr, "<UNKNOWN SCATTER-GATHER TYPE>");
+ fprintf(stderr, "<UNKNOWN GATHER TYPE>");
abort();
}
printf(" }");
}
static
-void tracer_print_sg_field(const struct side_event_field *field, const void *ptr)
+void tracer_print_gather_field(const struct side_event_field *field, const void *ptr)
{
printf("%s: ", field->field_name);
- (void) tracer_print_sg_type(&field->side_type, ptr);
+ (void) tracer_print_gather_type(&field->side_type, ptr);
}
static
-uint32_t tracer_print_sg_struct(const struct side_type_sg *type_sg, const void *_ptr)
+uint32_t tracer_print_gather_struct(const struct side_type_gather *type_gather, const void *_ptr)
{
- enum side_type_sg_access_mode access_mode = type_sg->u.side_struct.access_mode;
+ enum side_type_gather_access_mode access_mode = type_gather->u.side_struct.access_mode;
const char *ptr = (const char *) _ptr;
uint32_t i;
- ptr = tracer_sg_access(access_mode, ptr + type_sg->u.side_struct.offset);
- print_attributes("attr", ":", type_sg->u.side_struct.type->attr, type_sg->u.side_struct.type->nr_attr);
- printf("%s", type_sg->u.side_struct.type->nr_attr ? ", " : "");
+ ptr = tracer_gather_access(access_mode, ptr + type_gather->u.side_struct.offset);
+ print_attributes("attr", ":", type_gather->u.side_struct.type->attr, type_gather->u.side_struct.type->nr_attr);
+ printf("%s", type_gather->u.side_struct.type->nr_attr ? ", " : "");
printf("fields: { ");
- for (i = 0; i < type_sg->u.side_struct.type->nr_fields; i++) {
+ for (i = 0; i < type_gather->u.side_struct.type->nr_fields; i++) {
printf("%s", i ? ", " : "");
- tracer_print_sg_field(&type_sg->u.side_struct.type->fields[i], ptr);
+ tracer_print_gather_field(&type_gather->u.side_struct.type->fields[i], ptr);
}
printf(" }");
- return tracer_sg_size(access_mode, type_sg->u.side_struct.size);
+ return tracer_gather_size(access_mode, type_gather->u.side_struct.size);
}
static
-uint32_t tracer_print_sg_array(const struct side_type_sg *type_sg, const void *_ptr)
+uint32_t tracer_print_gather_array(const struct side_type_gather *type_gather, const void *_ptr)
{
- enum side_type_sg_access_mode access_mode = type_sg->u.side_array.access_mode;
+ enum side_type_gather_access_mode access_mode = type_gather->u.side_array.access_mode;
const char *ptr = (const char *) _ptr, *orig_ptr;
uint32_t i;
- ptr = tracer_sg_access(access_mode, ptr + type_sg->u.side_array.offset);
+ ptr = tracer_gather_access(access_mode, ptr + type_gather->u.side_array.offset);
orig_ptr = ptr;
- print_attributes("attr", ":", type_sg->u.side_array.type.attr, type_sg->u.side_array.type.nr_attr);
- printf("%s", type_sg->u.side_array.type.nr_attr ? ", " : "");
+ print_attributes("attr", ":", type_gather->u.side_array.type.attr, type_gather->u.side_array.type.nr_attr);
+ printf("%s", type_gather->u.side_array.type.nr_attr ? ", " : "");
printf("elements: ");
printf("[ ");
- for (i = 0; i < type_sg->u.side_array.type.length; i++) {
- switch (type_sg->u.side_array.type.elem_type->type) {
- case SIDE_TYPE_SG_VLA:
- fprintf(stderr, "<scatter-gather VLA only supported within scatter-gather structures>\n");
+ for (i = 0; i < type_gather->u.side_array.type.length; i++) {
+ switch (type_gather->u.side_array.type.elem_type->type) {
+ case SIDE_TYPE_GATHER_VLA:
+ fprintf(stderr, "<gather VLA only supported within gather structures>\n");
abort();
default:
break;
}
printf("%s", i ? ", " : "");
- ptr += tracer_print_sg_type(type_sg->u.side_array.type.elem_type, ptr);
+ ptr += tracer_print_gather_type(type_gather->u.side_array.type.elem_type, ptr);
}
printf(" ]");
- return tracer_sg_size(access_mode, ptr - orig_ptr);
+ return tracer_gather_size(access_mode, ptr - orig_ptr);
}
static
-uint32_t tracer_print_sg_vla(const struct side_type_sg *type_sg, const void *_ptr)
+uint32_t tracer_print_gather_vla(const struct side_type_gather *type_gather, const void *_ptr)
{
- enum side_type_sg_access_mode access_mode = type_sg->u.side_vla.access_mode;
+ enum side_type_gather_access_mode access_mode = type_gather->u.side_vla.access_mode;
const char *ptr = (const char *) _ptr, *orig_ptr;
uint32_t i, length;
/* Access length */
- switch (type_sg->u.side_vla.length_type->type) {
- case SIDE_TYPE_SG_UNSIGNED_INT:
- case SIDE_TYPE_SG_SIGNED_INT:
+ switch (type_gather->u.side_vla.length_type->type) {
+ case SIDE_TYPE_GATHER_UNSIGNED_INT:
+ case SIDE_TYPE_GATHER_SIGNED_INT:
break;
default:
- fprintf(stderr, "<scatter-gather VLA expects integer scatter-gather length type>\n");
+ fprintf(stderr, "<gather VLA expects integer gather length type>\n");
abort();
}
- length = (uint32_t) tracer_load_sg_integer_type(&type_sg->u.side_vla.length_type->u.side_sg, ptr);
- ptr = tracer_sg_access(access_mode, ptr + type_sg->u.side_vla.offset);
+ length = (uint32_t) tracer_load_gather_integer_type(&type_gather->u.side_vla.length_type->u.side_gather, ptr);
+ ptr = tracer_gather_access(access_mode, ptr + type_gather->u.side_vla.offset);
orig_ptr = ptr;
- print_attributes("attr", ":", type_sg->u.side_vla.type.attr, type_sg->u.side_vla.type.nr_attr);
- printf("%s", type_sg->u.side_vla.type.nr_attr ? ", " : "");
+ print_attributes("attr", ":", type_gather->u.side_vla.type.attr, type_gather->u.side_vla.type.nr_attr);
+ printf("%s", type_gather->u.side_vla.type.nr_attr ? ", " : "");
printf("elements: ");
printf("[ ");
for (i = 0; i < length; i++) {
- switch (type_sg->u.side_vla.type.elem_type->type) {
- case SIDE_TYPE_SG_VLA:
- fprintf(stderr, "<scatter-gather VLA only supported within scatter-gather structures>\n");
+ switch (type_gather->u.side_vla.type.elem_type->type) {
+ case SIDE_TYPE_GATHER_VLA:
+ fprintf(stderr, "<gather VLA only supported within gather structures>\n");
abort();
default:
break;
}
printf("%s", i ? ", " : "");
- ptr += tracer_print_sg_type(type_sg->u.side_vla.type.elem_type, ptr);
+ ptr += tracer_print_gather_type(type_gather->u.side_vla.type.elem_type, ptr);
}
printf(" ]");
- return tracer_sg_size(access_mode, ptr - orig_ptr);
+ return tracer_gather_size(access_mode, ptr - orig_ptr);
}
struct tracer_visitor_priv {
projects / libside.git / commitdiff
