LCOV - code coverage report
Current view: top level - usr/include/c++/6 - atomic (source / functions) Hit Total Coverage
Test: coverage.info Lines: 3 3 100.0 %
Date: 2018-11-14 16:53:58 Functions: 2 2 100.0 %

          Line data    Source code
       1             : // -*- C++ -*- header.
       2             : 
       3             : // Copyright (C) 2008-2016 Free Software Foundation, Inc.
       4             : //
       5             : // This file is part of the GNU ISO C++ Library.  This library is free
       6             : // software; you can redistribute it and/or modify it under the
       7             : // terms of the GNU General Public License as published by the
       8             : // Free Software Foundation; either version 3, or (at your option)
       9             : // any later version.
      10             : 
      11             : // This library is distributed in the hope that it will be useful,
      12             : // but WITHOUT ANY WARRANTY; without even the implied warranty of
      13             : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      14             : // GNU General Public License for more details.
      15             : 
      16             : // Under Section 7 of GPL version 3, you are granted additional
      17             : // permissions described in the GCC Runtime Library Exception, version
      18             : // 3.1, as published by the Free Software Foundation.
      19             : 
      20             : // You should have received a copy of the GNU General Public License and
      21             : // a copy of the GCC Runtime Library Exception along with this program;
      22             : // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
      23             : // <http://www.gnu.org/licenses/>.
      24             : 
      25             : /** @file include/atomic
      26             :  *  This is a Standard C++ Library header.
      27             :  */
      28             : 
      29             : // Based on "C++ Atomic Types and Operations" by Hans Boehm and Lawrence Crowl.
      30             : // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2427.html
      31             : 
      32             : #ifndef _GLIBCXX_ATOMIC
      33             : #define _GLIBCXX_ATOMIC 1
      34             : 
      35             : #pragma GCC system_header
      36             : 
      37             : #if __cplusplus < 201103L
      38             : # include <bits/c++0x_warning.h>
      39             : #else
      40             : 
      41             : #include <bits/atomic_base.h>
      42             : 
      43             : namespace std _GLIBCXX_VISIBILITY(default)
      44             : {
      45             : _GLIBCXX_BEGIN_NAMESPACE_VERSION
      46             : 
      47             :   /**
      48             :    * @addtogroup atomics
      49             :    * @{
      50             :    */
      51             : 
      52             :   template<typename _Tp>
      53             :     struct atomic;
      54             : 
      55             :   /// atomic<bool>
      56             :   // NB: No operators or fetch-operations for this type.
      57             :   template<>
      58             :   struct atomic<bool>
      59             :   {
      60             :   private:
      61             :     __atomic_base<bool>   _M_base;
      62             : 
      63             :   public:
      64             :     atomic() noexcept = default;
      65             :     ~atomic() noexcept = default;
      66             :     atomic(const atomic&) = delete;
      67             :     atomic& operator=(const atomic&) = delete;
      68             :     atomic& operator=(const atomic&) volatile = delete;
      69             : 
      70             :     constexpr atomic(bool __i) noexcept : _M_base(__i) { }
      71             : 
      72             :     bool
      73             :     operator=(bool __i) noexcept
      74             :     { return _M_base.operator=(__i); }
      75             : 
      76             :     bool
      77             :     operator=(bool __i) volatile noexcept
      78             :     { return _M_base.operator=(__i); }
      79             : 
      80             :     operator bool() const noexcept
      81             :     { return _M_base.load(); }
      82             : 
      83             :     operator bool() const volatile noexcept
      84             :     { return _M_base.load(); }
      85             : 
      86             :     bool
      87             :     is_lock_free() const noexcept { return _M_base.is_lock_free(); }
      88             : 
      89             :     bool
      90             :     is_lock_free() const volatile noexcept { return _M_base.is_lock_free(); }
      91             : 
      92             :     void
      93             :     store(bool __i, memory_order __m = memory_order_seq_cst) noexcept
      94             :     { _M_base.store(__i, __m); }
      95             : 
      96             :     void
      97             :     store(bool __i, memory_order __m = memory_order_seq_cst) volatile noexcept
      98             :     { _M_base.store(__i, __m); }
      99             : 
     100             :     bool
     101          23 :     load(memory_order __m = memory_order_seq_cst) const noexcept
     102          46 :     { return _M_base.load(__m); }
     103             : 
     104             :     bool
     105             :     load(memory_order __m = memory_order_seq_cst) const volatile noexcept
     106             :     { return _M_base.load(__m); }
     107             : 
     108             :     bool
     109             :     exchange(bool __i, memory_order __m = memory_order_seq_cst) noexcept
     110             :     { return _M_base.exchange(__i, __m); }
     111             : 
     112             :     bool
     113             :     exchange(bool __i,
     114             :              memory_order __m = memory_order_seq_cst) volatile noexcept
     115             :     { return _M_base.exchange(__i, __m); }
     116             : 
     117             :     bool
     118             :     compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1,
     119             :                           memory_order __m2) noexcept
     120             :     { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); }
     121             : 
     122             :     bool
     123             :     compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1,
     124             :                           memory_order __m2) volatile noexcept
     125             :     { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); }
     126             : 
     127             :     bool
     128             :     compare_exchange_weak(bool& __i1, bool __i2,
     129             :                           memory_order __m = memory_order_seq_cst) noexcept
     130             :     { return _M_base.compare_exchange_weak(__i1, __i2, __m); }
     131             : 
     132             :     bool
     133             :     compare_exchange_weak(bool& __i1, bool __i2,
     134             :                      memory_order __m = memory_order_seq_cst) volatile noexcept
     135             :     { return _M_base.compare_exchange_weak(__i1, __i2, __m); }
     136             : 
     137             :     bool
     138             :     compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1,
     139             :                             memory_order __m2) noexcept
     140             :     { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); }
     141             : 
     142             :     bool
     143             :     compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1,
     144             :                             memory_order __m2) volatile noexcept
     145             :     { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); }
     146             : 
     147             :     bool
     148             :     compare_exchange_strong(bool& __i1, bool __i2,
     149             :                             memory_order __m = memory_order_seq_cst) noexcept
     150             :     { return _M_base.compare_exchange_strong(__i1, __i2, __m); }
     151             : 
     152             :     bool
     153             :     compare_exchange_strong(bool& __i1, bool __i2,
     154             :                     memory_order __m = memory_order_seq_cst) volatile noexcept
     155             :     { return _M_base.compare_exchange_strong(__i1, __i2, __m); }
     156             :   };
     157             : 
     158             : 
     159             :   /**
     160             :    *  @brief Generic atomic type, primary class template.
     161             :    *
     162             :    *  @tparam _Tp  Type to be made atomic, must be trivally copyable.
     163             :    */
     164             :   template<typename _Tp>
     165             :     struct atomic
     166             :     {
     167             :     private:
     168             :       // Align 1/2/4/8/16-byte types to at least their size.
     169             :       static constexpr int _S_min_alignment
     170             :         = (sizeof(_Tp) & (sizeof(_Tp) - 1)) || sizeof(_Tp) > 16
     171             :         ? 0 : sizeof(_Tp);
     172             : 
     173             :       static constexpr int _S_alignment
     174             :         = _S_min_alignment > alignof(_Tp) ? _S_min_alignment : alignof(_Tp);
     175             : 
     176             :       alignas(_S_alignment) _Tp _M_i;
     177             : 
     178             :       static_assert(__is_trivially_copyable(_Tp),
     179             :                     "std::atomic requires a trivially copyable type");
     180             : 
     181             :       static_assert(sizeof(_Tp) > 0,
     182             :                     "Incomplete or zero-sized types are not supported");
     183             : 
     184             :     public:
     185             :       atomic() noexcept = default;
     186             :       ~atomic() noexcept = default;
     187             :       atomic(const atomic&) = delete;
     188             :       atomic& operator=(const atomic&) = delete;
     189             :       atomic& operator=(const atomic&) volatile = delete;
     190             : 
     191             :       constexpr atomic(_Tp __i) noexcept : _M_i(__i) { }
     192             : 
     193             :       operator _Tp() const noexcept
     194             :       { return load(); }
     195             : 
     196             :       operator _Tp() const volatile noexcept
     197             :       { return load(); }
     198             : 
     199             :       _Tp
     200             :       operator=(_Tp __i) noexcept 
     201             :       { store(__i); return __i; }
     202             : 
     203             :       _Tp
     204             :       operator=(_Tp __i) volatile noexcept 
     205             :       { store(__i); return __i; }
     206             : 
     207             :       bool
     208             :       is_lock_free() const noexcept
     209             :       {
     210             :         // Produce a fake, minimally aligned pointer.
     211             :         return __atomic_is_lock_free(sizeof(_M_i),
     212             :             reinterpret_cast<void *>(-__alignof(_M_i)));
     213             :       }
     214             : 
     215             :       bool
     216             :       is_lock_free() const volatile noexcept
     217             :       {
     218             :         // Produce a fake, minimally aligned pointer.
     219             :         return __atomic_is_lock_free(sizeof(_M_i),
     220             :             reinterpret_cast<void *>(-__alignof(_M_i)));
     221             :       }
     222             : 
     223             :       void
     224             :       store(_Tp __i, memory_order __m = memory_order_seq_cst) noexcept
     225             :       { __atomic_store(&_M_i, &__i, __m); }
     226             : 
     227             :       void
     228             :       store(_Tp __i, memory_order __m = memory_order_seq_cst) volatile noexcept
     229             :       { __atomic_store(&_M_i, &__i, __m); }
     230             : 
     231             :       _Tp
     232             :       load(memory_order __m = memory_order_seq_cst) const noexcept
     233             :       {
     234             :         alignas(_Tp) unsigned char __buf[sizeof(_Tp)];
     235             :         _Tp* __ptr = reinterpret_cast<_Tp*>(__buf);
     236             :         __atomic_load(&_M_i, __ptr, __m);
     237             :         return *__ptr;
     238             :       }
     239             : 
     240             :       _Tp
     241             :       load(memory_order __m = memory_order_seq_cst) const volatile noexcept
     242             :       {
     243             :         alignas(_Tp) unsigned char __buf[sizeof(_Tp)];
     244             :         _Tp* __ptr = reinterpret_cast<_Tp*>(__buf);
     245             :         __atomic_load(&_M_i, __ptr, __m);
     246             :         return *__ptr;
     247             :       }
     248             : 
     249             :       _Tp
     250             :       exchange(_Tp __i, memory_order __m = memory_order_seq_cst) noexcept
     251             :       {
     252             :         alignas(_Tp) unsigned char __buf[sizeof(_Tp)];
     253             :         _Tp* __ptr = reinterpret_cast<_Tp*>(__buf);
     254             :         __atomic_exchange(&_M_i, &__i, __ptr, __m);
     255             :         return *__ptr;
     256             :       }
     257             : 
     258             :       _Tp
     259             :       exchange(_Tp __i, 
     260             :                memory_order __m = memory_order_seq_cst) volatile noexcept
     261             :       {
     262             :         alignas(_Tp) unsigned char __buf[sizeof(_Tp)];
     263             :         _Tp* __ptr = reinterpret_cast<_Tp*>(__buf);
     264             :         __atomic_exchange(&_M_i, &__i, __ptr, __m);
     265             :         return *__ptr;
     266             :       }
     267             : 
     268             :       bool
     269             :       compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s, 
     270             :                             memory_order __f) noexcept
     271             :       {
     272             :         return __atomic_compare_exchange(&_M_i, &__e, &__i, true, __s, __f);
     273             :       }
     274             : 
     275             :       bool
     276             :       compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s, 
     277             :                             memory_order __f) volatile noexcept
     278             :       {
     279             :         return __atomic_compare_exchange(&_M_i, &__e, &__i, true, __s, __f);
     280             :       }
     281             : 
     282             :       bool
     283             :       compare_exchange_weak(_Tp& __e, _Tp __i,
     284             :                             memory_order __m = memory_order_seq_cst) noexcept
     285             :       { return compare_exchange_weak(__e, __i, __m,
     286             :                                      __cmpexch_failure_order(__m)); }
     287             : 
     288             :       bool
     289             :       compare_exchange_weak(_Tp& __e, _Tp __i,
     290             :                      memory_order __m = memory_order_seq_cst) volatile noexcept
     291             :       { return compare_exchange_weak(__e, __i, __m,
     292             :                                      __cmpexch_failure_order(__m)); }
     293             : 
     294             :       bool
     295             :       compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s, 
     296             :                               memory_order __f) noexcept
     297             :       {
     298             :         return __atomic_compare_exchange(&_M_i, &__e, &__i, false, __s, __f);
     299             :       }
     300             : 
     301             :       bool
     302             :       compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s, 
     303             :                               memory_order __f) volatile noexcept
     304             :       {
     305             :         return __atomic_compare_exchange(&_M_i, &__e, &__i, false, __s, __f);
     306             :       }
     307             : 
     308             :       bool
     309             :       compare_exchange_strong(_Tp& __e, _Tp __i,
     310             :                                memory_order __m = memory_order_seq_cst) noexcept
     311             :       { return compare_exchange_strong(__e, __i, __m,
     312             :                                        __cmpexch_failure_order(__m)); }
     313             : 
     314             :       bool
     315             :       compare_exchange_strong(_Tp& __e, _Tp __i,
     316             :                      memory_order __m = memory_order_seq_cst) volatile noexcept
     317             :       { return compare_exchange_strong(__e, __i, __m,
     318             :                                        __cmpexch_failure_order(__m)); }
     319             :     };
     320             : 
     321             : 
     322             :   /// Partial specialization for pointer types.
     323             :   template<typename _Tp>
     324             :     struct atomic<_Tp*>
     325             :     {
     326             :       typedef _Tp*                      __pointer_type;
     327             :       typedef __atomic_base<_Tp*> __base_type;
     328             :       __base_type                       _M_b;
     329             : 
     330             :       atomic() noexcept = default;
     331             :       ~atomic() noexcept = default;
     332             :       atomic(const atomic&) = delete;
     333             :       atomic& operator=(const atomic&) = delete;
     334             :       atomic& operator=(const atomic&) volatile = delete;
     335             : 
     336             :       constexpr atomic(__pointer_type __p) noexcept : _M_b(__p) { }
     337             : 
     338             :       operator __pointer_type() const noexcept
     339             :       { return __pointer_type(_M_b); }
     340             : 
     341             :       operator __pointer_type() const volatile noexcept
     342             :       { return __pointer_type(_M_b); }
     343             : 
     344             :       __pointer_type
     345             :       operator=(__pointer_type __p) noexcept
     346             :       { return _M_b.operator=(__p); }
     347             : 
     348             :       __pointer_type
     349             :       operator=(__pointer_type __p) volatile noexcept
     350             :       { return _M_b.operator=(__p); }
     351             : 
     352             :       __pointer_type
     353             :       operator++(int) noexcept
     354             :       { return _M_b++; }
     355             : 
     356             :       __pointer_type
     357             :       operator++(int) volatile noexcept
     358             :       { return _M_b++; }
     359             : 
     360             :       __pointer_type
     361             :       operator--(int) noexcept
     362             :       { return _M_b--; }
     363             : 
     364             :       __pointer_type
     365             :       operator--(int) volatile noexcept
     366             :       { return _M_b--; }
     367             : 
     368             :       __pointer_type
     369             :       operator++() noexcept
     370             :       { return ++_M_b; }
     371             : 
     372             :       __pointer_type
     373             :       operator++() volatile noexcept
     374             :       { return ++_M_b; }
     375             : 
     376             :       __pointer_type
     377             :       operator--() noexcept
     378             :       { return --_M_b; }
     379             : 
     380             :       __pointer_type
     381             :       operator--() volatile noexcept
     382             :       { return --_M_b; }
     383             : 
     384             :       __pointer_type
     385             :       operator+=(ptrdiff_t __d) noexcept
     386             :       { return _M_b.operator+=(__d); }
     387             : 
     388             :       __pointer_type
     389             :       operator+=(ptrdiff_t __d) volatile noexcept
     390             :       { return _M_b.operator+=(__d); }
     391             : 
     392             :       __pointer_type
     393             :       operator-=(ptrdiff_t __d) noexcept
     394             :       { return _M_b.operator-=(__d); }
     395             : 
     396             :       __pointer_type
     397             :       operator-=(ptrdiff_t __d) volatile noexcept
     398             :       { return _M_b.operator-=(__d); }
     399             : 
     400             :       bool
     401             :       is_lock_free() const noexcept
     402             :       { return _M_b.is_lock_free(); }
     403             : 
     404             :       bool
     405             :       is_lock_free() const volatile noexcept
     406             :       { return _M_b.is_lock_free(); }
     407             : 
     408             :       void
     409             :       store(__pointer_type __p,
     410             :             memory_order __m = memory_order_seq_cst) noexcept
     411             :       { return _M_b.store(__p, __m); }
     412             : 
     413             :       void
     414             :       store(__pointer_type __p,
     415             :             memory_order __m = memory_order_seq_cst) volatile noexcept
     416             :       { return _M_b.store(__p, __m); }
     417             : 
     418             :       __pointer_type
     419             :       load(memory_order __m = memory_order_seq_cst) const noexcept
     420             :       { return _M_b.load(__m); }
     421             : 
     422             :       __pointer_type
     423             :       load(memory_order __m = memory_order_seq_cst) const volatile noexcept
     424             :       { return _M_b.load(__m); }
     425             : 
     426             :       __pointer_type
     427             :       exchange(__pointer_type __p,
     428             :                memory_order __m = memory_order_seq_cst) noexcept
     429             :       { return _M_b.exchange(__p, __m); }
     430             : 
     431             :       __pointer_type
     432             :       exchange(__pointer_type __p,
     433             :                memory_order __m = memory_order_seq_cst) volatile noexcept
     434             :       { return _M_b.exchange(__p, __m); }
     435             : 
     436             :       bool
     437             :       compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
     438             :                             memory_order __m1, memory_order __m2) noexcept
     439             :       { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
     440             : 
     441             :       bool
     442             :       compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
     443             :                             memory_order __m1,
     444             :                             memory_order __m2) volatile noexcept
     445             :       { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
     446             : 
     447             :       bool
     448             :       compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
     449             :                             memory_order __m = memory_order_seq_cst) noexcept
     450             :       {
     451             :         return compare_exchange_weak(__p1, __p2, __m,
     452             :                                      __cmpexch_failure_order(__m));
     453             :       }
     454             : 
     455             :       bool
     456             :       compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
     457             :                     memory_order __m = memory_order_seq_cst) volatile noexcept
     458             :       {
     459             :         return compare_exchange_weak(__p1, __p2, __m,
     460             :                                      __cmpexch_failure_order(__m));
     461             :       }
     462             : 
     463             :       bool
     464             :       compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
     465             :                               memory_order __m1, memory_order __m2) noexcept
     466             :       { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
     467             : 
     468             :       bool
     469             :       compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
     470             :                               memory_order __m1,
     471             :                               memory_order __m2) volatile noexcept
     472             :       { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
     473             : 
     474             :       bool
     475             :       compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
     476             :                               memory_order __m = memory_order_seq_cst) noexcept
     477             :       {
     478             :         return _M_b.compare_exchange_strong(__p1, __p2, __m,
     479             :                                             __cmpexch_failure_order(__m));
     480             :       }
     481             : 
     482             :       bool
     483             :       compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
     484             :                     memory_order __m = memory_order_seq_cst) volatile noexcept
     485             :       {
     486             :         return _M_b.compare_exchange_strong(__p1, __p2, __m,
     487             :                                             __cmpexch_failure_order(__m));
     488             :       }
     489             : 
     490             :       __pointer_type
     491             :       fetch_add(ptrdiff_t __d,
     492             :                 memory_order __m = memory_order_seq_cst) noexcept
     493             :       { return _M_b.fetch_add(__d, __m); }
     494             : 
     495             :       __pointer_type
     496             :       fetch_add(ptrdiff_t __d,
     497             :                 memory_order __m = memory_order_seq_cst) volatile noexcept
     498             :       { return _M_b.fetch_add(__d, __m); }
     499             : 
     500             :       __pointer_type
     501             :       fetch_sub(ptrdiff_t __d,
     502             :                 memory_order __m = memory_order_seq_cst) noexcept
     503             :       { return _M_b.fetch_sub(__d, __m); }
     504             : 
     505             :       __pointer_type
     506             :       fetch_sub(ptrdiff_t __d,
     507             :                 memory_order __m = memory_order_seq_cst) volatile noexcept
     508             :       { return _M_b.fetch_sub(__d, __m); }
     509             :     };
     510             : 
     511             : 
     512             :   /// Explicit specialization for char.
     513             :   template<>
     514             :     struct atomic<char> : __atomic_base<char>
     515             :     {
     516             :       typedef char                      __integral_type;
     517             :       typedef __atomic_base<char>         __base_type;
     518             : 
     519             :       atomic() noexcept = default;
     520             :       ~atomic() noexcept = default;
     521             :       atomic(const atomic&) = delete;
     522             :       atomic& operator=(const atomic&) = delete;
     523             :       atomic& operator=(const atomic&) volatile = delete;
     524             : 
     525             :       constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
     526             : 
     527             :       using __base_type::operator __integral_type;
     528             :       using __base_type::operator=;
     529             :     };
     530             : 
     531             :   /// Explicit specialization for signed char.
     532             :   template<>
     533             :     struct atomic<signed char> : __atomic_base<signed char>
     534             :     {
     535             :       typedef signed char               __integral_type;
     536             :       typedef __atomic_base<signed char>  __base_type;
     537             : 
     538             :       atomic() noexcept= default;
     539             :       ~atomic() noexcept = default;
     540             :       atomic(const atomic&) = delete;
     541             :       atomic& operator=(const atomic&) = delete;
     542             :       atomic& operator=(const atomic&) volatile = delete;
     543             : 
     544             :       constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
     545             : 
     546             :       using __base_type::operator __integral_type;
     547             :       using __base_type::operator=;
     548             :     };
     549             : 
     550             :   /// Explicit specialization for unsigned char.
     551             :   template<>
     552             :     struct atomic<unsigned char> : __atomic_base<unsigned char>
     553             :     {
     554             :       typedef unsigned char             __integral_type;
     555             :       typedef __atomic_base<unsigned char>        __base_type;
     556             : 
     557             :       atomic() noexcept= default;
     558             :       ~atomic() noexcept = default;
     559             :       atomic(const atomic&) = delete;
     560             :       atomic& operator=(const atomic&) = delete;
     561             :       atomic& operator=(const atomic&) volatile = delete;
     562             : 
     563             :       constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
     564             : 
     565             :       using __base_type::operator __integral_type;
     566             :       using __base_type::operator=;
     567             :     };
     568             : 
     569             :   /// Explicit specialization for short.
     570             :   template<>
     571             :     struct atomic<short> : __atomic_base<short>
     572             :     {
     573             :       typedef short                     __integral_type;
     574             :       typedef __atomic_base<short>                __base_type;
     575             : 
     576             :       atomic() noexcept = default;
     577             :       ~atomic() noexcept = default;
     578             :       atomic(const atomic&) = delete;
     579             :       atomic& operator=(const atomic&) = delete;
     580             :       atomic& operator=(const atomic&) volatile = delete;
     581             : 
     582             :       constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
     583             : 
     584             :       using __base_type::operator __integral_type;
     585             :       using __base_type::operator=;
     586             :     };
     587             : 
     588             :   /// Explicit specialization for unsigned short.
     589             :   template<>
     590             :     struct atomic<unsigned short> : __atomic_base<unsigned short>
     591             :     {
     592             :       typedef unsigned short            __integral_type;
     593             :       typedef __atomic_base<unsigned short>               __base_type;
     594             : 
     595             :       atomic() noexcept = default;
     596             :       ~atomic() noexcept = default;
     597             :       atomic(const atomic&) = delete;
     598             :       atomic& operator=(const atomic&) = delete;
     599             :       atomic& operator=(const atomic&) volatile = delete;
     600             : 
     601             :       constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
     602             : 
     603             :       using __base_type::operator __integral_type;
     604             :       using __base_type::operator=;
     605             :     };
     606             : 
     607             :   /// Explicit specialization for int.
     608             :   template<>
     609             :     struct atomic<int> : __atomic_base<int>
     610             :     {
     611             :       typedef int                       __integral_type;
     612             :       typedef __atomic_base<int>          __base_type;
     613             : 
     614             :       atomic() noexcept = default;
     615             :       ~atomic() noexcept = default;
     616             :       atomic(const atomic&) = delete;
     617             :       atomic& operator=(const atomic&) = delete;
     618             :       atomic& operator=(const atomic&) volatile = delete;
     619             : 
     620         100 :       constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
     621             : 
     622             :       using __base_type::operator __integral_type;
     623             :       using __base_type::operator=;
     624             :     };
     625             : 
     626             :   /// Explicit specialization for unsigned int.
     627             :   template<>
     628             :     struct atomic<unsigned int> : __atomic_base<unsigned int>
     629             :     {
     630             :       typedef unsigned int              __integral_type;
     631             :       typedef __atomic_base<unsigned int>         __base_type;
     632             : 
     633             :       atomic() noexcept = default;
     634             :       ~atomic() noexcept = default;
     635             :       atomic(const atomic&) = delete;
     636             :       atomic& operator=(const atomic&) = delete;
     637             :       atomic& operator=(const atomic&) volatile = delete;
     638             : 
     639             :       constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
     640             : 
     641             :       using __base_type::operator __integral_type;
     642             :       using __base_type::operator=;
     643             :     };
     644             : 
     645             :   /// Explicit specialization for long.
     646             :   template<>
     647             :     struct atomic<long> : __atomic_base<long>
     648             :     {
     649             :       typedef long                      __integral_type;
     650             :       typedef __atomic_base<long>         __base_type;
     651             : 
     652             :       atomic() noexcept = default;
     653             :       ~atomic() noexcept = default;
     654             :       atomic(const atomic&) = delete;
     655             :       atomic& operator=(const atomic&) = delete;
     656             :       atomic& operator=(const atomic&) volatile = delete;
     657             : 
     658             :       constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
     659             : 
     660             :       using __base_type::operator __integral_type;
     661             :       using __base_type::operator=;
     662             :     };
     663             : 
     664             :   /// Explicit specialization for unsigned long.
     665             :   template<>
     666             :     struct atomic<unsigned long> : __atomic_base<unsigned long>
     667             :     {
     668             :       typedef unsigned long             __integral_type;
     669             :       typedef __atomic_base<unsigned long>        __base_type;
     670             : 
     671             :       atomic() noexcept = default;
     672             :       ~atomic() noexcept = default;
     673             :       atomic(const atomic&) = delete;
     674             :       atomic& operator=(const atomic&) = delete;
     675             :       atomic& operator=(const atomic&) volatile = delete;
     676             : 
     677             :       constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
     678             : 
     679             :       using __base_type::operator __integral_type;
     680             :       using __base_type::operator=;
     681             :     };
     682             : 
     683             :   /// Explicit specialization for long long.
     684             :   template<>
     685             :     struct atomic<long long> : __atomic_base<long long>
     686             :     {
     687             :       typedef long long                 __integral_type;
     688             :       typedef __atomic_base<long long>            __base_type;
     689             : 
     690             :       atomic() noexcept = default;
     691             :       ~atomic() noexcept = default;
     692             :       atomic(const atomic&) = delete;
     693             :       atomic& operator=(const atomic&) = delete;
     694             :       atomic& operator=(const atomic&) volatile = delete;
     695             : 
     696             :       constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
     697             : 
     698             :       using __base_type::operator __integral_type;
     699             :       using __base_type::operator=;
     700             :     };
     701             : 
     702             :   /// Explicit specialization for unsigned long long.
     703             :   template<>
     704             :     struct atomic<unsigned long long> : __atomic_base<unsigned long long>
     705             :     {
     706             :       typedef unsigned long long        __integral_type;
     707             :       typedef __atomic_base<unsigned long long>   __base_type;
     708             : 
     709             :       atomic() noexcept = default;
     710             :       ~atomic() noexcept = default;
     711             :       atomic(const atomic&) = delete;
     712             :       atomic& operator=(const atomic&) = delete;
     713             :       atomic& operator=(const atomic&) volatile = delete;
     714             : 
     715             :       constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
     716             : 
     717             :       using __base_type::operator __integral_type;
     718             :       using __base_type::operator=;
     719             :     };
     720             : 
     721             :   /// Explicit specialization for wchar_t.
     722             :   template<>
     723             :     struct atomic<wchar_t> : __atomic_base<wchar_t>
     724             :     {
     725             :       typedef wchar_t                   __integral_type;
     726             :       typedef __atomic_base<wchar_t>      __base_type;
     727             : 
     728             :       atomic() noexcept = default;
     729             :       ~atomic() noexcept = default;
     730             :       atomic(const atomic&) = delete;
     731             :       atomic& operator=(const atomic&) = delete;
     732             :       atomic& operator=(const atomic&) volatile = delete;
     733             : 
     734             :       constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
     735             : 
     736             :       using __base_type::operator __integral_type;
     737             :       using __base_type::operator=;
     738             :     };
     739             : 
     740             :   /// Explicit specialization for char16_t.
     741             :   template<>
     742             :     struct atomic<char16_t> : __atomic_base<char16_t>
     743             :     {
     744             :       typedef char16_t                  __integral_type;
     745             :       typedef __atomic_base<char16_t>     __base_type;
     746             : 
     747             :       atomic() noexcept = default;
     748             :       ~atomic() noexcept = default;
     749             :       atomic(const atomic&) = delete;
     750             :       atomic& operator=(const atomic&) = delete;
     751             :       atomic& operator=(const atomic&) volatile = delete;
     752             : 
     753             :       constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
     754             : 
     755             :       using __base_type::operator __integral_type;
     756             :       using __base_type::operator=;
     757             :     };
     758             : 
     759             :   /// Explicit specialization for char32_t.
     760             :   template<>
     761             :     struct atomic<char32_t> : __atomic_base<char32_t>
     762             :     {
     763             :       typedef char32_t                  __integral_type;
     764             :       typedef __atomic_base<char32_t>     __base_type;
     765             : 
     766             :       atomic() noexcept = default;
     767             :       ~atomic() noexcept = default;
     768             :       atomic(const atomic&) = delete;
     769             :       atomic& operator=(const atomic&) = delete;
     770             :       atomic& operator=(const atomic&) volatile = delete;
     771             : 
     772             :       constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
     773             : 
     774             :       using __base_type::operator __integral_type;
     775             :       using __base_type::operator=;
     776             :     };
     777             : 
     778             : 
     779             :   /// atomic_bool
     780             :   typedef atomic<bool>                    atomic_bool;
     781             : 
     782             :   /// atomic_char
     783             :   typedef atomic<char>                    atomic_char;
     784             : 
     785             :   /// atomic_schar
     786             :   typedef atomic<signed char>             atomic_schar;
     787             : 
     788             :   /// atomic_uchar
     789             :   typedef atomic<unsigned char>           atomic_uchar;
     790             : 
     791             :   /// atomic_short
     792             :   typedef atomic<short>                   atomic_short;
     793             : 
     794             :   /// atomic_ushort
     795             :   typedef atomic<unsigned short>  atomic_ushort;
     796             : 
     797             :   /// atomic_int
     798             :   typedef atomic<int>                     atomic_int;
     799             : 
     800             :   /// atomic_uint
     801             :   typedef atomic<unsigned int>            atomic_uint;
     802             : 
     803             :   /// atomic_long
     804             :   typedef atomic<long>                    atomic_long;
     805             : 
     806             :   /// atomic_ulong
     807             :   typedef atomic<unsigned long>           atomic_ulong;
     808             : 
     809             :   /// atomic_llong
     810             :   typedef atomic<long long>               atomic_llong;
     811             : 
     812             :   /// atomic_ullong
     813             :   typedef atomic<unsigned long long>      atomic_ullong;
     814             : 
     815             :   /// atomic_wchar_t
     816             :   typedef atomic<wchar_t>         atomic_wchar_t;
     817             : 
     818             :   /// atomic_char16_t
     819             :   typedef atomic<char16_t>                atomic_char16_t;
     820             : 
     821             :   /// atomic_char32_t
     822             :   typedef atomic<char32_t>                atomic_char32_t;
     823             : 
     824             : 
     825             :   /// atomic_int_least8_t
     826             :   typedef atomic<int_least8_t>            atomic_int_least8_t;
     827             : 
     828             :   /// atomic_uint_least8_t
     829             :   typedef atomic<uint_least8_t>           atomic_uint_least8_t;
     830             : 
     831             :   /// atomic_int_least16_t
     832             :   typedef atomic<int_least16_t>           atomic_int_least16_t;
     833             : 
     834             :   /// atomic_uint_least16_t
     835             :   typedef atomic<uint_least16_t>  atomic_uint_least16_t;
     836             : 
     837             :   /// atomic_int_least32_t
     838             :   typedef atomic<int_least32_t>           atomic_int_least32_t;
     839             : 
     840             :   /// atomic_uint_least32_t
     841             :   typedef atomic<uint_least32_t>  atomic_uint_least32_t;
     842             : 
     843             :   /// atomic_int_least64_t
     844             :   typedef atomic<int_least64_t>           atomic_int_least64_t;
     845             : 
     846             :   /// atomic_uint_least64_t
     847             :   typedef atomic<uint_least64_t>  atomic_uint_least64_t;
     848             : 
     849             : 
     850             :   /// atomic_int_fast8_t
     851             :   typedef atomic<int_fast8_t>             atomic_int_fast8_t;
     852             : 
     853             :   /// atomic_uint_fast8_t
     854             :   typedef atomic<uint_fast8_t>            atomic_uint_fast8_t;
     855             : 
     856             :   /// atomic_int_fast16_t
     857             :   typedef atomic<int_fast16_t>            atomic_int_fast16_t;
     858             : 
     859             :   /// atomic_uint_fast16_t
     860             :   typedef atomic<uint_fast16_t>           atomic_uint_fast16_t;
     861             : 
     862             :   /// atomic_int_fast32_t
     863             :   typedef atomic<int_fast32_t>            atomic_int_fast32_t;
     864             : 
     865             :   /// atomic_uint_fast32_t
     866             :   typedef atomic<uint_fast32_t>           atomic_uint_fast32_t;
     867             : 
     868             :   /// atomic_int_fast64_t
     869             :   typedef atomic<int_fast64_t>            atomic_int_fast64_t;
     870             : 
     871             :   /// atomic_uint_fast64_t
     872             :   typedef atomic<uint_fast64_t>           atomic_uint_fast64_t;
     873             : 
     874             : 
     875             :   /// atomic_intptr_t
     876             :   typedef atomic<intptr_t>                atomic_intptr_t;
     877             : 
     878             :   /// atomic_uintptr_t
     879             :   typedef atomic<uintptr_t>               atomic_uintptr_t;
     880             : 
     881             :   /// atomic_size_t
     882             :   typedef atomic<size_t>          atomic_size_t;
     883             : 
     884             :   /// atomic_intmax_t
     885             :   typedef atomic<intmax_t>                atomic_intmax_t;
     886             : 
     887             :   /// atomic_uintmax_t
     888             :   typedef atomic<uintmax_t>               atomic_uintmax_t;
     889             : 
     890             :   /// atomic_ptrdiff_t
     891             :   typedef atomic<ptrdiff_t>               atomic_ptrdiff_t;
     892             : 
     893             : 
     894             :   // Function definitions, atomic_flag operations.
     895             :   inline bool
     896             :   atomic_flag_test_and_set_explicit(atomic_flag* __a,
     897             :                                     memory_order __m) noexcept
     898             :   { return __a->test_and_set(__m); }
     899             : 
     900             :   inline bool
     901             :   atomic_flag_test_and_set_explicit(volatile atomic_flag* __a,
     902             :                                     memory_order __m) noexcept
     903             :   { return __a->test_and_set(__m); }
     904             : 
     905             :   inline void
     906             :   atomic_flag_clear_explicit(atomic_flag* __a, memory_order __m) noexcept
     907             :   { __a->clear(__m); }
     908             : 
     909             :   inline void
     910             :   atomic_flag_clear_explicit(volatile atomic_flag* __a,
     911             :                              memory_order __m) noexcept
     912             :   { __a->clear(__m); }
     913             : 
     914             :   inline bool
     915             :   atomic_flag_test_and_set(atomic_flag* __a) noexcept
     916             :   { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }
     917             : 
     918             :   inline bool
     919             :   atomic_flag_test_and_set(volatile atomic_flag* __a) noexcept
     920             :   { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }
     921             : 
     922             :   inline void
     923             :   atomic_flag_clear(atomic_flag* __a) noexcept
     924             :   { atomic_flag_clear_explicit(__a, memory_order_seq_cst); }
     925             : 
     926             :   inline void
     927             :   atomic_flag_clear(volatile atomic_flag* __a) noexcept
     928             :   { atomic_flag_clear_explicit(__a, memory_order_seq_cst); }
     929             : 
     930             : 
     931             :   // Function templates generally applicable to atomic types.
     932             :   template<typename _ITp>
     933             :     inline bool
     934             :     atomic_is_lock_free(const atomic<_ITp>* __a) noexcept
     935             :     { return __a->is_lock_free(); }
     936             : 
     937             :   template<typename _ITp>
     938             :     inline bool
     939             :     atomic_is_lock_free(const volatile atomic<_ITp>* __a) noexcept
     940             :     { return __a->is_lock_free(); }
     941             : 
     942             :   template<typename _ITp>
     943             :     inline void
     944             :     atomic_init(atomic<_ITp>* __a, _ITp __i) noexcept
     945             :     { __a->store(__i, memory_order_relaxed); }
     946             : 
     947             :   template<typename _ITp>
     948             :     inline void
     949             :     atomic_init(volatile atomic<_ITp>* __a, _ITp __i) noexcept
     950             :     { __a->store(__i, memory_order_relaxed); }
     951             : 
     952             :   template<typename _ITp>
     953             :     inline void
     954             :     atomic_store_explicit(atomic<_ITp>* __a, _ITp __i,
     955             :                           memory_order __m) noexcept
     956             :     { __a->store(__i, __m); }
     957             : 
     958             :   template<typename _ITp>
     959             :     inline void
     960             :     atomic_store_explicit(volatile atomic<_ITp>* __a, _ITp __i,
     961             :                           memory_order __m) noexcept
     962             :     { __a->store(__i, __m); }
     963             : 
     964             :   template<typename _ITp>
     965             :     inline _ITp
     966             :     atomic_load_explicit(const atomic<_ITp>* __a, memory_order __m) noexcept
     967             :     { return __a->load(__m); }
     968             : 
     969             :   template<typename _ITp>
     970             :     inline _ITp
     971             :     atomic_load_explicit(const volatile atomic<_ITp>* __a,
     972             :                          memory_order __m) noexcept
     973             :     { return __a->load(__m); }
     974             : 
     975             :   template<typename _ITp>
     976             :     inline _ITp
     977             :     atomic_exchange_explicit(atomic<_ITp>* __a, _ITp __i,
     978             :                              memory_order __m) noexcept
     979             :     { return __a->exchange(__i, __m); }
     980             : 
     981             :   template<typename _ITp>
     982             :     inline _ITp
     983             :     atomic_exchange_explicit(volatile atomic<_ITp>* __a, _ITp __i,
     984             :                              memory_order __m) noexcept
     985             :     { return __a->exchange(__i, __m); }
     986             : 
     987             :   template<typename _ITp>
     988             :     inline bool
     989             :     atomic_compare_exchange_weak_explicit(atomic<_ITp>* __a,
     990             :                                           _ITp* __i1, _ITp __i2,
     991             :                                           memory_order __m1,
     992             :                                           memory_order __m2) noexcept
     993             :     { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
     994             : 
     995             :   template<typename _ITp>
     996             :     inline bool
     997             :     atomic_compare_exchange_weak_explicit(volatile atomic<_ITp>* __a,
     998             :                                           _ITp* __i1, _ITp __i2,
     999             :                                           memory_order __m1,
    1000             :                                           memory_order __m2) noexcept
    1001             :     { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
    1002             : 
    1003             :   template<typename _ITp>
    1004             :     inline bool
    1005             :     atomic_compare_exchange_strong_explicit(atomic<_ITp>* __a,
    1006             :                                             _ITp* __i1, _ITp __i2,
    1007             :                                             memory_order __m1,
    1008             :                                             memory_order __m2) noexcept
    1009             :     { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
    1010             : 
    1011             :   template<typename _ITp>
    1012             :     inline bool
    1013             :     atomic_compare_exchange_strong_explicit(volatile atomic<_ITp>* __a,
    1014             :                                             _ITp* __i1, _ITp __i2,
    1015             :                                             memory_order __m1,
    1016             :                                             memory_order __m2) noexcept
    1017             :     { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
    1018             : 
    1019             : 
    1020             :   template<typename _ITp>
    1021             :     inline void
    1022             :     atomic_store(atomic<_ITp>* __a, _ITp __i) noexcept
    1023             :     { atomic_store_explicit(__a, __i, memory_order_seq_cst); }
    1024             : 
    1025             :   template<typename _ITp>
    1026             :     inline void
    1027             :     atomic_store(volatile atomic<_ITp>* __a, _ITp __i) noexcept
    1028             :     { atomic_store_explicit(__a, __i, memory_order_seq_cst); }
    1029             : 
    1030             :   template<typename _ITp>
    1031             :     inline _ITp
    1032             :     atomic_load(const atomic<_ITp>* __a) noexcept
    1033             :     { return atomic_load_explicit(__a, memory_order_seq_cst); }
    1034             : 
    1035             :   template<typename _ITp>
    1036             :     inline _ITp
    1037             :     atomic_load(const volatile atomic<_ITp>* __a) noexcept
    1038             :     { return atomic_load_explicit(__a, memory_order_seq_cst); }
    1039             : 
    1040             :   template<typename _ITp>
    1041             :     inline _ITp
    1042             :     atomic_exchange(atomic<_ITp>* __a, _ITp __i) noexcept
    1043             :     { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
    1044             : 
    1045             :   template<typename _ITp>
    1046             :     inline _ITp
    1047             :     atomic_exchange(volatile atomic<_ITp>* __a, _ITp __i) noexcept
    1048             :     { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
    1049             : 
    1050             :   template<typename _ITp>
    1051             :     inline bool
    1052             :     atomic_compare_exchange_weak(atomic<_ITp>* __a,
    1053             :                                  _ITp* __i1, _ITp __i2) noexcept
    1054             :     {
    1055             :       return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
    1056             :                                                    memory_order_seq_cst,
    1057             :                                                    memory_order_seq_cst);
    1058             :     }
    1059             : 
    1060             :   template<typename _ITp>
    1061             :     inline bool
    1062             :     atomic_compare_exchange_weak(volatile atomic<_ITp>* __a,
    1063             :                                  _ITp* __i1, _ITp __i2) noexcept
    1064             :     {
    1065             :       return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
    1066             :                                                    memory_order_seq_cst,
    1067             :                                                    memory_order_seq_cst);
    1068             :     }
    1069             : 
    1070             :   template<typename _ITp>
    1071             :     inline bool
    1072             :     atomic_compare_exchange_strong(atomic<_ITp>* __a,
    1073             :                                    _ITp* __i1, _ITp __i2) noexcept
    1074             :     {
    1075             :       return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
    1076             :                                                      memory_order_seq_cst,
    1077             :                                                      memory_order_seq_cst);
    1078             :     }
    1079             : 
    1080             :   template<typename _ITp>
    1081             :     inline bool
    1082             :     atomic_compare_exchange_strong(volatile atomic<_ITp>* __a,
    1083             :                                    _ITp* __i1, _ITp __i2) noexcept
    1084             :     {
    1085             :       return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
    1086             :                                                      memory_order_seq_cst,
    1087             :                                                      memory_order_seq_cst);
    1088             :     }
    1089             : 
    1090             :   // Function templates for atomic_integral operations only, using
    1091             :   // __atomic_base. Template argument should be constricted to
    1092             :   // intergral types as specified in the standard, excluding address
    1093             :   // types.
    1094             :   template<typename _ITp>
    1095             :     inline _ITp
    1096             :     atomic_fetch_add_explicit(__atomic_base<_ITp>* __a, _ITp __i,
    1097             :                               memory_order __m) noexcept
    1098             :     { return __a->fetch_add(__i, __m); }
    1099             : 
    1100             :   template<typename _ITp>
    1101             :     inline _ITp
    1102             :     atomic_fetch_add_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
    1103             :                               memory_order __m) noexcept
    1104             :     { return __a->fetch_add(__i, __m); }
    1105             : 
    1106             :   template<typename _ITp>
    1107             :     inline _ITp
    1108             :     atomic_fetch_sub_explicit(__atomic_base<_ITp>* __a, _ITp __i,
    1109             :                               memory_order __m) noexcept
    1110             :     { return __a->fetch_sub(__i, __m); }
    1111             : 
    1112             :   template<typename _ITp>
    1113             :     inline _ITp
    1114             :     atomic_fetch_sub_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
    1115             :                               memory_order __m) noexcept
    1116             :     { return __a->fetch_sub(__i, __m); }
    1117             : 
    1118             :   template<typename _ITp>
    1119             :     inline _ITp
    1120             :     atomic_fetch_and_explicit(__atomic_base<_ITp>* __a, _ITp __i,
    1121             :                               memory_order __m) noexcept
    1122             :     { return __a->fetch_and(__i, __m); }
    1123             : 
    1124             :   template<typename _ITp>
    1125             :     inline _ITp
    1126             :     atomic_fetch_and_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
    1127             :                               memory_order __m) noexcept
    1128             :     { return __a->fetch_and(__i, __m); }
    1129             : 
    1130             :   template<typename _ITp>
    1131             :     inline _ITp
    1132             :     atomic_fetch_or_explicit(__atomic_base<_ITp>* __a, _ITp __i,
    1133             :                              memory_order __m) noexcept
    1134             :     { return __a->fetch_or(__i, __m); }
    1135             : 
    1136             :   template<typename _ITp>
    1137             :     inline _ITp
    1138             :     atomic_fetch_or_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
    1139             :                              memory_order __m) noexcept
    1140             :     { return __a->fetch_or(__i, __m); }
    1141             : 
    1142             :   template<typename _ITp>
    1143             :     inline _ITp
    1144             :     atomic_fetch_xor_explicit(__atomic_base<_ITp>* __a, _ITp __i,
    1145             :                               memory_order __m) noexcept
    1146             :     { return __a->fetch_xor(__i, __m); }
    1147             : 
    1148             :   template<typename _ITp>
    1149             :     inline _ITp
    1150             :     atomic_fetch_xor_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
    1151             :                               memory_order __m) noexcept
    1152             :     { return __a->fetch_xor(__i, __m); }
    1153             : 
    1154             :   template<typename _ITp>
    1155             :     inline _ITp
    1156             :     atomic_fetch_add(__atomic_base<_ITp>* __a, _ITp __i) noexcept
    1157             :     { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
    1158             : 
    1159             :   template<typename _ITp>
    1160             :     inline _ITp
    1161             :     atomic_fetch_add(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
    1162             :     { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
    1163             : 
    1164             :   template<typename _ITp>
    1165             :     inline _ITp
    1166             :     atomic_fetch_sub(__atomic_base<_ITp>* __a, _ITp __i) noexcept
    1167             :     { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
    1168             : 
    1169             :   template<typename _ITp>
    1170             :     inline _ITp
    1171             :     atomic_fetch_sub(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
    1172             :     { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
    1173             : 
    1174             :   template<typename _ITp>
    1175             :     inline _ITp
    1176             :     atomic_fetch_and(__atomic_base<_ITp>* __a, _ITp __i) noexcept
    1177             :     { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }
    1178             : 
    1179             :   template<typename _ITp>
    1180             :     inline _ITp
    1181             :     atomic_fetch_and(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
    1182             :     { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }
    1183             : 
    1184             :   template<typename _ITp>
    1185             :     inline _ITp
    1186             :     atomic_fetch_or(__atomic_base<_ITp>* __a, _ITp __i) noexcept
    1187             :     { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }
    1188             : 
    1189             :   template<typename _ITp>
    1190             :     inline _ITp
    1191             :     atomic_fetch_or(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
    1192             :     { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }
    1193             : 
    1194             :   template<typename _ITp>
    1195             :     inline _ITp
    1196             :     atomic_fetch_xor(__atomic_base<_ITp>* __a, _ITp __i) noexcept
    1197             :     { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
    1198             : 
    1199             :   template<typename _ITp>
    1200             :     inline _ITp
    1201             :     atomic_fetch_xor(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
    1202             :     { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
    1203             : 
    1204             : 
    1205             :   // Partial specializations for pointers.
    1206             :   template<typename _ITp>
    1207             :     inline _ITp*
    1208             :     atomic_fetch_add_explicit(atomic<_ITp*>* __a, ptrdiff_t __d,
    1209             :                               memory_order __m) noexcept
    1210             :     { return __a->fetch_add(__d, __m); }
    1211             : 
    1212             :   template<typename _ITp>
    1213             :     inline _ITp*
    1214             :     atomic_fetch_add_explicit(volatile atomic<_ITp*>* __a, ptrdiff_t __d,
    1215             :                               memory_order __m) noexcept
    1216             :     { return __a->fetch_add(__d, __m); }
    1217             : 
    1218             :   template<typename _ITp>
    1219             :     inline _ITp*
    1220             :     atomic_fetch_add(volatile atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
    1221             :     { return __a->fetch_add(__d); }
    1222             : 
    1223             :   template<typename _ITp>
    1224             :     inline _ITp*
    1225             :     atomic_fetch_add(atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
    1226             :     { return __a->fetch_add(__d); }
    1227             : 
    1228             :   template<typename _ITp>
    1229             :     inline _ITp*
    1230             :     atomic_fetch_sub_explicit(volatile atomic<_ITp*>* __a,
    1231             :                               ptrdiff_t __d, memory_order __m) noexcept
    1232             :     { return __a->fetch_sub(__d, __m); }
    1233             : 
    1234             :   template<typename _ITp>
    1235             :     inline _ITp*
    1236             :     atomic_fetch_sub_explicit(atomic<_ITp*>* __a, ptrdiff_t __d,
    1237             :                               memory_order __m) noexcept
    1238             :     { return __a->fetch_sub(__d, __m); }
    1239             : 
    1240             :   template<typename _ITp>
    1241             :     inline _ITp*
    1242             :     atomic_fetch_sub(volatile atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
    1243             :     { return __a->fetch_sub(__d); }
    1244             : 
    1245             :   template<typename _ITp>
    1246             :     inline _ITp*
    1247             :     atomic_fetch_sub(atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
    1248             :     { return __a->fetch_sub(__d); }
    1249             :   // @} group atomics
    1250             : 
    1251             : _GLIBCXX_END_NAMESPACE_VERSION
    1252             : } // namespace
    1253             : 
    1254             : #endif // C++11
    1255             : 
    1256             : #endif // _GLIBCXX_ATOMIC

Generated by: LCOV version 1.13