passenger 6.0.13 → 6.0.15

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

@@ -0,0 +1,143 @@
+/*
+ * 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) 2021 Andrey Semashev
+ */
+/*!
+ * \file   atomic/detail/type_traits/has_unique_object_representations.hpp
+ *
+ * This header defines \c has_unique_object_representations type trait
+ */
+
+#ifndef BOOST_ATOMIC_DETAIL_TYPE_TRAITS_HAS_UNIQUE_OBJECT_REPRESENTATIONS_HPP_INCLUDED_
+#define BOOST_ATOMIC_DETAIL_TYPE_TRAITS_HAS_UNIQUE_OBJECT_REPRESENTATIONS_HPP_INCLUDED_
+
+#include <boost/atomic/detail/config.hpp>
+#if !defined(BOOST_ATOMIC_DETAIL_NO_CXX11_BASIC_HDR_TYPE_TRAITS)
+#include <type_traits>
+#endif
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+#if (defined(__cpp_lib_has_unique_object_representations) && __cpp_lib_has_unique_object_representations >= 201606) || \
+    (defined(_CPPLIB_VER) && _CPPLIB_VER >= 650 && defined(_MSVC_STL_VERSION) && _MSVC_STL_VERSION >= 141 && defined(_HAS_CXX17) && _HAS_CXX17 != 0)
+
+namespace boost {
+namespace atomics {
+namespace detail {
+
+using std::has_unique_object_representations;
+
+} // namespace detail
+} // namespace atomics
+} // namespace boost
+
+#else // defined(__cpp_lib_has_unique_object_representations) ...
+
+#if (defined(__GNUC__) && __GNUC__ >= 7) || (defined(BOOST_MSVC) && BOOST_MSVC >= 1929) || \
+    (defined(__INTEL_COMPILER) && __INTEL_COMPILER >= 1900)
+#define BOOST_ATOMIC_DETAIL_HAS_UNIQUE_OBJECT_REPRESENTATIONS(x) __has_unique_object_representations(x)
+#elif defined(__is_identifier)
+#if !__is_identifier(__has_unique_object_representations)
+#define BOOST_ATOMIC_DETAIL_HAS_UNIQUE_OBJECT_REPRESENTATIONS(x) __has_unique_object_representations(x)
+#endif
+#endif
+
+#if defined(BOOST_ATOMIC_DETAIL_HAS_UNIQUE_OBJECT_REPRESENTATIONS)
+
+#include <cstddef>
+#include <boost/atomic/detail/type_traits/integral_constant.hpp>
+
+namespace boost {
+namespace atomics {
+namespace detail {
+
+template< typename T >
+struct has_unique_object_representations :
+    public atomics::detail::integral_constant< bool, BOOST_ATOMIC_DETAIL_HAS_UNIQUE_OBJECT_REPRESENTATIONS(T) >
+{
+};
+
+template< typename T >
+struct has_unique_object_representations< T[] > :
+    public atomics::detail::has_unique_object_representations< T >
+{
+};
+
+template< typename T, std::size_t N >
+struct has_unique_object_representations< T[N] > :
+    public atomics::detail::has_unique_object_representations< T >
+{
+};
+
+template< typename T >
+struct has_unique_object_representations< const T > :
+    public atomics::detail::has_unique_object_representations< T >
+{
+};
+
+template< typename T >
+struct has_unique_object_representations< volatile T > :
+    public atomics::detail::has_unique_object_representations< T >
+{
+};
+
+template< typename T >
+struct has_unique_object_representations< const volatile T > :
+    public atomics::detail::has_unique_object_representations< T >
+{
+};
+
+template< typename T >
+struct has_unique_object_representations< const T[] > :
+    public atomics::detail::has_unique_object_representations< T >
+{
+};
+
+template< typename T >
+struct has_unique_object_representations< volatile T[] > :
+    public atomics::detail::has_unique_object_representations< T >
+{
+};
+
+template< typename T >
+struct has_unique_object_representations< const volatile T[] > :
+    public atomics::detail::has_unique_object_representations< T >
+{
+};
+
+template< typename T, std::size_t N >
+struct has_unique_object_representations< const T[N] > :
+    public atomics::detail::has_unique_object_representations< T >
+{
+};
+
+template< typename T, std::size_t N >
+struct has_unique_object_representations< volatile T[N] > :
+    public atomics::detail::has_unique_object_representations< T >
+{
+};
+
+template< typename T, std::size_t N >
+struct has_unique_object_representations< const volatile T[N] > :
+    public atomics::detail::has_unique_object_representations< T >
+{
+};
+
+} // namespace detail
+} // namespace atomics
+} // namespace boost
+
+#else // defined(BOOST_ATOMIC_DETAIL_HAS_UNIQUE_OBJECT_REPRESENTATIONS)
+
+#define BOOST_ATOMIC_DETAIL_NO_HAS_UNIQUE_OBJECT_REPRESENTATIONS
+
+#endif // defined(BOOST_ATOMIC_DETAIL_HAS_UNIQUE_OBJECT_REPRESENTATIONS)
+
+#endif // defined(__cpp_lib_has_unique_object_representations) ...
+
+#endif // BOOST_ATOMIC_DETAIL_TYPE_TRAITS_HAS_UNIQUE_OBJECT_REPRESENTATIONS_HPP_INCLUDED_

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

