passenger 6.1.0 → 6.1.1

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

@@ -0,0 +1,102 @@
+/*
+ * 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)
+ *
+ * (C) Copyright 2013 Tim Blechmann
+ * (C) Copyright 2013, 2020-2025 Andrey Semashev
+ */
+
+#ifndef BOOST_ATOMIC_THREAD_PAUSE_HPP_INCLUDED_
+#define BOOST_ATOMIC_THREAD_PAUSE_HPP_INCLUDED_
+
+#include <boost/atomic/detail/config.hpp>
+#if defined(_MSC_VER)
+#include <boost/atomic/detail/ops_msvc_common.hpp>
+#endif
+#include <boost/atomic/detail/header.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+#if defined(_MSC_VER)
+// (sigh, shake head) _M_ARM64EC and _M_AMD64 may be defined both
+// https://learn.microsoft.com/en-us/windows/arm/arm64ec-abi
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+extern "C" void __isb(unsigned int);
+#if defined(BOOST_MSVC)
+#pragma intrinsic(__isb)
+#endif
+#elif defined(_M_ARM)
+extern "C" void __yield(void);
+#if defined(BOOST_MSVC)
+#pragma intrinsic(__yield)
+#endif
+#elif defined(_M_AMD64) || defined(_M_IX86)
+extern "C" void _mm_pause(void);
+#if defined(BOOST_MSVC)
+#pragma intrinsic(_mm_pause)
+#endif
+#endif
+#endif
+
+#if defined(sun) || defined(__sun)
+// Avoid including synch.h
+extern "C" void smt_pause(void);
+#endif
+
+namespace boost {
+namespace atomics {
+
+//! The function pauses for a number of CPU cycles, potentially freeing CPU resources, allowing sibling threads to progress. May be a no-op.
+BOOST_FORCEINLINE void thread_pause() noexcept
+{
+#if defined(_MSC_VER)
+
+    BOOST_ATOMIC_DETAIL_COMPILER_BARRIER();
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+    __isb(0xF); // ISB SY
+#elif defined(_M_ARM)
+    __yield();
+#elif defined(_M_AMD64) || defined(_M_IX86)
+    _mm_pause();
+#endif
+    BOOST_ATOMIC_DETAIL_COMPILER_BARRIER();
+
+#elif defined(__GNUC__)
+
+#if defined(__i386__) || defined(__x86_64__)
+    __asm__ __volatile__("pause" : : : "memory");
+#elif defined(__aarch64__)
+    // https://github.com/rust-lang/rust/commit/c064b6560b7ce0adeb9bbf5d7dcf12b1acb0c807
+    // https://web.archive.org/web/20231004132033/https://bugs.java.com/bugdatabase/view_bug.do?bug_id=8258604
+    __asm__ __volatile__("isb" : : : "memory");
+#elif (defined(__ARM_ARCH) && __ARM_ARCH >= 8) || defined(__ARM_ARCH_8A__)
+    __asm__ __volatile__("yield" : : : "memory");
+#elif (defined(__POWERPC__) || defined(__PPC__))
+    __asm__ __volatile__("or 27,27,27" : : : "memory"); // yield pseudo-instruction
+#elif defined(__riscv) && (__riscv_xlen == 64)
+#if defined(__riscv_zihintpause)
+    __asm__ __volatile__("pause" : : : "memory");
+#else
+    // Encoding of the pause instruction
+    __asm__ __volatile__ (".4byte 0x100000F" : : : "memory");
+#endif
+#elif defined(sun) || defined(__sun)
+    smt_pause();
+#endif
+
+#elif defined(sun) || defined(__sun)
+
+    smt_pause();
+
+#endif
+}
+
+} // namespace atomics
+} // namespace boost
+
+#include <boost/atomic/detail/footer.hpp>
+
+#endif // BOOST_ATOMIC_THREAD_PAUSE_HPP_INCLUDED_

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

