32 #ifndef _GLIBCXX_ATOMIC
33 #define _GLIBCXX_ATOMIC 1
35 #pragma GCC system_header
37 #if __cplusplus < 201103L
43 namespace std _GLIBCXX_VISIBILITY(default)
45 _GLIBCXX_BEGIN_NAMESPACE_VERSION
52 #if __cplusplus >= 201703L
53 # define __cpp_lib_atomic_is_always_lock_free 201603
56 template<
typename _Tp>
64 using value_type = bool;
70 atomic() noexcept =
default;
71 ~
atomic() noexcept =
default;
76 constexpr
atomic(
bool __i) noexcept : _M_base(__i) { }
79 operator=(
bool __i) noexcept
80 {
return _M_base.operator=(__i); }
83 operator=(
bool __i)
volatile noexcept
84 {
return _M_base.operator=(__i); }
86 operator bool()
const noexcept
87 {
return _M_base.load(); }
89 operator bool()
const volatile noexcept
90 {
return _M_base.load(); }
93 is_lock_free()
const noexcept {
return _M_base.is_lock_free(); }
96 is_lock_free()
const volatile noexcept {
return _M_base.is_lock_free(); }
98 #if __cplusplus >= 201703L
103 store(
bool __i,
memory_order __m = memory_order_seq_cst) noexcept
104 { _M_base.store(__i, __m); }
107 store(
bool __i,
memory_order __m = memory_order_seq_cst)
volatile noexcept
108 { _M_base.store(__i, __m); }
111 load(
memory_order __m = memory_order_seq_cst)
const noexcept
112 {
return _M_base.load(__m); }
115 load(
memory_order __m = memory_order_seq_cst)
const volatile noexcept
116 {
return _M_base.load(__m); }
119 exchange(
bool __i,
memory_order __m = memory_order_seq_cst) noexcept
120 {
return _M_base.exchange(__i, __m); }
124 memory_order __m = memory_order_seq_cst)
volatile noexcept
125 {
return _M_base.exchange(__i, __m); }
128 compare_exchange_weak(
bool& __i1,
bool __i2,
memory_order __m1,
130 {
return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); }
133 compare_exchange_weak(
bool& __i1,
bool __i2,
memory_order __m1,
135 {
return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); }
138 compare_exchange_weak(
bool& __i1,
bool __i2,
140 {
return _M_base.compare_exchange_weak(__i1, __i2, __m); }
143 compare_exchange_weak(
bool& __i1,
bool __i2,
144 memory_order __m = memory_order_seq_cst)
volatile noexcept
145 {
return _M_base.compare_exchange_weak(__i1, __i2, __m); }
148 compare_exchange_strong(
bool& __i1,
bool __i2,
memory_order __m1,
150 {
return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); }
153 compare_exchange_strong(
bool& __i1,
bool __i2,
memory_order __m1,
155 {
return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); }
158 compare_exchange_strong(
bool& __i1,
bool __i2,
160 {
return _M_base.compare_exchange_strong(__i1, __i2, __m); }
163 compare_exchange_strong(
bool& __i1,
bool __i2,
164 memory_order __m = memory_order_seq_cst)
volatile noexcept
165 {
return _M_base.compare_exchange_strong(__i1, __i2, __m); }
167 #if __cpp_lib_atomic_wait
169 wait(
bool __old,
memory_order __m = memory_order_seq_cst)
const noexcept
170 { _M_base.wait(__old, __m); }
175 notify_one()
const noexcept
176 { _M_base.notify_one(); }
179 notify_all()
const noexcept
180 { _M_base.notify_all(); }
181 #endif // __cpp_lib_atomic_wait
184 #if __cplusplus <= 201703L
185 # define _GLIBCXX20_INIT(I)
187 # define _GLIBCXX20_INIT(I) = I
195 template<
typename _Tp>
198 using value_type = _Tp;
202 static constexpr
int _S_min_alignment
203 = (
sizeof(_Tp) & (
sizeof(_Tp) - 1)) ||
sizeof(_Tp) > 16
206 static constexpr
int _S_alignment
207 = _S_min_alignment >
alignof(_Tp) ? _S_min_alignment :
alignof(_Tp);
209 alignas(_S_alignment) _Tp _M_i _GLIBCXX20_INIT(_Tp());
211 static_assert(__is_trivially_copyable(_Tp),
212 "std::atomic requires a trivially copyable type");
214 static_assert(
sizeof(_Tp) > 0,
215 "Incomplete or zero-sized types are not supported");
217 #if __cplusplus > 201703L
218 static_assert(is_copy_constructible_v<_Tp>);
219 static_assert(is_move_constructible_v<_Tp>);
220 static_assert(is_copy_assignable_v<_Tp>);
221 static_assert(is_move_assignable_v<_Tp>);
226 ~
atomic() noexcept = default;
231 constexpr
atomic(_Tp __i) noexcept : _M_i(__i) { }
233 operator _Tp() const noexcept
236 operator _Tp() const volatile noexcept
240 operator=(_Tp __i) noexcept
241 { store(__i);
return __i; }
244 operator=(_Tp __i)
volatile noexcept
245 { store(__i);
return __i; }
248 is_lock_free() const noexcept
251 return __atomic_is_lock_free(
sizeof(_M_i),
252 reinterpret_cast<void *>(-_S_alignment));
256 is_lock_free() const volatile noexcept
259 return __atomic_is_lock_free(
sizeof(_M_i),
260 reinterpret_cast<void *>(-_S_alignment));
263 #if __cplusplus >= 201703L
264 static constexpr
bool is_always_lock_free
265 = __atomic_always_lock_free(
sizeof(_M_i), 0);
269 store(_Tp __i,
memory_order __m = memory_order_seq_cst) noexcept
275 store(_Tp __i,
memory_order __m = memory_order_seq_cst) volatile noexcept
281 load(
memory_order __m = memory_order_seq_cst) const noexcept
283 alignas(_Tp)
unsigned char __buf[
sizeof(_Tp)];
284 _Tp* __ptr =
reinterpret_cast<_Tp*
>(__buf);
290 load(
memory_order __m = memory_order_seq_cst) const volatile noexcept
292 alignas(_Tp)
unsigned char __buf[
sizeof(_Tp)];
293 _Tp* __ptr =
reinterpret_cast<_Tp*
>(__buf);
299 exchange(_Tp __i,
memory_order __m = memory_order_seq_cst) noexcept
301 alignas(_Tp)
unsigned char __buf[
sizeof(_Tp)];
302 _Tp* __ptr =
reinterpret_cast<_Tp*
>(__buf);
310 memory_order __m = memory_order_seq_cst) volatile noexcept
312 alignas(_Tp)
unsigned char __buf[
sizeof(_Tp)];
313 _Tp* __ptr =
reinterpret_cast<_Tp*
>(__buf);
320 compare_exchange_weak(_Tp& __e, _Tp __i,
memory_order __s,
326 true,
int(__s),
int(__f));
330 compare_exchange_weak(_Tp& __e, _Tp __i,
memory_order __s,
336 true,
int(__s),
int(__f));
340 compare_exchange_weak(_Tp& __e, _Tp __i,
342 {
return compare_exchange_weak(__e, __i, __m,
343 __cmpexch_failure_order(__m)); }
346 compare_exchange_weak(_Tp& __e, _Tp __i,
347 memory_order __m = memory_order_seq_cst) volatile noexcept
348 {
return compare_exchange_weak(__e, __i, __m,
349 __cmpexch_failure_order(__m)); }
352 compare_exchange_strong(_Tp& __e, _Tp __i,
memory_order __s,
358 false,
int(__s),
int(__f));
362 compare_exchange_strong(_Tp& __e, _Tp __i,
memory_order __s,
368 false,
int(__s),
int(__f));
372 compare_exchange_strong(_Tp& __e, _Tp __i,
374 {
return compare_exchange_strong(__e, __i, __m,
375 __cmpexch_failure_order(__m)); }
378 compare_exchange_strong(_Tp& __e, _Tp __i,
379 memory_order __m = memory_order_seq_cst) volatile noexcept
380 {
return compare_exchange_strong(__e, __i, __m,
381 __cmpexch_failure_order(__m)); }
383 #if __cpp_lib_atomic_wait
385 wait(_Tp __old,
memory_order __m = memory_order_seq_cst) const noexcept
387 std::__atomic_wait_address_v(&_M_i, __old,
388 [__m,
this] {
return this->load(__m); });
394 notify_one() const noexcept
395 { std::__atomic_notify_address(&_M_i,
false); }
398 notify_all() const noexcept
399 { std::__atomic_notify_address(&_M_i,
true); }
400 #endif // __cpp_lib_atomic_wait
403 #undef _GLIBCXX20_INIT
406 template<
typename _Tp>
409 using value_type = _Tp*;
410 using difference_type = ptrdiff_t;
412 typedef _Tp* __pointer_type;
416 atomic() noexcept =
default;
417 ~
atomic() noexcept =
default;
422 constexpr
atomic(__pointer_type __p) noexcept : _M_b(__p) { }
424 operator __pointer_type()
const noexcept
425 {
return __pointer_type(_M_b); }
427 operator __pointer_type()
const volatile noexcept
428 {
return __pointer_type(_M_b); }
432 {
return _M_b.operator=(__p); }
435 operator=(__pointer_type __p)
volatile noexcept
436 {
return _M_b.operator=(__p); }
439 operator++(
int) noexcept
441 #if __cplusplus >= 201703L
448 operator++(
int)
volatile noexcept
450 #if __cplusplus >= 201703L
457 operator--(
int) noexcept
459 #if __cplusplus >= 201703L
466 operator--(
int)
volatile noexcept
468 #if __cplusplus >= 201703L
475 operator++() noexcept
477 #if __cplusplus >= 201703L
484 operator++()
volatile noexcept
486 #if __cplusplus >= 201703L
493 operator--() noexcept
495 #if __cplusplus >= 201703L
502 operator--()
volatile noexcept
504 #if __cplusplus >= 201703L
511 operator+=(ptrdiff_t __d) noexcept
513 #if __cplusplus >= 201703L
516 return _M_b.operator+=(__d);
520 operator+=(ptrdiff_t __d)
volatile noexcept
522 #if __cplusplus >= 201703L
525 return _M_b.operator+=(__d);
529 operator-=(ptrdiff_t __d) noexcept
531 #if __cplusplus >= 201703L
534 return _M_b.operator-=(__d);
538 operator-=(ptrdiff_t __d)
volatile noexcept
540 #if __cplusplus >= 201703L
543 return _M_b.operator-=(__d);
547 is_lock_free()
const noexcept
548 {
return _M_b.is_lock_free(); }
551 is_lock_free()
const volatile noexcept
552 {
return _M_b.is_lock_free(); }
554 #if __cplusplus >= 201703L
555 static constexpr
bool is_always_lock_free = ATOMIC_POINTER_LOCK_FREE == 2;
559 store(__pointer_type __p,
561 {
return _M_b.store(__p, __m); }
564 store(__pointer_type __p,
565 memory_order __m = memory_order_seq_cst)
volatile noexcept
566 {
return _M_b.store(__p, __m); }
569 load(
memory_order __m = memory_order_seq_cst)
const noexcept
570 {
return _M_b.load(__m); }
573 load(
memory_order __m = memory_order_seq_cst)
const volatile noexcept
574 {
return _M_b.load(__m); }
579 {
return _M_b.exchange(__p, __m); }
583 memory_order __m = memory_order_seq_cst)
volatile noexcept
584 {
return _M_b.exchange(__p, __m); }
587 compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
589 {
return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
592 compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
595 {
return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
598 compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
601 return compare_exchange_weak(__p1, __p2, __m,
602 __cmpexch_failure_order(__m));
606 compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
607 memory_order __m = memory_order_seq_cst)
volatile noexcept
609 return compare_exchange_weak(__p1, __p2, __m,
610 __cmpexch_failure_order(__m));
614 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
616 {
return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
619 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
622 {
return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
625 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
628 return _M_b.compare_exchange_strong(__p1, __p2, __m,
629 __cmpexch_failure_order(__m));
633 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
634 memory_order __m = memory_order_seq_cst)
volatile noexcept
636 return _M_b.compare_exchange_strong(__p1, __p2, __m,
637 __cmpexch_failure_order(__m));
640 #if __cpp_lib_atomic_wait
642 wait(__pointer_type __old,
memory_order __m = memory_order_seq_cst) noexcept
643 { _M_b.wait(__old, __m); }
648 notify_one()
const noexcept
649 { _M_b.notify_one(); }
652 notify_all()
const noexcept
653 { _M_b.notify_all(); }
654 #endif // __cpp_lib_atomic_wait
656 fetch_add(ptrdiff_t __d,
659 #if __cplusplus >= 201703L
662 return _M_b.fetch_add(__d, __m);
666 fetch_add(ptrdiff_t __d,
667 memory_order __m = memory_order_seq_cst)
volatile noexcept
669 #if __cplusplus >= 201703L
672 return _M_b.fetch_add(__d, __m);
676 fetch_sub(ptrdiff_t __d,
679 #if __cplusplus >= 201703L
682 return _M_b.fetch_sub(__d, __m);
686 fetch_sub(ptrdiff_t __d,
687 memory_order __m = memory_order_seq_cst)
volatile noexcept
689 #if __cplusplus >= 201703L
692 return _M_b.fetch_sub(__d, __m);
701 typedef char __integral_type;
704 atomic() noexcept =
default;
705 ~
atomic() noexcept =
default;
712 using __base_type::operator __integral_type;
713 using __base_type::operator=;
715 #if __cplusplus >= 201703L
716 static constexpr
bool is_always_lock_free = ATOMIC_CHAR_LOCK_FREE == 2;
724 typedef signed char __integral_type;
727 atomic() noexcept=
default;
728 ~
atomic() noexcept =
default;
735 using __base_type::operator __integral_type;
736 using __base_type::operator=;
738 #if __cplusplus >= 201703L
739 static constexpr
bool is_always_lock_free = ATOMIC_CHAR_LOCK_FREE == 2;
747 typedef unsigned char __integral_type;
750 atomic() noexcept=
default;
751 ~
atomic() noexcept =
default;
758 using __base_type::operator __integral_type;
759 using __base_type::operator=;
761 #if __cplusplus >= 201703L
762 static constexpr
bool is_always_lock_free = ATOMIC_CHAR_LOCK_FREE == 2;
770 typedef short __integral_type;
773 atomic() noexcept =
default;
774 ~
atomic() noexcept =
default;
781 using __base_type::operator __integral_type;
782 using __base_type::operator=;
784 #if __cplusplus >= 201703L
785 static constexpr
bool is_always_lock_free = ATOMIC_SHORT_LOCK_FREE == 2;
793 typedef unsigned short __integral_type;
796 atomic() noexcept =
default;
797 ~
atomic() noexcept =
default;
804 using __base_type::operator __integral_type;
805 using __base_type::operator=;
807 #if __cplusplus >= 201703L
808 static constexpr
bool is_always_lock_free = ATOMIC_SHORT_LOCK_FREE == 2;
816 typedef int __integral_type;
819 atomic() noexcept =
default;
820 ~
atomic() noexcept =
default;
827 using __base_type::operator __integral_type;
828 using __base_type::operator=;
830 #if __cplusplus >= 201703L
831 static constexpr
bool is_always_lock_free = ATOMIC_INT_LOCK_FREE == 2;
839 typedef unsigned int __integral_type;
842 atomic() noexcept =
default;
843 ~
atomic() noexcept =
default;
850 using __base_type::operator __integral_type;
851 using __base_type::operator=;
853 #if __cplusplus >= 201703L
854 static constexpr
bool is_always_lock_free = ATOMIC_INT_LOCK_FREE == 2;
862 typedef long __integral_type;
865 atomic() noexcept =
default;
866 ~
atomic() noexcept =
default;
873 using __base_type::operator __integral_type;
874 using __base_type::operator=;
876 #if __cplusplus >= 201703L
877 static constexpr
bool is_always_lock_free = ATOMIC_LONG_LOCK_FREE == 2;
885 typedef unsigned long __integral_type;
888 atomic() noexcept =
default;
889 ~
atomic() noexcept =
default;
896 using __base_type::operator __integral_type;
897 using __base_type::operator=;
899 #if __cplusplus >= 201703L
900 static constexpr
bool is_always_lock_free = ATOMIC_LONG_LOCK_FREE == 2;
908 typedef long long __integral_type;
911 atomic() noexcept =
default;
912 ~
atomic() noexcept =
default;
919 using __base_type::operator __integral_type;
920 using __base_type::operator=;
922 #if __cplusplus >= 201703L
923 static constexpr
bool is_always_lock_free = ATOMIC_LLONG_LOCK_FREE == 2;
931 typedef unsigned long long __integral_type;
934 atomic() noexcept =
default;
935 ~
atomic() noexcept =
default;
942 using __base_type::operator __integral_type;
943 using __base_type::operator=;
945 #if __cplusplus >= 201703L
946 static constexpr
bool is_always_lock_free = ATOMIC_LLONG_LOCK_FREE == 2;
954 typedef wchar_t __integral_type;
957 atomic() noexcept =
default;
958 ~
atomic() noexcept =
default;
965 using __base_type::operator __integral_type;
966 using __base_type::operator=;
968 #if __cplusplus >= 201703L
969 static constexpr
bool is_always_lock_free = ATOMIC_WCHAR_T_LOCK_FREE == 2;
973 #ifdef _GLIBCXX_USE_CHAR8_T
978 typedef char8_t __integral_type;
981 atomic() noexcept = default;
982 ~
atomic() noexcept = default;
987 constexpr
atomic(__integral_type __i) noexcept : __base_type(__i) { }
989 using __base_type::operator __integral_type;
990 using __base_type::operator=;
992 #if __cplusplus > 201402L
993 static constexpr
bool is_always_lock_free = ATOMIC_CHAR8_T_LOCK_FREE == 2;
1002 typedef char16_t __integral_type;
1005 atomic() noexcept =
default;
1006 ~
atomic() noexcept =
default;
1013 using __base_type::operator __integral_type;
1014 using __base_type::operator=;
1016 #if __cplusplus >= 201703L
1017 static constexpr
bool is_always_lock_free = ATOMIC_CHAR16_T_LOCK_FREE == 2;
1025 typedef char32_t __integral_type;
1028 atomic() noexcept =
default;
1029 ~
atomic() noexcept =
default;
1036 using __base_type::operator __integral_type;
1037 using __base_type::operator=;
1039 #if __cplusplus >= 201703L
1040 static constexpr
bool is_always_lock_free = ATOMIC_CHAR32_T_LOCK_FREE == 2;
1084 #ifdef _GLIBCXX_USE_CHAR8_T
1095 #ifdef _GLIBCXX_USE_C99_STDINT_TR1
1187 #ifdef _GLIBCXX_USE_C99_STDINT_TR1
1197 atomic_flag_test_and_set_explicit(
atomic_flag* __a,
1199 {
return __a->test_and_set(__m); }
1202 atomic_flag_test_and_set_explicit(
volatile atomic_flag* __a,
1204 {
return __a->test_and_set(__m); }
1207 atomic_flag_clear_explicit(atomic_flag* __a,
memory_order __m) noexcept
1208 { __a->clear(__m); }
1211 atomic_flag_clear_explicit(
volatile atomic_flag* __a,
1213 { __a->clear(__m); }
1216 atomic_flag_test_and_set(atomic_flag* __a) noexcept
1217 {
return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }
1220 atomic_flag_test_and_set(
volatile atomic_flag* __a) noexcept
1221 {
return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }
1224 atomic_flag_clear(atomic_flag* __a) noexcept
1225 { atomic_flag_clear_explicit(__a, memory_order_seq_cst); }
1228 atomic_flag_clear(
volatile atomic_flag* __a) noexcept
1229 { atomic_flag_clear_explicit(__a, memory_order_seq_cst); }
1232 template<
typename _Tp>
1233 using __atomic_val_t =
typename atomic<_Tp>::value_type;
1234 template<
typename _Tp>
1235 using __atomic_diff_t =
typename atomic<_Tp>::difference_type;
1239 template<
typename _ITp>
1241 atomic_is_lock_free(
const atomic<_ITp>* __a) noexcept
1242 {
return __a->is_lock_free(); }
1244 template<
typename _ITp>
1246 atomic_is_lock_free(
const volatile atomic<_ITp>* __a) noexcept
1247 {
return __a->is_lock_free(); }
1249 template<
typename _ITp>
1251 atomic_init(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept
1252 { __a->store(__i, memory_order_relaxed); }
1254 template<
typename _ITp>
1256 atomic_init(
volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept
1257 { __a->store(__i, memory_order_relaxed); }
1259 template<
typename _ITp>
1261 atomic_store_explicit(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i,
1263 { __a->store(__i, __m); }
1265 template<
typename _ITp>
1267 atomic_store_explicit(
volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i,
1269 { __a->store(__i, __m); }
1271 template<
typename _ITp>
1273 atomic_load_explicit(
const atomic<_ITp>* __a,
memory_order __m) noexcept
1274 {
return __a->load(__m); }
1276 template<
typename _ITp>
1278 atomic_load_explicit(
const volatile atomic<_ITp>* __a,
1280 {
return __a->load(__m); }
1282 template<
typename _ITp>
1284 atomic_exchange_explicit(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i,
1286 {
return __a->exchange(__i, __m); }
1288 template<
typename _ITp>
1290 atomic_exchange_explicit(
volatile atomic<_ITp>* __a,
1291 __atomic_val_t<_ITp> __i,
1293 {
return __a->exchange(__i, __m); }
1295 template<
typename _ITp>
1297 atomic_compare_exchange_weak_explicit(atomic<_ITp>* __a,
1298 __atomic_val_t<_ITp>* __i1,
1299 __atomic_val_t<_ITp> __i2,
1302 {
return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
1304 template<
typename _ITp>
1306 atomic_compare_exchange_weak_explicit(
volatile atomic<_ITp>* __a,
1307 __atomic_val_t<_ITp>* __i1,
1308 __atomic_val_t<_ITp> __i2,
1311 {
return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
1313 template<
typename _ITp>
1315 atomic_compare_exchange_strong_explicit(atomic<_ITp>* __a,
1316 __atomic_val_t<_ITp>* __i1,
1317 __atomic_val_t<_ITp> __i2,
1320 {
return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
1322 template<
typename _ITp>
1324 atomic_compare_exchange_strong_explicit(
volatile atomic<_ITp>* __a,
1325 __atomic_val_t<_ITp>* __i1,
1326 __atomic_val_t<_ITp> __i2,
1329 {
return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
1332 template<
typename _ITp>
1334 atomic_store(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept
1335 { atomic_store_explicit(__a, __i, memory_order_seq_cst); }
1337 template<
typename _ITp>
1339 atomic_store(
volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept
1340 { atomic_store_explicit(__a, __i, memory_order_seq_cst); }
1342 template<
typename _ITp>
1344 atomic_load(
const atomic<_ITp>* __a) noexcept
1345 {
return atomic_load_explicit(__a, memory_order_seq_cst); }
1347 template<
typename _ITp>
1349 atomic_load(
const volatile atomic<_ITp>* __a) noexcept
1350 {
return atomic_load_explicit(__a, memory_order_seq_cst); }
1352 template<
typename _ITp>
1354 atomic_exchange(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept
1355 {
return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
1357 template<
typename _ITp>
1359 atomic_exchange(
volatile atomic<_ITp>* __a,
1360 __atomic_val_t<_ITp> __i) noexcept
1361 {
return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
1363 template<
typename _ITp>
1365 atomic_compare_exchange_weak(atomic<_ITp>* __a,
1366 __atomic_val_t<_ITp>* __i1,
1367 __atomic_val_t<_ITp> __i2) noexcept
1369 return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
1370 memory_order_seq_cst,
1371 memory_order_seq_cst);
1374 template<
typename _ITp>
1376 atomic_compare_exchange_weak(
volatile atomic<_ITp>* __a,
1377 __atomic_val_t<_ITp>* __i1,
1378 __atomic_val_t<_ITp> __i2) noexcept
1380 return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
1381 memory_order_seq_cst,
1382 memory_order_seq_cst);
1385 template<
typename _ITp>
1387 atomic_compare_exchange_strong(atomic<_ITp>* __a,
1388 __atomic_val_t<_ITp>* __i1,
1389 __atomic_val_t<_ITp> __i2) noexcept
1391 return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
1392 memory_order_seq_cst,
1393 memory_order_seq_cst);
1396 template<
typename _ITp>
1398 atomic_compare_exchange_strong(
volatile atomic<_ITp>* __a,
1399 __atomic_val_t<_ITp>* __i1,
1400 __atomic_val_t<_ITp> __i2) noexcept
1402 return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
1403 memory_order_seq_cst,
1404 memory_order_seq_cst);
1408 #if __cpp_lib_atomic_wait
1409 template<
typename _Tp>
1411 atomic_wait(
const atomic<_Tp>* __a,
1412 typename std::atomic<_Tp>::value_type __old) noexcept
1413 { __a->wait(__old); }
1415 template<
typename _Tp>
1417 atomic_wait_explicit(
const atomic<_Tp>* __a,
1418 typename std::atomic<_Tp>::value_type __old,
1420 { __a->wait(__old, __m); }
1422 template<
typename _Tp>
1424 atomic_notify_one(atomic<_Tp>* __a) noexcept
1425 { __a->notify_one(); }
1427 template<
typename _Tp>
1429 atomic_notify_all(atomic<_Tp>* __a) noexcept
1430 { __a->notify_all(); }
1431 #endif // __cpp_lib_atomic_wait
1437 template<
typename _ITp>
1439 atomic_fetch_add_explicit(atomic<_ITp>* __a,
1440 __atomic_diff_t<_ITp> __i,
1442 {
return __a->fetch_add(__i, __m); }
1444 template<
typename _ITp>
1446 atomic_fetch_add_explicit(
volatile atomic<_ITp>* __a,
1447 __atomic_diff_t<_ITp> __i,
1449 {
return __a->fetch_add(__i, __m); }
1451 template<
typename _ITp>
1453 atomic_fetch_sub_explicit(atomic<_ITp>* __a,
1454 __atomic_diff_t<_ITp> __i,
1456 {
return __a->fetch_sub(__i, __m); }
1458 template<
typename _ITp>
1460 atomic_fetch_sub_explicit(
volatile atomic<_ITp>* __a,
1461 __atomic_diff_t<_ITp> __i,
1463 {
return __a->fetch_sub(__i, __m); }
1465 template<
typename _ITp>
1467 atomic_fetch_and_explicit(__atomic_base<_ITp>* __a,
1468 __atomic_val_t<_ITp> __i,
1470 {
return __a->fetch_and(__i, __m); }
1472 template<
typename _ITp>
1474 atomic_fetch_and_explicit(
volatile __atomic_base<_ITp>* __a,
1475 __atomic_val_t<_ITp> __i,
1477 {
return __a->fetch_and(__i, __m); }
1479 template<
typename _ITp>
1481 atomic_fetch_or_explicit(__atomic_base<_ITp>* __a,
1482 __atomic_val_t<_ITp> __i,
1484 {
return __a->fetch_or(__i, __m); }
1486 template<
typename _ITp>
1488 atomic_fetch_or_explicit(
volatile __atomic_base<_ITp>* __a,
1489 __atomic_val_t<_ITp> __i,
1491 {
return __a->fetch_or(__i, __m); }
1493 template<
typename _ITp>
1495 atomic_fetch_xor_explicit(__atomic_base<_ITp>* __a,
1496 __atomic_val_t<_ITp> __i,
1498 {
return __a->fetch_xor(__i, __m); }
1500 template<
typename _ITp>
1502 atomic_fetch_xor_explicit(
volatile __atomic_base<_ITp>* __a,
1503 __atomic_val_t<_ITp> __i,
1505 {
return __a->fetch_xor(__i, __m); }
1507 template<
typename _ITp>
1509 atomic_fetch_add(atomic<_ITp>* __a,
1510 __atomic_diff_t<_ITp> __i) noexcept
1511 {
return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
1513 template<
typename _ITp>
1515 atomic_fetch_add(
volatile atomic<_ITp>* __a,
1516 __atomic_diff_t<_ITp> __i) noexcept
1517 {
return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
1519 template<
typename _ITp>
1521 atomic_fetch_sub(atomic<_ITp>* __a,
1522 __atomic_diff_t<_ITp> __i) noexcept
1523 {
return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
1525 template<
typename _ITp>
1527 atomic_fetch_sub(
volatile atomic<_ITp>* __a,
1528 __atomic_diff_t<_ITp> __i) noexcept
1529 {
return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
1531 template<
typename _ITp>
1533 atomic_fetch_and(__atomic_base<_ITp>* __a,
1534 __atomic_val_t<_ITp> __i) noexcept
1535 {
return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }
1537 template<
typename _ITp>
1539 atomic_fetch_and(
volatile __atomic_base<_ITp>* __a,
1540 __atomic_val_t<_ITp> __i) noexcept
1541 {
return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }
1543 template<
typename _ITp>
1545 atomic_fetch_or(__atomic_base<_ITp>* __a,
1546 __atomic_val_t<_ITp> __i) noexcept
1547 {
return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }
1549 template<
typename _ITp>
1551 atomic_fetch_or(
volatile __atomic_base<_ITp>* __a,
1552 __atomic_val_t<_ITp> __i) noexcept
1553 {
return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }
1555 template<
typename _ITp>
1557 atomic_fetch_xor(__atomic_base<_ITp>* __a,
1558 __atomic_val_t<_ITp> __i) noexcept
1559 {
return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
1561 template<
typename _ITp>
1563 atomic_fetch_xor(
volatile __atomic_base<_ITp>* __a,
1564 __atomic_val_t<_ITp> __i) noexcept
1565 {
return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
1567 #if __cplusplus > 201703L
1568 #define __cpp_lib_atomic_float 201711L
1570 struct atomic<float> : __atomic_float<float>
1572 atomic() noexcept = default;
1575 atomic(
float __fp) noexcept : __atomic_float<
float>(__fp)
1578 atomic& operator=(
const atomic&)
volatile =
delete;
1579 atomic& operator=(
const atomic&) =
delete;
1581 using __atomic_float<float>::operator=;
1585 struct atomic<double> : __atomic_float<double>
1587 atomic() noexcept = default;
1590 atomic(
double __fp) noexcept : __atomic_float<
double>(__fp)
1593 atomic& operator=(
const atomic&)
volatile =
delete;
1594 atomic& operator=(
const atomic&) =
delete;
1596 using __atomic_float<double>::operator=;
1600 struct atomic<long double> : __atomic_float<long double>
1602 atomic() noexcept = default;
1605 atomic(
long double __fp) noexcept : __atomic_float<
long double>(__fp)
1608 atomic& operator=(
const atomic&)
volatile =
delete;
1609 atomic& operator=(
const atomic&) =
delete;
1611 using __atomic_float<long double>::operator=;
1614 #define __cpp_lib_atomic_ref 201806L
1617 template<
typename _Tp>
1618 struct atomic_ref : __atomic_ref<_Tp>
1621 atomic_ref(_Tp& __t) noexcept : __atomic_ref<_Tp>(__t)
1624 atomic_ref&
operator=(
const atomic_ref&) =
delete;
1626 atomic_ref(
const atomic_ref&) =
default;
1628 using __atomic_ref<_Tp>::operator=;
1635 _GLIBCXX_END_NAMESPACE_VERSION
1640 #endif // _GLIBCXX_ATOMIC
atomic< uint_least32_t > atomic_uint_least32_t
atomic_uint_least32_t
atomic< int_least32_t > atomic_int_least32_t
atomic_int_least32_t
atomic< int8_t > atomic_int8_t
atomic_int8_t
Explicit specialization for long.
atomic< int_least8_t > atomic_int_least8_t
atomic_int_least8_t
atomic< int_least16_t > atomic_int_least16_t
atomic_int_least16_t
atomic< unsigned long > atomic_ulong
atomic_ulong
atomic< uint16_t > atomic_uint16_t
atomic_uint16_t
atomic< uint_fast16_t > atomic_uint_fast16_t
atomic_uint_fast16_t
atomic< bool > atomic_bool
atomic_bool
Explicit specialization for unsigned short.
Explicit specialization for char.
atomic< signed char > atomic_schar
atomic_schar
atomic< ptrdiff_t > atomic_ptrdiff_t
atomic_ptrdiff_t
Explicit specialization for int.
atomic< char16_t > atomic_char16_t
atomic_char16_t
Explicit specialization for short.
atomic< int_least64_t > atomic_int_least64_t
atomic_int_least64_t
Explicit specialization for unsigned long long.
atomic< size_t > atomic_size_t
atomic_size_t
atomic< uint_least8_t > atomic_uint_least8_t
atomic_uint_least8_t
Generic atomic type, primary class template.
atomic< uint_fast32_t > atomic_uint_fast32_t
atomic_uint_fast32_t
atomic< int > atomic_int
atomic_int
atomic< unsigned short > atomic_ushort
atomic_ushort
atomic< uintptr_t > atomic_uintptr_t
atomic_uintptr_t
atomic< unsigned int > atomic_uint
atomic_uint
atomic< uint_fast8_t > atomic_uint_fast8_t
atomic_uint_fast8_t
atomic< uint64_t > atomic_uint64_t
atomic_uint64_t
#define ATOMIC_BOOL_LOCK_FREE
atomic< uintmax_t > atomic_uintmax_t
atomic_uintmax_t
atomic< unsigned long long > atomic_ullong
atomic_ullong
atomic< int64_t > atomic_int64_t
atomic_int64_t
atomic< int_fast8_t > atomic_int_fast8_t
atomic_int_fast8_t
atomic< intptr_t > atomic_intptr_t
atomic_intptr_t
atomic< intmax_t > atomic_intmax_t
atomic_intmax_t
atomic< unsigned char > atomic_uchar
atomic_uchar
atomic< int32_t > atomic_int32_t
atomic_int32_t
Explicit specialization for char32_t.
atomic< uint_least64_t > atomic_uint_least64_t
atomic_uint_least64_t
Explicit specialization for long long.
atomic< uint_least16_t > atomic_uint_least16_t
atomic_uint_least16_t
atomic< long long > atomic_llong
atomic_llong
Explicit specialization for unsigned long.
atomic< long > atomic_long
atomic_long
Explicit specialization for unsigned char.
atomic< uint_fast64_t > atomic_uint_fast64_t
atomic_uint_fast64_t
Explicit specialization for wchar_t.
constexpr _Tp exchange(_Tp &__obj, _Up &&__new_val)
Assign __new_val to __obj and return its previous value.
Explicit specialization for char16_t.
atomic< uint32_t > atomic_uint32_t
atomic_uint32_t
atomic< short > atomic_short
atomic_short
atomic< int16_t > atomic_int16_t
atomic_int16_t
atomic< char32_t > atomic_char32_t
atomic_char32_t
atomic< int_fast64_t > atomic_int_fast64_t
atomic_int_fast64_t
atomic< int_fast32_t > atomic_int_fast32_t
atomic_int_fast32_t
constexpr _Tp * __addressof(_Tp &__r) noexcept
Same as C++11 std::addressof.
atomic< int_fast16_t > atomic_int_fast16_t
atomic_int_fast16_t
atomic< uint8_t > atomic_uint8_t
atomic_uint8_t
memory_order
Enumeration for memory_order.
atomic< wchar_t > atomic_wchar_t
atomic_wchar_t
Explicit specialization for unsigned int.
atomic< char > atomic_char
atomic_char
auto_ptr & operator=(auto_ptr &__a)
auto_ptr assignment operator.
Explicit specialization for signed char.