passenger 6.1.0 → 6.1.1

data/src/cxx_supportlib/vendor-modified/boost/atomic/detail/extending_cas_based_arithmetic.hpp

@@ -3,7 +3,7 @@
  * (See accompanying file LICENSE_1_0.txt or copy at
  * http://www.boost.org/LICENSE_1_0.txt)
  *
- * Copyright (c) 2014 Andrey Semashev
+ * Copyright (c) 2014-2025 Andrey Semashev
  */
 /*!
  * \file   atomic/detail/extending_cas_based_arithmetic.hpp
@@ -33,10 +33,10 @@ template< typename Base, std::size_t Size, bool Signed >
 struct extending_cas_based_arithmetic :
     public Base
 {
-    typedef typename Base::storage_type storage_type;
-    typedef typename storage_traits< Size >::type emulated_storage_type;
+    using storage_type = typename Base::storage_type;
+    using emulated_storage_type = typename storage_traits< Size >::type;
 
-    static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) noexcept
     {
         storage_type old_val;
         atomics::detail::non_atomic_load(storage, old_val);
@@ -49,7 +49,7 @@ struct extending_cas_based_arithmetic :
         return old_val;
     }
 
-    static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order order) noexcept
     {
         storage_type old_val;
         atomics::detail::non_atomic_load(storage, old_val);

data/src/cxx_supportlib/vendor-modified/boost/atomic/detail/extra_fp_ops_emulated.hpp

@@ -3,7 +3,7 @@
  * (See accompanying file LICENSE_1_0.txt or copy at
  * http://www.boost.org/LICENSE_1_0.txt)
  *
- * Copyright (c) 2018 Andrey Semashev
+ * Copyright (c) 2018-2025 Andrey Semashev
  */
 /*!
  * \file   atomic/detail/extra_fp_ops_emulated.hpp
@@ -34,12 +34,12 @@ template< typename Base, typename Value, std::size_t Size >
 struct extra_fp_operations_emulated :
     public Base
 {
-    typedef Base base_type;
-    typedef typename base_type::storage_type storage_type;
-    typedef Value value_type;
-    typedef typename base_type::scoped_lock scoped_lock;
+    using base_type = Base;
+    using storage_type = typename base_type::storage_type;
+    using value_type = Value;
+    using scoped_lock = typename base_type::scoped_lock;
 
-    static value_type fetch_negate(storage_type volatile& storage, memory_order) BOOST_NOEXCEPT
+    static value_type fetch_negate(storage_type volatile& storage, memory_order) noexcept
     {
         static_assert(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         storage_type& s = const_cast< storage_type& >(storage);
@@ -50,7 +50,7 @@ struct extra_fp_operations_emulated :
         return old_val;
     }
 
-    static value_type negate(storage_type volatile& storage, memory_order) BOOST_NOEXCEPT
+    static value_type negate(storage_type volatile& storage, memory_order) noexcept
     {
         static_assert(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         storage_type& s = const_cast< storage_type& >(storage);
@@ -61,7 +61,7 @@ struct extra_fp_operations_emulated :
         return new_val;
     }
 
-    static value_type add(storage_type volatile& storage, value_type v, memory_order) BOOST_NOEXCEPT
+    static value_type add(storage_type volatile& storage, value_type v, memory_order) noexcept
     {
         static_assert(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         storage_type& s = const_cast< storage_type& >(storage);
@@ -72,7 +72,7 @@ struct extra_fp_operations_emulated :
         return new_val;
     }
 
-    static value_type sub(storage_type volatile& storage, value_type v, memory_order) BOOST_NOEXCEPT
+    static value_type sub(storage_type volatile& storage, value_type v, memory_order) noexcept
     {
         static_assert(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         storage_type& s = const_cast< storage_type& >(storage);
@@ -83,19 +83,19 @@ struct extra_fp_operations_emulated :
         return new_val;
     }
 
-    static BOOST_FORCEINLINE void opaque_negate(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE void opaque_negate(storage_type volatile& storage, memory_order order) noexcept
     {
         static_assert(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         fetch_negate(storage, order);
     }
 
-    static BOOST_FORCEINLINE void opaque_add(storage_type volatile& storage, value_type v, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE void opaque_add(storage_type volatile& storage, value_type v, memory_order order) noexcept
     {
         static_assert(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         base_type::fetch_add(storage, v, order);
     }
 
-    static BOOST_FORCEINLINE void opaque_sub(storage_type volatile& storage, value_type v, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE void opaque_sub(storage_type volatile& storage, value_type v, memory_order order) noexcept
     {
         static_assert(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         base_type::fetch_sub(storage, v, order);

data/src/cxx_supportlib/vendor-modified/boost/atomic/detail/extra_fp_ops_generic.hpp

@@ -3,7 +3,7 @@
  * (See accompanying file LICENSE_1_0.txt or copy at
  * http://www.boost.org/LICENSE_1_0.txt)
  *
- * Copyright (c) 2018 Andrey Semashev
+ * Copyright (c) 2018-2025 Andrey Semashev
  */
 /*!
  * \file   atomic/detail/extra_fp_ops_generic.hpp
@@ -50,11 +50,11 @@ template<
 struct extra_fp_negate_generic :
     public Base
 {
-    typedef Base base_type;
-    typedef typename base_type::storage_type storage_type;
-    typedef Value value_type;
+    using base_type = Base;
+    using storage_type = typename base_type::storage_type;
+    using value_type = Value;
 
-    static BOOST_FORCEINLINE value_type fetch_negate(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE value_type fetch_negate(storage_type volatile& storage, memory_order order) noexcept
     {
         storage_type old_storage, new_storage;
         value_type old_val, new_val;
@@ -69,7 +69,7 @@ struct extra_fp_negate_generic :
         return old_val;
     }
 
-    static BOOST_FORCEINLINE value_type negate(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE value_type negate(storage_type volatile& storage, memory_order order) noexcept
     {
         storage_type old_storage, new_storage;
         value_type old_val, new_val;
@@ -84,7 +84,7 @@ struct extra_fp_negate_generic :
         return new_val;
     }
 
-    static BOOST_FORCEINLINE void opaque_negate(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE void opaque_negate(storage_type volatile& storage, memory_order order) noexcept
     {
         fetch_negate(storage, order);
     }
@@ -97,24 +97,24 @@ template< typename Base, typename Value, std::size_t Size >
 struct extra_fp_negate_generic< Base, Value, Size, true > :
     public Base
 {
-    typedef Base base_type;
-    typedef typename base_type::storage_type storage_type;
-    typedef Value value_type;
+    using base_type = Base;
+    using storage_type = typename base_type::storage_type;
+    using value_type = Value;
 
     //! The mask with only one sign bit set to 1
-    static BOOST_CONSTEXPR_OR_CONST storage_type sign_mask = static_cast< storage_type >(1u) << (atomics::detail::value_size_of< value_type >::value * 8u - 1u);
+    static constexpr storage_type sign_mask = static_cast< storage_type >(1u) << (atomics::detail::value_size_of< value_type >::value * 8u - 1u);
 
-    static BOOST_FORCEINLINE value_type fetch_negate(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE value_type fetch_negate(storage_type volatile& storage, memory_order order) noexcept
     {
         return atomics::detail::bitwise_fp_cast< value_type >(base_type::fetch_xor(storage, sign_mask, order));
     }
 
-    static BOOST_FORCEINLINE value_type negate(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE value_type negate(storage_type volatile& storage, memory_order order) noexcept
     {
         return atomics::detail::bitwise_fp_cast< value_type >(base_type::bitwise_xor(storage, sign_mask, order));
     }
 
-    static BOOST_FORCEINLINE void opaque_negate(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE void opaque_negate(storage_type volatile& storage, memory_order order) noexcept
     {
         base_type::opaque_xor(storage, sign_mask, order);
     }
@@ -127,11 +127,11 @@ template< typename Base, typename Value, std::size_t Size >
 struct extra_fp_operations_generic :
     public extra_fp_negate_generic< Base, Value, Size >
 {
-    typedef extra_fp_negate_generic< Base, Value, Size > base_type;
-    typedef typename base_type::storage_type storage_type;
-    typedef Value value_type;
+    using base_type = extra_fp_negate_generic< Base, Value, Size >;
+    using storage_type = typename base_type::storage_type;
+    using value_type = Value;
 
-    static BOOST_FORCEINLINE value_type add(storage_type volatile& storage, value_type v, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE value_type add(storage_type volatile& storage, value_type v, memory_order order) noexcept
     {
         storage_type old_storage, new_storage;
         value_type old_val, new_val;
@@ -146,7 +146,7 @@ struct extra_fp_operations_generic :
         return new_val;
     }
 
-    static BOOST_FORCEINLINE value_type sub(storage_type volatile& storage, value_type v, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE value_type sub(storage_type volatile& storage, value_type v, memory_order order) noexcept
     {
         storage_type old_storage, new_storage;
         value_type old_val, new_val;
@@ -161,12 +161,12 @@ struct extra_fp_operations_generic :
         return new_val;
     }
 
-    static BOOST_FORCEINLINE void opaque_add(storage_type volatile& storage, value_type v, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE void opaque_add(storage_type volatile& storage, value_type v, memory_order order) noexcept
     {
         base_type::fetch_add(storage, v, order);
     }
 
-    static BOOST_FORCEINLINE void opaque_sub(storage_type volatile& storage, value_type v, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE void opaque_sub(storage_type volatile& storage, value_type v, memory_order order) noexcept
     {
         base_type::fetch_sub(storage, v, order);
     }

data/src/cxx_supportlib/vendor-modified/boost/atomic/detail/extra_ops_emulated.hpp

@@ -3,7 +3,7 @@
  * (See accompanying file LICENSE_1_0.txt or copy at
  * http://www.boost.org/LICENSE_1_0.txt)
  *
- * Copyright (c) 2018 Andrey Semashev
+ * Copyright (c) 2018-2025 Andrey Semashev
  */
 /*!
  * \file   atomic/detail/extra_ops_emulated.hpp
@@ -34,11 +34,11 @@ template< typename Base, std::size_t Size, bool Signed >
 struct extra_operations_emulated :
     public Base
 {
-    typedef Base base_type;
-    typedef typename base_type::storage_type storage_type;
-    typedef typename base_type::scoped_lock scoped_lock;
+    using base_type = Base;
+    using storage_type = typename base_type::storage_type;
+    using scoped_lock = typename base_type::scoped_lock;
 
-    static storage_type fetch_negate(storage_type volatile& storage, memory_order) BOOST_NOEXCEPT
+    static storage_type fetch_negate(storage_type volatile& storage, memory_order) noexcept
     {
         static_assert(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         storage_type& s = const_cast< storage_type& >(storage);
@@ -48,7 +48,7 @@ struct extra_operations_emulated :
         return old_val;
     }
 
-    static storage_type negate(storage_type volatile& storage, memory_order) BOOST_NOEXCEPT
+    static storage_type negate(storage_type volatile& storage, memory_order) noexcept
     {
         static_assert(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         storage_type& s = const_cast< storage_type& >(storage);
@@ -58,7 +58,7 @@ struct extra_operations_emulated :
         return new_val;
     }
 
-    static storage_type add(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    static storage_type add(storage_type volatile& storage, storage_type v, memory_order) noexcept
     {
         static_assert(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         storage_type& s = const_cast< storage_type& >(storage);
@@ -69,7 +69,7 @@ struct extra_operations_emulated :
         return new_val;
     }
 
-    static storage_type sub(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    static storage_type sub(storage_type volatile& storage, storage_type v, memory_order) noexcept
     {
         static_assert(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         storage_type& s = const_cast< storage_type& >(storage);
@@ -80,7 +80,7 @@ struct extra_operations_emulated :
         return new_val;
     }
 
-    static storage_type bitwise_and(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    static storage_type bitwise_and(storage_type volatile& storage, storage_type v, memory_order) noexcept
     {
         static_assert(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         storage_type& s = const_cast< storage_type& >(storage);
@@ -91,7 +91,7 @@ struct extra_operations_emulated :
         return new_val;
     }
 
-    static storage_type bitwise_or(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    static storage_type bitwise_or(storage_type volatile& storage, storage_type v, memory_order) noexcept
     {
         static_assert(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         storage_type& s = const_cast< storage_type& >(storage);
@@ -102,7 +102,7 @@ struct extra_operations_emulated :
         return new_val;
     }
 
-    static storage_type bitwise_xor(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    static storage_type bitwise_xor(storage_type volatile& storage, storage_type v, memory_order) noexcept
     {
         static_assert(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         storage_type& s = const_cast< storage_type& >(storage);
@@ -113,7 +113,7 @@ struct extra_operations_emulated :
         return new_val;
     }
 
-    static storage_type fetch_complement(storage_type volatile& storage, memory_order) BOOST_NOEXCEPT
+    static storage_type fetch_complement(storage_type volatile& storage, memory_order) noexcept
     {
         static_assert(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         storage_type& s = const_cast< storage_type& >(storage);
@@ -123,7 +123,7 @@ struct extra_operations_emulated :
         return old_val;
     }
 
-    static storage_type bitwise_complement(storage_type volatile& storage, memory_order) BOOST_NOEXCEPT
+    static storage_type bitwise_complement(storage_type volatile& storage, memory_order) noexcept
     {
         static_assert(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         storage_type& s = const_cast< storage_type& >(storage);
@@ -133,91 +133,91 @@ struct extra_operations_emulated :
         return new_val;
     }
 
-    static BOOST_FORCEINLINE void opaque_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE void opaque_add(storage_type volatile& storage, storage_type v, memory_order order) noexcept
     {
         static_assert(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         base_type::fetch_add(storage, v, order);
     }
 
-    static BOOST_FORCEINLINE void opaque_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE void opaque_sub(storage_type volatile& storage, storage_type v, memory_order order) noexcept
     {
         static_assert(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         base_type::fetch_sub(storage, v, order);
     }
 
-    static BOOST_FORCEINLINE void opaque_negate(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE void opaque_negate(storage_type volatile& storage, memory_order order) noexcept
     {
         static_assert(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         fetch_negate(storage, order);
     }
 
-    static BOOST_FORCEINLINE void opaque_and(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE void opaque_and(storage_type volatile& storage, storage_type v, memory_order order) noexcept
     {
         static_assert(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         base_type::fetch_and(storage, v, order);
     }
 
-    static BOOST_FORCEINLINE void opaque_or(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE void opaque_or(storage_type volatile& storage, storage_type v, memory_order order) noexcept
     {
         static_assert(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         base_type::fetch_or(storage, v, order);
     }
 
-    static BOOST_FORCEINLINE void opaque_xor(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE void opaque_xor(storage_type volatile& storage, storage_type v, memory_order order) noexcept
     {
         static_assert(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         base_type::fetch_xor(storage, v, order);
     }
 
-    static BOOST_FORCEINLINE void opaque_complement(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE void opaque_complement(storage_type volatile& storage, memory_order order) noexcept
     {
         static_assert(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         fetch_complement(storage, order);
     }
 
-    static BOOST_FORCEINLINE bool add_and_test(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE bool add_and_test(storage_type volatile& storage, storage_type v, memory_order order) noexcept
     {
         static_assert(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         return !!add(storage, v, order);
     }
 
-    static BOOST_FORCEINLINE bool sub_and_test(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE bool sub_and_test(storage_type volatile& storage, storage_type v, memory_order order) noexcept
     {
         static_assert(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         return !!sub(storage, v, order);
     }
 
-    static BOOST_FORCEINLINE bool negate_and_test(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE bool negate_and_test(storage_type volatile& storage, memory_order order) noexcept
     {
         static_assert(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         return !!negate(storage, order);
     }
 
-    static BOOST_FORCEINLINE bool and_and_test(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE bool and_and_test(storage_type volatile& storage, storage_type v, memory_order order) noexcept
     {
         static_assert(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         return !!bitwise_and(storage, v, order);
     }
 
-    static BOOST_FORCEINLINE bool or_and_test(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE bool or_and_test(storage_type volatile& storage, storage_type v, memory_order order) noexcept
     {
         static_assert(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         return !!bitwise_or(storage, v, order);
     }
 
-    static BOOST_FORCEINLINE bool xor_and_test(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE bool xor_and_test(storage_type volatile& storage, storage_type v, memory_order order) noexcept
     {
         static_assert(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         return !!bitwise_xor(storage, v, order);
     }
 
-    static BOOST_FORCEINLINE bool complement_and_test(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE bool complement_and_test(storage_type volatile& storage, memory_order order) noexcept
     {
         static_assert(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         return !!bitwise_complement(storage, order);
     }
 
-    static BOOST_FORCEINLINE bool bit_test_and_set(storage_type volatile& storage, unsigned int bit_number, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE bool bit_test_and_set(storage_type volatile& storage, unsigned int bit_number, memory_order order) noexcept
     {
         static_assert(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         storage_type mask = static_cast< storage_type >(static_cast< storage_type >(1u) << bit_number);
@@ -225,7 +225,7 @@ struct extra_operations_emulated :
         return !!(old_val & mask);
     }
 
-    static BOOST_FORCEINLINE bool bit_test_and_reset(storage_type volatile& storage, unsigned int bit_number, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE bool bit_test_and_reset(storage_type volatile& storage, unsigned int bit_number, memory_order order) noexcept
     {
         static_assert(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         storage_type mask = static_cast< storage_type >(static_cast< storage_type >(1u) << bit_number);
@@ -233,7 +233,7 @@ struct extra_operations_emulated :
         return !!(old_val & mask);
     }
 
-    static BOOST_FORCEINLINE bool bit_test_and_complement(storage_type volatile& storage, unsigned int bit_number, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE bool bit_test_and_complement(storage_type volatile& storage, unsigned int bit_number, memory_order order) noexcept
     {
         static_assert(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         storage_type mask = static_cast< storage_type >(static_cast< storage_type >(1u) << bit_number);