libstdc++-v3/include/bits/c++config

   1 // Predefined symbols and macros -*- C++ -*-
   2
   3 // Copyright (C) 1997-2023 Free Software Foundation, Inc.
   4 //
   5 // This file is part of the GNU ISO C++ Library.  This library is free
   6 // software; you can redistribute it and/or modify it under the
   7 // terms of the GNU General Public License as published by the
   8 // Free Software Foundation; either version 3, or (at your option)
   9 // any later version.
  10
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15
  16 // Under Section 7 of GPL version 3, you are granted additional
  17 // permissions described in the GCC Runtime Library Exception, version
  18 // 3.1, as published by the Free Software Foundation.
  19
  20 // You should have received a copy of the GNU General Public License and
  21 // a copy of the GCC Runtime Library Exception along with this program;
  22 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  23 // <http://www.gnu.org/licenses/>.
  24
  25 /** @file bits/c++config.h
  26  *  This is an internal header file, included by other library headers.
  27  *  Do not attempt to use it directly. @headername{version}
  28  */
  29
  30 #ifndef _GLIBCXX_CXX_CONFIG_H
  31 #define _GLIBCXX_CXX_CONFIG_H 1
  32
  33 // The major release number for the GCC release the C++ library belongs to.
  34 #define _GLIBCXX_RELEASE
  35
  36 // The datestamp of the C++ library in compressed ISO date format.
  37 #define __GLIBCXX__
  38
  39 // Macros for various attributes.
  40 //   _GLIBCXX_PURE
  41 //   _GLIBCXX_CONST
  42 //   _GLIBCXX_NORETURN
  43 //   _GLIBCXX_NOTHROW
  44 //   _GLIBCXX_VISIBILITY
  45 #ifndef _GLIBCXX_PURE
  46 # define _GLIBCXX_PURE __attribute__ ((__pure__))
  47 #endif
  48
  49 #ifndef _GLIBCXX_CONST
  50 # define _GLIBCXX_CONST __attribute__ ((__const__))
  51 #endif
  52
  53 #ifndef _GLIBCXX_NORETURN
  54 # define _GLIBCXX_NORETURN __attribute__ ((__noreturn__))
  55 #endif
  56
  57 // See below for C++
  58 #ifndef _GLIBCXX_NOTHROW
  59 # ifndef __cplusplus
  60 #  define _GLIBCXX_NOTHROW __attribute__((__nothrow__))
  61 # endif
  62 #endif
  63
  64 // Macros for visibility attributes.
  65 //   _GLIBCXX_HAVE_ATTRIBUTE_VISIBILITY
  66 //   _GLIBCXX_VISIBILITY
  67 #define _GLIBCXX_HAVE_ATTRIBUTE_VISIBILITY
  68
  69 #if _GLIBCXX_HAVE_ATTRIBUTE_VISIBILITY
  70 # define _GLIBCXX_VISIBILITY(V) __attribute__ ((__visibility__ (#V)))
  71 #else
  72 // If this is not supplied by the OS-specific or CPU-specific
  73 // headers included below, it will be defined to an empty default.
  74 # define _GLIBCXX_VISIBILITY(V) _GLIBCXX_PSEUDO_VISIBILITY(V)
  75 #endif
  76
  77 // Macros for deprecated attributes.
  78 //   _GLIBCXX_USE_DEPRECATED
  79 //   _GLIBCXX_DEPRECATED
  80 //   _GLIBCXX_DEPRECATED_SUGGEST( string-literal )
  81 //   _GLIBCXX11_DEPRECATED
  82 //   _GLIBCXX11_DEPRECATED_SUGGEST( string-literal )
  83 //   _GLIBCXX14_DEPRECATED
  84 //   _GLIBCXX14_DEPRECATED_SUGGEST( string-literal )
  85 //   _GLIBCXX17_DEPRECATED
  86 //   _GLIBCXX17_DEPRECATED_SUGGEST( string-literal )
  87 //   _GLIBCXX20_DEPRECATED( string-literal )
  88 //   _GLIBCXX20_DEPRECATED_SUGGEST( string-literal )
  89 #ifndef _GLIBCXX_USE_DEPRECATED
  90 # define _GLIBCXX_USE_DEPRECATED 1
  91 #endif
  92
  93 #if defined(__DEPRECATED)
  94 # define _GLIBCXX_DEPRECATED __attribute__ ((__deprecated__))
  95 # define _GLIBCXX_DEPRECATED_SUGGEST(ALT) \
  96   __attribute__ ((__deprecated__ ("use '" ALT "' instead")))
  97 #else
  98 # define _GLIBCXX_DEPRECATED
  99 # define _GLIBCXX_DEPRECATED_SUGGEST(ALT)
 100 #endif
 101
 102 #if defined(__DEPRECATED) && (__cplusplus >= 201103L)
 103 # define _GLIBCXX11_DEPRECATED _GLIBCXX_DEPRECATED
 104 # define _GLIBCXX11_DEPRECATED_SUGGEST(ALT) _GLIBCXX_DEPRECATED_SUGGEST(ALT)
 105 #else
 106 # define _GLIBCXX11_DEPRECATED
 107 # define _GLIBCXX11_DEPRECATED_SUGGEST(ALT)
 108 #endif
 109
 110 #if defined(__DEPRECATED) && (__cplusplus >= 201402L)
 111 # define _GLIBCXX14_DEPRECATED _GLIBCXX_DEPRECATED
 112 # define _GLIBCXX14_DEPRECATED_SUGGEST(ALT) _GLIBCXX_DEPRECATED_SUGGEST(ALT)
 113 #else
 114 # define _GLIBCXX14_DEPRECATED
 115 # define _GLIBCXX14_DEPRECATED_SUGGEST(ALT)
 116 #endif
 117
 118 #if defined(__DEPRECATED) && (__cplusplus >= 201703L)
 119 # define _GLIBCXX17_DEPRECATED [[__deprecated__]]
 120 # define _GLIBCXX17_DEPRECATED_SUGGEST(ALT) _GLIBCXX_DEPRECATED_SUGGEST(ALT)
 121 #else
 122 # define _GLIBCXX17_DEPRECATED
 123 # define _GLIBCXX17_DEPRECATED_SUGGEST(ALT)
 124 #endif
 125
 126 #if defined(__DEPRECATED) && (__cplusplus >= 202002L)
 127 # define _GLIBCXX20_DEPRECATED(MSG) [[deprecated(MSG)]]
 128 # define _GLIBCXX20_DEPRECATED_SUGGEST(ALT) _GLIBCXX_DEPRECATED_SUGGEST(ALT)
 129 #else
 130 # define _GLIBCXX20_DEPRECATED(MSG)
 131 # define _GLIBCXX20_DEPRECATED_SUGGEST(ALT)
 132 #endif
 133
 134 // Macros for ABI tag attributes.
 135 #ifndef _GLIBCXX_ABI_TAG_CXX11
 136 # define _GLIBCXX_ABI_TAG_CXX11 __attribute ((__abi_tag__ ("cxx11")))
 137 #endif
 138
 139 // Macro to warn about unused results.
 140 #if __cplusplus >= 201703L
 141 # define _GLIBCXX_NODISCARD [[__nodiscard__]]
 142 #else
 143 # define _GLIBCXX_NODISCARD
 144 #endif
 145
 146
 147
 148 #if __cplusplus
 149
 150 // Macro for constexpr, to support in mixed 03/0x mode.
 151 #ifndef _GLIBCXX_CONSTEXPR
 152 # if __cplusplus >= 201103L
 153 #  define _GLIBCXX_CONSTEXPR constexpr
 154 #  define _GLIBCXX_USE_CONSTEXPR constexpr
 155 # else
 156 #  define _GLIBCXX_CONSTEXPR
 157 #  define _GLIBCXX_USE_CONSTEXPR const
 158 # endif
 159 #endif
 160
 161 #ifndef _GLIBCXX14_CONSTEXPR
 162 # if __cplusplus >= 201402L
 163 #  define _GLIBCXX14_CONSTEXPR constexpr
 164 # else
 165 #  define _GLIBCXX14_CONSTEXPR
 166 # endif
 167 #endif
 168
 169 #ifndef _GLIBCXX17_CONSTEXPR
 170 # if __cplusplus >= 201703L
 171 #  define _GLIBCXX17_CONSTEXPR constexpr
 172 # else
 173 #  define _GLIBCXX17_CONSTEXPR
 174 # endif
 175 #endif
 176
 177 #ifndef _GLIBCXX20_CONSTEXPR
 178 # if __cplusplus >= 202002L
 179 #  define _GLIBCXX20_CONSTEXPR constexpr
 180 # else
 181 #  define _GLIBCXX20_CONSTEXPR
 182 # endif
 183 #endif
 184
 185 #ifndef _GLIBCXX23_CONSTEXPR
 186 # if __cplusplus >= 202100L
 187 #  define _GLIBCXX23_CONSTEXPR constexpr
 188 # else
 189 #  define _GLIBCXX23_CONSTEXPR
 190 # endif
 191 #endif
 192
 193 #ifndef _GLIBCXX17_INLINE
 194 # if __cplusplus >= 201703L
 195 #  define _GLIBCXX17_INLINE inline
 196 # else
 197 #  define _GLIBCXX17_INLINE
 198 # endif
 199 #endif
 200
 201 // Macro for noexcept, to support in mixed 03/0x mode.
 202 #ifndef _GLIBCXX_NOEXCEPT
 203 # if __cplusplus >= 201103L
 204 #  define _GLIBCXX_NOEXCEPT noexcept
 205 #  define _GLIBCXX_NOEXCEPT_IF(...) noexcept(__VA_ARGS__)
 206 #  define _GLIBCXX_USE_NOEXCEPT noexcept
 207 #  define _GLIBCXX_THROW(_EXC)
 208 # else
 209 #  define _GLIBCXX_NOEXCEPT
 210 #  define _GLIBCXX_NOEXCEPT_IF(...)
 211 #  define _GLIBCXX_USE_NOEXCEPT throw()
 212 #  define _GLIBCXX_THROW(_EXC) throw(_EXC)
 213 # endif
 214 #endif
 215
 216 #ifndef _GLIBCXX_NOTHROW
 217 # define _GLIBCXX_NOTHROW _GLIBCXX_USE_NOEXCEPT
 218 #endif
 219
 220 #ifndef _GLIBCXX_THROW_OR_ABORT
 221 # if __cpp_exceptions
 222 #  define _GLIBCXX_THROW_OR_ABORT(_EXC) (throw (_EXC))
 223 # else
 224 #  define _GLIBCXX_THROW_OR_ABORT(_EXC) (__builtin_abort())
 225 # endif
 226 #endif
 227
 228 #if __cpp_noexcept_function_type
 229 #define _GLIBCXX_NOEXCEPT_PARM , bool _NE
 230 #define _GLIBCXX_NOEXCEPT_QUAL noexcept (_NE)
 231 #else
 232 #define _GLIBCXX_NOEXCEPT_PARM
 233 #define _GLIBCXX_NOEXCEPT_QUAL
 234 #endif
 235
 236 // Macro for extern template, ie controlling template linkage via use
 237 // of extern keyword on template declaration. As documented in the g++
 238 // manual, it inhibits all implicit instantiations and is used
 239 // throughout the library to avoid multiple weak definitions for
 240 // required types that are already explicitly instantiated in the
 241 // library binary. This substantially reduces the binary size of
 242 // resulting executables.
 243 // Special case: _GLIBCXX_EXTERN_TEMPLATE == -1 disallows extern
 244 // templates only in basic_string, thus activating its debug-mode
 245 // checks even at -O0.
 246 #define _GLIBCXX_EXTERN_TEMPLATE
 247
 248 /*
 249   Outline of libstdc++ namespaces.
 250
 251   namespace std
 252   {
 253     namespace __debug { }
 254     namespace __parallel { }
 255     namespace __cxx1998 { }
 256
 257     namespace __detail {
 258       namespace __variant { }                           // C++17
 259     }
 260
 261     namespace rel_ops { }
 262
 263     namespace tr1
 264     {
 265       namespace placeholders { }
 266       namespace regex_constants { }
 267       namespace __detail { }
 268     }
 269
 270     namespace tr2 { }
 271
 272     namespace decimal { }
 273
 274     namespace chrono { }                                // C++11
 275     namespace placeholders { }                          // C++11
 276     namespace regex_constants { }                       // C++11
 277     namespace this_thread { }                           // C++11
 278     inline namespace literals {                         // C++14
 279       inline namespace chrono_literals { }              // C++14
 280       inline namespace complex_literals { }             // C++14
 281       inline namespace string_literals { }              // C++14
 282       inline namespace string_view_literals { }         // C++17
 283     }
 284   }
 285
 286   namespace abi { }
 287
 288   namespace __gnu_cxx
 289   {
 290     namespace __detail { }
 291   }
 292
 293   For full details see:
 294   http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/namespaces.html
 295 */
 296 namespace std
 297 {
 298   typedef __SIZE_TYPE__         size_t;
 299   typedef __PTRDIFF_TYPE__      ptrdiff_t;
 300
 301 #if __cplusplus >= 201103L
 302   typedef decltype(nullptr)     nullptr_t;
 303 #endif
 304
 305 #pragma GCC visibility push(default)
 306   // This allows the library to terminate without including all of <exception>
 307   // and without making the declaration of std::terminate visible to users.
 308   extern "C++" __attribute__ ((__noreturn__, __always_inline__))
 309   inline void __terminate() _GLIBCXX_USE_NOEXCEPT
 310   {
 311     void terminate() _GLIBCXX_USE_NOEXCEPT __attribute__ ((__noreturn__));
 312     terminate();
 313   }
 314 #pragma GCC visibility pop
 315 }
 316
 317 #define _GLIBCXX_USE_DUAL_ABI
 318
 319 #if ! _GLIBCXX_USE_DUAL_ABI
 320 // Ignore any pre-defined value of _GLIBCXX_USE_CXX11_ABI
 321 # undef _GLIBCXX_USE_CXX11_ABI
 322 #endif
 323
 324 #ifndef _GLIBCXX_USE_CXX11_ABI
 325 #define _GLIBCXX_USE_CXX11_ABI
 326 #endif
 327
 328 #if _GLIBCXX_USE_CXX11_ABI
 329 namespace std
 330 {
 331   inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { }
 332 }
 333 namespace __gnu_cxx
 334 {
 335   inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { }
 336 }
 337 # define _GLIBCXX_NAMESPACE_CXX11 __cxx11::
 338 # define _GLIBCXX_BEGIN_NAMESPACE_CXX11 namespace __cxx11 {
 339 # define _GLIBCXX_END_NAMESPACE_CXX11 }
 340 # define _GLIBCXX_DEFAULT_ABI_TAG _GLIBCXX_ABI_TAG_CXX11
 341 #else
 342 # define _GLIBCXX_NAMESPACE_CXX11
 343 # define _GLIBCXX_BEGIN_NAMESPACE_CXX11
 344 # define _GLIBCXX_END_NAMESPACE_CXX11
 345 # define _GLIBCXX_DEFAULT_ABI_TAG
 346 #endif
 347
 348 // Non-zero if inline namespaces are used for versioning the entire library.
 349 #define _GLIBCXX_INLINE_VERSION
 350
 351 #if _GLIBCXX_INLINE_VERSION
 352 // Inline namespace for symbol versioning of (nearly) everything in std.
 353 # define _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace __8 {
 354 # define _GLIBCXX_END_NAMESPACE_VERSION }
 355 // Unused when everything in std is versioned anyway.
 356 # define _GLIBCXX_BEGIN_INLINE_ABI_NAMESPACE(X)
 357 # define _GLIBCXX_END_INLINE_ABI_NAMESPACE(X)
 358
 359 namespace std
 360 {
 361 inline _GLIBCXX_BEGIN_NAMESPACE_VERSION
 362 #if __cplusplus >= 201402L
 363   inline namespace literals {
 364     inline namespace chrono_literals { }
 365     inline namespace complex_literals { }
 366     inline namespace string_literals { }
 367 #if __cplusplus > 201402L
 368     inline namespace string_view_literals { }
 369 #endif // C++17
 370   }
 371 #endif // C++14
 372 _GLIBCXX_END_NAMESPACE_VERSION
 373 }
 374
 375 namespace __gnu_cxx
 376 {
 377 inline _GLIBCXX_BEGIN_NAMESPACE_VERSION
 378 _GLIBCXX_END_NAMESPACE_VERSION
 379 }
 380
 381 #else
 382 // Unused.
 383 # define _GLIBCXX_BEGIN_NAMESPACE_VERSION
 384 # define _GLIBCXX_END_NAMESPACE_VERSION
 385 // Used to version individual components, e.g. std::_V2::error_category.
 386 # define _GLIBCXX_BEGIN_INLINE_ABI_NAMESPACE(X) inline namespace X {
 387 # define _GLIBCXX_END_INLINE_ABI_NAMESPACE(X)   } // inline namespace X
 388 #endif
 389
 390 // Inline namespaces for special modes: debug, parallel.
 391 #if defined(_GLIBCXX_DEBUG) || defined(_GLIBCXX_PARALLEL)
 392 namespace std
 393 {
 394 _GLIBCXX_BEGIN_NAMESPACE_VERSION
 395
 396   // Non-inline namespace for components replaced by alternates in active mode.
 397   namespace __cxx1998
 398   {
 399 # if _GLIBCXX_USE_CXX11_ABI
 400   inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { }
 401 # endif
 402   }
 403
 404 _GLIBCXX_END_NAMESPACE_VERSION
 405
 406   // Inline namespace for debug mode.
 407 # ifdef _GLIBCXX_DEBUG
 408   inline namespace __debug { }
 409 # endif
 410
 411   // Inline namespaces for parallel mode.
 412 # ifdef _GLIBCXX_PARALLEL
 413   inline namespace __parallel { }
 414 # endif
 415 }
 416
 417 // Check for invalid usage and unsupported mixed-mode use.
 418 # if defined(_GLIBCXX_DEBUG) && defined(_GLIBCXX_PARALLEL)
 419 #  error illegal use of multiple inlined namespaces
 420 # endif
 421
 422 // Check for invalid use due to lack for weak symbols.
 423 # if __NO_INLINE__ && !__GXX_WEAK__
 424 #  warning currently using inlined namespace mode which may fail \
 425    without inlining due to lack of weak symbols
 426 # endif
 427 #endif
 428
 429 // Macros for namespace scope. Either namespace std:: or the name
 430 // of some nested namespace within it corresponding to the active mode.
 431 // _GLIBCXX_STD_A
 432 // _GLIBCXX_STD_C
 433 //
 434 // Macros for opening/closing conditional namespaces.
 435 // _GLIBCXX_BEGIN_NAMESPACE_ALGO
 436 // _GLIBCXX_END_NAMESPACE_ALGO
 437 // _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
 438 // _GLIBCXX_END_NAMESPACE_CONTAINER
 439 #if defined(_GLIBCXX_DEBUG)
 440 # define _GLIBCXX_STD_C __cxx1998
 441 # define _GLIBCXX_BEGIN_NAMESPACE_CONTAINER \
 442          namespace _GLIBCXX_STD_C {
 443 # define _GLIBCXX_END_NAMESPACE_CONTAINER }
 444 #else
 445 # define _GLIBCXX_STD_C std
 446 # define _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
 447 # define _GLIBCXX_END_NAMESPACE_CONTAINER
 448 #endif
 449
 450 #ifdef _GLIBCXX_PARALLEL
 451 # define _GLIBCXX_STD_A __cxx1998
 452 # define _GLIBCXX_BEGIN_NAMESPACE_ALGO \
 453          namespace _GLIBCXX_STD_A {
 454 # define _GLIBCXX_END_NAMESPACE_ALGO }
 455 #else
 456 # define _GLIBCXX_STD_A std
 457 # define _GLIBCXX_BEGIN_NAMESPACE_ALGO
 458 # define _GLIBCXX_END_NAMESPACE_ALGO
 459 #endif
 460
 461 // GLIBCXX_ABI Deprecated
 462 // Define if compatibility should be provided for -mlong-double-64.
 463 #undef _GLIBCXX_LONG_DOUBLE_COMPAT
 464
 465 // Define if compatibility should be provided for alternative 128-bit long
 466 // double formats. Not possible for Clang until __ibm128 is supported.
 467 #ifndef __clang__
 468 #undef _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT
 469 #endif
 470
 471 // Inline namespaces for long double 128 modes.
 472 #if defined _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT \
 473   && defined __LONG_DOUBLE_IEEE128__
 474 namespace std
 475 {
 476   // Namespaces for 128-bit IEEE long double format on 64-bit POWER LE.
 477   inline namespace __gnu_cxx_ieee128 { }
 478   inline namespace __gnu_cxx11_ieee128 { }
 479 }
 480 # define _GLIBCXX_NAMESPACE_LDBL __gnu_cxx_ieee128::
 481 # define _GLIBCXX_BEGIN_NAMESPACE_LDBL namespace __gnu_cxx_ieee128 {
 482 # define _GLIBCXX_END_NAMESPACE_LDBL }
 483 # define _GLIBCXX_NAMESPACE_LDBL_OR_CXX11 __gnu_cxx11_ieee128::
 484 # define _GLIBCXX_BEGIN_NAMESPACE_LDBL_OR_CXX11 namespace __gnu_cxx11_ieee128 {
 485 # define _GLIBCXX_END_NAMESPACE_LDBL_OR_CXX11 }
 486
 487 #else // _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT && IEEE128
 488
 489 #if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__
 490 namespace std
 491 {
 492   inline namespace __gnu_cxx_ldbl128 { }
 493 }
 494 # define _GLIBCXX_NAMESPACE_LDBL __gnu_cxx_ldbl128::
 495 # define _GLIBCXX_BEGIN_NAMESPACE_LDBL namespace __gnu_cxx_ldbl128 {
 496 # define _GLIBCXX_END_NAMESPACE_LDBL }
 497 #else
 498 # define _GLIBCXX_NAMESPACE_LDBL
 499 # define _GLIBCXX_BEGIN_NAMESPACE_LDBL
 500 # define _GLIBCXX_END_NAMESPACE_LDBL
 501 #endif
 502
 503 #if _GLIBCXX_USE_CXX11_ABI
 504 # define _GLIBCXX_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_NAMESPACE_CXX11
 505 # define _GLIBCXX_BEGIN_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_BEGIN_NAMESPACE_CXX11
 506 # define _GLIBCXX_END_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_END_NAMESPACE_CXX11
 507 #else
 508 # define _GLIBCXX_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_NAMESPACE_LDBL
 509 # define _GLIBCXX_BEGIN_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_BEGIN_NAMESPACE_LDBL
 510 # define _GLIBCXX_END_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_END_NAMESPACE_LDBL
 511 #endif
 512
 513 #endif // _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT && IEEE128
 514
 515 namespace std
 516 {
 517 #pragma GCC visibility push(default)
 518   // Internal version of std::is_constant_evaluated().
 519   // This can be used without checking if the compiler supports the feature.
 520   // The macro _GLIBCXX_HAVE_IS_CONSTANT_EVALUATED can be used to check if
 521   // the compiler support is present to make this function work as expected.
 522   _GLIBCXX_CONSTEXPR inline bool
 523   __is_constant_evaluated() _GLIBCXX_NOEXCEPT
 524   {
 525 #if __cpp_if_consteval >= 202106L
 526 # define _GLIBCXX_HAVE_IS_CONSTANT_EVALUATED 1
 527     if consteval { return true; } else { return false; }
 528 #elif __cplusplus >= 201103L && __has_builtin(__builtin_is_constant_evaluated)
 529 # define _GLIBCXX_HAVE_IS_CONSTANT_EVALUATED 1
 530     return __builtin_is_constant_evaluated();
 531 #else
 532     return false;
 533 #endif
 534   }
 535 #pragma GCC visibility pop
 536 }
 537
 538 // Debug Mode implies checking assertions.
 539 #if defined(_GLIBCXX_DEBUG) && !defined(_GLIBCXX_ASSERTIONS)
 540 # define _GLIBCXX_ASSERTIONS 1
 541 #endif
 542
 543 // Disable std::string explicit instantiation declarations in order to assert.
 544 #ifdef _GLIBCXX_ASSERTIONS
 545 # undef _GLIBCXX_EXTERN_TEMPLATE
 546 # define _GLIBCXX_EXTERN_TEMPLATE -1
 547 #endif
 548
 549
 550 #if _GLIBCXX_HAVE_IS_CONSTANT_EVALUATED
 551 # define __glibcxx_constexpr_assert(cond) \
 552   if (std::__is_constant_evaluated() && !bool(cond))    \
 553     __builtin_unreachable() /* precondition violation detected! */
 554 #else
 555 # define __glibcxx_constexpr_assert(unevaluated)
 556 #endif
 557
 558 #undef _GLIBCXX_VERBOSE_ASSERT
 559
 560 // Assert.
 561 #if defined(_GLIBCXX_ASSERTIONS) \
 562   || defined(_GLIBCXX_PARALLEL) || defined(_GLIBCXX_PARALLEL_ASSERTIONS)
 563 # ifdef _GLIBCXX_VERBOSE_ASSERT
 564 namespace std
 565 {
 566 #pragma GCC visibility push(default)
 567   // Avoid the use of assert, because we're trying to keep the <cassert>
 568   // include out of the mix.
 569   extern "C++" _GLIBCXX_NORETURN
 570   void
 571   __glibcxx_assert_fail(const char* __file, int __line,
 572                         const char* __function, const char* __condition)
 573   _GLIBCXX_NOEXCEPT;
 574 #pragma GCC visibility pop
 575 }
 576 #define __glibcxx_assert_impl(_Condition)                               \
 577   if (__builtin_expect(!bool(_Condition), false))                       \
 578   {                                                                     \
 579     __glibcxx_constexpr_assert(false);                                  \
 580     std::__glibcxx_assert_fail(__FILE__, __LINE__, __PRETTY_FUNCTION__, \
 581                                #_Condition);                            \
 582   }
 583 # else // ! VERBOSE_ASSERT
 584 # define __glibcxx_assert_impl(_Condition)              \
 585   if (__builtin_expect(!bool(_Condition), false))       \
 586   {                                                     \
 587     __glibcxx_constexpr_assert(false);                  \
 588     __builtin_abort();                                  \
 589   }
 590 # endif
 591 #endif
 592
 593 #if defined(_GLIBCXX_ASSERTIONS)
 594 # define __glibcxx_assert(cond) \
 595   do { __glibcxx_assert_impl(cond); } while (false)
 596 #else
 597 # define __glibcxx_assert(cond) \
 598   do { __glibcxx_constexpr_assert(cond); } while (false)
 599 #endif
 600
 601 // Macro indicating that TSAN is in use.
 602 #if __SANITIZE_THREAD__
 603 #  define _GLIBCXX_TSAN 1
 604 #elif defined __has_feature
 605 # if __has_feature(thread_sanitizer)
 606 #  define _GLIBCXX_TSAN 1
 607 # endif
 608 #endif
 609
 610 // Macros for race detectors.
 611 // _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(A) and
 612 // _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(A) should be used to explain
 613 // atomic (lock-free) synchronization to race detectors:
 614 // the race detector will infer a happens-before arc from the former to the
 615 // latter when they share the same argument pointer.
 616 //
 617 // The most frequent use case for these macros (and the only case in the
 618 // current implementation of the library) is atomic reference counting:
 619 //   void _M_remove_reference()
 620 //   {
 621 //     _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&this->_M_refcount);
 622 //     if (__gnu_cxx::__exchange_and_add_dispatch(&this->_M_refcount, -1) <= 0)
 623 //       {
 624 //         _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&this->_M_refcount);
 625 //         _M_destroy(__a);
 626 //       }
 627 //   }
 628 // The annotations in this example tell the race detector that all memory
 629 // accesses occurred when the refcount was positive do not race with
 630 // memory accesses which occurred after the refcount became zero.
 631 #ifndef _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE
 632 # define  _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(A)
 633 #endif
 634 #ifndef _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER
 635 # define  _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(A)
 636 #endif
 637
 638 // Macros for C linkage: define extern "C" linkage only when using C++.
 639 # define _GLIBCXX_BEGIN_EXTERN_C extern "C" {
 640 # define _GLIBCXX_END_EXTERN_C }
 641
 642 #define _GLIBCXX_USE_ALLOCATOR_NEW
 643
 644 #ifdef __SIZEOF_INT128__
 645 #if ! defined __GLIBCXX_TYPE_INT_N_0 && ! defined __STRICT_ANSI__
 646 // If __int128 is supported, we expect __GLIBCXX_TYPE_INT_N_0 to be defined
 647 // unless the compiler is in strict mode. If it's not defined and the strict
 648 // macro is not defined, something is wrong.
 649 #warning "__STRICT_ANSI__ seems to have been undefined; this is not supported"
 650 #endif
 651 #endif
 652
 653 #else // !__cplusplus
 654 # define _GLIBCXX_BEGIN_EXTERN_C
 655 # define _GLIBCXX_END_EXTERN_C
 656 #endif
 657
 658
 659 // First includes.
 660
 661 // Pick up any OS-specific definitions.
 662 #include <bits/os_defines.h>
 663
 664 // Pick up any CPU-specific definitions.
 665 #include <bits/cpu_defines.h>
 666
 667 // If platform uses neither visibility nor psuedo-visibility,
 668 // specify empty default for namespace annotation macros.
 669 #ifndef _GLIBCXX_PSEUDO_VISIBILITY
 670 # define _GLIBCXX_PSEUDO_VISIBILITY(V)
 671 #endif
 672
 673 // Certain function definitions that are meant to be overridable from
 674 // user code are decorated with this macro.  For some targets, this
 675 // macro causes these definitions to be weak.
 676 #ifndef _GLIBCXX_WEAK_DEFINITION
 677 # define _GLIBCXX_WEAK_DEFINITION
 678 #endif
 679
 680 // By default, we assume that __GXX_WEAK__ also means that there is support
 681 // for declaring functions as weak while not defining such functions.  This
 682 // allows for referring to functions provided by other libraries (e.g.,
 683 // libitm) without depending on them if the respective features are not used.
 684 #ifndef _GLIBCXX_USE_WEAK_REF
 685 # define _GLIBCXX_USE_WEAK_REF __GXX_WEAK__
 686 #endif
 687
 688 // Conditionally enable annotations for the Transactional Memory TS on C++11.
 689 // Most of the following conditions are due to limitations in the current
 690 // implementation.
 691 #if __cplusplus >= 201103L && _GLIBCXX_USE_CXX11_ABI                    \
 692   && _GLIBCXX_USE_DUAL_ABI && __cpp_transactional_memory >= 201500L     \
 693   &&  !_GLIBCXX_FULLY_DYNAMIC_STRING && _GLIBCXX_USE_WEAK_REF           \
 694   && _GLIBCXX_USE_ALLOCATOR_NEW
 695 #define _GLIBCXX_TXN_SAFE transaction_safe
 696 #define _GLIBCXX_TXN_SAFE_DYN transaction_safe_dynamic
 697 #else
 698 #define _GLIBCXX_TXN_SAFE
 699 #define _GLIBCXX_TXN_SAFE_DYN
 700 #endif
 701
 702 #if __cplusplus > 201402L
 703 // In C++17 mathematical special functions are in namespace std.
 704 # define _GLIBCXX_USE_STD_SPEC_FUNCS 1
 705 #elif __cplusplus >= 201103L && __STDCPP_WANT_MATH_SPEC_FUNCS__ != 0
 706 // For C++11 and C++14 they are in namespace std when requested.
 707 # define _GLIBCXX_USE_STD_SPEC_FUNCS 1
 708 #endif
 709
 710 // The remainder of the prewritten config is automatic; all the
 711 // user hooks are listed above.
 712
 713 // Create a boolean flag to be used to determine if --fast-math is set.
 714 #ifdef __FAST_MATH__
 715 # define _GLIBCXX_FAST_MATH 1
 716 #else
 717 # define _GLIBCXX_FAST_MATH 0
 718 #endif
 719
 720 // This marks string literals in header files to be extracted for eventual
 721 // translation.  It is primarily used for messages in thrown exceptions; see
 722 // src/functexcept.cc.  We use __N because the more traditional _N is used
 723 // for something else under certain OSes (see BADNAMES).
 724 #define __N(msgid)     (msgid)
 725
 726 // For example, <windows.h> is known to #define min and max as macros...
 727 #undef min
 728 #undef max
 729
 730 // N.B. these _GLIBCXX_USE_C99_XXX macros are defined unconditionally
 731 // so they should be tested with #if not with #ifdef.
 732 #if __cplusplus >= 201103L
 733 # ifndef _GLIBCXX_USE_C99_MATH
 734 #  define _GLIBCXX_USE_C99_MATH _GLIBCXX11_USE_C99_MATH
 735 # endif
 736 # ifndef _GLIBCXX_USE_C99_COMPLEX
 737 # define _GLIBCXX_USE_C99_COMPLEX _GLIBCXX11_USE_C99_COMPLEX
 738 # endif
 739 # ifndef _GLIBCXX_USE_C99_STDIO
 740 # define _GLIBCXX_USE_C99_STDIO _GLIBCXX11_USE_C99_STDIO
 741 # endif
 742 # ifndef _GLIBCXX_USE_C99_STDLIB
 743 # define _GLIBCXX_USE_C99_STDLIB _GLIBCXX11_USE_C99_STDLIB
 744 # endif
 745 # ifndef _GLIBCXX_USE_C99_WCHAR
 746 # define _GLIBCXX_USE_C99_WCHAR _GLIBCXX11_USE_C99_WCHAR
 747 # endif
 748 #else
 749 # ifndef _GLIBCXX_USE_C99_MATH
 750 #  define _GLIBCXX_USE_C99_MATH _GLIBCXX98_USE_C99_MATH
 751 # endif
 752 # ifndef _GLIBCXX_USE_C99_COMPLEX
 753 # define _GLIBCXX_USE_C99_COMPLEX _GLIBCXX98_USE_C99_COMPLEX
 754 # endif
 755 # ifndef _GLIBCXX_USE_C99_STDIO
 756 # define _GLIBCXX_USE_C99_STDIO _GLIBCXX98_USE_C99_STDIO
 757 # endif
 758 # ifndef _GLIBCXX_USE_C99_STDLIB
 759 # define _GLIBCXX_USE_C99_STDLIB _GLIBCXX98_USE_C99_STDLIB
 760 # endif
 761 # ifndef _GLIBCXX_USE_C99_WCHAR
 762 # define _GLIBCXX_USE_C99_WCHAR _GLIBCXX98_USE_C99_WCHAR
 763 # endif
 764 #endif
 765
 766 // Unless explicitly specified, enable char8_t extensions only if the core
 767 // language char8_t feature macro is defined.
 768 #ifndef _GLIBCXX_USE_CHAR8_T
 769 # ifdef __cpp_char8_t
 770 #  define _GLIBCXX_USE_CHAR8_T 1
 771 # endif
 772 #endif
 773 #ifdef _GLIBCXX_USE_CHAR8_T
 774 # define __cpp_lib_char8_t 201907L
 775 #endif
 776
 777 /* Define if __float128 is supported on this host.  */
 778 #if defined(__FLOAT128__) || defined(__SIZEOF_FLOAT128__)
 779 /* For powerpc64 don't use __float128 when it's the same type as long double. */
 780 # if !(defined(_GLIBCXX_LONG_DOUBLE_ALT128_COMPAT) && defined(__LONG_DOUBLE_IEEE128__))
 781 #  define _GLIBCXX_USE_FLOAT128
 782 # endif
 783 #endif
 784
 785 // Define if float has the IEEE binary32 format.
 786 #if __FLT_MANT_DIG__ == 24 \
 787   && __FLT_MIN_EXP__ == -125 \
 788   && __FLT_MAX_EXP__ == 128
 789 # define _GLIBCXX_FLOAT_IS_IEEE_BINARY32 1
 790 #endif
 791
 792 // Define if double has the IEEE binary64 format.
 793 #if __DBL_MANT_DIG__ == 53 \
 794   && __DBL_MIN_EXP__ == -1021 \
 795   && __DBL_MAX_EXP__ == 1024
 796 # define _GLIBCXX_DOUBLE_IS_IEEE_BINARY64 1
 797 #endif
 798
 799 // Define if long double has the IEEE binary128 format.
 800 #if __LDBL_MANT_DIG__ == 113 \
 801   && __LDBL_MIN_EXP__ == -16381 \
 802   && __LDBL_MAX_EXP__ == 16384
 803 # define _GLIBCXX_LDOUBLE_IS_IEEE_BINARY128 1
 804 #endif
 805
 806 #ifdef __STDCPP_BFLOAT16_T__
 807 namespace __gnu_cxx
 808 {
 809   using __bfloat16_t = decltype(0.0bf16);
 810 }
 811 #endif
 812
 813 #ifdef __has_builtin
 814 # ifdef __is_identifier
 815 // Intel and older Clang require !__is_identifier for some built-ins:
 816 #  define _GLIBCXX_HAS_BUILTIN(B) __has_builtin(B) || ! __is_identifier(B)
 817 # else
 818 #  define _GLIBCXX_HAS_BUILTIN(B) __has_builtin(B)
 819 # endif
 820 #endif
 821
 822 #if _GLIBCXX_HAS_BUILTIN(__has_unique_object_representations)
 823 # define _GLIBCXX_HAVE_BUILTIN_HAS_UNIQ_OBJ_REP 1
 824 #endif
 825
 826 #if _GLIBCXX_HAS_BUILTIN(__is_aggregate)
 827 # define _GLIBCXX_HAVE_BUILTIN_IS_AGGREGATE 1
 828 #endif
 829
 830 #if _GLIBCXX_HAS_BUILTIN(__is_same)
 831 #  define _GLIBCXX_HAVE_BUILTIN_IS_SAME 1
 832 #endif
 833
 834 #if _GLIBCXX_HAS_BUILTIN(__builtin_launder)
 835 # define _GLIBCXX_HAVE_BUILTIN_LAUNDER 1
 836 #endif
 837
 838 #undef _GLIBCXX_HAS_BUILTIN
 839
 840 // Mark code that should be ignored by the compiler, but seen by Doxygen.
 841 #define _GLIBCXX_DOXYGEN_ONLY(X)
 842
 843 // PSTL configuration
 844
 845 #if __cplusplus >= 201703L
 846 // This header is not installed for freestanding:
 847 #if __has_include(<pstl/pstl_config.h>)
 848 // Preserved here so we have some idea which version of upstream we've pulled in
 849 // #define PSTL_VERSION 9000
 850
 851 // For now this defaults to being based on the presence of Thread Building Blocks
 852 # ifndef _GLIBCXX_USE_TBB_PAR_BACKEND
 853 #  define _GLIBCXX_USE_TBB_PAR_BACKEND __has_include(<tbb/tbb.h>)
 854 # endif
 855 // This section will need some rework when a new (default) backend type is added
 856 # if _GLIBCXX_USE_TBB_PAR_BACKEND
 857 #  define _PSTL_PAR_BACKEND_TBB
 858 # else
 859 #  define _PSTL_PAR_BACKEND_SERIAL
 860 # endif
 861
 862 # define _PSTL_ASSERT(_Condition) __glibcxx_assert(_Condition)
 863 # define _PSTL_ASSERT_MSG(_Condition, _Message) __glibcxx_assert(_Condition)
 864
 865 #include <pstl/pstl_config.h>
 866 #endif // __has_include
 867 #endif // C++17
 868
 869 // End of prewritten config; the settings discovered at configure time follow.