30#ifndef _GLIBCXX_ATOMIC_BASE_H
31#define _GLIBCXX_ATOMIC_BASE_H 1
34#pragma GCC system_header
42#if __cplusplus > 201703L && _GLIBCXX_HOSTED
46#ifndef _GLIBCXX_ALWAYS_INLINE
47#define _GLIBCXX_ALWAYS_INLINE inline __attribute__((__always_inline__))
52namespace std _GLIBCXX_VISIBILITY(default)
54_GLIBCXX_BEGIN_NAMESPACE_VERSION
64#if __cplusplus > 201703L
75 inline constexpr memory_order memory_order_relaxed = memory_order::relaxed;
76 inline constexpr memory_order memory_order_consume = memory_order::consume;
77 inline constexpr memory_order memory_order_acquire = memory_order::acquire;
78 inline constexpr memory_order memory_order_release = memory_order::release;
79 inline constexpr memory_order memory_order_acq_rel = memory_order::acq_rel;
80 inline constexpr memory_order memory_order_seq_cst = memory_order::seq_cst;
94 enum __memory_order_modifier
96 __memory_order_mask = 0x0ffff,
97 __memory_order_modifier_mask = 0xffff0000,
98 __memory_order_hle_acquire = 0x10000,
99 __memory_order_hle_release = 0x20000
121 return __m == memory_order_acq_rel ? memory_order_acquire
122 : __m == memory_order_release ? memory_order_relaxed : __m;
128 return memory_order(__cmpexch_failure_order2(__m & __memory_order_mask)
129 | __memory_order_modifier(__m & __memory_order_modifier_mask));
133 __is_valid_cmpexch_failure_order(
memory_order __m)
noexcept
135 return (__m & __memory_order_mask) != memory_order_release
136 && (__m & __memory_order_mask) != memory_order_acq_rel;
140 template<
typename _IntTp>
141 struct __atomic_base;
145 _GLIBCXX_ALWAYS_INLINE
void
147 { __atomic_thread_fence(
int(__m)); }
149 _GLIBCXX_ALWAYS_INLINE
void
151 { __atomic_signal_fence(
int(__m)); }
154 template<
typename _Tp>
163#if __glibcxx_atomic_value_initialization
164# define _GLIBCXX20_INIT(I) = I
166# define _GLIBCXX20_INIT(I)
170#define ATOMIC_VAR_INIT(_VI) { _VI }
172 template<
typename _Tp>
175 template<
typename _Tp>
179#if __GCC_ATOMIC_TEST_AND_SET_TRUEVAL == 1
180 typedef bool __atomic_flag_data_type;
182 typedef unsigned char __atomic_flag_data_type;
197 _GLIBCXX_BEGIN_EXTERN_C
199 struct __atomic_flag_base
201 __atomic_flag_data_type _M_i _GLIBCXX20_INIT({});
204 _GLIBCXX_END_EXTERN_C
208#define ATOMIC_FLAG_INIT { 0 }
211 struct atomic_flag :
public __atomic_flag_base
213 atomic_flag()
noexcept =
default;
214 ~atomic_flag()
noexcept =
default;
215 atomic_flag(
const atomic_flag&) =
delete;
216 atomic_flag& operator=(
const atomic_flag&) =
delete;
217 atomic_flag& operator=(
const atomic_flag&)
volatile =
delete;
220 constexpr atomic_flag(
bool __i) noexcept
221 : __atomic_flag_base{ _S_init(__i) }
224 _GLIBCXX_ALWAYS_INLINE
bool
225 test_and_set(
memory_order __m = memory_order_seq_cst)
noexcept
227 return __atomic_test_and_set (&_M_i,
int(__m));
230 _GLIBCXX_ALWAYS_INLINE
bool
231 test_and_set(
memory_order __m = memory_order_seq_cst)
volatile noexcept
233 return __atomic_test_and_set (&_M_i,
int(__m));
236#ifdef __glibcxx_atomic_flag_test
237 _GLIBCXX_ALWAYS_INLINE
bool
238 test(
memory_order __m = memory_order_seq_cst)
const noexcept
240 __atomic_flag_data_type __v;
241 __atomic_load(&_M_i, &__v,
int(__m));
242 return __v == __GCC_ATOMIC_TEST_AND_SET_TRUEVAL;
245 _GLIBCXX_ALWAYS_INLINE
bool
246 test(
memory_order __m = memory_order_seq_cst)
const volatile noexcept
248 __atomic_flag_data_type __v;
249 __atomic_load(&_M_i, &__v,
int(__m));
250 return __v == __GCC_ATOMIC_TEST_AND_SET_TRUEVAL;
254#if __glibcxx_atomic_wait
255 _GLIBCXX_ALWAYS_INLINE
void
259 const __atomic_flag_data_type __v
260 = __old ? __GCC_ATOMIC_TEST_AND_SET_TRUEVAL : 0;
262 std::__atomic_wait_address_v(&_M_i, __v,
263 [__m,
this] {
return __atomic_load_n(&_M_i,
int(__m)); });
268 _GLIBCXX_ALWAYS_INLINE
void
269 notify_one()
noexcept
270 { std::__atomic_notify_address(&_M_i,
false); }
274 _GLIBCXX_ALWAYS_INLINE
void
275 notify_all()
noexcept
276 { std::__atomic_notify_address(&_M_i,
true); }
281 _GLIBCXX_ALWAYS_INLINE
void
285 = __m & __memory_order_mask;
286 __glibcxx_assert(__b != memory_order_consume);
287 __glibcxx_assert(__b != memory_order_acquire);
288 __glibcxx_assert(__b != memory_order_acq_rel);
290 __atomic_clear (&_M_i,
int(__m));
293 _GLIBCXX_ALWAYS_INLINE
void
294 clear(
memory_order __m = memory_order_seq_cst)
volatile noexcept
297 = __m & __memory_order_mask;
298 __glibcxx_assert(__b != memory_order_consume);
299 __glibcxx_assert(__b != memory_order_acquire);
300 __glibcxx_assert(__b != memory_order_acq_rel);
302 __atomic_clear (&_M_i,
int(__m));
306 static constexpr __atomic_flag_data_type
308 {
return __i ? __GCC_ATOMIC_TEST_AND_SET_TRUEVAL : 0; }
337 template<
typename _ITp>
344 typedef _ITp __int_type;
346 static constexpr int _S_alignment =
347 sizeof(_ITp) >
alignof(_ITp) ?
sizeof(_ITp) : alignof(_ITp);
349 alignas(_S_alignment) __int_type _M_i _GLIBCXX20_INIT(0);
352 __atomic_base() noexcept = default;
353 ~__atomic_base() noexcept = default;
354 __atomic_base(const __atomic_base&) = delete;
355 __atomic_base& operator=(const __atomic_base&) = delete;
356 __atomic_base& operator=(const __atomic_base&) volatile = delete;
359 constexpr __atomic_base(__int_type __i) noexcept : _M_i (__i) { }
361 operator __int_type() const noexcept
364 operator __int_type() const volatile noexcept
368 operator=(__int_type __i)
noexcept
375 operator=(__int_type __i)
volatile noexcept
382 operator++(
int)
noexcept
383 {
return fetch_add(1); }
386 operator++(
int)
volatile noexcept
387 {
return fetch_add(1); }
390 operator--(
int)
noexcept
391 {
return fetch_sub(1); }
394 operator--(
int)
volatile noexcept
395 {
return fetch_sub(1); }
398 operator++() noexcept
399 {
return __atomic_add_fetch(&_M_i, 1,
int(memory_order_seq_cst)); }
402 operator++() volatile noexcept
403 {
return __atomic_add_fetch(&_M_i, 1,
int(memory_order_seq_cst)); }
406 operator--() noexcept
407 {
return __atomic_sub_fetch(&_M_i, 1,
int(memory_order_seq_cst)); }
410 operator--() volatile noexcept
411 {
return __atomic_sub_fetch(&_M_i, 1,
int(memory_order_seq_cst)); }
414 operator+=(__int_type __i)
noexcept
415 {
return __atomic_add_fetch(&_M_i, __i,
int(memory_order_seq_cst)); }
418 operator+=(__int_type __i)
volatile noexcept
419 {
return __atomic_add_fetch(&_M_i, __i,
int(memory_order_seq_cst)); }
422 operator-=(__int_type __i)
noexcept
423 {
return __atomic_sub_fetch(&_M_i, __i,
int(memory_order_seq_cst)); }
426 operator-=(__int_type __i)
volatile noexcept
427 {
return __atomic_sub_fetch(&_M_i, __i,
int(memory_order_seq_cst)); }
430 operator&=(__int_type __i)
noexcept
431 {
return __atomic_and_fetch(&_M_i, __i,
int(memory_order_seq_cst)); }
434 operator&=(__int_type __i)
volatile noexcept
435 {
return __atomic_and_fetch(&_M_i, __i,
int(memory_order_seq_cst)); }
438 operator|=(__int_type __i)
noexcept
439 {
return __atomic_or_fetch(&_M_i, __i,
int(memory_order_seq_cst)); }
442 operator|=(__int_type __i)
volatile noexcept
443 {
return __atomic_or_fetch(&_M_i, __i,
int(memory_order_seq_cst)); }
446 operator^=(__int_type __i)
noexcept
447 {
return __atomic_xor_fetch(&_M_i, __i,
int(memory_order_seq_cst)); }
450 operator^=(__int_type __i)
volatile noexcept
451 {
return __atomic_xor_fetch(&_M_i, __i,
int(memory_order_seq_cst)); }
454 is_lock_free() const noexcept
457 return __atomic_is_lock_free(
sizeof(_M_i),
458 reinterpret_cast<void *
>(-_S_alignment));
462 is_lock_free() const volatile noexcept
465 return __atomic_is_lock_free(
sizeof(_M_i),
466 reinterpret_cast<void *
>(-_S_alignment));
469 _GLIBCXX_ALWAYS_INLINE
void
470 store(__int_type __i, memory_order __m = memory_order_seq_cst)
noexcept
473 = __m & __memory_order_mask;
474 __glibcxx_assert(__b != memory_order_acquire);
475 __glibcxx_assert(__b != memory_order_acq_rel);
476 __glibcxx_assert(__b != memory_order_consume);
478 __atomic_store_n(&_M_i, __i,
int(__m));
481 _GLIBCXX_ALWAYS_INLINE
void
482 store(__int_type __i,
483 memory_order __m = memory_order_seq_cst)
volatile noexcept
486 = __m & __memory_order_mask;
487 __glibcxx_assert(__b != memory_order_acquire);
488 __glibcxx_assert(__b != memory_order_acq_rel);
489 __glibcxx_assert(__b != memory_order_consume);
491 __atomic_store_n(&_M_i, __i,
int(__m));
494 _GLIBCXX_ALWAYS_INLINE __int_type
495 load(memory_order __m = memory_order_seq_cst)
const noexcept
498 = __m & __memory_order_mask;
499 __glibcxx_assert(__b != memory_order_release);
500 __glibcxx_assert(__b != memory_order_acq_rel);
502 return __atomic_load_n(&_M_i,
int(__m));
505 _GLIBCXX_ALWAYS_INLINE __int_type
506 load(memory_order __m = memory_order_seq_cst)
const volatile noexcept
509 = __m & __memory_order_mask;
510 __glibcxx_assert(__b != memory_order_release);
511 __glibcxx_assert(__b != memory_order_acq_rel);
513 return __atomic_load_n(&_M_i,
int(__m));
516 _GLIBCXX_ALWAYS_INLINE __int_type
517 exchange(__int_type __i,
518 memory_order __m = memory_order_seq_cst)
noexcept
520 return __atomic_exchange_n(&_M_i, __i,
int(__m));
524 _GLIBCXX_ALWAYS_INLINE __int_type
525 exchange(__int_type __i,
526 memory_order __m = memory_order_seq_cst)
volatile noexcept
528 return __atomic_exchange_n(&_M_i, __i,
int(__m));
531 _GLIBCXX_ALWAYS_INLINE
bool
532 compare_exchange_weak(__int_type& __i1, __int_type __i2,
533 memory_order __m1, memory_order __m2)
noexcept
535 __glibcxx_assert(__is_valid_cmpexch_failure_order(__m2));
537 return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1,
538 int(__m1),
int(__m2));
541 _GLIBCXX_ALWAYS_INLINE
bool
542 compare_exchange_weak(__int_type& __i1, __int_type __i2,
544 memory_order __m2)
volatile noexcept
546 __glibcxx_assert(__is_valid_cmpexch_failure_order(__m2));
548 return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1,
549 int(__m1),
int(__m2));
552 _GLIBCXX_ALWAYS_INLINE
bool
553 compare_exchange_weak(__int_type& __i1, __int_type __i2,
554 memory_order __m = memory_order_seq_cst)
noexcept
556 return compare_exchange_weak(__i1, __i2, __m,
557 __cmpexch_failure_order(__m));
560 _GLIBCXX_ALWAYS_INLINE
bool
561 compare_exchange_weak(__int_type& __i1, __int_type __i2,
562 memory_order __m = memory_order_seq_cst)
volatile noexcept
564 return compare_exchange_weak(__i1, __i2, __m,
565 __cmpexch_failure_order(__m));
568 _GLIBCXX_ALWAYS_INLINE
bool
569 compare_exchange_strong(__int_type& __i1, __int_type __i2,
570 memory_order __m1, memory_order __m2)
noexcept
572 __glibcxx_assert(__is_valid_cmpexch_failure_order(__m2));
574 return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0,
575 int(__m1),
int(__m2));
578 _GLIBCXX_ALWAYS_INLINE
bool
579 compare_exchange_strong(__int_type& __i1, __int_type __i2,
581 memory_order __m2)
volatile noexcept
583 __glibcxx_assert(__is_valid_cmpexch_failure_order(__m2));
585 return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0,
586 int(__m1),
int(__m2));
589 _GLIBCXX_ALWAYS_INLINE
bool
590 compare_exchange_strong(__int_type& __i1, __int_type __i2,
591 memory_order __m = memory_order_seq_cst)
noexcept
593 return compare_exchange_strong(__i1, __i2, __m,
594 __cmpexch_failure_order(__m));
597 _GLIBCXX_ALWAYS_INLINE
bool
598 compare_exchange_strong(__int_type& __i1, __int_type __i2,
599 memory_order __m = memory_order_seq_cst)
volatile noexcept
601 return compare_exchange_strong(__i1, __i2, __m,
602 __cmpexch_failure_order(__m));
605#if __glibcxx_atomic_wait
606 _GLIBCXX_ALWAYS_INLINE
void
607 wait(__int_type __old,
608 memory_order __m = memory_order_seq_cst)
const noexcept
610 std::__atomic_wait_address_v(&_M_i, __old,
611 [__m,
this] {
return this->load(__m); });
616 _GLIBCXX_ALWAYS_INLINE
void
617 notify_one() noexcept
618 { std::__atomic_notify_address(&_M_i,
false); }
622 _GLIBCXX_ALWAYS_INLINE
void
623 notify_all() noexcept
624 { std::__atomic_notify_address(&_M_i,
true); }
629 _GLIBCXX_ALWAYS_INLINE __int_type
630 fetch_add(__int_type __i,
631 memory_order __m = memory_order_seq_cst)
noexcept
632 {
return __atomic_fetch_add(&_M_i, __i,
int(__m)); }
634 _GLIBCXX_ALWAYS_INLINE __int_type
635 fetch_add(__int_type __i,
636 memory_order __m = memory_order_seq_cst)
volatile noexcept
637 {
return __atomic_fetch_add(&_M_i, __i,
int(__m)); }
639 _GLIBCXX_ALWAYS_INLINE __int_type
640 fetch_sub(__int_type __i,
641 memory_order __m = memory_order_seq_cst)
noexcept
642 {
return __atomic_fetch_sub(&_M_i, __i,
int(__m)); }
644 _GLIBCXX_ALWAYS_INLINE __int_type
645 fetch_sub(__int_type __i,
646 memory_order __m = memory_order_seq_cst)
volatile noexcept
647 {
return __atomic_fetch_sub(&_M_i, __i,
int(__m)); }
649 _GLIBCXX_ALWAYS_INLINE __int_type
650 fetch_and(__int_type __i,
651 memory_order __m = memory_order_seq_cst)
noexcept
652 {
return __atomic_fetch_and(&_M_i, __i,
int(__m)); }
654 _GLIBCXX_ALWAYS_INLINE __int_type
655 fetch_and(__int_type __i,
656 memory_order __m = memory_order_seq_cst)
volatile noexcept
657 {
return __atomic_fetch_and(&_M_i, __i,
int(__m)); }
659 _GLIBCXX_ALWAYS_INLINE __int_type
660 fetch_or(__int_type __i,
661 memory_order __m = memory_order_seq_cst)
noexcept
662 {
return __atomic_fetch_or(&_M_i, __i,
int(__m)); }
664 _GLIBCXX_ALWAYS_INLINE __int_type
665 fetch_or(__int_type __i,
666 memory_order __m = memory_order_seq_cst)
volatile noexcept
667 {
return __atomic_fetch_or(&_M_i, __i,
int(__m)); }
669 _GLIBCXX_ALWAYS_INLINE __int_type
670 fetch_xor(__int_type __i,
671 memory_order __m = memory_order_seq_cst)
noexcept
672 {
return __atomic_fetch_xor(&_M_i, __i,
int(__m)); }
674 _GLIBCXX_ALWAYS_INLINE __int_type
675 fetch_xor(__int_type __i,
676 memory_order __m = memory_order_seq_cst)
volatile noexcept
677 {
return __atomic_fetch_xor(&_M_i, __i,
int(__m)); }
682 template<
typename _PTp>
683 struct __atomic_base<_PTp*>
686 typedef _PTp* __pointer_type;
688 __pointer_type _M_p _GLIBCXX20_INIT(
nullptr);
690 static constexpr ptrdiff_t
691 _S_type_size(ptrdiff_t __d)
692 {
return __d *
sizeof(_PTp); }
695 __atomic_base() noexcept = default;
696 ~__atomic_base() noexcept = default;
697 __atomic_base(const __atomic_base&) = delete;
698 __atomic_base& operator=(const __atomic_base&) = delete;
699 __atomic_base& operator=(const __atomic_base&) volatile = delete;
702 constexpr __atomic_base(__pointer_type __p) noexcept : _M_p (__p) { }
704 operator __pointer_type() const noexcept
707 operator __pointer_type() const volatile noexcept
711 operator=(__pointer_type __p)
noexcept
718 operator=(__pointer_type __p)
volatile noexcept
725 operator++(
int)
noexcept
726 {
return fetch_add(1); }
729 operator++(
int)
volatile noexcept
730 {
return fetch_add(1); }
733 operator--(
int)
noexcept
734 {
return fetch_sub(1); }
737 operator--(
int)
volatile noexcept
738 {
return fetch_sub(1); }
741 operator++() noexcept
742 {
return __atomic_add_fetch(&_M_p, _S_type_size(1),
743 int(memory_order_seq_cst)); }
746 operator++() volatile noexcept
747 {
return __atomic_add_fetch(&_M_p, _S_type_size(1),
748 int(memory_order_seq_cst)); }
751 operator--() noexcept
752 {
return __atomic_sub_fetch(&_M_p, _S_type_size(1),
753 int(memory_order_seq_cst)); }
756 operator--() volatile noexcept
757 {
return __atomic_sub_fetch(&_M_p, _S_type_size(1),
758 int(memory_order_seq_cst)); }
761 operator+=(ptrdiff_t __d)
noexcept
762 {
return __atomic_add_fetch(&_M_p, _S_type_size(__d),
763 int(memory_order_seq_cst)); }
766 operator+=(ptrdiff_t __d)
volatile noexcept
767 {
return __atomic_add_fetch(&_M_p, _S_type_size(__d),
768 int(memory_order_seq_cst)); }
771 operator-=(ptrdiff_t __d)
noexcept
772 {
return __atomic_sub_fetch(&_M_p, _S_type_size(__d),
773 int(memory_order_seq_cst)); }
776 operator-=(ptrdiff_t __d)
volatile noexcept
777 {
return __atomic_sub_fetch(&_M_p, _S_type_size(__d),
778 int(memory_order_seq_cst)); }
781 is_lock_free() const noexcept
784 return __atomic_is_lock_free(
sizeof(_M_p),
785 reinterpret_cast<void *
>(-__alignof(_M_p)));
789 is_lock_free() const volatile noexcept
792 return __atomic_is_lock_free(
sizeof(_M_p),
793 reinterpret_cast<void *
>(-__alignof(_M_p)));
796 _GLIBCXX_ALWAYS_INLINE
void
797 store(__pointer_type __p,
801 = __m & __memory_order_mask;
803 __glibcxx_assert(__b != memory_order_acquire);
804 __glibcxx_assert(__b != memory_order_acq_rel);
805 __glibcxx_assert(__b != memory_order_consume);
807 __atomic_store_n(&_M_p, __p,
int(__m));
810 _GLIBCXX_ALWAYS_INLINE
void
811 store(__pointer_type __p,
812 memory_order __m = memory_order_seq_cst)
volatile noexcept
815 = __m & __memory_order_mask;
816 __glibcxx_assert(__b != memory_order_acquire);
817 __glibcxx_assert(__b != memory_order_acq_rel);
818 __glibcxx_assert(__b != memory_order_consume);
820 __atomic_store_n(&_M_p, __p,
int(__m));
823 _GLIBCXX_ALWAYS_INLINE __pointer_type
824 load(
memory_order __m = memory_order_seq_cst)
const noexcept
827 = __m & __memory_order_mask;
828 __glibcxx_assert(__b != memory_order_release);
829 __glibcxx_assert(__b != memory_order_acq_rel);
831 return __atomic_load_n(&_M_p,
int(__m));
834 _GLIBCXX_ALWAYS_INLINE __pointer_type
835 load(
memory_order __m = memory_order_seq_cst)
const volatile noexcept
838 = __m & __memory_order_mask;
839 __glibcxx_assert(__b != memory_order_release);
840 __glibcxx_assert(__b != memory_order_acq_rel);
842 return __atomic_load_n(&_M_p,
int(__m));
845 _GLIBCXX_ALWAYS_INLINE __pointer_type
846 exchange(__pointer_type __p,
849 return __atomic_exchange_n(&_M_p, __p,
int(__m));
853 _GLIBCXX_ALWAYS_INLINE __pointer_type
854 exchange(__pointer_type __p,
855 memory_order __m = memory_order_seq_cst)
volatile noexcept
857 return __atomic_exchange_n(&_M_p, __p,
int(__m));
860 _GLIBCXX_ALWAYS_INLINE
bool
861 compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
865 __glibcxx_assert(__is_valid_cmpexch_failure_order(__m2));
867 return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 1,
868 int(__m1),
int(__m2));
871 _GLIBCXX_ALWAYS_INLINE
bool
872 compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
876 __glibcxx_assert(__is_valid_cmpexch_failure_order(__m2));
878 return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 1,
879 int(__m1),
int(__m2));
882 _GLIBCXX_ALWAYS_INLINE
bool
883 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
887 __glibcxx_assert(__is_valid_cmpexch_failure_order(__m2));
889 return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0,
890 int(__m1),
int(__m2));
893 _GLIBCXX_ALWAYS_INLINE
bool
894 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
898 __glibcxx_assert(__is_valid_cmpexch_failure_order(__m2));
900 return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0,
901 int(__m1),
int(__m2));
904#if __glibcxx_atomic_wait
905 _GLIBCXX_ALWAYS_INLINE
void
906 wait(__pointer_type __old,
909 std::__atomic_wait_address_v(&_M_p, __old,
911 {
return this->load(__m); });
916 _GLIBCXX_ALWAYS_INLINE
void
917 notify_one() const noexcept
918 { std::__atomic_notify_address(&_M_p,
false); }
922 _GLIBCXX_ALWAYS_INLINE
void
923 notify_all() const noexcept
924 { std::__atomic_notify_address(&_M_p,
true); }
929 _GLIBCXX_ALWAYS_INLINE __pointer_type
930 fetch_add(ptrdiff_t __d,
932 {
return __atomic_fetch_add(&_M_p, _S_type_size(__d),
int(__m)); }
934 _GLIBCXX_ALWAYS_INLINE __pointer_type
935 fetch_add(ptrdiff_t __d,
936 memory_order __m = memory_order_seq_cst)
volatile noexcept
937 {
return __atomic_fetch_add(&_M_p, _S_type_size(__d),
int(__m)); }
939 _GLIBCXX_ALWAYS_INLINE __pointer_type
940 fetch_sub(ptrdiff_t __d,
942 {
return __atomic_fetch_sub(&_M_p, _S_type_size(__d),
int(__m)); }
944 _GLIBCXX_ALWAYS_INLINE __pointer_type
945 fetch_sub(ptrdiff_t __d,
946 memory_order __m = memory_order_seq_cst)
volatile noexcept
947 {
return __atomic_fetch_sub(&_M_p, _S_type_size(__d),
int(__m)); }
950 namespace __atomic_impl
954 template<
typename _Tp>
956 __maybe_has_padding()
958#if ! __has_builtin(__builtin_clear_padding)
960#elif __has_builtin(__has_unique_object_representations)
961 return !__has_unique_object_representations(_Tp)
962 && !is_same<_Tp, float>::value && !is_same<_Tp, double>::value;
968 template<
typename _Tp>
969 _GLIBCXX_ALWAYS_INLINE _GLIBCXX14_CONSTEXPR _Tp*
970 __clear_padding(_Tp& __val)
noexcept
973#if __has_builtin(__builtin_clear_padding)
974 if _GLIBCXX17_CONSTEXPR (__atomic_impl::__maybe_has_padding<_Tp>())
975 __builtin_clear_padding(__ptr);
981 template<
typename _Tp>
982 using _Val =
typename remove_volatile<_Tp>::type;
984#pragma GCC diagnostic push
985#pragma GCC diagnostic ignored "-Wc++17-extensions"
987 template<
bool _AtomicRef = false,
typename _Tp>
988 _GLIBCXX_ALWAYS_INLINE
bool
989 __compare_exchange(_Tp& __val, _Val<_Tp>& __e, _Val<_Tp>& __i,
991 memory_order __s, memory_order __f)
noexcept
993 __glibcxx_assert(__is_valid_cmpexch_failure_order(__f));
995 using _Vp = _Val<_Tp>;
998 if constexpr (!__atomic_impl::__maybe_has_padding<_Vp>())
1002 int(__s),
int(__f));
1004 else if constexpr (!_AtomicRef)
1007 _Vp*
const __pi = __atomic_impl::__clear_padding(__i);
1011 _Vp*
const __pexp = __atomic_impl::__clear_padding(__exp);
1015 if (__atomic_compare_exchange(__pval, __pexp, __pi,
1016 __is_weak,
int(__s),
int(__f)))
1025 _Vp*
const __pi = __atomic_impl::__clear_padding(__i);
1031 _Vp*
const __pexp = __atomic_impl::__clear_padding(__exp);
1048 if (__atomic_compare_exchange(__pval, __pexp, __pi,
1049 __is_weak,
int(__s),
int(__f)))
1056 if (__builtin_memcmp(__atomic_impl::__clear_padding(__orig),
1057 __atomic_impl::__clear_padding(__curr),
1068#pragma GCC diagnostic pop
1071#if __cplusplus > 201703L
1073 namespace __atomic_impl
1076 template<
typename _Tp>
1077 using _Diff = __conditional_t<is_pointer_v<_Tp>, ptrdiff_t, _Val<_Tp>>;
1079 template<
size_t _Size,
size_t _Align>
1080 _GLIBCXX_ALWAYS_INLINE
bool
1081 is_lock_free() noexcept
1084 return __atomic_is_lock_free(_Size,
reinterpret_cast<void *
>(-_Align));
1087 template<
typename _Tp>
1088 _GLIBCXX_ALWAYS_INLINE
void
1089 store(_Tp* __ptr, _Val<_Tp> __t, memory_order __m)
noexcept
1091 __atomic_store(__ptr, __atomic_impl::__clear_padding(__t),
int(__m));
1094 template<
typename _Tp>
1095 _GLIBCXX_ALWAYS_INLINE _Val<_Tp>
1096 load(
const _Tp* __ptr, memory_order __m)
noexcept
1098 alignas(_Tp)
unsigned char __buf[
sizeof(_Tp)];
1099 auto* __dest =
reinterpret_cast<_Val<_Tp>*
>(__buf);
1100 __atomic_load(__ptr, __dest,
int(__m));
1104 template<
typename _Tp>
1105 _GLIBCXX_ALWAYS_INLINE _Val<_Tp>
1106 exchange(_Tp* __ptr, _Val<_Tp> __desired, memory_order __m)
noexcept
1108 alignas(_Tp)
unsigned char __buf[
sizeof(_Tp)];
1109 auto* __dest =
reinterpret_cast<_Val<_Tp>*
>(__buf);
1110 __atomic_exchange(__ptr, __atomic_impl::__clear_padding(__desired),
1115 template<
bool _AtomicRef = false,
typename _Tp>
1116 _GLIBCXX_ALWAYS_INLINE
bool
1117 compare_exchange_weak(_Tp* __ptr, _Val<_Tp>& __expected,
1118 _Val<_Tp> __desired, memory_order __success,
1119 memory_order __failure)
noexcept
1121 return __atomic_impl::__compare_exchange<_AtomicRef>(
1122 *__ptr, __expected, __desired,
true, __success, __failure);
1125 template<
bool _AtomicRef = false,
typename _Tp>
1126 _GLIBCXX_ALWAYS_INLINE
bool
1127 compare_exchange_strong(_Tp* __ptr, _Val<_Tp>& __expected,
1128 _Val<_Tp> __desired, memory_order __success,
1129 memory_order __failure)
noexcept
1131 return __atomic_impl::__compare_exchange<_AtomicRef>(
1132 *__ptr, __expected, __desired,
false, __success, __failure);
1135#if __glibcxx_atomic_wait
1136 template<
typename _Tp>
1137 _GLIBCXX_ALWAYS_INLINE
void
1138 wait(
const _Tp* __ptr, _Val<_Tp> __old,
1139 memory_order __m = memory_order_seq_cst)
noexcept
1141 std::__atomic_wait_address_v(__ptr, __old,
1142 [__ptr, __m]() {
return __atomic_impl::load(__ptr, __m); });
1147 template<
typename _Tp>
1148 _GLIBCXX_ALWAYS_INLINE
void
1149 notify_one(
const _Tp* __ptr)
noexcept
1150 { std::__atomic_notify_address(__ptr,
false); }
1154 template<
typename _Tp>
1155 _GLIBCXX_ALWAYS_INLINE
void
1156 notify_all(
const _Tp* __ptr)
noexcept
1157 { std::__atomic_notify_address(__ptr,
true); }
1162 template<
typename _Tp>
1163 _GLIBCXX_ALWAYS_INLINE _Tp
1164 fetch_add(_Tp* __ptr, _Diff<_Tp> __i, memory_order __m)
noexcept
1165 {
return __atomic_fetch_add(__ptr, __i,
int(__m)); }
1167 template<
typename _Tp>
1168 _GLIBCXX_ALWAYS_INLINE _Tp
1169 fetch_sub(_Tp* __ptr, _Diff<_Tp> __i, memory_order __m)
noexcept
1170 {
return __atomic_fetch_sub(__ptr, __i,
int(__m)); }
1172 template<
typename _Tp>
1173 _GLIBCXX_ALWAYS_INLINE _Tp
1174 fetch_and(_Tp* __ptr, _Val<_Tp> __i, memory_order __m)
noexcept
1175 {
return __atomic_fetch_and(__ptr, __i,
int(__m)); }
1177 template<
typename _Tp>
1178 _GLIBCXX_ALWAYS_INLINE _Tp
1179 fetch_or(_Tp* __ptr, _Val<_Tp> __i, memory_order __m)
noexcept
1180 {
return __atomic_fetch_or(__ptr, __i,
int(__m)); }
1182 template<
typename _Tp>
1183 _GLIBCXX_ALWAYS_INLINE _Tp
1184 fetch_xor(_Tp* __ptr, _Val<_Tp> __i, memory_order __m)
noexcept
1185 {
return __atomic_fetch_xor(__ptr, __i,
int(__m)); }
1187 template<
typename _Tp>
1188 _GLIBCXX_ALWAYS_INLINE _Tp
1189 __add_fetch(_Tp* __ptr, _Diff<_Tp> __i)
noexcept
1190 {
return __atomic_add_fetch(__ptr, __i, __ATOMIC_SEQ_CST); }
1192 template<
typename _Tp>
1193 _GLIBCXX_ALWAYS_INLINE _Tp
1194 __sub_fetch(_Tp* __ptr, _Diff<_Tp> __i)
noexcept
1195 {
return __atomic_sub_fetch(__ptr, __i, __ATOMIC_SEQ_CST); }
1197 template<
typename _Tp>
1198 _GLIBCXX_ALWAYS_INLINE _Tp
1199 __and_fetch(_Tp* __ptr, _Val<_Tp> __i)
noexcept
1200 {
return __atomic_and_fetch(__ptr, __i, __ATOMIC_SEQ_CST); }
1202 template<
typename _Tp>
1203 _GLIBCXX_ALWAYS_INLINE _Tp
1204 __or_fetch(_Tp* __ptr, _Val<_Tp> __i)
noexcept
1205 {
return __atomic_or_fetch(__ptr, __i, __ATOMIC_SEQ_CST); }
1207 template<
typename _Tp>
1208 _GLIBCXX_ALWAYS_INLINE _Tp
1209 __xor_fetch(_Tp* __ptr, _Val<_Tp> __i)
noexcept
1210 {
return __atomic_xor_fetch(__ptr, __i, __ATOMIC_SEQ_CST); }
1212 template<
typename _Tp>
1214 __fetch_add_flt(_Tp* __ptr, _Val<_Tp> __i, memory_order __m)
noexcept
1216 _Val<_Tp> __oldval = load(__ptr, memory_order_relaxed);
1217 _Val<_Tp> __newval = __oldval + __i;
1218 while (!compare_exchange_weak(__ptr, __oldval, __newval, __m,
1219 memory_order_relaxed))
1220 __newval = __oldval + __i;
1224 template<
typename _Tp>
1226 __fetch_sub_flt(_Tp* __ptr, _Val<_Tp> __i, memory_order __m)
noexcept
1228 _Val<_Tp> __oldval = load(__ptr, memory_order_relaxed);
1229 _Val<_Tp> __newval = __oldval - __i;
1230 while (!compare_exchange_weak(__ptr, __oldval, __newval, __m,
1231 memory_order_relaxed))
1232 __newval = __oldval - __i;
1236 template<
typename _Tp>
1238 __add_fetch_flt(_Tp* __ptr, _Val<_Tp> __i)
noexcept
1240 _Val<_Tp> __oldval = load(__ptr, memory_order_relaxed);
1241 _Val<_Tp> __newval = __oldval + __i;
1242 while (!compare_exchange_weak(__ptr, __oldval, __newval,
1243 memory_order_seq_cst,
1244 memory_order_relaxed))
1245 __newval = __oldval + __i;
1249 template<
typename _Tp>
1251 __sub_fetch_flt(_Tp* __ptr, _Val<_Tp> __i)
noexcept
1253 _Val<_Tp> __oldval = load(__ptr, memory_order_relaxed);
1254 _Val<_Tp> __newval = __oldval - __i;
1255 while (!compare_exchange_weak(__ptr, __oldval, __newval,
1256 memory_order_seq_cst,
1257 memory_order_relaxed))
1258 __newval = __oldval - __i;
1264 template<
typename _Fp>
1265 struct __atomic_float
1267 static_assert(is_floating_point_v<_Fp>);
1269 static constexpr size_t _S_alignment = __alignof__(_Fp);
1272 using value_type = _Fp;
1273 using difference_type = value_type;
1275 static constexpr bool is_always_lock_free
1276 = __atomic_always_lock_free(
sizeof(_Fp), 0);
1278 __atomic_float() =
default;
1281 __atomic_float(_Fp __t) : _M_fp(__t)
1282 { __atomic_impl::__clear_padding(_M_fp); }
1284 __atomic_float(
const __atomic_float&) =
delete;
1285 __atomic_float& operator=(
const __atomic_float&) =
delete;
1286 __atomic_float& operator=(
const __atomic_float&)
volatile =
delete;
1289 operator=(_Fp __t)
volatile noexcept
1296 operator=(_Fp __t)
noexcept
1303 is_lock_free() const volatile noexcept
1304 {
return __atomic_impl::is_lock_free<sizeof(_Fp), _S_alignment>(); }
1307 is_lock_free() const noexcept
1308 {
return __atomic_impl::is_lock_free<sizeof(_Fp), _S_alignment>(); }
1311 store(_Fp __t, memory_order __m = memory_order_seq_cst)
volatile noexcept
1312 { __atomic_impl::store(&_M_fp, __t, __m); }
1315 store(_Fp __t, memory_order __m = memory_order_seq_cst)
noexcept
1316 { __atomic_impl::store(&_M_fp, __t, __m); }
1319 load(memory_order __m = memory_order_seq_cst)
const volatile noexcept
1320 {
return __atomic_impl::load(&_M_fp, __m); }
1323 load(memory_order __m = memory_order_seq_cst)
const noexcept
1324 {
return __atomic_impl::load(&_M_fp, __m); }
1326 operator _Fp() const volatile noexcept {
return this->load(); }
1327 operator _Fp() const noexcept {
return this->load(); }
1330 exchange(_Fp __desired,
1331 memory_order __m = memory_order_seq_cst)
volatile noexcept
1332 {
return __atomic_impl::exchange(&_M_fp, __desired, __m); }
1335 exchange(_Fp __desired,
1336 memory_order __m = memory_order_seq_cst)
noexcept
1337 {
return __atomic_impl::exchange(&_M_fp, __desired, __m); }
1340 compare_exchange_weak(_Fp& __expected, _Fp __desired,
1341 memory_order __success,
1342 memory_order __failure)
noexcept
1344 return __atomic_impl::compare_exchange_weak(&_M_fp,
1345 __expected, __desired,
1346 __success, __failure);
1350 compare_exchange_weak(_Fp& __expected, _Fp __desired,
1351 memory_order __success,
1352 memory_order __failure)
volatile noexcept
1354 return __atomic_impl::compare_exchange_weak(&_M_fp,
1355 __expected, __desired,
1356 __success, __failure);
1360 compare_exchange_strong(_Fp& __expected, _Fp __desired,
1361 memory_order __success,
1362 memory_order __failure)
noexcept
1364 return __atomic_impl::compare_exchange_strong(&_M_fp,
1365 __expected, __desired,
1366 __success, __failure);
1370 compare_exchange_strong(_Fp& __expected, _Fp __desired,
1371 memory_order __success,
1372 memory_order __failure)
volatile noexcept
1374 return __atomic_impl::compare_exchange_strong(&_M_fp,
1375 __expected, __desired,
1376 __success, __failure);
1380 compare_exchange_weak(_Fp& __expected, _Fp __desired,
1381 memory_order __order = memory_order_seq_cst)
1384 return compare_exchange_weak(__expected, __desired, __order,
1385 __cmpexch_failure_order(__order));
1389 compare_exchange_weak(_Fp& __expected, _Fp __desired,
1390 memory_order __order = memory_order_seq_cst)
1393 return compare_exchange_weak(__expected, __desired, __order,
1394 __cmpexch_failure_order(__order));
1398 compare_exchange_strong(_Fp& __expected, _Fp __desired,
1399 memory_order __order = memory_order_seq_cst)
1402 return compare_exchange_strong(__expected, __desired, __order,
1403 __cmpexch_failure_order(__order));
1407 compare_exchange_strong(_Fp& __expected, _Fp __desired,
1408 memory_order __order = memory_order_seq_cst)
1411 return compare_exchange_strong(__expected, __desired, __order,
1412 __cmpexch_failure_order(__order));
1415#if __glibcxx_atomic_wait
1416 _GLIBCXX_ALWAYS_INLINE
void
1417 wait(_Fp __old, memory_order __m = memory_order_seq_cst)
const noexcept
1418 { __atomic_impl::wait(&_M_fp, __old, __m); }
1422 _GLIBCXX_ALWAYS_INLINE
void
1423 notify_one() const noexcept
1424 { __atomic_impl::notify_one(&_M_fp); }
1428 _GLIBCXX_ALWAYS_INLINE
void
1429 notify_all() const noexcept
1430 { __atomic_impl::notify_all(&_M_fp); }
1436 fetch_add(value_type __i,
1437 memory_order __m = memory_order_seq_cst)
noexcept
1438 {
return __atomic_impl::__fetch_add_flt(&_M_fp, __i, __m); }
1441 fetch_add(value_type __i,
1442 memory_order __m = memory_order_seq_cst)
volatile noexcept
1443 {
return __atomic_impl::__fetch_add_flt(&_M_fp, __i, __m); }
1446 fetch_sub(value_type __i,
1447 memory_order __m = memory_order_seq_cst)
noexcept
1448 {
return __atomic_impl::__fetch_sub_flt(&_M_fp, __i, __m); }
1451 fetch_sub(value_type __i,
1452 memory_order __m = memory_order_seq_cst)
volatile noexcept
1453 {
return __atomic_impl::__fetch_sub_flt(&_M_fp, __i, __m); }
1456 operator+=(value_type __i)
noexcept
1457 {
return __atomic_impl::__add_fetch_flt(&_M_fp, __i); }
1460 operator+=(value_type __i)
volatile noexcept
1461 {
return __atomic_impl::__add_fetch_flt(&_M_fp, __i); }
1464 operator-=(value_type __i)
noexcept
1465 {
return __atomic_impl::__sub_fetch_flt(&_M_fp, __i); }
1468 operator-=(value_type __i)
volatile noexcept
1469 {
return __atomic_impl::__sub_fetch_flt(&_M_fp, __i); }
1472 alignas(_S_alignment) _Fp _M_fp _GLIBCXX20_INIT(0);
1474#undef _GLIBCXX20_INIT
1476 template<
typename _Tp,
1477 bool = is_integral_v<_Tp> && !is_same_v<_Tp, bool>,
1478 bool = is_floating_point_v<_Tp>>
1479 struct __atomic_ref;
1482 template<
typename _Tp>
1483 struct __atomic_ref<_Tp, false, false>
1485 static_assert(is_trivially_copyable_v<_Tp>);
1488 static constexpr int _S_min_alignment
1489 = (
sizeof(_Tp) & (
sizeof(_Tp) - 1)) ||
sizeof(_Tp) > 16
1493 using value_type = _Tp;
1495 static constexpr bool is_always_lock_free
1496 = __atomic_always_lock_free(
sizeof(_Tp), 0);
1498 static constexpr size_t required_alignment
1499 = _S_min_alignment >
alignof(_Tp) ? _S_min_alignment : alignof(_Tp);
1501 __atomic_ref& operator=(
const __atomic_ref&) =
delete;
1504 __atomic_ref(_Tp& __t) : _M_ptr(std::
__addressof(__t))
1506 __glibcxx_assert(((__UINTPTR_TYPE__)_M_ptr % required_alignment) == 0);
1509 __atomic_ref(
const __atomic_ref&)
noexcept =
default;
1512 operator=(_Tp __t)
const noexcept
1518 operator _Tp() const noexcept {
return this->load(); }
1521 is_lock_free() const noexcept
1522 {
return __atomic_impl::is_lock_free<sizeof(_Tp), required_alignment>(); }
1525 store(_Tp __t, memory_order __m = memory_order_seq_cst)
const noexcept
1526 { __atomic_impl::store(_M_ptr, __t, __m); }
1529 load(memory_order __m = memory_order_seq_cst)
const noexcept
1530 {
return __atomic_impl::load(_M_ptr, __m); }
1533 exchange(_Tp __desired, memory_order __m = memory_order_seq_cst)
1535 {
return __atomic_impl::exchange(_M_ptr, __desired, __m); }
1538 compare_exchange_weak(_Tp& __expected, _Tp __desired,
1539 memory_order __success,
1540 memory_order __failure)
const noexcept
1542 return __atomic_impl::compare_exchange_weak<true>(
1543 _M_ptr, __expected, __desired, __success, __failure);
1547 compare_exchange_strong(_Tp& __expected, _Tp __desired,
1548 memory_order __success,
1549 memory_order __failure)
const noexcept
1551 return __atomic_impl::compare_exchange_strong<true>(
1552 _M_ptr, __expected, __desired, __success, __failure);
1556 compare_exchange_weak(_Tp& __expected, _Tp __desired,
1557 memory_order __order = memory_order_seq_cst)
1560 return compare_exchange_weak(__expected, __desired, __order,
1561 __cmpexch_failure_order(__order));
1565 compare_exchange_strong(_Tp& __expected, _Tp __desired,
1566 memory_order __order = memory_order_seq_cst)
1569 return compare_exchange_strong(__expected, __desired, __order,
1570 __cmpexch_failure_order(__order));
1573#if __glibcxx_atomic_wait
1574 _GLIBCXX_ALWAYS_INLINE
void
1575 wait(_Tp __old, memory_order __m = memory_order_seq_cst)
const noexcept
1576 { __atomic_impl::wait(_M_ptr, __old, __m); }
1580 _GLIBCXX_ALWAYS_INLINE
void
1581 notify_one() const noexcept
1582 { __atomic_impl::notify_one(_M_ptr); }
1586 _GLIBCXX_ALWAYS_INLINE
void
1587 notify_all() const noexcept
1588 { __atomic_impl::notify_all(_M_ptr); }
1598 template<
typename _Tp>
1599 struct __atomic_ref<_Tp, true, false>
1601 static_assert(is_integral_v<_Tp>);
1604 using value_type = _Tp;
1605 using difference_type = value_type;
1607 static constexpr bool is_always_lock_free
1608 = __atomic_always_lock_free(
sizeof(_Tp), 0);
1610 static constexpr size_t required_alignment
1611 =
sizeof(_Tp) >
alignof(_Tp) ?
sizeof(_Tp) : alignof(_Tp);
1613 __atomic_ref() =
delete;
1614 __atomic_ref& operator=(
const __atomic_ref&) =
delete;
1617 __atomic_ref(_Tp& __t) : _M_ptr(&__t)
1619 __glibcxx_assert(((__UINTPTR_TYPE__)_M_ptr % required_alignment) == 0);
1622 __atomic_ref(
const __atomic_ref&)
noexcept =
default;
1625 operator=(_Tp __t)
const noexcept
1631 operator _Tp() const noexcept {
return this->load(); }
1634 is_lock_free() const noexcept
1636 return __atomic_impl::is_lock_free<sizeof(_Tp), required_alignment>();
1640 store(_Tp __t, memory_order __m = memory_order_seq_cst)
const noexcept
1641 { __atomic_impl::store(_M_ptr, __t, __m); }
1644 load(memory_order __m = memory_order_seq_cst)
const noexcept
1645 {
return __atomic_impl::load(_M_ptr, __m); }
1648 exchange(_Tp __desired,
1649 memory_order __m = memory_order_seq_cst)
const noexcept
1650 {
return __atomic_impl::exchange(_M_ptr, __desired, __m); }
1653 compare_exchange_weak(_Tp& __expected, _Tp __desired,
1654 memory_order __success,
1655 memory_order __failure)
const noexcept
1657 return __atomic_impl::compare_exchange_weak<true>(
1658 _M_ptr, __expected, __desired, __success, __failure);
1662 compare_exchange_strong(_Tp& __expected, _Tp __desired,
1663 memory_order __success,
1664 memory_order __failure)
const noexcept
1666 return __atomic_impl::compare_exchange_strong<true>(
1667 _M_ptr, __expected, __desired, __success, __failure);
1671 compare_exchange_weak(_Tp& __expected, _Tp __desired,
1672 memory_order __order = memory_order_seq_cst)
1675 return compare_exchange_weak(__expected, __desired, __order,
1676 __cmpexch_failure_order(__order));
1680 compare_exchange_strong(_Tp& __expected, _Tp __desired,
1681 memory_order __order = memory_order_seq_cst)
1684 return compare_exchange_strong(__expected, __desired, __order,
1685 __cmpexch_failure_order(__order));
1688#if __glibcxx_atomic_wait
1689 _GLIBCXX_ALWAYS_INLINE
void
1690 wait(_Tp __old, memory_order __m = memory_order_seq_cst)
const noexcept
1691 { __atomic_impl::wait(_M_ptr, __old, __m); }
1695 _GLIBCXX_ALWAYS_INLINE
void
1696 notify_one() const noexcept
1697 { __atomic_impl::notify_one(_M_ptr); }
1701 _GLIBCXX_ALWAYS_INLINE
void
1702 notify_all() const noexcept
1703 { __atomic_impl::notify_all(_M_ptr); }
1709 fetch_add(value_type __i,
1710 memory_order __m = memory_order_seq_cst)
const noexcept
1711 {
return __atomic_impl::fetch_add(_M_ptr, __i, __m); }
1714 fetch_sub(value_type __i,
1715 memory_order __m = memory_order_seq_cst)
const noexcept
1716 {
return __atomic_impl::fetch_sub(_M_ptr, __i, __m); }
1719 fetch_and(value_type __i,
1720 memory_order __m = memory_order_seq_cst)
const noexcept
1721 {
return __atomic_impl::fetch_and(_M_ptr, __i, __m); }
1724 fetch_or(value_type __i,
1725 memory_order __m = memory_order_seq_cst)
const noexcept
1726 {
return __atomic_impl::fetch_or(_M_ptr, __i, __m); }
1729 fetch_xor(value_type __i,
1730 memory_order __m = memory_order_seq_cst)
const noexcept
1731 {
return __atomic_impl::fetch_xor(_M_ptr, __i, __m); }
1733 _GLIBCXX_ALWAYS_INLINE value_type
1734 operator++(
int)
const noexcept
1735 {
return fetch_add(1); }
1737 _GLIBCXX_ALWAYS_INLINE value_type
1738 operator--(
int)
const noexcept
1739 {
return fetch_sub(1); }
1742 operator++() const noexcept
1743 {
return __atomic_impl::__add_fetch(_M_ptr, value_type(1)); }
1746 operator--() const noexcept
1747 {
return __atomic_impl::__sub_fetch(_M_ptr, value_type(1)); }
1750 operator+=(value_type __i)
const noexcept
1751 {
return __atomic_impl::__add_fetch(_M_ptr, __i); }
1754 operator-=(value_type __i)
const noexcept
1755 {
return __atomic_impl::__sub_fetch(_M_ptr, __i); }
1758 operator&=(value_type __i)
const noexcept
1759 {
return __atomic_impl::__and_fetch(_M_ptr, __i); }
1762 operator|=(value_type __i)
const noexcept
1763 {
return __atomic_impl::__or_fetch(_M_ptr, __i); }
1766 operator^=(value_type __i)
const noexcept
1767 {
return __atomic_impl::__xor_fetch(_M_ptr, __i); }
1774 template<
typename _Fp>
1775 struct __atomic_ref<_Fp, false, true>
1777 static_assert(is_floating_point_v<_Fp>);
1780 using value_type = _Fp;
1781 using difference_type = value_type;
1783 static constexpr bool is_always_lock_free
1784 = __atomic_always_lock_free(
sizeof(_Fp), 0);
1786 static constexpr size_t required_alignment = __alignof__(_Fp);
1788 __atomic_ref() =
delete;
1789 __atomic_ref& operator=(
const __atomic_ref&) =
delete;
1792 __atomic_ref(_Fp& __t) : _M_ptr(&__t)
1794 __glibcxx_assert(((__UINTPTR_TYPE__)_M_ptr % required_alignment) == 0);
1797 __atomic_ref(
const __atomic_ref&)
noexcept =
default;
1800 operator=(_Fp __t)
const noexcept
1806 operator _Fp() const noexcept {
return this->load(); }
1809 is_lock_free() const noexcept
1811 return __atomic_impl::is_lock_free<sizeof(_Fp), required_alignment>();
1815 store(_Fp __t, memory_order __m = memory_order_seq_cst)
const noexcept
1816 { __atomic_impl::store(_M_ptr, __t, __m); }
1819 load(memory_order __m = memory_order_seq_cst)
const noexcept
1820 {
return __atomic_impl::load(_M_ptr, __m); }
1823 exchange(_Fp __desired,
1824 memory_order __m = memory_order_seq_cst)
const noexcept
1825 {
return __atomic_impl::exchange(_M_ptr, __desired, __m); }
1828 compare_exchange_weak(_Fp& __expected, _Fp __desired,
1829 memory_order __success,
1830 memory_order __failure)
const noexcept
1832 return __atomic_impl::compare_exchange_weak<true>(
1833 _M_ptr, __expected, __desired, __success, __failure);
1837 compare_exchange_strong(_Fp& __expected, _Fp __desired,
1838 memory_order __success,
1839 memory_order __failure)
const noexcept
1841 return __atomic_impl::compare_exchange_strong<true>(
1842 _M_ptr, __expected, __desired, __success, __failure);
1846 compare_exchange_weak(_Fp& __expected, _Fp __desired,
1847 memory_order __order = memory_order_seq_cst)
1850 return compare_exchange_weak(__expected, __desired, __order,
1851 __cmpexch_failure_order(__order));
1855 compare_exchange_strong(_Fp& __expected, _Fp __desired,
1856 memory_order __order = memory_order_seq_cst)
1859 return compare_exchange_strong(__expected, __desired, __order,
1860 __cmpexch_failure_order(__order));
1863#if __glibcxx_atomic_wait
1864 _GLIBCXX_ALWAYS_INLINE
void
1865 wait(_Fp __old, memory_order __m = memory_order_seq_cst)
const noexcept
1866 { __atomic_impl::wait(_M_ptr, __old, __m); }
1870 _GLIBCXX_ALWAYS_INLINE
void
1871 notify_one() const noexcept
1872 { __atomic_impl::notify_one(_M_ptr); }
1876 _GLIBCXX_ALWAYS_INLINE
void
1877 notify_all() const noexcept
1878 { __atomic_impl::notify_all(_M_ptr); }
1884 fetch_add(value_type __i,
1885 memory_order __m = memory_order_seq_cst)
const noexcept
1886 {
return __atomic_impl::__fetch_add_flt(_M_ptr, __i, __m); }
1889 fetch_sub(value_type __i,
1890 memory_order __m = memory_order_seq_cst)
const noexcept
1891 {
return __atomic_impl::__fetch_sub_flt(_M_ptr, __i, __m); }
1894 operator+=(value_type __i)
const noexcept
1895 {
return __atomic_impl::__add_fetch_flt(_M_ptr, __i); }
1898 operator-=(value_type __i)
const noexcept
1899 {
return __atomic_impl::__sub_fetch_flt(_M_ptr, __i); }
1906 template<
typename _Tp>
1907 struct __atomic_ref<_Tp*,
false,
false>
1913 static constexpr bool is_always_lock_free = ATOMIC_POINTER_LOCK_FREE == 2;
1915 static constexpr size_t required_alignment = __alignof__(_Tp*);
1917 __atomic_ref() =
delete;
1918 __atomic_ref& operator=(
const __atomic_ref&) =
delete;
1921 __atomic_ref(_Tp*& __t) : _M_ptr(std::
__addressof(__t))
1923 __glibcxx_assert(((__UINTPTR_TYPE__)_M_ptr % required_alignment) == 0);
1926 __atomic_ref(
const __atomic_ref&)
noexcept =
default;
1929 operator=(_Tp* __t)
const noexcept
1935 operator _Tp*()
const noexcept {
return this->load(); }
1938 is_lock_free() const noexcept
1940 return __atomic_impl::is_lock_free<sizeof(_Tp*), required_alignment>();
1944 store(_Tp* __t,
memory_order __m = memory_order_seq_cst)
const noexcept
1945 { __atomic_impl::store(_M_ptr, __t, __m); }
1948 load(
memory_order __m = memory_order_seq_cst)
const noexcept
1949 {
return __atomic_impl::load(_M_ptr, __m); }
1952 exchange(_Tp* __desired,
1953 memory_order __m = memory_order_seq_cst)
const noexcept
1954 {
return __atomic_impl::exchange(_M_ptr, __desired, __m); }
1957 compare_exchange_weak(_Tp*& __expected, _Tp* __desired,
1961 return __atomic_impl::compare_exchange_weak<true>(
1962 _M_ptr, __expected, __desired, __success, __failure);
1966 compare_exchange_strong(_Tp*& __expected, _Tp* __desired,
1970 return __atomic_impl::compare_exchange_strong<true>(
1971 _M_ptr, __expected, __desired, __success, __failure);
1975 compare_exchange_weak(_Tp*& __expected, _Tp* __desired,
1979 return compare_exchange_weak(__expected, __desired, __order,
1980 __cmpexch_failure_order(__order));
1984 compare_exchange_strong(_Tp*& __expected, _Tp* __desired,
1988 return compare_exchange_strong(__expected, __desired, __order,
1989 __cmpexch_failure_order(__order));
1992#if __glibcxx_atomic_wait
1993 _GLIBCXX_ALWAYS_INLINE
void
1994 wait(_Tp* __old,
memory_order __m = memory_order_seq_cst)
const noexcept
1995 { __atomic_impl::wait(_M_ptr, __old, __m); }
1999 _GLIBCXX_ALWAYS_INLINE
void
2000 notify_one() const noexcept
2001 { __atomic_impl::notify_one(_M_ptr); }
2005 _GLIBCXX_ALWAYS_INLINE
void
2006 notify_all() const noexcept
2007 { __atomic_impl::notify_all(_M_ptr); }
2014 memory_order __m = memory_order_seq_cst)
const noexcept
2015 {
return __atomic_impl::fetch_add(_M_ptr, _S_type_size(__d), __m); }
2019 memory_order __m = memory_order_seq_cst)
const noexcept
2020 {
return __atomic_impl::fetch_sub(_M_ptr, _S_type_size(__d), __m); }
2023 operator++(
int)
const noexcept
2024 {
return fetch_add(1); }
2027 operator--(
int)
const noexcept
2028 {
return fetch_sub(1); }
2031 operator++() const noexcept
2033 return __atomic_impl::__add_fetch(_M_ptr, _S_type_size(1));
2037 operator--() const noexcept
2039 return __atomic_impl::__sub_fetch(_M_ptr, _S_type_size(1));
2045 return __atomic_impl::__add_fetch(_M_ptr, _S_type_size(__d));
2051 return __atomic_impl::__sub_fetch(_M_ptr, _S_type_size(__d));
2055 static constexpr ptrdiff_t
2056 _S_type_size(ptrdiff_t __d)
noexcept
2058 static_assert(is_object_v<_Tp>);
2059 return __d *
sizeof(_Tp);
2070_GLIBCXX_END_NAMESPACE_VERSION
constexpr _Tp * __addressof(_Tp &__r) noexcept
Same as C++11 std::addressof.
_Tp kill_dependency(_Tp __y) noexcept
kill_dependency
memory_order
Enumeration for memory_order.
ISO C++ entities toplevel namespace is std.
constexpr bitset< _Nb > operator|(const bitset< _Nb > &__x, const bitset< _Nb > &__y) noexcept
Global bitwise operations on bitsets.
constexpr bitset< _Nb > operator&(const bitset< _Nb > &__x, const bitset< _Nb > &__y) noexcept
Global bitwise operations on bitsets.