[libc][math] Added coshf function.

[orex]

Summary

Latest performance:

CORE_MATH_PERF_MODE=rdtsc PERF_ARGS='' ./perf.sh coshf
GNU libc version: 2.31
GNU libc release: stable
18.077
12.679
13.202
CORE_MATH_PERF_MODE=rdtsc PERF_ARGS='--latency' ./perf.sh coshf
GNU libc version: 2.31
GNU libc release: stable
48.662
37.058
51.001

[zimmermann6]

I couldn't build this patch on top of 'main' (revision 81af344):

/localdisk/zimmerma/llvm-project/libc/src/math/generic/coshf.cpp:11:10: fatal error: 'src/math/generic/expxf.h' file not found
#include "src/math/generic/expxf.h"
         ^~~~~~~~~~~~~~~~~~~~~~~~~~

Is there any dependency?

[orex]

Yes. You should first apply D129005, after D129215 and after that one. The initial revision were cut to several ones to improve review process and new function deployment.

[zimmermann6]

In D129275#3645017, @orex wrote:

Yes. You should first apply D129005, after D129215 and after that one. The initial revision were cut to several ones to improve review process and new function deployment.

thank you. I get one patch failure when I merge the last patch:

$ patch -p1 -i /tmp/D129275.diff
patching file libc/config/darwin/arm/entrypoints.txt
Hunk #1 succeeded at 111 (offset 1 line).
patching file libc/config/linux/aarch64/entrypoints.txt
Hunk #1 succeeded at 130 (offset 1 line).
patching file libc/config/linux/x86_64/entrypoints.txt
Hunk #1 succeeded at 136 (offset 1 line).
patching file libc/config/windows/entrypoints.txt
Hunk #1 succeeded at 114 (offset 1 line).
patching file libc/spec/stdc.td
patching file libc/src/__support/FPUtil/FPBits.h
Hunk #1 FAILED at 57.
Hunk #2 succeeded at 154 (offset 4 lines).
1 out of 2 hunks FAILED -- saving rejects to file libc/src/__support/FPUtil/FPBits.h.rej
patching file libc/src/math/CMakeLists.txt
patching file libc/src/math/coshf.h
patching file libc/src/math/generic/CMakeLists.txt
patching file libc/src/math/generic/coshf.cpp
patching file libc/test/src/math/CMakeLists.txt
Hunk #1 succeeded at 1314 (offset 3 lines).
patching file libc/test/src/math/coshf_test.cpp
patching file libc/test/src/math/exhaustive/CMakeLists.txt
patching file libc/test/src/math/exhaustive/coshf_test.cpp
patching file libc/utils/MPFRWrapper/MPFRUtils.h
patching file libc/utils/MPFRWrapper/MPFRUtils.cpp

This is on top of revision 1301995 (main).

[orex]

Can you try to put all the chain on top of the revision 60d6be5dd3f411cfe1b5392cbb... for now. I'll rebase the revisions to the last main tonight.

[zimmermann6]

In D129275#3645137, @orex wrote:

Can you try to put all the chain on top of the revision 60d6be5dd3f411cfe1b5392cbb... for now. I'll rebase the revisions to the last main tonight.

thank you, it works perfectly. All exhaustive tests do pass for the 4 rounding modes. For the efficiency I get on a AMD EPYC 7282 with gcc 10.2.1 and clang 11.0.1-2:

zimmerma@biscotte:~/svn/core-math$ LIBM=/localdisk/zimmerma/llvm-project/build/projects/libc/lib/libllvmlibc.a CORE_MATH_LAUNCHER="/localdisk/zimmerma/glibc-2.35/install/lib/ld-linux-x86-64.so.2 --library-path /localdisk/zimmerma/glibc-2.35/install/lib" CORE_MATH_PERF_MODE=rdtsc ./perf.sh coshf
GNU libc version: 2.35
GNU libc release: stable
17.537
15.789
35.447

