passenger 6.0.8 → 6.0.9

data/src/cxx_supportlib/vendor-modified/boost/move/algo/detail/merge.hpp

@@ -11,6 +11,7 @@
 #ifndef BOOST_MOVE_MERGE_HPP
 #define BOOST_MOVE_MERGE_HPP
 
+#include <boost/core/ignore_unused.hpp>
 #include <boost/move/algo/move.hpp>
 #include <boost/move/adl_move_swap.hpp>
 #include <boost/move/algo/detail/basic_op.hpp>
@@ -680,7 +681,7 @@ void op_merge_with_right_placed
       if (r_first == r_last) {
          InputOutIterator end = op(forward_t(), first, last, dest_first);
          BOOST_ASSERT(end == r_last);
-         (void)end;
+         boost::ignore_unused(end);
          return;
       }
       else if (comp(*r_first, *first)) {
@@ -717,7 +718,7 @@ void op_merge_with_left_placed
       if(first == last) {
          BidirOutIterator res = op(backward_t(), r_first, r_last, dest_last);
          BOOST_ASSERT(last == res);
-         (void)res;
+         boost::ignore_unused(res);
          return;
       }
       --r_last;
@@ -781,7 +782,7 @@ void uninitialized_merge_with_right_placed
          d.release();
          InputOutIterator end = ::boost::move(first, last, original_r_first);
          BOOST_ASSERT(end == r_last);
-         (void)end;
+         boost::ignore_unused(end);
          return;
       }
       else if (comp(*r_first, *first)) {
@@ -800,51 +801,6 @@ void uninitialized_merge_with_right_placed
    merge_with_right_placed(first, last, original_r_first, r_first, r_last, comp);
 }
 
-/*
-// [r_first, r_last) are already in the right part of the destination range.
-// [dest_first, r_first) is uninitialized memory
-template <class Compare, class BidirOutIterator, class BidirIterator>
-void uninitialized_merge_with_left_placed
-   ( BidirOutIterator dest_first, BidirOutIterator r_first, BidirOutIterator r_last
-   , BidirIterator first, BidirIterator last
-   , Compare comp)
-{
-   BOOST_ASSERT((last - first) == (r_last - r_first));
-   typedef typename iterator_traits<BidirOutIterator>::value_type value_type;
-   BidirOutIterator const original_r_last = r_last;
-
-   destruct_n<value_type> d(&*dest_last);
-
-   while ( first != last && dest_first != original_r_first ) {
-      if (r_first == r_last) {
-         for(; dest_first != original_r_first; ++dest_first, ++first){
-            ::new(&*dest_first) value_type(::boost::move(*first));
-            d.incr();
-         }
-         d.release();
-         BidirOutIterator end = ::boost::move(first, last, original_r_first);
-         BOOST_ASSERT(end == r_last);
-         (void)end;
-         return;
-      }
-      else if (comp(*r_first, *first)) {
-         ::new(&*dest_first) value_type(::boost::move(*r_first));
-         d.incr();
-         ++r_first;
-      }
-      else {
-         ::new(&*dest_first) value_type(::boost::move(*first));
-         d.incr();
-         ++first;
-      }
-      ++dest_first;
-   }
-   d.release();
-   merge_with_right_placed(first, last, original_r_first, r_first, r_last, comp);
-}
-*/
-
-
 /// This is a helper function for the merge routines.
 template<typename BidirectionalIterator1, typename BidirectionalIterator2>
    BidirectionalIterator1

data/src/cxx_supportlib/vendor-modified/boost/move/default_delete.hpp

@@ -112,6 +112,33 @@ void call_delete(T *p, is_array_del<false>)
    delete p;
 }
 
+template< class T, class U
+        , bool enable =  def_del_compatible_cond< U, T>::value &&
+                        !move_upmu::is_array<T>::value &&
+                        !move_upmu::is_same<typename move_upmu::remove_cv<T>::type, void>::value &&
+                        !move_upmu::is_same<typename move_upmu::remove_cv<U>::type, typename move_upmu::remove_cv<T>::type>::value
+        >
+struct missing_virtual_destructor_default_delete
+{  static const bool value = !move_upmu::has_virtual_destructor<T>::value;  };
+
+template<class T, class U>
+struct missing_virtual_destructor_default_delete<T, U, false>
+{  static const bool value = false;  };
+
+//////////////////////////////////////
+//       missing_virtual_destructor
+//////////////////////////////////////
+
+template<class Deleter, class U>
+struct missing_virtual_destructor
+{  static const bool value = false;  };
+
+template<class T, class U>
+struct missing_virtual_destructor< ::boost::movelib::default_delete<T>, U >
+   : missing_virtual_destructor_default_delete<T, U>
+{};
+
+
 }  //namespace move_upd {
 // @endcond
 
@@ -163,7 +190,7 @@ struct default_delete
    {
       //If T is not an array type, U derives from T
       //and T has no virtual destructor, then you have a problem
-      BOOST_STATIC_ASSERT(( !::boost::move_upmu::missing_virtual_destructor<default_delete, U>::value ));
+      BOOST_STATIC_ASSERT(( !bmupd::missing_virtual_destructor<default_delete, U>::value ));
    }
 
    //! <b>Effects</b>: Constructs a default_delete object from another <tt>default_delete<U></tt> object.
