Reapply "[libc][math] Refactor exp implementation to header-only in src/__support/math folder." (#148668)

This reverts commit f4630ba.

Author: bassiounix

libc/fuzzing/math/CMakeLists.txt

@@ -62,6 +62,42 @@ add_libc_fuzzer(
     libc.src.math.nextafterl
 )
 
+add_libc_fuzzer(
+  exp_fuzz
+  NEED_MPFR
+  SRCS
+    exp_fuzz.cpp
+  DEPENDS
+    libc.src.math.exp
+)
+
+add_libc_fuzzer(
+  exp10_fuzz
+  NEED_MPFR
+  SRCS
+    exp10_fuzz.cpp
+  DEPENDS
+    libc.src.math.exp10
+)
+
+add_libc_fuzzer(
+  exp2_fuzz
+  NEED_MPFR
+  SRCS
+    exp2_fuzz.cpp
+  DEPENDS
+    libc.src.math.exp2
+)
+
+add_libc_fuzzer(
+  expm1_fuzz
+  NEED_MPFR
+  SRCS
+    expm1_fuzz.cpp
+  DEPENDS
+    libc.src.math.expm1
+)
+
 add_libc_fuzzer(
   asin_fuzz
   NEED_MPFR

libc/fuzzing/math/exp10_fuzz.cpp

@@ -0,0 +1,38 @@
+//===-- exp10_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 exp10 implementation.
+///
+//===----------------------------------------------------------------------===//
+
+#include "src/math/exp10.h"
+#include "utils/MPFRWrapper/mpfr_inc.h"
+#include <math.h>
+
+extern "C" int LLVMFuzzerTestOneInput(double x) {
+  // remove NaN and inf
+  if (isnan(x) || isinf(x))
+    return 0;
+  // signed zeros already tested in unit tests
+  if (signbit(x) && x == 0.0)
+    return 0;
+  mpfr_t input;
+  mpfr_init2(input, 53);
+  mpfr_set_d(input, x, MPFR_RNDN);
+  int output = mpfr_exp10(input, input, MPFR_RNDN);
+  mpfr_subnormalize(input, output, MPFR_RNDN);
+  double to_compare = mpfr_get_d(input, MPFR_RNDN);
+
+  double result = LIBC_NAMESPACE::exp10(x);
+
+  if (result != to_compare)
+    __builtin_trap();
+
+  mpfr_clear(input);
+  return 0;
+}

libc/fuzzing/math/exp2_fuzz.cpp

@@ -0,0 +1,38 @@
+//===-- exp2_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 exp2 implementation.
+///
+//===----------------------------------------------------------------------===//
+
+#include "src/math/exp2.h"
+#include "utils/MPFRWrapper/mpfr_inc.h"
+#include <math.h>
+
+extern "C" int LLVMFuzzerTestOneInput(double x) {
+  // remove NaN and inf
+  if (isnan(x) || isinf(x))
+    return 0;
+  // signed zeros already tested in unit tests
+  if (signbit(x) && x == 0.0)
+    return 0;
+  mpfr_t input;
+  mpfr_init2(input, 53);
+  mpfr_set_d(input, x, MPFR_RNDN);
+  int output = mpfr_exp2(input, input, MPFR_RNDN);
+  mpfr_subnormalize(input, output, MPFR_RNDN);
+  double to_compare = mpfr_get_d(input, MPFR_RNDN);
+
+  double result = LIBC_NAMESPACE::exp2(x);
+
+  if (result != to_compare)
+    __builtin_trap();
+
+  mpfr_clear(input);
+  return 0;
+}

libc/fuzzing/math/exp_fuzz.cpp

@@ -0,0 +1,38 @@
+//===-- exp_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 exp implementation.
+///
+//===----------------------------------------------------------------------===//
+
+#include "src/math/exp.h"
+#include "utils/MPFRWrapper/mpfr_inc.h"
+#include <math.h>
+
+extern "C" int LLVMFuzzerTestOneInput(double x) {
+  // remove NaN and inf
+  if (isnan(x) || isinf(x))
+    return 0;
+  // signed zeros already tested in unit tests
+  if (signbit(x) && x == 0.0)
+    return 0;
+  mpfr_t input;
+  mpfr_init2(input, 53);
+  mpfr_set_d(input, x, MPFR_RNDN);
+  int output = mpfr_exp(input, input, MPFR_RNDN);
+  mpfr_subnormalize(input, output, MPFR_RNDN);
+  double to_compare = mpfr_get_d(input, MPFR_RNDN);
+
+  double result = LIBC_NAMESPACE::exp(x);
+
+  if (result != to_compare)
+    __builtin_trap();
+
+  mpfr_clear(input);
+  return 0;
+}

libc/fuzzing/math/expm1_fuzz.cpp

@@ -0,0 +1,38 @@
+//===-- expm1_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 expm1 implementation.
+///
+//===----------------------------------------------------------------------===//
+
+#include "src/math/expm1.h"
+#include "utils/MPFRWrapper/mpfr_inc.h"
+#include <math.h>
+
+extern "C" int LLVMFuzzerTestOneInput(double x) {
+  // remove NaN and inf
+  if (isnan(x) || isinf(x))
+    return 0;
+  // signed zeros already tested in unit tests
+  if (signbit(x) && x == 0.0)
+    return 0;
+  mpfr_t input;
+  mpfr_init2(input, 53);
+  mpfr_set_d(input, x, MPFR_RNDN);
+  int output = mpfr_expm1(input, input, MPFR_RNDN);
+  mpfr_subnormalize(input, output, MPFR_RNDN);
+  double to_compare = mpfr_get_d(input, MPFR_RNDN);
+
+  double result = LIBC_NAMESPACE::expm1(x);
+
+  if (result != to_compare)
+    __builtin_trap();
+
+  mpfr_clear(input);
+  return 0;
+}

libc/shared/math.h

@@ -11,6 +11,7 @@
 
 #include "libc_common.h"
 
+#include "math/exp.h"
 #include "math/expf.h"
 #include "math/expf16.h"
 #include "math/frexpf.h"
@@ -19,6 +20,5 @@
 #include "math/ldexpf.h"
 #include "math/ldexpf128.h"
 #include "math/ldexpf16.h"
-#include "math/exp.h"
 
 #endif // LLVM_LIBC_SHARED_MATH_H

libc/src/__support/math/exp.h

@@ -27,7 +27,6 @@
 #include "src/__support/macros/config.h"
 #include "src/__support/macros/optimization.h" // LIBC_UNLIKELY
 
-
 namespace LIBC_NAMESPACE_DECL {
 
 using fputil::DoubleDouble;
@@ -68,7 +67,7 @@ namespace {
 // Return expm1(dx) / x ~ 1 + dx / 2 + dx^2 / 6 + dx^3 / 24.
 // For |dx| < 2^-13 + 2^-30:
 //   | output - expm1(dx) / dx | < 2^-51.
-static constexpr double poly_approx_d(double dx) {
+static double poly_approx_d(double dx) {
   // dx^2
   double dx2 = dx * dx;
   // c0 = 1 + dx / 2
@@ -86,7 +85,7 @@ static constexpr double poly_approx_d(double dx) {
 // Return exp(dx) ~ 1 + dx + dx^2 / 2 + ... + dx^6 / 720
 // For |dx| < 2^-13 + 2^-30:
 //   | output - exp(dx) | < 2^-101
-static constexpr DoubleDouble poly_approx_dd(const DoubleDouble &dx) {
+static DoubleDouble poly_approx_dd(const DoubleDouble &dx) {
   // Taylor polynomial.
   constexpr DoubleDouble COEFFS[] = {
       {0, 0x1p0},                                      // 1
@@ -107,7 +106,7 @@ static constexpr DoubleDouble poly_approx_dd(const DoubleDouble &dx) {
 // Return exp(dx) ~ 1 + dx + dx^2 / 2 + ... + dx^7 / 5040
 // For |dx| < 2^-13 + 2^-30:
 //   | output - exp(dx) | < 2^-126.
-static constexpr Float128 poly_approx_f128(const Float128 &dx) {
+static Float128 poly_approx_f128(const Float128 &dx) {
   constexpr Float128 COEFFS_128[]{
       {Sign::POS, -127, 0x80000000'00000000'00000000'00000000_u128}, // 1.0
       {Sign::POS, -127, 0x80000000'00000000'00000000'00000000_u128}, // 1.0
@@ -128,7 +127,7 @@ static constexpr Float128 poly_approx_f128(const Float128 &dx) {
 // Compute exp(x) using 128-bit precision.
 // TODO(lntue): investigate triple-double precision implementation for this
 // step.
-static constexpr Float128 exp_f128(double x, double kd, int idx1, int idx2) {
+static Float128 exp_f128(double x, double kd, int idx1, int idx2) {
   // Recalculate dx:
 
   double t1 = fputil::multiply_add(kd, MLOG_2_EXP2_M12_HI, x); // exact
@@ -161,8 +160,8 @@ static constexpr Float128 exp_f128(double x, double kd, int idx1, int idx2) {
 }
 
 // Compute exp(x) with double-double precision.
-static constexpr DoubleDouble exp_double_double(double x, double kd,
-                               const DoubleDouble &exp_mid) {
+static DoubleDouble exp_double_double(double x, double kd,
+                                                const DoubleDouble &exp_mid) {
   // Recalculate dx:
   //   dx = x - k * 2^-12 * log(2)
   double t1 = fputil::multiply_add(kd, MLOG_2_EXP2_M12_HI, x); // exact
@@ -185,7 +184,7 @@ static constexpr DoubleDouble exp_double_double(double x, double kd,
 
 // Check for exceptional cases when
 // |x| <= 2^-53 or x < log(2^-1075) or x >= 0x1.6232bdd7abcd3p+9
-static constexpr double set_exceptional(double x) {
+static double set_exceptional(double x) {
   using FPBits = typename fputil::FPBits<double>;
   FPBits xbits(x);
 
@@ -235,7 +234,7 @@ static constexpr double set_exceptional(double x) {
 
 namespace math {
 
-static constexpr double exp(double x) {
+static double exp(double x) {
   using FPBits = typename fputil::FPBits<double>;
   FPBits xbits(x);
 

libc/src/__support/math/exp_utils.h

@@ -9,11 +9,10 @@
 #ifndef LLVM_LIBC_SRC___SUPPORT_MATH_EXP_UTILS_H
 #define LLVM_LIBC_SRC___SUPPORT_MATH_EXP_UTILS_H
 
-#include "src/__support/CPP/optional.h"
 #include "src/__support/CPP/bit.h"
+#include "src/__support/CPP/optional.h"
 #include "src/__support/FPUtil/FPBits.h"
 
-
 namespace LIBC_NAMESPACE_DECL {
 
 // Rounding tests for 2^hi * (mid + lo) when the output might be denormal. We
@@ -23,8 +22,8 @@ namespace LIBC_NAMESPACE_DECL {
 // So if we scale x up by 2^1022, we can use
 //   double(1.0 + 2^1022 * x) - 1.0 to test how x is rounded in denormal range.
 template <bool SKIP_ZIV_TEST = false>
-static constexpr cpp::optional<double>
-ziv_test_denorm(int hi, double mid, double lo, double err) {
+static constexpr cpp::optional<double> ziv_test_denorm(int hi, double mid,
+                                                       double lo, double err) {
   using FPBits = typename fputil::FPBits<double>;
 
   // Scaling factor = 1/(min normal number) = 2^1022

libc/src/math/generic/common_constants.h

@@ -11,9 +11,8 @@
 
 #include "src/__support/FPUtil/triple_double.h"
 #include "src/__support/macros/config.h"
-#include "src/__support/number_pair.h"
 #include "src/__support/math/exp_constants.h"
-
+#include "src/__support/number_pair.h"
 
 namespace LIBC_NAMESPACE_DECL {
 

libc/src/math/generic/exp.cpp

@@ -10,8 +10,6 @@
 #include "src/__support/math/exp.h"
 namespace LIBC_NAMESPACE_DECL {
 
-LLVM_LIBC_FUNCTION(double, exp, (double x)) {
-  return math::exp(x);
-}
+LLVM_LIBC_FUNCTION(double, exp, (double x)) { return math::exp(x); }
 
 } // namespace LIBC_NAMESPACE_DECL