[libc] Add explicit constructor calls to fix compilation when using UInt<T>

[mikhail.ramalho]

Summary

This patch is similar to 86fe88c8d9 and adds several explicit
constructor calls (bool(...), uint64_t(...), uint8_t(...)) that are
needed when we use UInt<T> (in my case UInt<128> in riscv32).

This patch also adds two operators to UInt<T>:

• operator/= required by printf_core/float_hex_converter.h:148
• operator-- required by FPUtil/ManipulationFunctions.h:166

[sivachandra]

OK from my side after addressing the nits but please wait for @lntue and @michaelrj also.

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

139

Nit: We are slowly switching over to use static_cast over bool(...) which apparently is equivalent to C like casts.

libc/src/__support/float_to_string.h

206

Same here and other places in this patch.

[michaelrj]

libc/src/__support/UInt.h

742

This should probably not be constexpr, and neither should operator++ since they call add and sub which use the non-const versions of add_with_carry and sub_with_borrow. You can add a constexpr version of those functions similar to how operator+ and operator- are if you want.

[mikhail.ramalho]

• Use static_cast<foo> instead of foo(...)
• Changed operator++ and operator-- to use operator+ and operator-, respectively

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

139

tbh, I thought this was calling the bool constructor. I'll change it.

[mikhail.ramalho]

• Implement get_val() for x86_64 long double class
• Use dyadic float in clinger_fast_path to fix conversion to long double

[lntue]

libc/src/__support/UInt.h

83

Bits >= 128

480

Should the return type be UInt<Bits>&?

[sivachandra]

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

131

Why was this method added? In other words, why was not required previously?

libc/src/__support/str_to_float.h

306

Why not this directly:

exp2 -= static_cast<uint32_t>(1) ^ static_cast<uint32_t>(msb);

libc/src/stdio/printf_core/float_dec_converter.h

1154

FPBits<double>::UIntType

1175

Ditto

1196

Ditto

libc/src/stdio/printf_core/float_hex_converter.h

55

Ditto

libc/src/stdio/printf_core/float_inf_nan_converter.h

40

Ditto

libc/src/stdio/printf_core/int_converter.h

46

Why not uintmax_t directly?

[mikhail.ramalho]

Addressed comments

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

131

That's because of the new dyadic_float object used in clinger_fast_path.

DyadicFloat's conversion operator calls get_val(), but this was only implemented in the non-x86_64 class.

libc/src/__support/UInt.h

480

I followed how it's done for the other operators, do you want me to change just this one?

[michaelrj]

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

129

I'm not sure this is correct, this seems to be setting the explicit bit in the output regardless of if it is set in the actual number. An example of where this might go wrong is the number 0.0.

[mikhail.ramalho]

• Rebased
• Fix zero conversion
• Added test case for 0

[lntue]

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

128

is_zero() is also true for -0.0L. You'll need to check for sign:

return get_sign() ? -0.0L : 0.0L;

libc/src/__support/UInt.h

480

Please fix other op= signature to return references if you see them. Thanks!

[michaelrj]

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

129

I meant more that if bits is accurate, then you shouldn't need to add the explicit bit separately at all. In get_explicit_mantissa it expands the mask to cover the explicit leading bit, but doesn't actually modify the resulting number at all.

[mikhail.ramalho]

This patch no longer needed.

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

if (bits.is_inf_or_nan()) {
         UIntType tmp = (y << 1) + current_bit; // 2*y(n - 1) + 2^(-n-1)
         if (r >= tmp) {
           r -= tmp;
           y += current_bit;
         }
       }
 
       // We compute one more iteration in order to round correctly.
-      bool lsb = y & 1; // Least significant bit
+      bool lsb = static_cast<bool>(y & 1); // Least significant bit
       bool rb = false;  // Round bit
       r <<= 2;
       UIntType tmp = (y << 2) + 1;
       if (r >= tmp) {
         r -= tmp;
         rb = true;
       }
 

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

