__cxx03/__atomic/atomic_base.h

0001 //===----------------------------------------------------------------------===//
0002 //
0003 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
0004 // See https://llvm.org/LICENSE.txt for license information.
0005 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
0006 //
0007 //===----------------------------------------------------------------------===//
0008
0009 #ifndef _LIBCPP___CXX03___ATOMIC_ATOMIC_BASE_H
0010 #define _LIBCPP___CXX03___ATOMIC_ATOMIC_BASE_H
0011
0012 #include <__cxx03/__atomic/atomic_sync.h>
0013 #include <__cxx03/__atomic/check_memory_order.h>
0014 #include <__cxx03/__atomic/cxx_atomic_impl.h>
0015 #include <__cxx03/__atomic/is_always_lock_free.h>
0016 #include <__cxx03/__atomic/memory_order.h>
0017 #include <__cxx03/__config>
0018 #include <__cxx03/__memory/addressof.h>
0019 #include <__cxx03/__type_traits/is_integral.h>
0020 #include <__cxx03/__type_traits/is_nothrow_constructible.h>
0021 #include <__cxx03/__type_traits/is_same.h>
0022 #include <__cxx03/version>
0023
0024 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
0025 #  pragma GCC system_header
0026 #endif
0027
0028 _LIBCPP_BEGIN_NAMESPACE_STD
0029
0030 template <class _Tp, bool = is_integral<_Tp>::value && !is_same<_Tp, bool>::value>
0031 struct __atomic_base // false
0032 {
0033   mutable __cxx_atomic_impl<_Tp> __a_;
0034
0035 #if _LIBCPP_STD_VER >= 17
0036   static constexpr bool is_always_lock_free = __libcpp_is_always_lock_free<__cxx_atomic_impl<_Tp> >::__value;
0037 #endif
0038
0039   _LIBCPP_HIDE_FROM_ABI bool is_lock_free() const volatile _NOEXCEPT {
0040     return __cxx_atomic_is_lock_free(sizeof(__cxx_atomic_impl<_Tp>));
0041   }
0042   _LIBCPP_HIDE_FROM_ABI bool is_lock_free() const _NOEXCEPT {
0043     return static_cast<__atomic_base const volatile*>(this)->is_lock_free();
0044   }
0045   _LIBCPP_HIDE_FROM_ABI void store(_Tp __d, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT
0046       _LIBCPP_CHECK_STORE_MEMORY_ORDER(__m) {
0047     std::__cxx_atomic_store(std::addressof(__a_), __d, __m);
0048   }
0049   _LIBCPP_HIDE_FROM_ABI void store(_Tp __d, memory_order __m = memory_order_seq_cst) _NOEXCEPT
0050       _LIBCPP_CHECK_STORE_MEMORY_ORDER(__m) {
0051     std::__cxx_atomic_store(std::addressof(__a_), __d, __m);
0052   }
0053   _LIBCPP_HIDE_FROM_ABI _Tp load(memory_order __m = memory_order_seq_cst) const volatile _NOEXCEPT
0054       _LIBCPP_CHECK_LOAD_MEMORY_ORDER(__m) {
0055     return std::__cxx_atomic_load(std::addressof(__a_), __m);
0056   }
0057   _LIBCPP_HIDE_FROM_ABI _Tp load(memory_order __m = memory_order_seq_cst) const _NOEXCEPT
0058       _LIBCPP_CHECK_LOAD_MEMORY_ORDER(__m) {
0059     return std::__cxx_atomic_load(std::addressof(__a_), __m);
0060   }
0061   _LIBCPP_HIDE_FROM_ABI operator _Tp() const volatile _NOEXCEPT { return load(); }
0062   _LIBCPP_HIDE_FROM_ABI operator _Tp() const _NOEXCEPT { return load(); }
0063   _LIBCPP_HIDE_FROM_ABI _Tp exchange(_Tp __d, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT {
0064     return std::__cxx_atomic_exchange(std::addressof(__a_), __d, __m);
0065   }
0066   _LIBCPP_HIDE_FROM_ABI _Tp exchange(_Tp __d, memory_order __m = memory_order_seq_cst) _NOEXCEPT {
0067     return std::__cxx_atomic_exchange(std::addressof(__a_), __d, __m);
0068   }
0069   _LIBCPP_HIDE_FROM_ABI bool
0070   compare_exchange_weak(_Tp& __e, _Tp __d, memory_order __s, memory_order __f) volatile _NOEXCEPT
0071       _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f) {
0072     return std::__cxx_atomic_compare_exchange_weak(std::addressof(__a_), std::addressof(__e), __d, __s, __f);
0073   }
0074   _LIBCPP_HIDE_FROM_ABI bool compare_exchange_weak(_Tp& __e, _Tp __d, memory_order __s, memory_order __f) _NOEXCEPT
0075       _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f) {
0076     return std::__cxx_atomic_compare_exchange_weak(std::addressof(__a_), std::addressof(__e), __d, __s, __f);
0077   }
0078   _LIBCPP_HIDE_FROM_ABI bool
0079   compare_exchange_strong(_Tp& __e, _Tp __d, memory_order __s, memory_order __f) volatile _NOEXCEPT
0080       _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f) {
0081     return std::__cxx_atomic_compare_exchange_strong(std::addressof(__a_), std::addressof(__e), __d, __s, __f);
0082   }
0083   _LIBCPP_HIDE_FROM_ABI bool compare_exchange_strong(_Tp& __e, _Tp __d, memory_order __s, memory_order __f) _NOEXCEPT
0084       _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f) {
0085     return std::__cxx_atomic_compare_exchange_strong(std::addressof(__a_), std::addressof(__e), __d, __s, __f);
0086   }
0087   _LIBCPP_HIDE_FROM_ABI bool
0088   compare_exchange_weak(_Tp& __e, _Tp __d, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT {
0089     return std::__cxx_atomic_compare_exchange_weak(std::addressof(__a_), std::addressof(__e), __d, __m, __m);
0090   }
0091   _LIBCPP_HIDE_FROM_ABI bool
0092   compare_exchange_weak(_Tp& __e, _Tp __d, memory_order __m = memory_order_seq_cst) _NOEXCEPT {
0093     return std::__cxx_atomic_compare_exchange_weak(std::addressof(__a_), std::addressof(__e), __d, __m, __m);
0094   }
0095   _LIBCPP_HIDE_FROM_ABI bool
0096   compare_exchange_strong(_Tp& __e, _Tp __d, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT {
0097     return std::__cxx_atomic_compare_exchange_strong(std::addressof(__a_), std::addressof(__e), __d, __m, __m);
0098   }
0099   _LIBCPP_HIDE_FROM_ABI bool
0100   compare_exchange_strong(_Tp& __e, _Tp __d, memory_order __m = memory_order_seq_cst) _NOEXCEPT {
0101     return std::__cxx_atomic_compare_exchange_strong(std::addressof(__a_), std::addressof(__e), __d, __m, __m);
0102   }
0103
0104   _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void wait(_Tp __v, memory_order __m = memory_order_seq_cst) const
0105       volatile _NOEXCEPT {
0106     std::__atomic_wait(*this, __v, __m);
0107   }
0108   _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void
0109   wait(_Tp __v, memory_order __m = memory_order_seq_cst) const _NOEXCEPT {
0110     std::__atomic_wait(*this, __v, __m);
0111   }
0112   _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void notify_one() volatile _NOEXCEPT {
0113     std::__atomic_notify_one(*this);
0114   }
0115   _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void notify_one() _NOEXCEPT { std::__atomic_notify_one(*this); }
0116   _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void notify_all() volatile _NOEXCEPT {
0117     std::__atomic_notify_all(*this);
0118   }
0119   _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void notify_all() _NOEXCEPT { std::__atomic_notify_all(*this); }
0120
0121 #if _LIBCPP_STD_VER >= 20
0122   _LIBCPP_HIDE_FROM_ABI constexpr __atomic_base() noexcept(is_nothrow_default_constructible_v<_Tp>) : __a_(_Tp()) {}
0123 #else
0124   _LIBCPP_HIDE_FROM_ABI __atomic_base() _NOEXCEPT = default;
0125 #endif
0126
0127   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR __atomic_base(_Tp __d) _NOEXCEPT : __a_(__d) {}
0128
0129   __atomic_base(const __atomic_base&) = delete;
0130 };
0131
0132 // atomic<Integral>
0133
0134 template <class _Tp>
0135 struct __atomic_base<_Tp, true> : public __atomic_base<_Tp, false> {
0136   using __base = __atomic_base<_Tp, false>;
0137
0138   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __atomic_base() _NOEXCEPT = default;
0139
0140   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR __atomic_base(_Tp __d) _NOEXCEPT : __base(__d) {}
0141
0142   _LIBCPP_HIDE_FROM_ABI _Tp fetch_add(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT {
0143     return std::__cxx_atomic_fetch_add(std::addressof(this->__a_), __op, __m);
0144   }
0145   _LIBCPP_HIDE_FROM_ABI _Tp fetch_add(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT {
0146     return std::__cxx_atomic_fetch_add(std::addressof(this->__a_), __op, __m);
0147   }
0148   _LIBCPP_HIDE_FROM_ABI _Tp fetch_sub(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT {
0149     return std::__cxx_atomic_fetch_sub(std::addressof(this->__a_), __op, __m);
0150   }
0151   _LIBCPP_HIDE_FROM_ABI _Tp fetch_sub(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT {
0152     return std::__cxx_atomic_fetch_sub(std::addressof(this->__a_), __op, __m);
0153   }
0154   _LIBCPP_HIDE_FROM_ABI _Tp fetch_and(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT {
0155     return std::__cxx_atomic_fetch_and(std::addressof(this->__a_), __op, __m);
0156   }
0157   _LIBCPP_HIDE_FROM_ABI _Tp fetch_and(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT {
0158     return std::__cxx_atomic_fetch_and(std::addressof(this->__a_), __op, __m);
0159   }
0160   _LIBCPP_HIDE_FROM_ABI _Tp fetch_or(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT {
0161     return std::__cxx_atomic_fetch_or(std::addressof(this->__a_), __op, __m);
0162   }
0163   _LIBCPP_HIDE_FROM_ABI _Tp fetch_or(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT {
0164     return std::__cxx_atomic_fetch_or(std::addressof(this->__a_), __op, __m);
0165   }
0166   _LIBCPP_HIDE_FROM_ABI _Tp fetch_xor(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT {
0167     return std::__cxx_atomic_fetch_xor(std::addressof(this->__a_), __op, __m);
0168   }
0169   _LIBCPP_HIDE_FROM_ABI _Tp fetch_xor(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT {
0170     return std::__cxx_atomic_fetch_xor(std::addressof(this->__a_), __op, __m);
0171   }
0172
0173   _LIBCPP_HIDE_FROM_ABI _Tp operator++(int) volatile _NOEXCEPT { return fetch_add(_Tp(1)); }
0174   _LIBCPP_HIDE_FROM_ABI _Tp operator++(int) _NOEXCEPT { return fetch_add(_Tp(1)); }
0175   _LIBCPP_HIDE_FROM_ABI _Tp operator--(int) volatile _NOEXCEPT { return fetch_sub(_Tp(1)); }
0176   _LIBCPP_HIDE_FROM_ABI _Tp operator--(int) _NOEXCEPT { return fetch_sub(_Tp(1)); }
0177   _LIBCPP_HIDE_FROM_ABI _Tp operator++() volatile _NOEXCEPT { return fetch_add(_Tp(1)) + _Tp(1); }
0178   _LIBCPP_HIDE_FROM_ABI _Tp operator++() _NOEXCEPT { return fetch_add(_Tp(1)) + _Tp(1); }
0179   _LIBCPP_HIDE_FROM_ABI _Tp operator--() volatile _NOEXCEPT { return fetch_sub(_Tp(1)) - _Tp(1); }
0180   _LIBCPP_HIDE_FROM_ABI _Tp operator--() _NOEXCEPT { return fetch_sub(_Tp(1)) - _Tp(1); }
0181   _LIBCPP_HIDE_FROM_ABI _Tp operator+=(_Tp __op) volatile _NOEXCEPT { return fetch_add(__op) + __op; }
0182   _LIBCPP_HIDE_FROM_ABI _Tp operator+=(_Tp __op) _NOEXCEPT { return fetch_add(__op) + __op; }
0183   _LIBCPP_HIDE_FROM_ABI _Tp operator-=(_Tp __op) volatile _NOEXCEPT { return fetch_sub(__op) - __op; }
0184   _LIBCPP_HIDE_FROM_ABI _Tp operator-=(_Tp __op) _NOEXCEPT { return fetch_sub(__op) - __op; }
0185   _LIBCPP_HIDE_FROM_ABI _Tp operator&=(_Tp __op) volatile _NOEXCEPT { return fetch_and(__op) & __op; }
0186   _LIBCPP_HIDE_FROM_ABI _Tp operator&=(_Tp __op) _NOEXCEPT { return fetch_and(__op) & __op; }
0187   _LIBCPP_HIDE_FROM_ABI _Tp operator|=(_Tp __op) volatile _NOEXCEPT { return fetch_or(__op) | __op; }
0188   _LIBCPP_HIDE_FROM_ABI _Tp operator|=(_Tp __op) _NOEXCEPT { return fetch_or(__op) | __op; }
0189   _LIBCPP_HIDE_FROM_ABI _Tp operator^=(_Tp __op) volatile _NOEXCEPT { return fetch_xor(__op) ^ __op; }
0190   _LIBCPP_HIDE_FROM_ABI _Tp operator^=(_Tp __op) _NOEXCEPT { return fetch_xor(__op) ^ __op; }
0191 };
0192
0193 // Here we need _IsIntegral because the default template argument is not enough
0194 // e.g  __atomic_base<int> is __atomic_base<int, true>, which inherits from
0195 // __atomic_base<int, false> and the caller of the wait function is
0196 // __atomic_base<int, false>. So specializing __atomic_base<_Tp> does not work
0197 template <class _Tp, bool _IsIntegral>
0198 struct __atomic_waitable_traits<__atomic_base<_Tp, _IsIntegral> > {
0199   static _LIBCPP_HIDE_FROM_ABI _Tp __atomic_load(const __atomic_base<_Tp, _IsIntegral>& __a, memory_order __order) {
0200     return __a.load(__order);
0201   }
0202
0203   static _LIBCPP_HIDE_FROM_ABI _Tp
0204   __atomic_load(const volatile __atomic_base<_Tp, _IsIntegral>& __this, memory_order __order) {
0205     return __this.load(__order);
0206   }
0207
0208   static _LIBCPP_HIDE_FROM_ABI const __cxx_atomic_impl<_Tp>*
0209   __atomic_contention_address(const __atomic_base<_Tp, _IsIntegral>& __a) {
0210     return std::addressof(__a.__a_);
0211   }
0212
0213   static _LIBCPP_HIDE_FROM_ABI const volatile __cxx_atomic_impl<_Tp>*
0214   __atomic_contention_address(const volatile __atomic_base<_Tp, _IsIntegral>& __this) {
0215     return std::addressof(__this.__a_);
0216   }
0217 };
0218
0219 _LIBCPP_END_NAMESPACE_STD
0220
0221 #endif // _LIBCPP___CXX03___ATOMIC_ATOMIC_BASE_H