libitm/local_atomic

   1 // -*- C++ -*- header.
   2
   3 // Copyright (C) 2008-2020 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 // ????????????????????????????????????????????????????????????????????
  26 //
  27 // This is a copy of the libstdc++ header, with the trivial modification
  28 // of ignoring the c++config.h include.  If and when the top-level build is
  29 // fixed so that target libraries can be built using the newly built, we can
  30 // delete this file.
  31 //
  32 // ????????????????????????????????????????????????????????????????????
  33
  34 /** @file include/atomic
  35  *  This is a Standard C++ Library header.
  36  */
  37
  38 // Based on "C++ Atomic Types and Operations" by Hans Boehm and Lawrence Crowl.
  39 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2427.html
  40
  41 #ifndef _GLIBCXX_ATOMIC
  42 #define _GLIBCXX_ATOMIC 1
  43
  44 #define __libitm_always_inline __attribute__((always_inline))
  45
  46 // #pragma GCC system_header
  47
  48 // #ifndef __GXX_EXPERIMENTAL_CXX0X__
  49 // # include <bits/c++0x_warning.h>
  50 // #endif
  51
  52 // #include <bits/atomic_base.h>
  53
  54 namespace std // _GLIBCXX_VISIBILITY(default)
  55 {
  56 // _GLIBCXX_BEGIN_NAMESPACE_VERSION
  57
  58   /**
  59    * @defgroup atomics Atomics
  60    *
  61    * Components for performing atomic operations.
  62    * @{
  63    */
  64
  65   /// Enumeration for memory_order
  66   typedef enum memory_order
  67     {
  68       memory_order_relaxed,
  69       memory_order_consume,
  70       memory_order_acquire,
  71       memory_order_release,
  72       memory_order_acq_rel,
  73       memory_order_seq_cst
  74     } memory_order;
  75
  76   inline __libitm_always_inline memory_order
  77   __calculate_memory_order(memory_order __m) noexcept
  78   {
  79     const bool __cond1 = __m == memory_order_release;
  80     const bool __cond2 = __m == memory_order_acq_rel;
  81     memory_order __mo1(__cond1 ? memory_order_relaxed : __m);
  82     memory_order __mo2(__cond2 ? memory_order_acquire : __mo1);
  83     return __mo2;
  84   }
  85
  86   inline __libitm_always_inline void
  87   atomic_thread_fence(memory_order __m) noexcept
  88   {
  89     __atomic_thread_fence (__m);
  90   }
  91
  92   inline __libitm_always_inline void
  93   atomic_signal_fence(memory_order __m) noexcept
  94   {
  95     __atomic_thread_fence (__m);
  96   }
  97
  98   /// kill_dependency
  99   template<typename _Tp>
 100     inline _Tp
 101     kill_dependency(_Tp __y) noexcept
 102     {
 103       _Tp __ret(__y);
 104       return __ret;
 105     }
 106
 107   /// Lock-free Property
 108
 109
 110 #define ATOMIC_BOOL_LOCK_FREE           __GCC_ATOMIC_BOOL_LOCK_FREE
 111 #define ATOMIC_CHAR_LOCK_FREE           __GCC_ATOMIC_CHAR_LOCK_FREE
 112 #define ATOMIC_WCHAR_T_LOCK_FREE        __GCC_ATOMIC_WCHAR_T_LOCK_FREE
 113 #define ATOMIC_CHAR16_T_LOCK_FREE       __GCC_ATOMIC_CHAR16_T_LOCK_FREE
 114 #define ATOMIC_CHAR32_T_LOCK_FREE       __GCC_ATOMIC_CHAR32_T_LOCK_FREE
 115 #define ATOMIC_SHORT_LOCK_FREE          __GCC_ATOMIC_SHORT_LOCK_FREE
 116 #define ATOMIC_INT_LOCK_FREE            __GCC_ATOMIC_INT_LOCK_FREE
 117 #define ATOMIC_LONG_LOCK_FREE           __GCC_ATOMIC_LONG_LOCK_FREE
 118 #define ATOMIC_LLONG_LOCK_FREE          __GCC_ATOMIC_LLONG_LOCK_FREE
 119 #define ATOMIC_POINTER_LOCK_FREE        __GCC_ATOMIC_POINTER_LOCK_FREE
 120
 121   // Base types for atomics.
 122   template<typename _IntTp>
 123     struct __atomic_base;
 124
 125   /// atomic_char
 126   typedef __atomic_base<char>                   atomic_char;
 127
 128   /// atomic_schar
 129   typedef __atomic_base<signed char>            atomic_schar;
 130
 131   /// atomic_uchar
 132   typedef __atomic_base<unsigned char>          atomic_uchar;
 133
 134   /// atomic_short
 135   typedef __atomic_base<short>                  atomic_short;
 136
 137   /// atomic_ushort
 138   typedef __atomic_base<unsigned short>         atomic_ushort;
 139
 140   /// atomic_int
 141   typedef __atomic_base<int>                    atomic_int;
 142
 143   /// atomic_uint
 144   typedef __atomic_base<unsigned int>           atomic_uint;
 145
 146   /// atomic_long
 147   typedef __atomic_base<long>                   atomic_long;
 148
 149   /// atomic_ulong
 150   typedef __atomic_base<unsigned long>          atomic_ulong;
 151
 152   /// atomic_llong
 153   typedef __atomic_base<long long>              atomic_llong;
 154
 155   /// atomic_ullong
 156   typedef __atomic_base<unsigned long long>     atomic_ullong;
 157
 158   /// atomic_wchar_t
 159   typedef __atomic_base<wchar_t>                atomic_wchar_t;
 160
 161   /// atomic_char16_t
 162   typedef __atomic_base<char16_t>               atomic_char16_t;
 163
 164   /// atomic_char32_t
 165   typedef __atomic_base<char32_t>               atomic_char32_t;
 166
 167   /// atomic_char32_t
 168   typedef __atomic_base<char32_t>               atomic_char32_t;
 169
 170
 171   /// atomic_int_least8_t
 172   typedef __atomic_base<int_least8_t>           atomic_int_least8_t;
 173
 174   /// atomic_uint_least8_t
 175   typedef __atomic_base<uint_least8_t>          atomic_uint_least8_t;
 176
 177   /// atomic_int_least16_t
 178   typedef __atomic_base<int_least16_t>          atomic_int_least16_t;
 179
 180   /// atomic_uint_least16_t
 181   typedef __atomic_base<uint_least16_t>         atomic_uint_least16_t;
 182
 183   /// atomic_int_least32_t
 184   typedef __atomic_base<int_least32_t>          atomic_int_least32_t;
 185
 186   /// atomic_uint_least32_t
 187   typedef __atomic_base<uint_least32_t>         atomic_uint_least32_t;
 188
 189   /// atomic_int_least64_t
 190   typedef __atomic_base<int_least64_t>          atomic_int_least64_t;
 191
 192   /// atomic_uint_least64_t
 193   typedef __atomic_base<uint_least64_t>         atomic_uint_least64_t;
 194
 195
 196   /// atomic_int_fast8_t
 197   typedef __atomic_base<int_fast8_t>            atomic_int_fast8_t;
 198
 199   /// atomic_uint_fast8_t
 200   typedef __atomic_base<uint_fast8_t>           atomic_uint_fast8_t;
 201
 202   /// atomic_int_fast16_t
 203   typedef __atomic_base<int_fast16_t>           atomic_int_fast16_t;
 204
 205   /// atomic_uint_fast16_t
 206   typedef __atomic_base<uint_fast16_t>          atomic_uint_fast16_t;
 207
 208   /// atomic_int_fast32_t
 209   typedef __atomic_base<int_fast32_t>           atomic_int_fast32_t;
 210
 211   /// atomic_uint_fast32_t
 212   typedef __atomic_base<uint_fast32_t>          atomic_uint_fast32_t;
 213
 214   /// atomic_int_fast64_t
 215   typedef __atomic_base<int_fast64_t>           atomic_int_fast64_t;
 216
 217   /// atomic_uint_fast64_t
 218   typedef __atomic_base<uint_fast64_t>          atomic_uint_fast64_t;
 219
 220
 221   /// atomic_intptr_t
 222   typedef __atomic_base<intptr_t>               atomic_intptr_t;
 223
 224   /// atomic_uintptr_t
 225   typedef __atomic_base<uintptr_t>              atomic_uintptr_t;
 226
 227   /// atomic_size_t
 228   typedef __atomic_base<size_t>                 atomic_size_t;
 229
 230   /// atomic_intmax_t
 231   typedef __atomic_base<intmax_t>               atomic_intmax_t;
 232
 233   /// atomic_uintmax_t
 234   typedef __atomic_base<uintmax_t>              atomic_uintmax_t;
 235
 236   /// atomic_ptrdiff_t
 237   typedef __atomic_base<ptrdiff_t>              atomic_ptrdiff_t;
 238
 239
 240 #define ATOMIC_VAR_INIT(_VI) { _VI }
 241
 242   template<typename _Tp>
 243     struct atomic;
 244
 245   template<typename _Tp>
 246     struct atomic<_Tp*>;
 247
 248
 249   /**
 250    *  @brief Base type for atomic_flag.
 251    *
 252    *  Base type is POD with data, allowing atomic_flag to derive from
 253    *  it and meet the standard layout type requirement. In addition to
 254    *  compatibilty with a C interface, this allows different
 255    *  implementations of atomic_flag to use the same atomic operation
 256    *  functions, via a standard conversion to the __atomic_flag_base
 257    *  argument.
 258   */
 259   // _GLIBCXX_BEGIN_EXTERN_C
 260
 261   struct __atomic_flag_base
 262   {
 263     bool _M_i;
 264   };
 265
 266   // _GLIBCXX_END_EXTERN_C
 267
 268 #define ATOMIC_FLAG_INIT { false }
 269
 270   /// atomic_flag
 271   struct atomic_flag : public __atomic_flag_base
 272   {
 273     atomic_flag() noexcept = default;
 274     ~atomic_flag() noexcept = default;
 275     atomic_flag(const atomic_flag&) = delete;
 276     atomic_flag& operator=(const atomic_flag&) = delete;
 277     atomic_flag& operator=(const atomic_flag&) volatile = delete;
 278
 279     // Conversion to ATOMIC_FLAG_INIT.
 280     atomic_flag(bool __i) noexcept : __atomic_flag_base({ __i }) { }
 281
 282     __libitm_always_inline bool
 283     test_and_set(memory_order __m = memory_order_seq_cst) noexcept
 284     {
 285       return __atomic_test_and_set (&_M_i, __m);
 286     }
 287
 288     __libitm_always_inline bool
 289     test_and_set(memory_order __m = memory_order_seq_cst) volatile noexcept
 290     {
 291       return __atomic_test_and_set (&_M_i, __m);
 292     }
 293
 294     __libitm_always_inline void
 295     clear(memory_order __m = memory_order_seq_cst) noexcept
 296     {
 297       // __glibcxx_assert(__m != memory_order_consume);
 298       // __glibcxx_assert(__m != memory_order_acquire);
 299       // __glibcxx_assert(__m != memory_order_acq_rel);
 300
 301       __atomic_clear (&_M_i, __m);
 302     }
 303
 304     __libitm_always_inline void
 305     clear(memory_order __m = memory_order_seq_cst) volatile noexcept
 306     {
 307       // __glibcxx_assert(__m != memory_order_consume);
 308       // __glibcxx_assert(__m != memory_order_acquire);
 309       // __glibcxx_assert(__m != memory_order_acq_rel);
 310
 311       __atomic_clear (&_M_i, __m);
 312     }
 313   };
 314
 315
 316   /// Base class for atomic integrals.
 317   //
 318   // For each of the integral types, define atomic_[integral type] struct
 319   //
 320   // atomic_bool     bool
 321   // atomic_char     char
 322   // atomic_schar    signed char
 323   // atomic_uchar    unsigned char
 324   // atomic_short    short
 325   // atomic_ushort   unsigned short
 326   // atomic_int      int
 327   // atomic_uint     unsigned int
 328   // atomic_long     long
 329   // atomic_ulong    unsigned long
 330   // atomic_llong    long long
 331   // atomic_ullong   unsigned long long
 332   // atomic_char16_t char16_t
 333   // atomic_char32_t char32_t
 334   // atomic_wchar_t  wchar_t
 335   //
 336   // NB: Assuming _ITp is an integral scalar type that is 1, 2, 4, or
 337   // 8 bytes, since that is what GCC built-in functions for atomic
 338   // memory access expect.
 339   template<typename _ITp>
 340     struct __atomic_base
 341     {
 342     private:
 343       typedef _ITp      __int_type;
 344
 345       __int_type        _M_i;
 346
 347     public:
 348       __atomic_base() noexcept = default;
 349       ~__atomic_base() noexcept = default;
 350       __atomic_base(const __atomic_base&) = delete;
 351       __atomic_base& operator=(const __atomic_base&) = delete;
 352       __atomic_base& operator=(const __atomic_base&) volatile = delete;
 353
 354       // Requires __int_type convertible to _M_i.
 355       constexpr __atomic_base(__int_type __i) noexcept : _M_i (__i) { }
 356
 357       operator __int_type() const noexcept
 358       { return load(); }
 359
 360       operator __int_type() const volatile noexcept
 361       { return load(); }
 362
 363       __int_type
 364       operator=(__int_type __i) noexcept
 365       {
 366         store(__i);
 367         return __i;
 368       }
 369
 370       __int_type
 371       operator=(__int_type __i) volatile noexcept
 372       {
 373         store(__i);
 374         return __i;
 375       }
 376
 377       __int_type
 378       operator++(int) noexcept
 379       { return fetch_add(1); }
 380
 381       __int_type
 382       operator++(int) volatile noexcept
 383       { return fetch_add(1); }
 384
 385       __int_type
 386       operator--(int) noexcept
 387       { return fetch_sub(1); }
 388
 389       __int_type
 390       operator--(int) volatile noexcept
 391       { return fetch_sub(1); }
 392
 393       __int_type
 394       operator++() noexcept
 395       { return __atomic_add_fetch(&_M_i, 1, memory_order_seq_cst); }
 396
 397       __int_type
 398       operator++() volatile noexcept
 399       { return __atomic_add_fetch(&_M_i, 1, memory_order_seq_cst); }
 400
 401       __int_type
 402       operator--() noexcept
 403       { return __atomic_sub_fetch(&_M_i, 1, memory_order_seq_cst); }
 404
 405       __int_type
 406       operator--() volatile noexcept
 407       { return __atomic_sub_fetch(&_M_i, 1, memory_order_seq_cst); }
 408
 409       __int_type
 410       operator+=(__int_type __i) noexcept
 411       { return __atomic_add_fetch(&_M_i, __i, memory_order_seq_cst); }
 412
 413       __int_type
 414       operator+=(__int_type __i) volatile noexcept
 415       { return __atomic_add_fetch(&_M_i, __i, memory_order_seq_cst); }
 416
 417       __int_type
 418       operator-=(__int_type __i) noexcept
 419       { return __atomic_sub_fetch(&_M_i, __i, memory_order_seq_cst); }
 420
 421       __int_type
 422       operator-=(__int_type __i) volatile noexcept
 423       { return __atomic_sub_fetch(&_M_i, __i, memory_order_seq_cst); }
 424
 425       __int_type
 426       operator&=(__int_type __i) noexcept
 427       { return __atomic_and_fetch(&_M_i, __i, memory_order_seq_cst); }
 428
 429       __int_type
 430       operator&=(__int_type __i) volatile noexcept
 431       { return __atomic_and_fetch(&_M_i, __i, memory_order_seq_cst); }
 432
 433       __int_type
 434       operator|=(__int_type __i) noexcept
 435       { return __atomic_or_fetch(&_M_i, __i, memory_order_seq_cst); }
 436
 437       __int_type
 438       operator|=(__int_type __i) volatile noexcept
 439       { return __atomic_or_fetch(&_M_i, __i, memory_order_seq_cst); }
 440
 441       __int_type
 442       operator^=(__int_type __i) noexcept
 443       { return __atomic_xor_fetch(&_M_i, __i, memory_order_seq_cst); }
 444
 445       __int_type
 446       operator^=(__int_type __i) volatile noexcept
 447       { return __atomic_xor_fetch(&_M_i, __i, memory_order_seq_cst); }
 448
 449       bool
 450       is_lock_free() const noexcept
 451       { return __atomic_is_lock_free (sizeof (_M_i), &_M_i); }
 452
 453       bool
 454       is_lock_free() const volatile noexcept
 455       { return __atomic_is_lock_free (sizeof (_M_i), &_M_i); }
 456
 457       __libitm_always_inline void
 458       store(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept
 459       {
 460         // __glibcxx_assert(__m != memory_order_acquire);
 461         // __glibcxx_assert(__m != memory_order_acq_rel);
 462         // __glibcxx_assert(__m != memory_order_consume);
 463
 464         __atomic_store_n(&_M_i, __i, __m);
 465       }
 466
 467       __libitm_always_inline void
 468       store(__int_type __i,
 469             memory_order __m = memory_order_seq_cst) volatile noexcept
 470       {
 471         // __glibcxx_assert(__m != memory_order_acquire);
 472         // __glibcxx_assert(__m != memory_order_acq_rel);
 473         // __glibcxx_assert(__m != memory_order_consume);
 474
 475         __atomic_store_n(&_M_i, __i, __m);
 476       }
 477
 478       __libitm_always_inline __int_type
 479       load(memory_order __m = memory_order_seq_cst) const noexcept
 480       {
 481         // __glibcxx_assert(__m != memory_order_release);
 482         // __glibcxx_assert(__m != memory_order_acq_rel);
 483
 484         return __atomic_load_n(&_M_i, __m);
 485       }
 486
 487       __libitm_always_inline __int_type
 488       load(memory_order __m = memory_order_seq_cst) const volatile noexcept
 489       {
 490         // __glibcxx_assert(__m != memory_order_release);
 491         // __glibcxx_assert(__m != memory_order_acq_rel);
 492
 493         return __atomic_load_n(&_M_i, __m);
 494       }
 495
 496       __libitm_always_inline __int_type
 497       exchange(__int_type __i,
 498                memory_order __m = memory_order_seq_cst) noexcept
 499       {
 500         return __atomic_exchange_n(&_M_i, __i, __m);
 501       }
 502
 503       __libitm_always_inline __int_type
 504       exchange(__int_type __i,
 505                memory_order __m = memory_order_seq_cst) volatile noexcept
 506       {
 507         return __atomic_exchange_n(&_M_i, __i, __m);
 508       }
 509
 510       __libitm_always_inline bool
 511       compare_exchange_weak(__int_type& __i1, __int_type __i2,
 512                             memory_order __m1, memory_order __m2) noexcept
 513       {
 514         // __glibcxx_assert(__m2 != memory_order_release);
 515         // __glibcxx_assert(__m2 != memory_order_acq_rel);
 516         // __glibcxx_assert(__m2 <= __m1);
 517
 518         return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1, __m1, __m2);
 519       }
 520
 521       __libitm_always_inline bool
 522       compare_exchange_weak(__int_type& __i1, __int_type __i2,
 523                             memory_order __m1,
 524                             memory_order __m2) volatile noexcept
 525       {
 526         // __glibcxx_assert(__m2 != memory_order_release);
 527         // __glibcxx_assert(__m2 != memory_order_acq_rel);
 528         // __glibcxx_assert(__m2 <= __m1);
 529
 530         return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1, __m1, __m2);
 531       }
 532
 533       __libitm_always_inline bool
 534       compare_exchange_weak(__int_type& __i1, __int_type __i2,
 535                             memory_order __m = memory_order_seq_cst) noexcept
 536       {
 537         return compare_exchange_weak(__i1, __i2, __m,
 538                                      __calculate_memory_order(__m));
 539       }
 540
 541       __libitm_always_inline bool
 542       compare_exchange_weak(__int_type& __i1, __int_type __i2,
 543                    memory_order __m = memory_order_seq_cst) volatile noexcept
 544       {
 545         return compare_exchange_weak(__i1, __i2, __m,
 546                                      __calculate_memory_order(__m));
 547       }
 548
 549       __libitm_always_inline bool
 550       compare_exchange_strong(__int_type& __i1, __int_type __i2,
 551                               memory_order __m1, memory_order __m2) noexcept
 552       {
 553         // __glibcxx_assert(__m2 != memory_order_release);
 554         // __glibcxx_assert(__m2 != memory_order_acq_rel);
 555         // __glibcxx_assert(__m2 <= __m1);
 556
 557         return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0, __m1, __m2);
 558       }
 559
 560       __libitm_always_inline bool
 561       compare_exchange_strong(__int_type& __i1, __int_type __i2,
 562                               memory_order __m1,
 563                               memory_order __m2) volatile noexcept
 564       {
 565         // __glibcxx_assert(__m2 != memory_order_release);
 566         // __glibcxx_assert(__m2 != memory_order_acq_rel);
 567         // __glibcxx_assert(__m2 <= __m1);
 568
 569         return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0, __m1, __m2);
 570       }
 571
 572       __libitm_always_inline bool
 573       compare_exchange_strong(__int_type& __i1, __int_type __i2,
 574                               memory_order __m = memory_order_seq_cst) noexcept
 575       {
 576         return compare_exchange_strong(__i1, __i2, __m,
 577                                        __calculate_memory_order(__m));
 578       }
 579
 580       __libitm_always_inline bool
 581       compare_exchange_strong(__int_type& __i1, __int_type __i2,
 582                  memory_order __m = memory_order_seq_cst) volatile noexcept
 583       {
 584         return compare_exchange_strong(__i1, __i2, __m,
 585                                        __calculate_memory_order(__m));
 586       }
 587
 588       __libitm_always_inline __int_type
 589       fetch_add(__int_type __i,
 590                 memory_order __m = memory_order_seq_cst) noexcept
 591       { return __atomic_fetch_add(&_M_i, __i, __m); }
 592
 593       __libitm_always_inline __int_type
 594       fetch_add(__int_type __i,
 595                 memory_order __m = memory_order_seq_cst) volatile noexcept
 596       { return __atomic_fetch_add(&_M_i, __i, __m); }
 597
 598       __libitm_always_inline __int_type
 599       fetch_sub(__int_type __i,
 600                 memory_order __m = memory_order_seq_cst) noexcept
 601       { return __atomic_fetch_sub(&_M_i, __i, __m); }
 602
 603       __libitm_always_inline __int_type
 604       fetch_sub(__int_type __i,
 605                 memory_order __m = memory_order_seq_cst) volatile noexcept
 606       { return __atomic_fetch_sub(&_M_i, __i, __m); }
 607
 608       __libitm_always_inline __int_type
 609       fetch_and(__int_type __i,
 610                 memory_order __m = memory_order_seq_cst) noexcept
 611       { return __atomic_fetch_and(&_M_i, __i, __m); }
 612
 613       __libitm_always_inline __int_type
 614       fetch_and(__int_type __i,
 615                 memory_order __m = memory_order_seq_cst) volatile noexcept
 616       { return __atomic_fetch_and(&_M_i, __i, __m); }
 617
 618       __libitm_always_inline __int_type
 619       fetch_or(__int_type __i,
 620                memory_order __m = memory_order_seq_cst) noexcept
 621       { return __atomic_fetch_or(&_M_i, __i, __m); }
 622
 623       __libitm_always_inline __int_type
 624       fetch_or(__int_type __i,
 625                memory_order __m = memory_order_seq_cst) volatile noexcept
 626       { return __atomic_fetch_or(&_M_i, __i, __m); }
 627
 628       __libitm_always_inline __int_type
 629       fetch_xor(__int_type __i,
 630                 memory_order __m = memory_order_seq_cst) noexcept
 631       { return __atomic_fetch_xor(&_M_i, __i, __m); }
 632
 633       __libitm_always_inline __int_type
 634       fetch_xor(__int_type __i,
 635                 memory_order __m = memory_order_seq_cst) volatile noexcept
 636       { return __atomic_fetch_xor(&_M_i, __i, __m); }
 637     };
 638
 639
 640   /// Partial specialization for pointer types.
 641   template<typename _PTp>
 642     struct __atomic_base<_PTp*>
 643     {
 644     private:
 645       typedef _PTp*     __pointer_type;
 646
 647       __pointer_type    _M_p;
 648
 649     public:
 650       __atomic_base() noexcept = default;
 651       ~__atomic_base() noexcept = default;
 652       __atomic_base(const __atomic_base&) = delete;
 653       __atomic_base& operator=(const __atomic_base&) = delete;
 654       __atomic_base& operator=(const __atomic_base&) volatile = delete;
 655
 656       // Requires __pointer_type convertible to _M_p.
 657       constexpr __atomic_base(__pointer_type __p) noexcept : _M_p (__p) { }
 658
 659       operator __pointer_type() const noexcept
 660       { return load(); }
 661
 662       operator __pointer_type() const volatile noexcept
 663       { return load(); }
 664
 665       __pointer_type
 666       operator=(__pointer_type __p) noexcept
 667       {
 668         store(__p);
 669         return __p;
 670       }
 671
 672       __pointer_type
 673       operator=(__pointer_type __p) volatile noexcept
 674       {
 675         store(__p);
 676         return __p;
 677       }
 678
 679       __pointer_type
 680       operator++(int) noexcept
 681       { return fetch_add(1); }
 682
 683       __pointer_type
 684       operator++(int) volatile noexcept
 685       { return fetch_add(1); }
 686
 687       __pointer_type
 688       operator--(int) noexcept
 689       { return fetch_sub(1); }
 690
 691       __pointer_type
 692       operator--(int) volatile noexcept
 693       { return fetch_sub(1); }
 694
 695       __pointer_type
 696       operator++() noexcept
 697       { return __atomic_add_fetch(&_M_p, 1, memory_order_seq_cst); }
 698
 699       __pointer_type
 700       operator++() volatile noexcept
 701       { return __atomic_add_fetch(&_M_p, 1, memory_order_seq_cst); }
 702
 703       __pointer_type
 704       operator--() noexcept
 705       { return __atomic_sub_fetch(&_M_p, 1, memory_order_seq_cst); }
 706
 707       __pointer_type
 708       operator--() volatile noexcept
 709       { return __atomic_sub_fetch(&_M_p, 1, memory_order_seq_cst); }
 710
 711       __pointer_type
 712       operator+=(ptrdiff_t __d) noexcept
 713       { return __atomic_add_fetch(&_M_p, __d, memory_order_seq_cst); }
 714
 715       __pointer_type
 716       operator+=(ptrdiff_t __d) volatile noexcept
 717       { return __atomic_add_fetch(&_M_p, __d, memory_order_seq_cst); }
 718
 719       __pointer_type
 720       operator-=(ptrdiff_t __d) noexcept
 721       { return __atomic_sub_fetch(&_M_p, __d, memory_order_seq_cst); }
 722
 723       __pointer_type
 724       operator-=(ptrdiff_t __d) volatile noexcept
 725       { return __atomic_sub_fetch(&_M_p, __d, memory_order_seq_cst); }
 726
 727       bool
 728       is_lock_free() const noexcept
 729       { return __atomic_is_lock_free (sizeof (_M_p), &_M_p); }
 730
 731       bool
 732       is_lock_free() const volatile noexcept
 733       { return __atomic_is_lock_free (sizeof (_M_p), &_M_p); }
 734
 735       __libitm_always_inline void
 736       store(__pointer_type __p,
 737             memory_order __m = memory_order_seq_cst) noexcept
 738       {
 739         // __glibcxx_assert(__m != memory_order_acquire);
 740         // __glibcxx_assert(__m != memory_order_acq_rel);
 741         // __glibcxx_assert(__m != memory_order_consume);
 742
 743         __atomic_store_n(&_M_p, __p, __m);
 744       }
 745
 746       __libitm_always_inline void
 747       store(__pointer_type __p,
 748             memory_order __m = memory_order_seq_cst) volatile noexcept
 749       {
 750         // __glibcxx_assert(__m != memory_order_acquire);
 751         // __glibcxx_assert(__m != memory_order_acq_rel);
 752         // __glibcxx_assert(__m != memory_order_consume);
 753
 754         __atomic_store_n(&_M_p, __p, __m);
 755       }
 756
 757       __libitm_always_inline __pointer_type
 758       load(memory_order __m = memory_order_seq_cst) const noexcept
 759       {
 760         // __glibcxx_assert(__m != memory_order_release);
 761         // __glibcxx_assert(__m != memory_order_acq_rel);
 762
 763         return __atomic_load_n(&_M_p, __m);
 764       }
 765
 766       __libitm_always_inline __pointer_type
 767       load(memory_order __m = memory_order_seq_cst) const volatile noexcept
 768       {
 769         // __glibcxx_assert(__m != memory_order_release);
 770         // __glibcxx_assert(__m != memory_order_acq_rel);
 771
 772         return __atomic_load_n(&_M_p, __m);
 773       }
 774
 775       __libitm_always_inline __pointer_type
 776       exchange(__pointer_type __p,
 777                memory_order __m = memory_order_seq_cst) noexcept
 778       {
 779         return __atomic_exchange_n(&_M_p, __p, __m);
 780       }
 781
 782       __libitm_always_inline __pointer_type
 783       exchange(__pointer_type __p,
 784                memory_order __m = memory_order_seq_cst) volatile noexcept
 785       {
 786         return __atomic_exchange_n(&_M_p, __p, __m);
 787       }
 788
 789       __libitm_always_inline bool
 790       compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
 791                               memory_order __m1,
 792                               memory_order __m2) noexcept
 793       {
 794         // __glibcxx_assert(__m2 != memory_order_release);
 795         // __glibcxx_assert(__m2 != memory_order_acq_rel);
 796         // __glibcxx_assert(__m2 <= __m1);
 797
 798         return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, __m1, __m2);
 799       }
 800
 801       __libitm_always_inline bool
 802       compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
 803                               memory_order __m1,
 804                               memory_order __m2) volatile noexcept
 805       {
 806         // __glibcxx_assert(__m2 != memory_order_release);
 807         // __glibcxx_assert(__m2 != memory_order_acq_rel);
 808         // __glibcxx_assert(__m2 <= __m1);
 809
 810         return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, __m1, __m2);
 811       }
 812
 813       __libitm_always_inline __pointer_type
 814       fetch_add(ptrdiff_t __d,
 815                 memory_order __m = memory_order_seq_cst) noexcept
 816       { return __atomic_fetch_add(&_M_p, __d, __m); }
 817
 818       __libitm_always_inline __pointer_type
 819       fetch_add(ptrdiff_t __d,
 820                 memory_order __m = memory_order_seq_cst) volatile noexcept
 821       { return __atomic_fetch_add(&_M_p, __d, __m); }
 822
 823       __libitm_always_inline __pointer_type
 824       fetch_sub(ptrdiff_t __d,
 825                 memory_order __m = memory_order_seq_cst) noexcept
 826       { return __atomic_fetch_sub(&_M_p, __d, __m); }
 827
 828       __libitm_always_inline __pointer_type
 829       fetch_sub(ptrdiff_t __d,
 830                 memory_order __m = memory_order_seq_cst) volatile noexcept
 831       { return __atomic_fetch_sub(&_M_p, __d, __m); }
 832     };
 833
 834
 835   /**
 836    * @addtogroup atomics
 837    * @{
 838    */
 839
 840   /// atomic_bool
 841   // NB: No operators or fetch-operations for this type.
 842   struct atomic_bool
 843   {
 844   private:
 845     __atomic_base<bool> _M_base;
 846
 847   public:
 848     atomic_bool() noexcept = default;
 849     ~atomic_bool() noexcept = default;
 850     atomic_bool(const atomic_bool&) = delete;
 851     atomic_bool& operator=(const atomic_bool&) = delete;
 852     atomic_bool& operator=(const atomic_bool&) volatile = delete;
 853
 854     constexpr atomic_bool(bool __i) noexcept : _M_base(__i) { }
 855
 856     bool
 857     operator=(bool __i) noexcept
 858     { return _M_base.operator=(__i); }
 859
 860     operator bool() const noexcept
 861     { return _M_base.load(); }
 862
 863     operator bool() const volatile noexcept
 864     { return _M_base.load(); }
 865
 866     bool
 867     is_lock_free() const noexcept { return _M_base.is_lock_free(); }
 868
 869     bool
 870     is_lock_free() const volatile noexcept { return _M_base.is_lock_free(); }
 871
 872     __libitm_always_inline void
 873     store(bool __i, memory_order __m = memory_order_seq_cst) noexcept
 874     { _M_base.store(__i, __m); }
 875
 876     __libitm_always_inline void
 877     store(bool __i, memory_order __m = memory_order_seq_cst) volatile noexcept
 878     { _M_base.store(__i, __m); }
 879
 880     __libitm_always_inline bool
 881     load(memory_order __m = memory_order_seq_cst) const noexcept
 882     { return _M_base.load(__m); }
 883
 884     __libitm_always_inline bool
 885     load(memory_order __m = memory_order_seq_cst) const volatile noexcept
 886     { return _M_base.load(__m); }
 887
 888     __libitm_always_inline bool
 889     exchange(bool __i, memory_order __m = memory_order_seq_cst) noexcept
 890     { return _M_base.exchange(__i, __m); }
 891
 892     __libitm_always_inline bool
 893     exchange(bool __i,
 894              memory_order __m = memory_order_seq_cst) volatile noexcept
 895     { return _M_base.exchange(__i, __m); }
 896
 897     __libitm_always_inline bool
 898     compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1,
 899                           memory_order __m2) noexcept
 900     { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); }
 901
 902     __libitm_always_inline bool
 903     compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1,
 904                           memory_order __m2) volatile noexcept
 905     { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); }
 906
 907     __libitm_always_inline bool
 908     compare_exchange_weak(bool& __i1, bool __i2,
 909                           memory_order __m = memory_order_seq_cst) noexcept
 910     { return _M_base.compare_exchange_weak(__i1, __i2, __m); }
 911
 912     __libitm_always_inline bool
 913     compare_exchange_weak(bool& __i1, bool __i2,
 914                      memory_order __m = memory_order_seq_cst) volatile noexcept
 915     { return _M_base.compare_exchange_weak(__i1, __i2, __m); }
 916
 917     __libitm_always_inline bool
 918     compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1,
 919                             memory_order __m2) noexcept
 920     { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); }
 921
 922     __libitm_always_inline bool
 923     compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1,
 924                             memory_order __m2) volatile noexcept
 925     { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); }
 926
 927     __libitm_always_inline bool
 928     compare_exchange_strong(bool& __i1, bool __i2,
 929                             memory_order __m = memory_order_seq_cst) noexcept
 930     { return _M_base.compare_exchange_strong(__i1, __i2, __m); }
 931
 932     __libitm_always_inline bool
 933     compare_exchange_strong(bool& __i1, bool __i2,
 934                     memory_order __m = memory_order_seq_cst) volatile noexcept
 935     { return _M_base.compare_exchange_strong(__i1, __i2, __m); }
 936   };
 937
 938
 939   /// atomic
 940   /// 29.4.3, Generic atomic type, primary class template.
 941   template<typename _Tp>
 942     struct atomic
 943     {
 944     private:
 945       _Tp _M_i;
 946
 947     public:
 948       atomic() noexcept = default;
 949       ~atomic() noexcept = default;
 950       atomic(const atomic&) = delete;
 951       atomic& operator=(const atomic&) = delete;
 952       atomic& operator=(const atomic&) volatile = delete;
 953
 954       constexpr atomic(_Tp __i) noexcept : _M_i(__i) { }
 955
 956       operator _Tp() const noexcept
 957       { return load(); }
 958
 959       operator _Tp() const volatile noexcept
 960       { return load(); }
 961
 962       _Tp
 963       operator=(_Tp __i) noexcept
 964       { store(__i); return __i; }
 965
 966       _Tp
 967       operator=(_Tp __i) volatile noexcept
 968       { store(__i); return __i; }
 969
 970       bool
 971       is_lock_free() const noexcept
 972       { return __atomic_is_lock_free(sizeof(_M_i), &_M_i); }
 973
 974       bool
 975       is_lock_free() const volatile noexcept
 976       { return __atomic_is_lock_free(sizeof(_M_i), &_M_i); }
 977
 978       void
 979       store(_Tp __i, memory_order _m = memory_order_seq_cst) noexcept
 980       { __atomic_store(&_M_i, &__i, _m); }
 981
 982       __libitm_always_inline void
 983       store(_Tp __i, memory_order _m = memory_order_seq_cst) volatile noexcept
 984       { __atomic_store(&_M_i, &__i, _m); }
 985
 986       __libitm_always_inline _Tp
 987       load(memory_order _m = memory_order_seq_cst) const noexcept
 988       {
 989         _Tp tmp;
 990         __atomic_load(&_M_i, &tmp, _m);
 991         return tmp;
 992       }
 993
 994       __libitm_always_inline _Tp
 995       load(memory_order _m = memory_order_seq_cst) const volatile noexcept
 996       {
 997         _Tp tmp;
 998         __atomic_load(&_M_i, &tmp, _m);
 999         return tmp;
1000       }
1001
1002       __libitm_always_inline _Tp
1003       exchange(_Tp __i, memory_order _m = memory_order_seq_cst) noexcept
1004       {
1005         _Tp tmp;
1006         __atomic_exchange(&_M_i, &__i, &tmp, _m);
1007         return tmp;
1008       }
1009
1010       __libitm_always_inline _Tp
1011       exchange(_Tp __i,
1012                memory_order _m = memory_order_seq_cst) volatile noexcept
1013       {
1014         _Tp tmp;
1015         __atomic_exchange(&_M_i, &__i, &tmp, _m);
1016         return tmp;
1017       }
1018
1019       __libitm_always_inline bool
1020       compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s,
1021                             memory_order __f) noexcept
1022       {
1023         return __atomic_compare_exchange(&_M_i, &__e, &__i, true, __s, __f);
1024       }
1025
1026       __libitm_always_inline bool
1027       compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s,
1028                             memory_order __f) volatile noexcept
1029       {
1030         return __atomic_compare_exchange(&_M_i, &__e, &__i, true, __s, __f);
1031       }
1032
1033       __libitm_always_inline bool
1034       compare_exchange_weak(_Tp& __e, _Tp __i,
1035                             memory_order __m = memory_order_seq_cst) noexcept
1036       { return compare_exchange_weak(__e, __i, __m, __m); }
1037
1038       __libitm_always_inline bool
1039       compare_exchange_weak(_Tp& __e, _Tp __i,
1040                      memory_order __m = memory_order_seq_cst) volatile noexcept
1041       { return compare_exchange_weak(__e, __i, __m, __m); }
1042
1043       __libitm_always_inline bool
1044       compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s,
1045                               memory_order __f) noexcept
1046       {
1047         return __atomic_compare_exchange(&_M_i, &__e, &__i, false, __s, __f);
1048       }
1049
1050       __libitm_always_inline bool
1051       compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s,
1052                               memory_order __f) volatile noexcept
1053       {
1054         return __atomic_compare_exchange(&_M_i, &__e, &__i, false, __s, __f);
1055       }
1056
1057       __libitm_always_inline bool
1058       compare_exchange_strong(_Tp& __e, _Tp __i,
1059                                memory_order __m = memory_order_seq_cst) noexcept
1060       { return compare_exchange_strong(__e, __i, __m, __m); }
1061
1062       __libitm_always_inline bool
1063       compare_exchange_strong(_Tp& __e, _Tp __i,
1064                      memory_order __m = memory_order_seq_cst) volatile noexcept
1065       { return compare_exchange_strong(__e, __i, __m, __m); }
1066     };
1067
1068
1069   /// Partial specialization for pointer types.
1070   template<typename _Tp>
1071     struct atomic<_Tp*>
1072     {
1073       typedef _Tp*                      __pointer_type;
1074       typedef __atomic_base<_Tp*>       __base_type;
1075       __base_type                       _M_b;
1076
1077       atomic() noexcept = default;
1078       ~atomic() noexcept = default;
1079       atomic(const atomic&) = delete;
1080       atomic& operator=(const atomic&) = delete;
1081       atomic& operator=(const atomic&) volatile = delete;
1082
1083       constexpr atomic(__pointer_type __p) noexcept : _M_b(__p) { }
1084
1085       operator __pointer_type() const noexcept
1086       { return __pointer_type(_M_b); }
1087
1088       operator __pointer_type() const volatile noexcept
1089       { return __pointer_type(_M_b); }
1090
1091       __pointer_type
1092       operator=(__pointer_type __p) noexcept
1093       { return _M_b.operator=(__p); }
1094
1095       __pointer_type
1096       operator=(__pointer_type __p) volatile noexcept
1097       { return _M_b.operator=(__p); }
1098
1099       __pointer_type
1100       operator++(int) noexcept
1101       { return _M_b++; }
1102
1103       __pointer_type
1104       operator++(int) volatile noexcept
1105       { return _M_b++; }
1106
1107       __pointer_type
1108       operator--(int) noexcept
1109       { return _M_b--; }
1110
1111       __pointer_type
1112       operator--(int) volatile noexcept
1113       { return _M_b--; }
1114
1115       __pointer_type
1116       operator++() noexcept
1117       { return ++_M_b; }
1118
1119       __pointer_type
1120       operator++() volatile noexcept
1121       { return ++_M_b; }
1122
1123       __pointer_type
1124       operator--() noexcept
1125       { return --_M_b; }
1126
1127       __pointer_type
1128       operator--() volatile noexcept
1129       { return --_M_b; }
1130
1131       __pointer_type
1132       operator+=(ptrdiff_t __d) noexcept
1133       { return _M_b.operator+=(__d); }
1134
1135       __pointer_type
1136       operator+=(ptrdiff_t __d) volatile noexcept
1137       { return _M_b.operator+=(__d); }
1138
1139       __pointer_type
1140       operator-=(ptrdiff_t __d) noexcept
1141       { return _M_b.operator-=(__d); }
1142
1143       __pointer_type
1144       operator-=(ptrdiff_t __d) volatile noexcept
1145       { return _M_b.operator-=(__d); }
1146
1147       bool
1148       is_lock_free() const noexcept
1149       { return _M_b.is_lock_free(); }
1150
1151       bool
1152       is_lock_free() const volatile noexcept
1153       { return _M_b.is_lock_free(); }
1154
1155       __libitm_always_inline void
1156       store(__pointer_type __p,
1157             memory_order __m = memory_order_seq_cst) noexcept
1158       { return _M_b.store(__p, __m); }
1159
1160       __libitm_always_inline void
1161       store(__pointer_type __p,
1162             memory_order __m = memory_order_seq_cst) volatile noexcept
1163       { return _M_b.store(__p, __m); }
1164
1165       __libitm_always_inline __pointer_type
1166       load(memory_order __m = memory_order_seq_cst) const noexcept
1167       { return _M_b.load(__m); }
1168
1169       __libitm_always_inline __pointer_type
1170       load(memory_order __m = memory_order_seq_cst) const volatile noexcept
1171       { return _M_b.load(__m); }
1172
1173       __libitm_always_inline __pointer_type
1174       exchange(__pointer_type __p,
1175                memory_order __m = memory_order_seq_cst) noexcept
1176       { return _M_b.exchange(__p, __m); }
1177
1178       __libitm_always_inline __pointer_type
1179       exchange(__pointer_type __p,
1180                memory_order __m = memory_order_seq_cst) volatile noexcept
1181       { return _M_b.exchange(__p, __m); }
1182
1183       __libitm_always_inline bool
1184       compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
1185                             memory_order __m1, memory_order __m2) noexcept
1186       { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
1187
1188       __libitm_always_inline bool
1189       compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
1190                             memory_order __m1,
1191                             memory_order __m2) volatile noexcept
1192       { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
1193
1194       __libitm_always_inline bool
1195       compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
1196                             memory_order __m = memory_order_seq_cst) noexcept
1197       {
1198         return compare_exchange_weak(__p1, __p2, __m,
1199                                      __calculate_memory_order(__m));
1200       }
1201
1202       __libitm_always_inline bool
1203       compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
1204                     memory_order __m = memory_order_seq_cst) volatile noexcept
1205       {
1206         return compare_exchange_weak(__p1, __p2, __m,
1207                                      __calculate_memory_order(__m));
1208       }
1209
1210       __libitm_always_inline bool
1211       compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
1212                               memory_order __m1, memory_order __m2) noexcept
1213       { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
1214
1215       __libitm_always_inline bool
1216       compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
1217                               memory_order __m1,
1218                               memory_order __m2) volatile noexcept
1219       { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
1220
1221       __libitm_always_inline bool
1222       compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
1223                               memory_order __m = memory_order_seq_cst) noexcept
1224       {
1225         return _M_b.compare_exchange_strong(__p1, __p2, __m,
1226                                             __calculate_memory_order(__m));
1227       }
1228
1229       __libitm_always_inline bool
1230       compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
1231                     memory_order __m = memory_order_seq_cst) volatile noexcept
1232       {
1233         return _M_b.compare_exchange_strong(__p1, __p2, __m,
1234                                             __calculate_memory_order(__m));
1235       }
1236
1237       __libitm_always_inline __pointer_type
1238       fetch_add(ptrdiff_t __d,
1239                 memory_order __m = memory_order_seq_cst) noexcept
1240       { return _M_b.fetch_add(__d, __m); }
1241
1242       __libitm_always_inline __pointer_type
1243       fetch_add(ptrdiff_t __d,
1244                 memory_order __m = memory_order_seq_cst) volatile noexcept
1245       { return _M_b.fetch_add(__d, __m); }
1246
1247       __libitm_always_inline __pointer_type
1248       fetch_sub(ptrdiff_t __d,
1249                 memory_order __m = memory_order_seq_cst) noexcept
1250       { return _M_b.fetch_sub(__d, __m); }
1251
1252       __libitm_always_inline __pointer_type
1253       fetch_sub(ptrdiff_t __d,
1254                 memory_order __m = memory_order_seq_cst) volatile noexcept
1255       { return _M_b.fetch_sub(__d, __m); }
1256     };
1257
1258
1259   /// Explicit specialization for bool.
1260   template<>
1261     struct atomic<bool> : public atomic_bool
1262     {
1263       typedef bool                      __integral_type;
1264       typedef atomic_bool               __base_type;
1265
1266       atomic() noexcept = default;
1267       ~atomic() noexcept = default;
1268       atomic(const atomic&) = delete;
1269       atomic& operator=(const atomic&) = delete;
1270       atomic& operator=(const atomic&) volatile = delete;
1271
1272       constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
1273
1274       using __base_type::operator __integral_type;
1275       using __base_type::operator=;
1276     };
1277
1278   /// Explicit specialization for char.
1279   template<>
1280     struct atomic<char> : public atomic_char
1281     {
1282       typedef char                      __integral_type;
1283       typedef atomic_char               __base_type;
1284
1285       atomic() noexcept = default;
1286       ~atomic() noexcept = default;
1287       atomic(const atomic&) = delete;
1288       atomic& operator=(const atomic&) = delete;
1289       atomic& operator=(const atomic&) volatile = delete;
1290
1291       constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
1292
1293       using __base_type::operator __integral_type;
1294       using __base_type::operator=;
1295     };
1296
1297   /// Explicit specialization for signed char.
1298   template<>
1299     struct atomic<signed char> : public atomic_schar
1300     {
1301       typedef signed char               __integral_type;
1302       typedef atomic_schar              __base_type;
1303
1304       atomic() noexcept= default;
1305       ~atomic() noexcept = default;
1306       atomic(const atomic&) = delete;
1307       atomic& operator=(const atomic&) = delete;
1308       atomic& operator=(const atomic&) volatile = delete;
1309
1310       constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
1311
1312       using __base_type::operator __integral_type;
1313       using __base_type::operator=;
1314     };
1315
1316   /// Explicit specialization for unsigned char.
1317   template<>
1318     struct atomic<unsigned char> : public atomic_uchar
1319     {
1320       typedef unsigned char             __integral_type;
1321       typedef atomic_uchar              __base_type;
1322
1323       atomic() noexcept= default;
1324       ~atomic() noexcept = default;
1325       atomic(const atomic&) = delete;
1326       atomic& operator=(const atomic&) = delete;
1327       atomic& operator=(const atomic&) volatile = delete;
1328
1329       constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
1330
1331       using __base_type::operator __integral_type;
1332       using __base_type::operator=;
1333     };
1334
1335   /// Explicit specialization for short.
1336   template<>
1337     struct atomic<short> : public atomic_short
1338     {
1339       typedef short                     __integral_type;
1340       typedef atomic_short              __base_type;
1341
1342       atomic() noexcept = default;
1343       ~atomic() noexcept = default;
1344       atomic(const atomic&) = delete;
1345       atomic& operator=(const atomic&) = delete;
1346       atomic& operator=(const atomic&) volatile = delete;
1347
1348       constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
1349
1350       using __base_type::operator __integral_type;
1351       using __base_type::operator=;
1352     };
1353
1354   /// Explicit specialization for unsigned short.
1355   template<>
1356     struct atomic<unsigned short> : public atomic_ushort
1357     {
1358       typedef unsigned short            __integral_type;
1359       typedef atomic_ushort             __base_type;
1360
1361       atomic() noexcept = default;
1362       ~atomic() noexcept = default;
1363       atomic(const atomic&) = delete;
1364       atomic& operator=(const atomic&) = delete;
1365       atomic& operator=(const atomic&) volatile = delete;
1366
1367       constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
1368
1369       using __base_type::operator __integral_type;
1370       using __base_type::operator=;
1371     };
1372
1373   /// Explicit specialization for int.
1374   template<>
1375     struct atomic<int> : atomic_int
1376     {
1377       typedef int                       __integral_type;
1378       typedef atomic_int                __base_type;
1379
1380       atomic() noexcept = default;
1381       ~atomic() noexcept = default;
1382       atomic(const atomic&) = delete;
1383       atomic& operator=(const atomic&) = delete;
1384       atomic& operator=(const atomic&) volatile = delete;
1385
1386       constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
1387
1388       using __base_type::operator __integral_type;
1389       using __base_type::operator=;
1390     };
1391
1392   /// Explicit specialization for unsigned int.
1393   template<>
1394     struct atomic<unsigned int> : public atomic_uint
1395     {
1396       typedef unsigned int              __integral_type;
1397       typedef atomic_uint               __base_type;
1398
1399       atomic() noexcept = default;
1400       ~atomic() noexcept = default;
1401       atomic(const atomic&) = delete;
1402       atomic& operator=(const atomic&) = delete;
1403       atomic& operator=(const atomic&) volatile = delete;
1404
1405       constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
1406
1407       using __base_type::operator __integral_type;
1408       using __base_type::operator=;
1409     };
1410
1411   /// Explicit specialization for long.
1412   template<>
1413     struct atomic<long> : public atomic_long
1414     {
1415       typedef long                      __integral_type;
1416       typedef atomic_long               __base_type;
1417
1418       atomic() noexcept = default;
1419       ~atomic() noexcept = default;
1420       atomic(const atomic&) = delete;
1421       atomic& operator=(const atomic&) = delete;
1422       atomic& operator=(const atomic&) volatile = delete;
1423
1424       constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
1425
1426       using __base_type::operator __integral_type;
1427       using __base_type::operator=;
1428     };
1429
1430   /// Explicit specialization for unsigned long.
1431   template<>
1432     struct atomic<unsigned long> : public atomic_ulong
1433     {
1434       typedef unsigned long             __integral_type;
1435       typedef atomic_ulong              __base_type;
1436
1437       atomic() noexcept = default;
1438       ~atomic() noexcept = default;
1439       atomic(const atomic&) = delete;
1440       atomic& operator=(const atomic&) = delete;
1441       atomic& operator=(const atomic&) volatile = delete;
1442
1443       constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
1444
1445       using __base_type::operator __integral_type;
1446       using __base_type::operator=;
1447     };
1448
1449   /// Explicit specialization for long long.
1450   template<>
1451     struct atomic<long long> : public atomic_llong
1452     {
1453       typedef long long                 __integral_type;
1454       typedef atomic_llong              __base_type;
1455
1456       atomic() noexcept = default;
1457       ~atomic() noexcept = default;
1458       atomic(const atomic&) = delete;
1459       atomic& operator=(const atomic&) = delete;
1460       atomic& operator=(const atomic&) volatile = delete;
1461
1462       constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
1463
1464       using __base_type::operator __integral_type;
1465       using __base_type::operator=;
1466     };
1467
1468   /// Explicit specialization for unsigned long long.
1469   template<>
1470     struct atomic<unsigned long long> : public atomic_ullong
1471     {
1472       typedef unsigned long long        __integral_type;
1473       typedef atomic_ullong             __base_type;
1474
1475       atomic() noexcept = default;
1476       ~atomic() noexcept = default;
1477       atomic(const atomic&) = delete;
1478       atomic& operator=(const atomic&) = delete;
1479       atomic& operator=(const atomic&) volatile = delete;
1480
1481       constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
1482
1483       using __base_type::operator __integral_type;
1484       using __base_type::operator=;
1485     };
1486
1487   /// Explicit specialization for wchar_t.
1488   template<>
1489     struct atomic<wchar_t> : public atomic_wchar_t
1490     {
1491       typedef wchar_t                   __integral_type;
1492       typedef atomic_wchar_t            __base_type;
1493
1494       atomic() noexcept = default;
1495       ~atomic() noexcept = default;
1496       atomic(const atomic&) = delete;
1497       atomic& operator=(const atomic&) = delete;
1498       atomic& operator=(const atomic&) volatile = delete;
1499
1500       constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
1501
1502       using __base_type::operator __integral_type;
1503       using __base_type::operator=;
1504     };
1505
1506   /// Explicit specialization for char16_t.
1507   template<>
1508     struct atomic<char16_t> : public atomic_char16_t
1509     {
1510       typedef char16_t                  __integral_type;
1511       typedef atomic_char16_t           __base_type;
1512
1513       atomic() noexcept = default;
1514       ~atomic() noexcept = default;
1515       atomic(const atomic&) = delete;
1516       atomic& operator=(const atomic&) = delete;
1517       atomic& operator=(const atomic&) volatile = delete;
1518
1519       constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
1520
1521       using __base_type::operator __integral_type;
1522       using __base_type::operator=;
1523     };
1524
1525   /// Explicit specialization for char32_t.
1526   template<>
1527     struct atomic<char32_t> : public atomic_char32_t
1528     {
1529       typedef char32_t                  __integral_type;
1530       typedef atomic_char32_t           __base_type;
1531
1532       atomic() noexcept = default;
1533       ~atomic() noexcept = default;
1534       atomic(const atomic&) = delete;
1535       atomic& operator=(const atomic&) = delete;
1536       atomic& operator=(const atomic&) volatile = delete;
1537
1538       constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
1539
1540       using __base_type::operator __integral_type;
1541       using __base_type::operator=;
1542     };
1543
1544
1545   // Function definitions, atomic_flag operations.
1546   inline __libitm_always_inline bool
1547   atomic_flag_test_and_set_explicit(atomic_flag* __a,
1548                                     memory_order __m) noexcept
1549   { return __a->test_and_set(__m); }
1550
1551   inline __libitm_always_inline bool
1552   atomic_flag_test_and_set_explicit(volatile atomic_flag* __a,
1553                                     memory_order __m) noexcept
1554   { return __a->test_and_set(__m); }
1555
1556   inline __libitm_always_inline void
1557   atomic_flag_clear_explicit(atomic_flag* __a, memory_order __m) noexcept
1558   { __a->clear(__m); }
1559
1560   inline __libitm_always_inline void
1561   atomic_flag_clear_explicit(volatile atomic_flag* __a,
1562                              memory_order __m) noexcept
1563   { __a->clear(__m); }
1564
1565   inline __libitm_always_inline bool
1566   atomic_flag_test_and_set(atomic_flag* __a) noexcept
1567   { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }
1568
1569   inline __libitm_always_inline bool
1570   atomic_flag_test_and_set(volatile atomic_flag* __a) noexcept
1571   { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }
1572
1573   inline __libitm_always_inline void
1574   atomic_flag_clear(atomic_flag* __a) noexcept
1575   { atomic_flag_clear_explicit(__a, memory_order_seq_cst); }
1576
1577   inline __libitm_always_inline void
1578   atomic_flag_clear(volatile atomic_flag* __a) noexcept
1579   { atomic_flag_clear_explicit(__a, memory_order_seq_cst); }
1580
1581
1582   // Function templates generally applicable to atomic types.
1583   template<typename _ITp>
1584     __libitm_always_inline bool
1585     atomic_is_lock_free(const atomic<_ITp>* __a) noexcept
1586     { return __a->is_lock_free(); }
1587
1588   template<typename _ITp>
1589     __libitm_always_inline bool
1590     atomic_is_lock_free(const volatile atomic<_ITp>* __a) noexcept
1591     { return __a->is_lock_free(); }
1592
1593   template<typename _ITp>
1594     __libitm_always_inline void
1595     atomic_init(atomic<_ITp>* __a, _ITp __i) noexcept;
1596
1597   template<typename _ITp>
1598     __libitm_always_inline void
1599     atomic_init(volatile atomic<_ITp>* __a, _ITp __i) noexcept;
1600
1601   template<typename _ITp>
1602     __libitm_always_inline void
1603     atomic_store_explicit(atomic<_ITp>* __a, _ITp __i,
1604                           memory_order __m) noexcept
1605     { __a->store(__i, __m); }
1606
1607   template<typename _ITp>
1608     __libitm_always_inline void
1609     atomic_store_explicit(volatile atomic<_ITp>* __a, _ITp __i,
1610                           memory_order __m) noexcept
1611     { __a->store(__i, __m); }
1612
1613   template<typename _ITp>
1614     __libitm_always_inline _ITp
1615     atomic_load_explicit(const atomic<_ITp>* __a, memory_order __m) noexcept
1616     { return __a->load(__m); }
1617
1618   template<typename _ITp>
1619     __libitm_always_inline _ITp
1620     atomic_load_explicit(const volatile atomic<_ITp>* __a,
1621                          memory_order __m) noexcept
1622     { return __a->load(__m); }
1623
1624   template<typename _ITp>
1625     __libitm_always_inline _ITp
1626     atomic_exchange_explicit(atomic<_ITp>* __a, _ITp __i,
1627                              memory_order __m) noexcept
1628     { return __a->exchange(__i, __m); }
1629
1630   template<typename _ITp>
1631     __libitm_always_inline _ITp
1632     atomic_exchange_explicit(volatile atomic<_ITp>* __a, _ITp __i,
1633                              memory_order __m) noexcept
1634     { return __a->exchange(__i, __m); }
1635
1636   template<typename _ITp>
1637     __libitm_always_inline bool
1638     atomic_compare_exchange_weak_explicit(atomic<_ITp>* __a,
1639                                           _ITp* __i1, _ITp __i2,
1640                                           memory_order __m1,
1641                                           memory_order __m2) noexcept
1642     { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
1643
1644   template<typename _ITp>
1645     __libitm_always_inline bool
1646     atomic_compare_exchange_weak_explicit(volatile atomic<_ITp>* __a,
1647                                           _ITp* __i1, _ITp __i2,
1648                                           memory_order __m1,
1649                                           memory_order __m2) noexcept
1650     { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
1651
1652   template<typename _ITp>
1653     __libitm_always_inline bool
1654     atomic_compare_exchange_strong_explicit(atomic<_ITp>* __a,
1655                                             _ITp* __i1, _ITp __i2,
1656                                             memory_order __m1,
1657                                             memory_order __m2) noexcept
1658     { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
1659
1660   template<typename _ITp>
1661     __libitm_always_inline bool
1662     atomic_compare_exchange_strong_explicit(volatile atomic<_ITp>* __a,
1663                                             _ITp* __i1, _ITp __i2,
1664                                             memory_order __m1,
1665                                             memory_order __m2) noexcept
1666     { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
1667
1668
1669   template<typename _ITp>
1670     __libitm_always_inline void
1671     atomic_store(atomic<_ITp>* __a, _ITp __i) noexcept
1672     { atomic_store_explicit(__a, __i, memory_order_seq_cst); }
1673
1674   template<typename _ITp>
1675     __libitm_always_inline void
1676     atomic_store(volatile atomic<_ITp>* __a, _ITp __i) noexcept
1677     { atomic_store_explicit(__a, __i, memory_order_seq_cst); }
1678
1679   template<typename _ITp>
1680     __libitm_always_inline _ITp
1681     atomic_load(const atomic<_ITp>* __a) noexcept
1682     { return atomic_load_explicit(__a, memory_order_seq_cst); }
1683
1684   template<typename _ITp>
1685     __libitm_always_inline _ITp
1686     atomic_load(const volatile atomic<_ITp>* __a) noexcept
1687     { return atomic_load_explicit(__a, memory_order_seq_cst); }
1688
1689   template<typename _ITp>
1690     __libitm_always_inline _ITp
1691     atomic_exchange(atomic<_ITp>* __a, _ITp __i) noexcept
1692     { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
1693
1694   template<typename _ITp>
1695     __libitm_always_inline _ITp
1696     atomic_exchange(volatile atomic<_ITp>* __a, _ITp __i) noexcept
1697     { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
1698
1699   template<typename _ITp>
1700     __libitm_always_inline bool
1701     atomic_compare_exchange_weak(atomic<_ITp>* __a,
1702                                  _ITp* __i1, _ITp __i2) noexcept
1703     {
1704       return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
1705                                                    memory_order_seq_cst,
1706                                                    memory_order_seq_cst);
1707     }
1708
1709   template<typename _ITp>
1710     __libitm_always_inline bool
1711     atomic_compare_exchange_weak(volatile atomic<_ITp>* __a,
1712                                  _ITp* __i1, _ITp __i2) noexcept
1713     {
1714       return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
1715                                                    memory_order_seq_cst,
1716                                                    memory_order_seq_cst);
1717     }
1718
1719   template<typename _ITp>
1720     __libitm_always_inline bool
1721     atomic_compare_exchange_strong(atomic<_ITp>* __a,
1722                                    _ITp* __i1, _ITp __i2) noexcept
1723     {
1724       return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
1725                                                      memory_order_seq_cst,
1726                                                      memory_order_seq_cst);
1727     }
1728
1729   template<typename _ITp>
1730     __libitm_always_inline bool
1731     atomic_compare_exchange_strong(volatile atomic<_ITp>* __a,
1732                                    _ITp* __i1, _ITp __i2) noexcept
1733     {
1734       return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
1735                                                      memory_order_seq_cst,
1736                                                      memory_order_seq_cst);
1737     }
1738
1739   // Function templates for atomic_integral operations only, using
1740   // __atomic_base. Template argument should be constricted to
1741   // intergral types as specified in the standard, excluding address
1742   // types.
1743   template<typename _ITp>
1744     __libitm_always_inline _ITp
1745     atomic_fetch_add_explicit(__atomic_base<_ITp>* __a, _ITp __i,
1746                               memory_order __m) noexcept
1747     { return __a->fetch_add(__i, __m); }
1748
1749   template<typename _ITp>
1750     __libitm_always_inline _ITp
1751     atomic_fetch_add_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
1752                               memory_order __m) noexcept
1753     { return __a->fetch_add(__i, __m); }
1754
1755   template<typename _ITp>
1756     __libitm_always_inline _ITp
1757     atomic_fetch_sub_explicit(__atomic_base<_ITp>* __a, _ITp __i,
1758                               memory_order __m) noexcept
1759     { return __a->fetch_sub(__i, __m); }
1760
1761   template<typename _ITp>
1762     __libitm_always_inline _ITp
1763     atomic_fetch_sub_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
1764                               memory_order __m) noexcept
1765     { return __a->fetch_sub(__i, __m); }
1766
1767   template<typename _ITp>
1768     __libitm_always_inline _ITp
1769     atomic_fetch_and_explicit(__atomic_base<_ITp>* __a, _ITp __i,
1770                               memory_order __m) noexcept
1771     { return __a->fetch_and(__i, __m); }
1772
1773   template<typename _ITp>
1774     __libitm_always_inline _ITp
1775     atomic_fetch_and_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
1776                               memory_order __m) noexcept
1777     { return __a->fetch_and(__i, __m); }
1778
1779   template<typename _ITp>
1780     __libitm_always_inline _ITp
1781     atomic_fetch_or_explicit(__atomic_base<_ITp>* __a, _ITp __i,
1782                              memory_order __m) noexcept
1783     { return __a->fetch_or(__i, __m); }
1784
1785   template<typename _ITp>
1786     __libitm_always_inline _ITp
1787     atomic_fetch_or_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
1788                              memory_order __m) noexcept
1789     { return __a->fetch_or(__i, __m); }
1790
1791   template<typename _ITp>
1792     __libitm_always_inline _ITp
1793     atomic_fetch_xor_explicit(__atomic_base<_ITp>* __a, _ITp __i,
1794                               memory_order __m) noexcept
1795     { return __a->fetch_xor(__i, __m); }
1796
1797   template<typename _ITp>
1798     __libitm_always_inline _ITp
1799     atomic_fetch_xor_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
1800                               memory_order __m) noexcept
1801     { return __a->fetch_xor(__i, __m); }
1802
1803   template<typename _ITp>
1804     __libitm_always_inline _ITp
1805     atomic_fetch_add(__atomic_base<_ITp>* __a, _ITp __i) noexcept
1806     { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
1807
1808   template<typename _ITp>
1809     __libitm_always_inline _ITp
1810     atomic_fetch_add(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
1811     { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
1812
1813   template<typename _ITp>
1814     __libitm_always_inline _ITp
1815     atomic_fetch_sub(__atomic_base<_ITp>* __a, _ITp __i) noexcept
1816     { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
1817
1818   template<typename _ITp>
1819     __libitm_always_inline _ITp
1820     atomic_fetch_sub(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
1821     { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
1822
1823   template<typename _ITp>
1824     __libitm_always_inline _ITp
1825     atomic_fetch_and(__atomic_base<_ITp>* __a, _ITp __i) noexcept
1826     { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }
1827
1828   template<typename _ITp>
1829     __libitm_always_inline _ITp
1830     atomic_fetch_and(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
1831     { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }
1832
1833   template<typename _ITp>
1834     __libitm_always_inline _ITp
1835     atomic_fetch_or(__atomic_base<_ITp>* __a, _ITp __i) noexcept
1836     { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }
1837
1838   template<typename _ITp>
1839     __libitm_always_inline _ITp
1840     atomic_fetch_or(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
1841     { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }
1842
1843   template<typename _ITp>
1844     __libitm_always_inline _ITp
1845     atomic_fetch_xor(__atomic_base<_ITp>* __a, _ITp __i) noexcept
1846     { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
1847
1848   template<typename _ITp>
1849     __libitm_always_inline _ITp
1850     atomic_fetch_xor(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
1851     { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
1852
1853
1854   // Partial specializations for pointers.
1855   template<typename _ITp>
1856     __libitm_always_inline _ITp*
1857     atomic_fetch_add_explicit(atomic<_ITp*>* __a, ptrdiff_t __d,
1858                               memory_order __m) noexcept
1859     { return __a->fetch_add(__d, __m); }
1860
1861   template<typename _ITp>
1862     __libitm_always_inline _ITp*
1863     atomic_fetch_add_explicit(volatile atomic<_ITp*>* __a, ptrdiff_t __d,
1864                               memory_order __m) noexcept
1865     { return __a->fetch_add(__d, __m); }
1866
1867   template<typename _ITp>
1868     __libitm_always_inline _ITp*
1869     atomic_fetch_add(volatile atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
1870     { return __a->fetch_add(__d); }
1871
1872   template<typename _ITp>
1873     __libitm_always_inline _ITp*
1874     atomic_fetch_add(atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
1875     { return __a->fetch_add(__d); }
1876
1877   template<typename _ITp>
1878     __libitm_always_inline _ITp*
1879     atomic_fetch_sub_explicit(volatile atomic<_ITp*>* __a,
1880                               ptrdiff_t __d, memory_order __m) noexcept
1881     { return __a->fetch_sub(__d, __m); }
1882
1883   template<typename _ITp>
1884     __libitm_always_inline _ITp*
1885     atomic_fetch_sub_explicit(atomic<_ITp*>* __a, ptrdiff_t __d,
1886                               memory_order __m) noexcept
1887     { return __a->fetch_sub(__d, __m); }
1888
1889   template<typename _ITp>
1890     __libitm_always_inline _ITp*
1891     atomic_fetch_sub(volatile atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
1892     { return __a->fetch_sub(__d); }
1893
1894   template<typename _ITp>
1895     __libitm_always_inline _ITp*
1896     atomic_fetch_sub(atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
1897     { return __a->fetch_sub(__d); }
1898   // @} group atomics
1899
1900 // _GLIBCXX_END_NAMESPACE_VERSION
1901 } // namespace
1902
1903 #endif