long-double

Author: izvolov

libcxx/include/__algorithm/radix_sort.h

@@ -337,6 +337,22 @@ using __unsigned_integer_of_size_t _LIBCPP_NODEBUG = typename __unsigned_integer
 template <class _Sc>
 using __unsigned_representation_for_t _LIBCPP_NODEBUG = __unsigned_integer_of_size_t<sizeof(_Sc)>;
 
+// Returns number of bits that are actually used by a floating-point type.
+
+// Counts the number of leading zero bits after the sign bit, and subtracts it from the total number of bits in the
+// integer representation.
+// E.g. there are platforms, where `sizeof(long double)` is equal to 16, but only 80 of 128 bits are actually used to
+// represent a floating point number, and the remaining bits are zero-padded. In these cases we need to determine the
+// actual bit capacity of `long double`.
+
+// Suitable for all IEEE 754 floats, but designed specifically for zero-padded 80-bit `long double`.
+template <class _Floating, enable_if_t< numeric_limits<_Floating>::is_iec559, int> = 0>
+_LIBCPP_HIDE_FROM_ABI constexpr size_t __bit_capacity() noexcept {
+  using __integral_type = __unsigned_representation_for_t<_Floating>;
+  return numeric_limits<__integral_type>::digits -
+         std::__countl_zero(std::__bit_cast<__integral_type>(-numeric_limits<_Floating>::infinity()));
+}
+
 // The function `__to_ordered_integral` is defined for integers and IEEE 754 floating-point numbers.
 // Returns an integer representation such that for any `x` and `y` such that `x < y`, the expression
 // `__to_ordered_integral(x) < __to_ordered_integral(y)` is true, where `x`, `y` are integers or IEEE 754 floats.
@@ -367,12 +383,13 @@ _LIBCPP_HIDE_FROM_ABI constexpr auto __to_ordered_integral(_Integral __n) {
 template <class _Floating, enable_if_t< numeric_limits<_Floating>::is_iec559, int> = 0>
 _LIBCPP_HIDE_FROM_ABI constexpr auto __to_ordered_integral(_Floating __f) {
   using __integral_type          = __unsigned_representation_for_t<_Floating>;
-  constexpr auto __bit_count     = std::numeric_limits<__integral_type>::digits;
+  constexpr auto __bit_count     = std::__bit_capacity<_Floating>();
   constexpr auto __sign_bit_mask = static_cast<__integral_type>(__integral_type{1} << (__bit_count - 1));
+  constexpr auto __all_bits_mask = static_cast<__integral_type>((__sign_bit_mask - 1) | __sign_bit_mask);
 
   const auto __u = std::__bit_cast<__integral_type>(__f);
 
-  return static_cast<__integral_type>(__u & __sign_bit_mask ? ~__u : __u ^ __sign_bit_mask);
+  return static_cast<__integral_type>(__u & __sign_bit_mask ? __u ^ __all_bits_mask : __u ^ __sign_bit_mask);
 }
 
 // There may exist user-defined comparison for enum, so we cannot compare enums just like integers.

libcxx/test/std/algorithms/alg.sorting/alg.sort/stable.sort/stable_sort.pass.cpp

@@ -250,6 +250,7 @@ int main(int, char**) {
   test<int>();
   test_floating<float>();
   test_floating<double>();
+  test_floating<long double>();
   test_enum();
 #if TEST_STD_VER >= 26
   static_assert(test<int>());