passenger 6.2.0 → 6.2.2

data/src/cxx_supportlib/vendor-modified/boost/container/detail/aligned_allocation.hpp

@@ -0,0 +1,149 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2025-2025. 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)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_CONTAINER_DETAIL_ALIGNED_ALLOCATION_HPP
+#define BOOST_CONTAINER_DETAIL_ALIGNED_ALLOCATION_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+// Platform detection
+#if defined(_WIN32) && !defined(__CYGWIN__)
+   #define BOOST_CONTAINER_HAS_ALIGNED_MALLOC
+#elif BOOST_CXX_VERSION >= 201703L
+   #define BOOST_CONTAINER_HAS_ALIGNED_ALLOC
+#elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)
+   //Note: in most C++ compilers __STDC_VERSION__ is not defined, but just in case
+   #define BOOST_CONTAINER_HAS_ALIGNED_ALLOC
+#else
+   #include <unistd.h>  //Include it to detect POSIX features
+   #if defined(_POSIX_C_SOURCE) && (_POSIX_C_SOURCE >= 200112L)
+      #define BOOST_CONTAINER_HAS_POSIX_MEMALIGN
+   #elif defined(__APPLE__)
+      //All recent Apple OSes (macOS 10.6+, iOS 3.0+, tvOS 9.0+, watchOS 2.0+) support posix_memalign
+      #define BOOST_CONTAINER_HAS_POSIX_MEMALIGN
+   #elif defined(__ANDROID__)
+      #if (__ANDROID_API__ >= 28)
+         #define BOOST_CONTAINER_HAS_ALIGNED_ALLOC
+      #else
+         #define BOOST_CONTAINER_HAS_POSIX_MEMALIGN
+      #endif
+   #endif
+#endif
+
+// Include
+#if defined(BOOST_CONTAINER_HAS_ALIGNED_MALLOC)
+   #include <malloc.h>
+#elif defined(BOOST_CONTAINER_HAS_POSIX_MEMALIGN)
+   #include <stdlib.h>
+#elif defined(BOOST_CONTAINER_HAS_ALIGNED_ALLOC)
+   #include <stdlib.h>
+#else
+   #include <stdlib.h> //for malloc
+#endif
+
+namespace boost {
+namespace container {
+namespace dtl {
+
+#if defined(BOOST_CONTAINER_HAS_POSIX_MEMALIGN)
+
+inline void* aligned_allocate(std::size_t al, std::size_t sz)
+{
+   void *ptr;
+   // posix_memalign requires aligned multiple of void*
+   if (al < sizeof(void*))
+      al = sizeof(void*);
+   int ret = posix_memalign(&ptr, al, sz);
+   if (ret != 0)
+      return 0;
+   return ptr;
+}
+
+#elif defined(BOOST_CONTAINER_HAS_ALIGNED_ALLOC)
+
+inline void* aligned_allocate(std::size_t al, std::size_t sz)
+{
+   // Some aligned_allocate are based on posix_memalign so require also minimal alignment
+   if (al < sizeof(void*))
+      al = sizeof(void*);
+
+   // aligned_allocate requires size to be a multiple of alignment
+   std::size_t rounded_size = std::size_t(sz + al - 1u) & ~std::size_t(al - 1);
+
+   //Check for rounded size overflow
+   return rounded_size ? ::aligned_alloc(al, rounded_size) : 0;
+}
+
+#elif defined(BOOST_CONTAINER_HAS_ALIGNED_MALLOC)
+
+inline void* aligned_allocate(std::size_t al, std::size_t sz)
+{
+   return _aligned_malloc(sz, al);
+}
+
+#else
+
+inline void* aligned_allocate(std::size_t al, std::size_t sz)
+{
+   //Make room for a back pointer metadata
+   void* const mptr = malloc(sz + sizeof(void*) + al);
+   if (!mptr)
+      return 0;
+
+   //Now align the returned pointer (which will be aligned at least to sizeof(void*)
+   const std::size_t raw_addr = reinterpret_cast<std::size_t>(mptr);
+   const std::size_t offset = sizeof(void*);
+   void *const ptr = reinterpret_cast<void*>((raw_addr + offset + al - 1u) & ~(al - 1u));
+
+   // Store the original pointer just before the aligned address
+   void** const backpointer = reinterpret_cast<void**>(ptr) - 1;
+   *backpointer = mptr;
+   return ptr;
+}
+
+#endif
+
+#if defined(BOOST_CONTAINER_HAS_ALIGNED_ALLOC) || defined(BOOST_CONTAINER_HAS_POSIX_MEMALIGN)
+
+inline void aligned_deallocate(void* ptr)
+{
+   if (!ptr)
+      return;
+   free(ptr);
+}
+
+#elif defined(BOOST_CONTAINER_HAS_ALIGNED_MALLOC)
+
+inline void aligned_deallocate(void* ptr)
+{
+   _aligned_free(ptr);  //_aligned_free supports NULL ptr
+}
+
+#else
+
+inline void aligned_deallocate(void* ptr)
+{
+    // Obtain backpointer data and free it
+    void** storage = reinterpret_cast<void**>(ptr) - 1;
+    free(*storage);
+}
+
+#endif//
+
+}  //namespace dtl {
+}  //namespace container {
+}  //namespace boost {
+
+#endif   //#ifndef BOOST_CONTAINER_DETAIL_ALIGNED_ALLOCATION_HPP

