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

   1 // Predefined symbols and macros -*- C++ -*-
   2
   3 // Copyright (C) 1997-2018 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{iosfwd}
  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 //   _GLIBCXX17_DEPRECATED
  81 #ifndef _GLIBCXX_USE_DEPRECATED
  82 # define _GLIBCXX_USE_DEPRECATED 1
  83 #endif
  84
  85 #if defined(__DEPRECATED) && (__cplusplus >= 201103L)
  86 # define _GLIBCXX_DEPRECATED __attribute__ ((__deprecated__))
  87 #else
  88 # define _GLIBCXX_DEPRECATED
  89 #endif
  90
  91 #if defined(__DEPRECATED) && (__cplusplus >= 201703L)
  92 # define _GLIBCXX17_DEPRECATED [[__deprecated__]]
  93 #else
  94 # define _GLIBCXX17_DEPRECATED
  95 #endif
  96
  97 // Macros for ABI tag attributes.
  98 #ifndef _GLIBCXX_ABI_TAG_CXX11
  99 # define _GLIBCXX_ABI_TAG_CXX11 __attribute ((__abi_tag__ ("cxx11")))
 100 #endif
 101
 102
 103 #if __cplusplus
 104
 105 // Macro for constexpr, to support in mixed 03/0x mode.
 106 #ifndef _GLIBCXX_CONSTEXPR
 107 # if __cplusplus >= 201103L
 108 #  define _GLIBCXX_CONSTEXPR constexpr
 109 #  define _GLIBCXX_USE_CONSTEXPR constexpr
 110 # else
 111 #  define _GLIBCXX_CONSTEXPR
 112 #  define _GLIBCXX_USE_CONSTEXPR const
 113 # endif
 114 #endif
 115
 116 #ifndef _GLIBCXX14_CONSTEXPR
 117 # if __cplusplus >= 201402L
 118 #  define _GLIBCXX14_CONSTEXPR constexpr
 119 # else
 120 #  define _GLIBCXX14_CONSTEXPR
 121 # endif
 122 #endif
 123
 124 #ifndef _GLIBCXX17_CONSTEXPR
 125 # if __cplusplus >= 201703L
 126 #  define _GLIBCXX17_CONSTEXPR constexpr
 127 # else
 128 #  define _GLIBCXX17_CONSTEXPR
 129 # endif
 130 #endif
 131
 132 #ifndef _GLIBCXX20_CONSTEXPR
 133 # if __cplusplus > 201703L
 134 #  define _GLIBCXX20_CONSTEXPR constexpr
 135 # else
 136 #  define _GLIBCXX20_CONSTEXPR
 137 # endif
 138 #endif
 139
 140 #ifndef _GLIBCXX17_INLINE
 141 # if __cplusplus >= 201703L
 142 #  define _GLIBCXX17_INLINE inline
 143 # else
 144 #  define _GLIBCXX17_INLINE
 145 # endif
 146 #endif
 147
 148 // Macro for noexcept, to support in mixed 03/0x mode.
 149 #ifndef _GLIBCXX_NOEXCEPT
 150 # if __cplusplus >= 201103L
 151 #  define _GLIBCXX_NOEXCEPT noexcept
 152 #  define _GLIBCXX_NOEXCEPT_IF(_COND) noexcept(_COND)
 153 #  define _GLIBCXX_USE_NOEXCEPT noexcept
 154 #  define _GLIBCXX_THROW(_EXC)
 155 # else
 156 #  define _GLIBCXX_NOEXCEPT
 157 #  define _GLIBCXX_NOEXCEPT_IF(_COND)
 158 #  define _GLIBCXX_USE_NOEXCEPT throw()
 159 #  define _GLIBCXX_THROW(_EXC) throw(_EXC)
 160 # endif
 161 #endif
 162
 163 #ifndef _GLIBCXX_NOTHROW
 164 # define _GLIBCXX_NOTHROW _GLIBCXX_USE_NOEXCEPT
 165 #endif
 166
 167 #ifndef _GLIBCXX_THROW_OR_ABORT
 168 # if __cpp_exceptions
 169 #  define _GLIBCXX_THROW_OR_ABORT(_EXC) (throw (_EXC))
 170 # else
 171 #  define _GLIBCXX_THROW_OR_ABORT(_EXC) (__builtin_abort())
 172 # endif
 173 #endif
 174
 175 #if __cpp_noexcept_function_type
 176 #define _GLIBCXX_NOEXCEPT_PARM , bool _NE
 177 #define _GLIBCXX_NOEXCEPT_QUAL noexcept (_NE)
 178 #else
 179 #define _GLIBCXX_NOEXCEPT_PARM
 180 #define _GLIBCXX_NOEXCEPT_QUAL
 181 #endif
 182
 183 // Macro for extern template, ie controlling template linkage via use
 184 // of extern keyword on template declaration. As documented in the g++
 185 // manual, it inhibits all implicit instantiations and is used
 186 // throughout the library to avoid multiple weak definitions for
 187 // required types that are already explicitly instantiated in the
 188 // library binary. This substantially reduces the binary size of
 189 // resulting executables.
 190 // Special case: _GLIBCXX_EXTERN_TEMPLATE == -1 disallows extern
 191 // templates only in basic_string, thus activating its debug-mode
 192 // checks even at -O0.
 193 #define _GLIBCXX_EXTERN_TEMPLATE
 194
 195 /*
 196   Outline of libstdc++ namespaces.
 197
 198   namespace std
 199   {
 200     namespace __debug { }
 201     namespace __parallel { }
 202     namespace __profile { }
 203     namespace __cxx1998 { }
 204
 205     namespace __detail {
 206       namespace __variant { }                           // C++17
 207     }
 208
 209     namespace rel_ops { }
 210
 211     namespace tr1
 212     {
 213       namespace placeholders { }
 214       namespace regex_constants { }
 215       namespace __detail { }
 216     }
 217
 218     namespace tr2 { }
 219
 220     namespace decimal { }
 221
 222     namespace chrono { }                                // C++11
 223     namespace placeholders { }                          // C++11
 224     namespace regex_constants { }                       // C++11
 225     namespace this_thread { }                           // C++11
 226     inline namespace literals {                         // C++14
 227       inline namespace chrono_literals { }              // C++14
 228       inline namespace complex_literals { }             // C++14
 229       inline namespace string_literals { }              // C++14
 230       inline namespace string_view_literals { }         // C++17
 231     }
 232   }
 233
 234   namespace abi { }
 235
 236   namespace __gnu_cxx
 237   {
 238     namespace __detail { }
 239   }
 240
 241   For full details see:
 242   http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/namespaces.html
 243 */
 244 namespace std
 245 {
 246   typedef __SIZE_TYPE__         size_t;
 247   typedef __PTRDIFF_TYPE__      ptrdiff_t;
 248
 249 #if __cplusplus >= 201103L
 250   typedef decltype(nullptr)     nullptr_t;
 251 #endif
 252 }
 253
 254 #define _GLIBCXX_USE_DUAL_ABI
 255
 256 #if ! _GLIBCXX_USE_DUAL_ABI
 257 // Ignore any pre-defined value of _GLIBCXX_USE_CXX11_ABI
 258 # undef _GLIBCXX_USE_CXX11_ABI
 259 #endif
 260
 261 #ifndef _GLIBCXX_USE_CXX11_ABI
 262 #define _GLIBCXX_USE_CXX11_ABI
 263 #endif
 264
 265 #if _GLIBCXX_USE_CXX11_ABI
 266 namespace std
 267 {
 268   inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { }
 269 }
 270 namespace __gnu_cxx
 271 {
 272   inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { }
 273 }
 274 # define _GLIBCXX_NAMESPACE_CXX11 __cxx11::
 275 # define _GLIBCXX_BEGIN_NAMESPACE_CXX11 namespace __cxx11 {
 276 # define _GLIBCXX_END_NAMESPACE_CXX11 }
 277 # define _GLIBCXX_DEFAULT_ABI_TAG _GLIBCXX_ABI_TAG_CXX11
 278 #else
 279 # define _GLIBCXX_NAMESPACE_CXX11
 280 # define _GLIBCXX_BEGIN_NAMESPACE_CXX11
 281 # define _GLIBCXX_END_NAMESPACE_CXX11
 282 # define _GLIBCXX_DEFAULT_ABI_TAG
 283 #endif
 284
 285 // Defined if inline namespaces are used for versioning.
 286 #define _GLIBCXX_INLINE_VERSION
 287
 288 // Inline namespace for symbol versioning.
 289 #if _GLIBCXX_INLINE_VERSION
 290 # define _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace __8 {
 291 # define _GLIBCXX_END_NAMESPACE_VERSION }
 292
 293 namespace std
 294 {
 295 inline _GLIBCXX_BEGIN_NAMESPACE_VERSION
 296 #if __cplusplus >= 201402L
 297   inline namespace literals {
 298     inline namespace chrono_literals { }
 299     inline namespace complex_literals { }
 300     inline namespace string_literals { }
 301 #if __cplusplus > 201402L
 302     inline namespace string_view_literals { }
 303 #endif // C++17
 304   }
 305 #endif // C++14
 306 _GLIBCXX_END_NAMESPACE_VERSION
 307 }
 308
 309 namespace __gnu_cxx
 310 {
 311 inline _GLIBCXX_BEGIN_NAMESPACE_VERSION
 312 _GLIBCXX_END_NAMESPACE_VERSION
 313 }
 314
 315 #else
 316 # define _GLIBCXX_BEGIN_NAMESPACE_VERSION
 317 # define _GLIBCXX_END_NAMESPACE_VERSION
 318 #endif
 319
 320 // Inline namespaces for special modes: debug, parallel, profile.
 321 #if defined(_GLIBCXX_DEBUG) || defined(_GLIBCXX_PARALLEL) \
 322     || defined(_GLIBCXX_PROFILE)
 323 namespace std
 324 {
 325 _GLIBCXX_BEGIN_NAMESPACE_VERSION
 326
 327   // Non-inline namespace for components replaced by alternates in active mode.
 328   namespace __cxx1998
 329   {
 330 # if _GLIBCXX_USE_CXX11_ABI
 331   inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { }
 332 # endif
 333   }
 334
 335 _GLIBCXX_END_NAMESPACE_VERSION
 336
 337   // Inline namespace for debug mode.
 338 # ifdef _GLIBCXX_DEBUG
 339   inline namespace __debug { }
 340 # endif
 341
 342   // Inline namespaces for parallel mode.
 343 # ifdef _GLIBCXX_PARALLEL
 344   inline namespace __parallel { }
 345 # endif
 346
 347   // Inline namespaces for profile mode
 348 # ifdef _GLIBCXX_PROFILE
 349   inline namespace __profile { }
 350 # endif
 351 }
 352
 353 // Check for invalid usage and unsupported mixed-mode use.
 354 # if defined(_GLIBCXX_DEBUG) && defined(_GLIBCXX_PARALLEL)
 355 #  error illegal use of multiple inlined namespaces
 356 # endif
 357 # if defined(_GLIBCXX_PROFILE) && defined(_GLIBCXX_DEBUG)
 358 #  error illegal use of multiple inlined namespaces
 359 # endif
 360 # if defined(_GLIBCXX_PROFILE) && defined(_GLIBCXX_PARALLEL)
 361 #  error illegal use of multiple inlined namespaces
 362 # endif
 363
 364 // Check for invalid use due to lack for weak symbols.
 365 # if __NO_INLINE__ && !__GXX_WEAK__
 366 #  warning currently using inlined namespace mode which may fail \
 367    without inlining due to lack of weak symbols
 368 # endif
 369 #endif
 370
 371 // Macros for namespace scope. Either namespace std:: or the name
 372 // of some nested namespace within it corresponding to the active mode.
 373 // _GLIBCXX_STD_A
 374 // _GLIBCXX_STD_C
 375 //
 376 // Macros for opening/closing conditional namespaces.
 377 // _GLIBCXX_BEGIN_NAMESPACE_ALGO
 378 // _GLIBCXX_END_NAMESPACE_ALGO
 379 // _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
 380 // _GLIBCXX_END_NAMESPACE_CONTAINER
 381 #if defined(_GLIBCXX_DEBUG) || defined(_GLIBCXX_PROFILE)
 382 # define _GLIBCXX_STD_C __cxx1998
 383 # define _GLIBCXX_BEGIN_NAMESPACE_CONTAINER \
 384          namespace _GLIBCXX_STD_C {
 385 # define _GLIBCXX_END_NAMESPACE_CONTAINER }
 386 #else
 387 # define _GLIBCXX_STD_C std
 388 # define _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
 389 # define _GLIBCXX_END_NAMESPACE_CONTAINER
 390 #endif
 391
 392 #ifdef _GLIBCXX_PARALLEL
 393 # define _GLIBCXX_STD_A __cxx1998
 394 # define _GLIBCXX_BEGIN_NAMESPACE_ALGO \
 395          namespace _GLIBCXX_STD_A {
 396 # define _GLIBCXX_END_NAMESPACE_ALGO }
 397 #else
 398 # define _GLIBCXX_STD_A std
 399 # define _GLIBCXX_BEGIN_NAMESPACE_ALGO
 400 # define _GLIBCXX_END_NAMESPACE_ALGO
 401 #endif
 402
 403 // GLIBCXX_ABI Deprecated
 404 // Define if compatibility should be provided for -mlong-double-64.
 405 #undef _GLIBCXX_LONG_DOUBLE_COMPAT
 406
 407 // Inline namespace for long double 128 mode.
 408 #if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__
 409 namespace std
 410 {
 411   inline namespace __gnu_cxx_ldbl128 { }
 412 }
 413 # define _GLIBCXX_NAMESPACE_LDBL __gnu_cxx_ldbl128::
 414 # define _GLIBCXX_BEGIN_NAMESPACE_LDBL namespace __gnu_cxx_ldbl128 {
 415 # define _GLIBCXX_END_NAMESPACE_LDBL }
 416 #else
 417 # define _GLIBCXX_NAMESPACE_LDBL
 418 # define _GLIBCXX_BEGIN_NAMESPACE_LDBL
 419 # define _GLIBCXX_END_NAMESPACE_LDBL
 420 #endif
 421 #if _GLIBCXX_USE_CXX11_ABI
 422 # define _GLIBCXX_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_NAMESPACE_CXX11
 423 # define _GLIBCXX_BEGIN_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_BEGIN_NAMESPACE_CXX11
 424 # define _GLIBCXX_END_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_END_NAMESPACE_CXX11
 425 #else
 426 # define _GLIBCXX_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_NAMESPACE_LDBL
 427 # define _GLIBCXX_BEGIN_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_BEGIN_NAMESPACE_LDBL
 428 # define _GLIBCXX_END_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_END_NAMESPACE_LDBL
 429 #endif
 430
 431 // Debug Mode implies checking assertions.
 432 #if defined(_GLIBCXX_DEBUG) && !defined(_GLIBCXX_ASSERTIONS)
 433 # define _GLIBCXX_ASSERTIONS 1
 434 #endif
 435
 436 // Disable std::string explicit instantiation declarations in order to assert.
 437 #ifdef _GLIBCXX_ASSERTIONS
 438 # undef _GLIBCXX_EXTERN_TEMPLATE
 439 # define _GLIBCXX_EXTERN_TEMPLATE -1
 440 #endif
 441
 442 // Assert.
 443 #if defined(_GLIBCXX_ASSERTIONS) \
 444   || defined(_GLIBCXX_PARALLEL) || defined(_GLIBCXX_PARALLEL_ASSERTIONS)
 445 namespace std
 446 {
 447   // Avoid the use of assert, because we're trying to keep the <cassert>
 448   // include out of the mix.
 449   extern "C++" inline void
 450   __replacement_assert(const char* __file, int __line,
 451                        const char* __function, const char* __condition)
 452   {
 453     __builtin_printf("%s:%d: %s: Assertion '%s' failed.\n", __file, __line,
 454                      __function, __condition);
 455     __builtin_abort();
 456   }
 457 }
 458 #define __glibcxx_assert_impl(_Condition)                                \
 459   do                                                                     \
 460   {                                                                      \
 461     if (! (_Condition))                                                  \
 462       std::__replacement_assert(__FILE__, __LINE__, __PRETTY_FUNCTION__, \
 463                                 #_Condition);                            \
 464   } while (false)
 465 #endif
 466
 467 #if defined(_GLIBCXX_ASSERTIONS)
 468 # define __glibcxx_assert(_Condition) __glibcxx_assert_impl(_Condition)
 469 #else
 470 # define __glibcxx_assert(_Condition)
 471 #endif
 472
 473 // Macros for race detectors.
 474 // _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(A) and
 475 // _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(A) should be used to explain
 476 // atomic (lock-free) synchronization to race detectors:
 477 // the race detector will infer a happens-before arc from the former to the
 478 // latter when they share the same argument pointer.
 479 //
 480 // The most frequent use case for these macros (and the only case in the
 481 // current implementation of the library) is atomic reference counting:
 482 //   void _M_remove_reference()
 483 //   {
 484 //     _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&this->_M_refcount);
 485 //     if (__gnu_cxx::__exchange_and_add_dispatch(&this->_M_refcount, -1) <= 0)
 486 //       {
 487 //         _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&this->_M_refcount);
 488 //         _M_destroy(__a);
 489 //       }
 490 //   }
 491 // The annotations in this example tell the race detector that all memory
 492 // accesses occurred when the refcount was positive do not race with
 493 // memory accesses which occurred after the refcount became zero.
 494 #ifndef _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE
 495 # define  _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(A)
 496 #endif
 497 #ifndef _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER
 498 # define  _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(A)
 499 #endif
 500
 501 // Macros for C linkage: define extern "C" linkage only when using C++.
 502 # define _GLIBCXX_BEGIN_EXTERN_C extern "C" {
 503 # define _GLIBCXX_END_EXTERN_C }
 504
 505 #define _GLIBCXX_USE_ALLOCATOR_NEW
 506
 507 #else // !__cplusplus
 508 # define _GLIBCXX_BEGIN_EXTERN_C
 509 # define _GLIBCXX_END_EXTERN_C
 510 #endif
 511
 512
 513 // First includes.
 514
 515 // Pick up any OS-specific definitions.
 516 #include <bits/os_defines.h>
 517
 518 // Pick up any CPU-specific definitions.
 519 #include <bits/cpu_defines.h>
 520
 521 // If platform uses neither visibility nor psuedo-visibility,
 522 // specify empty default for namespace annotation macros.
 523 #ifndef _GLIBCXX_PSEUDO_VISIBILITY
 524 # define _GLIBCXX_PSEUDO_VISIBILITY(V)
 525 #endif
 526
 527 // Certain function definitions that are meant to be overridable from
 528 // user code are decorated with this macro.  For some targets, this
 529 // macro causes these definitions to be weak.
 530 #ifndef _GLIBCXX_WEAK_DEFINITION
 531 # define _GLIBCXX_WEAK_DEFINITION
 532 #endif
 533
 534 // By default, we assume that __GXX_WEAK__ also means that there is support
 535 // for declaring functions as weak while not defining such functions.  This
 536 // allows for referring to functions provided by other libraries (e.g.,
 537 // libitm) without depending on them if the respective features are not used.
 538 #ifndef _GLIBCXX_USE_WEAK_REF
 539 # define _GLIBCXX_USE_WEAK_REF __GXX_WEAK__
 540 #endif
 541
 542 // Conditionally enable annotations for the Transactional Memory TS on C++11.
 543 // Most of the following conditions are due to limitations in the current
 544 // implementation.
 545 #if __cplusplus >= 201103L && _GLIBCXX_USE_CXX11_ABI                    \
 546   && _GLIBCXX_USE_DUAL_ABI && __cpp_transactional_memory >= 201500L     \
 547   &&  !_GLIBCXX_FULLY_DYNAMIC_STRING && _GLIBCXX_USE_WEAK_REF           \
 548   && _GLIBCXX_USE_ALLOCATOR_NEW
 549 #define _GLIBCXX_TXN_SAFE transaction_safe
 550 #define _GLIBCXX_TXN_SAFE_DYN transaction_safe_dynamic
 551 #else
 552 #define _GLIBCXX_TXN_SAFE
 553 #define _GLIBCXX_TXN_SAFE_DYN
 554 #endif
 555
 556 #if __cplusplus > 201402L
 557 // In C++17 mathematical special functions are in namespace std.
 558 # define _GLIBCXX_USE_STD_SPEC_FUNCS 1
 559 #elif __cplusplus >= 201103L && __STDCPP_WANT_MATH_SPEC_FUNCS__ != 0
 560 // For C++11 and C++14 they are in namespace std when requested.
 561 # define _GLIBCXX_USE_STD_SPEC_FUNCS 1
 562 #endif
 563
 564 // The remainder of the prewritten config is automatic; all the
 565 // user hooks are listed above.
 566
 567 // Create a boolean flag to be used to determine if --fast-math is set.
 568 #ifdef __FAST_MATH__
 569 # define _GLIBCXX_FAST_MATH 1
 570 #else
 571 # define _GLIBCXX_FAST_MATH 0
 572 #endif
 573
 574 // This marks string literals in header files to be extracted for eventual
 575 // translation.  It is primarily used for messages in thrown exceptions; see
 576 // src/functexcept.cc.  We use __N because the more traditional _N is used
 577 // for something else under certain OSes (see BADNAMES).
 578 #define __N(msgid)     (msgid)
 579
 580 // For example, <windows.h> is known to #define min and max as macros...
 581 #undef min
 582 #undef max
 583
 584 // N.B. these _GLIBCXX_USE_C99_XXX macros are defined unconditionally
 585 // so they should be tested with #if not with #ifdef.
 586 #if __cplusplus >= 201103L
 587 # ifndef _GLIBCXX_USE_C99_MATH
 588 #  define _GLIBCXX_USE_C99_MATH _GLIBCXX11_USE_C99_MATH
 589 # endif
 590 # ifndef _GLIBCXX_USE_C99_COMPLEX
 591 # define _GLIBCXX_USE_C99_COMPLEX _GLIBCXX11_USE_C99_COMPLEX
 592 # endif
 593 # ifndef _GLIBCXX_USE_C99_STDIO
 594 # define _GLIBCXX_USE_C99_STDIO _GLIBCXX11_USE_C99_STDIO
 595 # endif
 596 # ifndef _GLIBCXX_USE_C99_STDLIB
 597 # define _GLIBCXX_USE_C99_STDLIB _GLIBCXX11_USE_C99_STDLIB
 598 # endif
 599 # ifndef _GLIBCXX_USE_C99_WCHAR
 600 # define _GLIBCXX_USE_C99_WCHAR _GLIBCXX11_USE_C99_WCHAR
 601 # endif
 602 #else
 603 # ifndef _GLIBCXX_USE_C99_MATH
 604 #  define _GLIBCXX_USE_C99_MATH _GLIBCXX98_USE_C99_MATH
 605 # endif
 606 # ifndef _GLIBCXX_USE_C99_COMPLEX
 607 # define _GLIBCXX_USE_C99_COMPLEX _GLIBCXX98_USE_C99_COMPLEX
 608 # endif
 609 # ifndef _GLIBCXX_USE_C99_STDIO
 610 # define _GLIBCXX_USE_C99_STDIO _GLIBCXX98_USE_C99_STDIO
 611 # endif
 612 # ifndef _GLIBCXX_USE_C99_STDLIB
 613 # define _GLIBCXX_USE_C99_STDLIB _GLIBCXX98_USE_C99_STDLIB
 614 # endif
 615 # ifndef _GLIBCXX_USE_C99_WCHAR
 616 # define _GLIBCXX_USE_C99_WCHAR _GLIBCXX98_USE_C99_WCHAR
 617 # endif
 618 #endif
 619
 620 /* Define if __float128 is supported on this host. */
 621 #if defined(__FLOAT128__) || defined(__SIZEOF_FLOAT128__)
 622 #define _GLIBCXX_USE_FLOAT128
 623 #endif
 624
 625 // End of prewritten config; the settings discovered at configure time follow.