passenger 6.1.0 → 6.1.1

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

@@ -46,7 +46,8 @@ extern "C" long __cdecl InterlockedDecrement(long*);
 
 #endif // _WIN32_WCE >= 0x600
 
-#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest, exchange, compare) ((void*)BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE((long*)(dest), (long)(exchange), (long)(compare)))
+#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest, exchange, compare) \
+    ((void*)BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE((long*)(dest), (long)(exchange), (long)(compare)))
 #define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_POINTER(dest, exchange) ((void*)BOOST_ATOMIC_INTERLOCKED_EXCHANGE((long*)(dest), (long)(exchange)))
 
 #elif defined(_MSC_VER) && _MSC_VER >= 1310
@@ -73,7 +74,8 @@ extern "C" long __cdecl _InterlockedDecrement(long volatile*);
 #define BOOST_ATOMIC_INTERLOCKED_INCREMENT(dest) _InterlockedIncrement((long*)(dest))
 #define BOOST_ATOMIC_INTERLOCKED_DECREMENT(dest) _InterlockedDecrement((long*)(dest))
 
-#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest, exchange, compare) ((void*)BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE((long*)(dest), (long)(exchange), (long)(compare)))
+#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest, exchange, compare) \
+    ((void*)BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE((long*)(dest), (long)(exchange), (long)(compare)))
 #define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_POINTER(dest, exchange) ((void*)BOOST_ATOMIC_INTERLOCKED_EXCHANGE((long*)(dest), (long)(exchange)))
 
 #else // _MSC_VER < 1400
@@ -104,7 +106,7 @@ extern "C" long __cdecl _InterlockedDecrement(long volatile*);
 #define BOOST_ATOMIC_INTERLOCKED_BTS(dest, arg) _interlockedbittestandset((long*)(dest), (long)(arg))
 #define BOOST_ATOMIC_INTERLOCKED_BTR(dest, arg) _interlockedbittestandreset((long*)(dest), (long)(arg))
 
-#if defined(_M_AMD64)
+#if defined(_M_AMD64) && !defined(_M_ARM64EC)
 #if defined(BOOST_MSVC)
 #pragma intrinsic(_interlockedbittestandset64)
 #pragma intrinsic(_interlockedbittestandreset64)
@@ -112,20 +114,21 @@ extern "C" long __cdecl _InterlockedDecrement(long volatile*);
 
 #define BOOST_ATOMIC_INTERLOCKED_BTS64(dest, arg) _interlockedbittestandset64((__int64*)(dest), (__int64)(arg))
 #define BOOST_ATOMIC_INTERLOCKED_BTR64(dest, arg) _interlockedbittestandreset64((__int64*)(dest), (__int64)(arg))
-#endif // defined(_M_AMD64)
+#endif // defined(_M_AMD64) && !defined(_M_ARM64EC)
 
-#if (defined(_M_IX86) && _M_IX86 >= 500) || defined(_M_AMD64) || defined(_M_IA64)
+#if (defined(_M_IX86) && _M_IX86 >= 500) || (defined(_M_AMD64) && !defined(_M_ARM64EC)) || defined(_M_IA64)
 #if defined(BOOST_MSVC)
 #pragma intrinsic(_InterlockedCompareExchange64)
 #endif
 #define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE64(dest, exchange, compare) _InterlockedCompareExchange64((__int64*)(dest), (__int64)(exchange), (__int64)(compare))
 #endif
 
-#if _MSC_VER >= 1500 && defined(_M_AMD64)
+#if _MSC_VER >= 1500 && (defined(_M_AMD64) && !defined(_M_ARM64EC))
 #if defined(BOOST_MSVC)
 #pragma intrinsic(_InterlockedCompareExchange128)
 #endif
