passenger 6.0.2 → 6.0.15

data/src/cxx_supportlib/vendor-modified/boost/libs/system/src/error_code.cpp

@@ -1,6 +1,7 @@
-//  error_code support implementation file  ----------------------------------//
+//  error_code stub implementation, for compatibility only
 
 //  Copyright Beman Dawes 2002, 2006
+//  Copyright Peter Dimov 2018
 
 //  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)
@@ -13,8 +14,18 @@
 // the library is being built (possibly exporting rather than importing code)
 #define BOOST_SYSTEM_SOURCE
 
-#include <boost/system/error_code.hpp>
+#include <boost/system/config.hpp>
 
-#ifndef BOOST_ERROR_CODE_HEADER_ONLY
-#include <boost/system/detail/error_code.ipp>
-#endif
+namespace boost
+{
+
+namespace system
+{
+
+BOOST_SYSTEM_DECL void dummy_exported_function()
+{
+}
+
+} // namespace system
+
+} // namespace boost

data/src/cxx_supportlib/vendor-modified/boost/libs/thread/src/future.cpp

@@ -4,8 +4,8 @@
 // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include <boost/thread/detail/config.hpp>
-#ifndef BOOST_NO_EXCEPTIONS
 
+#ifndef BOOST_NO_EXCEPTIONS
 
 #include <boost/thread/futures/future_error_code.hpp>
 #include <string>

data/src/cxx_supportlib/vendor-modified/boost/libs/thread/src/pthread/once.cpp

@@ -8,7 +8,6 @@
 #include "./once_atomic.cpp"
 #else
 #define __STDC_CONSTANT_MACROS
-#include <boost/thread/pthread/pthread_mutex_scoped_lock.hpp>
 #include <boost/thread/once.hpp>
 #include <boost/assert.hpp>
 #include <boost/throw_exception.hpp>

data/src/cxx_supportlib/vendor-modified/boost/libs/thread/src/pthread/once_atomic.cpp

@@ -7,6 +7,7 @@
 //#define __STDC_CONSTANT_MACROS
 #include <boost/thread/detail/config.hpp>
 #include <boost/thread/once.hpp>
+#include <boost/thread/pthread/pthread_helpers.hpp>
 #include <boost/thread/pthread/pthread_mutex_scoped_lock.hpp>
 #include <boost/assert.hpp>
 #include <boost/static_assert.hpp>
@@ -57,7 +58,7 @@ namespace boost
             {
               // Wait until the initialization is complete
               //pthread::pthread_mutex_scoped_lock lk(&once_mutex);
-              BOOST_VERIFY(!pthread_cond_wait(&once_cv, &once_mutex));
+              BOOST_VERIFY(!posix::pthread_cond_wait(&once_cv, &once_mutex));
             }
           }
         }
@@ -72,7 +73,7 @@ namespace boost
         pthread::pthread_mutex_scoped_lock lk(&once_mutex);
         f.store(initialized, memory_order_release);
       }
-      BOOST_VERIFY(!pthread_cond_broadcast(&once_cv));
+      BOOST_VERIFY(!posix::pthread_cond_broadcast(&once_cv));
     }
 
     BOOST_THREAD_DECL void rollback_once_region(once_flag& flag) BOOST_NOEXCEPT
@@ -82,7 +83,7 @@ namespace boost
         pthread::pthread_mutex_scoped_lock lk(&once_mutex);
         f.store(uninitialized, memory_order_release);
       }
-      BOOST_VERIFY(!pthread_cond_broadcast(&once_cv));
+      BOOST_VERIFY(!posix::pthread_cond_broadcast(&once_cv));
     }
 
   } // namespace thread_detail

data/src/cxx_supportlib/vendor-modified/boost/libs/thread/src/pthread/thread.cpp

@@ -17,6 +17,8 @@
 #include <boost/thread/once.hpp>
 #include <boost/thread/tss.hpp>
 #include <boost/thread/future.hpp>
+#include <boost/thread/pthread/pthread_helpers.hpp>
+#include <boost/thread/pthread/pthread_mutex_scoped_lock.hpp>
 
 #ifdef __GLIBC__
 #include <sys/sysinfo.h>
@@ -27,9 +29,9 @@
 #include <unistd.h>
 #endif
 
-#if defined(__VXWORKS__) 
+#if defined(__VXWORKS__)
 #include <vxCpuLib.h>
-#endif 
+#endif
 
 #include <boost/algorithm/string/split.hpp>
 #include <boost/algorithm/string/trim.hpp>
@@ -53,11 +55,13 @@ namespace boost
                 i->second->unlock();
                 i->first->notify_all();
             }
+//#ifndef BOOST_NO_EXCEPTIONS
             for (async_states_t::iterator i = async_states_.begin(), e = async_states_.end();
                     i != e; ++i)
             {
                 (*i)->notify_deferred();
             }
+//#endif
         }
 
         struct thread_exit_callback_node
@@ -109,7 +113,7 @@ namespace boost
                                     = thread_info->tss_data.begin();
                                 if(current->second.func && (current->second.value!=0))
                                 {
-                                    (*current->second.func)(current->second.value);
+                                    (*current->second.caller)(current->second.func,current->second.value);
                                 }
                                 thread_info->tss_data.erase(current);
                             }
@@ -147,7 +151,7 @@ namespace boost
 
         boost::detail::thread_data_base* get_current_thread_data()
         {
-            boost::call_once(current_thread_tls_init_flag,create_current_thread_tls_key);
+            boost::call_once(current_thread_tls_init_flag,&create_current_thread_tls_key);
             return (boost::detail::thread_data_base*)pthread_getspecific(current_thread_tls_key);
         }
 
@@ -213,8 +217,10 @@ namespace boost
             ~externally_launched_thread() {
               BOOST_ASSERT(notify.empty());
               notify.clear();
+//#ifndef BOOST_NO_EXCEPTIONS
               BOOST_ASSERT(async_states_.empty());
               async_states_.clear();
+//#endif
             }
             void run()
             {}
@@ -466,7 +472,7 @@ namespace boost
 #   elif defined(BOOST_HAS_PTHREAD_YIELD)
             BOOST_VERIFY(!pthread_yield());
 //#   elif defined BOOST_THREAD_USES_DATETIME
-//            xtime xt;
+//            ::boost::xtime xt;
 //            xtime_get(&xt, TIME_UTC_);
 //            sleep(xt);
 //            sleep_for(chrono::milliseconds(0));
@@ -474,7 +480,7 @@ namespace boost
             mutex mx;
             unique_lock<mutex> lock(mx);
             condition_variable cond;
-            cond.do_wait_until(lock, detail::internal_platform_clock::now())
+            cond.do_wait_until(lock, detail::internal_platform_clock::now());
 #   endif
         }
     }
@@ -498,9 +504,9 @@ namespace boost
            set &= set -1;
         }
         return(i);
-  #else  
+  #else
         return (__builtin_popcount(set) );
-  #endif  
+  #endif
 #elif defined(__GLIBC__)
         return get_nprocs();
 #else
@@ -577,7 +583,7 @@ namespace boost
             if(local_thread_info->current_cond)
             {
                 boost::pthread::pthread_mutex_scoped_lock internal_lock(local_thread_info->cond_mutex);
-                BOOST_VERIFY(!pthread_cond_broadcast(local_thread_info->current_cond));
+                BOOST_VERIFY(!posix::pthread_cond_broadcast(local_thread_info->current_cond));
             }
         }
     }
@@ -722,11 +728,12 @@ namespace boost
         }
 
         void add_new_tss_node(void const* key,
-                              boost::shared_ptr<tss_cleanup_function> func,
+                              detail::tss_data_node::cleanup_caller_t caller,
+                              detail::tss_data_node::cleanup_func_t func,
                               void* tss_data)
         {
             detail::thread_data_base* const current_thread_data(get_or_make_current_thread_data());
-            current_thread_data->tss_data.insert(std::make_pair(key,tss_data_node(func,tss_data)));
+            current_thread_data->tss_data.insert(std::make_pair(key,tss_data_node(caller,func,tss_data)));
         }
 
         void erase_tss_node(void const* key)
