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(&_M_i, __old,
390 const auto __v = this->load(__m);
393 return __builtin_memcmp(&__old, &__v,
401 notify_one()
const noexcept
402 { std::__atomic_notify(&_M_i,
false); }
405 notify_all()
const noexcept
406 { std::__atomic_notify(&_M_i,
true); }
410 #undef _GLIBCXX20_INIT
413 template<
typename _Tp>
416 using value_type = _Tp*;
417 using difference_type = ptrdiff_t;
419 typedef _Tp* __pointer_type;
423 atomic() noexcept =
default;
424 ~
atomic() noexcept =
default;
429 constexpr
atomic(__pointer_type __p) noexcept : _M_b(__p) { }
431 operator __pointer_type()
const noexcept
432 {
return __pointer_type(_M_b); }
434 operator __pointer_type()
const volatile noexcept
435 {
return __pointer_type(_M_b); }
439 {
return _M_b.operator=(__p); }
442 operator=(__pointer_type __p)
volatile noexcept
443 {
return _M_b.operator=(__p); }
446 operator++(
int) noexcept
448 #if __cplusplus >= 201703L
455 operator++(
int)
volatile noexcept
457 #if __cplusplus >= 201703L
464 operator--(
int) noexcept
466 #if __cplusplus >= 201703L
473 operator--(
int)
volatile noexcept
475 #if __cplusplus >= 201703L
482 operator++() noexcept
484 #if __cplusplus >= 201703L
491 operator++()
volatile noexcept
493 #if __cplusplus >= 201703L
500 operator--() noexcept
502 #if __cplusplus >= 201703L
509 operator--()
volatile noexcept
511 #if __cplusplus >= 201703L
518 operator+=(ptrdiff_t __d) noexcept
520 #if __cplusplus >= 201703L
523 return _M_b.operator+=(__d);
527 operator+=(ptrdiff_t __d)
volatile noexcept
529 #if __cplusplus >= 201703L
532 return _M_b.operator+=(__d);
536 operator-=(ptrdiff_t __d) noexcept
538 #if __cplusplus >= 201703L
541 return _M_b.operator-=(__d);
545 operator-=(ptrdiff_t __d)
volatile noexcept
547 #if __cplusplus >= 201703L
550 return _M_b.operator-=(__d);
554 is_lock_free()
const noexcept
555 {
return _M_b.is_lock_free(); }
558 is_lock_free()
const volatile noexcept
559 {
return _M_b.is_lock_free(); }
561 #if __cplusplus >= 201703L
562 static constexpr
bool is_always_lock_free = ATOMIC_POINTER_LOCK_FREE == 2;
566 store(__pointer_type __p,
568 {
return _M_b.store(__p, __m); }
571 store(__pointer_type __p,
572 memory_order __m = memory_order_seq_cst)
volatile noexcept
573 {
return _M_b.store(__p, __m); }
576 load(
memory_order __m = memory_order_seq_cst)
const noexcept
577 {
return _M_b.load(__m); }
580 load(
memory_order __m = memory_order_seq_cst)
const volatile noexcept
581 {
return _M_b.load(__m); }
586 {
return _M_b.exchange(__p, __m); }
590 memory_order __m = memory_order_seq_cst)
volatile noexcept
591 {
return _M_b.exchange(__p, __m); }
594 compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
596 {
return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
599 compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
602 {
return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
605 compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
608 return compare_exchange_weak(__p1, __p2, __m,
609 __cmpexch_failure_order(__m));
613 compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
614 memory_order __m = memory_order_seq_cst)
volatile noexcept
616 return compare_exchange_weak(__p1, __p2, __m,
617 __cmpexch_failure_order(__m));
621 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
623 {
return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
626 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
629 {
return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
632 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
635 return _M_b.compare_exchange_strong(__p1, __p2, __m,
636 __cmpexch_failure_order(__m));
640 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
641 memory_order __m = memory_order_seq_cst)
volatile noexcept
643 return _M_b.compare_exchange_strong(__p1, __p2, __m,
644 __cmpexch_failure_order(__m));
647 #if __cpp_lib_atomic_wait
649 wait(__pointer_type __old,
memory_order __m = memory_order_seq_cst) noexcept
650 { _M_b.wait(__old, __m); }
655 notify_one()
const noexcept
656 { _M_b.notify_one(); }
659 notify_all()
const noexcept
660 { _M_b.notify_all(); }
663 fetch_add(ptrdiff_t __d,
666 #if __cplusplus >= 201703L
669 return _M_b.fetch_add(__d, __m);
673 fetch_add(ptrdiff_t __d,
674 memory_order __m = memory_order_seq_cst)
volatile noexcept
676 #if __cplusplus >= 201703L
679 return _M_b.fetch_add(__d, __m);
683 fetch_sub(ptrdiff_t __d,
686 #if __cplusplus >= 201703L
689 return _M_b.fetch_sub(__d, __m);
693 fetch_sub(ptrdiff_t __d,
694 memory_order __m = memory_order_seq_cst)
volatile noexcept
696 #if __cplusplus >= 201703L
699 return _M_b.fetch_sub(__d, __m);
708 typedef char __integral_type;
711 atomic() noexcept =
default;
712 ~
atomic() noexcept =
default;
719 using __base_type::operator __integral_type;
720 using __base_type::operator=;
722 #if __cplusplus >= 201703L
723 static constexpr
bool is_always_lock_free = ATOMIC_CHAR_LOCK_FREE == 2;
731 typedef signed char __integral_type;
734 atomic() noexcept=
default;
735 ~
atomic() noexcept =
default;
742 using __base_type::operator __integral_type;
743 using __base_type::operator=;
745 #if __cplusplus >= 201703L
746 static constexpr
bool is_always_lock_free = ATOMIC_CHAR_LOCK_FREE == 2;
754 typedef unsigned char __integral_type;
757 atomic() noexcept=
default;
758 ~
atomic() noexcept =
default;
765 using __base_type::operator __integral_type;
766 using __base_type::operator=;
768 #if __cplusplus >= 201703L
769 static constexpr
bool is_always_lock_free = ATOMIC_CHAR_LOCK_FREE == 2;
777 typedef short __integral_type;
780 atomic() noexcept =
default;
781 ~
atomic() noexcept =
default;
788 using __base_type::operator __integral_type;
789 using __base_type::operator=;
791 #if __cplusplus >= 201703L
792 static constexpr
bool is_always_lock_free = ATOMIC_SHORT_LOCK_FREE == 2;
800 typedef unsigned short __integral_type;
803 atomic() noexcept =
default;
804 ~
atomic() noexcept =
default;
811 using __base_type::operator __integral_type;
812 using __base_type::operator=;
814 #if __cplusplus >= 201703L
815 static constexpr
bool is_always_lock_free = ATOMIC_SHORT_LOCK_FREE == 2;
823 typedef int __integral_type;
826 atomic() noexcept =
default;
827 ~
atomic() noexcept =
default;
834 using __base_type::operator __integral_type;
835 using __base_type::operator=;
837 #if __cplusplus >= 201703L
838 static constexpr
bool is_always_lock_free = ATOMIC_INT_LOCK_FREE == 2;
846 typedef unsigned int __integral_type;
849 atomic() noexcept =
default;
850 ~
atomic() noexcept =
default;
857 using __base_type::operator __integral_type;
858 using __base_type::operator=;
860 #if __cplusplus >= 201703L
861 static constexpr
bool is_always_lock_free = ATOMIC_INT_LOCK_FREE == 2;
869 typedef long __integral_type;
872 atomic() noexcept =
default;
873 ~
atomic() noexcept =
default;
880 using __base_type::operator __integral_type;
881 using __base_type::operator=;
883 #if __cplusplus >= 201703L
884 static constexpr
bool is_always_lock_free = ATOMIC_LONG_LOCK_FREE == 2;
892 typedef unsigned long __integral_type;
895 atomic() noexcept =
default;
896 ~
atomic() noexcept =
default;
903 using __base_type::operator __integral_type;
904 using __base_type::operator=;
906 #if __cplusplus >= 201703L
907 static constexpr
bool is_always_lock_free = ATOMIC_LONG_LOCK_FREE == 2;
915 typedef long long __integral_type;
918 atomic() noexcept =
default;
919 ~
atomic() noexcept =
default;
926 using __base_type::operator __integral_type;
927 using __base_type::operator=;
929 #if __cplusplus >= 201703L
930 static constexpr
bool is_always_lock_free = ATOMIC_LLONG_LOCK_FREE == 2;
938 typedef unsigned long long __integral_type;
941 atomic() noexcept =
default;
942 ~
atomic() noexcept =
default;
949 using __base_type::operator __integral_type;
950 using __base_type::operator=;
952 #if __cplusplus >= 201703L
953 static constexpr
bool is_always_lock_free = ATOMIC_LLONG_LOCK_FREE == 2;
961 typedef wchar_t __integral_type;
964 atomic() noexcept =
default;
965 ~
atomic() noexcept =
default;
972 using __base_type::operator __integral_type;
973 using __base_type::operator=;
975 #if __cplusplus >= 201703L
976 static constexpr
bool is_always_lock_free = ATOMIC_WCHAR_T_LOCK_FREE == 2;
980 #ifdef _GLIBCXX_USE_CHAR8_T
985 typedef char8_t __integral_type;
988 atomic() noexcept = default;
989 ~
atomic() noexcept = default;
994 constexpr
atomic(__integral_type __i) noexcept : __base_type(__i) { }
996 using __base_type::operator __integral_type;
997 using __base_type::operator=;
999 #if __cplusplus > 201402L
1000 static constexpr
bool is_always_lock_free = ATOMIC_CHAR8_T_LOCK_FREE == 2;
1009 typedef char16_t __integral_type;
1012 atomic() noexcept =
default;
1013 ~
atomic() noexcept =
default;
1020 using __base_type::operator __integral_type;
1021 using __base_type::operator=;
1023 #if __cplusplus >= 201703L
1024 static constexpr
bool is_always_lock_free = ATOMIC_CHAR16_T_LOCK_FREE == 2;
1032 typedef char32_t __integral_type;
1035 atomic() noexcept =
default;
1036 ~
atomic() noexcept =
default;
1043 using __base_type::operator __integral_type;
1044 using __base_type::operator=;
1046 #if __cplusplus >= 201703L
1047 static constexpr
bool is_always_lock_free = ATOMIC_CHAR32_T_LOCK_FREE == 2;
1091 #ifdef _GLIBCXX_USE_CHAR8_T
1102 #ifdef _GLIBCXX_USE_C99_STDINT_TR1
1194 #ifdef _GLIBCXX_USE_C99_STDINT_TR1
1204 atomic_flag_test_and_set_explicit(
atomic_flag* __a,
1206 {
return __a->test_and_set(__m); }
1209 atomic_flag_test_and_set_explicit(
volatile atomic_flag* __a,
1211 {
return __a->test_and_set(__m); }
1214 atomic_flag_clear_explicit(atomic_flag* __a,
memory_order __m) noexcept
1215 { __a->clear(__m); }
1218 atomic_flag_clear_explicit(
volatile atomic_flag* __a,
1220 { __a->clear(__m); }
1223 atomic_flag_test_and_set(atomic_flag* __a) noexcept
1224 {
return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }
1227 atomic_flag_test_and_set(
volatile atomic_flag* __a) noexcept
1228 {
return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }
1231 atomic_flag_clear(atomic_flag* __a) noexcept
1232 { atomic_flag_clear_explicit(__a, memory_order_seq_cst); }
1235 atomic_flag_clear(
volatile atomic_flag* __a) noexcept
1236 { atomic_flag_clear_explicit(__a, memory_order_seq_cst); }
1239 template<
typename _Tp>
1240 using __atomic_val_t =
typename atomic<_Tp>::value_type;
1241 template<
typename _Tp>
1242 using __atomic_diff_t =
typename atomic<_Tp>::difference_type;
1246 template<
typename _ITp>
1248 atomic_is_lock_free(
const atomic<_ITp>* __a) noexcept
1249 {
return __a->is_lock_free(); }
1251 template<
typename _ITp>
1253 atomic_is_lock_free(
const volatile atomic<_ITp>* __a) noexcept
1254 {
return __a->is_lock_free(); }
1256 template<
typename _ITp>
1258 atomic_init(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept
1259 { __a->store(__i, memory_order_relaxed); }
1261 template<
typename _ITp>
1263 atomic_init(
volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept
1264 { __a->store(__i, memory_order_relaxed); }
1266 template<
typename _ITp>
1268 atomic_store_explicit(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i,
1270 { __a->store(__i, __m); }
1272 template<
typename _ITp>
1274 atomic_store_explicit(
volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i,
1276 { __a->store(__i, __m); }
1278 template<
typename _ITp>
1280 atomic_load_explicit(
const atomic<_ITp>* __a,
memory_order __m) noexcept
1281 {
return __a->load(__m); }
1283 template<
typename _ITp>
1285 atomic_load_explicit(
const volatile atomic<_ITp>* __a,
1287 {
return __a->load(__m); }
1289 template<
typename _ITp>
1291 atomic_exchange_explicit(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i,
1293 {
return __a->exchange(__i, __m); }
1295 template<
typename _ITp>
1297 atomic_exchange_explicit(
volatile atomic<_ITp>* __a,
1298 __atomic_val_t<_ITp> __i,
1300 {
return __a->exchange(__i, __m); }
1302 template<
typename _ITp>
1304 atomic_compare_exchange_weak_explicit(atomic<_ITp>* __a,
1305 __atomic_val_t<_ITp>* __i1,
1306 __atomic_val_t<_ITp> __i2,
1309 {
return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
1311 template<
typename _ITp>
1313 atomic_compare_exchange_weak_explicit(
volatile atomic<_ITp>* __a,
1314 __atomic_val_t<_ITp>* __i1,
1315 __atomic_val_t<_ITp> __i2,
1318 {
return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
1320 template<
typename _ITp>
1322 atomic_compare_exchange_strong_explicit(atomic<_ITp>* __a,
1323 __atomic_val_t<_ITp>* __i1,
1324 __atomic_val_t<_ITp> __i2,
1327 {
return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
1329 template<
typename _ITp>
1331 atomic_compare_exchange_strong_explicit(
volatile atomic<_ITp>* __a,
1332 __atomic_val_t<_ITp>* __i1,
1333 __atomic_val_t<_ITp> __i2,
1336 {
return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
1339 template<
typename _ITp>
1341 atomic_store(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept
1342 { atomic_store_explicit(__a, __i, memory_order_seq_cst); }
1344 template<
typename _ITp>
1346 atomic_store(
volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept
1347 { atomic_store_explicit(__a, __i, memory_order_seq_cst); }
1349 template<
typename _ITp>
1351 atomic_load(
const atomic<_ITp>* __a) noexcept
1352 {
return atomic_load_explicit(__a, memory_order_seq_cst); }
1354 template<
typename _ITp>
1356 atomic_load(
const volatile atomic<_ITp>* __a) noexcept
1357 {
return atomic_load_explicit(__a, memory_order_seq_cst); }
1359 template<
typename _ITp>
1361 atomic_exchange(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept
1362 {
return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
1364 template<
typename _ITp>
1366 atomic_exchange(
volatile atomic<_ITp>* __a,
1367 __atomic_val_t<_ITp> __i) noexcept
1368 {
return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
1370 template<
typename _ITp>
1372 atomic_compare_exchange_weak(atomic<_ITp>* __a,
1373 __atomic_val_t<_ITp>* __i1,
1374 __atomic_val_t<_ITp> __i2) noexcept
1376 return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
1377 memory_order_seq_cst,
1378 memory_order_seq_cst);
1381 template<
typename _ITp>
1383 atomic_compare_exchange_weak(
volatile atomic<_ITp>* __a,
1384 __atomic_val_t<_ITp>* __i1,
1385 __atomic_val_t<_ITp> __i2) noexcept
1387 return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
1388 memory_order_seq_cst,
1389 memory_order_seq_cst);
1392 template<
typename _ITp>
1394 atomic_compare_exchange_strong(atomic<_ITp>* __a,
1395 __atomic_val_t<_ITp>* __i1,
1396 __atomic_val_t<_ITp> __i2) noexcept
1398 return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
1399 memory_order_seq_cst,
1400 memory_order_seq_cst);
1403 template<
typename _ITp>
1405 atomic_compare_exchange_strong(
volatile atomic<_ITp>* __a,
1406 __atomic_val_t<_ITp>* __i1,
1407 __atomic_val_t<_ITp> __i2) noexcept
1409 return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
1410 memory_order_seq_cst,
1411 memory_order_seq_cst);
1415 #if __cpp_lib_atomic_wait
1416 template<
typename _Tp>
1418 atomic_wait(
const atomic<_Tp>* __a,
1419 typename std::atomic<_Tp>::value_type __old) noexcept
1420 { __a->wait(__old); }
1422 template<
typename _Tp>
1424 atomic_wait_explicit(
const atomic<_Tp>* __a,
1425 typename std::atomic<_Tp>::value_type __old,
1427 { __a->wait(__old, __m); }
1429 template<
typename _Tp>
1431 atomic_notify_one(atomic<_Tp>* __a) noexcept
1432 { __a->notify_one(); }
1434 template<
typename _Tp>
1436 atomic_notify_all(atomic<_Tp>* __a) noexcept
1437 { __a->notify_all(); }
1444 template<
typename _ITp>
1446 atomic_fetch_add_explicit(atomic<_ITp>* __a,
1447 __atomic_diff_t<_ITp> __i,
1449 {
return __a->fetch_add(__i, __m); }
1451 template<
typename _ITp>
1453 atomic_fetch_add_explicit(
volatile atomic<_ITp>* __a,
1454 __atomic_diff_t<_ITp> __i,
1456 {
return __a->fetch_add(__i, __m); }
1458 template<
typename _ITp>
1460 atomic_fetch_sub_explicit(atomic<_ITp>* __a,
1461 __atomic_diff_t<_ITp> __i,
1463 {
return __a->fetch_sub(__i, __m); }
1465 template<
typename _ITp>
1467 atomic_fetch_sub_explicit(
volatile atomic<_ITp>* __a,
1468 __atomic_diff_t<_ITp> __i,
1470 {
return __a->fetch_sub(__i, __m); }
1472 template<
typename _ITp>
1474 atomic_fetch_and_explicit(__atomic_base<_ITp>* __a,
1475 __atomic_val_t<_ITp> __i,
1477 {
return __a->fetch_and(__i, __m); }
1479 template<
typename _ITp>
1481 atomic_fetch_and_explicit(
volatile __atomic_base<_ITp>* __a,
1482 __atomic_val_t<_ITp> __i,
1484 {
return __a->fetch_and(__i, __m); }
1486 template<
typename _ITp>
1488 atomic_fetch_or_explicit(__atomic_base<_ITp>* __a,
1489 __atomic_val_t<_ITp> __i,
1491 {
return __a->fetch_or(__i, __m); }
1493 template<
typename _ITp>
1495 atomic_fetch_or_explicit(
volatile __atomic_base<_ITp>* __a,
1496 __atomic_val_t<_ITp> __i,
1498 {
return __a->fetch_or(__i, __m); }
1500 template<
typename _ITp>
1502 atomic_fetch_xor_explicit(__atomic_base<_ITp>* __a,
1503 __atomic_val_t<_ITp> __i,
1505 {
return __a->fetch_xor(__i, __m); }
1507 template<
typename _ITp>
1509 atomic_fetch_xor_explicit(
volatile __atomic_base<_ITp>* __a,
1510 __atomic_val_t<_ITp> __i,
1512 {
return __a->fetch_xor(__i, __m); }
1514 template<
typename _ITp>
1516 atomic_fetch_add(atomic<_ITp>* __a,
1517 __atomic_diff_t<_ITp> __i) noexcept
1518 {
return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
1520 template<
typename _ITp>
1522 atomic_fetch_add(
volatile atomic<_ITp>* __a,
1523 __atomic_diff_t<_ITp> __i) noexcept
1524 {
return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
1526 template<
typename _ITp>
1528 atomic_fetch_sub(atomic<_ITp>* __a,
1529 __atomic_diff_t<_ITp> __i) noexcept
1530 {
return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
1532 template<
typename _ITp>
1534 atomic_fetch_sub(
volatile atomic<_ITp>* __a,
1535 __atomic_diff_t<_ITp> __i) noexcept
1536 {
return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
1538 template<
typename _ITp>
1540 atomic_fetch_and(__atomic_base<_ITp>* __a,
1541 __atomic_val_t<_ITp> __i) noexcept
1542 {
return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }
1544 template<
typename _ITp>
1546 atomic_fetch_and(
volatile __atomic_base<_ITp>* __a,
1547 __atomic_val_t<_ITp> __i) noexcept
1548 {
return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }
1550 template<
typename _ITp>
1552 atomic_fetch_or(__atomic_base<_ITp>* __a,
1553 __atomic_val_t<_ITp> __i) noexcept
1554 {
return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }
1556 template<
typename _ITp>
1558 atomic_fetch_or(
volatile __atomic_base<_ITp>* __a,
1559 __atomic_val_t<_ITp> __i) noexcept
1560 {
return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }
1562 template<
typename _ITp>
1564 atomic_fetch_xor(__atomic_base<_ITp>* __a,
1565 __atomic_val_t<_ITp> __i) noexcept
1566 {
return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
1568 template<
typename _ITp>
1570 atomic_fetch_xor(
volatile __atomic_base<_ITp>* __a,
1571 __atomic_val_t<_ITp> __i) noexcept
1572 {
return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
1574 #if __cplusplus > 201703L
1575 #define __cpp_lib_atomic_float 201711L
1577 struct atomic<float> : __atomic_float<float>
1579 atomic() noexcept = default;
1582 atomic(
float __fp) noexcept : __atomic_float<
float>(__fp)
1585 atomic& operator=(
const atomic&)
volatile =
delete;
1586 atomic& operator=(
const atomic&) =
delete;
1588 using __atomic_float<float>::operator=;
1592 struct atomic<double> : __atomic_float<double>
1594 atomic() noexcept = default;
1597 atomic(
double __fp) noexcept : __atomic_float<
double>(__fp)
1600 atomic& operator=(
const atomic&)
volatile =
delete;
1601 atomic& operator=(
const atomic&) =
delete;
1603 using __atomic_float<double>::operator=;
1607 struct atomic<long double> : __atomic_float<long double>
1609 atomic() noexcept = default;
1612 atomic(
long double __fp) noexcept : __atomic_float<
long double>(__fp)
1615 atomic& operator=(
const atomic&)
volatile =
delete;
1616 atomic& operator=(
const atomic&) =
delete;
1618 using __atomic_float<long double>::operator=;
1621 #define __cpp_lib_atomic_ref 201806L
1624 template<
typename _Tp>
1625 struct atomic_ref : __atomic_ref<_Tp>
1628 atomic_ref(_Tp& __t) noexcept : __atomic_ref<_Tp>(__t)
1631 atomic_ref&
operator=(
const atomic_ref&) =
delete;
1633 atomic_ref(
const atomic_ref&) =
default;
1635 using __atomic_ref<_Tp>::operator=;
1642 _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.