[libc][NFC] clean up type warnings in printf

[michaelrj]

Summary

In preparation for https://reviews.llvm.org/D156630 this patch cleans up
all integer size and sign conversion warnings in printf.

libc/src/__support/float_to_string.h

 template <size_t INT_SIZE>
 LIBC_INLINE constexpr cpp::UInt<MID_INT_SIZE> get_table_positive(int exponent,
                                                                  size_t i) {
   // INT_SIZE is the size of int that is used for the internal calculations of
   // this function. It should be large enough to hold 2^(exponent+constant), so
   // ~1000 for double and ~16000 for long double. Be warned that the time
   // complexity of exponentiation is O(n^2 * log_2(m)) where n is the number of
   // bits in the number being exponentiated and m is the exponent.
-  const int shift_amount = exponent + CALC_SHIFT_CONST - (BLOCK_SIZE * i);
+  const int shift_amount =
+      static_cast<int>(exponent + CALC_SHIFT_CONST - (BLOCK_SIZE * i));
   if (shift_amount < 0) {
     return 1;
   }
   cpp::UInt<INT_SIZE> num(0);
   // MOD_SIZE is one of the limiting factors for how big the constant argument
   // can get, since it needs to be small enough to fit in the result UInt,
   // otherwise we'll get truncation on return.
   constexpr cpp::UInt<INT_SIZE> MOD_SIZE =
LIBC_INLINE cpp::UInt<MID_INT_SIZE> get_table_positive_df(int exponent,
   static_assert(INT_SIZE == 256,
                 "Only 256 is supported as an int size right now.");
   // This version uses dyadic floats with 256 bit mantissas to perform the same
   // calculation as above. Due to floating point imprecision it is only accurate
   // for the first 50 digits, but it's much faster. Since even 128 bit long
   // doubles are only accurate to ~35 digits, the 50 digits of accuracy are
   // enough for these floats to be converted back and forth safely. This is
   // ideal for avoiding the size of the long double table.
-  const int shift_amount = exponent + CALC_SHIFT_CONST - (9 * i);
+  const int shift_amount =
+      static_cast<int>(exponent + CALC_SHIFT_CONST - (9 * i));
   if (shift_amount < 0) {
     return 1;
   }
   fputil::DyadicFloat<INT_SIZE> num(false, 0, 1);
   constexpr cpp::UInt<INT_SIZE> MOD_SIZE =
       (cpp::UInt<INT_SIZE>(1000000000)
        << (CALC_SHIFT_CONST + (IDX_SIZE > 1 ? IDX_SIZE : 0)));
 
if (shift_amount < 0) {
     int block_shifts = (-shift_amount) / BLOCK_SIZE;
     if (block_shifts < static_cast<int>(ten_blocks)) {
       ten_blocks = ten_blocks - block_shifts;
       five_blocks = block_shifts;
       shift_amount = shift_amount + (block_shifts * BLOCK_SIZE);
     } else {
       ten_blocks = 0;
       five_blocks = i;
-      shift_amount = shift_amount + (i * BLOCK_SIZE);
+      shift_amount = static_cast<int>(shift_amount + (i * BLOCK_SIZE));
     }
   }
 
   if (five_blocks > 0) {
     cpp::UInt<INT_SIZE> fives(FIVE_EXP_NINE);
     fives.pow_n(five_blocks);
     num = fives;
   }

 LIBC_INLINE uint32_t fast_uint_mod_1e9(const cpp::UInt<MID_INT_SIZE> &val) {
   // The formula for mult_const is:
   //  1 + floor((2^(bits in target integer size + log_2(divider))) / divider)
   // Where divider is 10^9 and target integer size is 128.
   const cpp::UInt<MID_INT_SIZE> mult_const(
       {0x31680A88F8953031u, 0x89705F4136B4A597u, 0});
   const auto middle = (mult_const * val);
   const uint64_t result = static_cast<uint64_t>(middle[2]);
-  const uint32_t shifted = result >> 29;
-  return static_cast<uint32_t>(val) - (1000000000 * shifted);
+  const uint64_t shifted = result >> 29;
+  return static_cast<uint32_t>(static_cast<uint32_t>(val) -
+                               (1000000000 * shifted));
 }
 
 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] = static_cast<size_t>(mantissa & (uint64_t(-1)));
   wide_mant[1] = static_cast<size_t>(mantissa >> 64);
   val = (val * wide_mant) >> shift_amount;
 
-  return val.div_uint32_times_pow_2(1000000000, 0).value()[0];
+  return static_cast<uint32_t>(
+      val.div_uint32_times_pow_2(1000000000, 0).value());
   // 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
 // request blocks of digits and convert them from integers to strings themself.
#endif
 
   // This takes the index of a block after the decimal point (a negative block)
   // and return if it's sure that all of the digits after it are zero.
   LIBC_INLINE constexpr bool is_lowest_block(size_t block_index) {
 #ifdef LIBC_COPT_FLOAT_TO_STR_NO_TABLE
     return false;
 #else
     const int32_t idx = -exponent / IDX_SIZE;
-    const uint32_t p = POW10_OFFSET_2[idx] + block_index - MIN_BLOCK_2[idx];
+    const size_t p = POW10_OFFSET_2[idx] + block_index - MIN_BLOCK_2[idx];
     // If the remaining digits are all 0, then this is the lowest block.
     return p >= POW10_OFFSET_2[idx + 1];
 #endif
   }
 
   LIBC_INLINE constexpr size_t zero_blocks_after_point() {
 #ifdef LIBC_COPT_FLOAT_TO_STR_NO_TABLE
     return 0;

libc/src/stdio/printf_core/float_dec_converter.h

PaddingWriter(const FormatSection &to_conv, char init_sign_char)
       : left_justified((to_conv.flags & FormatFlags::LEFT_JUSTIFIED) > 0),
         leading_zeroes((to_conv.flags & FormatFlags::LEADING_ZEROES) > 0),
         sign_char(init_sign_char),
         min_width(to_conv.min_width > 0 ? to_conv.min_width : 0) {}
 
   int write_left_padding(Writer *writer, size_t total_digits) {
     // The pattern is (spaces) (sign) (zeroes), but only one of spaces and
     // zeroes can be written, and only if the padding amount is positive.
-    int padding_amount = min_width - total_digits - (sign_char > 0 ? 1 : 0);
+    int padding_amount =
+        static_cast<int>(min_width - total_digits - (sign_char > 0 ? 1 : 0));
     if (left_justified || padding_amount < 0) {
       if (sign_char > 0) {
         RET_IF_RESULT_NEGATIVE(writer->write(sign_char));
       }
       return 0;
     }
     if (!leading_zeroes) {
       RET_IF_RESULT_NEGATIVE(writer->write(' ', padding_amount));
     }
     if (sign_char > 0) {
       RET_IF_RESULT_NEGATIVE(writer->write(sign_char));
     }
     if (leading_zeroes) {
       RET_IF_RESULT_NEGATIVE(writer->write('0', padding_amount));
     }
     return 0;
   }
 
   int write_right_padding(Writer *writer, size_t total_digits) {
     // If and only if the conversion is left justified, there may be trailing
     // spaces.
-    int padding_amount = min_width - total_digits - (sign_char > 0 ? 1 : 0);
+    int padding_amount =
+        static_cast<int>(min_width - total_digits - (sign_char > 0 ? 1 : 0));
     if (left_justified && padding_amount > 0) {
       RET_IF_RESULT_NEGATIVE(writer->write(' ', padding_amount));
     }
     return 0;
   }
 };
 
 /*
int write_last_block_dec(BlockInt block, size_t block_digits,
                            RoundDirection round) {
     char end_buff[BLOCK_SIZE];
 
     char buf[IntegerToString::dec_bufsize<intmax_t>()];
     auto const int_to_str = *IntegerToString::dec(block + (MAX_BLOCK + 1), buf);
 
     // copy the last block_digits characters into the start of end_buff.
     // TODO: Replace with memcpy
-    for (int count = block_digits - 1; count >= 0; --count) {
+    for (size_t count = 0; count < block_digits; ++count) {
       end_buff[count] = int_to_str[count + 1 + (BLOCK_SIZE - block_digits)];
     }
 
     char low_digit;
     if (block_digits > 0) {
       low_digit = end_buff[block_digits - 1];
     } else if (max_block_count > 0) {
       low_digit = '9';
     } else {
       low_digit = block_buffer[buffered_digits - 1];
     }
 
     // Round up
     if (round == RoundDirection::Up ||
         (round == RoundDirection::Even && low_digit % 2 != 0)) {
       bool has_carry = true;
       // handle the low block that we're adding
-      for (int count = block_digits - 1; count >= 0 && has_carry; --count) {
+      for (int count = static_cast<int>(block_digits) - 1;
+           count >= 0 && has_carry; --count) {
         if (end_buff[count] == '9') {
           end_buff[count] = '0';
         } else {
           end_buff[count] += 1;
           has_carry = false;
         }
       }
       // handle the high block that's buffered
-      for (int count = buffered_digits - 1; count >= 0 && has_carry; --count) {
+      for (int count = static_cast<int>(buffered_digits) - 1;
+           count >= 0 && has_carry; --count) {
         if (block_buffer[count] == '9') {
           block_buffer[count] = '0';
         } else {
           block_buffer[count] += 1;
           has_carry = false;
         }
       }
 
int write_last_block_exp(uint32_t block, size_t block_digits,
 
     {
       char buf[IntegerToString::dec_bufsize<intmax_t>()];
       auto const int_to_str =
           *IntegerToString::dec(block + (MAX_BLOCK + 1), buf);
 
       // copy the last block_digits characters into the start of end_buff.
       // TODO: Replace with memcpy
-      for (int count = block_digits - 1; count >= 0; --count) {
+      for (size_t count = 0; count < block_digits; ++count) {
         end_buff[count] = int_to_str[count + 1 + (BLOCK_SIZE - block_digits)];
       }
     }
 
     char low_digit;
     if (block_digits > 0) {
       low_digit = end_buff[block_digits - 1];
     } else if (max_block_count > 0) {
       low_digit = '9';
     } else {
       low_digit = block_buffer[buffered_digits - 1];
     }
 
     // Round up
     if (round == RoundDirection::Up ||
         (round == RoundDirection::Even && low_digit % 2 != 0)) {
       bool has_carry = true;
       // handle the low block that we're adding
-      for (int count = block_digits - 1; count >= 0 && has_carry; --count) {
+      for (int count = static_cast<int>(block_digits) - 1;
+           count >= 0 && has_carry; --count) {
         if (end_buff[count] == '9') {
           end_buff[count] = '0';
         } else {
           end_buff[count] += 1;
           has_carry = false;
         }
       }
       // handle the high block that's buffered
-      for (int count = buffered_digits - 1; count >= 0 && has_carry; --count) {
+      for (int count = static_cast<int>(buffered_digits) - 1;
+           count >= 0 && has_carry; --count) {
         if (block_buffer[count] == '9') {
           block_buffer[count] = '0';
         } else {
           block_buffer[count] += 1;
           has_carry = false;
         }
       }
 
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 = ' ';
 
   // If to_conv doesn't specify a precision, the precision defaults to 6.
-  const size_t precision = to_conv.precision < 0 ? 6 : to_conv.precision;
+  const unsigned int precision = to_conv.precision < 0 ? 6 : to_conv.precision;
   bool has_decimal_point =
       (precision > 0) || ((to_conv.flags & FormatFlags::ALTERNATE_FORM) != 0);
 
   // nonzero is false until a nonzero digit is found. It is used to determine if
   // leading zeroes should be printed, since before the first digit they are
   // ignored.
   bool nonzero = false;
 
   PaddingWriter padding_writer(to_conv, sign_char);
   FloatWriter float_writer(writer, has_decimal_point, padding_writer);
   FloatToString<T> float_converter(static_cast<T>(float_bits));
 
-  const uint32_t positive_blocks = float_converter.get_positive_blocks();
+  const size_t positive_blocks = float_converter.get_positive_blocks();
 
   if (positive_blocks >= 0) {
     // This loop iterates through the number a block at a time until it finds a
     // block that is not zero or it hits the decimal point. This is because all
     // zero blocks before the first nonzero digit or the decimal point are
     // ignored (no leading zeroes, at least at this stage).
     int32_t i = static_cast<int32_t>(positive_blocks) - 1;
     for (; i >= 0; --i) {
if (exponent < MANT_WIDTH) {
     const uint32_t blocks = (precision / BLOCK_SIZE) + 1;
     uint32_t i = 0;
     // if all the blocks we should write are zero
     if (blocks <= float_converter.zero_blocks_after_point()) {
       i = blocks; // just write zeroes up to precision
       RET_IF_RESULT_NEGATIVE(float_writer.write_zeroes(precision));
     } else if (i < float_converter.zero_blocks_after_point()) {
       // else if there are some blocks that are zeroes
-      i = float_converter.zero_blocks_after_point();
+      i = static_cast<uint32_t>(float_converter.zero_blocks_after_point());
       // write those blocks as zeroes.
       RET_IF_RESULT_NEGATIVE(float_writer.write_zeroes(9 * i));
     }
     // for each unwritten block
     for (; i < blocks; ++i) {
       if (float_converter.is_lowest_block(i)) {
         const uint32_t fill = precision - 9 * i;
         RET_IF_RESULT_NEGATIVE(float_writer.write_zeroes(fill));
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 = ' ';
 
   // If to_conv doesn't specify a precision, the precision defaults to 6.
-  const size_t precision = to_conv.precision < 0 ? 6 : to_conv.precision;
+  const unsigned int precision = to_conv.precision < 0 ? 6 : to_conv.precision;
   bool has_decimal_point =
       (precision > 0) || ((to_conv.flags & FormatFlags::ALTERNATE_FORM) != 0);
 
   PaddingWriter padding_writer(to_conv, sign_char);
   FloatWriter float_writer(writer, has_decimal_point, padding_writer);
   FloatToString<T> float_converter(static_cast<T>(float_bits));
 
   size_t digits_written = 0;
   int final_exponent = 0;
 
   // Here we would subtract 1 to account for the fact that block 0 counts as a
   // positive block, but the loop below accounts for this by starting with
   // subtracting 1 from cur_block.
   int cur_block;
 
   if (exponent < 0) {
-    cur_block = -float_converter.zero_blocks_after_point();
+    cur_block = -static_cast<int>(float_converter.zero_blocks_after_point());
   } else {
-    cur_block = float_converter.get_positive_blocks();
+    cur_block = static_cast<int>(float_converter.get_positive_blocks());
   }
 
   BlockInt digits = 0;
 
   // If the mantissa is 0, then the number is 0, meaning that looping until a
   // non-zero block is found will loop forever. The first block is just 0.
   if (mantissa != 0) {
     // This loop finds the first block.
     while (digits == 0) {
       --cur_block;
       digits = float_converter.get_block(cur_block);
     }
   } else {
     cur_block = 0;
   }
 
   // TODO: Find a better way to calculate the number of digits in the
   // initial block and exponent.
   char buf[IntegerToString::dec_bufsize<intmax_t>()];
   auto int_to_str = *IntegerToString::dec(digits, buf);
   size_t block_width = int_to_str.size();
 
-  final_exponent = (cur_block * BLOCK_SIZE) + (block_width - 1);
+  final_exponent = (cur_block * BLOCK_SIZE) + static_cast<int>(block_width - 1);
   int positive_exponent = final_exponent < 0 ? -final_exponent : final_exponent;
 
   int_to_str = *IntegerToString::dec(positive_exponent, buf);
   size_t exponent_width = int_to_str.size();
 
   // Calculate the total number of digits in the number.
   // 1 - the digit before the decimal point
   // 1 - the decimal point (optional)
LIBC_INLINE int convert_float_dec_exp_typed(Writer *writer,
   if (digits_written == 0) {
     // TODO: Find a better way to calculate the number of digits in a block.
     char buf[IntegerToString::dec_bufsize<intmax_t>()];
     auto int_to_str = *IntegerToString::dec(digits, buf);
     last_block_size = int_to_str.size();
   }
 
   // This is the last block.
-  const uint32_t maximum = precision + 1 - digits_written;
+  const size_t maximum = precision + 1 - digits_written;
   uint32_t last_digit = 0;
   for (uint32_t k = 0; k < last_block_size - maximum; ++k) {
     last_digit = digits % 10;
     digits /= 10;
   }
 
   // If the last block we read doesn't have the digit after the end of what
   // we'll print, then we need to read the next block to get that digit.
LIBC_INLINE int convert_float_dec_auto_typed(Writer *writer,
   // 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();
   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 size_t init_precision = to_conv.precision <= 0
+  const unsigned int init_precision = to_conv.precision <= 0
                                           ? (to_conv.precision == 0 ? 1 : 6)
                                           : to_conv.precision;
 
   //  Then, if a conversion with style E would have an exponent of X
   //  (base_10_exp):
   int base_10_exp = 0;
   // If P > X >= -4 the conversion is with style F and precision P - (X + 1).
   // Otherwise, the conversion is with style E and precision P - 1.
 
   // For calculating the base 10 exponent, we need to process the number as if
   // it has style E, so here we calculate the precision we'll use in that case.
-  const size_t exp_precision = init_precision - 1;
+  const unsigned int exp_precision = init_precision - 1;
 
   FloatToString<T> float_converter(static_cast<T>(float_bits));
 
   // Here we would subtract 1 to account for the fact that block 0 counts as a
   // positive block, but the loop below accounts for this by starting with
   // subtracting 1 from cur_block.
   int cur_block;
 
   if (exponent < 0) {
-    cur_block = -float_converter.zero_blocks_after_point();
+    cur_block = -static_cast<int>(float_converter.zero_blocks_after_point());
   } else {
-    cur_block = float_converter.get_positive_blocks();
+    cur_block = static_cast<int>(float_converter.get_positive_blocks());
   }
 
   BlockInt digits = 0;
 
   // If the mantissa is 0, then the number is 0, meaning that looping until a
   // non-zero block is found will loop forever.
   if (mantissa != 0) {
     // This loop finds the first non-zero block.
LIBC_INLINE int convert_float_dec_auto_typed(Writer *writer,
   }
 
   size_t digits_checked = 0;
   // TODO: look into unifying trailing_zeroes and trailing_nines. The number can
   // end in a nine or a zero, but not both.
   size_t trailing_zeroes = 0;
   size_t trailing_nines = 0;
 
-  base_10_exp = (cur_block * BLOCK_SIZE) + (block_width - 1);
+  base_10_exp = (cur_block * BLOCK_SIZE) + static_cast<int>(block_width - 1);
 
   // If the first block is not also the last block
   if (block_width <= exp_precision + 1) {
     char buf[IntegerToString::dec_bufsize<intmax_t>()];
     auto int_to_str = *IntegerToString::dec(digits, buf);
 
     for (size_t i = 0; i < block_width; ++i) {
       if (int_to_str[i] == '9') {
LIBC_INLINE int convert_float_dec_auto_typed(Writer *writer,
 
   digits = float_converter.get_block(cur_block);
 
   size_t last_block_size = BLOCK_SIZE;
 
   char buf[IntegerToString::dec_bufsize<intmax_t>()];
   auto int_to_str = *IntegerToString::dec(digits, buf);
 
-  int implicit_leading_zeroes = BLOCK_SIZE - int_to_str.size();
+  size_t implicit_leading_zeroes = BLOCK_SIZE - int_to_str.size();
 
   // if the last block is also the first block, then ignore leading zeroes.
   if (digits_checked == 0) {
     last_block_size = int_to_str.size();
     implicit_leading_zeroes = 0;
   }
 
-  int digits_requested = (exp_precision + 1) - digits_checked;
+  unsigned int digits_requested =
+      (exp_precision + 1) - static_cast<unsigned int>(digits_checked);
 
-  int digits_to_check = digits_requested - implicit_leading_zeroes;
+  int digits_to_check =
+      digits_requested - static_cast<int>(implicit_leading_zeroes);
   if (digits_to_check < 0) {
     digits_to_check = 0;
   }
 
   // If the block is not the maximum size, that means it has leading
   // zeroes, and zeroes are not nines.
   if (implicit_leading_zeroes > 0) {
     trailing_nines = 0;
for (int i = 0; i < digits_to_check; ++i) {
     } else {
       trailing_nines = 0;
       trailing_zeroes = 0;
     }
   }
 
   // Find the digit after the lowest digit that we'll actually print to
   // determine the rounding.
-  const uint32_t maximum = exp_precision + 1 - digits_checked;
+  const uint32_t maximum =
+      exp_precision + 1 - static_cast<uint32_t>(digits_checked);
   uint32_t last_digit = 0;
   for (uint32_t k = 0; k < last_block_size - maximum; ++k) {
     last_digit = digits % 10;
     digits /= 10;
   }
 
   // If the last block we read doesn't have the digit after the end of what
   // we'll print, then we need to read the next block to get that digit.
if (trailing_nines == init_precision) {
       }
     }
   }
 
   // if P > X >= -4, the conversion is with style f (or F) and precision equals
   //  P - (X + 1).
   if (static_cast<int>(init_precision) > base_10_exp && base_10_exp >= -4) {
     FormatSection new_conv = to_conv;
-    const size_t conv_precision = init_precision - (base_10_exp + 1);
+    const int conv_precision = init_precision - (base_10_exp + 1);
 
     if ((to_conv.flags & FormatFlags::ALTERNATE_FORM) != 0) {
       new_conv.precision = conv_precision;
     } else {
       // If alt form isn't set, then we need to determine the number of trailing
       // zeroes and set the precision such that they are removed.
 
       /*
       Here's a diagram of an example:
 
       printf("%.15g", 22.25);
 
                             +--- init_precision = 15
                             |
                             +-------------------+
                             |                   |
                             |  ++--- trimmed_precision = 2
                             |  ||               |
                             22.250000000000000000
                             ||   |              |
                             ++   +--------------+
                              |   |
        base_10_exp + 1 = 2 --+   +--- trailing_zeroes = 11
       */
-      int trimmed_precision =
-          digits_checked - (base_10_exp + 1) - trailing_zeroes;
+      int trimmed_precision = static_cast<int>(
+          digits_checked - (base_10_exp + 1) - trailing_zeroes);
       if (trimmed_precision < 0) {
         trimmed_precision = 0;
       }
-      new_conv.precision =
-          (static_cast<size_t>(trimmed_precision) > conv_precision)
+      new_conv.precision = (trimmed_precision > conv_precision)
                                ? conv_precision
                                : trimmed_precision;
     }
 
     return convert_float_decimal_typed<T>(writer, new_conv, float_bits);
   } else {
     // otherwise, the conversion is with style e (or E) and precision equals
     // P - 1
-    const size_t conv_precision = init_precision - 1;
+    const int conv_precision = init_precision - 1;
     FormatSection new_conv = to_conv;
     if ((to_conv.flags & FormatFlags::ALTERNATE_FORM) != 0) {
       new_conv.precision = conv_precision;
     } else {
       // If alt form isn't set, then we need to determine the number of trailing
       // zeroes and set the precision such that they are removed.
-      int trimmed_precision = digits_checked - 1 - trailing_zeroes;
+      int trimmed_precision =
+          static_cast<int>(digits_checked - 1 - trailing_zeroes);
       if (trimmed_precision < 0) {
         trimmed_precision = 0;
       }
-      new_conv.precision =
-          (static_cast<size_t>(trimmed_precision) > conv_precision)
+      new_conv.precision = (trimmed_precision > conv_precision)
                                ? conv_precision
                                : trimmed_precision;
     }
     return convert_float_dec_exp_typed<T>(writer, new_conv, float_bits);
   }
 }
 
 // TODO: unify the float converters to remove the duplicated checks for inf/nan.
 LIBC_INLINE int convert_float_decimal(Writer *writer,
                                       const FormatSection &to_conv) {

libc/src/stdio/printf_core/float_hex_converter.h

if (exp_cur == EXP_LEN) { // if nothing else was written, write a 0.
     exp_cur = EXP_LEN - 1;
   }
 
   exp_buffer[exp_cur - 1] = exp_is_negative ? '-' : '+';
   --exp_cur;
 
   // these are signed to prevent underflow due to negative values. The eventual
   // values will always be non-negative.
-  int trailing_zeroes = 0;
+  size_t trailing_zeroes = 0;
   int padding;
 
   // prefix is "0x", and always appears.
   constexpr size_t PREFIX_LEN = 2;
   char prefix[PREFIX_LEN];
   prefix[0] = '0';
   prefix[1] = a + ('x' - 'a');
   const cpp::string_view prefix_str(prefix, PREFIX_LEN);
 
   // If the precision is greater than the actual result, pad with 0s
   if (to_conv.precision > static_cast<int>(mant_digits - 1))
     trailing_zeroes = to_conv.precision - (mant_digits - 1);
 
   bool has_hexadecimal_point =
       (mant_digits > 1) || ((to_conv.flags & FormatFlags::ALTERNATE_FORM) ==
                             FormatFlags::ALTERNATE_FORM);
   constexpr cpp::string_view HEXADECIMAL_POINT(".");
 
   // This is for the letter 'p' before the exponent.
   const char exp_seperator = a + ('p' - 'a');
   constexpr int EXP_SEPERATOR_LEN = 1;
 
-  padding = to_conv.min_width - (sign_char > 0 ? 1 : 0) - PREFIX_LEN -
-            mant_digits - (has_hexadecimal_point ? 1 : 0) - EXP_SEPERATOR_LEN -
-            (EXP_LEN - exp_cur);
+  padding = static_cast<int>(to_conv.min_width - (sign_char > 0 ? 1 : 0) -
+                             PREFIX_LEN - mant_digits -
+                             static_cast<int>(has_hexadecimal_point) -
+                             EXP_SEPERATOR_LEN - (EXP_LEN - exp_cur));
   if (padding < 0)
     padding = 0;
 
   if ((to_conv.flags & FormatFlags::LEFT_JUSTIFIED) ==
       FormatFlags::LEFT_JUSTIFIED) {
     // The pattern is (sign), 0x, digit, (.), (other digits), (zeroes), p,
     // exponent, (spaces)
     if (sign_char > 0)

libc/src/stdio/printf_core/int_converter.h

LIBC_INLINE int convert_int(Writer *writer, const FormatSection &to_conv) {
 
   // Negative precision indicates that it was not specified.
   if (to_conv.precision < 0) {
     if ((flags & (FormatFlags::LEADING_ZEROES | FormatFlags::LEFT_JUSTIFIED)) ==
         FormatFlags::LEADING_ZEROES) {
       // If this conv has flag 0 but not - and no specified precision, it's
       // padded with 0's instead of spaces identically to if precision =
       // min_width - (1 if sign_char). For example: ("%+04d", 1) -> "+001"
-      zeroes = to_conv.min_width - digits_written - prefix_len;
+      zeroes =
+          static_cast<int>(to_conv.min_width - digits_written - prefix_len);
       spaces = 0;
     } else {
       // If there are enough digits to pass over the precision, just write the
       // number, padded by spaces.
       zeroes = 0;
-      spaces = to_conv.min_width - digits_written - prefix_len;
+      spaces =
+          static_cast<int>(to_conv.min_width - digits_written - prefix_len);
     }
   } else {
     // If precision was specified, possibly write zeroes, and possibly write
     // spaces. Example: ("%5.4d", 10000) -> "10000"
     // If the check for if zeroes is negative was not there, spaces would be
     // incorrectly evaluated as 1.
     //
     // The standard treats the case when num and precision are both zeroes as
     // special - it requires that no characters are produced. So, we adjust for
     // that special case first.
     if (num == 0 && to_conv.precision == 0)
       digits_written = 0;
-    zeroes = to_conv.precision - digits_written; // a negative value means 0
+    zeroes = static_cast<int>(to_conv.precision -
+                              digits_written); // a negative value means 0
     if (zeroes < 0)
       zeroes = 0;
-    spaces = to_conv.min_width - zeroes - digits_written - prefix_len;
+    spaces = static_cast<int>(to_conv.min_width - zeroes - digits_written -
+                              prefix_len);
   }
 
   if ((to_conv.conv_name == 'o') &&
       ((to_conv.flags & FormatFlags::ALTERNATE_FORM) != 0) && zeroes < 1) {
     zeroes = 1;
     --spaces;
   }
 

libc/src/stdio/printf_core/vfprintf_internal.h

 }
 
 LIBC_INLINE void funlockfile(FILE *f) {
   reinterpret_cast<__llvm_libc::File *>(f)->unlock();
 }
 
 LIBC_INLINE int fwrite_unlocked(const void *ptr, size_t size, size_t nmemb,
                                 FILE *f) {
-  return reinterpret_cast<__llvm_libc::File *>(f)->write_unlocked(ptr,
-                                                                  size * nmemb);
+  return static_cast<int>(
+      reinterpret_cast<__llvm_libc::File *>(f)->write_unlocked(ptr,
+                                                               size * nmemb));
 }
 #else  // defined(LIBC_COPT_PRINTF_USE_SYSTEM_FILE)
 LIBC_INLINE int ferror_unlocked(::FILE *f) { return ::ferror_unlocked(f); }
 
 LIBC_INLINE void flockfile(::FILE *f) { ::flockfile(f); }
 
 LIBC_INLINE void funlockfile(::FILE *f) { ::funlockfile(f); }
 

libc/src/stdio/printf_core/write_int_converter.h

 namespace printf_core {
 
 LIBC_INLINE int convert_write_int(Writer *writer,
                                   const FormatSection &to_conv) {
 
   // This is an additional check added by LLVM-libc. The reason it returns -3 is
   // because printf uses negative return values for errors, and -1 and -2 are
   // already in use by the file_writer class for file errors.
+  // TODO: Remove this. It's better to crash than to provide an incorrect
+  // result.
   if (to_conv.conv_val_ptr == nullptr)
     return NULLPTR_WRITE_ERROR;
 
   int written = writer->get_chars_written();
 
   switch (to_conv.length_modifier) {
   case LengthModifier::none:
     *reinterpret_cast<int *>(to_conv.conv_val_ptr) = written;
     break;
   case LengthModifier::l:
     *reinterpret_cast<long *>(to_conv.conv_val_ptr) = written;
     break;
   case LengthModifier::ll:
   case LengthModifier::L:
     *reinterpret_cast<long long *>(to_conv.conv_val_ptr) = written;
     break;
   case LengthModifier::h:
-    *reinterpret_cast<short *>(to_conv.conv_val_ptr) = written;
+    *reinterpret_cast<short *>(to_conv.conv_val_ptr) =
+        static_cast<short>(written);
     break;
   case LengthModifier::hh:
-    *reinterpret_cast<signed char *>(to_conv.conv_val_ptr) = written;
+    *reinterpret_cast<signed char *>(to_conv.conv_val_ptr) =
+        static_cast<signed char>(written);
     break;
   case LengthModifier::z:
     *reinterpret_cast<size_t *>(to_conv.conv_val_ptr) = written;
     break;
   case LengthModifier::t:
     *reinterpret_cast<ptrdiff_t *>(to_conv.conv_val_ptr) = written;
     break;
   case LengthModifier::j: