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)
120 #if (SIDE_BYTE_ORDER == SIDE_LITTLE_ENDIAN)
121 #define SIDE_ENDIAN_ORDER(_low, _high) _low, _high
123 #define SIDE_ENDIAN_ORDER(_low, _high) _high, _low
127 * The side_ptr macros allow defining a pointer type which is suitable
128 * for use by 32-bit, 64-bit and 128-bit kernels without compatibility
129 * code, while preserving information about the pointer type.
131 * Those pointers are stored as 128-bit integers, and the type of the
132 * actual pointer is kept alongside with the 128-bit pointer value in a
133 * 0-len array within a union.
135 #if (__SIZEOF_POINTER__ <= 8)
136 # define side_raw_ptr_t(_type) \
139 uint64_t SIDE_ENDIAN_ORDER(low, high); \
146 # define side_ptr_get(_field) \
147 ((__typeof__((_field).s.t[0]))(uintptr_t)(_field).v.low)
148 # define side_ptr_set(_field, _ptr) \
150 (_field).v.low = (uint64_t)(uintptr_t)(_ptr); \
151 (_field).v.high = 0; \
154 /* Keep the correct field init order to make old g++ happy. */
155 # if (SIDE_BYTE_ORDER == SIDE_LITTLE_ENDIAN)
156 # define SIDE_PTR_INIT(...) \
159 .low = (uintptr_t) (__VA_ARGS__), \
164 # define SIDE_PTR_INIT(...) \
168 .low = (uintptr_t) (__VA_ARGS__), \
172 #elif (__SIZEOF_POINTER__ == 16)
173 # define side_raw_ptr_t(_type) \
181 # define side_ptr_get(_field) \
182 ((__typeof__((_field).s.t[0]))(_field).v)
183 # define side_ptr_set(_field, _ptr) \
185 (_field).v = (uintptr_t)(_ptr); \
187 # define SIDE_PTR_INIT(...) { .v = (uintptr_t) (__VA_ARGS__) }
189 # error "Unsupported pointer size"
192 #define side_ptr_t(_type) side_raw_ptr_t(_type *)
193 #define side_func_ptr_t(_type) side_raw_ptr_t(_type)
195 side_static_assert(sizeof(side_ptr_t(int)) == 16,
196 "Unexpected size for side_ptr_t",
197 unexpected_size_side_ptr_t
);
200 * side_enum_t allows defining fixed-sized enumerations while preserving
201 * typing information.
203 #define side_enum_t(_enum_type, _size_type) \
211 #define side_enum_get(_field) \
212 ((__typeof__((_field).s.t[0]))(_field).v)
214 #define side_enum_set(_field, _v) \
219 #define SIDE_ENUM_INIT(...) { .v = (__VA_ARGS__) }
221 #endif /* _SIDE_MACROS_H */