[libc] fix MPFR rounding problems in fuzz test

[michaelrj]

Summary

The accuracy for the MPFR numbers in the strtofloat fuzz test was set
too high, causing rounding issues when rounding to a smaller final
result.

[lntue]

libc/fuzzing/stdlib/strtofloat_fuzz.cpp

83

These values are useful. Maybe you could add them directly to FloatProperties , something like:
FloatProperties<T>::PRECISION ?

[lntue]

libc/fuzzing/stdlib/strtofloat_fuzz.cpp

83

They are also used in https://github.com/llvm/llvm-project/blob/main/libc/utils/MPFRWrapper/MPFRUtils.cpp#L33

[michaelrj]

add MANTISSA_PRECISION to float_properties, and use it in MPFR utils.

I also changed the title of the commit slightly since the proposed one was too long

libc/fuzzing/stdlib/CMakeLists.txt

add_libc_fuzzer(
   NEED_MPFR
   SRCS
     strtofloat_fuzz.cpp
   DEPENDS
     libc.src.stdlib.atof
     libc.src.stdlib.strtof
     libc.src.stdlib.strtod
     libc.src.stdlib.strtold
+    libc.src.__support.FPUtil.float_properties
 )
 
 add_libc_fuzzer(
   strtointeger_differential_fuzz
   SRCS
     strtointeger_differential_fuzz.cpp
   HDRS
     StringParserOutputDiff.h

libc/fuzzing/stdlib/strtofloat_fuzz.cpp

 //===-- strtofloat_fuzz.cpp -----------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 ///
 /// Fuzzing test for llvm-libc atof implementation.
 ///
 //===----------------------------------------------------------------------===//
 #include "src/stdlib/atof.h"
 #include "src/stdlib/strtod.h"
 #include "src/stdlib/strtof.h"
 #include "src/stdlib/strtold.h"
 
+#include "src/__support/FPUtil/FloatProperties.h"
+
 #include <math.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include "utils/MPFRWrapper/mpfr_inc.h"
 
+using __llvm_libc::fputil::FloatProperties;
+
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
   uint8_t *container = new uint8_t[size + 1];
   if (!container)
     __builtin_trap();
   size_t i;
 
   for (i = 0; i < size; ++i) {
     // MPFR's strtofr uses "@" as a base-independent exponent symbol
     if (data[i] != '@')
       container[i] = data[i];
     else {
       container[i] = '#';
     }
   }
   container[size] = '\0'; // Add null terminator to container.
 
   const char *str_ptr = reinterpret_cast<const char *>(container);
 
   char *out_ptr = nullptr;
 
+  size_t base = 0;
+
+  // This is just used to determine the base.
   mpfr_t result;
   mpfr_init2(result, 256);
   mpfr_t bin_result;
   mpfr_init2(bin_result, 256);
   mpfr_strtofr(result, str_ptr, &out_ptr, 0 /* base */, MPFR_RNDN);
   ptrdiff_t result_strlen = out_ptr - str_ptr;
   mpfr_strtofr(bin_result, str_ptr, &out_ptr, 2 /* base */, MPFR_RNDN);
   ptrdiff_t bin_result_strlen = out_ptr - str_ptr;
 
   long double bin_result_ld = mpfr_get_ld(bin_result, MPFR_RNDN);
   long double result_ld = mpfr_get_ld(result, MPFR_RNDN);
 
   // This detects if mpfr's strtofr selected a base of 2, which libc does not
   // support. If a base 2 decoding is detected, it is replaced by a base 10
   // decoding.
   if ((bin_result_ld != 0.0 || bin_result_strlen == result_strlen) &&
       bin_result_ld == result_ld) {
     mpfr_strtofr(result, str_ptr, &out_ptr, 10 /* base */, MPFR_RNDN);
     result_strlen = out_ptr - str_ptr;
+    base = 10;
   }
 
+  mpfr_clear(result);
+  mpfr_clear(bin_result);
+
+  // These must be calculated with the correct precision, and not any more, to
+  // prevent numbers like 66336650.00...01 (many zeroes) from causing an issue.
+  // 66336650 is exactly between two float values (66336652 and 66336648) so the
+  // correct float result for 66336650.00...01 is rounding up to 66336652. The
+  // correct double is instead 66336650, which when converted to float is
+  // rounded down to 66336648. This means we have to compare against the correct
+  // precision to get the correct result.
+  mpfr_t mpfr_float;
+  mpfr_init2(mpfr_float, FloatProperties<float>::MANTISSA_PRECISION);
+
+  mpfr_t mpfr_double;
+  mpfr_init2(mpfr_double, FloatProperties<double>::MANTISSA_PRECISION);
+
+  mpfr_t mpfr_long_double;
+  mpfr_init2(mpfr_long_double,
+             FloatProperties<long double>::MANTISSA_PRECISION);
+
+  // TODO: Add support for other rounding modes.
+  mpfr_strtofr(mpfr_float, str_ptr, &out_ptr, base, MPFR_RNDN);
+  mpfr_strtofr(mpfr_double, str_ptr, &out_ptr, base, MPFR_RNDN);
+  mpfr_strtofr(mpfr_long_double, str_ptr, &out_ptr, base, MPFR_RNDN);
+
+  float volatile float_result = mpfr_get_flt(mpfr_float, MPFR_RNDN);
+  double volatile double_result = mpfr_get_d(mpfr_double, MPFR_RNDN);
+  long double volatile long_double_result =
+      mpfr_get_ld(mpfr_long_double, MPFR_RNDN);
+
+  mpfr_clear(mpfr_float);
+  mpfr_clear(mpfr_double);
+  mpfr_clear(mpfr_long_double);
+
   auto volatile atof_output = __llvm_libc::atof(str_ptr);
   auto volatile strtof_output = __llvm_libc::strtof(str_ptr, &out_ptr);
   ptrdiff_t strtof_strlen = out_ptr - str_ptr;
   if (result_strlen != strtof_strlen)
     __builtin_trap();
   auto volatile strtod_output = __llvm_libc::strtod(str_ptr, &out_ptr);
   ptrdiff_t strtod_strlen = out_ptr - str_ptr;
   if (result_strlen != strtod_strlen)
     __builtin_trap();
   auto volatile strtold_output = __llvm_libc::strtold(str_ptr, &out_ptr);
   ptrdiff_t strtold_strlen = out_ptr - str_ptr;
   if (result_strlen != strtold_strlen)
     __builtin_trap();
 
   // If any result is NaN, all of them should be NaN. We can't use the usual
   // comparisons because NaN != NaN.
-  if (isnan(result_ld)) {
+  if (isnan(float_result)) {
     if (!(isnan(atof_output) && isnan(strtof_output) && isnan(strtod_output) &&
           isnan(strtold_output)))
       __builtin_trap();
   } else {
-    if (mpfr_get_d(result, MPFR_RNDN) != atof_output)
+    if (double_result != atof_output)
       __builtin_trap();
-    if (mpfr_get_flt(result, MPFR_RNDN) != strtof_output)
+    if (float_result != strtof_output)
       __builtin_trap();
-    if (mpfr_get_d(result, MPFR_RNDN) != strtod_output)
+    if (double_result != strtod_output)
       __builtin_trap();
-    if (mpfr_get_ld(result, MPFR_RNDN) != strtold_output)
+    if (long_double_result != strtold_output)
       __builtin_trap();
   }
 
-  mpfr_clear(result);
-  mpfr_clear(bin_result);
   delete[] container;
   return 0;
 }

libc/src/__support/FPUtil/FloatProperties.h

 template <> struct FloatProperties<float> {
   typedef uint32_t BitsType;
   static_assert(sizeof(BitsType) == sizeof(float),
                 "Unexpected size of 'float' type.");
 
   static constexpr uint32_t BIT_WIDTH = sizeof(BitsType) * 8;
 
   static constexpr uint32_t MANTISSA_WIDTH = 23;
+  // The mantissa precision includes the implicit bit.
+  static constexpr uint32_t MANTISSA_PRECISION = MANTISSA_WIDTH + 1;
   static constexpr uint32_t EXPONENT_WIDTH = 8;
   static constexpr BitsType MANTISSA_MASK = (BitsType(1) << MANTISSA_WIDTH) - 1;
   static constexpr BitsType SIGN_MASK = BitsType(1)
                                         << (EXPONENT_WIDTH + MANTISSA_WIDTH);
   static constexpr BitsType EXPONENT_MASK = ~(SIGN_MASK | MANTISSA_MASK);
   static constexpr uint32_t EXPONENT_BIAS = 127;
 
   static constexpr BitsType EXP_MANT_MASK = MANTISSA_MASK + EXPONENT_MASK;

 template <> struct FloatProperties<double> {
   typedef uint64_t BitsType;
   static_assert(sizeof(BitsType) == sizeof(double),
                 "Unexpected size of 'double' type.");
 
   static constexpr uint32_t BIT_WIDTH = sizeof(BitsType) * 8;
 
   static constexpr uint32_t MANTISSA_WIDTH = 52;
+  static constexpr uint32_t MANTISSA_PRECISION = MANTISSA_WIDTH + 1;
   static constexpr uint32_t EXPONENT_WIDTH = 11;
   static constexpr BitsType MANTISSA_MASK = (BitsType(1) << MANTISSA_WIDTH) - 1;
   static constexpr BitsType SIGN_MASK = BitsType(1)
                                         << (EXPONENT_WIDTH + MANTISSA_WIDTH);
   static constexpr BitsType EXPONENT_MASK = ~(SIGN_MASK | MANTISSA_MASK);
   static constexpr uint32_t EXPONENT_BIAS = 1023;
 
   static constexpr BitsType EXP_MANT_MASK = MANTISSA_MASK + EXPONENT_MASK;
template <> struct FloatProperties<long double> {
   typedef uint64_t BitsType;
   static_assert(sizeof(BitsType) == sizeof(double),
                 "Unexpected size of 'double' type.");
 
   static constexpr uint32_t BIT_WIDTH = FloatProperties<double>::BIT_WIDTH;
 
   static constexpr uint32_t MANTISSA_WIDTH =
       FloatProperties<double>::MANTISSA_WIDTH;
+  static constexpr uint32_t MANTISSA_PRECISION = MANTISSA_WIDTH + 1;
   static constexpr uint32_t EXPONENT_WIDTH =
       FloatProperties<double>::EXPONENT_WIDTH;
   static constexpr BitsType MANTISSA_MASK =
       FloatProperties<double>::MANTISSA_MASK;
   static constexpr BitsType SIGN_MASK = FloatProperties<double>::SIGN_MASK;
   static constexpr BitsType EXPONENT_MASK =
       FloatProperties<double>::EXPONENT_MASK;
   static constexpr uint32_t EXPONENT_BIAS =
template <> struct FloatProperties<long double> {
   typedef UInt128 BitsType;
   static_assert(sizeof(BitsType) == sizeof(long double),
                 "Unexpected size of 'long double' type.");
 
   static constexpr uint32_t BIT_WIDTH = (sizeof(BitsType) * 8) - 48;
   static constexpr BitsType FULL_WIDTH_MASK = ((BitsType(1) << BIT_WIDTH) - 1);
 
   static constexpr uint32_t MANTISSA_WIDTH = 63;
+  static constexpr uint32_t MANTISSA_PRECISION = MANTISSA_WIDTH + 1;
   static constexpr uint32_t EXPONENT_WIDTH = 15;
   static constexpr BitsType MANTISSA_MASK = (BitsType(1) << MANTISSA_WIDTH) - 1;
 
   // The x86 80 bit float represents the leading digit of the mantissa
   // explicitly. This is the mask for that bit.
   static constexpr BitsType EXPLICIT_BIT_MASK = (BitsType(1) << MANTISSA_WIDTH);
 
   static constexpr BitsType SIGN_MASK =

 template <> struct FloatProperties<long double> {
   typedef UInt128 BitsType;
   static_assert(sizeof(BitsType) == sizeof(long double),
                 "Unexpected size of 'long double' type.");
 
   static constexpr uint32_t BIT_WIDTH = sizeof(BitsType) << 3;
 
   static constexpr uint32_t MANTISSA_WIDTH = 112;
+  static constexpr uint32_t MANTISSA_PRECISION = MANTISSA_WIDTH + 1;
   static constexpr uint32_t EXPONENT_WIDTH = 15;
   static constexpr BitsType MANTISSA_MASK = (BitsType(1) << MANTISSA_WIDTH) - 1;
   static constexpr BitsType SIGN_MASK = BitsType(1)
                                         << (EXPONENT_WIDTH + MANTISSA_WIDTH);
   static constexpr BitsType EXPONENT_MASK = ~(SIGN_MASK | MANTISSA_MASK);
   static constexpr uint32_t EXPONENT_BIAS = 16383;
 
   static constexpr BitsType EXP_MANT_MASK = MANTISSA_MASK | EXPONENT_MASK;

libc/utils/MPFRWrapper/CMakeLists.txt

 if(LIBC_TESTS_CAN_USE_MPFR)
   add_library(libcMPFRWrapper
     MPFRUtils.cpp
     MPFRUtils.h
     mpfr_inc.h
   )
   add_compile_options(
     -O3
   )
   add_dependencies(
     libcMPFRWrapper 
     libc.src.__support.CPP.string_view 
     libc.src.__support.CPP.type_traits 
     libc.src.__support.FPUtil.fp_bits
+    libc.src.__support.FPUtil.float_properties
     libc.src.__support.FPUtil.fpbits_str
     libc.src.__support.FPUtil.platform_defs
     LibcTest.unit
   )
   if(EXISTS ${LLVM_LIBC_MPFR_INSTALL_PATH})
     target_include_directories(libcMPFRWrapper PUBLIC ${LLVM_LIBC_MPFR_INSTALL_PATH}/include)
     target_link_directories(libcMPFRWrapper PUBLIC ${LLVM_LIBC_MPFR_INSTALL_PATH}/lib)
   endif()
   target_link_libraries(libcMPFRWrapper LibcFPTestHelpers.unit LibcTest.unit mpfr gmp)
 elseif(NOT LIBC_TARGET_ARCHITECTURE_IS_GPU)
   message(WARNING "Math tests using MPFR will be skipped.")
 endif()

libc/utils/MPFRWrapper/MPFRUtils.cpp

 //===-- Utils which wrap MPFR ---------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "MPFRUtils.h"
 
 #include "src/__support/CPP/string.h"
 #include "src/__support/CPP/string_view.h"
 #include "src/__support/FPUtil/FPBits.h"
+#include "src/__support/FPUtil/FloatProperties.h"
 #include "src/__support/FPUtil/PlatformDefs.h"
 #include "src/__support/FPUtil/fpbits_str.h"
 #include "test/UnitTest/FPMatcher.h"
 
 #include <cmath>
 #include <fenv.h>
 #include <memory>
 #include <stdint.h>
 
 #include "mpfr_inc.h"
 
 template <typename T> using FPBits = __llvm_libc::fputil::FPBits<T>;
 
 namespace __llvm_libc {
 namespace testing {
 namespace mpfr {
 
-template <typename T> struct Precision;
-
-template <> struct Precision<float> {
-  static constexpr unsigned int VALUE = 24;
-};
-
-template <> struct Precision<double> {
-  static constexpr unsigned int VALUE = 53;
-};
-
-#if defined(LONG_DOUBLE_IS_DOUBLE)
-template <> struct Precision<long double> {
-  static constexpr unsigned int VALUE = 53;
-};
-#elif defined(SPECIAL_X86_LONG_DOUBLE)
-template <> struct Precision<long double> {
-  static constexpr unsigned int VALUE = 64;
-};
-#else
-template <> struct Precision<long double> {
-  static constexpr unsigned int VALUE = 113;
-};
-#endif
-
 // A precision value which allows sufficiently large additional
 // precision compared to the floating point precision.
 template <typename T> struct ExtraPrecision;
 
 template <> struct ExtraPrecision<float> {
   static constexpr unsigned int VALUE = 128;
 };
 
 template <> struct ExtraPrecision<double> {
   static constexpr unsigned int VALUE = 256;
 };
 
 template <> struct ExtraPrecision<long double> {
   static constexpr unsigned int VALUE = 256;
 };
 
 // If the ulp tolerance is less than or equal to 0.5, we would check that the
 // result is rounded correctly with respect to the rounding mode by using the
 // same precision as the inputs.
 template <typename T>
 static inline unsigned int get_precision(double ulp_tolerance) {
   if (ulp_tolerance <= 0.5) {
-    return Precision<T>::VALUE;
+    return __llvm_libc::fputil::FloatProperties<T>::MANTISSA_PRECISION;
   } else {
     return ExtraPrecision<T>::VALUE;
   }
 }
 
 static inline mpfr_rnd_t get_mpfr_rounding_mode(RoundingMode mode) {
   switch (mode) {
   case RoundingMode::Upward:

utils/bazel/llvm-project-overlay/libc/utils/MPFRWrapper/BUILD.bazel

cc_library(
     ),
     deps = [
         "//libc:__support_common",
         "//libc:__support_cpp_bit",
         "//libc:__support_cpp_bitset",
         "//libc:__support_cpp_string",
         "//libc:__support_cpp_string_view",
         "//libc:__support_cpp_type_traits",
+        "//libc:__support_fputil_float_properties",
         "//libc:__support_fputil_fp_bits",
         "//libc:__support_fputil_fpbits_str",
         "//libc:__support_fputil_platform_defs",
         "//libc:libc_root",
         "//libc/test/UnitTest:LibcUnitTest",
         "//libc/test/UnitTest:fp_test_helpers",
         "//libc/utils/MPFRWrapper:mpfr_impl",
     ],
 )