passenger 6.1.0 → 6.1.1

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

@@ -5,7 +5,7 @@
  *
  * Copyright (c) 2009 Helge Bahmann
  * Copyright (c) 2012 Tim Blechmann
- * Copyright (c) 2013-2018, 2020-2021 Andrey Semashev
+ * Copyright (c) 2013-2018, 2020-2025 Andrey Semashev
  */
 /*!
  * \file   atomic/detail/bitwise_cast.hpp
@@ -17,11 +17,11 @@
 #define BOOST_ATOMIC_DETAIL_BITWISE_CAST_HPP_INCLUDED_
 
 #include <cstddef>
+#include <type_traits>
 #include <boost/atomic/detail/config.hpp>
 #include <boost/atomic/detail/addressof.hpp>
 #include <boost/atomic/detail/string_ops.hpp>
-#include <boost/atomic/detail/type_traits/remove_cv.hpp>
-#include <boost/atomic/detail/type_traits/integral_constant.hpp>
+#include <boost/atomic/detail/type_traits/is_trivially_copyable.hpp>
 #include <boost/atomic/detail/type_traits/has_unique_object_representations.hpp>
 #include <boost/atomic/detail/header.hpp>
 
@@ -43,12 +43,12 @@
 
 #endif // !defined(BOOST_ATOMIC_DETAIL_NO_HAS_UNIQUE_OBJECT_REPRESENTATIONS)
 
-#if defined(BOOST_NO_CXX11_CONSTEXPR) || !defined(BOOST_ATOMIC_DETAIL_BIT_CAST) || !defined(BOOST_ATOMIC_DETAIL_HAS_BUILTIN_ADDRESSOF)
+#if !defined(BOOST_ATOMIC_DETAIL_BIT_CAST) || !defined(BOOST_ATOMIC_DETAIL_HAS_BUILTIN_ADDRESSOF)
 #define BOOST_ATOMIC_DETAIL_NO_CXX11_CONSTEXPR_BITWISE_CAST
 #endif
 
 #if !defined(BOOST_ATOMIC_DETAIL_NO_CXX11_CONSTEXPR_BITWISE_CAST)
-#define BOOST_ATOMIC_DETAIL_CONSTEXPR_BITWISE_CAST BOOST_CONSTEXPR
+#define BOOST_ATOMIC_DETAIL_CONSTEXPR_BITWISE_CAST constexpr
 #else
 #define BOOST_ATOMIC_DETAIL_CONSTEXPR_BITWISE_CAST
 #endif
@@ -64,83 +64,96 @@ namespace atomics {
 namespace detail {
 
 template< std::size_t ValueSize, typename To >
-BOOST_FORCEINLINE void clear_tail_padding_bits(To& to, atomics::detail::true_type) BOOST_NOEXCEPT
+BOOST_FORCEINLINE void clear_tail_padding_bits(To& to, std::true_type) noexcept
 {
     BOOST_ATOMIC_DETAIL_MEMSET(reinterpret_cast< unsigned char* >(atomics::detail::addressof(to)) + ValueSize, 0, sizeof(To) - ValueSize);
 }
 
 template< std::size_t ValueSize, typename To >
-BOOST_FORCEINLINE void clear_tail_padding_bits(To&, atomics::detail::false_type) BOOST_NOEXCEPT
+BOOST_FORCEINLINE void clear_tail_padding_bits(To&, std::false_type) noexcept
 {
 }
 
 template< std::size_t ValueSize, typename To >
-BOOST_FORCEINLINE void clear_tail_padding_bits(To& to) BOOST_NOEXCEPT
+BOOST_FORCEINLINE void clear_tail_padding_bits(To& to) noexcept
 {
-    atomics::detail::clear_tail_padding_bits< ValueSize >(to, atomics::detail::integral_constant< bool, ValueSize < sizeof(To) >());
+    atomics::detail::clear_tail_padding_bits< ValueSize >(to, std::integral_constant< bool, ValueSize < sizeof(To) >());
 }
 
 template< typename To, std::size_t FromValueSize, typename From >
-BOOST_FORCEINLINE To bitwise_cast_memcpy(From const& from) BOOST_NOEXCEPT
+BOOST_FORCEINLINE To bitwise_cast_memcpy(From const& from) noexcept
 {
-    typedef typename atomics::detail::remove_cv< To >::type unqualified_to_t;
-    unqualified_to_t to;
+    using unqualified_to_t = typename std::remove_cv< To >::type;
+    static_assert(atomics::detail::is_trivially_copyable< unqualified_to_t >::value, "bitwise_cast target type must be trivially copyable");
+    static_assert(atomics::detail::is_trivially_copyable< From >::value, "bitwise_cast source type must be trivially copyable");
+
+    // Suppress default constructor of To as it may potentially be a non-trivial throwing constructor
+    union cast_helper
+    {
+        unsigned char as_bytes[sizeof(unqualified_to_t)];
+        unqualified_to_t as_to;
+
+        BOOST_FORCEINLINE cast_helper() noexcept {}
+    }
+    storage;
+
 #if !defined(BOOST_ATOMIC_NO_CLEAR_PADDING)
     From from2(from);
     BOOST_ATOMIC_DETAIL_CLEAR_PADDING(atomics::detail::addressof(from2));
     BOOST_ATOMIC_DETAIL_MEMCPY
     (
-        atomics::detail::addressof(to),
+        atomics::detail::addressof(storage.as_to),
         atomics::detail::addressof(from2),
         (FromValueSize < sizeof(unqualified_to_t) ? FromValueSize : sizeof(unqualified_to_t))
     );
 #else
     BOOST_ATOMIC_DETAIL_MEMCPY
     (
-        atomics::detail::addressof(to),
+        atomics::detail::addressof(storage.as_to),
         atomics::detail::addressof(from),
         (FromValueSize < sizeof(unqualified_to_t) ? FromValueSize : sizeof(unqualified_to_t))
     );
 #endif
-    atomics::detail::clear_tail_padding_bits< FromValueSize >(to);
-    return to;
+    atomics::detail::clear_tail_padding_bits< FromValueSize >(storage.as_to);
+    return storage.as_to;
 }
 
 #if defined(BOOST_ATOMIC_DETAIL_BIT_CAST)
 
 template< typename To, std::size_t FromValueSize, typename From >
-BOOST_FORCEINLINE BOOST_ATOMIC_DETAIL_CONSTEXPR_BITWISE_CAST To bitwise_cast_impl(From const& from, atomics::detail::true_type) BOOST_NOEXCEPT
+BOOST_FORCEINLINE BOOST_ATOMIC_DETAIL_CONSTEXPR_BITWISE_CAST To bitwise_cast_impl(From const& from, std::true_type) noexcept
 {
     // This implementation is only called when the From type has no padding and From and To have the same size
-    return BOOST_ATOMIC_DETAIL_BIT_CAST(typename atomics::detail::remove_cv< To >::type, from);
+    return BOOST_ATOMIC_DETAIL_BIT_CAST(typename std::remove_cv< To >::type, from);
 }
 
 template< typename To, std::size_t FromValueSize, typename From >
-BOOST_FORCEINLINE To bitwise_cast_impl(From const& from, atomics::detail::false_type) BOOST_NOEXCEPT
+BOOST_FORCEINLINE To bitwise_cast_impl(From const& from, std::false_type) noexcept
 {
     return atomics::detail::bitwise_cast_memcpy< To, FromValueSize >(from);
 }
 
 template< typename To, std::size_t FromValueSize, typename From >
-BOOST_FORCEINLINE BOOST_ATOMIC_DETAIL_CONSTEXPR_BITWISE_CAST To bitwise_cast(From const& from) BOOST_NOEXCEPT
+BOOST_FORCEINLINE BOOST_ATOMIC_DETAIL_CONSTEXPR_BITWISE_CAST To bitwise_cast(From const& from) noexcept
 {
-    return atomics::detail::bitwise_cast_impl< To, FromValueSize >(from, atomics::detail::integral_constant< bool,
+    return atomics::detail::bitwise_cast_impl< To, FromValueSize >(from, std::integral_constant< bool,
         FromValueSize == sizeof(To) && atomics::detail::has_unique_object_representations< From >::value >());
 }
 
 #else // defined(BOOST_ATOMIC_DETAIL_BIT_CAST)
 
 template< typename To, std::size_t FromValueSize, typename From >
-BOOST_FORCEINLINE To bitwise_cast(From const& from) BOOST_NOEXCEPT
+BOOST_FORCEINLINE To bitwise_cast(From const& from) noexcept
 {
     return atomics::detail::bitwise_cast_memcpy< To, FromValueSize >(from);
 }
 
 #endif // defined(BOOST_ATOMIC_DETAIL_BIT_CAST)
 
-//! Converts the source object to the target type, possibly by padding or truncating it on the right, and clearing any padding bits (if supported by compiler). Preserves value bits unchanged.
+//! Converts the source object to the target type, possibly by padding or truncating it on the right, and clearing any padding bits (if supported by compiler).
+//! Preserves value bits unchanged.
 template< typename To, typename From >
-BOOST_FORCEINLINE BOOST_ATOMIC_DETAIL_CONSTEXPR_BITWISE_CAST To bitwise_cast(From const& from) BOOST_NOEXCEPT
+BOOST_FORCEINLINE BOOST_ATOMIC_DETAIL_CONSTEXPR_BITWISE_CAST To bitwise_cast(From const& from) noexcept
 {
     return atomics::detail::bitwise_cast< To, sizeof(From) >(from);
 }

data/src/cxx_supportlib/vendor-modified/boost/atomic/detail/bitwise_fp_cast.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, 2021 Andrey Semashev
+ * Copyright (c) 2018-2025 Andrey Semashev
  */
 /*!
  * \file   atomic/detail/bitwise_fp_cast.hpp
@@ -19,7 +19,7 @@
 #include <boost/atomic/detail/float_sizes.hpp>
 #include <boost/atomic/detail/bitwise_cast.hpp>
 #if defined(BOOST_ATOMIC_DETAIL_BIT_CAST)
-#include <boost/atomic/detail/type_traits/integral_constant.hpp>
+#include <type_traits>
 #endif
 #include <boost/atomic/detail/header.hpp>
 
@@ -40,14 +40,14 @@ namespace detail {
 template< typename T >
 struct value_size_of
 {
-    static BOOST_CONSTEXPR_OR_CONST std::size_t value = sizeof(T);
+    static constexpr std::size_t value = sizeof(T);
 };
 
 #if defined(BOOST_ATOMIC_DETAIL_SIZEOF_FLOAT_VALUE)
 template< >
 struct value_size_of< float >
 {
-    static BOOST_CONSTEXPR_OR_CONST std::size_t value = BOOST_ATOMIC_DETAIL_SIZEOF_FLOAT_VALUE;
+    static constexpr std::size_t value = BOOST_ATOMIC_DETAIL_SIZEOF_FLOAT_VALUE;
 };
 #endif
 
@@ -55,7 +55,7 @@ struct value_size_of< float >
 template< >
 struct value_size_of< double >
 {
-    static BOOST_CONSTEXPR_OR_CONST std::size_t value = BOOST_ATOMIC_DETAIL_SIZEOF_DOUBLE_VALUE;
+    static constexpr std::size_t value = BOOST_ATOMIC_DETAIL_SIZEOF_DOUBLE_VALUE;
 };
 #endif
 
@@ -63,7 +63,7 @@ struct value_size_of< double >
 template< >
 struct value_size_of< long double >
 {
-    static BOOST_CONSTEXPR_OR_CONST std::size_t value = BOOST_ATOMIC_DETAIL_SIZEOF_LONG_DOUBLE_VALUE;
+    static constexpr std::size_t value = BOOST_ATOMIC_DETAIL_SIZEOF_LONG_DOUBLE_VALUE;
 };
 #endif
 
@@ -89,12 +89,12 @@ struct value_size_of< const volatile T > : value_size_of< T > {};
 
 //! Similar to bitwise_cast, but either \c From or \c To is expected to be a floating point type. Attempts to detect the actual value size in the source object and considers the rest of the object as padding.
 template< typename To, typename From >
-BOOST_FORCEINLINE BOOST_ATOMIC_DETAIL_CONSTEXPR_BITWISE_CAST To bitwise_fp_cast(From const& from) BOOST_NOEXCEPT
+BOOST_FORCEINLINE BOOST_ATOMIC_DETAIL_CONSTEXPR_BITWISE_CAST To bitwise_fp_cast(From const& from) noexcept
 {
     // For floating point types, has_unique_object_representations is typically false even if the type contains no padding bits.
     // Here, we rely on our detection of the actual value size to select constexpr bit_cast implementation when possible. We assume
     // here that floating point value bits are contiguous.
-    return atomics::detail::bitwise_cast_impl< To, BOOST_ATOMIC_DETAIL_BITWISE_FP_CAST_VALUE_SIZE_OF(From) >(from, atomics::detail::integral_constant< bool,
+    return atomics::detail::bitwise_cast_impl< To, BOOST_ATOMIC_DETAIL_BITWISE_FP_CAST_VALUE_SIZE_OF(From) >(from, std::integral_constant< bool,
         atomics::detail::value_size_of< From >::value == sizeof(From) && atomics::detail::value_size_of< From >::value == sizeof(To) >());
 }
 
@@ -102,7 +102,7 @@ BOOST_FORCEINLINE BOOST_ATOMIC_DETAIL_CONSTEXPR_BITWISE_CAST To bitwise_fp_cast(
 
 //! Similar to bitwise_cast, but either \c From or \c To is expected to be a floating point type. Attempts to detect the actual value size in the source object and considers the rest of the object as padding.
 template< typename To, typename From >
-BOOST_FORCEINLINE BOOST_ATOMIC_DETAIL_CONSTEXPR_BITWISE_CAST To bitwise_fp_cast(From const& from) BOOST_NOEXCEPT
+BOOST_FORCEINLINE BOOST_ATOMIC_DETAIL_CONSTEXPR_BITWISE_CAST To bitwise_fp_cast(From const& from) noexcept
 {
     return atomics::detail::bitwise_cast< To, BOOST_ATOMIC_DETAIL_BITWISE_FP_CAST_VALUE_SIZE_OF(From) >(from);
 }

data/src/cxx_supportlib/vendor-modified/boost/atomic/detail/cas_based_exchange.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/cas_based_exchange.hpp
@@ -30,9 +30,9 @@ template< typename Base >
 struct cas_based_exchange :
     public Base
 {
-    typedef typename Base::storage_type storage_type;
+    using storage_type = typename Base::storage_type;
 
-    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
     {
         storage_type old_val;
         atomics::detail::non_atomic_load(storage, old_val);

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

@@ -0,0 +1,93 @@
+/*
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * Copyright (c) 2025 Andrey Semashev
+ */
+/*!
+ * \file   atomic/detail/chrono.hpp
+ *
+ * This header contains \c std::chrono utilities.
+ */
+
+#ifndef BOOST_ATOMIC_DETAIL_CHRONO_HPP_INCLUDED_
+#define BOOST_ATOMIC_DETAIL_CHRONO_HPP_INCLUDED_
+
+#include <time.h>
+#include <chrono>
+#if !defined(__cpp_lib_chrono) || (__cpp_lib_chrono < 201510l)
+#include <ratio>
+#include <type_traits>
+#endif // !defined(__cpp_lib_chrono) || (__cpp_lib_chrono < 201510l)
+#if defined(CLOCK_REALTIME)
+#include <boost/atomic/posix_clock_traits_fwd.hpp>
+#endif // defined(CLOCK_REALTIME)
+#include <boost/atomic/detail/config.hpp>
+#include <boost/atomic/detail/header.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+namespace boost {
+namespace atomics {
+namespace detail {
+namespace chrono {
+
+#if defined(__cpp_lib_chrono) && (__cpp_lib_chrono >= 201510l)
+
+using std::chrono::ceil;
+
+#else // defined(__cpp_lib_chrono) && (__cpp_lib_chrono >= 201510l)
+
+template< typename To, typename Rep, typename Period >
+inline constexpr To ceil(std::chrono::duration< Rep, Period > from) noexcept
+{
+    using conv_ratio = std::ratio_divide< Period, typename To::period >;
+    using common_rep = typename std::common_type< Rep, typename To::rep, decltype(conv_ratio::num) >::type;
+    return To(static_cast< typename To::rep >((static_cast< common_rep >(from.count()) * conv_ratio::num) / conv_ratio::den +
+        static_cast< common_rep >(((static_cast< common_rep >(from.count()) * conv_ratio::num) % conv_ratio::den) != static_cast< common_rep >(0))));
+}
+
+#endif // defined(__cpp_lib_chrono) && (__cpp_lib_chrono >= 201510l)
+
+} // namespace chrono
+} // namespace detail
+
+#if defined(CLOCK_REALTIME)
+
+//! Integrate `std::chrono::system_clock` with POSIX clocks
+template< >
+struct posix_clock_traits< std::chrono::system_clock >
+{
+    //! POSIX clock identifier
+    static constexpr clockid_t clock_id = CLOCK_REALTIME;
+
+    //! Function that converts a time point to a timespec structure
+    static timespec to_timespec(std::chrono::system_clock::time_point time_point) noexcept
+    {
+        timespec ts{};
+        std::chrono::nanoseconds::rep time_ns = std::chrono::duration_cast< std::chrono::nanoseconds >(time_point.time_since_epoch()).count();
+        // Note: The standard doesn't require that std::chrono::system_clock epoch matches the POSIX CLOCK_REALTIME epoch. Also, std::chrono::system_clock::to_time_t
+        //       is allowed to round or truncate the time point when converting to time_t resolution, which means to_time_t may return a time before or after time_point.
+        ts.tv_sec = std::chrono::system_clock::to_time_t(std::chrono::system_clock::time_point()) + static_cast< decltype(ts.tv_sec) >(time_ns / 1000000000);
+        time_ns %= 1000000000;
+        if (BOOST_UNLIKELY(time_ns < 0))
+        {
+            --ts.tv_sec;
+            time_ns += 1000000000;
+        }
+        ts.tv_nsec = static_cast< decltype(ts.tv_nsec) >(time_ns);
+        return ts;
+    }
+};
+
+#endif // defined(CLOCK_REALTIME)
+
+} // namespace atomics
+} // namespace boost
+
+#include <boost/atomic/detail/footer.hpp>
+
+#endif // BOOST_ATOMIC_DETAIL_CHRONO_HPP_INCLUDED_

