passenger 6.1.0 → 6.1.1

data/src/cxx_supportlib/vendor-modified/boost/atomic/detail/futex.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 Andrey Semashev
+ * Copyright (c) 2020-2025 Andrey Semashev
  */
 /*!
  * \file   atomic/detail/futex.hpp
@@ -23,7 +23,7 @@
 #pragma once
 #endif
 
-#if defined(__linux__) || defined(__NETBSD__) || defined(__NetBSD__)
+#if defined(__linux__)
 
 #include <sys/syscall.h>
 
@@ -33,16 +33,10 @@
 // On some 32-bit targets (e.g. riscv32) SYS_futex is not defined and instead SYS_futex_time64 is implemented,
 // which is equivalent to SYS_futex but uses 64-bit time_t.
 #define BOOST_ATOMIC_DETAIL_SYS_FUTEX SYS_futex_time64
+#define BOOST_ATOMIC_DETAIL_FUTEX_TIME64
 #elif defined(__NR_futex)
 // Some Android NDKs (Google NDK and older Crystax.NET NDK versions) don't define SYS_futex.
 #define BOOST_ATOMIC_DETAIL_SYS_FUTEX __NR_futex
-#elif defined(SYS___futex)
-// NetBSD defines SYS___futex, which has slightly different parameters. Basically, it has decoupled timeout and val2 parameters:
-// int __futex(int *addr1, int op, int val1, const struct timespec *timeout, int *addr2, int val2, int val3);
-// https://ftp.netbsd.org/pub/NetBSD/NetBSD-current/src/sys/sys/syscall.h
-// http://bxr.su/NetBSD/sys/kern/sys_futex.c
-#define BOOST_ATOMIC_DETAIL_SYS_FUTEX SYS___futex
-#define BOOST_ATOMIC_DETAIL_NETBSD_FUTEX
 #endif
 
 #elif defined(__OpenBSD__)
@@ -52,51 +46,97 @@
 // https://github.com/openbsd/src/commit/cafeb892b121ee89c39c2b940e8ccd6950f50009
 
 #include <sys/param.h>
+#include <cerrno>
 
 #if OpenBSD >= 201711
 #define BOOST_ATOMIC_DETAIL_OPENBSD_FUTEX
-#endif
+#endif // OpenBSD >= 201711
+
+#elif defined(__NETBSD__) || defined(__NetBSD__)
+
+#include <sys/syscall.h>
+
+#if defined(SYS___futex)
+// NetBSD defines SYS___futex, which has slightly different parameters. Basically, it has decoupled timeout and val2 parameters:
+// int __futex(int *addr1, int op, int val1, const struct timespec *timeout, int *addr2, int val2, int val3);
+// https://ftp.netbsd.org/pub/NetBSD/NetBSD-current/src/sys/sys/syscall.h
+// http://bxr.su/NetBSD/sys/kern/sys_futex.c
+#define BOOST_ATOMIC_DETAIL_SYS_FUTEX SYS___futex
+#define BOOST_ATOMIC_DETAIL_NETBSD_FUTEX
+#endif // defined(SYS___futex)
 
 #endif
 
 #if defined(BOOST_ATOMIC_DETAIL_SYS_FUTEX) || defined(BOOST_ATOMIC_DETAIL_OPENBSD_FUTEX)
 
-#include <cstddef>
 #if defined(__linux__)
 #include <linux/futex.h>
 #else
 #include <sys/futex.h>
 #endif
-#include <boost/cstdint.hpp>
+#include <time.h> // timespec
+#include <cstdint>
 #include <boost/atomic/detail/intptr.hpp>
 #include <boost/atomic/detail/header.hpp>
 
 #define BOOST_ATOMIC_DETAIL_HAS_FUTEX
 
+// Note: On Android, futex.h is lacking many definitions, but the actual Linux kernel supports the API in full.
+#if defined(FUTEX_WAIT_BITSET)
+#define BOOST_ATOMIC_DETAIL_FUTEX_WAIT_BITSET FUTEX_WAIT_BITSET
+#elif defined(__ANDROID__)
+#define BOOST_ATOMIC_DETAIL_FUTEX_WAIT_BITSET 9
+#endif
+
 #if defined(FUTEX_PRIVATE_FLAG)
 #define BOOST_ATOMIC_DETAIL_FUTEX_PRIVATE_FLAG FUTEX_PRIVATE_FLAG
 #elif defined(__ANDROID__)
-// On Android, futex.h is lacking many definitions, but the actual Linux kernel supports the API in full.
 #define BOOST_ATOMIC_DETAIL_FUTEX_PRIVATE_FLAG 128
 #else
 #define BOOST_ATOMIC_DETAIL_FUTEX_PRIVATE_FLAG 0
 #endif
 
+#if defined(FUTEX_CLOCK_REALTIME)
+#define BOOST_ATOMIC_DETAIL_FUTEX_CLOCK_REALTIME FUTEX_CLOCK_REALTIME
+#elif defined(__ANDROID__)
+#define BOOST_ATOMIC_DETAIL_FUTEX_CLOCK_REALTIME 256
+#endif
+
 namespace boost {
 namespace atomics {
 namespace detail {
 
+#if defined(BOOST_ATOMIC_DETAIL_FUTEX_TIME64)
+
+//! An equivalent of `timespec` that uses 64-bit members when the userland `timespec` is 32-bit
+struct futex_timespec
+{
+    std::int64_t tv_sec;
+    std::int64_t tv_nsec;
+
+    futex_timespec() = default;
+    explicit futex_timespec(::timespec ts) noexcept :
+        tv_sec(ts.tv_sec), tv_nsec(ts.tv_nsec)
+    {}
+};
+
+#else // defined(BOOST_ATOMIC_DETAIL_FUTEX_TIME64)
+
+using futex_timespec = ::timespec;
+
+#endif // defined(BOOST_ATOMIC_DETAIL_FUTEX_TIME64)
+
 //! Invokes an operation on the futex
-BOOST_FORCEINLINE int futex_invoke(void* addr1, int op, unsigned int val1, const void* timeout = NULL, void* addr2 = NULL, unsigned int val3 = 0) BOOST_NOEXCEPT
+BOOST_FORCEINLINE int futex_invoke(void* addr1, int op, unsigned int val1, const futex_timespec* timeout = nullptr, void* addr2 = nullptr, unsigned int val3 = 0u) noexcept
 {
 #if defined(BOOST_ATOMIC_DETAIL_OPENBSD_FUTEX)
     return ::futex
     (
-        static_cast< volatile uint32_t* >(addr1),
+        static_cast< volatile std::uint32_t* >(addr1),
         op,
         static_cast< int >(val1),
-        static_cast< const struct timespec* >(timeout),
-        static_cast< volatile uint32_t* >(addr2)
+        timeout,
+        static_cast< volatile std::uint32_t* >(addr2)
     );
 #elif defined(BOOST_ATOMIC_DETAIL_NETBSD_FUTEX)
     // Pass 0 in val2.
@@ -107,71 +147,92 @@ BOOST_FORCEINLINE int futex_invoke(void* addr1, int op, unsigned int val1, const
 }
 
 //! Invokes an operation on the futex
-BOOST_FORCEINLINE int futex_invoke(void* addr1, int op, unsigned int val1, unsigned int val2, void* addr2 = NULL, unsigned int val3 = 0) BOOST_NOEXCEPT
+BOOST_FORCEINLINE int futex_invoke(void* addr1, int op, unsigned int val1, unsigned int val2, void* addr2 = nullptr, unsigned int val3 = 0u) noexcept
 {
 #if defined(BOOST_ATOMIC_DETAIL_OPENBSD_FUTEX)
     return ::futex
     (
-        static_cast< volatile uint32_t* >(addr1),
+        static_cast< volatile std::uint32_t* >(addr1),
         op,
         static_cast< int >(val1),
-        reinterpret_cast< const struct timespec* >(static_cast< atomics::detail::uintptr_t >(val2)),
-        static_cast< volatile uint32_t* >(addr2)
+        reinterpret_cast< const futex_timespec* >(static_cast< atomics::detail::uintptr_t >(val2)),
+        static_cast< volatile std::uint32_t* >(addr2)
     );
 #elif defined(BOOST_ATOMIC_DETAIL_NETBSD_FUTEX)
-    // Pass NULL in timeout.
-    return ::syscall(BOOST_ATOMIC_DETAIL_SYS_FUTEX, addr1, op, val1, static_cast< void* >(NULL), addr2, val2, val3);
+    // Pass nullptr in timeout.
+    return ::syscall(BOOST_ATOMIC_DETAIL_SYS_FUTEX, addr1, op, val1, static_cast< void* >(nullptr), addr2, val2, val3);
 #else
     return ::syscall(BOOST_ATOMIC_DETAIL_SYS_FUTEX, addr1, op, val1, static_cast< atomics::detail::uintptr_t >(val2), addr2, val3);
 #endif
 }
 
 //! Checks that the value \c pval is \c expected and blocks
-BOOST_FORCEINLINE int futex_wait(void* pval, unsigned int expected) BOOST_NOEXCEPT
+BOOST_FORCEINLINE int futex_wait(void* pval, unsigned int expected, int flags) noexcept
 {
-    return futex_invoke(pval, FUTEX_WAIT, expected);
+    int res = futex_invoke(pval, FUTEX_WAIT | flags, expected);
+#if defined(OpenBSD) && (OpenBSD < 202111)
+    // In older OpenBSD versions, futex(2) returned error code directly instead of setting errno and returning -1.
+    // This was fixed in OpenBSD 7.0 (https://github.com/openbsd/src/commit/3288ea8fbfe504db25b57dd18b664a1aa377e4bf).
+    // This primarily affects FUTEX_WAIT. For FUTEX_WAKE and FUTEX_REQUEUE the returned value may be positive
+    // on successful completion of the call and there seem to be no errors that can be returned. Other functions
+    // are not supported on OpenBSD 7.0 and older.
+    if (res > 0)
+    {
+        errno = res;
+        res = -1;
+    }
+#endif // defined(OpenBSD) && (OpenBSD < 202111)
+    return res;
 }
 
-//! Checks that the value \c pval is \c expected and blocks
-BOOST_FORCEINLINE int futex_wait_private(void* pval, unsigned int expected) BOOST_NOEXCEPT
+//! Checks that the value \c pval is \c expected and blocks until timeout
+BOOST_FORCEINLINE int futex_wait_for(void* pval, unsigned int expected, futex_timespec const& timeout, int flags) noexcept
 {
-    return futex_invoke(pval, FUTEX_WAIT | BOOST_ATOMIC_DETAIL_FUTEX_PRIVATE_FLAG, expected);
+    int res = futex_invoke(pval, FUTEX_WAIT | flags, expected, &timeout);
+#if defined(OpenBSD) && (OpenBSD < 202111)
+    // See the comment in futex_wait
+    if (res > 0)
+    {
+        errno = res;
+        res = -1;
+    }
+#endif // defined(OpenBSD) && (OpenBSD < 202111)
+    return res;
 }
 
-//! Wakes the specified number of threads waiting on the futex
-BOOST_FORCEINLINE int futex_signal(void* pval, unsigned int count = 1u) BOOST_NOEXCEPT
-{
-    return futex_invoke(pval, FUTEX_WAKE, count);
-}
+#if defined(BOOST_ATOMIC_DETAIL_FUTEX_WAIT_BITSET)
 
-//! Wakes the specified number of threads waiting on the futex
-BOOST_FORCEINLINE int futex_signal_private(void* pval, unsigned int count = 1u) BOOST_NOEXCEPT
+//! Checks that the value \c pval is \c expected and blocks until timeout
+BOOST_FORCEINLINE int futex_wait_until(void* pval, unsigned int expected, futex_timespec const& timeout, int flags) noexcept
 {
-    return futex_invoke(pval, FUTEX_WAKE | BOOST_ATOMIC_DETAIL_FUTEX_PRIVATE_FLAG, count);
+    return futex_invoke(pval, BOOST_ATOMIC_DETAIL_FUTEX_WAIT_BITSET | flags, expected, &timeout, nullptr, ~static_cast< unsigned int >(0u));
 }
 
-//! Wakes all threads waiting on the futex
-BOOST_FORCEINLINE int futex_broadcast(void* pval) BOOST_NOEXCEPT
-{
-    return futex_signal(pval, (~static_cast< unsigned int >(0u)) >> 1);
-}
+#endif // defined(BOOST_ATOMIC_DETAIL_FUTEX_WAIT_BITSET)
 
-//! Wakes all threads waiting on the futex
-BOOST_FORCEINLINE int futex_broadcast_private(void* pval) BOOST_NOEXCEPT
+//! Wakes the specified number of threads waiting on the futex
+BOOST_FORCEINLINE int futex_signal(void* pval, int flags, unsigned int count = 1u) noexcept
 {
-    return futex_signal_private(pval, (~static_cast< unsigned int >(0u)) >> 1);
+    return futex_invoke(pval, FUTEX_WAKE | flags, count);
 }
 
-//! Wakes the wake_count threads waiting on the futex pval1 and requeues up to requeue_count of the blocked threads onto another futex pval2
-BOOST_FORCEINLINE int futex_requeue(void* pval1, void* pval2, unsigned int wake_count = 1u, unsigned int requeue_count = (~static_cast< unsigned int >(0u)) >> 1) BOOST_NOEXCEPT
+//! Wakes all threads waiting on the futex
+BOOST_FORCEINLINE int futex_broadcast(void* pval, int flags) noexcept
 {
-    return futex_invoke(pval1, FUTEX_REQUEUE, wake_count, requeue_count, pval2);
+    return futex_signal(pval, flags, (~static_cast< unsigned int >(0u)) >> 1u);
 }
 
 //! Wakes the wake_count threads waiting on the futex pval1 and requeues up to requeue_count of the blocked threads onto another futex pval2
-BOOST_FORCEINLINE int futex_requeue_private(void* pval1, void* pval2, unsigned int wake_count = 1u, unsigned int requeue_count = (~static_cast< unsigned int >(0u)) >> 1) BOOST_NOEXCEPT
+BOOST_FORCEINLINE int futex_requeue
+(
+    void* pval1,
+    void* pval2,
+    int flags,
+    unsigned int wake_count = 1u,
+    unsigned int requeue_count = (~static_cast< unsigned int >(0u)) >> 1u
+) noexcept
 {
-    return futex_invoke(pval1, FUTEX_REQUEUE | BOOST_ATOMIC_DETAIL_FUTEX_PRIVATE_FLAG, wake_count, requeue_count, pval2);
+    return futex_invoke(pval1, FUTEX_REQUEUE | flags, wake_count, requeue_count, pval2);
 }
 
 } // namespace detail

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

@@ -50,7 +50,7 @@ namespace detail {
  *       propagate constants even when functions are marked with BOOST_FORCEINLINE. In this case
  *       all atomic operaions will be executed with seq_cst semantics.
  */
