passenger 6.0.14 → 6.0.27

data/src/cxx_supportlib/vendor-modified/boost/core/bit.hpp

@@ -20,17 +20,46 @@
 #include <boost/cstdint.hpp>
 #include <limits>
 #include <cstring>
+#include <cstdlib>
 
 #if defined(_MSC_VER)
+
 # include <intrin.h>
 # pragma intrinsic(_BitScanForward)
 # pragma intrinsic(_BitScanReverse)
+
 # if defined(_M_X64)
 #  pragma intrinsic(_BitScanForward64)
 #  pragma intrinsic(_BitScanReverse64)
 # endif
+
+# pragma warning(push)
+# pragma warning(disable: 4127) // conditional expression is constant
+# pragma warning(disable: 4244) // conversion from int to T
+
 #endif // defined(_MSC_VER)
 
+#if defined(BOOST_MSVC) && BOOST_MSVC >= 1925
+# define BOOST_CORE_HAS_BUILTIN_ISCONSTEVAL
+#endif
+
+#if defined(__has_builtin)
+# if __has_builtin(__builtin_bit_cast)
+#  define BOOST_CORE_HAS_BUILTIN_BIT_CAST
+# endif
+# if __has_builtin(__builtin_bswap16)
+#  define BOOST_CORE_HAS_BUILTIN_BSWAP16
+# endif
+#endif
+
+#if !defined(BOOST_CORE_HAS_BUILTIN_BIT_CAST) && (defined(BOOST_MSVC) && BOOST_MSVC >= 1926)
+#  define BOOST_CORE_HAS_BUILTIN_BIT_CAST
+#endif
+
+#if !defined(BOOST_CORE_HAS_BUILTIN_BSWAP16) && (defined(BOOST_GCC) && BOOST_GCC >= 40800)
+#  define BOOST_CORE_HAS_BUILTIN_BSWAP16
+#endif
+
 namespace boost
 {
 namespace core
@@ -38,6 +67,16 @@ namespace core
 
 // bit_cast
 
+#if defined(BOOST_CORE_HAS_BUILTIN_BIT_CAST)
+
+template<class To, class From>
+BOOST_CONSTEXPR To bit_cast( From const & from ) BOOST_NOEXCEPT
+{
+    return __builtin_bit_cast( To, from );
+}
+
+#else
+
 template<class To, class From>
 To bit_cast( From const & from ) BOOST_NOEXCEPT
 {
@@ -48,6 +87,8 @@ To bit_cast( From const & from ) BOOST_NOEXCEPT
     return to;
 }
 
+#endif
+
 // countl
 
 #if defined(__GNUC__) || defined(__clang__)
@@ -75,9 +116,9 @@ BOOST_CONSTEXPR inline int countl_impl( unsigned long x ) BOOST_NOEXCEPT
     return x? __builtin_clzl( x ): std::numeric_limits<unsigned long>::digits;
 }
 
-BOOST_CONSTEXPR inline int countl_impl( unsigned long long x ) BOOST_NOEXCEPT
+BOOST_CONSTEXPR inline int countl_impl( boost::ulong_long_type x ) BOOST_NOEXCEPT
 {
-    return x? __builtin_clzll( x ): std::numeric_limits<unsigned long long>::digits;
+    return x? __builtin_clzll( x ): std::numeric_limits<boost::ulong_long_type>::digits;
 }
 
 } // namespace detail
@@ -85,6 +126,8 @@ BOOST_CONSTEXPR inline int countl_impl( unsigned long long x ) BOOST_NOEXCEPT
 template<class T>
 BOOST_CONSTEXPR int countl_zero( T x ) BOOST_NOEXCEPT
 {
+    BOOST_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
+
     return boost::core::detail::countl_impl( x );
 }
 
