[libc][math] Set floating point exceptions for exp*f, sinhf, and coshf.

[lntue]

Summary

Set FE_OVERFLOW and FE_UNDERFLOW for expf, exp2f, exp10f, expm1f, sinhf
and coshf.

[sivachandra]

Should the errno be set and exceptions raised based on math_errhandling?

[lntue]

In D144340#4145798, @sivachandra wrote:

Should the errno be set and exceptions raised based on math_errhandling?

I skipped the check for math_errhandling because of the following line from https://en.cppreference.com/w/cpp/numeric/math/math_errhandling :

If the implementation supports IEEE floating-point arithmetic (IEC 60559), math_errhandling & MATH_ERREXCEPT is required to be non-zero.

[renyichen]

libc/test/src/math/exp10f_test.cpp

42

also test Underflow?

[sivachandra]

In D144340#4145803, @lntue wrote:

In D144340#4145798, @sivachandra wrote:

Should the errno be set and exceptions raised based on math_errhandling?

I skipped the check for math_errhandling because of the following line from https://en.cppreference.com/w/cpp/numeric/math/math_errhandling :

If the implementation supports IEEE floating-point arithmetic (IEC 60559), math_errhandling & MATH_ERREXCEPT is required to be non-zero.

I think that is true when the implementation is conformant. But, under __FAST_MATH__, it is expected that math_errhandling evaluates to zero: https://github.com/llvm/llvm-project/blob/main/libc/config/linux/api.td#L57. There is __NO_MATH_ERRNO__ also.

[lntue]

Only raise floating point exceptions for math functions if required.

[lntue]

Add underflow tests for exp10f.

[sivachandra]

libc/src/__support/FPUtil/FEnvImpl.h

52 ↗