@@ -0,0 +1,42 @@
+/*
+ * 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) 2021 Andrey Semashev
+ */
+/*!
+ * \file   atomic/detail/type_traits/is_enum.hpp
+ *
+ * This header defines \c is_enum type trait
+ */
+
+#ifndef BOOST_ATOMIC_DETAIL_TYPE_TRAITS_IS_ENUM_HPP_INCLUDED_
+#define BOOST_ATOMIC_DETAIL_TYPE_TRAITS_IS_ENUM_HPP_INCLUDED_
+
+#include <boost/atomic/detail/config.hpp>
+#if !defined(BOOST_ATOMIC_DETAIL_NO_CXX11_BASIC_HDR_TYPE_TRAITS)
+#include <type_traits>
+#else
+#include <boost/type_traits/is_enum.hpp>
+#endif
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+namespace boost {
+namespace atomics {
+namespace detail {
+
+#if !defined(BOOST_ATOMIC_DETAIL_NO_CXX11_BASIC_HDR_TYPE_TRAITS)
+using std::is_enum;
+#else
+using boost::is_enum;
+#endif
+
+} // namespace detail
+} // namespace atomics
+} // namespace boost
+
+#endif // BOOST_ATOMIC_DETAIL_TYPE_TRAITS_IS_ENUM_HPP_INCLUDED_

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

@@ -0,0 +1,46 @@
+/*
+ * 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) 2021 Andrey Semashev
+ */
+/*!
+ * \file   atomic/detail/type_traits/is_nothrow_default_constructible.hpp
+ *
+ * This header defines \c is_nothrow_default_constructible type trait
+ */
+
+#ifndef BOOST_ATOMIC_DETAIL_TYPE_TRAITS_IS_NOTHROW_DEFAULT_CONSTRUCTIBLE_HPP_INCLUDED_
+#define BOOST_ATOMIC_DETAIL_TYPE_TRAITS_IS_NOTHROW_DEFAULT_CONSTRUCTIBLE_HPP_INCLUDED_
+
+#include <boost/atomic/detail/config.hpp>
+#if !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
+#include <type_traits>
+#else
+#include <boost/type_traits/has_nothrow_constructor.hpp>
+#endif
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+namespace boost {
+namespace atomics {
+namespace detail {
+
+#if !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
+using std::is_nothrow_default_constructible;
+#elif !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+template< typename T >
+using is_nothrow_default_constructible = boost::has_nothrow_constructor< T >;
+#else
+template< typename T >
+struct is_nothrow_default_constructible : public boost::has_nothrow_constructor< T > {};
+#endif
+
+} // namespace detail
+} // namespace atomics
+} // namespace boost
+
+#endif // BOOST_ATOMIC_DETAIL_TYPE_TRAITS_IS_NOTHROW_DEFAULT_CONSTRUCTIBLE_HPP_INCLUDED_

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

