lib/cdefs.h

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