1 /* Copyright (C) 1992-2020 Free Software Foundation, Inc. 2 This file is part of the GNU C Library. 3 4 The GNU C Library is free software; you can redistribute it and/or 5 modify it under the terms of the GNU General Public 6 License as published by the Free Software Foundation; either 7 version 3 of the License, or (at your option) any later version. 8 9 The GNU C Library is distributed in the hope that it will be useful, 10 but WITHOUT ANY WARRANTY; without even the implied warranty of 11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 12 General Public License for more details. 13 14 You should have received a copy of the GNU General Public 15 License along with the GNU C Library; if not, see 16 <https://www.gnu.org/licenses/>. */ 17 18 #ifndef _SYS_CDEFS_H 19 #define _SYS_CDEFS_H 1 20 21 /* We are almost always included from features.h. */ 22 #ifndef _FEATURES_H 23 # include <features.h> 24 #endif 25 26 /* The GNU libc does not support any K&R compilers or the traditional mode 27 of ISO C compilers anymore. Check for some of the combinations not 28 anymore supported. */ 29 #if defined __GNUC__ && !defined __STDC__ 30 # error "You need a ISO C conforming compiler to use the glibc headers" 31 #endif 32 33 /* Some user header file might have defined this before. */ 34 #undef __P 35 #undef __PMT 36 37 #ifdef __GNUC__ 38 39 /* All functions, except those with callbacks or those that 40 synchronize memory, are leaf functions. */ 41 # if __GNUC_PREREQ (4, 6) && !defined _LIBC 42 # define __LEAF , __leaf__ 43 # define __LEAF_ATTR __attribute__ ((__leaf__)) 44 # else 45 # define __LEAF 46 # define __LEAF_ATTR 47 # endif 48 49 /* GCC can always grok prototypes. For C++ programs we add throw() 50 to help it optimize the function calls. But this works only with 51 gcc 2.8.x and egcs. For gcc 3.2 and up we even mark C functions 52 as non-throwing using a function attribute since programs can use 53 the -fexceptions options for C code as well. */ 54 # if !defined __cplusplus && __GNUC_PREREQ (3, 3) 55 # define __THROW __attribute__ ((__nothrow__ __LEAF)) 56 # define __THROWNL __attribute__ ((__nothrow__)) 57 # define __NTH(fct) __attribute__ ((__nothrow__ __LEAF)) fct 58 # define __NTHNL(fct) __attribute__ ((__nothrow__)) fct 59 # else 60 # if defined __cplusplus && __GNUC_PREREQ (2,8) 61 # define __THROW throw () 62 # define __THROWNL throw () 63 # define __NTH(fct) __LEAF_ATTR fct throw () 64 # define __NTHNL(fct) fct throw () 65 # else 66 # define __THROW 67 # define __THROWNL 68 # define __NTH(fct) fct 69 # define __NTHNL(fct) fct 70 # endif 71 # endif 72 73 #else /* Not GCC. */ 74 75 # if (defined __cplusplus \ 76 || (defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L)) 77 # define __inline inline 78 # else 79 # define __inline /* No inline functions. */ 80 # endif 81 82 # define __THROW 83 # define __THROWNL 84 # define __NTH(fct) fct 85 86 #endif /* GCC. */ 87 88 /* Compilers that are not clang may object to 89 #if defined __clang__ && __has_extension(...) 90 even though they do not need to evaluate the right-hand side of the &&. */ 91 #if defined __clang__ && defined __has_extension 92 # define __glibc_clang_has_extension(ext) __has_extension (ext) 93 #else 94 # define __glibc_clang_has_extension(ext) 0 95 #endif 96 97 /* These two macros are not used in glibc anymore. They are kept here 98 only because some other projects expect the macros to be defined. */ 99 #define __P(args) args 100 #define __PMT(args) args 101 102 /* For these things, GCC behaves the ANSI way normally, 103 and the non-ANSI way under -traditional. */ 104 105 #define __CONCAT(x,y) x ## y 106 #define __STRING(x) #x 107 108 /* This is not a typedef so `const __ptr_t' does the right thing. */ 109 #define __ptr_t void * 110 111 112 /* C++ needs to know that types and declarations are C, not C++. */ 113 #ifdef __cplusplus 114 # define __BEGIN_DECLS extern "C" { 115 # define __END_DECLS } 116 #else 117 # define __BEGIN_DECLS 118 # define __END_DECLS 119 #endif 120 121 122 /* Fortify support. */ 123 #define __bos(ptr) __builtin_object_size (ptr, __USE_FORTIFY_LEVEL > 1) 124 #define __bos0(ptr) __builtin_object_size (ptr, 0) 125 126 #if __GNUC_PREREQ (4,3) 127 # define __warndecl(name, msg) \ 128 extern void name (void) __attribute__((__warning__ (msg))) 129 # define __warnattr(msg) __attribute__((__warning__ (msg))) 130 # define __errordecl(name, msg) \ 131 extern void name (void) __attribute__((__error__ (msg))) 132 #else 133 # define __warndecl(name, msg) extern void name (void) 134 # define __warnattr(msg) 135 # define __errordecl(name, msg) extern void name (void) 136 #endif 137 138 /* Support for flexible arrays. 139 Headers that should use flexible arrays only if they're "real" 140 (e.g. only if they won't affect sizeof()) should test 141 #if __glibc_c99_flexarr_available. */ 142 #if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L && !defined __HP_cc 143 # define __flexarr [] 144 # define __glibc_c99_flexarr_available 1 145 #elif __GNUC_PREREQ (2,97) 146 /* GCC 2.97 supports C99 flexible array members as an extension, 147 even when in C89 mode or compiling C++ (any version). */ 148 # define __flexarr [] 149 # define __glibc_c99_flexarr_available 1 150 #elif defined __GNUC__ 151 /* Pre-2.97 GCC did not support C99 flexible arrays but did have 152 an equivalent extension with slightly different notation. */ 153 # define __flexarr [0] 154 # define __glibc_c99_flexarr_available 1 155 #else 156 /* Some other non-C99 compiler. Approximate with [1]. */ 157 # define __flexarr [1] 158 # define __glibc_c99_flexarr_available 0 159 #endif 160 161 162 /* __asm__ ("xyz") is used throughout the headers to rename functions 163 at the assembly language level. This is wrapped by the __REDIRECT 164 macro, in order to support compilers that can do this some other 165 way. When compilers don't support asm-names at all, we have to do 166 preprocessor tricks instead (which don't have exactly the right 167 semantics, but it's the best we can do). 168 169 Example: 170 int __REDIRECT(setpgrp, (__pid_t pid, __pid_t pgrp), setpgid); */ 171 172 #if defined __GNUC__ && __GNUC__ >= 2 173 174 # define __REDIRECT(name, proto, alias) name proto __asm__ (__ASMNAME (#alias)) 175 # ifdef __cplusplus 176 # define __REDIRECT_NTH(name, proto, alias) \ 177 name proto __THROW __asm__ (__ASMNAME (#alias)) 178 # define __REDIRECT_NTHNL(name, proto, alias) \ 179 name proto __THROWNL __asm__ (__ASMNAME (#alias)) 180 # else 181 # define __REDIRECT_NTH(name, proto, alias) \ 182 name proto __asm__ (__ASMNAME (#alias)) __THROW 183 # define __REDIRECT_NTHNL(name, proto, alias) \ 184 name proto __asm__ (__ASMNAME (#alias)) __THROWNL 185 # endif 186 # define __ASMNAME(cname) __ASMNAME2 (__USER_LABEL_PREFIX__, cname) 187 # define __ASMNAME2(prefix, cname) __STRING (prefix) cname 188 189 /* 190 #elif __SOME_OTHER_COMPILER__ 191 192 # define __REDIRECT(name, proto, alias) name proto; \ 193 _Pragma("let " #name " = " #alias) 194 */ 195 #endif 196 197 /* GCC has various useful declarations that can be made with the 198 `__attribute__' syntax. All of the ways we use this do fine if 199 they are omitted for compilers that don't understand it. */ 200 #if !defined __GNUC__ || __GNUC__ < 2 201 # define __attribute__(xyz) /* Ignore */ 202 #endif 203 204 /* At some point during the gcc 2.96 development the `malloc' attribute 205 for functions was introduced. We don't want to use it unconditionally 206 (although this would be possible) since it generates warnings. */ 207 #if __GNUC_PREREQ (2,96) 208 # define __attribute_malloc__ __attribute__ ((__malloc__)) 209 #else 210 # define __attribute_malloc__ /* Ignore */ 211 #endif 212 213 /* Tell the compiler which arguments to an allocation function 214 indicate the size of the allocation. */ 215 #if __GNUC_PREREQ (4, 3) 216 # define __attribute_alloc_size__(params) \ 217 __attribute__ ((__alloc_size__ params)) 218 #else 219 # define __attribute_alloc_size__(params) /* Ignore. */ 220 #endif 221 222 /* At some point during the gcc 2.96 development the `pure' attribute 223 for functions was introduced. We don't want to use it unconditionally 224 (although this would be possible) since it generates warnings. */ 225 #if __GNUC_PREREQ (2,96) 226 # define __attribute_pure__ __attribute__ ((__pure__)) 227 #else 228 # define __attribute_pure__ /* Ignore */ 229 #endif 230 231 /* This declaration tells the compiler that the value is constant. */ 232 #if __GNUC_PREREQ (2,5) 233 # define __attribute_const__ __attribute__ ((__const__)) 234 #else 235 # define __attribute_const__ /* Ignore */ 236 #endif 237 238 /* At some point during the gcc 3.1 development the `used' attribute 239 for functions was introduced. We don't want to use it unconditionally 240 (although this would be possible) since it generates warnings. */ 241 #if __GNUC_PREREQ (3,1) 242 # define __attribute_used__ __attribute__ ((__used__)) 243 # define __attribute_noinline__ __attribute__ ((__noinline__)) 244 #else 245 # define __attribute_used__ __attribute__ ((__unused__)) 246 # define __attribute_noinline__ /* Ignore */ 247 #endif 248 249 /* Since version 3.2, gcc allows marking deprecated functions. */ 250 #if __GNUC_PREREQ (3,2) 251 # define __attribute_deprecated__ __attribute__ ((__deprecated__)) 252 #else 253 # define __attribute_deprecated__ /* Ignore */ 254 #endif 255 256 /* Since version 4.5, gcc also allows one to specify the message printed 257 when a deprecated function is used. clang claims to be gcc 4.2, but 258 may also support this feature. */ 259 #if __GNUC_PREREQ (4,5) || \ 260 __glibc_clang_has_extension (__attribute_deprecated_with_message__) 261 # define __attribute_deprecated_msg__(msg) \ 262 __attribute__ ((__deprecated__ (msg))) 263 #else 264 # define __attribute_deprecated_msg__(msg) __attribute_deprecated__ 265 #endif 266 267 /* At some point during the gcc 2.8 development the `format_arg' attribute 268 for functions was introduced. We don't want to use it unconditionally 269 (although this would be possible) since it generates warnings. 270 If several `format_arg' attributes are given for the same function, in 271 gcc-3.0 and older, all but the last one are ignored. In newer gccs, 272 all designated arguments are considered. */ 273 #if __GNUC_PREREQ (2,8) 274 # define __attribute_format_arg__(x) __attribute__ ((__format_arg__ (x))) 275 #else 276 # define __attribute_format_arg__(x) /* Ignore */ 277 #endif 278 279 /* At some point during the gcc 2.97 development the `strfmon' format 280 attribute for functions was introduced. We don't want to use it 281 unconditionally (although this would be possible) since it 282 generates warnings. */ 283 #if __GNUC_PREREQ (2,97) 284 # define __attribute_format_strfmon__(a,b) \ 285 __attribute__ ((__format__ (__strfmon__, a, b))) 286 #else 287 # define __attribute_format_strfmon__(a,b) /* Ignore */ 288 #endif 289 290 /* The nonnull function attribute marks pointer parameters that 291 must not be NULL. Do not define __nonnull if it is already defined, 292 for portability when this file is used in Gnulib. */ 293 #ifndef __nonnull 294 # if __GNUC_PREREQ (3,3) 295 # define __nonnull(params) __attribute__ ((__nonnull__ params)) 296 # else 297 # define __nonnull(params) 298 # endif 299 #endif 300 301 /* If fortification mode, we warn about unused results of certain 302 function calls which can lead to problems. */ 303 #if __GNUC_PREREQ (3,4) 304 # define __attribute_warn_unused_result__ \ 305 __attribute__ ((__warn_unused_result__)) 306 # if defined __USE_FORTIFY_LEVEL && __USE_FORTIFY_LEVEL > 0 307 # define __wur __attribute_warn_unused_result__ 308 # endif 309 #else 310 # define __attribute_warn_unused_result__ /* empty */ 311 #endif 312 #ifndef __wur 313 # define __wur /* Ignore */ 314 #endif 315 316 /* Forces a function to be always inlined. */ 317 #if __GNUC_PREREQ (3,2) 318 /* The Linux kernel defines __always_inline in stddef.h (283d7573), and 319 it conflicts with this definition. Therefore undefine it first to 320 allow either header to be included first. */ 321 # undef __always_inline 322 # define __always_inline __inline __attribute__ ((__always_inline__)) 323 #else 324 # undef __always_inline 325 # define __always_inline __inline 326 #endif 327 328 /* Associate error messages with the source location of the call site rather 329 than with the source location inside the function. */ 330 #if __GNUC_PREREQ (4,3) 331 # define __attribute_artificial__ __attribute__ ((__artificial__)) 332 #else 333 # define __attribute_artificial__ /* Ignore */ 334 #endif 335 336 /* GCC 4.3 and above with -std=c99 or -std=gnu99 implements ISO C99 337 inline semantics, unless -fgnu89-inline is used. Using __GNUC_STDC_INLINE__ 338 or __GNUC_GNU_INLINE is not a good enough check for gcc because gcc versions 339 older than 4.3 may define these macros and still not guarantee GNU inlining 340 semantics. 341 342 clang++ identifies itself as gcc-4.2, but has support for GNU inlining 343 semantics, that can be checked for by using the __GNUC_STDC_INLINE_ and 344 __GNUC_GNU_INLINE__ macro definitions. */ 345 #if (!defined __cplusplus || __GNUC_PREREQ (4,3) \ 346 || (defined __clang__ && (defined __GNUC_STDC_INLINE__ \ 347 || defined __GNUC_GNU_INLINE__))) 348 # if defined __GNUC_STDC_INLINE__ || defined __cplusplus 349 # define __extern_inline extern __inline __attribute__ ((__gnu_inline__)) 350 # define __extern_always_inline \ 351 extern __always_inline __attribute__ ((__gnu_inline__)) 352 # else 353 # define __extern_inline extern __inline 354 # define __extern_always_inline extern __always_inline 355 # endif 356 #endif 357 358 #ifdef __extern_always_inline 359 # define __fortify_function __extern_always_inline __attribute_artificial__ 360 #endif 361 362 /* GCC 4.3 and above allow passing all anonymous arguments of an 363 __extern_always_inline function to some other vararg function. */ 364 #if __GNUC_PREREQ (4,3) 365 # define __va_arg_pack() __builtin_va_arg_pack () 366 # define __va_arg_pack_len() __builtin_va_arg_pack_len () 367 #endif 368 369 /* It is possible to compile containing GCC extensions even if GCC is 370 run in pedantic mode if the uses are carefully marked using the 371 `__extension__' keyword. But this is not generally available before 372 version 2.8. */ 373 #if !__GNUC_PREREQ (2,8) 374 # define __extension__ /* Ignore */ 375 #endif 376 377 /* __restrict is known in EGCS 1.2 and above. */ 378 #if !__GNUC_PREREQ (2,92) 379 # if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L 380 # define __restrict restrict 381 # else 382 # define __restrict /* Ignore */ 383 # endif 384 #endif 385 386 /* ISO C99 also allows to declare arrays as non-overlapping. The syntax is 387 array_name[restrict] 388 GCC 3.1 supports this. */ 389 #if __GNUC_PREREQ (3,1) && !defined __GNUG__ 390 # define __restrict_arr __restrict 391 #else 392 # ifdef __GNUC__ 393 # define __restrict_arr /* Not supported in old GCC. */ 394 # else 395 # if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L 396 # define __restrict_arr restrict 397 # else 398 /* Some other non-C99 compiler. */ 399 # define __restrict_arr /* Not supported. */ 400 # endif 401 # endif 402 #endif 403 404 #if __GNUC__ >= 3 405 # define __glibc_unlikely(cond) __builtin_expect ((cond), 0) 406 # define __glibc_likely(cond) __builtin_expect ((cond), 1) 407 #else 408 # define __glibc_unlikely(cond) (cond) 409 # define __glibc_likely(cond) (cond) 410 #endif 411 412 #ifdef __has_attribute 413 # define __glibc_has_attribute(attr) __has_attribute (attr) 414 #else 415 # define __glibc_has_attribute(attr) 0 416 #endif 417 418 #if (!defined _Noreturn \ 419 && (defined __STDC_VERSION__ ? __STDC_VERSION__ : 0) < 201112 \ 420 && !__GNUC_PREREQ (4,7)) 421 # if __GNUC_PREREQ (2,8) 422 # define _Noreturn __attribute__ ((__noreturn__)) 423 # else 424 # define _Noreturn 425 # endif 426 #endif 427 428 #if __GNUC_PREREQ (8, 0) 429 /* Describes a char array whose address can safely be passed as the first 430 argument to strncpy and strncat, as the char array is not necessarily 431 a NUL-terminated string. */ 432 # define __attribute_nonstring__ __attribute__ ((__nonstring__)) 433 #else 434 # define __attribute_nonstring__ 435 #endif 436 437 #if (!defined _Static_assert && !defined __cplusplus \ 438 && (defined __STDC_VERSION__ ? __STDC_VERSION__ : 0) < 201112 \ 439 && (!__GNUC_PREREQ (4, 6) || defined __STRICT_ANSI__)) 440 # define _Static_assert(expr, diagnostic) \ 441 extern int (*__Static_assert_function (void)) \ 442 [!!sizeof (struct { int __error_if_negative: (expr) ? 2 : -1; })] 443 #endif 444 445 /* The #ifndef lets Gnulib avoid including these on non-glibc 446 platforms, where the includes typically do not exist. */ 447 #ifndef __WORDSIZE 448 # include <bits/wordsize.h> 449 # include <bits/long-double.h> 450 #endif 451 452 #if defined __LONG_DOUBLE_MATH_OPTIONAL && defined __NO_LONG_DOUBLE_MATH 453 # define __LDBL_COMPAT 1 454 # ifdef __REDIRECT 455 # define __LDBL_REDIR1(name, proto, alias) __REDIRECT (name, proto, alias) 456 # define __LDBL_REDIR(name, proto) \ 457 __LDBL_REDIR1 (name, proto, __nldbl_##name) 458 # define __LDBL_REDIR1_NTH(name, proto, alias) __REDIRECT_NTH (name, proto, alias) 459 # define __LDBL_REDIR_NTH(name, proto) \ 460 __LDBL_REDIR1_NTH (name, proto, __nldbl_##name) 461 # define __LDBL_REDIR1_DECL(name, alias) \ 462 extern __typeof (name) name __asm (__ASMNAME (#alias)); 463 # define __LDBL_REDIR_DECL(name) \ 464 extern __typeof (name) name __asm (__ASMNAME ("__nldbl_" #name)); 465 # define __REDIRECT_LDBL(name, proto, alias) \ 466 __LDBL_REDIR1 (name, proto, __nldbl_##alias) 467 # define __REDIRECT_NTH_LDBL(name, proto, alias) \ 468 __LDBL_REDIR1_NTH (name, proto, __nldbl_##alias) 469 # endif 470 #endif 471 #if !defined __LDBL_COMPAT || !defined __REDIRECT 472 # define __LDBL_REDIR1(name, proto, alias) name proto 473 # define __LDBL_REDIR(name, proto) name proto 474 # define __LDBL_REDIR1_NTH(name, proto, alias) name proto __THROW 475 # define __LDBL_REDIR_NTH(name, proto) name proto __THROW 476 # define __LDBL_REDIR_DECL(name) 477 # ifdef __REDIRECT 478 # define __REDIRECT_LDBL(name, proto, alias) __REDIRECT (name, proto, alias) 479 # define __REDIRECT_NTH_LDBL(name, proto, alias) \ 480 __REDIRECT_NTH (name, proto, alias) 481 # endif 482 #endif 483 484 /* __glibc_macro_warning (MESSAGE) issues warning MESSAGE. This is 485 intended for use in preprocessor macros. 486 487 Note: MESSAGE must be a _single_ string; concatenation of string 488 literals is not supported. */ 489 #if __GNUC_PREREQ (4,8) || __glibc_clang_prereq (3,5) 490 # define __glibc_macro_warning1(message) _Pragma (#message) 491 # define __glibc_macro_warning(message) \ 492 __glibc_macro_warning1 (GCC warning message) 493 #else 494 # define __glibc_macro_warning(msg) 495 #endif 496 497 /* Generic selection (ISO C11) is a C-only feature, available in GCC 498 since version 4.9. Previous versions do not provide generic 499 selection, even though they might set __STDC_VERSION__ to 201112L, 500 when in -std=c11 mode. Thus, we must check for !defined __GNUC__ 501 when testing __STDC_VERSION__ for generic selection support. 502 On the other hand, Clang also defines __GNUC__, so a clang-specific 503 check is required to enable the use of generic selection. */ 504 #if !defined __cplusplus \ 505 && (__GNUC_PREREQ (4, 9) \ 506 || __glibc_clang_has_extension (c_generic_selections) \ 507 || (!defined __GNUC__ && defined __STDC_VERSION__ \ 508 && __STDC_VERSION__ >= 201112L)) 509 # define __HAVE_GENERIC_SELECTION 1 510 #else 511 # define __HAVE_GENERIC_SELECTION 0 512 #endif 513 514 #endif /* sys/cdefs.h */ 515