which means 18 cycles for CORE-MATH, 16 cycles for glibc 2.35, and 35 for llvm-libc.

[lntue]

libc/src/__support/FPUtil/FPBits.h

64

Why do we need extra inline's here? They should be implicit for class methods with definitions in the headers?

libc/src/math/generic/coshf.cpp

44–46

Add comments about your expanded formula / computations:

exp(x) = ep_p.mult_exp * (ep_p.r + 1)
exp(-x) = ep_m.mult_exp * (ep_m.r + 1)
cosh(x) = (exp(x) + exp(-x)) / 2 = ...

In the evaluation, it looks like there is (... - 1.0) + (... - 1.0) followed by (0.5 * ...) + 1.0 so all the 1.0's are actually cancelled. Maybe this can be simplified to:

ep = fputil::multiply_add(ep_p.mult_exp, ep_p.r, ep_p.mult_exp) +
     fputil::multiply_add(ep_m.mult_exp, ep_m.r, ep_m.mult_exp);
return 0.5 * ep;

And the 0.5 * ep can even be dropped with an update in exp_eval.

libc/test/src/math/CMakeLists.txt

1320

Unit test doesn't need NO_RUN_POSTBUILD, unless you only want to run it manually.

libc/test/src/math/coshf_test.cpp

65

0.5 for tolerance?

72

0.5 for tolerance?

77

0.5 for tolerance?

[orex]

Rebasing on main with small fixes.

[orex]

Review fixes.

[lntue]

libc/src/math/generic/CMakeLists.txt

1137

Add expxf.h to HDRS and nearest_integer to DEPENDS

[orex]

Review fixes.

[lntue]

Looks good to me. Let's wait for @zimmermann6 to confirm the accuracy and performance.

[zimmermann6]

I get slightly different figures on my machine:

zimmerma@biscotte:~/svn/core-math$ LIBM=/localdisk/zimmerma/llvm-project/build/projects/libc/lib/libllvmlibc.a CORE_MATH_PERF_MODE=rdtsc ./perf.sh coshf
GNU libc version: 2.33
GNU libc release: release
17.730
19.322
22.815
zimmerma@biscotte:~/svn/core-math$ LIBM=/localdisk/zimmerma/llvm-project/build/projects/libc/lib/libllvmlibc.a CORE_MATH_PERF_MODE=rdtsc PERF_ARGS=--latency ./perf.sh coshf
GNU libc version: 2.33
GNU libc release: release
49.478
48.614
75.194

[orex]

Thank you Paul for sharing the results.
The results I got using the same compiler (llvm 11) as Paul (@zimmermann6):

CORE_MATH_PERF_MODE=rdtsc PERF_ARGS='' ./perf.sh coshf
GNU libc version: 2.31
GNU libc release: stable
18.534
13.019
17.590
CORE_MATH_PERF_MODE=rdtsc PERF_ARGS='--latency' ./perf.sh coshf
GNU libc version: 2.31
GNU libc release: stable
49.670
38.334
50.461

As you can see llvm 12 significantly improve throughput of this version of coshf over version 11. Partially this problem can be explained by this difference. Another source of the difference is Intel vs AMD. We observe such difference with (@lntue).
Paul, can you confirm, that the precision is OK? I think that we can push the changes even though the solution is not the fastest for all platforms/compilers? Tue?

[lntue]

In D129275#3686972, @orex wrote:

Thank you Paul for sharing the results.
The results I got using the same compiler (llvm 11) as Paul (@zimmermann6):

CORE_MATH_PERF_MODE=rdtsc PERF_ARGS='' ./perf.sh coshf
GNU libc version: 2.31
GNU libc release: stable
18.534
13.019
17.590
CORE_MATH_PERF_MODE=rdtsc PERF_ARGS='--latency' ./perf.sh coshf
GNU libc version: 2.31
GNU libc release: stable
49.670
38.334
50.461

