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 template<
typename _Tp>
64 atomic() noexcept =
default;
65 ~
atomic() noexcept =
default;
70 constexpr
atomic(
bool __i) noexcept : _M_base(__i) { }
73 operator=(
bool __i) noexcept
74 {
return _M_base.operator=(__i); }
77 operator=(
bool __i)
volatile noexcept
78 {
return _M_base.operator=(__i); }
80 operator bool()
const noexcept
81 {
return _M_base.load(); }
83 operator bool()
const volatile noexcept
84 {
return _M_base.load(); }
87 is_lock_free()
const noexcept {
return _M_base.is_lock_free(); }
90 is_lock_free()
const volatile noexcept {
return _M_base.is_lock_free(); }
93 store(
bool __i,
memory_order __m = memory_order_seq_cst) noexcept
94 { _M_base.store(__i, __m); }
97 store(
bool __i,
memory_order __m = memory_order_seq_cst)
volatile noexcept
98 { _M_base.store(__i, __m); }
101 load(
memory_order __m = memory_order_seq_cst)
const noexcept
102 {
return _M_base.load(__m); }
105 load(
memory_order __m = memory_order_seq_cst)
const volatile noexcept
106 {
return _M_base.load(__m); }
109 exchange(
bool __i,
memory_order __m = memory_order_seq_cst) noexcept
110 {
return _M_base.exchange(__i, __m); }
114 memory_order __m = memory_order_seq_cst)
volatile noexcept
115 {
return _M_base.exchange(__i, __m); }
118 compare_exchange_weak(
bool& __i1,
bool __i2,
memory_order __m1,
120 {
return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); }
123 compare_exchange_weak(
bool& __i1,
bool __i2,
memory_order __m1,
125 {
return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); }
128 compare_exchange_weak(
bool& __i1,
bool __i2,
130 {
return _M_base.compare_exchange_weak(__i1, __i2, __m); }
133 compare_exchange_weak(
bool& __i1,
bool __i2,
134 memory_order __m = memory_order_seq_cst)
volatile noexcept
135 {
return _M_base.compare_exchange_weak(__i1, __i2, __m); }
138 compare_exchange_strong(
bool& __i1,
bool __i2,
memory_order __m1,
140 {
return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); }
143 compare_exchange_strong(
bool& __i1,
bool __i2,
memory_order __m1,
145 {
return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); }
148 compare_exchange_strong(
bool& __i1,
bool __i2,
150 {
return _M_base.compare_exchange_strong(__i1, __i2, __m); }
153 compare_exchange_strong(
bool& __i1,
bool __i2,
154 memory_order __m = memory_order_seq_cst)
volatile noexcept
155 {
return _M_base.compare_exchange_strong(__i1, __i2, __m); }
164 template<
typename _Tp>
169 static constexpr
int _S_min_alignment
170 = (
sizeof(_Tp) & (
sizeof(_Tp) - 1)) ||
sizeof(_Tp) > 16
173 static constexpr
int _S_alignment
174 = _S_min_alignment >
alignof(_Tp) ? _S_min_alignment :
alignof(_Tp);
176 alignas(_S_alignment) _Tp _M_i;
178 static_assert(__is_trivially_copyable(_Tp),
179 "std::atomic requires a trivially copyable type");
181 static_assert(
sizeof(_Tp) > 0,
182 "Incomplete or zero-sized types are not supported");
185 atomic() noexcept = default;
186 ~
atomic() noexcept = default;
191 constexpr
atomic(_Tp __i) noexcept : _M_i(__i) { }
193 operator _Tp() const noexcept
196 operator _Tp() const volatile noexcept
200 operator=(_Tp __i) noexcept
201 { store(__i);
return __i; }
204 operator=(_Tp __i)
volatile noexcept
205 { store(__i);
return __i; }
208 is_lock_free() const noexcept
211 return __atomic_is_lock_free(
sizeof(_M_i),
212 reinterpret_cast<void *>(-__alignof(_M_i)));
216 is_lock_free() const volatile noexcept
219 return __atomic_is_lock_free(
sizeof(_M_i),
220 reinterpret_cast<void *>(-__alignof(_M_i)));
224 store(_Tp __i,
memory_order __m = memory_order_seq_cst) noexcept
225 { __atomic_store(&_M_i, &__i, __m); }
228 store(_Tp __i,
memory_order __m = memory_order_seq_cst) volatile noexcept
229 { __atomic_store(&_M_i, &__i, __m); }
232 load(
memory_order __m = memory_order_seq_cst) const noexcept
234 alignas(_Tp)
unsigned char __buf[
sizeof(_Tp)];
235 _Tp* __ptr =
reinterpret_cast<_Tp*
>(__buf);
236 __atomic_load(&_M_i, __ptr, __m);
241 load(
memory_order __m = memory_order_seq_cst) const volatile noexcept
243 alignas(_Tp)
unsigned char __buf[
sizeof(_Tp)];
244 _Tp* __ptr =
reinterpret_cast<_Tp*
>(__buf);
245 __atomic_load(&_M_i, __ptr, __m);
250 exchange(_Tp __i,
memory_order __m = memory_order_seq_cst) noexcept
252 alignas(_Tp)
unsigned char __buf[
sizeof(_Tp)];
253 _Tp* __ptr =
reinterpret_cast<_Tp*
>(__buf);
254 __atomic_exchange(&_M_i, &__i, __ptr, __m);
260 memory_order __m = memory_order_seq_cst) volatile noexcept
262 alignas(_Tp)
unsigned char __buf[
sizeof(_Tp)];
263 _Tp* __ptr =
reinterpret_cast<_Tp*
>(__buf);
264 __atomic_exchange(&_M_i, &__i, __ptr, __m);
269 compare_exchange_weak(_Tp& __e, _Tp __i,
memory_order __s,
272 return __atomic_compare_exchange(&_M_i, &__e, &__i,
true, __s, __f);
276 compare_exchange_weak(_Tp& __e, _Tp __i,
memory_order __s,
279 return __atomic_compare_exchange(&_M_i, &__e, &__i,
true, __s, __f);
283 compare_exchange_weak(_Tp& __e, _Tp __i,
285 {
return compare_exchange_weak(__e, __i, __m,
286 __cmpexch_failure_order(__m)); }
289 compare_exchange_weak(_Tp& __e, _Tp __i,
290 memory_order __m = memory_order_seq_cst) volatile noexcept
291 {
return compare_exchange_weak(__e, __i, __m,
292 __cmpexch_failure_order(__m)); }
295 compare_exchange_strong(_Tp& __e, _Tp __i,
memory_order __s,
298 return __atomic_compare_exchange(&_M_i, &__e, &__i,
false, __s, __f);
302 compare_exchange_strong(_Tp& __e, _Tp __i,
memory_order __s,
305 return __atomic_compare_exchange(&_M_i, &__e, &__i,
false, __s, __f);
309 compare_exchange_strong(_Tp& __e, _Tp __i,
311 {
return compare_exchange_strong(__e, __i, __m,
312 __cmpexch_failure_order(__m)); }
315 compare_exchange_strong(_Tp& __e, _Tp __i,
316 memory_order __m = memory_order_seq_cst) volatile noexcept
317 {
return compare_exchange_strong(__e, __i, __m,
318 __cmpexch_failure_order(__m)); }
323 template<
typename _Tp>
326 typedef _Tp* __pointer_type;
330 atomic() noexcept =
default;
331 ~
atomic() noexcept =
default;
336 constexpr
atomic(__pointer_type __p) noexcept : _M_b(__p) { }
338 operator __pointer_type()
const noexcept
339 {
return __pointer_type(_M_b); }
341 operator __pointer_type()
const volatile noexcept
342 {
return __pointer_type(_M_b); }
345 operator=(__pointer_type __p) noexcept
346 {
return _M_b.operator=(__p); }
349 operator=(__pointer_type __p)
volatile noexcept
350 {
return _M_b.operator=(__p); }
353 operator++(
int) noexcept
357 operator++(
int)
volatile noexcept
361 operator--(
int) noexcept
365 operator--(
int)
volatile noexcept
369 operator++() noexcept
373 operator++()
volatile noexcept
377 operator--() noexcept
381 operator--()
volatile noexcept
385 operator+=(ptrdiff_t __d) noexcept
386 {
return _M_b.operator+=(__d); }
389 operator+=(ptrdiff_t __d)
volatile noexcept
390 {
return _M_b.operator+=(__d); }
393 operator-=(ptrdiff_t __d) noexcept
394 {
return _M_b.operator-=(__d); }
397 operator-=(ptrdiff_t __d)
volatile noexcept
398 {
return _M_b.operator-=(__d); }
401 is_lock_free()
const noexcept
402 {
return _M_b.is_lock_free(); }
405 is_lock_free()
const volatile noexcept
406 {
return _M_b.is_lock_free(); }
409 store(__pointer_type __p,
411 {
return _M_b.store(__p, __m); }
414 store(__pointer_type __p,
415 memory_order __m = memory_order_seq_cst)
volatile noexcept
416 {
return _M_b.store(__p, __m); }
419 load(
memory_order __m = memory_order_seq_cst)
const noexcept
420 {
return _M_b.load(__m); }
423 load(
memory_order __m = memory_order_seq_cst)
const volatile noexcept
424 {
return _M_b.load(__m); }
429 {
return _M_b.exchange(__p, __m); }
433 memory_order __m = memory_order_seq_cst)
volatile noexcept
434 {
return _M_b.exchange(__p, __m); }
437 compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
439 {
return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
442 compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
445 {
return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
448 compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
451 return compare_exchange_weak(__p1, __p2, __m,
452 __cmpexch_failure_order(__m));
456 compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
457 memory_order __m = memory_order_seq_cst)
volatile noexcept
459 return compare_exchange_weak(__p1, __p2, __m,
460 __cmpexch_failure_order(__m));
464 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
466 {
return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
469 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
472 {
return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
475 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
478 return _M_b.compare_exchange_strong(__p1, __p2, __m,
479 __cmpexch_failure_order(__m));
483 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
484 memory_order __m = memory_order_seq_cst)
volatile noexcept
486 return _M_b.compare_exchange_strong(__p1, __p2, __m,
487 __cmpexch_failure_order(__m));
491 fetch_add(ptrdiff_t __d,
493 {
return _M_b.fetch_add(__d, __m); }
496 fetch_add(ptrdiff_t __d,
497 memory_order __m = memory_order_seq_cst)
volatile noexcept
498 {
return _M_b.fetch_add(__d, __m); }
501 fetch_sub(ptrdiff_t __d,
503 {
return _M_b.fetch_sub(__d, __m); }
506 fetch_sub(ptrdiff_t __d,
507 memory_order __m = memory_order_seq_cst)
volatile noexcept
508 {
return _M_b.fetch_sub(__d, __m); }
516 typedef char __integral_type;
519 atomic() noexcept =
default;
520 ~
atomic() noexcept =
default;
527 using __base_type::operator __integral_type;
528 using __base_type::operator=;
535 typedef signed char __integral_type;
538 atomic() noexcept=
default;
539 ~
atomic() noexcept =
default;
546 using __base_type::operator __integral_type;
547 using __base_type::operator=;
554 typedef unsigned char __integral_type;
557 atomic() noexcept=
default;
558 ~
atomic() noexcept =
default;
565 using __base_type::operator __integral_type;
566 using __base_type::operator=;
573 typedef short __integral_type;
576 atomic() noexcept =
default;
577 ~
atomic() noexcept =
default;
584 using __base_type::operator __integral_type;
585 using __base_type::operator=;
592 typedef unsigned short __integral_type;
595 atomic() noexcept =
default;
596 ~
atomic() noexcept =
default;
603 using __base_type::operator __integral_type;
604 using __base_type::operator=;
611 typedef int __integral_type;
614 atomic() noexcept =
default;
615 ~
atomic() noexcept =
default;
622 using __base_type::operator __integral_type;
623 using __base_type::operator=;
630 typedef unsigned int __integral_type;
633 atomic() noexcept =
default;
634 ~
atomic() noexcept =
default;
641 using __base_type::operator __integral_type;
642 using __base_type::operator=;
649 typedef long __integral_type;
652 atomic() noexcept =
default;
653 ~
atomic() noexcept =
default;
660 using __base_type::operator __integral_type;
661 using __base_type::operator=;
668 typedef unsigned long __integral_type;
671 atomic() noexcept =
default;
672 ~
atomic() noexcept =
default;
679 using __base_type::operator __integral_type;
680 using __base_type::operator=;
687 typedef long long __integral_type;
690 atomic() noexcept =
default;
691 ~
atomic() noexcept =
default;
698 using __base_type::operator __integral_type;
699 using __base_type::operator=;
706 typedef unsigned long long __integral_type;
709 atomic() noexcept =
default;
710 ~
atomic() noexcept =
default;
717 using __base_type::operator __integral_type;
718 using __base_type::operator=;
725 typedef wchar_t __integral_type;
728 atomic() noexcept =
default;
729 ~
atomic() noexcept =
default;
736 using __base_type::operator __integral_type;
737 using __base_type::operator=;
744 typedef char16_t __integral_type;
747 atomic() noexcept =
default;
748 ~
atomic() noexcept =
default;
755 using __base_type::operator __integral_type;
756 using __base_type::operator=;
763 typedef char32_t __integral_type;
766 atomic() noexcept =
default;
767 ~
atomic() noexcept =
default;
774 using __base_type::operator __integral_type;
775 using __base_type::operator=;
896 atomic_flag_test_and_set_explicit(
atomic_flag* __a,
898 {
return __a->test_and_set(__m); }
901 atomic_flag_test_and_set_explicit(
volatile atomic_flag* __a,
903 {
return __a->test_and_set(__m); }
906 atomic_flag_clear_explicit(atomic_flag* __a,
memory_order __m) noexcept
910 atomic_flag_clear_explicit(
volatile atomic_flag* __a,
915 atomic_flag_test_and_set(atomic_flag* __a) noexcept
916 {
return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }
919 atomic_flag_test_and_set(
volatile atomic_flag* __a) noexcept
920 {
return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }
923 atomic_flag_clear(atomic_flag* __a) noexcept
924 { atomic_flag_clear_explicit(__a, memory_order_seq_cst); }
927 atomic_flag_clear(
volatile atomic_flag* __a) noexcept
928 { atomic_flag_clear_explicit(__a, memory_order_seq_cst); }
932 template<
typename _ITp>
934 atomic_is_lock_free(
const atomic<_ITp>* __a) noexcept
935 {
return __a->is_lock_free(); }
937 template<
typename _ITp>
939 atomic_is_lock_free(
const volatile atomic<_ITp>* __a) noexcept
940 {
return __a->is_lock_free(); }
942 template<
typename _ITp>
944 atomic_init(atomic<_ITp>* __a, _ITp __i) noexcept
945 { __a->store(__i, memory_order_relaxed); }
947 template<
typename _ITp>
949 atomic_init(
volatile atomic<_ITp>* __a, _ITp __i) noexcept
950 { __a->store(__i, memory_order_relaxed); }
952 template<
typename _ITp>
954 atomic_store_explicit(atomic<_ITp>* __a, _ITp __i,
956 { __a->store(__i, __m); }
958 template<
typename _ITp>
960 atomic_store_explicit(
volatile atomic<_ITp>* __a, _ITp __i,
962 { __a->store(__i, __m); }
964 template<
typename _ITp>
966 atomic_load_explicit(
const atomic<_ITp>* __a,
memory_order __m) noexcept
967 {
return __a->load(__m); }
969 template<
typename _ITp>
971 atomic_load_explicit(
const volatile atomic<_ITp>* __a,
973 {
return __a->load(__m); }
975 template<
typename _ITp>
977 atomic_exchange_explicit(atomic<_ITp>* __a, _ITp __i,
979 {
return __a->exchange(__i, __m); }
981 template<
typename _ITp>
983 atomic_exchange_explicit(
volatile atomic<_ITp>* __a, _ITp __i,
985 {
return __a->exchange(__i, __m); }
987 template<
typename _ITp>
989 atomic_compare_exchange_weak_explicit(atomic<_ITp>* __a,
990 _ITp* __i1, _ITp __i2,
993 {
return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
995 template<
typename _ITp>
997 atomic_compare_exchange_weak_explicit(
volatile atomic<_ITp>* __a,
998 _ITp* __i1, _ITp __i2,
1001 {
return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
1003 template<
typename _ITp>
1005 atomic_compare_exchange_strong_explicit(atomic<_ITp>* __a,
1006 _ITp* __i1, _ITp __i2,
1009 {
return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
1011 template<
typename _ITp>
1013 atomic_compare_exchange_strong_explicit(
volatile atomic<_ITp>* __a,
1014 _ITp* __i1, _ITp __i2,
1017 {
return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
1020 template<
typename _ITp>
1022 atomic_store(atomic<_ITp>* __a, _ITp __i) noexcept
1023 { atomic_store_explicit(__a, __i, memory_order_seq_cst); }
1025 template<
typename _ITp>
1027 atomic_store(
volatile atomic<_ITp>* __a, _ITp __i) noexcept
1028 { atomic_store_explicit(__a, __i, memory_order_seq_cst); }
1030 template<
typename _ITp>
1032 atomic_load(
const atomic<_ITp>* __a) noexcept
1033 {
return atomic_load_explicit(__a, memory_order_seq_cst); }
1035 template<
typename _ITp>
1037 atomic_load(
const volatile atomic<_ITp>* __a) noexcept
1038 {
return atomic_load_explicit(__a, memory_order_seq_cst); }
1040 template<
typename _ITp>
1042 atomic_exchange(atomic<_ITp>* __a, _ITp __i) noexcept
1043 {
return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
1045 template<
typename _ITp>
1047 atomic_exchange(
volatile atomic<_ITp>* __a, _ITp __i) noexcept
1048 {
return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
1050 template<
typename _ITp>
1052 atomic_compare_exchange_weak(atomic<_ITp>* __a,
1053 _ITp* __i1, _ITp __i2) noexcept
1055 return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
1056 memory_order_seq_cst,
1057 memory_order_seq_cst);
1060 template<
typename _ITp>
1062 atomic_compare_exchange_weak(
volatile atomic<_ITp>* __a,
1063 _ITp* __i1, _ITp __i2) noexcept
1065 return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
1066 memory_order_seq_cst,
1067 memory_order_seq_cst);
1070 template<
typename _ITp>
1072 atomic_compare_exchange_strong(atomic<_ITp>* __a,
1073 _ITp* __i1, _ITp __i2) noexcept
1075 return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
1076 memory_order_seq_cst,
1077 memory_order_seq_cst);
1080 template<
typename _ITp>
1082 atomic_compare_exchange_strong(
volatile atomic<_ITp>* __a,
1083 _ITp* __i1, _ITp __i2) noexcept
1085 return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
1086 memory_order_seq_cst,
1087 memory_order_seq_cst);
1094 template<
typename _ITp>
1096 atomic_fetch_add_explicit(__atomic_base<_ITp>* __a, _ITp __i,
1098 {
return __a->fetch_add(__i, __m); }
1100 template<
typename _ITp>
1102 atomic_fetch_add_explicit(
volatile __atomic_base<_ITp>* __a, _ITp __i,
1104 {
return __a->fetch_add(__i, __m); }
1106 template<
typename _ITp>
1108 atomic_fetch_sub_explicit(__atomic_base<_ITp>* __a, _ITp __i,
1110 {
return __a->fetch_sub(__i, __m); }
1112 template<
typename _ITp>
1114 atomic_fetch_sub_explicit(
volatile __atomic_base<_ITp>* __a, _ITp __i,
1116 {
return __a->fetch_sub(__i, __m); }
1118 template<
typename _ITp>
1120 atomic_fetch_and_explicit(__atomic_base<_ITp>* __a, _ITp __i,
1122 {
return __a->fetch_and(__i, __m); }
1124 template<
typename _ITp>
1126 atomic_fetch_and_explicit(
volatile __atomic_base<_ITp>* __a, _ITp __i,
1128 {
return __a->fetch_and(__i, __m); }
1130 template<
typename _ITp>
1132 atomic_fetch_or_explicit(__atomic_base<_ITp>* __a, _ITp __i,
1134 {
return __a->fetch_or(__i, __m); }
1136 template<
typename _ITp>
1138 atomic_fetch_or_explicit(
volatile __atomic_base<_ITp>* __a, _ITp __i,
1140 {
return __a->fetch_or(__i, __m); }
1142 template<
typename _ITp>
1144 atomic_fetch_xor_explicit(__atomic_base<_ITp>* __a, _ITp __i,
1146 {
return __a->fetch_xor(__i, __m); }
1148 template<
typename _ITp>
1150 atomic_fetch_xor_explicit(
volatile __atomic_base<_ITp>* __a, _ITp __i,
1152 {
return __a->fetch_xor(__i, __m); }
1154 template<
typename _ITp>
1156 atomic_fetch_add(__atomic_base<_ITp>* __a, _ITp __i) noexcept
1157 {
return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
1159 template<
typename _ITp>
1161 atomic_fetch_add(
volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
1162 {
return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
1164 template<
typename _ITp>
1166 atomic_fetch_sub(__atomic_base<_ITp>* __a, _ITp __i) noexcept
1167 {
return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
1169 template<
typename _ITp>
1171 atomic_fetch_sub(
volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
1172 {
return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
1174 template<
typename _ITp>
1176 atomic_fetch_and(__atomic_base<_ITp>* __a, _ITp __i) noexcept
1177 {
return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }
1179 template<
typename _ITp>
1181 atomic_fetch_and(
volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
1182 {
return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }
1184 template<
typename _ITp>
1186 atomic_fetch_or(__atomic_base<_ITp>* __a, _ITp __i) noexcept
1187 {
return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }
1189 template<
typename _ITp>
1191 atomic_fetch_or(
volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
1192 {
return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }
1194 template<
typename _ITp>
1196 atomic_fetch_xor(__atomic_base<_ITp>* __a, _ITp __i) noexcept
1197 {
return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
1199 template<
typename _ITp>
1201 atomic_fetch_xor(
volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
1202 {
return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
1206 template<
typename _ITp>
1208 atomic_fetch_add_explicit(atomic<_ITp*>* __a, ptrdiff_t __d,
1210 {
return __a->fetch_add(__d, __m); }
1212 template<
typename _ITp>
1214 atomic_fetch_add_explicit(
volatile atomic<_ITp*>* __a, ptrdiff_t __d,
1216 {
return __a->fetch_add(__d, __m); }
1218 template<
typename _ITp>
1220 atomic_fetch_add(
volatile atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
1221 {
return __a->fetch_add(__d); }
1223 template<
typename _ITp>
1225 atomic_fetch_add(atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
1226 {
return __a->fetch_add(__d); }
1228 template<
typename _ITp>
1230 atomic_fetch_sub_explicit(
volatile atomic<_ITp*>* __a,
1232 {
return __a->fetch_sub(__d, __m); }
1234 template<
typename _ITp>
1236 atomic_fetch_sub_explicit(atomic<_ITp*>* __a, ptrdiff_t __d,
1238 {
return __a->fetch_sub(__d, __m); }
1240 template<
typename _ITp>
1242 atomic_fetch_sub(
volatile atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
1243 {
return __a->fetch_sub(__d); }
1245 template<
typename _ITp>
1247 atomic_fetch_sub(atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
1248 {
return __a->fetch_sub(__d); }
1251 _GLIBCXX_END_NAMESPACE_VERSION
1256 #endif // _GLIBCXX_ATOMIC
atomic< int > atomic_int
atomic_int
Explicit specialization for wchar_t.
atomic< intmax_t > atomic_intmax_t
atomic_intmax_t
Explicit specialization for char16_t.
atomic< unsigned long long > atomic_ullong
atomic_ullong
atomic< uint_fast64_t > atomic_uint_fast64_t
atomic_uint_fast64_t
atomic< unsigned long > atomic_ulong
atomic_ulong
Explicit specialization for short.
atomic< wchar_t > atomic_wchar_t
atomic_wchar_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
atomic< uint_least16_t > atomic_uint_least16_t
atomic_uint_least16_t
atomic< long > atomic_long
atomic_long
_Tp exchange(_Tp &__obj, _Up &&__new_val)
Assign __new_val to __obj and return its previous value.
atomic< size_t > atomic_size_t
atomic_size_t
Explicit specialization for unsigned short.
atomic< unsigned short > atomic_ushort
atomic_ushort
atomic< short > atomic_short
atomic_short
atomic< uint_fast16_t > atomic_uint_fast16_t
atomic_uint_fast16_t
Explicit specialization for unsigned int.
atomic< int_least8_t > atomic_int_least8_t
atomic_int_least8_t
Generic atomic type, primary class template.
atomic< uint_least64_t > atomic_uint_least64_t
atomic_uint_least64_t
Explicit specialization for char.
Explicit specialization for long long.
Explicit specialization for int.
atomic< uint_least8_t > atomic_uint_least8_t
atomic_uint_least8_t
Explicit specialization for unsigned char.
atomic< int_least64_t > atomic_int_least64_t
atomic_int_least64_t
atomic< char16_t > atomic_char16_t
atomic_char16_t
atomic< intptr_t > atomic_intptr_t
atomic_intptr_t
Explicit specialization for unsigned long long.
atomic< unsigned char > atomic_uchar
atomic_uchar
atomic< bool > atomic_bool
atomic_bool
atomic< long long > atomic_llong
atomic_llong
atomic< uintmax_t > atomic_uintmax_t
atomic_uintmax_t
atomic< unsigned int > atomic_uint
atomic_uint
atomic< int_fast16_t > atomic_int_fast16_t
atomic_int_fast16_t
Explicit specialization for long.
Explicit specialization for char32_t.
atomic< signed char > atomic_schar
atomic_schar
atomic< uint_fast8_t > atomic_uint_fast8_t
atomic_uint_fast8_t
atomic< int_fast8_t > atomic_int_fast8_t
atomic_int_fast8_t
atomic< uint_least32_t > atomic_uint_least32_t
atomic_uint_least32_t
memory_order
Enumeration for memory_order.
atomic< char > atomic_char
atomic_char
atomic< int_least32_t > atomic_int_least32_t
atomic_int_least32_t
atomic< uint_fast32_t > atomic_uint_fast32_t
atomic_uint_fast32_t
atomic< char32_t > atomic_char32_t
atomic_char32_t
Explicit specialization for signed char.
atomic< int_least16_t > atomic_int_least16_t
atomic_int_least16_t
atomic< uintptr_t > atomic_uintptr_t
atomic_uintptr_t
Explicit specialization for unsigned long.
atomic< ptrdiff_t > atomic_ptrdiff_t
atomic_ptrdiff_t