[libc][math] Implement asinhf function correctly rounded for all rounding modes.

[lntue]

Summary

Implement asinhf function correctly rounded for all rounding modes.

[zimmermann6]

I confirm all exhaustive tests do pass, and the timings are similar to CORE-MATH:

zimmerma@biscotte:~/svn/core-math$ LIBM=/localdisk/zimmerma/llvm-project/build/projects/libc/lib/libllvmlibc.a ./perf.sh asinhf
GNU libc version: 2.36
GNU libc release: stable
[####################] 100 %
Ntrial = 20 ; Min = 24.687 + 0.365 clc/call; Median-Min = 0.296 clc/call; Max = 26.051 clc/call;
[####################] 100 %
Ntrial = 20 ; Min = 37.687 + 0.295 clc/call; Median-Min = 0.287 clc/call; Max = 39.359 clc/call;
[####################] 100 %
Ntrial = 20 ; Min = 25.939 + 0.320 clc/call; Median-Min = 0.292 clc/call; Max = 26.596 clc/call;

libc/config/darwin/arm/entrypoints.txt

set(TARGET_LIBM_ENTRYPOINTS
     libc.src.fenv.fesetround
     libc.src.fenv.feraiseexcept
     libc.src.fenv.fetestexcept
     libc.src.fenv.feupdateenv
 
     # math.h entrypoints
     libc.src.math.acosf
     libc.src.math.asinf
+    libc.src.math.asinhf
     libc.src.math.atanf
     libc.src.math.atanhf
     libc.src.math.copysign
     libc.src.math.copysignf
     libc.src.math.copysignl
     libc.src.math.ceil
     libc.src.math.ceilf
     libc.src.math.ceill

libc/config/linux/aarch64/entrypoints.txt

set(TARGET_LIBM_ENTRYPOINTS
     libc.src.fenv.feraiseexcept
     libc.src.fenv.fetestexcept
     libc.src.fenv.feupdateenv
 
     # math.h entrypoints
     libc.src.math.acosf
     libc.src.math.asin
     libc.src.math.asinf
+    libc.src.math.asinhf
     libc.src.math.atanf
     libc.src.math.atanhf    
     libc.src.math.copysign
     libc.src.math.copysignf
     libc.src.math.copysignl
     libc.src.math.ceil
     libc.src.math.ceilf
     libc.src.math.ceill

libc/config/linux/x86_64/entrypoints.txt

set(TARGET_LIBM_ENTRYPOINTS
     libc.src.fenv.feraiseexcept
     libc.src.fenv.fetestexcept
     libc.src.fenv.feupdateenv
 
     # math.h entrypoints
     libc.src.math.acosf
     libc.src.math.asin
     libc.src.math.asinf
+    libc.src.math.asinhf
     libc.src.math.atanf
     libc.src.math.atanhf
     libc.src.math.copysign
     libc.src.math.copysignf
     libc.src.math.copysignl
     libc.src.math.ceil
     libc.src.math.ceilf
     libc.src.math.ceill

libc/config/windows/entrypoints.txt

set(TARGET_LIBM_ENTRYPOINTS
     libc.src.fenv.feraiseexcept
     libc.src.fenv.fetestexcept
     libc.src.fenv.feupdateenv
 
     # math.h entrypoints
     libc.src.math.acosf
     libc.src.math.asin
     libc.src.math.asinf
+    libc.src.math.asinhf
     libc.src.math.atanf    
     libc.src.math.atanhf
     libc.src.math.copysign
     libc.src.math.copysignf
     libc.src.math.copysignl
     libc.src.math.ceil
     libc.src.math.ceilf
     libc.src.math.ceill

libc/docs/math.rst

 ---------------------
 
 ============== ================ =============== ======================
 <Func>         <Func_f> (float) <Func> (double) <Func_l> (long double)
 ============== ================ =============== ======================
 acos           :green:`XA`
 acosh
 asin           :green:`XA`
-asinh
+asinh          :green:`XA`
 atan           :green:`XA`
 atan2
 atanh          :green:`XA`
 cbrt
 cos            :green:`XA`      :green:`XA`
 cosh           :green:`XA`
 erf
 erfc

 Accuracy of Higher Math Functions
 =================================
 
 ============== ================ =============== ======================
 <Func>         <Func_f> (float) <Func> (double) <Func_l> (long double)
 ============== ================ =============== ======================
 acos           :green:`XA`
 asin           :green:`XA`
+asinh          :green:`XA`
 atan           :green:`XA`
 atanh          :green:`XA`
 cos            :green:`XA`      large
 cosh           :green:`XA`
 exp            :green:`XA`
 exp10          :green:`XA`
 exp2           :green:`XA`
 expm1          :green:`XA`

libc/spec/stdc.td

HeaderSpec Math = HeaderSpec<
           FunctionSpec<"sinhf", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
           FunctionSpec<"tanhf", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
 
           FunctionSpec<"acosf", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
           FunctionSpec<"asinf", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
           FunctionSpec<"asin", RetValSpec<DoubleType>, [ArgSpec<DoubleType>]>,
           FunctionSpec<"atanf", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
 
+          FunctionSpec<"asinhf", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
           FunctionSpec<"atanhf", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
       ]
   >;
 
   HeaderSpec StdIO = HeaderSpec<
       "stdio.h",
       [
           Macro<"stdin">,

libc/src/math/CMakeLists.txt

add_entrypoint_object(
   COMPILE_OPTIONS
     -O3
 )
 
 add_math_entrypoint_object(acosf)
 
 add_math_entrypoint_object(asin)
 add_math_entrypoint_object(asinf)
+add_math_entrypoint_object(asinhf)
 
 add_math_entrypoint_object(atanf)
 
 add_math_entrypoint_object(atanhf)
 
 add_math_entrypoint_object(ceil)
 add_math_entrypoint_object(ceilf)
 add_math_entrypoint_object(ceill)

libc/src/math/asinhf.h

+//===-- Implementation header for asinhf ------------------------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIBC_SRC_MATH_ASINHF_H
+#define LLVM_LIBC_SRC_MATH_ASINHF_H
+
+namespace __llvm_libc {
+
+float asinhf(float x);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_MATH_ASINHF_H

libc/src/math/generic/CMakeLists.txt

add_entrypoint_object(
   DEPENDS
     .explogxf
     libc.src.__support.FPUtil.fp_bits
   COMPILE_OPTIONS
     -O3
 )
 
 add_entrypoint_object(
+  asinhf
+  SRCS
+    asinhf.cpp
+  HDRS
+    ../asinhf.h
+  DEPENDS
+    .explogxf
+    libc.src.__support.FPUtil.fp_bits
+    libc.src.__support.FPUtil.multiply_add
+    libc.src.__support.FPUtil.polyeval
+    libc.src.__support.FPUtil.sqrt
+  COMPILE_OPTIONS
+    -O3
+)
+
+add_entrypoint_object(
   atanhf
   SRCS
     atanhf.cpp
   HDRS
     ../atanhf.h
   DEPENDS
     .explogxf
     libc.src.__support.FPUtil.fp_bits

libc/src/math/generic/asinhf.cpp

+//===-- Single-precision asinh function -----------------------------------===//
+//
+// 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 "src/math/asinhf.h"
+#include "src/__support/FPUtil/FPBits.h"
+#include "src/__support/FPUtil/PolyEval.h"
+#include "src/__support/FPUtil/multiply_add.h"
+#include "src/__support/FPUtil/sqrt.h"
+#include "src/math/generic/common_constants.h"
+#include "src/math/generic/explogxf.h"
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(float, asinhf, (float x)) {
+  using FPBits_t = typename fputil::FPBits<float>;
+  FPBits_t xbits(x);
+  uint32_t x_u = xbits.uintval();
+  uint32_t x_abs = x_u & FPBits_t::FloatProp::EXP_MANT_MASK;
+
+  // |x| <= 2^-3
+  if (unlikely(x_abs <= 0x3e80'0000U)) {
+    // |x| <= 2^-26
+    if (unlikely(x_abs <= 0x3280'0000U)) {
+      return unlikely(x_abs == 0) ? x : (x - 0x1.5555555555555p-3 * x * x * x);
+    }
+
+    double x_d = x;
+    double x_sq = x_d * x_d;
+    // Generated by Sollya with:
+    // > P = fpminimax(asinh(x)/x, [|0, 2, 4, 6, 8, 10, 12, 14, 16], [|D...|],
+    //                 [0, 2^-2]);
+    double p = fputil::polyeval(
+        x_sq, 0.0, -0x1.555555555551ep-3, 0x1.3333333325495p-4,
+        -0x1.6db6db5a7622bp-5, 0x1.f1c70f82928c6p-6, -0x1.6e893934266b7p-6,
+        0x1.1c0b41d3fbe78p-6, -0x1.c0f47810b3c4fp-7, 0x1.2c8602690143dp-7);
+    return fputil::multiply_add(x_d, p, x_d);
+  }
+
+  const double SIGN[2] = {1.0, -1.0};
+  double x_sign = SIGN[x_u >> 31];
+  double x_d = x;
+
+  // Helper functions to set results for exceptional cases.
+  auto round_result_slightly_down = [x_sign](float r) -> float {
+    return fputil::multiply_add(static_cast<float>(x_sign), r,
+                                static_cast<float>(x_sign) * (-0x1.0p-24f));
+  };
+  auto round_result_slightly_up = [x_sign](float r) -> float {
+    return fputil::multiply_add(static_cast<float>(x_sign), r,
+                                static_cast<float>(x_sign) * 0x1.0p-24f);
+  };
+
+  if (unlikely(x_abs >= 0x4bdd'65a5U)) {
+    if (unlikely(x_abs >= 0x7f80'0000U)) {
+      // x is +-inf or nan
+      return x;
+    }
+
+    // Exceptional cases when x > 2^24.
+    switch (x_abs) {
+    case 0x4bdd65a5: // |x| = 0x1.bacb4ap24f
+      return round_result_slightly_down(0x1.1e0696p4f);
+    case 0x4c803f2c: // |x| = 0x1.007e58p26f
+      return round_result_slightly_down(0x1.2b786cp4f);
+    case 0x4f8ffb03: // |x| = 0x1.1ff606p32f
+      return round_result_slightly_up(0x1.6fdd34p4f);
+    case 0x5c569e88: // |x| = 0x1.ad3d1p57f
+      return round_result_slightly_up(0x1.45c146p5f);
+    case 0x5e68984e: // |x| = 0x1.d1309cp61f
+      return round_result_slightly_up(0x1.5c9442p5f);
+    case 0x655890d3: // |x| = 0x1.b121a6p75f
+      return round_result_slightly_down(0x1.a9a3f2p5f);
+    case 0x65de7ca6: // |x| = 0x1.bcf94cp76f
+      return round_result_slightly_up(0x1.af66cp5f);
+    case 0x6eb1a8ec: // |x| = 0x1.6351d8p94f
+      return round_result_slightly_down(0x1.08b512p6f);
+    case 0x7997f30a: // |x| = 0x1.2fe614p116f
+      return round_result_slightly_up(0x1.451436p6f);
+    }
+  } else {
+    // Exceptional cases when x < 2^24.
+    if (unlikely(x_abs == 0x45abaf26)) {
+      // |x| = 0x1.575e4cp12f
+      return round_result_slightly_down(0x1.29becap3f);
+    }
+    if (unlikely(x_abs == 0x49d29048)) {
+      // |x| = 0x1.a5209p20f
+      return round_result_slightly_down(0x1.e1b92p3f);
+    }
+  }
+
+  // asinh(x) = log(x + sqrt(x^2 + 1))
+  return x_sign *
+         log_eval(fputil::multiply_add(
+             x_d, x_sign, fputil::sqrt(fputil::multiply_add(x_d, x_d, 1.0))));
+}
+
+} // namespace __llvm_libc

libc/src/math/generic/explogxf.h

 //===-- Single-precision general exp/log functions ------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_MATH_GENERIC_EXPLOGXF_H
 #define LLVM_LIBC_SRC_MATH_GENERIC_EXPLOGXF_H
 
+#include "common_constants.h"
 #include "math_utils.h"
 #include "src/__support/FPUtil/FEnvImpl.h"
 #include "src/__support/FPUtil/FPBits.h"
 #include "src/__support/FPUtil/PolyEval.h"
 #include "src/__support/FPUtil/nearest_integer.h"
 #include "src/__support/common.h"
 #include <src/__support/FPUtil/NearestIntegerOperations.h>
 
LIBC_INLINE static double log2_eval(double x) {
   // c0 = dx * (1.0 / ln(2)) + LOG_P1_LOG2[p1]
   double c0 = fputil::multiply_add(dx, 0x1.71547652b82fep+0, LOG_P1_LOG2[p1]);
   result += __llvm_libc::fputil::polyeval(dx * dx, c0, c1, c2, c3, c4);
   return result;
 }
 
 // x should be positive, normal finite value
 LIBC_INLINE static double log_eval(double x) {
-  // ln(x) = log[2,x] * ln(2)
-  return log2_eval(x) * 0x1.62e42fefa39efp-1;
+  // For x = 2^ex * (1 + mx)
+  //   log(x) = ex * log(2) + log(1 + mx)
+  using FPB = fputil::FPBits<double>;
+  FPB bs(x);
+
+  double ex = static_cast<double>(bs.get_exponent());
+
+  // p1 is the leading 7 bits of mx, i.e.
+  // p1 * 2^(-7) <= m_x < (p1 + 1) * 2^(-7).
+  int p1 = (bs.get_mantissa() >> (FPB::FloatProp::MANTISSA_WIDTH - 7));
+
+  // Set bs to (1 + (mx - p1*2^(-7))
+  bs.bits &= FPB::FloatProp::MANTISSA_MASK >> 7;
+  bs.set_unbiased_exponent(FPB::FloatProp::EXPONENT_BIAS);
+  // dx = (mx - p1*2^(-7)) / (1 + p1*2^(-7)).
+  double dx = (bs.get_val() - 1.0) * ONE_OVER_F[p1];
+
+  // Minimax polynomial of log(1 + dx) generated by Sollya with:
+  // > P = fpminimax(log(1 + x)/x, 6, [|D...|], [0, 2^-7]);
+  const double COEFFS[6] = {-0x1.ffffffffffffcp-2, 0x1.5555555552ddep-2,
+                            -0x1.ffffffefe562dp-3, 0x1.9999817d3a50fp-3,
+                            -0x1.554317b3f67a5p-3, 0x1.1dc5c45e09c18p-3};
+  double dx2 = dx * dx;
+  double c1 = fputil::multiply_add(dx, COEFFS[1], COEFFS[0]);
+  double c2 = fputil::multiply_add(dx, COEFFS[3], COEFFS[2]);
+  double c3 = fputil::multiply_add(dx, COEFFS[5], COEFFS[4]);
+
+  double p = fputil::polyeval(dx2, dx, c1, c2, c3);
+  double result =
+      fputil::multiply_add(ex, /*log(2)*/ 0x1.62e42fefa39efp-1, LOG_F[p1] + p);
+  return result;
 }
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_MATH_GENERIC_EXPLOGXF_H

libc/test/src/math/CMakeLists.txt

add_fp_unittest(
   DEPENDS
     libc.include.errno
     libc.src.errno.errno
     libc.src.math.atanhf
     libc.src.__support.FPUtil.fp_bits
 )
 
 add_fp_unittest(
+  asinhf_test
+  NEED_MPFR
+  SUITE
+    libc_math_unittests
+  SRCS
+    asinhf_test.cpp
+  DEPENDS
+    libc.include.errno
+    libc.src.errno.errno
+    libc.src.math.asinhf
+    libc.src.__support.FPUtil.fp_bits
+)
+
+add_fp_unittest(
   asinf_test
   NEED_MPFR
   SUITE
     libc_math_unittests
   SRCS
     asinf_test.cpp
   DEPENDS
     libc.include.errno

libc/test/src/math/asinhf_test.cpp

+//===-- Unittests for asinhf ----------------------------------------------===//
+//
+// 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 "src/__support/FPUtil/FPBits.h"
+#include "src/math/asinhf.h"
+#include "utils/MPFRWrapper/MPFRUtils.h"
+#include "utils/UnitTest/FPMatcher.h"
+#include "utils/UnitTest/Test.h"
+#include <math.h>
+
+#include <errno.h>
+#include <stdint.h>
+
+using FPBits_t = __llvm_libc::fputil::FPBits<float>;
+
+namespace mpfr = __llvm_libc::testing::mpfr;
+
+DECLARE_SPECIAL_CONSTANTS(float)
+
+TEST(LlvmLibcAsinhfTest, SpecialNumbers) {
+  errno = 0;
+
+  EXPECT_FP_EQ(aNaN, __llvm_libc::asinhf(aNaN));
+  EXPECT_MATH_ERRNO(0);
+
+  EXPECT_FP_EQ(0.0f, __llvm_libc::asinhf(0.0f));
+  EXPECT_MATH_ERRNO(0);
+
+  EXPECT_FP_EQ(-0.0f, __llvm_libc::asinhf(-0.0f));
+  EXPECT_MATH_ERRNO(0);
+
+  EXPECT_FP_EQ(inf, __llvm_libc::asinhf(inf));
+  EXPECT_MATH_ERRNO(0);
+
+  EXPECT_FP_EQ(neg_inf, __llvm_libc::asinhf(neg_inf));
+  EXPECT_MATH_ERRNO(0);
+}
+
+TEST(LlvmLibcAsinhfTest, 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_t(v));
+    if (isnan(x) || isinf(x))
+      continue;
+    ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Asinh, x,
+                                   __llvm_libc::asinhf(x), 0.5);
+    ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Asinh, -x,
+                                   __llvm_libc::asinhf(-x), 0.5);
+  }
+}
+
+TEST(LlvmLibcAsinhfTest, SpecificBitPatterns) {
+  constexpr int N = 11;
+  constexpr uint32_t INPUTS[N] = {
+      0x45abaf26, // |x| = 0x1.575e4cp12f
+      0x49d29048, // |x| = 0x1.a5209p20f
+      0x4bdd65a5, // |x| = 0x1.bacb4ap24f
+      0x4c803f2c, // |x| = 0x1.007e58p26f
+      0x4f8ffb03, // |x| = 0x1.1ff606p32f
+      0x5c569e88, // |x| = 0x1.ad3d1p57f
+      0x5e68984e, // |x| = 0x1.d1309cp61f
+      0x655890d3, // |x| = 0x1.b121a6p75f
+      0x65de7ca6, // |x| = 0x1.bcf94cp76f
+      0x6eb1a8ec, // |x| = 0x1.6351d8p94f
+      0x7997f30a, // |x| = 0x1.2fe614p116f
+  };
+
+  for (int i = 0; i < N; ++i) {
+    float x = float(FPBits_t(INPUTS[i]));
+    EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Asinh, x,
+                                   __llvm_libc::asinhf(x), 0.5);
+    EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Asinh, -x,
+                                   __llvm_libc::asinhf(-x), 0.5);
+  }
+}

libc/test/src/math/exhaustive/CMakeLists.txt

DEPENDS
     libc.include.math
     libc.src.math.tanhf
     libc.src.__support.FPUtil.fp_bits
   LINK_LIBRARIES
     -lpthread
 )
 
 add_fp_unittest(
+  asinhf_test
+  NO_RUN_POSTBUILD
+  NEED_MPFR
+  SUITE
+    libc_math_exhaustive_tests
+  SRCS
+    asinhf_test.cpp
+  DEPENDS
+    .exhaustive_test
+    libc.include.math
+    libc.src.math.asinhf
+    libc.src.__support.FPUtil.fp_bits
+  LINK_LIBRARIES
+    -lpthread
+)
+
+add_fp_unittest(
   atanhf_test
   NO_RUN_POSTBUILD
   NEED_MPFR
   SUITE
     libc_math_exhaustive_tests
   SRCS
     atanhf_test.cpp
   DEPENDS

libc/test/src/math/exhaustive/asinhf_test.cpp

+//===-- Exhaustive test for asinhf ----------------------------------------===//
+//
+// 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 "exhaustive_test.h"
+#include "src/__support/FPUtil/FPBits.h"
+#include "src/math/asinhf.h"
+#include "utils/MPFRWrapper/MPFRUtils.h"
+
+#include <thread>
+
+using FPBits = __llvm_libc::fputil::FPBits<float>;
+
+namespace mpfr = __llvm_libc::testing::mpfr;
+
+struct LlvmLibcAsinhfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
+  bool check(uint32_t start, uint32_t stop,
+             mpfr::RoundingMode rounding) override {
+    mpfr::ForceRoundingMode r(rounding);
+    uint32_t bits = start;
+    bool result = true;
+    do {
+      FPBits xbits(bits);
+      float x = float(xbits);
+      result &= EXPECT_MPFR_MATCH(mpfr::Operation::Asinh, x,
+                                  __llvm_libc::asinhf(x), 0.5, rounding);
+    } while (bits++ < stop);
+    return result;
+  }
+};
+
+static const int NUM_THREADS = std::thread::hardware_concurrency();
+
+// Range: [0, Inf];
+static const uint32_t POS_START = 0x0000'0000U;
+static const uint32_t POS_STOP = 0x7f80'0000U;
+
+TEST_F(LlvmLibcAsinhfExhaustiveTest, PostiveRangeRoundNearestTieToEven) {
+  test_full_range(POS_START, POS_STOP, mpfr::RoundingMode::Nearest);
+}
+
+TEST_F(LlvmLibcAsinhfExhaustiveTest, PostiveRangeRoundUp) {
+  test_full_range(POS_START, POS_STOP, mpfr::RoundingMode::Upward);
+}
+
+TEST_F(LlvmLibcAsinhfExhaustiveTest, PostiveRangeRoundDown) {
+  test_full_range(POS_START, POS_STOP, mpfr::RoundingMode::Downward);
+}
+
+TEST_F(LlvmLibcAsinhfExhaustiveTest, PostiveRangeRoundTowardZero) {
+  test_full_range(POS_START, POS_STOP, mpfr::RoundingMode::TowardZero);
+}
+
+// Range: [-1.0, 0];
+static const uint32_t NEG_START = 0x8000'0000U;
+static const uint32_t NEG_STOP = 0xff80'0000U;
+
+TEST_F(LlvmLibcAsinhfExhaustiveTest, NegativeRangeRoundNearestTieToEven) {
+  test_full_range(NEG_START, NEG_STOP, mpfr::RoundingMode::Nearest);
+}
+
+TEST_F(LlvmLibcAsinhfExhaustiveTest, NegativeRangeRoundUp) {
+  test_full_range(NEG_START, NEG_STOP, mpfr::RoundingMode::Upward);
+}
+
+TEST_F(LlvmLibcAsinhfExhaustiveTest, NegativeRangeRoundDown) {
+  test_full_range(NEG_START, NEG_STOP, mpfr::RoundingMode::Downward);
+}
+
+TEST_F(LlvmLibcAsinhfExhaustiveTest, NegativeRangeRoundTowardZero) {
+  test_full_range(NEG_START, NEG_STOP, mpfr::RoundingMode::TowardZero);
+}

libc/test/src/math/exhaustive/exhaustive_test.cpp

thread_list.emplace_back([&, this]() {
         {
           std::lock_guard<std::mutex> lock(mx_cur_val);
           if (current_value == stop)
             return;
 
           range_begin = current_value;
           if (stop >= increment && stop - increment >= current_value) {
             range_end = current_value + increment;
-          } else
+          } else {
             range_end = stop;
+          }
           current_value = range_end;
-          int pc = 100.0 * double(range_end - start) / double(stop - start);
+          int pc = 100.0 * (range_end - start) / (stop - start);
           if (current_percent != pc) {
             new_percent = pc;
             current_percent = pc;
           }
         }
         if (new_percent >= 0) {
           std::stringstream msg;
           msg << new_percent << "% is in process     \r";
           std::cout << msg.str() << std::flush;
-          ;
         }
 
         bool check_passed = check(range_begin, range_end, rounding);
         if (!check_passed) {
           std::stringstream msg;
           msg << "Test failed in range: " << std::dec << range_begin << " to "
               << range_end << " [0x" << std::hex << range_begin << ", 0x"
               << range_end << "), [" << std::hexfloat
void LlvmLibcExhaustiveTest<T, FloatType>::test_full_range(
 
   for (auto &thread : thread_list) {
     if (thread.joinable()) {
       thread.join();
     }
   }
   std::cout << std::endl;
   std::cout << "Test " << ((failed > 0) ? "FAILED" : "PASSED") << std::endl;
+  ASSERT_EQ(failed.load(), uint64_t(0));
 }
 
 template void
     LlvmLibcExhaustiveTest<uint32_t>::test_full_range(uint32_t, uint32_t,
                                                       mpfr::RoundingMode);
 template void LlvmLibcExhaustiveTest<uint64_t, double>::test_full_range(
     uint64_t, uint64_t, mpfr::RoundingMode);

libc/utils/MPFRWrapper/MPFRUtils.h

 enum class Operation : int {
   // Operations with take a single floating point number as input
   // and produce a single floating point number as output. The input
   // and output floating point numbers are of the same kind.
   BeginUnaryOperationsSingleOutput,
   Abs,
   Acos,
   Asin,
+  Asinh,
   Atan,
   Atanh,
   Ceil,
   Cos,
   Cosh,
   Exp,
   Exp2,
   Exp10,

libc/utils/MPFRWrapper/MPFRUtils.cpp

public:
   }
 
   MPFRNumber asin() const {
     MPFRNumber result(*this);
     mpfr_asin(result.value, value, mpfr_rounding);
     return result;
   }
 
+  MPFRNumber asinh() const {
+    MPFRNumber result(*this);
+    mpfr_asinh(result.value, value, mpfr_rounding);
+    return result;
+  }
   MPFRNumber atan() const {
     MPFRNumber result(*this);
     mpfr_atan(result.value, value, mpfr_rounding);
     return result;
   }
 
   MPFRNumber atanh() const {
     MPFRNumber result(*this);
unary_operation(Operation op, InputType input, unsigned int precision,
   MPFRNumber mpfrInput(input, precision, rounding);
   switch (op) {
   case Operation::Abs:
     return mpfrInput.abs();
   case Operation::Acos:
     return mpfrInput.acos();
   case Operation::Asin:
     return mpfrInput.asin();
+  case Operation::Asinh:
+    return mpfrInput.asinh();
   case Operation::Atan:
     return mpfrInput.atan();
   case Operation::Atanh:
     return mpfrInput.atanh();
   case Operation::Ceil:
     return mpfrInput.ceil();
   case Operation::Cos:
     return mpfrInput.cos();