template <> struct FPBits<long double> {
   template <typename XType,
             cpp::enable_if_t<cpp::is_same_v<XType, UIntType>, int> = 0>
   explicit FPBits(XType x) : bits(x) {}
 
   LIBC_INLINE operator long double() {
     return cpp::bit_cast<long double>(bits);
   }
 
+  LIBC_INLINE long double get_val() const {
+    UIntType bits_with_explicit_bit{bits};
+    bits_with_explicit_bit &= ~(UIntType(1) << FloatProp::MANTISSA_WIDTH);
+    bits_with_explicit_bit |= (UIntType(true) << FloatProp::MANTISSA_WIDTH);
+    return cpp::bit_cast<long double>(bits_with_explicit_bit);
+  }
+
   LIBC_INLINE UIntType uintval() {
     // We zero the padding bits as they can contain garbage.
     static constexpr UIntType MASK =
         (UIntType(1) << (sizeof(long double) * 8 -
                          Padding<sizeof(uintptr_t)>::VALUE)) -
         1;
     return bits & MASK;
   }

libc/src/__support/UInt.h

for (size_t i = 1; i < WORDCOUNT; ++i) {
       val[i] = 0;
     }
   }
   constexpr explicit UInt(const cpp::array<uint64_t, WORDCOUNT> &words) {
     for (size_t i = 0; i < WORDCOUNT; ++i)
       val[i] = words[i];
   }
 
+#ifdef __SIZEOF_INT128__
+  constexpr explicit operator __uint128_t() const {
+    __uint128_t tmp = val[0];
+    if constexpr (Bits >= 128)
+      tmp += (__uint128_t(val[1]) << 64);
+    return tmp;
+  }
+#endif // __SIZEOF_INT128__
+
   constexpr explicit operator uint64_t() const { return val[0]; }
 
   constexpr explicit operator uint32_t() const {
     return uint32_t(uint64_t(*this));
   }
 
   constexpr explicit operator uint16_t() const {
     return uint16_t(uint64_t(*this));
#endif // __SIZEOF_INT128__
   }
 
   constexpr UInt<Bits> operator/(const UInt<Bits> &other) const {
     UInt<Bits> result(*this);
     result.div(other);
     return result;
   }
 
+  constexpr UInt<Bits> operator/=(const UInt<Bits> &other) {
+    *this = *this / other;
+    return *this;
+  }
+
   constexpr UInt<Bits> operator%(const UInt<Bits> &other) const {
     UInt<Bits> result(*this);
     return *result.div(other);
   }
 
   constexpr UInt<Bits> &operator*=(const UInt<Bits> &other) {
     *this = *this * other;
     return *this;
for (size_t i = WORDCOUNT; i > 0; --i) {
       else if (word < other_word)
         return true;
     }
     // Equal
     return true;
   }
 
   constexpr UInt<Bits> &operator++() {
-    UInt<Bits> one(1);
-    add(one);
+    *this = *this + 1;
+    return *this;
+  }
+
+  constexpr UInt<Bits> &operator--() {
+    *this = *this - 1;
     return *this;
   }
 
   // Return the i-th 64-bit word of the number.
   constexpr const uint64_t &operator[](size_t i) const { return val[i]; }
 
   // Return the i-th 64-bit word of the number.
   constexpr uint64_t &operator[](size_t i) { return val[i]; }
 
   uint64_t *data() { return val; }
 
   const uint64_t *data() const { return val; }
 };
 

libc/src/__support/float_to_string.h

 
 LIBC_INLINE uint32_t mul_shift_mod_1e9(const MantissaInt mantissa,
                                        const cpp::UInt<MID_INT_SIZE> &large,
                                        const int32_t shift_amount) {
   constexpr size_t MANT_INT_SIZE = sizeof(MantissaInt) * 8;
   cpp::UInt<MID_INT_SIZE + MANT_INT_SIZE> val(large);
   // TODO: Find a better way to force __uint128_t to be UInt<128>
   cpp::UInt<MANT_INT_SIZE> wide_mant(0);
-  wide_mant[0] = mantissa & (uint64_t(-1));
-  wide_mant[1] = mantissa >> 64;
+  wide_mant[0] = static_cast<uint64_t>(mantissa & UINT64_MAX);
+  wide_mant[1] = static_cast<uint64_t>(mantissa >> 64);
   val = (val * wide_mant) >> shift_amount;
   return fast_uint_mod_1e9(val);
 }
 
 } // namespace internal
 
 // Convert floating point values to their string representation.
 // Because the result may not fit in a reasonably sized array, the caller must

libc/src/__support/str_to_float.h

 //===-- String to float conversion utils ------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LIBC_SRC_SUPPORT_STR_TO_FLOAT_H
 #define LIBC_SRC_SUPPORT_STR_TO_FLOAT_H
 
 #include "src/__support/CPP/limits.h"
 #include "src/__support/CPP/optional.h"
 #include "src/__support/FPUtil/FEnvImpl.h"
 #include "src/__support/FPUtil/FPBits.h"
