passenger 6.1.0 → 6.1.1

data/src/cxx_supportlib/vendor-modified/boost/atomic/detail/core_operations_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) 2014, 2020 Andrey Semashev
+ * Copyright (c) 2014-2025 Andrey Semashev
  */
 /*!
  * \file   atomic/detail/core_operations_emulated.hpp
@@ -33,13 +33,13 @@ namespace detail {
 template< std::size_t Size, std::size_t Alignment, bool = Alignment >= storage_traits< Size >::native_alignment >
 struct core_operations_emulated_base
 {
-    typedef typename storage_traits< Size >::type storage_type;
+    using storage_type = typename storage_traits< Size >::type;
 };
 
 template< std::size_t Size, std::size_t Alignment >
 struct core_operations_emulated_base< Size, Alignment, false >
 {
-    typedef buffer_storage< Size, Alignment > storage_type;
+    using storage_type = buffer_storage< Size, Alignment >;
 };
 
 //! Emulated implementation of core atomic operations
@@ -47,40 +47,40 @@ template< std::size_t Size, std::size_t Alignment, bool Signed, bool Interproces
 struct core_operations_emulated :
     public core_operations_emulated_base< Size, Alignment >
 {
-    typedef core_operations_emulated_base< Size, Alignment > base_type;
+    using base_type = core_operations_emulated_base< Size, Alignment >;
 
     // Define storage_type to have alignment not greater than Alignment. This will allow operations to work with value_types
     // that possibly have weaker alignment requirements than storage_traits< Size >::type would. This is important for atomic_ref<>.
     // atomic<> will allow higher alignment requirement than its value_type.
     // Note that storage_type should be an integral type, if possible, so that arithmetic and bitwise operations are possible.
-    typedef typename base_type::storage_type storage_type;
+    using storage_type = typename base_type::storage_type;
 
-    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = Size;
-    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_alignment = Alignment >= storage_traits< Size >::alignment ? storage_traits< Size >::alignment : Alignment;
+    static constexpr std::size_t storage_size = Size;
+    static constexpr std::size_t storage_alignment = Alignment >= storage_traits< Size >::alignment ? storage_traits< Size >::alignment : Alignment;
 
-    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
-    static BOOST_CONSTEXPR_OR_CONST bool is_interprocess = Interprocess;
-    static BOOST_CONSTEXPR_OR_CONST bool full_cas_based = false;
+    static constexpr bool is_signed = Signed;
+    static constexpr bool is_interprocess = Interprocess;
+    static constexpr bool full_cas_based = false;
 
-    static BOOST_CONSTEXPR_OR_CONST bool is_always_lock_free = false;
+    static constexpr bool is_always_lock_free = false;
 
-    typedef lock_pool::scoped_lock< storage_alignment > scoped_lock;
+    using scoped_lock = lock_pool::scoped_lock< storage_alignment >;
 
-    static void store(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    static void store(storage_type volatile& storage, storage_type v, memory_order) noexcept
     {
         static_assert(!is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         scoped_lock lock(&storage);
         const_cast< storage_type& >(storage) = v;
     }
 
-    static storage_type load(storage_type const volatile& storage, memory_order) BOOST_NOEXCEPT
+    static storage_type load(storage_type const volatile& storage, memory_order) noexcept
     {
         static_assert(!is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         scoped_lock lock(&storage);
         return const_cast< storage_type const& >(storage);
     }
 
-    static storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    static storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order) noexcept
     {
         static_assert(!is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         storage_type& s = const_cast< storage_type& >(storage);
@@ -90,7 +90,7 @@ struct core_operations_emulated :
         return old_val;
     }
 
-    static storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    static storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order) noexcept
     {
         static_assert(!is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         storage_type& s = const_cast< storage_type& >(storage);
@@ -100,7 +100,7 @@ struct core_operations_emulated :
         return old_val;
     }
 
-    static storage_type exchange(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    static storage_type exchange(storage_type volatile& storage, storage_type v, memory_order) noexcept
     {
         static_assert(!is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         storage_type& s = const_cast< storage_type& >(storage);
@@ -111,7 +111,7 @@ struct core_operations_emulated :
     }
 
     static bool compare_exchange_strong(
-        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order, memory_order) BOOST_NOEXCEPT
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order, memory_order) noexcept
     {
         static_assert(!is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         storage_type& s = const_cast< storage_type& >(storage);
@@ -126,7 +126,7 @@ struct core_operations_emulated :
     }
 
     static bool compare_exchange_weak(
-        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order, memory_order) BOOST_NOEXCEPT
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order, memory_order) noexcept
     {
         // Note: This function is the exact copy of compare_exchange_strong. The reason we're not just forwarding the call
         // is that MSVC-12 ICEs in this case.
@@ -142,7 +142,7 @@ struct core_operations_emulated :
         return res;
     }
 
-    static storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    static storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order) noexcept
     {
         static_assert(!is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         storage_type& s = const_cast< storage_type& >(storage);
@@ -152,7 +152,7 @@ struct core_operations_emulated :
         return old_val;
     }
 
-    static storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    static storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order) noexcept
     {
         static_assert(!is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         storage_type& s = const_cast< storage_type& >(storage);
@@ -162,7 +162,7 @@ struct core_operations_emulated :
         return old_val;
     }
 
-    static storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    static storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order) noexcept
     {
         static_assert(!is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         storage_type& s = const_cast< storage_type& >(storage);
@@ -172,13 +172,13 @@ struct core_operations_emulated :
         return old_val;
     }
 
-    static BOOST_FORCEINLINE bool test_and_set(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE bool test_and_set(storage_type volatile& storage, memory_order order) noexcept
     {
         static_assert(!is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         return !!exchange(storage, (storage_type)1, order);
     }
 
-    static BOOST_FORCEINLINE void clear(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE void clear(storage_type volatile& storage, memory_order order) noexcept
     {
         static_assert(!is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         store(storage, (storage_type)0, order);

data/src/cxx_supportlib/vendor-modified/boost/atomic/detail/core_ops_cas_based.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/core_ops_cas_based.hpp
@@ -30,11 +30,11 @@ template< typename Base >
 struct core_operations_cas_based :
     public Base
 {
-    typedef typename Base::storage_type storage_type;
+    using storage_type = typename Base::storage_type;
 
-    static BOOST_CONSTEXPR_OR_CONST bool full_cas_based = true;
+    static constexpr bool full_cas_based = true;
 
-    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);
@@ -42,7 +42,7 @@ struct core_operations_cas_based :
         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);
@@ -50,7 +50,7 @@ struct core_operations_cas_based :
         return old_val;
     }
 
-    static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order order) noexcept
     {
         storage_type old_val;
         atomics::detail::non_atomic_load(storage, old_val);
@@ -58,7 +58,7 @@ struct core_operations_cas_based :
         return old_val;
     }
 
-    static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order order) noexcept
     {
         storage_type old_val;
         atomics::detail::non_atomic_load(storage, old_val);
@@ -66,7 +66,7 @@ struct core_operations_cas_based :
         return old_val;
     }
 
-    static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order order) noexcept
     {
         storage_type old_val;
         atomics::detail::non_atomic_load(storage, old_val);
@@ -74,12 +74,12 @@ struct core_operations_cas_based :
         return old_val;
     }
 
-    static BOOST_FORCEINLINE bool test_and_set(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE bool test_and_set(storage_type volatile& storage, memory_order order) noexcept
     {
         return !!Base::exchange(storage, (storage_type)1, order);
     }
 
-    static BOOST_FORCEINLINE void clear(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE void clear(storage_type volatile& storage, memory_order order) noexcept
     {
         Base::store(storage, (storage_type)0, order);
     }

data/src/cxx_supportlib/vendor-modified/boost/atomic/detail/core_ops_gcc_atomic.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, 2020 Andrey Semashev
+ * Copyright (c) 2014-2025 Andrey Semashev
  */
 /*!
  * \file   atomic/detail/core_ops_gcc_atomic.hpp
@@ -23,8 +23,10 @@
 #include <boost/atomic/detail/capabilities.hpp>
 #include <boost/atomic/detail/gcc_atomic_memory_order_utils.hpp>
 
-#if BOOST_ATOMIC_DETAIL_GCC_ATOMIC_INT8_LOCK_FREE < BOOST_ATOMIC_DETAIL_GCC_ATOMIC_INT16_LOCK_FREE || BOOST_ATOMIC_DETAIL_GCC_ATOMIC_INT16_LOCK_FREE < BOOST_ATOMIC_DETAIL_GCC_ATOMIC_INT32_LOCK_FREE ||\
-    BOOST_ATOMIC_DETAIL_GCC_ATOMIC_INT32_LOCK_FREE < BOOST_ATOMIC_DETAIL_GCC_ATOMIC_INT64_LOCK_FREE || BOOST_ATOMIC_DETAIL_GCC_ATOMIC_INT64_LOCK_FREE < BOOST_ATOMIC_DETAIL_GCC_ATOMIC_INT128_LOCK_FREE
+#if BOOST_ATOMIC_DETAIL_GCC_ATOMIC_INT8_LOCK_FREE < BOOST_ATOMIC_DETAIL_GCC_ATOMIC_INT16_LOCK_FREE || \
+    BOOST_ATOMIC_DETAIL_GCC_ATOMIC_INT16_LOCK_FREE < BOOST_ATOMIC_DETAIL_GCC_ATOMIC_INT32_LOCK_FREE || \
+    BOOST_ATOMIC_DETAIL_GCC_ATOMIC_INT32_LOCK_FREE < BOOST_ATOMIC_DETAIL_GCC_ATOMIC_INT64_LOCK_FREE || \
+    BOOST_ATOMIC_DETAIL_GCC_ATOMIC_INT64_LOCK_FREE < BOOST_ATOMIC_DETAIL_GCC_ATOMIC_INT128_LOCK_FREE
 // There are platforms where we need to use larger storage types
 #include <boost/atomic/detail/int_sizes.hpp>
 #include <boost/atomic/detail/extending_cas_based_arithmetic.hpp>
@@ -51,20 +53,20 @@ namespace detail {
 template< std::size_t Size, bool Signed, bool Interprocess >
 struct core_operations_gcc_atomic
 {
-    typedef typename storage_traits< Size >::type storage_type;
+    using storage_type = typename storage_traits< Size >::type;
 
-    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = Size;
-    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_alignment = storage_traits< Size >::alignment;
-    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
-    static BOOST_CONSTEXPR_OR_CONST bool is_interprocess = Interprocess;
-    static BOOST_CONSTEXPR_OR_CONST bool full_cas_based = false;
+    static constexpr std::size_t storage_size = Size;
+    static constexpr std::size_t storage_alignment = storage_traits< Size >::alignment;
+    static constexpr bool is_signed = Signed;
+    static constexpr bool is_interprocess = Interprocess;
+    static constexpr bool full_cas_based = false;
 
     // Note: In the current implementation, core_operations_gcc_atomic are used only when the particularly sized __atomic
     // intrinsics are always lock-free (i.e. the corresponding LOCK_FREE macro is 2). Therefore it is safe to
     // always set is_always_lock_free to true here.
-    static BOOST_CONSTEXPR_OR_CONST bool is_always_lock_free = true;
+    static constexpr bool is_always_lock_free = true;
 
-    static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) noexcept
     {
 #if defined(BOOST_GCC) && BOOST_GCC < 100100 && (defined(__x86_64__) || defined(__i386__))
         // gcc up to 10.1 generates mov + mfence for seq_cst stores, which is slower than xchg
@@ -77,35 +79,36 @@ struct core_operations_gcc_atomic
 #endif
     }
 
-    static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order order) noexcept
     {
-#if defined(BOOST_ATOMIC_DETAIL_AARCH64_HAS_RCPC)
+#if defined(BOOST_ATOMIC_DETAIL_AARCH64_HAS_RCPC) && !((defined(BOOST_GCC) && BOOST_GCC >= 130100) || (defined(BOOST_CLANG) && BOOST_CLANG_VERSION >= 160000))
         // At least gcc 9.3 and clang 10 do not generate relaxed ldapr instructions that are available in ARMv8.3-RCPC extension.
         // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=95751
-        typedef atomics::detail::core_arch_operations< storage_size, is_signed, is_interprocess > core_arch_operations;
+        // This was fixed in gcc 13.1 and clang 16.
+        using core_arch_operations = atomics::detail::core_arch_operations< storage_size, is_signed, is_interprocess >;
         return core_arch_operations::load(storage, order);
 #else
         return __atomic_load_n(&storage, atomics::detail::convert_memory_order_to_gcc(order));
 #endif
     }
 
-    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
     {
         return __atomic_fetch_add(&storage, v, atomics::detail::convert_memory_order_to_gcc(order));
     }
 
-    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
     {
         return __atomic_fetch_sub(&storage, v, atomics::detail::convert_memory_order_to_gcc(order));
     }
 
-    static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order order) noexcept
     {
         return __atomic_exchange_n(&storage, v, atomics::detail::convert_memory_order_to_gcc(order));
     }
 
     static BOOST_FORCEINLINE bool compare_exchange_strong(
-        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) noexcept
     {
         return __atomic_compare_exchange_n
         (
@@ -116,7 +119,7 @@ struct core_operations_gcc_atomic
     }
 
     static BOOST_FORCEINLINE bool compare_exchange_weak(
-        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) noexcept
     {
         return __atomic_compare_exchange_n
         (
@@ -126,27 +129,27 @@ struct core_operations_gcc_atomic
         );
     }
 
-    static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order order) noexcept
     {
         return __atomic_fetch_and(&storage, v, atomics::detail::convert_memory_order_to_gcc(order));
     }
 
-    static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order order) noexcept
     {
         return __atomic_fetch_or(&storage, v, atomics::detail::convert_memory_order_to_gcc(order));
     }
 
-    static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order order) noexcept
     {
         return __atomic_fetch_xor(&storage, v, atomics::detail::convert_memory_order_to_gcc(order));
     }
 
-    static BOOST_FORCEINLINE bool test_and_set(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE bool test_and_set(storage_type volatile& storage, memory_order order) noexcept
     {
         return __atomic_test_and_set(&storage, atomics::detail::convert_memory_order_to_gcc(order));
     }
 
-    static BOOST_FORCEINLINE void clear(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE void clear(storage_type volatile& storage, memory_order order) noexcept
     {
         __atomic_clear(const_cast< storage_type* >(&storage), atomics::detail::convert_memory_order_to_gcc(order));
     }

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

@@ -5,7 +5,7 @@
  *
  * Copyright (c) 2011 Helge Bahmann
  * Copyright (c) 2013 Tim Blechmann
- * Copyright (c) 2014 Andrey Semashev
+ * Copyright (c) 2014-2025 Andrey Semashev
  */
 /*!
  * \file   atomic/detail/core_ops_gcc_sync.hpp
@@ -17,12 +17,12 @@
 #define BOOST_ATOMIC_DETAIL_CORE_OPS_GCC_SYNC_HPP_INCLUDED_
 
 #include <cstddef>
+#include <type_traits>
 #include <boost/memory_order.hpp>
 #include <boost/atomic/detail/config.hpp>
 #include <boost/atomic/detail/storage_traits.hpp>
 #include <boost/atomic/detail/core_operations_fwd.hpp>
 #include <boost/atomic/detail/extending_cas_based_arithmetic.hpp>
-#include <boost/atomic/detail/type_traits/integral_constant.hpp>
 #include <boost/atomic/detail/capabilities.hpp>
 #include <boost/atomic/detail/header.hpp>
 
@@ -36,22 +36,22 @@ namespace detail {
 
 struct core_operations_gcc_sync_base
 {
-    static BOOST_CONSTEXPR_OR_CONST bool full_cas_based = false;
-    static BOOST_CONSTEXPR_OR_CONST bool is_always_lock_free = true;
+    static constexpr bool full_cas_based = false;
+    static constexpr bool is_always_lock_free = true;
 
-    static BOOST_FORCEINLINE void fence_before_store(memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE void fence_before_store(memory_order order) noexcept
     {
         if ((static_cast< unsigned int >(order) & static_cast< unsigned int >(memory_order_release)) != 0u)
             __sync_synchronize();
     }
 
-    static BOOST_FORCEINLINE void fence_after_store(memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE void fence_after_store(memory_order order) noexcept
     {
         if (order == memory_order_seq_cst)
             __sync_synchronize();
     }
 
-    static BOOST_FORCEINLINE void fence_after_load(memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE void fence_after_load(memory_order order) noexcept
     {
         if ((static_cast< unsigned int >(order) & (static_cast< unsigned int >(memory_order_acquire) | static_cast< unsigned int >(memory_order_consume))) != 0u)
             __sync_synchronize();
@@ -62,49 +62,40 @@ template< std::size_t Size, bool Signed, bool Interprocess >
 struct core_operations_gcc_sync :
     public core_operations_gcc_sync_base
 {
-    typedef typename storage_traits< Size >::type storage_type;
+    using storage_type = typename storage_traits< Size >::type;
 
-    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = Size;
-    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_alignment = storage_traits< storage_size >::alignment;
-    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
-    static BOOST_CONSTEXPR_OR_CONST bool is_interprocess = Interprocess;
+    static constexpr std::size_t storage_size = Size;
+    static constexpr std::size_t storage_alignment = storage_traits< storage_size >::alignment;
+    static constexpr bool is_signed = Signed;
+    static constexpr bool is_interprocess = Interprocess;
 
+private:
     // In general, we cannot guarantee atomicity of plain loads and stores of anything larger than a single byte on
     // an arbitrary CPU architecture. However, all modern architectures seem to guarantee atomic loads and stores of
     // suitably aligned objects of up to a pointer size. For larger objects we should probably use intrinsics to guarantee
     // atomicity. If there appears an architecture where this doesn't hold, this threshold needs to be updated (patches are welcome).
-    typedef atomics::detail::integral_constant< bool, storage_size <= sizeof(void*) > plain_stores_loads_are_atomic;
+    using plain_stores_loads_are_atomic = std::integral_constant< bool, storage_size <= sizeof(void*) >;
 
-    static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
-    {
-        store(storage, v, order, plain_stores_loads_are_atomic());
-    }
-
-    static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order, atomics::detail::true_type) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order, std::true_type) noexcept
     {
         fence_before_store(order);
         storage = v;
         fence_after_store(order);
     }
 
-    static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order, atomics::detail::false_type) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order, std::false_type) noexcept
     {
         exchange(storage, v, order);
     }
 
-    static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order order) BOOST_NOEXCEPT
-    {
-        return load(storage, order, plain_stores_loads_are_atomic());
-    }
-
-    static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order order, atomics::detail::true_type) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order order, std::true_type) noexcept
     {
         storage_type v = storage;
         fence_after_load(order);
         return v;
     }
 
-    static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order, atomics::detail::false_type) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order, std::false_type) noexcept
     {
         // Note: don't use fetch_add or other arithmetics here since storage_type may not be an arithmetic type.
         storage_type expected = storage_type();
@@ -113,17 +104,28 @@ struct core_operations_gcc_sync :
         return __sync_val_compare_and_swap(const_cast< storage_type volatile* >(&storage), expected, desired);
     }
 
-    static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+public:
+    static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) noexcept
+    {
+        store(storage, v, order, plain_stores_loads_are_atomic());
+    }
+
+    static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order order) noexcept
+    {
+        return load(storage, order, plain_stores_loads_are_atomic());
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order) noexcept
     {
         return __sync_fetch_and_add(&storage, v);
     }
 
-    static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order) noexcept
     {
         return __sync_fetch_and_sub(&storage, v);
     }
 
-    static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order order) noexcept
     {
         // GCC docs mention that not all architectures may support full exchange semantics for this intrinsic. However, GCC's implementation of
         // std::atomic<> uses this intrinsic unconditionally. We do so as well. In case if some architectures actually don't support this, we can always
@@ -134,7 +136,7 @@ struct core_operations_gcc_sync :
     }
 
     static BOOST_FORCEINLINE bool compare_exchange_strong(
-        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order, memory_order) BOOST_NOEXCEPT
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order, memory_order) noexcept
     {
         storage_type expected2 = expected;
         storage_type old_val = __sync_val_compare_and_swap(&storage, expected2, desired);
@@ -151,34 +153,34 @@ struct core_operations_gcc_sync :
     }
 
     static BOOST_FORCEINLINE bool compare_exchange_weak(
-        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) noexcept
     {
         return compare_exchange_strong(storage, expected, desired, success_order, failure_order);
     }
 
-    static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order) noexcept
     {
         return __sync_fetch_and_and(&storage, v);
     }
 
-    static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order) noexcept
     {
         return __sync_fetch_and_or(&storage, v);
     }
 
-    static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order) noexcept
     {
         return __sync_fetch_and_xor(&storage, v);
     }
 
-    static BOOST_FORCEINLINE bool test_and_set(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE bool test_and_set(storage_type volatile& storage, memory_order order) noexcept
     {
         if ((static_cast< unsigned int >(order) & static_cast< unsigned int >(memory_order_release)) != 0u)
             __sync_synchronize();
         return !!__sync_lock_test_and_set(&storage, 1);
     }
 
-    static BOOST_FORCEINLINE void clear(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE void clear(storage_type volatile& storage, memory_order order) noexcept
     {
         __sync_lock_release(&storage);
         if (order == memory_order_seq_cst)

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

@@ -7,7 +7,7 @@
  * Copyright (c) 2009 Phil Endecott
  * Copyright (c) 2013 Tim Blechmann
  * Linux-specific code by Phil Endecott
- * Copyright (c) 2014 Andrey Semashev
+ * Copyright (c) 2014-2025 Andrey Semashev
  */
 /*!
  * \file   atomic/detail/core_ops_linux_arm.hpp
@@ -62,22 +62,22 @@ namespace detail {
 
 struct linux_arm_cas_base
 {
-    static BOOST_CONSTEXPR_OR_CONST bool full_cas_based = true;
-    static BOOST_CONSTEXPR_OR_CONST bool is_always_lock_free = true;
+    static constexpr bool full_cas_based = true;
+    static constexpr bool is_always_lock_free = true;
 
-    static BOOST_FORCEINLINE void fence_before_store(memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE void fence_before_store(memory_order order) noexcept
     {
         if ((static_cast< unsigned int >(order) & static_cast< unsigned int >(memory_order_release)) != 0u)
             fence_operations::hardware_full_fence();
     }
 
-    static BOOST_FORCEINLINE void fence_after_store(memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE void fence_after_store(memory_order order) noexcept
     {
         if (order == memory_order_seq_cst)
             fence_operations::hardware_full_fence();
     }
 
-    static BOOST_FORCEINLINE void fence_after_load(memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE void fence_after_load(memory_order order) noexcept
     {
         if ((static_cast< unsigned int >(order) & (static_cast< unsigned int >(memory_order_consume) | static_cast< unsigned int >(memory_order_acquire))) != 0u)
             fence_operations::hardware_full_fence();
@@ -88,21 +88,21 @@ template< bool Signed, bool Interprocess >
 struct linux_arm_cas :
     public linux_arm_cas_base
 {
-    typedef typename storage_traits< 4u >::type storage_type;
+    using storage_type = typename storage_traits< 4u >::type;
 
-    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 4u;
-    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_alignment = 4u;
-    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
-    static BOOST_CONSTEXPR_OR_CONST bool is_interprocess = Interprocess;
+    static constexpr std::size_t storage_size = 4u;
+    static constexpr std::size_t storage_alignment = 4u;
+    static constexpr bool is_signed = Signed;
+    static constexpr bool is_interprocess = Interprocess;
 
-    static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) noexcept
     {
         fence_before_store(order);
         storage = v;
         fence_after_store(order);
     }
 
-    static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order order) noexcept
     {
         storage_type v = storage;
         fence_after_load(order);
@@ -110,7 +110,7 @@ struct linux_arm_cas :
     }
 
     static BOOST_FORCEINLINE bool compare_exchange_strong(
-        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) noexcept
     {
         while (true)
         {
@@ -126,11 +126,11 @@ struct linux_arm_cas :
     }
 
     static BOOST_FORCEINLINE bool compare_exchange_weak(
-        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order, memory_order) BOOST_NOEXCEPT
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order, memory_order) noexcept
     {
-        typedef storage_type (*kernel_cmpxchg32_t)(storage_type oldval, storage_type newval, volatile storage_type* ptr);
+        using kernel_cmpxchg32_t = storage_type (storage_type oldval, storage_type newval, volatile storage_type* ptr);
 
-        if (((kernel_cmpxchg32_t)0xffff0fc0)(expected, desired, &storage) == 0)
+        if (((kernel_cmpxchg32_t*)0xffff0fc0)(expected, desired, &storage) == 0)
         {
             return true;
         }