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; }

Reply via email to