@@ -93,10 +136,51 @@ BOOST_CONSTEXPR int countl_zero( T x ) BOOST_NOEXCEPT
 namespace detail
 {
 
-inline int countl_impl( boost::uint32_t x ) BOOST_NOEXCEPT
+#if defined(_MSC_VER) && defined(BOOST_CORE_HAS_BUILTIN_ISCONSTEVAL)
+
+BOOST_CXX14_CONSTEXPR inline int countl_impl( boost::uint32_t x ) BOOST_NOEXCEPT
 {
-#if defined(_MSC_VER)
+    if( __builtin_is_constant_evaluated() )
+    {
+        constexpr unsigned char mod37[ 37 ] = { 32, 31, 6, 30, 9, 5, 0, 29, 16, 8, 2, 4, 21, 0, 19, 28, 25, 15, 0, 7, 10, 1, 17, 3, 22, 20, 26, 0, 11, 18, 23, 27, 12, 24, 13, 14, 0 };
 
+        x |= x >> 1;
+        x |= x >> 2;
+        x |= x >> 4;
+        x |= x >> 8;
+        x |= x >> 16;
+
+        return mod37[ x % 37 ];
+    }
+    else
+    {
+        unsigned long r;
+
+        if( _BitScanReverse( &r, x ) )
+        {
+            return 31 - static_cast<int>( r );
+        }
+        else
+        {
+            return 32;
+        }
+    }
+}
+
+BOOST_CXX14_CONSTEXPR inline int countl_impl( boost::uint8_t x ) BOOST_NOEXCEPT
+{
+    return boost::core::detail::countl_impl( static_cast<boost::uint32_t>( x ) ) - 24;
+}
+
+BOOST_CXX14_CONSTEXPR inline int countl_impl( boost::uint16_t x ) BOOST_NOEXCEPT
+{
+    return boost::core::detail::countl_impl( static_cast<boost::uint32_t>( x ) ) - 16;
+}
+
+#elif defined(_MSC_VER)
+
+inline int countl_impl( boost::uint32_t x ) BOOST_NOEXCEPT
+{
     unsigned long r;
 
     if( _BitScanReverse( &r, x ) )
@@ -107,9 +191,22 @@ inline int countl_impl( boost::uint32_t x ) BOOST_NOEXCEPT
     {
         return 32;
     }
+}
+
+inline int countl_impl( boost::uint8_t x ) BOOST_NOEXCEPT
+{
+    return boost::core::detail::countl_impl( static_cast<boost::uint32_t>( x ) ) - 24;
+}
+
+inline int countl_impl( boost::uint16_t x ) BOOST_NOEXCEPT
+{
+    return boost::core::detail::countl_impl( static_cast<boost::uint32_t>( x ) ) - 16;
+}
 
 #else
 
+inline int countl_impl( boost::uint32_t x ) BOOST_NOEXCEPT
+{
     static unsigned char const mod37[ 37 ] = { 32, 31, 6, 30, 9, 5, 0, 29, 16, 8, 2, 4, 21, 0, 19, 28, 25, 15, 0, 7, 10, 1, 17, 3, 22, 20, 26, 0, 11, 18, 23, 27, 12, 24, 13, 14, 0 };
 
     x |= x >> 1;
@@ -119,14 +216,49 @@ inline int countl_impl( boost::uint32_t x ) BOOST_NOEXCEPT
     x |= x >> 16;
 
     return mod37[ x % 37 ];
+}
+
+inline int countl_impl( boost::uint8_t x ) BOOST_NOEXCEPT
+{
+    return boost::core::detail::countl_impl( static_cast<boost::uint32_t>( x ) ) - 24;
+}
+
+inline int countl_impl( boost::uint16_t x ) BOOST_NOEXCEPT
+{
+    return boost::core::detail::countl_impl( static_cast<boost::uint32_t>( x ) ) - 16;
+}
 
 #endif
+
+#if defined(_MSC_VER) && defined(_M_X64) && defined(BOOST_CORE_HAS_BUILTIN_ISCONSTEVAL)
+
+BOOST_CXX14_CONSTEXPR inline int countl_impl( boost::uint64_t x ) BOOST_NOEXCEPT
+{
+    if( __builtin_is_constant_evaluated() )
+    {
+        return static_cast<boost::uint32_t>( x >> 32 ) != 0?
+            boost::core::detail::countl_impl( static_cast<boost::uint32_t>( x >> 32 ) ):
+            boost::core::detail::countl_impl( static_cast<boost::uint32_t>( x ) ) + 32;
+    }
+    else
+    {
+        unsigned long r;
+
+        if( _BitScanReverse64( &r, x ) )
+        {
+            return 63 - static_cast<int>( r );
+        }
+        else
+        {
+            return 64;
+        }
+    }
 }
 
+#elif defined(_MSC_VER) && defined(_M_X64)
+
 inline int countl_impl( boost::uint64_t x ) BOOST_NOEXCEPT
 {
-#if defined(_MSC_VER) && defined(_M_X64)
-
     unsigned long r;
 
     if( _BitScanReverse64( &r, x ) )
@@ -137,42 +269,46 @@ inline int countl_impl( boost::uint64_t x ) BOOST_NOEXCEPT
     {
         return 64;
     }
+}
 
-#else
+#elif defined(_MSC_VER) && defined(BOOST_CORE_HAS_BUILTIN_ISCONSTEVAL)
 
+BOOST_CXX14_CONSTEXPR inline int countl_impl( boost::uint64_t x ) BOOST_NOEXCEPT
+{
     return static_cast<boost::uint32_t>( x >> 32 ) != 0?
         boost::core::detail::countl_impl( static_cast<boost::uint32_t>( x >> 32 ) ):
         boost::core::detail::countl_impl( static_cast<boost::uint32_t>( x ) ) + 32;
-
-#endif
 }
 
-inline int countl_impl( boost::uint8_t x ) BOOST_NOEXCEPT
-{
-    return boost::core::detail::countl_impl( static_cast<boost::uint32_t>( x ) ) - 24;
-}
+#else
 
-inline int countl_impl( boost::uint16_t x ) BOOST_NOEXCEPT
+inline int countl_impl( boost::uint64_t x ) BOOST_NOEXCEPT
 {
-    return boost::core::detail::countl_impl( static_cast<boost::uint32_t>( x ) ) - 16;
+    return static_cast<boost::uint32_t>( x >> 32 ) != 0?
+        boost::core::detail::countl_impl( static_cast<boost::uint32_t>( x >> 32 ) ):
+        boost::core::detail::countl_impl( static_cast<boost::uint32_t>( x ) ) + 32;
 }
 
+#endif
+
 } // namespace detail
 
 template<class T>
