src/basic/macro.h

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