| 1 |
/* Copyright (C) 1992-2024 Free Software Foundation, Inc. |
| 2 |
Copyright The GNU Toolchain Authors. |
| 3 |
This file is part of the GNU C Library. |
| 4 |
|
| 5 |
The GNU C Library is free software; you can redistribute it and/or |
| 6 |
modify it under the terms of the GNU Lesser General Public |
| 7 |
License as published by the Free Software Foundation; either |
| 8 |
version 2.1 of the License, or (at your option) any later version. |
| 9 |
|
| 10 |
The GNU C Library is distributed in the hope that it will be useful, |
| 11 |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 12 |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| 13 |
Lesser General Public License for more details. |
| 14 |
|
| 15 |
You should have received a copy of the GNU Lesser General Public |
| 16 |
License along with the GNU C Library; if not, see |
| 17 |
<https://www.gnu.org/licenses/>. */ |
| 18 |
|
| 19 |
#ifndef _SYS_CDEFS_H |
| 20 |
#define _SYS_CDEFS_H 1 |
| 21 |
|
| 22 |
/* We are almost always included from features.h. */ |
| 23 |
#ifndef _FEATURES_H |
| 24 |
# include <features.h> |
| 25 |
#endif |
| 26 |
|
| 27 |
/* The GNU libc does not support any K&R compilers or the traditional mode |
| 28 |
of ISO C compilers anymore. Check for some of the combinations not |
| 29 |
supported anymore. */ |
| 30 |
#if defined __GNUC__ && !defined __STDC__ |
| 31 |
# error "You need a ISO C conforming compiler to use the glibc headers" |
| 32 |
#endif |
| 33 |
|
| 34 |
/* Some user header file might have defined this before. */ |
| 35 |
#undef __P |
| 36 |
#undef __PMT |
| 37 |
|
| 38 |
/* Compilers that lack __has_attribute may object to |
| 39 |
#if defined __has_attribute && __has_attribute (...) |
| 40 |
even though they do not need to evaluate the right-hand side of the &&. |
| 41 |
Similarly for __has_builtin, etc. */ |
| 42 |
#if (defined __has_attribute \ |
| 43 |
&& (!defined __clang_minor__ \ |
| 44 |
|| (defined __apple_build_version__ \ |
| 45 |
? 7000000 <= __apple_build_version__ \ |
| 46 |
: 5 <= __clang_major__))) |
| 47 |
# define __glibc_has_attribute(attr) __has_attribute (attr) |
| 48 |
#else |
| 49 |
# define __glibc_has_attribute(attr) 0 |
| 50 |
#endif |
| 51 |
#ifdef __has_builtin |
| 52 |
# define __glibc_has_builtin(name) __has_builtin (name) |
| 53 |
#else |
| 54 |
# define __glibc_has_builtin(name) 0 |
| 55 |
#endif |
| 56 |
#ifdef __has_extension |
| 57 |
# define __glibc_has_extension(ext) __has_extension (ext) |
| 58 |
#else |
| 59 |
# define __glibc_has_extension(ext) 0 |
| 60 |
#endif |
| 61 |
|
| 62 |
#if defined __GNUC__ || defined __clang__ |
| 63 |
|
| 64 |
/* All functions, except those with callbacks or those that |
| 65 |
synchronize memory, are leaf functions. */ |
| 66 |
# if __GNUC_PREREQ (4, 6) && !defined _LIBC |
| 67 |
# define __LEAF , __leaf__ |
| 68 |
# define __LEAF_ATTR __attribute__ ((__leaf__)) |
| 69 |
# else |
| 70 |
# define __LEAF |
| 71 |
# define __LEAF_ATTR |
| 72 |
# endif |
| 73 |
|
| 74 |
/* GCC can always grok prototypes. For C++ programs we add throw() |
| 75 |
to help it optimize the function calls. But this only works with |
| 76 |
gcc 2.8.x and egcs. For gcc 3.4 and up we even mark C functions |
| 77 |
as non-throwing using a function attribute since programs can use |
| 78 |
the -fexceptions options for C code as well. */ |
| 79 |
# if !defined __cplusplus \ |
| 80 |
&& (__GNUC_PREREQ (3, 4) || __glibc_has_attribute (__nothrow__)) |
| 81 |
# define __THROW __attribute__ ((__nothrow__ __LEAF)) |
| 82 |
# define __THROWNL __attribute__ ((__nothrow__)) |
| 83 |
# define __NTH(fct) __attribute__ ((__nothrow__ __LEAF)) fct |
| 84 |
# define __NTHNL(fct) __attribute__ ((__nothrow__)) fct |
| 85 |
# else |
| 86 |
# if defined __cplusplus && (__GNUC_PREREQ (2,8) || __clang_major__ >= 4) |
| 87 |
# if __cplusplus >= 201103L |
| 88 |
# define __THROW noexcept (true) |
| 89 |
# else |
| 90 |
# define __THROW throw () |
| 91 |
# endif |
| 92 |
# define __THROWNL __THROW |
| 93 |
# define __NTH(fct) __LEAF_ATTR fct __THROW |
| 94 |
# define __NTHNL(fct) fct __THROW |
| 95 |
# else |
| 96 |
# define __THROW |
| 97 |
# define __THROWNL |
| 98 |
# define __NTH(fct) fct |
| 99 |
# define __NTHNL(fct) fct |
| 100 |
# endif |
| 101 |
# endif |
| 102 |
|
| 103 |
#else /* Not GCC or clang. */ |
| 104 |
|
| 105 |
# if (defined __cplusplus \ |
| 106 |
|| (defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L)) |
| 107 |
# define __inline inline |
| 108 |
# else |
| 109 |
# define __inline /* No inline functions. */ |
| 110 |
# endif |
| 111 |
|
| 112 |
# define __THROW |
| 113 |
# define __THROWNL |
| 114 |
# define __NTH(fct) fct |
| 115 |
|
| 116 |
#endif /* GCC || clang. */ |
| 117 |
|
| 118 |
/* These two macros are not used in glibc anymore. They are kept here |
| 119 |
only because some other projects expect the macros to be defined. */ |
| 120 |
#define __P(args) args |
| 121 |
#define __PMT(args) args |
| 122 |
|
| 123 |
/* For these things, GCC behaves the ANSI way normally, |
| 124 |
and the non-ANSI way under -traditional. */ |
| 125 |
|
| 126 |
#define __CONCAT(x,y) x ## y |
| 127 |
#define __STRING(x) #x |
| 128 |
|
| 129 |
/* This is not a typedef so `const __ptr_t' does the right thing. */ |
| 130 |
#define __ptr_t void * |
| 131 |
|
| 132 |
|
| 133 |
/* C++ needs to know that types and declarations are C, not C++. */ |
| 134 |
#ifdef __cplusplus |
| 135 |
# define __BEGIN_DECLS extern "C" { |
| 136 |
# define __END_DECLS } |
| 137 |
#else |
| 138 |
# define __BEGIN_DECLS |
| 139 |
# define __END_DECLS |
| 140 |
#endif |
| 141 |
|
| 142 |
|
| 143 |
/* Gnulib avoids these definitions, as they don't work on non-glibc platforms. |
| 144 |
In particular, __bos and __bos0 are defined differently in the Android libc. |
| 145 |
*/ |
| 146 |
#ifndef __GNULIB_CDEFS |
| 147 |
|
| 148 |
/* Fortify support. */ |
| 149 |
# define __bos(ptr) __builtin_object_size (ptr, __USE_FORTIFY_LEVEL > 1) |
| 150 |
# define __bos0(ptr) __builtin_object_size (ptr, 0) |
| 151 |
|
| 152 |
/* Use __builtin_dynamic_object_size at _FORTIFY_SOURCE=3 when available. */ |
| 153 |
# if __USE_FORTIFY_LEVEL == 3 && (__glibc_clang_prereq (9, 0) \ |
| 154 |
|| __GNUC_PREREQ (12, 0)) |
| 155 |
# define __glibc_objsize0(__o) __builtin_dynamic_object_size (__o, 0) |
| 156 |
# define __glibc_objsize(__o) __builtin_dynamic_object_size (__o, 1) |
| 157 |
# else |
| 158 |
# define __glibc_objsize0(__o) __bos0 (__o) |
| 159 |
# define __glibc_objsize(__o) __bos (__o) |
| 160 |
# endif |
| 161 |
|
| 162 |
/* Compile time conditions to choose between the regular, _chk and _chk_warn |
| 163 |
variants. These conditions should get evaluated to constant and optimized |
| 164 |
away. */ |
| 165 |
|
| 166 |
# define __glibc_safe_len_cond(__l, __s, __osz) ((__l) <= (__osz) / (__s)) |
| 167 |
# define __glibc_unsigned_or_positive(__l) \ |
| 168 |
((__typeof (__l)) 0 < (__typeof (__l)) -1 \ |
| 169 |
|| (__builtin_constant_p (__l) && (__l) > 0)) |
| 170 |
|
| 171 |
/* Length is known to be safe at compile time if the __L * __S <= __OBJSZ |
| 172 |
condition can be folded to a constant and if it is true, or unknown (-1) */ |
| 173 |
# define __glibc_safe_or_unknown_len(__l, __s, __osz) \ |
| 174 |
((__osz) == (__SIZE_TYPE__) -1 \ |
| 175 |
|| (__glibc_unsigned_or_positive (__l) \ |
| 176 |
&& __builtin_constant_p (__glibc_safe_len_cond ((__SIZE_TYPE__) (__l), \ |
| 177 |
(__s), (__osz))) \ |
| 178 |
&& __glibc_safe_len_cond ((__SIZE_TYPE__) (__l), (__s), (__osz)))) |
| 179 |
|
| 180 |
/* Conversely, we know at compile time that the length is unsafe if the |
| 181 |
__L * __S <= __OBJSZ condition can be folded to a constant and if it is |
| 182 |
false. */ |
| 183 |
# define __glibc_unsafe_len(__l, __s, __osz) \ |
| 184 |
(__glibc_unsigned_or_positive (__l) \ |
| 185 |
&& __builtin_constant_p (__glibc_safe_len_cond ((__SIZE_TYPE__) (__l), \ |
| 186 |
__s, __osz)) \ |
| 187 |
&& !__glibc_safe_len_cond ((__SIZE_TYPE__) (__l), __s, __osz)) |
| 188 |
|
| 189 |
/* Fortify function f. __f_alias, __f_chk and __f_chk_warn must be |
| 190 |
declared. */ |
| 191 |
|
| 192 |
# define __glibc_fortify(f, __l, __s, __osz, ...) \ |
| 193 |
(__glibc_safe_or_unknown_len (__l, __s, __osz) \ |
| 194 |
? __ ## f ## _alias (__VA_ARGS__) \ |
| 195 |
: (__glibc_unsafe_len (__l, __s, __osz) \ |
| 196 |
? __ ## f ## _chk_warn (__VA_ARGS__, __osz) \ |
| 197 |
: __ ## f ## _chk (__VA_ARGS__, __osz))) \ |
| 198 |
|
| 199 |
/* Fortify function f, where object size argument passed to f is the number of |
| 200 |
elements and not total size. */ |
| 201 |
|
| 202 |
# define __glibc_fortify_n(f, __l, __s, __osz, ...) \ |
| 203 |
(__glibc_safe_or_unknown_len (__l, __s, __osz) \ |
| 204 |
? __ ## f ## _alias (__VA_ARGS__) \ |
| 205 |
: (__glibc_unsafe_len (__l, __s, __osz) \ |
| 206 |
? __ ## f ## _chk_warn (__VA_ARGS__, (__osz) / (__s)) \ |
| 207 |
: __ ## f ## _chk (__VA_ARGS__, (__osz) / (__s)))) \ |
| 208 |
|
| 209 |
#endif |
| 210 |
|
| 211 |
|
| 212 |
#if __GNUC_PREREQ (4,3) |
| 213 |
# define __warnattr(msg) __attribute__((__warning__ (msg))) |
| 214 |
# define __errordecl(name, msg) \ |
| 215 |
extern void name (void) __attribute__((__error__ (msg))) |
| 216 |
#else |
| 217 |
# define __warnattr(msg) |
| 218 |
# define __errordecl(name, msg) extern void name (void) |
| 219 |
#endif |
| 220 |
|
| 221 |
/* Support for flexible arrays. |
| 222 |
Headers that should use flexible arrays only if they're "real" |
| 223 |
(e.g. only if they won't affect sizeof()) should test |
| 224 |
#if __glibc_c99_flexarr_available. */ |
| 225 |
#if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L && !defined __HP_cc |
| 226 |
# define __flexarr [] |
| 227 |
# define __glibc_c99_flexarr_available 1 |
| 228 |
#elif __GNUC_PREREQ (2,97) || defined __clang__ |
| 229 |
/* GCC 2.97 and clang support C99 flexible array members as an extension, |
| 230 |
even when in C89 mode or compiling C++ (any version). */ |
| 231 |
# define __flexarr [] |
| 232 |
# define __glibc_c99_flexarr_available 1 |
| 233 |
#elif defined __GNUC__ |
| 234 |
/* Pre-2.97 GCC did not support C99 flexible arrays but did have |
| 235 |
an equivalent extension with slightly different notation. */ |
| 236 |
# define __flexarr [0] |
| 237 |
# define __glibc_c99_flexarr_available 1 |
| 238 |
#else |
| 239 |
/* Some other non-C99 compiler. Approximate with [1]. */ |
| 240 |
# define __flexarr [1] |
| 241 |
# define __glibc_c99_flexarr_available 0 |
| 242 |
#endif |
| 243 |
|
| 244 |
|
| 245 |
/* __asm__ ("xyz") is used throughout the headers to rename functions |
| 246 |
at the assembly language level. This is wrapped by the __REDIRECT |
| 247 |
macro, in order to support compilers that can do this some other |
| 248 |
way. When compilers don't support asm-names at all, we have to do |
| 249 |
preprocessor tricks instead (which don't have exactly the right |
| 250 |
semantics, but it's the best we can do). |
| 251 |
|
| 252 |
Example: |
| 253 |
int __REDIRECT(setpgrp, (__pid_t pid, __pid_t pgrp), setpgid); */ |
| 254 |
|
| 255 |
#if (defined __GNUC__ && __GNUC__ >= 2) || (__clang_major__ >= 4) |
| 256 |
|
| 257 |
# define __REDIRECT(name, proto, alias) name proto __asm__ (__ASMNAME (#alias)) |
| 258 |
# ifdef __cplusplus |
| 259 |
# define __REDIRECT_NTH(name, proto, alias) \ |
| 260 |
name proto __THROW __asm__ (__ASMNAME (#alias)) |
| 261 |
# define __REDIRECT_NTHNL(name, proto, alias) \ |
| 262 |
name proto __THROWNL __asm__ (__ASMNAME (#alias)) |
| 263 |
# else |
| 264 |
# define __REDIRECT_NTH(name, proto, alias) \ |
| 265 |
name proto __asm__ (__ASMNAME (#alias)) __THROW |
| 266 |
# define __REDIRECT_NTHNL(name, proto, alias) \ |
| 267 |
name proto __asm__ (__ASMNAME (#alias)) __THROWNL |
| 268 |
# endif |
| 269 |
# define __ASMNAME(cname) __ASMNAME2 (__USER_LABEL_PREFIX__, cname) |
| 270 |
# define __ASMNAME2(prefix, cname) __STRING (prefix) cname |
| 271 |
|
| 272 |
/* |
| 273 |
#elif __SOME_OTHER_COMPILER__ |
| 274 |
|
| 275 |
# define __REDIRECT(name, proto, alias) name proto; \ |
| 276 |
_Pragma("let " #name " = " #alias) |
| 277 |
*/ |
| 278 |
#endif |
| 279 |
|
| 280 |
/* GCC and clang have various useful declarations that can be made with |
| 281 |
the '__attribute__' syntax. All of the ways we use this do fine if |
| 282 |
they are omitted for compilers that don't understand it. */ |
| 283 |
#if !(defined __GNUC__ || defined __clang__) |
| 284 |
# define __attribute__(xyz) /* Ignore */ |
| 285 |
#endif |
| 286 |
|
| 287 |
/* At some point during the gcc 2.96 development the `malloc' attribute |
| 288 |
for functions was introduced. We don't want to use it unconditionally |
| 289 |
(although this would be possible) since it generates warnings. */ |
| 290 |
#if __GNUC_PREREQ (2,96) || __glibc_has_attribute (__malloc__) |
| 291 |
# define __attribute_malloc__ __attribute__ ((__malloc__)) |
| 292 |
#else |
| 293 |
# define __attribute_malloc__ /* Ignore */ |
| 294 |
#endif |
| 295 |
|
| 296 |
/* Tell the compiler which arguments to an allocation function |
| 297 |
indicate the size of the allocation. */ |
| 298 |
#if __GNUC_PREREQ (4, 3) |
| 299 |
# define __attribute_alloc_size__(params) \ |
| 300 |
__attribute__ ((__alloc_size__ params)) |
| 301 |
#else |
| 302 |
# define __attribute_alloc_size__(params) /* Ignore. */ |
| 303 |
#endif |
| 304 |
|
| 305 |
/* Tell the compiler which argument to an allocation function |
| 306 |
indicates the alignment of the allocation. */ |
| 307 |
#if __GNUC_PREREQ (4, 9) || __glibc_has_attribute (__alloc_align__) |
| 308 |
# define __attribute_alloc_align__(param) \ |
| 309 |
__attribute__ ((__alloc_align__ param)) |
| 310 |
#else |
| 311 |
# define __attribute_alloc_align__(param) /* Ignore. */ |
| 312 |
#endif |
| 313 |
|
| 314 |
/* At some point during the gcc 2.96 development the `pure' attribute |
| 315 |
for functions was introduced. We don't want to use it unconditionally |
| 316 |
(although this would be possible) since it generates warnings. */ |
| 317 |
#if __GNUC_PREREQ (2,96) || __glibc_has_attribute (__pure__) |
| 318 |
# define __attribute_pure__ __attribute__ ((__pure__)) |
| 319 |
#else |
| 320 |
# define __attribute_pure__ /* Ignore */ |
| 321 |
#endif |
| 322 |
|
| 323 |
/* This declaration tells the compiler that the value is constant. */ |
| 324 |
#if __GNUC_PREREQ (2,5) || __glibc_has_attribute (__const__) |
| 325 |
# define __attribute_const__ __attribute__ ((__const__)) |
| 326 |
#else |
| 327 |
# define __attribute_const__ /* Ignore */ |
| 328 |
#endif |
| 329 |
|
| 330 |
#if __GNUC_PREREQ (2,7) || __glibc_has_attribute (__unused__) |
| 331 |
# define __attribute_maybe_unused__ __attribute__ ((__unused__)) |
| 332 |
#else |
| 333 |
# define __attribute_maybe_unused__ /* Ignore */ |
| 334 |
#endif |
| 335 |
|
| 336 |
/* At some point during the gcc 3.1 development the `used' attribute |
| 337 |
for functions was introduced. We don't want to use it unconditionally |
| 338 |
(although this would be possible) since it generates warnings. */ |
| 339 |
#if __GNUC_PREREQ (3,1) || __glibc_has_attribute (__used__) |
| 340 |
# define __attribute_used__ __attribute__ ((__used__)) |
| 341 |
# define __attribute_noinline__ __attribute__ ((__noinline__)) |
| 342 |
#else |
| 343 |
# define __attribute_used__ __attribute__ ((__unused__)) |
| 344 |
# define __attribute_noinline__ /* Ignore */ |
| 345 |
#endif |
| 346 |
|
| 347 |
/* Since version 3.2, gcc allows marking deprecated functions. */ |
| 348 |
#if __GNUC_PREREQ (3,2) || __glibc_has_attribute (__deprecated__) |
| 349 |
# define __attribute_deprecated__ __attribute__ ((__deprecated__)) |
| 350 |
#else |
| 351 |
# define __attribute_deprecated__ /* Ignore */ |
| 352 |
#endif |
| 353 |
|
| 354 |
/* Since version 4.5, gcc also allows one to specify the message printed |
| 355 |
when a deprecated function is used. clang claims to be gcc 4.2, but |
| 356 |
may also support this feature. */ |
| 357 |
#if __GNUC_PREREQ (4,5) \ |
| 358 |
|| __glibc_has_extension (__attribute_deprecated_with_message__) |
| 359 |
# define __attribute_deprecated_msg__(msg) \ |
| 360 |
__attribute__ ((__deprecated__ (msg))) |
| 361 |
#else |
| 362 |
# define __attribute_deprecated_msg__(msg) __attribute_deprecated__ |
| 363 |
#endif |
| 364 |
|
| 365 |
/* At some point during the gcc 2.8 development the `format_arg' attribute |
| 366 |
for functions was introduced. We don't want to use it unconditionally |
| 367 |
(although this would be possible) since it generates warnings. |
| 368 |
If several `format_arg' attributes are given for the same function, in |
| 369 |
gcc-3.0 and older, all but the last one are ignored. In newer gccs, |
| 370 |
all designated arguments are considered. */ |
| 371 |
#if __GNUC_PREREQ (2,8) || __glibc_has_attribute (__format_arg__) |
| 372 |
# define __attribute_format_arg__(x) __attribute__ ((__format_arg__ (x))) |
| 373 |
#else |
| 374 |
# define __attribute_format_arg__(x) /* Ignore */ |
| 375 |
#endif |
| 376 |
|
| 377 |
/* At some point during the gcc 2.97 development the `strfmon' format |
| 378 |
attribute for functions was introduced. We don't want to use it |
| 379 |
unconditionally (although this would be possible) since it |
| 380 |
generates warnings. */ |
| 381 |
#if __GNUC_PREREQ (2,97) || __glibc_has_attribute (__format__) |
| 382 |
# define __attribute_format_strfmon__(a,b) \ |
| 383 |
__attribute__ ((__format__ (__strfmon__, a, b))) |
| 384 |
#else |
| 385 |
# define __attribute_format_strfmon__(a,b) /* Ignore */ |
| 386 |
#endif |
| 387 |
|
| 388 |
/* The nonnull function attribute marks pointer parameters that |
| 389 |
must not be NULL. This has the name __nonnull in glibc, |
| 390 |
and __attribute_nonnull__ in files shared with Gnulib to avoid |
| 391 |
collision with a different __nonnull in DragonFlyBSD 5.9. */ |
| 392 |
#ifndef __attribute_nonnull__ |
| 393 |
# if __GNUC_PREREQ (3,3) || __glibc_has_attribute (__nonnull__) |
| 394 |
# define __attribute_nonnull__(params) __attribute__ ((__nonnull__ params)) |
| 395 |
# else |
| 396 |
# define __attribute_nonnull__(params) |
| 397 |
# endif |
| 398 |
#endif |
| 399 |
#ifndef __nonnull |
| 400 |
# define __nonnull(params) __attribute_nonnull__ (params) |
| 401 |
#endif |
| 402 |
|
| 403 |
/* The returns_nonnull function attribute marks the return type of the function |
| 404 |
as always being non-null. */ |
| 405 |
#ifndef __returns_nonnull |
| 406 |
# if __GNUC_PREREQ (4, 9) || __glibc_has_attribute (__returns_nonnull__) |
| 407 |
# define __returns_nonnull __attribute__ ((__returns_nonnull__)) |
| 408 |
# else |
| 409 |
# define __returns_nonnull |
| 410 |
# endif |
| 411 |
#endif |
| 412 |
|
| 413 |
/* If fortification mode, we warn about unused results of certain |
| 414 |
function calls which can lead to problems. */ |
| 415 |
#if __GNUC_PREREQ (3,4) || __glibc_has_attribute (__warn_unused_result__) |
| 416 |
# define __attribute_warn_unused_result__ \ |
| 417 |
__attribute__ ((__warn_unused_result__)) |
| 418 |
# if defined __USE_FORTIFY_LEVEL && __USE_FORTIFY_LEVEL > 0 |
| 419 |
# define __wur __attribute_warn_unused_result__ |
| 420 |
# endif |
| 421 |
#else |
| 422 |
# define __attribute_warn_unused_result__ /* empty */ |
| 423 |
#endif |
| 424 |
#ifndef __wur |
| 425 |
# define __wur /* Ignore */ |
| 426 |
#endif |
| 427 |
|
| 428 |
/* Forces a function to be always inlined. */ |
| 429 |
#if __GNUC_PREREQ (3,2) || __glibc_has_attribute (__always_inline__) |
| 430 |
/* The Linux kernel defines __always_inline in stddef.h (283d7573), and |
| 431 |
it conflicts with this definition. Therefore undefine it first to |
| 432 |
allow either header to be included first. */ |
| 433 |
# undef __always_inline |
| 434 |
# define __always_inline __inline __attribute__ ((__always_inline__)) |
| 435 |
#else |
| 436 |
# undef __always_inline |
| 437 |
# define __always_inline __inline |
| 438 |
#endif |
| 439 |
|
| 440 |
/* Associate error messages with the source location of the call site rather |
| 441 |
than with the source location inside the function. */ |
| 442 |
#if __GNUC_PREREQ (4,3) || __glibc_has_attribute (__artificial__) |
| 443 |
# define __attribute_artificial__ __attribute__ ((__artificial__)) |
| 444 |
#else |
| 445 |
# define __attribute_artificial__ /* Ignore */ |
| 446 |
#endif |
| 447 |
|
| 448 |
/* GCC 4.3 and above with -std=c99 or -std=gnu99 implements ISO C99 |
| 449 |
inline semantics, unless -fgnu89-inline is used. Using __GNUC_STDC_INLINE__ |
| 450 |
or __GNUC_GNU_INLINE is not a good enough check for gcc because gcc versions |
| 451 |
older than 4.3 may define these macros and still not guarantee GNU inlining |
| 452 |
semantics. |
| 453 |
|
| 454 |
clang++ identifies itself as gcc-4.2, but has support for GNU inlining |
| 455 |
semantics, that can be checked for by using the __GNUC_STDC_INLINE_ and |
| 456 |
__GNUC_GNU_INLINE__ macro definitions. */ |
| 457 |
#if (!defined __cplusplus || __GNUC_PREREQ (4,3) \ |
| 458 |
|| (defined __clang__ && (defined __GNUC_STDC_INLINE__ \ |
| 459 |
|| defined __GNUC_GNU_INLINE__))) |
| 460 |
# if defined __GNUC_STDC_INLINE__ || defined __cplusplus |
| 461 |
# define __extern_inline extern __inline __attribute__ ((__gnu_inline__)) |
| 462 |
# define __extern_always_inline \ |
| 463 |
extern __always_inline __attribute__ ((__gnu_inline__)) |
| 464 |
# else |
| 465 |
# define __extern_inline extern __inline |
| 466 |
# define __extern_always_inline extern __always_inline |
| 467 |
# endif |
| 468 |
#endif |
| 469 |
|
| 470 |
#ifdef __extern_always_inline |
| 471 |
# define __fortify_function __extern_always_inline __attribute_artificial__ |
| 472 |
#endif |
| 473 |
|
| 474 |
/* GCC 4.3 and above allow passing all anonymous arguments of an |
| 475 |
__extern_always_inline function to some other vararg function. */ |
| 476 |
#if __GNUC_PREREQ (4,3) |
| 477 |
# define __va_arg_pack() __builtin_va_arg_pack () |
| 478 |
# define __va_arg_pack_len() __builtin_va_arg_pack_len () |
| 479 |
#endif |
| 480 |
|
| 481 |
/* It is possible to compile containing GCC extensions even if GCC is |
| 482 |
run in pedantic mode if the uses are carefully marked using the |
| 483 |
`__extension__' keyword. But this is not generally available before |
| 484 |
version 2.8. */ |
| 485 |
#if !(__GNUC_PREREQ (2,8) || defined __clang__) |
| 486 |
# define __extension__ /* Ignore */ |
| 487 |
#endif |
| 488 |
|
| 489 |
/* __restrict is known in EGCS 1.2 and above, and in clang. |
| 490 |
It works also in C++ mode (outside of arrays), but only when spelled |
| 491 |
as '__restrict', not 'restrict'. */ |
| 492 |
#if !(__GNUC_PREREQ (2,92) || __clang_major__ >= 3) |
| 493 |
# if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L |
| 494 |
# define __restrict restrict |
| 495 |
# else |
| 496 |
# define __restrict /* Ignore */ |
| 497 |
# endif |
| 498 |
#endif |
| 499 |
|
| 500 |
/* ISO C99 also allows to declare arrays as non-overlapping. The syntax is |
| 501 |
array_name[restrict] |
| 502 |
GCC 3.1 and clang support this. |
| 503 |
This syntax is not usable in C++ mode. */ |
| 504 |
#if (__GNUC_PREREQ (3,1) || __clang_major__ >= 3) && !defined __cplusplus |
| 505 |
# define __restrict_arr __restrict |
| 506 |
#else |
| 507 |
# ifdef __GNUC__ |
| 508 |
# define __restrict_arr /* Not supported in old GCC. */ |
| 509 |
# else |
| 510 |
# if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L |
| 511 |
# define __restrict_arr restrict |
| 512 |
# else |
| 513 |
/* Some other non-C99 compiler. */ |
| 514 |
# define __restrict_arr /* Not supported. */ |
| 515 |
# endif |
| 516 |
# endif |
| 517 |
#endif |
| 518 |
|
| 519 |
#if (__GNUC__ >= 3) || __glibc_has_builtin (__builtin_expect) |
| 520 |
# define __glibc_unlikely(cond) __builtin_expect ((cond), 0) |
| 521 |
# define __glibc_likely(cond) __builtin_expect ((cond), 1) |
| 522 |
#else |
| 523 |
# define __glibc_unlikely(cond) (cond) |
| 524 |
# define __glibc_likely(cond) (cond) |
| 525 |
#endif |
| 526 |
|
| 527 |
#if (!defined _Noreturn \ |
| 528 |
&& (defined __STDC_VERSION__ ? __STDC_VERSION__ : 0) < 201112 \ |
| 529 |
&& !(__GNUC_PREREQ (4,7) \ |
| 530 |
|| (3 < __clang_major__ + (5 <= __clang_minor__)))) |
| 531 |
# if __GNUC_PREREQ (2,8) |
| 532 |
# define _Noreturn __attribute__ ((__noreturn__)) |
| 533 |
# else |
| 534 |
# define _Noreturn |
| 535 |
# endif |
| 536 |
#endif |
| 537 |
|
| 538 |
#if __GNUC_PREREQ (8, 0) |
| 539 |
/* Describes a char array whose address can safely be passed as the first |
| 540 |
argument to strncpy and strncat, as the char array is not necessarily |
| 541 |
a NUL-terminated string. */ |
| 542 |
# define __attribute_nonstring__ __attribute__ ((__nonstring__)) |
| 543 |
#else |
| 544 |
# define __attribute_nonstring__ |
| 545 |
#endif |
| 546 |
|
| 547 |
/* Undefine (also defined in libc-symbols.h). */ |
| 548 |
#undef __attribute_copy__ |
| 549 |
#if __GNUC_PREREQ (9, 0) |
| 550 |
/* Copies attributes from the declaration or type referenced by |
| 551 |
the argument. */ |
| 552 |
# define __attribute_copy__(arg) __attribute__ ((__copy__ (arg))) |
| 553 |
#else |
| 554 |
# define __attribute_copy__(arg) |
| 555 |
#endif |
| 556 |
|
| 557 |
#if (!defined _Static_assert && !defined __cplusplus \ |
| 558 |
&& (defined __STDC_VERSION__ ? __STDC_VERSION__ : 0) < 201112 \ |
| 559 |
&& (!(__GNUC_PREREQ (4, 6) || __clang_major__ >= 4) \ |
| 560 |
|| defined __STRICT_ANSI__)) |
| 561 |
# define _Static_assert(expr, diagnostic) \ |
| 562 |
extern int (*__Static_assert_function (void)) \ |
| 563 |
[!!sizeof (struct { int __error_if_negative: (expr) ? 2 : -1; })] |
| 564 |
#endif |
| 565 |
|
| 566 |
/* Gnulib avoids including these, as they don't work on non-glibc or |
| 567 |
older glibc platforms. */ |
| 568 |
#ifndef __GNULIB_CDEFS |
| 569 |
# include <bits/wordsize.h> |
| 570 |
# include <bits/long-double.h> |
| 571 |
#endif |
| 572 |
|
| 573 |
#if __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI == 1 |
| 574 |
# ifdef __REDIRECT |
| 575 |
|
| 576 |
/* Alias name defined automatically. */ |
| 577 |
# define __LDBL_REDIR(name, proto) ... unused__ldbl_redir |
| 578 |
# define __LDBL_REDIR_DECL(name) \ |
| 579 |
extern __typeof (name) name __asm (__ASMNAME ("__" #name "ieee128")); |
| 580 |
|
| 581 |
/* Alias name defined automatically, with leading underscores. */ |
| 582 |
# define __LDBL_REDIR2_DECL(name) \ |
| 583 |
extern __typeof (__##name) __##name \ |
| 584 |
__asm (__ASMNAME ("__" #name "ieee128")); |
| 585 |
|
| 586 |
/* Alias name defined manually. */ |
| 587 |
# define __LDBL_REDIR1(name, proto, alias) ... unused__ldbl_redir1 |
| 588 |
# define __LDBL_REDIR1_DECL(name, alias) \ |
| 589 |
extern __typeof (name) name __asm (__ASMNAME (#alias)); |
| 590 |
|
| 591 |
# define __LDBL_REDIR1_NTH(name, proto, alias) \ |
| 592 |
__REDIRECT_NTH (name, proto, alias) |
| 593 |
# define __REDIRECT_NTH_LDBL(name, proto, alias) \ |
| 594 |
__LDBL_REDIR1_NTH (name, proto, __##alias##ieee128) |
| 595 |
|
| 596 |
/* Unused. */ |
| 597 |
# define __REDIRECT_LDBL(name, proto, alias) ... unused__redirect_ldbl |
| 598 |
# define __LDBL_REDIR_NTH(name, proto) ... unused__ldbl_redir_nth |
| 599 |
|
| 600 |
# else |
| 601 |
_Static_assert (0, "IEEE 128-bits long double requires redirection on this platform"); |
| 602 |
# endif |
| 603 |
#elif defined __LONG_DOUBLE_MATH_OPTIONAL && defined __NO_LONG_DOUBLE_MATH |
| 604 |
# define __LDBL_COMPAT 1 |
| 605 |
# ifdef __REDIRECT |
| 606 |
# define __LDBL_REDIR1(name, proto, alias) __REDIRECT (name, proto, alias) |
| 607 |
# define __LDBL_REDIR(name, proto) \ |
| 608 |
__LDBL_REDIR1 (name, proto, __nldbl_##name) |
| 609 |
# define __LDBL_REDIR1_NTH(name, proto, alias) __REDIRECT_NTH (name, proto, alias) |
| 610 |
# define __LDBL_REDIR_NTH(name, proto) \ |
| 611 |
__LDBL_REDIR1_NTH (name, proto, __nldbl_##name) |
| 612 |
# define __LDBL_REDIR2_DECL(name) \ |
| 613 |
extern __typeof (__##name) __##name __asm (__ASMNAME ("__nldbl___" #name)); |
| 614 |
# define __LDBL_REDIR1_DECL(name, alias) \ |
| 615 |
extern __typeof (name) name __asm (__ASMNAME (#alias)); |
| 616 |
# define __LDBL_REDIR_DECL(name) \ |
| 617 |
extern __typeof (name) name __asm (__ASMNAME ("__nldbl_" #name)); |
| 618 |
# define __REDIRECT_LDBL(name, proto, alias) \ |
| 619 |
__LDBL_REDIR1 (name, proto, __nldbl_##alias) |
| 620 |
# define __REDIRECT_NTH_LDBL(name, proto, alias) \ |
| 621 |
__LDBL_REDIR1_NTH (name, proto, __nldbl_##alias) |
| 622 |
# endif |
| 623 |
#endif |
| 624 |
#if (!defined __LDBL_COMPAT && __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI == 0) \ |
| 625 |
|| !defined __REDIRECT |
| 626 |
# define __LDBL_REDIR1(name, proto, alias) name proto |
| 627 |
# define __LDBL_REDIR(name, proto) name proto |
| 628 |
# define __LDBL_REDIR1_NTH(name, proto, alias) name proto __THROW |
| 629 |
# define __LDBL_REDIR_NTH(name, proto) name proto __THROW |
| 630 |
# define __LDBL_REDIR2_DECL(name) |
| 631 |
# define __LDBL_REDIR_DECL(name) |
| 632 |
# ifdef __REDIRECT |
| 633 |
# define __REDIRECT_LDBL(name, proto, alias) __REDIRECT (name, proto, alias) |
| 634 |
# define __REDIRECT_NTH_LDBL(name, proto, alias) \ |
| 635 |
__REDIRECT_NTH (name, proto, alias) |
| 636 |
# endif |
| 637 |
#endif |
| 638 |
|
| 639 |
/* __glibc_macro_warning (MESSAGE) issues warning MESSAGE. This is |
| 640 |
intended for use in preprocessor macros. |
| 641 |
|
| 642 |
Note: MESSAGE must be a _single_ string; concatenation of string |
| 643 |
literals is not supported. */ |
| 644 |
#if __GNUC_PREREQ (4,8) || __glibc_clang_prereq (3,5) |
| 645 |
# define __glibc_macro_warning1(message) _Pragma (#message) |
| 646 |
# define __glibc_macro_warning(message) \ |
| 647 |
__glibc_macro_warning1 (GCC warning message) |
| 648 |
#else |
| 649 |
# define __glibc_macro_warning(msg) |
| 650 |
#endif |
| 651 |
|
| 652 |
/* Generic selection (ISO C11) is a C-only feature, available in GCC |
| 653 |
since version 4.9. Previous versions do not provide generic |
| 654 |
selection, even though they might set __STDC_VERSION__ to 201112L, |
| 655 |
when in -std=c11 mode. Thus, we must check for !defined __GNUC__ |
| 656 |
when testing __STDC_VERSION__ for generic selection support. |
| 657 |
On the other hand, Clang also defines __GNUC__, so a clang-specific |
| 658 |
check is required to enable the use of generic selection. */ |
| 659 |
#if !defined __cplusplus \ |
| 660 |
&& (__GNUC_PREREQ (4, 9) \ |
| 661 |
|| __glibc_has_extension (c_generic_selections) \ |
| 662 |
|| (!defined __GNUC__ && defined __STDC_VERSION__ \ |
| 663 |
&& __STDC_VERSION__ >= 201112L)) |
| 664 |
# define __HAVE_GENERIC_SELECTION 1 |
| 665 |
#else |
| 666 |
# define __HAVE_GENERIC_SELECTION 0 |
| 667 |
#endif |
| 668 |
|
| 669 |
#if __GNUC_PREREQ (10, 0) |
| 670 |
/* Designates a 1-based positional argument ref-index of pointer type |
| 671 |
that can be used to access size-index elements of the pointed-to |
| 672 |
array according to access mode, or at least one element when |
| 673 |
size-index is not provided: |
| 674 |
access (access-mode, <ref-index> [, <size-index>]) */ |
| 675 |
# define __attr_access(x) __attribute__ ((__access__ x)) |
| 676 |
/* For _FORTIFY_SOURCE == 3 we use __builtin_dynamic_object_size, which may |
| 677 |
use the access attribute to get object sizes from function definition |
| 678 |
arguments, so we can't use them on functions we fortify. Drop the object |
| 679 |
size hints for such functions. */ |
| 680 |
# if __USE_FORTIFY_LEVEL == 3 |
| 681 |
# define __fortified_attr_access(a, o, s) __attribute__ ((__access__ (a, o))) |
| 682 |
# else |
| 683 |
# define __fortified_attr_access(a, o, s) __attr_access ((a, o, s)) |
| 684 |
# endif |
| 685 |
# if __GNUC_PREREQ (11, 0) |
| 686 |
# define __attr_access_none(argno) __attribute__ ((__access__ (__none__, argno))) |
| 687 |
# else |
| 688 |
# define __attr_access_none(argno) |
| 689 |
# endif |
| 690 |
#else |
| 691 |
# define __fortified_attr_access(a, o, s) |
| 692 |
# define __attr_access(x) |
| 693 |
# define __attr_access_none(argno) |
| 694 |
#endif |
| 695 |
|
| 696 |
#if __GNUC_PREREQ (11, 0) |
| 697 |
/* Designates dealloc as a function to call to deallocate objects |
| 698 |
allocated by the declared function. */ |
| 699 |
# define __attr_dealloc(dealloc, argno) \ |
| 700 |
__attribute__ ((__malloc__ (dealloc, argno))) |
| 701 |
# define __attr_dealloc_free __attr_dealloc (__builtin_free, 1) |
| 702 |
#else |
| 703 |
# define __attr_dealloc(dealloc, argno) |
| 704 |
# define __attr_dealloc_free |
| 705 |
#endif |
| 706 |
|
| 707 |
/* Specify that a function such as setjmp or vfork may return |
| 708 |
twice. */ |
| 709 |
#if __GNUC_PREREQ (4, 1) |
| 710 |
# define __attribute_returns_twice__ __attribute__ ((__returns_twice__)) |
| 711 |
#else |
| 712 |
# define __attribute_returns_twice__ /* Ignore. */ |
| 713 |
#endif |
| 714 |
|
| 715 |
#endif /* sys/cdefs.h */ |