-int countl_zero( T x ) BOOST_NOEXCEPT
+BOOST_CXX14_CONSTEXPR int countl_zero( T x ) BOOST_NOEXCEPT
 {
+    BOOST_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
+
     BOOST_STATIC_ASSERT( sizeof(T) == sizeof(boost::uint8_t) || sizeof(T) == sizeof(boost::uint16_t) || sizeof(T) == sizeof(boost::uint32_t) || sizeof(T) == sizeof(boost::uint64_t) );
 
-    if( sizeof(T) == sizeof(boost::uint8_t) )
+    BOOST_IF_CONSTEXPR ( sizeof(T) == sizeof(boost::uint8_t) )
     {
         return boost::core::detail::countl_impl( static_cast<boost::uint8_t>( x ) );
     }
-    else if( sizeof(T) == sizeof(boost::uint16_t) )
+    else BOOST_IF_CONSTEXPR ( sizeof(T) == sizeof(boost::uint16_t) )
     {
         return boost::core::detail::countl_impl( static_cast<boost::uint16_t>( x ) );
     }
-    else if( sizeof(T) == sizeof(boost::uint32_t) )
+    else BOOST_IF_CONSTEXPR ( sizeof(T) == sizeof(boost::uint32_t) )
     {
         return boost::core::detail::countl_impl( static_cast<boost::uint32_t>( x ) );
     }
@@ -187,6 +323,8 @@ int countl_zero( T x ) BOOST_NOEXCEPT
 template<class T>
 BOOST_CONSTEXPR int countl_one( T x ) BOOST_NOEXCEPT
 {
+    BOOST_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
+
     return boost::core::countl_zero( static_cast<T>( ~x ) );
 }
 
@@ -217,9 +355,9 @@ BOOST_CONSTEXPR inline int countr_impl( unsigned long x ) BOOST_NOEXCEPT
     return x? __builtin_ctzl( x ): std::numeric_limits<unsigned long>::digits;
 }
 
