1 /* $NetBSD: cdefs.h,v 1.166 2025/04/06 22:43:08 rillig Exp $ */ 2 3 /* * Copyright (c) 1991, 1993 4 * The Regents of the University of California. All rights reserved. 5 * 6 * This code is derived from software contributed to Berkeley by 7 * Berkeley Software Design, Inc. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 3. Neither the name of the University nor the names of its contributors 18 * may be used to endorse or promote products derived from this software 19 * without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 24 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31 * SUCH DAMAGE. 32 * 33 * @(#)cdefs.h 8.8 (Berkeley) 1/9/95 34 */ 35 36 #ifndef _SYS_CDEFS_H_ 37 #define _SYS_CDEFS_H_ 38 39 /* 40 * Macro to test if we're using a GNU C compiler of a specific vintage 41 * or later, for e.g. features that appeared in a particular version 42 * of GNU C. Usage: 43 * 44 * #if __GNUC_PREREQ__(major, minor) 45 * ...cool feature... 46 * #else 47 * ...delete feature... 48 * #endif 49 */ 50 #ifdef __GNUC__ 51 #define __GNUC_PREREQ__(x, y) \ 52 ((__GNUC__ == (x) && __GNUC_MINOR__ >= (y)) || \ 53 (__GNUC__ > (x))) 54 #else 55 #define __GNUC_PREREQ__(x, y) 0 56 #endif 57 58 /* 59 * Macros to test Clang/LLVM features. 60 * Usage: 61 * 62 * #if __has_feature(safe_stack) 63 * ...SafeStack specific code... 64 * #else 65 * ..regular code... 66 * #endif 67 */ 68 #ifndef __has_feature 69 #define __has_feature(x) 0 70 #endif 71 72 #ifndef __has_extension 73 #define __has_extension __has_feature /* Compat with pre-3.0 Clang */ 74 #endif 75 76 #include <machine/cdefs.h> 77 #ifdef __ELF__ 78 #include <sys/cdefs_elf.h> 79 #else 80 #include <sys/cdefs_aout.h> 81 #endif 82 83 #ifdef __GNUC__ 84 #define __strict_weak_alias(alias,sym) \ 85 __unused static __typeof__(alias) *__weak_alias_##alias = &sym; \ 86 __weak_alias(alias,sym) 87 #else 88 #define __strict_weak_alias(alias,sym) __weak_alias(alias,sym) 89 #endif 90 91 /* 92 * Optional marker for size-optimised MD calling convention. 93 */ 94 #ifndef __compactcall 95 #define __compactcall 96 #endif 97 98 /* 99 * The __CONCAT macro is used to concatenate parts of symbol names, e.g. 100 * with "#define OLD(foo) __CONCAT(old,foo)", OLD(foo) produces oldfoo. 101 * The __CONCAT macro is a bit tricky -- make sure you don't put spaces 102 * in between its arguments. __CONCAT can also concatenate double-quoted 103 * strings produced by the __STRING macro, but this only works with ANSI C. 104 */ 105 106 #define ___STRING(x) __STRING(x) 107 #define ___CONCAT(x,y) __CONCAT(x,y) 108 109 #if __STDC__ || defined(__cplusplus) 110 #define __P(protos) protos /* full-blown ANSI C */ 111 #define __CONCAT(x,y) x ## y 112 #define __STRING(x) #x 113 114 #define __const const /* define reserved names to standard */ 115 #define __signed signed 116 #define __volatile volatile 117 118 #define __CONCAT3(a,b,c) a ## b ## c 119 #define __CONCAT4(a,b,c,d) a ## b ## c ## d 120 #define __CONCAT5(a,b,c,d,e) a ## b ## c ## d ## e 121 #define __CONCAT6(a,b,c,d,e,f) a ## b ## c ## d ## e ## f 122 #define __CONCAT7(a,b,c,d,e,f,g) a ## b ## c ## d ## e ## f ## g 123 #define __CONCAT8(a,b,c,d,e,f,g,h) a ## b ## c ## d ## e ## f ## g ## h 124 125 #if defined(__cplusplus) || defined(__PCC__) 126 #define __inline inline /* convert to C++/C99 keyword */ 127 #else 128 #if !defined(__GNUC__) && !defined(__lint__) 129 #define __inline /* delete GCC keyword */ 130 #endif /* !__GNUC__ && !__lint__ */ 131 #endif /* !__cplusplus */ 132 133 #else /* !(__STDC__ || __cplusplus) */ 134 #define __P(protos) () /* traditional C preprocessor */ 135 #define __CONCAT(x,y) x/**/y 136 #define __STRING(x) "x" 137 138 #ifndef __GNUC__ 139 #define __const /* delete pseudo-ANSI C keywords */ 140 #define __inline 141 #define __signed 142 #define __volatile 143 #endif /* !__GNUC__ */ 144 145 /* 146 * In non-ANSI C environments, new programs will want ANSI-only C keywords 147 * deleted from the program and old programs will want them left alone. 148 * Programs using the ANSI C keywords const, inline etc. as normal 149 * identifiers should define -DNO_ANSI_KEYWORDS. 150 */ 151 #ifndef NO_ANSI_KEYWORDS 152 #define const __const /* convert ANSI C keywords */ 153 #define inline __inline 154 #define signed __signed 155 #define volatile __volatile 156 #endif /* !NO_ANSI_KEYWORDS */ 157 #endif /* !(__STDC__ || __cplusplus) */ 158 159 /* 160 * Used for internal auditing of the NetBSD source tree. 161 */ 162 #ifdef __AUDIT__ 163 #define __aconst __const 164 #else 165 #define __aconst 166 #endif 167 168 /* 169 * Compile Time Assertion. 170 */ 171 #ifdef __COUNTER__ 172 #define __CTASSERT(x) __CTASSERT0(x, __ctassert, __COUNTER__) 173 #else 174 #define __CTASSERT(x) __CTASSERT99(x, __INCLUDE_LEVEL__, __LINE__) 175 #define __CTASSERT99(x, a, b) __CTASSERT0(x, __CONCAT(__ctassert,a), \ 176 __CONCAT(_,b)) 177 #endif 178 #define __CTASSERT0(x, y, z) __CTASSERT1(x, y, z) 179 #define __CTASSERT1(x, y, z) \ 180 struct y ## z ## _struct { \ 181 unsigned int y ## z : /*CONSTCOND*/(x) ? 1 : -1; \ 182 } 183 184 /* 185 * The following macro is used to remove const cast-away warnings 186 * from gcc -Wcast-qual; it should be used with caution because it 187 * can hide valid errors; in particular most valid uses are in 188 * situations where the API requires it, not to cast away string 189 * constants. We don't use *intptr_t on purpose here and we are 190 * explicit about unsigned long so that we don't have additional 191 * dependencies. 192 */ 193 #define __UNCONST(a) ((void *)(unsigned long)(const void *)(a)) 194 195 /* 196 * The following macro is used to remove the volatile cast-away warnings 197 * from gcc -Wcast-qual; as above it should be used with caution 198 * because it can hide valid errors or warnings. Valid uses include 199 * making it possible to pass a volatile pointer to memset(). 200 * For the same reasons as above, we use unsigned long and not intptr_t. 201 */ 202 #define __UNVOLATILE(a) ((void *)(unsigned long)(volatile void *)(a)) 203 204 /* 205 * The following macro is used to remove the the function type cast warnings 206 * from gcc -Wcast-function-type and as above should be used with caution. 207 */ 208 #define __FPTRCAST(t, f) ((t)(void *)(f)) 209 210 /* 211 * GCC2 provides __extension__ to suppress warnings for various GNU C 212 * language extensions under "-ansi -pedantic". 213 */ 214 #if !__GNUC_PREREQ__(2, 0) 215 #define __extension__ /* delete __extension__ if non-gcc or gcc1 */ 216 #endif 217 218 /* 219 * GCC1 and some versions of GCC2 declare dead (non-returning) and 220 * pure (no side effects) functions using "volatile" and "const"; 221 * unfortunately, these then cause warnings under "-ansi -pedantic". 222 * GCC2 uses a new, peculiar __attribute__((attrs)) style. All of 223 * these work for GNU C++ (modulo a slight glitch in the C++ grammar 224 * in the distribution version of 2.5.5). 225 * 226 * GCC defines a pure function as depending only on its arguments and 227 * global variables. Typical examples are strlen and sqrt. 228 * 229 * GCC defines a const function as depending only on its arguments. 230 * Therefore calling a const function again with identical arguments 231 * will always produce the same result. 232 * 233 * Rounding modes for floating point operations are considered global 234 * variables and prevent sqrt from being a const function. 235 * 236 * Calls to const functions can be optimised away and moved around 237 * without limitations. 238 */ 239 #if !__GNUC_PREREQ__(2, 0) && !defined(__lint__) 240 #define __attribute__(x) 241 #endif 242 243 #if __GNUC_PREREQ__(2, 5) || defined(__lint__) 244 #define __dead __attribute__((__noreturn__)) 245 #elif defined(__GNUC__) 246 #define __dead __volatile 247 #else 248 #define __dead 249 #endif 250 251 #if __GNUC_PREREQ__(2, 96) || defined(__lint__) 252 #define __pure __attribute__((__pure__)) 253 #elif defined(__GNUC__) 254 #define __pure __const 255 #else 256 #define __pure 257 #endif 258 259 #if __GNUC_PREREQ__(2, 5) || defined(__lint__) 260 #define __constfunc __attribute__((__const__)) 261 #else 262 #define __constfunc 263 #endif 264 265 #if __GNUC_PREREQ__(3, 0) || defined(__lint__) 266 #define __noinline __attribute__((__noinline__)) 267 #else 268 #define __noinline /* nothing */ 269 #endif 270 271 #if __GNUC_PREREQ__(3, 0) || defined(__lint__) 272 #define __always_inline __attribute__((__always_inline__)) 273 #else 274 #define __always_inline /* nothing */ 275 #endif 276 277 #if __GNUC_PREREQ__(4, 0) || defined(__lint__) 278 #define __null_sentinel __attribute__((__sentinel__)) 279 #else 280 #define __null_sentinel /* nothing */ 281 #endif 282 283 #if __GNUC_PREREQ__(4, 1) || defined(__lint__) 284 #define __returns_twice __attribute__((__returns_twice__)) 285 #else 286 #define __returns_twice /* nothing */ 287 #endif 288 289 #if __GNUC_PREREQ__(4, 5) || defined(__lint__) 290 #define __noclone __attribute__((__noclone__)) 291 #else 292 #define __noclone /* nothing */ 293 #endif 294 295 /* 296 * __unused: Note that item or function might be unused. 297 */ 298 #if __GNUC_PREREQ__(2, 7) || defined(__lint__) 299 #define __unused __attribute__((__unused__)) 300 #else 301 #define __unused /* delete */ 302 #endif 303 304 /* 305 * __used: Note that item is needed, even if it appears to be unused. 306 */ 307 #if __GNUC_PREREQ__(3, 1) || defined(__lint__) 308 #define __used __attribute__((__used__)) 309 #else 310 #define __used __unused 311 #endif 312 313 /* 314 * __diagused: Note that item is used in diagnostic code, but may be 315 * unused in non-diagnostic code. 316 */ 317 #if (defined(_KERNEL) && defined(DIAGNOSTIC)) \ 318 || (!defined(_KERNEL) && !defined(NDEBUG)) 319 #define __diagused /* empty */ 320 #else 321 #define __diagused __unused 322 #endif 323 324 /* 325 * __debugused: Note that item is used in debug code, but may be 326 * unused in non-debug code. 327 */ 328 #if defined(DEBUG) 329 #define __debugused /* empty */ 330 #else 331 #define __debugused __unused 332 #endif 333 334 #if __GNUC_PREREQ__(3, 1) || defined(__lint__) 335 #define __noprofile __attribute__((__no_instrument_function__)) 336 #else 337 #define __noprofile /* nothing */ 338 #endif 339 340 #if __GNUC_PREREQ__(4, 6) || defined(__clang__) || defined(__lint__) 341 #define __unreachable() __builtin_unreachable() 342 #else 343 #define __unreachable() do {} while (0) 344 #endif 345 346 #if defined(_KERNEL) || defined(_RUMPKERNEL) 347 #if defined(__clang__) && __has_feature(address_sanitizer) 348 #define __noasan __attribute__((no_sanitize("kernel-address", "address"))) 349 #elif __GNUC_PREREQ__(4, 9) && defined(__SANITIZE_ADDRESS__) 350 #define __noasan __attribute__((no_sanitize_address)) 351 #else 352 #define __noasan /* nothing */ 353 #endif 354 355 #if defined(__clang__) && __has_feature(thread_sanitizer) 356 #define __nocsan __attribute__((no_sanitize("thread"))) 357 #elif __GNUC_PREREQ__(4, 9) && defined(__SANITIZE_THREAD__) 358 #define __nocsan __attribute__((no_sanitize_thread)) 359 #else 360 #define __nocsan /* nothing */ 361 #endif 362 363 #if defined(__clang__) && __has_feature(memory_sanitizer) 364 #define __nomsan __attribute__((no_sanitize("kernel-memory", "memory"))) 365 #else 366 #define __nomsan /* nothing */ 367 #endif 368 369 #if defined(__clang__) && __has_feature(undefined_behavior_sanitizer) 370 #define __noubsan __attribute__((no_sanitize("undefined"))) 371 #elif __GNUC_PREREQ__(4, 9) && defined(__SANITIZE_UNDEFINED__) 372 #define __noubsan __attribute__((no_sanitize_undefined)) 373 #else 374 #define __noubsan /* nothing */ 375 #endif 376 #endif 377 378 #if defined(__COVERITY__) || \ 379 __has_feature(address_sanitizer) || defined(__SANITIZE_ADDRESS__) ||\ 380 __has_feature(leak_sanitizer) || defined(__SANITIZE_LEAK__) 381 #define __NO_LEAKS 382 #endif 383 384 /* 385 * To be used when an empty body is required like: 386 * 387 * #ifdef DEBUG 388 * # define dprintf(a) printf(a) 389 * #else 390 * # define dprintf(a) __nothing 391 * #endif 392 * 393 * We use ((void)0) instead of do {} while (0) so that it 394 * works on , expressions. 395 */ 396 #define __nothing (/*LINTED*/(void)0) 397 398 #if defined(__cplusplus) 399 #define __BEGIN_EXTERN_C extern "C" { 400 #define __END_EXTERN_C } 401 #define __static_cast(x,y) static_cast<x>(y) 402 #else 403 #define __BEGIN_EXTERN_C 404 #define __END_EXTERN_C 405 #define __static_cast(x,y) (x)y 406 #endif 407 408 #if __GNUC_PREREQ__(4, 0) || defined(__lint__) 409 # define __dso_public __attribute__((__visibility__("default"))) 410 # define __dso_hidden __attribute__((__visibility__("hidden"))) 411 # define __BEGIN_PUBLIC_DECLS \ 412 _Pragma("GCC visibility push(default)") __BEGIN_EXTERN_C 413 # define __END_PUBLIC_DECLS __END_EXTERN_C _Pragma("GCC visibility pop") 414 # define __BEGIN_HIDDEN_DECLS \ 415 _Pragma("GCC visibility push(hidden)") __BEGIN_EXTERN_C 416 # define __END_HIDDEN_DECLS __END_EXTERN_C _Pragma("GCC visibility pop") 417 #else 418 # define __dso_public 419 # define __dso_hidden 420 # define __BEGIN_PUBLIC_DECLS __BEGIN_EXTERN_C 421 # define __END_PUBLIC_DECLS __END_EXTERN_C 422 # define __BEGIN_HIDDEN_DECLS __BEGIN_EXTERN_C 423 # define __END_HIDDEN_DECLS __END_EXTERN_C 424 #endif 425 #if __GNUC_PREREQ__(4, 2) || defined(__lint__) 426 # define __dso_protected __attribute__((__visibility__("protected"))) 427 #else 428 # define __dso_protected 429 #endif 430 431 #define __BEGIN_DECLS __BEGIN_PUBLIC_DECLS 432 #define __END_DECLS __END_PUBLIC_DECLS 433 434 /* 435 * Non-static C99 inline functions are optional bodies. They don't 436 * create global symbols if not used, but can be replaced if desirable. 437 * This differs from the behavior of GCC before version 4.3. The nearest 438 * equivalent for older GCC is `extern inline'. For newer GCC, use the 439 * gnu_inline attribute additionally to get the old behavior. 440 * 441 * For C99 compilers other than GCC, the C99 behavior is expected. 442 */ 443 #if defined(__GNUC__) && defined(__GNUC_STDC_INLINE__) 444 #define __c99inline extern __attribute__((__gnu_inline__)) __inline 445 #elif defined(__GNUC__) 446 #define __c99inline extern __inline 447 #elif defined(__STDC_VERSION__) || defined(__lint__) 448 #define __c99inline __inline 449 #endif 450 451 #if defined(__lint__) 452 #define __thread /* delete */ 453 #define __packed __packed 454 #define __aligned(x) _Alignas((x)) 455 #define __section(x) /* delete */ 456 #elif __GNUC_PREREQ__(2, 7) || defined(__PCC__) || defined(__lint__) 457 #define __packed __attribute__((__packed__)) 458 #define __aligned(x) __attribute__((__aligned__(x))) 459 #define __section(x) __attribute__((__section__(x))) 460 #elif defined(_MSC_VER) 461 #define __packed /* ignore */ 462 #else 463 #define __packed error: no __packed for this compiler 464 #define __aligned(x) error: no __aligned for this compiler 465 #define __section(x) error: no __section for this compiler 466 #endif 467 468 /* 469 * C99 defines the restrict type qualifier keyword, which was made available 470 * in GCC 2.92. 471 */ 472 #if __STDC_VERSION__ >= 199901L 473 #define __restrict restrict 474 #elif __GNUC_PREREQ__(2, 92) 475 #define __restrict __restrict__ 476 #else 477 #define __restrict /* delete __restrict when not supported */ 478 #endif 479 480 /* 481 * C99 and C++11 define __func__ predefined identifier, which was made 482 * available in GCC 2.95. 483 */ 484 #if !(__STDC_VERSION__ >= 199901L) && !(__cplusplus - 0 >= 201103L) 485 #if __GNUC_PREREQ__(2, 4) || defined(__lint__) 486 #define __func__ __FUNCTION__ 487 #else 488 #define __func__ "" 489 #endif 490 #endif /* !(__STDC_VERSION__ >= 199901L) && !(__cplusplus - 0 >= 201103L) */ 491 492 #if defined(_KERNEL) && defined(NO_KERNEL_RCSIDS) 493 #undef __KERNEL_RCSID 494 #define __KERNEL_RCSID(_n, _s) /* nothing */ 495 #undef __RCSID 496 #define __RCSID(_s) /* nothing */ 497 #endif 498 499 #if !defined(_STANDALONE) && !defined(_KERNEL) 500 #if defined(__GNUC__) || defined(__PCC__) 501 #define __RENAME(x) ___RENAME(x) 502 #elif defined(__lint__) 503 #define __RENAME(x) __symbolrename(x) 504 #else 505 #error "No function renaming possible" 506 #endif /* __GNUC__ */ 507 #else /* _STANDALONE || _KERNEL */ 508 #define __RENAME(x) no renaming in kernel/standalone environment 509 #endif 510 511 /* 512 * A barrier to stop the optimizer from moving code or assume live 513 * register values. This is gcc specific, the version is more or less 514 * arbitrary, might work with older compilers. 515 */ 516 #if __GNUC_PREREQ__(2, 95) || defined(__lint__) 517 #define __insn_barrier() __asm __volatile("":::"memory") 518 #else 519 #define __insn_barrier() /* */ 520 #endif 521 522 /* 523 * GNU C version 2.96 adds explicit branch prediction so that 524 * the CPU back-end can hint the processor and also so that 525 * code blocks can be reordered such that the predicted path 526 * sees a more linear flow, thus improving cache behavior, etc. 527 * 528 * The following two macros provide us with a way to use this 529 * compiler feature. Use __predict_true() if you expect the expression 530 * to evaluate to true, and __predict_false() if you expect the 531 * expression to evaluate to false. 532 * 533 * A few notes about usage: 534 * 535 * * Generally, __predict_false() error condition checks (unless 536 * you have some _strong_ reason to do otherwise, in which case 537 * document it), and/or __predict_true() `no-error' condition 538 * checks, assuming you want to optimize for the no-error case. 539 * 540 * * Other than that, if you don't know the likelihood of a test 541 * succeeding from empirical or other `hard' evidence, don't 542 * make predictions. 543 * 544 * * These are meant to be used in places that are run `a lot'. 545 * It is wasteful to make predictions in code that is run 546 * seldomly (e.g. at subsystem initialization time) as the 547 * basic block reordering that this affects can often generate 548 * larger code. 549 * 550 * We use an explicit ternary operator to map any value to exactly 0 or 551 * 1 so that (a) we can specify one value to expect, and (b) the given 552 * expression occurs only in the position of a conditional so that C++ 553 * classes with conversion to bool work as if this were a conditional. 554 * In contrast, say, `(exp) != 0' would require the type of exp to 555 * support conversion to integer as well. 556 */ 557 #if __GNUC_PREREQ__(2, 96) || defined(__lint__) 558 #define __predict_true(exp) __builtin_expect((exp) ? 1 : 0, 1) 559 #define __predict_false(exp) __builtin_expect((exp) ? 1 : 0, 0) 560 #else 561 #define __predict_true(exp) (exp) 562 #define __predict_false(exp) (exp) 563 #endif 564 565 /* 566 * Compiler-dependent macros to declare that functions take printf-like 567 * or scanf-like arguments. They are null except for versions of gcc 568 * that are known to support the features properly (old versions of gcc-2 569 * didn't permit keeping the keywords out of the application namespace). 570 */ 571 #if __GNUC_PREREQ__(2, 7) || defined(__lint__) 572 #define __printflike(fmtarg, firstvararg) \ 573 __attribute__((__format__ (__printf__, fmtarg, firstvararg))) 574 #ifndef __syslog_attribute__ 575 #define __syslog__ __printf__ 576 #endif 577 #define __sysloglike(fmtarg, firstvararg) \ 578 __attribute__((__format__ (__syslog__, fmtarg, firstvararg))) 579 #define __scanflike(fmtarg, firstvararg) \ 580 __attribute__((__format__ (__scanf__, fmtarg, firstvararg))) 581 #define __format_arg(fmtarg) __attribute__((__format_arg__ (fmtarg))) 582 #else 583 #define __printflike(fmtarg, firstvararg) /* nothing */ 584 #define __scanflike(fmtarg, firstvararg) /* nothing */ 585 #define __sysloglike(fmtarg, firstvararg) /* nothing */ 586 #define __format_arg(fmtarg) /* nothing */ 587 #endif 588 589 /* 590 * Macros for manipulating "link sets". Link sets are arrays of pointers 591 * to objects, which are gathered up by the linker. 592 * 593 * Object format-specific code has provided us with the following macros: 594 * 595 * __link_set_add_text(set, sym) 596 * Add a reference to the .text symbol `sym' to `set'. 597 * 598 * __link_set_add_rodata(set, sym) 599 * Add a reference to the .rodata symbol `sym' to `set'. 600 * 601 * __link_set_add_data(set, sym) 602 * Add a reference to the .data symbol `sym' to `set'. 603 * 604 * __link_set_add_bss(set, sym) 605 * Add a reference to the .bss symbol `sym' to `set'. 606 * 607 * __link_set_decl(set, ptype) 608 * Provide an extern declaration of the set `set', which 609 * contains an array of pointers to type `ptype'. This 610 * macro must be used by any code which wishes to reference 611 * the elements of a link set. 612 * 613 * __link_set_start(set) 614 * This points to the first slot in the link set. 615 * 616 * __link_set_end(set) 617 * This points to the (non-existent) slot after the last 618 * entry in the link set. 619 * 620 * __link_set_count(set) 621 * Count the number of entries in link set `set'. 622 * 623 * In addition, we provide the following macros for accessing link sets: 624 * 625 * __link_set_foreach(pvar, set) 626 * Iterate over the link set `set'. Because a link set is 627 * an array of pointers, pvar must be declared as "type **pvar", 628 * and the actual entry accessed as "*pvar". 629 * 630 * __link_set_entry(set, idx) 631 * Access the link set entry at index `idx' from set `set'. 632 */ 633 #define __link_set_foreach(pvar, set) \ 634 for (pvar = __link_set_start(set); pvar < __link_set_end(set); pvar++) 635 636 #define __link_set_entry(set, idx) (__link_set_start(set)[idx]) 637 638 /* 639 * Return the natural alignment in bytes for the given type 640 */ 641 #if __GNUC_PREREQ__(4, 1) || defined(__lint__) 642 #define __alignof(__t) __alignof__(__t) 643 #else 644 #define __alignof(__t) (sizeof(struct { char __x; __t __y; }) - sizeof(__t)) 645 #endif 646 647 /* 648 * Return the number of elements in a statically-allocated array, 649 * __x. 650 */ 651 #define __arraycount(__x) (sizeof(__x) / sizeof(__x[0])) 652 653 #ifndef __ASSEMBLER__ 654 /* __BIT(n): nth bit, where __BIT(0) == 0x1. */ 655 #define __BIT(__n) \ 656 (((__UINTMAX_TYPE__)(__n) >= __CHAR_BIT__ * sizeof(__UINTMAX_TYPE__)) \ 657 ? 0 \ 658 : ((__UINTMAX_TYPE__)1 << \ 659 (__UINTMAX_TYPE__)((__n) & \ 660 (__CHAR_BIT__ * sizeof(__UINTMAX_TYPE__) - 1)))) 661 662 /* __MASK(n): first n bits all set, where __MASK(4) == 0b1111. */ 663 #define __MASK(__n) (__BIT(__n) - 1) 664 665 /* Macros for min/max. */ 666 #define __MIN(a,b) ((/*CONSTCOND*/(a)<=(b))?(a):(b)) 667 #define __MAX(a,b) ((/*CONSTCOND*/(a)>(b))?(a):(b)) 668 669 /* __BITS(m, n): bits m through n, m < n. */ 670 #define __BITS(__m, __n) \ 671 ((__BIT(__MAX((__m), (__n)) + 1) - 1) ^ (__BIT(__MIN((__m), (__n))) - 1)) 672 #endif /* !__ASSEMBLER__ */ 673 674 /* find least significant bit that is set */ 675 #define __LOWEST_SET_BIT(__mask) ((((__mask) - 1) & (__mask)) ^ (__mask)) 676 677 #define __PRIuBIT PRIuMAX 678 #define __PRIuBITS __PRIuBIT 679 680 #define __PRIxBIT PRIxMAX 681 #define __PRIxBITS __PRIxBIT 682 683 #define __SHIFTOUT(__x, __mask) (((__x) & (__mask)) / __LOWEST_SET_BIT(__mask)) 684 #define __SHIFTIN(__x, __mask) ((__x) * __LOWEST_SET_BIT(__mask)) 685 #define __SHIFTOUT_MASK(__mask) __SHIFTOUT((__mask), (__mask)) 686 687 /* 688 * Only to be used in other headers that are included from both c or c++ 689 * NOT to be used in code. 690 */ 691 #ifdef __cplusplus 692 #define __CAST(__dt, __st) static_cast<__dt>(__st) 693 #else 694 #define __CAST(__dt, __st) ((__dt)(__st)) 695 #endif 696 697 #define __CASTV(__dt, __st) __CAST(__dt, __CAST(void *, __st)) 698 #define __CASTCV(__dt, __st) __CAST(__dt, __CAST(const void *, __st)) 699 700 /* 701 * Suppresses `variable set but not used' warnings. 702 * 703 * Typically for #ifdefs, where one branch of the #ifdef uses a 704 * variable but the other does not. Useful in patching external code 705 * to keep the patches narrowly scoped. 706 * 707 * Limitation: Only for variables, and only non-volatile variables. 708 * 709 * (Abusing this for anything else may lead to side effects. Pointers 710 * to volatile objects are OK, as in `volatile int *a', as long as the 711 * pointer itself is not volatile, as in `int *volatile a'.) 712 */ 713 #define __USE(a) (/*LINTED*/(void)(a)) 714 715 /* 716 * Verifies the expression e compiles, but does not evaluate it. Safe 717 * when e has side effects. 718 * 719 * Typically used for the arguments to macros with conditional 720 * definitions like DIAGNOSTIC or KDTRACE_HOOKS: when enabled, the 721 * macro uses the argument; when disabled, the macro passes the 722 * argument to __MACROUSE but doesn't otherwise use it. Cast to long 723 * in case the argument is a bit field, which is forbidden in sizeof. 724 * 725 * Limitation: Doesn't work for expressions of aggregate (struct/union) 726 * types. 727 * 728 * (If you find a way to handle both bit fields and aggregate types, 729 * you could unify __USE and __MACROUSE.) 730 */ 731 #define __MACROUSE(e) (/*LINTED*/(void)sizeof((long)(e))) 732 733 #define __type_mask(t) (/*LINTED*/sizeof(t) < sizeof(__INTMAX_TYPE__) ? \ 734 (~((1ULL << (sizeof(t) * __CHAR_BIT__)) - 1)) : 0ULL) 735 736 #ifndef __ASSEMBLER__ 737 static __inline long long __zeroll(void) { return 0; } 738 static __inline unsigned long long __zeroull(void) { return 0; } 739 #else 740 #define __zeroll() (0LL) 741 #define __zeroull() (0ULL) 742 #endif 743 744 #define __negative_p(x) (!((x) > 0) && ((x) != 0)) 745 746 #define __type_min_s(t) ((t)((1ULL << (sizeof(t) * __CHAR_BIT__ - 1)))) 747 #define __type_max_s(t) ((t)~((1ULL << (sizeof(t) * __CHAR_BIT__ - 1)))) 748 #define __type_min_u(t) ((t)0ULL) 749 #define __type_max_u(t) ((t)~0ULL) 750 #define __type_is_signed(t) (/*LINTED*/__type_min_s(t) + (t)1 < (t)1) 751 #define __type_min(t) (__type_is_signed(t) ? __type_min_s(t) : __type_min_u(t)) 752 #define __type_max(t) (__type_is_signed(t) ? __type_max_s(t) : __type_max_u(t)) 753 754 755 #define __type_fit_u(t, a) \ 756 (/*LINTED*/!__negative_p(a) && \ 757 ((__UINTMAX_TYPE__)((a) + __zeroull()) <= \ 758 (__UINTMAX_TYPE__)__type_max_u(t))) 759 760 #define __type_fit_s(t, a) \ 761 (/*LINTED*/__negative_p(a) \ 762 ? ((__INTMAX_TYPE__)((a) + __zeroll()) >= \ 763 (__INTMAX_TYPE__)__type_min_s(t)) \ 764 : ((__INTMAX_TYPE__)((a) + __zeroll()) >= (__INTMAX_TYPE__)0 && \ 765 ((__INTMAX_TYPE__)((a) + __zeroll()) <= \ 766 (__INTMAX_TYPE__)__type_max_s(t)))) 767 768 /* 769 * return true if value 'a' fits in type 't' 770 */ 771 #define __type_fit(t, a) (__type_is_signed(t) ? \ 772 __type_fit_s(t, a) : __type_fit_u(t, a)) 773 774 #endif /* !_SYS_CDEFS_H_ */ 775
Indexes created Sat Sep 20 22:09:52 GMT 2025