1 //===----------------------------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #ifndef _LIBCPP___ATOMIC_ATOMIC_BASE_H
10 #define _LIBCPP___ATOMIC_ATOMIC_BASE_H
11 
12 #include <__atomic/atomic_sync.h>
13 #include <__atomic/check_memory_order.h>
14 #include <__atomic/cxx_atomic_impl.h>
15 #include <__atomic/is_always_lock_free.h>
16 #include <__atomic/memory_order.h>
17 #include <__availability>
18 #include <__config>
19 #include <__memory/addressof.h>
20 #include <__type_traits/is_integral.h>
21 #include <__type_traits/is_nothrow_default_constructible.h>
22 #include <__type_traits/is_same.h>
23 #include <version>
24 
25 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
26 #  pragma GCC system_header
27 #endif
28 
29 _LIBCPP_BEGIN_NAMESPACE_STD
30 
31 template <class _Tp, bool = is_integral<_Tp>::value && !is_same<_Tp, bool>::value>
32 struct __atomic_base  // false
33 {
34     mutable __cxx_atomic_impl<_Tp> __a_;
35 
36 #if _LIBCPP_STD_VER >= 17
37   static _LIBCPP_CONSTEXPR bool is_always_lock_free = __libcpp_is_always_lock_free<__cxx_atomic_impl<_Tp> >::__value;
38 #endif
39 
40     _LIBCPP_HIDE_FROM_ABI
41     bool is_lock_free() const volatile _NOEXCEPT
42         {return __cxx_atomic_is_lock_free(sizeof(_Tp));}
43     _LIBCPP_HIDE_FROM_ABI
44     bool is_lock_free() const _NOEXCEPT
45         {return static_cast<__atomic_base const volatile*>(this)->is_lock_free();}
46     _LIBCPP_HIDE_FROM_ABI void store(_Tp __d, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT
47         _LIBCPP_CHECK_STORE_MEMORY_ORDER(__m) {
48       std::__cxx_atomic_store(std::addressof(__a_), __d, __m);
49     }
50     _LIBCPP_HIDE_FROM_ABI void store(_Tp __d, memory_order __m = memory_order_seq_cst) _NOEXCEPT
51         _LIBCPP_CHECK_STORE_MEMORY_ORDER(__m) {
52       std::__cxx_atomic_store(std::addressof(__a_), __d, __m);
53     }
54     _LIBCPP_HIDE_FROM_ABI _Tp load(memory_order __m = memory_order_seq_cst) const volatile _NOEXCEPT
55         _LIBCPP_CHECK_LOAD_MEMORY_ORDER(__m) {
56       return std::__cxx_atomic_load(std::addressof(__a_), __m);
57     }
58     _LIBCPP_HIDE_FROM_ABI _Tp load(memory_order __m = memory_order_seq_cst) const _NOEXCEPT
59         _LIBCPP_CHECK_LOAD_MEMORY_ORDER(__m) {
60       return std::__cxx_atomic_load(std::addressof(__a_), __m);
61     }
62     _LIBCPP_HIDE_FROM_ABI
63     operator _Tp() const volatile _NOEXCEPT {return load();}
64     _LIBCPP_HIDE_FROM_ABI
65     operator _Tp() const _NOEXCEPT          {return load();}
66     _LIBCPP_HIDE_FROM_ABI _Tp exchange(_Tp __d, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT {
67       return std::__cxx_atomic_exchange(std::addressof(__a_), __d, __m);
68     }
69     _LIBCPP_HIDE_FROM_ABI _Tp exchange(_Tp __d, memory_order __m = memory_order_seq_cst) _NOEXCEPT {
70       return std::__cxx_atomic_exchange(std::addressof(__a_), __d, __m);
71     }
72     _LIBCPP_HIDE_FROM_ABI bool
73     compare_exchange_weak(_Tp& __e, _Tp __d, memory_order __s, memory_order __f) volatile _NOEXCEPT
74         _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f) {
75       return std::__cxx_atomic_compare_exchange_weak(std::addressof(__a_), std::addressof(__e), __d, __s, __f);
76     }
77     _LIBCPP_HIDE_FROM_ABI bool compare_exchange_weak(_Tp& __e, _Tp __d, memory_order __s, memory_order __f) _NOEXCEPT
78         _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f) {
79       return std::__cxx_atomic_compare_exchange_weak(std::addressof(__a_), std::addressof(__e), __d, __s, __f);
80     }
81     _LIBCPP_HIDE_FROM_ABI bool
82     compare_exchange_strong(_Tp& __e, _Tp __d, memory_order __s, memory_order __f) volatile _NOEXCEPT
83         _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f) {
84       return std::__cxx_atomic_compare_exchange_strong(std::addressof(__a_), std::addressof(__e), __d, __s, __f);
85     }
86     _LIBCPP_HIDE_FROM_ABI bool compare_exchange_strong(_Tp& __e, _Tp __d, memory_order __s, memory_order __f) _NOEXCEPT
87         _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f) {
88       return std::__cxx_atomic_compare_exchange_strong(std::addressof(__a_), std::addressof(__e), __d, __s, __f);
89     }
90     _LIBCPP_HIDE_FROM_ABI bool
91     compare_exchange_weak(_Tp& __e, _Tp __d, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT {
92       return std::__cxx_atomic_compare_exchange_weak(std::addressof(__a_), std::addressof(__e), __d, __m, __m);
93     }
94     _LIBCPP_HIDE_FROM_ABI bool
95     compare_exchange_weak(_Tp& __e, _Tp __d, memory_order __m = memory_order_seq_cst) _NOEXCEPT {
96       return std::__cxx_atomic_compare_exchange_weak(std::addressof(__a_), std::addressof(__e), __d, __m, __m);
97     }
98     _LIBCPP_HIDE_FROM_ABI bool
99     compare_exchange_strong(_Tp& __e, _Tp __d, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT {
100       return std::__cxx_atomic_compare_exchange_strong(std::addressof(__a_), std::addressof(__e), __d, __m, __m);
101     }
102     _LIBCPP_HIDE_FROM_ABI bool
103     compare_exchange_strong(_Tp& __e, _Tp __d, memory_order __m = memory_order_seq_cst) _NOEXCEPT {
104       return std::__cxx_atomic_compare_exchange_strong(std::addressof(__a_), std::addressof(__e), __d, __m, __m);
105     }
106 
107     _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void wait(_Tp __v, memory_order __m = memory_order_seq_cst) const
108         volatile _NOEXCEPT {
109       std::__cxx_atomic_wait(std::addressof(__a_), __v, __m);
110     }
111     _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void
112     wait(_Tp __v, memory_order __m = memory_order_seq_cst) const _NOEXCEPT {
113       std::__cxx_atomic_wait(std::addressof(__a_), __v, __m);
114     }
115     _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void notify_one() volatile _NOEXCEPT {
116       std::__cxx_atomic_notify_one(std::addressof(__a_));
117     }
118     _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void notify_one() _NOEXCEPT {
119       std::__cxx_atomic_notify_one(std::addressof(__a_));
120     }
121     _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void notify_all() volatile _NOEXCEPT {
122       std::__cxx_atomic_notify_all(std::addressof(__a_));
123     }
124     _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void notify_all() _NOEXCEPT {
125       std::__cxx_atomic_notify_all(std::addressof(__a_));
126     }
127 
128 #if _LIBCPP_STD_VER >= 20
129     _LIBCPP_HIDE_FROM_ABI constexpr
130     __atomic_base() noexcept(is_nothrow_default_constructible_v<_Tp>) : __a_(_Tp()) {}
131 #else
132     _LIBCPP_HIDE_FROM_ABI
133     __atomic_base() _NOEXCEPT = default;
134 #endif
135 
136     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
137     __atomic_base(_Tp __d) _NOEXCEPT : __a_(__d) {}
138 
139     __atomic_base(const __atomic_base&) = delete;
140 };
141 
142 #if _LIBCPP_STD_VER >= 17
143 template <class _Tp, bool __b>
144 _LIBCPP_CONSTEXPR bool __atomic_base<_Tp, __b>::is_always_lock_free;
145 #endif
146 
147 // atomic<Integral>
148 
149 template <class _Tp>
150 struct __atomic_base<_Tp, true>
151     : public __atomic_base<_Tp, false>
152 {
153     using __base = __atomic_base<_Tp, false>;
154 
155     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
156     __atomic_base() _NOEXCEPT = default;
157 
158     _LIBCPP_HIDE_FROM_ABI
159     _LIBCPP_CONSTEXPR __atomic_base(_Tp __d) _NOEXCEPT : __base(__d) {}
160 
161     _LIBCPP_HIDE_FROM_ABI _Tp fetch_add(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT {
162       return std::__cxx_atomic_fetch_add(std::addressof(this->__a_), __op, __m);
163     }
164     _LIBCPP_HIDE_FROM_ABI _Tp fetch_add(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT {
165       return std::__cxx_atomic_fetch_add(std::addressof(this->__a_), __op, __m);
166     }
167     _LIBCPP_HIDE_FROM_ABI _Tp fetch_sub(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT {
168       return std::__cxx_atomic_fetch_sub(std::addressof(this->__a_), __op, __m);
169     }
170     _LIBCPP_HIDE_FROM_ABI _Tp fetch_sub(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT {
171       return std::__cxx_atomic_fetch_sub(std::addressof(this->__a_), __op, __m);
172     }
173     _LIBCPP_HIDE_FROM_ABI _Tp fetch_and(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT {
174       return std::__cxx_atomic_fetch_and(std::addressof(this->__a_), __op, __m);
175     }
176     _LIBCPP_HIDE_FROM_ABI _Tp fetch_and(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT {
177       return std::__cxx_atomic_fetch_and(std::addressof(this->__a_), __op, __m);
178     }
179     _LIBCPP_HIDE_FROM_ABI _Tp fetch_or(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT {
180       return std::__cxx_atomic_fetch_or(std::addressof(this->__a_), __op, __m);
181     }
182     _LIBCPP_HIDE_FROM_ABI _Tp fetch_or(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT {
183       return std::__cxx_atomic_fetch_or(std::addressof(this->__a_), __op, __m);
184     }
185     _LIBCPP_HIDE_FROM_ABI _Tp fetch_xor(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT {
186       return std::__cxx_atomic_fetch_xor(std::addressof(this->__a_), __op, __m);
187     }
188     _LIBCPP_HIDE_FROM_ABI _Tp fetch_xor(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT {
189       return std::__cxx_atomic_fetch_xor(std::addressof(this->__a_), __op, __m);
190     }
191 
192     _LIBCPP_HIDE_FROM_ABI
193     _Tp operator++(int) volatile _NOEXCEPT      {return fetch_add(_Tp(1));}
194     _LIBCPP_HIDE_FROM_ABI
195     _Tp operator++(int) _NOEXCEPT               {return fetch_add(_Tp(1));}
196     _LIBCPP_HIDE_FROM_ABI
197     _Tp operator--(int) volatile _NOEXCEPT      {return fetch_sub(_Tp(1));}
198     _LIBCPP_HIDE_FROM_ABI
199     _Tp operator--(int) _NOEXCEPT               {return fetch_sub(_Tp(1));}
200     _LIBCPP_HIDE_FROM_ABI
201     _Tp operator++() volatile _NOEXCEPT         {return fetch_add(_Tp(1)) + _Tp(1);}
202     _LIBCPP_HIDE_FROM_ABI
203     _Tp operator++() _NOEXCEPT                  {return fetch_add(_Tp(1)) + _Tp(1);}
204     _LIBCPP_HIDE_FROM_ABI
205     _Tp operator--() volatile _NOEXCEPT         {return fetch_sub(_Tp(1)) - _Tp(1);}
206     _LIBCPP_HIDE_FROM_ABI
207     _Tp operator--() _NOEXCEPT                  {return fetch_sub(_Tp(1)) - _Tp(1);}
208     _LIBCPP_HIDE_FROM_ABI
209     _Tp operator+=(_Tp __op) volatile _NOEXCEPT {return fetch_add(__op) + __op;}
210     _LIBCPP_HIDE_FROM_ABI
211     _Tp operator+=(_Tp __op) _NOEXCEPT          {return fetch_add(__op) + __op;}
212     _LIBCPP_HIDE_FROM_ABI
213     _Tp operator-=(_Tp __op) volatile _NOEXCEPT {return fetch_sub(__op) - __op;}
214     _LIBCPP_HIDE_FROM_ABI
215     _Tp operator-=(_Tp __op) _NOEXCEPT          {return fetch_sub(__op) - __op;}
216     _LIBCPP_HIDE_FROM_ABI
217     _Tp operator&=(_Tp __op) volatile _NOEXCEPT {return fetch_and(__op) & __op;}
218     _LIBCPP_HIDE_FROM_ABI
219     _Tp operator&=(_Tp __op) _NOEXCEPT          {return fetch_and(__op) & __op;}
220     _LIBCPP_HIDE_FROM_ABI
221     _Tp operator|=(_Tp __op) volatile _NOEXCEPT {return fetch_or(__op) | __op;}
222     _LIBCPP_HIDE_FROM_ABI
223     _Tp operator|=(_Tp __op) _NOEXCEPT          {return fetch_or(__op) | __op;}
224     _LIBCPP_HIDE_FROM_ABI
225     _Tp operator^=(_Tp __op) volatile _NOEXCEPT {return fetch_xor(__op) ^ __op;}
226     _LIBCPP_HIDE_FROM_ABI
227     _Tp operator^=(_Tp __op) _NOEXCEPT          {return fetch_xor(__op) ^ __op;}
228 };
229 
230 _LIBCPP_END_NAMESPACE_STD
231 
232 #endif // _LIBCPP___ATOMIC_ATOMIC_BASE_H
233