-BOOST_CONSTEXPR inline int countr_impl( unsigned long long x ) BOOST_NOEXCEPT
+BOOST_CONSTEXPR inline int countr_impl( boost::ulong_long_type x ) BOOST_NOEXCEPT
 {
-    return x? __builtin_ctzll( x ): std::numeric_limits<unsigned long long>::digits;
+    return x? __builtin_ctzll( x ): std::numeric_limits<boost::ulong_long_type>::digits;
 }
 
 } // namespace detail
@@ -227,6 +365,8 @@ BOOST_CONSTEXPR inline int countr_impl( unsigned long long x ) BOOST_NOEXCEPT
 template<class T>
 BOOST_CONSTEXPR int countr_zero( T x ) BOOST_NOEXCEPT
 {
+    BOOST_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
+
     return boost::core::detail::countr_impl( x );
 }
 
@@ -235,10 +375,44 @@ BOOST_CONSTEXPR int countr_zero( T x ) BOOST_NOEXCEPT
 namespace detail
 {
 
-inline int countr_impl( boost::uint32_t x ) BOOST_NOEXCEPT
+#if defined(_MSC_VER) && defined(BOOST_CORE_HAS_BUILTIN_ISCONSTEVAL)
+
+BOOST_CXX14_CONSTEXPR inline int countr_impl( boost::uint32_t x ) BOOST_NOEXCEPT
 {
-#if defined(_MSC_VER)
+    if( __builtin_is_constant_evaluated() )
+    {
+        constexpr unsigned char mod37[ 37 ] = { 32, 0, 1, 26, 2, 23, 27, 0, 3, 16, 24, 30, 28, 11, 0, 13, 4, 7, 17, 0, 25, 22, 31, 15, 29, 10, 12, 6, 0, 21, 14, 9, 5, 20, 8, 19, 18 };
+        return mod37[ ( -(boost::int32_t)x & x ) % 37 ];
+    }
+    else
+    {
+        unsigned long r;
+
+        if( _BitScanForward( &r, x ) )
+        {
+            return static_cast<int>( r );
+        }
+        else
+        {
+            return 32;
+        }
+    }
+}
+
+BOOST_CXX14_CONSTEXPR inline int countr_impl( boost::uint8_t x ) BOOST_NOEXCEPT
+{
+    return boost::core::detail::countr_impl( static_cast<boost::uint32_t>( x ) | 0x100 );
+}
 
+BOOST_CXX14_CONSTEXPR inline int countr_impl( boost::uint16_t x ) BOOST_NOEXCEPT
+{
+    return boost::core::detail::countr_impl( static_cast<boost::uint32_t>( x ) | 0x10000 );
+}
+
+#elif defined(_MSC_VER)
+
+inline int countr_impl( boost::uint32_t x ) BOOST_NOEXCEPT
+{
     unsigned long r;
 
     if( _BitScanForward( &r, x ) )
@@ -249,19 +423,67 @@ inline int countr_impl( boost::uint32_t x ) BOOST_NOEXCEPT
     {
         return 32;
     }
+}
+
+inline int countr_impl( boost::uint8_t x ) BOOST_NOEXCEPT
+{
+    return boost::core::detail::countr_impl( static_cast<boost::uint32_t>( x ) | 0x100 );
+}
+
+inline int countr_impl( boost::uint16_t x ) BOOST_NOEXCEPT
+{
+    return boost::core::detail::countr_impl( static_cast<boost::uint32_t>( x ) | 0x10000 );
+}
 
 #else
 
+inline int countr_impl( boost::uint32_t x ) BOOST_NOEXCEPT
+{
     static unsigned char const mod37[ 37 ] = { 32, 0, 1, 26, 2, 23, 27, 0, 3, 16, 24, 30, 28, 11, 0, 13, 4, 7, 17, 0, 25, 22, 31, 15, 29, 10, 12, 6, 0, 21, 14, 9, 5, 20, 8, 19, 18 };
     return mod37[ ( -(boost::int32_t)x & x ) % 37 ];
+}
+
+inline int countr_impl( boost::uint8_t x ) BOOST_NOEXCEPT
+{
+    return boost::core::detail::countr_impl( static_cast<boost::uint32_t>( x ) | 0x100 );
+}
+
+inline int countr_impl( boost::uint16_t x ) BOOST_NOEXCEPT
+{
+    return boost::core::detail::countr_impl( static_cast<boost::uint32_t>( x ) | 0x10000 );
+}
 
 #endif
+
+#if defined(_MSC_VER) && defined(_M_X64) && defined(BOOST_CORE_HAS_BUILTIN_ISCONSTEVAL)
+
+BOOST_CXX14_CONSTEXPR inline int countr_impl( boost::uint64_t x ) BOOST_NOEXCEPT
+{
+    if( __builtin_is_constant_evaluated() )
+    {
+        return static_cast<boost::uint32_t>( x ) != 0?
+            boost::core::detail::countr_impl( static_cast<boost::uint32_t>( x ) ):
+            boost::core::detail::countr_impl( static_cast<boost::uint32_t>( x >> 32 ) ) + 32;
+    }
+    else
+    {
+        unsigned long r;
+
+        if( _BitScanForward64( &r, x ) )
+        {
+            return static_cast<int>( r );
+        }
+        else
+        {
+            return 64;
+        }
+    }
 }
 
+#elif defined(_MSC_VER) && defined(_M_X64)
+
 inline int countr_impl( boost::uint64_t x ) BOOST_NOEXCEPT
 {
-#if defined(_MSC_VER) && defined(_M_X64)
-
     unsigned long r;
 
     if( _BitScanForward64( &r, x ) )
@@ -272,42 +494,46 @@ inline int countr_impl( boost::uint64_t x ) BOOST_NOEXCEPT
     {
         return 64;
     }
+}
 
-#else
+#elif defined(_MSC_VER) && defined(BOOST_CORE_HAS_BUILTIN_ISCONSTEVAL)
 
+BOOST_CXX14_CONSTEXPR inline int countr_impl( boost::uint64_t x ) BOOST_NOEXCEPT
+{
     return static_cast<boost::uint32_t>( x ) != 0?
         boost::core::detail::countr_impl( static_cast<boost::uint32_t>( x ) ):
         boost::core::detail::countr_impl( static_cast<boost::uint32_t>( x >> 32 ) ) + 32;
-
-#endif
 }
 
-inline int countr_impl( boost::uint8_t x ) BOOST_NOEXCEPT
-{
-    return boost::core::detail::countr_impl( static_cast<boost::uint32_t>( x ) | 0x100 );
-}
+#else
 
-inline int countr_impl( boost::uint16_t x ) BOOST_NOEXCEPT
+inline int countr_impl( boost::uint64_t x ) BOOST_NOEXCEPT
 {
-    return boost::core::detail::countr_impl( static_cast<boost::uint32_t>( x ) | 0x10000 );
+    return static_cast<boost::uint32_t>( x ) != 0?
+        boost::core::detail::countr_impl( static_cast<boost::uint32_t>( x ) ):
+        boost::core::detail::countr_impl( static_cast<boost::uint32_t>( x >> 32 ) ) + 32;
 }
 
+#endif
+
 } // namespace detail
 
 template<class T>