(On Diff #500230)

The utils here are what I would view as "only if required" utils to be employed just before returning from a public function. So, I would prefer if they live in the src/math directory, much like https://github.com/llvm/llvm-project/blob/main/libc/src/math/generic/math_utils.h#L53. At some point they should be unified.

55 ↗

(On Diff #500230)

if constexpr (...) here and below?

[lntue]

libc/src/__support/FPUtil/FEnvImpl.h

55 ↗

(On Diff #500230)

If I remember it right, last time I tried on some platform (maybe Apple clang on mac M1 ?), math_errhandling is defined to be a non-constexpr builtin function call __builtin_math_errhandling, making if failed to compile if math_errhandling is put under if constexpr.

libc/src/math/generic/coshf.cpp

if (LIBC_UNLIKELY(x_u >= 0x42b4'0000U)) {
     if (xbits.is_inf_or_nan())
       return x + FPBits::inf().get_val();
 
     int rounding = fputil::get_round();
     if (LIBC_UNLIKELY(rounding == FE_DOWNWARD || rounding == FE_TOWARDZERO))
       return FPBits(FPBits::MAX_NORMAL).get_val();
 
     errno = ERANGE;
+    fputil::raise_except(FE_OVERFLOW);
 
     return x + FPBits::inf().get_val();
   }
 
   // TODO: We should be able to reduce the latency and reciprocal throughput
   // further by using a low degree (maybe 3-7 ?) minimax polynomial for small
   // but not too small inputs, such as |x| < 2^-2, or |x| < 2^-3.
 
   // cosh(x) = (e^x + e^(-x)) / 2.
   return exp_pm_eval</*is_sinh*/ false>(x);
 }
 
 } // namespace __llvm_libc

libc/src/math/generic/exp10f.cpp

if (x_u > 0xc234'9e35U) {
       if (xbits.is_inf())
         return 0.0f;
       // exp(nan) = nan
       if (xbits.is_nan())
         return x;
       if (fputil::get_round() == FE_UPWARD)
         return static_cast<float>(FPBits(FPBits::MIN_SUBNORMAL));
       errno = ERANGE;
+      fputil::raise_except(FE_UNDERFLOW);
       return 0.0f;
     }
     // x >= log10(2^128) or nan
     if (!xbits.get_sign() && (x_u >= 0x421a'209bU)) {
       // x is finite
       if (x_u < 0x7f80'0000U) {
         int rounding = fputil::get_round();
         if (rounding == FE_DOWNWARD || rounding == FE_TOWARDZERO)
           return static_cast<float>(FPBits(FPBits::MAX_NORMAL));
 
         errno = ERANGE;
+        fputil::raise_except(FE_OVERFLOW);
       }
       // x is +inf or nan
       return x + static_cast<float>(FPBits::inf());
     }
   }
 
   // When |x| <= log10(2)*2^-6
   if (LIBC_UNLIKELY(x_abs <= 0x3b9a'209bU)) {

libc/src/math/generic/exp2f.cpp

if (LIBC_UNLIKELY(x_abs >= 0x4300'0000U)) {
     if (!xbits.get_sign()) {
       // x is finite
       if (x_u < 0x7f80'0000U) {
         int rounding = fputil::get_round();
         if (rounding == FE_DOWNWARD || rounding == FE_TOWARDZERO)
           return static_cast<float>(FPBits(FPBits::MAX_NORMAL));
 
         errno = ERANGE;
+        fputil::raise_except(FE_OVERFLOW);
       }
       // x is +inf or nan
       return x + FPBits::inf().get_val();
     }
     // x <= -150
     if (x_u >= 0xc316'0000U) {
       // exp(-Inf) = 0
       if (xbits.is_inf())
         return 0.0f;
       // exp(nan) = nan
       if (xbits.is_nan())
         return x;
       if (fputil::get_round() == FE_UPWARD)
         return FPBits(FPBits::MIN_SUBNORMAL).get_val();
-      if (x != 0.0f)
+      if (x != 0.0f) {
         errno = ERANGE;
+        fputil::raise_except(FE_UNDERFLOW);
+      }
       return 0.0f;
     }
   }
 
   // Check exceptional values.
   if (LIBC_UNLIKELY((x_u & exval_mask) == exval_mask)) {
     if (LIBC_UNLIKELY(x_u == exval1)) { // x = 0x1.853a6ep-9f
       if (fputil::get_round() == FE_TONEAREST)

libc/src/math/generic/expf.cpp

if (xbits.uintval() >= 0xc2cf'f1b5U) {
       if (xbits.is_inf())
         return 0.0f;
       // exp(nan) = nan
       if (xbits.is_nan())
         return x;
       if (fputil::get_round() == FE_UPWARD)
         return static_cast<float>(FPBits(FPBits::MIN_SUBNORMAL));
       errno = ERANGE;
+      fputil::raise_except(FE_UNDERFLOW);
       return 0.0f;
     }
     // x >= 89 or nan
     if (!xbits.get_sign() && (xbits.uintval() >= 0x42b2'0000)) {
       // x is finite
       if (xbits.uintval() < 0x7f80'0000U) {
         int rounding = fputil::get_round();
         if (rounding == FE_DOWNWARD || rounding == FE_TOWARDZERO)
           return static_cast<float>(FPBits(FPBits::MAX_NORMAL));
 
         errno = ERANGE;
+        fputil::raise_except(FE_OVERFLOW);
       }
       // x is +inf or nan
       return x + static_cast<float>(FPBits::inf());
     }
   }
   // For -104 < x < 89, to compute exp(x), we perform the following range
   // reduction: find hi, mid, lo such that:
   //   x = hi + mid + lo, in which

libc/src/math/generic/expm1f.cpp

if (xbits.get_sign()) {
       // x >= 89 or nan
       if (xbits.uintval() >= 0x42b2'0000) {
         if (xbits.uintval() < 0x7f80'0000U) {
           int rounding = fputil::get_round();
           if (rounding == FE_DOWNWARD || rounding == FE_TOWARDZERO)
             return static_cast<float>(FPBits(FPBits::MAX_NORMAL));
 
           errno = ERANGE;
+          fputil::raise_except(FE_OVERFLOW);
         }
         return x + static_cast<float>(FPBits::inf());
       }
     }
   }
 
   // |x| < 2^-4
   if (x_abs < 0x3d80'0000U) {

libc/src/math/generic/sinhf.cpp

if (sign) {
         return FPBits(FPBits::MAX_NORMAL | FPBits::FloatProp::SIGN_MASK)
             .get_val();
     } else {
       if (LIBC_UNLIKELY(rounding == FE_DOWNWARD || rounding == FE_TOWARDZERO))
         return FPBits(FPBits::MAX_NORMAL).get_val();
     }
 
     errno = ERANGE;
+    fputil::raise_except(FE_OVERFLOW);
 
     return x + FPBits::inf(sign).get_val();
   }
 
   // |x| <= 0.078125
   if (LIBC_UNLIKELY(x_abs <= 0x3da0'0000U)) {
     // |x| = 0.0005589424981735646724700927734375
     if (LIBC_UNLIKELY(x_abs == 0x3a12'85ffU)) {

libc/test/src/math/coshf_test.cpp

TEST(LlvmLibcCoshfTest, SpecialNumbers) {
   EXPECT_MATH_ERRNO(0);
 
   EXPECT_FP_EQ(1.0f, __llvm_libc::coshf(-0.0f));
   EXPECT_MATH_ERRNO(0);
 }
 
 TEST(LlvmLibcCoshfTest, Overflow) {
   errno = 0;
-  EXPECT_FP_EQ(inf, __llvm_libc::coshf(float(FPBits(0x7f7fffffU))));
+  EXPECT_FP_EQ_WITH_EXCEPTION(
+      inf, __llvm_libc::coshf(float(FPBits(0x7f7fffffU))), FE_OVERFLOW);
   EXPECT_MATH_ERRNO(ERANGE);
 
-  EXPECT_FP_EQ(inf, __llvm_libc::coshf(float(FPBits(0x42cffff8U))));
+  EXPECT_FP_EQ_WITH_EXCEPTION(
+      inf, __llvm_libc::coshf(float(FPBits(0x42cffff8U))), FE_OVERFLOW);
   EXPECT_MATH_ERRNO(ERANGE);
 
-  EXPECT_FP_EQ(inf, __llvm_libc::coshf(float(FPBits(0x42d00008U))));
+  EXPECT_FP_EQ_WITH_EXCEPTION(
+      inf, __llvm_libc::coshf(float(FPBits(0x42d00008U))), FE_OVERFLOW);
   EXPECT_MATH_ERRNO(ERANGE);
 }
 
 TEST(LlvmLibcCoshfTest, InFloatRange) {
   constexpr uint32_t COUNT = 1000000;
   constexpr uint32_t STEP = UINT32_MAX / COUNT;
   for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
     float x = float(FPBits(v));

libc/test/src/math/exp10f_test.cpp

TEST(LlvmLibcExp10fTest, SpecialNumbers) {
 
   EXPECT_FP_EQ(1.0f, __llvm_libc::exp10f(0.0f));
   EXPECT_MATH_ERRNO(0);
 
   EXPECT_FP_EQ(1.0f, __llvm_libc::exp10f(-0.0f));
   EXPECT_MATH_ERRNO(0);
 }
 
 TEST(LlvmLibcExp10fTest, Overflow) {
   errno = 0;
-  EXPECT_FP_EQ(inf, __llvm_libc::exp10f(float(FPBits(0x7f7fffffU))));
+  EXPECT_FP_EQ_WITH_EXCEPTION(
+      inf, __llvm_libc::exp10f(float(FPBits(0x7f7fffffU))), FE_OVERFLOW);
   EXPECT_MATH_ERRNO(ERANGE);
 
-  EXPECT_FP_EQ(inf, __llvm_libc::exp10f(float(FPBits(0x43000000U))));
+  EXPECT_FP_EQ_WITH_EXCEPTION(
+      inf, __llvm_libc::exp10f(float(FPBits(0x43000000U))), FE_OVERFLOW);
   EXPECT_MATH_ERRNO(ERANGE);
 
-  EXPECT_FP_EQ(inf, __llvm_libc::exp10f(float(FPBits(0x43000001U))));
+  EXPECT_FP_EQ_WITH_EXCEPTION(
+      inf, __llvm_libc::exp10f(float(FPBits(0x43000001U))), FE_OVERFLOW);
   EXPECT_MATH_ERRNO(ERANGE);
 }
 
 TEST(LlvmLibcExp10fTest, TrickyInputs) {
   constexpr int N = 20;
   constexpr uint32_t INPUTS[N] = {
       0x325e5bd8, // x = 0x1.bcb7bp-27f
       0x325e5bd9, // x = 0x1.bcb7b2p-27f

libc/test/src/math/exp2f_test.cpp

TEST(LlvmLibcExp2fTest, SpecialNumbers) {
   EXPECT_MATH_ERRNO(0);
 
   EXPECT_FP_EQ(1.0f, __llvm_libc::exp2f(-0.0f));
   EXPECT_MATH_ERRNO(0);
 }
 
 TEST(LlvmLibcExp2fTest, Overflow) {
   errno = 0;
-  EXPECT_FP_EQ(inf, __llvm_libc::exp2f(float(FPBits(0x7f7fffffU))));
+  EXPECT_FP_EQ_WITH_EXCEPTION(
+      inf, __llvm_libc::exp2f(float(FPBits(0x7f7fffffU))), FE_OVERFLOW);
   EXPECT_MATH_ERRNO(ERANGE);
 
-  EXPECT_FP_EQ(inf, __llvm_libc::exp2f(float(FPBits(0x43000000U))));
+  EXPECT_FP_EQ_WITH_EXCEPTION(
+      inf, __llvm_libc::exp2f(float(FPBits(0x43000000U))), FE_OVERFLOW);
   EXPECT_MATH_ERRNO(ERANGE);
 
-  EXPECT_FP_EQ(inf, __llvm_libc::exp2f(float(FPBits(0x43000001U))));
+  EXPECT_FP_EQ_WITH_EXCEPTION(
+      inf, __llvm_libc::exp2f(float(FPBits(0x43000001U))), FE_OVERFLOW);
   EXPECT_MATH_ERRNO(ERANGE);
 }
 
 TEST(LlvmLibcExp2fTest, TrickyInputs) {
   constexpr int N = 12;
   constexpr uint32_t INPUTS[N] = {
       0x3b429d37U, /*0x1.853a6ep-9f*/
       0x3c02a9adU, /*0x1.05535ap-7f*/
for (int i = 0; i < N; ++i) {
     EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp2, x,
                                    __llvm_libc::exp2f(x), 0.5);
     EXPECT_MATH_ERRNO(0);
   }
 }
 
 TEST(LlvmLibcExp2fTest, Underflow) {
   errno = 0;
-  EXPECT_FP_EQ(0.0f, __llvm_libc::exp2f(float(FPBits(0xff7fffffU))));
+  EXPECT_FP_EQ_WITH_EXCEPTION(
+      0.0f, __llvm_libc::exp2f(float(FPBits(0xff7fffffU))), FE_UNDERFLOW);
   EXPECT_MATH_ERRNO(ERANGE);
 
   float x = float(FPBits(0xc3158000U));
   EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp2, x,
                                  __llvm_libc::exp2f(x), 0.5);
   EXPECT_MATH_ERRNO(0);
 
   x = float(FPBits(0xc3160000U));

libc/test/src/math/expf_test.cpp

TEST(LlvmLibcExpfTest, SpecialNumbers) {
   EXPECT_MATH_ERRNO(0);
 
   EXPECT_FP_EQ(1.0f, __llvm_libc::expf(-0.0f));
   EXPECT_MATH_ERRNO(0);
 }
 
 TEST(LlvmLibcExpfTest, Overflow) {
   errno = 0;
-  EXPECT_FP_EQ(inf, __llvm_libc::expf(float(FPBits(0x7f7fffffU))));
+  EXPECT_FP_EQ_WITH_EXCEPTION(
+      inf, __llvm_libc::expf(float(FPBits(0x7f7fffffU))), FE_OVERFLOW);
   EXPECT_MATH_ERRNO(ERANGE);
 
-  EXPECT_FP_EQ(inf, __llvm_libc::expf(float(FPBits(0x42cffff8U))));
+  EXPECT_FP_EQ_WITH_EXCEPTION(
+      inf, __llvm_libc::expf(float(FPBits(0x42cffff8U))), FE_OVERFLOW);
   EXPECT_MATH_ERRNO(ERANGE);
 
-  EXPECT_FP_EQ(inf, __llvm_libc::expf(float(FPBits(0x42d00008U))));
+  EXPECT_FP_EQ_WITH_EXCEPTION(
+      inf, __llvm_libc::expf(float(FPBits(0x42d00008U))), FE_OVERFLOW);
   EXPECT_MATH_ERRNO(ERANGE);
 }
 
 TEST(LlvmLibcExpfTest, Underflow) {
   errno = 0;
-  EXPECT_FP_EQ(0.0f, __llvm_libc::expf(float(FPBits(0xff7fffffU))));
+  EXPECT_FP_EQ_WITH_EXCEPTION(
+      0.0f, __llvm_libc::expf(float(FPBits(0xff7fffffU))), FE_UNDERFLOW);
   EXPECT_MATH_ERRNO(ERANGE);
 
   float x = float(FPBits(0xc2cffff8U));
   EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp, x, __llvm_libc::expf(x),
                                  0.5);
   EXPECT_MATH_ERRNO(ERANGE);
 
   x = float(FPBits(0xc2d00008U));

libc/test/src/math/expm1f_test.cpp

TEST(LlvmLibcExpm1fTest, SpecialNumbers) {
   EXPECT_MATH_ERRNO(0);
 
   EXPECT_FP_EQ(-0.0f, __llvm_libc::expm1f(-0.0f));
   EXPECT_MATH_ERRNO(0);
 }
 
 TEST(LlvmLibcExpm1fTest, Overflow) {
   errno = 0;
-  EXPECT_FP_EQ(inf, __llvm_libc::expm1f(float(FPBits(0x7f7fffffU))));
+  EXPECT_FP_EQ_WITH_EXCEPTION(
+      inf, __llvm_libc::expm1f(float(FPBits(0x7f7fffffU))), FE_OVERFLOW);
   EXPECT_MATH_ERRNO(ERANGE);
 
-  EXPECT_FP_EQ(inf, __llvm_libc::expm1f(float(FPBits(0x42cffff8U))));
+  EXPECT_FP_EQ_WITH_EXCEPTION(
+      inf, __llvm_libc::expm1f(float(FPBits(0x42cffff8U))), FE_OVERFLOW);
   EXPECT_MATH_ERRNO(ERANGE);
 
-  EXPECT_FP_EQ(inf, __llvm_libc::expm1f(float(FPBits(0x42d00008U))));
+  EXPECT_FP_EQ_WITH_EXCEPTION(
+      inf, __llvm_libc::expm1f(float(FPBits(0x42d00008U))), FE_OVERFLOW);
   EXPECT_MATH_ERRNO(ERANGE);
 }
 
 TEST(LlvmLibcExpm1fTest, Underflow) {
   errno = 0;
   EXPECT_FP_EQ(-1.0f, __llvm_libc::expm1f(float(FPBits(0xff7fffffU))));
 
   float x = float(FPBits(0xc2cffff8U));

libc/test/src/math/sinhf_test.cpp

TEST(LlvmLibcSinhfTest, SmallValues) {
   x = float(FPBits(uint32_t(0x00400000)));
   result = __llvm_libc::sinhf(x);
   EXPECT_MPFR_MATCH(mpfr::Operation::Sinh, x, result, 0.5);
   EXPECT_FP_EQ(x, result);
 }
 
 TEST(LlvmLibcSinhfTest, Overflow) {
   errno = 0;
-  EXPECT_FP_EQ(inf, __llvm_libc::sinhf(float(FPBits(0x7f7fffffU))));
+  EXPECT_FP_EQ_WITH_EXCEPTION(
+      inf, __llvm_libc::sinhf(float(FPBits(0x7f7fffffU))), FE_OVERFLOW);
   EXPECT_MATH_ERRNO(ERANGE);
 
-  EXPECT_FP_EQ(inf, __llvm_libc::sinhf(float(FPBits(0x42cffff8U))));
+  EXPECT_FP_EQ_WITH_EXCEPTION(
+      inf, __llvm_libc::sinhf(float(FPBits(0x42cffff8U))), FE_OVERFLOW);
   EXPECT_MATH_ERRNO(ERANGE);
 
-  EXPECT_FP_EQ(inf, __llvm_libc::sinhf(float(FPBits(0x42d00008U))));
+  EXPECT_FP_EQ_WITH_EXCEPTION(
+      inf, __llvm_libc::sinhf(float(FPBits(0x42d00008U))), FE_OVERFLOW);
   EXPECT_MATH_ERRNO(ERANGE);
 }
 
 TEST(LlvmLibcSinhfTest, ExceptionalValues) {
   float x = float(FPBits(uint32_t(0x3a12'85ffU)));
   EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Sinh, x,
                                  __llvm_libc::sinhf(x), 0.5);
 
   x = -float(FPBits(uint32_t(0x3a12'85ffU)));
   EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Sinh, x,
                                  __llvm_libc::sinhf(x), 0.5);
 }