[libc] Resolve NaN/implementation-defined behavior of floating-point tests

[ddcc]

Remove deprecated change

[michaelrj]

libc/src/__support/FPUtil/FPBits.h

95

if you're going to make these UIntType then you should change the variable to be UIntType as well, but that shouldn't be necessary as the largest float we need to handle is quadruple precision which uses 15 bits for its exponent, and int is defined as being at least 16 bits.

169

this would make it impossible to generate a signaling NaN with this function, since it would always set the quiet bit. Currently the expectation is that the client code will pass a mantissa with the quiet bit set iff the resulting NaN should be quiet.

libc/test/src/math/RoundToIntegerTest.h

87

is this flag set anywhere?

[lntue]

libc/src/__support/FPUtil/FPBits.h

169

It's probably better to add another method called build_quiet_nan and leave build_nan to create signaling nan if needed? Most of build_nan usage in src/math folder then can simply be replaced with build_quiet_nan.

[ddcc]

Use build_quiet_nan and update CMakeLists.txt

[lntue]

libc/src/__support/FPUtil/FPBits.h

174

I think you meant to call build_nan. Otherwise this is an infinite recursion.

[ddcc]

Fix infinite recursion from sed replace

[ddcc]

Fix x86_64 long double

[michaelrj]

libc/utils/UnitTest/FPMatcher.h

75

the build failures were caused by this line. Changing it back to build_nan fixes the issue. Maybe add qNaN as an additional variable for quiet NaN purposes.

[lntue]

libc/utils/UnitTest/FPMatcher.h

75

Look like the failures are actually in the implementation and tests of atanf and atanhf. According to the spec, we should not set floating point exceptional flags when the input is NaN, signaling or quiet. You can change the atanf_test and atanhf_test to EXPECT_FP_EXCEPTION(0); for aNaN inputs and simply return x in atanf.cpp and atanhf.cpp for NaN inputs instead of x + 1.0f as of now.

[ddcc]

Fix atan behavior

[ddcc]

libc/utils/UnitTest/FPMatcher.h

75

Thanks for the help! Is there an easy way to rerun the test? ninja check-llvmlibc only works once.

[lntue]

libc/utils/UnitTest/FPMatcher.h

75

Normally I would simply $ touch <test_files> or $ touch <source_files>, and then simply run the test directly with $ ninja libc.test.src.math.<test>, unless the changes are in CMakeFiles.txt

libc/CMakeLists.txt

message(STATUS "Set COMPILER_RESOURCE_DIR to "
                  "${COMPILER_RESOURCE_DIR} using --print-resource-dir")
 else()
   set(COMPILER_RESOURCE_DIR OFF)
   message(STATUS "COMPILER_RESOURCE_DIR not set
                   --print-resource-dir not supported by host compiler")
 endif()
 
 option(LLVM_LIBC_FULL_BUILD "Build and test LLVM libc as if it is the full libc" OFF)
-
+option(LLVM_LIBC_IMPLEMENTATION_DEFINED_TEST_BEHAVIOR "Build LLVM libc tests assuming our implementation-defined behavior" ON)
 option(LLVM_LIBC_ENABLE_LINTING "Enables linting of libc source files" OFF)
 
 if(LLVM_LIBC_CLANG_TIDY)
   set(LLVM_LIBC_ENABLE_LINTING ON)
 endif()
 
 if(LLVM_LIBC_ENABLE_LINTING)
   if(NOT CMAKE_CXX_COMPILER_ID STREQUAL "Clang")

libc/src/__support/FPUtil/DivisionAndRemainderOperations.h

 template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0>
 static inline T remquo(T x, T y, int &q) {
   FPBits<T> xbits(x), ybits(y);
   if (xbits.is_nan())
     return x;
   if (ybits.is_nan())
     return y;
   if (xbits.is_inf() || ybits.is_zero())
-    return FPBits<T>::build_nan(1);
+    return FPBits<T>::build_quiet_nan(1);
 
   if (xbits.is_zero()) {
     q = 0;
     return __llvm_libc::fputil::copysign(T(0.0), x);
   }
 
   if (ybits.is_inf()) {
     q = 0;

libc/src/__support/FPUtil/FPBits.h

template <typename T> struct FPBits {
 
   bool get_sign() const { return (bits & FloatProp::SIGN_MASK) != 0; }
 
   static_assert(sizeof(T) == sizeof(UIntType),
                 "Data type and integral representation have different sizes.");
 
   static constexpr int EXPONENT_BIAS = (1 << (ExponentWidth<T>::VALUE - 1)) - 1;
   static constexpr int MAX_EXPONENT = (1 << ExponentWidth<T>::VALUE) - 1;
 
   static constexpr UIntType MIN_SUBNORMAL = UIntType(1);
   static constexpr UIntType MAX_SUBNORMAL =
       (UIntType(1) << MantissaWidth<T>::VALUE) - 1;
   static constexpr UIntType MIN_NORMAL =
       (UIntType(1) << MantissaWidth<T>::VALUE);
   static constexpr UIntType MAX_NORMAL =
       ((UIntType(MAX_EXPONENT) - 1) << MantissaWidth<T>::VALUE) | MAX_SUBNORMAL;
 
template <typename T> struct FPBits {
   static constexpr FPBits<T> neg_inf() {
     FPBits<T> bits = inf();
     bits.set_sign(1);
     return bits;
   }
 
   static constexpr T build_nan(UIntType v) {
     FPBits<T> bits = inf();
     bits.set_mantissa(v);
     return T(bits);
   }
 
+  static constexpr T build_quiet_nan(UIntType v) {
+    return build_nan(FloatProp::QUIET_NAN_MASK | v);
+  }
+
   // The function convert integer number and unbiased exponent to proper float
   // T type:
   //   Result = number * 2^(ep+1 - exponent_bias)
   // Be careful!
   //   1) "ep" is raw exponent value.
   //   2) The function add to +1 to ep for seamless normalized to denormalized
   //      transition.
   //   3) The function did not check exponent high limit.

libc/src/__support/FPUtil/generic/FMod.h

 //    https://www.open-std.org/JTC1/SC22/WG14/www/docs/n1011.htm
 template <typename T> struct FModExceptionalInputHandler {
 
   static_assert(cpp::is_floating_point_v<T>,
                 "FModCStandardWrapper instantiated with invalid type.");
 
   static bool PreCheck(T x, T y, T &out) {
     using FPB = fputil::FPBits<T>;
-    const T quiet_NaN = FPB::build_nan(FPB::FloatProp::QUIET_NAN_MASK);
+    const T quiet_NaN = FPB::build_quiet_nan(0);
     FPB sx(x), sy(y);
     if (likely(!sy.is_zero() && !sy.is_inf_or_nan() && !sx.is_inf_or_nan())) {
       return false;
     }
 
     if (sx.is_nan() || sy.is_nan()) {
       if ((sx.is_nan() && !sx.is_quiet_nan()) ||
           (sy.is_nan() && !sy.is_quiet_nan()))

libc/src/__support/FPUtil/generic/sqrt.h

if constexpr (internal::SpecialLongDouble<T>::VALUE) {
     using UIntType = typename FPBits<T>::UIntType;
     constexpr UIntType ONE = UIntType(1) << MantissaWidth<T>::VALUE;
 
     FPBits<T> bits(x);
 
     if (bits.is_inf_or_nan()) {
       if (bits.get_sign() && (bits.get_mantissa() == 0)) {
         // sqrt(-Inf) = NaN
-        return FPBits<T>::build_nan(ONE >> 1);
+        return FPBits<T>::build_quiet_nan(ONE >> 1);
       } else {
         // sqrt(NaN) = NaN
         // sqrt(+Inf) = +Inf
         return x;
       }
     } else if (bits.is_zero()) {
       // sqrt(+0) = +0
       // sqrt(-0) = -0
       return x;
     } else if (bits.get_sign()) {
       // sqrt( negative numbers ) = NaN
-      return FPBits<T>::build_nan(ONE >> 1);
+      return FPBits<T>::build_quiet_nan(ONE >> 1);
     } else {
       int x_exp = bits.get_exponent();
       UIntType x_mant = bits.get_mantissa();
 
       // Step 1a: Normalize denormal input and append hidden bit to the mantissa
       if (bits.get_unbiased_exponent() == 0) {
         ++x_exp; // let x_exp be the correct exponent of ONE bit.
         internal::normalize<T>(x_exp, x_mant);

libc/src/__support/FPUtil/generic/sqrt_80_bit_long_double.h

static inline long double sqrt(long double x) {
   constexpr UIntType ONE = UIntType(1)
                            << int(MantissaWidth<long double>::VALUE);
 
   FPBits<long double> bits(x);
 
   if (bits.is_inf_or_nan()) {
     if (bits.get_sign() && (bits.get_mantissa() == 0)) {
       // sqrt(-Inf) = NaN
-      return FPBits<long double>::build_nan(ONE >> 1);
+      return FPBits<long double>::build_quiet_nan(ONE >> 1);
     } else {
       // sqrt(NaN) = NaN
       // sqrt(+Inf) = +Inf
       return x;
     }
   } else if (bits.is_zero()) {
     // sqrt(+0) = +0
     // sqrt(-0) = -0
     return x;
   } else if (bits.get_sign()) {
     // sqrt( negative numbers ) = NaN
-    return FPBits<long double>::build_nan(ONE >> 1);
+    return FPBits<long double>::build_quiet_nan(ONE >> 1);
   } else {
     int x_exp = bits.get_exponent();
     UIntType x_mant = bits.get_mantissa();
 
     // Step 1a: Normalize denormal input
     if (bits.get_implicit_bit()) {
       x_mant |= ONE;
     } else if (bits.get_unbiased_exponent() == 0) {

libc/src/__support/FPUtil/x86_64/LongDoubleBits.h

template <> struct FPBits<long double> {
   static long double build_nan(UIntType v) {
     FPBits<long double> bits(0.0l);
     bits.set_unbiased_exponent(MAX_EXPONENT);
     bits.set_implicit_bit(1);
     bits.set_mantissa(v);
     return bits;
   }
 
+  static long double build_quiet_nan(UIntType v) {
+    return build_nan(FloatProp::QUIET_NAN_MASK | v);
+  }
+
   inline static FPBits<long double>
   create_value(bool sign, UIntType unbiased_exp, UIntType mantissa) {
     FPBits<long double> result;
     result.set_sign(sign);
     result.set_unbiased_exponent(unbiased_exp);
     result.set_mantissa(mantissa);
     return result;
   }

libc/src/__support/str_to_float.h

if ((src[1] | 32) == nan_string[1] && (src[2] | 32) == nan_string[2]) {
             if (*temp_src != ')')
               nan_mantissa = 0;
           }
         } else
           src = left_paren;
       }
       nan_mantissa |= fputil::FloatProperties<T>::QUIET_NAN_MASK;
       if (result.get_sign()) {
-        result = fputil::FPBits<T>(result.build_nan(nan_mantissa));
+        result = fputil::FPBits<T>(result.build_quiet_nan(nan_mantissa));
         result.set_sign(true);
       } else {
         result.set_sign(false);
-        result = fputil::FPBits<T>(result.build_nan(nan_mantissa));
+        result = fputil::FPBits<T>(result.build_quiet_nan(nan_mantissa));
       }
     }
   } else if ((*src | 32) == 'i') { // INF
     if ((src[1] | 32) == inf_string[1] && (src[2] | 32) == inf_string[2]) {
       seen_digit = true;
       if (result.get_sign())
         result = result.neg_inf();
       else

libc/src/math/generic/atanf.cpp

LLVM_LIBC_FUNCTION(float, atanf, (float x)) {
   FPBits xbits(x);
   bool sign = xbits.get_sign();
   xbits.set_sign(false);
 
   if (unlikely(xbits.is_inf_or_nan())) {
     if (xbits.is_inf())
       return opt_barrier(sign ? -M_MATH_PI_2 : M_MATH_PI_2);
     else
-      return x + 1.0f;
+      return x;
   }
   // |x| == 0.06905200332403183
   if (unlikely(xbits.uintval() == 0x3d8d6b23U)) {
     if (fputil::get_round() == FE_TONEAREST) {
       // 0.06894256919622421
       FPBits br(0x3d8d31c3U);
       br.set_sign(sign);
       return br.get_val();

libc/src/math/generic/atanhf.cpp

LLVM_LIBC_FUNCTION(float, atanhf, (float x)) {
   using FPBits = typename fputil::FPBits<float>;
   FPBits xbits(x);
   bool sign = xbits.get_sign();
   uint32_t x_abs = xbits.uintval() & FPBits::FloatProp::EXP_MANT_MASK;
 
   // |x| >= 1.0
   if (unlikely(x_abs >= 0x3F80'0000U)) {
     if (xbits.is_nan()) {
-      return x + 1.0f;
+      return x;
     }
     // |x| == 0
     if (x_abs == 0x3F80'0000U) {
       fputil::set_except(FE_DIVBYZERO);
       return with_errno(FPBits::inf(sign).get_val(), ERANGE);
     } else {
       fputil::set_except(FE_INVALID);
       return with_errno(

libc/test/src/math/FDimTest.h

for (UIntType i = 0, v = 0, w = UIntType(-1); i <= COUNT;
         EXPECT_FP_EQ(zero, func(x, y));
       }
     }
   }
 
 private:
   // constexpr does not work on FPBits yet, so we cannot have these constants as
   // static.
-  const T nan = T(__llvm_libc::fputil::FPBits<T>::build_nan(1));
+  const T nan = T(__llvm_libc::fputil::FPBits<T>::build_quiet_nan(1));
   const T inf = T(__llvm_libc::fputil::FPBits<T>::inf());
   const T neg_inf = T(__llvm_libc::fputil::FPBits<T>::neg_inf());
   const T zero = T(__llvm_libc::fputil::FPBits<T>::zero());
   const T neg_zero = T(__llvm_libc::fputil::FPBits<T>::neg_zero());
 };

libc/test/src/math/FmaTest.h

 namespace mpfr = __llvm_libc::testing::mpfr;
 
 template <typename T>
 class FmaTestTemplate : public __llvm_libc::testing::Test {
 private:
   using Func = T (*)(T, T, T);
   using FPBits = __llvm_libc::fputil::FPBits<T>;
   using UIntType = typename FPBits::UIntType;
-  const T nan = T(__llvm_libc::fputil::FPBits<T>::build_nan(1));
+  const T nan = T(__llvm_libc::fputil::FPBits<T>::build_quiet_nan(1));
   const T inf = T(__llvm_libc::fputil::FPBits<T>::inf());
   const T neg_inf = T(__llvm_libc::fputil::FPBits<T>::neg_inf());
   const T zero = T(__llvm_libc::fputil::FPBits<T>::zero());
   const T neg_zero = T(__llvm_libc::fputil::FPBits<T>::neg_zero());
 
   UIntType get_random_bit_pattern() {
     UIntType bits{0};
     for (UIntType i = 0; i < sizeof(UIntType) / 2; ++i) {

libc/test/src/math/HypotTest.h

 namespace mpfr = __llvm_libc::testing::mpfr;
 
 template <typename T>
 class HypotTestTemplate : public __llvm_libc::testing::Test {
 private:
   using Func = T (*)(T, T);
   using FPBits = __llvm_libc::fputil::FPBits<T>;
   using UIntType = typename FPBits::UIntType;
-  const T nan = T(FPBits::build_nan(1));
+  const T nan = T(FPBits::build_quiet_nan(1));
   const T inf = T(FPBits::inf());
   const T neg_inf = T(FPBits::neg_inf());
   const T zero = T(FPBits::zero());
   const T neg_zero = T(FPBits::neg_zero());
   const T max_normal = T(FPBits(FPBits::MAX_NORMAL));
   const T min_normal = T(FPBits(FPBits::MIN_NORMAL));
   const T max_subnormal = T(FPBits(FPBits::MAX_SUBNORMAL));
   const T min_subnormal = T(FPBits(FPBits::MIN_SUBNORMAL));

libc/test/src/math/ILogbTest.h

public:
   template <typename T> struct ILogbFunc { typedef int (*Func)(T); };
 
   template <typename T>
   void test_special_numbers(typename ILogbFunc<T>::Func func) {
     EXPECT_EQ(FP_ILOGB0, func(T(__llvm_libc::fputil::FPBits<T>::zero())));
     EXPECT_EQ(FP_ILOGB0, func(T(__llvm_libc::fputil::FPBits<T>::neg_zero())));
 
     EXPECT_EQ(FP_ILOGBNAN,
-              func(T(__llvm_libc::fputil::FPBits<T>::build_nan(1))));
+              func(T(__llvm_libc::fputil::FPBits<T>::build_quiet_nan(1))));
 
     EXPECT_EQ(INT_MAX, func(T(__llvm_libc::fputil::FPBits<T>::inf())));
     EXPECT_EQ(INT_MAX, func(T(__llvm_libc::fputil::FPBits<T>::neg_inf())));
   }
 
   template <typename T>
   void test_powers_of_two(typename ILogbFunc<T>::Func func) {
     EXPECT_EQ(0, func(T(1.0)));

libc/test/src/math/LdExpTest.h

static constexpr UIntType MANTISSA_WIDTH =
       __llvm_libc::fputil::MantissaWidth<T>::VALUE;
   // A normalized mantissa to be used with tests.
   static constexpr UIntType MANTISSA = NormalFloat::ONE + 0x1234;
 
   const T zero = T(__llvm_libc::fputil::FPBits<T>::zero());
   const T neg_zero = T(__llvm_libc::fputil::FPBits<T>::neg_zero());
   const T inf = T(__llvm_libc::fputil::FPBits<T>::inf());
   const T neg_inf = T(__llvm_libc::fputil::FPBits<T>::neg_inf());
-  const T nan = T(__llvm_libc::fputil::FPBits<T>::build_nan(1));
+  const T nan = T(__llvm_libc::fputil::FPBits<T>::build_quiet_nan(1));
 
 public:
   typedef T (*LdExpFunc)(T, int);
 
   void testSpecialNumbers(LdExpFunc func) {
     int exp_array[5] = {-INT_MAX - 1, -10, 0, 10, INT_MAX};
     for (int exp : exp_array) {
       ASSERT_FP_EQ(zero, func(zero, exp));

libc/test/src/math/NextAfterTest.h

class NextAfterTestTemplate : public __llvm_libc::testing::Test {
 
   static constexpr int BIT_WIDTH_OF_TYPE =
       __llvm_libc::fputil::FloatProperties<T>::BIT_WIDTH;
 
   const T zero = T(FPBits::zero());
   const T neg_zero = T(FPBits::neg_zero());
   const T inf = T(FPBits::inf());
   const T neg_inf = T(FPBits::neg_inf());
-  const T nan = T(FPBits::build_nan(1));
+  const T nan = T(FPBits::build_quiet_nan(1));
   const UIntType min_subnormal = FPBits::MIN_SUBNORMAL;
   const UIntType max_subnormal = FPBits::MAX_SUBNORMAL;
   const UIntType min_normal = FPBits::MIN_NORMAL;
   const UIntType max_normal = FPBits::MAX_NORMAL;
 
 public:
   typedef T (*NextAfterFunc)(T, T);
 

libc/test/src/math/RIntTest.h

 private:
   using FPBits = __llvm_libc::fputil::FPBits<T>;
   using UIntType = typename FPBits::UIntType;
 
   const T zero = T(FPBits::zero());
   const T neg_zero = T(FPBits::neg_zero());
   const T inf = T(FPBits::inf());
   const T neg_inf = T(FPBits::neg_inf());
-  const T nan = T(FPBits::build_nan(1));
+  const T nan = T(FPBits::build_quiet_nan(1));
 
   static inline mpfr::RoundingMode to_mpfr_rounding_mode(int mode) {
     switch (mode) {
     case FE_UPWARD:
       return mpfr::RoundingMode::Upward;
     case FE_DOWNWARD:
       return mpfr::RoundingMode::Downward;
     case FE_TOWARDZERO:

libc/test/src/math/RemQuoTest.h

 class RemQuoTestTemplate : public __llvm_libc::testing::Test {
   using FPBits = __llvm_libc::fputil::FPBits<T>;
   using UIntType = typename FPBits::UIntType;
 
   const T zero = T(__llvm_libc::fputil::FPBits<T>::zero());
   const T neg_zero = T(__llvm_libc::fputil::FPBits<T>::neg_zero());
   const T inf = T(__llvm_libc::fputil::FPBits<T>::inf());
   const T neg_inf = T(__llvm_libc::fputil::FPBits<T>::neg_inf());
-  const T nan = T(__llvm_libc::fputil::FPBits<T>::build_nan(1));
+  const T nan = T(__llvm_libc::fputil::FPBits<T>::build_quiet_nan(1));
 
 public:
   typedef T (*RemQuoFunc)(T, T, int *);
 
   void testSpecialNumbers(RemQuoFunc func) {
     int quotient;
     T x, y;
 

libc/test/src/math/RoundToIntegerTest.h

 private:
   using FPBits = __llvm_libc::fputil::FPBits<F>;
   using UIntType = typename FPBits::UIntType;
 
   const F zero = F(__llvm_libc::fputil::FPBits<F>::zero());
   const F neg_zero = F(__llvm_libc::fputil::FPBits<F>::neg_zero());
   const F inf = F(__llvm_libc::fputil::FPBits<F>::inf());
   const F neg_inf = F(__llvm_libc::fputil::FPBits<F>::neg_inf());
-  const F nan = F(__llvm_libc::fputil::FPBits<F>::build_nan(1));
+  const F nan = F(__llvm_libc::fputil::FPBits<F>::build_quiet_nan(1));
   static constexpr I INTEGER_MIN = I(1) << (sizeof(I) * 8 - 1);
   static constexpr I INTEGER_MAX = -(INTEGER_MIN + 1);
 
   void test_one_input(RoundToIntegerFunc func, F input, I expected,
                       bool expectError) {
     errno = 0;
     __llvm_libc::fputil::clear_except(FE_ALL_EXCEPT);
 
if (math_errhandling & MATH_ERREXCEPT) {
       // if the appropriate flag was raised.
       __llvm_libc::fputil::disable_except(FE_ALL_EXCEPT);
     }
   }
 
   void do_infinity_and_na_n_test(RoundToIntegerFunc func) {
     test_one_input(func, inf, INTEGER_MAX, true);
     test_one_input(func, neg_inf, INTEGER_MIN, true);
+#if LLVM_LIBC_IMPLEMENTATION_DEFINED_TEST_BEHAVIOR
+    // Result is not well-defined, we always returns INTEGER_MAX
     test_one_input(func, nan, INTEGER_MAX, true);
+#endif
   }
 
   void testInfinityAndNaN(RoundToIntegerFunc func) {
     if (TestModes) {
       for (int mode : ROUNDING_MODES) {
         __llvm_libc::fputil::set_round(mode);
         do_infinity_and_na_n_test(func);
       }

libc/test/src/math/atanf_test.cpp

 namespace mpfr = __llvm_libc::testing::mpfr;
 
 DECLARE_SPECIAL_CONSTANTS(float)
 
 TEST(LlvmLibcAtanfTest, SpecialNumbers) {
   errno = 0;
   __llvm_libc::fputil::clear_except(FE_ALL_EXCEPT);
   EXPECT_FP_EQ(aNaN, __llvm_libc::atanf(aNaN));
-  EXPECT_FP_EXCEPTION(FE_INVALID);
+  EXPECT_FP_EXCEPTION(0);
   EXPECT_MATH_ERRNO(0);
 
   __llvm_libc::fputil::clear_except(FE_ALL_EXCEPT);
   EXPECT_FP_EQ(0.0f, __llvm_libc::atanf(0.0f));
   EXPECT_FP_EXCEPTION(0);
   EXPECT_MATH_ERRNO(0);
 
   __llvm_libc::fputil::clear_except(FE_ALL_EXCEPT);

libc/test/src/math/atanhf_test.cpp

 namespace mpfr = __llvm_libc::testing::mpfr;
 
 DECLARE_SPECIAL_CONSTANTS(float)
 
 TEST(LlvmLibcAtanhfTest, SpecialNumbers) {
   errno = 0;
   __llvm_libc::fputil::clear_except(FE_ALL_EXCEPT);
   EXPECT_FP_EQ(aNaN, __llvm_libc::atanhf(aNaN));
-  EXPECT_FP_EXCEPTION(FE_INVALID);
+  EXPECT_FP_EXCEPTION(0);
   EXPECT_MATH_ERRNO(0);
 
   __llvm_libc::fputil::clear_except(FE_ALL_EXCEPT);
   EXPECT_FP_EQ(0.0f, __llvm_libc::atanhf(0.0f));
   EXPECT_FP_EXCEPTION(0);
   EXPECT_MATH_ERRNO(0);
 
   __llvm_libc::fputil::clear_except(FE_ALL_EXCEPT);

libc/utils/UnitTest/FPMatcher.h

 } // namespace fputil
 } // namespace __llvm_libc
 
 #define DECLARE_SPECIAL_CONSTANTS(T)                                           \
   using FPBits = __llvm_libc::fputil::FPBits<T>;                               \
   using UIntType = typename FPBits::UIntType;                                  \
   const T zero = T(FPBits::zero());                                            \
   const T neg_zero = T(FPBits::neg_zero());                                    \
-  const T aNaN = T(FPBits::build_nan(1));                                      \
+  const T aNaN = T(FPBits::build_quiet_nan(1));                                \
   const T inf = T(FPBits::inf());                                              \
   const T neg_inf = T(FPBits::neg_inf());
 
 #define EXPECT_FP_EQ(expected, actual)                                         \
   EXPECT_THAT(                                                                 \
       actual,                                                                  \
       __llvm_libc::fputil::testing::getMatcher<__llvm_libc::testing::Cond_EQ>( \
           expected))