@@ -0,0 +1,58 @@
+/*
+ * 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) 2021 Andrey Semashev
+ */
+/*!
+ * \file   atomic/detail/wait_caps_darwin_ulock.hpp
+ *
+ * This header defines waiting/notifying operations capabilities macros.
+ */
+
+#ifndef BOOST_ATOMIC_DETAIL_WAIT_CAPS_DARWIN_ULOCK_HPP_INCLUDED_
+#define BOOST_ATOMIC_DETAIL_WAIT_CAPS_DARWIN_ULOCK_HPP_INCLUDED_
+
+#include <boost/atomic/detail/config.hpp>
+#include <boost/atomic/detail/capabilities.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+#define BOOST_ATOMIC_HAS_NATIVE_INT32_WAIT_NOTIFY BOOST_ATOMIC_INT32_LOCK_FREE
+
+// Darwin 19+ (Mac OS 10.15+, iOS 13.0+, tvOS 13.0+, watchOS 6.0+) adds support for 64-bit
+// and inter-process ulock operations.
+// https://shift.click/blog/futex-like-apis/#darwin-macos-ios-tvos-watchos-and-more
+// https://github.com/thomcc/ulock-sys/blob/2597e63cc5372459a903c292a3919d385a3e3789/src/lib.rs
+#if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 101500) || \
+    (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 130000) || \
+    (defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ >= 130000) || \
+    (defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ >= 60000)
+#define BOOST_ATOMIC_DETAIL_HAS_DARWIN_ULOCK64
+#define BOOST_ATOMIC_DETAIL_HAS_DARWIN_ULOCK_SHARED
+#endif
+
+// Darwin 20+ (Mac OS 11.0+, iOS 14.0+, tvOS 14.0+, watchOS 7.0+) introduces __ulock_wait2, which accepts
+// the timeout in nanoseconds. __ulock_wait is a wrapper on top of __ulock_wait2.
+#if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 110000) || \
+    (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 140000) || \
+    (defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ >= 140000) || \
+    (defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ >= 70000)
+#define BOOST_ATOMIC_DETAIL_HAS_DARWIN_ULOCK_WAIT2
+#endif
+
+#if defined(BOOST_ATOMIC_DETAIL_HAS_DARWIN_ULOCK_SHARED)
+#define BOOST_ATOMIC_HAS_NATIVE_INT32_IPC_WAIT_NOTIFY BOOST_ATOMIC_INT32_LOCK_FREE
+#endif // defined(BOOST_ATOMIC_DETAIL_HAS_DARWIN_ULOCK_SHARED)
+
+#if defined(BOOST_ATOMIC_DETAIL_HAS_DARWIN_ULOCK64)
+#define BOOST_ATOMIC_HAS_NATIVE_INT64_WAIT_NOTIFY BOOST_ATOMIC_INT64_LOCK_FREE
+#if defined(BOOST_ATOMIC_DETAIL_HAS_DARWIN_ULOCK_SHARED)
+#define BOOST_ATOMIC_HAS_NATIVE_INT64_IPC_WAIT_NOTIFY BOOST_ATOMIC_INT64_LOCK_FREE
+#endif // defined(BOOST_ATOMIC_DETAIL_HAS_DARWIN_ULOCK_SHARED)
+#endif // defined(BOOST_ATOMIC_DETAIL_HAS_DARWIN_ULOCK64)
+
+#endif // BOOST_ATOMIC_DETAIL_WAIT_CAPS_DARWIN_ULOCK_HPP_INCLUDED_

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

@@ -29,6 +29,8 @@
 
 #if BOOST_USE_WINAPI_VERSION >= BOOST_WINAPI_VERSION_WIN8 && (BOOST_WINAPI_PARTITION_APP || BOOST_WINAPI_PARTITION_SYSTEM)
 