@@ -0,0 +1,56 @@
+/*
+ * 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/wait_result.hpp
+ *
+ * This header contains definition of the \c wait_result class template.
+ */
+
+#ifndef BOOST_ATOMIC_WAIT_RESULT_HPP_INCLUDED_
+#define BOOST_ATOMIC_WAIT_RESULT_HPP_INCLUDED_
+
+#include <type_traits>
+#include <boost/atomic/detail/config.hpp>
+#include <boost/atomic/detail/header.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+namespace boost {
+namespace atomics {
+
+//! The structure contains the result of a timed waiting operation
+template< typename T >
+struct wait_result
+{
+    //! Last value read as part of the waiting operation
+    T value;
+    //! Indicates whether the waiting operation has ended due to timeout
+    bool timeout;
+
+    constexpr wait_result() noexcept(std::is_nothrow_default_constructible< T >::value) :
+        value(),
+        timeout(false)
+    {
+    }
+
+    template< typename U, typename = typename std::enable_if< std::is_constructible< T, U&& >::value >::type >
+    constexpr wait_result(U&& val, bool tout) noexcept(std::is_nothrow_constructible< T, U&& >::value) :
+        value(static_cast< U&& >(val)),
+        timeout(tout)
+    {
+    }
+};
+
+} // namespace atomics
+} // namespace boost
+
+#include <boost/atomic/detail/footer.hpp>
+
+#endif // BOOST_ATOMIC_WAIT_RESULT_HPP_INCLUDED_

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

@@ -2,7 +2,7 @@
 #define BOOST_ATOMIC_HPP
 
 //  Copyright (c) 2011 Helge Bahmann
-//  Copyright (c) 2020 Andrey Semashev
+//  Copyright (c) 2020-2025 Andrey Semashev
 //
 //  Distributed under the Boost Software License, Version 1.0.
 //  See accompanying file LICENSE_1_0.txt or copy at
@@ -12,12 +12,15 @@
 
 #include <boost/memory_order.hpp>
 #include <boost/atomic/capabilities.hpp>
+#include <boost/atomic/posix_clock_traits_fwd.hpp>
+#include <boost/atomic/wait_result.hpp>
 #include <boost/atomic/atomic.hpp>
 #include <boost/atomic/atomic_ref.hpp>
 #include <boost/atomic/atomic_flag.hpp>
 #include <boost/atomic/ipc_atomic.hpp>
 #include <boost/atomic/ipc_atomic_ref.hpp>
 #include <boost/atomic/ipc_atomic_flag.hpp>
+#include <boost/atomic/thread_pause.hpp>
 #include <boost/atomic/fences.hpp>
 
 #ifdef BOOST_HAS_PRAGMA_ONCE

data/src/cxx_supportlib/vendor-modified/boost/config/stdlib/libcpp.hpp

@@ -177,4 +177,9 @@
 #endif
 #endif
 
+#if _LIBCPP_VERSION <= 170006
+// no std::ranges::join_view
+#  define BOOST_NO_CXX20_HDR_RANGES
+#endif
+
 //  --- end ---

data/src/cxx_supportlib/vendor-modified/boost/container/allocator.hpp

@@ -116,7 +116,7 @@ class allocator
    allocator& operator=(const allocator<T2, Version2, AllocationDisableMask2>&);
 
    BOOST_STATIC_CONSTEXPR unsigned int ForbiddenMask =
-      BOOST_CONTAINER_ALLOCATE_NEW | BOOST_CONTAINER_EXPAND_BWD | BOOST_CONTAINER_EXPAND_FWD ;
+      BOOST_CONTAINER_ALLOCATE_NEW | BOOST_CONTAINER_EXPAND_BWD | BOOST_CONTAINER_EXPAND_FWD;
 
    //The mask can't disable all the allocation types
    BOOST_CONTAINER_STATIC_ASSERT((  (AllocationDisableMask & ForbiddenMask) != ForbiddenMask  ));

data/src/cxx_supportlib/vendor-modified/boost/container/allocator_traits.hpp

@@ -91,24 +91,7 @@ namespace dtl {
 template<class T, class ...Args>
 BOOST_CONTAINER_FORCEINLINE void construct_type(T *p, BOOST_FWD_REF(Args) ...args)
 {
-   ::new((void*)p, boost_container_new_t()) T(::boost::forward<Args>(args)...);
-}
-
-template < class Pair, class KeyType, class ... Args>
-typename dtl::enable_if< dtl::is_pair<Pair>, void >::type
-construct_type
-   (Pair* p, try_emplace_t, BOOST_FWD_REF(KeyType) k, BOOST_FWD_REF(Args) ...args)
-{
-   construct_type(dtl::addressof(p->first), ::boost::forward<KeyType>(k));
-   BOOST_CONTAINER_TRY{
-      construct_type(dtl::addressof(p->second), ::boost::forward<Args>(args)...);
-   }
-   BOOST_CONTAINER_CATCH(...) {
-      typedef typename Pair::first_type first_type;
-      dtl::addressof(p->first)->~first_type();
-      BOOST_CONTAINER_RETHROW
-   }
-   BOOST_CONTAINER_CATCH_END
+   ::new(const_cast<void*>(static_cast<const volatile void*>(p)), boost_container_new_t()) T(::boost::forward<Args>(args)...);
 }
 
 #else
@@ -119,38 +102,18 @@ BOOST_CONTAINER_FORCEINLINE \
    typename dtl::disable_if_c<dtl::is_pair<T>::value, void >::type \
 construct_type(T *p BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
 {\
-   ::new((void*)p, boost_container_new_t()) T( BOOST_MOVE_FWD##N );\
+   ::new(const_cast<void*>(static_cast<const volatile void*>(p)), boost_container_new_t()) T( BOOST_MOVE_FWD##N );\
 }\
 //
 BOOST_MOVE_ITERATE_0TO8(BOOST_CONTAINER_ALLOCATOR_TRAITS_CONSTRUCT_TYPEJ)
 #undef BOOST_CONTAINER_ALLOCATOR_TRAITS_CONSTRUCT_TYPEJ
 
-#define BOOST_CONTAINER_ALLOCATOR_TRAITS_CONSTRUCT_TYPE(N) \
-template < class Pair, class KeyType BOOST_MOVE_I##N BOOST_MOVE_CLASS##N>\
-typename dtl::enable_if< dtl::is_pair<Pair>, void >::type construct_type\
-   (Pair* p, try_emplace_t, BOOST_FWD_REF(KeyType) k BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
-{\
-   construct_type(dtl::addressof(p->first), ::boost::forward<KeyType>(k));\
-   BOOST_CONTAINER_TRY{\
-      construct_type(dtl::addressof(p->second) BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
-   }\
-   BOOST_CONTAINER_CATCH(...) {\
-      typedef typename Pair::first_type first_type;\
-      dtl::addressof(p->first)->~first_type();\
-      BOOST_CONTAINER_RETHROW\
-   }\
-   BOOST_CONTAINER_CATCH_END\
-}\
-//
-BOOST_MOVE_ITERATE_0TO8(BOOST_CONTAINER_ALLOCATOR_TRAITS_CONSTRUCT_TYPE)
-#undef BOOST_CONTAINER_ALLOCATOR_TRAITS_CONSTRUCT_TYPE
-
 #endif
 
 template<class T>
 inline
 typename dtl::enable_if<dtl::is_pair<T>, void >::type
-construct_type(T* p)
+   construct_type(T* p)
 {
    dtl::construct_type(dtl::addressof(p->first));
    BOOST_CONTAINER_TRY{
@@ -164,7 +127,6 @@ construct_type(T* p)
    BOOST_CONTAINER_CATCH_END
 }
 
-
 template<class T, class U>
 inline
 typename dtl::enable_if_c
@@ -230,9 +192,19 @@ class small_vector_allocator;
 
 namespace allocator_traits_detail {
 
+#if defined(BOOST_CONTAINER_GCC_COMPATIBLE_HAS_DIAGNOSTIC_IGNORED)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
 BOOST_INTRUSIVE_HAS_STATIC_MEMBER_FUNC_SIGNATURE(has_max_size, max_size)
 BOOST_INTRUSIVE_HAS_STATIC_MEMBER_FUNC_SIGNATURE(has_select_on_container_copy_construction, select_on_container_copy_construction)
 
+
+#if defined(BOOST_CONTAINER_GCC_COMPATIBLE_HAS_DIAGNOSTIC_IGNORED)
+#pragma GCC diagnostic pop
+#endif
+
 }  //namespace allocator_traits_detail {
 
 namespace dtl {
@@ -255,6 +227,11 @@ template<class Allocator>
 struct is_not_std_allocator
 {  BOOST_STATIC_CONSTEXPR bool value = !is_std_allocator<Allocator>::value; };
 
+#if defined(BOOST_CONTAINER_GCC_COMPATIBLE_HAS_DIAGNOSTIC_IGNORED)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
 BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(pointer)
 BOOST_INTRUSIVE_INSTANTIATE_EVAL_DEFAULT_TYPE_TMPLT(const_pointer)
 BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(reference)
@@ -269,6 +246,10 @@ BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(is_always_equal)
 BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(difference_type)
 BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(is_partially_propagable)
 
+#if defined(BOOST_CONTAINER_GCC_COMPATIBLE_HAS_DIAGNOSTIC_IGNORED)
+#pragma GCC diagnostic pop
+#endif
+
 }  //namespace dtl {
 
 #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
@@ -509,6 +490,25 @@ struct allocator_traits
       }
    #endif
 
+   #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+
+      template < class Pair, class KeyType, class ... Args>
+      static typename dtl::enable_if< dtl::is_pair<Pair>, void >::type construct
+         (Allocator & a, Pair* p, try_emplace_t, BOOST_FWD_REF(KeyType) k, BOOST_FWD_REF(Args) ...args)
+      {
+         allocator_traits::construct(a, dtl::addressof(p->first), ::boost::forward<KeyType>(k));
+         BOOST_CONTAINER_TRY{
+            allocator_traits::construct(a, dtl::addressof(p->second), ::boost::forward<Args>(args)...);
+         }
+         BOOST_CONTAINER_CATCH(...) {
+            typedef typename Pair::first_type first_type;
+            dtl::addressof(p->first)->~first_type();
+            BOOST_CONTAINER_RETHROW
+         }
+         BOOST_CONTAINER_CATCH_END
+      }
+   #endif
+
    //! <b>Returns</b>: <code>a.storage_is_unpropagable(p)</code> if is_partially_propagable::value is true; otherwise,
    //! <code>false</code>.
    inline static bool storage_is_unpropagable(const Allocator &a, pointer p) BOOST_NOEXCEPT_OR_NOTHROW
@@ -533,17 +533,35 @@ struct allocator_traits
    inline static pointer priv_allocate(dtl::false_type, Allocator &a, size_type n, const_void_pointer)
    {  return a.allocate(n);  }
 
+   #if defined(BOOST_CONTAINER_GCC_COMPATIBLE_HAS_DIAGNOSTIC_IGNORED)
+   #pragma GCC diagnostic push
+   #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+   #endif
+
    template<class T>
    inline static void priv_destroy(dtl::true_type, Allocator &a, T* p) BOOST_NOEXCEPT_OR_NOTHROW
    {  a.destroy(p);  }
 
+   #if defined(BOOST_CONTAINER_GCC_COMPATIBLE_HAS_DIAGNOSTIC_IGNORED)
+   #pragma GCC diagnostic pop
+   #endif
+
    template<class T>
    inline static void priv_destroy(dtl::false_type, Allocator &, T* p) BOOST_NOEXCEPT_OR_NOTHROW
    {  p->~T(); (void)p;  }
 
+   #if defined(BOOST_CONTAINER_GCC_COMPATIBLE_HAS_DIAGNOSTIC_IGNORED)
+   #pragma GCC diagnostic push
+   #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+   #endif
+
    inline static size_type priv_max_size(dtl::true_type, const Allocator &a) BOOST_NOEXCEPT_OR_NOTHROW
    {  return a.max_size();  }
 
+   #if defined(BOOST_CONTAINER_GCC_COMPATIBLE_HAS_DIAGNOSTIC_IGNORED)
+   #pragma GCC diagnostic pop
+   #endif
+
    inline static size_type priv_max_size(dtl::false_type, const Allocator &) BOOST_NOEXCEPT_OR_NOTHROW
    {  return size_type(-1)/sizeof(value_type);  }
 
@@ -553,11 +571,33 @@ struct allocator_traits
    inline static const Allocator &priv_select_on_container_copy_construction(dtl::false_type, const Allocator &a) BOOST_NOEXCEPT_OR_NOTHROW
    {  return a;  }
 
+
+   #if defined(BOOST_CONTAINER_GCC_COMPATIBLE_HAS_DIAGNOSTIC_IGNORED)
+   #pragma GCC diagnostic push
+   #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+   #endif
+
    #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
       template<class T, class ...Args>
       inline static void priv_construct(dtl::true_type, Allocator &a, T *p, BOOST_FWD_REF(Args) ...args)
       {  a.construct( p, ::boost::forward<Args>(args)...);  }
 
+      template<class T, class KeyType, class ...Args>
+      inline static typename dtl::enable_if< dtl::is_pair<T>, void >::type
+         priv_construct(dtl::true_type, Allocator &a, T *p, try_emplace_t, BOOST_FWD_REF(KeyType) k, BOOST_FWD_REF(Args) ...args)
+      {
+         a.construct(dtl::addressof(p->first), ::boost::forward<KeyType>(k));
+         BOOST_CONTAINER_TRY{
+            a.construct(dtl::addressof(p->second), ::boost::forward<Args>(args)...);
+         }
+         BOOST_CONTAINER_CATCH(...) {
+            typedef typename T::first_type first_type;
+            dtl::addressof(p->first)->~first_type();
+            BOOST_CONTAINER_RETHROW
+         }
+         BOOST_CONTAINER_CATCH_END
+      }
+
       template<class T, class ...Args>
       inline static void priv_construct(dtl::false_type, Allocator &, T *p, BOOST_FWD_REF(Args) ...args)
       {  dtl::construct_type(p, ::boost::forward<Args>(args)...); }
@@ -576,6 +616,28 @@ struct allocator_traits
          dtl::bool_<value> flag;\
          (priv_construct)(flag, a, p BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
       }\
+      \
+      //
+      BOOST_MOVE_ITERATE_0TO8(BOOST_CONTAINER_ALLOCATOR_TRAITS_CONSTRUCT_IMPL)
+      #undef BOOST_CONTAINER_ALLOCATOR_TRAITS_CONSTRUCT_IMPL
+
+      #define BOOST_CONTAINER_ALLOCATOR_TRAITS_CONSTRUCT_IMPL(N) \
+      template<class T, class KeyType BOOST_MOVE_I##N BOOST_MOVE_CLASS##N >\
+      inline static typename dtl::enable_if< dtl::is_pair<T>, void >::type\
+         construct(Allocator &a, T *p, try_emplace_t, BOOST_FWD_REF(KeyType) k BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
+      {\
+         allocator_traits::construct(a, dtl::addressof(p->first), ::boost::forward<KeyType>(k));\
+         BOOST_CONTAINER_TRY{\
+            allocator_traits::construct(a, dtl::addressof(p->second) BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
+         }\
+         BOOST_CONTAINER_CATCH(...) {\
+            typedef typename T::first_type first_type;\
+            dtl::addressof(p->first)->~first_type();\
+            BOOST_CONTAINER_RETHROW\
+         }\
+         BOOST_CONTAINER_CATCH_END\
+      }\
+      \
       //
       BOOST_MOVE_ITERATE_0TO8(BOOST_CONTAINER_ALLOCATOR_TRAITS_CONSTRUCT_IMPL)
       #undef BOOST_CONTAINER_ALLOCATOR_TRAITS_CONSTRUCT_IMPL
@@ -598,6 +660,11 @@ struct allocator_traits
 
    #endif   // #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
+   #if defined(BOOST_CONTAINER_GCC_COMPATIBLE_HAS_DIAGNOSTIC_IGNORED)
+   #pragma GCC diagnostic pop
+   #endif
+
+
    template<class T>
    inline static void priv_construct(dtl::false_type, Allocator &, T *p, const ::boost::container::default_init_t&)
    {  ::new((void*)p, boost_container_new_t()) T; }