@@ -739,17 +746,19 @@ namespace boost
         }
 
         void set_tss_data(void const* key,
-                          boost::shared_ptr<tss_cleanup_function> func,
+                          detail::tss_data_node::cleanup_caller_t caller,
+                          detail::tss_data_node::cleanup_func_t func,
                           void* tss_data,bool cleanup_existing)
         {
             if(tss_data_node* const current_node=find_tss_data(key))
             {
                 if(cleanup_existing && current_node->func && (current_node->value!=0))
                 {
-                    (*current_node->func)(current_node->value);
+                    (*current_node->caller)(current_node->func,current_node->value);
                 }
                 if(func || (tss_data!=0))
                 {
+                    current_node->caller=caller;
                     current_node->func=func;
                     current_node->value=tss_data;
                 }
@@ -760,7 +769,7 @@ namespace boost
             }
             else if(func || (tss_data!=0))
             {
-                add_new_tss_node(key,func,tss_data);
+                add_new_tss_node(key,caller,func,tss_data);
             }
         }
     }
@@ -773,6 +782,8 @@ namespace boost
         current_thread_data->notify_all_at_thread_exit(&cond, lk.release());
       }
     }
+
+//#ifndef BOOST_NO_EXCEPTIONS
 namespace detail {
 
     void BOOST_THREAD_DECL make_ready_at_thread_exit(shared_ptr<shared_state_base> as)
@@ -784,7 +795,7 @@ namespace detail {
       }
     }
 }
-
+//#endif
 
 
 }

data/src/cxx_supportlib/vendor-modified/boost/libs/thread/src/tss_null.cpp

@@ -6,7 +6,7 @@
 
 #include <boost/thread/detail/config.hpp>
 
-#if defined(BOOST_HAS_WINTHREADS) && (defined(BOOST_THREAD_BUILD_LIB) || defined(BOOST_THREAD_TEST) || defined(UNDER_CE)) && (!defined(_MSC_VER) || defined(UNDER_CE))
+#if defined(BOOST_THREAD_WIN32) && (defined(BOOST_THREAD_BUILD_LIB) || defined(BOOST_THREAD_TEST) || defined(UNDER_CE)) && (!defined(_MSC_VER) || defined(UNDER_CE))
 
 namespace boost
 {
@@ -35,4 +35,4 @@ namespace boost
 
 }
 
-#endif //defined(BOOST_HAS_WINTHREADS) && defined(BOOST_THREAD_BUILD_LIB) && !defined(_MSC_VER)
+#endif //defined(BOOST_THREAD_WIN32) && defined(BOOST_THREAD_BUILD_LIB) && !defined(_MSC_VER)

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

@@ -54,18 +54,12 @@ enum class memory_order : unsigned int
     seq_cst = 14 // acq_rel | 8
 };
 
-#if !defined(BOOST_NO_CXX17_INLINE_VARIABLES)
-#define BOOST_MEMORY_ORDER_INLINE_VARIABLE inline
-#else
-#define BOOST_MEMORY_ORDER_INLINE_VARIABLE
-#endif
-
-BOOST_MEMORY_ORDER_INLINE_VARIABLE BOOST_CONSTEXPR_OR_CONST memory_order memory_order_relaxed = memory_order::relaxed;
-BOOST_MEMORY_ORDER_INLINE_VARIABLE BOOST_CONSTEXPR_OR_CONST memory_order memory_order_consume = memory_order::consume;
-BOOST_MEMORY_ORDER_INLINE_VARIABLE BOOST_CONSTEXPR_OR_CONST memory_order memory_order_acquire = memory_order::acquire;
-BOOST_MEMORY_ORDER_INLINE_VARIABLE BOOST_CONSTEXPR_OR_CONST memory_order memory_order_release = memory_order::release;
-BOOST_MEMORY_ORDER_INLINE_VARIABLE BOOST_CONSTEXPR_OR_CONST memory_order memory_order_acq_rel = memory_order::acq_rel;
-BOOST_MEMORY_ORDER_INLINE_VARIABLE BOOST_CONSTEXPR_OR_CONST memory_order memory_order_seq_cst = memory_order::seq_cst;
+BOOST_INLINE_VARIABLE BOOST_CONSTEXPR_OR_CONST memory_order memory_order_relaxed = memory_order::relaxed;
+BOOST_INLINE_VARIABLE BOOST_CONSTEXPR_OR_CONST memory_order memory_order_consume = memory_order::consume;
+BOOST_INLINE_VARIABLE BOOST_CONSTEXPR_OR_CONST memory_order memory_order_acquire = memory_order::acquire;
+BOOST_INLINE_VARIABLE BOOST_CONSTEXPR_OR_CONST memory_order memory_order_release = memory_order::release;
+BOOST_INLINE_VARIABLE BOOST_CONSTEXPR_OR_CONST memory_order memory_order_acq_rel = memory_order::acq_rel;
+BOOST_INLINE_VARIABLE BOOST_CONSTEXPR_OR_CONST memory_order memory_order_seq_cst = memory_order::seq_cst;
 
 #undef BOOST_MEMORY_ORDER_INLINE_VARIABLE
 

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