data/src/cxx_supportlib/vendor-modified/boost/atomic/detail/classify.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) 2020-2021 Andrey Semashev
+ * Copyright (c) 2020-2025 Andrey Semashev
  */
 /*!
  * \file   atomic/detail/classify.hpp
@@ -14,10 +14,9 @@
 #ifndef BOOST_ATOMIC_DETAIL_CLASSIFY_HPP_INCLUDED_
 #define BOOST_ATOMIC_DETAIL_CLASSIFY_HPP_INCLUDED_
 
+#include <type_traits>
 #include <boost/atomic/detail/config.hpp>
-#include <boost/atomic/detail/type_traits/is_enum.hpp>
 #include <boost/atomic/detail/type_traits/is_integral.hpp>
-#include <boost/atomic/detail/type_traits/is_function.hpp>
 #include <boost/atomic/detail/type_traits/is_floating_point.hpp>
 #include <boost/atomic/detail/header.hpp>
 
@@ -29,57 +28,57 @@ namespace boost {
 namespace atomics {
 namespace detail {
 
-template< typename T, bool IsFunction = atomics::detail::is_function< T >::value >
+template< typename T, bool IsFunction = std::is_function< T >::value >
 struct classify_pointer
 {
-    typedef void* type;
+    using type = void*;
 };
 
 template< typename T >
 struct classify_pointer< T, true >
 {
-    typedef void type;
+    using type = void;
 };
 
 template<
     typename T,
     bool IsInt = atomics::detail::is_integral< T >::value,
     bool IsFloat = atomics::detail::is_floating_point< T >::value,
-    bool IsEnum = atomics::detail::is_enum< T >::value
+    bool IsEnum = std::is_enum< T >::value
 >
 struct classify
 {
-    typedef void type;
+    using type = void;
 };
 
 template< typename T >
-struct classify< T, true, false, false > { typedef int type; };
+struct classify< T, true, false, false > { using type = int; };
 
 #if !defined(BOOST_ATOMIC_NO_FLOATING_POINT)
 template< typename T >
-struct classify< T, false, true, false > { typedef float type; };
+struct classify< T, false, true, false > { using type = float; };
 #endif
 
 template< typename T >
-struct classify< T, false, false, true > { typedef const int type; };
+struct classify< T, false, false, true > { using type = const int; };
 
 template< typename T >
-struct classify< T*, false, false, false > { typedef typename classify_pointer< T >::type type; };
+struct classify< T*, false, false, false > { using type = typename classify_pointer< T >::type; };
 
 template< >
-struct classify< void*, false, false, false > { typedef void type; };
+struct classify< void*, false, false, false > { using type = void; };
 
 template< >
-struct classify< const void*, false, false, false > { typedef void type; };
+struct classify< const void*, false, false, false > { using type = void; };
 
 template< >
-struct classify< volatile void*, false, false, false > { typedef void type; };
+struct classify< volatile void*, false, false, false > { using type = void; };
 
 template< >
-struct classify< const volatile void*, false, false, false > { typedef void type; };
+struct classify< const volatile void*, false, false, false > { using type = void; };
 
 template< typename T, typename U >
-struct classify< T U::*, false, false, false > { typedef void type; };
+struct classify< T U::*, false, false, false > { using type = void; };
 
 } // namespace detail
 } // namespace atomics

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

@@ -4,7 +4,7 @@
  * http://www.boost.org/LICENSE_1_0.txt)
  *
  * Copyright (c) 2012 Hartmut Kaiser
- * Copyright (c) 2014-2018, 2020-2021 Andrey Semashev
+ * Copyright (c) 2014-2018, 2020-2025 Andrey Semashev
  */
 /*!
  * \file   atomic/detail/config.hpp
@@ -21,6 +21,29 @@
 #pragma once
 #endif
 
+#if defined(__SANITIZE_THREAD__)
+#define BOOST_ATOMIC_DETAIL_TSAN
+#elif defined(__has_feature)
+#if __has_feature(thread_sanitizer)
+#define BOOST_ATOMIC_DETAIL_TSAN
+#endif
+#endif
+
+// Instrumentation macros to make TSan aware of the memory order semantics of asm blocks
+#if defined(BOOST_ATOMIC_DETAIL_TSAN)
+extern "C" {
+void __tsan_acquire(void*);
+void __tsan_release(void*);
+} // extern "C"
+#define BOOST_ATOMIC_DETAIL_TSAN_ACQUIRE(ptr, mo) \
+    { if ((static_cast< unsigned int >(mo) & static_cast< unsigned int >(memory_order_acquire)) != 0u) __tsan_acquire((void*)(ptr)); }
+#define BOOST_ATOMIC_DETAIL_TSAN_RELEASE(ptr, mo) \
+    { if ((static_cast< unsigned int >(mo) & static_cast< unsigned int >(memory_order_release)) != 0u) __tsan_release((void*)(ptr)); }
+#else // defined(BOOST_ATOMIC_DETAIL_TSAN)
+#define BOOST_ATOMIC_DETAIL_TSAN_ACQUIRE(ptr, mo)
+#define BOOST_ATOMIC_DETAIL_TSAN_RELEASE(ptr, mo)
+#endif // defined(BOOST_ATOMIC_DETAIL_TSAN)
+
 #if defined(__CUDACC__)
 // nvcc does not support alternatives ("q,m") in asm statement constraints
 #define BOOST_ATOMIC_DETAIL_NO_ASM_CONSTRAINT_ALTERNATIVES
@@ -47,13 +70,6 @@
 #define BOOST_ATOMIC_DETAIL_X86_ASM_PRESERVE_EBX
 #endif
 
-#if defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
-#if !(defined(BOOST_LIBSTDCXX11) && BOOST_LIBSTDCXX_VERSION >= 40700) /* libstdc++ from gcc >= 4.7 in C++11 mode */
-// This macro indicates that there is not even a basic <type_traits> standard header that is sufficient for most Boost.Atomic needs.
-#define BOOST_ATOMIC_DETAIL_NO_CXX11_BASIC_HDR_TYPE_TRAITS
-#endif
-#endif // defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
-
 #if defined(BOOST_NO_CXX11_ALIGNAS) ||\
     (defined(BOOST_GCC) && BOOST_GCC < 40900) ||\
     (defined(BOOST_MSVC) && BOOST_MSVC < 1910 && defined(_M_IX86))
