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
66 constexpr
atomic_bool(
bool __i) noexcept : _M_base(__i) { }
69 operator=(
bool __i) noexcept
70 {
return _M_base.operator=(__i); }
73 operator=(
bool __i)
volatile noexcept
74 {
return _M_base.operator=(__i); }
76 operator bool()
const noexcept
77 {
return _M_base.load(); }
79 operator bool()
const volatile noexcept
80 {
return _M_base.load(); }
83 is_lock_free()
const noexcept {
return _M_base.is_lock_free(); }
86 is_lock_free()
const volatile noexcept {
return _M_base.is_lock_free(); }
89 store(
bool __i,
memory_order __m = memory_order_seq_cst) noexcept
90 { _M_base.store(__i, __m); }
93 store(
bool __i,
memory_order __m = memory_order_seq_cst)
volatile noexcept
94 { _M_base.store(__i, __m); }
97 load(
memory_order __m = memory_order_seq_cst)
const noexcept
98 {
return _M_base.load(__m); }
101 load(
memory_order __m = memory_order_seq_cst)
const volatile noexcept
102 {
return _M_base.load(__m); }
105 exchange(
bool __i,
memory_order __m = memory_order_seq_cst) noexcept
106 {
return _M_base.exchange(__i, __m); }
110 memory_order __m = memory_order_seq_cst)
volatile noexcept
111 {
return _M_base.exchange(__i, __m); }
114 compare_exchange_weak(
bool& __i1,
bool __i2,
memory_order __m1,
116 {
return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); }
119 compare_exchange_weak(
bool& __i1,
bool __i2,
memory_order __m1,
121 {
return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); }
124 compare_exchange_weak(
bool& __i1,
bool __i2,
126 {
return _M_base.compare_exchange_weak(__i1, __i2, __m); }
129 compare_exchange_weak(
bool& __i1,
bool __i2,
130 memory_order __m = memory_order_seq_cst)
volatile noexcept
131 {
return _M_base.compare_exchange_weak(__i1, __i2, __m); }
134 compare_exchange_strong(
bool& __i1,
bool __i2,
memory_order __m1,
136 {
return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); }
139 compare_exchange_strong(
bool& __i1,
bool __i2,
memory_order __m1,
141 {
return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); }
144 compare_exchange_strong(
bool& __i1,
bool __i2,
146 {
return _M_base.compare_exchange_strong(__i1, __i2, __m); }
149 compare_exchange_strong(
bool& __i1,
bool __i2,
150 memory_order __m = memory_order_seq_cst)
volatile noexcept
151 {
return _M_base.compare_exchange_strong(__i1, __i2, __m); }
160 template<
typename _Tp>
167 atomic() noexcept =
default;
168 ~
atomic() noexcept =
default;
173 constexpr
atomic(_Tp __i) noexcept : _M_i(__i) { }
175 operator _Tp()
const noexcept
178 operator _Tp()
const volatile noexcept
182 operator=(_Tp __i) noexcept
183 { store(__i);
return __i; }
186 operator=(_Tp __i)
volatile noexcept
187 { store(__i);
return __i; }
190 is_lock_free()
const noexcept
191 {
return __atomic_is_lock_free(
sizeof(_M_i),
nullptr); }
194 is_lock_free()
const volatile noexcept
195 {
return __atomic_is_lock_free(
sizeof(_M_i),
nullptr); }
198 store(_Tp __i,
memory_order _m = memory_order_seq_cst) noexcept
199 { __atomic_store(&_M_i, &__i, _m); }
202 store(_Tp __i,
memory_order _m = memory_order_seq_cst)
volatile noexcept
203 { __atomic_store(&_M_i, &__i, _m); }
206 load(
memory_order _m = memory_order_seq_cst)
const noexcept
209 __atomic_load(&_M_i, &tmp, _m);
214 load(
memory_order _m = memory_order_seq_cst)
const volatile noexcept
217 __atomic_load(&_M_i, &tmp, _m);
222 exchange(_Tp __i,
memory_order _m = memory_order_seq_cst) noexcept
225 __atomic_exchange(&_M_i, &__i, &tmp, _m);
231 memory_order _m = memory_order_seq_cst)
volatile noexcept
234 __atomic_exchange(&_M_i, &__i, &tmp, _m);
239 compare_exchange_weak(_Tp& __e, _Tp __i,
memory_order __s,
242 return __atomic_compare_exchange(&_M_i, &__e, &__i,
true, __s, __f);
246 compare_exchange_weak(_Tp& __e, _Tp __i,
memory_order __s,
249 return __atomic_compare_exchange(&_M_i, &__e, &__i,
true, __s, __f);
253 compare_exchange_weak(_Tp& __e, _Tp __i,
255 {
return compare_exchange_weak(__e, __i, __m, __m); }
258 compare_exchange_weak(_Tp& __e, _Tp __i,
259 memory_order __m = memory_order_seq_cst)
volatile noexcept
260 {
return compare_exchange_weak(__e, __i, __m, __m); }
263 compare_exchange_strong(_Tp& __e, _Tp __i,
memory_order __s,
266 return __atomic_compare_exchange(&_M_i, &__e, &__i,
false, __s, __f);
270 compare_exchange_strong(_Tp& __e, _Tp __i,
memory_order __s,
273 return __atomic_compare_exchange(&_M_i, &__e, &__i,
false, __s, __f);
277 compare_exchange_strong(_Tp& __e, _Tp __i,
279 {
return compare_exchange_strong(__e, __i, __m, __m); }
282 compare_exchange_strong(_Tp& __e, _Tp __i,
283 memory_order __m = memory_order_seq_cst)
volatile noexcept
284 {
return compare_exchange_strong(__e, __i, __m, __m); }
289 template<
typename _Tp>
292 typedef _Tp* __pointer_type;
296 atomic() noexcept =
default;
297 ~
atomic() noexcept =
default;
302 constexpr
atomic(__pointer_type __p) noexcept : _M_b(__p) { }
304 operator __pointer_type()
const noexcept
305 {
return __pointer_type(_M_b); }
307 operator __pointer_type()
const volatile noexcept
308 {
return __pointer_type(_M_b); }
311 operator=(__pointer_type __p) noexcept
312 {
return _M_b.operator=(__p); }
315 operator=(__pointer_type __p)
volatile noexcept
316 {
return _M_b.operator=(__p); }
319 operator++(
int) noexcept
323 operator++(
int)
volatile noexcept
327 operator--(
int) noexcept
331 operator--(
int)
volatile noexcept
335 operator++() noexcept
339 operator++()
volatile noexcept
343 operator--() noexcept
347 operator--()
volatile noexcept
351 operator+=(ptrdiff_t __d) noexcept
352 {
return _M_b.operator+=(__d); }
355 operator+=(ptrdiff_t __d)
volatile noexcept
356 {
return _M_b.operator+=(__d); }
359 operator-=(ptrdiff_t __d) noexcept
360 {
return _M_b.operator-=(__d); }
363 operator-=(ptrdiff_t __d)
volatile noexcept
364 {
return _M_b.operator-=(__d); }
367 is_lock_free()
const noexcept
368 {
return _M_b.is_lock_free(); }
371 is_lock_free()
const volatile noexcept
372 {
return _M_b.is_lock_free(); }
375 store(__pointer_type __p,
377 {
return _M_b.store(__p, __m); }
380 store(__pointer_type __p,
381 memory_order __m = memory_order_seq_cst)
volatile noexcept
382 {
return _M_b.store(__p, __m); }
385 load(
memory_order __m = memory_order_seq_cst)
const noexcept
386 {
return _M_b.load(__m); }
389 load(
memory_order __m = memory_order_seq_cst)
const volatile noexcept
390 {
return _M_b.load(__m); }
393 exchange(__pointer_type __p,
395 {
return _M_b.exchange(__p, __m); }
398 exchange(__pointer_type __p,
399 memory_order __m = memory_order_seq_cst)
volatile noexcept
400 {
return _M_b.exchange(__p, __m); }
403 compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
405 {
return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
408 compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
411 {
return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
414 compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
417 return compare_exchange_weak(__p1, __p2, __m,
418 __cmpexch_failure_order(__m));
422 compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
423 memory_order __m = memory_order_seq_cst)
volatile noexcept
425 return compare_exchange_weak(__p1, __p2, __m,
426 __cmpexch_failure_order(__m));
430 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
432 {
return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
435 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
438 {
return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
441 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
444 return _M_b.compare_exchange_strong(__p1, __p2, __m,
445 __cmpexch_failure_order(__m));
449 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
450 memory_order __m = memory_order_seq_cst)
volatile noexcept
452 return _M_b.compare_exchange_strong(__p1, __p2, __m,
453 __cmpexch_failure_order(__m));
457 fetch_add(ptrdiff_t __d,
459 {
return _M_b.fetch_add(__d, __m); }
462 fetch_add(ptrdiff_t __d,
463 memory_order __m = memory_order_seq_cst)
volatile noexcept
464 {
return _M_b.fetch_add(__d, __m); }
467 fetch_sub(ptrdiff_t __d,
469 {
return _M_b.fetch_sub(__d, __m); }
472 fetch_sub(ptrdiff_t __d,
473 memory_order __m = memory_order_seq_cst)
volatile noexcept
474 {
return _M_b.fetch_sub(__d, __m); }
482 typedef bool __integral_type;
485 atomic() noexcept =
default;
486 ~
atomic() noexcept =
default;
493 using __base_type::operator __integral_type;
494 using __base_type::operator=;
501 typedef char __integral_type;
504 atomic() noexcept =
default;
505 ~
atomic() noexcept =
default;
512 using __base_type::operator __integral_type;
513 using __base_type::operator=;
520 typedef signed char __integral_type;
523 atomic() noexcept=
default;
524 ~
atomic() noexcept =
default;
531 using __base_type::operator __integral_type;
532 using __base_type::operator=;
539 typedef unsigned char __integral_type;
542 atomic() noexcept=
default;
543 ~
atomic() noexcept =
default;
550 using __base_type::operator __integral_type;
551 using __base_type::operator=;
558 typedef short __integral_type;
561 atomic() noexcept =
default;
562 ~
atomic() noexcept =
default;
569 using __base_type::operator __integral_type;
570 using __base_type::operator=;
577 typedef unsigned short __integral_type;
580 atomic() noexcept =
default;
581 ~
atomic() noexcept =
default;
588 using __base_type::operator __integral_type;
589 using __base_type::operator=;
596 typedef int __integral_type;
599 atomic() noexcept =
default;
600 ~
atomic() noexcept =
default;
607 using __base_type::operator __integral_type;
608 using __base_type::operator=;
615 typedef unsigned int __integral_type;
618 atomic() noexcept =
default;
619 ~
atomic() noexcept =
default;
626 using __base_type::operator __integral_type;
627 using __base_type::operator=;
634 typedef long __integral_type;
637 atomic() noexcept =
default;
638 ~
atomic() noexcept =
default;
645 using __base_type::operator __integral_type;
646 using __base_type::operator=;
653 typedef unsigned long __integral_type;
656 atomic() noexcept =
default;
657 ~
atomic() noexcept =
default;
664 using __base_type::operator __integral_type;
665 using __base_type::operator=;
672 typedef long long __integral_type;
675 atomic() noexcept =
default;
676 ~
atomic() noexcept =
default;
683 using __base_type::operator __integral_type;
684 using __base_type::operator=;
691 typedef unsigned long long __integral_type;
694 atomic() noexcept =
default;
695 ~
atomic() noexcept =
default;
702 using __base_type::operator __integral_type;
703 using __base_type::operator=;
710 typedef wchar_t __integral_type;
713 atomic() noexcept =
default;
714 ~
atomic() noexcept =
default;
721 using __base_type::operator __integral_type;
722 using __base_type::operator=;
729 typedef char16_t __integral_type;
732 atomic() noexcept =
default;
733 ~
atomic() noexcept =
default;
740 using __base_type::operator __integral_type;
741 using __base_type::operator=;
748 typedef char32_t __integral_type;
751 atomic() noexcept =
default;
752 ~
atomic() noexcept =
default;
759 using __base_type::operator __integral_type;
760 using __base_type::operator=;
766 atomic_flag_test_and_set_explicit(
atomic_flag* __a,
768 {
return __a->test_and_set(__m); }
771 atomic_flag_test_and_set_explicit(
volatile atomic_flag* __a,
773 {
return __a->test_and_set(__m); }
776 atomic_flag_clear_explicit(atomic_flag* __a,
memory_order __m) noexcept
780 atomic_flag_clear_explicit(
volatile atomic_flag* __a,
785 atomic_flag_test_and_set(atomic_flag* __a) noexcept
786 {
return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }
789 atomic_flag_test_and_set(
volatile atomic_flag* __a) noexcept
790 {
return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }
793 atomic_flag_clear(atomic_flag* __a) noexcept
794 { atomic_flag_clear_explicit(__a, memory_order_seq_cst); }
797 atomic_flag_clear(
volatile atomic_flag* __a) noexcept
798 { atomic_flag_clear_explicit(__a, memory_order_seq_cst); }
802 template<
typename _ITp>
804 atomic_is_lock_free(
const atomic<_ITp>* __a) noexcept
805 {
return __a->is_lock_free(); }
807 template<
typename _ITp>
809 atomic_is_lock_free(
const volatile atomic<_ITp>* __a) noexcept
810 {
return __a->is_lock_free(); }
812 template<
typename _ITp>
814 atomic_init(atomic<_ITp>* __a, _ITp __i) noexcept;
816 template<
typename _ITp>
818 atomic_init(
volatile atomic<_ITp>* __a, _ITp __i) noexcept;
820 template<
typename _ITp>
822 atomic_store_explicit(atomic<_ITp>* __a, _ITp __i,
824 { __a->store(__i, __m); }
826 template<
typename _ITp>
828 atomic_store_explicit(
volatile atomic<_ITp>* __a, _ITp __i,
830 { __a->store(__i, __m); }
832 template<
typename _ITp>
834 atomic_load_explicit(
const atomic<_ITp>* __a,
memory_order __m) noexcept
835 {
return __a->load(__m); }
837 template<
typename _ITp>
839 atomic_load_explicit(
const volatile atomic<_ITp>* __a,
841 {
return __a->load(__m); }
843 template<
typename _ITp>
845 atomic_exchange_explicit(atomic<_ITp>* __a, _ITp __i,
847 {
return __a->exchange(__i, __m); }
849 template<
typename _ITp>
851 atomic_exchange_explicit(
volatile atomic<_ITp>* __a, _ITp __i,
853 {
return __a->exchange(__i, __m); }
855 template<
typename _ITp>
857 atomic_compare_exchange_weak_explicit(atomic<_ITp>* __a,
858 _ITp* __i1, _ITp __i2,
861 {
return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
863 template<
typename _ITp>
865 atomic_compare_exchange_weak_explicit(
volatile atomic<_ITp>* __a,
866 _ITp* __i1, _ITp __i2,
869 {
return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
871 template<
typename _ITp>
873 atomic_compare_exchange_strong_explicit(atomic<_ITp>* __a,
874 _ITp* __i1, _ITp __i2,
877 {
return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
879 template<
typename _ITp>
881 atomic_compare_exchange_strong_explicit(
volatile atomic<_ITp>* __a,
882 _ITp* __i1, _ITp __i2,
885 {
return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
888 template<
typename _ITp>
890 atomic_store(atomic<_ITp>* __a, _ITp __i) noexcept
891 { atomic_store_explicit(__a, __i, memory_order_seq_cst); }
893 template<
typename _ITp>
895 atomic_store(
volatile atomic<_ITp>* __a, _ITp __i) noexcept
896 { atomic_store_explicit(__a, __i, memory_order_seq_cst); }
898 template<
typename _ITp>
900 atomic_load(
const atomic<_ITp>* __a) noexcept
901 {
return atomic_load_explicit(__a, memory_order_seq_cst); }
903 template<
typename _ITp>
905 atomic_load(
const volatile atomic<_ITp>* __a) noexcept
906 {
return atomic_load_explicit(__a, memory_order_seq_cst); }
908 template<
typename _ITp>
910 atomic_exchange(atomic<_ITp>* __a, _ITp __i) noexcept
911 {
return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
913 template<
typename _ITp>
915 atomic_exchange(
volatile atomic<_ITp>* __a, _ITp __i) noexcept
916 {
return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
918 template<
typename _ITp>
920 atomic_compare_exchange_weak(atomic<_ITp>* __a,
921 _ITp* __i1, _ITp __i2) noexcept
923 return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
924 memory_order_seq_cst,
925 memory_order_seq_cst);
928 template<
typename _ITp>
930 atomic_compare_exchange_weak(
volatile atomic<_ITp>* __a,
931 _ITp* __i1, _ITp __i2) noexcept
933 return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
934 memory_order_seq_cst,
935 memory_order_seq_cst);
938 template<
typename _ITp>
940 atomic_compare_exchange_strong(atomic<_ITp>* __a,
941 _ITp* __i1, _ITp __i2) noexcept
943 return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
944 memory_order_seq_cst,
945 memory_order_seq_cst);
948 template<
typename _ITp>
950 atomic_compare_exchange_strong(
volatile atomic<_ITp>* __a,
951 _ITp* __i1, _ITp __i2) noexcept
953 return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
954 memory_order_seq_cst,
955 memory_order_seq_cst);
962 template<
typename _ITp>
964 atomic_fetch_add_explicit(__atomic_base<_ITp>* __a, _ITp __i,
966 {
return __a->fetch_add(__i, __m); }
968 template<
typename _ITp>
970 atomic_fetch_add_explicit(
volatile __atomic_base<_ITp>* __a, _ITp __i,
972 {
return __a->fetch_add(__i, __m); }
974 template<
typename _ITp>
976 atomic_fetch_sub_explicit(__atomic_base<_ITp>* __a, _ITp __i,
978 {
return __a->fetch_sub(__i, __m); }
980 template<
typename _ITp>
982 atomic_fetch_sub_explicit(
volatile __atomic_base<_ITp>* __a, _ITp __i,
984 {
return __a->fetch_sub(__i, __m); }
986 template<
typename _ITp>
988 atomic_fetch_and_explicit(__atomic_base<_ITp>* __a, _ITp __i,
990 {
return __a->fetch_and(__i, __m); }
992 template<
typename _ITp>
994 atomic_fetch_and_explicit(
volatile __atomic_base<_ITp>* __a, _ITp __i,
996 {
return __a->fetch_and(__i, __m); }
998 template<
typename _ITp>
1000 atomic_fetch_or_explicit(__atomic_base<_ITp>* __a, _ITp __i,
1002 {
return __a->fetch_or(__i, __m); }
1004 template<
typename _ITp>
1006 atomic_fetch_or_explicit(
volatile __atomic_base<_ITp>* __a, _ITp __i,
1008 {
return __a->fetch_or(__i, __m); }
1010 template<
typename _ITp>
1012 atomic_fetch_xor_explicit(__atomic_base<_ITp>* __a, _ITp __i,
1014 {
return __a->fetch_xor(__i, __m); }
1016 template<
typename _ITp>
1018 atomic_fetch_xor_explicit(
volatile __atomic_base<_ITp>* __a, _ITp __i,
1020 {
return __a->fetch_xor(__i, __m); }
1022 template<
typename _ITp>
1024 atomic_fetch_add(__atomic_base<_ITp>* __a, _ITp __i) noexcept
1025 {
return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
1027 template<
typename _ITp>
1029 atomic_fetch_add(
volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
1030 {
return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
1032 template<
typename _ITp>
1034 atomic_fetch_sub(__atomic_base<_ITp>* __a, _ITp __i) noexcept
1035 {
return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
1037 template<
typename _ITp>
1039 atomic_fetch_sub(
volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
1040 {
return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
1042 template<
typename _ITp>
1044 atomic_fetch_and(__atomic_base<_ITp>* __a, _ITp __i) noexcept
1045 {
return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }
1047 template<
typename _ITp>
1049 atomic_fetch_and(
volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
1050 {
return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }
1052 template<
typename _ITp>
1054 atomic_fetch_or(__atomic_base<_ITp>* __a, _ITp __i) noexcept
1055 {
return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }
1057 template<
typename _ITp>
1059 atomic_fetch_or(
volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
1060 {
return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }
1062 template<
typename _ITp>
1064 atomic_fetch_xor(__atomic_base<_ITp>* __a, _ITp __i) noexcept
1065 {
return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
1067 template<
typename _ITp>
1069 atomic_fetch_xor(
volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
1070 {
return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
1074 template<
typename _ITp>
1076 atomic_fetch_add_explicit(atomic<_ITp*>* __a, ptrdiff_t __d,
1078 {
return __a->fetch_add(__d, __m); }
1080 template<
typename _ITp>
1082 atomic_fetch_add_explicit(
volatile atomic<_ITp*>* __a, ptrdiff_t __d,
1084 {
return __a->fetch_add(__d, __m); }
1086 template<
typename _ITp>
1088 atomic_fetch_add(
volatile atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
1089 {
return __a->fetch_add(__d); }
1091 template<
typename _ITp>
1093 atomic_fetch_add(atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
1094 {
return __a->fetch_add(__d); }
1096 template<
typename _ITp>
1098 atomic_fetch_sub_explicit(
volatile atomic<_ITp*>* __a,
1100 {
return __a->fetch_sub(__d, __m); }
1102 template<
typename _ITp>
1104 atomic_fetch_sub_explicit(atomic<_ITp*>* __a, ptrdiff_t __d,
1106 {
return __a->fetch_sub(__d, __m); }
1108 template<
typename _ITp>
1110 atomic_fetch_sub(
volatile atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
1111 {
return __a->fetch_sub(__d); }
1113 template<
typename _ITp>
1115 atomic_fetch_sub(atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
1116 {
return __a->fetch_sub(__d); }
1119 _GLIBCXX_END_NAMESPACE_VERSION
memory_order
Enumeration for memory_order.
Generic atomic type, primary class template.