passenger 6.0.0 → 6.0.5

data/src/cxx_supportlib/vendor-modified/boost/asio/ssl/stream.hpp

@@ -635,7 +635,8 @@ public:
    *
    * @note The async_write_some operation may not transmit all of the data to
    * the peer. Consider using the @ref async_write function if you need to
-   * ensure that all data is written before the blocking operation completes.
+   * ensure that all data is written before the asynchronous operation
+   * completes.
    */
   template <typename ConstBufferSequence, typename WriteHandler>
   BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,

data/src/cxx_supportlib/vendor-modified/boost/asio/thread_pool.hpp

@@ -33,7 +33,7 @@ namespace asio {
  *
  * @par Submitting tasks to the pool
  *
- * To submit functions to the io_context, use the @ref boost::asio::dispatch,
+ * To submit functions to the thread_pool, use the @ref boost::asio::dispatch,
  * @ref boost::asio::post or @ref boost::asio::defer free functions.
  *
  * For example:

data/src/cxx_supportlib/vendor-modified/boost/asio/use_future.hpp

@@ -16,8 +16,9 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
+#include <boost/asio/detail/future.hpp>
 
-#if defined(BOOST_ASIO_HAS_STD_FUTURE) \
+#if defined(BOOST_ASIO_HAS_STD_FUTURE_CLASS) \
   || defined(GENERATING_DOCUMENTATION)
 
 #include <memory>
@@ -155,7 +156,7 @@ __declspec(selectany) use_future_t<> use_future;
 
 #include <boost/asio/impl/use_future.hpp>
 
-#endif // defined(BOOST_ASIO_HAS_STD_FUTURE)
+#endif // defined(BOOST_ASIO_HAS_STD_FUTURE_CLASS)
        //   || defined(GENERATING_DOCUMENTATION)
 
 #endif // BOOST_ASIO_USE_FUTURE_HPP

data/src/cxx_supportlib/vendor-modified/boost/asio/version.hpp

@@ -18,6 +18,6 @@
 // BOOST_ASIO_VERSION % 100 is the sub-minor version
 // BOOST_ASIO_VERSION / 100 % 1000 is the minor version
 // BOOST_ASIO_VERSION / 100000 is the major version
-#define BOOST_ASIO_VERSION 101201 // 1.12.1
+#define BOOST_ASIO_VERSION 101202 // 1.12.2
 
 #endif // BOOST_ASIO_VERSION_HPP

data/src/cxx_supportlib/vendor-modified/boost/asio/write.hpp

@@ -33,7 +33,8 @@ namespace asio {
 /**
  * @defgroup write boost::asio::write
  *
- * @brief Write a certain amount of data to a stream before returning.
+ * @brief The @c write function is a composed operation that writes a certain
+ * amount of data to a stream before returning.
  */
 /*@{*/
 
@@ -533,8 +534,8 @@ std::size_t write(SyncWriteStream& s, basic_streambuf& b,
 /**
  * @defgroup async_write boost::asio::async_write
  *
- * @brief Start an asynchronous operation to write a certain amount of data to a
- * stream.
+ * @brief The @c async_write function is a composed asynchronous operation that
+ * writes a certain amount of data to a stream before completion.
  */
 /*@{*/
 

data/src/cxx_supportlib/vendor-modified/boost/asio/write_at.hpp

@@ -33,7 +33,8 @@ namespace asio {
 /**
  * @defgroup write_at boost::asio::write_at
  *
- * @brief Write a certain amount of data at a specified offset before returning.
+ * @brief The @c write_at function is a composed operation that writes a
+ * certain amount of data at a specified offset before returning.
  */
 /*@{*/
 
@@ -393,8 +394,9 @@ std::size_t write_at(SyncRandomAccessWriteDevice& d, uint64_t offset,
 /**
  * @defgroup async_write_at boost::asio::async_write_at
  *
- * @brief Start an asynchronous operation to write a certain amount of data at
- * the specified offset.
+ * @brief The @c async_write_at function is a composed asynchronous operation
+ * that writes a certain amount of data at the specified offset before
+ * completion.
  */
 /*@{*/
 

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

@@ -158,11 +158,13 @@ struct gcc_dcas_x86
         }
         else
         {
-#if defined(__clang__)
-            // Clang cannot allocate eax:edx register pairs but it has sync intrinsics
-            value = __sync_val_compare_and_swap(&storage, (storage_type)0, (storage_type)0);
-#elif defined(BOOST_ATOMIC_DETAIL_X86_NO_ASM_AX_DX_PAIRS)
+            // Note that despite const qualification cmpxchg8b below may issue a store to the storage. The storage value
+            // will not change, but this prevents the storage to reside in read-only memory.
+
+#if defined(BOOST_ATOMIC_DETAIL_X86_NO_ASM_AX_DX_PAIRS)
+
             uint32_t value_bits[2];
+
             // We don't care for comparison result here; the previous value will be stored into value anyway.
             // Also we don't care for ebx and ecx values, they just have to be equal to eax and edx before cmpxchg8b.
             __asm__ __volatile__
@@ -175,7 +177,9 @@ struct gcc_dcas_x86
                 : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "memory"
             );
             BOOST_ATOMIC_DETAIL_MEMCPY(&value, value_bits, sizeof(value));
+
 #else // defined(BOOST_ATOMIC_DETAIL_X86_NO_ASM_AX_DX_PAIRS)
+
             // We don't care for comparison result here; the previous value will be stored into value anyway.
             // Also we don't care for ebx and ecx values, they just have to be equal to eax and edx before cmpxchg8b.
             __asm__ __volatile__
@@ -187,6 +191,7 @@ struct gcc_dcas_x86
                 : [storage] "m" (storage)
                 : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "memory"
             );
+
 #endif // defined(BOOST_ATOMIC_DETAIL_X86_NO_ASM_AX_DX_PAIRS)
         }
 
@@ -266,7 +271,7 @@ struct gcc_dcas_x86
         return compare_exchange_strong(storage, expected, desired, success_order, failure_order);
     }
 
-    static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
     {
 #if defined(BOOST_ATOMIC_DETAIL_X86_ASM_PRESERVE_EBX)
 #if defined(BOOST_ATOMIC_DETAIL_X86_NO_ASM_AX_DX_PAIRS)
@@ -401,15 +406,11 @@ struct gcc_dcas_x86_64
 
     static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order) BOOST_NOEXCEPT
     {
-#if defined(__clang__)
+        // Note that despite const qualification cmpxchg16b below may issue a store to the storage. The storage value
+        // will not change, but this prevents the storage to reside in read-only memory.
 
-        // Clang cannot allocate rax:rdx register pairs but it has sync intrinsics
-        storage_type value = storage_type();
-        return __sync_val_compare_and_swap(&storage, value, value);
-
-#elif defined(BOOST_ATOMIC_DETAIL_X86_NO_ASM_AX_DX_PAIRS)
+#if defined(BOOST_ATOMIC_DETAIL_X86_NO_ASM_AX_DX_PAIRS)
 
-        // Some compilers can't allocate rax:rdx register pair either and also don't support 128-bit __sync_val_compare_and_swap
         uint64_t value_bits[2];
 
         // We don't care for comparison result here; the previous value will be stored into value anyway.

data/src/cxx_supportlib/vendor-modified/boost/chrono/detail/inlined/mac/chrono.hpp

@@ -40,7 +40,7 @@ system_clock::now(system::error_code & ec)
 {
     timeval tv;
     gettimeofday(&tv, 0);
-    if (!BOOST_CHRONO_IS_THROWS(ec))
+    if (!::boost::chrono::is_throws(ec))
     {
         ec.clear();
     }
@@ -89,7 +89,7 @@ BOOST_CHRONO_STATIC
 steady_clock::rep
 steady_simplified_ec(system::error_code & ec)
 {
-    if (!BOOST_CHRONO_IS_THROWS(ec))
+    if (!::boost::chrono::is_throws(ec))
     {
         ec.clear();
     }
@@ -131,21 +131,21 @@ steady_full_ec(system::error_code & ec)
     const double factor = chrono_detail::compute_steady_factor(err);
     if (err != 0)
     {
-        if (BOOST_CHRONO_IS_THROWS(ec))
+        if (::boost::chrono::is_throws(ec))
         {
             boost::throw_exception(
                     system::system_error(
                             err,
-                            BOOST_CHRONO_SYSTEM_CATEGORY,
+                            ::boost::system::system_category(),
                             "chrono::steady_clock" ));
         }
         else
         {
-            ec.assign( errno, BOOST_CHRONO_SYSTEM_CATEGORY );
+            ec.assign( errno, ::boost::system::system_category() );
             return steady_clock::rep();
         }
     }
-    if (!BOOST_CHRONO_IS_THROWS(ec))
+    if (!::boost::chrono::is_throws(ec))
     {
         ec.clear();
     }
@@ -217,21 +217,21 @@ steady_clock::now(system::error_code & ec)
     chrono_detail::FP_ec fp = chrono_detail::init_steady_clock_ec(err);
     if ( err != 0  )
     {
-        if (BOOST_CHRONO_IS_THROWS(ec))
+        if (::boost::chrono::is_throws(ec))
         {
             boost::throw_exception(
                     system::system_error(
                             err,
-                            BOOST_CHRONO_SYSTEM_CATEGORY,
+                            ::boost::system::system_category(),
                             "chrono::steady_clock" ));
         }
         else
         {
-            ec.assign( err, BOOST_CHRONO_SYSTEM_CATEGORY );
+            ec.assign( err, ::boost::system::system_category() );
             return time_point();
         }
     }
-    if (!BOOST_CHRONO_IS_THROWS(ec))
+    if (!::boost::chrono::is_throws(ec))
     {
         ec.clear();
     }

data/src/cxx_supportlib/vendor-modified/boost/chrono/detail/inlined/mac/process_cpu_clocks.hpp

@@ -95,12 +95,12 @@ namespace boost
       clock_t c = ::times(&tm);
       if (c == clock_t(-1)) // error
       {
-        if (BOOST_CHRONO_IS_THROWS(ec))
+        if (::boost::chrono::is_throws(ec))
         {
-          boost::throw_exception(system::system_error(errno, BOOST_CHRONO_SYSTEM_CATEGORY, "chrono::process_real_cpu_clock"));
+          boost::throw_exception(system::system_error(errno, ::boost::system::system_category(), "chrono::process_real_cpu_clock"));
         } else
         {
-          ec.assign(errno, BOOST_CHRONO_SYSTEM_CATEGORY);
+          ec.assign(errno, ::boost::system::system_category());
           return time_point();
         }
       } else
@@ -108,19 +108,19 @@ namespace boost
         long factor = chrono_detail::tick_factor();
         if (factor != -1)
         {
-          if (!BOOST_CHRONO_IS_THROWS(ec))
+          if (!::boost::chrono::is_throws(ec))
           {
             ec.clear();
           }
           return time_point(nanoseconds(c * factor));
         } else
         {
-          if (BOOST_CHRONO_IS_THROWS(ec))
+          if (::boost::chrono::is_throws(ec))
           {
-            boost::throw_exception(system::system_error(errno, BOOST_CHRONO_SYSTEM_CATEGORY, "chrono::process_real_cpu_clock"));
+            boost::throw_exception(system::system_error(errno, ::boost::system::system_category(), "chrono::process_real_cpu_clock"));
           } else
           {
-            ec.assign(errno, BOOST_CHRONO_SYSTEM_CATEGORY);
+            ec.assign(errno, ::boost::system::system_category());
             return time_point();
           }
         }
@@ -129,12 +129,12 @@ namespace boost
       clock_t c = ::clock();
       if (c == clock_t(-1)) // error
       {
-        if (BOOST_CHRONO_IS_THROWS(ec))
+        if (::boost::chrono::is_throws(ec))
         {
-          boost::throw_exception(system::system_error(errno, BOOST_CHRONO_SYSTEM_CATEGORY, "chrono::process_real_cpu_clock"));
+          boost::throw_exception(system::system_error(errno, ::boost::system::system_category(), "chrono::process_real_cpu_clock"));
         } else
         {
-          ec.assign(errno, BOOST_CHRONO_SYSTEM_CATEGORY);
+          ec.assign(errno, ::boost::system::system_category());
           return time_point();
         }
       } else
@@ -142,19 +142,19 @@ namespace boost
         long factor = chrono_detail::tick_factor();
         if (factor != -1)
         {
-          if (!BOOST_CHRONO_IS_THROWS(ec))
+          if (!::boost::chrono::is_throws(ec))
           {
             ec.clear();
           }
           return time_point(nanoseconds(c * factor));
         } else
         {
-          if (BOOST_CHRONO_IS_THROWS(ec))
+          if (::boost::chrono::is_throws(ec))
           {
-            boost::throw_exception(system::system_error(errno, BOOST_CHRONO_SYSTEM_CATEGORY, "chrono::process_real_cpu_clock"));
+            boost::throw_exception(system::system_error(errno, ::boost::system::system_category(), "chrono::process_real_cpu_clock"));
           } else
           {
-            ec.assign(errno, BOOST_CHRONO_SYSTEM_CATEGORY);
+            ec.assign(errno, ::boost::system::system_category());
             return time_point();
           }
         }
@@ -171,12 +171,12 @@ namespace boost
       clock_t c = ::times(&tm);
       if (c == clock_t(-1)) // error
       {
-        if (BOOST_CHRONO_IS_THROWS(ec))
+        if (::boost::chrono::is_throws(ec))
         {
-          boost::throw_exception(system::system_error(errno, BOOST_CHRONO_SYSTEM_CATEGORY, "chrono::process_user_cpu_clock"));
+          boost::throw_exception(system::system_error(errno, ::boost::system::system_category(), "chrono::process_user_cpu_clock"));
         } else
         {
-          ec.assign(errno, BOOST_CHRONO_SYSTEM_CATEGORY);
+          ec.assign(errno, ::boost::system::system_category());
           return time_point();
         }
       } else
@@ -184,19 +184,19 @@ namespace boost
         long factor = chrono_detail::tick_factor();
         if (factor != -1)
         {
-          if (!BOOST_CHRONO_IS_THROWS(ec))
+          if (!::boost::chrono::is_throws(ec))
           {
             ec.clear();
           }
           return time_point(nanoseconds((tm.tms_utime + tm.tms_cutime) * factor));
         } else
         {
-          if (BOOST_CHRONO_IS_THROWS(ec))
+          if (::boost::chrono::is_throws(ec))
           {
-            boost::throw_exception(system::system_error(errno, BOOST_CHRONO_SYSTEM_CATEGORY, "chrono::process_user_cpu_clock"));
+            boost::throw_exception(system::system_error(errno, ::boost::system::system_category(), "chrono::process_user_cpu_clock"));
           } else
           {
-            ec.assign(errno, BOOST_CHRONO_SYSTEM_CATEGORY);
+            ec.assign(errno, ::boost::system::system_category());
             return time_point();
           }
         }
@@ -254,12 +254,12 @@ namespace boost
       clock_t c = ::times(&tm);
       if (c == clock_t(-1)) // error
       {
-        if (BOOST_CHRONO_IS_THROWS(ec))
+        if (::boost::chrono::is_throws(ec))
         {
-          boost::throw_exception(system::system_error(errno, BOOST_CHRONO_SYSTEM_CATEGORY, "chrono::process_system_cpu_clock"));
+          boost::throw_exception(system::system_error(errno, ::boost::system::system_category(), "chrono::process_system_cpu_clock"));
         } else
         {
-          ec.assign(errno, BOOST_CHRONO_SYSTEM_CATEGORY);
+          ec.assign(errno, ::boost::system::system_category());
           return time_point();
         }
       } else
@@ -267,19 +267,19 @@ namespace boost
         long factor = chrono_detail::tick_factor();
         if (factor != -1)
         {
-          if (!BOOST_CHRONO_IS_THROWS(ec))
+          if (!::boost::chrono::is_throws(ec))
           {
             ec.clear();
           }
           return time_point(nanoseconds((tm.tms_stime + tm.tms_cstime) * factor));
         } else
         {
-          if (BOOST_CHRONO_IS_THROWS(ec))
+          if (::boost::chrono::is_throws(ec))
           {
-            boost::throw_exception(system::system_error(errno, BOOST_CHRONO_SYSTEM_CATEGORY, "chrono::process_system_cpu_clock"));
+            boost::throw_exception(system::system_error(errno, ::boost::system::system_category(), "chrono::process_system_cpu_clock"));
           } else
           {
-            ec.assign(errno, BOOST_CHRONO_SYSTEM_CATEGORY);
+            ec.assign(errno, ::boost::system::system_category());
             return time_point();
           }
         }
@@ -319,12 +319,12 @@ namespace boost
       clock_t c = ::times(&tm);
       if (c == clock_t(-1)) // error
       {
-        if (BOOST_CHRONO_IS_THROWS(ec))
+        if (::boost::chrono::is_throws(ec))
         {
-          boost::throw_exception(system::system_error(errno, BOOST_CHRONO_SYSTEM_CATEGORY, "chrono::process_clock"));
+          boost::throw_exception(system::system_error(errno, ::boost::system::system_category(), "chrono::process_clock"));
         } else
         {
-          ec.assign(errno, BOOST_CHRONO_SYSTEM_CATEGORY);
+          ec.assign(errno, ::boost::system::system_category());
           return time_point();
         }
       } else
@@ -338,12 +338,12 @@ namespace boost
           return time_point(duration(r));
         } else
         {
-          if (BOOST_CHRONO_IS_THROWS(ec))
+          if (::boost::chrono::is_throws(ec))
           {
-            boost::throw_exception(system::system_error(errno, BOOST_CHRONO_SYSTEM_CATEGORY, "chrono::process_clock"));
+            boost::throw_exception(system::system_error(errno, ::boost::system::system_category(), "chrono::process_clock"));
           } else
           {
-            ec.assign(errno, BOOST_CHRONO_SYSTEM_CATEGORY);
+            ec.assign(errno, ::boost::system::system_category());
             return time_point();
           }
         }

data/src/cxx_supportlib/vendor-modified/boost/chrono/detail/inlined/mac/thread_clock.hpp

@@ -58,21 +58,21 @@ namespace boost { namespace chrono {
         mach_msg_type_number_t count = THREAD_BASIC_INFO_COUNT;
         if ( thread_info(port, THREAD_BASIC_INFO, (thread_info_t)&info, &count) != KERN_SUCCESS )
         {
-            if (BOOST_CHRONO_IS_THROWS(ec))
+            if (::boost::chrono::is_throws(ec))
             {
                 boost::throw_exception(
                         system::system_error(
                                 EINVAL,
-                                BOOST_CHRONO_SYSTEM_CATEGORY,
+                                ::boost::system::system_category(),
                                 "chrono::thread_clock" ));
             }
             else
             {
-                ec.assign( errno, BOOST_CHRONO_SYSTEM_CATEGORY );
+                ec.assign( errno, ::boost::system::system_category() );
                 return time_point();
             }
         }
-        if (!BOOST_CHRONO_IS_THROWS(ec))
+        if (!::boost::chrono::is_throws(ec))
         {
             ec.clear();
         }

data/src/cxx_supportlib/vendor-modified/boost/chrono/detail/inlined/posix/chrono.hpp

@@ -36,22 +36,22 @@ namespace chrono
     timespec ts;
     if ( ::clock_gettime( CLOCK_REALTIME, &ts ) )
     {
-        if (BOOST_CHRONO_IS_THROWS(ec))
+        if (::boost::chrono::is_throws(ec))
         {
             boost::throw_exception(
                     system::system_error(
                             errno,
-                            BOOST_CHRONO_SYSTEM_CATEGORY,
+                            ::boost::system::system_category(),
                             "chrono::system_clock" ));
         }
         else
         {
-            ec.assign( errno, BOOST_CHRONO_SYSTEM_CATEGORY );
+            ec.assign( errno, ::boost::system::system_category() );
             return time_point();
         }
     }
 
-    if (!BOOST_CHRONO_IS_THROWS(ec))
+    if (!::boost::chrono::is_throws(ec))
     {
         ec.clear();
     }
@@ -90,22 +90,22 @@ namespace chrono
     timespec ts;
     if ( ::clock_gettime( CLOCK_MONOTONIC, &ts ) )
     {
-        if (BOOST_CHRONO_IS_THROWS(ec))
+        if (::boost::chrono::is_throws(ec))
         {
             boost::throw_exception(
                     system::system_error(
                             errno,
-                            BOOST_CHRONO_SYSTEM_CATEGORY,
+                            ::boost::system::system_category(),
                             "chrono::steady_clock" ));
         }
         else
         {
-            ec.assign( errno, BOOST_CHRONO_SYSTEM_CATEGORY );
+            ec.assign( errno, ::boost::system::system_category() );
             return time_point();
         }
     }
 
-    if (!BOOST_CHRONO_IS_THROWS(ec))
+    if (!::boost::chrono::is_throws(ec))
     {
         ec.clear();
     }