passenger 6.1.0 → 6.1.1

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

@@ -5,7 +5,7 @@
  *
  * Copyright (c) 2009 Helge Bahmann
  * Copyright (c) 2012 Tim Blechmann
- * Copyright (c) 2013 - 2020 Andrey Semashev
+ * Copyright (c) 2013-2025 Andrey Semashev
  */
 /*!
  * \file   atomic/detail/storage_traits.hpp
@@ -17,7 +17,7 @@
 #define BOOST_ATOMIC_DETAIL_STORAGE_TRAITS_HPP_INCLUDED_
 
 #include <cstddef>
-#include <boost/cstdint.hpp>
+#include <cstdint>
 #include <boost/atomic/detail/config.hpp>
 #include <boost/atomic/detail/string_ops.hpp>
 #include <boost/atomic/detail/aligned_variable.hpp>
@@ -33,7 +33,7 @@ namespace atomics {
 namespace detail {
 
 template< typename T >
-BOOST_FORCEINLINE void non_atomic_load(T const volatile& from, T& to) BOOST_NOEXCEPT
+BOOST_FORCEINLINE void non_atomic_load(T const volatile& from, T& to) noexcept
 {
     to = from;
 }
@@ -41,27 +41,27 @@ BOOST_FORCEINLINE void non_atomic_load(T const volatile& from, T& to) BOOST_NOEX
 template< std::size_t Size, std::size_t Alignment = 1u >
 struct BOOST_ATOMIC_DETAIL_MAY_ALIAS buffer_storage
 {
-    typedef unsigned char data_type[Size];
+    using data_type = unsigned char [Size];
     BOOST_ATOMIC_DETAIL_ALIGNED_VAR_TPL(Alignment, data_type, data);
 
-    BOOST_FORCEINLINE bool operator! () const BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool operator! () const noexcept
     {
         return (data[0] == 0u && BOOST_ATOMIC_DETAIL_MEMCMP(data, data + 1, Size - 1u) == 0);
     }
 
-    BOOST_FORCEINLINE bool operator== (buffer_storage const& that) const BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool operator== (buffer_storage const& that) const noexcept
     {
         return BOOST_ATOMIC_DETAIL_MEMCMP(data, that.data, Size) == 0;
     }
 
-    BOOST_FORCEINLINE bool operator!= (buffer_storage const& that) const BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool operator!= (buffer_storage const& that) const noexcept
     {
         return BOOST_ATOMIC_DETAIL_MEMCMP(data, that.data, Size) != 0;
     }
 };
 
 template< std::size_t Size, std::size_t Alignment >
-BOOST_FORCEINLINE void non_atomic_load(buffer_storage< Size, Alignment > const volatile& from, buffer_storage< Size, Alignment >& to) BOOST_NOEXCEPT
+BOOST_FORCEINLINE void non_atomic_load(buffer_storage< Size, Alignment > const volatile& from, buffer_storage< Size, Alignment >& to) noexcept
 {
     BOOST_ATOMIC_DETAIL_MEMCPY(to.data, const_cast< unsigned char const* >(from.data), Size);
 }
@@ -69,48 +69,48 @@ BOOST_FORCEINLINE void non_atomic_load(buffer_storage< Size, Alignment > const v
 template< std::size_t Size >
 struct storage_traits
 {
-    typedef buffer_storage< Size, 1u > type;
+    using type = buffer_storage< Size, 1u >;
 
-    static BOOST_CONSTEXPR_OR_CONST std::size_t native_alignment = 1u;
+    static constexpr std::size_t native_alignment = 1u;
 
     // By default, prefer the maximum supported alignment
-    static BOOST_CONSTEXPR_OR_CONST std::size_t alignment = 16u;
+    static constexpr std::size_t alignment = 16u;
 };
 
 template< >
 struct storage_traits< 1u >
 {
-    typedef boost::uint8_t BOOST_ATOMIC_DETAIL_MAY_ALIAS type;
+    using type = std::uint8_t BOOST_ATOMIC_DETAIL_MAY_ALIAS;
 
-    static BOOST_CONSTEXPR_OR_CONST std::size_t native_alignment = 1u;
-    static BOOST_CONSTEXPR_OR_CONST std::size_t alignment = 1u;
+    static constexpr std::size_t native_alignment = 1u;
+    static constexpr std::size_t alignment = 1u;
 };
 
 template< >
 struct storage_traits< 2u >
 {
-    typedef boost::uint16_t BOOST_ATOMIC_DETAIL_MAY_ALIAS type;
+    using type = std::uint16_t BOOST_ATOMIC_DETAIL_MAY_ALIAS;
 
-    static BOOST_CONSTEXPR_OR_CONST std::size_t native_alignment = atomics::detail::alignment_of< boost::uint16_t >::value;
-    static BOOST_CONSTEXPR_OR_CONST std::size_t alignment = 2u;
+    static constexpr std::size_t native_alignment = atomics::detail::alignment_of< std::uint16_t >::value;
+    static constexpr std::size_t alignment = 2u;
 };
 
 template< >
 struct storage_traits< 4u >
 {
-    typedef boost::uint32_t BOOST_ATOMIC_DETAIL_MAY_ALIAS type;
+    using type = std::uint32_t BOOST_ATOMIC_DETAIL_MAY_ALIAS;
 
-    static BOOST_CONSTEXPR_OR_CONST std::size_t native_alignment = atomics::detail::alignment_of< boost::uint32_t >::value;
-    static BOOST_CONSTEXPR_OR_CONST std::size_t alignment = 4u;
+    static constexpr std::size_t native_alignment = atomics::detail::alignment_of< std::uint32_t >::value;
+    static constexpr std::size_t alignment = 4u;
 };
 
 template< >
 struct storage_traits< 8u >
 {
-    typedef boost::uint64_t BOOST_ATOMIC_DETAIL_MAY_ALIAS type;
+    using type = std::uint64_t BOOST_ATOMIC_DETAIL_MAY_ALIAS;
 
-    static BOOST_CONSTEXPR_OR_CONST std::size_t native_alignment = atomics::detail::alignment_of< boost::uint64_t >::value;
-    static BOOST_CONSTEXPR_OR_CONST std::size_t alignment = 8u;
+    static constexpr std::size_t native_alignment = atomics::detail::alignment_of< std::uint64_t >::value;
+    static constexpr std::size_t alignment = 8u;
 };
 
 #if defined(BOOST_HAS_INT128)
@@ -118,10 +118,10 @@ struct storage_traits< 8u >
 template< >
 struct storage_traits< 16u >
 {
-    typedef boost::uint128_type BOOST_ATOMIC_DETAIL_MAY_ALIAS type;
+    using type = boost::uint128_type BOOST_ATOMIC_DETAIL_MAY_ALIAS;
 
-    static BOOST_CONSTEXPR_OR_CONST std::size_t native_alignment = atomics::detail::alignment_of< boost::uint128_type >::value;
-    static BOOST_CONSTEXPR_OR_CONST std::size_t alignment = 16u;
+    static constexpr std::size_t native_alignment = atomics::detail::alignment_of< boost::uint128_type >::value;
+    static constexpr std::size_t alignment = 16u;
 };
 
 #else
@@ -163,10 +163,10 @@ union max_align_t
 template< >
 struct storage_traits< 16u >
 {
-    typedef buffer_storage< 16u, atomics::detail::alignment_of< atomics::detail::max_align_t >::value > type;
+    using type = buffer_storage< 16u, atomics::detail::alignment_of< atomics::detail::max_align_t >::value >;
 
-    static BOOST_CONSTEXPR_OR_CONST std::size_t native_alignment = atomics::detail::alignment_of< atomics::detail::max_align_t >::value;
-    static BOOST_CONSTEXPR_OR_CONST std::size_t alignment = 16u;
+    static constexpr std::size_t native_alignment = atomics::detail::alignment_of< atomics::detail::max_align_t >::value;
+    static constexpr std::size_t alignment = 16u;
 };
 
 #endif
@@ -174,8 +174,8 @@ struct storage_traits< 16u >
 template< typename T >
 struct storage_size_of
 {
-    static BOOST_CONSTEXPR_OR_CONST std::size_t size = sizeof(T);
-    static BOOST_CONSTEXPR_OR_CONST std::size_t value = (size == 3u ? 4u : (size >= 5u && size <= 7u ? 8u : (size >= 9u && size <= 15u ? 16u : size)));
+    static constexpr std::size_t size = sizeof(T);
+    static constexpr std::size_t value = (size == 3u ? 4u : (size >= 5u && size <= 7u ? 8u : (size >= 9u && size <= 15u ? 16u : size)));
 };
 
 } // namespace detail

data/src/cxx_supportlib/vendor-modified/boost/atomic/detail/type_traits/alignment_of.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/type_traits/alignment_of.hpp
@@ -16,8 +16,7 @@
 
 #include <boost/atomic/detail/config.hpp>
 
-#if defined(BOOST_ATOMIC_DETAIL_NO_CXX11_BASIC_HDR_TYPE_TRAITS) ||\
-    (defined(BOOST_GCC) && BOOST_GCC < 80100) ||\
+#if (defined(BOOST_GCC) && BOOST_GCC < 80100) ||\
     (defined(BOOST_CLANG) && !defined(__apple_build_version__) && __clang_major__ < 9) ||\
     (defined(BOOST_CLANG) && defined(__apple_build_version__) && __clang_major__ < 10)
 // For some compilers std::alignment_of gives the wrong result for 64-bit types on 32-bit targets

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

@@ -14,10 +14,8 @@
 #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
+#include <boost/atomic/detail/config.hpp>
 
 #ifdef BOOST_HAS_PRAGMA_ONCE
 #pragma once
@@ -50,7 +48,6 @@ using std::has_unique_object_representations;
 #if defined(BOOST_ATOMIC_DETAIL_HAS_UNIQUE_OBJECT_REPRESENTATIONS)
 
 #include <cstddef>
-#include <boost/atomic/detail/type_traits/integral_constant.hpp>
 
 namespace boost {
 namespace atomics {
@@ -58,7 +55,7 @@ namespace detail {
 
 template< typename T >
 struct has_unique_object_representations :
-    public atomics::detail::integral_constant< bool, BOOST_ATOMIC_DETAIL_HAS_UNIQUE_OBJECT_REPRESENTATIONS(T) >
+    public std::integral_constant< bool, BOOST_ATOMIC_DETAIL_HAS_UNIQUE_OBJECT_REPRESENTATIONS(T) >
 {
 };
 

data/src/cxx_supportlib/vendor-modified/boost/atomic/detail/type_traits/is_floating_point.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/type_traits/is_floating_point.hpp
@@ -16,7 +16,7 @@
 
 #include <boost/atomic/detail/config.hpp>
 // Some versions of libstdc++ don't consider __float128 a floating point type. Use Boost.TypeTraits because of that.
-#if !defined(BOOST_ATOMIC_DETAIL_NO_CXX11_BASIC_HDR_TYPE_TRAITS) && !defined(BOOST_HAS_FLOAT128)
+#if !defined(BOOST_HAS_FLOAT128)
 #include <type_traits>
 #else
 #include <boost/type_traits/is_floating_point.hpp>
@@ -30,7 +30,7 @@ namespace boost {
 namespace atomics {
 namespace detail {
 
-#if !defined(BOOST_ATOMIC_DETAIL_NO_CXX11_BASIC_HDR_TYPE_TRAITS) && !defined(BOOST_HAS_FLOAT128)
+#if !defined(BOOST_HAS_FLOAT128)
 using std::is_floating_point;
 #else
 using boost::is_floating_point;

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

@@ -28,7 +28,7 @@ namespace detail {
 template< typename T >
 struct is_iec559
 {
-    static BOOST_CONSTEXPR_OR_CONST bool value = !!std::numeric_limits< T >::is_iec559;
+    static constexpr bool value = !!std::numeric_limits< T >::is_iec559;
 };
 
 #if defined(BOOST_HAS_FLOAT128)
@@ -36,7 +36,7 @@ struct is_iec559
 template< >
 struct is_iec559< boost::float128_type >
 {
-    static BOOST_CONSTEXPR_OR_CONST bool value = true;
+    static constexpr bool value = true;
 };
 #endif // defined(BOOST_HAS_FLOAT128)
 

data/src/cxx_supportlib/vendor-modified/boost/atomic/detail/type_traits/is_integral.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) 2017 Andrey Semashev
+ * Copyright (c) 2017-2025 Andrey Semashev
  */
 /*!
  * \file   atomic/detail/type_traits/is_integral.hpp
@@ -16,7 +16,7 @@
 
 #include <boost/atomic/detail/config.hpp>
 // Some versions of libstdc++ don't consider __int128 an integral type. Use Boost.TypeTraits because of that.
-#if !defined(BOOST_ATOMIC_DETAIL_NO_CXX11_BASIC_HDR_TYPE_TRAITS) && !defined(BOOST_HAS_INT128)
+#if !defined(BOOST_HAS_INT128)
 #include <type_traits>
 #else
 #include <boost/type_traits/is_integral.hpp>
@@ -30,7 +30,7 @@ namespace boost {
 namespace atomics {
 namespace detail {
 
-#if !defined(BOOST_ATOMIC_DETAIL_NO_CXX11_BASIC_HDR_TYPE_TRAITS) && !defined(BOOST_HAS_INT128)
+#if !defined(BOOST_HAS_INT128)
 using std::is_integral;
 #else
 using boost::is_integral;

data/src/cxx_supportlib/vendor-modified/boost/atomic/detail/type_traits/is_signed.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) 2017 Andrey Semashev
+ * Copyright (c) 2017-2025 Andrey Semashev
  */
 /*!
  * \file   atomic/detail/type_traits/is_signed.hpp
@@ -16,7 +16,7 @@
 
 #include <boost/atomic/detail/config.hpp>
 // Some versions of libstdc++ don't consider __int128 an integral type. Use Boost.TypeTraits because of that.
-#if !defined(BOOST_ATOMIC_DETAIL_NO_CXX11_BASIC_HDR_TYPE_TRAITS) && !defined(BOOST_HAS_INT128)
+#if !defined(BOOST_HAS_INT128)
 #include <type_traits>
 #else
 #include <boost/type_traits/is_signed.hpp>
@@ -30,7 +30,7 @@ namespace boost {
 namespace atomics {
 namespace detail {
 
-#if !defined(BOOST_ATOMIC_DETAIL_NO_CXX11_BASIC_HDR_TYPE_TRAITS) && !defined(BOOST_HAS_INT128)
+#if !defined(BOOST_HAS_INT128)
 using std::is_signed;
 #else
 using boost::is_signed;

data/src/cxx_supportlib/vendor-modified/boost/atomic/detail/type_traits/is_trivially_copyable.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/type_traits/is_trivially_copyable.hpp
@@ -14,32 +14,39 @@
 #ifndef BOOST_ATOMIC_DETAIL_TYPE_TRAITS_IS_TRIVIALLY_COPYABLE_HPP_INCLUDED_
 #define BOOST_ATOMIC_DETAIL_TYPE_TRAITS_IS_TRIVIALLY_COPYABLE_HPP_INCLUDED_
 
-#include <boost/atomic/detail/config.hpp>
-#if !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
 #include <type_traits>
-#else
-// For std::is_trivially_copyable we require a genuine support from the compiler.
-// Fallback to is_pod or a false negative result in Boost.TypeTraits is not acceptable
-// as this trait will be used in a static assert and may deny valid uses of boost::atomic/atomic_ref.
-#define BOOST_ATOMIC_DETAIL_NO_CXX11_IS_TRIVIALLY_COPYABLE
-#endif
+#include <boost/atomic/detail/config.hpp>
 
 #ifdef BOOST_HAS_PRAGMA_ONCE
 #pragma once
 #endif
 
-#if !defined(BOOST_ATOMIC_DETAIL_NO_CXX11_IS_TRIVIALLY_COPYABLE)
-
 namespace boost {
 namespace atomics {
 namespace detail {
 
+#if !defined(BOOST_LIBSTDCXX_VERSION) || (BOOST_LIBSTDCXX_VERSION >= 50100)
+
 using std::is_trivially_copyable;
 
+#else // !defined(BOOST_LIBSTDCXX_VERSION) || (BOOST_LIBSTDCXX_VERSION >= 50100)
+
+template< typename T >
+using is_trivially_copyable_impl = std::integral_constant<
+    bool,
+    std::is_trivially_destructible< T >::value && std::has_trivial_copy_constructor< T >::value && std::has_trivial_copy_assign< T >::value
+>;
+
+template< typename T >
+struct is_trivially_copyable :
+    public is_trivially_copyable_impl< typename std::remove_cv< typename std::remove_all_extents< T >::type >::type >
+{
+};
+
+#endif // !defined(BOOST_LIBSTDCXX_VERSION) || (BOOST_LIBSTDCXX_VERSION >= 50100)
+
 } // namespace detail
 } // namespace atomics
 } // namespace boost
 
-#endif // !defined(BOOST_ATOMIC_DETAIL_NO_CXX11_IS_TRIVIALLY_COPYABLE)
-
 #endif // BOOST_ATOMIC_DETAIL_TYPE_TRAITS_IS_TRIVIALLY_COPYABLE_HPP_INCLUDED_

data/src/cxx_supportlib/vendor-modified/boost/atomic/detail/type_traits/is_trivially_default_constructible.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/type_traits/is_trivially_default_constructible.hpp
@@ -14,12 +14,8 @@
 #ifndef BOOST_ATOMIC_DETAIL_TYPE_TRAITS_IS_TRIVIALLY_DEFAULT_CONSTRUCTIBLE_HPP_INCLUDED_
 #define BOOST_ATOMIC_DETAIL_TYPE_TRAITS_IS_TRIVIALLY_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_trivial_constructor.hpp>
-#endif
+#include <boost/atomic/detail/config.hpp>
 
 #ifdef BOOST_HAS_PRAGMA_ONCE
 #pragma once
@@ -29,15 +25,19 @@ namespace boost {
 namespace atomics {
 namespace detail {
 
-#if !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
+#if !defined(BOOST_LIBSTDCXX_VERSION) || (BOOST_LIBSTDCXX_VERSION >= 50100)
+
 using std::is_trivially_default_constructible;
-#elif !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
-template< typename T >
-using is_trivially_default_constructible = boost::has_trivial_constructor< T >;
-#else
+
+#else // !defined(BOOST_LIBSTDCXX_VERSION) || (BOOST_LIBSTDCXX_VERSION >= 50100)
+
 template< typename T >
-struct is_trivially_default_constructible : public boost::has_trivial_constructor< T > {};
-#endif
+struct is_trivially_default_constructible :
+    public std::has_trivial_default_constructor< typename std::remove_cv< typename std::remove_all_extents< T >::type >::type >::type
+{
+};
+
+#endif // !defined(BOOST_LIBSTDCXX_VERSION) || (BOOST_LIBSTDCXX_VERSION >= 50100)
 
 } // namespace detail
 } // namespace atomics

data/src/cxx_supportlib/vendor-modified/boost/atomic/detail/type_traits/make_signed.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) 2017 Andrey Semashev
+ * Copyright (c) 2017-2025 Andrey Semashev
  */
 /*!
  * \file   atomic/detail/type_traits/make_signed.hpp
@@ -16,7 +16,7 @@
 
 #include <boost/atomic/detail/config.hpp>
 // Some versions of libstdc++ don't consider __int128 an integral type. Use Boost.TypeTraits because of that.
-#if !defined(BOOST_ATOMIC_DETAIL_NO_CXX11_BASIC_HDR_TYPE_TRAITS) && !defined(BOOST_HAS_INT128)
+#if !defined(BOOST_HAS_INT128)
 #include <type_traits>
 #else
 #include <boost/type_traits/make_signed.hpp>
@@ -30,7 +30,7 @@ namespace boost {
 namespace atomics {
 namespace detail {
 
-#if !defined(BOOST_ATOMIC_DETAIL_NO_CXX11_BASIC_HDR_TYPE_TRAITS) && !defined(BOOST_HAS_INT128)
+#if !defined(BOOST_HAS_INT128)
 using std::make_signed;
 #else
 using boost::make_signed;

data/src/cxx_supportlib/vendor-modified/boost/atomic/detail/type_traits/make_unsigned.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) 2017 Andrey Semashev
+ * Copyright (c) 2017-2025 Andrey Semashev
  */
 /*!
  * \file   atomic/detail/type_traits/make_unsigned.hpp
@@ -16,7 +16,7 @@
 
 #include <boost/atomic/detail/config.hpp>
 // Some versions of libstdc++ don't consider __int128 an integral type. Use Boost.TypeTraits because of that.
-#if !defined(BOOST_ATOMIC_DETAIL_NO_CXX11_BASIC_HDR_TYPE_TRAITS) && !defined(BOOST_HAS_INT128)
+#if !defined(BOOST_HAS_INT128)
 #include <type_traits>
 #else
 #include <boost/type_traits/make_unsigned.hpp>
@@ -30,7 +30,7 @@ namespace boost {
 namespace atomics {
 namespace detail {
 
-#if !defined(BOOST_ATOMIC_DETAIL_NO_CXX11_BASIC_HDR_TYPE_TRAITS) && !defined(BOOST_HAS_INT128)
+#if !defined(BOOST_HAS_INT128)
 using std::make_unsigned;
 #else
 using boost::make_unsigned;

data/src/cxx_supportlib/vendor-modified/boost/atomic/detail/wait_ops_darwin_ulock.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) 2021 Andrey Semashev
+ * Copyright (c) 2021-2025 Andrey Semashev
  */
 /*!
  * \file   atomic/detail/wait_ops_darwin_ulock.hpp
@@ -19,8 +19,10 @@
 
 #include <stdint.h>
 #include <cerrno>
+#include <chrono>
 #include <boost/memory_order.hpp>
 #include <boost/atomic/detail/config.hpp>
+#include <boost/atomic/detail/chrono.hpp>
 #include <boost/atomic/detail/wait_capabilities.hpp>
 #include <boost/atomic/detail/wait_operations_fwd.hpp>
 #include <boost/atomic/detail/header.hpp>
@@ -35,12 +37,12 @@ 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);
+int __ulock_wait(std::uint32_t operation, void* addr, std::uint64_t value, std::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);
+int __ulock_wait2(std::uint32_t operation, void* addr, std::uint64_t value, std::uint64_t timeout, std::uint64_t value2);
 #endif // defined(BOOST_ATOMIC_DETAIL_HAS_DARWIN_ULOCK_WAIT2)
-int __ulock_wake(uint32_t operation, void* addr, uint64_t wake_value);
+int __ulock_wake(std::uint32_t operation, void* addr, std::uint64_t wake_value);
 } // extern "C"
 
 enum ulock_op
@@ -63,21 +65,21 @@ enum ulock_op
     ulock_flag_no_errno = 0x01000000
 };
 
-template< typename Base, uint32_t Opcode >
+template< typename Base, std::uint32_t Opcode >
 struct wait_operations_darwin_ulock_common :
     public Base
 {
-    typedef Base base_type;
-    typedef typename base_type::storage_type storage_type;
+    using base_type = Base;
+    using storage_type = typename base_type::storage_type;
 
-    static BOOST_CONSTEXPR_OR_CONST bool always_has_native_wait_notify = true;
+    static constexpr bool always_has_native_wait_notify = true;
 
-    static BOOST_FORCEINLINE bool has_native_wait_notify(storage_type const volatile&) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE bool has_native_wait_notify(storage_type const volatile&) noexcept
     {
         return true;
     }
 
-    static BOOST_FORCEINLINE storage_type wait(storage_type const volatile& storage, storage_type old_val, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE storage_type wait(storage_type const volatile& storage, storage_type old_val, memory_order order) noexcept
     {
         storage_type new_val = base_type::load(storage, order);
         while (new_val == old_val)
@@ -93,7 +95,79 @@ struct wait_operations_darwin_ulock_common :
         return new_val;
     }
 
-    static BOOST_FORCEINLINE void notify_one(storage_type volatile& storage) BOOST_NOEXCEPT
+private:
+    template< typename Clock >
+    static BOOST_FORCEINLINE storage_type wait_until_impl
+    (
+        storage_type const volatile& storage,
+        storage_type old_val,
+        typename Clock::time_point timeout,
+        typename Clock::time_point now,
+        memory_order order,
+        bool& timed_out
+    ) noexcept(noexcept(Clock::now()))
+    {
+        storage_type new_val = base_type::load(storage, order);
+        while (new_val == old_val)
+        {
+#if defined(BOOST_ATOMIC_DETAIL_HAS_DARWIN_ULOCK_WAIT2)
+            const std::int64_t rel_timeout = atomics::detail::chrono::ceil< std::chrono::nanoseconds >(timeout - now).count();
+#else
+            const std::int64_t rel_timeout = atomics::detail::chrono::ceil< std::chrono::microseconds >(timeout - now).count();
+#endif
+            if (rel_timeout <= 0)
+            {
+                timed_out = true;
+                break;
+            }
+
+#if defined(BOOST_ATOMIC_DETAIL_HAS_DARWIN_ULOCK_WAIT2)
+            __ulock_wait2(Opcode | ulock_flag_no_errno, const_cast< storage_type* >(&storage), old_val, static_cast< std::uint64_t >(rel_timeout), 0u);
+#else
+            __ulock_wait
+            (
+                Opcode | ulock_flag_no_errno,
+                const_cast< storage_type* >(&storage),
+                old_val,
+                rel_timeout <= static_cast< std::int64_t >(~static_cast< std::uint32_t >(0u)) ? static_cast< std::uint32_t >(rel_timeout) : ~static_cast< std::uint32_t >(0u)
+            );
+#endif
+            now = Clock::now();
+            new_val = base_type::load(storage, order);
+        }
+
+        return new_val;
+    }
+
+public:
+    template< typename Clock, typename Duration >
+    static BOOST_FORCEINLINE storage_type wait_until
+    (
+        storage_type const volatile& storage,
+        storage_type old_val,
+        std::chrono::time_point< Clock, Duration > timeout,
+        memory_order order,
+        bool& timed_out
+    ) noexcept(noexcept(Clock::now()))
+    {
+        return wait_until_impl< Clock >(storage, old_val, timeout, Clock::now(), order, timed_out);
+    }
+
+    template< typename Rep, typename Period >
+    static BOOST_FORCEINLINE storage_type wait_for
+    (
+        storage_type const volatile& storage,
+        storage_type old_val,
+        std::chrono::duration< Rep, Period > timeout,
+        memory_order order,
+        bool& timed_out
+    ) noexcept
+    {
+        const std::chrono::steady_clock::time_point now = std::chrono::steady_clock::now();
+        return wait_until_impl< std::chrono::steady_clock >(storage, old_val, now + timeout, now, order, timed_out);
+    }
+
+    static BOOST_FORCEINLINE void notify_one(storage_type volatile& storage) noexcept
     {
         while (true)
         {
@@ -103,7 +177,7 @@ struct wait_operations_darwin_ulock_common :
         }
     }
 
-    static BOOST_FORCEINLINE void notify_all(storage_type volatile& storage) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE void notify_all(storage_type volatile& storage) noexcept
     {
         while (true)
         {
@@ -115,7 +189,7 @@ struct wait_operations_darwin_ulock_common :
 };
 
 template< typename Base >
-struct wait_operations< Base, sizeof(uint32_t), true, false > :
+struct wait_operations< Base, sizeof(std::uint32_t), true, false > :
     public wait_operations_darwin_ulock_common< Base, ulock_op_compare_and_wait >
 {
 };
@@ -123,7 +197,7 @@ struct wait_operations< Base, sizeof(uint32_t), true, false > :
 #if defined(BOOST_ATOMIC_DETAIL_HAS_DARWIN_ULOCK_SHARED)
 
 template< typename Base >
-struct wait_operations< Base, sizeof(uint32_t), true, true > :
+struct wait_operations< Base, sizeof(std::uint32_t), true, true > :
     public wait_operations_darwin_ulock_common< Base, ulock_op_compare_and_wait_shared >
 {
 };
@@ -133,7 +207,7 @@ struct wait_operations< Base, sizeof(uint32_t), true, true > :
 #if defined(BOOST_ATOMIC_DETAIL_HAS_DARWIN_ULOCK64)
 
 template< typename Base >
-struct wait_operations< Base, sizeof(uint64_t), true, false > :
+struct wait_operations< Base, sizeof(std::uint64_t), true, false > :
     public wait_operations_darwin_ulock_common< Base, ulock_op_compare_and_wait64 >
 {
 };
@@ -141,7 +215,7 @@ struct wait_operations< Base, sizeof(uint64_t), true, false > :
 #if defined(BOOST_ATOMIC_DETAIL_HAS_DARWIN_ULOCK_SHARED)
 
 template< typename Base >
-struct wait_operations< Base, sizeof(uint64_t), true, true > :
+struct wait_operations< Base, sizeof(std::uint64_t), true, true > :
     public wait_operations_darwin_ulock_common< Base, ulock_op_compare_and_wait64_shared >
 {
 };