[libc] Simplify decimalStringToFloat and hexadecimalStringToFloat in str_to_float.h and improve their performance.

[lntue]

Summary

Combine two loops in decimalStringToFloat and hexadecimalStringToFloat that extract the digits and re-arrange them a little bit. This slightly improves the performance of strtof and strtod:
Running libc_str_to_float_comparison_test parse-number-fxx-test_data/data/* on my machine (Ryzen 1700)

• with glibc: ~1.92 seconds
• with current implementation: ~1.78 seconds
• with this change: ~1.67 seconds

[michaelrj]

LGTM with the nit that the commit name is much longer than the recommended length, so shortening it would be good.

[lntue]

[libc] Simplify decimalStringToFloat and hexadecimalStringToFloat and improve their performance.

[lntue]

[libc] Simplify decimalStringToFloat and hexadecimalStringToFloat and improve their performance.

libc/src/__support/str_to_float.h

 static inline void
 binaryExpToFloat(typename fputil::FPBits<T>::UIntType mantissa, int32_t exp2,
                  typename fputil::FPBits<T>::UIntType *outputMantissa,
                  uint32_t *outputExp2) {
   using BitsType = typename fputil::FPBits<T>::UIntType;
 
   // This is the number of leading zeroes a properly normalized float of type T
   // should have.
-  constexpr uint32_t NORMALIZED_LEADING_ZEROES =
+  constexpr int32_t NORMALIZED_LEADING_ZEROES =
       (sizeof(BitsType) * 8) - fputil::FloatProperties<T>::mantissaWidth - 1;
   constexpr BitsType OVERFLOWED_MANTISSA =
       BitsType(1) << (fputil::FloatProperties<T>::mantissaWidth + 1);
 
   // Normalization
   int32_t amountToShift =
-      NORMALIZED_LEADING_ZEROES - leadingZeroes<BitsType>(mantissa);
+      NORMALIZED_LEADING_ZEROES -
+      static_cast<int32_t>(leadingZeroes<BitsType>(mantissa));
   if (amountToShift < 0) {
     mantissa <<= -amountToShift;
   } else {
     mantissa = shiftRightAndRound(mantissa, amountToShift);
     if (mantissa == OVERFLOWED_MANTISSA) {
       mantissa >>= 1;
       exp2 += 1;
     }
decimalStringToFloat(const char *__restrict src, const char DECIMAL_POINT,
   bool seenDigit = false;
   bool afterDecimal = false;
   BitsType mantissa = 0;
   int32_t exponent = 0;
 
   // The goal for the first step of parsing is to convert the number in src to
   // the format mantissa * (base ^ exponent)
 
-  // The first loop fills the mantissa with as many digits as it can hold
+  // The loop fills the mantissa with as many digits as it can hold
   const BitsType BITSTYPE_MAX_DIV_BY_BASE =
       __llvm_libc::cpp::NumericLimits<BitsType>::max() / BASE;
-  while ((isdigit(*src) || *src == DECIMAL_POINT) &&
-         mantissa < BITSTYPE_MAX_DIV_BY_BASE) {
-    if (*src == DECIMAL_POINT) {
-      if (afterDecimal) {
-        break; // this means that *src points to a second decimal point, ending
-               // the number.
-      } else {
-        afterDecimal = true;
-        ++src;
-        continue;
-      }
-    }
+  while (true) {
+    if (isdigit(*src)) {
       uint32_t digit = *src - '0';
+      seenDigit = true;
 
+      if (mantissa < BITSTYPE_MAX_DIV_BY_BASE) {
         mantissa = (mantissa * BASE) + digit;
-    seenDigit = true;
         if (afterDecimal) {
           --exponent;
         }
+      } else {
+        if (digit > 0)
+          truncated = true;
+        if (!afterDecimal)
+          ++exponent;
+      }
 
       ++src;
+      continue;
     }
-
-  if (!seenDigit)
-    return false;
-
-  // The second loop is to run through the remaining digits after we've filled
-  // the mantissa.
-  while (isdigit(*src) || *src == DECIMAL_POINT) {
     if (*src == DECIMAL_POINT) {
       if (afterDecimal) {
         break; // this means that *src points to a second decimal point, ending
                // the number.
-      } else {
-        afterDecimal = true;
-        ++src;
-        continue;
-      }
-    }
-    uint32_t digit = *src - '0';
-
-    if (digit > 0)
-      truncated = true;
+      }
+    // The character is neither a digit nor a decimal point.
+    break;
 
-    if (!afterDecimal)
-      ++exponent;
-
-    ++src;
-  }
+  if (!seenDigit)
+    return false;
 
   if ((*src | 32) == EXPONENT_MARKER) {
     if (*(src + 1) == '+' || *(src + 1) == '-' || isdigit(*(src + 1))) {
       ++src;
       char *tempStrEnd;
       int32_t add_to_exponent = strtointeger<int32_t>(src, &tempStrEnd, 10);
       if (add_to_exponent > 100000)
         add_to_exponent = 100000;
hexadecimalStringToFloat(const char *__restrict src, const char DECIMAL_POINT,
   bool seenDigit = false;
   bool afterDecimal = false;
   BitsType mantissa = 0;
   int32_t exponent = 0;
 
   // The goal for the first step of parsing is to convert the number in src to
   // the format mantissa * (base ^ exponent)
 
-  // The first loop fills the mantissa with as many digits as it can hold
+  // The loop fills the mantissa with as many digits as it can hold
   const BitsType BITSTYPE_MAX_DIV_BY_BASE =
       __llvm_libc::cpp::NumericLimits<BitsType>::max() / BASE;
-  while ((isalnum(*src) || *src == DECIMAL_POINT) &&
-         mantissa < BITSTYPE_MAX_DIV_BY_BASE) {
-    if (*src == DECIMAL_POINT) {
-      if (afterDecimal) {
-        break; // this means that *src points to a second decimal point, ending
-               // the number.
-      } else {
-        afterDecimal = true;
-        ++src;
-        continue;
-      }
-    }
+  while (true) {
+    if (isalnum(*src)) {
       uint32_t digit = b36_char_to_int(*src);
-    if (digit >= BASE)
+      if (digit >= BASE) {
+        seenDigit = false;
         break;
+      }
+      seenDigit = true;
 
+      if (mantissa < BITSTYPE_MAX_DIV_BY_BASE) {
         mantissa = (mantissa * BASE) + digit;
-    seenDigit = true;
         if (afterDecimal)
           --exponent;
-
+      } else {
+        if (digit > 0)
+          truncated = true;
+        if (!afterDecimal)
+          ++exponent;
+      }
       ++src;
+      continue;
     }
-
-  if (!seenDigit)
-    return false;
-
-  // The second loop is to run through the remaining digits after we've filled
-  // the mantissa.
-  while (isalnum(*src) || *src == DECIMAL_POINT) {
     if (*src == DECIMAL_POINT) {
       if (afterDecimal) {
         break; // this means that *src points to a second decimal point, ending
                // the number.
-      } else {
-        afterDecimal = true;
-        ++src;
-        continue;
-      }
-    }
-    uint32_t digit = b36_char_to_int(*src);
-    if (digit >= BASE)
-      break;
-
-    if (digit > 0)
-      truncated = true;
-
-    if (!afterDecimal)
-      ++exponent;
-
-    ++src;
+      }
+    // The character is neither a hexadecimal digit nor a decimal point.
   }
 
+  if (!seenDigit)
+    return false;
+
   // Convert the exponent from having a base of 16 to having a base of 2.
   exponent *= 4;
 
   if ((*src | 32) == EXPONENT_MARKER) {
     if (*(src + 1) == '+' || *(src + 1) == '-' || isdigit(*(src + 1))) {
       ++src;
       char *tempStrEnd;
       int32_t add_to_exponent = strtointeger<int32_t>(src, &tempStrEnd, 10);