-#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE128(dest, exchange, compare) _InterlockedCompareExchange128((__int64*)(dest), ((const __int64*)(&exchange))[1], ((const __int64*)(&exchange))[0], (__int64*)(compare))
+#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE128(dest, exchange, compare) \
+    _InterlockedCompareExchange128((__int64*)(dest), ((const __int64*)(&exchange))[1], ((const __int64*)(&exchange))[0], (__int64*)(compare))
 #endif
 
 #if _MSC_VER >= 1600
@@ -168,7 +171,7 @@ extern "C" long __cdecl _InterlockedDecrement(long volatile*);
 
 #endif // _MSC_VER >= 1600
 
-#if defined(_M_AMD64) || defined(_M_IA64)
+#if (defined(_M_AMD64) && !defined(_M_ARM64EC)) || defined(_M_IA64)
 
 #if defined(BOOST_MSVC)
 #pragma intrinsic(_InterlockedExchangeAdd64)
@@ -201,7 +204,7 @@ extern "C" long __cdecl _InterlockedDecrement(long volatile*);
 
 #endif
 
-#if _MSC_VER >= 1700 && (defined(_M_ARM) || defined(_M_ARM64))
+#if _MSC_VER >= 1700 && (defined(_M_ARM) || defined(_M_ARM64) || defined(_M_ARM64EC))
 
 #if defined(BOOST_MSVC)
 #pragma intrinsic(_InterlockedExchangeAdd64)
@@ -231,29 +234,62 @@ extern "C" long __cdecl _InterlockedDecrement(long volatile*);
 #pragma intrinsic(_InterlockedCompareExchange64_nf)
 #pragma intrinsic(_InterlockedCompareExchange64_acq)
 #pragma intrinsic(_InterlockedCompareExchange64_rel)
+#if _MSC_VER >= 1900 && (defined(_M_ARM64) || defined(_M_ARM64EC))
+#pragma intrinsic(_InterlockedCompareExchange128)
+#pragma intrinsic(_InterlockedCompareExchange128_nf)
+#pragma intrinsic(_InterlockedCompareExchange128_acq)
+#pragma intrinsic(_InterlockedCompareExchange128_rel)
+#endif
 #pragma intrinsic(_InterlockedCompareExchangePointer)
 #pragma intrinsic(_InterlockedCompareExchangePointer_nf)
 #pragma intrinsic(_InterlockedCompareExchangePointer_acq)
 #pragma intrinsic(_InterlockedCompareExchangePointer_rel)
 #endif
 
-#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE8_RELAXED(dest, exchange, compare) _InterlockedCompareExchange8_nf((char*)(dest), (char)(exchange), (char)(compare))
-#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE8_ACQUIRE(dest, exchange, compare) _InterlockedCompareExchange8_acq((char*)(dest), (char)(exchange), (char)(compare))
-#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE8_RELEASE(dest, exchange, compare) _InterlockedCompareExchange8_rel((char*)(dest), (char)(exchange), (char)(compare))
-#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE16_RELAXED(dest, exchange, compare) _InterlockedCompareExchange16_nf((short*)(dest), (short)(exchange), (short)(compare))
-#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE16_ACQUIRE(dest, exchange, compare) _InterlockedCompareExchange16_acq((short*)(dest), (short)(exchange), (short)(compare))
-#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE16_RELEASE(dest, exchange, compare) _InterlockedCompareExchange16_rel((short*)(dest), (short)(exchange), (short)(compare))
-#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_RELAXED(dest, exchange, compare) _InterlockedCompareExchange_nf((long*)(dest), (long)(exchange), (long)(compare))
-#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_ACQUIRE(dest, exchange, compare) _InterlockedCompareExchange_acq((long*)(dest), (long)(exchange), (long)(compare))
-#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_RELEASE(dest, exchange, compare) _InterlockedCompareExchange_rel((long*)(dest), (long)(exchange), (long)(compare))
-#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE64(dest, exchange, compare) _InterlockedCompareExchange64((__int64*)(dest), (__int64)(exchange), (__int64)(compare))
-#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE64_RELAXED(dest, exchange, compare) _InterlockedCompareExchange64_nf((__int64*)(dest), (__int64)(exchange), (__int64)(compare))
-#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE64_ACQUIRE(dest, exchange, compare) _InterlockedCompareExchange64_acq((__int64*)(dest), (__int64)(exchange), (__int64)(compare))
-#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE64_RELEASE(dest, exchange, compare) _InterlockedCompareExchange64_rel((__int64*)(dest), (__int64)(exchange), (__int64)(compare))
-#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest, exchange, compare) _InterlockedCompareExchangePointer((void**)(dest), (void*)(exchange), (void*)(compare))
-#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_POINTER_RELAXED(dest, exchange, compare) _InterlockedCompareExchangePointer_nf((void**)(dest), (void*)(exchange), (void*)(compare))
-#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_POINTER_ACQUIRE(dest, exchange, compare) _InterlockedCompareExchangePointer_acq((void**)(dest), (void*)(exchange), (void*)(compare))
-#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_POINTER_RELEASE(dest, exchange, compare) _InterlockedCompareExchangePointer_rel((void**)(dest), (void*)(exchange), (void*)(compare))
+#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE8_RELAXED(dest, exchange, compare) \
+    _InterlockedCompareExchange8_nf((char*)(dest), (char)(exchange), (char)(compare))
+#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE8_ACQUIRE(dest, exchange, compare) \
+    _InterlockedCompareExchange8_acq((char*)(dest), (char)(exchange), (char)(compare))
+#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE8_RELEASE(dest, exchange, compare) \
+    _InterlockedCompareExchange8_rel((char*)(dest), (char)(exchange), (char)(compare))
+#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE16_RELAXED(dest, exchange, compare) \
+    _InterlockedCompareExchange16_nf((short*)(dest), (short)(exchange), (short)(compare))
+#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE16_ACQUIRE(dest, exchange, compare) \
+    _InterlockedCompareExchange16_acq((short*)(dest), (short)(exchange), (short)(compare))
+#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE16_RELEASE(dest, exchange, compare) \
+    _InterlockedCompareExchange16_rel((short*)(dest), (short)(exchange), (short)(compare))
+#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_RELAXED(dest, exchange, compare) \
+    _InterlockedCompareExchange_nf((long*)(dest), (long)(exchange), (long)(compare))
+#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_ACQUIRE(dest, exchange, compare) \
+    _InterlockedCompareExchange_acq((long*)(dest), (long)(exchange), (long)(compare))
+#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_RELEASE(dest, exchange, compare) \
+    _InterlockedCompareExchange_rel((long*)(dest), (long)(exchange), (long)(compare))
+#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE64(dest, exchange, compare) \
+    _InterlockedCompareExchange64((__int64*)(dest), (__int64)(exchange), (__int64)(compare))
+#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE64_RELAXED(dest, exchange, compare) \
+    _InterlockedCompareExchange64_nf((__int64*)(dest), (__int64)(exchange), (__int64)(compare))
+#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE64_ACQUIRE(dest, exchange, compare) \
+    _InterlockedCompareExchange64_acq((__int64*)(dest), (__int64)(exchange), (__int64)(compare))
+#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE64_RELEASE(dest, exchange, compare) \
+    _InterlockedCompareExchange64_rel((__int64*)(dest), (__int64)(exchange), (__int64)(compare))
+#if _MSC_VER >= 1900 && (defined(_M_ARM64) || defined(_M_ARM64EC))
+#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE128(dest, exchange, compare) \
+    _InterlockedCompareExchange128((__int64*)(dest), ((const __int64*)(&exchange))[1], ((const __int64*)(&exchange))[0], (__int64*)(compare))
+#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE128_RELAXED(dest, exchange, compare) \
+    _InterlockedCompareExchange128_nf((__int64*)(dest), ((const __int64*)(&exchange))[1], ((const __int64*)(&exchange))[0], (__int64*)(compare))
+#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE128_ACQUIRE(dest, exchange, compare) \
+    _InterlockedCompareExchange128_acq((__int64*)(dest), ((const __int64*)(&exchange))[1], ((const __int64*)(&exchange))[0], (__int64*)(compare))
+#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE128_RELEASE(dest, exchange, compare) \
+    _InterlockedCompareExchange128_rel((__int64*)(dest), ((const __int64*)(&exchange))[1], ((const __int64*)(&exchange))[0], (__int64*)(compare))
+#endif
+#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest, exchange, compare) \
+    _InterlockedCompareExchangePointer((void**)(dest), (void*)(exchange), (void*)(compare))
+#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_POINTER_RELAXED(dest, exchange, compare) \
+    _InterlockedCompareExchangePointer_nf((void**)(dest), (void*)(exchange), (void*)(compare))
+#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_POINTER_ACQUIRE(dest, exchange, compare) \
+    _InterlockedCompareExchangePointer_acq((void**)(dest), (void*)(exchange), (void*)(compare))
+#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_POINTER_RELEASE(dest, exchange, compare) \
+    _InterlockedCompareExchangePointer_rel((void**)(dest), (void*)(exchange), (void*)(compare))
 
 #if defined(BOOST_MSVC)
 #pragma intrinsic(_InterlockedExchangeAdd8_nf)
@@ -283,7 +319,7 @@ extern "C" long __cdecl _InterlockedDecrement(long volatile*);
 #define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD64_ACQUIRE(dest, addend) _InterlockedExchangeAdd64_acq((__int64*)(dest), (__int64)(addend))
 #define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD64_RELEASE(dest, addend) _InterlockedExchangeAdd64_rel((__int64*)(dest), (__int64)(addend))
 
-#if defined(_M_ARM64)
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
 #define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD_POINTER(dest, byte_offset) ((void*)BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD64((__int64*)(dest), byte_offset))
 #define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD_POINTER_RELAXED(dest, byte_offset) ((void*)BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD64_RELAXED((__int64*)(dest), byte_offset))
 #define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD_POINTER_ACQUIRE(dest, byte_offset) ((void*)BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD64_ACQUIRE((__int64*)(dest), byte_offset))
@@ -500,7 +536,8 @@ BOOST_ATOMIC_INTERLOCKED_IMPORT long __stdcall InterlockedExchangeAdd(long volat
 BOOST_ATOMIC_INTERLOCKED_IMPORT long __stdcall InterlockedIncrement(long volatile*, long);
 BOOST_ATOMIC_INTERLOCKED_IMPORT long __stdcall InterlockedDecrement(long volatile*, long);
 
-#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE(dest, exchange, compare) boost::atomics::detail::InterlockedCompareExchange((long*)(dest), (long)(exchange), (long)(compare))
+#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE(dest, exchange, compare) \
+    boost::atomics::detail::InterlockedCompareExchange((long*)(dest), (long)(exchange), (long)(compare))
 #define BOOST_ATOMIC_INTERLOCKED_EXCHANGE(dest, newval) boost::atomics::detail::InterlockedExchange((long*)(dest), (long)(newval))
 #define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD(dest, addend) boost::atomics::detail::InterlockedExchangeAdd((long*)(dest), (long)(addend))
 #define BOOST_ATOMIC_INTERLOCKED_INCREMENT(dest) boost::atomics::detail::InterlockedIncrement((long*)(dest))
@@ -515,11 +552,13 @@ BOOST_ATOMIC_INTERLOCKED_IMPORT __int64 __stdcall InterlockedExchangeAdd64(__int
 BOOST_ATOMIC_INTERLOCKED_IMPORT void* __stdcall InterlockedCompareExchangePointer(void* volatile*, void*, void*);
 BOOST_ATOMIC_INTERLOCKED_IMPORT void* __stdcall InterlockedExchangePointer(void* volatile*, void*);
 
-#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE64(dest, exchange, compare) boost::atomics::detail::InterlockedCompareExchange64((__int64*)(dest), (__int64)(exchange), (__int64)(compare))
+#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE64(dest, exchange, compare) \
+    boost::atomics::detail::InterlockedCompareExchange64((__int64*)(dest), (__int64)(exchange), (__int64)(compare))
 #define BOOST_ATOMIC_INTERLOCKED_EXCHANGE64(dest, newval) boost::atomics::detail::InterlockedExchange64((__int64*)(dest), (__int64)(newval))
 #define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD64(dest, addend) boost::atomics::detail::InterlockedExchangeAdd64((__int64*)(dest), (__int64)(addend))
 
-#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest, exchange, compare) boost::atomics::detail::InterlockedCompareExchangePointer((void**)(dest), (void*)(exchange), (void*)(compare))
+#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest, exchange, compare) \
+    boost::atomics::detail::InterlockedCompareExchangePointer((void**)(dest), (void*)(exchange), (void*)(compare))
 #define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_POINTER(dest, newval) boost::atomics::detail::InterlockedExchangePointer((void**)(dest), (void*)(newval))
 #define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD_POINTER(dest, byte_offset) ((void*)BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD64(dest, byte_offset))
 

data/src/cxx_supportlib/vendor-modified/boost/atomic/detail/intptr.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/intptr.hpp
@@ -14,8 +14,8 @@
 #ifndef BOOST_ATOMIC_DETAIL_INTPTR_HPP_INCLUDED_
 #define BOOST_ATOMIC_DETAIL_INTPTR_HPP_INCLUDED_
 
-#include <boost/cstdint.hpp>
-#if defined(BOOST_HAS_INTPTR_T)
+#include <cstdint>
+#if !defined(UINTPTR_MAX)
 #include <cstddef>
 #endif
 #include <boost/atomic/detail/config.hpp>
@@ -29,12 +29,12 @@ namespace boost {
 namespace atomics {
 namespace detail {
 
-#if !defined(BOOST_HAS_INTPTR_T)
-using boost::uintptr_t;
-using boost::intptr_t;
+#if defined(UINTPTR_MAX)
+using std::uintptr_t;
+using std::intptr_t;
 #else
-typedef std::size_t uintptr_t;
-typedef std::ptrdiff_t intptr_t;
+using uintptr_t = std::size_t;
+using intptr_t = std::ptrdiff_t;
 #endif
 
 } // namespace detail

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

@@ -16,16 +16,18 @@
 #define BOOST_ATOMIC_DETAIL_LOCK_POOL_HPP_INCLUDED_
 
 #include <cstddef>
+#include <chrono>
 #include <boost/atomic/detail/config.hpp>
 #include <boost/atomic/detail/link.hpp>
 #include <boost/atomic/detail/intptr.hpp>
 #if defined(BOOST_WINDOWS)
 #include <boost/winapi/thread.hpp>
-#elif defined(BOOST_HAS_NANOSLEEP)
+#else // defined(BOOST_WINDOWS)
 #include <time.h>
-#else
+#if !defined(BOOST_HAS_NANOSLEEP)
 #include <unistd.h>
-#endif
+#endif // !defined(BOOST_HAS_NANOSLEEP)
+#endif // defined(BOOST_WINDOWS)
 #include <boost/atomic/detail/header.hpp>
 
 #ifdef BOOST_HAS_PRAGMA_ONCE
@@ -36,7 +38,7 @@ namespace boost {
 namespace atomics {
 namespace detail {
 
-BOOST_FORCEINLINE void wait_some() BOOST_NOEXCEPT
+BOOST_FORCEINLINE void wait_some() noexcept
 {
 #if defined(BOOST_WINDOWS)
     boost::winapi::SwitchToThread();
@@ -44,41 +46,45 @@ BOOST_FORCEINLINE void wait_some() BOOST_NOEXCEPT
     // Do not use sched_yield or pthread_yield as at least on Linux it doesn't block the thread if there are no other
     // pending threads on the current CPU. Proper sleeping is guaranteed to block the thread, which allows other threads
     // to potentially migrate to this CPU and complete the tasks we're waiting for.
-    struct ::timespec ts = {};
+    timespec ts{};
     ts.tv_sec = 0;
     ts.tv_nsec = 1000;
-    ::nanosleep(&ts, NULL);
+    nanosleep(&ts, nullptr);
 #else
-    ::usleep(1);
+    usleep(1);
 #endif
 }
 
 namespace lock_pool {
 
-BOOST_ATOMIC_DECL void* short_lock(atomics::detail::uintptr_t h) BOOST_NOEXCEPT;
-BOOST_ATOMIC_DECL void* long_lock(atomics::detail::uintptr_t h) BOOST_NOEXCEPT;
-BOOST_ATOMIC_DECL void unlock(void* ls) BOOST_NOEXCEPT;
+BOOST_ATOMIC_DECL void* short_lock(atomics::detail::uintptr_t h) noexcept;
+BOOST_ATOMIC_DECL void* long_lock(atomics::detail::uintptr_t h) noexcept;
+BOOST_ATOMIC_DECL void unlock(void* vls) noexcept;
 
-BOOST_ATOMIC_DECL void* allocate_wait_state(void* ls, const volatile void* addr) BOOST_NOEXCEPT;
-BOOST_ATOMIC_DECL void free_wait_state(void* ls, void* ws) BOOST_NOEXCEPT;
-BOOST_ATOMIC_DECL void wait(void* ls, void* ws) BOOST_NOEXCEPT;
-BOOST_ATOMIC_DECL void notify_one(void* ls, const volatile void* addr) BOOST_NOEXCEPT;
-BOOST_ATOMIC_DECL void notify_all(void* ls, const volatile void* addr) BOOST_NOEXCEPT;
+BOOST_ATOMIC_DECL void* allocate_wait_state(void* vls, const volatile void* addr) noexcept;
+BOOST_ATOMIC_DECL void free_wait_state(void* vls, void* vws) noexcept;
+BOOST_ATOMIC_DECL void wait(void* vls, void* vws) noexcept;
+#if !defined(BOOST_WINDOWS)
+BOOST_ATOMIC_DECL bool wait_until(void* vls, void* vws, clockid_t clock_id, timespec const& abs_timeout) noexcept;
+#endif // !defined(BOOST_WINDOWS)
+BOOST_ATOMIC_DECL bool wait_for(void* vls, void* vws, std::chrono::nanoseconds rel_timeout) noexcept;
+BOOST_ATOMIC_DECL void notify_one(void* vls, const volatile void* addr) noexcept;
+BOOST_ATOMIC_DECL void notify_all(void* vls, const volatile void* addr) noexcept;
 
-BOOST_ATOMIC_DECL void thread_fence() BOOST_NOEXCEPT;
-BOOST_ATOMIC_DECL void signal_fence() BOOST_NOEXCEPT;
+BOOST_ATOMIC_DECL void thread_fence() noexcept;
+BOOST_ATOMIC_DECL void signal_fence() noexcept;
 
 template< std::size_t Alignment >
-BOOST_FORCEINLINE atomics::detail::uintptr_t hash_ptr(const volatile void* addr) BOOST_NOEXCEPT
+BOOST_FORCEINLINE atomics::detail::uintptr_t hash_ptr(const volatile void* addr) noexcept
 {
-    atomics::detail::uintptr_t ptr = (atomics::detail::uintptr_t)addr;
+    atomics::detail::uintptr_t ptr = reinterpret_cast< atomics::detail::uintptr_t >(addr);
     atomics::detail::uintptr_t h = ptr / Alignment;
 
     // Since many malloc/new implementations return pointers with higher alignment
     // than indicated by Alignment, it makes sense to mix higher bits
     // into the lower ones. On 64-bit platforms, malloc typically aligns to 16 bytes,
     // on 32-bit - to 8 bytes.
-    BOOST_CONSTEXPR_OR_CONST std::size_t malloc_alignment = sizeof(void*) >= 8u ? 16u : 8u;
+    constexpr std::size_t malloc_alignment = sizeof(void*) >= 8u ? 16u : 8u;
     BOOST_IF_CONSTEXPR (Alignment != malloc_alignment)
         h ^= ptr / malloc_alignment;
 
@@ -92,7 +98,7 @@ private:
     void* m_lock;
 
 public:
-    explicit scoped_lock(const volatile void* addr) BOOST_NOEXCEPT
+    explicit scoped_lock(const volatile void* addr) noexcept
     {
         atomics::detail::uintptr_t h = lock_pool::hash_ptr< Alignment >(addr);
         BOOST_IF_CONSTEXPR (!LongLock)
@@ -100,18 +106,19 @@ public:
         else
             m_lock = lock_pool::long_lock(h);
     }
-    ~scoped_lock() BOOST_NOEXCEPT
+
+    scoped_lock(scoped_lock const&) = delete;
+    scoped_lock& operator=(scoped_lock const&) = delete;
+
+    ~scoped_lock() noexcept
     {
         lock_pool::unlock(m_lock);
     }
 
-    void* get_lock_state() const BOOST_NOEXCEPT
+    void* get_lock_state() const noexcept
     {
         return m_lock;
     }
-
-    BOOST_DELETED_FUNCTION(scoped_lock(scoped_lock const&))
-    BOOST_DELETED_FUNCTION(scoped_lock& operator=(scoped_lock const&))
 };
 
 template< std::size_t Alignment >
@@ -122,23 +129,36 @@ private:
     void* m_wait_state;
 
 public:
-    explicit scoped_wait_state(const volatile void* addr) BOOST_NOEXCEPT :
+    explicit scoped_wait_state(const volatile void* addr) noexcept :
         scoped_lock< Alignment, true >(addr)
     {
         m_wait_state = lock_pool::allocate_wait_state(this->get_lock_state(), addr);
     }
-    ~scoped_wait_state() BOOST_NOEXCEPT
+
+    scoped_wait_state(scoped_wait_state const&) = delete;
+    scoped_wait_state& operator=(scoped_wait_state const&) = delete;
+
+    ~scoped_wait_state() noexcept
     {
         lock_pool::free_wait_state(this->get_lock_state(), m_wait_state);
     }
 
-    void wait() BOOST_NOEXCEPT
+    void wait() noexcept
     {
         lock_pool::wait(this->get_lock_state(), m_wait_state);
     }
 
-    BOOST_DELETED_FUNCTION(scoped_wait_state(scoped_wait_state const&))
-    BOOST_DELETED_FUNCTION(scoped_wait_state& operator=(scoped_wait_state const&))
+#if !defined(BOOST_WINDOWS)
+    bool wait_until(clockid_t clock_id, timespec const& abs_timeout) noexcept
+    {
+        return lock_pool::wait_until(this->get_lock_state(), m_wait_state, clock_id, abs_timeout);
+    }
+#endif // !defined(BOOST_WINDOWS)
+
+    bool wait_for(std::chrono::nanoseconds rel_timeout) noexcept
+    {
+        return lock_pool::wait_for(this->get_lock_state(), m_wait_state, rel_timeout);
+    }
 };
 
 } // namespace lock_pool

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

@@ -26,12 +26,12 @@ namespace boost {
 namespace atomics {
 namespace detail {
 
-BOOST_FORCEINLINE BOOST_CONSTEXPR memory_order deduce_failure_order(memory_order order) BOOST_NOEXCEPT
+BOOST_FORCEINLINE constexpr memory_order deduce_failure_order(memory_order order) noexcept
 {
     return order == memory_order_acq_rel ? memory_order_acquire : (order == memory_order_release ? memory_order_relaxed : order);
 }
 
-BOOST_FORCEINLINE BOOST_CONSTEXPR bool cas_failure_order_must_not_be_stronger_than_success_order(memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT
+BOOST_FORCEINLINE constexpr bool cas_failure_order_must_not_be_stronger_than_success_order(memory_order success_order, memory_order failure_order) noexcept
 {
     // 15 == (memory_order_seq_cst | memory_order_consume), see memory_order.hpp
     // Given the enum values we can test the strength of memory order requirements with this single condition.

data/src/cxx_supportlib/vendor-modified/boost/atomic/detail/once_flag.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/once_flag.hpp
@@ -27,7 +27,7 @@ namespace boost {
 namespace atomics {
 namespace detail {
 
-typedef atomics::detail::core_operations< 1u, false, false > once_flag_operations;
+using once_flag_operations = atomics::detail::core_operations< 1u, false, false >;
 
 struct once_flag
 {

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

@@ -16,7 +16,7 @@
 #ifndef BOOST_ATOMIC_DETAIL_OPS_GCC_ARM_COMMON_HPP_INCLUDED_
 #define BOOST_ATOMIC_DETAIL_OPS_GCC_ARM_COMMON_HPP_INCLUDED_
 
-#include <boost/cstdint.hpp>
+#include <cstdint>
 #include <boost/memory_order.hpp>
 #include <boost/atomic/detail/config.hpp>
 #include <boost/atomic/detail/fence_arch_operations.hpp>
@@ -32,22 +32,22 @@ namespace detail {
 
 struct core_arch_operations_gcc_arm_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(memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE void fence_before(memory_order order) noexcept
     {
         if ((static_cast< unsigned int >(order) & static_cast< unsigned int >(memory_order_release)) != 0u)
             fence_arch_operations::hardware_full_fence();
     }
 
-    static BOOST_FORCEINLINE void fence_after(memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE void fence_after(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_arch_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_arch_operations::hardware_full_fence();

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

@@ -41,10 +41,10 @@ namespace detail {
 
 struct core_arch_operations_gcc_ppc_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(memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE void fence_before(memory_order order) noexcept
     {
 #if defined(__powerpc64__) || defined(__PPC64__)
         if (order == memory_order_seq_cst)
@@ -57,7 +57,7 @@ struct core_arch_operations_gcc_ppc_base
 #endif
     }
 
-    static BOOST_FORCEINLINE void fence_after(memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE void fence_after(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)
             __asm__ __volatile__ ("isync" ::: "memory");

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

@@ -82,13 +82,13 @@
 
 #define BOOST_ATOMIC_DETAIL_CORE_ARCH_BACKEND gcc_alpha
 
-#elif defined(_MSC_VER) && (defined(_M_IX86) || defined(_M_X64))
+#elif defined(_MSC_VER) && _MSC_VER >= 1700 && (defined(_M_ARM) || defined(_M_ARM64) || defined(_M_ARM64EC))
 
-#define BOOST_ATOMIC_DETAIL_CORE_ARCH_BACKEND msvc_x86
+#define BOOST_ATOMIC_DETAIL_CORE_ARCH_BACKEND msvc_arm
 
-#elif defined(_MSC_VER) && _MSC_VER >= 1700 && (defined(_M_ARM) || defined(_M_ARM64))
+#elif defined(_MSC_VER) && (defined(_M_IX86) || defined(_M_AMD64))
 
-#define BOOST_ATOMIC_DETAIL_CORE_ARCH_BACKEND msvc_arm
+#define BOOST_ATOMIC_DETAIL_CORE_ARCH_BACKEND msvc_x86
 
 #endif
 
@@ -133,7 +133,7 @@
 
 #define BOOST_ATOMIC_DETAIL_CORE_BACKEND linux_arm
 
-#elif defined(BOOST_WINDOWS) || defined(_WIN32_CE)
+#elif defined(BOOST_WINDOWS) || defined(_WIN32_WCE)
 
 #define BOOST_ATOMIC_DETAIL_CORE_BACKEND windows