chiark / gitweb /
5088e6720d8640e8e13c1d58e7c74a1da7ff9423
[elogind.git] / src / basic / macro.h
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 #pragma once
4
5 /***
6   This file is part of systemd.
7
8   Copyright 2010 Lennart Poettering
9
10   systemd is free software; you can redistribute it and/or modify it
11   under the terms of the GNU Lesser General Public License as published by
12   the Free Software Foundation; either version 2.1 of the License, or
13   (at your option) any later version.
14
15   systemd is distributed in the hope that it will be useful, but
16   WITHOUT ANY WARRANTY; without even the implied warranty of
17   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18   Lesser General Public License for more details.
19
20   You should have received a copy of the GNU Lesser General Public License
21   along with systemd; If not, see <http://www.gnu.org/licenses/>.
22 ***/
23
24 #include <assert.h>
25 #include <inttypes.h>
26 #include <stdbool.h>
27 #include <sys/param.h>
28 #include <sys/types.h>
29
30 #define _printf_(a,b) __attribute__ ((format (printf, a, b)))
31 #define _alloc_(...) __attribute__ ((alloc_size(__VA_ARGS__)))
32 #define _sentinel_ __attribute__ ((sentinel))
33 #define _unused_ __attribute__ ((unused))
34 #define _destructor_ __attribute__ ((destructor))
35 #define _pure_ __attribute__ ((pure))
36 #define _const_ __attribute__ ((const))
37 #define _deprecated_ __attribute__ ((deprecated))
38 #define _packed_ __attribute__ ((packed))
39 #define _malloc_ __attribute__ ((malloc))
40 #define _weak_ __attribute__ ((weak))
41 #define _likely_(x) (__builtin_expect(!!(x),1))
42 #define _unlikely_(x) (__builtin_expect(!!(x),0))
43 #define _public_ __attribute__ ((visibility("default")))
44 #define _hidden_ __attribute__ ((visibility("hidden")))
45 #define _weakref_(x) __attribute__((weakref(#x)))
46 #define _alignas_(x) __attribute__((aligned(__alignof(x))))
47 #define _cleanup_(x) __attribute__((cleanup(x)))
48
49 /* Temporarily disable some warnings */
50 #define DISABLE_WARNING_DECLARATION_AFTER_STATEMENT                     \
51         _Pragma("GCC diagnostic push");                                 \
52         _Pragma("GCC diagnostic ignored \"-Wdeclaration-after-statement\"")
53
54 #define DISABLE_WARNING_FORMAT_NONLITERAL                               \
55         _Pragma("GCC diagnostic push");                                 \
56         _Pragma("GCC diagnostic ignored \"-Wformat-nonliteral\"")
57
58 #define DISABLE_WARNING_MISSING_PROTOTYPES                              \
59         _Pragma("GCC diagnostic push");                                 \
60         _Pragma("GCC diagnostic ignored \"-Wmissing-prototypes\"")
61
62 #define DISABLE_WARNING_NONNULL                                         \
63         _Pragma("GCC diagnostic push");                                 \
64         _Pragma("GCC diagnostic ignored \"-Wnonnull\"")
65
66 #define DISABLE_WARNING_SHADOW                                          \
67         _Pragma("GCC diagnostic push");                                 \
68         _Pragma("GCC diagnostic ignored \"-Wshadow\"")
69
70 #define DISABLE_WARNING_INCOMPATIBLE_POINTER_TYPES                      \
71         _Pragma("GCC diagnostic push");                                 \
72         _Pragma("GCC diagnostic ignored \"-Wincompatible-pointer-types\"")
73
74 #define REENABLE_WARNING                                                \
75         _Pragma("GCC diagnostic pop")
76
77 /* automake test harness */
78 #define EXIT_TEST_SKIP 77
79
80 #define XSTRINGIFY(x) #x
81 #define STRINGIFY(x) XSTRINGIFY(x)
82
83 #define XCONCATENATE(x, y) x ## y
84 #define CONCATENATE(x, y) XCONCATENATE(x, y)
85
86 #define UNIQ_T(x, uniq) CONCATENATE(__unique_prefix_, CONCATENATE(x, uniq))
87 #define UNIQ __COUNTER__
88
89 /* Rounds up */
90
91 #define ALIGN4(l) (((l) + 3) & ~3)
92 #define ALIGN8(l) (((l) + 7) & ~7)
93
94 #if __SIZEOF_POINTER__ == 8
95 #define ALIGN(l) ALIGN8(l)
96 #elif __SIZEOF_POINTER__ == 4
97 #define ALIGN(l) ALIGN4(l)
98 #else
99 #error "Wut? Pointers are neither 4 nor 8 bytes long?"
100 #endif
101
102 #define ALIGN_PTR(p) ((void*) ALIGN((unsigned long) (p)))
103 #define ALIGN4_PTR(p) ((void*) ALIGN4((unsigned long) (p)))
104 #define ALIGN8_PTR(p) ((void*) ALIGN8((unsigned long) (p)))
105
106 static inline size_t ALIGN_TO(size_t l, size_t ali) {
107         return ((l + ali - 1) & ~(ali - 1));
108 }
109
110 #define ALIGN_TO_PTR(p, ali) ((void*) ALIGN_TO((unsigned long) (p), (ali)))
111
112 /* align to next higher power-of-2 (except for: 0 => 0, overflow => 0) */
113 static inline unsigned long ALIGN_POWER2(unsigned long u) {
114         /* clz(0) is undefined */
115         if (u == 1)
116                 return 1;
117
118         /* left-shift overflow is undefined */
119         if (__builtin_clzl(u - 1UL) < 1)
120                 return 0;
121
122         return 1UL << (sizeof(u) * 8 - __builtin_clzl(u - 1UL));
123 }
124
125 #define ELEMENTSOF(x)                                                    \
126         __extension__ (__builtin_choose_expr(                            \
127                 !__builtin_types_compatible_p(typeof(x), typeof(&*(x))), \
128                 sizeof(x)/sizeof((x)[0]),                                \
129                 (void)0))
130 /*
131  * container_of - cast a member of a structure out to the containing structure
132  * @ptr: the pointer to the member.
133  * @type: the type of the container struct this is embedded in.
134  * @member: the name of the member within the struct.
135  */
136 #define container_of(ptr, type, member) __container_of(UNIQ, (ptr), type, member)
137 #define __container_of(uniq, ptr, type, member)                         \
138         __extension__ ({                                                \
139                 const typeof( ((type*)0)->member ) *UNIQ_T(A, uniq) = (ptr); \
140                 (type*)( (char *)UNIQ_T(A, uniq) - offsetof(type,member) ); \
141         })
142
143 #undef MAX
144 #define MAX(a, b) __MAX(UNIQ, (a), UNIQ, (b))
145 #define __MAX(aq, a, bq, b)                             \
146         __extension__ ({                                \
147                 const typeof(a) UNIQ_T(A, aq) = (a);    \
148                 const typeof(b) UNIQ_T(B, bq) = (b);    \
149                 UNIQ_T(A,aq) > UNIQ_T(B,bq) ? UNIQ_T(A,aq) : UNIQ_T(B,bq); \
150         })
151
152 /* evaluates to (void) if _A or _B are not constant or of different types */
153 #define CONST_MAX(_A, _B) \
154         __extension__ (__builtin_choose_expr(                           \
155                 __builtin_constant_p(_A) &&                             \
156                 __builtin_constant_p(_B) &&                             \
157                 __builtin_types_compatible_p(typeof(_A), typeof(_B)),   \
158                 ((_A) > (_B)) ? (_A) : (_B),                            \
159                 (void)0))
160
161 /* takes two types and returns the size of the larger one */
162 #define MAXSIZE(A, B) (sizeof(union _packed_ { typeof(A) a; typeof(B) b; }))
163
164 #define MAX3(x,y,z)                                     \
165         __extension__ ({                                \
166                         const typeof(x) _c = MAX(x,y);  \
167                         MAX(_c, z);                     \
168                 })
169
170 #undef MIN
171 #define MIN(a, b) __MIN(UNIQ, (a), UNIQ, (b))
172 #define __MIN(aq, a, bq, b)                             \
173         __extension__ ({                                \
174                 const typeof(a) UNIQ_T(A, aq) = (a);    \
175                 const typeof(b) UNIQ_T(B, bq) = (b);    \
176                 UNIQ_T(A,aq) < UNIQ_T(B,bq) ? UNIQ_T(A,aq) : UNIQ_T(B,bq); \
177         })
178
179 #define MIN3(x,y,z)                                     \
180         __extension__ ({                                \
181                         const typeof(x) _c = MIN(x,y);  \
182                         MIN(_c, z);                     \
183                 })
184
185 #define LESS_BY(a, b) __LESS_BY(UNIQ, (a), UNIQ, (b))
186 #define __LESS_BY(aq, a, bq, b)                         \
187         __extension__ ({                                \
188                 const typeof(a) UNIQ_T(A, aq) = (a);    \
189                 const typeof(b) UNIQ_T(B, bq) = (b);    \
190                 UNIQ_T(A,aq) > UNIQ_T(B,bq) ? UNIQ_T(A,aq) - UNIQ_T(B,bq) : 0; \
191         })
192
193 #undef CLAMP
194 #define CLAMP(x, low, high) __CLAMP(UNIQ, (x), UNIQ, (low), UNIQ, (high))
195 #define __CLAMP(xq, x, lowq, low, highq, high)                          \
196         __extension__ ({                                                \
197                 const typeof(x) UNIQ_T(X,xq) = (x);                     \
198                 const typeof(low) UNIQ_T(LOW,lowq) = (low);             \
199                 const typeof(high) UNIQ_T(HIGH,highq) = (high);         \
200                         UNIQ_T(X,xq) > UNIQ_T(HIGH,highq) ?             \
201                                 UNIQ_T(HIGH,highq) :                    \
202                                 UNIQ_T(X,xq) < UNIQ_T(LOW,lowq) ?       \
203                                         UNIQ_T(LOW,lowq) :              \
204                                         UNIQ_T(X,xq);                   \
205         })
206
207 /* [(x + y - 1) / y] suffers from an integer overflow, even though the
208  * computation should be possible in the given type. Therefore, we use
209  * [x / y + !!(x % y)]. Note that on "Real CPUs" a division returns both the
210  * quotient and the remainder, so both should be equally fast. */
211 #define DIV_ROUND_UP(_x, _y)                                            \
212         __extension__ ({                                                \
213                 const typeof(_x) __x = (_x);                            \
214                 const typeof(_y) __y = (_y);                            \
215                 (__x / __y + !!(__x % __y));                            \
216         })
217
218 #define assert_message_se(expr, message)                                \
219         do {                                                            \
220                 if (_unlikely_(!(expr)))                                \
221                         log_assert_failed(message, __FILE__, __LINE__, __PRETTY_FUNCTION__); \
222         } while (false)
223
224 #define assert_se(expr) assert_message_se(expr, #expr)
225
226 /* We override the glibc assert() here. */
227 #undef assert
228 #ifdef NDEBUG
229 #define assert(expr) do {} while(false)
230 #else
231 #define assert(expr) assert_message_se(expr, #expr)
232 #endif
233
234 #define assert_not_reached(t)                                           \
235         do {                                                            \
236                 log_assert_failed_unreachable(t, __FILE__, __LINE__, __PRETTY_FUNCTION__); \
237         } while (false)
238
239 #if defined(static_assert)
240 /* static_assert() is sometimes defined in a way that trips up
241  * -Wdeclaration-after-statement, hence let's temporarily turn off
242  * this warning around it. */
243 #define assert_cc(expr)                                                 \
244         DISABLE_WARNING_DECLARATION_AFTER_STATEMENT;                    \
245         static_assert(expr, #expr);                                     \
246         REENABLE_WARNING
247 #else
248 #define assert_cc(expr)                                                 \
249         DISABLE_WARNING_DECLARATION_AFTER_STATEMENT;                    \
250         struct CONCATENATE(_assert_struct_, __COUNTER__) {              \
251                 char x[(expr) ? 0 : -1];                                \
252         };                                                              \
253         REENABLE_WARNING
254 #endif
255
256 #define assert_log(expr, message) ((_likely_(expr))                     \
257         ? (true)                                                        \
258         : (log_assert_failed_return(message, __FILE__, __LINE__, __PRETTY_FUNCTION__), false))
259
260 #define assert_return(expr, r)                                          \
261         do {                                                            \
262                 if (!assert_log(expr, #expr))                           \
263                         return (r);                                     \
264         } while (false)
265
266 #define assert_return_errno(expr, r, err)                               \
267         do {                                                            \
268                 if (!assert_log(expr, #expr)) {                         \
269                         errno = err;                                    \
270                         return (r);                                     \
271                 }                                                       \
272         } while (false)
273
274 #define PTR_TO_INT(p) ((int) ((intptr_t) (p)))
275 #define INT_TO_PTR(u) ((void *) ((intptr_t) (u)))
276 #define PTR_TO_UINT(p) ((unsigned int) ((uintptr_t) (p)))
277 #define UINT_TO_PTR(u) ((void *) ((uintptr_t) (u)))
278
279 #define PTR_TO_LONG(p) ((long) ((intptr_t) (p)))
280 #define LONG_TO_PTR(u) ((void *) ((intptr_t) (u)))
281 #define PTR_TO_ULONG(p) ((unsigned long) ((uintptr_t) (p)))
282 #define ULONG_TO_PTR(u) ((void *) ((uintptr_t) (u)))
283
284 #define PTR_TO_INT32(p) ((int32_t) ((intptr_t) (p)))
285 #define INT32_TO_PTR(u) ((void *) ((intptr_t) (u)))
286 #define PTR_TO_UINT32(p) ((uint32_t) ((uintptr_t) (p)))
287 #define UINT32_TO_PTR(u) ((void *) ((uintptr_t) (u)))
288
289 #define PTR_TO_INT64(p) ((int64_t) ((intptr_t) (p)))
290 #define INT64_TO_PTR(u) ((void *) ((intptr_t) (u)))
291 #define PTR_TO_UINT64(p) ((uint64_t) ((uintptr_t) (p)))
292 #define UINT64_TO_PTR(u) ((void *) ((uintptr_t) (u)))
293
294 #define PTR_TO_SIZE(p) ((size_t) ((uintptr_t) (p)))
295 #define SIZE_TO_PTR(u) ((void *) ((uintptr_t) (u)))
296
297 #define CHAR_TO_STR(x) ((char[2]) { x, 0 })
298
299 #define char_array_0(x) x[sizeof(x)-1] = 0;
300
301 /* Returns the number of chars needed to format variables of the
302  * specified type as a decimal string. Adds in extra space for a
303  * negative '-' prefix (hence works correctly on signed
304  * types). Includes space for the trailing NUL. */
305 #define DECIMAL_STR_MAX(type)                                           \
306         (2+(sizeof(type) <= 1 ? 3 :                                     \
307             sizeof(type) <= 2 ? 5 :                                     \
308             sizeof(type) <= 4 ? 10 :                                    \
309             sizeof(type) <= 8 ? 20 : sizeof(int[-2*(sizeof(type) > 8)])))
310
311 #define DECIMAL_STR_WIDTH(x)                            \
312         ({                                              \
313                 typeof(x) _x_ = (x);                    \
314                 unsigned ans = 1;                       \
315                 while (_x_ /= 10)                       \
316                         ans++;                          \
317                 ans;                                    \
318         })
319
320 #define SET_FLAG(v, flag, b) \
321         (v) = (b) ? ((v) | (flag)) : ((v) & ~(flag))
322
323 #define IN_SET(x, y, ...)                                               \
324         ({                                                              \
325                 static const typeof(y) _array[] = { (y), __VA_ARGS__ }; \
326                 const typeof(y) _x = (x);                               \
327                 unsigned _i;                                            \
328                 bool _found = false;                                    \
329                 for (_i = 0; _i < ELEMENTSOF(_array); _i++)             \
330                         if (_array[_i] == _x) {                         \
331                                 _found = true;                          \
332                                 break;                                  \
333                         }                                               \
334                 _found;                                                 \
335         })
336
337 /* Define C11 thread_local attribute even on older gcc compiler
338  * version */
339 #ifndef thread_local
340 /*
341  * Don't break on glibc < 2.16 that doesn't define __STDC_NO_THREADS__
342  * see http://gcc.gnu.org/bugzilla/show_bug.cgi?id=53769
343  */
344 #if __STDC_VERSION__ >= 201112L && !(defined(__STDC_NO_THREADS__) || (defined(__GNU_LIBRARY__) && __GLIBC__ == 2 && __GLIBC_MINOR__ < 16))
345 #define thread_local _Thread_local
346 #else
347 #define thread_local __thread
348 #endif
349 #endif
350
351 /* Define C11 noreturn without <stdnoreturn.h> and even on older gcc
352  * compiler versions */
353 #ifndef noreturn
354 #if __STDC_VERSION__ >= 201112L
355 #define noreturn _Noreturn
356 #else
357 #define noreturn __attribute__((noreturn))
358 #endif
359 #endif
360
361 #define DEFINE_TRIVIAL_CLEANUP_FUNC(type, func)                 \
362         static inline void func##p(type *p) {                   \
363                 if (*p)                                         \
364                         func(*p);                               \
365         }                                                       \
366         struct __useless_struct_to_allow_trailing_semicolon__
367
368 #include "log.h"