passenger 6.0.22 → 6.0.24

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

@@ -23,7 +23,7 @@
 #pragma once
 #endif
 
-#if defined(__linux__) || defined(__OpenBSD__) || defined(__NETBSD__) || defined(__NetBSD__)
+#if defined(__linux__) || defined(__NETBSD__) || defined(__NetBSD__)
 
 #include <sys/syscall.h>
 
@@ -45,7 +45,21 @@
 #define BOOST_ATOMIC_DETAIL_NETBSD_FUTEX
 #endif
 
-#if defined(BOOST_ATOMIC_DETAIL_SYS_FUTEX)
+#elif defined(__OpenBSD__)
+
+// OpenBSD provides futex(2) function wrapper since OpenBSD 6.2 (https://man.openbsd.org/OpenBSD-6.2/futex.2).
+// It has also removed syscall(2) interface:
+// https://github.com/openbsd/src/commit/cafeb892b121ee89c39c2b940e8ccd6950f50009
+
+#include <sys/param.h>
+
+#if OpenBSD >= 201711
+#define BOOST_ATOMIC_DETAIL_OPENBSD_FUTEX
+#endif
+
+#endif
+
+#if defined(BOOST_ATOMIC_DETAIL_SYS_FUTEX) || defined(BOOST_ATOMIC_DETAIL_OPENBSD_FUTEX)
 
 #include <cstddef>
 #if defined(__linux__)
@@ -53,6 +67,7 @@
 #else
 #include <sys/futex.h>
 #endif
+#include <boost/cstdint.hpp>
 #include <boost/atomic/detail/intptr.hpp>
 #include <boost/atomic/detail/header.hpp>
 