+#include "src/__support/FPUtil/dyadic_float.h"
 #include "src/__support/UInt128.h"
 #include "src/__support/builtin_wrappers.h"
 #include "src/__support/common.h"
 #include "src/__support/ctype_utils.h"
 #include "src/__support/detailed_powers_of_ten.h"
 #include "src/__support/high_precision_decimal.h"
 #include "src/__support/str_to_integer.h"
 #include "src/__support/str_to_num_result.h"
if ((final_approx_upper & HALFWAY_CONSTANT) == HALFWAY_CONSTANT &&
       final_approx_lower + mantissa < mantissa) {
     return cpp::nullopt;
   }
 
   // Shifting to 65 bits for 80 bit floats and 113 bits for 128 bit floats
   BitsType msb = final_approx_upper >> (BITS_IN_MANTISSA - 1);
   BitsType final_mantissa =
       final_approx_upper >>
-      (msb + BITS_IN_MANTISSA -
+      static_cast<uint64_t>(
+          msb + BITS_IN_MANTISSA -
           (fputil::FloatProperties<long double>::MANTISSA_WIDTH + 3));
-  exp2 -= static_cast<uint32_t>(1 ^ msb); // same as !msb
+  exp2 -= static_cast<uint32_t>(1) ^ static_cast<uint32_t>(msb); // same as !msb
 
   if (round == RoundDirection::Nearest) {
     // Half-way ambiguity
     if (final_approx_lower == 0 &&
         (final_approx_upper & HALFWAY_CONSTANT) == 0 &&
         (final_mantissa & 3) == 1) {
       return cpp::nullopt;
     }
     // Round to even.
clinger_fast_path(ExpandedFloat<T> init_num,
   typename fputil::FPBits<T>::UIntType mantissa = init_num.mantissa;
   int32_t exp10 = init_num.exponent;
 
   if (mantissa >> fputil::FloatProperties<T>::MANTISSA_WIDTH > 0) {
     return cpp::nullopt;
   }
 
   fputil::FPBits<T> result;
-  T float_mantissa = static_cast<T>(mantissa);
+  T float_mantissa =
+      static_cast<T>(fputil::DyadicFloat<128>(/*sign*/ false, /*exponent*/ 0,
+                                              /*mantissa*/ mantissa));
 
   if (exp10 == 0) {
     result = fputil::FPBits<T>(float_mantissa);
   }
   if (exp10 > 0) {
     if (exp10 > ClingerConsts<T>::EXACT_POWERS_OF_TEN +
                     ClingerConsts<T>::DIGITS_IN_MANTISSA) {
       return cpp::nullopt;
if (amount_to_shift_right > NUMBITS) {
       output.num = {0, 0};
       output.error = ERANGE;
       return output;
     }
   }
 
   BitsType round_bit_mask = BitsType(1) << (amount_to_shift_right - 1);
   BitsType sticky_mask = round_bit_mask - 1;
-  bool round_bit = mantissa & round_bit_mask;
+  bool round_bit = static_cast<bool>(mantissa & round_bit_mask);
   bool sticky_bit = static_cast<bool>(mantissa & sticky_mask) || truncated;
 
   if (amount_to_shift_right < NUMBITS) {
     // Shift the mantissa and clear the implicit bit.
     mantissa >>= amount_to_shift_right;
     mantissa &= fputil::FloatProperties<T>::MANTISSA_MASK;
   } else {
     mantissa = 0;
   }
-  bool least_significant_bit = mantissa & BitsType(1);
+  bool least_significant_bit = static_cast<bool>(mantissa & BitsType(1));
 
   // TODO: check that this rounding behavior is correct.
 
   if (round == RoundDirection::Nearest) {
     // Perform rounding-to-nearest, tie-to-even.
     if (round_bit && (least_significant_bit || sticky_bit)) {
       ++mantissa;
     }

libc/src/stdio/printf_core/char_converter.h

 #include "src/stdio/printf_core/converter_utils.h"
 #include "src/stdio/printf_core/core_structs.h"
 #include "src/stdio/printf_core/writer.h"
 
 namespace __llvm_libc {
 namespace printf_core {
 
 LIBC_INLINE int convert_char(Writer *writer, const FormatSection &to_conv) {
-  char c = to_conv.conv_val_raw;
+  char c = static_cast<uint8_t>(to_conv.conv_val_raw);
 
   constexpr int string_len = 1;
 
   size_t padding_spaces =
       to_conv.min_width > string_len ? to_conv.min_width - string_len : 0;
 
   // If the padding is on the left side, write the spaces first.
   if (padding_spaces > 0 &&

libc/src/stdio/printf_core/float_dec_converter.h

for (; i < blocks; ++i) {
         }
         RoundDirection round;
         // Is m * 10^(additionalDigits + 1) / 2^(-exponent) integer?
         const int32_t requiredTwos =
             -(exponent - MANT_WIDTH) - static_cast<int32_t>(precision) - 1;
         const bool trailingZeros =
             requiredTwos <= 0 ||
             (requiredTwos < 60 &&
-             multiple_of_power_of_2(float_bits.get_explicit_mantissa(),
-                                    static_cast<uint32_t>(requiredTwos)));
+             multiple_of_power_of_2(
+                 static_cast<uint64_t>(float_bits.get_explicit_mantissa()),
         switch (fputil::get_round()) {
         case FE_TONEAREST:
           // Round to nearest, if it's exactly halfway then round to even.
           if (last_digit != 5) {
             round = last_digit > 5 ? RoundDirection::Up : RoundDirection::Down;
           } else {
             round = trailingZeros ? RoundDirection::Even : RoundDirection::Up;
           }
LIBC_INLINE int convert_float_dec_exp_typed(Writer *writer,
 
   RoundDirection round;
   // Is m * 10^(additionalDigits + 1) / 2^(-exponent) integer?
   const int32_t requiredTwos =
       -(exponent - MANT_WIDTH) - static_cast<int32_t>(precision) - 1;
   const bool trailingZeros =
       requiredTwos <= 0 ||
       (requiredTwos < 60 &&
-       multiple_of_power_of_2(float_bits.get_explicit_mantissa(),
-                              static_cast<uint32_t>(requiredTwos)));
+       multiple_of_power_of_2(
+           static_cast<uint64_t>(float_bits.get_explicit_mantissa()),
   switch (fputil::get_round()) {
   case FE_TONEAREST:
     // Round to nearest, if it's exactly halfway then round to even.
     if (last_digit != 5) {
       round = last_digit > 5 ? RoundDirection::Up : RoundDirection::Down;
     } else {
       round = trailingZeros ? RoundDirection::Even : RoundDirection::Up;
     }
LIBC_INLINE int convert_float_dec_auto_typed(Writer *writer,
   RoundDirection round;
   // Is m * 10^(additionalDigits + 1) / 2^(-exponent) integer?
   const int32_t requiredTwos =
       -(exponent - MANT_WIDTH) - static_cast<int32_t>(exp_precision) - 1;
   // TODO: rename this variable to remove confusion with trailing_zeroes
   const bool trailingZeros =
       requiredTwos <= 0 ||
       (requiredTwos < 60 &&
-       multiple_of_power_of_2(float_bits.get_explicit_mantissa(),
-                              static_cast<uint32_t>(requiredTwos)));
+       multiple_of_power_of_2(
+           static_cast<uint64_t>(float_bits.get_explicit_mantissa()),
   switch (fputil::get_round()) {
   case FE_TONEAREST:
     // Round to nearest, if it's exactly halfway then round to even.
     if (last_digit != 5) {
       round = last_digit > 5 ? RoundDirection::Up : RoundDirection::Down;
     } else {
       round = trailingZeros ? RoundDirection::Even : RoundDirection::Up;
     }
LIBC_INLINE int convert_float_decimal(Writer *writer,
   if (to_conv.length_modifier == LengthModifier::L) {
     fputil::FPBits<long double>::UIntType float_raw = to_conv.conv_val_raw;
     fputil::FPBits<long double> float_bits(float_raw);
     if (!float_bits.is_inf_or_nan()) {
       return convert_float_decimal_typed<long double>(writer, to_conv,
                                                       float_bits);
     }
   } else {
-    fputil::FPBits<double>::UIntType float_raw = to_conv.conv_val_raw;
+    fputil::FPBits<double>::UIntType float_raw =
+        static_cast<fputil::FPBits<double>::UIntType>(to_conv.conv_val_raw);
     fputil::FPBits<double> float_bits(float_raw);
     if (!float_bits.is_inf_or_nan()) {
       return convert_float_decimal_typed<double>(writer, to_conv, float_bits);
     }
   }
 
   return convert_inf_nan(writer, to_conv);
 }
 
 LIBC_INLINE int convert_float_dec_exp(Writer *writer,
                                       const FormatSection &to_conv) {
   if (to_conv.length_modifier == LengthModifier::L) {
     fputil::FPBits<long double>::UIntType float_raw = to_conv.conv_val_raw;
     fputil::FPBits<long double> float_bits(float_raw);
     if (!float_bits.is_inf_or_nan()) {
       return convert_float_dec_exp_typed<long double>(writer, to_conv,
                                                       float_bits);
     }
   } else {
-    fputil::FPBits<double>::UIntType float_raw = to_conv.conv_val_raw;
+    fputil::FPBits<double>::UIntType float_raw =
+        static_cast<fputil::FPBits<double>::UIntType>(to_conv.conv_val_raw);
     fputil::FPBits<double> float_bits(float_raw);
     if (!float_bits.is_inf_or_nan()) {
       return convert_float_dec_exp_typed<double>(writer, to_conv, float_bits);
     }
   }
 
   return convert_inf_nan(writer, to_conv);
 }
 
 LIBC_INLINE int convert_float_dec_auto(Writer *writer,
                                        const FormatSection &to_conv) {
   if (to_conv.length_modifier == LengthModifier::L) {
     fputil::FPBits<long double>::UIntType float_raw = to_conv.conv_val_raw;
     fputil::FPBits<long double> float_bits(float_raw);
     if (!float_bits.is_inf_or_nan()) {
       return convert_float_dec_auto_typed<long double>(writer, to_conv,
                                                        float_bits);
     }
   } else {
-    fputil::FPBits<double>::UIntType float_raw = to_conv.conv_val_raw;
+    fputil::FPBits<double>::UIntType float_raw =
+        static_cast<fputil::FPBits<double>::UIntType>(to_conv.conv_val_raw);
     fputil::FPBits<double> float_bits(float_raw);
     if (!float_bits.is_inf_or_nan()) {
       return convert_float_dec_auto_typed<double>(writer, to_conv, float_bits);
     }
   }
 
   return convert_inf_nan(writer, to_conv);
 }
 
 } // namespace printf_core
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STDIO_PRINTF_CORE_FLOAT_DEC_CONVERTER_H

libc/src/stdio/printf_core/float_hex_converter.h

if (to_conv.length_modifier == LengthModifier::L) {
     fputil::FPBits<long double> float_bits(float_raw);
     is_negative = float_bits.get_sign();
     exponent = float_bits.get_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 = to_conv.conv_val_raw;
+    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();
     mantissa = float_bits.get_explicit_mantissa();
     is_inf_or_nan = float_bits.is_inf_or_nan();
   }
 
   if (is_inf_or_nan)
if (to_conv.precision + 1 < static_cast<int>(mant_len) &&
     }
 
     mant_len = intended_digits;
   }
 
   size_t mant_cur = mant_len;
   size_t first_non_zero = 1;
   for (; mant_cur > 0; --mant_cur, mantissa /= 16) {
-    char new_digit = ((mantissa % 16) > 9) ? ((mantissa % 16) - 10 + a)
-                                           : ((mantissa % 16) + '0');
+    char new_digit =
+        static_cast<uint8_t>(((mantissa % 16) > 9) ? ((mantissa % 16) - 10 + a)
+                                                   : ((mantissa % 16) + '0'));
     mant_buffer[mant_cur - 1] = new_digit;
     if (new_digit != '0' && first_non_zero < mant_cur)
       first_non_zero = mant_cur;
   }
 
   size_t mant_digits = first_non_zero;
   if (to_conv.precision >= 0)
     mant_digits = mant_len;

libc/src/stdio/printf_core/float_inf_nan_converter.h

LIBC_INLINE int convert_inf_nan(Writer *writer, const FormatSection &to_conv) {
   bool is_negative;
   MantissaInt mantissa;
   if (to_conv.length_modifier == LengthModifier::L) {
     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();
     mantissa = float_bits.get_explicit_mantissa();
   } else {
-    fputil::FPBits<double>::UIntType float_raw = to_conv.conv_val_raw;
+    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();
     mantissa = float_bits.get_explicit_mantissa();
   }
 
   char sign_char = 0;
 
   if (is_negative)

libc/src/stdio/printf_core/int_converter.h

if (to_lower(conv_name) == 'x') {
     return IntegerToString::dec(num, bufref);
   }
 }
 
 LIBC_INLINE int convert_int(Writer *writer, const FormatSection &to_conv) {
   static constexpr size_t BITS_IN_BYTE = 8;
   static constexpr size_t BITS_IN_NUM = sizeof(uintmax_t) * BITS_IN_BYTE;
 
-  uintmax_t num = to_conv.conv_val_raw;
+  uintmax_t num = static_cast<uintmax_t>(to_conv.conv_val_raw);
   bool is_negative = false;
   FormatFlags flags = to_conv.flags;
 
   const char a = is_lower(to_conv.conv_name) ? 'a' : 'A';
 
   // If the conversion is signed, then handle negative values.
   if (to_conv.conv_name == 'd' || to_conv.conv_name == 'i') {
     // Check if the number is negative by checking the high bit. This works even