libstdc++-v3/include/c_global/cstdatomic

   1 // -*- C++ -*- header.
   2
   3 // Copyright (C) 2008, 2009
   4 // Free Software Foundation, Inc.
   5 //
   6 // This file is part of the GNU ISO C++ Library.  This library is free
   7 // software; you can redistribute it and/or modify it under the
   8 // terms of the GNU General Public License as published by the
   9 // Free Software Foundation; either version 3, or (at your option)
  10 // any later version.
  11
  12 // This library is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // GNU General Public License for more details.
  16
  17 // Under Section 7 of GPL version 3, you are granted additional
  18 // permissions described in the GCC Runtime Library Exception, version
  19 // 3.1, as published by the Free Software Foundation.
  20
  21 // You should have received a copy of the GNU General Public License and
  22 // a copy of the GCC Runtime Library Exception along with this program;
  23 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  24 // <http://www.gnu.org/licenses/>.
  25
  26 /** @file cstdatomic
  27  *  This is a Standard C++ Library file.  You should @c \#include this file
  28  *  in your programs, rather than any of the "*.h" implementation files.
  29  *
  30  *  This is the C++ version of the Standard C Library header @c stdatomic.h,
  31  *  and its contents are (mostly) the same as that header, but are all
  32  *  contained in the namespace @c std (except for names which are defined
  33  *  as macros in C).
  34  */
  35
  36 // Based on "C++ Atomic Types and Operations" by Hans Boehm and Lawrence Crowl.
  37 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2427.html
  38
  39 #ifndef _GLIBCXX_STDATOMIC
  40 #define _GLIBCXX_STDATOMIC 1
  41
  42 #pragma GCC system_header
  43
  44 #ifndef __GXX_EXPERIMENTAL_CXX0X__
  45 # include <c++0x_warning.h>
  46 #endif
  47
  48 #include <stdatomic.h>
  49 #include <cstddef>
  50
  51 _GLIBCXX_BEGIN_NAMESPACE(std)
  52
  53   /**
  54    * @addtogroup atomics
  55    * @{
  56    */
  57
  58   /// kill_dependency
  59   template<typename _Tp>
  60     inline _Tp
  61     kill_dependency(_Tp __y)
  62     {
  63       _Tp ret(__y);
  64       return ret;
  65     }
  66
  67   inline memory_order
  68   __calculate_memory_order(memory_order __m)
  69   {
  70     const bool __cond1 = __m == memory_order_release;
  71     const bool __cond2 = __m == memory_order_acq_rel;
  72     memory_order __mo1(__cond1 ? memory_order_relaxed : __m);
  73     memory_order __mo2(__cond2 ? memory_order_acquire : __mo1);
  74     return __mo2;
  75   }
  76
  77   //
  78   // Three nested namespaces for atomic implementation details.
  79   //
  80   // The nested namespace inlined into std:: is determined by the value
  81   // of the _GLIBCXX_ATOMIC_PROPERTY macro and the resulting
  82   // ATOMIC_*_LOCK_FREE macros. See file stdatomic.h.
  83   //
  84   // 0 == __atomic0 == Never lock-free
  85   // 1 == __atomic1 == Best available, sometimes lock-free
  86   // 2 == __atomic2 == Always lock-free
  87 #include <bits/atomic_0.h>
  88 #include <bits/atomic_2.h>
  89
  90   /// atomic
  91   /// 29.4.3, Generic atomic type, primary class template.
  92   template<typename _Tp>
  93     struct atomic
  94     {
  95     private:
  96       _Tp _M_i;
  97
  98     public:
  99       atomic() = default;
 100       ~atomic() = default;
 101       atomic(const atomic&) = delete;
 102       atomic& operator=(const atomic&) = delete;
 103
 104       atomic(_Tp __i) : _M_i(__i) { }
 105
 106       operator _Tp() const volatile;
 107
 108       _Tp
 109       operator=(_Tp __i) volatile { store(__i); return __i; }
 110
 111       bool
 112       is_lock_free() const volatile;
 113
 114       void
 115       store(_Tp, memory_order = memory_order_seq_cst) volatile;
 116
 117       _Tp
 118       load(memory_order = memory_order_seq_cst) const volatile;
 119
 120       _Tp
 121       exchange(_Tp __i, memory_order = memory_order_seq_cst) volatile;
 122
 123       bool
 124       compare_exchange_weak(_Tp&, _Tp, memory_order, memory_order) volatile;
 125
 126       bool
 127       compare_exchange_strong(_Tp&, _Tp, memory_order, memory_order) volatile;
 128
 129       bool
 130       compare_exchange_weak(_Tp&, _Tp,
 131                             memory_order = memory_order_seq_cst) volatile;
 132
 133       bool
 134       compare_exchange_strong(_Tp&, _Tp,
 135                               memory_order = memory_order_seq_cst) volatile;
 136     };
 137
 138
 139   /// Partial specialization for pointer types.
 140   template<typename _Tp>
 141     struct atomic<_Tp*> : atomic_address
 142     {
 143       atomic() = default;
 144       ~atomic() = default;
 145       atomic(const atomic&) = delete;
 146       atomic& operator=(const atomic&) = delete;
 147
 148       atomic(_Tp* __v) : atomic_address(__v) { }
 149
 150       void
 151       store(_Tp*, memory_order = memory_order_seq_cst) volatile;
 152
 153       _Tp*
 154       load(memory_order = memory_order_seq_cst) const volatile;
 155
 156       _Tp*
 157       exchange(_Tp*, memory_order = memory_order_seq_cst) volatile;
 158
 159       bool
 160       compare_exchange_weak(_Tp*&, _Tp*, memory_order, memory_order) volatile;
 161
 162       bool
 163       compare_exchange_strong(_Tp*&, _Tp*, memory_order, memory_order) volatile;
 164
 165       bool
 166       compare_exchange_weak(_Tp*&, _Tp*,
 167                             memory_order = memory_order_seq_cst) volatile;
 168
 169       bool
 170       compare_exchange_strong(_Tp*&, _Tp*,
 171                               memory_order = memory_order_seq_cst) volatile;
 172
 173       _Tp*
 174       fetch_add(ptrdiff_t, memory_order = memory_order_seq_cst) volatile;
 175
 176       _Tp*
 177       fetch_sub(ptrdiff_t, memory_order = memory_order_seq_cst) volatile;
 178
 179       operator _Tp*() const volatile
 180       { return load(); }
 181
 182       _Tp*
 183       operator=(_Tp* __v) volatile
 184       {
 185         store(__v);
 186         return __v;
 187       }
 188
 189       _Tp*
 190       operator++(int) volatile { return fetch_add(1); }
 191
 192       _Tp*
 193       operator--(int) volatile { return fetch_sub(1); }
 194
 195       _Tp*
 196       operator++() volatile { return fetch_add(1) + 1; }
 197
 198       _Tp*
 199       operator--() volatile { return fetch_sub(1) - 1; }
 200
 201       _Tp*
 202       operator+=(ptrdiff_t __d) volatile
 203       { return fetch_add(__d) + __d; }
 204
 205       _Tp*
 206       operator-=(ptrdiff_t __d) volatile
 207       { return fetch_sub(__d) - __d; }
 208     };
 209
 210
 211   /// Explicit specialization for void*
 212   template<>
 213     struct atomic<void*> : public atomic_address
 214     {
 215       typedef void*                     __integral_type;
 216       typedef atomic_address            __base_type;
 217
 218       atomic() = default;
 219       ~atomic() = default;
 220       atomic(const atomic&) = delete;
 221       atomic& operator=(const atomic&) = delete;
 222
 223       atomic(__integral_type __i) : __base_type(__i) { }
 224
 225       using __base_type::operator __integral_type;
 226       using __base_type::operator=;
 227     };
 228
 229   /// Explicit specialization for bool.
 230   template<>
 231     struct atomic<bool> : public atomic_bool
 232     {
 233       typedef bool                      __integral_type;
 234       typedef atomic_bool               __base_type;
 235
 236       atomic() = default;
 237       ~atomic() = default;
 238       atomic(const atomic&) = delete;
 239       atomic& operator=(const atomic&) = delete;
 240
 241       atomic(__integral_type __i) : __base_type(__i) { }
 242
 243       using __base_type::operator __integral_type;
 244       using __base_type::operator=;
 245     };
 246
 247   /// Explicit specialization for char.
 248   template<>
 249     struct atomic<char> : public atomic_char
 250     {
 251       typedef char                      __integral_type;
 252       typedef atomic_char               __base_type;
 253
 254       atomic() = default;
 255       ~atomic() = default;
 256       atomic(const atomic&) = delete;
 257       atomic& operator=(const atomic&) = delete;
 258
 259       atomic(__integral_type __i) : __base_type(__i) { }
 260
 261       using __base_type::operator __integral_type;
 262       using __base_type::operator=;
 263     };
 264
 265   /// Explicit specialization for signed char.
 266   template<>
 267     struct atomic<signed char> : public atomic_schar
 268     {
 269       typedef signed char               __integral_type;
 270       typedef atomic_schar              __base_type;
 271
 272       atomic() = default;
 273       ~atomic() = default;
 274       atomic(const atomic&) = delete;
 275       atomic& operator=(const atomic&) = delete;
 276
 277       atomic(__integral_type __i) : __base_type(__i) { }
 278
 279       using __base_type::operator __integral_type;
 280       using __base_type::operator=;
 281     };
 282
 283   /// Explicit specialization for unsigned char.
 284   template<>
 285     struct atomic<unsigned char> : public atomic_uchar
 286     {
 287       typedef unsigned char             __integral_type;
 288       typedef atomic_uchar              __base_type;
 289
 290       atomic() = default;
 291       ~atomic() = default;
 292       atomic(const atomic&) = delete;
 293       atomic& operator=(const atomic&) = delete;
 294
 295       atomic(__integral_type __i) : __base_type(__i) { }
 296
 297       using __base_type::operator __integral_type;
 298       using __base_type::operator=;
 299     };
 300
 301   /// Explicit specialization for short.
 302   template<>
 303     struct atomic<short> : public atomic_short
 304     {
 305       typedef short                     __integral_type;
 306       typedef atomic_short              __base_type;
 307
 308       atomic() = default;
 309       ~atomic() = default;
 310       atomic(const atomic&) = delete;
 311       atomic& operator=(const atomic&) = delete;
 312
 313       atomic(__integral_type __i) : __base_type(__i) { }
 314
 315       using __base_type::operator __integral_type;
 316       using __base_type::operator=;
 317     };
 318
 319   /// Explicit specialization for unsigned short.
 320   template<>
 321     struct atomic<unsigned short> : public atomic_ushort
 322     {
 323       typedef unsigned short            __integral_type;
 324       typedef atomic_ushort             __base_type;
 325
 326       atomic() = default;
 327       ~atomic() = default;
 328       atomic(const atomic&) = delete;
 329       atomic& operator=(const atomic&) = delete;
 330
 331       atomic(__integral_type __i) : __base_type(__i) { }
 332
 333       using __base_type::operator __integral_type;
 334       using __base_type::operator=;
 335     };
 336
 337   /// Explicit specialization for int.
 338   template<>
 339     struct atomic<int> : atomic_int
 340     {
 341       typedef int                       __integral_type;
 342       typedef atomic_int                __base_type;
 343
 344       atomic() = default;
 345       ~atomic() = default;
 346       atomic(const atomic&) = delete;
 347       atomic& operator=(const atomic&) = delete;
 348
 349       atomic(__integral_type __i) : __base_type(__i) { }
 350
 351       using __base_type::operator __integral_type;
 352       using __base_type::operator=;
 353     };
 354
 355   /// Explicit specialization for unsigned int.
 356   template<>
 357     struct atomic<unsigned int> : public atomic_uint
 358     {
 359       typedef unsigned int              __integral_type;
 360       typedef atomic_uint               __base_type;
 361
 362       atomic() = default;
 363       ~atomic() = default;
 364       atomic(const atomic&) = delete;
 365       atomic& operator=(const atomic&) = delete;
 366
 367       atomic(__integral_type __i) : __base_type(__i) { }
 368
 369       using __base_type::operator __integral_type;
 370       using __base_type::operator=;
 371     };
 372
 373   /// Explicit specialization for long.
 374   template<>
 375     struct atomic<long> : public atomic_long
 376     {
 377       typedef long                      __integral_type;
 378       typedef atomic_long               __base_type;
 379
 380       atomic() = default;
 381       ~atomic() = default;
 382       atomic(const atomic&) = delete;
 383       atomic& operator=(const atomic&) = delete;
 384
 385       atomic(__integral_type __i) : __base_type(__i) { }
 386
 387       using __base_type::operator __integral_type;
 388       using __base_type::operator=;
 389     };
 390
 391   /// Explicit specialization for unsigned long.
 392   template<>
 393     struct atomic<unsigned long> : public atomic_ulong
 394     {
 395       typedef unsigned long             __integral_type;
 396       typedef atomic_ulong              __base_type;
 397
 398       atomic() = default;
 399       ~atomic() = default;
 400       atomic(const atomic&) = delete;
 401       atomic& operator=(const atomic&) = delete;
 402
 403       atomic(__integral_type __i) : __base_type(__i) { }
 404
 405       using __base_type::operator __integral_type;
 406       using __base_type::operator=;
 407     };
 408
 409   /// Explicit specialization for long long.
 410   template<>
 411     struct atomic<long long> : public atomic_llong
 412     {
 413       typedef long long                 __integral_type;
 414       typedef atomic_llong              __base_type;
 415
 416       atomic() = default;
 417       ~atomic() = default;
 418       atomic(const atomic&) = delete;
 419       atomic& operator=(const atomic&) = delete;
 420
 421       atomic(__integral_type __i) : __base_type(__i) { }
 422
 423       using __base_type::operator __integral_type;
 424       using __base_type::operator=;
 425     };
 426
 427   /// Explicit specialization for unsigned long long.
 428   template<>
 429     struct atomic<unsigned long long> : public atomic_ullong
 430     {
 431       typedef unsigned long long        __integral_type;
 432       typedef atomic_ullong             __base_type;
 433
 434       atomic() = default;
 435       ~atomic() = default;
 436       atomic(const atomic&) = delete;
 437       atomic& operator=(const atomic&) = delete;
 438
 439       atomic(__integral_type __i) : __base_type(__i) { }
 440
 441       using __base_type::operator __integral_type;
 442       using __base_type::operator=;
 443     };
 444
 445   /// Explicit specialization for wchar_t.
 446   template<>
 447     struct atomic<wchar_t> : public atomic_wchar_t
 448     {
 449       typedef wchar_t                   __integral_type;
 450       typedef atomic_wchar_t            __base_type;
 451
 452       atomic() = default;
 453       ~atomic() = default;
 454       atomic(const atomic&) = delete;
 455       atomic& operator=(const atomic&) = delete;
 456
 457       atomic(__integral_type __i) : __base_type(__i) { }
 458
 459       using __base_type::operator __integral_type;
 460       using __base_type::operator=;
 461     };
 462
 463   /// Explicit specialization for char16_t.
 464   template<>
 465     struct atomic<char16_t> : public atomic_char16_t
 466     {
 467       typedef char16_t                  __integral_type;
 468       typedef atomic_char16_t           __base_type;
 469
 470       atomic() = default;
 471       ~atomic() = default;
 472       atomic(const atomic&) = delete;
 473       atomic& operator=(const atomic&) = delete;
 474
 475       atomic(__integral_type __i) : __base_type(__i) { }
 476
 477       using __base_type::operator __integral_type;
 478       using __base_type::operator=;
 479     };
 480
 481   /// Explicit specialization for char32_t.
 482   template<>
 483     struct atomic<char32_t> : public atomic_char32_t
 484     {
 485       typedef char32_t                  __integral_type;
 486       typedef atomic_char32_t           __base_type;
 487
 488       atomic() = default;
 489       ~atomic() = default;
 490       atomic(const atomic&) = delete;
 491       atomic& operator=(const atomic&) = delete;
 492
 493       atomic(__integral_type __i) : __base_type(__i) { }
 494
 495       using __base_type::operator __integral_type;
 496       using __base_type::operator=;
 497     };
 498
 499
 500   template<typename _Tp>
 501     _Tp*
 502     atomic<_Tp*>::load(memory_order __m) const volatile
 503     { return static_cast<_Tp*>(atomic_address::load(__m)); }
 504
 505   template<typename _Tp>
 506     _Tp*
 507     atomic<_Tp*>::exchange(_Tp* __v, memory_order __m) volatile
 508     { return static_cast<_Tp*>(atomic_address::exchange(__v, __m)); }
 509
 510   template<typename _Tp>
 511     bool
 512     atomic<_Tp*>::compare_exchange_weak(_Tp*& __r, _Tp* __v, memory_order __m1,
 513                                         memory_order __m2) volatile
 514     {
 515       void** __vr = reinterpret_cast<void**>(&__r);
 516       void* __vv = static_cast<void*>(__v);
 517       return atomic_address::compare_exchange_weak(*__vr, __vv, __m1, __m2);
 518     }
 519
 520   template<typename _Tp>
 521     bool
 522     atomic<_Tp*>::compare_exchange_strong(_Tp*& __r, _Tp* __v,
 523                                           memory_order __m1,
 524                                           memory_order __m2) volatile
 525     {
 526       void** __vr = reinterpret_cast<void**>(&__r);
 527       void* __vv = static_cast<void*>(__v);
 528       return atomic_address::compare_exchange_strong(*__vr, __vv, __m1, __m2);
 529     }
 530
 531   template<typename _Tp>
 532     bool
 533     atomic<_Tp*>::compare_exchange_weak(_Tp*& __r, _Tp* __v,
 534                                         memory_order __m) volatile
 535     {
 536       return compare_exchange_weak(__r, __v, __m,
 537                                    __calculate_memory_order(__m));
 538     }
 539
 540   template<typename _Tp>
 541     bool
 542     atomic<_Tp*>::compare_exchange_strong(_Tp*& __r, _Tp* __v,
 543                                         memory_order __m) volatile
 544     {
 545       return compare_exchange_strong(__r, __v, __m,
 546                                      __calculate_memory_order(__m));
 547     }
 548
 549   template<typename _Tp>
 550     _Tp*
 551     atomic<_Tp*>::fetch_add(ptrdiff_t __d, memory_order __m) volatile
 552     {
 553       void* __p = atomic_fetch_add_explicit(this, sizeof(_Tp) * __d, __m);
 554       return static_cast<_Tp*>(__p);
 555     }
 556
 557   template<typename _Tp>
 558     _Tp*
 559     atomic<_Tp*>::fetch_sub(ptrdiff_t __d, memory_order __m) volatile
 560     {
 561       void* __p = atomic_fetch_sub_explicit(this, sizeof(_Tp) * __d, __m);
 562       return static_cast<_Tp*>(__p);
 563     }
 564
 565   // Convenience function definitions, atomic_flag.
 566   inline bool
 567   atomic_flag_test_and_set_explicit(volatile atomic_flag* __a, memory_order __m)
 568   { return __a->test_and_set(__m); }
 569
 570   inline void
 571   atomic_flag_clear_explicit(volatile atomic_flag* __a, memory_order __m)
 572   { return __a->clear(__m); }
 573
 574
 575   // Convenience function definitions, atomic_address.
 576   inline bool
 577   atomic_is_lock_free(const volatile atomic_address* __a)
 578   { return __a->is_lock_free(); }
 579
 580   inline void
 581   atomic_store(volatile atomic_address* __a, void* __v)
 582   { __a->store(__v); }
 583
 584   inline void
 585   atomic_store_explicit(volatile atomic_address* __a, void* __v,
 586                         memory_order __m)
 587   { __a->store(__v, __m); }
 588
 589   inline void*
 590   atomic_load(const volatile atomic_address* __a)
 591   { return __a->load(); }
 592
 593   inline void*
 594   atomic_load_explicit(const volatile atomic_address* __a, memory_order __m)
 595   { return __a->load(__m); }
 596
 597   inline void*
 598   atomic_exchange(volatile atomic_address* __a, void* __v)
 599   { return __a->exchange(__v); }
 600
 601   inline void*
 602   atomic_exchange_explicit(volatile atomic_address* __a, void* __v,
 603                            memory_order __m)
 604   { return __a->exchange(__v, __m); }
 605
 606   inline bool
 607   atomic_compare_exchange_weak(volatile atomic_address* __a,
 608                                void** __v1, void* __v2)
 609   {
 610     return __a->compare_exchange_weak(*__v1, __v2, memory_order_seq_cst,
 611                                       memory_order_seq_cst);
 612   }
 613
 614   inline bool
 615   atomic_compare_exchange_strong(volatile atomic_address* __a,
 616                                void** __v1, void* __v2)
 617   {
 618     return __a->compare_exchange_strong(*__v1, __v2, memory_order_seq_cst,
 619                                       memory_order_seq_cst);
 620   }
 621
 622   inline bool
 623   atomic_compare_exchange_weak_explicit(volatile atomic_address* __a,
 624                                         void** __v1, void* __v2,
 625                                         memory_order __m1, memory_order __m2)
 626   { return __a->compare_exchange_weak(*__v1, __v2, __m1, __m2); }
 627
 628   inline bool
 629   atomic_compare_exchange_strong_explicit(volatile atomic_address* __a,
 630                                         void** __v1, void* __v2,
 631                                         memory_order __m1, memory_order __m2)
 632   { return __a->compare_exchange_strong(*__v1, __v2, __m1, __m2); }
 633
 634   inline void*
 635   atomic_fetch_add_explicit(volatile atomic_address* __a, ptrdiff_t __d,
 636                             memory_order __m)
 637   { return __a->fetch_add(__d, __m); }
 638
 639   inline void*
 640   atomic_fetch_add(volatile atomic_address* __a, ptrdiff_t __d)
 641   { return __a->fetch_add(__d); }
 642
 643   inline void*
 644   atomic_fetch_sub_explicit(volatile atomic_address* __a, ptrdiff_t __d,
 645                             memory_order __m)
 646   { return __a->fetch_sub(__d, __m); }
 647
 648   inline void*
 649   atomic_fetch_sub(volatile atomic_address* __a, ptrdiff_t __d)
 650   { return __a->fetch_sub(__d); }
 651
 652
 653   // Convenience function definitions, atomic_bool.
 654   inline bool
 655   atomic_is_lock_free(const volatile atomic_bool* __a)
 656   { return __a->is_lock_free(); }
 657
 658   inline void
 659   atomic_store(volatile atomic_bool* __a, bool __i)
 660   { __a->store(__i); }
 661
 662   inline void
 663   atomic_store_explicit(volatile atomic_bool* __a, bool __i, memory_order __m)
 664   { __a->store(__i, __m); }
 665
 666   inline bool
 667   atomic_load(const volatile atomic_bool* __a)
 668   { return __a->load(); }
 669
 670   inline bool
 671   atomic_load_explicit(const volatile atomic_bool* __a, memory_order __m)
 672   { return __a->load(__m); }
 673
 674   inline bool
 675   atomic_exchange(volatile atomic_bool* __a, bool __i)
 676   { return __a->exchange(__i); }
 677
 678   inline bool
 679   atomic_exchange_explicit(volatile atomic_bool* __a, bool __i,
 680                            memory_order __m)
 681   { return __a->exchange(__i, __m); }
 682
 683   inline bool
 684   atomic_compare_exchange_weak(volatile atomic_bool* __a, bool* __i1, bool __i2)
 685   {
 686     return __a->compare_exchange_weak(*__i1, __i2, memory_order_seq_cst,
 687                                       memory_order_seq_cst);
 688   }
 689
 690   inline bool
 691   atomic_compare_exchange_strong(volatile atomic_bool* __a,
 692                                  bool* __i1, bool __i2)
 693   {
 694     return __a->compare_exchange_strong(*__i1, __i2, memory_order_seq_cst,
 695                                         memory_order_seq_cst);
 696   }
 697
 698   inline bool
 699   atomic_compare_exchange_weak_explicit(volatile atomic_bool* __a, bool* __i1,
 700                                         bool __i2, memory_order __m1,
 701                                         memory_order __m2)
 702   { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
 703
 704   inline bool
 705   atomic_compare_exchange_strong_explicit(volatile atomic_bool* __a,
 706                                           bool* __i1, bool __i2,
 707                                           memory_order __m1, memory_order __m2)
 708   { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
 709
 710
 711
 712   // Free standing functions. Template argument should be constricted
 713   // to intergral types as specified in the standard.
 714   template<typename _ITp>
 715     inline void
 716     atomic_store_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
 717                           memory_order __m)
 718     { __a->store(__i, __m); }
 719
 720   template<typename _ITp>
 721     inline _ITp
 722     atomic_load_explicit(const volatile __atomic_base<_ITp>* __a,
 723                          memory_order __m)
 724     { return __a->load(__m); }
 725
 726   template<typename _ITp>
 727     inline _ITp
 728     atomic_exchange_explicit(volatile __atomic_base<_ITp>* __a,
 729                              _ITp __i, memory_order __m)
 730     { return __a->exchange(__i, __m); }
 731
 732   template<typename _ITp>
 733     inline bool
 734     atomic_compare_exchange_weak_explicit(volatile __atomic_base<_ITp>* __a,
 735                                           _ITp* __i1, _ITp __i2,
 736                                           memory_order __m1, memory_order __m2)
 737     { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
 738
 739   template<typename _ITp>
 740     inline bool
 741     atomic_compare_exchange_strong_explicit(volatile __atomic_base<_ITp>* __a,
 742                                             _ITp* __i1, _ITp __i2,
 743                                             memory_order __m1,
 744                                             memory_order __m2)
 745     { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
 746
 747   template<typename _ITp>
 748     inline _ITp
 749     atomic_fetch_add_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
 750                               memory_order __m)
 751     { return __a->fetch_add(__i, __m); }
 752
 753   template<typename _ITp>
 754     inline _ITp
 755     atomic_fetch_sub_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
 756                               memory_order __m)
 757     { return __a->fetch_sub(__i, __m); }
 758
 759   template<typename _ITp>
 760     inline _ITp
 761     atomic_fetch_and_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
 762                               memory_order __m)
 763     { return __a->fetch_and(__i, __m); }
 764
 765   template<typename _ITp>
 766     inline _ITp
 767     atomic_fetch_or_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
 768                              memory_order __m)
 769     { return __a->fetch_or(__i, __m); }
 770
 771   template<typename _ITp>
 772     inline _ITp
 773     atomic_fetch_xor_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
 774                               memory_order __m)
 775     { return __a->fetch_xor(__i, __m); }
 776
 777   template<typename _ITp>
 778     inline bool
 779     atomic_is_lock_free(const volatile __atomic_base<_ITp>* __a)
 780     { return __a->is_lock_free(); }
 781
 782   template<typename _ITp>
 783     inline void
 784     atomic_store(volatile __atomic_base<_ITp>* __a, _ITp __i)
 785     { atomic_store_explicit(__a, __i, memory_order_seq_cst); }
 786
 787   template<typename _ITp>
 788     inline _ITp
 789     atomic_load(const volatile __atomic_base<_ITp>* __a)
 790     { return atomic_load_explicit(__a, memory_order_seq_cst); }
 791
 792   template<typename _ITp>
 793     inline _ITp
 794     atomic_exchange(volatile __atomic_base<_ITp>* __a, _ITp __i)
 795     { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
 796
 797   template<typename _ITp>
 798     inline bool
 799     atomic_compare_exchange_weak(volatile __atomic_base<_ITp>* __a,
 800                                  _ITp* __i1, _ITp __i2)
 801     {
 802       return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
 803                                                    memory_order_seq_cst,
 804                                                    memory_order_seq_cst);
 805     }
 806
 807   template<typename _ITp>
 808     inline bool
 809     atomic_compare_exchange_strong(volatile __atomic_base<_ITp>* __a,
 810                                    _ITp* __i1, _ITp __i2)
 811     {
 812       return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
 813                                                      memory_order_seq_cst,
 814                                                      memory_order_seq_cst);
 815     }
 816
 817   template<typename _ITp>
 818     inline _ITp
 819     atomic_fetch_add(volatile __atomic_base<_ITp>* __a, _ITp __i)
 820     { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
 821
 822   template<typename _ITp>
 823     inline _ITp
 824     atomic_fetch_sub(volatile __atomic_base<_ITp>* __a, _ITp __i)
 825     { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
 826
 827   template<typename _ITp>
 828     inline _ITp
 829     atomic_fetch_and(volatile __atomic_base<_ITp>* __a, _ITp __i)
 830     { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }
 831
 832   template<typename _ITp>
 833     inline _ITp
 834     atomic_fetch_or(volatile __atomic_base<_ITp>* __a, _ITp __i)
 835     { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }
 836
 837   template<typename _ITp>
 838     inline _ITp
 839     atomic_fetch_xor(volatile __atomic_base<_ITp>* __a, _ITp __i)
 840     { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
 841
 842   // @} group atomics
 843
 844 _GLIBCXX_END_NAMESPACE
 845
 846 #endif
 847
 848