[libc] tweak strtof errno behavior

[michaelrj]

Summary

When strtof/d/ld return a subnormal number they may set errno to
ERANGE. This change makes this behavior more consistent by making any
decimal number converting to a subnormal set errno to ERANGE. This
brings it in line with hexadecimals, which currently only set errno to
ERANGE if the number is truncated when converting to a subnormal.

libc/src/__support/str_to_float.h

simpleDecimalConversion(const char *__restrict numStart,
 
   // Check if rounding added a bit, and shift down if that's the case.
   if (finalMantissa == typename fputil::FPBits<T>::UIntType(2)
                            << fputil::FloatProperties<T>::mantissaWidth) {
     finalMantissa >>= 1;
     ++exp2;
   }
 
+  if (exp2 == 0) {
+    errno = ERANGE; // NOLINT
+  }
+
   *outputMantissa = finalMantissa;
   *outputExp2 = exp2;
 }
 
 // This class is used for templating the constants for Clinger's Fast Path,
 // described as a method of approximation in
 // Clinger WD. How to Read Floating Point Numbers Accurately. SIGPLAN Not 1990
 // Jun;25(6):92–101. https://doi.org/10.1145/93548.93557.

libc/test/src/__support/str_to_float_test.cpp

 TEST_F(LlvmLibcStrToFloatTest, SimpleDecimalConversion64BasicExponents) {
   SimpleDecimalConversionTest<double>("1e10", 0x12a05f20000000, 1056);
   SimpleDecimalConversionTest<double>("1e-10", 0x1b7cdfd9d7bdbb, 989);
   SimpleDecimalConversionTest<double>("1e300", 0x17e43c8800759c, 2019);
   SimpleDecimalConversionTest<double>("1e-300", 0x156e1fc2f8f359, 26);
 }
 
 TEST_F(LlvmLibcStrToFloatTest, SimpleDecimalConversion64BasicSubnormals) {
-  SimpleDecimalConversionTest<double>("1e-320", 0x7e8, 0);
-  SimpleDecimalConversionTest<double>("1e-308", 0x730d67819e8d2, 0);
+  SimpleDecimalConversionTest<double>("1e-320", 0x7e8, 0, ERANGE);
+  SimpleDecimalConversionTest<double>("1e-308", 0x730d67819e8d2, 0, ERANGE);
   SimpleDecimalConversionTest<double>("2.9e-308", 0x14da6df5e4bcc8, 1);
 }
 
 TEST_F(LlvmLibcStrToFloatTest, SimpleDecimalConversion64SubnormalRounding) {
 
   // Technically you can keep adding digits until you hit the truncation limit,
   // but this is the shortest string that results in the maximum subnormal that
   // I found.
   SimpleDecimalConversionTest<double>("2.225073858507201e-308", 0xfffffffffffff,
-                                      0);
+                                      0, ERANGE);
 
   // Same here, if you were to extend the max subnormal out for another 800
   // digits, incrementing any one of those digits would create a normal number.
   SimpleDecimalConversionTest<double>("2.2250738585072012e-308",
                                       0x10000000000000, 1);
 }
 
 TEST_F(LlvmLibcStrToFloatTest, SimpleDecimalConversion32SpecificFailures) {
   SimpleDecimalConversionTest<float>(
-      "1.4012984643248170709237295832899161312802619418765e-45", 0x1, 0);
+      "1.4012984643248170709237295832899161312802619418765e-45", 0x1, 0,
+      ERANGE);
 }
 
 TEST(LlvmLibcStrToFloatTest, SimpleDecimalConversionExtraTypes) {
   uint32_t floatOutputMantissa = 0;
   uint32_t outputExp2 = 0;
 
   errno = 0;
   __llvm_libc::internal::simpleDecimalConversion<float>(

libc/test/src/stdlib/strtof_test.cpp

 
 TEST_F(LlvmLibcStrToFTest, DecimalsWithRoundingProblems) {
   runTest("20040229", 8, 0x4b98e512);
   runTest("20040401", 8, 0x4b98e568);
   runTest("9E9", 3, 0x50061c46);
 }
 
 TEST_F(LlvmLibcStrToFTest, DecimalSubnormals) {
-  runTest("1.4012984643248170709237295832899161312802619418765e-45", 55, 0x1);
+  runTest("1.4012984643248170709237295832899161312802619418765e-45", 55, 0x1,
+          ERANGE);
 }
 
 TEST_F(LlvmLibcStrToFTest, DecimalWithLongExponent) {
   runTest("1e2147483648", 12, 0x7f800000, ERANGE);
   runTest("1e2147483646", 12, 0x7f800000, ERANGE);
   runTest("100e2147483646", 14, 0x7f800000, ERANGE);
   runTest("1e-2147483647", 13, 0x0, ERANGE);
   runTest("1e-2147483649", 13, 0x0, ERANGE);