+#define BOOST_ATOMIC_DETAIL_WINDOWS_HAS_WAIT_ON_ADDRESS
+
 #define BOOST_ATOMIC_HAS_NATIVE_INT8_WAIT_NOTIFY BOOST_ATOMIC_INT8_LOCK_FREE
 #define BOOST_ATOMIC_HAS_NATIVE_INT16_WAIT_NOTIFY BOOST_ATOMIC_INT16_LOCK_FREE
 #define BOOST_ATOMIC_HAS_NATIVE_INT32_WAIT_NOTIFY BOOST_ATOMIC_INT32_LOCK_FREE
@@ -36,7 +38,7 @@
 
 #else // BOOST_USE_WINAPI_VERSION >= BOOST_WINAPI_VERSION_WIN8 && (BOOST_WINAPI_PARTITION_APP || BOOST_WINAPI_PARTITION_SYSTEM)
 
-// Since will detect availability of WaitOnAddress etc. at run time, we have to define capability macros to 1 instead of 2
+// Since we'll detect availability of WaitOnAddress etc. at run time, we have to define capability macros to 1 instead of 2
 #if BOOST_ATOMIC_INT8_LOCK_FREE > 0
 #define BOOST_ATOMIC_HAS_NATIVE_INT8_WAIT_NOTIFY 1
 #endif

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

@@ -0,0 +1,65 @@
+/*
+ * 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) 2021 Andrey Semashev
+ */
+/*!
+ * \file   atomic/detail/wait_on_address.hpp
+ *
+ * This header contains declaration of runtime detection of \c WaitOnAddress and related APIs on Windows.
+ */
+
+#ifndef BOOST_ATOMIC_DETAIL_WAIT_ON_ADDRESS_HPP_INCLUDED_
+#define BOOST_ATOMIC_DETAIL_WAIT_ON_ADDRESS_HPP_INCLUDED_
+
+#include <boost/atomic/detail/config.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/memory_order.hpp>
+#include <boost/winapi/basic_types.hpp>
+#include <boost/atomic/detail/link.hpp>
+#include <boost/atomic/detail/once_flag.hpp>
+#include <boost/atomic/detail/header.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+namespace boost {
+namespace atomics {
+namespace detail {
+
+typedef boost::winapi::BOOL_ BOOST_WINAPI_WINAPI_CC
+wait_on_address_t(
+    volatile boost::winapi::VOID_* addr,
+    boost::winapi::PVOID_ compare_addr,
+    boost::winapi::SIZE_T_ size,
+    boost::winapi::DWORD_ timeout_ms);
+
+typedef boost::winapi::VOID_ BOOST_WINAPI_WINAPI_CC
+wake_by_address_t(boost::winapi::PVOID_ addr);
+
+extern BOOST_ATOMIC_DECL wait_on_address_t* wait_on_address;
+extern BOOST_ATOMIC_DECL wake_by_address_t* wake_by_address_single;
+extern BOOST_ATOMIC_DECL wake_by_address_t* wake_by_address_all;
+
+extern BOOST_ATOMIC_DECL once_flag wait_functions_once_flag;
+BOOST_ATOMIC_DECL void initialize_wait_functions() BOOST_NOEXCEPT;
+
+BOOST_FORCEINLINE void ensure_wait_functions_initialized() BOOST_NOEXCEPT
+{
+    BOOST_STATIC_ASSERT_MSG(once_flag_operations::is_always_lock_free, "Boost.Atomic unsupported target platform: native atomic operations not implemented for bytes");
+    if (BOOST_LIKELY(once_flag_operations::load(wait_functions_once_flag.m_flag, boost::memory_order_acquire) == 0u))
+        return;
+
+    initialize_wait_functions();
+}
+
+} // namespace detail
+} // namespace atomics
+} // namespace boost
+
+#include <boost/atomic/detail/footer.hpp>
+
+#endif // BOOST_ATOMIC_DETAIL_WAIT_ON_ADDRESS_HPP_INCLUDED_

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