data/src/cxx_supportlib/vendor-modified/boost/container/detail/alloc_helpers.hpp

@@ -22,6 +22,7 @@
 #include <boost/move/adl_move_swap.hpp>
 #include <boost/move/utility_core.hpp>
 #include <boost/container/detail/mpl.hpp>
+#include <boost/assert.hpp>
 
 namespace boost {
 namespace container {
@@ -54,6 +55,40 @@ template<class AllocatorType>
 inline void move_alloc(AllocatorType &l, AllocatorType &r, dtl::true_type)
 {  l = ::boost::move(r);   }
 
+template<class SizeType, class LimitSizeType, bool = sizeof(SizeType)<= sizeof(LimitSizeType)>
+struct limit_by_stored_size_type
+{
+   static BOOST_CONTAINER_FORCEINLINE SizeType clamp(SizeType val)
+   {  return val; }
+
+   static BOOST_CONTAINER_FORCEINLINE void set(LimitSizeType &val, SizeType v)
+   {  val = v; }
+
+   template <class F>
+   BOOST_CONTAINER_FORCEINLINE static void call_if_overflows(SizeType, F)
+   {}
+};
+
+template<class SizeType, class LimitSizeType>
+struct limit_by_stored_size_type<SizeType, LimitSizeType, false>
+{
+   static BOOST_CONTAINER_FORCEINLINE SizeType clamp(SizeType val)
+   {  return val <= LimitSizeType(-1) ? val : LimitSizeType(-1);  }
+
+   static void set(LimitSizeType &dst, SizeType val)
+   {
+      BOOST_ASSERT(LimitSizeType(-1) >= val);
+      dst = static_cast<LimitSizeType>(val);
+   }
+
+   template <class F>
+   BOOST_CONTAINER_FORCEINLINE static void call_if_overflows(SizeType v, F f)
+   {
+      if(LimitSizeType(-1) < v)
+         f();
+   }
+};
+
 }  //namespace dtl {
 }  //namespace container {
 }  //namespace boost {

data/src/cxx_supportlib/vendor-modified/boost/container/detail/alloc_lib.h