-int countr_zero( T x ) BOOST_NOEXCEPT
+BOOST_CXX14_CONSTEXPR int countr_zero( T x ) BOOST_NOEXCEPT
 {
+    BOOST_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
+
     BOOST_STATIC_ASSERT( sizeof(T) == sizeof(boost::uint8_t) || sizeof(T) == sizeof(boost::uint16_t) || sizeof(T) == sizeof(boost::uint32_t) || sizeof(T) == sizeof(boost::uint64_t) );
 
-    if( sizeof(T) == sizeof(boost::uint8_t) )
+    BOOST_IF_CONSTEXPR ( sizeof(T) == sizeof(boost::uint8_t) )
     {
         return boost::core::detail::countr_impl( static_cast<boost::uint8_t>( x ) );
     }
-    else if( sizeof(T) == sizeof(boost::uint16_t) )
+    else BOOST_IF_CONSTEXPR ( sizeof(T) == sizeof(boost::uint16_t) )
     {
         return boost::core::detail::countr_impl( static_cast<boost::uint16_t>( x ) );
     }
-    else if( sizeof(T) == sizeof(boost::uint32_t) )
+    else BOOST_IF_CONSTEXPR ( sizeof(T) == sizeof(boost::uint32_t) )
     {
         return boost::core::detail::countr_impl( static_cast<boost::uint32_t>( x ) );
     }
@@ -322,6 +548,8 @@ int countr_zero( T x ) BOOST_NOEXCEPT
 template<class T>
 BOOST_CONSTEXPR int countr_one( T x ) BOOST_NOEXCEPT
 {
+    BOOST_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
+
     return boost::core::countr_zero( static_cast<T>( ~x ) );
 }
 
@@ -358,7 +586,7 @@ BOOST_CORE_POPCOUNT_CONSTEXPR inline int popcount_impl( unsigned long x ) BOOST_
     return __builtin_popcountl( x );
 }
 