@@ -0,0 +1,158 @@
+/*
+ * 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) 2021 Andrey Semashev
+ */
+/*!
+ * \file   atomic/detail/wait_ops_darwin_ulock.hpp
+ *
+ * This header contains implementation of the waiting/notifying atomic operations based on Darwin systems using ulock syscalls.
+ *
+ * https://github.com/apple/darwin-xnu/blob/master/bsd/sys/ulock.h
+ * https://github.com/apple/darwin-xnu/blob/master/bsd/kern/sys_ulock.c
+ */
+
+#ifndef BOOST_ATOMIC_DETAIL_WAIT_OPS_DARWIN_ULOCK_HPP_INCLUDED_
+#define BOOST_ATOMIC_DETAIL_WAIT_OPS_DARWIN_ULOCK_HPP_INCLUDED_
+
+#include <stdint.h>
+#include <cerrno>
+#include <boost/memory_order.hpp>
+#include <boost/atomic/detail/config.hpp>
+#include <boost/atomic/detail/wait_capabilities.hpp>
+#include <boost/atomic/detail/wait_operations_fwd.hpp>
+#include <boost/atomic/detail/header.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+namespace boost {
+namespace atomics {
+namespace detail {
+
+extern "C" {
+// Timeout is in microseconds with zero meaning no timeout
+int __ulock_wait(uint32_t operation, void* addr, uint64_t value, uint32_t timeout);
+#if defined(BOOST_ATOMIC_DETAIL_HAS_DARWIN_ULOCK_WAIT2)
+// Timeout is in nanoseconds with zero meaning no timeout
+int __ulock_wait2(uint32_t operation, void* addr, uint64_t value, uint64_t timeout, uint64_t value2);
+#endif // defined(BOOST_ATOMIC_DETAIL_HAS_DARWIN_ULOCK_WAIT2)
+int __ulock_wake(uint32_t operation, void* addr, uint64_t wake_value);
+} // extern "C"
+
+enum ulock_op
+{
+    ulock_op_compare_and_wait = 1,
+#if defined(BOOST_ATOMIC_DETAIL_HAS_DARWIN_ULOCK_SHARED)
+    ulock_op_compare_and_wait_shared = 3,
+#endif // defined(BOOST_ATOMIC_DETAIL_HAS_DARWIN_ULOCK_SHARED)
+#if defined(BOOST_ATOMIC_DETAIL_HAS_DARWIN_ULOCK64)
+    ulock_op_compare_and_wait64 = 5,
+#if defined(BOOST_ATOMIC_DETAIL_HAS_DARWIN_ULOCK_SHARED)
+    ulock_op_compare_and_wait64_shared = 6,
+#endif // defined(BOOST_ATOMIC_DETAIL_HAS_DARWIN_ULOCK_SHARED)
+#endif // defined(BOOST_ATOMIC_DETAIL_HAS_DARWIN_ULOCK64)
+
+    // Flags for __ulock_wake
+    ulock_flag_wake_all = 0x00000100,
+
+    // Generic flags
+    ulock_flag_no_errno = 0x01000000
+};
+
+template< typename Base, uint32_t Opcode >
+struct wait_operations_darwin_ulock_common :
+    public Base
+{
+    typedef Base base_type;
+    typedef typename base_type::storage_type storage_type;
+
+    static BOOST_CONSTEXPR_OR_CONST bool always_has_native_wait_notify = true;
+
+    static BOOST_FORCEINLINE bool has_native_wait_notify(storage_type const volatile&) BOOST_NOEXCEPT
+    {
+        return true;
+    }
+
+    static BOOST_FORCEINLINE storage_type wait(storage_type const volatile& storage, storage_type old_val, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type new_val = base_type::load(storage, order);
+        while (new_val == old_val)
+        {
+#if defined(BOOST_ATOMIC_DETAIL_HAS_DARWIN_ULOCK_WAIT2)
+            __ulock_wait2(Opcode | ulock_flag_no_errno, const_cast< storage_type* >(&storage), old_val, 0u, 0u);
+#else
+            __ulock_wait(Opcode | ulock_flag_no_errno, const_cast< storage_type* >(&storage), old_val, 0u);
+#endif
+            new_val = base_type::load(storage, order);
+        }
+
+        return new_val;
+    }
+
+    static BOOST_FORCEINLINE void notify_one(storage_type volatile& storage) BOOST_NOEXCEPT
+    {
+        while (true)
+        {
+            const int res = __ulock_wake(Opcode | ulock_flag_no_errno, const_cast< storage_type* >(&storage), 0u);
+            if (BOOST_LIKELY(res != -EINTR))
+                break;
+        }
+    }
+
+    static BOOST_FORCEINLINE void notify_all(storage_type volatile& storage) BOOST_NOEXCEPT
+    {
+        while (true)
+        {
+            const int res = __ulock_wake(Opcode | ulock_flag_wake_all | ulock_flag_no_errno, const_cast< storage_type* >(&storage), 0u);
+            if (BOOST_LIKELY(res != -EINTR))
+                break;
+        }
+    }
+};
+
+template< typename Base >
+struct wait_operations< Base, sizeof(uint32_t), true, false > :
+    public wait_operations_darwin_ulock_common< Base, ulock_op_compare_and_wait >
+{
+};
+
+#if defined(BOOST_ATOMIC_DETAIL_HAS_DARWIN_ULOCK_SHARED)
+
+template< typename Base >
+struct wait_operations< Base, sizeof(uint32_t), true, true > :
+    public wait_operations_darwin_ulock_common< Base, ulock_op_compare_and_wait_shared >
+{
+};
+
+#endif // defined(BOOST_ATOMIC_DETAIL_HAS_DARWIN_ULOCK_SHARED)
+
+#if defined(BOOST_ATOMIC_DETAIL_HAS_DARWIN_ULOCK64)
+
+template< typename Base >
+struct wait_operations< Base, sizeof(uint64_t), true, false > :
+    public wait_operations_darwin_ulock_common< Base, ulock_op_compare_and_wait64 >
+{
+};
+
+#if defined(BOOST_ATOMIC_DETAIL_HAS_DARWIN_ULOCK_SHARED)
+
+template< typename Base >
+struct wait_operations< Base, sizeof(uint64_t), true, true > :
+    public wait_operations_darwin_ulock_common< Base, ulock_op_compare_and_wait64_shared >
+{
+};
+
+#endif // defined(BOOST_ATOMIC_DETAIL_HAS_DARWIN_ULOCK_SHARED)
+#endif // defined(BOOST_ATOMIC_DETAIL_HAS_DARWIN_ULOCK64)
+
+} // namespace detail
+} // namespace atomics
+} // namespace boost
+
+#include <boost/atomic/detail/footer.hpp>
+
+#endif // BOOST_ATOMIC_DETAIL_WAIT_OPS_DARWIN_ULOCK_HPP_INCLUDED_

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