@@ -15,6 +15,11 @@
 #include <boost/move/detail/config_begin.hpp>
 #include <boost/move/algo/detail/adaptive_sort_merge.hpp>
 
+#if defined(BOOST_CLANG) || (defined(BOOST_GCC) && (BOOST_GCC >= 40600))
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wsign-conversion"
+#endif
+
 namespace boost {
 namespace movelib {
 
@@ -23,21 +28,22 @@ namespace detail_adaptive {
 
 template<class RandIt, class Compare, class XBuf>
 inline void adaptive_merge_combine_blocks( RandIt first
-                                      , typename iterator_traits<RandIt>::size_type len1
-                                      , typename iterator_traits<RandIt>::size_type len2
-                                      , typename iterator_traits<RandIt>::size_type collected
-                                      , typename iterator_traits<RandIt>::size_type n_keys
-                                      , typename iterator_traits<RandIt>::size_type l_block
+                                      , typename iter_size<RandIt>::type len1
+                                      , typename iter_size<RandIt>::type len2
+                                      , typename iter_size<RandIt>::type collected
+                                      , typename iter_size<RandIt>::type n_keys
+                                      , typename iter_size<RandIt>::type l_block
                                       , bool use_internal_buf
                                       , bool xbuf_used
                                       , Compare comp
                                       , XBuf & xbuf
                                       )
 {
-   typedef typename iterator_traits<RandIt>::size_type size_type;
-   size_type const len = len1+len2;
-   size_type const l_combine  = len-collected;
-   size_type const l_combine1 = len1-collected;
+   typedef typename iter_size<RandIt>::type       size_type;
+
+   size_type const len = size_type(len1+len2);
+   size_type const l_combine  = size_type(len-collected);
+   size_type const l_combine1 = size_type(len1-collected);
 
     if(n_keys){
       RandIt const first_data = first+collected;
@@ -63,7 +69,8 @@ inline void adaptive_merge_combine_blocks( RandIt first
                            , n_block_a, n_block_b, l_irreg1, l_irreg2);   //Outputs
          if(use_internal_buf){
             op_merge_blocks_with_buf
-               (keys, comp, first_data, l_block, l_irreg1, n_block_a, n_block_b, l_irreg2, comp, swap_op(), first_data-l_block);
+               ( keys, comp, first_data, l_block, l_irreg1, n_block_a, n_block_b
+               , l_irreg2, comp, swap_op(), first_data-l_block);
             BOOST_MOVE_ADAPTIVE_SORT_PRINT_L2("   A mrg buf: ", len);
          }
          else{
@@ -94,49 +101,55 @@ inline void adaptive_merge_combine_blocks( RandIt first
 
 template<class RandIt, class Compare, class XBuf>
 inline void adaptive_merge_final_merge( RandIt first
-                                      , typename iterator_traits<RandIt>::size_type len1
-                                      , typename iterator_traits<RandIt>::size_type len2
-                                      , typename iterator_traits<RandIt>::size_type collected
-                                      , typename iterator_traits<RandIt>::size_type l_intbuf
-                                      , typename iterator_traits<RandIt>::size_type l_block
-                                      , bool use_internal_buf
+                                      , typename iter_size<RandIt>::type len1
+                                      , typename iter_size<RandIt>::type len2
+                                      , typename iter_size<RandIt>::type collected
+                                      , typename iter_size<RandIt>::type l_intbuf
+                                      , typename iter_size<RandIt>::type //l_block
+                                      , bool //use_internal_buf
                                       , bool xbuf_used
                                       , Compare comp
                                       , XBuf & xbuf
                                       )
 {
-   typedef typename iterator_traits<RandIt>::size_type size_type;
-   (void)l_block;
-   size_type n_keys = collected-l_intbuf;
-   size_type len = len1+len2;
-   if(use_internal_buf){
-      if(xbuf_used){
-         xbuf.clear();
-         //Nothing to do
-         if(n_keys){
-            unstable_sort(first, first+n_keys, comp, xbuf);
-            stable_merge(first, first+n_keys, first+len, comp, xbuf);
-            BOOST_MOVE_ADAPTIVE_SORT_PRINT_L2("   A key mrg: ", len);
-         }
-      }
-      else{
-         xbuf.clear();
-         unstable_sort(first, first+collected, comp, xbuf);
-         BOOST_MOVE_ADAPTIVE_SORT_PRINT_L2("   A k/b srt: ", len);
-         stable_merge(first, first+collected, first+len, comp, xbuf);
-         BOOST_MOVE_ADAPTIVE_SORT_PRINT_L2("   A k/b mrg: ", len);
-      }
-   }
-   else{
+   typedef typename iter_size<RandIt>::type       size_type;
+
+   size_type n_keys = size_type(collected-l_intbuf);
+   size_type len = size_type(len1+len2);
+   if (!xbuf_used || n_keys) {
       xbuf.clear();
-      unstable_sort(first, first+collected, comp, xbuf);
+      const size_type middle = xbuf_used && n_keys ? n_keys: collected;
+      unstable_sort(first, first + middle, comp, xbuf);
       BOOST_MOVE_ADAPTIVE_SORT_PRINT_L2("   A k/b srt: ", len);
-      stable_merge(first, first+collected, first+len1+len2, comp, xbuf);
-      BOOST_MOVE_ADAPTIVE_SORT_PRINT_L2("   A k/b mrg: ", len);
+      stable_merge(first, first + middle, first + len, comp, xbuf);
    }
    BOOST_MOVE_ADAPTIVE_SORT_PRINT_L1("   A fin mrg: ", len);
 }
 
+template<class SizeType>
+inline static SizeType adaptive_merge_n_keys_without_external_keys(SizeType l_block, SizeType len1, SizeType len2, SizeType l_intbuf)
+{
+   typedef SizeType size_type;
+   //This is the minimum number of keys to implement the ideal algorithm
+   size_type n_keys = size_type(len1/l_block + len2/l_block);
+   const size_type second_half_blocks = size_type(len2/l_block);
+   const size_type first_half_aux = size_type(len1 - l_intbuf);
+   while(n_keys >= ((first_half_aux-n_keys)/l_block + second_half_blocks)){
+      --n_keys;
+   }
+   ++n_keys;
+   return n_keys;
+}
+
+template<class SizeType>
+inline static SizeType adaptive_merge_n_keys_with_external_keys(SizeType l_block, SizeType len1, SizeType len2, SizeType l_intbuf)
+{
+   typedef SizeType size_type;
+   //This is the minimum number of keys to implement the ideal algorithm
+   size_type n_keys = size_type((len1-l_intbuf)/l_block + len2/l_block);
+   return n_keys;
+}
+
 template<class SizeType, class Xbuf>
 inline SizeType adaptive_merge_n_keys_intbuf(SizeType &rl_block, SizeType len1, SizeType len2, Xbuf & xbuf, SizeType &l_intbuf_inout)
 {
@@ -144,19 +157,18 @@ inline SizeType adaptive_merge_n_keys_intbuf(SizeType &rl_block, SizeType len1,
    size_type l_block = rl_block;
    size_type l_intbuf = xbuf.capacity() >= l_block ? 0u : l_block;
 
-   while(xbuf.capacity() >= l_block*2){
-      l_block *= 2;
+   if (xbuf.capacity() > l_block){
+      l_block = xbuf.capacity();
    }
 
    //This is the minimum number of keys to implement the ideal algorithm
-   size_type n_keys = len1/l_block+len2/l_block;
-   while(n_keys >= ((len1-l_intbuf-n_keys)/l_block + len2/l_block)){
-      --n_keys;
-   }
-   ++n_keys;
+   size_type n_keys = adaptive_merge_n_keys_without_external_keys(l_block, len1, len2, l_intbuf);
    BOOST_ASSERT(n_keys >= ((len1-l_intbuf-n_keys)/l_block + len2/l_block));
 
-   if(xbuf.template supports_aligned_trailing<size_type>(l_block, n_keys)){
+   if(xbuf.template supports_aligned_trailing<size_type>
+      ( l_block
+      , adaptive_merge_n_keys_with_external_keys(l_block, len1, len2, l_intbuf)))
+   {
       n_keys = 0u;
    }
    l_intbuf_inout = l_intbuf;
@@ -210,19 +222,20 @@ inline SizeType adaptive_merge_n_keys_intbuf(SizeType &rl_block, SizeType len1,
 template<class RandIt, class Compare, class XBuf>
 void adaptive_merge_impl
    ( RandIt first
-   , typename iterator_traits<RandIt>::size_type len1
-   , typename iterator_traits<RandIt>::size_type len2
+   , typename iter_size<RandIt>::type len1
+   , typename iter_size<RandIt>::type len2
    , Compare comp
    , XBuf & xbuf
    )
 {
-   typedef typename iterator_traits<RandIt>::size_type size_type;
+   typedef typename iter_size<RandIt>::type size_type;
 
    if(xbuf.capacity() >= min_value<size_type>(len1, len2)){
-      buffered_merge(first, first+len1, first+(len1+len2), comp, xbuf);
+      buffered_merge( first, first+len1
+                    , first + len1+len2, comp, xbuf);
    }
    else{
-      const size_type len = len1+len2;
+      const size_type len = size_type(len1+len2);
       //Calculate ideal parameters and try to collect needed unique keys
       size_type l_block = size_type(ceil_sqrt(len));
 
@@ -237,7 +250,7 @@ void adaptive_merge_impl
       //internal buffer is needed so l_intbuf will remain 0.
       size_type l_intbuf = 0;
       size_type n_keys = adaptive_merge_n_keys_intbuf(l_block, len1, len2, xbuf, l_intbuf);
-      size_type const to_collect = l_intbuf+n_keys;
+      size_type const to_collect = size_type(l_intbuf+n_keys);
       //Try to extract needed unique values from the first range
       size_type const collected  = collect_unique(first, first+len1, to_collect, comp, xbuf);
       BOOST_MOVE_ADAPTIVE_SORT_PRINT_L1("\n   A collect: ", len);
@@ -303,18 +316,48 @@ void adaptive_merge_impl
 template<class RandIt, class Compare>
 void adaptive_merge( RandIt first, RandIt middle, RandIt last, Compare comp
                 , typename iterator_traits<RandIt>::value_type* uninitialized = 0
-                , std::size_t uninitialized_len = 0)
+                , typename iter_size<RandIt>::type uninitialized_len = 0)
 {
-   typedef typename iterator_traits<RandIt>::size_type  size_type;
+   typedef typename iter_size<RandIt>::type  size_type;
    typedef typename iterator_traits<RandIt>::value_type value_type;
 
-   ::boost::movelib::detail_adaptive::adaptive_xbuf<value_type> xbuf(uninitialized, uninitialized_len);
+   if (first == middle || middle == last){
+      return;
+   }
+
+   //Reduce ranges to merge if possible
+   do {
+      if (comp(*middle, *first)){
+         break;
+      }
+      ++first;
+      if (first == middle)
+         return;
+   } while(1);
+
+   RandIt first_high(middle);
+   --first_high;
+   do {
+      --last;
+      if (comp(*last, *first_high)){
+         ++last;
+         break;
+      }
+      if (last == middle)
+         return;
+   } while(1);
+
+   ::boost::movelib::adaptive_xbuf<value_type, value_type*, size_type> xbuf(uninitialized, size_type(uninitialized_len));
    ::boost::movelib::detail_adaptive::adaptive_merge_impl(first, size_type(middle - first), size_type(last - middle), comp, xbuf);
 }
 
 }  //namespace movelib {
 }  //namespace boost {
 
+#if defined(BOOST_CLANG) || (defined(BOOST_GCC) && (BOOST_GCC >= 40600))
+#pragma GCC diagnostic pop
+#endif
+
 #include <boost/move/detail/config_end.hpp>
 
 #endif   //#define BOOST_MOVE_ADAPTIVE_MERGE_HPP