-BOOST_CORE_POPCOUNT_CONSTEXPR inline int popcount_impl( unsigned long long x ) BOOST_NOEXCEPT
+BOOST_CORE_POPCOUNT_CONSTEXPR inline int popcount_impl( boost::ulong_long_type x ) BOOST_NOEXCEPT
 {
     return __builtin_popcountll( x );
 }
@@ -370,6 +598,8 @@ BOOST_CORE_POPCOUNT_CONSTEXPR inline int popcount_impl( unsigned long long x ) B
 template<class T>
 BOOST_CONSTEXPR int popcount( T x ) BOOST_NOEXCEPT
 {
+    BOOST_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
+
     return boost::core::detail::popcount_impl( x );
 }
 
@@ -401,9 +631,11 @@ BOOST_CXX14_CONSTEXPR inline int popcount_impl( boost::uint64_t x ) BOOST_NOEXCE
 template<class T>
 BOOST_CXX14_CONSTEXPR int popcount( T x ) BOOST_NOEXCEPT
 {
+    BOOST_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
+
     BOOST_STATIC_ASSERT( sizeof(T) <= sizeof(boost::uint64_t) );
 
-    if( sizeof(T) <= sizeof(boost::uint32_t) )
+    BOOST_IF_CONSTEXPR ( sizeof(T) <= sizeof(boost::uint32_t) )
     {
         return boost::core::detail::popcount_impl( static_cast<boost::uint32_t>( x ) );
     }
@@ -420,15 +652,19 @@ BOOST_CXX14_CONSTEXPR int popcount( T x ) BOOST_NOEXCEPT
 template<class T>
 BOOST_CXX14_CONSTEXPR T rotl( T x, int s ) BOOST_NOEXCEPT
 {
+    BOOST_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
+
     unsigned const mask = std::numeric_limits<T>::digits - 1;
-    return x << (s & mask) | x >> ((-s) & mask);
+    return static_cast<T>( x << (static_cast<unsigned>( s ) & mask) | x >> (static_cast<unsigned>( -s ) & mask) );
 }
 
 template<class T>
 BOOST_CXX14_CONSTEXPR T rotr( T x, int s ) BOOST_NOEXCEPT
 {
+    BOOST_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
+
     unsigned const mask = std::numeric_limits<T>::digits - 1;
-    return x >> (s & mask) | x << ((-s) & mask);
+    return static_cast<T>( x >> (static_cast<unsigned>( s ) & mask) | x << (static_cast<unsigned>( -s ) & mask) );
 }
 
 // integral powers of 2
@@ -436,19 +672,28 @@ BOOST_CXX14_CONSTEXPR T rotr( T x, int s ) BOOST_NOEXCEPT
 template<class T>
 BOOST_CONSTEXPR bool has_single_bit( T x ) BOOST_NOEXCEPT
 {
+    BOOST_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
+
     return x != 0 && ( x & ( x - 1 ) ) == 0;
 }
 
+// bit_width returns `int` now, https://cplusplus.github.io/LWG/issue3656
+// has been applied to C++20 as a DR
+
 template<class T>
-BOOST_CONSTEXPR T bit_width( T x ) BOOST_NOEXCEPT
+BOOST_CONSTEXPR int bit_width( T x ) BOOST_NOEXCEPT
 {
+    BOOST_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
+
     return std::numeric_limits<T>::digits - boost::core::countl_zero( x );
 }
 
 template<class T>
 BOOST_CONSTEXPR T bit_floor( T x ) BOOST_NOEXCEPT
 {
-    return x == 0? 0: T(1) << ( boost::core::bit_width( x ) - 1 );
+    BOOST_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
+
+    return x == 0? T(0): static_cast<T>( T(1) << ( boost::core::bit_width( x ) - 1 ) );
 }
 
 namespace detail
@@ -500,9 +745,11 @@ BOOST_CXX14_CONSTEXPR inline boost::uint64_t bit_ceil_impl( boost::uint64_t x )
 template<class T>
 BOOST_CXX14_CONSTEXPR T bit_ceil( T x ) BOOST_NOEXCEPT
 {
+    BOOST_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
+
     BOOST_STATIC_ASSERT( sizeof(T) <= sizeof(boost::uint64_t) );
 
-    if( sizeof(T) <= sizeof(boost::uint32_t) )
+    BOOST_IF_CONSTEXPR ( sizeof(T) <= sizeof(boost::uint32_t) )
     {
         return static_cast<T>( boost::core::detail::bit_ceil_impl( static_cast<boost::uint32_t>( x ) ) );
     }
@@ -575,7 +822,133 @@ typedef endian::type endian_type;
 
 #undef BOOST_CORE_BIT_NATIVE_INITIALIZER
 
+// byteswap
+
+namespace detail
+{
+
+BOOST_CONSTEXPR inline boost::uint8_t byteswap_impl( boost::uint8_t x ) BOOST_NOEXCEPT
+{
+    return x;
+}
+
+#if defined(BOOST_CORE_HAS_BUILTIN_BSWAP16)
+
+BOOST_CONSTEXPR inline boost::uint16_t byteswap_impl( boost::uint16_t x ) BOOST_NOEXCEPT
+{
+    return __builtin_bswap16( x );
+}
+
+#else
+
+BOOST_CONSTEXPR inline boost::uint16_t byteswap_impl( boost::uint16_t x ) BOOST_NOEXCEPT
+{
+    return static_cast<boost::uint16_t>( x << 8 | x >> 8 );
+}
+
+#endif
+
+#if defined(__GNUC__) || defined(__clang__)
+
+BOOST_CXX14_CONSTEXPR inline boost::uint32_t byteswap_impl( boost::uint32_t x ) BOOST_NOEXCEPT
+{
+    return __builtin_bswap32( x );
+}
+
+BOOST_CXX14_CONSTEXPR inline boost::uint64_t byteswap_impl( boost::uint64_t x ) BOOST_NOEXCEPT
+{
+    return __builtin_bswap64( x );
+}
+
+#elif defined(_MSC_VER) && defined(BOOST_CORE_HAS_BUILTIN_ISCONSTEVAL)
+
+BOOST_CXX14_CONSTEXPR inline boost::uint32_t byteswap_impl( boost::uint32_t x ) BOOST_NOEXCEPT
+{
+    if( __builtin_is_constant_evaluated() )
+    {
+        boost::uint32_t step16 = x << 16 | x >> 16;
+        return ((step16 << 8) & 0xff00ff00) | ((step16 >> 8) & 0x00ff00ff);
+    }
+    else
+    {
+        return _byteswap_ulong( x );
+    }
+}
+
+BOOST_CXX14_CONSTEXPR inline boost::uint64_t byteswap_impl( boost::uint64_t x ) BOOST_NOEXCEPT
+{
+    if( __builtin_is_constant_evaluated() )
+    {
+        boost::uint64_t step32 = x << 32 | x >> 32;
+        boost::uint64_t step16 = (step32 & 0x0000FFFF0000FFFFULL) << 16 | (step32 & 0xFFFF0000FFFF0000ULL) >> 16;
+        return (step16 & 0x00FF00FF00FF00FFULL) << 8 | (step16 & 0xFF00FF00FF00FF00ULL) >> 8;
+    }
+    else
+    {
+        return _byteswap_uint64( x );
+    }
+}
+
+#elif defined(_MSC_VER)
+
+inline boost::uint32_t byteswap_impl( boost::uint32_t x ) BOOST_NOEXCEPT
+{
+    return _byteswap_ulong( x );
+}
+
+inline boost::uint64_t byteswap_impl( boost::uint64_t x ) BOOST_NOEXCEPT
+{
+    return _byteswap_uint64( x );
+}
+
+#else
+
+BOOST_CXX14_CONSTEXPR inline boost::uint32_t byteswap_impl( boost::uint32_t x ) BOOST_NOEXCEPT
+{
+    boost::uint32_t step16 = x << 16 | x >> 16;
+    return ((step16 << 8) & 0xff00ff00) | ((step16 >> 8) & 0x00ff00ff);
+}
+
+BOOST_CXX14_CONSTEXPR inline boost::uint64_t byteswap_impl( boost::uint64_t x ) BOOST_NOEXCEPT
+{
+    boost::uint64_t step32 = x << 32 | x >> 32;
+    boost::uint64_t step16 = (step32 & 0x0000FFFF0000FFFFULL) << 16 | (step32 & 0xFFFF0000FFFF0000ULL) >> 16;
+    return (step16 & 0x00FF00FF00FF00FFULL) << 8 | (step16 & 0xFF00FF00FF00FF00ULL) >> 8;
+}
+
+#endif
+
+} // namespace detail
+
+template<class T> BOOST_CXX14_CONSTEXPR T byteswap( T x ) BOOST_NOEXCEPT
+{
+    BOOST_STATIC_ASSERT( std::numeric_limits<T>::is_integer );
+
+    BOOST_STATIC_ASSERT( sizeof(T) == sizeof(boost::uint8_t) || sizeof(T) == sizeof(boost::uint16_t) || sizeof(T) == sizeof(boost::uint32_t) || sizeof(T) == sizeof(boost::uint64_t) );
+
+    BOOST_IF_CONSTEXPR ( sizeof(T) == sizeof(boost::uint8_t) )
+    {
+        return static_cast<T>( boost::core::detail::byteswap_impl( static_cast<boost::uint8_t>( x ) ) );
+    }
+    else BOOST_IF_CONSTEXPR ( sizeof(T) == sizeof(boost::uint16_t) )
+    {
+        return static_cast<T>( boost::core::detail::byteswap_impl( static_cast<boost::uint16_t>( x ) ) );
+    }
+    else BOOST_IF_CONSTEXPR ( sizeof(T) == sizeof(boost::uint32_t) )
+    {
+        return static_cast<T>( boost::core::detail::byteswap_impl( static_cast<boost::uint32_t>( x ) ) );
+    }
+    else
+    {
+        return static_cast<T>( boost::core::detail::byteswap_impl( static_cast<boost::uint64_t>( x ) ) );
+    }
+}
+
 } // namespace core
 } // namespace boost
 
+#if defined(_MSC_VER)
+# pragma warning(pop)
+#endif
+
 #endif  // #ifndef BOOST_CORE_BIT_HPP_INCLUDED