@@ -74,22 +89,40 @@ namespace detail {
 //! Invokes an operation on the futex
 BOOST_FORCEINLINE int futex_invoke(void* addr1, int op, unsigned int val1, const void* timeout = NULL, void* addr2 = NULL, unsigned int val3 = 0) BOOST_NOEXCEPT
 {
-#if !defined(BOOST_ATOMIC_DETAIL_NETBSD_FUTEX)
-    return ::syscall(BOOST_ATOMIC_DETAIL_SYS_FUTEX, addr1, op, val1, timeout, addr2, val3);
-#else
+#if defined(BOOST_ATOMIC_DETAIL_OPENBSD_FUTEX)
+    return ::futex
+    (
+        static_cast< volatile uint32_t* >(addr1),
+        op,
+        static_cast< int >(val1),
+        static_cast< const struct timespec* >(timeout),
+        static_cast< volatile uint32_t* >(addr2)
+    );
+#elif defined(BOOST_ATOMIC_DETAIL_NETBSD_FUTEX)
     // Pass 0 in val2.
     return ::syscall(BOOST_ATOMIC_DETAIL_SYS_FUTEX, addr1, op, val1, timeout, addr2, 0u, val3);
+#else
+    return ::syscall(BOOST_ATOMIC_DETAIL_SYS_FUTEX, addr1, op, val1, timeout, addr2, val3);
 #endif
 }
 
 //! Invokes an operation on the futex
 BOOST_FORCEINLINE int futex_invoke(void* addr1, int op, unsigned int val1, unsigned int val2, void* addr2 = NULL, unsigned int val3 = 0) BOOST_NOEXCEPT
 {
-#if !defined(BOOST_ATOMIC_DETAIL_NETBSD_FUTEX)
-    return ::syscall(BOOST_ATOMIC_DETAIL_SYS_FUTEX, addr1, op, val1, static_cast< atomics::detail::uintptr_t >(val2), addr2, val3);
-#else
+#if defined(BOOST_ATOMIC_DETAIL_OPENBSD_FUTEX)
+    return ::futex
+    (
+        static_cast< volatile uint32_t* >(addr1),
+        op,
+        static_cast< int >(val1),
+        reinterpret_cast< const struct timespec* >(static_cast< atomics::detail::uintptr_t >(val2)),
+        static_cast< volatile uint32_t* >(addr2)
+    );
+#elif defined(BOOST_ATOMIC_DETAIL_NETBSD_FUTEX)
     // Pass NULL in timeout.
     return ::syscall(BOOST_ATOMIC_DETAIL_SYS_FUTEX, addr1, op, val1, static_cast< void* >(NULL), addr2, val2, val3);
+#else
+    return ::syscall(BOOST_ATOMIC_DETAIL_SYS_FUTEX, addr1, op, val1, static_cast< atomics::detail::uintptr_t >(val2), addr2, val3);
 #endif
 }
 
@@ -147,8 +180,6 @@ BOOST_FORCEINLINE int futex_requeue_private(void* pval1, void* pval2, unsigned i
 
 #include <boost/atomic/detail/footer.hpp>
 
-#endif // defined(BOOST_ATOMIC_DETAIL_SYS_FUTEX)
-
-#endif // defined(__linux__) || defined(__OpenBSD__) || defined(__NETBSD__) || defined(__NetBSD__)
+#endif // defined(BOOST_ATOMIC_DETAIL_SYS_FUTEX) || defined(BOOST_ATOMIC_DETAIL_OPENBSD_FUTEX)
 
 #endif // BOOST_ATOMIC_DETAIL_FUTEX_HPP_INCLUDED_

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

@@ -737,44 +737,18 @@ template<class F, class... A>
 namespace _bi
 {
 
-template< class Pm, int I > struct add_cref;
+template<class M, int I> struct add_cref;
 
-template< class M, class T > struct add_cref< M T::*, 0 >
+template<class M> struct add_cref<M, 0>
 {
     typedef M type;
 };
 
-template< class M, class T > struct add_cref< M T::*, 1 >
+template<class M> struct add_cref<M, 1>
 {
-#ifdef BOOST_MSVC
-#pragma warning(push)
-#pragma warning(disable:4180)
-#endif
-    typedef M const & type;
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-};
-
-template< class R, class T > struct add_cref< R (T::*) (), 1 >
-{
-    typedef void type;
-};
-
-template< class R, class T > struct add_cref< R (T::*) () const, 1 >
-{
-    typedef void type;
-};
-
-#if defined( __cpp_noexcept_function_type ) || defined( _NOEXCEPT_TYPES_SUPPORTED )
-
-template< class R, class T > struct add_cref< R (T::*) () const noexcept, 1 >
-{
-    typedef void type;
+    typedef M const& type;
 };
 
-#endif // __cpp_noexcept_function_type
-
 template<class R> struct isref
 {
     enum value_type { value = 0 };
@@ -790,30 +764,34 @@ template<class R> struct isref< R* >
     enum value_type { value = 1 };
 };
 
-template<class Pm, class A1> struct dm_result
+template<class M, class A1, bool fn = std::is_function<M>::value> struct dm_result
+{
+};
+
+template<class M, class A1> struct dm_result<M, A1, false>
 {
-    typedef typename add_cref< Pm, 1 >::type type;
+    typedef typename add_cref< M, 1 >::type type;
 };
 
-template<class Pm, class R, class F, class L> struct dm_result< Pm, bind_t<R, F, L> >
+template<class M, class R, class F, class L> struct dm_result<M, bind_t<R, F, L>, false>
 {
     typedef typename bind_t<R, F, L>::result_type result_type;
-    typedef typename add_cref< Pm, isref< result_type >::value >::type type;
+    typedef typename add_cref< M, isref< result_type >::value >::type type;
 };
 
 } // namespace _bi
 
-template< class A1, class M, class T >
+template<class A1, class M, class T>
 
 _bi::bind_t<
-    typename _bi::dm_result< M T::*, A1 >::type,
+    typename _bi::dm_result<M, A1>::type,
     _mfi::dm<M, T>,
     typename _bi::list_av<A1>::type
 >
 
 BOOST_BIND( M T::*f, A1 a1 )
 {
-    typedef typename _bi::dm_result< M T::*, A1 >::type result_type;
+    typedef typename _bi::dm_result<M, A1>::type result_type;
     typedef _mfi::dm<M, T> F;
     typedef typename _bi::list_av<A1>::type list_type;
     return _bi::bind_t< result_type, F, list_type >( F( f ), list_type( a1 ) );

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

@@ -71,10 +71,10 @@ class adaptive_pool
          BOOST_CONTAINER_DOCIGN(BOOST_MOVE_I Version)
          >   self_t;
 
-   static const std::size_t nodes_per_block        = NodesPerBlock;
-   static const std::size_t max_free_blocks        = MaxFreeBlocks;
-   static const std::size_t overhead_percent       = OverheadPercent;
-   static const std::size_t real_nodes_per_block   = NodesPerBlock;
+   BOOST_STATIC_CONSTEXPR std::size_t nodes_per_block        = NodesPerBlock;
+   BOOST_STATIC_CONSTEXPR std::size_t max_free_blocks        = MaxFreeBlocks;
+   BOOST_STATIC_CONSTEXPR std::size_t overhead_percent       = OverheadPercent;
+   BOOST_STATIC_CONSTEXPR std::size_t real_nodes_per_block   = NodesPerBlock;
 
    BOOST_CONTAINER_DOCIGN(BOOST_CONTAINER_STATIC_ASSERT((Version <=2)));
 
@@ -384,10 +384,10 @@ class private_adaptive_pool
          BOOST_CONTAINER_DOCIGN(BOOST_MOVE_I Version)
          >   self_t;
 
-   static const std::size_t nodes_per_block        = NodesPerBlock;
-   static const std::size_t max_free_blocks        = MaxFreeBlocks;
-   static const std::size_t overhead_percent       = OverheadPercent;
-   static const std::size_t real_nodes_per_block   = NodesPerBlock;
+   BOOST_STATIC_CONSTEXPR std::size_t nodes_per_block        = NodesPerBlock;
+   BOOST_STATIC_CONSTEXPR std::size_t max_free_blocks        = MaxFreeBlocks;
+   BOOST_STATIC_CONSTEXPR std::size_t overhead_percent       = OverheadPercent;
+   BOOST_STATIC_CONSTEXPR std::size_t real_nodes_per_block   = NodesPerBlock;
 
    BOOST_CONTAINER_DOCIGN(BOOST_CONTAINER_STATIC_ASSERT((Version <=2)));
 

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

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

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

@@ -32,6 +32,8 @@
 #include <boost/container/detail/mpl.hpp>
 #include <boost/container/detail/type_traits.hpp>  //is_empty
 #include <boost/container/detail/placement_new.hpp>
+#include <boost/container/detail/is_pair.hpp>
+#include <boost/container/detail/addressof.hpp>
 #ifndef BOOST_CONTAINER_DETAIL_STD_FWD_HPP
 #include <boost/container/detail/std_fwd.hpp>
 #endif
@@ -47,9 +49,10 @@
 
 #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
-#if defined(BOOST_GCC) && (BOOST_GCC >= 40600)
+#if defined(BOOST_CONTAINER_GCC_COMPATIBLE_HAS_DIAGNOSTIC_IGNORED)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wunused-result"
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 #endif
 
 #define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME allocate
@@ -73,7 +76,7 @@
 #define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX 9
 #include <boost/intrusive/detail/has_member_function_callable_with.hpp>
 
-#if defined(BOOST_GCC) && (BOOST_GCC >= 40600)
+#if defined(BOOST_CONTAINER_GCC_COMPATIBLE_HAS_DIAGNOSTIC_IGNORED)
 #pragma GCC diagnostic pop
 #endif
 
@@ -81,6 +84,144 @@
 
 namespace boost {
 namespace container {
+namespace dtl {
+
+#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)
+{
+   ::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
+}
+
+#else
+
+#define BOOST_CONTAINER_ALLOCATOR_TRAITS_CONSTRUCT_TYPEJ(N) \
+template<class T BOOST_MOVE_I##N BOOST_MOVE_CLASS##N>\
+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 );\
+}\
+//
+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)
+{
+   dtl::construct_type(dtl::addressof(p->first));
+   BOOST_CONTAINER_TRY{
+      dtl::construct_type(dtl::addressof(p->second));
+   }
+   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 U>
+inline
+typename dtl::enable_if_c
+   <  dtl::is_pair<T>::value
+   , void >::type
+construct_type(T* p, U &u)
+{
+   dtl::construct_type(dtl::addressof(p->first), u.first);
+   BOOST_CONTAINER_TRY{
+      dtl::construct_type(dtl::addressof(p->second), u.second);
+   }
+   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 U>
+inline
+typename dtl::enable_if_c
+   <  dtl::is_pair<typename dtl::remove_reference<T>::type>::value &&
+      !boost::move_detail::is_reference<U>::value  //This is needed for MSVC10 and ambiguous overloads
+   , void >::type
+construct_type(T* p, BOOST_RV_REF(U) u)
+{
+   dtl::construct_type(dtl::addressof(p->first), ::boost::move(u.first));
+   BOOST_CONTAINER_TRY{
+      dtl::construct_type(dtl::addressof(p->second), ::boost::move(u.second));
+   }
+   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 U, class V>
+inline
+typename dtl::enable_if<dtl::is_pair<T>, void >::type
+construct_type(T* p, BOOST_FWD_REF(U) x, BOOST_FWD_REF(V) y)
+{
+   dtl::construct_type(dtl::addressof(p->first), ::boost::forward<U>(x));
+   BOOST_CONTAINER_TRY{
+      dtl::construct_type(dtl::addressof(p->second), ::boost::forward<V>(y));
+   }
+   BOOST_CONTAINER_CATCH(...) {
+      typedef typename T::first_type first_type;
+      dtl::addressof(p->first)->~first_type();
+      BOOST_CONTAINER_RETHROW
+   }
+   BOOST_CONTAINER_CATCH_END
+}
+
+}  //namespace dtl
 
 #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
@@ -100,19 +241,19 @@ namespace dtl {
 //supporting rvalue references
 template<class Allocator>
 struct is_std_allocator
-{  static const bool value = false; };
+{  BOOST_STATIC_CONSTEXPR bool value = false; };
 
 template<class T>
 struct is_std_allocator< std::allocator<T> >
-{  static const bool value = true; };
+{  BOOST_STATIC_CONSTEXPR bool value = true; };
 
 template<class T, class Options>
 struct is_std_allocator< small_vector_allocator<T, std::allocator<T>, Options > >
-{  static const bool value = true; };
+{  BOOST_STATIC_CONSTEXPR bool value = true; };
 
 template<class Allocator>
 struct is_not_std_allocator
-{  static const bool value = !is_std_allocator<Allocator>::value; };
+{  BOOST_STATIC_CONSTEXPR bool value = !is_std_allocator<Allocator>::value; };
 
 BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(pointer)
 BOOST_INTRUSIVE_INSTANTIATE_EVAL_DEFAULT_TYPE_TMPLT(const_pointer)
@@ -358,7 +499,7 @@ struct allocator_traits
       template <class T, class ...Args>
       inline static void construct(Allocator & a, T* p, BOOST_FWD_REF(Args)... args)
       {
-         static const bool value = ::boost::move_detail::and_
+         BOOST_STATIC_CONSTEXPR bool value = ::boost::move_detail::and_
             < dtl::is_not_std_allocator<Allocator>
             , boost::container::dtl::has_member_function_callable_with_construct
                   < Allocator, T*, Args... >
@@ -419,7 +560,7 @@ struct allocator_traits
 
       template<class T, class ...Args>
       inline static void priv_construct(dtl::false_type, Allocator &, T *p, BOOST_FWD_REF(Args) ...args)
-      {  ::new((void*)p, boost_container_new_t()) T(::boost::forward<Args>(args)...); }
+      {  dtl::construct_type(p, ::boost::forward<Args>(args)...); }
    #else // #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
       public:
 
@@ -427,7 +568,7 @@ struct allocator_traits
       template<class T BOOST_MOVE_I##N BOOST_MOVE_CLASS##N >\
       inline static void construct(Allocator &a, T *p BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
       {\
-         static const bool value = ::boost::move_detail::and_ \
+         BOOST_STATIC_CONSTEXPR bool value = ::boost::move_detail::and_ \
             < dtl::is_not_std_allocator<Allocator> \
             , boost::container::dtl::has_member_function_callable_with_construct \
                   < Allocator, T* BOOST_MOVE_I##N BOOST_MOVE_FWD_T##N > \
@@ -450,7 +591,7 @@ struct allocator_traits
       \
       template<class T BOOST_MOVE_I##N BOOST_MOVE_CLASS##N >\
       inline static void priv_construct(dtl::false_type, Allocator &, T *p BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
-      {  ::new((void*)p, boost_container_new_t()) T(BOOST_MOVE_FWD##N); }\
+      {  dtl::construct_type(p BOOST_MOVE_I##N BOOST_MOVE_FWD##N); }\
       //
       BOOST_MOVE_ITERATE_0TO8(BOOST_CONTAINER_ALLOCATOR_TRAITS_PRIV_CONSTRUCT_IMPL)
       #undef BOOST_CONTAINER_ALLOCATOR_TRAITS_PRIV_CONSTRUCT_IMPL

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

@@ -15,6 +15,8 @@
 #  include <boost/config.hpp>
 #endif
 
+#include <boost/container/detail/workaround.hpp>
+
 #if defined(BOOST_HAS_PRAGMA_ONCE)
 #  pragma once
 #endif
@@ -277,10 +279,10 @@ class basic_string;
 typedef basic_string <char>   string;
 typedef basic_string<wchar_t> wstring;
 
-static const std::size_t ADP_nodes_per_block    = 256u;
-static const std::size_t ADP_max_free_blocks    = 2u;
-static const std::size_t ADP_overhead_percent   = 1u;
-static const std::size_t ADP_only_alignment     = 0u;
+BOOST_STATIC_CONSTEXPR std::size_t ADP_nodes_per_block    = 256u;
+BOOST_STATIC_CONSTEXPR std::size_t ADP_max_free_blocks    = 2u;
+BOOST_STATIC_CONSTEXPR std::size_t ADP_overhead_percent   = 1u;
+BOOST_STATIC_CONSTEXPR std::size_t ADP_only_alignment     = 0u;
 
 template < class T
          , std::size_t NodesPerBlock   = ADP_nodes_per_block
@@ -295,7 +297,7 @@ template < class T
          , unsigned int AllocationDisableMask = 0>
 class allocator;
 
-static const std::size_t NodeAlloc_nodes_per_block = 256u;
+BOOST_STATIC_CONSTEXPR std::size_t NodeAlloc_nodes_per_block = 256u;
 
 template
    < class T
@@ -332,7 +334,7 @@ struct ordered_range_t
 
 //! Value used to tag that the input range is
 //! guaranteed to be ordered
-static const ordered_range_t ordered_range = ordered_range_t();
+BOOST_CONTAINER_CONSTANT_VAR ordered_range_t ordered_range = ordered_range_t();
 
 //! Type used to tag that the input range is
 //! guaranteed to be ordered and unique
@@ -342,7 +344,7 @@ struct ordered_unique_range_t
 
 //! Value used to tag that the input range is
 //! guaranteed to be ordered and unique
-static const ordered_unique_range_t ordered_unique_range = ordered_unique_range_t();
+BOOST_CONTAINER_CONSTANT_VAR ordered_unique_range_t ordered_unique_range = ordered_unique_range_t();
 
 //! Type used to tag that the inserted values
 //! should be default initialized
@@ -351,7 +353,7 @@ struct default_init_t
 
 //! Value used to tag that the inserted values
 //! should be default initialized
-static const default_init_t default_init = default_init_t();
+BOOST_CONTAINER_CONSTANT_VAR default_init_t default_init = default_init_t();
 #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
 //! Type used to tag that the inserted values
@@ -361,7 +363,7 @@ struct value_init_t
 
 //! Value used to tag that the inserted values
 //! should be value initialized
-static const value_init_t value_init = value_init_t();
+BOOST_CONTAINER_CONSTANT_VAR value_init_t value_init = value_init_t();
 
 namespace container_detail_really_deep_namespace {