[libc] add performance options for string to float

[michaelrj]

Summary

This allows the client to set compile flags to disable the passes that
the string to float function uses. A client may be willing to trade off
performance for a reduction in code size, and this allows for that
fine-tuning.

[sivachandra]

libc/src/__support/str_to_float.h

214–215

Why did this and the above changes, which look like just formatting changes, happen?

610

Why should this be a conditional also?

[michaelrj]

libc/src/__support/str_to_float.h

214–215

Previous patches must've forgotten to format the file. I didn't touch these manually, they came from running clang-format.

610

It's mostly there for my own performance testing, but could also be used for cases where speed is preferred over accuracy.

libc/src/__support/str_to_float.h

if (exp10 < DETAILED_POWERS_OF_TEN_MIN_EXP_10 ||
       exp10 > DETAILED_POWERS_OF_TEN_MAX_EXP_10) {
     return false;
   }
 
   // Normalization
   uint32_t clz = leading_zeroes<BitsType>(mantissa);
   mantissa <<= clz;
 
-  uint32_t exp2 = static_cast<uint32_t>(exp10_to_exp2(exp10)) + BITS_IN_MANTISSA +
-                  fputil::FloatProperties<T>::EXPONENT_BIAS - clz;
+  uint32_t exp2 = static_cast<uint32_t>(exp10_to_exp2(exp10)) +
+                  BITS_IN_MANTISSA + fputil::FloatProperties<T>::EXPONENT_BIAS -
+                  clz;
 
   // Multiplication
   const uint64_t *power_of_ten =
       DETAILED_POWERS_OF_TEN[exp10 - DETAILED_POWERS_OF_TEN_MIN_EXP_10];
 
   UInt128 first_approx =
       static_cast<UInt128>(mantissa) * static_cast<UInt128>(power_of_ten[1]);
 
if ((high64(second_approx) & halfway_constant) == halfway_constant &&
       return false;
     }
     final_approx = second_approx;
   } else {
     final_approx = first_approx;
   }
 
   // Shifting to 54 bits for doubles and 25 bits for floats
-  BitsType msb = static_cast<BitsType>(high64(final_approx) >> (BITS_IN_MANTISSA - 1));
-  BitsType final_mantissa = static_cast<BitsType>(high64(final_approx) >>
+  BitsType msb =
+      static_cast<BitsType>(high64(final_approx) >> (BITS_IN_MANTISSA - 1));
+  BitsType final_mantissa =
+      static_cast<BitsType>(high64(final_approx) >>
                             (msb + BITS_IN_MANTISSA -
                              (fputil::FloatProperties<T>::MANTISSA_WIDTH + 3)));
   exp2 -= static_cast<uint32_t>(1 ^ msb); // same as !msb
 
   // Half-way ambiguity
   if (low64(final_approx) == 0 &&
       (high64(final_approx) & halfway_constant) == 0 &&
       (final_mantissa & 3) == 1) {
if (exp10 < DETAILED_POWERS_OF_TEN_MIN_EXP_10 ||
       exp10 > DETAILED_POWERS_OF_TEN_MAX_EXP_10) {
     return false;
   }
 
   // Normalization
   uint32_t clz = leading_zeroes<BitsType>(mantissa);
   mantissa <<= clz;
 
-  uint32_t exp2 = static_cast<uint32_t>(exp10_to_exp2(exp10)) + BITS_IN_MANTISSA +
+  uint32_t exp2 = static_cast<uint32_t>(exp10_to_exp2(exp10)) +
+                  BITS_IN_MANTISSA +
                   fputil::FloatProperties<long double>::EXPONENT_BIAS - clz;
 
   // Multiplication
   const uint64_t *power_of_ten =
       DETAILED_POWERS_OF_TEN[exp10 - DETAILED_POWERS_OF_TEN_MIN_EXP_10];
 
   // Since the input mantissa is more than 64 bits, we have to multiply with the
   // full 128 bits of the power of ten to get an approximation with the same
if (exp10 < 0 &&
                                fputil::FloatProperties<T>::MANTISSA_WIDTH) /
               2) {
     *outputMantissa = 0;
     *outputExp2 = 0;
     errno = ERANGE;
     return;
   }
 
+#ifndef LLVM_LIBC_DISABLE_CLINGER_FAST_PATH
   if (!truncated) {
     if (clinger_fast_path<T>(mantissa, exp10, outputMantissa, outputExp2)) {
       return;
     }
   }
+#endif // LLVM_LIBC_DISABLE_CLINGER_FAST_PATH
 
+#ifndef LLVM_LIBC_DISABLE_EISEL_LEMIRE
   // Try Eisel-Lemire
   if (eisel_lemire<T>(mantissa, exp10, outputMantissa, outputExp2)) {
     if (!truncated) {
       return;
     }
     // If the mantissa is truncated, then the result may be off by the LSB, so
     // check if rounding the mantissa up changes the result. If not, then it's
     // safe, else use the fallback.
     typename fputil::FPBits<T>::UIntType first_mantissa = *outputMantissa;
     uint32_t first_exp2 = *outputExp2;
     if (eisel_lemire<T>(mantissa + 1, exp10, outputMantissa, outputExp2)) {
       if (*outputMantissa == first_mantissa && *outputExp2 == first_exp2) {
         return;
       }
     }
   }
+#endif // LLVM_LIBC_DISABLE_EISEL_LEMIRE
 
+#ifndef LLVM_LIBC_DISABLE_SIMPLE_DECIMAL_CONVERSION
   simple_decimal_conversion<T>(numStart, outputMantissa, outputExp2);
+#endif // LLVM_LIBC_DISABLE_SIMPLE_DECIMAL_CONVERSION
 
   return;
 }
 
 // Takes a mantissa and base 2 exponent and converts it into its closest
 // floating point type T equivalient. Since the exponent is already in the right
 // form, this is mostly just shifting and rounding. This is used for hexadecimal
 // numbers since a base 16 exponent multiplied by 4 is the base 2 exponent.