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__
36 * SIDE_PARAM_SELECT_ARG1
38 * Select second argument. Use inside macros to implement optional last
39 * macro argument, such as:
41 * #define macro(_a, _b, _c, _optional...) \
42 * SIDE_PARAM_SELECT_ARG1(_, ##_optional, do_default_macro())
44 * This macro is far from pretty, but attempts to create a cleaner layer
45 * on top fails for various reasons:
47 * - The libside API needs to use the default argument selection as an
48 * argument to itself (recursively), e.g. for fields and for types, so
49 * using the argument selection within an extra layer of macro fails
50 * because the extra layer cannot expand recursively.
51 * - Attempts to make the extra layer of macro support recursion through
52 * another layer of macros which expands all arguments failed because
53 * the optional argument may contain commas, and is therefore expanded
54 * into multiple arguments before argument selection, which fails to
55 * select the optional argument content after its first comma.
57 #define SIDE_PARAM_SELECT_ARG1(_arg0, _arg1, ...) _arg1
60 * Compile time assertion.
61 * - predicate: boolean expression to evaluate,
62 * - msg: string to print to the user on failure when `static_assert()` is
64 * - c_identifier_msg: message to be included in the typedef to emulate a
65 * static assertion. This parameter must be a valid C identifier as it will
66 * be used as a typedef name.
69 #define side_static_assert(predicate, msg, c_identifier_msg) \
70 static_assert(predicate, msg)
71 #elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)
72 #define side_static_assert(predicate, msg, c_identifier_msg) \
73 _Static_assert(predicate, msg)
76 * Evaluates the predicate and emit a compilation error on failure.
78 * If the predicate evaluates to true, this macro emits a function
79 * prototype with an argument type which is an array of size 0.
81 * If the predicate evaluates to false, this macro emits a function
82 * prototype with an argument type which is an array of negative size
83 * which is invalid in C and forces a compiler error. The
84 * c_identifier_msg parameter is used as the argument identifier so it
85 * is printed to the user when the error is reported.
87 #define side_static_assert(predicate, msg, c_identifier_msg) \
88 void side_static_assert_proto(char c_identifier_msg[2*!!(predicate)-1])
92 * side_container_of - Get the address of an object containing a field.
94 * @ptr: pointer to the field.
95 * @type: type of the object.
96 * @member: name of the field within the object.
98 #define side_container_of(ptr, type, member) \
101 const __typeof__(((type *) NULL)->member) * __ptr = (ptr); \
102 (type *)((char *)__ptr - offsetof(type, member)); \
105 #define side_struct_field_sizeof(_struct, _field) \
106 sizeof(((_struct * )NULL)->_field)
108 #define SIDE_PACKED __attribute__((packed))
110 #define side_padding(bytes) char padding[bytes]
112 #define side_check_size(_type, _len) \
113 side_static_assert(sizeof(_type) == (_len), \
114 "Unexpected size for type: `" #_type "`", \
115 unexpected_size_for_type_##_type)
117 #if (SIDE_BYTE_ORDER == SIDE_LITTLE_ENDIAN)
118 #define SIDE_ENDIAN_ORDER(_low, _high) _low, _high
120 #define SIDE_ENDIAN_ORDER(_low, _high) _high, _low
124 * The side_ptr macros allow defining a pointer type which is suitable
125 * for use by 32-bit, 64-bit and 128-bit kernels without compatibility
126 * code, while preserving information about the pointer type.
128 * Those pointers are stored as 128-bit integers, and the type of the
129 * actual pointer is kept alongside with the 128-bit pointer value in a
130 * 0-len array within a union.
132 #if (__SIZEOF_POINTER__ <= 8)
133 # define side_raw_ptr_t(_type) \
136 uint64_t SIDE_ENDIAN_ORDER(low, high); \
143 # define side_ptr_get(_field) \
144 ((__typeof__((_field).s.t[0]))(uintptr_t)(_field).v.low)
145 # define side_ptr_set(_field, _ptr) \
147 (_field).v.low = (uint64_t)(uintptr_t)(_ptr); \
148 (_field).v.high = 0; \
151 /* Keep the correct field init order to make old g++ happy. */
152 # if (SIDE_BYTE_ORDER == SIDE_LITTLE_ENDIAN)
153 # define SIDE_PTR_INIT(...) \
156 .low = (uintptr_t) (__VA_ARGS__), \
161 # define SIDE_PTR_INIT(...) \
165 .low = (uintptr_t) (__VA_ARGS__), \
169 #elif (__SIZEOF_POINTER__ == 16)
170 # define side_raw_ptr_t(_type) \
178 # define side_ptr_get(_field) \
179 ((__typeof__((_field).s.t[0]))(_field).v)
180 # define side_ptr_set(_field, _ptr) \
182 (_field).v = (uintptr_t)(_ptr); \
184 # define SIDE_PTR_INIT(...) { .v = (uintptr_t) (__VA_ARGS__) }
186 # error "Unsupported pointer size"
189 #define side_ptr_t(_type) side_raw_ptr_t(_type *)
190 #define side_func_ptr_t(_type) side_raw_ptr_t(_type)
192 side_static_assert(sizeof(side_ptr_t(int)) == 16,
193 "Unexpected size for side_ptr_t",
194 unexpected_size_side_ptr_t
);
197 * side_enum_t allows defining fixed-sized enumerations while preserving
198 * typing information.
200 #define side_enum_t(_enum_type, _size_type) \
208 #define side_enum_get(_field) \
209 ((__typeof__((_field).s.t[0]))(_field).v)
211 #define side_enum_set(_field, _v) \
216 #define SIDE_ENUM_INIT(...) { .v = (__VA_ARGS__) }
218 #endif /* _SIDE_MACROS_H */