As you can see llvm 12 significantly improve throughput of this version of coshf over version 11. Partially this problem can be explained by this difference. Another source of the difference is Intel vs AMD. We observe such difference with (@lntue).
Paul, can you confirm, that the precision is OK? I think that we can push the changes even though the solution is not the fastest for all platforms/compilers? Tue?

Even though there is a regression in performance with clang-11, it still looks good for me. You can go ahead with this patch.

libc/config/darwin/arm/entrypoints.txt

set(TARGET_LIBM_ENTRYPOINTS
 
     # math.h entrypoints
     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.src.math.coshf
     libc.src.math.cosf
     libc.src.math.expf
     libc.src.math.exp2f
     libc.src.math.expm1f
     libc.src.math.fabs
     libc.src.math.fabsf
     libc.src.math.fabsl
     libc.src.math.fdim

libc/config/linux/aarch64/entrypoints.txt

set(TARGET_LIBM_ENTRYPOINTS
 
     # math.h entrypoints
     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.src.math.coshf
     libc.src.math.cosf
     libc.src.math.expf
     libc.src.math.exp2f
     libc.src.math.expm1f
     libc.src.math.fabs
     libc.src.math.fabsf
     libc.src.math.fabsl
     libc.src.math.fdim

libc/config/linux/x86_64/entrypoints.txt

set(TARGET_LIBM_ENTRYPOINTS
     # math.h entrypoints
     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.src.math.cos
+    libc.src.math.coshf
     libc.src.math.cosf
     libc.src.math.expf
     libc.src.math.exp2f
     libc.src.math.expm1f
     libc.src.math.fabs
     libc.src.math.fabsf
     libc.src.math.fabsl
     libc.src.math.fdim

libc/config/windows/entrypoints.txt

set(TARGET_LIBM_ENTRYPOINTS
     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.src.math.cos
     libc.src.math.cosf
+    libc.src.math.coshf
     libc.src.math.expf
     libc.src.math.exp2f
     libc.src.math.expm1f
     libc.src.math.fabs
     libc.src.math.fabsf
     libc.src.math.fabsl
     libc.src.math.fdim
     libc.src.math.fdimf

libc/spec/stdc.td

HeaderSpec Math = HeaderSpec<
 
           FunctionSpec<"nearbyint", RetValSpec<DoubleType>, [ArgSpec<DoubleType>]>,
           FunctionSpec<"nearbyintf", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
           FunctionSpec<"nearbyintl", RetValSpec<LongDoubleType>, [ArgSpec<LongDoubleType>]>,
 
           FunctionSpec<"nextafterf", RetValSpec<FloatType>, [ArgSpec<FloatType>, ArgSpec<FloatType>]>,
           FunctionSpec<"nextafter", RetValSpec<DoubleType>, [ArgSpec<DoubleType>, ArgSpec<DoubleType>]>,
           FunctionSpec<"nextafterl", RetValSpec<LongDoubleType>, [ArgSpec<LongDoubleType>, ArgSpec<LongDoubleType>]>,
+
+          FunctionSpec<"coshf", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
       ]
   >;
 
   HeaderSpec StdIO = HeaderSpec<
       "stdio.h",
       [
           Macro<"stderr">,
           Macro<"stdout">,

libc/src/__support/FPUtil/FPBits.h

template <typename T> struct FPBits {
   UIntType bits;
 
   void set_mantissa(UIntType mantVal) {
     mantVal &= (FloatProp::MANTISSA_MASK);
     bits &= ~(FloatProp::MANTISSA_MASK);
     bits |= mantVal;
   }
 
-  UIntType get_mantissa() const { return bits & FloatProp::MANTISSA_MASK; }
+  inline UIntType get_mantissa() const {
+    return bits & FloatProp::MANTISSA_MASK;
+  }
 
   void set_unbiased_exponent(UIntType expVal) {
     expVal = (expVal << (FloatProp::MANTISSA_WIDTH)) & FloatProp::EXPONENT_MASK;
     bits &= ~(FloatProp::EXPONENT_MASK);
     bits |= expVal;
   }
 
-  uint16_t get_unbiased_exponent() const {
+  inline uint16_t get_unbiased_exponent() const {
     return uint16_t((bits & FloatProp::EXPONENT_MASK) >>
                     (FloatProp::MANTISSA_WIDTH));
   }
 
   // The function return mantissa with the implicit bit set iff the current
   // value is a valid normal number.
   constexpr UIntType get_explicit_mantissa() {
     return ((get_unbiased_exponent() > 0 && !is_inf_or_nan())
                 ? (FloatProp::MANTISSA_MASK + 1)
                 : 0) |
            (FloatProp::MANTISSA_MASK & bits);
   }
 
   void set_sign(bool signVal) {
     bits |= FloatProp::SIGN_MASK;
     if (!signVal)
       bits -= FloatProp::SIGN_MASK;
   }
 
-  bool get_sign() const { return (bits & FloatProp::SIGN_MASK) != 0; }
+  inline 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);
template <typename T> struct FPBits {
   }
 
   static constexpr FPBits<T> zero(bool sign = false) {
     return FPBits(sign ? FloatProp::SIGN_MASK : UIntType(0));
   }
 
   static constexpr FPBits<T> neg_zero() { return zero(true); }
 
-  static constexpr FPBits<T> inf() {
-    FPBits<T> bits;
+  static constexpr FPBits<T> inf(bool sign = false) {
+    FPBits<T> bits(sign ? FloatProp::SIGN_MASK : UIntType(0));
     bits.set_unbiased_exponent(MAX_EXPONENT);
     return bits;
   }
 
   static constexpr FPBits<T> neg_inf() {
     FPBits<T> bits = inf();
     bits.set_sign(1);
     return bits;

libc/src/math/CMakeLists.txt

 add_math_entrypoint_object(ceill)
 
 add_math_entrypoint_object(copysign)
 add_math_entrypoint_object(copysignf)
 add_math_entrypoint_object(copysignl)
 
 add_math_entrypoint_object(cos)
 add_math_entrypoint_object(cosf)
+add_math_entrypoint_object(coshf)
 
 add_math_entrypoint_object(expf)
 
 add_math_entrypoint_object(exp2f)
 
 add_math_entrypoint_object(expm1f)
 
 add_math_entrypoint_object(fabs)

libc/src/math/coshf.h

+//===-- Implementation header for coshf -------------------------*- 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_COSHF_H
+#define LLVM_LIBC_SRC_MATH_COSHF_H
+
+namespace __llvm_libc {
+
+float coshf(float x);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_MATH_COSHF_H

libc/src/math/generic/CMakeLists.txt

add_entrypoint_object(
   HDRS
     ../fmodf.h
   DEPENDS
     libc.include.math
     libc.src.__support.FPUtil.generic.fmod
   COMPILE_OPTIONS
     -O3
 )
+
+add_entrypoint_object(
+  coshf
+  SRCS
+    coshf.cpp
+  HDRS
+    ../coshf.h
+  DEPENDS
+    .common_constants
+    libc.src.__support.FPUtil.fputil
+    libc.src.__support.FPUtil.polyeval
+    libc.include.math
+  COMPILE_OPTIONS
+    -O3
+)
+

libc/src/math/generic/coshf.cpp

+//===-- Single-precision cosh 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/coshf.h"
+#include "src/__support/FPUtil/FPBits.h"
+#include "src/math/generic/expxf.h"
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(float, coshf, (float x)) {
+  using FPBits = typename fputil::FPBits<float>;
+  FPBits xbits(x);
+  xbits.set_sign(false);
+  x = xbits.get_val();
+
+  uint32_t x_u = xbits.uintval();
+
+  // |x| <= 2^-26
+  if (unlikely(x_u <= 0x3280'0000U)) {
+    return 1.0f + x;
+  }
+
+  // When |x| >= 90, or x is inf or nan
+  if (unlikely(x_u >= 0x42b4'0000U)) {
+    if (xbits.is_inf_or_nan())
+      return x + FPBits::inf().get_val();
+
+    int rounding = fputil::get_round();
+    if (unlikely(rounding == FE_DOWNWARD || rounding == FE_TOWARDZERO))
+      return FPBits(FPBits::MAX_NORMAL).get_val();
+
+    errno = ERANGE;
+
+    return x + FPBits::inf().get_val();
+  }
+  auto ep_p = exp_eval<-1>(x);
+  auto ep_m = exp_eval<-1>(-x);
+  double ep = fputil::multiply_add(ep_p.mult_exp, ep_p.r, ep_p.mult_exp) +
+              fputil::multiply_add(ep_m.mult_exp, ep_m.r, ep_m.mult_exp);
+  return ep;
+}
+
+} // namespace __llvm_libc

libc/test/src/math/CMakeLists.txt

SUITE
     libc_math_unittests
   SRCS
     expxf_test.cpp
   DEPENDS
     libc.src.math.generic.common_constants
     libc.src.__support.FPUtil.fputil
 )
 
+add_fp_unittest(
+  coshf_test
+  NEED_MPFR
+  NO_RUN_POSTBUILD
+  SUITE
+    libc_math_unittests
+  SRCS
+    coshf_test.cpp
+  HDRS
+    sdcomp26094.h
+  DEPENDS
+    libc.include.errno
+    libc.src.math.coshf
+    libc.src.__support.CPP.array
+    libc.src.__support.FPUtil.fputil
+)
+
 add_subdirectory(generic)
 add_subdirectory(exhaustive)
 add_subdirectory(differential_testing)

libc/test/src/math/coshf_test.cpp

+//===-- Unittests for coshf -----------------------------------------------===//
+//
+// 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/CPP/Array.h"
+#include "src/__support/FPUtil/FPBits.h"
+#include "src/math/coshf.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 = __llvm_libc::fputil::FPBits<float>;
+
+namespace mpfr = __llvm_libc::testing::mpfr;
+
+DECLARE_SPECIAL_CONSTANTS(float)
+
+TEST(LlvmLibcCoshfTest, SpecialNumbers) {
+  errno = 0;
+
+  EXPECT_FP_EQ(aNaN, __llvm_libc::coshf(aNaN));
+  EXPECT_MATH_ERRNO(0);
+
+  EXPECT_FP_EQ(inf, __llvm_libc::coshf(inf));
+  EXPECT_MATH_ERRNO(0);
+
+  EXPECT_FP_EQ(inf, __llvm_libc::coshf(neg_inf));
+  EXPECT_MATH_ERRNO(0);
+
+  EXPECT_FP_EQ(1.0f, __llvm_libc::coshf(0.0f));
+  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_MATH_ERRNO(ERANGE);
+
+  EXPECT_FP_EQ(inf, __llvm_libc::coshf(float(FPBits(0x42cffff8U))));
+  EXPECT_MATH_ERRNO(ERANGE);
+
+  EXPECT_FP_EQ(inf, __llvm_libc::coshf(float(FPBits(0x42d00008U))));
+  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));
+    if (isnan(x) || isinf(x))
+      continue;
+    ASSERT_MPFR_MATCH(mpfr::Operation::Cosh, x, __llvm_libc::coshf(x), 0.5);
+  }
+}
+
+TEST(LlvmLibcCoshfTest, SmallValues) {
+  float x = float(FPBits(0x17800000U));
+  float result = __llvm_libc::coshf(x);
+  EXPECT_MPFR_MATCH(mpfr::Operation::Cosh, x, result, 0.5);
+  EXPECT_FP_EQ(1.0f, result);
+
+  x = float(FPBits(0x0040000U));
+  result = __llvm_libc::coshf(x);
+  EXPECT_MPFR_MATCH(mpfr::Operation::Cosh, x, result, 0.5);
+  EXPECT_FP_EQ(1.0f, result);
+}

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

add_fp_unittest(
   SUITE
     libc_math_exhaustive_tests
   SRCS
     fmod_generic_impl_test.cpp
   DEPENDS
     libc.src.__support.FPUtil.fputil
     libc.src.__support.FPUtil.generic.fmod
 )
+
+add_fp_unittest(
+  coshf_test
+  NO_RUN_POSTBUILD
+  NEED_MPFR
+  SUITE
+    libc_math_exhaustive_tests
+  SRCS
+    coshf_test.cpp
+  DEPENDS
+    .exhaustive_test
+    libc.include.math
+    libc.src.math.coshf
+    libc.src.__support.FPUtil.fputil
+  LINK_LIBRARIES
+    -lpthread
+)
+

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

+//===-- Exhaustive test for expf ------------------------------------------===//
+//
+// 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/coshf.h"
+#include "utils/MPFRWrapper/MPFRUtils.h"
+#include "utils/UnitTest/FPMatcher.h"
+
+#include <thread>
+
+using FPBits = __llvm_libc::fputil::FPBits<float>;
+
+namespace mpfr = __llvm_libc::testing::mpfr;
+
+struct LlvmLibcCoshfExhaustiveTest : 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::Cosh, x,
+                                  __llvm_libc::coshf(x), 0.5, rounding);
+    } while (bits++ < stop);
+    return result;
+  }
+};
+
+static const int NUM_THREADS = std::thread::hardware_concurrency();
+
+// Range: [0, 90];
+static constexpr uint32_t POS_START = 0x0000'0000U;
+static constexpr uint32_t POS_STOP = 0x42b4'0000U;
+
+TEST_F(LlvmLibcCoshfExhaustiveTest, PostiveRangeRoundNearestTieToEven) {
+  test_full_range(POS_START, POS_STOP, mpfr::RoundingMode::Nearest);
+}
+
+TEST_F(LlvmLibcCoshfExhaustiveTest, PostiveRangeRoundUp) {
+  test_full_range(POS_START, POS_STOP, mpfr::RoundingMode::Upward);
+}
+
+TEST_F(LlvmLibcCoshfExhaustiveTest, PostiveRangeRoundDown) {
+  test_full_range(POS_START, POS_STOP, mpfr::RoundingMode::Downward);
+}
+
+TEST_F(LlvmLibcCoshfExhaustiveTest, PostiveRangeRoundTowardZero) {
+  test_full_range(POS_START, POS_STOP, mpfr::RoundingMode::TowardZero);
+}

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,
   Ceil,
   Cos,
+  Cosh,
   Exp,
   Exp2,
   Expm1,
   Floor,
   Log,
   Log2,
   Log10,
   Log1p,

libc/utils/MPFRWrapper/MPFRUtils.cpp

public:
   }
 
   MPFRNumber cos() const {
     MPFRNumber result(*this);
     mpfr_cos(result.value, value, mpfr_rounding);
     return result;
   }
 
+  MPFRNumber cosh() const {
+    MPFRNumber result(*this);
+    mpfr_cosh(result.value, value, mpfr_rounding);
+    return result;
+  }
+
   MPFRNumber exp() const {
     MPFRNumber result(*this);
     mpfr_exp(result.value, value, mpfr_rounding);
     return result;
   }
 
   MPFRNumber exp2() 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::Ceil:
     return mpfrInput.ceil();
   case Operation::Cos:
     return mpfrInput.cos();
+  case Operation::Cosh:
+    return mpfrInput.cosh();
   case Operation::Exp:
     return mpfrInput.exp();
   case Operation::Exp2:
     return mpfrInput.exp2();
   case Operation::Expm1:
     return mpfrInput.expm1();
   case Operation::Floor:
     return mpfrInput.floor();