@@ -284,6 +284,7 @@ int boost_cont_malloc_check(void);
 boost_cont_command_ret_t boost_cont_allocation_command
    ( allocation_type command
    , size_t sizeof_object
+   , size_t alignof_object
    , size_t limit_objects
    , size_t preferred_objects
    , size_t *received_objects

data/src/cxx_supportlib/vendor-modified/boost/container/detail/bit_utilities.hpp

@@ -0,0 +1,133 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2026. 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)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_CONTAINER_DETAIL_BIT_UTILITIES_HPP
+#define BOOST_CONTAINER_DETAIL_BIT_UTILITIES_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/detail/workaround.hpp>
+#include <boost/assert.hpp>
+#include <boost/cstdint.hpp>
+
+//_BitScan{Forward,Reverse}[64] used by the bit helpers below. The 64-bit
+//variants only exist on x64/ARM64; the 32-bit ones are also available on x86
+//and ARM, where the 64-bit value is scanned as two 32-bit halves.
+#if defined(BOOST_MSVC) && \
+    (defined(_M_X64) || defined(_M_ARM64) || defined(_M_IX86) || defined(_M_ARM))
+#  include <intrin.h>
+#endif
+
+namespace boost {
+namespace container {
+namespace dtl {
+
+//! Count trailing zero bits of a 64-bit value.
+//! Precondition: x != 0 (the result is undefined otherwise).
+BOOST_CONTAINER_FORCEINLINE int unchecked_countr_zero(boost::uint64_t x)
+{
+#if defined(BOOST_MSVC) && (defined(_M_X64) || defined(_M_ARM64))
+   unsigned long r;
+   _BitScanForward64(&r, x);
+   return (int)r;
+#elif defined(BOOST_GCC) || defined(BOOST_CLANG)
+   return (int)__builtin_ctzll(x);
+#elif defined(BOOST_MSVC) && (defined(_M_IX86) || defined(_M_ARM))
+   //32-bit MSVC targets lack _BitScanForward64: scan the two 32-bit halves.
+   unsigned long r;
+   if (_BitScanForward(&r, (unsigned long)x))
+      return (int)r;
+   _BitScanForward(&r, (unsigned long)(x >> 32));
+   return (int)r + 32;
+#else
+   //O(1) branchless fallback for compilers without intrinsics, using
+   //mod-37 perfect-hash table on 32-bit halves
+   //(avoids 64-bit multiplies, friendlier to exotic 32-bit-only targets)
+   static const unsigned char mod37[37] =
+   { 32, 0, 1, 26, 2, 23, 27, 0, 3, 16, 24, 30, 28, 11, 0, 13, 4, 7, 17, 0
+   , 25, 22, 31, 15, 29, 10, 12, 6, 0, 21, 14, 9, 5, 20, 8, 19, 18 };
+   boost::uint32_t lo = (boost::uint32_t)x;
+   if (lo)
+      return mod37[((boost::uint32_t)(0u - lo) & lo) % 37u];
+   boost::uint32_t hi = (boost::uint32_t)(x >> 32);
+   return 32 + mod37[((boost::uint32_t)(0u - hi) & hi) % 37u];
+#endif
+}
+
+//! Count trailing one bits of a 64-bit value.
+//! Precondition: x != (uint64_t)-1 (the result is undefined otherwise).
+BOOST_CONTAINER_FORCEINLINE int unchecked_countr_one(boost::uint64_t x)
+{
+   return unchecked_countr_zero(~x);
+}
+
+//! Count leading zero bits of a 64-bit value.
+//! Precondition: x != 0 (the result is undefined otherwise).
+BOOST_CONTAINER_FORCEINLINE int unchecked_countl_zero(boost::uint64_t x)
+{
+#if defined(BOOST_MSVC) && (defined(_M_X64) || defined(_M_ARM64))
+   unsigned long r;
+   _BitScanReverse64(&r, x);
+   return (int)(63 - r);
+#elif defined(BOOST_GCC) || defined(BOOST_CLANG)
+   return (int)__builtin_clzll(x);
+#elif defined(BOOST_MSVC) && (defined(_M_IX86) || defined(_M_ARM))
+   //32-bit MSVC targets lack _BitScanReverse64: scan the two 32-bit halves.
+   unsigned long r;
+   if (_BitScanReverse(&r, (unsigned long)(x >> 32)))
+      return 31 - (int)r;
+   _BitScanReverse(&r, (unsigned long)x);
+   return 63 - (int)r;
+#else
+   //O(1) branchless fallback for compilers without intrinsics, using
+   //smear-right + mod-37 perfect-hash table on 32-bit halves
+   static const unsigned char mod37[37] =
+   { 32, 31, 6, 30, 9, 5, 0, 29, 16, 8, 2, 4, 21, 0, 19, 28, 25, 15, 0, 7
+   , 10, 1, 17, 3, 22, 20, 26, 0, 11, 18, 23, 27, 12, 24, 13, 14, 0 };
+   boost::uint32_t hi = (boost::uint32_t)(x >> 32);
+   if (hi) {
+      hi |= hi >> 1; hi |= hi >> 2; hi |= hi >> 4; hi |= hi >> 8; hi |= hi >> 16;
+      return mod37[hi % 37u];
+   }
+   boost::uint32_t lo = (boost::uint32_t)x;
+   lo |= lo >> 1; lo |= lo >> 2; lo |= lo >> 4; lo |= lo >> 8; lo |= lo >> 16;
+   return 32 + mod37[lo % 37u];
+#endif
+}
+
+//! Count the number of set bits of a 64-bit value.
+BOOST_CONTAINER_FORCEINLINE int popcount(boost::uint64_t x)
+{
+#if defined(BOOST_GCC) || defined(BOOST_CLANG)
+   return (int)__builtin_popcountll(x);
+#elif defined(BOOST_MSVC) && defined(_M_X64)
+   return (int)__popcnt64(x);
+#else
+   //Portable SWAR population count.
+   x = x - ((x >> 1) & boost::uint64_t(0x5555555555555555));
+   x = (x & boost::uint64_t(0x3333333333333333)) + ((x >> 2) & boost::uint64_t(0x3333333333333333));
+   x = (x + (x >> 4)) & boost::uint64_t(0x0f0f0f0f0f0f0f0f);
+   return (int)((x * boost::uint64_t(0x0101010101010101)) >> 56);
+#endif
+}
+
+} //namespace dtl {
+} //namespace container {
+} //namespace boost {
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif //BOOST_CONTAINER_DETAIL_BIT_UTILITIES_HPP

