[libc] Add get_explicit_exponent to fpbits

[michaelrj]

Summary

In the same way that get_explicit_mantissa is used to get the mantissa
with all the implicit bits spelled out, get_explicit_exponent gives you
the exponent with the special cases handled. Mainly it handles the cases
where the exponent is zero, which causes the exponent to either be 1
higher than expected, or just 0.

[michaelrj]

move explicit exponent changes in printf floats to this patch

[michaelrj]

the rest of the explicit exponent changes

[michaelrj]

fix 80 bit sqrt

[lntue]

libc/src/__support/FPUtil/x86_64/LongDoubleBits.h

150

In most of the conventions for floating point exponents, zeros are often grouped together with denormal numbers. Unless it's used in more places, do you think the logic that requires different ways of handling exponents of zeros can be put locally to those functions?

[michaelrj]

libc/src/__support/FPUtil/x86_64/LongDoubleBits.h

150

We can handle subnormals and zero in the individual places, that's what I was doing before, but I added this function because I realized it was repeated.

Regardless of if we add the new function, we should keep the change for long double get_exponent because otherwise it behaves differently from other float types.

libc/src/__support/FPUtil/FPBits.h

template <typename T> struct FPBits {
   LIBC_INLINE explicit operator T() const { return get_val(); }
 
   LIBC_INLINE UIntType uintval() const { return bits; }
 
   LIBC_INLINE int get_exponent() const {
     return int(get_unbiased_exponent()) - EXPONENT_BIAS;
   }
 
+  // If the number is subnormal, the exponent is treated as if it were the
+  // minimum exponent for a normal number. This is to keep continuity between
+  // the normal and subnormal ranges, but it causes problems for functions where
+  // values are calculated from the exponent, since just subtracting the bias
+  // will give a slightly incorrect result. Additionally, zero has an exponent
+  // of zero, and that should actually be treated as zero.
+  LIBC_INLINE int get_explicit_exponent() const {
+    const int unbiased_exp = int(get_unbiased_exponent());
+    if (is_zero()) {
+      return 0;
+    } else if (unbiased_exp == 0) {
+      return 1 - EXPONENT_BIAS;
+    } else {
+      return unbiased_exp - EXPONENT_BIAS;
+    }
+  }
+
   LIBC_INLINE bool is_zero() const {
     // Remove sign bit by shift
     return (bits << 1) == 0;
   }
 
   LIBC_INLINE bool is_inf() const {
     return (bits & FloatProp::EXP_MANT_MASK) == FloatProp::EXPONENT_MASK;
   }

libc/src/__support/FPUtil/generic/sqrt_80_bit_long_double.h

LIBC_INLINE long double sqrt(long double x) {
   } else if (bits.is_zero()) {
     // sqrt(+0) = +0
     // sqrt(-0) = -0
     return x;
   } else if (bits.get_sign()) {
     // sqrt( negative numbers ) = NaN
     return FPBits<long double>::build_quiet_nan(ONE >> 1);
   } else {
-    int x_exp = bits.get_exponent();
+    int x_exp = bits.get_explicit_exponent();
     UIntType x_mant = bits.get_mantissa();
 
     // Step 1a: Normalize denormal input
     if (bits.get_implicit_bit()) {
       x_mant |= ONE;
     } else if (bits.get_unbiased_exponent() == 0) {
       normalize(x_exp, x_mant);
     }

libc/src/__support/FPUtil/x86_64/LongDoubleBits.h

LIBC_INLINE UIntType uintval() {
     return bits & MASK;
   }
 
   LIBC_INLINE long double get_val() const {
     return cpp::bit_cast<long double>(bits);
   }
 
   LIBC_INLINE int get_exponent() const {
-    if (get_unbiased_exponent() == 0)
-      return int(1) - EXPONENT_BIAS;
     return int(get_unbiased_exponent()) - EXPONENT_BIAS;
   }
 
+  // If the number is subnormal, the exponent is treated as if it were the
+  // minimum exponent for a normal number. This is to keep continuity between
+  // the normal and subnormal ranges, but it causes problems for functions where
+  // values are calculated from the exponent, since just subtracting the bias
+  // will give a slightly incorrect result. Additionally, zero has an exponent
+  // of zero, and that should actually be treated as zero.
+  LIBC_INLINE int get_explicit_exponent() const {
+    const int unbiased_exp = int(get_unbiased_exponent());
+    if (is_zero()) {
+      return 0;
+    } else if (unbiased_exp == 0) {
+      return 1 - EXPONENT_BIAS;
+    } else {
+      return unbiased_exp - EXPONENT_BIAS;
+    }
+  }
+
   LIBC_INLINE bool is_zero() const {
     return get_unbiased_exponent() == 0 && get_mantissa() == 0 &&
            get_implicit_bit() == 0;
   }
 
   LIBC_INLINE bool is_inf() const {
     return get_unbiased_exponent() == MAX_EXPONENT && get_mantissa() == 0 &&
            get_implicit_bit() == 1;

libc/src/__support/float_to_string.h

class FloatToString {
   MantissaInt mantissa;
 
   static constexpr int MANT_WIDTH = fputil::MantissaWidth<T>::VALUE;
   static constexpr int EXP_BIAS = fputil::FPBits<T>::EXPONENT_BIAS;
 
 public:
   LIBC_INLINE constexpr FloatToString(T init_float) : float_bits(init_float) {
     is_negative = float_bits.get_sign();
-    exponent = float_bits.get_exponent();
+    exponent = float_bits.get_explicit_exponent();
     mantissa = float_bits.get_explicit_mantissa();
 
-    // Handle the exponent for numbers with a 0 exponent.
-    if (exponent == -EXP_BIAS) {
-      if (mantissa > 0) { // Subnormals
-        ++exponent;
-      } else { // Zeroes
-        exponent = 0;
-      }
-    }
-
     // Adjust for the width of the mantissa.
     exponent -= MANT_WIDTH;
 
     // init_convert();
   }
 
   LIBC_INLINE constexpr bool is_nan() { return float_bits.is_nan(); }
   LIBC_INLINE constexpr bool is_inf() { return float_bits.is_inf(); }

libc/src/stdio/printf_core/float_dec_converter.h

 // https://doi.org/10.1145/3360595
 template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0>
 LIBC_INLINE int convert_float_decimal_typed(Writer *writer,
                                             const FormatSection &to_conv,
                                             fputil::FPBits<T> float_bits) {
   // signed because later we use -MANT_WIDTH
   constexpr int32_t MANT_WIDTH = fputil::MantissaWidth<T>::VALUE;
   bool is_negative = float_bits.get_sign();
-  int exponent = float_bits.get_exponent();
+  int exponent = float_bits.get_explicit_exponent();
 
   char sign_char = 0;
 
   if (is_negative)
     sign_char = '-';
   else if ((to_conv.flags & FormatFlags::FORCE_SIGN) == FormatFlags::FORCE_SIGN)
     sign_char = '+'; // FORCE_SIGN has precedence over SPACE_PREFIX
   else if ((to_conv.flags & FormatFlags::SPACE_PREFIX) ==

 
 template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0>
 LIBC_INLINE int convert_float_dec_exp_typed(Writer *writer,
                                             const FormatSection &to_conv,
                                             fputil::FPBits<T> float_bits) {
   // signed because later we use -MANT_WIDTH
   constexpr int32_t MANT_WIDTH = fputil::MantissaWidth<T>::VALUE;
   bool is_negative = float_bits.get_sign();
-  int exponent = float_bits.get_exponent();
+  int exponent = float_bits.get_explicit_exponent();
   MantissaInt mantissa = float_bits.get_explicit_mantissa();
 
   const char a = (to_conv.conv_name & 32) | 'A';
 
   char sign_char = 0;
 
   if (is_negative)
     sign_char = '-';

 
 template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0>
 LIBC_INLINE int convert_float_dec_auto_typed(Writer *writer,
                                              const FormatSection &to_conv,
                                              fputil::FPBits<T> float_bits) {
   // signed because later we use -MANT_WIDTH
   constexpr int32_t MANT_WIDTH = fputil::MantissaWidth<T>::VALUE;
   bool is_negative = float_bits.get_sign();
-  int exponent = float_bits.get_exponent();
+  int exponent = float_bits.get_explicit_exponent();
   MantissaInt mantissa = float_bits.get_explicit_mantissa();
 
   // From the standard: Let P (init_precision) equal the precision if nonzero, 6
   // if the precision is omitted, or 1 if the precision is zero.
   const unsigned int init_precision = to_conv.precision <= 0
                                           ? (to_conv.precision == 0 ? 1 : 6)
                                           : to_conv.precision;
 

libc/src/stdio/printf_core/float_hex_converter.h

LIBC_INLINE int convert_float_hex_exp(Writer *writer,
   // conversion name into the letter 'a' with the appropriate case.
   const char a = (to_conv.conv_name & 32) | 'A';
 
   bool is_negative;
   int exponent;
   MantissaInt mantissa;
   bool is_inf_or_nan;
   uint32_t mantissa_width;
-  int exponent_bias;
   if (to_conv.length_modifier == LengthModifier::L) {
     mantissa_width = fputil::MantissaWidth<long double>::VALUE;
-    exponent_bias = fputil::FPBits<long double>::EXPONENT_BIAS;
     fputil::FPBits<long double>::UIntType float_raw = to_conv.conv_val_raw;
     fputil::FPBits<long double> float_bits(float_raw);
     is_negative = float_bits.get_sign();
-    exponent = float_bits.get_exponent();
+    exponent = float_bits.get_explicit_exponent();
     mantissa = float_bits.get_explicit_mantissa();
     is_inf_or_nan = float_bits.is_inf_or_nan();
   } else {
     mantissa_width = fputil::MantissaWidth<double>::VALUE;
-    exponent_bias = fputil::FPBits<double>::EXPONENT_BIAS;
     fputil::FPBits<double>::UIntType float_raw =
         static_cast<fputil::FPBits<double>::UIntType>(to_conv.conv_val_raw);
     fputil::FPBits<double> float_bits(float_raw);
     is_negative = float_bits.get_sign();
-    exponent = float_bits.get_exponent();
+    exponent = float_bits.get_explicit_exponent();
     mantissa = float_bits.get_explicit_mantissa();
     is_inf_or_nan = float_bits.is_inf_or_nan();
   }
 
   if (is_inf_or_nan)
     return convert_inf_nan(writer, to_conv);
 
   char sign_char = 0;
 
   if (is_negative)
     sign_char = '-';
   else if ((to_conv.flags & FormatFlags::FORCE_SIGN) == FormatFlags::FORCE_SIGN)
     sign_char = '+'; // FORCE_SIGN has precedence over SPACE_PREFIX
   else if ((to_conv.flags & FormatFlags::SPACE_PREFIX) ==
            FormatFlags::SPACE_PREFIX)
     sign_char = ' ';
 
-  // Handle the exponent for numbers with a 0 exponent
-  if (exponent == -exponent_bias) {
-    if (mantissa > 0) // Subnormals
-      ++exponent;
-    else // Zeroes
-      exponent = 0;
-  }
-
   constexpr size_t BITS_IN_HEX_DIGIT = 4;
 
   // This is to handle situations where the mantissa isn't an even number of hex
   // digits. This is primarily relevant for x86 80 bit long doubles, which have
   // 63 bit mantissas.
   if (mantissa_width % BITS_IN_HEX_DIGIT != 0) {
     exponent -= mantissa_width % BITS_IN_HEX_DIGIT;
   }