--- /dev/null
+// SPDX-License-Identifier: MIT
+/*
+ *
+ * Copyright (C) 2012,2022 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
+ */
+
+/*
+ * This header defines the following endian macros based on the current
+ * platform endian headers:
+ *
+ * BYTE_ORDER this macro shall have a value equal to one
+ * of the *_ENDIAN macros in this header.
+ * FLOAT_WORD_ORDER this macro shall have a value equal to one
+ * of the *_ENDIAN macros in this header.
+ * LITTLE_ENDIAN if BYTE_ORDER == LITTLE_ENDIAN, the host
+ * byte order is from least significant to
+ * most significant.
+ * BIG_ENDIAN if BYTE_ORDER == BIG_ENDIAN, the host byte
+ * order is from most significant to least
+ * significant.
+ *
+ * Direct byte swapping interfaces:
+ *
+ * uint16_t bswap_16(uint16_t x); (* swap bytes 16-bit word *)
+ * uint32_t bswap_32(uint32_t x); (* swap bytes 32-bit word *)
+ * uint64_t bswap_64(uint32_t x); (* swap bytes 64-bit word *)
+ */
+
+#ifndef _SIDE_ENDIAN_H
+#define _SIDE_ENDIAN_H
+
+#include <math.h>
+
+#if (defined(__linux__) || defined(__CYGWIN__))
+#include <endian.h>
+#include <byteswap.h>
+
+#define side_bswap_16(x) bswap_16(x)
+#define side_bswap_32(x) bswap_32(x)
+#define side_bswap_64(x) bswap_64(x)
+
+#define SIDE_BYTE_ORDER __BYTE_ORDER
+#define SIDE_LITTLE_ENDIAN __LITTLE_ENDIAN
+#define SIDE_BIG_ENDIAN __BIG_ENDIAN
+
+#ifdef __FLOAT_WORD_ORDER
+#define SIDE_FLOAT_WORD_ORDER __FLOAT_WORD_ORDER
+#else /* __FLOAT_WORD_ORDER */
+#define SIDE_FLOAT_WORD_ORDER __BYTE_ORDER
+#endif /* __FLOAT_WORD_ORDER */
+
+#elif defined(__FreeBSD__)
+
+#include <sys/endian.h>
+
+#define side_bswap_16(x) bswap16(x)
+#define side_bswap_32(x) bswap32(x)
+#define side_bswap_64(x) bswap64(x)
+
+#define SIDE_BYTE_ORDER BYTE_ORDER
+#define SIDE_LITTLE_ENDIAN LITTLE_ENDIAN
+#define SIDE_BIG_ENDIAN BIG_ENDIAN
+#define SIDE_FLOAT_WORD_ORDER BYTE_ORDER
+
+#else
+#error "Please add support for your OS."
+#endif
+
+#ifdef __HAVE_FLOAT128
+static inline
+void side_bswap_128p(char *p)
+{
+ int i;
+
+ for (i = 0; i < 8; i++)
+ p[i] = p[15 - i];
+}
+#endif
+
+#endif /* _SIDE_ENDIAN_H */
#include <stdio.h>
#include <math.h>
#include <side/macros.h>
+#include <side/endian.h>
/* SIDE stands for "Static Instrumentation Dynamically Enabled" */
SIDE_ERROR_EXITING = 5,
};
+enum side_type_byte_order {
+ SIDE_TYPE_BYTE_ORDER_LE = 0,
+ SIDE_TYPE_BYTE_ORDER_BE = 1,
+};
+
+#if (SIDE_BYTE_ORDER == SIDE_LITTLE_ENDIAN)
+# define SIDE_TYPE_BYTE_ORDER_HOST SIDE_TYPE_BYTE_ORDER_LE
+#else
+# define SIDE_TYPE_BYTE_ORDER_HOST SIDE_TYPE_BYTE_ORDER_BE
+#endif
+
+#if (SIDE_FLOAT_WORD_ORDER == SIDE_LITTLE_ENDIAN)
+# define SIDE_TYPE_FLOAT_WORD_ORDER_HOST SIDE_TYPE_BYTE_ORDER_LE
+#else
+# define SIDE_TYPE_FLOAT_WORD_ORDER_HOST SIDE_TYPE_BYTE_ORDER_BE
+#endif
+
typedef enum side_visitor_status (*side_visitor)(
const struct side_tracer_visitor_ctx *tracer_ctx,
void *app_ctx);
struct {
const struct side_attr *attr;
uint32_t nr_attr;
+ uint32_t byte_order; /* enum side_type_byte_order */
} side_basic;
/* Compound types */
struct {
const struct side_attr *attr;
uint32_t nr_attr;
+ uint32_t byte_order; /* enum side_type_byte_order */
union {
uint8_t side_bool;
uint8_t side_u8;
/* Static field definition */
-#define _side_type_basic(_type, _attr) \
+#define _side_type_basic(_type, _byte_order, _attr) \
{ \
.type = _type, \
.u = { \
.side_basic = { \
.attr = _attr, \
.nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
+ .byte_order = _byte_order, \
}, \
}, \
}
-#define side_type_bool(_attr) _side_type_basic(SIDE_TYPE_BOOL, SIDE_PARAM(_attr))
-#define side_type_u8(_attr) _side_type_basic(SIDE_TYPE_U8, SIDE_PARAM(_attr))
-#define side_type_u16(_attr) _side_type_basic(SIDE_TYPE_U16, SIDE_PARAM(_attr))
-#define side_type_u32(_attr) _side_type_basic(SIDE_TYPE_U32, SIDE_PARAM(_attr))
-#define side_type_u64(_attr) _side_type_basic(SIDE_TYPE_U64, SIDE_PARAM(_attr))
-#define side_type_s8(_attr) _side_type_basic(SIDE_TYPE_S8, SIDE_PARAM(_attr))
-#define side_type_s16(_attr) _side_type_basic(SIDE_TYPE_S16, SIDE_PARAM(_attr))
-#define side_type_s32(_attr) _side_type_basic(SIDE_TYPE_S32, SIDE_PARAM(_attr))
-#define side_type_s64(_attr) _side_type_basic(SIDE_TYPE_S64, SIDE_PARAM(_attr))
-#define side_type_byte(_attr) _side_type_basic(SIDE_TYPE_BYTE, SIDE_PARAM(_attr))
-#define side_type_float_binary16(_attr) _side_type_basic(SIDE_TYPE_FLOAT_BINARY16, SIDE_PARAM(_attr))
-#define side_type_float_binary32(_attr) _side_type_basic(SIDE_TYPE_FLOAT_BINARY32, SIDE_PARAM(_attr))
-#define side_type_float_binary64(_attr) _side_type_basic(SIDE_TYPE_FLOAT_BINARY64, SIDE_PARAM(_attr))
-#define side_type_float_binary128(_attr) _side_type_basic(SIDE_TYPE_FLOAT_BINARY128, SIDE_PARAM(_attr))
-#define side_type_string(_attr) _side_type_basic(SIDE_TYPE_STRING, SIDE_PARAM(_attr))
-#define side_type_dynamic(_attr) _side_type_basic(SIDE_TYPE_DYNAMIC, SIDE_PARAM(_attr))
-
#define _side_field(_name, _type) \
{ \
.field_name = _name, \
.side_type = _type, \
}
+/* Host endian */
+#define side_type_bool(_attr) _side_type_basic(SIDE_TYPE_BOOL, SIDE_TYPE_BYTE_ORDER_HOST, SIDE_PARAM(_attr))
+#define side_type_u8(_attr) _side_type_basic(SIDE_TYPE_U8, SIDE_TYPE_BYTE_ORDER_HOST, SIDE_PARAM(_attr))
+#define side_type_u16(_attr) _side_type_basic(SIDE_TYPE_U16, SIDE_TYPE_BYTE_ORDER_HOST, SIDE_PARAM(_attr))
+#define side_type_u32(_attr) _side_type_basic(SIDE_TYPE_U32, SIDE_TYPE_BYTE_ORDER_HOST, SIDE_PARAM(_attr))
+#define side_type_u64(_attr) _side_type_basic(SIDE_TYPE_U64, SIDE_TYPE_BYTE_ORDER_HOST, SIDE_PARAM(_attr))
+#define side_type_s8(_attr) _side_type_basic(SIDE_TYPE_S8, SIDE_TYPE_BYTE_ORDER_HOST, SIDE_PARAM(_attr))
+#define side_type_s16(_attr) _side_type_basic(SIDE_TYPE_S16, SIDE_TYPE_BYTE_ORDER_HOST, SIDE_PARAM(_attr))
+#define side_type_s32(_attr) _side_type_basic(SIDE_TYPE_S32, SIDE_TYPE_BYTE_ORDER_HOST, SIDE_PARAM(_attr))
+#define side_type_s64(_attr) _side_type_basic(SIDE_TYPE_S64, SIDE_TYPE_BYTE_ORDER_HOST, SIDE_PARAM(_attr))
+#define side_type_byte(_attr) _side_type_basic(SIDE_TYPE_BYTE, SIDE_TYPE_BYTE_ORDER_HOST, SIDE_PARAM(_attr))
+#define side_type_float_binary16(_attr) _side_type_basic(SIDE_TYPE_FLOAT_BINARY16, SIDE_TYPE_FLOAT_WORD_ORDER_HOST, SIDE_PARAM(_attr))
+#define side_type_float_binary32(_attr) _side_type_basic(SIDE_TYPE_FLOAT_BINARY32, SIDE_TYPE_FLOAT_WORD_ORDER_HOST, SIDE_PARAM(_attr))
+#define side_type_float_binary64(_attr) _side_type_basic(SIDE_TYPE_FLOAT_BINARY64, SIDE_TYPE_FLOAT_WORD_ORDER_HOST, SIDE_PARAM(_attr))
+#define side_type_float_binary128(_attr) _side_type_basic(SIDE_TYPE_FLOAT_BINARY128, SIDE_TYPE_FLOAT_WORD_ORDER_HOST, SIDE_PARAM(_attr))
+#define side_type_string(_attr) _side_type_basic(SIDE_TYPE_STRING, SIDE_TYPE_BYTE_ORDER_HOST, SIDE_PARAM(_attr))
+#define side_type_dynamic(_attr) _side_type_basic(SIDE_TYPE_DYNAMIC, SIDE_TYPE_BYTE_ORDER_HOST, SIDE_PARAM(_attr))
+
#define side_field_bool(_name, _attr) _side_field(_name, side_type_bool(SIDE_PARAM(_attr)))
#define side_field_u8(_name, _attr) _side_field(_name, side_type_u8(SIDE_PARAM(_attr)))
#define side_field_u16(_name, _attr) _side_field(_name, side_type_u16(SIDE_PARAM(_attr)))
#define side_field_string(_name, _attr) _side_field(_name, side_type_string(SIDE_PARAM(_attr)))
#define side_field_dynamic(_name, _attr) _side_field(_name, side_type_dynamic(SIDE_PARAM(_attr)))
+/* Little endian */
+#define side_type_u16_le(_attr) _side_type_basic(SIDE_TYPE_U16, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
+#define side_type_u32_le(_attr) _side_type_basic(SIDE_TYPE_U32, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
+#define side_type_u64_le(_attr) _side_type_basic(SIDE_TYPE_U64, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
+#define side_type_s16_le(_attr) _side_type_basic(SIDE_TYPE_S16, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
+#define side_type_s32_le(_attr) _side_type_basic(SIDE_TYPE_S32, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
+#define side_type_s64_le(_attr) _side_type_basic(SIDE_TYPE_S64, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
+#define side_type_float_binary16_le(_attr) _side_type_basic(SIDE_TYPE_FLOAT_BINARY16, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
+#define side_type_float_binary32_le(_attr) _side_type_basic(SIDE_TYPE_FLOAT_BINARY32, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
+#define side_type_float_binary64_le(_attr) _side_type_basic(SIDE_TYPE_FLOAT_BINARY64, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
+#define side_type_float_binary128_le(_attr) _side_type_basic(SIDE_TYPE_FLOAT_BINARY128, SIDE_TYPE_BYTE_ORDER_LE, 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)))
+#define side_field_u64_le(_name, _attr) _side_field(_name, side_type_u64_le(SIDE_PARAM(_attr)))
+#define side_field_s16_le(_name, _attr) _side_field(_name, side_type_s16_le(SIDE_PARAM(_attr)))
+#define side_field_s32_le(_name, _attr) _side_field(_name, side_type_s32_le(SIDE_PARAM(_attr)))
+#define side_field_s64_le(_name, _attr) _side_field(_name, side_type_s64_le(SIDE_PARAM(_attr)))
+#define side_field_float_binary16_le(_name, _attr) _side_field(_name, side_type_float_binary16_le(SIDE_PARAM(_attr)))
+#define side_field_float_binary32_le(_name, _attr) _side_field(_name, side_type_float_binary32_le(SIDE_PARAM(_attr)))
+#define side_field_float_binary64_le(_name, _attr) _side_field(_name, side_type_float_binary64_le(SIDE_PARAM(_attr)))
+#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_basic(SIDE_TYPE_U16, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
+#define side_type_u32_be(_attr) _side_type_basic(SIDE_TYPE_U32, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
+#define side_type_u64_be(_attr) _side_type_basic(SIDE_TYPE_U64, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
+#define side_type_s16_be(_attr) _side_type_basic(SIDE_TYPE_S16, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
+#define side_type_s32_be(_attr) _side_type_basic(SIDE_TYPE_S32, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
+#define side_type_s64_be(_attr) _side_type_basic(SIDE_TYPE_S64, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
+#define side_type_float_binary16_be(_attr) _side_type_basic(SIDE_TYPE_FLOAT_BINARY16, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
+#define side_type_float_binary32_be(_attr) _side_type_basic(SIDE_TYPE_FLOAT_BINARY32, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
+#define side_type_float_binary64_be(_attr) _side_type_basic(SIDE_TYPE_FLOAT_BINARY64, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
+#define side_type_float_binary128_be(_attr) _side_type_basic(SIDE_TYPE_FLOAT_BINARY128, SIDE_TYPE_BYTE_ORDER_BE, 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)))
+#define side_field_u64_be(_name, _attr) _side_field(_name, side_type_u64_be(SIDE_PARAM(_attr)))
+#define side_field_s16_be(_name, _attr) _side_field(_name, side_type_s16_be(SIDE_PARAM(_attr)))
+#define side_field_s32_be(_name, _attr) _side_field(_name, side_type_s32_be(SIDE_PARAM(_attr)))
+#define side_field_s64_be(_name, _attr) _side_field(_name, side_type_s64_be(SIDE_PARAM(_attr)))
+#define side_field_float_binary16_be(_name, _attr) _side_field(_name, side_type_float_binary16_be(SIDE_PARAM(_attr)))
+#define side_field_float_binary32_be(_name, _attr) _side_field(_name, side_type_float_binary32_be(SIDE_PARAM(_attr)))
+#define side_field_float_binary64_be(_name, _attr) _side_field(_name, side_type_float_binary64_be(SIDE_PARAM(_attr)))
+#define side_field_float_binary128_be(_name, _attr) _side_field(_name, side_type_float_binary128_be(SIDE_PARAM(_attr)))
+
#define side_type_enum(_mappings, _elem_type) \
{ \
.type = SIDE_TYPE_ENUM, \
.side_basic = { \
.attr = _attr, \
.nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
+ .byte_order = SIDE_TYPE_BYTE_ORDER_HOST, \
}, \
}, \
}
.side_basic = { \
.attr = _attr, \
.nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
+ .byte_order = SIDE_TYPE_BYTE_ORDER_HOST, \
.u = { \
.side_bool = !!(_val), \
}, \
.side_basic = { \
.attr = _attr, \
.nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
+ .byte_order = SIDE_TYPE_BYTE_ORDER_HOST, \
.u = { \
.side_u8 = (_val), \
}, \
}, \
}, \
}
-#define side_arg_dynamic_u16(_val, _attr) \
+#define side_arg_dynamic_s8(_val, _attr) \
{ \
- .dynamic_type = SIDE_DYNAMIC_TYPE_U16, \
+ .dynamic_type = SIDE_DYNAMIC_TYPE_S8, \
.u = { \
.side_basic = { \
.attr = _attr, \
.nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
+ .byte_order = SIDE_TYPE_BYTE_ORDER_HOST, \
.u = { \
- .side_u16 = (_val), \
+ .side_s8 = (_val), \
}, \
}, \
}, \
}
-#define side_arg_dynamic_u32(_val, _attr) \
+#define side_arg_dynamic_byte(_val, _attr) \
{ \
- .dynamic_type = SIDE_DYNAMIC_TYPE_U32, \
+ .dynamic_type = SIDE_DYNAMIC_TYPE_BYTE, \
.u = { \
.side_basic = { \
.attr = _attr, \
.nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
+ .byte_order = SIDE_TYPE_BYTE_ORDER_HOST, \
.u = { \
- .side_u32 = (_val), \
+ .side_byte = (_val), \
}, \
}, \
}, \
}
-#define side_arg_dynamic_u64(_val, _attr) \
+#define side_arg_dynamic_string(_val, _attr) \
{ \
- .dynamic_type = SIDE_DYNAMIC_TYPE_U64, \
+ .dynamic_type = SIDE_DYNAMIC_TYPE_STRING, \
.u = { \
.side_basic = { \
.attr = _attr, \
.nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
+ .byte_order = SIDE_TYPE_BYTE_ORDER_HOST, \
.u = { \
- .side_u64 = (_val), \
+ .string = (_val), \
}, \
}, \
}, \
}
-#define side_arg_dynamic_s8(_val, _attr) \
+#define _side_arg_dynamic_u16(_val, _byte_order, _attr) \
{ \
- .dynamic_type = SIDE_DYNAMIC_TYPE_S8, \
+ .dynamic_type = SIDE_DYNAMIC_TYPE_U16, \
.u = { \
.side_basic = { \
.attr = _attr, \
.nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
+ .byte_order = _byte_order, \
.u = { \
- .side_s8 = (_val), \
+ .side_u16 = (_val), \
}, \
}, \
}, \
}
-#define side_arg_dynamic_s16(_val, _attr) \
+#define _side_arg_dynamic_u32(_val, _byte_order, _attr) \
{ \
- .dynamic_type = SIDE_DYNAMIC_TYPE_S16, \
+ .dynamic_type = SIDE_DYNAMIC_TYPE_U32, \
.u = { \
.side_basic = { \
.attr = _attr, \
.nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
+ .byte_order = _byte_order, \
.u = { \
- .side_s16 = (_val), \
+ .side_u32 = (_val), \
}, \
}, \
}, \
}
-#define side_arg_dynamic_s32(_val, _attr) \
+#define _side_arg_dynamic_u64(_val, _byte_order, _attr) \
{ \
- .dynamic_type = SIDE_DYNAMIC_TYPE_S32, \
+ .dynamic_type = SIDE_DYNAMIC_TYPE_U64, \
.u = { \
.side_basic = { \
.attr = _attr, \
.nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
+ .byte_order = _byte_order, \
.u = { \
- .side_s32 = (_val), \
+ .side_u64 = (_val), \
}, \
}, \
}, \
}
-#define side_arg_dynamic_s64(_val, _attr) \
+
+#define _side_arg_dynamic_s16(_val, _byte_order, _attr) \
{ \
- .dynamic_type = SIDE_DYNAMIC_TYPE_S64, \
+ .dynamic_type = SIDE_DYNAMIC_TYPE_S16, \
.u = { \
.side_basic = { \
.attr = _attr, \
.nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
+ .byte_order = _byte_order, \
.u = { \
- .side_s64 = (_val), \
+ .side_s16 = (_val), \
}, \
}, \
}, \
}
-#define side_arg_dynamic_byte(_val, _attr) \
+#define _side_arg_dynamic_s32(_val, _byte_order, _attr) \
{ \
- .dynamic_type = SIDE_DYNAMIC_TYPE_BYTE, \
+ .dynamic_type = SIDE_DYNAMIC_TYPE_S32, \
.u = { \
.side_basic = { \
.attr = _attr, \
.nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
+ .byte_order = _byte_order, \
.u = { \
- .side_byte = (_val), \
+ .side_s32 = (_val), \
}, \
}, \
}, \
}
-
-#define side_arg_dynamic_float_binary16(_val, _attr) \
+#define _side_arg_dynamic_s64(_val, _byte_order, _attr) \
{ \
- .dynamic_type = SIDE_DYNAMIC_TYPE_FLOAT_BINARY16, \
+ .dynamic_type = SIDE_DYNAMIC_TYPE_S64, \
.u = { \
.side_basic = { \
.attr = _attr, \
.nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
+ .byte_order = _byte_order, \
.u = { \
- .side_float_binary16 = (_val), \
+ .side_s64 = (_val), \
}, \
}, \
}, \
}
-#define side_arg_dynamic_float_binary32(_val, _attr) \
+#define _side_arg_dynamic_float_binary16(_val, _byte_order, _attr) \
{ \
- .dynamic_type = SIDE_DYNAMIC_TYPE_FLOAT_BINARY32, \
+ .dynamic_type = SIDE_DYNAMIC_TYPE_FLOAT_BINARY16, \
.u = { \
.side_basic = { \
.attr = _attr, \
.nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
+ .byte_order = _byte_order, \
.u = { \
- .side_float_binary32 = (_val), \
+ .side_float_binary16 = (_val), \
}, \
}, \
}, \
}
-#define side_arg_dynamic_float_binary64(_val, _attr) \
+#define _side_arg_dynamic_float_binary32(_val, _byte_order, _attr) \
{ \
- .dynamic_type = SIDE_DYNAMIC_TYPE_FLOAT_BINARY64, \
+ .dynamic_type = SIDE_DYNAMIC_TYPE_FLOAT_BINARY32, \
.u = { \
.side_basic = { \
.attr = _attr, \
.nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
+ .byte_order = _byte_order, \
.u = { \
- .side_float_binary64 = (_val), \
+ .side_float_binary32 = (_val), \
}, \
}, \
}, \
}
-#define side_arg_dynamic_float_binary128(_val, _attr) \
+#define _side_arg_dynamic_float_binary64(_val, _byte_order, _attr) \
{ \
- .dynamic_type = SIDE_DYNAMIC_TYPE_FLOAT_BINARY128, \
+ .dynamic_type = SIDE_DYNAMIC_TYPE_FLOAT_BINARY64, \
.u = { \
.side_basic = { \
.attr = _attr, \
.nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
+ .byte_order = _byte_order, \
.u = { \
- .side_float_binary128 = (_val), \
+ .side_float_binary64 = (_val), \
}, \
}, \
}, \
}
-
-#define side_arg_dynamic_string(_val, _attr) \
+#define _side_arg_dynamic_float_binary128(_val, _byte_order, _attr) \
{ \
- .dynamic_type = SIDE_DYNAMIC_TYPE_STRING, \
+ .dynamic_type = SIDE_DYNAMIC_TYPE_FLOAT_BINARY128, \
.u = { \
.side_basic = { \
.attr = _attr, \
.nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
+ .byte_order = _byte_order, \
.u = { \
- .string = (_val), \
+ .side_float_binary128 = (_val), \
}, \
}, \
}, \
}
+/* Host endian */
+#define side_arg_dynamic_u16(_val, _attr) _side_arg_dynamic_u16(_val, SIDE_TYPE_BYTE_ORDER_HOST, SIDE_PARAM(_attr))
+#define side_arg_dynamic_u32(_val, _attr) _side_arg_dynamic_u32(_val, SIDE_TYPE_BYTE_ORDER_HOST, SIDE_PARAM(_attr))
+#define side_arg_dynamic_u64(_val, _attr) _side_arg_dynamic_u64(_val, SIDE_TYPE_BYTE_ORDER_HOST, SIDE_PARAM(_attr))
+#define side_arg_dynamic_s16(_val, _attr) _side_arg_dynamic_s16(_val, SIDE_TYPE_BYTE_ORDER_HOST, SIDE_PARAM(_attr))
+#define side_arg_dynamic_s32(_val, _attr) _side_arg_dynamic_s32(_val, SIDE_TYPE_BYTE_ORDER_HOST, SIDE_PARAM(_attr))
+#define side_arg_dynamic_s64(_val, _attr) _side_arg_dynamic_s64(_val, SIDE_TYPE_BYTE_ORDER_HOST, SIDE_PARAM(_attr))
+#define side_arg_dynamic_float_binary16(_val, _attr) _side_arg_dynamic_float_binary16(_val, SIDE_TYPE_FLOAT_WORD_ORDER_HOST, SIDE_PARAM(_attr))
+#define side_arg_dynamic_float_binary32(_val, _attr) _side_arg_dynamic_float_binary32(_val, SIDE_TYPE_FLOAT_WORD_ORDER_HOST, SIDE_PARAM(_attr))
+#define side_arg_dynamic_float_binary64(_val, _attr) _side_arg_dynamic_float_binary64(_val, SIDE_TYPE_FLOAT_WORD_ORDER_HOST, SIDE_PARAM(_attr))
+#define side_arg_dynamic_float_binary128(_val, _attr) _side_arg_dynamic_float_binary128(_val, SIDE_TYPE_FLOAT_WORD_ORDER_HOST, SIDE_PARAM(_attr))
+
+/* Little endian */
+#define side_arg_dynamic_u16_le(_val, _attr) _side_arg_dynamic_u16(_val, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
+#define side_arg_dynamic_u32_le(_val, _attr) _side_arg_dynamic_u32(_val, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
+#define side_arg_dynamic_u64_le(_val, _attr) _side_arg_dynamic_u64(_val, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
+#define side_arg_dynamic_s16_le(_val, _attr) _side_arg_dynamic_s16(_val, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
+#define side_arg_dynamic_s32_le(_val, _attr) _side_arg_dynamic_s32(_val, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
+#define side_arg_dynamic_s64_le(_val, _attr) _side_arg_dynamic_s64(_val, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
+#define side_arg_dynamic_float_binary16_le(_val, _attr) _side_arg_dynamic_float_binary16(_val, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
+#define side_arg_dynamic_float_binary32_le(_val, _attr) _side_arg_dynamic_float_binary32(_val, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
+#define side_arg_dynamic_float_binary64_le(_val, _attr) _side_arg_dynamic_float_binary64(_val, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
+#define side_arg_dynamic_float_binary128_le(_val, _attr) _side_arg_dynamic_float_binary128(_val, SIDE_TYPE_BYTE_ORDER_LE, SIDE_PARAM(_attr))
+
+/* Big endian */
+#define side_arg_dynamic_u16_be(_val, _attr) _side_arg_dynamic_u16(_val, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
+#define side_arg_dynamic_u32_be(_val, _attr) _side_arg_dynamic_u32(_val, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
+#define side_arg_dynamic_u64_be(_val, _attr) _side_arg_dynamic_u64(_val, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
+#define side_arg_dynamic_s16_be(_val, _attr) _side_arg_dynamic_s16(_val, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
+#define side_arg_dynamic_s32_be(_val, _attr) _side_arg_dynamic_s32(_val, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
+#define side_arg_dynamic_s64_be(_val, _attr) _side_arg_dynamic_s64(_val, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
+#define side_arg_dynamic_float_binary16_be(_val, _attr) _side_arg_dynamic_float_binary16(_val, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
+#define side_arg_dynamic_float_binary32_be(_val, _attr) _side_arg_dynamic_float_binary32(_val, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
+#define side_arg_dynamic_float_binary64_be(_val, _attr) _side_arg_dynamic_float_binary64(_val, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
+#define side_arg_dynamic_float_binary128_be(_val, _attr) _side_arg_dynamic_float_binary128(_val, SIDE_TYPE_BYTE_ORDER_BE, SIDE_PARAM(_attr))
+
#define side_arg_dynamic_vla(_vla) \
{ \
.dynamic_type = SIDE_DYNAMIC_TYPE_VLA, \
all: test
-HEADERS = ../include/side/trace.h ../include/side/macros.h rcu.h smp.h list.h
+HEADERS = ../include/side/trace.h ../include/side/macros.h rcu.h smp.h list.h \
+ ../include/side/endian.h
CFLAGS = -g -O2 -Wall
CPPFLAGS = -I../include/ -D_GNU_SOURCE
side_field_list(
#if __HAVE_FLOAT16
side_field_float_binary16("binary16", side_attr_list()),
+ side_field_float_binary16_le("binary16_le", side_attr_list()),
+ side_field_float_binary16_be("binary16_be", side_attr_list()),
#endif
#if __HAVE_FLOAT32
side_field_float_binary32("binary32", side_attr_list()),
+ side_field_float_binary32_le("binary32_le", side_attr_list()),
+ side_field_float_binary32_be("binary32_be", side_attr_list()),
#endif
#if __HAVE_FLOAT64
side_field_float_binary64("binary64", side_attr_list()),
+ side_field_float_binary64_le("binary64_le", side_attr_list()),
+ side_field_float_binary64_be("binary64_be", side_attr_list()),
#endif
#if __HAVE_FLOAT128
side_field_float_binary128("binary128", side_attr_list()),
+ side_field_float_binary128_le("binary128_le", side_attr_list()),
+ side_field_float_binary128_be("binary128_be", side_attr_list()),
#endif
),
side_attr_list()
static
void test_float(void)
{
+#if __HAVE_FLOAT16
+ union {
+ _Float16 f;
+ uint16_t u;
+ } float16 = {
+ .f = 1.1,
+ };
+#endif
+#if __HAVE_FLOAT32
+ union {
+ _Float32 f;
+ uint32_t u;
+ } float32 = {
+ .f = 2.2,
+ };
+#endif
+#if __HAVE_FLOAT64
+ union {
+ _Float64 f;
+ uint64_t u;
+ } float64 = {
+ .f = 3.3,
+ };
+#endif
+#if __HAVE_FLOAT128
+ union {
+ _Float128 f;
+ char arr[16];
+ } float128 = {
+ .f = 4.4,
+ };
+#endif
+
+#if __HAVE_FLOAT16
+ float16.u = side_bswap_16(float16.u);
+#endif
+#if __HAVE_FLOAT32
+ float32.u = side_bswap_32(float32.u);
+#endif
+#if __HAVE_FLOAT64
+ float64.u = side_bswap_64(float64.u);
+#endif
+#if __HAVE_FLOAT128
+ side_bswap_128p(float128.arr);
+#endif
+
side_event(my_provider_event_float,
side_arg_list(
#if __HAVE_FLOAT16
side_arg_float_binary16(1.1),
+# if SIDE_FLOAT_WORD_ORDER == SIDE_LITTLE_ENDIAN
+ side_arg_float_binary16(1.1),
+ side_arg_float_binary16(float16.f),
+# else
+ side_arg_float_binary16(float16.f),
+ side_arg_float_binary16(1.1),
+# endif
#endif
#if __HAVE_FLOAT32
side_arg_float_binary32(2.2),
+# if SIDE_FLOAT_WORD_ORDER == SIDE_LITTLE_ENDIAN
+ side_arg_float_binary32(2.2),
+ side_arg_float_binary32(float32.f),
+# else
+ side_arg_float_binary32(float32.f),
+ side_arg_float_binary32(2.2),
+# endif
#endif
#if __HAVE_FLOAT64
side_arg_float_binary64(3.3),
+# if SIDE_FLOAT_WORD_ORDER == SIDE_LITTLE_ENDIAN
+ side_arg_float_binary64(3.3),
+ side_arg_float_binary64(float64.f),
+# else
+ side_arg_float_binary64(float64.f),
+ side_arg_float_binary64(3.3),
+# endif
#endif
#if __HAVE_FLOAT128
side_arg_float_binary128(4.4),
+# if SIDE_FLOAT_WORD_ORDER == SIDE_LITTLE_ENDIAN
+ side_arg_float_binary128(4.4),
+ side_arg_float_binary128(float128.f),
+# else
+ side_arg_float_binary128(float128.f),
+ side_arg_float_binary128(4.4),
+# endif
#endif
)
);
static
void test_variadic_float(void)
{
+#if __HAVE_FLOAT16
+ union {
+ _Float16 f;
+ uint16_t u;
+ } float16 = {
+ .f = 1.1,
+ };
+#endif
+#if __HAVE_FLOAT32
+ union {
+ _Float32 f;
+ uint32_t u;
+ } float32 = {
+ .f = 2.2,
+ };
+#endif
+#if __HAVE_FLOAT64
+ union {
+ _Float64 f;
+ uint64_t u;
+ } float64 = {
+ .f = 3.3,
+ };
+#endif
+#if __HAVE_FLOAT128
+ union {
+ _Float128 f;
+ char arr[16];
+ } float128 = {
+ .f = 4.4,
+ };
+#endif
+
+#if __HAVE_FLOAT16
+ float16.u = side_bswap_16(float16.u);
+#endif
+#if __HAVE_FLOAT32
+ float32.u = side_bswap_32(float32.u);
+#endif
+#if __HAVE_FLOAT64
+ float64.u = side_bswap_64(float64.u);
+#endif
+#if __HAVE_FLOAT128
+ side_bswap_128p(float128.arr);
+#endif
+
side_event_variadic(my_provider_event_variadic_float,
side_arg_list(),
side_arg_list(
#if __HAVE_FLOAT16
- side_arg_dynamic_field("binary16",
- side_arg_dynamic_float_binary16(1.1, side_attr_list())
- ),
+ side_arg_dynamic_field("binary16", side_arg_dynamic_float_binary16(1.1, side_attr_list())),
+# if SIDE_FLOAT_WORD_ORDER == SIDE_LITTLE_ENDIAN
+ side_arg_dynamic_field("binary16_le", side_arg_dynamic_float_binary16_le(1.1, side_attr_list())),
+ side_arg_dynamic_field("binary16_be", side_arg_dynamic_float_binary16_be(float16.f, side_attr_list())),
+# else
+ side_arg_dynamic_field("binary16_le", side_arg_dynamic_float_binary16_le(float16.f, side_attr_list())),
+ side_arg_dynamic_field("binary16_be", side_arg_dynamic_float_binary16_be(1.1, side_attr_list())),
+# endif
#endif
#if __HAVE_FLOAT32
- side_arg_dynamic_field("binary32",
- side_arg_dynamic_float_binary32(2.2, side_attr_list())
- ),
+ side_arg_dynamic_field("binary32", side_arg_dynamic_float_binary32(2.2, side_attr_list())),
+# if SIDE_FLOAT_WORD_ORDER == SIDE_LITTLE_ENDIAN
+ side_arg_dynamic_field("binary32_le", side_arg_dynamic_float_binary32_le(2.2, side_attr_list())),
+ side_arg_dynamic_field("binary32_be", side_arg_dynamic_float_binary32_be(float32.f, side_attr_list())),
+# else
+ side_arg_dynamic_field("binary32_le", side_arg_dynamic_float_binary32_le(float32.f, side_attr_list())),
+ side_arg_dynamic_field("binary32_be", side_arg_dynamic_float_binary32_be(2.2, side_attr_list())),
+# endif
#endif
#if __HAVE_FLOAT64
- side_arg_dynamic_field("binary64",
- side_arg_dynamic_float_binary64(3.3, side_attr_list())
- ),
+ side_arg_dynamic_field("binary64", side_arg_dynamic_float_binary64(3.3, side_attr_list())),
+# if SIDE_FLOAT_WORD_ORDER == SIDE_LITTLE_ENDIAN
+ side_arg_dynamic_field("binary64_le", side_arg_dynamic_float_binary64_le(3.3, side_attr_list())),
+ side_arg_dynamic_field("binary64_be", side_arg_dynamic_float_binary64_be(float64.f, side_attr_list())),
+# else
+ side_arg_dynamic_field("binary64_le", side_arg_dynamic_float_binary64_le(float64.f, side_attr_list())),
+ side_arg_dynamic_field("binary64_be", side_arg_dynamic_float_binary64_be(3.3, side_attr_list())),
+# endif
#endif
#if __HAVE_FLOAT128
- side_arg_dynamic_field("binary128",
- side_arg_dynamic_float_binary128(4.4, side_attr_list())
- ),
+ side_arg_dynamic_field("binary128", side_arg_dynamic_float_binary128(4.4, side_attr_list())),
+# if SIDE_FLOAT_WORD_ORDER == SIDE_LITTLE_ENDIAN
+ side_arg_dynamic_field("binary128_le", side_arg_dynamic_float_binary128_le(4.4, side_attr_list())),
+ side_arg_dynamic_field("binary128_be", side_arg_dynamic_float_binary128_be(float128.f, side_attr_list())),
+# else
+ side_arg_dynamic_field("binary128_le", side_arg_dynamic_float_binary128_le(float128.f, side_attr_list())),
+ side_arg_dynamic_field("binary128_be", side_arg_dynamic_float_binary128_be(4.4, side_attr_list())),
+# endif
#endif
),
side_attr_list()
side_field_enum("400", &myenum, side_elem(side_type_u64(side_attr_list()))),
side_field_enum("200", &myenum, side_elem(side_type_u8(side_attr_list()))),
side_field_enum("-100", &myenum, side_elem(side_type_s8(side_attr_list()))),
+ side_field_enum("6_be", &myenum, side_elem(side_type_u32_be(side_attr_list()))),
+ side_field_enum("6_le", &myenum, side_elem(side_type_u32_le(side_attr_list()))),
),
side_attr_list()
);
side_arg_u64(400),
side_arg_u8(200),
side_arg_s8(-100),
+#if SIDE_BYTE_ORDER == SIDE_LITTLE_ENDIAN
+ side_arg_u32(side_bswap_32(6)),
+ side_arg_u32(6),
+#else
+ side_arg_u32(side_bswap_32(6)),
+ side_arg_u32(6),
+#endif
)
);
}
side_elem(side_type_array(side_elem(side_type_u32(side_attr_list())), 5, side_attr_list()))),
side_field_enum_bitmap("bit_159", &myenum_bitmap,
side_elem(side_type_vla(side_elem(side_type_u32(side_attr_list())), side_attr_list()))),
+ side_field_enum_bitmap("bit_2_be", &myenum_bitmap, side_elem(side_type_u32_be(side_attr_list()))),
+ side_field_enum_bitmap("bit_2_le", &myenum_bitmap, side_elem(side_type_u32_le(side_attr_list()))),
),
side_attr_list()
);
side_arg_byte(1 << 2),
side_arg_array(&myarray),
side_arg_vla(&myarray),
+#if SIDE_BYTE_ORDER == SIDE_LITTLE_ENDIAN
+ side_arg_u32(side_bswap_32(1 << 2)),
+ side_arg_u32(1 << 2),
+#else
+ side_arg_u32(0x06000000),
+ side_arg_u32(side_bswap_32(1 << 2)),
+#endif
)
);
}
}
}
+side_static_event_variadic(my_provider_event_endian, "myprovider", "myevent_endian", SIDE_LOGLEVEL_DEBUG,
+ side_field_list(
+ side_field_u16_le("u16_le", side_attr_list()),
+ side_field_u32_le("u32_le", side_attr_list()),
+ side_field_u64_le("u64_le", side_attr_list()),
+ side_field_s16_le("s16_le", side_attr_list()),
+ side_field_s32_le("s32_le", side_attr_list()),
+ side_field_s64_le("s64_le", side_attr_list()),
+ side_field_u16_be("u16_be", side_attr_list()),
+ side_field_u32_be("u32_be", side_attr_list()),
+ side_field_u64_be("u64_be", side_attr_list()),
+ side_field_s16_be("s16_be", side_attr_list()),
+ side_field_s32_be("s32_be", side_attr_list()),
+ side_field_s64_be("s64_be", side_attr_list()),
+ ),
+ side_attr_list()
+);
+
+static
+void test_endian(void)
+{
+ side_event_variadic(my_provider_event_endian,
+ side_arg_list(
+#if SIDE_BYTE_ORDER == SIDE_LITTLE_ENDIAN
+ side_arg_u16(1),
+ side_arg_u32(1),
+ side_arg_u64(1),
+ side_arg_s16(1),
+ side_arg_s32(1),
+ side_arg_s64(1),
+ side_arg_u16(side_bswap_16(1)),
+ side_arg_u32(side_bswap_32(1)),
+ side_arg_u64(side_bswap_64(1)),
+ side_arg_s16(side_bswap_16(1)),
+ side_arg_s32(side_bswap_32(1)),
+ side_arg_s64(side_bswap_64(1)),
+#else
+ side_arg_u16(side_bswap_16(1)),
+ side_arg_u32(side_bswap_32(1)),
+ side_arg_u64(side_bswap_64(1)),
+ side_arg_s16(side_bswap_16(1)),
+ side_arg_s32(side_bswap_32(1)),
+ side_arg_s64(side_bswap_64(1)),
+ side_arg_u16(1),
+ side_arg_u32(1),
+ side_arg_u64(1),
+ side_arg_s16(1),
+ side_arg_s32(1),
+ side_arg_s64(1),
+#endif
+ ),
+ side_arg_list(
+#if SIDE_BYTE_ORDER == SIDE_LITTLE_ENDIAN
+ side_arg_dynamic_field("u16_le", side_arg_dynamic_u16_le(1, side_attr_list())),
+ side_arg_dynamic_field("u32_le", side_arg_dynamic_u32_le(1, side_attr_list())),
+ side_arg_dynamic_field("u64_le", side_arg_dynamic_u64_le(1, side_attr_list())),
+ side_arg_dynamic_field("s16_le", side_arg_dynamic_s16_le(1, side_attr_list())),
+ side_arg_dynamic_field("s32_le", side_arg_dynamic_s32_le(1, side_attr_list())),
+ side_arg_dynamic_field("s64_le", side_arg_dynamic_s64_le(1, side_attr_list())),
+ side_arg_dynamic_field("u16_be", side_arg_dynamic_u16_be(side_bswap_16(1), side_attr_list())),
+ side_arg_dynamic_field("u32_be", side_arg_dynamic_u32_be(side_bswap_32(1), side_attr_list())),
+ side_arg_dynamic_field("u64_be", side_arg_dynamic_u64_be(side_bswap_64(1), side_attr_list())),
+ side_arg_dynamic_field("s16_be", side_arg_dynamic_s16_be(side_bswap_16(1), side_attr_list())),
+ side_arg_dynamic_field("s32_be", side_arg_dynamic_s32_be(side_bswap_32(1), side_attr_list())),
+ side_arg_dynamic_field("s64_be", side_arg_dynamic_s64_be(side_bswap_64(1), side_attr_list())),
+#else
+ side_arg_dynamic_field("u16_le", side_arg_dynamic_u16_le(side_bswap_16(1), side_attr_list())),
+ side_arg_dynamic_field("u32_le", side_arg_dynamic_u32_le(side_bswap_32(1), side_attr_list())),
+ side_arg_dynamic_field("u64_le", side_arg_dynamic_u64_le(side_bswap_64(1), side_attr_list())),
+ side_arg_dynamic_field("s16_le", side_arg_dynamic_s16_le(side_bswap_16(1), side_attr_list())),
+ side_arg_dynamic_field("s32_le", side_arg_dynamic_s32_le(side_bswap_32(1), side_attr_list())),
+ side_arg_dynamic_field("s64_le", side_arg_dynamic_s64_le(side_bswap_64(1), side_attr_list())),
+ side_arg_dynamic_field("u16_be", side_arg_dynamic_u16_be(1, side_attr_list())),
+ side_arg_dynamic_field("u32_be", side_arg_dynamic_u32_be(1, side_attr_list())),
+ side_arg_dynamic_field("u64_be", side_arg_dynamic_u64_be(1, side_attr_list())),
+ side_arg_dynamic_field("s16_be", side_arg_dynamic_s16_be(1, side_attr_list())),
+ side_arg_dynamic_field("s32_be", side_arg_dynamic_s32_be(1, side_attr_list())),
+ side_arg_dynamic_field("s64_be", side_arg_dynamic_s64_be(1, side_attr_list())),
+#endif
+ ),
+ side_attr_list()
+ );
+}
+
int main()
{
test_fields();
test_enum_bitmap();
test_blob();
test_fmt_string();
+ test_endian();
return 0;
}
static
void tracer_print_type(const struct side_type_description *type_desc, const struct side_arg_vec *item);
+static
+bool type_to_host_reverse_bo(const struct side_type_description *type_desc)
+{
+ switch (type_desc->type) {
+ case SIDE_TYPE_U8:
+ case SIDE_TYPE_S8:
+ case SIDE_TYPE_BYTE:
+ return false;
+ case SIDE_TYPE_U16:
+ case SIDE_TYPE_U32:
+ case SIDE_TYPE_U64:
+ case SIDE_TYPE_S16:
+ case SIDE_TYPE_S32:
+ case SIDE_TYPE_S64:
+ if (type_desc->u.side_basic.byte_order != SIDE_TYPE_BYTE_ORDER_HOST)
+ return true;
+ else
+ return false;
+ break;
+ case SIDE_TYPE_FLOAT_BINARY16:
+ case SIDE_TYPE_FLOAT_BINARY32:
+ case SIDE_TYPE_FLOAT_BINARY64:
+ case SIDE_TYPE_FLOAT_BINARY128:
+ if (type_desc->u.side_basic.byte_order != SIDE_TYPE_FLOAT_WORD_ORDER_HOST)
+ return true;
+ else
+ return false;
+ break;
+ default:
+ fprintf(stderr, "Unexpected type\n");
+ abort();
+ }
+}
+
+static
+bool dynamic_type_to_host_reverse_bo(const struct side_arg_dynamic_vec *item)
+{
+ switch (item->dynamic_type) {
+ case SIDE_DYNAMIC_TYPE_U8:
+ case SIDE_DYNAMIC_TYPE_S8:
+ case SIDE_DYNAMIC_TYPE_BYTE:
+ return false;
+ case SIDE_DYNAMIC_TYPE_U16:
+ case SIDE_DYNAMIC_TYPE_U32:
+ case SIDE_DYNAMIC_TYPE_U64:
+ case SIDE_DYNAMIC_TYPE_S16:
+ case SIDE_DYNAMIC_TYPE_S32:
+ case SIDE_DYNAMIC_TYPE_S64:
+ if (item->u.side_basic.byte_order != SIDE_TYPE_BYTE_ORDER_HOST)
+ return true;
+ else
+ return false;
+ break;
+ case SIDE_DYNAMIC_TYPE_FLOAT_BINARY16:
+ case SIDE_DYNAMIC_TYPE_FLOAT_BINARY32:
+ case SIDE_DYNAMIC_TYPE_FLOAT_BINARY64:
+ case SIDE_DYNAMIC_TYPE_FLOAT_BINARY128:
+ if (item->u.side_basic.byte_order != SIDE_TYPE_FLOAT_WORD_ORDER_HOST)
+ return true;
+ else
+ return false;
+ break;
+ default:
+ fprintf(stderr, "Unexpected type\n");
+ abort();
+ }
+}
+
static
void tracer_print_attr_type(const char *separator, const struct side_attr *attr)
{
void print_enum(const struct side_type_description *type_desc, const struct side_arg_vec *item)
{
const struct side_enum_mappings *mappings = type_desc->u.side_enum.mappings;
+ const struct side_type_description *elem_type = type_desc->u.side_enum.elem_type;
int i, print_count = 0;
int64_t value;
- if (type_desc->u.side_enum.elem_type->type != item->type) {
+ if (elem_type->type != item->type) {
fprintf(stderr, "ERROR: Unexpected enum element type\n");
abort();
}
value = (int64_t) item->u.side_u8;
break;
case SIDE_TYPE_U16:
- value = (int64_t) item->u.side_u16;
+ {
+ uint16_t v;
+
+ v = item->u.side_u16;
+ if (type_to_host_reverse_bo(elem_type))
+ v = side_bswap_16(v);
+ value = (int64_t) v;
break;
+ }
case SIDE_TYPE_U32:
- value = (int64_t) item->u.side_u32;
+ {
+ uint32_t v;
+
+ v = item->u.side_u32;
+ if (type_to_host_reverse_bo(elem_type))
+ v = side_bswap_32(v);
+ value = (int64_t) v;
break;
+ }
case SIDE_TYPE_U64:
- value = (int64_t) item->u.side_u64;
+ {
+ uint64_t v;
+
+ v = item->u.side_u64;
+ if (type_to_host_reverse_bo(elem_type))
+ v = side_bswap_64(v);
+ value = (int64_t) v;
break;
+ }
case SIDE_TYPE_S8:
value = (int64_t) item->u.side_s8;
break;
case SIDE_TYPE_S16:
- value = (int64_t) item->u.side_s16;
+ {
+ int16_t v;
+
+ v = item->u.side_s16;
+ if (type_to_host_reverse_bo(elem_type))
+ v = side_bswap_16(v);
+ value = (int64_t) v;
break;
+ }
case SIDE_TYPE_S32:
- value = (int64_t) item->u.side_s32;
+ {
+ int32_t v;
+
+ v = item->u.side_s32;
+ if (type_to_host_reverse_bo(elem_type))
+ v = side_bswap_32(v);
+ value = (int64_t) v;
break;
+ }
case SIDE_TYPE_S64:
- value = (int64_t) item->u.side_s64;
+ {
+ int64_t v;
+
+ v = item->u.side_s64;
+ if (type_to_host_reverse_bo(elem_type))
+ v = side_bswap_64(v);
+ value = v;
break;
+ }
default:
fprintf(stderr, "ERROR: Unexpected enum element type\n");
abort();
const struct side_enum_bitmap_mappings *side_enum_mappings = type_desc->u.side_enum_bitmap.mappings;
int i, print_count = 0;
uint32_t stride_bit, nr_items;
+ bool reverse_byte_order = false;
const struct side_arg_vec *array_item;
switch (elem_type->type) {
case SIDE_TYPE_U32: /* Fall-through */
case SIDE_TYPE_U64:
stride_bit = enum_elem_type_to_stride(elem_type);
+ reverse_byte_order = type_to_host_reverse_bo(elem_type);
array_item = item;
nr_items = 1;
break;
case SIDE_TYPE_ARRAY:
stride_bit = enum_elem_type_to_stride(elem_type->u.side_array.elem_type);
+ reverse_byte_order = type_to_host_reverse_bo(elem_type->u.side_array.elem_type);
array_item = item->u.side_array->sav;
nr_items = type_desc->u.side_array.length;
break;
case SIDE_TYPE_VLA:
stride_bit = enum_elem_type_to_stride(elem_type->u.side_vla.elem_type);
+ reverse_byte_order = type_to_host_reverse_bo(elem_type->u.side_vla.elem_type);
array_item = item->u.side_vla->sav;
nr_items = item->u.side_vla->len;
break;
case 16:
{
uint16_t v = array_item[bit / 16].u.side_u16;
+ if (reverse_byte_order)
+ v = side_bswap_16(v);
if (v & (1ULL << (bit % 16))) {
match = true;
goto match;
case 32:
{
uint32_t v = array_item[bit / 32].u.side_u32;
+ if (reverse_byte_order)
+ v = side_bswap_32(v);
if (v & (1ULL << (bit % 32))) {
match = true;
goto match;
case 64:
{
uint64_t v = array_item[bit / 64].u.side_u64;
+ if (reverse_byte_order)
+ v = side_bswap_64(v);
if (v & (1ULL << (bit % 64))) {
match = true;
goto match;
printf("%" PRIu8, item->u.side_u8);
break;
case SIDE_TYPE_U16:
+ {
+ uint16_t v;
+
+ v = item->u.side_u16;
+ if (type_to_host_reverse_bo(type_desc))
+ v = side_bswap_16(v);
tracer_print_basic_type_header(type_desc);
- printf("%" PRIu16, item->u.side_u16);
+ printf("%" PRIu16, v);
break;
+ }
case SIDE_TYPE_U32:
+ {
+ uint32_t v;
+
+ v = item->u.side_u32;
+ if (type_to_host_reverse_bo(type_desc))
+ v = side_bswap_32(v);
tracer_print_basic_type_header(type_desc);
- printf("%" PRIu32, item->u.side_u32);
+ printf("%" PRIu32, v);
break;
+ }
case SIDE_TYPE_U64:
+ {
+ uint64_t v;
+
+ v = item->u.side_u64;
+ if (type_to_host_reverse_bo(type_desc))
+ v = side_bswap_64(v);
tracer_print_basic_type_header(type_desc);
- printf("%" PRIu64, item->u.side_u64);
+ printf("%" PRIu64, v);
break;
+ }
case SIDE_TYPE_S8:
tracer_print_basic_type_header(type_desc);
printf("%" PRId8, item->u.side_s8);
break;
case SIDE_TYPE_S16:
+ {
+ int16_t v;
+
+ v = item->u.side_s16;
+ if (type_to_host_reverse_bo(type_desc))
+ v = side_bswap_16(v);
tracer_print_basic_type_header(type_desc);
- printf("%" PRId16, item->u.side_s16);
+ printf("%" PRId16, v);
break;
+ }
case SIDE_TYPE_S32:
+ {
+ int32_t v;
+
+ v = item->u.side_s32;
+ if (type_to_host_reverse_bo(type_desc))
+ v = side_bswap_32(v);
tracer_print_basic_type_header(type_desc);
- printf("%" PRId32, item->u.side_s32);
+ printf("%" PRId32, v);
break;
+ }
case SIDE_TYPE_S64:
+ {
+ int64_t v;
+
+ v = item->u.side_s64;
+ if (type_to_host_reverse_bo(type_desc))
+ v = side_bswap_64(v);
tracer_print_basic_type_header(type_desc);
- printf("%" PRId64, item->u.side_s64);
+ printf("%" PRId64, v);
break;
+ }
case SIDE_TYPE_BYTE:
tracer_print_basic_type_header(type_desc);
printf("0x%" PRIx8, item->u.side_byte);
break;
case SIDE_TYPE_FLOAT_BINARY16:
- tracer_print_basic_type_header(type_desc);
+ {
#if __HAVE_FLOAT16
- printf("%g", (double) item->u.side_float_binary16);
+ union {
+ _Float16 f;
+ uint16_t u;
+ } float16 = {
+ .f = item->u.side_float_binary16,
+ };
+
+ if (type_to_host_reverse_bo(type_desc))
+ float16.u = side_bswap_16(float16.u);
+ tracer_print_basic_type_header(type_desc);
+ printf("%g", (double) float16.f);
break;
#else
fprintf(stderr, "ERROR: Unsupported binary16 float type\n");
abort();
#endif
+ }
case SIDE_TYPE_FLOAT_BINARY32:
- tracer_print_basic_type_header(type_desc);
+ {
#if __HAVE_FLOAT32
- printf("%g", (double) item->u.side_float_binary32);
+ union {
+ _Float32 f;
+ uint32_t u;
+ } float32 = {
+ .f = item->u.side_float_binary32,
+ };
+
+ if (type_to_host_reverse_bo(type_desc))
+ float32.u = side_bswap_32(float32.u);
+ tracer_print_basic_type_header(type_desc);
+ printf("%g", (double) float32.f);
break;
#else
fprintf(stderr, "ERROR: Unsupported binary32 float type\n");
abort();
#endif
+ }
case SIDE_TYPE_FLOAT_BINARY64:
- tracer_print_basic_type_header(type_desc);
+ {
#if __HAVE_FLOAT64
- printf("%g", (double) item->u.side_float_binary64);
+ union {
+ _Float64 f;
+ uint64_t u;
+ } float64 = {
+ .f = item->u.side_float_binary64,
+ };
+
+ if (type_to_host_reverse_bo(type_desc))
+ float64.u = side_bswap_64(float64.u);
+ tracer_print_basic_type_header(type_desc);
+ printf("%g", (double) float64.f);
break;
#else
fprintf(stderr, "ERROR: Unsupported binary64 float type\n");
abort();
#endif
+ }
case SIDE_TYPE_FLOAT_BINARY128:
- tracer_print_basic_type_header(type_desc);
+ {
#if __HAVE_FLOAT128
- printf("%Lg", (long double) item->u.side_float_binary128);
+ union {
+ _Float128 f;
+ char arr[16];
+ } float128 = {
+ .f = item->u.side_float_binary128,
+ };
+
+ if (type_to_host_reverse_bo(type_desc))
+ side_bswap_128p(float128.arr);
+ tracer_print_basic_type_header(type_desc);
+ printf("%Lg", (long double) float128.f);
break;
#else
fprintf(stderr, "ERROR: Unsupported binary128 float type\n");
abort();
#endif
+ }
case SIDE_TYPE_STRING:
tracer_print_basic_type_header(type_desc);
printf("\"%s\"", item->u.string);
printf("%" PRIu8, item->u.side_basic.u.side_u8);
break;
case SIDE_DYNAMIC_TYPE_U16:
+ {
+ uint16_t v;
+
+ v = item->u.side_basic.u.side_u16;
+ if (dynamic_type_to_host_reverse_bo(item))
+ v = side_bswap_16(v);
tracer_print_dynamic_basic_type_header(item);
- printf("%" PRIu16, item->u.side_basic.u.side_u16);
+ printf("%" PRIu16, v);
break;
+ }
case SIDE_DYNAMIC_TYPE_U32:
+ {
+ uint32_t v;
+
+ v = item->u.side_basic.u.side_u32;
+ if (dynamic_type_to_host_reverse_bo(item))
+ v = side_bswap_32(v);
tracer_print_dynamic_basic_type_header(item);
- printf("%" PRIu32, item->u.side_basic.u.side_u32);
+ printf("%" PRIu32, v);
break;
+ }
case SIDE_DYNAMIC_TYPE_U64:
+ {
+ uint64_t v;
+
+ v = item->u.side_basic.u.side_u64;
+ if (dynamic_type_to_host_reverse_bo(item))
+ v = side_bswap_64(v);
tracer_print_dynamic_basic_type_header(item);
- printf("%" PRIu64, item->u.side_basic.u.side_u64);
+ printf("%" PRIu64, v);
break;
+ }
case SIDE_DYNAMIC_TYPE_S8:
tracer_print_dynamic_basic_type_header(item);
printf("%" PRId8, item->u.side_basic.u.side_s8);
break;
case SIDE_DYNAMIC_TYPE_S16:
+ {
+ int16_t v;
+
+ v = item->u.side_basic.u.side_u16;
+ if (dynamic_type_to_host_reverse_bo(item))
+ v = side_bswap_16(v);
tracer_print_dynamic_basic_type_header(item);
- printf("%" PRId16, item->u.side_basic.u.side_s16);
+ printf("%" PRId16, v);
break;
+ }
case SIDE_DYNAMIC_TYPE_S32:
+ {
+ int32_t v;
+
+ v = item->u.side_basic.u.side_u32;
+ if (dynamic_type_to_host_reverse_bo(item))
+ v = side_bswap_32(v);
tracer_print_dynamic_basic_type_header(item);
- printf("%" PRId32, item->u.side_basic.u.side_s32);
+ printf("%" PRId32, v);
break;
+ }
case SIDE_DYNAMIC_TYPE_S64:
+ {
+ int64_t v;
+
+ v = item->u.side_basic.u.side_u64;
+ if (dynamic_type_to_host_reverse_bo(item))
+ v = side_bswap_64(v);
tracer_print_dynamic_basic_type_header(item);
- printf("%" PRId64, item->u.side_basic.u.side_s64);
+ printf("%" PRId64, v);
break;
+ }
case SIDE_DYNAMIC_TYPE_BYTE:
tracer_print_dynamic_basic_type_header(item);
printf("0x%" PRIx8, item->u.side_basic.u.side_byte);
break;
case SIDE_DYNAMIC_TYPE_FLOAT_BINARY16:
- tracer_print_dynamic_basic_type_header(item);
+ {
#if __HAVE_FLOAT16
- printf("%g", (double) item->u.side_basic.u.side_float_binary16);
+ union {
+ _Float16 f;
+ uint16_t u;
+ } float16 = {
+ .f = item->u.side_basic.u.side_float_binary16,
+ };
+
+ if (dynamic_type_to_host_reverse_bo(item))
+ float16.u = side_bswap_16(float16.u);
+ tracer_print_dynamic_basic_type_header(item);
+ printf("%g", (double) float16.f);
break;
#else
fprintf(stderr, "ERROR: Unsupported binary16 float type\n");
abort();
#endif
+ }
case SIDE_DYNAMIC_TYPE_FLOAT_BINARY32:
- tracer_print_dynamic_basic_type_header(item);
+ {
#if __HAVE_FLOAT32
- printf("%g", (double) item->u.side_basic.u.side_float_binary32);
+ union {
+ _Float32 f;
+ uint32_t u;
+ } float32 = {
+ .f = item->u.side_basic.u.side_float_binary32,
+ };
+
+ if (dynamic_type_to_host_reverse_bo(item))
+ float32.u = side_bswap_32(float32.u);
+ tracer_print_dynamic_basic_type_header(item);
+ printf("%g", (double) float32.f);
break;
#else
fprintf(stderr, "ERROR: Unsupported binary32 float type\n");
abort();
#endif
+ }
case SIDE_DYNAMIC_TYPE_FLOAT_BINARY64:
- tracer_print_dynamic_basic_type_header(item);
+ {
#if __HAVE_FLOAT64
- printf("%g", (double) item->u.side_basic.u.side_float_binary64);
+ union {
+ _Float64 f;
+ uint64_t u;
+ } float64 = {
+ .f = item->u.side_basic.u.side_float_binary64,
+ };
+
+ if (dynamic_type_to_host_reverse_bo(item))
+ float64.u = side_bswap_64(float64.u);
+ tracer_print_dynamic_basic_type_header(item);
+ printf("%g", (double) float64.f);
break;
#else
fprintf(stderr, "ERROR: Unsupported binary64 float type\n");
abort();
#endif
+ }
case SIDE_DYNAMIC_TYPE_FLOAT_BINARY128:
- tracer_print_dynamic_basic_type_header(item);
+ {
#if __HAVE_FLOAT128
- printf("%Lg", (long double) item->u.side_basic.u.side_float_binary128);
+ union {
+ _Float128 f;
+ char arr[16];
+ } float128 = {
+ .f = item->u.side_basic.u.side_float_binary128,
+ };
+
+ if (dynamic_type_to_host_reverse_bo(item))
+ side_bswap_128p(float128.arr);
+ tracer_print_dynamic_basic_type_header(item);
+ printf("%Lg", (long double) float128.f);
break;
#else
fprintf(stderr, "ERROR: Unsupported binary128 float type\n");
abort();
#endif
+ }
case SIDE_DYNAMIC_TYPE_STRING:
tracer_print_dynamic_basic_type_header(item);
printf("\"%s\"", item->u.side_basic.u.string);
projects / libside.git / commitdiff