-BOOST_FORCEINLINE BOOST_CONSTEXPR int convert_memory_order_to_gcc(memory_order order) BOOST_NOEXCEPT
+BOOST_FORCEINLINE constexpr int convert_memory_order_to_gcc(memory_order order) noexcept
 {
     return (order == memory_order_relaxed ? __ATOMIC_RELAXED : (order == memory_order_consume ? __ATOMIC_CONSUME :
         (order == memory_order_acquire ? __ATOMIC_ACQUIRE : (order == memory_order_release ? __ATOMIC_RELEASE :

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

@@ -0,0 +1,51 @@
+/*
+ * 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/has_posix_clock_traits.hpp
+ *
+ * This header contains utilities for working with \c posix_clock_traits.
+ */
+
+#ifndef BOOST_ATOMIC_DETAIL_HAS_POSIX_CLOCK_TRAITS_HPP_INCLUDED_
+#define BOOST_ATOMIC_DETAIL_HAS_POSIX_CLOCK_TRAITS_HPP_INCLUDED_
+
+#include <sys/types.h> // clockid_t
+#include <type_traits>
+#include <boost/atomic/posix_clock_traits_fwd.hpp>
+#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 {
+
+template< typename Clock >
+struct has_posix_clock_traits_impl
+{
+    template< typename T, clockid_t = posix_clock_traits< T >::clock_id >
+    static std::true_type check_posix_clock_traits_clock_id(T*);
+    static std::false_type check_posix_clock_traits_clock_id(...);
+
+    using type = decltype(has_posix_clock_traits_impl< Clock >::check_posix_clock_traits_clock_id(static_cast< Clock* >(nullptr)));
+};
+
+//! Checks if there exists a specialization of \c posix_clock_traits for \c Clock
+template< typename Clock >
+using has_posix_clock_traits = typename has_posix_clock_traits_impl< Clock >::type;
+
+} // namespace detail
+} // namespace atomics
+} // namespace boost
+
+#include <boost/atomic/detail/footer.hpp>
+
+#endif // BOOST_ATOMIC_DETAIL_HAS_POSIX_CLOCK_TRAITS_HPP_INCLUDED_

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

@@ -39,7 +39,7 @@
 #if defined(__SIZEOF_POINTER__)
 #define BOOST_ATOMIC_DETAIL_SIZEOF_POINTER __SIZEOF_POINTER__
 #elif defined(_MSC_VER)
-#if defined(_M_AMD64) || defined(_M_ARM64) || defined(_M_IA64)
+#if defined(_M_AMD64) || defined(_M_ARM64) || defined(_M_ARM64EC) || defined(_M_IA64)
 #define BOOST_ATOMIC_DETAIL_SIZEOF_POINTER 8
 #else
 #define BOOST_ATOMIC_DETAIL_SIZEOF_POINTER 4
@@ -52,45 +52,40 @@
 
 // Try to deduce sizes from limits
 #include <limits.h>
-#if defined(__has_include)
-#if __has_include(<stdint.h>)
-#include <stdint.h>
-#endif
-#endif
-#include <boost/cstdint.hpp>
+#include <cstdint>
 
 #if !defined(BOOST_ATOMIC_DETAIL_SIZEOF_SHORT)
-#if (USHRT_MAX + 0) == 0xff
+#if (USHRT_MAX == 0xff)
 #define BOOST_ATOMIC_DETAIL_SIZEOF_SHORT 1
-#elif (USHRT_MAX + 0) == 0xffff
+#elif (USHRT_MAX == 0xffff)
 #define BOOST_ATOMIC_DETAIL_SIZEOF_SHORT 2
-#elif (USHRT_MAX + 0) == 0xffffffff
+#elif (USHRT_MAX == 0xffffffff)
 #define BOOST_ATOMIC_DETAIL_SIZEOF_SHORT 4
-#elif (USHRT_MAX + 0) == UINT64_C(0xffffffffffffffff)
+#elif (USHRT_MAX == UINT64_C(0xffffffffffffffff))
 #define BOOST_ATOMIC_DETAIL_SIZEOF_SHORT 8
 #endif
 #endif // !defined(BOOST_ATOMIC_DETAIL_SIZEOF_SHORT)
 
 #if !defined(BOOST_ATOMIC_DETAIL_SIZEOF_INT)
-#if (UINT_MAX + 0) == 0xff
+#if (UINT_MAX == 0xff)
 #define BOOST_ATOMIC_DETAIL_SIZEOF_INT 1
-#elif (UINT_MAX + 0) == 0xffff
+#elif (UINT_MAX == 0xffff)
 #define BOOST_ATOMIC_DETAIL_SIZEOF_INT 2
-#elif (UINT_MAX + 0) == 0xffffffff
+#elif (UINT_MAX == 0xffffffff)
 #define BOOST_ATOMIC_DETAIL_SIZEOF_INT 4
-#elif (UINT_MAX + 0) == UINT64_C(0xffffffffffffffff)
+#elif (UINT_MAX == UINT64_C(0xffffffffffffffff))
 #define BOOST_ATOMIC_DETAIL_SIZEOF_INT 8
 #endif
 #endif // !defined(BOOST_ATOMIC_DETAIL_SIZEOF_INT)
 
 #if !defined(BOOST_ATOMIC_DETAIL_SIZEOF_LONG)
-#if (ULONG_MAX + 0) == 0xff
+#if (ULONG_MAX == 0xff)
 #define BOOST_ATOMIC_DETAIL_SIZEOF_LONG 1
-#elif (ULONG_MAX + 0) == 0xffff
+#elif (ULONG_MAX == 0xffff)
 #define BOOST_ATOMIC_DETAIL_SIZEOF_LONG 2
-#elif (ULONG_MAX + 0) == 0xffffffff
+#elif (ULONG_MAX == 0xffffffff)
 #define BOOST_ATOMIC_DETAIL_SIZEOF_LONG 4
-#elif (ULONG_MAX + 0) == UINT64_C(0xffffffffffffffff)
+#elif (ULONG_MAX == UINT64_C(0xffffffffffffffff))
 #define BOOST_ATOMIC_DETAIL_SIZEOF_LONG 8
 #endif
 #endif // !defined(BOOST_ATOMIC_DETAIL_SIZEOF_LONG)
@@ -100,7 +95,7 @@
 #define BOOST_ATOMIC_DETAIL_SIZEOF_LLONG 8
 #else
 
-// The list of the non-standard macros (the ones except ULLONG_MAX) is taken from cstdint.hpp
+// The list of the non-standard macros (the ones except ULLONG_MAX) is taken from boost/cstdint.hpp
 #if defined(ULLONG_MAX)
 #define BOOST_ATOMIC_DETAIL_ULLONG_MAX ULLONG_MAX
 #elif defined(ULONG_LONG_MAX)
@@ -111,13 +106,13 @@
 #define BOOST_ATOMIC_DETAIL_ULLONG_MAX _LLONG_MAX
 #endif
 
-#if (BOOST_ATOMIC_DETAIL_ULLONG_MAX + 0) == 0xff
+#if (BOOST_ATOMIC_DETAIL_ULLONG_MAX == 0xff)
 #define BOOST_ATOMIC_DETAIL_SIZEOF_LLONG 1
-#elif (BOOST_ATOMIC_DETAIL_ULLONG_MAX + 0) == 0xffff
+#elif (BOOST_ATOMIC_DETAIL_ULLONG_MAX == 0xffff)
 #define BOOST_ATOMIC_DETAIL_SIZEOF_LLONG 2
-#elif (BOOST_ATOMIC_DETAIL_ULLONG_MAX + 0) == 0xffffffff
+#elif (BOOST_ATOMIC_DETAIL_ULLONG_MAX == 0xffffffff)
 #define BOOST_ATOMIC_DETAIL_SIZEOF_LLONG 4
-#elif (BOOST_ATOMIC_DETAIL_ULLONG_MAX + 0) == UINT64_C(0xffffffffffffffff)
+#elif (BOOST_ATOMIC_DETAIL_ULLONG_MAX == UINT64_C(0xffffffffffffffff))
 #define BOOST_ATOMIC_DETAIL_SIZEOF_LLONG 8
 #endif
 
@@ -125,11 +120,11 @@
 #endif // !defined(BOOST_ATOMIC_DETAIL_SIZEOF_LLONG)
 
 #if !defined(BOOST_ATOMIC_DETAIL_SIZEOF_POINTER) && defined(UINTPTR_MAX)
-#if (UINTPTR_MAX + 0) == 0xffff
+#if (UINTPTR_MAX == 0xffff)
 #define BOOST_ATOMIC_DETAIL_SIZEOF_POINTER 2
-#elif (UINTPTR_MAX + 0) == 0xffffffff
+#elif (UINTPTR_MAX == 0xffffffff)
 #define BOOST_ATOMIC_DETAIL_SIZEOF_POINTER 4
-#elif (UINTPTR_MAX + 0) == UINT64_C(0xffffffffffffffff)
+#elif (UINTPTR_MAX == UINT64_C(0xffffffffffffffff))
 #define BOOST_ATOMIC_DETAIL_SIZEOF_POINTER 8
 #endif
 #endif // !defined(BOOST_ATOMIC_DETAIL_SIZEOF_POINTER) && defined(UINTPTR_MAX)
@@ -139,18 +134,17 @@
 #if !defined(BOOST_ATOMIC_DETAIL_SIZEOF_WCHAR_T)
 
 #include <wchar.h>
-#include <boost/cstdint.hpp>
 
 #if defined(_MSC_VER) && (_MSC_VER <= 1310 || defined(UNDER_CE) && _MSC_VER <= 1500)
 // MSVC 7.1 and MSVC 8 (arm) define WCHAR_MAX to a value not suitable for constant expressions
 #define BOOST_ATOMIC_DETAIL_SIZEOF_WCHAR_T 2
-#elif (WCHAR_MAX + 0) == 0xff || (WCHAR_MAX + 0) == 0x7f
+#elif (WCHAR_MAX == 0xff) || (WCHAR_MAX == 0x7f)
 #define BOOST_ATOMIC_DETAIL_SIZEOF_WCHAR_T 1
-#elif (WCHAR_MAX + 0) == 0xffff || (WCHAR_MAX + 0) == 0x7fff
+#elif (WCHAR_MAX == 0xffff) || (WCHAR_MAX == 0x7fff)
 #define BOOST_ATOMIC_DETAIL_SIZEOF_WCHAR_T 2
-#elif (WCHAR_MAX + 0) == 0xffffffff || (WCHAR_MAX + 0) == 0x7fffffff
+#elif (WCHAR_MAX == 0xffffffff) || (WCHAR_MAX == 0x7fffffff)
 #define BOOST_ATOMIC_DETAIL_SIZEOF_WCHAR_T 4
-#elif (WCHAR_MAX + 0) == UINT64_C(0xffffffffffffffff) || (WCHAR_MAX + 0) == INT64_C(0x7fffffffffffffff)
+#elif (WCHAR_MAX == UINT64_C(0xffffffffffffffff)) || (WCHAR_MAX == INT64_C(0x7fffffffffffffff))
 #define BOOST_ATOMIC_DETAIL_SIZEOF_WCHAR_T 8
 #endif
 #endif

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

@@ -3,7 +3,7 @@
  * (See accompanying file LICENSE_1_0.txt or copy at
  * http://www.boost.org/LICENSE_1_0.txt)
  *
- * Copyright (c) 2018 Andrey Semashev
+ * Copyright (c) 2018-2025 Andrey Semashev
  */
 /*!
  * \file   atomic/detail/integral_conversions.hpp
@@ -14,9 +14,9 @@
 #ifndef BOOST_ATOMIC_DETAIL_INTEGRAL_CONVERSIONS_HPP_INCLUDED_
 #define BOOST_ATOMIC_DETAIL_INTEGRAL_CONVERSIONS_HPP_INCLUDED_
 
+#include <type_traits>
 #include <boost/atomic/detail/config.hpp>
 #include <boost/atomic/detail/bitwise_cast.hpp>
-#include <boost/atomic/detail/type_traits/integral_constant.hpp>
 #include <boost/atomic/detail/type_traits/is_signed.hpp>
 #include <boost/atomic/detail/type_traits/make_signed.hpp>
 #include <boost/atomic/detail/type_traits/make_unsigned.hpp>
@@ -31,7 +31,7 @@ namespace atomics {
 namespace detail {
 
 template< typename Output, typename Input >
-BOOST_FORCEINLINE Output zero_extend_impl(Input input, atomics::detail::true_type) BOOST_NOEXCEPT
+BOOST_FORCEINLINE Output zero_extend_impl(Input input, std::true_type) noexcept
 {
     // Note: If we are casting with truncation or to the same-sized output, don't cause signed integer overflow by this chain of conversions
     return atomics::detail::bitwise_cast< Output >(static_cast< typename atomics::detail::make_unsigned< Output >::type >(
@@ -39,64 +39,64 @@ BOOST_FORCEINLINE Output zero_extend_impl(Input input, atomics::detail::true_typ
 }
 
 template< typename Output, typename Input >
-BOOST_FORCEINLINE Output zero_extend_impl(Input input, atomics::detail::false_type) BOOST_NOEXCEPT
+BOOST_FORCEINLINE Output zero_extend_impl(Input input, std::false_type) noexcept
 {
     return static_cast< Output >(static_cast< typename atomics::detail::make_unsigned< Input >::type >(input));
 }
 
 //! Zero-extends or truncates (wraps) input operand to fit in the output type
 template< typename Output, typename Input >
-BOOST_FORCEINLINE Output zero_extend(Input input) BOOST_NOEXCEPT
+BOOST_FORCEINLINE Output zero_extend(Input input) noexcept
 {
-    return atomics::detail::zero_extend_impl< Output >(input, atomics::detail::integral_constant< bool, atomics::detail::is_signed< Output >::value >());
+    return atomics::detail::zero_extend_impl< Output >(input, std::integral_constant< bool, atomics::detail::is_signed< Output >::value >());
 }
 
 //! Truncates (wraps) input operand to fit in the output type
 template< typename Output, typename Input >
-BOOST_FORCEINLINE Output integral_truncate(Input input) BOOST_NOEXCEPT
+BOOST_FORCEINLINE Output integral_truncate(Input input) noexcept
 {
     // zero_extend does the truncation
     return atomics::detail::zero_extend< Output >(input);
 }
 
 template< typename Output, typename Input >
-BOOST_FORCEINLINE Output sign_extend_impl(Input input, atomics::detail::true_type) BOOST_NOEXCEPT
+BOOST_FORCEINLINE Output sign_extend_impl(Input input, std::true_type) noexcept
 {
     return atomics::detail::integral_truncate< Output >(input);
 }
 
 template< typename Output, typename Input >
-BOOST_FORCEINLINE Output sign_extend_impl(Input input, atomics::detail::false_type) BOOST_NOEXCEPT
+BOOST_FORCEINLINE Output sign_extend_impl(Input input, std::false_type) noexcept
 {
     return static_cast< Output >(atomics::detail::bitwise_cast< typename atomics::detail::make_signed< Input >::type >(input));
 }
 
 //! Sign-extends or truncates (wraps) input operand to fit in the output type
 template< typename Output, typename Input >
-BOOST_FORCEINLINE Output sign_extend(Input input) BOOST_NOEXCEPT
+BOOST_FORCEINLINE Output sign_extend(Input input) noexcept
 {
-    return atomics::detail::sign_extend_impl< Output >(input, atomics::detail::integral_constant< bool, sizeof(Output) <= sizeof(Input) >());
+    return atomics::detail::sign_extend_impl< Output >(input, std::integral_constant< bool, sizeof(Output) <= sizeof(Input) >());
 }
 
 //! Sign-extends or truncates (wraps) input operand to fit in the output type
 template< typename Output, typename Input >
-BOOST_FORCEINLINE Output integral_extend(Input input, atomics::detail::true_type) BOOST_NOEXCEPT
+BOOST_FORCEINLINE Output integral_extend(Input input, std::true_type) noexcept
 {
     return atomics::detail::sign_extend< Output >(input);
 }
 
 //! Zero-extends or truncates (wraps) input operand to fit in the output type
 template< typename Output, typename Input >
-BOOST_FORCEINLINE Output integral_extend(Input input, atomics::detail::false_type) BOOST_NOEXCEPT
+BOOST_FORCEINLINE Output integral_extend(Input input, std::false_type) noexcept
 {
     return atomics::detail::zero_extend< Output >(input);
 }
 
 //! Sign- or zero-extends or truncates (wraps) input operand to fit in the output type
 template< bool Signed, typename Output, typename Input >
-BOOST_FORCEINLINE Output integral_extend(Input input) BOOST_NOEXCEPT
+BOOST_FORCEINLINE Output integral_extend(Input input) noexcept
 {
-    return atomics::detail::integral_extend< Output >(input, atomics::detail::integral_constant< bool, Signed >());
+    return atomics::detail::integral_extend< Output >(input, std::integral_constant< bool, Signed >());
 }
 
 } // namespace detail