1 // SPDX-License-Identifier: MIT
3 * Copyright 2022 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
12 #include <side/endian.h>
16 #define SIDE_ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
19 * Compound literals with static storage are needed by SIDE
21 * Compound literals are part of the C99 and C11 standards, but not
22 * part of the C++ standards. They are supported by most C++ compilers
26 * static struct mystruct *var = LTTNG_UST_COMPOUND_LITERAL(struct mystruct, { 1, 2, 3 });
28 #define SIDE_COMPOUND_LITERAL(type, ...) (type[]) { __VA_ARGS__ }
30 #define side_likely(x) __builtin_expect(!!(x), 1)
31 #define side_unlikely(x) __builtin_expect(!!(x), 0)
33 #define SIDE_PARAM(...) __VA_ARGS__
35 #define side_offsetofend(type, member) \
36 (offsetof(type, member) + sizeof(((type *)0)->member))
39 * SIDE_PARAM_SELECT_ARG1
41 * Select second argument. Use inside macros to implement optional last
42 * macro argument, such as:
44 * #define macro(_a, _b, _c, _optional...) \
45 * SIDE_PARAM_SELECT_ARG1(_, ##_optional, do_default_macro())
47 * This macro is far from pretty, but attempts to create a cleaner layer
48 * on top fails for various reasons:
50 * - The libside API needs to use the default argument selection as an
51 * argument to itself (recursively), e.g. for fields and for types, so
52 * using the argument selection within an extra layer of macro fails
53 * because the extra layer cannot expand recursively.
54 * - Attempts to make the extra layer of macro support recursion through
55 * another layer of macros which expands all arguments failed because
56 * the optional argument may contain commas, and is therefore expanded
57 * into multiple arguments before argument selection, which fails to
58 * select the optional argument content after its first comma.
60 #define SIDE_PARAM_SELECT_ARG1(_arg0, _arg1, ...) _arg1
63 * Compile time assertion.
64 * - predicate: boolean expression to evaluate,
65 * - msg: string to print to the user on failure when `static_assert()` is
67 * - c_identifier_msg: message to be included in the typedef to emulate a
68 * static assertion. This parameter must be a valid C identifier as it will
69 * be used as a typedef name.
72 #define side_static_assert(predicate, msg, c_identifier_msg) \
73 static_assert(predicate, msg)
74 #elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)
75 #define side_static_assert(predicate, msg, c_identifier_msg) \
76 _Static_assert(predicate, msg)
79 * Evaluates the predicate and emit a compilation error on failure.
81 * If the predicate evaluates to true, this macro emits a function
82 * prototype with an argument type which is an array of size 0.
84 * If the predicate evaluates to false, this macro emits a function
85 * prototype with an argument type which is an array of negative size
86 * which is invalid in C and forces a compiler error. The
87 * c_identifier_msg parameter is used as the argument identifier so it
88 * is printed to the user when the error is reported.
90 #define side_static_assert(predicate, msg, c_identifier_msg) \
91 void side_static_assert_proto(char c_identifier_msg[2*!!(predicate)-1])
95 * side_container_of - Get the address of an object containing a field.
97 * @ptr: pointer to the field.
98 * @type: type of the object.
99 * @member: name of the field within the object.
101 #define side_container_of(ptr, type, member) \
104 const __typeof__(((type *) NULL)->member) * __ptr = (ptr); \
105 (type *)((char *)__ptr - offsetof(type, member)); \
108 #define side_struct_field_sizeof(_struct, _field) \
109 sizeof(((_struct * )NULL)->_field)
111 #define SIDE_PACKED __attribute__((packed))
113 #define side_padding(bytes) char padding[bytes]
115 #define side_check_size(_type, _len) \
116 side_static_assert(sizeof(_type) == (_len), \
117 "Unexpected size for type: `" #_type "`", \
118 unexpected_size_for_type_##_type)
121 * The side_ptr macros allow defining a pointer type which is suitable
122 * for use by 32-bit, 64-bit and 128-bit kernels without compatibility
123 * code, while preserving information about the pointer type.
125 * Those pointers are stored as 128-bit integers, and the type of the
126 * actual pointer is kept alongside with the 128-bit pointer value in a
127 * 0-len array within a union.
130 #if (SIDE_BYTE_ORDER == SIDE_LITTLE_ENDIAN)
131 # define SIDE_U128_PTR_IDX(n) (n)
133 # define SIDE_U128_PTR_IDX(n) ((16 / __SIZEOF_POINTER__) - (n) - 1)
136 #define side_raw_ptr_t(_type) \
138 _type v[16 / __SIZEOF_POINTER__]; \
141 /* side_ptr_get() can be used as rvalue or lvalue. */
142 #define side_ptr_get(_field) (_field).v[SIDE_U128_PTR_IDX(0)]
144 #if (__SIZEOF_POINTER__ == 4)
145 # define side_ptr_set(_field, _ptr) \
147 (_field).v[SIDE_U128_PTR_IDX(0)] = (_ptr); \
148 (_field).v[SIDE_U128_PTR_IDX(1)] = 0; \
149 (_field).v[SIDE_U128_PTR_IDX(2)] = 0; \
150 (_field).v[SIDE_U128_PTR_IDX(3)] = 0; \
153 /* Keep the correct field init order to make old g++ happy. */
154 # if (SIDE_BYTE_ORDER == SIDE_LITTLE_ENDIAN)
155 # define SIDE_PTR_INIT(...) \
158 [0] = (__VA_ARGS__), \
165 # define SIDE_PTR_INIT(...) \
171 [3] = (__VA_ARGS__), \
175 #elif (__SIZEOF_POINTER__ == 8)
176 # define side_ptr_set(_field, _ptr) \
178 (_field).v[SIDE_U128_PTR_IDX(0)] = (_ptr); \
179 (_field).v[SIDE_U128_PTR_IDX(1)] = 0; \
182 /* Keep the correct field init order to make old g++ happy. */
183 # if (SIDE_BYTE_ORDER == SIDE_LITTLE_ENDIAN)
184 # define SIDE_PTR_INIT(...) \
187 [0] = (__VA_ARGS__), \
192 # define SIDE_PTR_INIT(...) \
196 [1] = (__VA_ARGS__), \
200 #elif (__SIZEOF_POINTER__ == 16)
201 # define side_ptr_set(_field, _ptr) \
203 (_field).v[SIDE_U128_PTR_IDX(0)] = (_ptr); \
206 # define SIDE_PTR_INIT(...) \
209 [0] = (__VA_ARGS__), \
213 # error "Unsupported pointer size"
216 #define side_ptr_t(_type) side_raw_ptr_t(_type *)
217 #define side_func_ptr_t(_type) side_raw_ptr_t(_type)
219 side_static_assert(sizeof(side_ptr_t(int)) == 16,
220 "Unexpected size for side_ptr_t",
221 unexpected_size_side_ptr_t
);
224 * side_enum_t allows defining fixed-sized enumerations while preserving
225 * typing information.
227 #define side_enum_t(_enum_type, _size_type) \
235 #define side_enum_get(_field) \
236 ((__typeof__((_field).s.t[0]))(_field).v)
238 #define side_enum_set(_field, _v) \
243 #define SIDE_ENUM_INIT(...) { .v = (__VA_ARGS__) }
245 #endif /* _SIDE_MACROS_H */