@@ -178,7 +205,7 @@ struct default_delete
    {
       //If T is not an array type, U derives from T
       //and T has no virtual destructor, then you have a problem
-      BOOST_STATIC_ASSERT(( !::boost::move_upmu::missing_virtual_destructor<default_delete, U>::value ));
+      BOOST_STATIC_ASSERT(( !bmupd::missing_virtual_destructor<default_delete, U>::value ));
       return *this;
    }
 
@@ -198,7 +225,7 @@ struct default_delete
       BOOST_STATIC_ASSERT(sizeof(U) > 0);
       //If T is not an array type, U derives from T
       //and T has no virtual destructor, then you have a problem
-      BOOST_STATIC_ASSERT(( !::boost::move_upmu::missing_virtual_destructor<default_delete, U>::value ));
+      BOOST_STATIC_ASSERT(( !bmupd::missing_virtual_destructor<default_delete, U>::value ));
       element_type * const p = static_cast<element_type*>(ptr);
       move_upd::call_delete(p, move_upd::is_array_del<bmupmu::is_array<T>::value>());
    }

data/src/cxx_supportlib/vendor-modified/boost/move/detail/fwd_macros.hpp

@@ -336,6 +336,18 @@ namespace move_detail {
 #define BOOST_MOVE_VAL_INITQ8 BOOST_MOVE_VAL_INITQ7, m_q7(q7)
 #define BOOST_MOVE_VAL_INITQ9 BOOST_MOVE_VAL_INITQ8, m_q8(q8)
 
+//BOOST_MOVE_UREFANONN
+#define BOOST_MOVE_UREFANON0
+#define BOOST_MOVE_UREFANON1                       BOOST_FWD_REF(P0)
+#define BOOST_MOVE_UREFANON2 BOOST_MOVE_UREFANON1, BOOST_FWD_REF(P1)
+#define BOOST_MOVE_UREFANON3 BOOST_MOVE_UREFANON2, BOOST_FWD_REF(P2)
+#define BOOST_MOVE_UREFANON4 BOOST_MOVE_UREFANON3, BOOST_FWD_REF(P3)
+#define BOOST_MOVE_UREFANON5 BOOST_MOVE_UREFANON4, BOOST_FWD_REF(P4)
+#define BOOST_MOVE_UREFANON6 BOOST_MOVE_UREFANON5, BOOST_FWD_REF(P5)
+#define BOOST_MOVE_UREFANON7 BOOST_MOVE_UREFANON6, BOOST_FWD_REF(P6)
+#define BOOST_MOVE_UREFANON8 BOOST_MOVE_UREFANON7, BOOST_FWD_REF(P7)
+#define BOOST_MOVE_UREFANON9 BOOST_MOVE_UREFANON8, BOOST_FWD_REF(P8)
+
 //BOOST_MOVE_UREFN
 #define BOOST_MOVE_UREF0
 #define BOOST_MOVE_UREF1                   BOOST_FWD_REF(P0) p0

data/src/cxx_supportlib/vendor-modified/boost/move/detail/nsec_clock.hpp

@@ -0,0 +1,224 @@
+//  This code is based on Timer and Chrono code. Thanks to authors:
+//
+//  Boost.Timer:
+//  Copyright Beman Dawes 1994-2007, 2011
+//
+//  Boost.Chrono:
+//  Copyright Beman Dawes 2008
+//  Copyright 2009-2010 Vicente J. Botet Escriba
+//
+//  Simplified and modified to be able to support exceptionless (-fno-exceptions).
+//  Boost.Timer depends on Boost.Chorno wich uses boost::throw_exception.
+//  And Boost.Chrono DLLs don't build in Win32 as there is no 
+//  boost::throw_exception(std::exception const&) implementation
+//  in Boost.Chrono:
+//
+//  Copyright 2020 Ion Gaztanaga
+//
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+//----------------------------------------------------------------------------//
+//                                Windows                                     //
+//----------------------------------------------------------------------------//
+#ifndef BOOST_MOVE_DETAIL_NSEC_CLOCK_HPP
+#define BOOST_MOVE_DETAIL_NSEC_CLOCK_HPP
+
+#include <boost/config.hpp>
+#include <boost/cstdint.hpp>
+#include <cstdlib>
+
+
+#   if (defined(_WIN32) || defined(__WIN32__) || defined(WIN32))
+#     define BOOST_MOVE_DETAIL_WINDOWS_API
+#   elif defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__)
+#     define BOOST_MOVE_DETAIL_MAC_API
+#   else
+#     define BOOST_MOVE_DETAIL_POSIX_API
+#   endif
+
+#if defined(BOOST_MOVE_DETAIL_WINDOWS_API)
+
+#include <boost/winapi/time.hpp>
+#include <boost/winapi/timers.hpp>
+#include <boost/winapi/get_last_error.hpp>
+#include <boost/winapi/error_codes.hpp>
+#include <boost/assert.hpp>
+#include <boost/core/ignore_unused.hpp>
+
+namespace boost { namespace move_detail {
+
+template<int Dummy>
+struct QPFHolder
+{
+   static inline double get_nsec_per_tic()
+   {
+      boost::winapi::LARGE_INTEGER_ freq;
+      boost::winapi::BOOL_ r = boost::winapi::QueryPerformanceFrequency( &freq );
+      boost::ignore_unused(r);
+      BOOST_ASSERT(r != 0 && "Boost::Move - get_nanosecs_per_tic Internal Error");
+
+      return double(1000000000.0L / freq.QuadPart);
+   }
+
+   static const double nanosecs_per_tic;
+};
+
+template<int Dummy>
+const double QPFHolder<Dummy>::nanosecs_per_tic = get_nsec_per_tic();
+
+inline boost::uint64_t nsec_clock() BOOST_NOEXCEPT
+{
+   double nanosecs_per_tic = QPFHolder<0>::nanosecs_per_tic;
+   
+   boost::winapi::LARGE_INTEGER_ pcount;
+   unsigned times=0;
+   while ( !boost::winapi::QueryPerformanceCounter( &pcount ) )
+   {
+      if ( ++times > 3 )
+      {
+         BOOST_ASSERT("Boost::Move - QueryPerformanceCounter Internal Error");
+         return 0u;
+      }
+   }
+
+   return static_cast<boost::uint64_t>((nanosecs_per_tic) * pcount.QuadPart);
+}
+
+}}  //namespace boost { namespace move_detail {
+
+#elif defined(BOOST_MOVE_DETAIL_MAC_API)
+
+#include <mach/mach_time.h>  // mach_absolute_time, mach_timebase_info_data_t
+
+inline boost::uint64_t nsec_clock() BOOST_NOEXCEPT
+{
+   boost::uint64_t count = ::mach_absolute_time();
+
+   mach_timebase_info_data_t info;
+   mach_timebase_info(&info);
+   return static_cast<boost::uint64_t>
+      (  static_cast<double>(count)*(static_cast<double>(info.numer) / info.denom);
+}
+
+#elif defined(BOOST_MOVE_DETAIL_POSIX_API)
+
+#include <time.h>
+
+#  if defined(CLOCK_MONOTONIC_PRECISE)   //BSD
+#     define BOOST_MOVE_DETAIL_CLOCK_MONOTONIC CLOCK_MONOTONIC_PRECISE
+#  elif defined(CLOCK_MONOTONIC_RAW)     //Linux
+#     define BOOST_MOVE_DETAIL_CLOCK_MONOTONIC CLOCK_MONOTONIC_RAW
+#  elif defined(CLOCK_HIGHRES)           //Solaris
+#     define BOOST_MOVE_DETAIL_CLOCK_MONOTONIC CLOCK_HIGHRES
+#  elif defined(CLOCK_MONOTONIC)         //POSIX (AIX, BSD, Linux, Solaris)
+#     define BOOST_MOVE_DETAIL_CLOCK_MONOTONIC CLOCK_MONOTONIC
+#  else
+#     error "No high resolution steady clock in your system, please provide a patch"
+#  endif
+
+inline boost::uint64_t nsec_clock() BOOST_NOEXCEPT
+{
+   struct timespec count;
+   ::clock_gettime(BOOST_MOVE_DETAIL_CLOCK_MONOTONIC, &count);
+   boost::uint64_t r = count.tv_sec;
+   r *= 1000000000U;
+   r += count.tv_nsec;
+   return r;
+}
+
+#endif  // POSIX
+
+namespace boost { namespace move_detail {
+
+typedef boost::uint64_t nanosecond_type;
+
+struct cpu_times
+{
+   nanosecond_type wall;
+   nanosecond_type user;
+   nanosecond_type system;
+
+   void clear() { wall = user = system = 0; }
+};
+
+
+inline void get_cpu_times(boost::move_detail::cpu_times& current)
+{
+    current.wall = nsec_clock();
+}
+
+
+class cpu_timer
+{
+   public:
+
+      //  constructor
+      cpu_timer() BOOST_NOEXCEPT                                   { start(); }
+
+      //  observers
+      bool          is_stopped() const BOOST_NOEXCEPT              { return m_is_stopped; }
+      cpu_times     elapsed() const BOOST_NOEXCEPT;  // does not stop()
+
+      //  actions
+      void          start() BOOST_NOEXCEPT;
+      void          stop() BOOST_NOEXCEPT;
+      void          resume() BOOST_NOEXCEPT; 
+
+   private:
+      cpu_times     m_times;
+      bool          m_is_stopped;
+};
+
+
+//  cpu_timer  ---------------------------------------------------------------------//
+
+inline void cpu_timer::start() BOOST_NOEXCEPT
+{
+   m_is_stopped = false;
+   get_cpu_times(m_times);
+}
+
+inline void cpu_timer::stop() BOOST_NOEXCEPT
+{
+   if (is_stopped())
+      return;
+   m_is_stopped = true;
+      
+   cpu_times current;
+   get_cpu_times(current);
+   m_times.wall = (current.wall - m_times.wall);
+   m_times.user = (current.user - m_times.user);
+   m_times.system = (current.system - m_times.system);
+}
+
+inline cpu_times cpu_timer::elapsed() const BOOST_NOEXCEPT
+{
+   if (is_stopped())
+      return m_times;
+   cpu_times current;
+   get_cpu_times(current);
+   current.wall -= m_times.wall;
+   current.user -= m_times.user;
+   current.system -= m_times.system;
+   return current;
+}
+
+inline void cpu_timer::resume() BOOST_NOEXCEPT
+{
+   if (is_stopped())
+   {
+      cpu_times current (m_times);
+      start();
+      m_times.wall   -= current.wall;
+      m_times.user   -= current.user;
+      m_times.system -= current.system;
+   }
+}
+
+
+
+}  // namespace move_detail
+}  // namespace boost
+
+#endif   //BOOST_MOVE_DETAIL_NSEC_CLOCK_HPP

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

@@ -65,6 +65,8 @@
 // BOOST_MOVE_HAS_NOTHROW_COPY(T) should evaluate to true if T(t) can not throw
 // BOOST_MOVE_HAS_NOTHROW_ASSIGN(T) should evaluate to true if t = u can not throw
 // BOOST_MOVE_IS_ENUM(T) should evaluate to true it t is a union type.
+// BOOST_MOVE_HAS_NOTHROW_MOVE_CONSTRUCTOR(T) should evaluate to true if T has a non-throwing move constructor.
+// BOOST_MOVE_HAS_NOTHROW_MOVE_ASSIGN(T) should evaluate to true if T has a non-throwing move assignment operator.
 //
 // The following can also be defined: when detected our implementation is greatly simplified.
 //
@@ -102,51 +104,123 @@
 #       define BOOST_MOVE_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T)   (__has_trivial_move_constructor(T) || ::boost::move_detail::is_pod<T>::value)
 #       define BOOST_MOVE_HAS_TRIVIAL_MOVE_ASSIGN(T)        (__has_trivial_move_assign(T) || ::boost::move_detail::is_pod<T>::value)
 #   endif
+#  if _MSC_FULL_VER >= 180020827
+#     define BOOST_MOVE_HAS_NOTHROW_MOVE_ASSIGN(T) (__is_nothrow_assignable(T&, T&&))
+#     define BOOST_MOVE_HAS_NOTHROW_MOVE_CONSTRUCTOR(T) (__is_nothrow_constructible(T, T&&))
+#  endif
 #endif
 
-#if defined(BOOST_CLANG) && defined(__has_feature)
+#if defined(BOOST_CLANG)
+//    BOOST_MOVE_HAS_TRAIT
+#   if defined __is_identifier
+#       define BOOST_MOVE_HAS_TRAIT(T) (__has_extension(T) || !__is_identifier(__##T))
+#   elif defined(__has_extension)
+#     define BOOST_MOVE_HAS_TRAIT(T) __has_extension(T)
+#   else
+#     define BOOST_MOVE_HAS_TRAIT(T) 0
+#   endif
 
-#   if __has_feature(is_union)
+//    BOOST_MOVE_IS_UNION
+#   if BOOST_MOVE_HAS_TRAIT(is_union)
 #     define BOOST_MOVE_IS_UNION(T) __is_union(T)
 #   endif
-#   if (!defined(__GLIBCXX__) || (__GLIBCXX__ >= 20080306 && __GLIBCXX__ != 20080519)) && __has_feature(is_pod)
+
+//    BOOST_MOVE_IS_ENUM
+#   if BOOST_MOVE_HAS_TRAIT(is_enum)
+#     define BOOST_MOVE_IS_ENUM(T) __is_enum(T)
+#   endif
+
+//    BOOST_MOVE_IS_POD
+#   if (!defined(__GLIBCXX__) || (__GLIBCXX__ >= 20080306 && __GLIBCXX__ != 20080519)) && BOOST_MOVE_HAS_TRAIT(is_pod)
 #     define BOOST_MOVE_IS_POD(T) __is_pod(T)
 #   endif
-#   if (!defined(__GLIBCXX__) || (__GLIBCXX__ >= 20080306 && __GLIBCXX__ != 20080519)) && __has_feature(is_empty)
+
+//    BOOST_MOVE_IS_EMPTY
+#   if (!defined(__GLIBCXX__) || (__GLIBCXX__ >= 20080306 && __GLIBCXX__ != 20080519)) && BOOST_MOVE_HAS_TRAIT(is_empty)
 #     define BOOST_MOVE_IS_EMPTY(T) __is_empty(T)
 #   endif
-#   if __has_feature(has_trivial_constructor)
+
+//    BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR
+#   if BOOST_MOVE_HAS_TRAIT(is_constructible) && BOOST_MOVE_HAS_TRAIT(is_trivially_constructible)
+#     define BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T) __is_trivially_constructible(T)
+#   elif BOOST_MOVE_HAS_TRAIT(has_trivial_constructor)
 #     define BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T) __has_trivial_constructor(T)
 #   endif
-#   if __has_feature(has_trivial_copy)
+
+//    BOOST_MOVE_HAS_TRIVIAL_COPY
+#   if BOOST_MOVE_HAS_TRAIT(is_constructible) && BOOST_MOVE_HAS_TRAIT(is_trivially_constructible)
+#     define BOOST_MOVE_HAS_TRIVIAL_COPY(T) (__is_constructible(T, const T &) && __is_trivially_constructible(T, const T &))
+#   elif BOOST_MOVE_HAS_TRAIT(has_trivial_copy)
 #     define BOOST_MOVE_HAS_TRIVIAL_COPY(T) __has_trivial_copy(T)
 #   endif
-#   if __has_feature(has_trivial_assign)
-#     define BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T) (__has_trivial_assign(T) )
+
+//    BOOST_MOVE_HAS_TRIVIAL_ASSIGN
+#   if BOOST_MOVE_HAS_TRAIT(is_assignable) && BOOST_MOVE_HAS_TRAIT(is_trivially_assignable)
+#     define BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T) (__is_assignable(T, const T &) && __is_trivially_assignable(T, const T &))
+#   elif BOOST_MOVE_HAS_TRAIT(has_trivial_copy)
+#     define BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T) __has_trivial_assign(T)
 #   endif
-#   if __has_feature(has_trivial_destructor)
+
+//    BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR
+#   if BOOST_MOVE_HAS_TRAIT(is_trivially_destructible)
+#     define BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T) __is_trivially_destructible(T)
+#   elif BOOST_MOVE_HAS_TRAIT(has_trivial_destructor)
 #     define BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T) __has_trivial_destructor(T)
 #   endif
-#   if __has_feature(has_nothrow_constructor)
+
+//    BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR
+#   if BOOST_MOVE_HAS_TRAIT(is_nothrow_constructible)
+#     define BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR(T) __is_nothrow_constructible(T)
+#   elif BOOST_MOVE_HAS_TRAIT(has_nothrow_constructor)
 #     define BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR(T) __has_nothrow_constructor(T)
 #   endif
-#   if __has_feature(has_nothrow_copy)
+
+//    BOOST_MOVE_HAS_NOTHROW_COPY
+#   if BOOST_MOVE_HAS_TRAIT(is_constructible) && BOOST_MOVE_HAS_TRAIT(is_nothrow_constructible)
+#     define BOOST_MOVE_HAS_NOTHROW_COPY(T) (__is_constructible(T, const T &) && __is_nothrow_constructible(T, const T &))
+#   elif BOOST_MOVE_HAS_TRAIT(has_nothrow_copy)
 #     define BOOST_MOVE_HAS_NOTHROW_COPY(T) (__has_nothrow_copy(T))
 #   endif
-#   if __has_feature(is_nothrow_copy_assignable)
+
+//    BOOST_MOVE_HAS_NOTHROW_ASSIGN
+#   if BOOST_MOVE_HAS_TRAIT(is_assignable) && BOOST_MOVE_HAS_TRAIT(is_nothrow_assignable)
+#     define BOOST_MOVE_HAS_NOTHROW_ASSIGN(T) (__is_assignable(T, const T &) && __is_nothrow_assignable(T, const T &))
+#   elif BOOST_MOVE_HAS_TRAIT(has_nothrow_assign)
 #     define BOOST_MOVE_HAS_NOTHROW_ASSIGN(T) (__has_nothrow_assign(T))
 #   endif
-#   if __has_feature(is_enum)
-#     define BOOST_MOVE_IS_ENUM(T) __is_enum(T)
-#   endif
-#   if __has_feature(has_trivial_move_constructor)
+
+//    BOOST_MOVE_HAS_TRIVIAL_MOVE_CONSTRUCTOR
+#   if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && BOOST_MOVE_HAS_TRAIT(is_constructible) && BOOST_MOVE_HAS_TRAIT(is_trivially_constructible)
+#     define BOOST_MOVE_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) (__is_constructible(T, T&&) && __is_trivially_constructible(T, T&&))
+#   elif BOOST_MOVE_HAS_TRAIT(has_trivial_move_constructor)
 #     define BOOST_MOVE_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) __has_trivial_move_constructor(T)
 #   endif
-#   if __has_feature(has_trivial_move_assign)
+
+//    BOOST_MOVE_HAS_TRIVIAL_MOVE_ASSIGN
+#   if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && BOOST_MOVE_HAS_TRAIT(is_assignable) && BOOST_MOVE_HAS_TRAIT(is_trivially_assignable)
+#     define BOOST_MOVE_HAS_TRIVIAL_MOVE_ASSIGN(T) (__is_assignable(T, T&&) && __is_trivially_assignable(T, T&&))
+#   elif BOOST_MOVE_HAS_TRAIT(has_trivial_move_assign)
 #     define BOOST_MOVE_HAS_TRIVIAL_MOVE_ASSIGN(T) __has_trivial_move_assign(T)
 #   endif
+
+//    BOOST_MOVE_HAS_NOTHROW_MOVE_CONSTRUCTOR
+#   if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && BOOST_MOVE_HAS_TRAIT(is_constructible) && BOOST_MOVE_HAS_TRAIT(is_nothrow_constructible)
+#     define BOOST_MOVE_HAS_NOTHROW_MOVE_CONSTRUCTOR(T) (__is_constructible(T, T&&) && __is_nothrow_constructible(T, T&&))
+#   elif BOOST_MOVE_HAS_TRAIT(has_nothrow_move_constructor)
+#     define BOOST_MOVE_HAS_NOTHROW_MOVE_CONSTRUCTOR(T) __has_nothrow_move_constructor(T)
+#   endif
+
+//    BOOST_MOVE_HAS_NOTHROW_MOVE_ASSIGN
+#   if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && BOOST_MOVE_HAS_TRAIT(is_assignable) && BOOST_MOVE_HAS_TRAIT(is_nothrow_assignable)
+#     define BOOST_MOVE_HAS_NOTHROW_MOVE_ASSIGN(T) (__is_assignable(T, T&&) && __is_nothrow_assignable(T, T&&))
+#   elif BOOST_MOVE_HAS_TRAIT(has_nothrow_move_assign)
+#     define BOOST_MOVE_HAS_NOTHROW_MOVE_ASSIGN(T) __has_nothrow_move_assign(T)
+#   endif
+
+//    BOOST_MOVE_ALIGNMENT_OF
 #   define BOOST_MOVE_ALIGNMENT_OF(T) __alignof(T)
-#endif
+
+#endif   //#if defined(BOOST_CLANG)
 
 #if defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3) && !defined(__GCCXML__))) && !defined(BOOST_CLANG)
 
@@ -160,14 +234,106 @@
 #   define BOOST_MOVE_IS_POD(T) __is_pod(T)
 #   define BOOST_MOVE_IS_EMPTY(T) __is_empty(T)
 #   define BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T) ((__has_trivial_constructor(T) BOOST_MOVE_INTEL_TT_OPTS))
-#   define BOOST_MOVE_HAS_TRIVIAL_COPY(T) ((__has_trivial_copy(T) BOOST_MOVE_INTEL_TT_OPTS))
-#   define BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T) ((__has_trivial_assign(T) BOOST_MOVE_INTEL_TT_OPTS) )
+
+#   if defined(BOOST_GCC) && (BOOST_GCC > 50000)
+#     define BOOST_MOVE_HAS_TRIVIAL_COPY(T) (__is_trivially_constructible(T, const T &))
+#     define BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T) (__is_trivially_assignable(T, const T &))
+#   else
+#     define BOOST_MOVE_HAS_TRIVIAL_COPY(T) ((__has_trivial_copy(T) BOOST_MOVE_INTEL_TT_OPTS))
+#     define BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T) ((__has_trivial_assign(T) BOOST_MOVE_INTEL_TT_OPTS) )
+#   endif
+
 #   define BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T) (__has_trivial_destructor(T) BOOST_MOVE_INTEL_TT_OPTS)
 #   define BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR(T) (__has_nothrow_constructor(T) BOOST_MOVE_INTEL_TT_OPTS)
 #   define BOOST_MOVE_HAS_NOTHROW_COPY(T) ((__has_nothrow_copy(T) BOOST_MOVE_INTEL_TT_OPTS))
 #   define BOOST_MOVE_HAS_NOTHROW_ASSIGN(T) ((__has_nothrow_assign(T) BOOST_MOVE_INTEL_TT_OPTS))
 
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_NO_CXX11_SFINAE_EXPR)
+
+   template <typename T>
+   T && boost_move_tt_declval() BOOST_NOEXCEPT;
+
+#  if defined(BOOST_GCC) && (BOOST_GCC >= 80000)
+// __is_assignable / __is_constructible implemented
+#     define BOOST_MOVE_IS_ASSIGNABLE(T, U)     __is_assignable(T, U)
+#     define BOOST_MOVE_IS_CONSTRUCTIBLE(T, U)  __is_constructible(T, U)
+#  else
+
+   template<typename Tt, typename Ut>
+   class boost_move_tt_is_assignable
+   {
+      struct twochar {  char dummy[2]; };
+      template < class T
+               , class U
+               , class = decltype(boost_move_tt_declval<T>() = boost_move_tt_declval<U>())
+               > static char test(int);
+
+      template<class, class> static twochar test(...);
+
+      public:
+      static const bool value = sizeof(test<Tt, Ut>(0)) == sizeof(char);
+   };
+
+   template<typename Tt, typename Ut>
+   class boost_move_tt_is_constructible
+   {
+      struct twochar {  char dummy[2]; };
+      template < class T
+               , class U
+               , class = decltype(T(boost_move_tt_declval<U>()))
+               > static char test(int);
+
+      template<class, class> static twochar test(...);
+
+      public:
+      static const bool value = sizeof(test<Tt, Ut>(0)) == sizeof(char);
+   };
+
+#     define BOOST_MOVE_IS_ASSIGNABLE(T, U)     boost_move_tt_is_assignable<T,U>::value
+#     define BOOST_MOVE_IS_CONSTRUCTIBLE(T, U)  boost_move_tt_is_constructible<T, U>::value
+
+#  endif
+
+   template <typename T, typename U, bool = BOOST_MOVE_IS_ASSIGNABLE(T, U)>
+   struct boost_move_tt_is_nothrow_assignable
+   {
+      static const bool value = false;
+   };
+
+   template <typename T, typename U>
+   struct boost_move_tt_is_nothrow_assignable<T, U, true>
+   {
+      #if !defined(BOOST_NO_CXX11_NOEXCEPT)
+      static const bool value = noexcept(boost_move_tt_declval<T>() = boost_move_tt_declval<U>());
+      #else
+      static const bool value = false;
+      #endif
+   };
+
+   template <typename T, typename U, bool = BOOST_MOVE_IS_CONSTRUCTIBLE(T, U)>
+   struct boost_move_tt_is_nothrow_constructible
+   {
+      static const bool value = false;
+   };
+
+   template <typename T, typename U>
+   struct boost_move_tt_is_nothrow_constructible<T, U, true>
+   {
+      #if !defined(BOOST_NO_CXX11_NOEXCEPT)
+      static const bool value = noexcept(T(boost_move_tt_declval<U>()));
+      #else
+      static const bool value = false;
+      #endif
+   };
+
+#     define BOOST_MOVE_HAS_NOTHROW_MOVE_ASSIGN(T)       boost_move_tt_is_nothrow_assignable<T, T&&>::value
+#     define BOOST_MOVE_HAS_NOTHROW_MOVE_CONSTRUCTOR(T)  boost_move_tt_is_nothrow_constructible<T, T&&>::value
+
+#  endif
+
 #   define BOOST_MOVE_IS_ENUM(T) __is_enum(T)
+
+// BOOST_MOVE_ALIGNMENT_OF
 #   if (!defined(unix) && !defined(__unix__)) || defined(__LP64__)
       // GCC sometimes lies about alignment requirements
       // of type double on 32-bit unix platforms, use the
@@ -243,13 +409,13 @@
 #endif
 
 #ifdef BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR
-   #define BOOST_MOVE_IS_TRIVIALLY_DEFAULT_CONSTRUCTIBLE(T)  BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T)
+   #define BOOST_MOVE_IS_TRIVIALLY_DEFAULT_CONSTRUCTIBLE(T)  BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T) || ::boost::move_detail::is_pod<T>::value
 #else
    #define BOOST_MOVE_IS_TRIVIALLY_DEFAULT_CONSTRUCTIBLE(T)  ::boost::move_detail::is_pod<T>::value
 #endif
 
 #ifdef BOOST_MOVE_HAS_TRIVIAL_MOVE_CONSTRUCTOR
-   #define BOOST_MOVE_IS_TRIVIALLY_MOVE_CONSTRUCTIBLE(T)   BOOST_MOVE_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T)
+   #define BOOST_MOVE_IS_TRIVIALLY_MOVE_CONSTRUCTIBLE(T)   BOOST_MOVE_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) || ::boost::move_detail::is_pod<T>::value
 #else
    #define BOOST_MOVE_IS_TRIVIALLY_MOVE_CONSTRUCTIBLE(T)   ::boost::move_detail::is_pod<T>::value
 #endif
@@ -263,45 +429,45 @@
 #endif
 
 #ifdef BOOST_MOVE_HAS_TRIVIAL_MOVE_ASSIGN
-   #define BOOST_MOVE_IS_TRIVIALLY_MOVE_ASSIGNABLE(T)  BOOST_MOVE_HAS_TRIVIAL_MOVE_ASSIGN(T)
+   #define BOOST_MOVE_IS_TRIVIALLY_MOVE_ASSIGNABLE(T)  BOOST_MOVE_HAS_TRIVIAL_MOVE_ASSIGN(T) || ::boost::move_detail::is_pod<T>::value
 #else
    #define BOOST_MOVE_IS_TRIVIALLY_MOVE_ASSIGNABLE(T)  ::boost::move_detail::is_pod<T>::value
 #endif
 
 #ifdef BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR
-   #define BOOST_MOVE_IS_TRIVIALLY_DESTRUCTIBLE(T)   BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T)
+   #define BOOST_MOVE_IS_TRIVIALLY_DESTRUCTIBLE(T)   BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T) || ::boost::move_detail::is_pod<T>::value
 #else
    #define BOOST_MOVE_IS_TRIVIALLY_DESTRUCTIBLE(T)   ::boost::move_detail::is_pod<T>::value
 #endif
 
 #ifdef BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR
-   #define BOOST_MOVE_IS_NOTHROW_DEFAULT_CONSTRUCTIBLE(T)  BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR(T)
+   #define BOOST_MOVE_IS_NOTHROW_DEFAULT_CONSTRUCTIBLE(T)  BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR(T) || ::boost::move_detail::is_pod<T>::value
 #else
    #define BOOST_MOVE_IS_NOTHROW_DEFAULT_CONSTRUCTIBLE(T)  ::boost::move_detail::is_pod<T>::value
 #endif
 
 #ifdef BOOST_MOVE_HAS_NOTHROW_COPY
-   #define BOOST_MOVE_IS_NOTHROW_COPY_CONSTRUCTIBLE(T)   BOOST_MOVE_HAS_NOTHROW_COPY(T)
+   #define BOOST_MOVE_IS_NOTHROW_COPY_CONSTRUCTIBLE(T)   BOOST_MOVE_HAS_NOTHROW_COPY(T) || ::boost::move_detail::is_pod<T>::value
 #else
-   #define BOOST_MOVE_IS_NOTHROW_COPY_CONSTRUCTIBLE(T)   ::boost::move_detail::is_pod<T>::value
+   #define BOOST_MOVE_IS_NOTHROW_COPY_CONSTRUCTIBLE(T)   BOOST_MOVE_IS_TRIVIALLY_COPY_ASSIGNABLE(T)
 #endif
 
-#ifdef BOOST_MOVE_HAS_NOTHROW_MOVE
-   #define BOOST_MOVE_IS_NOTHROW_MOVE_CONSTRUCTIBLE(T)   BOOST_MOVE_HAS_NOTHROW_MOVE(T)
+#ifdef BOOST_MOVE_HAS_NOTHROW_ASSIGN
+   #define BOOST_MOVE_IS_NOTHROW_COPY_ASSIGNABLE(T) BOOST_MOVE_HAS_NOTHROW_ASSIGN(T) || ::boost::move_detail::is_pod<T>::value
 #else
-   #define BOOST_MOVE_IS_NOTHROW_MOVE_CONSTRUCTIBLE(T)   ::boost::move_detail::is_pod<T>::value
+   #define BOOST_MOVE_IS_NOTHROW_COPY_ASSIGNABLE(T) BOOST_MOVE_IS_TRIVIALLY_COPY_ASSIGNABLE(T)
 #endif
 
-#ifdef BOOST_MOVE_HAS_NOTHROW_ASSIGN
-   #define BOOST_MOVE_IS_NOTHROW_COPY_ASSIGNABLE(T) BOOST_MOVE_HAS_NOTHROW_ASSIGN(T)
+#ifdef BOOST_MOVE_HAS_NOTHROW_MOVE_CONSTRUCTOR
+   #define BOOST_MOVE_IS_NOTHROW_MOVE_CONSTRUCTIBLE(T)   BOOST_MOVE_HAS_NOTHROW_MOVE_CONSTRUCTOR(T) || ::boost::move_detail::is_pod<T>::value
 #else
-   #define BOOST_MOVE_IS_NOTHROW_COPY_ASSIGNABLE(T) ::boost::move_detail::is_pod<T>::value
+   #define BOOST_MOVE_IS_NOTHROW_MOVE_CONSTRUCTIBLE(T)   BOOST_MOVE_IS_TRIVIALLY_MOVE_ASSIGNABLE(T)
 #endif
 
 #ifdef BOOST_MOVE_HAS_NOTHROW_MOVE_ASSIGN
-   #define BOOST_MOVE_IS_NOTHROW_MOVE_ASSIGNABLE(T) BOOST_MOVE_HAS_NOTHROW_MOVE_ASSIGN(T)
+   #define BOOST_MOVE_IS_NOTHROW_MOVE_ASSIGNABLE(T) BOOST_MOVE_HAS_NOTHROW_MOVE_ASSIGN(T) || ::boost::move_detail::is_pod<T>::value
 #else
-   #define BOOST_MOVE_IS_NOTHROW_MOVE_ASSIGNABLE(T) ::boost::move_detail::is_pod<T>::value
+   #define BOOST_MOVE_IS_NOTHROW_MOVE_ASSIGNABLE(T) BOOST_MOVE_IS_TRIVIALLY_MOVE_ASSIGNABLE(T)
 #endif
 
 #ifdef BOOST_MOVE_IS_ENUM
@@ -403,6 +569,15 @@ template<typename T> struct remove_cv<const T>           {  typedef T type;   };
 template<typename T> struct remove_cv<const volatile T>  {  typedef T type;   };
 template<typename T> struct remove_cv<volatile T>        {  typedef T type;   };
 
+//////////////////////////
+//    remove_cvref
+//////////////////////////
+template<class T>
+struct remove_cvref
+   : remove_cv<typename remove_reference<T>::type>
+{
+};
+
 //////////////////////////
 //    make_unsigned
 //////////////////////////
@@ -817,8 +992,6 @@ struct is_trivially_default_constructible
 template<class T>
 struct is_trivially_copy_constructible
 {
-   //In several compilers BOOST_MOVE_IS_TRIVIALLY_COPY_CONSTRUCTIBLE return true even with
-   //deleted copy constructors so make sure the type is copy constructible.
    static const bool value = BOOST_MOVE_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T);
 };
 
