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(); }
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); }
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(); }
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(); }
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
auto_ptr & operator=(auto_ptr &__a)
auto_ptr assignment operator.
constexpr _Tp * __addressof(_Tp &__r) noexcept
Same as C++11 std::addressof.
atomic< unsigned long > atomic_ulong
atomic_ulong
atomic< intmax_t > atomic_intmax_t
atomic_intmax_t
atomic< uintptr_t > atomic_uintptr_t
atomic_uintptr_t
atomic< signed char > atomic_schar
atomic_schar
atomic< int_least8_t > atomic_int_least8_t
atomic_int_least8_t
atomic< unsigned long long > atomic_ullong
atomic_ullong
atomic< uint_fast8_t > atomic_uint_fast8_t
atomic_uint_fast8_t
atomic< intptr_t > atomic_intptr_t
atomic_intptr_t
atomic< int16_t > atomic_int16_t
atomic_int16_t
atomic< size_t > atomic_size_t
atomic_size_t
atomic< long > atomic_long
atomic_long
atomic< uint_least8_t > atomic_uint_least8_t
atomic_uint_least8_t
atomic< short > atomic_short
atomic_short
atomic< uint_least16_t > atomic_uint_least16_t
atomic_uint_least16_t
atomic< uint16_t > atomic_uint16_t
atomic_uint16_t
atomic< uint64_t > atomic_uint64_t
atomic_uint64_t
atomic< int_least32_t > atomic_int_least32_t
atomic_int_least32_t
atomic< uint8_t > atomic_uint8_t
atomic_uint8_t
#define ATOMIC_BOOL_LOCK_FREE
atomic< wchar_t > atomic_wchar_t
atomic_wchar_t
atomic< unsigned int > atomic_uint
atomic_uint
atomic< uint_least32_t > atomic_uint_least32_t
atomic_uint_least32_t
atomic< uint_fast64_t > atomic_uint_fast64_t
atomic_uint_fast64_t
atomic< int_fast32_t > atomic_int_fast32_t
atomic_int_fast32_t
atomic< char > atomic_char
atomic_char
atomic< int > atomic_int
atomic_int
atomic< uint_least64_t > atomic_uint_least64_t
atomic_uint_least64_t
atomic< int64_t > atomic_int64_t
atomic_int64_t
atomic< uintmax_t > atomic_uintmax_t
atomic_uintmax_t
atomic< int_fast16_t > atomic_int_fast16_t
atomic_int_fast16_t
atomic< int32_t > atomic_int32_t
atomic_int32_t
memory_order
Enumeration for memory_order.
atomic< uint_fast16_t > atomic_uint_fast16_t
atomic_uint_fast16_t
atomic< int8_t > atomic_int8_t
atomic_int8_t
atomic< long long > atomic_llong
atomic_llong
atomic< char16_t > atomic_char16_t
atomic_char16_t
atomic< int_fast64_t > atomic_int_fast64_t
atomic_int_fast64_t
atomic< ptrdiff_t > atomic_ptrdiff_t
atomic_ptrdiff_t
atomic< char32_t > atomic_char32_t
atomic_char32_t
atomic< int_least16_t > atomic_int_least16_t
atomic_int_least16_t
atomic< unsigned char > atomic_uchar
atomic_uchar
atomic< int_fast8_t > atomic_int_fast8_t
atomic_int_fast8_t
atomic< unsigned short > atomic_ushort
atomic_ushort
atomic< int_least64_t > atomic_int_least64_t
atomic_int_least64_t
atomic< bool > atomic_bool
atomic_bool
atomic< uint_fast32_t > atomic_uint_fast32_t
atomic_uint_fast32_t
atomic< uint32_t > atomic_uint32_t
atomic_uint32_t
ISO C++ entities toplevel namespace is std.
constexpr _Tp exchange(_Tp &__obj, _Up &&__new_val)
Assign __new_val to __obj and return its previous value.
Generic atomic type, primary class template.
Explicit specialization for char.
Explicit specialization for signed char.
Explicit specialization for unsigned char.
Explicit specialization for short.
Explicit specialization for unsigned short.
Explicit specialization for int.
Explicit specialization for unsigned int.
Explicit specialization for long.
Explicit specialization for unsigned long.
Explicit specialization for long long.
Explicit specialization for unsigned long long.
Explicit specialization for wchar_t.
Explicit specialization for char16_t.
Explicit specialization for char32_t.