passenger 6.2.1 → 6.2.2

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

@@ -150,25 +150,30 @@ class adaptive_pool
 
    //!Returns the number of elements that could be allocated.
    //!Never throws
+   BOOST_CONTAINER_NODISCARD
    size_type max_size() const BOOST_NOEXCEPT_OR_NOTHROW
    {  return size_type(-1)/(2u*sizeof(T));   }
 
    //!Allocate memory for an array of count elements.
    //!Throws bad_alloc if there is no enough memory
-   pointer allocate(size_type count, const void * = 0)
+   BOOST_CONTAINER_NODISCARD
+   pointer allocate(size_type count)
    {
-      if(BOOST_UNLIKELY(count > size_type(-1)/(2u*sizeof(T))))
+      if(BOOST_UNLIKELY(count > this->max_size()))
          boost::container::throw_bad_alloc();
 
-      if(Version == 1 && count == 1){
+      BOOST_IF_CONSTEXPR(Version == 1)
+      if(count == 1){
          typedef typename dtl::shared_adaptive_node_pool
-            <sizeof(T), NodesPerBlock, MaxFreeBlocks, OverheadPercent> shared_pool_t;
+            < sizeof(T), NodesPerBlock, MaxFreeBlocks
+            , OverheadPercent, dtl::alignment_of<T>::value> shared_pool_t;
          typedef dtl::singleton_default<shared_pool_t> singleton_t;
          return pointer(static_cast<T*>(singleton_t::instance().allocate_node()));
       }
-      else{
-         return static_cast<pointer>(dlmalloc_malloc(count*sizeof(T)));
-      }
+      void *ret = dlmalloc_memalign(count*sizeof(T), dtl::alignment_of<T>::value);
+      if(BOOST_UNLIKELY(!ret))
+         boost::container::throw_bad_alloc();
+      return static_cast<pointer>(ret);
    }
 
    //!Deallocate allocated memory.
@@ -176,22 +181,22 @@ class adaptive_pool
    void deallocate(const pointer &ptr, size_type count) BOOST_NOEXCEPT_OR_NOTHROW
    {
       (void)count;
-      if(Version == 1 && count == 1){
+      BOOST_IF_CONSTEXPR(Version == 1)
+      if(count == 1){
          typedef dtl::shared_adaptive_node_pool
-            <sizeof(T), NodesPerBlock, MaxFreeBlocks, OverheadPercent> shared_pool_t;
+            <sizeof(T), NodesPerBlock, MaxFreeBlocks, OverheadPercent, dtl::alignment_of<T>::value> shared_pool_t;
          typedef dtl::singleton_default<shared_pool_t> singleton_t;
          singleton_t::instance().deallocate_node(ptr);
+         return;
       }
-      else{
-         dlmalloc_free(ptr);
-      }
+      dlmalloc_free(ptr);
    }
 
-   pointer allocation_command(allocation_type command,
-                         size_type limit_size,
-                         size_type &prefer_in_recvd_out_size,
-                         pointer &reuse)
+   BOOST_CONTAINER_NODISCARD
+   pointer allocation_command
+      (allocation_type command, size_type limit_size, size_type &prefer_in_recvd_out_size, pointer &reuse)
    {
+      BOOST_CONTAINER_STATIC_ASSERT(( Version > 1 ));
       pointer ret = this->priv_allocation_command(command, limit_size, prefer_in_recvd_out_size, reuse);
       if(BOOST_UNLIKELY(!ret && !(command & BOOST_CONTAINER_NOTHROW_ALLOCATION)))
          boost::container::throw_bad_alloc();
@@ -200,16 +205,21 @@ class adaptive_pool
 
    //!Returns maximum the number of objects the previously allocated memory
    //!pointed by p can hold.
+   BOOST_CONTAINER_NODISCARD
    size_type size(pointer p) const BOOST_NOEXCEPT_OR_NOTHROW
-   {  return dlmalloc_size(p);  }
+   {
+      BOOST_CONTAINER_STATIC_ASSERT(( Version > 1 ));
+      return dlmalloc_size(p);
+   }
 
    //!Allocates just one object. Memory allocated with this function
    //!must be deallocated only with deallocate_one().
    //!Throws bad_alloc if there is no enough memory
+   BOOST_CONTAINER_NODISCARD
    pointer allocate_one()
    {
       typedef dtl::shared_adaptive_node_pool
-         <sizeof(T), NodesPerBlock, MaxFreeBlocks, OverheadPercent> shared_pool_t;
+         <sizeof(T), NodesPerBlock, MaxFreeBlocks, OverheadPercent, dtl::alignment_of<T>::value> shared_pool_t;
       typedef dtl::singleton_default<shared_pool_t> singleton_t;
       return (pointer)singleton_t::instance().allocate_node();
    }
@@ -218,8 +228,9 @@ class adaptive_pool
    //!Elements must be individually deallocated with deallocate_one()
    void allocate_individual(std::size_t num_elements, multiallocation_chain &chain)
    {
+      BOOST_CONTAINER_STATIC_ASSERT(( Version > 1 ));
       typedef dtl::shared_adaptive_node_pool
-         <sizeof(T), NodesPerBlock, MaxFreeBlocks, OverheadPercent> shared_pool_t;
+         <sizeof(T), NodesPerBlock, MaxFreeBlocks, OverheadPercent, dtl::alignment_of<T>::value> shared_pool_t;
       typedef dtl::singleton_default<shared_pool_t> singleton_t;
       singleton_t::instance().allocate_nodes(num_elements, static_cast<typename shared_pool_t::multiallocation_chain&>(chain));
       //typename shared_pool_t::multiallocation_chain ch;
@@ -233,16 +244,18 @@ class adaptive_pool
    //!with other functions different from allocate_one(). Never throws
    void deallocate_one(pointer p) BOOST_NOEXCEPT_OR_NOTHROW
    {
+      BOOST_CONTAINER_STATIC_ASSERT(( Version > 1 ));
       typedef dtl::shared_adaptive_node_pool
-         <sizeof(T), NodesPerBlock, MaxFreeBlocks, OverheadPercent> shared_pool_t;
+         <sizeof(T), NodesPerBlock, MaxFreeBlocks, OverheadPercent, dtl::alignment_of<T>::value> shared_pool_t;
       typedef dtl::singleton_default<shared_pool_t> singleton_t;
       singleton_t::instance().deallocate_node(p);
    }
 
    void deallocate_individual(multiallocation_chain &chain) BOOST_NOEXCEPT_OR_NOTHROW
    {
+      BOOST_CONTAINER_STATIC_ASSERT(( Version > 1 ));
       typedef dtl::shared_adaptive_node_pool
-         <sizeof(T), NodesPerBlock, MaxFreeBlocks, OverheadPercent> shared_pool_t;
+         <sizeof(T), NodesPerBlock, MaxFreeBlocks, OverheadPercent, dtl::alignment_of<T>::value> shared_pool_t;
       typedef dtl::singleton_default<shared_pool_t> singleton_t;
       //typename shared_pool_t::multiallocation_chain ch(&*chain.begin(), &*chain.last(), chain.size());
       //singleton_t::instance().deallocate_nodes(ch);
@@ -305,7 +318,7 @@ class adaptive_pool
    static void deallocate_free_blocks() BOOST_NOEXCEPT_OR_NOTHROW
    {
       typedef dtl::shared_adaptive_node_pool
-         <sizeof(T), NodesPerBlock, MaxFreeBlocks, OverheadPercent> shared_pool_t;
+         <sizeof(T), NodesPerBlock, MaxFreeBlocks, OverheadPercent, dtl::alignment_of<T>::value> shared_pool_t;
       typedef dtl::singleton_default<shared_pool_t> singleton_t;
       singleton_t::instance().deallocate_free_blocks();
    }
@@ -317,11 +330,13 @@ class adaptive_pool
 
    //!An allocator always compares to true, as memory allocated with one
    //!instance can be deallocated by another instance
+   BOOST_CONTAINER_NODISCARD
    friend bool operator==(const adaptive_pool &, const adaptive_pool &) BOOST_NOEXCEPT_OR_NOTHROW
    {  return true;   }
 
    //!An allocator always compares to false, as memory allocated with one
    //!instance can be deallocated by another instance
+   BOOST_CONTAINER_NODISCARD
    friend bool operator!=(const adaptive_pool &, const adaptive_pool &) BOOST_NOEXCEPT_OR_NOTHROW
    {  return false;   }
 
@@ -340,7 +355,8 @@ class adaptive_pool
       std::size_t r_size;
       {
          void* reuse_ptr_void = reuse_ptr;
-         ret = dlmalloc_allocation_command(command, sizeof(T), l_size, p_size, &r_size, reuse_ptr_void);
+         ret = dlmalloc_allocation_command( command, sizeof(T), dtl::alignment_of<T>::value
+                                          , l_size, p_size, &r_size, reuse_ptr_void);
          reuse_ptr = ret.second ? static_cast<T*>(reuse_ptr_void) : 0;
       }
       prefer_in_recvd_out_size = r_size/sizeof(T);
@@ -348,30 +364,11 @@ class adaptive_pool
    }
 };
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
 template < class T
          , std::size_t NodesPerBlock   = ADP_nodes_per_block
          , std::size_t MaxFreeBlocks   = ADP_max_free_blocks
          , std::size_t OverheadPercent = ADP_overhead_percent
-         , unsigned Version = 2
+         BOOST_CONTAINER_DOCIGN(BOOST_MOVE_I unsigned Version = 2)
          >
 class private_adaptive_pool
 {
@@ -392,7 +389,8 @@ class private_adaptive_pool
    BOOST_CONTAINER_DOCIGN(BOOST_CONTAINER_STATIC_ASSERT((Version <=2)));
 
    typedef dtl::private_adaptive_node_pool
-      <sizeof(T), NodesPerBlock, MaxFreeBlocks, OverheadPercent> pool_t;
+      < sizeof(T), NodesPerBlock, MaxFreeBlocks
+      , OverheadPercent, dtl::alignment_of<T>::value>    pool_t;
    pool_t m_pool;
 
    public:
@@ -466,22 +464,23 @@ class private_adaptive_pool
 
    //!Returns the number of elements that could be allocated.
    //!Never throws
+   BOOST_CONTAINER_NODISCARD
    size_type max_size() const BOOST_NOEXCEPT_OR_NOTHROW
    {  return size_type(-1)/(2u*sizeof(T));   }
 
    //!Allocate memory for an array of count elements.
    //!Throws bad_alloc if there is no enough memory
+   BOOST_CONTAINER_NODISCARD
    pointer allocate(size_type count, const void * = 0)
    {
       if(BOOST_UNLIKELY(count > size_type(-1)/(2u*sizeof(T))))
          boost::container::throw_bad_alloc();
 
-      if(Version == 1 && count == 1){
+      BOOST_IF_CONSTEXPR(Version == 1)
+      if(count == 1){
          return pointer(static_cast<T*>(m_pool.allocate_node()));
       }
-      else{
-         return static_cast<pointer>(dlmalloc_malloc(count*sizeof(T)));
-      }
+      return static_cast<pointer>(dlmalloc_memalign(count*sizeof(T), dtl::alignment_of<T>::value));
    }
 
    //!Deallocate allocated memory.
@@ -489,14 +488,15 @@ class private_adaptive_pool
    void deallocate(const pointer &ptr, size_type count) BOOST_NOEXCEPT_OR_NOTHROW
    {
       (void)count;
-      if(Version == 1 && count == 1){
+      BOOST_IF_CONSTEXPR(Version == 1)
+      if(count == 1){
          m_pool.deallocate_node(ptr);
+         return;
       }
-      else{
-         dlmalloc_free(ptr);
-      }
+      dlmalloc_free(ptr);
    }
 
+   BOOST_CONTAINER_NODISCARD
    pointer allocation_command(allocation_type command,
                          size_type limit_size,
                          size_type &prefer_in_recvd_out_size,
@@ -516,6 +516,7 @@ class private_adaptive_pool
    //!Allocates just one object. Memory allocated with this function
    //!must be deallocated only with deallocate_one().
    //!Throws bad_alloc if there is no enough memory
+   BOOST_CONTAINER_NODISCARD
    pointer allocate_one()
    {
       return (pointer)m_pool.allocate_node();
@@ -583,11 +584,13 @@ class private_adaptive_pool
 
    //!An allocator always compares to true, as memory allocated with one
    //!instance can be deallocated by another instance
+   BOOST_CONTAINER_NODISCARD
    friend bool operator==(const private_adaptive_pool &, const private_adaptive_pool &) BOOST_NOEXCEPT_OR_NOTHROW
    {  return true;   }
 
    //!An allocator always compares to false, as memory allocated with one
    //!instance can be deallocated by another instance
+   BOOST_CONTAINER_NODISCARD
    friend bool operator!=(const private_adaptive_pool &, const private_adaptive_pool &) BOOST_NOEXCEPT_OR_NOTHROW
    {  return false;   }
 
@@ -606,7 +609,8 @@ class private_adaptive_pool
       std::size_t r_size;
       {
          void* reuse_ptr_void = reuse_ptr;
-         ret = dlmalloc_allocation_command(command, sizeof(T), l_size, p_size, &r_size, reuse_ptr_void);
+         ret = dlmalloc_allocation_command( command, sizeof(T), dtl::alignment_of<T>::value
+                                          , l_size, p_size, &r_size, reuse_ptr_void);
          reuse_ptr = ret.second ? static_cast<T*>(reuse_ptr_void) : 0;
       }
       prefer_in_recvd_out_size = r_size/sizeof(T);

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

@@ -179,12 +179,11 @@ class allocator
    //!Throws bad_alloc if there is no enough memory
    //!If Version is 2, this allocated memory can only be deallocated
    //!with deallocate() or (for Version == 2) deallocate_many()
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD pointer allocate(size_type count, const void * hint= 0)
+   BOOST_CONTAINER_NODISCARD pointer allocate(size_type count)
    {
-      (void)hint;
       if(count > size_type(-1)/(2u*sizeof(T)))
          boost::container::throw_bad_alloc();
-      void *ret = dlmalloc_malloc(count*sizeof(T));
+      void *ret = dlmalloc_memalign(count*sizeof(T), dtl::alignment_of<T>::value);
       if(!ret)
          boost::container::throw_bad_alloc();
       return static_cast<pointer>(ret);
@@ -197,7 +196,7 @@ class allocator
 
    //!Returns the maximum number of elements that could be allocated.
    //!Never throws
-   inline size_type max_size() const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_NODISCARD inline size_type max_size() const BOOST_NOEXCEPT_OR_NOTHROW
    {  return size_type(-1)/(2u*sizeof(T));   }
 
    //!Swaps two allocators, does nothing
@@ -207,13 +206,13 @@ class allocator
 
    //!An allocator always compares to true, as memory allocated with one
    //!instance can be deallocated by another instance
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD
+   BOOST_CONTAINER_NODISCARD
       friend bool operator==(const allocator &, const allocator &) BOOST_NOEXCEPT_OR_NOTHROW
    {  return true;   }
 
    //!An allocator always compares to false, as memory allocated with one
    //!instance can be deallocated by another instance
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
+   BOOST_CONTAINER_NODISCARD inline
       friend bool operator!=(const allocator &, const allocator &) BOOST_NOEXCEPT_OR_NOTHROW
    {  return false;   }
 
@@ -221,7 +220,7 @@ class allocator
    //!capabilities. Memory allocated with this function can only be deallocated with deallocate()
    //!or deallocate_many().
    //!This function is available only with Version == 2
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD pointer allocation_command(allocation_type command,
+   BOOST_CONTAINER_NODISCARD pointer allocation_command(allocation_type command,
                          size_type limit_size,
                          size_type &prefer_in_recvd_out_size,
                          pointer &reuse)
@@ -240,7 +239,7 @@ class allocator
    //!Memory must not have been allocated with
    //!allocate_one or allocate_individual.
    //!This function is available only with Version == 2
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD size_type size(pointer p) const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_NODISCARD size_type size(pointer p) const BOOST_NOEXCEPT_OR_NOTHROW
    {
       BOOST_CONTAINER_STATIC_ASSERT(( Version > 1 ));
       return dlmalloc_size(p);
@@ -250,7 +249,7 @@ class allocator
    //!must be deallocated only with deallocate_one().
    //!Throws bad_alloc if there is no enough memory
    //!This function is available only with Version == 2
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline pointer allocate_one()
+   BOOST_CONTAINER_NODISCARD inline pointer allocate_one()
    {
       BOOST_CONTAINER_STATIC_ASSERT(( Version > 1 ));
       return this->allocate(1);
@@ -359,7 +358,8 @@ class allocator
       std::size_t r_size;
       {
          void* reuse_ptr_void = reuse_ptr;
-         ret = dlmalloc_allocation_command(command, sizeof(T), l_size, p_size, &r_size, reuse_ptr_void);
+         ret = dlmalloc_allocation_command( command, sizeof(T), dtl::alignment_of<T>::value
+                                          , l_size, p_size, &r_size, reuse_ptr_void);
          reuse_ptr = ret.second ? static_cast<T*>(reuse_ptr_void) : 0;
       }
       prefer_in_recvd_out_size = r_size/sizeof(T);

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

@@ -47,6 +47,8 @@
 #include <boost/move/detail/fwd_macros.hpp>
 #endif
 
+#include <boost/assert.hpp>
+
 #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
 #if defined(BOOST_CONTAINER_GCC_COMPATIBLE_HAS_DIAGNOSTIC_IGNORED)
@@ -84,13 +86,26 @@
 
 namespace boost {
 namespace container {
+
+#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
+
 namespace dtl {
 
+template <class T>
+class allocator_traits_dummy
+{
+   public:
+   typedef T value_type;
+   T *allocate(std::size_t){ return 0;  }
+   void deallocate(T *, std::size_t){}
+};
+
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
 template<class T, class ...Args>
 BOOST_CONTAINER_FORCEINLINE void construct_type(T *p, BOOST_FWD_REF(Args) ...args)
 {
+   BOOST_CONTAINER_ASSUME(p != 0);   //elide the new-expression's null check on placement new
    ::new(const_cast<void*>(static_cast<const volatile void*>(p)), boost_container_new_t()) T(::boost::forward<Args>(args)...);
 }
 
@@ -102,6 +117,7 @@ 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)\
 {\
+   BOOST_CONTAINER_ASSUME(p != 0);\
    ::new(const_cast<void*>(static_cast<const volatile void*>(p)), boost_container_new_t()) T( BOOST_MOVE_FWD##N );\
 }\
 //
@@ -185,8 +201,6 @@ construct_type(T* p, BOOST_FWD_REF(U) x, BOOST_FWD_REF(V) y)
 
 }  //namespace dtl
 
-#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
-
 template<class T, class VoidAllocator, class Options>
 class small_vector_allocator;
 
@@ -418,6 +432,7 @@ struct allocator_traits
 
    //! <b>Returns</b>: <code>a.allocate(n)</code>
    //!
+   BOOST_CONTAINER_NODISCARD
    inline static pointer allocate(Allocator &a, size_type n)
    {  return a.allocate(n);  }
 
@@ -429,6 +444,7 @@ struct allocator_traits
 
    //! <b>Effects</b>: calls <code>a.allocate(n, p)</code> if that call is well-formed;
    //! otherwise, invokes <code>a.allocate(n)</code>
+   BOOST_CONTAINER_NODISCARD
    inline static pointer allocate(Allocator &a, size_type n, const_void_pointer p)
    {
       const bool value = boost::container::dtl::
@@ -453,6 +469,7 @@ struct allocator_traits
 
    //! <b>Returns</b>: <code>a.max_size()</code> if that expression is well-formed; otherwise,
    //! <code>numeric_limits<size_type>::max()</code>.
+   BOOST_CONTAINER_NODISCARD
    inline static size_type max_size(const Allocator &a) BOOST_NOEXCEPT_OR_NOTHROW
    {
       const bool value = allocator_traits_detail::has_max_size<Allocator, size_type (Allocator::*)() const>::value;
@@ -474,6 +491,17 @@ struct allocator_traits
       return allocator_traits::priv_select_on_container_copy_construction(flag, a);
    }
 
+   #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
+   //! <b>Effects</b>: calls <code>a.construct(p)</code> if that call is well-formed;
+   //! otherwise, invokes <code>`placement new` (static_cast<void*>(p)) T()</code>
+   //! 
+   //! <b>Note</b>: Non-standard extension .
+   template <class T>
+   inline static void construct(Allocator & a, T* p, const value_init_t &)
+   {  allocator_traits::construct(a, p);  }
+
+   #endif
+
    #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
       //! <b>Effects</b>: calls <code>a.construct(p, std::forward<Args>(args)...)</code> if that call is well-formed;
       //! otherwise, invokes <code>`placement new` (static_cast<void*>(p)) T(std::forward<Args>(args)...)</code>
@@ -669,6 +697,10 @@ struct allocator_traits
    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; }
 
+   template<class T>
+   inline static void priv_construct(dtl::false_type, Allocator &, T *p, const ::boost::container::value_init_t&)
+   {  ::new((void*)p, boost_container_new_t()) T(); }
+
    inline static bool priv_storage_is_unpropagable(dtl::true_type, const Allocator &a, pointer p)
    {  return a.storage_is_unpropagable(p);  }
 

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

@@ -29,6 +29,8 @@
 //!   - boost::container::small_vector_base
 //!   - boost::container::small_vector
 //!   - boost::container::devector
+//!   - boost::container::deque
+//!   - boost::container::segtor
 //!   - boost::container::slist
 //!   - boost::container::list
 //!   - boost::container::set
@@ -132,6 +134,11 @@ template <class T
          ,class Options   = void>
 class deque;
 
+template <class T
+         ,class Allocator = void
+         ,class Options   = void>
+class segtor;
+
 template <class T
          ,class Allocator = void >
 class list;
@@ -140,6 +147,10 @@ template <class T
          ,class Allocator = void >
 class slist;
 
+template <class T
+         ,class Allocator = void >
+class hub;
+
 template <class Key
          ,class Compare  = std::less<Key>
          ,class Allocator = void
@@ -272,8 +283,9 @@ struct small_flat_multimap_of
 };
 
 template <class CharT
-         ,class Traits = std::char_traits<CharT>
-         ,class Allocator  = void >
+         ,class Traits     = std::char_traits<CharT>
+         ,class Allocator  = void
+         ,class Options    = void >
 class basic_string;
 
 typedef basic_string <char>   string;