passenger 6.1.0 → 6.1.1

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

@@ -5,7 +5,7 @@
  *
  * Copyright (c) 2009 Helge Bahmann
  * Copyright (c) 2013 Tim Blechmann
- * Copyright (c) 2014, 2020 Andrey Semashev
+ * Copyright (c) 2014-2025 Andrey Semashev
  */
 /*!
  * \file   atomic/detail/core_arch_ops_gcc_arm.hpp
@@ -17,7 +17,7 @@
 #define BOOST_ATOMIC_DETAIL_CORE_ARCH_OPS_GCC_ARM_HPP_INCLUDED_
 
 #include <cstddef>
-#include <boost/cstdint.hpp>
+#include <cstdint>
 #include <boost/memory_order.hpp>
 #include <boost/atomic/detail/config.hpp>
 #include <boost/atomic/detail/storage_traits.hpp>
@@ -60,32 +60,32 @@ template< bool Signed, bool Interprocess >
 struct core_arch_operations< 4u, Signed, Interprocess > :
     public core_arch_operations_gcc_arm_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(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(order);
         return 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
     {
         fence_before(order);
         storage_type original;
-        uint32_t tmp;
+        std::uint32_t tmp;
         __asm__ __volatile__
         (
             BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp])
@@ -104,12 +104,12 @@ struct core_arch_operations< 4u, Signed, Interprocess > :
     }
 
     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
     {
         fence_before(success_order);
         bool success = false;
 #if !defined(BOOST_ATOMIC_DETAIL_ARM_ASM_TMPREG_UNUSED)
-        uint32_t tmp;
+        std::uint32_t tmp;
 #endif
         storage_type original;
         __asm__ __volatile__
@@ -140,12 +140,12 @@ struct core_arch_operations< 4u, Signed, Interprocess > :
     }
 
     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
     {
         fence_before(success_order);
         bool success = false;
 #if !defined(BOOST_ATOMIC_DETAIL_ARM_ASM_TMPREG_UNUSED)
-        uint32_t tmp;
+        std::uint32_t tmp;
 #endif
         storage_type original;
         __asm__ __volatile__
@@ -178,10 +178,10 @@ struct core_arch_operations< 4u, Signed, Interprocess > :
         return success;
     }
 
-    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
     {
         fence_before(order);
-        uint32_t tmp;
+        std::uint32_t tmp;
         storage_type original, result;
         __asm__ __volatile__
         (
@@ -204,10 +204,10 @@ struct core_arch_operations< 4u, Signed, Interprocess > :
         return original;
     }
 
-    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
     {
         fence_before(order);
-        uint32_t tmp;
+        std::uint32_t tmp;
         storage_type original, result;
         __asm__ __volatile__
         (
@@ -230,10 +230,10 @@ struct core_arch_operations< 4u, Signed, Interprocess > :
         return original;
     }
 
-    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
     {
         fence_before(order);
-        uint32_t tmp;
+        std::uint32_t tmp;
         storage_type original, result;
         __asm__ __volatile__
         (
@@ -256,10 +256,10 @@ struct core_arch_operations< 4u, Signed, Interprocess > :
         return original;
     }
 
-    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
     {
         fence_before(order);
-        uint32_t tmp;
+        std::uint32_t tmp;
         storage_type original, result;
         __asm__ __volatile__
         (
@@ -282,10 +282,10 @@ struct core_arch_operations< 4u, Signed, Interprocess > :
         return original;
     }
 
-    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
     {
         fence_before(order);
-        uint32_t tmp;
+        std::uint32_t tmp;
         storage_type original, result;
         __asm__ __volatile__
         (
@@ -308,12 +308,12 @@ struct core_arch_operations< 4u, Signed, Interprocess > :
         return original;
     }
 
-    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 !!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
     {
         store(storage, (storage_type)0, order);
     }
@@ -325,33 +325,33 @@ template< bool Signed, bool Interprocess >
 struct core_arch_operations< 1u, Signed, Interprocess > :
     public core_arch_operations_gcc_arm_base
 {
-    typedef typename storage_traits< 1u >::type storage_type;
-    typedef typename storage_traits< 4u >::type extended_storage_type;
+    using storage_type = typename storage_traits< 1u >::type;
+    using extended_storage_type = typename storage_traits< 4u >::type;
 
-    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 1u;
-    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_alignment = 1u;
-    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 = 1u;
+    static constexpr std::size_t storage_alignment = 1u;
+    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(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(order);
         return 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
     {
         fence_before(order);
         extended_storage_type original;
-        uint32_t tmp;
+        std::uint32_t tmp;
         __asm__ __volatile__
         (
             BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp])
@@ -370,12 +370,12 @@ struct core_arch_operations< 1u, Signed, Interprocess > :
     }
 
     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
     {
         fence_before(success_order);
         bool success = false;
 #if !defined(BOOST_ATOMIC_DETAIL_ARM_ASM_TMPREG_UNUSED)
-        uint32_t tmp;
+        std::uint32_t tmp;
 #endif
         extended_storage_type original;
         __asm__ __volatile__
@@ -406,12 +406,12 @@ struct core_arch_operations< 1u, Signed, Interprocess > :
     }
 
     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
     {
         fence_before(success_order);
         bool success = false;
 #if !defined(BOOST_ATOMIC_DETAIL_ARM_ASM_TMPREG_UNUSED)
-        uint32_t tmp;
+        std::uint32_t tmp;
 #endif
         extended_storage_type original;
         __asm__ __volatile__
@@ -444,10 +444,10 @@ struct core_arch_operations< 1u, Signed, Interprocess > :
         return success;
     }
 
-    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
     {
         fence_before(order);
-        uint32_t tmp;
+        std::uint32_t tmp;
         extended_storage_type original, result;
         __asm__ __volatile__
         (
@@ -470,10 +470,10 @@ struct core_arch_operations< 1u, Signed, Interprocess > :
         return static_cast< storage_type >(original);
     }
 
-    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
     {
         fence_before(order);
-        uint32_t tmp;
+        std::uint32_t tmp;
         extended_storage_type original, result;
         __asm__ __volatile__
         (
@@ -496,10 +496,10 @@ struct core_arch_operations< 1u, Signed, Interprocess > :
         return static_cast< storage_type >(original);
     }
 
-    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
     {
         fence_before(order);
-        uint32_t tmp;
+        std::uint32_t tmp;
         extended_storage_type original, result;
         __asm__ __volatile__
         (
@@ -522,10 +522,10 @@ struct core_arch_operations< 1u, Signed, Interprocess > :
         return static_cast< storage_type >(original);
     }
 
-    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
     {
         fence_before(order);
-        uint32_t tmp;
+        std::uint32_t tmp;
         extended_storage_type original, result;
         __asm__ __volatile__
         (
@@ -548,10 +548,10 @@ struct core_arch_operations< 1u, Signed, Interprocess > :
         return static_cast< storage_type >(original);
     }
 
-    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
     {
         fence_before(order);
-        uint32_t tmp;
+        std::uint32_t tmp;
         extended_storage_type original, result;
         __asm__ __volatile__
         (
@@ -574,12 +574,12 @@ struct core_arch_operations< 1u, Signed, Interprocess > :
         return static_cast< storage_type >(original);
     }
 
-    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 !!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
     {
         store(storage, (storage_type)0, order);
     }
@@ -591,13 +591,13 @@ template< bool Interprocess >
 struct core_arch_operations< 1u, false, Interprocess > :
     public core_arch_operations< 4u, false, Interprocess >
 {
-    typedef core_arch_operations< 4u, false, Interprocess > base_type;
-    typedef typename base_type::storage_type storage_type;
+    using base_type = core_arch_operations< 4u, false, Interprocess >;
+    using storage_type = typename base_type::storage_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
     {
         base_type::fence_before(order);
-        uint32_t tmp;
+        std::uint32_t tmp;
         storage_type original, result;
         __asm__ __volatile__
         (
@@ -621,10 +621,10 @@ struct core_arch_operations< 1u, false, Interprocess > :
         return original;
     }
 
-    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
     {
         base_type::fence_before(order);
-        uint32_t tmp;
+        std::uint32_t tmp;
         storage_type original, result;
         __asm__ __volatile__
         (
@@ -653,13 +653,13 @@ template< bool Interprocess >
 struct core_arch_operations< 1u, true, Interprocess > :
     public core_arch_operations< 4u, true, Interprocess >
 {
-    typedef core_arch_operations< 4u, true, Interprocess > base_type;
-    typedef typename base_type::storage_type storage_type;
+    using base_type = core_arch_operations< 4u, true, Interprocess >;
+    using storage_type = typename base_type::storage_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
     {
         base_type::fence_before(order);
-        uint32_t tmp;
+        std::uint32_t tmp;
         storage_type original, result;
         __asm__ __volatile__
         (
@@ -683,10 +683,10 @@ struct core_arch_operations< 1u, true, Interprocess > :
         return original;
     }
 
-    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
     {
         base_type::fence_before(order);
-        uint32_t tmp;
+        std::uint32_t tmp;
         storage_type original, result;
         __asm__ __volatile__
         (
@@ -719,33 +719,33 @@ template< bool Signed, bool Interprocess >
 struct core_arch_operations< 2u, Signed, Interprocess > :
     public core_arch_operations_gcc_arm_base
 {
-    typedef typename storage_traits< 2u >::type storage_type;
-    typedef typename storage_traits< 4u >::type extended_storage_type;
+    using storage_type = typename storage_traits< 2u >::type;
+    using extended_storage_type = typename storage_traits< 4u >::type;
 
-    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 2u;
-    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_alignment = 2u;
-    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 = 2u;
+    static constexpr std::size_t storage_alignment = 2u;
+    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(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(order);
         return 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
     {
         fence_before(order);
         extended_storage_type original;
-        uint32_t tmp;
+        std::uint32_t tmp;
         __asm__ __volatile__
         (
             BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp])
@@ -764,12 +764,12 @@ struct core_arch_operations< 2u, Signed, Interprocess > :
     }
 
     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
     {
         fence_before(success_order);
         bool success = false;
 #if !defined(BOOST_ATOMIC_DETAIL_ARM_ASM_TMPREG_UNUSED)
-        uint32_t tmp;
+        std::uint32_t tmp;
 #endif
         extended_storage_type original;
         __asm__ __volatile__
@@ -800,12 +800,12 @@ struct core_arch_operations< 2u, Signed, Interprocess > :
     }
 
     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
     {
         fence_before(success_order);
         bool success = false;
 #if !defined(BOOST_ATOMIC_DETAIL_ARM_ASM_TMPREG_UNUSED)
-        uint32_t tmp;
+        std::uint32_t tmp;
 #endif
         extended_storage_type original;
         __asm__ __volatile__
@@ -838,10 +838,10 @@ struct core_arch_operations< 2u, Signed, Interprocess > :
         return success;
     }
 
-    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
     {
         fence_before(order);
-        uint32_t tmp;
+        std::uint32_t tmp;
         extended_storage_type original, result;
         __asm__ __volatile__
         (
@@ -864,10 +864,10 @@ struct core_arch_operations< 2u, Signed, Interprocess > :
         return static_cast< storage_type >(original);
     }
 
-    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
     {
         fence_before(order);
-        uint32_t tmp;
+        std::uint32_t tmp;
         extended_storage_type original, result;
         __asm__ __volatile__
         (
@@ -890,10 +890,10 @@ struct core_arch_operations< 2u, Signed, Interprocess > :
         return static_cast< storage_type >(original);
     }
 
-    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
     {
         fence_before(order);
-        uint32_t tmp;
+        std::uint32_t tmp;
         extended_storage_type original, result;
         __asm__ __volatile__
         (
@@ -916,10 +916,10 @@ struct core_arch_operations< 2u, Signed, Interprocess > :
         return static_cast< storage_type >(original);
     }
 
-    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
     {
         fence_before(order);
-        uint32_t tmp;
+        std::uint32_t tmp;
         extended_storage_type original, result;
         __asm__ __volatile__
         (
@@ -942,10 +942,10 @@ struct core_arch_operations< 2u, Signed, Interprocess > :
         return static_cast< storage_type >(original);
     }
 
-    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
     {
         fence_before(order);
-        uint32_t tmp;
+        std::uint32_t tmp;
         extended_storage_type original, result;
         __asm__ __volatile__
         (
@@ -968,12 +968,12 @@ struct core_arch_operations< 2u, Signed, Interprocess > :
         return static_cast< storage_type >(original);
     }
 
-    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 !!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
     {
         store(storage, (storage_type)0, order);
     }
@@ -985,13 +985,13 @@ template< bool Interprocess >
 struct core_arch_operations< 2u, false, Interprocess > :
     public core_arch_operations< 4u, false, Interprocess >
 {
-    typedef core_arch_operations< 4u, false, Interprocess > base_type;
-    typedef typename base_type::storage_type storage_type;
+    using base_type = core_arch_operations< 4u, false, Interprocess >;
+    using storage_type = typename base_type::storage_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
     {
         base_type::fence_before(order);
-        uint32_t tmp;
+        std::uint32_t tmp;
         storage_type original, result;
         __asm__ __volatile__
         (
@@ -1015,10 +1015,10 @@ struct core_arch_operations< 2u, false, Interprocess > :
         return original;
     }
 
-    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
     {
         base_type::fence_before(order);
-        uint32_t tmp;
+        std::uint32_t tmp;
         storage_type original, result;
         __asm__ __volatile__
         (
@@ -1047,13 +1047,13 @@ template< bool Interprocess >
 struct core_arch_operations< 2u, true, Interprocess > :
     public core_arch_operations< 4u, true, Interprocess >
 {
-    typedef core_arch_operations< 4u, true, Interprocess > base_type;
-    typedef typename base_type::storage_type storage_type;
+    using base_type = core_arch_operations< 4u, true, Interprocess >;
+    using storage_type = typename base_type::storage_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
     {
         base_type::fence_before(order);
-        uint32_t tmp;
+        std::uint32_t tmp;
         storage_type original, result;
         __asm__ __volatile__
         (
@@ -1077,10 +1077,10 @@ struct core_arch_operations< 2u, true, Interprocess > :
         return original;
     }
 
-    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
     {
         base_type::fence_before(order);
-        uint32_t tmp;
+        std::uint32_t tmp;
         storage_type original, result;
         __asm__ __volatile__
         (
@@ -1124,19 +1124,19 @@ template< bool Signed, bool Interprocess >
 struct core_arch_operations< 8u, Signed, Interprocess > :
     public core_arch_operations_gcc_arm_base
 {
-    typedef typename storage_traits< 8u >::type storage_type;
+    using storage_type = typename storage_traits< 8u >::type;
 
-    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 8u;
-    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_alignment = 8u;
-    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 = 8u;
+    static constexpr std::size_t storage_alignment = 8u;
+    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
     {
         exchange(storage, v, 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
     {
         // ARMv7 says ldrex (and other load-exclusive instructions) can be used without a matching strex, see
         // "ARM Architecture Reference Manual ARMv7-A and ARMv7-R edition", Section A3.4.5 "Load-Exclusive and Store-Exclusive usage restrictions".
@@ -1149,7 +1149,7 @@ struct core_arch_operations< 8u, Signed, Interprocess > :
             : "Q" (storage)      // %1
         );
 #else
-        uint32_t tmp;
+        std::uint32_t tmp;
         __asm__ __volatile__
         (
             BOOST_ATOMIC_DETAIL_ARM_ASM_START(%0)
@@ -1164,11 +1164,11 @@ struct core_arch_operations< 8u, Signed, Interprocess > :
         return original;
     }
 
-    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
     {
         fence_before(order);
         storage_type original;
-        uint32_t tmp;
+        std::uint32_t tmp;
         __asm__ __volatile__
         (
             BOOST_ATOMIC_DETAIL_ARM_ASM_START(%0)
@@ -1189,12 +1189,12 @@ struct core_arch_operations< 8u, Signed, Interprocess > :
     }
 
     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
     {
         fence_before(success_order);
         storage_type original;
         bool success = false;
-        uint32_t tmp;
+        std::uint32_t tmp;
         __asm__ __volatile__
         (
             BOOST_ATOMIC_DETAIL_ARM_ASM_START(%0)
@@ -1224,12 +1224,12 @@ struct core_arch_operations< 8u, Signed, Interprocess > :
     }
 
     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
     {
         fence_before(success_order);
         storage_type original;
         bool success = false;
-        uint32_t tmp;
+        std::uint32_t tmp;
         __asm__ __volatile__
         (
             BOOST_ATOMIC_DETAIL_ARM_ASM_START(%0)
@@ -1260,11 +1260,11 @@ struct core_arch_operations< 8u, Signed, Interprocess > :
         return success;
     }
 
-    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
     {
         fence_before(order);
         storage_type original, result;
-        uint32_t tmp;
+        std::uint32_t tmp;
         __asm__ __volatile__
         (
             BOOST_ATOMIC_DETAIL_ARM_ASM_START(%0)
@@ -1287,11 +1287,11 @@ struct core_arch_operations< 8u, Signed, Interprocess > :
         return original;
     }
 
-    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
     {
         fence_before(order);
         storage_type original, result;
-        uint32_t tmp;
+        std::uint32_t tmp;
         __asm__ __volatile__
         (
             BOOST_ATOMIC_DETAIL_ARM_ASM_START(%0)
@@ -1314,11 +1314,11 @@ struct core_arch_operations< 8u, Signed, Interprocess > :
         return original;
     }
 
-    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
     {
         fence_before(order);
         storage_type original, result;
-        uint32_t tmp;
+        std::uint32_t tmp;
         __asm__ __volatile__
         (
             BOOST_ATOMIC_DETAIL_ARM_ASM_START(%0)
@@ -1341,11 +1341,11 @@ struct core_arch_operations< 8u, Signed, Interprocess > :
         return original;
     }
 
-    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
     {
         fence_before(order);
         storage_type original, result;
-        uint32_t tmp;
+        std::uint32_t tmp;
         __asm__ __volatile__
         (
             BOOST_ATOMIC_DETAIL_ARM_ASM_START(%0)
@@ -1368,11 +1368,11 @@ struct core_arch_operations< 8u, Signed, Interprocess > :
         return original;
     }
 
-    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
     {
         fence_before(order);
         storage_type original, result;
-        uint32_t tmp;
+        std::uint32_t tmp;
         __asm__ __volatile__
         (
             BOOST_ATOMIC_DETAIL_ARM_ASM_START(%0)
@@ -1395,12 +1395,12 @@ struct core_arch_operations< 8u, Signed, Interprocess > :
         return original;
     }
 
-    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 !!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
     {
         store(storage, (storage_type)0, order);
     }