@@ -63,18 +79,6 @@
 #define BOOST_ATOMIC_DETAIL_NO_CXX11_ALIGNAS
 #endif
 
-#if defined(BOOST_NO_CXX11_CONSTEXPR) || (defined(BOOST_GCC) && BOOST_GCC < 40800)
-// This macro indicates that the compiler doesn't support constexpr constructors that initialize one member
-// of an anonymous union member of the class.
-#define BOOST_ATOMIC_DETAIL_NO_CXX11_CONSTEXPR_UNION_INIT
-#endif
-
-#if !defined(BOOST_ATOMIC_DETAIL_NO_CXX11_CONSTEXPR_UNION_INIT)
-#define BOOST_ATOMIC_DETAIL_CONSTEXPR_UNION_INIT BOOST_CONSTEXPR
-#else
-#define BOOST_ATOMIC_DETAIL_CONSTEXPR_UNION_INIT
-#endif
-
 // Enable pointer/reference casts between storage and value when possible.
 // Note: Despite that MSVC does not employ strict aliasing rules for optimizations
 // and does not require an explicit markup for types that may alias, we still don't
@@ -91,19 +95,6 @@
 #define BOOST_ATOMIC_DETAIL_ASM_HAS_FLAG_OUTPUTS
 #endif
 
-#if defined(BOOST_INTEL) || (defined(BOOST_GCC) && BOOST_GCC < 40700) ||\
-    (defined(BOOST_CLANG) && !defined(__apple_build_version__) && (__clang_major__ * 100 + __clang_minor__) < 302) ||\
-    (defined(__clang__) && defined(__apple_build_version__) && (__clang_major__ * 100 + __clang_minor__) < 402)
-// Intel compiler (at least 18.0 update 1) breaks if noexcept specification is used in defaulted function declarations:
-// error: the default constructor of "boost::atomics::atomic<T>" cannot be referenced -- it is a deleted function
-// GCC 4.6 doesn't seem to support that either. Clang 3.1 deduces wrong noexcept for the defaulted function and fails as well.
-#define BOOST_ATOMIC_DETAIL_DEF_NOEXCEPT_DECL
-#define BOOST_ATOMIC_DETAIL_DEF_NOEXCEPT_IMPL BOOST_NOEXCEPT
-#else
-#define BOOST_ATOMIC_DETAIL_DEF_NOEXCEPT_DECL BOOST_NOEXCEPT
-#define BOOST_ATOMIC_DETAIL_DEF_NOEXCEPT_IMPL
-#endif
-
 #if defined(__has_builtin)
 #if __has_builtin(__builtin_constant_p)
 #define BOOST_ATOMIC_DETAIL_IS_CONSTANT(x) __builtin_constant_p(x)
@@ -135,7 +126,7 @@
 #endif
 
 #if (defined(__BYTE_ORDER__) && defined(__FLOAT_WORD_ORDER__) && __BYTE_ORDER__ == __FLOAT_WORD_ORDER__) ||\
-    defined(__i386__) || defined(__x86_64__) || defined(_M_IX86) || defined(_M_X64)
+    defined(__i386__) || defined(__x86_64__) || defined(_M_IX86) || defined(_M_AMD64) || defined(_M_ARM) || defined(_M_ARM64) || defined(_M_ARM64EC)
 // This macro indicates that integer and floating point endianness is the same
 #define BOOST_ATOMIC_DETAIL_INT_FP_ENDIAN_MATCH
 #endif