data/src/cxx_supportlib/vendor-modified/boost/container/detail/compare_functors.hpp

@@ -32,12 +32,12 @@ class equal_to_value
    const value_type &t_;
 
    public:
-   inline explicit equal_to_value(const value_type &t)
+   BOOST_CONTAINER_FORCEINLINE explicit equal_to_value(const value_type &t)
       :  t_(t)
    {}
 
    template <class U>
-   inline bool operator()(const U &t)const
+   BOOST_CONTAINER_FORCEINLINE bool operator()(const U &t)const
    {
       return t_ == t;
    }
@@ -55,7 +55,7 @@ class equal_to_value_first
    {}
 
    template <class U>
-   inline bool operator()(const U &t)const
+   BOOST_CONTAINER_FORCEINLINE bool operator()(const U &t)const
    {
       return t_ == t.first;
    }
@@ -149,6 +149,21 @@ struct key_node_pred
 };
 
 
+template<class Pred>
+class not_pred
+{
+   BOOST_ATTRIBUTE_NO_UNIQUE_ADDRESS Pred m_p;
+
+   public:
+   BOOST_CONTAINER_FORCEINLINE explicit not_pred(const Pred &p)
+      :  m_p(p)
+   {}
+
+   template <class U>
+   BOOST_CONTAINER_FORCEINLINE bool operator()(const U &u) const
+   {  return !m_p(u);  }
+};
+
 }  //namespace container {
 }  //namespace boost {
 

data/src/cxx_supportlib/vendor-modified/boost/container/detail/config_begin.hpp

@@ -59,3 +59,8 @@
 #pragma GCC diagnostic ignored "-Wsign-conversion"
 #endif
 #endif
+
+#if defined(BOOST_CLANG)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpass-failed"   // ignore some missed optimization warnings
+#endif

data/src/cxx_supportlib/vendor-modified/boost/container/detail/config_end.hpp

@@ -14,3 +14,7 @@
 #if defined(BOOST_GCC) && (BOOST_GCC >= 40600)
 #pragma GCC diagnostic pop
 #endif
+
+#if defined(BOOST_CLANG)
+#pragma clang diagnostic pop
+#endif

data/src/cxx_supportlib/vendor-modified/boost/container/detail/container_rebind.hpp

@@ -150,7 +150,7 @@ namespace dtl {
       typedef Cont<U, typename void_or_portable_rebind_alloc<V, A, U>::type, P0, P1, P2, P3, P4, P5, P6, P7, P8> type;
    };
 
-#endif   //!defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+#endif   //   !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
    //for small_vector,static_vector
 

data/src/cxx_supportlib/vendor-modified/boost/container/detail/copy_move_algo.hpp

