diff --git a/libstdc++-v3/include/bits/atomic_base.h b/libstdc++-v3/include/bits/atomic_base.h index 146e70a9f2e..718eca7424a 100644 --- a/libstdc++-v3/include/bits/atomic_base.h +++ b/libstdc++-v3/include/bits/atomic_base.h @@ -230,6 +230,207 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { return __i ? __GCC_ATOMIC_TEST_AND_SET_TRUEVAL : 0; } }; + // Implementation details of std::atomic and std::atomic_ref + namespace __atomic_impl + { + // Remove volatile and create a non-deduced context for value arguments. + template + using _Val = typename remove_volatile<_Tp>::type; + + // As above, but for difference_type arguments. + template + using _Diff = typename + conditional::value, ptrdiff_t, _Val<_Tp>>::type; + + template + _GLIBCXX_ALWAYS_INLINE bool + is_lock_free() noexcept + { + // Produce a fake, minimally aligned pointer. + return __atomic_is_lock_free(_Size, reinterpret_cast(-_Align)); + } + + template + _GLIBCXX_ALWAYS_INLINE void + store(_Tp* __ptr, _Val<_Tp> __t, memory_order __m) noexcept + { + const memory_order __b __attribute__((__unused__)) + = __m & __memory_order_mask; + __glibcxx_assert(__b != memory_order_acquire); + __glibcxx_assert(__b != memory_order_acq_rel); + __glibcxx_assert(__b != memory_order_consume); + + __atomic_store(__ptr, std::__addressof(__t), int(__m)); + } + + template + _GLIBCXX_ALWAYS_INLINE _Val<_Tp> + load(_Tp* __ptr, memory_order __m) noexcept + { + const memory_order __b __attribute__((__unused__)) + = __m & __memory_order_mask; + __glibcxx_assert(__b != memory_order_release); + __glibcxx_assert(__b != memory_order_acq_rel); + + alignas(_Tp) unsigned char __buf[sizeof(_Tp)]; + auto __dest = reinterpret_cast<_Val<_Tp>*>(__buf); + __atomic_load(__ptr, __dest, int(__m)); + return *__dest; + } + + template + _GLIBCXX_ALWAYS_INLINE _Val<_Tp> + exchange(_Tp* __ptr, _Val<_Tp> __desired, memory_order __m) noexcept + { + __glibcxx_assert((__m & __memory_order_mask) != memory_order_consume); + + alignas(_Tp) unsigned char __buf[sizeof(_Tp)]; + auto __dest = reinterpret_cast<_Val<_Tp>*>(__buf); + __atomic_exchange(__ptr, std::__addressof(__desired), __dest, int(__m)); + return *__dest; + } + + template + _GLIBCXX_ALWAYS_INLINE bool + compare_exchange_weak(_Tp* __ptr, _Val<_Tp>& __expected, + _Val<_Tp> __desired, memory_order __success, + memory_order __failure) noexcept + { + const memory_order __bs __attribute__((__unused__)) + = __success & __memory_order_mask; + const memory_order __bf __attribute__((__unused__)) + = __failure & __memory_order_mask; + __glibcxx_assert(__bf != memory_order_release); + __glibcxx_assert(__bf != memory_order_acq_rel); + __glibcxx_assert(__bf <= __bs); + + return __atomic_compare_exchange(__ptr, std::__addressof(__expected), + std::__addressof(__desired), true, + int(__success), int(__failure)); + } + + template + _GLIBCXX_ALWAYS_INLINE bool + compare_exchange_strong(_Tp* __ptr, _Val<_Tp>& __expected, + _Val<_Tp> __desired, memory_order __success, + memory_order __failure) noexcept + { + const memory_order __succ __attribute__((__unused__)) + = __success & __memory_order_mask; + const memory_order __fail __attribute__((__unused__)) + = __failure & __memory_order_mask; + __glibcxx_assert(__fail != memory_order_release); + __glibcxx_assert(__fail != memory_order_acq_rel); + __glibcxx_assert(__fail <= __succ); + + return __atomic_compare_exchange(__ptr, std::__addressof(__expected), + std::__addressof(__desired), false, + int(__success), int(__failure)); + } + + template + _GLIBCXX_ALWAYS_INLINE _Tp + fetch_add(_Tp* __ptr, _Diff<_Tp> __i, memory_order __m) noexcept + { return __atomic_fetch_add(__ptr, __i, int(__m)); } + + template + _GLIBCXX_ALWAYS_INLINE _Tp + fetch_sub(_Tp* __ptr, _Diff<_Tp> __i, memory_order __m) noexcept + { return __atomic_fetch_sub(__ptr, __i, int(__m)); } + + template + _GLIBCXX_ALWAYS_INLINE _Tp + fetch_and(_Tp* __ptr, _Val<_Tp> __i, memory_order __m) noexcept + { return __atomic_fetch_and(__ptr, __i, int(__m)); } + + template + _GLIBCXX_ALWAYS_INLINE _Tp + fetch_or(_Tp* __ptr, _Val<_Tp> __i, memory_order __m) noexcept + { return __atomic_fetch_or(__ptr, __i, int(__m)); } + + template + _GLIBCXX_ALWAYS_INLINE _Tp + fetch_xor(_Tp* __ptr, _Val<_Tp> __i, memory_order __m) noexcept + { return __atomic_fetch_xor(__ptr, __i, int(__m)); } + + template + _GLIBCXX_ALWAYS_INLINE _Tp + __add_fetch(_Tp* __ptr, _Diff<_Tp> __i) noexcept + { return __atomic_add_fetch(__ptr, __i, __ATOMIC_SEQ_CST); } + + template + _GLIBCXX_ALWAYS_INLINE _Tp + __sub_fetch(_Tp* __ptr, _Diff<_Tp> __i) noexcept + { return __atomic_sub_fetch(__ptr, __i, __ATOMIC_SEQ_CST); } + + template + _GLIBCXX_ALWAYS_INLINE _Tp + __and_fetch(_Tp* __ptr, _Val<_Tp> __i) noexcept + { return __atomic_and_fetch(__ptr, __i, __ATOMIC_SEQ_CST); } + + template + _GLIBCXX_ALWAYS_INLINE _Tp + __or_fetch(_Tp* __ptr, _Val<_Tp> __i) noexcept + { return __atomic_or_fetch(__ptr, __i, __ATOMIC_SEQ_CST); } + + template + _GLIBCXX_ALWAYS_INLINE _Tp + __xor_fetch(_Tp* __ptr, _Val<_Tp> __i) noexcept + { return __atomic_xor_fetch(__ptr, __i, __ATOMIC_SEQ_CST); } + +#if __cplusplus > 201703L + template + _Tp + __fetch_add_flt(_Tp* __ptr, _Val<_Tp> __i, memory_order __m) noexcept + { + _Val<_Tp> __oldval = load(__ptr, memory_order_relaxed); + _Val<_Tp> __newval = __oldval + __i; + while (!compare_exchange_weak(__ptr, __oldval, __newval, __m, + memory_order_relaxed)) + __newval = __oldval + __i; + return __oldval; + } + + template + _Tp + __fetch_sub_flt(_Tp* __ptr, _Val<_Tp> __i, memory_order __m) noexcept + { + _Val<_Tp> __oldval = load(__ptr, memory_order_relaxed); + _Val<_Tp> __newval = __oldval - __i; + while (!compare_exchange_weak(__ptr, __oldval, __newval, __m, + memory_order_relaxed)) + __newval = __oldval - __i; + return __oldval; + } + + template + _Tp + __add_fetch_flt(_Tp* __ptr, _Val<_Tp> __i) noexcept + { + _Val<_Tp> __oldval = load(__ptr, memory_order_relaxed); + _Val<_Tp> __newval = __oldval + __i; + while (!compare_exchange_weak(__ptr, __oldval, __newval, + memory_order_seq_cst, + memory_order_relaxed)) + __newval = __oldval + __i; + return __newval; + } + + template + _Tp + __sub_fetch_flt(_Tp* __ptr, _Val<_Tp> __i) noexcept + { + _Val<_Tp> __oldval = load(__ptr, memory_order_relaxed); + _Val<_Tp> __newval = __oldval - __i; + while (!compare_exchange_weak(__ptr, __oldval, __newval, + memory_order_seq_cst, + memory_order_relaxed)) + __newval = __oldval - __i; + return __newval; + } +#endif // C++2a + } // namespace __atomic_impl + /// Base class for atomic integrals. // @@ -262,12 +463,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION using difference_type = value_type; private: - typedef _ITp __int_type; - static constexpr int _S_alignment = sizeof(_ITp) > alignof(_ITp) ? sizeof(_ITp) : alignof(_ITp); - alignas(_S_alignment) __int_type _M_i; + alignas(_S_alignment) value_type _M_i; public: __atomic_base() noexcept = default; @@ -276,206 +475,154 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __atomic_base& operator=(const __atomic_base&) = delete; __atomic_base& operator=(const __atomic_base&) volatile = delete; - // Requires __int_type convertible to _M_i. - constexpr __atomic_base(__int_type __i) noexcept : _M_i (__i) { } + constexpr __atomic_base(value_type __i) noexcept : _M_i (__i) { } - operator __int_type() const noexcept + operator value_type() const noexcept { return load(); } - operator __int_type() const volatile noexcept + operator value_type() const volatile noexcept { return load(); } - __int_type - operator=(__int_type __i) noexcept + value_type + operator=(value_type __i) noexcept { store(__i); return __i; } - __int_type - operator=(__int_type __i) volatile noexcept + value_type + operator=(value_type __i) volatile noexcept { store(__i); return __i; } - __int_type + value_type operator++(int) noexcept { return fetch_add(1); } - __int_type + value_type operator++(int) volatile noexcept { return fetch_add(1); } - __int_type + value_type operator--(int) noexcept { return fetch_sub(1); } - __int_type + value_type operator--(int) volatile noexcept { return fetch_sub(1); } - __int_type + value_type operator++() noexcept - { return __atomic_add_fetch(&_M_i, 1, int(memory_order_seq_cst)); } + { return __atomic_impl::__add_fetch(&_M_i, 1); } - __int_type + value_type operator++() volatile noexcept - { return __atomic_add_fetch(&_M_i, 1, int(memory_order_seq_cst)); } + { return __atomic_impl::__add_fetch(&_M_i, 1); } - __int_type + value_type operator--() noexcept - { return __atomic_sub_fetch(&_M_i, 1, int(memory_order_seq_cst)); } + { return __atomic_impl::__sub_fetch(&_M_i, 1); } - __int_type + value_type operator--() volatile noexcept - { return __atomic_sub_fetch(&_M_i, 1, int(memory_order_seq_cst)); } + { return __atomic_impl::__sub_fetch(&_M_i, 1); } - __int_type - operator+=(__int_type __i) noexcept - { return __atomic_add_fetch(&_M_i, __i, int(memory_order_seq_cst)); } + value_type + operator+=(value_type __i) noexcept + { return __atomic_impl::__add_fetch(&_M_i, __i); } - __int_type - operator+=(__int_type __i) volatile noexcept - { return __atomic_add_fetch(&_M_i, __i, int(memory_order_seq_cst)); } + value_type + operator+=(value_type __i) volatile noexcept + { return __atomic_impl::__add_fetch(&_M_i, __i); } - __int_type - operator-=(__int_type __i) noexcept - { return __atomic_sub_fetch(&_M_i, __i, int(memory_order_seq_cst)); } + value_type + operator-=(value_type __i) noexcept + { return __atomic_impl::__sub_fetch(&_M_i, __i); } - __int_type - operator-=(__int_type __i) volatile noexcept - { return __atomic_sub_fetch(&_M_i, __i, int(memory_order_seq_cst)); } + value_type + operator-=(value_type __i) volatile noexcept + { return __atomic_impl::__sub_fetch(&_M_i, __i); } - __int_type - operator&=(__int_type __i) noexcept - { return __atomic_and_fetch(&_M_i, __i, int(memory_order_seq_cst)); } + value_type + operator&=(value_type __i) noexcept + { return __atomic_impl::__and_fetch(&_M_i, __i); } - __int_type - operator&=(__int_type __i) volatile noexcept - { return __atomic_and_fetch(&_M_i, __i, int(memory_order_seq_cst)); } + value_type + operator&=(value_type __i) volatile noexcept + { return __atomic_impl::__and_fetch(&_M_i, __i); } - __int_type - operator|=(__int_type __i) noexcept - { return __atomic_or_fetch(&_M_i, __i, int(memory_order_seq_cst)); } + value_type + operator|=(value_type __i) noexcept + { return __atomic_impl::__or_fetch(&_M_i, __i); } - __int_type - operator|=(__int_type __i) volatile noexcept - { return __atomic_or_fetch(&_M_i, __i, int(memory_order_seq_cst)); } + value_type + operator|=(value_type __i) volatile noexcept + { return __atomic_impl::__or_fetch(&_M_i, __i); } - __int_type - operator^=(__int_type __i) noexcept - { return __atomic_xor_fetch(&_M_i, __i, int(memory_order_seq_cst)); } + value_type + operator^=(value_type __i) noexcept + { return __atomic_impl::__xor_fetch(&_M_i, __i); } - __int_type - operator^=(__int_type __i) volatile noexcept - { return __atomic_xor_fetch(&_M_i, __i, int(memory_order_seq_cst)); } + value_type + operator^=(value_type __i) volatile noexcept + { return __atomic_impl::__xor_fetch(&_M_i, __i); } bool is_lock_free() const noexcept - { - // Use a fake, minimally aligned pointer. - return __atomic_is_lock_free(sizeof(_M_i), - reinterpret_cast(-_S_alignment)); - } + { return __atomic_impl::is_lock_free(); } bool is_lock_free() const volatile noexcept - { - // Use a fake, minimally aligned pointer. - return __atomic_is_lock_free(sizeof(_M_i), - reinterpret_cast(-_S_alignment)); - } + { return __atomic_impl::is_lock_free(); } _GLIBCXX_ALWAYS_INLINE void - store(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept - { - memory_order __b = __m & __memory_order_mask; - __glibcxx_assert(__b != memory_order_acquire); - __glibcxx_assert(__b != memory_order_acq_rel); - __glibcxx_assert(__b != memory_order_consume); - - __atomic_store_n(&_M_i, __i, int(__m)); - } + store(value_type __i, memory_order __m = memory_order_seq_cst) noexcept + { __atomic_impl::store(&_M_i, __i, __m); } _GLIBCXX_ALWAYS_INLINE void - store(__int_type __i, + store(value_type __i, memory_order __m = memory_order_seq_cst) volatile noexcept - { - memory_order __b = __m & __memory_order_mask; - __glibcxx_assert(__b != memory_order_acquire); - __glibcxx_assert(__b != memory_order_acq_rel); - __glibcxx_assert(__b != memory_order_consume); + { __atomic_impl::store(&_M_i, __i, __m); } - __atomic_store_n(&_M_i, __i, int(__m)); - } - - _GLIBCXX_ALWAYS_INLINE __int_type + _GLIBCXX_ALWAYS_INLINE value_type load(memory_order __m = memory_order_seq_cst) const noexcept - { - memory_order __b = __m & __memory_order_mask; - __glibcxx_assert(__b != memory_order_release); - __glibcxx_assert(__b != memory_order_acq_rel); - - return __atomic_load_n(&_M_i, int(__m)); - } + { return __atomic_impl::load(&_M_i, __m); } - _GLIBCXX_ALWAYS_INLINE __int_type + _GLIBCXX_ALWAYS_INLINE value_type load(memory_order __m = memory_order_seq_cst) const volatile noexcept - { - memory_order __b = __m & __memory_order_mask; - __glibcxx_assert(__b != memory_order_release); - __glibcxx_assert(__b != memory_order_acq_rel); + { return __atomic_impl::load(&_M_i, __m); } - return __atomic_load_n(&_M_i, int(__m)); - } - - _GLIBCXX_ALWAYS_INLINE __int_type - exchange(__int_type __i, + _GLIBCXX_ALWAYS_INLINE value_type + exchange(value_type __i, memory_order __m = memory_order_seq_cst) noexcept - { - return __atomic_exchange_n(&_M_i, __i, int(__m)); - } - + { return __atomic_impl::exchange(&_M_i, __i, __m); } - _GLIBCXX_ALWAYS_INLINE __int_type - exchange(__int_type __i, + _GLIBCXX_ALWAYS_INLINE value_type + exchange(value_type __i, memory_order __m = memory_order_seq_cst) volatile noexcept - { - return __atomic_exchange_n(&_M_i, __i, int(__m)); - } + { return __atomic_impl::exchange(&_M_i, __i, __m); } _GLIBCXX_ALWAYS_INLINE bool - compare_exchange_weak(__int_type& __i1, __int_type __i2, + compare_exchange_weak(value_type& __i1, value_type __i2, memory_order __m1, memory_order __m2) noexcept { - memory_order __b2 = __m2 & __memory_order_mask; - memory_order __b1 = __m1 & __memory_order_mask; - __glibcxx_assert(__b2 != memory_order_release); - __glibcxx_assert(__b2 != memory_order_acq_rel); - __glibcxx_assert(__b2 <= __b1); - - return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1, - int(__m1), int(__m2)); + return __atomic_impl::compare_exchange_weak(&_M_i, __i1, __i2, + __m1, __m2); } _GLIBCXX_ALWAYS_INLINE bool - compare_exchange_weak(__int_type& __i1, __int_type __i2, + compare_exchange_weak(value_type& __i1, value_type __i2, memory_order __m1, memory_order __m2) volatile noexcept { - memory_order __b2 = __m2 & __memory_order_mask; - memory_order __b1 = __m1 & __memory_order_mask; - __glibcxx_assert(__b2 != memory_order_release); - __glibcxx_assert(__b2 != memory_order_acq_rel); - __glibcxx_assert(__b2 <= __b1); - - return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1, - int(__m1), int(__m2)); + return __atomic_impl::compare_exchange_weak(&_M_i, __i1, __i2, + __m1, __m2); } _GLIBCXX_ALWAYS_INLINE bool - compare_exchange_weak(__int_type& __i1, __int_type __i2, + compare_exchange_weak(value_type& __i1, value_type __i2, memory_order __m = memory_order_seq_cst) noexcept { return compare_exchange_weak(__i1, __i2, __m, @@ -483,7 +630,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } _GLIBCXX_ALWAYS_INLINE bool - compare_exchange_weak(__int_type& __i1, __int_type __i2, + compare_exchange_weak(value_type& __i1, value_type __i2, memory_order __m = memory_order_seq_cst) volatile noexcept { return compare_exchange_weak(__i1, __i2, __m, @@ -491,37 +638,24 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } _GLIBCXX_ALWAYS_INLINE bool - compare_exchange_strong(__int_type& __i1, __int_type __i2, + compare_exchange_strong(value_type& __i1, value_type __i2, memory_order __m1, memory_order __m2) noexcept { - memory_order __b2 = __m2 & __memory_order_mask; - memory_order __b1 = __m1 & __memory_order_mask; - __glibcxx_assert(__b2 != memory_order_release); - __glibcxx_assert(__b2 != memory_order_acq_rel); - __glibcxx_assert(__b2 <= __b1); - - return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0, - int(__m1), int(__m2)); + return __atomic_impl::compare_exchange_strong(&_M_i, __i1, __i2, + __m1, __m2); } _GLIBCXX_ALWAYS_INLINE bool - compare_exchange_strong(__int_type& __i1, __int_type __i2, + compare_exchange_strong(value_type& __i1, value_type __i2, memory_order __m1, memory_order __m2) volatile noexcept { - memory_order __b2 = __m2 & __memory_order_mask; - memory_order __b1 = __m1 & __memory_order_mask; - - __glibcxx_assert(__b2 != memory_order_release); - __glibcxx_assert(__b2 != memory_order_acq_rel); - __glibcxx_assert(__b2 <= __b1); - - return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0, - int(__m1), int(__m2)); + return __atomic_impl::compare_exchange_strong(&_M_i, __i1, __i2, + __m1, __m2); } _GLIBCXX_ALWAYS_INLINE bool - compare_exchange_strong(__int_type& __i1, __int_type __i2, + compare_exchange_strong(value_type& __i1, value_type __i2, memory_order __m = memory_order_seq_cst) noexcept { return compare_exchange_strong(__i1, __i2, __m, @@ -529,464 +663,67 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } _GLIBCXX_ALWAYS_INLINE bool - compare_exchange_strong(__int_type& __i1, __int_type __i2, + compare_exchange_strong(value_type& __i1, value_type __i2, memory_order __m = memory_order_seq_cst) volatile noexcept { return compare_exchange_strong(__i1, __i2, __m, __cmpexch_failure_order(__m)); } - _GLIBCXX_ALWAYS_INLINE __int_type - fetch_add(__int_type __i, + _GLIBCXX_ALWAYS_INLINE value_type + fetch_add(value_type __i, memory_order __m = memory_order_seq_cst) noexcept - { return __atomic_fetch_add(&_M_i, __i, int(__m)); } + { return __atomic_impl::fetch_add(&_M_i, __i, __m); } - _GLIBCXX_ALWAYS_INLINE __int_type - fetch_add(__int_type __i, + _GLIBCXX_ALWAYS_INLINE value_type + fetch_add(value_type __i, memory_order __m = memory_order_seq_cst) volatile noexcept - { return __atomic_fetch_add(&_M_i, __i, int(__m)); } + { return __atomic_impl::fetch_add(&_M_i, __i, __m); } - _GLIBCXX_ALWAYS_INLINE __int_type - fetch_sub(__int_type __i, + _GLIBCXX_ALWAYS_INLINE value_type + fetch_sub(value_type __i, memory_order __m = memory_order_seq_cst) noexcept - { return __atomic_fetch_sub(&_M_i, __i, int(__m)); } + { return __atomic_impl::fetch_sub(&_M_i, __i, __m); } - _GLIBCXX_ALWAYS_INLINE __int_type - fetch_sub(__int_type __i, + _GLIBCXX_ALWAYS_INLINE value_type + fetch_sub(value_type __i, memory_order __m = memory_order_seq_cst) volatile noexcept - { return __atomic_fetch_sub(&_M_i, __i, int(__m)); } + { return __atomic_impl::fetch_sub(&_M_i, __i, __m); } - _GLIBCXX_ALWAYS_INLINE __int_type - fetch_and(__int_type __i, + _GLIBCXX_ALWAYS_INLINE value_type + fetch_and(value_type __i, memory_order __m = memory_order_seq_cst) noexcept - { return __atomic_fetch_and(&_M_i, __i, int(__m)); } + { return __atomic_impl::fetch_and(&_M_i, __i, __m); } - _GLIBCXX_ALWAYS_INLINE __int_type - fetch_and(__int_type __i, + _GLIBCXX_ALWAYS_INLINE value_type + fetch_and(value_type __i, memory_order __m = memory_order_seq_cst) volatile noexcept - { return __atomic_fetch_and(&_M_i, __i, int(__m)); } + { return __atomic_impl::fetch_and(&_M_i, __i, __m); } - _GLIBCXX_ALWAYS_INLINE __int_type - fetch_or(__int_type __i, + _GLIBCXX_ALWAYS_INLINE value_type + fetch_or(value_type __i, memory_order __m = memory_order_seq_cst) noexcept - { return __atomic_fetch_or(&_M_i, __i, int(__m)); } + { return __atomic_impl::fetch_or(&_M_i, __i, __m); } - _GLIBCXX_ALWAYS_INLINE __int_type - fetch_or(__int_type __i, + _GLIBCXX_ALWAYS_INLINE value_type + fetch_or(value_type __i, memory_order __m = memory_order_seq_cst) volatile noexcept - { return __atomic_fetch_or(&_M_i, __i, int(__m)); } + { return __atomic_impl::fetch_or(&_M_i, __i, __m); } - _GLIBCXX_ALWAYS_INLINE __int_type - fetch_xor(__int_type __i, + _GLIBCXX_ALWAYS_INLINE value_type + fetch_xor(value_type __i, memory_order __m = memory_order_seq_cst) noexcept - { return __atomic_fetch_xor(&_M_i, __i, int(__m)); } + { return __atomic_impl::fetch_xor(&_M_i, __i, __m); } - _GLIBCXX_ALWAYS_INLINE __int_type - fetch_xor(__int_type __i, + _GLIBCXX_ALWAYS_INLINE value_type + fetch_xor(value_type __i, memory_order __m = memory_order_seq_cst) volatile noexcept - { return __atomic_fetch_xor(&_M_i, __i, int(__m)); } - }; - - - /// Partial specialization for pointer types. - template - struct __atomic_base<_PTp*> - { - private: - typedef _PTp* __pointer_type; - - __pointer_type _M_p; - - // Factored out to facilitate explicit specialization. - constexpr ptrdiff_t - _M_type_size(ptrdiff_t __d) const { return __d * sizeof(_PTp); } - - constexpr ptrdiff_t - _M_type_size(ptrdiff_t __d) const volatile { return __d * sizeof(_PTp); } - - public: - __atomic_base() noexcept = default; - ~__atomic_base() noexcept = default; - __atomic_base(const __atomic_base&) = delete; - __atomic_base& operator=(const __atomic_base&) = delete; - __atomic_base& operator=(const __atomic_base&) volatile = delete; - - // Requires __pointer_type convertible to _M_p. - constexpr __atomic_base(__pointer_type __p) noexcept : _M_p (__p) { } - - operator __pointer_type() const noexcept - { return load(); } - - operator __pointer_type() const volatile noexcept - { return load(); } - - __pointer_type - operator=(__pointer_type __p) noexcept - { - store(__p); - return __p; - } - - __pointer_type - operator=(__pointer_type __p) volatile noexcept - { - store(__p); - return __p; - } - - __pointer_type - operator++(int) noexcept - { return fetch_add(1); } - - __pointer_type - operator++(int) volatile noexcept - { return fetch_add(1); } - - __pointer_type - operator--(int) noexcept - { return fetch_sub(1); } - - __pointer_type - operator--(int) volatile noexcept - { return fetch_sub(1); } - - __pointer_type - operator++() noexcept - { return __atomic_add_fetch(&_M_p, _M_type_size(1), - int(memory_order_seq_cst)); } - - __pointer_type - operator++() volatile noexcept - { return __atomic_add_fetch(&_M_p, _M_type_size(1), - int(memory_order_seq_cst)); } - - __pointer_type - operator--() noexcept - { return __atomic_sub_fetch(&_M_p, _M_type_size(1), - int(memory_order_seq_cst)); } - - __pointer_type - operator--() volatile noexcept - { return __atomic_sub_fetch(&_M_p, _M_type_size(1), - int(memory_order_seq_cst)); } - - __pointer_type - operator+=(ptrdiff_t __d) noexcept - { return __atomic_add_fetch(&_M_p, _M_type_size(__d), - int(memory_order_seq_cst)); } - - __pointer_type - operator+=(ptrdiff_t __d) volatile noexcept - { return __atomic_add_fetch(&_M_p, _M_type_size(__d), - int(memory_order_seq_cst)); } - - __pointer_type - operator-=(ptrdiff_t __d) noexcept - { return __atomic_sub_fetch(&_M_p, _M_type_size(__d), - int(memory_order_seq_cst)); } - - __pointer_type - operator-=(ptrdiff_t __d) volatile noexcept - { return __atomic_sub_fetch(&_M_p, _M_type_size(__d), - int(memory_order_seq_cst)); } - - bool - is_lock_free() const noexcept - { - // Produce a fake, minimally aligned pointer. - return __atomic_is_lock_free(sizeof(_M_p), - reinterpret_cast(-__alignof(_M_p))); - } - - bool - is_lock_free() const volatile noexcept - { - // Produce a fake, minimally aligned pointer. - return __atomic_is_lock_free(sizeof(_M_p), - reinterpret_cast(-__alignof(_M_p))); - } - - _GLIBCXX_ALWAYS_INLINE void - store(__pointer_type __p, - memory_order __m = memory_order_seq_cst) noexcept - { - memory_order __b = __m & __memory_order_mask; - - __glibcxx_assert(__b != memory_order_acquire); - __glibcxx_assert(__b != memory_order_acq_rel); - __glibcxx_assert(__b != memory_order_consume); - - __atomic_store_n(&_M_p, __p, int(__m)); - } - - _GLIBCXX_ALWAYS_INLINE void - store(__pointer_type __p, - memory_order __m = memory_order_seq_cst) volatile noexcept - { - memory_order __b = __m & __memory_order_mask; - __glibcxx_assert(__b != memory_order_acquire); - __glibcxx_assert(__b != memory_order_acq_rel); - __glibcxx_assert(__b != memory_order_consume); - - __atomic_store_n(&_M_p, __p, int(__m)); - } - - _GLIBCXX_ALWAYS_INLINE __pointer_type - load(memory_order __m = memory_order_seq_cst) const noexcept - { - memory_order __b = __m & __memory_order_mask; - __glibcxx_assert(__b != memory_order_release); - __glibcxx_assert(__b != memory_order_acq_rel); - - return __atomic_load_n(&_M_p, int(__m)); - } - - _GLIBCXX_ALWAYS_INLINE __pointer_type - load(memory_order __m = memory_order_seq_cst) const volatile noexcept - { - memory_order __b = __m & __memory_order_mask; - __glibcxx_assert(__b != memory_order_release); - __glibcxx_assert(__b != memory_order_acq_rel); - - return __atomic_load_n(&_M_p, int(__m)); - } - - _GLIBCXX_ALWAYS_INLINE __pointer_type - exchange(__pointer_type __p, - memory_order __m = memory_order_seq_cst) noexcept - { - return __atomic_exchange_n(&_M_p, __p, int(__m)); - } - - - _GLIBCXX_ALWAYS_INLINE __pointer_type - exchange(__pointer_type __p, - memory_order __m = memory_order_seq_cst) volatile noexcept - { - return __atomic_exchange_n(&_M_p, __p, int(__m)); - } - - _GLIBCXX_ALWAYS_INLINE bool - compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, - memory_order __m1, - memory_order __m2) noexcept - { - memory_order __b2 = __m2 & __memory_order_mask; - memory_order __b1 = __m1 & __memory_order_mask; - __glibcxx_assert(__b2 != memory_order_release); - __glibcxx_assert(__b2 != memory_order_acq_rel); - __glibcxx_assert(__b2 <= __b1); - - return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, - int(__m1), int(__m2)); - } - - _GLIBCXX_ALWAYS_INLINE bool - compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, - memory_order __m1, - memory_order __m2) volatile noexcept - { - memory_order __b2 = __m2 & __memory_order_mask; - memory_order __b1 = __m1 & __memory_order_mask; - - __glibcxx_assert(__b2 != memory_order_release); - __glibcxx_assert(__b2 != memory_order_acq_rel); - __glibcxx_assert(__b2 <= __b1); - - return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, - int(__m1), int(__m2)); - } - - _GLIBCXX_ALWAYS_INLINE __pointer_type - fetch_add(ptrdiff_t __d, - memory_order __m = memory_order_seq_cst) noexcept - { return __atomic_fetch_add(&_M_p, _M_type_size(__d), int(__m)); } - - _GLIBCXX_ALWAYS_INLINE __pointer_type - fetch_add(ptrdiff_t __d, - memory_order __m = memory_order_seq_cst) volatile noexcept - { return __atomic_fetch_add(&_M_p, _M_type_size(__d), int(__m)); } - - _GLIBCXX_ALWAYS_INLINE __pointer_type - fetch_sub(ptrdiff_t __d, - memory_order __m = memory_order_seq_cst) noexcept - { return __atomic_fetch_sub(&_M_p, _M_type_size(__d), int(__m)); } - - _GLIBCXX_ALWAYS_INLINE __pointer_type - fetch_sub(ptrdiff_t __d, - memory_order __m = memory_order_seq_cst) volatile noexcept - { return __atomic_fetch_sub(&_M_p, _M_type_size(__d), int(__m)); } + { return __atomic_impl::fetch_xor(&_M_i, __i, __m); } }; #if __cplusplus > 201703L - // Implementation details of atomic_ref and atomic. - namespace __atomic_impl - { - // Remove volatile and create a non-deduced context for value arguments. - template - using _Val = remove_volatile_t<_Tp>; - - // As above, but for difference_type arguments. - template - using _Diff = conditional_t, ptrdiff_t, _Val<_Tp>>; - - template - _GLIBCXX_ALWAYS_INLINE bool - is_lock_free() noexcept - { - // Produce a fake, minimally aligned pointer. - return __atomic_is_lock_free(_Size, reinterpret_cast(-_Align)); - } - - template - _GLIBCXX_ALWAYS_INLINE void - store(_Tp* __ptr, _Val<_Tp> __t, memory_order __m) noexcept - { __atomic_store(__ptr, std::__addressof(__t), int(__m)); } - - template - _GLIBCXX_ALWAYS_INLINE _Tp - load(_Tp* __ptr, memory_order __m) noexcept - { - alignas(_Tp) unsigned char __buf[sizeof(_Tp)]; - _Tp* __dest = reinterpret_cast<_Tp*>(__buf); - __atomic_load(__ptr, __dest, int(__m)); - return *__dest; - } - - template - _GLIBCXX_ALWAYS_INLINE _Tp - exchange(_Tp* __ptr, _Val<_Tp> __desired, memory_order __m) noexcept - { - alignas(_Tp) unsigned char __buf[sizeof(_Tp)]; - _Tp* __dest = reinterpret_cast<_Tp*>(__buf); - __atomic_exchange(__ptr, std::__addressof(__desired), __dest, int(__m)); - return *__dest; - } - - template - _GLIBCXX_ALWAYS_INLINE bool - compare_exchange_weak(_Tp* __ptr, _Val<_Tp>& __expected, - _Val<_Tp> __desired, memory_order __success, - memory_order __failure) noexcept - { - return __atomic_compare_exchange(__ptr, std::__addressof(__expected), - std::__addressof(__desired), true, - int(__success), int(__failure)); - } - - template - _GLIBCXX_ALWAYS_INLINE bool - compare_exchange_strong(_Tp* __ptr, _Val<_Tp>& __expected, - _Val<_Tp> __desired, memory_order __success, - memory_order __failure) noexcept - { - return __atomic_compare_exchange(__ptr, std::__addressof(__expected), - std::__addressof(__desired), false, - int(__success), int(__failure)); - } - - template - _GLIBCXX_ALWAYS_INLINE _Tp - fetch_add(_Tp* __ptr, _Diff<_Tp> __i, memory_order __m) noexcept - { return __atomic_fetch_add(__ptr, __i, int(__m)); } - - template - _GLIBCXX_ALWAYS_INLINE _Tp - fetch_sub(_Tp* __ptr, _Diff<_Tp> __i, memory_order __m) noexcept - { return __atomic_fetch_sub(__ptr, __i, int(__m)); } - - template - _GLIBCXX_ALWAYS_INLINE _Tp - fetch_and(_Tp* __ptr, _Val<_Tp> __i, memory_order __m) noexcept - { return __atomic_fetch_and(__ptr, __i, int(__m)); } - - template - _GLIBCXX_ALWAYS_INLINE _Tp - fetch_or(_Tp* __ptr, _Val<_Tp> __i, memory_order __m) noexcept - { return __atomic_fetch_or(__ptr, __i, int(__m)); } - - template - _GLIBCXX_ALWAYS_INLINE _Tp - fetch_xor(_Tp* __ptr, _Val<_Tp> __i, memory_order __m) noexcept - { return __atomic_fetch_xor(__ptr, __i, int(__m)); } - - template - _GLIBCXX_ALWAYS_INLINE _Tp - __add_fetch(_Tp* __ptr, _Diff<_Tp> __i) noexcept - { return __atomic_add_fetch(__ptr, __i, __ATOMIC_SEQ_CST); } - - template - _GLIBCXX_ALWAYS_INLINE _Tp - __sub_fetch(_Tp* __ptr, _Diff<_Tp> __i) noexcept - { return __atomic_sub_fetch(__ptr, __i, __ATOMIC_SEQ_CST); } - - template - _GLIBCXX_ALWAYS_INLINE _Tp - __and_fetch(_Tp* __ptr, _Val<_Tp> __i) noexcept - { return __atomic_and_fetch(__ptr, __i, __ATOMIC_SEQ_CST); } - - template - _GLIBCXX_ALWAYS_INLINE _Tp - __or_fetch(_Tp* __ptr, _Val<_Tp> __i) noexcept - { return __atomic_or_fetch(__ptr, __i, __ATOMIC_SEQ_CST); } - - template - _GLIBCXX_ALWAYS_INLINE _Tp - __xor_fetch(_Tp* __ptr, _Val<_Tp> __i) noexcept - { return __atomic_xor_fetch(__ptr, __i, __ATOMIC_SEQ_CST); } - - template - _Tp - __fetch_add_flt(_Tp* __ptr, _Val<_Tp> __i, memory_order __m) noexcept - { - _Val<_Tp> __oldval = load(__ptr, memory_order_relaxed); - _Val<_Tp> __newval = __oldval + __i; - while (!compare_exchange_weak(__ptr, __oldval, __newval, __m, - memory_order_relaxed)) - __newval = __oldval + __i; - return __oldval; - } - - template - _Tp - __fetch_sub_flt(_Tp* __ptr, _Val<_Tp> __i, memory_order __m) noexcept - { - _Val<_Tp> __oldval = load(__ptr, memory_order_relaxed); - _Val<_Tp> __newval = __oldval - __i; - while (!compare_exchange_weak(__ptr, __oldval, __newval, __m, - memory_order_relaxed)) - __newval = __oldval - __i; - return __oldval; - } - - template - _Tp - __add_fetch_flt(_Tp* __ptr, _Val<_Tp> __i) noexcept - { - _Val<_Tp> __oldval = load(__ptr, memory_order_relaxed); - _Val<_Tp> __newval = __oldval + __i; - while (!compare_exchange_weak(__ptr, __oldval, __newval, - memory_order_seq_cst, - memory_order_relaxed)) - __newval = __oldval + __i; - return __newval; - } - - template - _Tp - __sub_fetch_flt(_Tp* __ptr, _Val<_Tp> __i) noexcept - { - _Val<_Tp> __oldval = load(__ptr, memory_order_relaxed); - _Val<_Tp> __newval = __oldval - __i; - while (!compare_exchange_weak(__ptr, __oldval, __newval, - memory_order_seq_cst, - memory_order_relaxed)) - __newval = __oldval - __i; - return __newval; - } - } // namespace __atomic_impl - - // base class for atomic + // Base class for atomic. + // Implementation for atomic, atomic, atomic. template struct __atomic_float { diff --git a/libstdc++-v3/include/std/atomic b/libstdc++-v3/include/std/atomic index 26d8d3946da..686ecc9114e 100644 --- a/libstdc++-v3/include/std/atomic +++ b/libstdc++-v3/include/std/atomic @@ -218,19 +218,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION bool is_lock_free() const noexcept - { - // Produce a fake, minimally aligned pointer. - return __atomic_is_lock_free(sizeof(_M_i), - reinterpret_cast(-_S_alignment)); - } + { return __atomic_impl::is_lock_free(); } bool is_lock_free() const volatile noexcept - { - // Produce a fake, minimally aligned pointer. - return __atomic_is_lock_free(sizeof(_M_i), - reinterpret_cast(-_S_alignment)); - } + { return __atomic_impl::is_lock_free(); } #if __cplusplus >= 201703L static constexpr bool is_always_lock_free @@ -239,69 +231,43 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION void store(_Tp __i, memory_order __m = memory_order_seq_cst) noexcept - { __atomic_store(std::__addressof(_M_i), std::__addressof(__i), int(__m)); } + { __atomic_impl::store(std::__addressof(_M_i), __i, __m); } void store(_Tp __i, memory_order __m = memory_order_seq_cst) volatile noexcept - { __atomic_store(std::__addressof(_M_i), std::__addressof(__i), int(__m)); } + { __atomic_impl::store(std::__addressof(_M_i), __i, __m); } _Tp load(memory_order __m = memory_order_seq_cst) const noexcept - { - alignas(_Tp) unsigned char __buf[sizeof(_Tp)]; - _Tp* __ptr = reinterpret_cast<_Tp*>(__buf); - __atomic_load(std::__addressof(_M_i), __ptr, int(__m)); - return *__ptr; - } + { return __atomic_impl::load(std::__addressof(_M_i), __m); } _Tp load(memory_order __m = memory_order_seq_cst) const volatile noexcept - { - alignas(_Tp) unsigned char __buf[sizeof(_Tp)]; - _Tp* __ptr = reinterpret_cast<_Tp*>(__buf); - __atomic_load(std::__addressof(_M_i), __ptr, int(__m)); - return *__ptr; - } + { return __atomic_impl::load(std::__addressof(_M_i), __m); } _Tp exchange(_Tp __i, memory_order __m = memory_order_seq_cst) noexcept - { - alignas(_Tp) unsigned char __buf[sizeof(_Tp)]; - _Tp* __ptr = reinterpret_cast<_Tp*>(__buf); - __atomic_exchange(std::__addressof(_M_i), std::__addressof(__i), - __ptr, int(__m)); - return *__ptr; - } + { return __atomic_impl::exchange(std::__addressof(_M_i), __i, __m); } _Tp exchange(_Tp __i, memory_order __m = memory_order_seq_cst) volatile noexcept - { - alignas(_Tp) unsigned char __buf[sizeof(_Tp)]; - _Tp* __ptr = reinterpret_cast<_Tp*>(__buf); - __atomic_exchange(std::__addressof(_M_i), std::__addressof(__i), - __ptr, int(__m)); - return *__ptr; - } + { return __atomic_impl::exchange(std::__addressof(_M_i), __i, __m); } bool compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s, memory_order __f) noexcept { - return __atomic_compare_exchange(std::__addressof(_M_i), - std::__addressof(__e), - std::__addressof(__i), - true, int(__s), int(__f)); + return __atomic_impl::compare_exchange_weak(std::__addressof(_M_i), + __e, __i, __s, __f); } bool compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s, memory_order __f) volatile noexcept { - return __atomic_compare_exchange(std::__addressof(_M_i), - std::__addressof(__e), - std::__addressof(__i), - true, int(__s), int(__f)); + return __atomic_impl::compare_exchange_weak(std::__addressof(_M_i), + __e, __i, __s, __f); } bool @@ -320,20 +286,16 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s, memory_order __f) noexcept { - return __atomic_compare_exchange(std::__addressof(_M_i), - std::__addressof(__e), - std::__addressof(__i), - false, int(__s), int(__f)); + return __atomic_impl::compare_exchange_strong(std::__addressof(_M_i), + __e, __i, __s, __f); } bool compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s, memory_order __f) volatile noexcept { - return __atomic_compare_exchange(std::__addressof(_M_i), - std::__addressof(__e), - std::__addressof(__i), - false, int(__s), int(__f)); + return __atomic_impl::compare_exchange_strong(std::__addressof(_M_i), + __e, __i, __s, __f); } bool @@ -357,9 +319,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION using value_type = _Tp*; using difference_type = ptrdiff_t; - typedef _Tp* __pointer_type; - typedef __atomic_base<_Tp*> __base_type; - __base_type _M_b; + value_type _M_p; atomic() noexcept = default; ~atomic() noexcept = default; @@ -367,183 +327,207 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; - constexpr atomic(__pointer_type __p) noexcept : _M_b(__p) { } + constexpr atomic(value_type __p) noexcept : _M_p(__p) { } - operator __pointer_type() const noexcept - { return __pointer_type(_M_b); } + operator value_type() const noexcept + { return load(); } - operator __pointer_type() const volatile noexcept - { return __pointer_type(_M_b); } + operator value_type() const volatile noexcept + { return load(); } - __pointer_type - operator=(__pointer_type __p) noexcept - { return _M_b.operator=(__p); } + value_type + operator=(value_type __p) noexcept + { + store(__p); + return __p; + } - __pointer_type - operator=(__pointer_type __p) volatile noexcept - { return _M_b.operator=(__p); } + value_type + operator=(value_type __p) volatile noexcept + { + store(__p); + return __p; + } - __pointer_type + _GLIBCXX_ALWAYS_INLINE value_type operator++(int) noexcept { #if __cplusplus >= 201703L static_assert( is_object<_Tp>::value, "pointer to object type" ); #endif - return _M_b++; + return fetch_add(1); } - __pointer_type + _GLIBCXX_ALWAYS_INLINE value_type operator++(int) volatile noexcept { #if __cplusplus >= 201703L static_assert( is_object<_Tp>::value, "pointer to object type" ); #endif - return _M_b++; + return fetch_add(1); } - __pointer_type + _GLIBCXX_ALWAYS_INLINE value_type operator--(int) noexcept { #if __cplusplus >= 201703L static_assert( is_object<_Tp>::value, "pointer to object type" ); #endif - return _M_b--; + return fetch_sub(1); } - __pointer_type + _GLIBCXX_ALWAYS_INLINE value_type operator--(int) volatile noexcept { #if __cplusplus >= 201703L static_assert( is_object<_Tp>::value, "pointer to object type" ); #endif - return _M_b--; + return fetch_sub(1); } - __pointer_type + value_type operator++() noexcept { #if __cplusplus >= 201703L static_assert( is_object<_Tp>::value, "pointer to object type" ); #endif - return ++_M_b; + return __atomic_impl::__add_fetch(std::__addressof(_M_p), + _S_type_size(1)); } - __pointer_type + value_type operator++() volatile noexcept { #if __cplusplus >= 201703L static_assert( is_object<_Tp>::value, "pointer to object type" ); #endif - return ++_M_b; + return __atomic_impl::__add_fetch(std::__addressof(_M_p), + _S_type_size(1)); } - __pointer_type + value_type operator--() noexcept { #if __cplusplus >= 201703L static_assert( is_object<_Tp>::value, "pointer to object type" ); #endif - return --_M_b; + return __atomic_impl::__sub_fetch(std::__addressof(_M_p), + _S_type_size(1)); } - __pointer_type + value_type operator--() volatile noexcept { #if __cplusplus >= 201703L static_assert( is_object<_Tp>::value, "pointer to object type" ); #endif - return --_M_b; + return __atomic_impl::__sub_fetch(std::__addressof(_M_p), + _S_type_size(1)); } - __pointer_type + value_type operator+=(ptrdiff_t __d) noexcept { #if __cplusplus >= 201703L static_assert( is_object<_Tp>::value, "pointer to object type" ); #endif - return _M_b.operator+=(__d); + return __atomic_impl::__add_fetch(std::__addressof(_M_p), + _S_type_size(__d)); } - __pointer_type + value_type operator+=(ptrdiff_t __d) volatile noexcept { #if __cplusplus >= 201703L static_assert( is_object<_Tp>::value, "pointer to object type" ); #endif - return _M_b.operator+=(__d); + return __atomic_impl::__add_fetch(std::__addressof(_M_p), + _S_type_size(__d)); } - __pointer_type + value_type operator-=(ptrdiff_t __d) noexcept { #if __cplusplus >= 201703L static_assert( is_object<_Tp>::value, "pointer to object type" ); #endif - return _M_b.operator-=(__d); + return __atomic_impl::__sub_fetch(std::__addressof(_M_p), + _S_type_size(__d)); } - __pointer_type + value_type operator-=(ptrdiff_t __d) volatile noexcept { #if __cplusplus >= 201703L static_assert( is_object<_Tp>::value, "pointer to object type" ); #endif - return _M_b.operator-=(__d); + return __atomic_impl::__sub_fetch(std::__addressof(_M_p), + _S_type_size(__d)); } bool is_lock_free() const noexcept - { return _M_b.is_lock_free(); } + { + return __atomic_impl::is_lock_free(); + } bool is_lock_free() const volatile noexcept - { return _M_b.is_lock_free(); } + { + return __atomic_impl::is_lock_free(); + } #if __cplusplus >= 201703L static constexpr bool is_always_lock_free = ATOMIC_POINTER_LOCK_FREE == 2; #endif void - store(__pointer_type __p, + store(value_type __p, memory_order __m = memory_order_seq_cst) noexcept - { return _M_b.store(__p, __m); } + { __atomic_impl::store(std::__addressof(_M_p), __p, __m); } void - store(__pointer_type __p, + store(value_type __p, memory_order __m = memory_order_seq_cst) volatile noexcept - { return _M_b.store(__p, __m); } + { __atomic_impl::store(std::__addressof(_M_p), __p, __m); } - __pointer_type + value_type load(memory_order __m = memory_order_seq_cst) const noexcept - { return _M_b.load(__m); } + { return __atomic_impl::load(std::__addressof(_M_p), __m); } - __pointer_type + value_type load(memory_order __m = memory_order_seq_cst) const volatile noexcept - { return _M_b.load(__m); } + { return __atomic_impl::load(std::__addressof(_M_p), __m); } - __pointer_type - exchange(__pointer_type __p, + value_type + exchange(value_type __p, memory_order __m = memory_order_seq_cst) noexcept - { return _M_b.exchange(__p, __m); } + { return __atomic_impl::exchange(std::__addressof(_M_p), __p, __m); } - __pointer_type - exchange(__pointer_type __p, + value_type + exchange(value_type __p, memory_order __m = memory_order_seq_cst) volatile noexcept - { return _M_b.exchange(__p, __m); } + { return __atomic_impl::exchange(std::__addressof(_M_p), __p, __m); } bool - compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, + compare_exchange_weak(value_type& __p1, value_type __p2, memory_order __m1, memory_order __m2) noexcept - { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); } + { + return __atomic_impl::compare_exchange_weak(std::__addressof(_M_p), + __p1, __p2, __m1, __m2); + } bool - compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, + compare_exchange_weak(value_type& __p1, value_type __p2, memory_order __m1, memory_order __m2) volatile noexcept - { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); } + { + return __atomic_impl::compare_exchange_weak(std::__addressof(_M_p), + __p1, __p2, __m1, __m2); + } bool - compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, + compare_exchange_weak(value_type& __p1, value_type __p2, memory_order __m = memory_order_seq_cst) noexcept { return compare_exchange_weak(__p1, __p2, __m, @@ -551,7 +535,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } bool - compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, + compare_exchange_weak(value_type& __p1, value_type __p2, memory_order __m = memory_order_seq_cst) volatile noexcept { return compare_exchange_weak(__p1, __p2, __m, @@ -559,70 +543,78 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } bool - compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, + compare_exchange_strong(value_type& __p1, value_type __p2, memory_order __m1, memory_order __m2) noexcept - { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); } + { + return __atomic_impl::compare_exchange_strong(std::__addressof(_M_p), + __p1, __p2, __m1, __m2); + } bool - compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, + compare_exchange_strong(value_type& __p1, value_type __p2, memory_order __m1, memory_order __m2) volatile noexcept - { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); } + { + return __atomic_impl::compare_exchange_strong(std::__addressof(_M_p), + __p1, __p2, __m1, __m2); + } bool - compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, + compare_exchange_strong(value_type& __p1, value_type __p2, memory_order __m = memory_order_seq_cst) noexcept { - return _M_b.compare_exchange_strong(__p1, __p2, __m, - __cmpexch_failure_order(__m)); + return compare_exchange_strong(__p1, __p2, __m, + __cmpexch_failure_order(__m)); } bool - compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, + compare_exchange_strong(value_type& __p1, value_type __p2, memory_order __m = memory_order_seq_cst) volatile noexcept { - return _M_b.compare_exchange_strong(__p1, __p2, __m, - __cmpexch_failure_order(__m)); + return compare_exchange_strong(__p1, __p2, __m, + __cmpexch_failure_order(__m)); } - __pointer_type + value_type fetch_add(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) noexcept { -#if __cplusplus >= 201703L - static_assert( is_object<_Tp>::value, "pointer to object type" ); -#endif - return _M_b.fetch_add(__d, __m); + return __atomic_impl::fetch_add(std::__addressof(_M_p), + _S_type_size(__d), __m); } - __pointer_type + value_type fetch_add(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) volatile noexcept { -#if __cplusplus >= 201703L - static_assert( is_object<_Tp>::value, "pointer to object type" ); -#endif - return _M_b.fetch_add(__d, __m); + return __atomic_impl::fetch_add(std::__addressof(_M_p), + _S_type_size(__d), __m); } - __pointer_type + value_type fetch_sub(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) noexcept { -#if __cplusplus >= 201703L - static_assert( is_object<_Tp>::value, "pointer to object type" ); -#endif - return _M_b.fetch_sub(__d, __m); + return __atomic_impl::fetch_sub(std::__addressof(_M_p), + _S_type_size(__d), __m); } - __pointer_type + value_type fetch_sub(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) volatile noexcept { + return __atomic_impl::fetch_sub(std::__addressof(_M_p), + _S_type_size(__d), __m); + } + + private: + static constexpr ptrdiff_t + _S_type_size(ptrdiff_t __d) noexcept + { #if __cplusplus >= 201703L - static_assert( is_object<_Tp>::value, "pointer to object type" ); + static_assert(is_object_v<_Tp>); #endif - return _M_b.fetch_sub(__d, __m); + return __d * sizeof(_Tp); } }; @@ -631,8 +623,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template<> struct atomic : __atomic_base { - typedef char __integral_type; - typedef __atomic_base __base_type; + using value_type = char; atomic() noexcept = default; ~atomic() noexcept = default; @@ -640,10 +631,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; - constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + constexpr atomic(value_type __i) noexcept + : __atomic_base(__i) { } - using __base_type::operator __integral_type; - using __base_type::operator=; + using __atomic_base::operator value_type; + using __atomic_base::operator=; #if __cplusplus >= 201703L static constexpr bool is_always_lock_free = ATOMIC_CHAR_LOCK_FREE == 2; @@ -654,8 +646,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template<> struct atomic : __atomic_base { - typedef signed char __integral_type; - typedef __atomic_base __base_type; + using value_type = signed char; atomic() noexcept= default; ~atomic() noexcept = default; @@ -663,10 +654,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; - constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + constexpr atomic(value_type __i) noexcept + : __atomic_base(__i) { } - using __base_type::operator __integral_type; - using __base_type::operator=; + using __atomic_base::operator value_type; + using __atomic_base::operator=; #if __cplusplus >= 201703L static constexpr bool is_always_lock_free = ATOMIC_CHAR_LOCK_FREE == 2; @@ -677,8 +669,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template<> struct atomic : __atomic_base { - typedef unsigned char __integral_type; - typedef __atomic_base __base_type; + using value_type = unsigned char; atomic() noexcept= default; ~atomic() noexcept = default; @@ -686,10 +677,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; - constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + constexpr atomic(value_type __i) noexcept + : __atomic_base(__i) { } - using __base_type::operator __integral_type; - using __base_type::operator=; + using __atomic_base::operator value_type; + using __atomic_base::operator=; #if __cplusplus >= 201703L static constexpr bool is_always_lock_free = ATOMIC_CHAR_LOCK_FREE == 2; @@ -700,8 +692,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template<> struct atomic : __atomic_base { - typedef short __integral_type; - typedef __atomic_base __base_type; + using value_type = short; atomic() noexcept = default; ~atomic() noexcept = default; @@ -709,10 +700,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; - constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + constexpr atomic(value_type __i) noexcept + : __atomic_base(__i) { } - using __base_type::operator __integral_type; - using __base_type::operator=; + using __atomic_base::operator value_type; + using __atomic_base::operator=; #if __cplusplus >= 201703L static constexpr bool is_always_lock_free = ATOMIC_SHORT_LOCK_FREE == 2; @@ -723,8 +715,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template<> struct atomic : __atomic_base { - typedef unsigned short __integral_type; - typedef __atomic_base __base_type; + using value_type = unsigned short; atomic() noexcept = default; ~atomic() noexcept = default; @@ -732,10 +723,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; - constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + constexpr atomic(value_type __i) noexcept + : __atomic_base(__i) { } - using __base_type::operator __integral_type; - using __base_type::operator=; + using __atomic_base::operator value_type; + using __atomic_base::operator=; #if __cplusplus >= 201703L static constexpr bool is_always_lock_free = ATOMIC_SHORT_LOCK_FREE == 2; @@ -746,8 +738,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template<> struct atomic : __atomic_base { - typedef int __integral_type; - typedef __atomic_base __base_type; + using value_type = int; atomic() noexcept = default; ~atomic() noexcept = default; @@ -755,10 +746,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; - constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + constexpr atomic(value_type __i) noexcept + : __atomic_base(__i) { } - using __base_type::operator __integral_type; - using __base_type::operator=; + using __atomic_base::operator value_type; + using __atomic_base::operator=; #if __cplusplus >= 201703L static constexpr bool is_always_lock_free = ATOMIC_INT_LOCK_FREE == 2; @@ -769,8 +761,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template<> struct atomic : __atomic_base { - typedef unsigned int __integral_type; - typedef __atomic_base __base_type; + using value_type = unsigned int; atomic() noexcept = default; ~atomic() noexcept = default; @@ -778,10 +769,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; - constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + constexpr atomic(value_type __i) noexcept + : __atomic_base(__i) { } - using __base_type::operator __integral_type; - using __base_type::operator=; + using __atomic_base::operator value_type; + using __atomic_base::operator=; #if __cplusplus >= 201703L static constexpr bool is_always_lock_free = ATOMIC_INT_LOCK_FREE == 2; @@ -792,8 +784,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template<> struct atomic : __atomic_base { - typedef long __integral_type; - typedef __atomic_base __base_type; + using value_type = long; atomic() noexcept = default; ~atomic() noexcept = default; @@ -801,10 +792,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; - constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + constexpr atomic(value_type __i) noexcept + : __atomic_base(__i) { } - using __base_type::operator __integral_type; - using __base_type::operator=; + using __atomic_base::operator value_type; + using __atomic_base::operator=; #if __cplusplus >= 201703L static constexpr bool is_always_lock_free = ATOMIC_LONG_LOCK_FREE == 2; @@ -815,8 +807,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template<> struct atomic : __atomic_base { - typedef unsigned long __integral_type; - typedef __atomic_base __base_type; + using value_type = unsigned long; atomic() noexcept = default; ~atomic() noexcept = default; @@ -824,10 +815,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; - constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + constexpr atomic(value_type __i) noexcept + : __atomic_base(__i) { } - using __base_type::operator __integral_type; - using __base_type::operator=; + using __atomic_base::operator value_type; + using __atomic_base::operator=; #if __cplusplus >= 201703L static constexpr bool is_always_lock_free = ATOMIC_LONG_LOCK_FREE == 2; @@ -838,8 +830,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template<> struct atomic : __atomic_base { - typedef long long __integral_type; - typedef __atomic_base __base_type; + using value_type = long long; atomic() noexcept = default; ~atomic() noexcept = default; @@ -847,10 +838,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; - constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + constexpr atomic(value_type __i) noexcept + : __atomic_base(__i) { } - using __base_type::operator __integral_type; - using __base_type::operator=; + using __atomic_base::operator value_type; + using __atomic_base::operator=; #if __cplusplus >= 201703L static constexpr bool is_always_lock_free = ATOMIC_LLONG_LOCK_FREE == 2; @@ -861,8 +853,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template<> struct atomic : __atomic_base { - typedef unsigned long long __integral_type; - typedef __atomic_base __base_type; + using value_type = unsigned long long; atomic() noexcept = default; ~atomic() noexcept = default; @@ -870,10 +861,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; - constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + constexpr atomic(value_type __i) noexcept + : __atomic_base(__i) { } - using __base_type::operator __integral_type; - using __base_type::operator=; + using __atomic_base::operator value_type; + using __atomic_base::operator=; #if __cplusplus >= 201703L static constexpr bool is_always_lock_free = ATOMIC_LLONG_LOCK_FREE == 2; @@ -884,8 +876,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template<> struct atomic : __atomic_base { - typedef wchar_t __integral_type; - typedef __atomic_base __base_type; + using value_type = wchar_t; atomic() noexcept = default; ~atomic() noexcept = default; @@ -893,10 +884,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; - constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + constexpr atomic(value_type __i) noexcept + : __atomic_base(__i) { } - using __base_type::operator __integral_type; - using __base_type::operator=; + using __atomic_base::operator value_type; + using __atomic_base::operator=; #if __cplusplus >= 201703L static constexpr bool is_always_lock_free = ATOMIC_WCHAR_T_LOCK_FREE == 2; @@ -908,8 +900,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template<> struct atomic : __atomic_base { - typedef char8_t __integral_type; - typedef __atomic_base __base_type; + using value_type = char8_t; atomic() noexcept = default; ~atomic() noexcept = default; @@ -917,23 +908,23 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; - constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + constexpr atomic(value_type __i) noexcept + : __atomic_base(__i) { } - using __base_type::operator __integral_type; - using __base_type::operator=; + using __atomic_base::operator value_type; + using __atomic_base::operator=; #if __cplusplus > 201402L static constexpr bool is_always_lock_free = ATOMIC_CHAR8_T_LOCK_FREE == 2; #endif }; -#endif +#endif // char8_t /// Explicit specialization for char16_t. template<> struct atomic : __atomic_base { - typedef char16_t __integral_type; - typedef __atomic_base __base_type; + using value_type = char16_t; atomic() noexcept = default; ~atomic() noexcept = default; @@ -941,10 +932,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; - constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + constexpr atomic(value_type __i) noexcept + : __atomic_base(__i) { } - using __base_type::operator __integral_type; - using __base_type::operator=; + using __atomic_base::operator value_type; + using __atomic_base::operator=; #if __cplusplus >= 201703L static constexpr bool is_always_lock_free = ATOMIC_CHAR16_T_LOCK_FREE == 2; @@ -955,8 +947,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template<> struct atomic : __atomic_base { - typedef char32_t __integral_type; - typedef __atomic_base __base_type; + using value_type = char32_t; atomic() noexcept = default; ~atomic() noexcept = default; @@ -964,10 +955,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; - constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + constexpr atomic(value_type __i) noexcept + : __atomic_base(__i) { } - using __base_type::operator __integral_type; - using __base_type::operator=; + using __atomic_base::operator value_type; + using __atomic_base::operator=; #if __cplusplus >= 201703L static constexpr bool is_always_lock_free = ATOMIC_CHAR32_T_LOCK_FREE == 2; @@ -1337,9 +1329,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION memory_order_seq_cst); } - // Function templates for atomic_integral and atomic_pointer operations only. - // Some operations (and, or, xor) are only available for atomic integrals, - // which is implemented by taking a parameter of type __atomic_base<_ITp>*. + // Function templates for atomic and atomic operations only. + // These functions are ill-formed if called for a specialization that + // does not define the corresponding member function. template inline _ITp @@ -1371,42 +1363,42 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template inline _ITp - atomic_fetch_and_explicit(__atomic_base<_ITp>* __a, + atomic_fetch_and_explicit(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i, memory_order __m) noexcept { return __a->fetch_and(__i, __m); } template inline _ITp - atomic_fetch_and_explicit(volatile __atomic_base<_ITp>* __a, + atomic_fetch_and_explicit(volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i, memory_order __m) noexcept { return __a->fetch_and(__i, __m); } template inline _ITp - atomic_fetch_or_explicit(__atomic_base<_ITp>* __a, + atomic_fetch_or_explicit(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i, memory_order __m) noexcept { return __a->fetch_or(__i, __m); } template inline _ITp - atomic_fetch_or_explicit(volatile __atomic_base<_ITp>* __a, + atomic_fetch_or_explicit(volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i, memory_order __m) noexcept { return __a->fetch_or(__i, __m); } template inline _ITp - atomic_fetch_xor_explicit(__atomic_base<_ITp>* __a, + atomic_fetch_xor_explicit(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i, memory_order __m) noexcept { return __a->fetch_xor(__i, __m); } template inline _ITp - atomic_fetch_xor_explicit(volatile __atomic_base<_ITp>* __a, + atomic_fetch_xor_explicit(volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i, memory_order __m) noexcept { return __a->fetch_xor(__i, __m); } @@ -1437,37 +1429,37 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template inline _ITp - atomic_fetch_and(__atomic_base<_ITp>* __a, + atomic_fetch_and(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); } template inline _ITp - atomic_fetch_and(volatile __atomic_base<_ITp>* __a, + atomic_fetch_and(volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); } template inline _ITp - atomic_fetch_or(__atomic_base<_ITp>* __a, + atomic_fetch_or(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); } template inline _ITp - atomic_fetch_or(volatile __atomic_base<_ITp>* __a, + atomic_fetch_or(volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); } template inline _ITp - atomic_fetch_xor(__atomic_base<_ITp>* __a, + atomic_fetch_xor(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); } template inline _ITp - atomic_fetch_xor(volatile __atomic_base<_ITp>* __a, + atomic_fetch_xor(volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }