32#ifndef _GLIBCXX_ATOMIC
33#define _GLIBCXX_ATOMIC 1
35#pragma GCC system_header
37#if __cplusplus < 201103L
41#define __glibcxx_want_atomic_is_always_lock_free
42#define __glibcxx_want_atomic_flag_test
43#define __glibcxx_want_atomic_float
44#define __glibcxx_want_atomic_ref
45#define __glibcxx_want_atomic_lock_free_type_aliases
46#define __glibcxx_want_atomic_value_initialization
47#define __glibcxx_want_atomic_wait
52namespace std _GLIBCXX_VISIBILITY(default)
54_GLIBCXX_BEGIN_NAMESPACE_VERSION
61 template<
typename _Tp>
69 using value_type = bool;
72 __atomic_base<bool> _M_base;
75 atomic()
noexcept =
default;
81 constexpr atomic(
bool __i) noexcept : _M_base(__i) { }
84 operator=(
bool __i)
noexcept
85 {
return _M_base.operator=(__i); }
88 operator=(
bool __i)
volatile noexcept
89 {
return _M_base.operator=(__i); }
91 operator bool()
const noexcept
92 {
return _M_base.load(); }
94 operator bool()
const volatile noexcept
95 {
return _M_base.load(); }
98 is_lock_free()
const noexcept {
return _M_base.is_lock_free(); }
101 is_lock_free()
const volatile noexcept {
return _M_base.is_lock_free(); }
103#ifdef __cpp_lib_atomic_is_always_lock_free
108 store(
bool __i,
memory_order __m = memory_order_seq_cst)
noexcept
109 { _M_base.store(__i, __m); }
112 store(
bool __i,
memory_order __m = memory_order_seq_cst)
volatile noexcept
113 { _M_base.store(__i, __m); }
116 load(
memory_order __m = memory_order_seq_cst)
const noexcept
117 {
return _M_base.load(__m); }
120 load(
memory_order __m = memory_order_seq_cst)
const volatile noexcept
121 {
return _M_base.load(__m); }
124 exchange(
bool __i,
memory_order __m = memory_order_seq_cst)
noexcept
125 {
return _M_base.exchange(__i, __m); }
129 memory_order __m = memory_order_seq_cst)
volatile noexcept
130 {
return _M_base.exchange(__i, __m); }
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,
memory_order __m1,
140 {
return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); }
143 compare_exchange_weak(
bool& __i1,
bool __i2,
145 {
return _M_base.compare_exchange_weak(__i1, __i2, __m); }
148 compare_exchange_weak(
bool& __i1,
bool __i2,
149 memory_order __m = memory_order_seq_cst)
volatile noexcept
150 {
return _M_base.compare_exchange_weak(__i1, __i2, __m); }
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,
memory_order __m1,
160 {
return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); }
163 compare_exchange_strong(
bool& __i1,
bool __i2,
165 {
return _M_base.compare_exchange_strong(__i1, __i2, __m); }
168 compare_exchange_strong(
bool& __i1,
bool __i2,
169 memory_order __m = memory_order_seq_cst)
volatile noexcept
170 {
return _M_base.compare_exchange_strong(__i1, __i2, __m); }
172#if __cpp_lib_atomic_wait
174 wait(
bool __old,
memory_order __m = memory_order_seq_cst)
const noexcept
175 { _M_base.wait(__old, __m); }
180 notify_one()
noexcept
181 { _M_base.notify_one(); }
184 notify_all()
noexcept
185 { _M_base.notify_all(); }
190#if __cpp_lib_atomic_value_initialization
191# define _GLIBCXX20_INIT(I) = I
193# define _GLIBCXX20_INIT(I)
202 template<
typename _Tp>
205 using value_type = _Tp;
209 static constexpr int _S_min_alignment
210 = (
sizeof(_Tp) & (
sizeof(_Tp) - 1)) ||
sizeof(_Tp) > 16
213 static constexpr int _S_alignment
214 = _S_min_alignment >
alignof(_Tp) ? _S_min_alignment :
alignof(_Tp);
216 alignas(_S_alignment) _Tp _M_i _GLIBCXX20_INIT(_Tp());
218 static_assert(__is_trivially_copyable(_Tp),
219 "std::atomic requires a trivially copyable type");
221 static_assert(
sizeof(_Tp) > 0,
222 "Incomplete or zero-sized types are not supported");
224#if __cplusplus > 201703L
225 static_assert(is_copy_constructible_v<_Tp>);
226 static_assert(is_move_constructible_v<_Tp>);
227 static_assert(is_copy_assignable_v<_Tp>);
228 static_assert(is_move_assignable_v<_Tp>);
238 constexpr atomic(_Tp __i) noexcept : _M_i(__i)
240#if __cplusplus >= 201402L && __has_builtin(__builtin_clear_padding)
241 if _GLIBCXX17_CONSTEXPR (__atomic_impl::__maybe_has_padding<_Tp>())
246 operator _Tp()
const noexcept
249 operator _Tp()
const volatile noexcept
253 operator=(_Tp __i)
noexcept
254 { store(__i);
return __i; }
257 operator=(_Tp __i)
volatile noexcept
258 { store(__i);
return __i; }
261 is_lock_free()
const noexcept
264 return __atomic_is_lock_free(
sizeof(_M_i),
265 reinterpret_cast<void *
>(-_S_alignment));
269 is_lock_free()
const volatile noexcept
272 return __atomic_is_lock_free(
sizeof(_M_i),
273 reinterpret_cast<void *
>(-_S_alignment));
276#ifdef __cpp_lib_atomic_is_always_lock_free
277 static constexpr bool is_always_lock_free
278 = __atomic_always_lock_free(
sizeof(_M_i), 0);
282 store(_Tp __i,
memory_order __m = memory_order_seq_cst)
noexcept
285 __atomic_impl::__clear_padding(__i),
290 store(_Tp __i,
memory_order __m = memory_order_seq_cst)
volatile noexcept
293 __atomic_impl::__clear_padding(__i),
298 load(
memory_order __m = memory_order_seq_cst)
const noexcept
300 alignas(_Tp)
unsigned char __buf[
sizeof(_Tp)];
301 _Tp* __ptr =
reinterpret_cast<_Tp*
>(__buf);
307 load(
memory_order __m = memory_order_seq_cst)
const volatile noexcept
309 alignas(_Tp)
unsigned char __buf[
sizeof(_Tp)];
310 _Tp* __ptr =
reinterpret_cast<_Tp*
>(__buf);
316 exchange(_Tp __i,
memory_order __m = memory_order_seq_cst)
noexcept
318 alignas(_Tp)
unsigned char __buf[
sizeof(_Tp)];
319 _Tp* __ptr =
reinterpret_cast<_Tp*
>(__buf);
321 __atomic_impl::__clear_padding(__i),
328 memory_order __m = memory_order_seq_cst)
volatile noexcept
330 alignas(_Tp)
unsigned char __buf[
sizeof(_Tp)];
331 _Tp* __ptr =
reinterpret_cast<_Tp*
>(__buf);
333 __atomic_impl::__clear_padding(__i),
339 compare_exchange_weak(_Tp& __e, _Tp __i,
memory_order __s,
342 return __atomic_impl::__compare_exchange(_M_i, __e, __i,
true,
347 compare_exchange_weak(_Tp& __e, _Tp __i,
memory_order __s,
350 return __atomic_impl::__compare_exchange(_M_i, __e, __i,
true,
355 compare_exchange_weak(_Tp& __e, _Tp __i,
357 {
return compare_exchange_weak(__e, __i, __m,
358 __cmpexch_failure_order(__m)); }
361 compare_exchange_weak(_Tp& __e, _Tp __i,
362 memory_order __m = memory_order_seq_cst)
volatile noexcept
363 {
return compare_exchange_weak(__e, __i, __m,
364 __cmpexch_failure_order(__m)); }
367 compare_exchange_strong(_Tp& __e, _Tp __i,
memory_order __s,
370 return __atomic_impl::__compare_exchange(_M_i, __e, __i,
false,
375 compare_exchange_strong(_Tp& __e, _Tp __i,
memory_order __s,
378 return __atomic_impl::__compare_exchange(_M_i, __e, __i,
false,
383 compare_exchange_strong(_Tp& __e, _Tp __i,
385 {
return compare_exchange_strong(__e, __i, __m,
386 __cmpexch_failure_order(__m)); }
389 compare_exchange_strong(_Tp& __e, _Tp __i,
390 memory_order __m = memory_order_seq_cst)
volatile noexcept
391 {
return compare_exchange_strong(__e, __i, __m,
392 __cmpexch_failure_order(__m)); }
394#if __cpp_lib_atomic_wait
396 wait(_Tp __old,
memory_order __m = memory_order_seq_cst)
const noexcept
398 std::__atomic_wait_address_v(&_M_i, __old,
399 [__m,
this] {
return this->load(__m); });
405 notify_one()
noexcept
406 { std::__atomic_notify_address(&_M_i,
false); }
409 notify_all()
noexcept
410 { std::__atomic_notify_address(&_M_i,
true); }
414#undef _GLIBCXX20_INIT
417 template<
typename _Tp>
420 using value_type = _Tp*;
421 using difference_type = ptrdiff_t;
423 typedef _Tp* __pointer_type;
424 typedef __atomic_base<_Tp*> __base_type;
427 atomic()
noexcept =
default;
433 constexpr atomic(__pointer_type __p) noexcept : _M_b(__p) { }
435 operator __pointer_type()
const noexcept
436 {
return __pointer_type(_M_b); }
438 operator __pointer_type()
const volatile noexcept
439 {
return __pointer_type(_M_b); }
442 operator=(__pointer_type __p)
noexcept
443 {
return _M_b.operator=(__p); }
446 operator=(__pointer_type __p)
volatile noexcept
447 {
return _M_b.operator=(__p); }
450 operator++(
int)
noexcept
452#if __cplusplus >= 201703L
459 operator++(
int)
volatile noexcept
461#if __cplusplus >= 201703L
468 operator--(
int)
noexcept
470#if __cplusplus >= 201703L
477 operator--(
int)
volatile noexcept
479#if __cplusplus >= 201703L
486 operator++()
noexcept
488#if __cplusplus >= 201703L
495 operator++()
volatile noexcept
497#if __cplusplus >= 201703L
504 operator--()
noexcept
506#if __cplusplus >= 201703L
513 operator--()
volatile noexcept
515#if __cplusplus >= 201703L
522 operator+=(ptrdiff_t __d)
noexcept
524#if __cplusplus >= 201703L
527 return _M_b.operator+=(__d);
531 operator+=(ptrdiff_t __d)
volatile noexcept
533#if __cplusplus >= 201703L
536 return _M_b.operator+=(__d);
540 operator-=(ptrdiff_t __d)
noexcept
542#if __cplusplus >= 201703L
545 return _M_b.operator-=(__d);
549 operator-=(ptrdiff_t __d)
volatile noexcept
551#if __cplusplus >= 201703L
554 return _M_b.operator-=(__d);
558 is_lock_free()
const noexcept
559 {
return _M_b.is_lock_free(); }
562 is_lock_free()
const volatile noexcept
563 {
return _M_b.is_lock_free(); }
565#ifdef __cpp_lib_atomic_is_always_lock_free
566 static constexpr bool is_always_lock_free
567 = ATOMIC_POINTER_LOCK_FREE == 2;
571 store(__pointer_type __p,
573 {
return _M_b.store(__p, __m); }
576 store(__pointer_type __p,
577 memory_order __m = memory_order_seq_cst)
volatile noexcept
578 {
return _M_b.store(__p, __m); }
581 load(
memory_order __m = memory_order_seq_cst)
const noexcept
582 {
return _M_b.load(__m); }
585 load(
memory_order __m = memory_order_seq_cst)
const volatile noexcept
586 {
return _M_b.load(__m); }
589 exchange(__pointer_type __p,
591 {
return _M_b.exchange(__p, __m); }
594 exchange(__pointer_type __p,
595 memory_order __m = memory_order_seq_cst)
volatile noexcept
596 {
return _M_b.exchange(__p, __m); }
599 compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
601 {
return _M_b.compare_exchange_weak(__p1, __p2, __m1, __m2); }
604 compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
607 {
return _M_b.compare_exchange_weak(__p1, __p2, __m1, __m2); }
610 compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
613 return compare_exchange_weak(__p1, __p2, __m,
614 __cmpexch_failure_order(__m));
618 compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
619 memory_order __m = memory_order_seq_cst)
volatile noexcept
621 return compare_exchange_weak(__p1, __p2, __m,
622 __cmpexch_failure_order(__m));
626 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
628 {
return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
631 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
634 {
return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
637 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
640 return _M_b.compare_exchange_strong(__p1, __p2, __m,
641 __cmpexch_failure_order(__m));
645 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
646 memory_order __m = memory_order_seq_cst)
volatile noexcept
648 return _M_b.compare_exchange_strong(__p1, __p2, __m,
649 __cmpexch_failure_order(__m));
652#if __cpp_lib_atomic_wait
654 wait(__pointer_type __old,
memory_order __m = memory_order_seq_cst)
const noexcept
655 { _M_b.wait(__old, __m); }
660 notify_one()
noexcept
661 { _M_b.notify_one(); }
664 notify_all()
noexcept
665 { _M_b.notify_all(); }
669 fetch_add(ptrdiff_t __d,
672#if __cplusplus >= 201703L
675 return _M_b.fetch_add(__d, __m);
679 fetch_add(ptrdiff_t __d,
680 memory_order __m = memory_order_seq_cst)
volatile noexcept
682#if __cplusplus >= 201703L
685 return _M_b.fetch_add(__d, __m);
689 fetch_sub(ptrdiff_t __d,
692#if __cplusplus >= 201703L
695 return _M_b.fetch_sub(__d, __m);
699 fetch_sub(ptrdiff_t __d,
700 memory_order __m = memory_order_seq_cst)
volatile noexcept
702#if __cplusplus >= 201703L
705 return _M_b.fetch_sub(__d, __m);
712 struct atomic<char> : __atomic_base<char>
714 typedef char __integral_type;
715 typedef __atomic_base<char> __base_type;
717 atomic()
noexcept =
default;
723 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
725 using __base_type::operator __integral_type;
726 using __base_type::operator=;
728#ifdef __cpp_lib_atomic_is_always_lock_free
729 static constexpr bool is_always_lock_free = ATOMIC_CHAR_LOCK_FREE == 2;
735 struct atomic<signed char> : __atomic_base<signed char>
737 typedef signed char __integral_type;
738 typedef __atomic_base<signed char> __base_type;
740 atomic()
noexcept=
default;
746 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
748 using __base_type::operator __integral_type;
749 using __base_type::operator=;
751#ifdef __cpp_lib_atomic_is_always_lock_free
752 static constexpr bool is_always_lock_free = ATOMIC_CHAR_LOCK_FREE == 2;
758 struct atomic<unsigned char> : __atomic_base<unsigned char>
760 typedef unsigned char __integral_type;
761 typedef __atomic_base<unsigned char> __base_type;
763 atomic()
noexcept=
default;
769 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
771 using __base_type::operator __integral_type;
772 using __base_type::operator=;
774#ifdef __cpp_lib_atomic_is_always_lock_free
775 static constexpr bool is_always_lock_free = ATOMIC_CHAR_LOCK_FREE == 2;
781 struct atomic<short> : __atomic_base<short>
783 typedef short __integral_type;
784 typedef __atomic_base<short> __base_type;
786 atomic()
noexcept =
default;
792 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
794 using __base_type::operator __integral_type;
795 using __base_type::operator=;
797#ifdef __cpp_lib_atomic_is_always_lock_free
798 static constexpr bool is_always_lock_free = ATOMIC_SHORT_LOCK_FREE == 2;
804 struct atomic<unsigned short> : __atomic_base<unsigned short>
806 typedef unsigned short __integral_type;
807 typedef __atomic_base<unsigned short> __base_type;
809 atomic()
noexcept =
default;
815 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
817 using __base_type::operator __integral_type;
818 using __base_type::operator=;
820#ifdef __cpp_lib_atomic_is_always_lock_free
821 static constexpr bool is_always_lock_free = ATOMIC_SHORT_LOCK_FREE == 2;
829 typedef int __integral_type;
830 typedef __atomic_base<int> __base_type;
832 atomic()
noexcept =
default;
838 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
840 using __base_type::operator __integral_type;
841 using __base_type::operator=;
843#ifdef __cpp_lib_atomic_is_always_lock_free
844 static constexpr bool is_always_lock_free = ATOMIC_INT_LOCK_FREE == 2;
850 struct atomic<unsigned int> : __atomic_base<unsigned int>
852 typedef unsigned int __integral_type;
853 typedef __atomic_base<unsigned int> __base_type;
855 atomic()
noexcept =
default;
861 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
863 using __base_type::operator __integral_type;
864 using __base_type::operator=;
866#ifdef __cpp_lib_atomic_is_always_lock_free
867 static constexpr bool is_always_lock_free = ATOMIC_INT_LOCK_FREE == 2;
873 struct atomic<long> : __atomic_base<long>
875 typedef long __integral_type;
876 typedef __atomic_base<long> __base_type;
878 atomic()
noexcept =
default;
884 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
886 using __base_type::operator __integral_type;
887 using __base_type::operator=;
889#ifdef __cpp_lib_atomic_is_always_lock_free
890 static constexpr bool is_always_lock_free = ATOMIC_LONG_LOCK_FREE == 2;
896 struct atomic<unsigned long> : __atomic_base<unsigned long>
898 typedef unsigned long __integral_type;
899 typedef __atomic_base<unsigned long> __base_type;
901 atomic()
noexcept =
default;
907 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
909 using __base_type::operator __integral_type;
910 using __base_type::operator=;
912#ifdef __cpp_lib_atomic_is_always_lock_free
913 static constexpr bool is_always_lock_free = ATOMIC_LONG_LOCK_FREE == 2;
919 struct atomic<long long> : __atomic_base<long long>
921 typedef long long __integral_type;
922 typedef __atomic_base<long long> __base_type;
924 atomic()
noexcept =
default;
930 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
932 using __base_type::operator __integral_type;
933 using __base_type::operator=;
935#ifdef __cpp_lib_atomic_is_always_lock_free
936 static constexpr bool is_always_lock_free = ATOMIC_LLONG_LOCK_FREE == 2;
942 struct atomic<unsigned long long> : __atomic_base<unsigned long long>
944 typedef unsigned long long __integral_type;
945 typedef __atomic_base<unsigned long long> __base_type;
947 atomic()
noexcept =
default;
953 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
955 using __base_type::operator __integral_type;
956 using __base_type::operator=;
958#ifdef __cpp_lib_atomic_is_always_lock_free
959 static constexpr bool is_always_lock_free = ATOMIC_LLONG_LOCK_FREE == 2;
965 struct atomic<wchar_t> : __atomic_base<wchar_t>
967 typedef wchar_t __integral_type;
968 typedef __atomic_base<wchar_t> __base_type;
970 atomic()
noexcept =
default;
976 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
978 using __base_type::operator __integral_type;
979 using __base_type::operator=;
981#ifdef __cpp_lib_atomic_is_always_lock_free
982 static constexpr bool is_always_lock_free = ATOMIC_WCHAR_T_LOCK_FREE == 2;
986#ifdef _GLIBCXX_USE_CHAR8_T
989 struct atomic<char8_t> : __atomic_base<char8_t>
991 typedef char8_t __integral_type;
992 typedef __atomic_base<char8_t> __base_type;
994 atomic() noexcept = default;
995 ~
atomic() noexcept = default;
1000 constexpr
atomic(__integral_type __i) noexcept : __base_type(__i) { }
1002 using __base_type::operator __integral_type;
1003 using __base_type::operator=;
1005#ifdef __cpp_lib_atomic_is_always_lock_free
1006 static constexpr bool is_always_lock_free
1007 = ATOMIC_CHAR8_T_LOCK_FREE == 2;
1014 struct atomic<char16_t> : __atomic_base<char16_t>
1016 typedef char16_t __integral_type;
1017 typedef __atomic_base<char16_t> __base_type;
1019 atomic()
noexcept =
default;
1025 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
1027 using __base_type::operator __integral_type;
1028 using __base_type::operator=;
1030#ifdef __cpp_lib_atomic_is_always_lock_free
1031 static constexpr bool is_always_lock_free
1032 = ATOMIC_CHAR16_T_LOCK_FREE == 2;
1038 struct atomic<char32_t> : __atomic_base<char32_t>
1040 typedef char32_t __integral_type;
1041 typedef __atomic_base<char32_t> __base_type;
1043 atomic()
noexcept =
default;
1049 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
1051 using __base_type::operator __integral_type;
1052 using __base_type::operator=;
1054#ifdef __cpp_lib_atomic_is_always_lock_free
1055 static constexpr bool is_always_lock_free
1056 = ATOMIC_CHAR32_T_LOCK_FREE == 2;
1100#ifdef _GLIBCXX_USE_CHAR8_T
1111#ifdef _GLIBCXX_USE_C99_STDINT
1210 atomic_flag_test_and_set_explicit(
atomic_flag* __a,
1212 {
return __a->test_and_set(__m); }
1215 atomic_flag_test_and_set_explicit(
volatile atomic_flag* __a,
1217 {
return __a->test_and_set(__m); }
1219#if __cpp_lib_atomic_flag_test
1221 atomic_flag_test(
const atomic_flag* __a)
noexcept
1222 {
return __a->test(); }
1225 atomic_flag_test(
const volatile atomic_flag* __a)
noexcept
1226 {
return __a->test(); }
1229 atomic_flag_test_explicit(
const atomic_flag* __a,
1231 {
return __a->test(__m); }
1234 atomic_flag_test_explicit(
const volatile atomic_flag* __a,
1236 {
return __a->test(__m); }
1240 atomic_flag_clear_explicit(atomic_flag* __a,
memory_order __m)
noexcept
1241 { __a->clear(__m); }
1244 atomic_flag_clear_explicit(
volatile atomic_flag* __a,
1246 { __a->clear(__m); }
1249 atomic_flag_test_and_set(atomic_flag* __a)
noexcept
1250 {
return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }
1253 atomic_flag_test_and_set(
volatile atomic_flag* __a)
noexcept
1254 {
return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }
1257 atomic_flag_clear(atomic_flag* __a)
noexcept
1258 { atomic_flag_clear_explicit(__a, memory_order_seq_cst); }
1261 atomic_flag_clear(
volatile atomic_flag* __a)
noexcept
1262 { atomic_flag_clear_explicit(__a, memory_order_seq_cst); }
1264#if __cpp_lib_atomic_wait
1266 atomic_flag_wait(atomic_flag* __a,
bool __old)
noexcept
1267 { __a->wait(__old); }
1270 atomic_flag_wait_explicit(atomic_flag* __a,
bool __old,
1272 { __a->wait(__old, __m); }
1275 atomic_flag_notify_one(atomic_flag* __a)
noexcept
1276 { __a->notify_one(); }
1279 atomic_flag_notify_all(atomic_flag* __a)
noexcept
1280 { __a->notify_all(); }
1286 template<
typename _Tp>
1287 using __atomic_val_t = __type_identity_t<_Tp>;
1288 template<
typename _Tp>
1289 using __atomic_diff_t =
typename atomic<_Tp>::difference_type;
1294 template<
typename _ITp>
1296 atomic_is_lock_free(
const atomic<_ITp>* __a)
noexcept
1297 {
return __a->is_lock_free(); }
1299 template<
typename _ITp>
1301 atomic_is_lock_free(
const volatile atomic<_ITp>* __a)
noexcept
1302 {
return __a->is_lock_free(); }
1304 template<
typename _ITp>
1306 atomic_init(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i)
noexcept
1307 { __a->store(__i, memory_order_relaxed); }
1309 template<
typename _ITp>
1311 atomic_init(
volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i)
noexcept
1312 { __a->store(__i, memory_order_relaxed); }
1314 template<
typename _ITp>
1316 atomic_store_explicit(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i,
1318 { __a->store(__i, __m); }
1320 template<
typename _ITp>
1322 atomic_store_explicit(
volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i,
1324 { __a->store(__i, __m); }
1326 template<
typename _ITp>
1328 atomic_load_explicit(
const atomic<_ITp>* __a,
memory_order __m)
noexcept
1329 {
return __a->load(__m); }
1331 template<
typename _ITp>
1333 atomic_load_explicit(
const volatile atomic<_ITp>* __a,
1335 {
return __a->load(__m); }
1337 template<
typename _ITp>
1339 atomic_exchange_explicit(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i,
1341 {
return __a->exchange(__i, __m); }
1343 template<
typename _ITp>
1345 atomic_exchange_explicit(
volatile atomic<_ITp>* __a,
1346 __atomic_val_t<_ITp> __i,
1348 {
return __a->exchange(__i, __m); }
1350 template<
typename _ITp>
1352 atomic_compare_exchange_weak_explicit(atomic<_ITp>* __a,
1353 __atomic_val_t<_ITp>* __i1,
1354 __atomic_val_t<_ITp> __i2,
1357 {
return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
1359 template<
typename _ITp>
1361 atomic_compare_exchange_weak_explicit(
volatile atomic<_ITp>* __a,
1362 __atomic_val_t<_ITp>* __i1,
1363 __atomic_val_t<_ITp> __i2,
1366 {
return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
1368 template<
typename _ITp>
1370 atomic_compare_exchange_strong_explicit(atomic<_ITp>* __a,
1371 __atomic_val_t<_ITp>* __i1,
1372 __atomic_val_t<_ITp> __i2,
1375 {
return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
1377 template<
typename _ITp>
1379 atomic_compare_exchange_strong_explicit(
volatile atomic<_ITp>* __a,
1380 __atomic_val_t<_ITp>* __i1,
1381 __atomic_val_t<_ITp> __i2,
1384 {
return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
1387 template<
typename _ITp>
1389 atomic_store(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i)
noexcept
1390 { atomic_store_explicit(__a, __i, memory_order_seq_cst); }
1392 template<
typename _ITp>
1394 atomic_store(
volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i)
noexcept
1395 { atomic_store_explicit(__a, __i, memory_order_seq_cst); }
1397 template<
typename _ITp>
1399 atomic_load(
const atomic<_ITp>* __a)
noexcept
1400 {
return atomic_load_explicit(__a, memory_order_seq_cst); }
1402 template<
typename _ITp>
1404 atomic_load(
const volatile atomic<_ITp>* __a)
noexcept
1405 {
return atomic_load_explicit(__a, memory_order_seq_cst); }
1407 template<
typename _ITp>
1409 atomic_exchange(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i)
noexcept
1410 {
return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
1412 template<
typename _ITp>
1414 atomic_exchange(
volatile atomic<_ITp>* __a,
1415 __atomic_val_t<_ITp> __i)
noexcept
1416 {
return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
1418 template<
typename _ITp>
1420 atomic_compare_exchange_weak(atomic<_ITp>* __a,
1421 __atomic_val_t<_ITp>* __i1,
1422 __atomic_val_t<_ITp> __i2)
noexcept
1424 return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
1425 memory_order_seq_cst,
1426 memory_order_seq_cst);
1429 template<
typename _ITp>
1431 atomic_compare_exchange_weak(
volatile atomic<_ITp>* __a,
1432 __atomic_val_t<_ITp>* __i1,
1433 __atomic_val_t<_ITp> __i2)
noexcept
1435 return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
1436 memory_order_seq_cst,
1437 memory_order_seq_cst);
1440 template<
typename _ITp>
1442 atomic_compare_exchange_strong(atomic<_ITp>* __a,
1443 __atomic_val_t<_ITp>* __i1,
1444 __atomic_val_t<_ITp> __i2)
noexcept
1446 return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
1447 memory_order_seq_cst,
1448 memory_order_seq_cst);
1451 template<
typename _ITp>
1453 atomic_compare_exchange_strong(
volatile atomic<_ITp>* __a,
1454 __atomic_val_t<_ITp>* __i1,
1455 __atomic_val_t<_ITp> __i2)
noexcept
1457 return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
1458 memory_order_seq_cst,
1459 memory_order_seq_cst);
1463#if __cpp_lib_atomic_wait
1464 template<
typename _Tp>
1466 atomic_wait(
const atomic<_Tp>* __a,
1467 typename std::atomic<_Tp>::value_type __old)
noexcept
1468 { __a->wait(__old); }
1470 template<
typename _Tp>
1472 atomic_wait_explicit(
const atomic<_Tp>* __a,
1473 typename std::atomic<_Tp>::value_type __old,
1475 { __a->wait(__old, __m); }
1477 template<
typename _Tp>
1479 atomic_notify_one(atomic<_Tp>* __a)
noexcept
1480 { __a->notify_one(); }
1482 template<
typename _Tp>
1484 atomic_notify_all(atomic<_Tp>* __a)
noexcept
1485 { __a->notify_all(); }
1492 template<
typename _ITp>
1494 atomic_fetch_add_explicit(atomic<_ITp>* __a,
1495 __atomic_diff_t<_ITp> __i,
1497 {
return __a->fetch_add(__i, __m); }
1499 template<
typename _ITp>
1501 atomic_fetch_add_explicit(
volatile atomic<_ITp>* __a,
1502 __atomic_diff_t<_ITp> __i,
1504 {
return __a->fetch_add(__i, __m); }
1506 template<
typename _ITp>
1508 atomic_fetch_sub_explicit(atomic<_ITp>* __a,
1509 __atomic_diff_t<_ITp> __i,
1511 {
return __a->fetch_sub(__i, __m); }
1513 template<
typename _ITp>
1515 atomic_fetch_sub_explicit(
volatile atomic<_ITp>* __a,
1516 __atomic_diff_t<_ITp> __i,
1518 {
return __a->fetch_sub(__i, __m); }
1520 template<
typename _ITp>
1522 atomic_fetch_and_explicit(__atomic_base<_ITp>* __a,
1523 __atomic_val_t<_ITp> __i,
1525 {
return __a->fetch_and(__i, __m); }
1527 template<
typename _ITp>
1529 atomic_fetch_and_explicit(
volatile __atomic_base<_ITp>* __a,
1530 __atomic_val_t<_ITp> __i,
1532 {
return __a->fetch_and(__i, __m); }
1534 template<
typename _ITp>
1536 atomic_fetch_or_explicit(__atomic_base<_ITp>* __a,
1537 __atomic_val_t<_ITp> __i,
1539 {
return __a->fetch_or(__i, __m); }
1541 template<
typename _ITp>
1543 atomic_fetch_or_explicit(
volatile __atomic_base<_ITp>* __a,
1544 __atomic_val_t<_ITp> __i,
1546 {
return __a->fetch_or(__i, __m); }
1548 template<
typename _ITp>
1550 atomic_fetch_xor_explicit(__atomic_base<_ITp>* __a,
1551 __atomic_val_t<_ITp> __i,
1553 {
return __a->fetch_xor(__i, __m); }
1555 template<
typename _ITp>
1557 atomic_fetch_xor_explicit(
volatile __atomic_base<_ITp>* __a,
1558 __atomic_val_t<_ITp> __i,
1560 {
return __a->fetch_xor(__i, __m); }
1562 template<
typename _ITp>
1564 atomic_fetch_add(atomic<_ITp>* __a,
1565 __atomic_diff_t<_ITp> __i)
noexcept
1566 {
return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
1568 template<
typename _ITp>
1570 atomic_fetch_add(
volatile atomic<_ITp>* __a,
1571 __atomic_diff_t<_ITp> __i)
noexcept
1572 {
return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
1574 template<
typename _ITp>
1576 atomic_fetch_sub(atomic<_ITp>* __a,
1577 __atomic_diff_t<_ITp> __i)
noexcept
1578 {
return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
1580 template<
typename _ITp>
1582 atomic_fetch_sub(
volatile atomic<_ITp>* __a,
1583 __atomic_diff_t<_ITp> __i)
noexcept
1584 {
return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
1586 template<
typename _ITp>
1588 atomic_fetch_and(__atomic_base<_ITp>* __a,
1589 __atomic_val_t<_ITp> __i)
noexcept
1590 {
return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }
1592 template<
typename _ITp>
1594 atomic_fetch_and(
volatile __atomic_base<_ITp>* __a,
1595 __atomic_val_t<_ITp> __i)
noexcept
1596 {
return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }
1598 template<
typename _ITp>
1600 atomic_fetch_or(__atomic_base<_ITp>* __a,
1601 __atomic_val_t<_ITp> __i)
noexcept
1602 {
return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }
1604 template<
typename _ITp>
1606 atomic_fetch_or(
volatile __atomic_base<_ITp>* __a,
1607 __atomic_val_t<_ITp> __i)
noexcept
1608 {
return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }
1610 template<
typename _ITp>
1612 atomic_fetch_xor(__atomic_base<_ITp>* __a,
1613 __atomic_val_t<_ITp> __i)
noexcept
1614 {
return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
1616 template<
typename _ITp>
1618 atomic_fetch_xor(
volatile __atomic_base<_ITp>* __a,
1619 __atomic_val_t<_ITp> __i)
noexcept
1620 {
return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
1622#ifdef __cpp_lib_atomic_float
1624 struct atomic<float> : __atomic_float<float>
1626 atomic() noexcept = default;
1629 atomic(
float __fp) noexcept : __atomic_float<
float>(__fp)
1632 atomic& operator=(
const atomic&)
volatile =
delete;
1633 atomic& operator=(
const atomic&) =
delete;
1635 using __atomic_float<
float>::operator=;
1639 struct atomic<double> : __atomic_float<double>
1641 atomic() noexcept = default;
1644 atomic(
double __fp) noexcept : __atomic_float<
double>(__fp)
1647 atomic& operator=(
const atomic&)
volatile =
delete;
1648 atomic& operator=(
const atomic&) =
delete;
1650 using __atomic_float<
double>::operator=;
1654 struct atomic<long double> : __atomic_float<long double>
1656 atomic() noexcept = default;
1659 atomic(
long double __fp) noexcept : __atomic_float<
long double>(__fp)
1662 atomic& operator=(
const atomic&)
volatile =
delete;
1663 atomic& operator=(
const atomic&) =
delete;
1665 using __atomic_float<
long double>::operator=;
1668#ifdef __STDCPP_FLOAT16_T__
1670 struct atomic<_Float16> : __atomic_float<_Float16>
1672 atomic() noexcept = default;
1675 atomic(_Float16 __fp) noexcept : __atomic_float<_Float16>(__fp)
1678 atomic& operator=(
const atomic&)
volatile =
delete;
1679 atomic& operator=(
const atomic&) =
delete;
1681 using __atomic_float<_Float16>::operator=;
1685#ifdef __STDCPP_FLOAT32_T__
1687 struct atomic<_Float32> : __atomic_float<_Float32>
1689 atomic() noexcept = default;
1692 atomic(_Float32 __fp) noexcept : __atomic_float<_Float32>(__fp)
1695 atomic& operator=(
const atomic&)
volatile =
delete;
1696 atomic& operator=(
const atomic&) =
delete;
1698 using __atomic_float<_Float32>::operator=;
1702#ifdef __STDCPP_FLOAT64_T__
1704 struct atomic<_Float64> : __atomic_float<_Float64>
1706 atomic() noexcept = default;
1709 atomic(_Float64 __fp) noexcept : __atomic_float<_Float64>(__fp)
1712 atomic& operator=(
const atomic&)
volatile =
delete;
1713 atomic& operator=(
const atomic&) =
delete;
1715 using __atomic_float<_Float64>::operator=;
1719#ifdef __STDCPP_FLOAT128_T__
1721 struct atomic<_Float128> : __atomic_float<_Float128>
1723 atomic() noexcept = default;
1726 atomic(_Float128 __fp) noexcept : __atomic_float<_Float128>(__fp)
1729 atomic& operator=(
const atomic&)
volatile =
delete;
1730 atomic& operator=(
const atomic&) =
delete;
1732 using __atomic_float<_Float128>::operator=;
1736#ifdef __STDCPP_BFLOAT16_T__
1738 struct atomic<
__gnu_cxx::__bfloat16_t> : __atomic_float<__gnu_cxx::__bfloat16_t>
1740 atomic() noexcept = default;
1743 atomic(
__gnu_cxx::__bfloat16_t __fp) noexcept : __atomic_float<
__gnu_cxx::__bfloat16_t>(__fp)
1746 atomic& operator=(
const atomic&)
volatile =
delete;
1747 atomic& operator=(
const atomic&) =
delete;
1749 using __atomic_float<__gnu_cxx::__bfloat16_t>::operator=;
1754#ifdef __cpp_lib_atomic_ref
1756 template<
typename _Tp>
1757 struct atomic_ref : __atomic_ref<_Tp>
1760 atomic_ref(_Tp& __t) noexcept : __atomic_ref<_Tp>(__t)
1763 atomic_ref& operator=(
const atomic_ref&) =
delete;
1765 atomic_ref(
const atomic_ref&) =
default;
1767 using __atomic_ref<_Tp>::operator=;
1771#ifdef __cpp_lib_atomic_lock_free_type_aliases
1772# ifdef _GLIBCXX_HAVE_PLATFORM_WAIT
1773 using atomic_signed_lock_free
1774 = atomic<make_signed_t<__detail::__platform_wait_t>>;
1775 using atomic_unsigned_lock_free
1776 = atomic<make_unsigned_t<__detail::__platform_wait_t>>;
1777# elif ATOMIC_INT_LOCK_FREE == 2
1778 using atomic_signed_lock_free = atomic<signed int>;
1779 using atomic_unsigned_lock_free = atomic<unsigned int>;
1780# elif ATOMIC_LONG_LOCK_FREE == 2
1781 using atomic_signed_lock_free = atomic<signed long>;
1782 using atomic_unsigned_lock_free = atomic<unsigned long>;
1783# elif ATOMIC_CHAR_LOCK_FREE == 2
1784 using atomic_signed_lock_free = atomic<signed char>;
1785 using atomic_unsigned_lock_free = atomic<unsigned char>;
1787# error "libstdc++ bug: no lock-free atomics but they were emitted in <version>"
1793_GLIBCXX_END_NAMESPACE_VERSION
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
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
memory_order
Enumeration for memory_order.
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.
GNU extensions for public use.
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.