@@ -535,11 +535,22 @@ inline typename dtl::disable_if_memtransfer_copy_constructible<I, F, F>::type
 {
    F back = r;
    BOOST_CONTAINER_TRY{
+      //GCC's value-range analysis issues a spurious -Wmaybe-uninitialized here
+      //when this copy-construct loop is inlined into a fixed-capacity container's
+      //(e.g. static_vector) copy constructor after a near-end single-element
+      //insert: it cannot prove the just-built trailing slot is initialized.
+#if defined(BOOST_GCC) && (BOOST_GCC >= 40600)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
+#endif
       while (n) {
          --n;
          allocator_traits<Allocator>::construct(a, boost::movelib::iterator_to_raw_pointer(r), *f);
          ++f; ++r;
       }
+#if defined(BOOST_GCC) && (BOOST_GCC >= 40600)
+#pragma GCC diagnostic pop
+#endif
    }
    BOOST_CONTAINER_CATCH(...){
       for (; back != r; ++back){
@@ -1619,7 +1630,7 @@ void expand_backward_forward_and_insert_alloc_move_backward
          //Old values destroyed automatically with "old_values_destroyer"
          //when "old_values_destroyer" goes out of scope unless the have trivial
          //destructor after move.
-         if(trivial_dctr_after_move)
+         BOOST_IF_CONSTEXPR(trivial_dctr_after_move)
             old_values_destroyer.release();
       }
       //raw_before is so big that divides old_end
@@ -1649,7 +1660,7 @@ void expand_backward_forward_and_insert_alloc_move_backward
             remaining_pos = ::boost::container::move_forward_overlapping(remaining_pos, old_finish, old_start);
             (void)remaining_pos;
             //Once moved, avoid calling the destructors if trivial after move
-            if(!trivial_dctr_after_move) {
+            BOOST_IF_CONSTEXPR(!trivial_dctr_after_move) {
                boost::container::destroy_alloc(a, remaining_pos, old_finish);
             }
          }
@@ -1720,7 +1731,7 @@ void expand_backward_forward_and_insert_alloc_move_backward
             B const new_first(make_iterator_uadvance(next, new_1st_range));
             B const p = ::boost::container::move_forward_overlapping(pos, old_finish, new_first);
             (void)p;
-            if(!trivial_dctr_after_move)
+            BOOST_IF_CONSTEXPR(!trivial_dctr_after_move)
                boost::container::destroy_alloc(a, p, old_finish);
          }
       }
@@ -1771,7 +1782,7 @@ void expand_backward_forward_and_insert_alloc_move_backward
                               //trivial_dctr_after_move is true
             //Destroy remaining moved elements from old_end except if they
             //have trivial destructor after being moved
-            if(!trivial_dctr_after_move) {
+            BOOST_IF_CONSTEXPR(!trivial_dctr_after_move) {
                boost::container::destroy_alloc(a, move_end, old_finish);
             }
          }
@@ -1922,7 +1933,7 @@ inline void expand_backward_forward_and_insert_alloc_move_forward
          //Old values destroyed automatically with "old_values_destroyer"
          //when "old_values_destroyer" goes out of scope unless the have trivial
          //destructor after move.
-         if(trivial_dctr_after_move)
+         BOOST_IF_CONSTEXPR(trivial_dctr_after_move)
             old_values_destroyer.release();
       }
       //raw_before is so big that divides old_end
@@ -1948,7 +1959,7 @@ inline void expand_backward_forward_and_insert_alloc_move_forward
          BOOST_ASSERT(old_start != old_finish);
          boost::container::move_backward_overlapping(old_start, pre_pos_raw, old_finish);
          old_values_destroyer.release();
-         if (!trivial_dctr_after_move) {
+         BOOST_IF_CONSTEXPR(!trivial_dctr_after_move) {
             boost::container::destroy_alloc(a, old_start, new_start);
          }
       }
@@ -1987,7 +1998,7 @@ inline void expand_backward_forward_and_insert_alloc_move_forward
          //Destroy remaining moved elements from old_begin except if they
          //have trivial destructor after being moved
          old_values_destroyer.release();
-         if (!trivial_dctr_after_move) {
+         BOOST_IF_CONSTEXPR(!trivial_dctr_after_move) {
             boost::container::destroy_alloc(a, old_start, p);
          }
       }
@@ -2014,9 +2025,8 @@ inline void expand_backward_forward_and_insert_alloc_move_forward
          insertion_proxy.copy_n_and_update(a, new_beg_pos, n);
          B const p = ::boost::container::move_backward_overlapping(old_start, pos, new_beg_pos);
          old_values_destroyer.release();
-
-         if (!trivial_dctr_after_move) {
-            (void)p;
+         (void)p;
+         BOOST_IF_CONSTEXPR(!trivial_dctr_after_move) {
             boost::container::destroy_alloc(a, old_start, p);
          }
       }