@@ -835,8 +1008,6 @@ struct is_trivially_move_constructible
 template<class T>
 struct is_trivially_copy_assignable
 {
-   //In several compilers BOOST_MOVE_IS_TRIVIALLY_COPY_CONSTRUCTIBLE return true even with
-   //deleted copy constructors so make sure the type is copy constructible.
    static const bool value = BOOST_MOVE_IS_TRIVIALLY_COPY_ASSIGNABLE(T);
 };                             
 
@@ -852,7 +1023,6 @@ struct is_trivially_move_assignable
 //////////////////////////////////////
 template<class T>
 struct is_nothrow_default_constructible
-   : is_pod<T>
 {  static const bool value = BOOST_MOVE_IS_NOTHROW_DEFAULT_CONSTRUCTIBLE(T);  };
 
 //////////////////////////////////////
@@ -965,7 +1135,46 @@ typedef union max_align max_align_t;
 //    aligned_storage
 /////////////////////////////
 
-#if !defined(BOOST_NO_ALIGNMENT)
+#if defined(_MSC_VER) && defined(_M_IX86)
+
+// Special version for usual alignments on x86 MSVC because it might crash
+// when passsing aligned types by value even for 8 byte alignment.
+template<std::size_t Align>
+struct aligned_struct;
+
+template <> struct aligned_struct<1> { char data; };
+template <> struct aligned_struct<2> { short data; };
+template <> struct aligned_struct<4> { int data; };
+template <> struct aligned_struct<8> { double data; };
+
+#define BOOST_MOVE_ALIGNED_STRUCT(x) \
+  template <> struct aligned_struct<x> { \
+    __declspec(align(x)) char data; \
+  }
+BOOST_MOVE_ALIGNED_STRUCT(16);
+BOOST_MOVE_ALIGNED_STRUCT(32);
+BOOST_MOVE_ALIGNED_STRUCT(64);
+BOOST_MOVE_ALIGNED_STRUCT(128);
+BOOST_MOVE_ALIGNED_STRUCT(512);
+BOOST_MOVE_ALIGNED_STRUCT(1024);
+BOOST_MOVE_ALIGNED_STRUCT(2048);
+BOOST_MOVE_ALIGNED_STRUCT(4096);
+
+template<std::size_t Len, std::size_t Align>
+union aligned_union
+{
+   typedef aligned_struct<Align> aligner_t;
+   aligner_t aligner;
+   unsigned char data[Len > sizeof(aligner_t) ? Len : sizeof(aligner_t)];
+};
+
+template<std::size_t Len, std::size_t Align>
+struct aligned_storage_impl
+{
+   typedef aligned_union<Len, Align> type;
+};
+
+#elif !defined(BOOST_NO_ALIGNMENT)
 
 template<std::size_t Len, std::size_t Align>
 struct aligned_struct;
@@ -1000,8 +1209,9 @@ BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x1000)
 template<std::size_t Len, std::size_t Align>
 union aligned_struct_wrapper
 {
+   typedef aligned_struct<Len, Align> aligner_t;
    aligned_struct<Len, Align> aligner;
-   unsigned char data[sizeof(aligned_struct<Len, Align>)];
+   unsigned char data[Len > sizeof(aligner_t) ? Len : sizeof(aligner_t)];
 };
 
 template<std::size_t Len, std::size_t Align>
@@ -1016,7 +1226,7 @@ template<class T, std::size_t Len>
 union aligned_union
 {   
    T aligner;
-   unsigned char data[Len];
+   unsigned char data[Len > sizeof(T) ? Len : sizeof(T)];
 };
 
 template<std::size_t Len, std::size_t Align, class T, bool Ok>