@@ -14,16 +14,28 @@
 #ifndef BOOST_ATOMIC_DETAIL_WAIT_OPS_WINDOWS_HPP_INCLUDED_
 #define BOOST_ATOMIC_DETAIL_WAIT_OPS_WINDOWS_HPP_INCLUDED_
 
-#include <cstddef>
-#include <boost/static_assert.hpp>
+#include <boost/atomic/detail/config.hpp>
 #include <boost/memory_order.hpp>
-#include <boost/winapi/basic_types.hpp>
 #include <boost/winapi/wait_constants.hpp>
-#include <boost/atomic/detail/config.hpp>
-#include <boost/atomic/detail/link.hpp>
-#include <boost/atomic/detail/once_flag.hpp>
 #include <boost/atomic/detail/wait_operations_fwd.hpp>
+#include <boost/atomic/detail/wait_capabilities.hpp>
+#if defined(BOOST_ATOMIC_DETAIL_WINDOWS_HAS_WAIT_ON_ADDRESS)
+#include <boost/winapi/wait_on_address.hpp>
+#if (defined(BOOST_ATOMIC_FORCE_AUTO_LINK) || (!defined(BOOST_ALL_NO_LIB) && !defined(BOOST_ATOMIC_NO_LIB))) && !defined(BOOST_ATOMIC_NO_SYNCHRONIZATION_LIB)
+#define BOOST_LIB_NAME "synchronization"
+#if defined(BOOST_AUTO_LINK_NOMANGLE)
+#include <boost/config/auto_link.hpp>
+#else // defined(BOOST_AUTO_LINK_NOMANGLE)
+#define BOOST_AUTO_LINK_NOMANGLE
+#include <boost/config/auto_link.hpp>
+#undef BOOST_AUTO_LINK_NOMANGLE
+#endif // defined(BOOST_AUTO_LINK_NOMANGLE)
+#endif // (defined(BOOST_ATOMIC_FORCE_AUTO_LINK) || (!defined(BOOST_ALL_NO_LIB) && !defined(BOOST_ATOMIC_NO_LIB))) && !defined(BOOST_ATOMIC_NO_SYNCHRONIZATION_LIB)
+#else // defined(BOOST_ATOMIC_DETAIL_WINDOWS_HAS_WAIT_ON_ADDRESS)
+#include <cstddef>
+#include <boost/atomic/detail/wait_on_address.hpp>
 #include <boost/atomic/detail/wait_ops_generic.hpp>
