https://gcc.gnu.org/g:e509c1127d321143eff1d08219bb1def5b31da3e
commit r17-6112-ge509c1127d321143eff1d08219bb1def5b31da3e Author: Jonathan Wakely <[email protected]> Date: Mon Oct 19 22:03:20 2026 +0100 libstdc++: Use always_inline in <atomic> with memory_order params [PR127693] As described in the bug report, std::atomic member functions might not be inlined at -Os and if that happens, the std::memory_order parameter becomes a runtime argument. This causes the atomic builtin to fall back to a seq_cst operation. By adding the always_inline attribute a compile-time constant memory order is propagated to the builtin and so it might be expanded to a more efficient implementation than for seq_cst. libstdc++-v3/ChangeLog: PR libstdc++/127693 * include/bits/atomic_base.h (__atomic_float::store) (__atomic_float::load, __atomic_float::exchange) (__atomic_float::compare_exchange_weak) (__atomic_float::compare_exchange_strong) (__atomic_float::fetch_add, __atomic_float::fetch_sub) (__atomic_float::fetch_min, __atomic_float::fetch_max) (__atomic_ref_base::load, __atomic_ref_base::store) (__atomic_ref_base::exchange) (__atomic_ref_base::compare_exchange_strong) (__atomic_ref_base::compare_exchange_weak) (__atomic_ref<integral-type>::fetch_add) (__atomic_ref<integral-type>::fetch_sub) (__atomic_ref<integral-type>::fetch_and) (__atomic_ref<integral-type>::fetch_or) (__atomic_ref<integral-type>::fetch_xor) (__atomic_ref<integral-type>::fetch_min) (__atomic_ref<integral-type>::fetch_max) (__atomic_ref<floating-point-type>::fetch_add) (__atomic_ref<floating-point-type>::fetch_sub) (__atomic_ref<floating-point-type>::fetch_min) (__atomic_ref<floating-point-type>::fetch_max): Add macro for always_inline attribute. * include/std/atomic (atomic<bool>::store) (atomic<bool>::load, atomic<bool>::exchange) (atomic<bool>::compare_exchange_weak) (atomic<bool>::compare_exchange_strong, atomic<bool>::wait) (atomic::store, atomic::load, atomic::exchange) (atomic::compare_exchange_weak, atomic::compare_exchange_strong) (atomic::wait, atomic<T*>::store, atomic<T*>::load) (atomic<T*>::exchange, atomic<T*>::compare_exchange_weak) (atomic<T*>::compare_exchange_strong, atomic<T*>::wait) (atomic<T*>::fetch_add, atomic<T*>::fetch_sub) (atomic<T*>::fetch_min, atomic<T*>::fetch_max): Likewise. * testsuite/29_atomics/atomic/127693.cc: New test. * testsuite/29_atomics/atomic_ref/127693.cc: New test. Reviewed-by: Tomasz KamiĆski <[email protected]> Diff: --- libstdc++-v3/include/bits/atomic_base.h | 40 ++++++++++++ libstdc++-v3/include/std/atomic | 53 ++++++++++++++++ libstdc++-v3/testsuite/29_atomics/atomic/127693.cc | 69 ++++++++++++++++++++ .../testsuite/29_atomics/atomic_ref/127693.cc | 74 ++++++++++++++++++++++ 4 files changed, 236 insertions(+) diff --git a/libstdc++-v3/include/bits/atomic_base.h b/libstdc++-v3/include/bits/atomic_base.h index 1d97ccf57b90..a6117a39e32c 100644 --- a/libstdc++-v3/include/bits/atomic_base.h +++ b/libstdc++-v3/include/bits/atomic_base.h @@ -1460,18 +1460,22 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION is_lock_free() const noexcept { return __atomic_impl::is_lock_free<sizeof(_Fp), _S_alignment>(); } + _GLIBCXX_ALWAYS_INLINE void store(_Fp __t, memory_order __m = memory_order_seq_cst) volatile noexcept { __atomic_impl::store(&_M_fp, __t, __m); } + _GLIBCXX_ALWAYS_INLINE void store(_Fp __t, memory_order __m = memory_order_seq_cst) noexcept { __atomic_impl::store(&_M_fp, __t, __m); } + _GLIBCXX_ALWAYS_INLINE _Fp load(memory_order __m = memory_order_seq_cst) const volatile noexcept { return __atomic_impl::load(&_M_fp, __m); } + _GLIBCXX_ALWAYS_INLINE _Fp load(memory_order __m = memory_order_seq_cst) const noexcept { return __atomic_impl::load(&_M_fp, __m); } @@ -1484,11 +1488,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_impl::exchange(&_M_fp, __desired, __m); } + _GLIBCXX_ALWAYS_INLINE _Fp exchange(_Fp __desired, memory_order __m = memory_order_seq_cst) noexcept { return __atomic_impl::exchange(&_M_fp, __desired, __m); } + _GLIBCXX_ALWAYS_INLINE bool compare_exchange_weak(_Fp& __expected, _Fp __desired, memory_order __success, @@ -1499,6 +1505,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __success, __failure); } + _GLIBCXX_ALWAYS_INLINE bool compare_exchange_weak(_Fp& __expected, _Fp __desired, memory_order __success, @@ -1509,6 +1516,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __success, __failure); } + _GLIBCXX_ALWAYS_INLINE bool compare_exchange_strong(_Fp& __expected, _Fp __desired, memory_order __success, @@ -1519,6 +1527,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __success, __failure); } + _GLIBCXX_ALWAYS_INLINE bool compare_exchange_strong(_Fp& __expected, _Fp __desired, memory_order __success, @@ -1529,6 +1538,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __success, __failure); } + _GLIBCXX_ALWAYS_INLINE bool compare_exchange_weak(_Fp& __expected, _Fp __desired, memory_order __order = memory_order_seq_cst) @@ -1538,6 +1548,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __cmpexch_failure_order(__order)); } + _GLIBCXX_ALWAYS_INLINE bool compare_exchange_weak(_Fp& __expected, _Fp __desired, memory_order __order = memory_order_seq_cst) @@ -1547,6 +1558,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __cmpexch_failure_order(__order)); } + _GLIBCXX_ALWAYS_INLINE bool compare_exchange_strong(_Fp& __expected, _Fp __desired, memory_order __order = memory_order_seq_cst) @@ -1556,6 +1568,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __cmpexch_failure_order(__order)); } + _GLIBCXX_ALWAYS_INLINE bool compare_exchange_strong(_Fp& __expected, _Fp __desired, memory_order __order = memory_order_seq_cst) @@ -1585,42 +1598,50 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION // TODO add const volatile overload #endif // __glibcxx_atomic_wait + _GLIBCXX_ALWAYS_INLINE value_type fetch_add(value_type __i, memory_order __m = memory_order_seq_cst) noexcept { return __atomic_impl::__fetch_add_flt(&_M_fp, __i, __m); } + _GLIBCXX_ALWAYS_INLINE value_type fetch_add(value_type __i, memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_impl::__fetch_add_flt(&_M_fp, __i, __m); } + _GLIBCXX_ALWAYS_INLINE value_type fetch_sub(value_type __i, memory_order __m = memory_order_seq_cst) noexcept { return __atomic_impl::__fetch_sub_flt(&_M_fp, __i, __m); } + _GLIBCXX_ALWAYS_INLINE value_type fetch_sub(value_type __i, memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_impl::__fetch_sub_flt(&_M_fp, __i, __m); } #if __glibcxx_atomic_min_max + _GLIBCXX_ALWAYS_INLINE value_type fetch_min(value_type __i, memory_order __m = memory_order_seq_cst) noexcept { return __atomic_impl::__fetch_min(&_M_fp, __i, __m); } + _GLIBCXX_ALWAYS_INLINE value_type fetch_min(value_type __i, memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_impl::__fetch_min(&_M_fp, __i, __m); } + _GLIBCXX_ALWAYS_INLINE value_type fetch_max(value_type __i, memory_order __m = memory_order_seq_cst) noexcept { return __atomic_impl::__fetch_max(&_M_fp, __i, __m); } + _GLIBCXX_ALWAYS_INLINE value_type fetch_max(value_type __i, memory_order __m = memory_order_seq_cst) volatile noexcept @@ -1715,6 +1736,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION is_lock_free() const noexcept { return __atomic_impl::is_lock_free<sizeof(_Tp), required_alignment>(); } + _GLIBCXX_ALWAYS_INLINE value_type load(memory_order __m = memory_order_seq_cst) const noexcept { return __atomic_impl::load(_M_ptr, __m); } @@ -1762,15 +1784,18 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION return __t; } + _GLIBCXX_ALWAYS_INLINE void store(value_type __t, memory_order __m = memory_order_seq_cst) const noexcept { __atomic_impl::store(this->_M_ptr, __t, __m); } + _GLIBCXX_ALWAYS_INLINE value_type exchange(value_type __desired, memory_order __m = memory_order_seq_cst) const noexcept { return __atomic_impl::exchange(this->_M_ptr, __desired, __m); } + _GLIBCXX_ALWAYS_INLINE bool compare_exchange_weak(value_type& __expected, value_type __desired, memory_order __success, @@ -1780,6 +1805,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION this->_M_ptr, __expected, __desired, __success, __failure); } + _GLIBCXX_ALWAYS_INLINE bool compare_exchange_strong(value_type& __expected, value_type __desired, memory_order __success, @@ -1789,6 +1815,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION this->_M_ptr, __expected, __desired, __success, __failure); } + _GLIBCXX_ALWAYS_INLINE bool compare_exchange_weak(value_type& __expected, value_type __desired, memory_order __order = memory_order_seq_cst) @@ -1798,6 +1825,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __cmpexch_failure_order(__order)); } + _GLIBCXX_ALWAYS_INLINE bool compare_exchange_strong(value_type& __expected, value_type __desired, memory_order __order = memory_order_seq_cst) @@ -1867,37 +1895,44 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION using __atomic_ref_base<_Tp>::__atomic_ref_base; using __atomic_ref_base<_Tp>::operator=; + _GLIBCXX_ALWAYS_INLINE value_type fetch_add(value_type __i, memory_order __m = memory_order_seq_cst) const noexcept { return __atomic_impl::fetch_add(this->_M_ptr, __i, __m); } + _GLIBCXX_ALWAYS_INLINE value_type fetch_sub(value_type __i, memory_order __m = memory_order_seq_cst) const noexcept { return __atomic_impl::fetch_sub(this->_M_ptr, __i, __m); } + _GLIBCXX_ALWAYS_INLINE value_type fetch_and(value_type __i, memory_order __m = memory_order_seq_cst) const noexcept { return __atomic_impl::fetch_and(this->_M_ptr, __i, __m); } + _GLIBCXX_ALWAYS_INLINE value_type fetch_or(value_type __i, memory_order __m = memory_order_seq_cst) const noexcept { return __atomic_impl::fetch_or(this->_M_ptr, __i, __m); } + _GLIBCXX_ALWAYS_INLINE value_type fetch_xor(value_type __i, memory_order __m = memory_order_seq_cst) const noexcept { return __atomic_impl::fetch_xor(this->_M_ptr, __i, __m); } #if __glibcxx_atomic_min_max + _GLIBCXX_ALWAYS_INLINE value_type fetch_min(value_type __i, memory_order __m = memory_order_seq_cst) const noexcept { return __atomic_impl::__fetch_min(this->_M_ptr, __i, __m); } + _GLIBCXX_ALWAYS_INLINE value_type fetch_max(value_type __i, memory_order __m = memory_order_seq_cst) const noexcept @@ -1960,22 +1995,26 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION using __atomic_ref_base<_Fp>::__atomic_ref_base; using __atomic_ref_base<_Fp>::operator=; + _GLIBCXX_ALWAYS_INLINE value_type fetch_add(value_type __i, memory_order __m = memory_order_seq_cst) const noexcept { return __atomic_impl::__fetch_add_flt(this->_M_ptr, __i, __m); } + _GLIBCXX_ALWAYS_INLINE value_type fetch_sub(value_type __i, memory_order __m = memory_order_seq_cst) const noexcept { return __atomic_impl::__fetch_sub_flt(this->_M_ptr, __i, __m); } #if __glibcxx_atomic_min_max + _GLIBCXX_ALWAYS_INLINE value_type fetch_min(value_type __i, memory_order __m = memory_order_seq_cst) const noexcept { return __atomic_impl::__fetch_min(this->_M_ptr, __i, __m); } + _GLIBCXX_ALWAYS_INLINE value_type fetch_max(value_type __i, memory_order __m = memory_order_seq_cst) const noexcept @@ -2009,6 +2048,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION using __atomic_ref_base<_Pt>::__atomic_ref_base; using __atomic_ref_base<_Pt>::operator=; + _GLIBCXX_ALWAYS_INLINE value_type fetch_add(difference_type __d, memory_order __m = memory_order_seq_cst) const noexcept diff --git a/libstdc++-v3/include/std/atomic b/libstdc++-v3/include/std/atomic index b53872c81bd8..64e8f8336aef 100644 --- a/libstdc++-v3/include/std/atomic +++ b/libstdc++-v3/include/std/atomic @@ -109,72 +109,87 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static constexpr bool is_always_lock_free = ATOMIC_BOOL_LOCK_FREE == 2; #endif + _GLIBCXX_ALWAYS_INLINE void store(bool __i, memory_order __m = memory_order_seq_cst) noexcept { _M_base.store(__i, __m); } + _GLIBCXX_ALWAYS_INLINE void store(bool __i, memory_order __m = memory_order_seq_cst) volatile noexcept { _M_base.store(__i, __m); } + _GLIBCXX_ALWAYS_INLINE bool load(memory_order __m = memory_order_seq_cst) const noexcept { return _M_base.load(__m); } + _GLIBCXX_ALWAYS_INLINE bool load(memory_order __m = memory_order_seq_cst) const volatile noexcept { return _M_base.load(__m); } + _GLIBCXX_ALWAYS_INLINE bool exchange(bool __i, memory_order __m = memory_order_seq_cst) noexcept { return _M_base.exchange(__i, __m); } + _GLIBCXX_ALWAYS_INLINE bool exchange(bool __i, memory_order __m = memory_order_seq_cst) volatile noexcept { return _M_base.exchange(__i, __m); } + _GLIBCXX_ALWAYS_INLINE bool compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1, memory_order __m2) noexcept { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); } + _GLIBCXX_ALWAYS_INLINE bool compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1, memory_order __m2) volatile noexcept { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); } + _GLIBCXX_ALWAYS_INLINE bool compare_exchange_weak(bool& __i1, bool __i2, memory_order __m = memory_order_seq_cst) noexcept { return _M_base.compare_exchange_weak(__i1, __i2, __m); } + _GLIBCXX_ALWAYS_INLINE bool compare_exchange_weak(bool& __i1, bool __i2, memory_order __m = memory_order_seq_cst) volatile noexcept { return _M_base.compare_exchange_weak(__i1, __i2, __m); } + _GLIBCXX_ALWAYS_INLINE bool compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1, memory_order __m2) noexcept { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); } + _GLIBCXX_ALWAYS_INLINE bool compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1, memory_order __m2) volatile noexcept { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); } + _GLIBCXX_ALWAYS_INLINE bool compare_exchange_strong(bool& __i1, bool __i2, memory_order __m = memory_order_seq_cst) noexcept { return _M_base.compare_exchange_strong(__i1, __i2, __m); } + _GLIBCXX_ALWAYS_INLINE bool compare_exchange_strong(bool& __i1, bool __i2, memory_order __m = memory_order_seq_cst) volatile noexcept { return _M_base.compare_exchange_strong(__i1, __i2, __m); } #if __cpp_lib_atomic_wait + _GLIBCXX_ALWAYS_INLINE void wait(bool __old, memory_order __m = memory_order_seq_cst) const noexcept { _M_base.wait(__old, __m); } @@ -294,6 +309,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION = __atomic_always_lock_free(sizeof(_M_i), 0); #endif + _GLIBCXX_ALWAYS_INLINE void store(_Tp __i, memory_order __m = memory_order_seq_cst) noexcept { @@ -302,6 +318,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION int(__m)); } + _GLIBCXX_ALWAYS_INLINE void store(_Tp __i, memory_order __m = memory_order_seq_cst) volatile noexcept { @@ -310,6 +327,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION int(__m)); } + _GLIBCXX_ALWAYS_INLINE _Tp load(memory_order __m = memory_order_seq_cst) const noexcept { @@ -319,6 +337,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION return *__ptr; } + _GLIBCXX_ALWAYS_INLINE _Tp load(memory_order __m = memory_order_seq_cst) const volatile noexcept { @@ -328,6 +347,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION return *__ptr; } + _GLIBCXX_ALWAYS_INLINE _Tp exchange(_Tp __i, memory_order __m = memory_order_seq_cst) noexcept { @@ -339,6 +359,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION return *__ptr; } + _GLIBCXX_ALWAYS_INLINE _Tp exchange(_Tp __i, memory_order __m = memory_order_seq_cst) volatile noexcept @@ -351,6 +372,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION return *__ptr; } + _GLIBCXX_ALWAYS_INLINE bool compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s, memory_order __f) noexcept @@ -359,6 +381,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __s, __f); } + _GLIBCXX_ALWAYS_INLINE bool compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s, memory_order __f) volatile noexcept @@ -367,18 +390,21 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __s, __f); } + _GLIBCXX_ALWAYS_INLINE bool compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __m = memory_order_seq_cst) noexcept { return compare_exchange_weak(__e, __i, __m, __cmpexch_failure_order(__m)); } + _GLIBCXX_ALWAYS_INLINE bool compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __m = memory_order_seq_cst) volatile noexcept { return compare_exchange_weak(__e, __i, __m, __cmpexch_failure_order(__m)); } + _GLIBCXX_ALWAYS_INLINE bool compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s, memory_order __f) noexcept @@ -387,6 +413,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __s, __f); } + _GLIBCXX_ALWAYS_INLINE bool compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s, memory_order __f) volatile noexcept @@ -395,12 +422,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __s, __f); } + _GLIBCXX_ALWAYS_INLINE bool compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __m = memory_order_seq_cst) noexcept { return compare_exchange_strong(__e, __i, __m, __cmpexch_failure_order(__m)); } + _GLIBCXX_ALWAYS_INLINE bool compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __m = memory_order_seq_cst) volatile noexcept @@ -408,6 +437,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __cmpexch_failure_order(__m)); } #if __cpp_lib_atomic_wait // C++ >= 20 + _GLIBCXX_ALWAYS_INLINE void wait(_Tp __old, memory_order __m = memory_order_seq_cst) const noexcept { @@ -581,45 +611,54 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION = ATOMIC_POINTER_LOCK_FREE == 2; #endif + _GLIBCXX_ALWAYS_INLINE void store(__pointer_type __p, memory_order __m = memory_order_seq_cst) noexcept { return _M_b.store(__p, __m); } + _GLIBCXX_ALWAYS_INLINE void store(__pointer_type __p, memory_order __m = memory_order_seq_cst) volatile noexcept { return _M_b.store(__p, __m); } + _GLIBCXX_ALWAYS_INLINE __pointer_type load(memory_order __m = memory_order_seq_cst) const noexcept { return _M_b.load(__m); } + _GLIBCXX_ALWAYS_INLINE __pointer_type load(memory_order __m = memory_order_seq_cst) const volatile noexcept { return _M_b.load(__m); } + _GLIBCXX_ALWAYS_INLINE __pointer_type exchange(__pointer_type __p, memory_order __m = memory_order_seq_cst) noexcept { return _M_b.exchange(__p, __m); } + _GLIBCXX_ALWAYS_INLINE __pointer_type exchange(__pointer_type __p, memory_order __m = memory_order_seq_cst) volatile noexcept { return _M_b.exchange(__p, __m); } + _GLIBCXX_ALWAYS_INLINE bool compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, memory_order __m1, memory_order __m2) noexcept { return _M_b.compare_exchange_weak(__p1, __p2, __m1, __m2); } + _GLIBCXX_ALWAYS_INLINE bool compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, memory_order __m1, memory_order __m2) volatile noexcept { return _M_b.compare_exchange_weak(__p1, __p2, __m1, __m2); } + _GLIBCXX_ALWAYS_INLINE bool compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, memory_order __m = memory_order_seq_cst) noexcept @@ -628,6 +667,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __cmpexch_failure_order(__m)); } + _GLIBCXX_ALWAYS_INLINE bool compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, memory_order __m = memory_order_seq_cst) volatile noexcept @@ -636,17 +676,20 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __cmpexch_failure_order(__m)); } + _GLIBCXX_ALWAYS_INLINE bool compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, memory_order __m1, memory_order __m2) noexcept { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); } + _GLIBCXX_ALWAYS_INLINE bool compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, memory_order __m1, memory_order __m2) volatile noexcept { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); } + _GLIBCXX_ALWAYS_INLINE bool compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, memory_order __m = memory_order_seq_cst) noexcept @@ -655,6 +698,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __cmpexch_failure_order(__m)); } + _GLIBCXX_ALWAYS_INLINE bool compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, memory_order __m = memory_order_seq_cst) volatile noexcept @@ -664,6 +708,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } #if __cpp_lib_atomic_wait + _GLIBCXX_ALWAYS_INLINE void wait(__pointer_type __old, memory_order __m = memory_order_seq_cst) const noexcept @@ -680,6 +725,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { _M_b.notify_all(); } #endif // __cpp_lib_atomic_wait + _GLIBCXX_ALWAYS_INLINE __pointer_type fetch_add(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) noexcept @@ -690,6 +736,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION return _M_b.fetch_add(__d, __m); } + _GLIBCXX_ALWAYS_INLINE __pointer_type fetch_add(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) volatile noexcept @@ -700,6 +747,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION return _M_b.fetch_add(__d, __m); } + _GLIBCXX_ALWAYS_INLINE __pointer_type fetch_sub(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) noexcept @@ -710,6 +758,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION return _M_b.fetch_sub(__d, __m); } + _GLIBCXX_ALWAYS_INLINE __pointer_type fetch_sub(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) volatile noexcept @@ -721,21 +770,25 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } #if __glibcxx_atomic_min_max + _GLIBCXX_ALWAYS_INLINE __pointer_type fetch_min(__pointer_type __p, memory_order __m = memory_order_seq_cst) noexcept { return _M_b.fetch_min(__p, __m); } + _GLIBCXX_ALWAYS_INLINE __pointer_type fetch_min(__pointer_type __p, memory_order __m = memory_order_seq_cst) volatile noexcept { return _M_b.fetch_min(__p, __m); } + _GLIBCXX_ALWAYS_INLINE __pointer_type fetch_max(__pointer_type __p, memory_order __m = memory_order_seq_cst) noexcept { return _M_b.fetch_max(__p, __m); } + _GLIBCXX_ALWAYS_INLINE __pointer_type fetch_max(__pointer_type __p, memory_order __m = memory_order_seq_cst) volatile noexcept diff --git a/libstdc++-v3/testsuite/29_atomics/atomic/127693.cc b/libstdc++-v3/testsuite/29_atomics/atomic/127693.cc new file mode 100644 index 000000000000..961edffaa66c --- /dev/null +++ b/libstdc++-v3/testsuite/29_atomics/atomic/127693.cc @@ -0,0 +1,69 @@ +// { dg-options "-Os -g0" } +// { dg-do compile { target c++11 } } +// { dg-final { scan-assembler-not "E4loadESt12memory_order" } } + +#include <atomic> + +enum E { Ea, Eb = 1000 }; + +std::atomic<bool> b; +std::atomic<unsigned char> u; +std::atomic<float> f; +std::atomic<int*> p; +std::atomic<enum E> e; +int sink; + +void bool_1() { if (b.load(std::memory_order_relaxed)) sink = 1; } +void bool_2() { if (b.load(std::memory_order_relaxed)) sink = 2; } +void bool_3() { if (b.load(std::memory_order_relaxed)) sink = 3; } +void bool_4() { if (b.load(std::memory_order_relaxed)) sink = 4; } +void bool_5() { if (b.load(std::memory_order_relaxed)) sink = 5; } +void bool_6() { if (b.load(std::memory_order_relaxed)) sink = 6; } +void bool_7() { if (b.load(std::memory_order_relaxed)) sink = 7; } +void bool_8() { if (b.load(std::memory_order_relaxed)) sink = 8; } +void bool_9() { if (b.load(std::memory_order_relaxed)) sink = 9; } +void bool_10() { if (b.load(std::memory_order_relaxed)) sink = 10; } + +void uchar_1() { if (u.load(std::memory_order_relaxed)) sink = 1; } +void uchar_2() { if (u.load(std::memory_order_relaxed)) sink = 2; } +void uchar_3() { if (u.load(std::memory_order_relaxed)) sink = 3; } +void uchar_4() { if (u.load(std::memory_order_relaxed)) sink = 4; } +void uchar_5() { if (u.load(std::memory_order_relaxed)) sink = 5; } +void uchar_6() { if (u.load(std::memory_order_relaxed)) sink = 6; } +void uchar_7() { if (u.load(std::memory_order_relaxed)) sink = 7; } +void uchar_8() { if (u.load(std::memory_order_relaxed)) sink = 8; } +void uchar_9() { if (u.load(std::memory_order_relaxed)) sink = 9; } +void uchar_10() { if (u.load(std::memory_order_relaxed)) sink = 10; } + +void float_1() { if (f.load(std::memory_order_relaxed)) sink = 1; } +void float_2() { if (f.load(std::memory_order_relaxed)) sink = 2; } +void float_3() { if (f.load(std::memory_order_relaxed)) sink = 3; } +void float_4() { if (f.load(std::memory_order_relaxed)) sink = 4; } +void float_5() { if (f.load(std::memory_order_relaxed)) sink = 5; } +void float_6() { if (f.load(std::memory_order_relaxed)) sink = 6; } +void float_7() { if (f.load(std::memory_order_relaxed)) sink = 7; } +void float_8() { if (f.load(std::memory_order_relaxed)) sink = 8; } +void float_9() { if (f.load(std::memory_order_relaxed)) sink = 9; } +void float_10() { if (f.load(std::memory_order_relaxed)) sink = 10; } + +void ptr_1() { if (p.load(std::memory_order_relaxed)) sink = 1; } +void ptr_2() { if (p.load(std::memory_order_relaxed)) sink = 2; } +void ptr_3() { if (p.load(std::memory_order_relaxed)) sink = 3; } +void ptr_4() { if (p.load(std::memory_order_relaxed)) sink = 4; } +void ptr_5() { if (p.load(std::memory_order_relaxed)) sink = 5; } +void ptr_6() { if (p.load(std::memory_order_relaxed)) sink = 6; } +void ptr_7() { if (p.load(std::memory_order_relaxed)) sink = 7; } +void ptr_8() { if (p.load(std::memory_order_relaxed)) sink = 8; } +void ptr_9() { if (p.load(std::memory_order_relaxed)) sink = 9; } +void ptr_10() { if (p.load(std::memory_order_relaxed)) sink = 10; } + +void enum_1() { if (e.load(std::memory_order_relaxed)) sink = 1; } +void enum_2() { if (e.load(std::memory_order_relaxed)) sink = 2; } +void enum_3() { if (e.load(std::memory_order_relaxed)) sink = 3; } +void enum_4() { if (e.load(std::memory_order_relaxed)) sink = 4; } +void enum_5() { if (e.load(std::memory_order_relaxed)) sink = 5; } +void enum_6() { if (e.load(std::memory_order_relaxed)) sink = 6; } +void enum_7() { if (e.load(std::memory_order_relaxed)) sink = 7; } +void enum_8() { if (e.load(std::memory_order_relaxed)) sink = 8; } +void enum_9() { if (e.load(std::memory_order_relaxed)) sink = 9; } +void enum_10() { if (e.load(std::memory_order_relaxed)) sink = 10; } diff --git a/libstdc++-v3/testsuite/29_atomics/atomic_ref/127693.cc b/libstdc++-v3/testsuite/29_atomics/atomic_ref/127693.cc new file mode 100644 index 000000000000..092016f0cba3 --- /dev/null +++ b/libstdc++-v3/testsuite/29_atomics/atomic_ref/127693.cc @@ -0,0 +1,74 @@ +// { dg-options "-Os -g0" } +// { dg-do compile { target c++20 } } +// { dg-final { scan-assembler-not "E4loadESt12memory_order" } } + +#include <atomic> + +enum E { Ea, Eb = 1000 }; +bool bb; +unsigned char uu; +float ff; +int* pp; +enum E ee; + +std::atomic_ref<bool> b(bb); +std::atomic_ref<unsigned char> u(uu); +std::atomic_ref<float> f(ff); +std::atomic_ref<int*> p(pp); +std::atomic_ref<enum E> e(ee); +int sink; + +void bool_1() { if (b.load(std::memory_order_relaxed)) sink = 1; } +void bool_2() { if (b.load(std::memory_order_relaxed)) sink = 2; } +void bool_3() { if (b.load(std::memory_order_relaxed)) sink = 3; } +void bool_4() { if (b.load(std::memory_order_relaxed)) sink = 4; } +void bool_5() { if (b.load(std::memory_order_relaxed)) sink = 5; } +void bool_6() { if (b.load(std::memory_order_relaxed)) sink = 6; } +void bool_7() { if (b.load(std::memory_order_relaxed)) sink = 7; } +void bool_8() { if (b.load(std::memory_order_relaxed)) sink = 8; } +void bool_9() { if (b.load(std::memory_order_relaxed)) sink = 9; } +void bool_10() { if (b.load(std::memory_order_relaxed)) sink = 10; } + +void uchar_1() { if (u.load(std::memory_order_relaxed)) sink = 1; } +void uchar_2() { if (u.load(std::memory_order_relaxed)) sink = 2; } +void uchar_3() { if (u.load(std::memory_order_relaxed)) sink = 3; } +void uchar_4() { if (u.load(std::memory_order_relaxed)) sink = 4; } +void uchar_5() { if (u.load(std::memory_order_relaxed)) sink = 5; } +void uchar_6() { if (u.load(std::memory_order_relaxed)) sink = 6; } +void uchar_7() { if (u.load(std::memory_order_relaxed)) sink = 7; } +void uchar_8() { if (u.load(std::memory_order_relaxed)) sink = 8; } +void uchar_9() { if (u.load(std::memory_order_relaxed)) sink = 9; } +void uchar_10() { if (u.load(std::memory_order_relaxed)) sink = 10; } + +void float_1() { if (f.load(std::memory_order_relaxed)) sink = 1; } +void float_2() { if (f.load(std::memory_order_relaxed)) sink = 2; } +void float_3() { if (f.load(std::memory_order_relaxed)) sink = 3; } +void float_4() { if (f.load(std::memory_order_relaxed)) sink = 4; } +void float_5() { if (f.load(std::memory_order_relaxed)) sink = 5; } +void float_6() { if (f.load(std::memory_order_relaxed)) sink = 6; } +void float_7() { if (f.load(std::memory_order_relaxed)) sink = 7; } +void float_8() { if (f.load(std::memory_order_relaxed)) sink = 8; } +void float_9() { if (f.load(std::memory_order_relaxed)) sink = 9; } +void float_10() { if (f.load(std::memory_order_relaxed)) sink = 10; } + +void ptr_1() { if (p.load(std::memory_order_relaxed)) sink = 1; } +void ptr_2() { if (p.load(std::memory_order_relaxed)) sink = 2; } +void ptr_3() { if (p.load(std::memory_order_relaxed)) sink = 3; } +void ptr_4() { if (p.load(std::memory_order_relaxed)) sink = 4; } +void ptr_5() { if (p.load(std::memory_order_relaxed)) sink = 5; } +void ptr_6() { if (p.load(std::memory_order_relaxed)) sink = 6; } +void ptr_7() { if (p.load(std::memory_order_relaxed)) sink = 7; } +void ptr_8() { if (p.load(std::memory_order_relaxed)) sink = 8; } +void ptr_9() { if (p.load(std::memory_order_relaxed)) sink = 9; } +void ptr_10() { if (p.load(std::memory_order_relaxed)) sink = 10; } + +void enum_1() { if (e.load(std::memory_order_relaxed)) sink = 1; } +void enum_2() { if (e.load(std::memory_order_relaxed)) sink = 2; } +void enum_3() { if (e.load(std::memory_order_relaxed)) sink = 3; } +void enum_4() { if (e.load(std::memory_order_relaxed)) sink = 4; } +void enum_5() { if (e.load(std::memory_order_relaxed)) sink = 5; } +void enum_6() { if (e.load(std::memory_order_relaxed)) sink = 6; } +void enum_7() { if (e.load(std::memory_order_relaxed)) sink = 7; } +void enum_8() { if (e.load(std::memory_order_relaxed)) sink = 8; } +void enum_9() { if (e.load(std::memory_order_relaxed)) sink = 9; } +void enum_10() { if (e.load(std::memory_order_relaxed)) sink = 10; }
