1// Predefined symbols and macros -*- C++ -*- 2 3// Copyright (C) 1997-2015 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 current version of the C++ library in compressed ISO date format. 34#define __GLIBCXX__ 35 36// Macros for various attributes. 37// _GLIBCXX_PURE 38// _GLIBCXX_CONST 39// _GLIBCXX_NORETURN 40// _GLIBCXX_NOTHROW 41// _GLIBCXX_VISIBILITY 42#ifndef _GLIBCXX_PURE 43# define _GLIBCXX_PURE __attribute__ ((__pure__)) 44#endif 45 46#ifndef _GLIBCXX_CONST 47# define _GLIBCXX_CONST __attribute__ ((__const__)) 48#endif 49 50#ifndef _GLIBCXX_NORETURN 51# define _GLIBCXX_NORETURN __attribute__ ((__noreturn__)) 52#endif 53 54// See below for C++ 55#ifndef _GLIBCXX_NOTHROW 56# ifndef __cplusplus 57# define _GLIBCXX_NOTHROW __attribute__((__nothrow__)) 58# endif 59#endif 60 61// Macros for visibility attributes. 62// _GLIBCXX_HAVE_ATTRIBUTE_VISIBILITY 63// _GLIBCXX_VISIBILITY 64#define _GLIBCXX_HAVE_ATTRIBUTE_VISIBILITY 65 66#if _GLIBCXX_HAVE_ATTRIBUTE_VISIBILITY 67# define _GLIBCXX_VISIBILITY(V) __attribute__ ((__visibility__ (#V))) 68#else 69// If this is not supplied by the OS-specific or CPU-specific 70// headers included below, it will be defined to an empty default. 71# define _GLIBCXX_VISIBILITY(V) _GLIBCXX_PSEUDO_VISIBILITY(V) 72#endif 73 74// Macros for deprecated attributes. 75// _GLIBCXX_USE_DEPRECATED 76// _GLIBCXX_DEPRECATED 77#ifndef _GLIBCXX_USE_DEPRECATED 78# define _GLIBCXX_USE_DEPRECATED 1 79#endif 80 81#if defined(__DEPRECATED) && (__cplusplus >= 201103L) 82# define _GLIBCXX_DEPRECATED __attribute__ ((__deprecated__)) 83#else 84# define _GLIBCXX_DEPRECATED 85#endif 86 87// Macros for ABI tag attributes. 88#ifndef _GLIBCXX_ABI_TAG_CXX11 89# define _GLIBCXX_ABI_TAG_CXX11 __attribute ((__abi_tag__ ("cxx11"))) 90#endif 91 92 93#if __cplusplus 94 95// Macro for constexpr, to support in mixed 03/0x mode. 96#ifndef _GLIBCXX_CONSTEXPR 97# if __cplusplus >= 201103L 98# define _GLIBCXX_CONSTEXPR constexpr 99# define _GLIBCXX_USE_CONSTEXPR constexpr 100# else 101# define _GLIBCXX_CONSTEXPR 102# define _GLIBCXX_USE_CONSTEXPR const 103# endif 104#endif 105 106#ifndef _GLIBCXX14_CONSTEXPR 107# if __cplusplus >= 201402L 108# define _GLIBCXX14_CONSTEXPR constexpr 109# else 110# define _GLIBCXX14_CONSTEXPR 111# endif 112#endif 113 114// Macro for noexcept, to support in mixed 03/0x mode. 115#ifndef _GLIBCXX_NOEXCEPT 116# if __cplusplus >= 201103L 117# define _GLIBCXX_NOEXCEPT noexcept 118# define _GLIBCXX_USE_NOEXCEPT noexcept 119# define _GLIBCXX_THROW(_EXC) 120# else 121# define _GLIBCXX_NOEXCEPT 122# define _GLIBCXX_USE_NOEXCEPT throw() 123# define _GLIBCXX_THROW(_EXC) throw(_EXC) 124# endif 125#endif 126 127#ifndef _GLIBCXX_NOTHROW 128# define _GLIBCXX_NOTHROW _GLIBCXX_USE_NOEXCEPT 129#endif 130 131#ifndef _GLIBCXX_THROW_OR_ABORT 132# if __cpp_exceptions 133# define _GLIBCXX_THROW_OR_ABORT(_EXC) (throw (_EXC)) 134# else 135# define _GLIBCXX_THROW_OR_ABORT(_EXC) (__builtin_abort()) 136# endif 137#endif 138 139// Macro for extern template, ie controling template linkage via use 140// of extern keyword on template declaration. As documented in the g++ 141// manual, it inhibits all implicit instantiations and is used 142// throughout the library to avoid multiple weak definitions for 143// required types that are already explicitly instantiated in the 144// library binary. This substantially reduces the binary size of 145// resulting executables. 146// Special case: _GLIBCXX_EXTERN_TEMPLATE == -1 disallows extern 147// templates only in basic_string, thus activating its debug-mode 148// checks even at -O0. 149#define _GLIBCXX_EXTERN_TEMPLATE 150 151/* 152 Outline of libstdc++ namespaces. 153 154 namespace std 155 { 156 namespace __debug { } 157 namespace __parallel { } 158 namespace __profile { } 159 namespace __cxx1998 { } 160 161 namespace __detail { } 162 163 namespace rel_ops { } 164 165 namespace tr1 166 { 167 namespace placeholders { } 168 namespace regex_constants { } 169 namespace __detail { } 170 } 171 172 namespace tr2 { } 173 174 namespace decimal { } 175 176 namespace chrono { } 177 namespace placeholders { } 178 namespace regex_constants { } 179 namespace this_thread { } 180 181 namespace experimental { } 182 } 183 184 namespace abi { } 185 186 namespace __gnu_cxx 187 { 188 namespace __detail { } 189 } 190 191 For full details see: 192 http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/namespaces.html 193*/ 194namespace std 195{ 196 typedef __SIZE_TYPE__ size_t; 197 typedef __PTRDIFF_TYPE__ ptrdiff_t; 198 199#if __cplusplus >= 201103L 200 typedef decltype(nullptr) nullptr_t; 201#endif 202} 203 204#define _GLIBCXX_USE_DUAL_ABI 205 206#if ! _GLIBCXX_USE_DUAL_ABI 207// Ignore any pre-defined value of _GLIBCXX_USE_CXX11_ABI 208# undef _GLIBCXX_USE_CXX11_ABI 209#endif 210 211#ifndef _GLIBCXX_USE_CXX11_ABI 212#define _GLIBCXX_USE_CXX11_ABI 213#endif 214 215#if _GLIBCXX_USE_CXX11_ABI 216namespace std 217{ 218 inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } 219} 220namespace __gnu_cxx 221{ 222 inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } 223} 224# define _GLIBCXX_NAMESPACE_CXX11 __cxx11:: 225# define _GLIBCXX_BEGIN_NAMESPACE_CXX11 namespace __cxx11 { 226# define _GLIBCXX_END_NAMESPACE_CXX11 } 227# define _GLIBCXX_DEFAULT_ABI_TAG _GLIBCXX_ABI_TAG_CXX11 228#else 229# define _GLIBCXX_NAMESPACE_CXX11 230# define _GLIBCXX_BEGIN_NAMESPACE_CXX11 231# define _GLIBCXX_END_NAMESPACE_CXX11 232# define _GLIBCXX_DEFAULT_ABI_TAG 233#endif 234 235 236// Defined if inline namespaces are used for versioning. 237#define _GLIBCXX_INLINE_VERSION 238 239// Inline namespace for symbol versioning. 240#if _GLIBCXX_INLINE_VERSION 241 242namespace std 243{ 244 inline namespace __7 { } 245 246 namespace rel_ops { inline namespace __7 { } } 247 248 namespace tr1 249 { 250 inline namespace __7 { } 251 namespace placeholders { inline namespace __7 { } } 252 namespace regex_constants { inline namespace __7 { } } 253 namespace __detail { inline namespace __7 { } } 254 } 255 256 namespace tr2 257 { inline namespace __7 { } } 258 259 namespace decimal { inline namespace __7 { } } 260 261 namespace chrono { inline namespace __7 { } } 262 namespace placeholders { inline namespace __7 { } } 263 namespace regex_constants { inline namespace __7 { } } 264 namespace this_thread { inline namespace __7 { } } 265 266 namespace experimental { inline namespace __7 { } } 267 268 namespace __detail { inline namespace __7 { } } 269} 270 271namespace __gnu_cxx 272{ 273 inline namespace __7 { } 274 namespace __detail { inline namespace __7 { } } 275} 276# define _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace __7 { 277# define _GLIBCXX_END_NAMESPACE_VERSION } 278#else 279# define _GLIBCXX_BEGIN_NAMESPACE_VERSION 280# define _GLIBCXX_END_NAMESPACE_VERSION 281#endif 282 283 284// Inline namespaces for special modes: debug, parallel, profile. 285#if defined(_GLIBCXX_DEBUG) || defined(_GLIBCXX_PARALLEL) \ 286 || defined(_GLIBCXX_PROFILE) 287namespace std 288{ 289 // Non-inline namespace for components replaced by alternates in active mode. 290 namespace __cxx1998 291 { 292# if _GLIBCXX_INLINE_VERSION 293 inline namespace __7 { } 294# endif 295 296# if _GLIBCXX_USE_CXX11_ABI 297 inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } 298# endif 299 } 300 301 // Inline namespace for debug mode. 302# ifdef _GLIBCXX_DEBUG 303 inline namespace __debug { } 304# endif 305 306 // Inline namespaces for parallel mode. 307# ifdef _GLIBCXX_PARALLEL 308 inline namespace __parallel { } 309# endif 310 311 // Inline namespaces for profile mode 312# ifdef _GLIBCXX_PROFILE 313 inline namespace __profile { } 314# endif 315} 316 317// Check for invalid usage and unsupported mixed-mode use. 318# if defined(_GLIBCXX_DEBUG) && defined(_GLIBCXX_PARALLEL) 319# error illegal use of multiple inlined namespaces 320# endif 321# if defined(_GLIBCXX_PROFILE) && defined(_GLIBCXX_DEBUG) 322# error illegal use of multiple inlined namespaces 323# endif 324# if defined(_GLIBCXX_PROFILE) && defined(_GLIBCXX_PARALLEL) 325# error illegal use of multiple inlined namespaces 326# endif 327 328// Check for invalid use due to lack for weak symbols. 329# if __NO_INLINE__ && !__GXX_WEAK__ 330# warning currently using inlined namespace mode which may fail \ 331 without inlining due to lack of weak symbols 332# endif 333#endif 334 335// Macros for namespace scope. Either namespace std:: or the name 336// of some nested namespace within it corresponding to the active mode. 337// _GLIBCXX_STD_A 338// _GLIBCXX_STD_C 339// 340// Macros for opening/closing conditional namespaces. 341// _GLIBCXX_BEGIN_NAMESPACE_ALGO 342// _GLIBCXX_END_NAMESPACE_ALGO 343// _GLIBCXX_BEGIN_NAMESPACE_CONTAINER 344// _GLIBCXX_END_NAMESPACE_CONTAINER 345#if defined(_GLIBCXX_DEBUG) || defined(_GLIBCXX_PROFILE) 346# define _GLIBCXX_STD_C __cxx1998 347# define _GLIBCXX_BEGIN_NAMESPACE_CONTAINER \ 348 namespace _GLIBCXX_STD_C { _GLIBCXX_BEGIN_NAMESPACE_VERSION 349# define _GLIBCXX_END_NAMESPACE_CONTAINER \ 350 _GLIBCXX_END_NAMESPACE_VERSION } 351# undef _GLIBCXX_EXTERN_TEMPLATE 352# define _GLIBCXX_EXTERN_TEMPLATE -1 353#endif 354 355#ifdef _GLIBCXX_PARALLEL 356# define _GLIBCXX_STD_A __cxx1998 357# define _GLIBCXX_BEGIN_NAMESPACE_ALGO \ 358 namespace _GLIBCXX_STD_A { _GLIBCXX_BEGIN_NAMESPACE_VERSION 359# define _GLIBCXX_END_NAMESPACE_ALGO \ 360 _GLIBCXX_END_NAMESPACE_VERSION } 361#endif 362 363#ifndef _GLIBCXX_STD_A 364# define _GLIBCXX_STD_A std 365#endif 366 367#ifndef _GLIBCXX_STD_C 368# define _GLIBCXX_STD_C std 369#endif 370 371#ifndef _GLIBCXX_BEGIN_NAMESPACE_ALGO 372# define _GLIBCXX_BEGIN_NAMESPACE_ALGO 373#endif 374 375#ifndef _GLIBCXX_END_NAMESPACE_ALGO 376# define _GLIBCXX_END_NAMESPACE_ALGO 377#endif 378 379#ifndef _GLIBCXX_BEGIN_NAMESPACE_CONTAINER 380# define _GLIBCXX_BEGIN_NAMESPACE_CONTAINER 381#endif 382 383#ifndef _GLIBCXX_END_NAMESPACE_CONTAINER 384# define _GLIBCXX_END_NAMESPACE_CONTAINER 385#endif 386 387// GLIBCXX_ABI Deprecated 388// Define if compatibility should be provided for -mlong-double-64. 389#undef _GLIBCXX_LONG_DOUBLE_COMPAT 390 391// Inline namespace for long double 128 mode. 392#if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__ 393namespace std 394{ 395 inline namespace __gnu_cxx_ldbl128 { } 396} 397# define _GLIBCXX_NAMESPACE_LDBL __gnu_cxx_ldbl128:: 398# define _GLIBCXX_BEGIN_NAMESPACE_LDBL namespace __gnu_cxx_ldbl128 { 399# define _GLIBCXX_END_NAMESPACE_LDBL } 400#else 401# define _GLIBCXX_NAMESPACE_LDBL 402# define _GLIBCXX_BEGIN_NAMESPACE_LDBL 403# define _GLIBCXX_END_NAMESPACE_LDBL 404#endif 405#if _GLIBCXX_USE_CXX11_ABI 406# define _GLIBCXX_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_NAMESPACE_CXX11 407# define _GLIBCXX_BEGIN_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_BEGIN_NAMESPACE_CXX11 408# define _GLIBCXX_END_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_END_NAMESPACE_CXX11 409#else 410# define _GLIBCXX_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_NAMESPACE_LDBL 411# define _GLIBCXX_BEGIN_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_BEGIN_NAMESPACE_LDBL 412# define _GLIBCXX_END_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_END_NAMESPACE_LDBL 413#endif 414 415// Assert. 416#if !defined(_GLIBCXX_DEBUG) && !defined(_GLIBCXX_PARALLEL) 417# define __glibcxx_assert(_Condition) 418#else 419namespace std 420{ 421 // Avoid the use of assert, because we're trying to keep the <cassert> 422 // include out of the mix. 423 inline void 424 __replacement_assert(const char* __file, int __line, 425 const char* __function, const char* __condition) 426 { 427 __builtin_printf("%s:%d: %s: Assertion '%s' failed.\n", __file, __line, 428 __function, __condition); 429 __builtin_abort(); 430 } 431} 432#define __glibcxx_assert(_Condition) \ 433 do \ 434 { \ 435 if (! (_Condition)) \ 436 std::__replacement_assert(__FILE__, __LINE__, __PRETTY_FUNCTION__, \ 437 #_Condition); \ 438 } while (false) 439#endif 440 441// Macros for race detectors. 442// _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(A) and 443// _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(A) should be used to explain 444// atomic (lock-free) synchronization to race detectors: 445// the race detector will infer a happens-before arc from the former to the 446// latter when they share the same argument pointer. 447// 448// The most frequent use case for these macros (and the only case in the 449// current implementation of the library) is atomic reference counting: 450// void _M_remove_reference() 451// { 452// _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&this->_M_refcount); 453// if (__gnu_cxx::__exchange_and_add_dispatch(&this->_M_refcount, -1) <= 0) 454// { 455// _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&this->_M_refcount); 456// _M_destroy(__a); 457// } 458// } 459// The annotations in this example tell the race detector that all memory 460// accesses occurred when the refcount was positive do not race with 461// memory accesses which occurred after the refcount became zero. 462#ifndef _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE 463# define _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(A) 464#endif 465#ifndef _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER 466# define _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(A) 467#endif 468 469// Macros for C linkage: define extern "C" linkage only when using C++. 470# define _GLIBCXX_BEGIN_EXTERN_C extern "C" { 471# define _GLIBCXX_END_EXTERN_C } 472 473#else // !__cplusplus 474# define _GLIBCXX_BEGIN_EXTERN_C 475# define _GLIBCXX_END_EXTERN_C 476#endif 477 478 479// First includes. 480 481// Pick up any OS-specific definitions. 482#include <bits/os_defines.h> 483 484// Pick up any CPU-specific definitions. 485#include <bits/cpu_defines.h> 486 487// If platform uses neither visibility nor psuedo-visibility, 488// specify empty default for namespace annotation macros. 489#ifndef _GLIBCXX_PSEUDO_VISIBILITY 490# define _GLIBCXX_PSEUDO_VISIBILITY(V) 491#endif 492 493// Certain function definitions that are meant to be overridable from 494// user code are decorated with this macro. For some targets, this 495// macro causes these definitions to be weak. 496#ifndef _GLIBCXX_WEAK_DEFINITION 497# define _GLIBCXX_WEAK_DEFINITION 498#endif 499 500 501// The remainder of the prewritten config is automatic; all the 502// user hooks are listed above. 503 504// Create a boolean flag to be used to determine if --fast-math is set. 505#ifdef __FAST_MATH__ 506# define _GLIBCXX_FAST_MATH 1 507#else 508# define _GLIBCXX_FAST_MATH 0 509#endif 510 511// This marks string literals in header files to be extracted for eventual 512// translation. It is primarily used for messages in thrown exceptions; see 513// src/functexcept.cc. We use __N because the more traditional _N is used 514// for something else under certain OSes (see BADNAMES). 515#define __N(msgid) (msgid) 516 517// For example, <windows.h> is known to #define min and max as macros... 518#undef min 519#undef max 520 521// End of prewritten config; the settings discovered at configure time follow. 522