32 #ifndef _GLIBCXX_ATOMIC 33 #define _GLIBCXX_ATOMIC 1 35 #pragma GCC system_header 37 #if __cplusplus < 201103L 44 namespace std _GLIBCXX_VISIBILITY(default)
46 _GLIBCXX_BEGIN_NAMESPACE_VERSION
53 #if __cplusplus > 201402L 54 # define __cpp_lib_atomic_is_always_lock_free 201603 57 template<
typename _Tp>
69 atomic() noexcept =
default;
70 ~
atomic() noexcept =
default;
75 constexpr
atomic(
bool __i) noexcept : _M_base(__i) { }
78 operator=(
bool __i) noexcept
79 {
return _M_base.operator=(__i); }
82 operator=(
bool __i)
volatile noexcept
83 {
return _M_base.operator=(__i); }
85 operator bool()
const noexcept
86 {
return _M_base.load(); }
88 operator bool()
const volatile noexcept
89 {
return _M_base.load(); }
92 is_lock_free()
const noexcept {
return _M_base.is_lock_free(); }
95 is_lock_free()
const volatile noexcept {
return _M_base.is_lock_free(); }
97 #if __cplusplus > 201402L 102 store(
bool __i,
memory_order __m = memory_order_seq_cst) noexcept
103 { _M_base.store(__i, __m); }
106 store(
bool __i,
memory_order __m = memory_order_seq_cst)
volatile noexcept
107 { _M_base.store(__i, __m); }
110 load(
memory_order __m = memory_order_seq_cst)
const noexcept
111 {
return _M_base.load(__m); }
114 load(
memory_order __m = memory_order_seq_cst)
const volatile noexcept
115 {
return _M_base.load(__m); }
118 exchange(
bool __i,
memory_order __m = memory_order_seq_cst) noexcept
119 {
return _M_base.exchange(__i, __m); }
123 memory_order __m = memory_order_seq_cst)
volatile noexcept
124 {
return _M_base.exchange(__i, __m); }
127 compare_exchange_weak(
bool& __i1,
bool __i2,
memory_order __m1,
129 {
return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); }
132 compare_exchange_weak(
bool& __i1,
bool __i2,
memory_order __m1,
134 {
return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); }
137 compare_exchange_weak(
bool& __i1,
bool __i2,
139 {
return _M_base.compare_exchange_weak(__i1, __i2, __m); }
142 compare_exchange_weak(
bool& __i1,
bool __i2,
143 memory_order __m = memory_order_seq_cst)
volatile noexcept
144 {
return _M_base.compare_exchange_weak(__i1, __i2, __m); }
147 compare_exchange_strong(
bool& __i1,
bool __i2,
memory_order __m1,
149 {
return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); }
152 compare_exchange_strong(
bool& __i1,
bool __i2,
memory_order __m1,
154 {
return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); }
157 compare_exchange_strong(
bool& __i1,
bool __i2,
159 {
return _M_base.compare_exchange_strong(__i1, __i2, __m); }
162 compare_exchange_strong(
bool& __i1,
bool __i2,
163 memory_order __m = memory_order_seq_cst)
volatile noexcept
164 {
return _M_base.compare_exchange_strong(__i1, __i2, __m); }
173 template<
typename _Tp>
178 static constexpr
int _S_min_alignment
179 = (
sizeof(_Tp) & (
sizeof(_Tp) - 1)) ||
sizeof(_Tp) > 16
182 static constexpr
int _S_alignment
183 = _S_min_alignment >
alignof(_Tp) ? _S_min_alignment :
alignof(_Tp);
185 alignas(_S_alignment) _Tp _M_i;
187 static_assert(__is_trivially_copyable(_Tp),
188 "std::atomic requires a trivially copyable type");
190 static_assert(
sizeof(_Tp) > 0,
191 "Incomplete or zero-sized types are not supported");
194 atomic() noexcept =
default;
195 ~
atomic() noexcept =
default;
200 constexpr
atomic(_Tp __i) noexcept : _M_i(__i) { }
202 operator _Tp()
const noexcept
205 operator _Tp()
const volatile noexcept
209 operator=(_Tp __i) noexcept
210 { store(__i);
return __i; }
213 operator=(_Tp __i)
volatile noexcept
214 { store(__i);
return __i; }
217 is_lock_free()
const noexcept
220 return __atomic_is_lock_free(
sizeof(_M_i),
221 reinterpret_cast<void *>(-__alignof(_M_i)));
225 is_lock_free()
const volatile noexcept
228 return __atomic_is_lock_free(
sizeof(_M_i),
229 reinterpret_cast<void *>(-__alignof(_M_i)));
232 #if __cplusplus > 201402L 233 static constexpr
bool is_always_lock_free
234 = __atomic_always_lock_free(
sizeof(_M_i), 0);
238 store(_Tp __i,
memory_order __m = memory_order_seq_cst) noexcept
242 store(_Tp __i,
memory_order __m = memory_order_seq_cst)
volatile noexcept
246 load(
memory_order __m = memory_order_seq_cst)
const noexcept
254 load(
memory_order __m = memory_order_seq_cst)
const volatile noexcept
272 memory_order __m = memory_order_seq_cst)
volatile noexcept
281 compare_exchange_weak(_Tp& __e, _Tp __i,
memory_order __s,
291 compare_exchange_weak(_Tp& __e, _Tp __i,
memory_order __s,
301 compare_exchange_weak(_Tp& __e, _Tp __i,
303 {
return compare_exchange_weak(__e, __i, __m,
304 __cmpexch_failure_order(__m)); }
307 compare_exchange_weak(_Tp& __e, _Tp __i,
308 memory_order __m = memory_order_seq_cst)
volatile noexcept
309 {
return compare_exchange_weak(__e, __i, __m,
310 __cmpexch_failure_order(__m)); }
313 compare_exchange_strong(_Tp& __e, _Tp __i,
memory_order __s,
323 compare_exchange_strong(_Tp& __e, _Tp __i,
memory_order __s,
333 compare_exchange_strong(_Tp& __e, _Tp __i,
335 {
return compare_exchange_strong(__e, __i, __m,
336 __cmpexch_failure_order(__m)); }
339 compare_exchange_strong(_Tp& __e, _Tp __i,
340 memory_order __m = memory_order_seq_cst)
volatile noexcept
341 {
return compare_exchange_strong(__e, __i, __m,
342 __cmpexch_failure_order(__m)); }
347 template<
typename _Tp>
350 typedef _Tp* __pointer_type;
354 atomic() noexcept =
default;
355 ~
atomic() noexcept =
default;
360 constexpr
atomic(__pointer_type __p) noexcept : _M_b(__p) { }
362 operator __pointer_type()
const noexcept
363 {
return __pointer_type(_M_b); }
365 operator __pointer_type()
const volatile noexcept
366 {
return __pointer_type(_M_b); }
369 operator=(__pointer_type __p) noexcept
370 {
return _M_b.operator=(__p); }
373 operator=(__pointer_type __p)
volatile noexcept
374 {
return _M_b.operator=(__p); }
377 operator++(
int) noexcept
381 operator++(
int)
volatile noexcept
385 operator--(
int) noexcept
389 operator--(
int)
volatile noexcept
393 operator++() noexcept
397 operator++()
volatile noexcept
401 operator--() noexcept
405 operator--()
volatile noexcept
409 operator+=(ptrdiff_t __d) noexcept
410 {
return _M_b.operator+=(__d); }
413 operator+=(ptrdiff_t __d)
volatile noexcept
414 {
return _M_b.operator+=(__d); }
417 operator-=(ptrdiff_t __d) noexcept
418 {
return _M_b.operator-=(__d); }
421 operator-=(ptrdiff_t __d)
volatile noexcept
422 {
return _M_b.operator-=(__d); }
425 is_lock_free()
const noexcept
426 {
return _M_b.is_lock_free(); }
429 is_lock_free()
const volatile noexcept
430 {
return _M_b.is_lock_free(); }
432 #if __cplusplus > 201402L 433 static constexpr
bool is_always_lock_free = ATOMIC_POINTER_LOCK_FREE == 2;
437 store(__pointer_type __p,
439 {
return _M_b.store(__p, __m); }
442 store(__pointer_type __p,
443 memory_order __m = memory_order_seq_cst)
volatile noexcept
444 {
return _M_b.store(__p, __m); }
447 load(
memory_order __m = memory_order_seq_cst)
const noexcept
448 {
return _M_b.load(__m); }
451 load(
memory_order __m = memory_order_seq_cst)
const volatile noexcept
452 {
return _M_b.load(__m); }
457 {
return _M_b.exchange(__p, __m); }
461 memory_order __m = memory_order_seq_cst)
volatile noexcept
462 {
return _M_b.exchange(__p, __m); }
465 compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
467 {
return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
470 compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
473 {
return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
476 compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
479 return compare_exchange_weak(__p1, __p2, __m,
480 __cmpexch_failure_order(__m));
484 compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
485 memory_order __m = memory_order_seq_cst)
volatile noexcept
487 return compare_exchange_weak(__p1, __p2, __m,
488 __cmpexch_failure_order(__m));
492 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
494 {
return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
497 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
500 {
return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
503 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
506 return _M_b.compare_exchange_strong(__p1, __p2, __m,
507 __cmpexch_failure_order(__m));
511 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
512 memory_order __m = memory_order_seq_cst)
volatile noexcept
514 return _M_b.compare_exchange_strong(__p1, __p2, __m,
515 __cmpexch_failure_order(__m));
519 fetch_add(ptrdiff_t __d,
521 {
return _M_b.fetch_add(__d, __m); }
524 fetch_add(ptrdiff_t __d,
525 memory_order __m = memory_order_seq_cst)
volatile noexcept
526 {
return _M_b.fetch_add(__d, __m); }
529 fetch_sub(ptrdiff_t __d,
531 {
return _M_b.fetch_sub(__d, __m); }
534 fetch_sub(ptrdiff_t __d,
535 memory_order __m = memory_order_seq_cst)
volatile noexcept
536 {
return _M_b.fetch_sub(__d, __m); }
544 typedef char __integral_type;
547 atomic() noexcept =
default;
548 ~
atomic() noexcept =
default;
553 constexpr
atomic(__integral_type __i) noexcept : __base_type(__i) { }
555 using __base_type::operator __integral_type;
556 using __base_type::operator=;
558 #if __cplusplus > 201402L 559 static constexpr
bool is_always_lock_free = ATOMIC_CHAR_LOCK_FREE == 2;
567 typedef signed char __integral_type;
570 atomic() noexcept=
default;
571 ~
atomic() noexcept =
default;
576 constexpr
atomic(__integral_type __i) noexcept : __base_type(__i) { }
578 using __base_type::operator __integral_type;
579 using __base_type::operator=;
581 #if __cplusplus > 201402L 582 static constexpr
bool is_always_lock_free = ATOMIC_CHAR_LOCK_FREE == 2;
590 typedef unsigned char __integral_type;
593 atomic() noexcept=
default;
594 ~
atomic() noexcept =
default;
599 constexpr
atomic(__integral_type __i) noexcept : __base_type(__i) { }
601 using __base_type::operator __integral_type;
602 using __base_type::operator=;
604 #if __cplusplus > 201402L 605 static constexpr
bool is_always_lock_free = ATOMIC_CHAR_LOCK_FREE == 2;
613 typedef short __integral_type;
616 atomic() noexcept =
default;
617 ~
atomic() noexcept =
default;
622 constexpr
atomic(__integral_type __i) noexcept : __base_type(__i) { }
624 using __base_type::operator __integral_type;
625 using __base_type::operator=;
627 #if __cplusplus > 201402L 628 static constexpr
bool is_always_lock_free = ATOMIC_SHORT_LOCK_FREE == 2;
636 typedef unsigned short __integral_type;
639 atomic() noexcept =
default;
640 ~
atomic() noexcept =
default;
645 constexpr
atomic(__integral_type __i) noexcept : __base_type(__i) { }
647 using __base_type::operator __integral_type;
648 using __base_type::operator=;
650 #if __cplusplus > 201402L 651 static constexpr
bool is_always_lock_free = ATOMIC_SHORT_LOCK_FREE == 2;
659 typedef int __integral_type;
662 atomic() noexcept =
default;
663 ~
atomic() noexcept =
default;
668 constexpr
atomic(__integral_type __i) noexcept : __base_type(__i) { }
670 using __base_type::operator __integral_type;
671 using __base_type::operator=;
673 #if __cplusplus > 201402L 674 static constexpr
bool is_always_lock_free = ATOMIC_INT_LOCK_FREE == 2;
682 typedef unsigned int __integral_type;
685 atomic() noexcept =
default;
686 ~
atomic() noexcept =
default;
691 constexpr
atomic(__integral_type __i) noexcept : __base_type(__i) { }
693 using __base_type::operator __integral_type;
694 using __base_type::operator=;
696 #if __cplusplus > 201402L 697 static constexpr
bool is_always_lock_free = ATOMIC_INT_LOCK_FREE == 2;
705 typedef long __integral_type;
708 atomic() noexcept =
default;
709 ~
atomic() noexcept =
default;
714 constexpr
atomic(__integral_type __i) noexcept : __base_type(__i) { }
716 using __base_type::operator __integral_type;
717 using __base_type::operator=;
719 #if __cplusplus > 201402L 720 static constexpr
bool is_always_lock_free = ATOMIC_LONG_LOCK_FREE == 2;
728 typedef unsigned long __integral_type;
731 atomic() noexcept =
default;
732 ~
atomic() noexcept =
default;
737 constexpr
atomic(__integral_type __i) noexcept : __base_type(__i) { }
739 using __base_type::operator __integral_type;
740 using __base_type::operator=;
742 #if __cplusplus > 201402L 743 static constexpr
bool is_always_lock_free = ATOMIC_LONG_LOCK_FREE == 2;
751 typedef long long __integral_type;
754 atomic() noexcept =
default;
755 ~
atomic() noexcept =
default;
760 constexpr
atomic(__integral_type __i) noexcept : __base_type(__i) { }
762 using __base_type::operator __integral_type;
763 using __base_type::operator=;
765 #if __cplusplus > 201402L 766 static constexpr
bool is_always_lock_free = ATOMIC_LLONG_LOCK_FREE == 2;
774 typedef unsigned long long __integral_type;
777 atomic() noexcept =
default;
778 ~
atomic() noexcept =
default;
783 constexpr
atomic(__integral_type __i) noexcept : __base_type(__i) { }
785 using __base_type::operator __integral_type;
786 using __base_type::operator=;
788 #if __cplusplus > 201402L 789 static constexpr
bool is_always_lock_free = ATOMIC_LLONG_LOCK_FREE == 2;
797 typedef wchar_t __integral_type;
800 atomic() noexcept =
default;
801 ~
atomic() noexcept =
default;
806 constexpr
atomic(__integral_type __i) noexcept : __base_type(__i) { }
808 using __base_type::operator __integral_type;
809 using __base_type::operator=;
811 #if __cplusplus > 201402L 812 static constexpr
bool is_always_lock_free = ATOMIC_WCHAR_T_LOCK_FREE == 2;
820 typedef char16_t __integral_type;
823 atomic() noexcept =
default;
824 ~
atomic() noexcept =
default;
829 constexpr
atomic(__integral_type __i) noexcept : __base_type(__i) { }
831 using __base_type::operator __integral_type;
832 using __base_type::operator=;
834 #if __cplusplus > 201402L 835 static constexpr
bool is_always_lock_free = ATOMIC_CHAR16_T_LOCK_FREE == 2;
843 typedef char32_t __integral_type;
846 atomic() noexcept =
default;
847 ~
atomic() noexcept =
default;
852 constexpr
atomic(__integral_type __i) noexcept : __base_type(__i) { }
854 using __base_type::operator __integral_type;
855 using __base_type::operator=;
857 #if __cplusplus > 201402L 858 static constexpr
bool is_always_lock_free = ATOMIC_CHAR32_T_LOCK_FREE == 2;
1008 atomic_flag_test_and_set_explicit(
atomic_flag* __a,
1010 {
return __a->test_and_set(__m); }
1013 atomic_flag_test_and_set_explicit(
volatile atomic_flag* __a,
1015 {
return __a->test_and_set(__m); }
1019 { __a->clear(__m); }
1022 atomic_flag_clear_explicit(
volatile atomic_flag* __a,
1024 { __a->clear(__m); }
1027 atomic_flag_test_and_set(
atomic_flag* __a) noexcept
1028 {
return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }
1031 atomic_flag_test_and_set(
volatile atomic_flag* __a) noexcept
1032 {
return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }
1036 { atomic_flag_clear_explicit(__a, memory_order_seq_cst); }
1039 atomic_flag_clear(
volatile atomic_flag* __a) noexcept
1040 { atomic_flag_clear_explicit(__a, memory_order_seq_cst); }
1044 template<
typename _ITp>
1047 {
return __a->is_lock_free(); }
1049 template<
typename _ITp>
1051 atomic_is_lock_free(
const volatile atomic<_ITp>* __a) noexcept
1052 {
return __a->is_lock_free(); }
1054 template<
typename _ITp>
1057 { __a->store(__i, memory_order_relaxed); }
1059 template<
typename _ITp>
1061 atomic_init(
volatile atomic<_ITp>* __a, _ITp __i) noexcept
1062 { __a->store(__i, memory_order_relaxed); }
1064 template<
typename _ITp>
1068 { __a->store(__i, __m); }
1070 template<
typename _ITp>
1072 atomic_store_explicit(
volatile atomic<_ITp>* __a, _ITp __i,
1074 { __a->store(__i, __m); }
1076 template<
typename _ITp>
1079 {
return __a->load(__m); }
1081 template<
typename _ITp>
1085 {
return __a->load(__m); }
1087 template<
typename _ITp>
1091 {
return __a->exchange(__i, __m); }
1093 template<
typename _ITp>
1095 atomic_exchange_explicit(
volatile atomic<_ITp>* __a, _ITp __i,
1097 {
return __a->exchange(__i, __m); }
1099 template<
typename _ITp>
1101 atomic_compare_exchange_weak_explicit(
atomic<_ITp>* __a,
1102 _ITp* __i1, _ITp __i2,
1105 {
return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
1107 template<
typename _ITp>
1109 atomic_compare_exchange_weak_explicit(
volatile atomic<_ITp>* __a,
1110 _ITp* __i1, _ITp __i2,
1113 {
return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
1115 template<
typename _ITp>
1117 atomic_compare_exchange_strong_explicit(
atomic<_ITp>* __a,
1118 _ITp* __i1, _ITp __i2,
1121 {
return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
1123 template<
typename _ITp>
1125 atomic_compare_exchange_strong_explicit(
volatile atomic<_ITp>* __a,
1126 _ITp* __i1, _ITp __i2,
1129 {
return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
1132 template<
typename _ITp>
1135 { atomic_store_explicit(__a, __i, memory_order_seq_cst); }
1137 template<
typename _ITp>
1139 atomic_store(
volatile atomic<_ITp>* __a, _ITp __i) noexcept
1140 { atomic_store_explicit(__a, __i, memory_order_seq_cst); }
1142 template<
typename _ITp>
1145 {
return atomic_load_explicit(__a, memory_order_seq_cst); }
1147 template<
typename _ITp>
1150 {
return atomic_load_explicit(__a, memory_order_seq_cst); }
1152 template<
typename _ITp>
1155 {
return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
1157 template<
typename _ITp>
1159 atomic_exchange(
volatile atomic<_ITp>* __a, _ITp __i) noexcept
1160 {
return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
1162 template<
typename _ITp>
1165 _ITp* __i1, _ITp __i2) noexcept
1167 return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
1168 memory_order_seq_cst,
1169 memory_order_seq_cst);
1172 template<
typename _ITp>
1174 atomic_compare_exchange_weak(
volatile atomic<_ITp>* __a,
1175 _ITp* __i1, _ITp __i2) noexcept
1177 return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
1178 memory_order_seq_cst,
1179 memory_order_seq_cst);
1182 template<
typename _ITp>
1185 _ITp* __i1, _ITp __i2) noexcept
1187 return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
1188 memory_order_seq_cst,
1189 memory_order_seq_cst);
1192 template<
typename _ITp>
1194 atomic_compare_exchange_strong(
volatile atomic<_ITp>* __a,
1195 _ITp* __i1, _ITp __i2) noexcept
1197 return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
1198 memory_order_seq_cst,
1199 memory_order_seq_cst);
1206 template<
typename _ITp>
1210 {
return __a->fetch_add(__i, __m); }
1212 template<
typename _ITp>
1216 {
return __a->fetch_add(__i, __m); }
1218 template<
typename _ITp>
1222 {
return __a->fetch_sub(__i, __m); }
1224 template<
typename _ITp>
1228 {
return __a->fetch_sub(__i, __m); }
1230 template<
typename _ITp>
1234 {
return __a->fetch_and(__i, __m); }
1236 template<
typename _ITp>
1240 {
return __a->fetch_and(__i, __m); }
1242 template<
typename _ITp>
1246 {
return __a->fetch_or(__i, __m); }
1248 template<
typename _ITp>
1252 {
return __a->fetch_or(__i, __m); }
1254 template<
typename _ITp>
1258 {
return __a->fetch_xor(__i, __m); }
1260 template<
typename _ITp>
1264 {
return __a->fetch_xor(__i, __m); }
1266 template<
typename _ITp>
1269 {
return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
1271 template<
typename _ITp>
1274 {
return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
1276 template<
typename _ITp>
1279 {
return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
1281 template<
typename _ITp>
1284 {
return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
1286 template<
typename _ITp>
1289 {
return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }
1291 template<
typename _ITp>
1294 {
return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }
1296 template<
typename _ITp>
1299 {
return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }
1301 template<
typename _ITp>
1304 {
return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }
1306 template<
typename _ITp>
1309 {
return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
1311 template<
typename _ITp>
1314 {
return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
1318 template<
typename _ITp>
1320 atomic_fetch_add_explicit(
atomic<_ITp*>* __a, ptrdiff_t __d,
1322 {
return __a->fetch_add(__d, __m); }
1324 template<
typename _ITp>
1326 atomic_fetch_add_explicit(
volatile atomic<_ITp*>* __a, ptrdiff_t __d,
1328 {
return __a->fetch_add(__d, __m); }
1330 template<
typename _ITp>
1332 atomic_fetch_add(
volatile atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
1333 {
return __a->fetch_add(__d); }
1335 template<
typename _ITp>
1337 atomic_fetch_add(
atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
1338 {
return __a->fetch_add(__d); }
1340 template<
typename _ITp>
1344 {
return __a->fetch_sub(__d, __m); }
1346 template<
typename _ITp>
1348 atomic_fetch_sub_explicit(
atomic<_ITp*>* __a, ptrdiff_t __d,
1350 {
return __a->fetch_sub(__d, __m); }
1352 template<
typename _ITp>
1354 atomic_fetch_sub(
volatile atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
1355 {
return __a->fetch_sub(__d); }
1357 template<
typename _ITp>
1359 atomic_fetch_sub(
atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
1360 {
return __a->fetch_sub(__d); }
1363 _GLIBCXX_END_NAMESPACE_VERSION
1368 #endif // _GLIBCXX_ATOMIC _Tp exchange(_Tp &__obj, _Up &&__new_val)
Assign __new_val to __obj and return its previous value.
Explicit specialization for unsigned short.
atomic< unsigned short > atomic_ushort
atomic_ushort
Explicit specialization for unsigned long.
atomic< short > atomic_short
atomic_short
atomic< int_least32_t > atomic_int_least32_t
atomic_int_least32_t
atomic< int_least8_t > atomic_int_least8_t
atomic_int_least8_t
atomic< unsigned long long > atomic_ullong
atomic_ullong
Explicit specialization for int.
atomic< uint8_t > atomic_uint8_t
atomic_uint8_t
atomic< long > atomic_long
atomic_long
Explicit specialization for unsigned long long.
Explicit specialization for unsigned int.
atomic< int32_t > atomic_int32_t
atomic_int32_t
atomic< uint_fast8_t > atomic_uint_fast8_t
atomic_uint_fast8_t
atomic< char16_t > atomic_char16_t
atomic_char16_t
Explicit specialization for short.
atomic< uint_fast16_t > atomic_uint_fast16_t
atomic_uint_fast16_t
atomic< uint_least16_t > atomic_uint_least16_t
atomic_uint_least16_t
atomic< long long > atomic_llong
atomic_llong
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< wchar_t > atomic_wchar_t
atomic_wchar_t
atomic< uint32_t > atomic_uint32_t
atomic_uint32_t
Generic atomic type, primary class template.
ISO C++ entities toplevel namespace is std.
atomic< ptrdiff_t > atomic_ptrdiff_t
atomic_ptrdiff_t
Explicit specialization for char32_t.
atomic< int > atomic_int
atomic_int
Explicit specialization for char.
atomic< int16_t > atomic_int16_t
atomic_int16_t
constexpr _Tp * __addressof(_Tp &__r) noexcept
Same as C++11 std::addressof.
Explicit specialization for long long.
atomic< int64_t > atomic_int64_t
atomic_int64_t
atomic< int_least64_t > atomic_int_least64_t
atomic_int_least64_t
atomic< bool > atomic_bool
atomic_bool
atomic< char > atomic_char
atomic_char
Explicit specialization for unsigned char.
atomic< uint_fast32_t > atomic_uint_fast32_t
atomic_uint_fast32_t
atomic< int8_t > atomic_int8_t
atomic_int8_t
atomic< uint_fast64_t > atomic_uint_fast64_t
atomic_uint_fast64_t
atomic< uint_least64_t > atomic_uint_least64_t
atomic_uint_least64_t
atomic< int_least16_t > atomic_int_least16_t
atomic_int_least16_t
Explicit specialization for wchar_t.
atomic< uint16_t > atomic_uint16_t
atomic_uint16_t
Explicit specialization for char16_t.
atomic< intptr_t > atomic_intptr_t
atomic_intptr_t
atomic< size_t > atomic_size_t
atomic_size_t
atomic< uint_least8_t > atomic_uint_least8_t
atomic_uint_least8_t
atomic< signed char > atomic_schar
atomic_schar
atomic< intmax_t > atomic_intmax_t
atomic_intmax_t
atomic< unsigned char > atomic_uchar
atomic_uchar
#define ATOMIC_BOOL_LOCK_FREE
atomic< uintmax_t > atomic_uintmax_t
atomic_uintmax_t
Explicit specialization for long.
atomic< char32_t > atomic_char32_t
atomic_char32_t
atomic< uintptr_t > atomic_uintptr_t
atomic_uintptr_t
atomic< unsigned int > atomic_uint
atomic_uint
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< unsigned long > atomic_ulong
atomic_ulong
atomic< uint64_t > atomic_uint64_t
atomic_uint64_t
atomic< int_fast16_t > atomic_int_fast16_t
atomic_int_fast16_t
Explicit specialization for signed char.