+#endif // defined(BOOST_ATOMIC_DETAIL_WINDOWS_HAS_WAIT_ON_ADDRESS)
 #include <boost/atomic/detail/header.hpp>
 
 #ifdef BOOST_HAS_PRAGMA_ONCE
@@ -34,31 +46,46 @@ namespace boost {
 namespace atomics {
 namespace detail {
 
-typedef boost::winapi::BOOL_ BOOST_WINAPI_WINAPI_CC
-wait_on_address_t(
-    volatile boost::winapi::VOID_* addr,
-    boost::winapi::PVOID_ compare_addr,
-    boost::winapi::SIZE_T_ size,
-    boost::winapi::DWORD_ timeout_ms);
+#if defined(BOOST_ATOMIC_DETAIL_WINDOWS_HAS_WAIT_ON_ADDRESS)
 
-typedef boost::winapi::VOID_ BOOST_WINAPI_WINAPI_CC
-wake_by_address_t(boost::winapi::PVOID_ addr);
+template< typename Base, std::size_t Size >
+struct wait_operations_windows :
+    public Base
+{
+    typedef Base base_type;
+    typedef typename base_type::storage_type storage_type;
 
-extern BOOST_ATOMIC_DECL wait_on_address_t* wait_on_address;
-extern BOOST_ATOMIC_DECL wake_by_address_t* wake_by_address_single;
-extern BOOST_ATOMIC_DECL wake_by_address_t* wake_by_address_all;
+    static BOOST_CONSTEXPR_OR_CONST bool always_has_native_wait_notify = true;
 
-extern BOOST_ATOMIC_DECL once_flag wait_functions_once_flag;
-BOOST_ATOMIC_DECL void initialize_wait_functions() BOOST_NOEXCEPT;
+    static BOOST_FORCEINLINE bool has_native_wait_notify(storage_type const volatile&) BOOST_NOEXCEPT
+    {
+        return true;
+    }
 
-BOOST_FORCEINLINE void ensure_wait_functions_initialized() BOOST_NOEXCEPT
-{
-    BOOST_STATIC_ASSERT_MSG(once_flag_operations::is_always_lock_free, "Boost.Atomic unsupported target platform: native atomic operations not implemented for bytes");
-    if (BOOST_LIKELY(once_flag_operations::load(wait_functions_once_flag.m_flag, boost::memory_order_acquire) == 0u))
-        return;
+    static BOOST_FORCEINLINE storage_type wait(storage_type const volatile& storage, storage_type old_val, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type new_val = base_type::load(storage, order);
+        while (new_val == old_val)
+        {
+            boost::winapi::WaitOnAddress(const_cast< storage_type* >(&storage), &old_val, Size, boost::winapi::infinite);
+            new_val = base_type::load(storage, order);
+        }
+
+        return new_val;
+    }
+
+    static BOOST_FORCEINLINE void notify_one(storage_type volatile& storage) BOOST_NOEXCEPT
+    {
+        boost::winapi::WakeByAddressSingle(const_cast< storage_type* >(&storage));
+    }
 
-    initialize_wait_functions();
-}
+    static BOOST_FORCEINLINE void notify_all(storage_type volatile& storage) BOOST_NOEXCEPT
+    {
+        boost::winapi::WakeByAddressAll(const_cast< storage_type* >(&storage));
+    }
+};
+
+#else // defined(BOOST_ATOMIC_DETAIL_WINDOWS_HAS_WAIT_ON_ADDRESS)
 
 template< typename Base, std::size_t Size >
 struct wait_operations_windows :
@@ -117,6 +144,8 @@ struct wait_operations_windows :
     }
 };
 
+#endif // defined(BOOST_ATOMIC_DETAIL_WINDOWS_HAS_WAIT_ON_ADDRESS)
+
 template< typename Base >
 struct wait_operations< Base, 1u, true, false > :
     public wait_operations_windows< Base, 1u >

data/src/cxx_supportlib/vendor-modified/boost/atomic/ipc_atomic.hpp

@@ -22,6 +22,7 @@
 #include <boost/atomic/detail/classify.hpp>
 #include <boost/atomic/detail/atomic_impl.hpp>
 #include <boost/atomic/detail/type_traits/is_trivially_copyable.hpp>
+#include <boost/atomic/detail/type_traits/is_nothrow_default_constructible.hpp>
 #include <boost/atomic/detail/header.hpp>
 
 #ifdef BOOST_HAS_PRAGMA_ONCE
@@ -49,8 +50,13 @@ public:
 #endif
 
 public:
-    BOOST_DEFAULTED_FUNCTION(ipc_atomic() BOOST_ATOMIC_DETAIL_DEF_NOEXCEPT_DECL, BOOST_ATOMIC_DETAIL_DEF_NOEXCEPT_IMPL {})
-    BOOST_FORCEINLINE BOOST_ATOMIC_DETAIL_CONSTEXPR_UNION_INIT ipc_atomic(value_arg_type v) BOOST_NOEXCEPT : base_type(v) {}
+    BOOST_FORCEINLINE BOOST_ATOMIC_DETAIL_CONSTEXPR_UNION_INIT ipc_atomic() BOOST_NOEXCEPT_IF(atomics::detail::is_nothrow_default_constructible< value_type >::value) : base_type()
+    {
+    }
+
+    BOOST_FORCEINLINE BOOST_ATOMIC_DETAIL_CONSTEXPR_UNION_INIT ipc_atomic(value_arg_type v) BOOST_NOEXCEPT : base_type(v)
+    {
+    }
 
     BOOST_FORCEINLINE value_type operator= (value_arg_type v) BOOST_NOEXCEPT
     {

data/src/cxx_supportlib/vendor-modified/boost/atomic/ipc_atomic_ref.hpp

@@ -74,10 +74,10 @@ public:
     BOOST_DELETED_FUNCTION(ipc_atomic_ref& operator= (ipc_atomic_ref const&))
 };
 
-#if !defined(BOOST_ATOMIC_DETAIL_NO_CXX17_DEDUCTION_GUIDES)
+#if !defined(BOOST_NO_CXX17_DEDUCTION_GUIDES)
 template< typename T >
 ipc_atomic_ref(T&) -> ipc_atomic_ref< T >;
-#endif // !defined(BOOST_ATOMIC_DETAIL_NO_CXX17_DEDUCTION_GUIDES)
+#endif // !defined(BOOST_NO_CXX17_DEDUCTION_GUIDES)
 
 //! IPC atomic reference factory function
 template< typename T >