[libc] Add rounding mode support for MPFR testing macros.

[lntue]

Summary

Add an extra argument for rounding mode to EXPECT_MPFR_MATCH and ASSERT_MPFR_MATCH macros.

[michaelrj]

LGTM

[sivachandra]

libc/utils/MPFRWrapper/MPFRUtils.h

306–319

I am not sure if this MISSING_ARGS macro is any useful. For, if any error occurs, it will print an error message but tell us nothing about what is actually wrong. I would think a better approach would be to let the RoundingMode arg to get_mpfr_matcher take a default value of RoundingMode::Nearest. That way, you can also simplify the macros below to some thing like this:

#define EXPECT_MPFR_MATCH(op, input, match_value, tolerance, ...) \
  EXPECT_THAT(match_value,                                        \
              __llvm_libc::testing::mpfr::get_mpfr_matcher<op>(   \
                  input, match_value, tolerance                   \
                  __VA_OPT__(,) __VA_ARGS__))

This way, if there is any error in the args, we will actually get a proper compiler error message. If using __VA_OPT__ is a concern, we can use -std=c++20 for compiling MPFRWrapper.

[lntue]

Change MISSING_ARGS to GET_MPFR_DUMMY_ARG.

[lntue]

libc/utils/MPFRWrapper/MPFRUtils.h

306–319

I use MISSING_ARGS as a simple way to avoid gnu-zero-variadic-macro-arguments warnings. It is simpler and does not require extra compiler flags as VA_OPT option. I changed it to GET_MPFR_DUMMY_ARG and added comments to make the intention clearer.

[sivachandra]

libc/utils/MPFRWrapper/MPFRUtils.h

306–319

Ah! So, why should GET_MPFR_MACRO be a variadic macro at all?

310

Add double-underscore prefix to internal macro names.

[lntue]

libc/utils/MPFRWrapper/MPFRUtils.h

306–319

To support and not litter all current usages of EXPECT_MPFR_MATCH with default rounding mode as the 5th argument, it is expanded to either EXPECT_MPFR_MATCH_ROUNDING with 5 arguments, or EXPECT_MPFR_MATCH_DEFAULT with 4 arguments by GET_MPFR_MACRO.

If 5 arguments are provided to EXPECT_MPFR_MATCH, GET_MPFR_MACRO will get 6 arguments (not including GET_MPFR_DUMMY_ARG), and if 4 arguments are provided to EXPECT_MPFR_MATCH, GET_MPFR_MACRO will only get 5 arguments (not including GET_MPFR_DUMMY_ARG), and hence it needs to be variadic.

It is the 4 argument case that variadic GET_MPFR_MACRO got complained by -Wgnu-zero-variadic-macro-arguments without GET_MPFR_DUMMY_ARG.

[lntue]

[libc] Add rounding mode support for MPFR testing macros.

[sivachandra]

libc/utils/MPFRWrapper/MPFRUtils.h

306–319

So, the way you have set it up, it can already support 4 or 5 args. But, it need not be a variadic macro. FWIW, I patched your change and removed the ... and also the last arg to the macro on line 309 and line 325. It goes through fine.

[lntue]

Add simple tests for sqrt with different rounding modes.
Make all the MPFR util functions accept both precision and rounding mode.

[lntue]

libc/utils/MPFRWrapper/MPFRUtils.h

306–319

Because there were no tests using the updated macros with rounding parameters. I've added simple tests for sqrt with different rounding modes. Now the build would fail if you remove ... from GET_MPFR_MACRO.

[sivachandra]

libc/utils/MPFRWrapper/MPFRUtils.cpp

149–152

Nit: you should probably use XType here and below instead of float etc.

libc/utils/MPFRWrapper/MPFRUtils.h

306–319

Thanks! That helps me see it better. I still prefer to keep it simple really. The new macro can be called ASSERT_MPFR_MATCH_WITH_ROUNDING and make it explicit. I agree it is verbose, but keeps everything really simple. For, the error message I see now says that there are incorrect number of args somewhere, but does not tell me where exactly. I will leave it up to you do decide.

310

This is still not addressed.

[sivachandra]

libc/test/src/math/SqrtTest.h

69

I am assuming this is just a demo and that you will remove it before submitting.

[lntue]

[libc] Add rounding mode support for MPFR testing macros.

[lntue]

[libc] Add rounding mode support for MPFR testing macros.

libc/test/src/math/SqrtTest.h

-//===-- Utility class to test fabs[f|l] -------------------------*- C++ -*-===//
+//===-- Utility class to test sqrt[f|l] -------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "utils/MPFRWrapper/MPFRUtils.h"
template <typename T> class SqrtTest : public __llvm_libc::testing::Test {
   DECLARE_SPECIAL_CONSTANTS(T)
 
   static constexpr UIntType HIDDEN_BIT =
       UIntType(1) << __llvm_libc::fputil::MantissaWidth<T>::VALUE;
 
 public:
   typedef T (*SqrtFunc)(T);
 
-  void testSpecialNumbers(SqrtFunc func) {
+  void test_special_numbers(SqrtFunc func) {
     ASSERT_FP_EQ(aNaN, func(aNaN));
     ASSERT_FP_EQ(inf, func(inf));
     ASSERT_FP_EQ(aNaN, func(neg_inf));
     ASSERT_FP_EQ(0.0, func(0.0));
     ASSERT_FP_EQ(-0.0, func(-0.0));
     ASSERT_FP_EQ(aNaN, func(T(-1.0)));
     ASSERT_FP_EQ(T(1.0), func(T(1.0)));
     ASSERT_FP_EQ(T(2.0), func(T(4.0)));
     ASSERT_FP_EQ(T(3.0), func(T(9.0)));
   }
 
-  void testDenormalValues(SqrtFunc func) {
+  void test_denormal_values(SqrtFunc func) {
     for (UIntType mant = 1; mant < HIDDEN_BIT; mant <<= 1) {
       FPBits denormal(T(0.0));
       denormal.set_mantissa(mant);
 
-      ASSERT_MPFR_MATCH(mpfr::Operation::Sqrt, T(denormal), func(T(denormal)),
-                        T(0.5));
+      test_all_rounding_modes(func, T(denormal));
     }
 
     constexpr UIntType COUNT = 1'000'001;
     constexpr UIntType STEP = HIDDEN_BIT / COUNT;
     for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
       T x = *reinterpret_cast<T *>(&v);
-      ASSERT_MPFR_MATCH(mpfr::Operation::Sqrt, x, func(x), 0.5);
+      test_all_rounding_modes(func, x);
     }
   }
 
-  void testNormalRange(SqrtFunc func) {
+  void test_normal_range(SqrtFunc func) {
     constexpr UIntType COUNT = 10'000'001;
     constexpr UIntType STEP = UIntType(-1) / COUNT;
     for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
       T x = *reinterpret_cast<T *>(&v);
       if (isnan(x) || (x < 0)) {
         continue;
       }
-      ASSERT_MPFR_MATCH(mpfr::Operation::Sqrt, x, func(x), 0.5);
+      test_all_rounding_modes(func, x);
     }
   }
+
+  void test_all_rounding_modes(SqrtFunc func, T x) {
+    mpfr::ForceRoundingMode r1(mpfr::RoundingMode::Nearest);
+    EXPECT_MPFR_MATCH(mpfr::Operation::Sqrt, x, func(x), 0.5,
+                      mpfr::RoundingMode::Nearest);
+
+    mpfr::ForceRoundingMode r2(mpfr::RoundingMode::Upward);
+    EXPECT_MPFR_MATCH(mpfr::Operation::Sqrt, x, func(x), 0.5,
+                      mpfr::RoundingMode::Upward);
+
+    mpfr::ForceRoundingMode r3(mpfr::RoundingMode::Downward);
+    EXPECT_MPFR_MATCH(mpfr::Operation::Sqrt, x, func(x), 0.5,
+                      mpfr::RoundingMode::Downward);
+
+    mpfr::ForceRoundingMode r4(mpfr::RoundingMode::TowardZero);
+    EXPECT_MPFR_MATCH(mpfr::Operation::Sqrt, x, func(x), 0.5,
+                      mpfr::RoundingMode::TowardZero);
+  }
 };
 
 #define LIST_SQRT_TESTS(T, func)                                               \
   using LlvmLibcSqrtTest = SqrtTest<T>;                                        \
-  TEST_F(LlvmLibcSqrtTest, SpecialNumbers) { testSpecialNumbers(&func); }      \
-  TEST_F(LlvmLibcSqrtTest, DenormalValues) { testDenormalValues(&func); }      \
-  TEST_F(LlvmLibcSqrtTest, NormalRange) { testNormalRange(&func); }
+  TEST_F(LlvmLibcSqrtTest, SpecialNumbers) { test_special_numbers(&func); }    \
+  TEST_F(LlvmLibcSqrtTest, DenormalValues) { test_denormal_values(&func); }    \
+  TEST_F(LlvmLibcSqrtTest, NormalRange) { test_normal_range(&func); }

libc/utils/MPFRWrapper/MPFRUtils.h

enum class Operation : int {
   // Operations which take three floating point nubmers of the same type as
   // input and produce a single floating point number of the same type as
   // output.
   BeginTernaryOperationsSingleOuput,
   Fma,
   EndTernaryOperationsSingleOutput,
 };
 
+enum class RoundingMode : uint8_t { Upward, Downward, TowardZero, Nearest };
+
+int get_fe_rounding(RoundingMode mode);
+
+struct ForceRoundingMode {
+  ForceRoundingMode(RoundingMode);
+  ~ForceRoundingMode();
+
+  int old_rounding_mode;
+  int rounding_mode;
+};
+
 template <typename T> struct BinaryInput {
   static_assert(
       __llvm_libc::cpp::IsFloatingPointType<T>::Value,
       "Template parameter of BinaryInput must be a floating point type.");
 
   using Type = T;
   T x, y;
 };

 
 template <typename T>
 struct AreMatchingBinaryInputAndBinaryOutput<BinaryInput<T>, BinaryOutput<T>> {
   static constexpr bool VALUE = cpp::IsFloatingPointType<T>::Value;
 };
 
 template <typename T>
 bool compare_unary_operation_single_output(Operation op, T input, T libc_output,
-                                           double t);
+                                           double ulp_tolerance,
+                                           RoundingMode rounding);
 template <typename T>
 bool compare_unary_operation_two_outputs(Operation op, T input,
                                          const BinaryOutput<T> &libc_output,
-                                         double t);
+                                         double ulp_tolerance,
+                                         RoundingMode rounding);
 template <typename T>
 bool compare_binary_operation_two_outputs(Operation op,
                                           const BinaryInput<T> &input,
                                           const BinaryOutput<T> &libc_output,
-                                          double t);
+                                          double ulp_tolerance,
+                                          RoundingMode rounding);
 
 template <typename T>
 bool compare_binary_operation_one_output(Operation op,
                                          const BinaryInput<T> &input,
-                                         T libc_output, double t);
+                                         T libc_output, double ulp_tolerance,
+                                         RoundingMode rounding);
 
 template <typename T>
 bool compare_ternary_operation_one_output(Operation op,
                                           const TernaryInput<T> &input,
-                                          T libc_output, double t);
+                                          T libc_output, double ulp_tolerance,
+                                          RoundingMode rounding);
 
 template <typename T>
 void explain_unary_operation_single_output_error(Operation op, T input,
                                                  T match_value,
+                                                 double ulp_tolerance,
+                                                 RoundingMode rounding,
                                                  testutils::StreamWrapper &OS);
 template <typename T>
 void explain_unary_operation_two_outputs_error(
     Operation op, T input, const BinaryOutput<T> &match_value,
-    testutils::StreamWrapper &OS);
+    double ulp_tolerance, RoundingMode rounding, testutils::StreamWrapper &OS);
 template <typename T>
 void explain_binary_operation_two_outputs_error(
     Operation op, const BinaryInput<T> &input,
-    const BinaryOutput<T> &match_value, testutils::StreamWrapper &OS);
+    const BinaryOutput<T> &match_value, double ulp_tolerance,
+    RoundingMode rounding, testutils::StreamWrapper &OS);
 
 template <typename T>
-void explain_binary_operation_one_output_error(Operation op,
-                                               const BinaryInput<T> &input,
-                                               T match_value,
-                                               testutils::StreamWrapper &OS);
+void explain_binary_operation_one_output_error(
+    Operation op, const BinaryInput<T> &input, T match_value,
+    double ulp_tolerance, RoundingMode rounding, testutils::StreamWrapper &OS);
 
 template <typename T>
-void explain_ternary_operation_one_output_error(Operation op,
-                                                const TernaryInput<T> &input,
-                                                T match_value,
-                                                testutils::StreamWrapper &OS);
+void explain_ternary_operation_one_output_error(
+    Operation op, const TernaryInput<T> &input, T match_value,
+    double ulp_tolerance, RoundingMode rounding, testutils::StreamWrapper &OS);
 
 template <Operation op, typename InputType, typename OutputType>
 class MPFRMatcher : public testing::Matcher<OutputType> {
   InputType input;
   OutputType match_value;
   double ulp_tolerance;
+  RoundingMode rounding;
 
 public:
-  MPFRMatcher(InputType testInput, double ulp_tolerance)
-      : input(testInput), ulp_tolerance(ulp_tolerance) {}
+  MPFRMatcher(InputType testInput, double ulp_tolerance, RoundingMode rounding)
+      : input(testInput), ulp_tolerance(ulp_tolerance), rounding(rounding) {}
 
   bool match(OutputType libcResult) {
     match_value = libcResult;
-    return match(input, match_value, ulp_tolerance);
+    return match(input, match_value);
   }
 
   // This method is marked with NOLINT because it the name `explainError`
   // does not confirm to the coding style.
   void explainError(testutils::StreamWrapper &OS) override { // NOLINT
     explain_error(input, match_value, OS);
   }
 
 private:
-  template <typename T> static bool match(T in, T out, double tolerance) {
-    return compare_unary_operation_single_output(op, in, out, tolerance);
+  template <typename T> bool match(T in, T out) {
+    return compare_unary_operation_single_output(op, in, out, ulp_tolerance,
+                                                 rounding);
   }
 
-  template <typename T>
-  static bool match(T in, const BinaryOutput<T> &out, double tolerance) {
-    return compare_unary_operation_two_outputs(op, in, out, tolerance);
+  template <typename T> bool match(T in, const BinaryOutput<T> &out) {
+    return compare_unary_operation_two_outputs(op, in, out, ulp_tolerance,
+                                               rounding);
   }
 
-  template <typename T>
-  static bool match(const BinaryInput<T> &in, T out, double tolerance) {
-    return compare_binary_operation_one_output(op, in, out, tolerance);
+  template <typename T> bool match(const BinaryInput<T> &in, T out) {
+    return compare_binary_operation_one_output(op, in, out, ulp_tolerance,
+                                               rounding);
   }
 
   template <typename T>
-  static bool match(BinaryInput<T> in, const BinaryOutput<T> &out,
-                    double tolerance) {
-    return compare_binary_operation_two_outputs(op, in, out, tolerance);
+  bool match(BinaryInput<T> in, const BinaryOutput<T> &out) {
+    return compare_binary_operation_two_outputs(op, in, out, ulp_tolerance,
+                                                rounding);
   }
 
-  template <typename T>
-  static bool match(const TernaryInput<T> &in, T out, double tolerance) {
-    return compare_ternary_operation_one_output(op, in, out, tolerance);
+  template <typename T> bool match(const TernaryInput<T> &in, T out) {
+    return compare_ternary_operation_one_output(op, in, out, ulp_tolerance,
+                                                rounding);
   }
 
   template <typename T>
-  static void explain_error(T in, T out, testutils::StreamWrapper &OS) {
-    explain_unary_operation_single_output_error(op, in, out, OS);
+  void explain_error(T in, T out, testutils::StreamWrapper &OS) {
+    explain_unary_operation_single_output_error(op, in, out, ulp_tolerance,
+                                                rounding, OS);
   }
 
   template <typename T>
-  static void explain_error(T in, const BinaryOutput<T> &out,
-                            testutils::StreamWrapper &OS) {
-    explain_unary_operation_two_outputs_error(op, in, out, OS);
+  void explain_error(T in, const BinaryOutput<T> &out,
+    explain_unary_operation_two_outputs_error(op, in, out, ulp_tolerance,
+                                              rounding, OS);
   }
 
   template <typename T>
-  static void explain_error(const BinaryInput<T> &in,
-                            const BinaryOutput<T> &out,
-                            testutils::StreamWrapper &OS) {
-    explain_binary_operation_two_outputs_error(op, in, out, OS);
+  void explain_error(const BinaryInput<T> &in, const BinaryOutput<T> &out,
+    explain_binary_operation_two_outputs_error(op, in, out, ulp_tolerance,
+                                               rounding, OS);
   }
 
   template <typename T>
-  static void explain_error(const BinaryInput<T> &in, T out,
-                            testutils::StreamWrapper &OS) {
-    explain_binary_operation_one_output_error(op, in, out, OS);
+  void explain_error(const BinaryInput<T> &in, T out,
+    explain_binary_operation_one_output_error(op, in, out, ulp_tolerance,
+                                              rounding, OS);
   }
 
   template <typename T>
-  static void explain_error(const TernaryInput<T> &in, T out,
-                            testutils::StreamWrapper &OS) {
-    explain_ternary_operation_one_output_error(op, in, out, OS);
+  void explain_error(const TernaryInput<T> &in, T out,
+    explain_ternary_operation_one_output_error(op, in, out, ulp_tolerance,
+                                               rounding, OS);
   }
 };
 
 } // namespace internal
 
 // Return true if the input and ouput types for the operation op are valid
 // types.
 template <Operation op, typename InputType, typename OutputType>
return (Operation::BeginUnaryOperationsSingleOutput < op &&
           cpp::IsFloatingPointType<OutputType>::Value &&
           cpp::IsSame<InputType, TernaryInput<OutputType>>::Value);
 }
 
 template <Operation op, typename InputType, typename OutputType>
 __attribute__((no_sanitize("address")))
 cpp::EnableIfType<is_valid_operation<op, InputType, OutputType>(),
                   internal::MPFRMatcher<op, InputType, OutputType>>
-get_mpfr_matcher(InputType input, OutputType output_unused, double t) {
-  return internal::MPFRMatcher<op, InputType, OutputType>(input, t);
+get_mpfr_matcher(InputType input, OutputType output_unused,
+                 double ulp_tolerance, RoundingMode rounding) {
+  return internal::MPFRMatcher<op, InputType, OutputType>(input, ulp_tolerance,
+                                                          rounding);
 }
 
-enum class RoundingMode : uint8_t { Upward, Downward, TowardZero, Nearest };
-
 template <typename T> T round(T x, RoundingMode mode);
 
 template <typename T> bool round_to_long(T x, long &result);
 template <typename T> bool round_to_long(T x, RoundingMode mode, long &result);
 
 } // namespace mpfr
 } // namespace testing
 } // namespace __llvm_libc
 
-#define EXPECT_MPFR_MATCH(op, input, match_value, tolerance)                   \
+// GET_MPFR_DUMMY_ARG is going to be added to the end of GET_MPFR_MACRO as a
+// simple way to avoid the compiler warning `gnu-zero-variadic-macro-arguments`.
+#define GET_MPFR_DUMMY_ARG(...) 0
+
+#define GET_MPFR_MACRO(__1, __2, __3, __4, __5, __NAME, ...) __NAME
+
+#define EXPECT_MPFR_MATCH_DEFAULT(op, input, match_value, ulp_tolerance)       \
+  EXPECT_THAT(match_value,                                                     \
+              __llvm_libc::testing::mpfr::get_mpfr_matcher<op>(                \
+                  input, match_value, ulp_tolerance,                           \
+                  __llvm_libc::testing::mpfr::RoundingMode::Nearest))
+
+#define EXPECT_MPFR_MATCH_ROUNDING(op, input, match_value, ulp_tolerance,      \
+                                   rounding)                                   \
   EXPECT_THAT(match_value, __llvm_libc::testing::mpfr::get_mpfr_matcher<op>(   \
-                               input, match_value, tolerance))
+                               input, match_value, ulp_tolerance, rounding))
 
-#define ASSERT_MPFR_MATCH(op, input, match_value, tolerance)                   \
+#define EXPECT_MPFR_MATCH(...)                                                 \
+  GET_MPFR_MACRO(__VA_ARGS__, EXPECT_MPFR_MATCH_ROUNDING,                      \
+                 EXPECT_MPFR_MATCH_DEFAULT, GET_MPFR_DUMMY_ARG)                \
+  (__VA_ARGS__)
+
+#define ASSERT_MPFR_MATCH_DEFAULT(op, input, match_value, ulp_tolerance)       \
+  ASSERT_THAT(match_value,                                                     \
+              __llvm_libc::testing::mpfr::get_mpfr_matcher<op>(                \
+                  input, match_value, ulp_tolerance,                           \
+                  __llvm_libc::testing::mpfr::RoundingMode::Nearest))
+
+#define ASSERT_MPFR_MATCH_ROUNDING(op, input, match_value, ulp_tolerance,      \
+                                   rounding)                                   \
   ASSERT_THAT(match_value, __llvm_libc::testing::mpfr::get_mpfr_matcher<op>(   \
-                               input, match_value, tolerance))
+                               input, match_value, ulp_tolerance, rounding))
+
+#define ASSERT_MPFR_MATCH(...)                                                 \
+  GET_MPFR_MACRO(__VA_ARGS__, ASSERT_MPFR_MATCH_ROUNDING,                      \
+                 ASSERT_MPFR_MATCH_DEFAULT, GET_MPFR_DUMMY_ARG)                \
+  (__VA_ARGS__)
 
 #endif // LLVM_LIBC_UTILS_TESTUTILS_MPFRUTILS_H

libc/utils/MPFRWrapper/MPFRUtils.cpp

 //===-- Utils which wrap MPFR ---------------------------------------------===//
 //
 // 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 "MPFRUtils.h"
 
 #include "src/__support/CPP/StringView.h"
 #include "src/__support/FPUtil/FPBits.h"
 #include "src/__support/architectures.h"
 #include "utils/UnitTest/FPMatcher.h"
 
 #include <cmath>
+#include <fenv.h>
 #include <memory>
 #include <stdint.h>
 #include <string>
 
 #ifdef CUSTOM_MPFR_INCLUDER
 // Some downstream repos are monoliths carrying MPFR sources in their third
 // party directory. In such repos, including the MPFR header as
 // `#include <mpfr.h>` is either disallowed or not possible. If that is the
template <> struct Precision<long double> {
   static constexpr unsigned int VALUE = 64;
 };
 #else
 template <> struct Precision<long double> {
   static constexpr unsigned int VALUE = 113;
 };
 #endif
 
-class MPFRNumber {
-  // A precision value which allows sufficiently large additional
-  // precision even compared to quad-precision floating point values.
+// precision compared to the floating point precision.
+template <typename T> struct ExtraPrecision;
+
+template <> struct ExtraPrecision<float> {
+  static constexpr unsigned int VALUE = 128;
+};
+
+template <> struct ExtraPrecision<double> {
+  static constexpr unsigned int VALUE = 256;
+};
+
+template <> struct ExtraPrecision<long double> {
+  static constexpr unsigned int VALUE = 256;
+};
+
+// If the ulp tolerance is less than or equal to 0.5, we would check that the
+// result is rounded correctly with respect to the rounding mode by using the
+// same precision as the inputs.
+template <typename T>
+static inline unsigned int get_precision(double ulp_tolerance) {
+  if (ulp_tolerance <= 0.5) {
+    return Precision<T>::VALUE;
+  } else {
+    return ExtraPrecision<T>::VALUE;
+  }
+}
+
+static inline mpfr_rnd_t get_mpfr_rounding_mode(RoundingMode mode) {
+  switch (mode) {
+  case RoundingMode::Upward:
+    return MPFR_RNDU;
+    break;
+  case RoundingMode::Downward:
+    return MPFR_RNDD;
+    break;
+  case RoundingMode::TowardZero:
+    return MPFR_RNDZ;
+    break;
+  case RoundingMode::Nearest:
+    return MPFR_RNDN;
+    break;
+  }
+}
+
+int get_fe_rounding(RoundingMode mode) {
+  switch (mode) {
+  case RoundingMode::Upward:
+    return FE_UPWARD;
+    break;
+  case RoundingMode::Downward:
+    return FE_DOWNWARD;
+    break;
+  case RoundingMode::TowardZero:
+    return FE_TOWARDZERO;
+    break;
+  case RoundingMode::Nearest:
+    return FE_TONEAREST;
+    break;
+  }
+}
+
+ForceRoundingMode::ForceRoundingMode(RoundingMode mode) {
+  old_rounding_mode = fegetround();
+  rounding_mode = get_fe_rounding(mode);
+  if (old_rounding_mode != rounding_mode)
+    fesetround(rounding_mode);
+}
+
+ForceRoundingMode::~ForceRoundingMode() {
+  if (old_rounding_mode != rounding_mode)
+    fesetround(old_rounding_mode);
+}
+
+class MPFRNumber {
   unsigned int mpfr_precision;
+  mpfr_rnd_t mpfr_rounding;
 
   mpfr_t value;
 
 public:
-  MPFRNumber() : mpfr_precision(256) { mpfr_init2(value, mpfr_precision); }
+  MPFRNumber() : mpfr_precision(256), mpfr_rounding(MPFR_RNDN) {
+    mpfr_init2(value, mpfr_precision);
+  }
 
   // We use explicit EnableIf specializations to disallow implicit
   // conversions. Implicit conversions can potentially lead to loss of
   // precision.
   template <typename XType,
             cpp::EnableIfType<cpp::IsSame<float, XType>::Value, int> = 0>
-  explicit MPFRNumber(XType x, int precision = 128)
-      : mpfr_precision(precision) {
+  explicit MPFRNumber(XType x, int precision = ExtraPrecision<XType>::VALUE,
+                      RoundingMode rounding = RoundingMode::Nearest)
+      : mpfr_precision(precision),
+        mpfr_rounding(get_mpfr_rounding_mode(rounding)) {
     mpfr_init2(value, mpfr_precision);
-    mpfr_set_flt(value, x, MPFR_RNDN);
+    mpfr_set_flt(value, x, mpfr_rounding);
   }
 
   template <typename XType,
             cpp::EnableIfType<cpp::IsSame<double, XType>::Value, int> = 0>
-  explicit MPFRNumber(XType x, int precision = 128)
-      : mpfr_precision(precision) {
+  explicit MPFRNumber(XType x, int precision = ExtraPrecision<XType>::VALUE,
+                      RoundingMode rounding = RoundingMode::Nearest)
+      : mpfr_precision(precision),
+        mpfr_rounding(get_mpfr_rounding_mode(rounding)) {
     mpfr_init2(value, mpfr_precision);
-    mpfr_set_d(value, x, MPFR_RNDN);
+    mpfr_set_d(value, x, mpfr_rounding);
   }
 
   template <typename XType,
             cpp::EnableIfType<cpp::IsSame<long double, XType>::Value, int> = 0>
-  explicit MPFRNumber(XType x, int precision = 128)
-      : mpfr_precision(precision) {
+  explicit MPFRNumber(XType x, int precision = ExtraPrecision<XType>::VALUE,
+                      RoundingMode rounding = RoundingMode::Nearest)
+      : mpfr_precision(precision),
+        mpfr_rounding(get_mpfr_rounding_mode(rounding)) {
     mpfr_init2(value, mpfr_precision);
-    mpfr_set_ld(value, x, MPFR_RNDN);
+    mpfr_set_ld(value, x, mpfr_rounding);
   }
 
   template <typename XType,
             cpp::EnableIfType<cpp::IsIntegral<XType>::Value, int> = 0>
-  explicit MPFRNumber(XType x, int precision = 128)
-      : mpfr_precision(precision) {
+  explicit MPFRNumber(XType x, int precision = ExtraPrecision<float>::VALUE,
+                      RoundingMode rounding = RoundingMode::Nearest)
+      : mpfr_precision(precision),
+        mpfr_rounding(get_mpfr_rounding_mode(rounding)) {
     mpfr_init2(value, mpfr_precision);
-    mpfr_set_sj(value, x, MPFR_RNDN);
+    mpfr_set_sj(value, x, mpfr_rounding);
   }
 
-  MPFRNumber(const MPFRNumber &other) : mpfr_precision(other.mpfr_precision) {
+  MPFRNumber(const MPFRNumber &other)
+      : mpfr_precision(other.mpfr_precision),
+        mpfr_rounding(other.mpfr_rounding) {
     mpfr_init2(value, mpfr_precision);
-    mpfr_set(value, other.value, MPFR_RNDN);
+    mpfr_set(value, other.value, mpfr_rounding);
   }
 
   ~MPFRNumber() { mpfr_clear(value); }
 
   MPFRNumber &operator=(const MPFRNumber &rhs) {
     mpfr_precision = rhs.mpfr_precision;
-    mpfr_set(value, rhs.value, MPFR_RNDN);
+    mpfr_rounding = rhs.mpfr_rounding;
+    mpfr_set(value, rhs.value, mpfr_rounding);
     return *this;
   }
 
   MPFRNumber abs() const {
-    MPFRNumber result;
-    mpfr_abs(result.value, value, MPFR_RNDN);
+    MPFRNumber result(*this);
+    mpfr_abs(result.value, value, mpfr_rounding);
     return result;
   }
 
   MPFRNumber ceil() const {
-    MPFRNumber result;
+    MPFRNumber result(*this);
     mpfr_ceil(result.value, value);
     return result;
   }
 
   MPFRNumber cos() const {
-    MPFRNumber result;
-    mpfr_cos(result.value, value, MPFR_RNDN);
+    MPFRNumber result(*this);
+    mpfr_cos(result.value, value, mpfr_rounding);
     return result;
   }
 
   MPFRNumber exp() const {
-    MPFRNumber result;
-    mpfr_exp(result.value, value, MPFR_RNDN);
+    MPFRNumber result(*this);
+    mpfr_exp(result.value, value, mpfr_rounding);
     return result;
   }
 
   MPFRNumber exp2() const {
-    MPFRNumber result;
-    mpfr_exp2(result.value, value, MPFR_RNDN);
+    MPFRNumber result(*this);
+    mpfr_exp2(result.value, value, mpfr_rounding);
     return result;
   }
 
   MPFRNumber expm1() const {
-    MPFRNumber result;
-    mpfr_expm1(result.value, value, MPFR_RNDN);
+    MPFRNumber result(*this);
+    mpfr_expm1(result.value, value, mpfr_rounding);
     return result;
   }
 
   MPFRNumber floor() const {
-    MPFRNumber result;
+    MPFRNumber result(*this);
     mpfr_floor(result.value, value);
     return result;
   }
 
   MPFRNumber frexp(int &exp) {
-    MPFRNumber result;
+    MPFRNumber result(*this);
     mpfr_exp_t resultExp;
-    mpfr_frexp(&resultExp, result.value, value, MPFR_RNDN);
+    mpfr_frexp(&resultExp, result.value, value, mpfr_rounding);
     exp = resultExp;
     return result;
   }
 
   MPFRNumber hypot(const MPFRNumber &b) {
-    MPFRNumber result;
-    mpfr_hypot(result.value, value, b.value, MPFR_RNDN);
+    MPFRNumber result(*this);
+    mpfr_hypot(result.value, value, b.value, mpfr_rounding);
     return result;
   }
 
   MPFRNumber log() const {
-    MPFRNumber result;
-    mpfr_log(result.value, value, MPFR_RNDN);
+    MPFRNumber result(*this);
+    mpfr_log(result.value, value, mpfr_rounding);
     return result;
   }
 
   MPFRNumber remquo(const MPFRNumber &divisor, int &quotient) {
-    MPFRNumber remainder;
+    MPFRNumber remainder(*this);
     long q;
-    mpfr_remquo(remainder.value, &q, value, divisor.value, MPFR_RNDN);
+    mpfr_remquo(remainder.value, &q, value, divisor.value, mpfr_rounding);
     quotient = q;
     return remainder;
   }
 
   MPFRNumber round() const {
-    MPFRNumber result;
+    MPFRNumber result(*this);
     mpfr_round(result.value, value);
     return result;
   }
 
-  bool roung_to_long(long &result) const {
+  bool round_to_long(long &result) const {
     // We first calculate the rounded value. This way, when converting
     // to long using mpfr_get_si, the rounding direction of MPFR_RNDN
     // (or any other rounding mode), does not have an influence.
     MPFRNumber roundedValue = round();
     mpfr_clear_erangeflag();
     result = mpfr_get_si(roundedValue.value, MPFR_RNDN);
     return mpfr_erangeflag_p();
   }
 
-  bool roung_to_long(mpfr_rnd_t rnd, long &result) const {
-    MPFRNumber rint_result;
+  bool round_to_long(mpfr_rnd_t rnd, long &result) const {
+    MPFRNumber rint_result(*this);
     mpfr_rint(rint_result.value, value, rnd);
-    return rint_result.roung_to_long(result);
+    return rint_result.round_to_long(result);
   }
 
   MPFRNumber rint(mpfr_rnd_t rnd) const {
-    MPFRNumber result;
+    MPFRNumber result(*this);
     mpfr_rint(result.value, value, rnd);
     return result;
   }
 
   MPFRNumber mod_2pi() const {
     MPFRNumber result(0.0, 1280);
     MPFRNumber _2pi(0.0, 1280);
     mpfr_const_pi(_2pi.value, MPFR_RNDN);
MPFRNumber mod_pi_over_4() const {
     MPFRNumber pi_over_4(0.0, 1280);
     mpfr_const_pi(pi_over_4.value, MPFR_RNDN);
     mpfr_mul_d(pi_over_4.value, pi_over_4.value, 0.25, MPFR_RNDN);
     mpfr_fmod(result.value, value, pi_over_4.value, MPFR_RNDN);
     return result;
   }
 
   MPFRNumber sin() const {
-    MPFRNumber result;
-    mpfr_sin(result.value, value, MPFR_RNDN);
+    MPFRNumber result(*this);
+    mpfr_sin(result.value, value, mpfr_rounding);
     return result;
   }
 
   MPFRNumber sqrt() const {
-    MPFRNumber result;
-    mpfr_sqrt(result.value, value, MPFR_RNDN);
+    MPFRNumber result(*this);
+    mpfr_sqrt(result.value, value, mpfr_rounding);
     return result;
   }
 
   MPFRNumber tan() const {
-    MPFRNumber result;
-    mpfr_tan(result.value, value, MPFR_RNDN);
+    MPFRNumber result(*this);
+    mpfr_tan(result.value, value, mpfr_rounding);
     return result;
   }
 
   MPFRNumber trunc() const {
-    MPFRNumber result;
+    MPFRNumber result(*this);
     mpfr_trunc(result.value, value);
     return result;
   }
 
   MPFRNumber fma(const MPFRNumber &b, const MPFRNumber &c) {
     MPFRNumber result(*this);
-    mpfr_fma(result.value, value, b.value, c.value, MPFR_RNDN);
+    mpfr_fma(result.value, value, b.value, c.value, mpfr_rounding);
     return result;
   }
 
   std::string str() const {
     // 200 bytes should be more than sufficient to hold a 100-digit number
     // plus additional bytes for the decimal point, '-' sign etc.
     constexpr size_t printBufSize = 200;
     char buffer[printBufSize];
     mpfr_snprintf(buffer, printBufSize, "%100.50Rf", value);
     cpp::StringView view(buffer);
     view = view.trim(' ');
     return std::string(view.data());
   }
 
   // These functions are useful for debugging.
   template <typename T> T as() const;
 
-  template <> float as<float>() const { return mpfr_get_flt(value, MPFR_RNDN); }
-  template <> double as<double>() const { return mpfr_get_d(value, MPFR_RNDN); }
+  template <> float as<float>() const {
+    return mpfr_get_flt(value, mpfr_rounding);
+  }
+  template <> double as<double>() const {
+    return mpfr_get_d(value, mpfr_rounding);
+  }
   template <> long double as<long double>() const {
-    return mpfr_get_ld(value, MPFR_RNDN);
+    return mpfr_get_ld(value, mpfr_rounding);
   }
 
   void dump(const char *msg) const { mpfr_printf("%s%.128Rf\n", msg, value); }
 
   // Return the ULP (units-in-the-last-place) difference between the
   // stored MPFR and a floating point number.
   //
   // We define ULP difference as follows:
cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, double> ulp(T input) {
     return minMPFR.as<double>();
   }
 };
 
 namespace internal {
 
 template <typename InputType>
 cpp::EnableIfType<cpp::IsFloatingPointType<InputType>::Value, MPFRNumber>
-unary_operation(Operation op, InputType input) {
-  MPFRNumber mpfrInput(input);
+unary_operation(Operation op, InputType input, unsigned int precision,
+                RoundingMode rounding) {
+  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::Exp:
case Operation::Trunc:
     return mpfrInput.trunc();
   default:
     __builtin_unreachable();
   }
 }
 
 template <typename InputType>
 cpp::EnableIfType<cpp::IsFloatingPointType<InputType>::Value, MPFRNumber>
-unary_operation_two_outputs(Operation op, InputType input, int &output) {
-  MPFRNumber mpfrInput(input);
+unary_operation_two_outputs(Operation op, InputType input, int &output,
+                            unsigned int precision, RoundingMode rounding) {
+  MPFRNumber mpfrInput(input, precision, rounding);
   switch (op) {
   case Operation::Frexp:
     return mpfrInput.frexp(output);
   default:
     __builtin_unreachable();
   }
 }
 
 template <typename InputType>
 cpp::EnableIfType<cpp::IsFloatingPointType<InputType>::Value, MPFRNumber>
-binary_operation_one_output(Operation op, InputType x, InputType y) {
-  MPFRNumber inputX(x), inputY(y);
+binary_operation_one_output(Operation op, InputType x, InputType y,
+                            unsigned int precision, RoundingMode rounding) {
+  MPFRNumber inputX(x, precision, rounding);
+  MPFRNumber inputY(y, precision, rounding);
   switch (op) {
   case Operation::Hypot:
     return inputX.hypot(inputY);
   default:
     __builtin_unreachable();
   }
 }
 
 template <typename InputType>
 cpp::EnableIfType<cpp::IsFloatingPointType<InputType>::Value, MPFRNumber>
 binary_operation_two_outputs(Operation op, InputType x, InputType y,
-                             int &output) {
-  MPFRNumber inputX(x), inputY(y);
+                             int &output, unsigned int precision,
+                             RoundingMode rounding) {
+  MPFRNumber inputX(x, precision, rounding);
+  MPFRNumber inputY(y, precision, rounding);
   switch (op) {
   case Operation::RemQuo:
     return inputX.remquo(inputY, output);
   default:
     __builtin_unreachable();
   }
 }
 
 template <typename InputType>
 cpp::EnableIfType<cpp::IsFloatingPointType<InputType>::Value, MPFRNumber>
 ternary_operation_one_output(Operation op, InputType x, InputType y,
-                             InputType z) {
+                             InputType z, unsigned int precision,
+                             RoundingMode rounding) {
   // For FMA function, we just need to compare with the mpfr_fma with the same
   // precision as InputType.  Using higher precision as the intermediate results
   // to compare might incorrectly fail due to double-rounding errors.
-  constexpr unsigned int prec = Precision<InputType>::VALUE;
-  MPFRNumber inputX(x, prec), inputY(y, prec), inputZ(z, prec);
+  MPFRNumber inputX(x, precision, rounding);
+  MPFRNumber inputY(y, precision, rounding);
+  MPFRNumber inputZ(z, precision, rounding);
   switch (op) {
   case Operation::Fma:
     return inputX.fma(inputY, inputZ);
   default:
     __builtin_unreachable();
   }
 }
 
 template <typename T>
 void explain_unary_operation_single_output_error(Operation op, T input,
                                                  T matchValue,
+                                                 double ulp_tolerance,
+                                                 RoundingMode rounding,
                                                  testutils::StreamWrapper &OS) {
-  MPFRNumber mpfrInput(input);
-  MPFRNumber mpfr_result = unary_operation(op, input);
+  unsigned int precision = get_precision<T>(ulp_tolerance);
+  MPFRNumber mpfrInput(input, precision);
+  MPFRNumber mpfr_result;
+  mpfr_result = unary_operation(op, input, precision, rounding);
   MPFRNumber mpfrMatchValue(matchValue);
-  FPBits<T> inputBits(input);
-  FPBits<T> matchBits(matchValue);
-  FPBits<T> mpfr_resultBits(mpfr_result.as<T>());
   OS << "Match value not within tolerance value of MPFR result:\n"
      << "  Input decimal: " << mpfrInput.str() << '\n';
   __llvm_libc::fputil::testing::describeValue("     Input bits: ", input, OS);
   OS << '\n' << "  Match decimal: " << mpfrMatchValue.str() << '\n';
   __llvm_libc::fputil::testing::describeValue("     Match bits: ", matchValue,
                                               OS);
   OS << '\n' << "    MPFR result: " << mpfr_result.str() << '\n';
   __llvm_libc::fputil::testing::describeValue(
       "   MPFR rounded: ", mpfr_result.as<T>(), OS);
   OS << '\n';
   OS << "      ULP error: " << std::to_string(mpfr_result.ulp(matchValue))
      << '\n';
 }
 
 template void
 explain_unary_operation_single_output_error<float>(Operation op, float, float,
+                                                   double, RoundingMode,
                                                    testutils::StreamWrapper &);
 template void explain_unary_operation_single_output_error<double>(
-    Operation op, double, double, testutils::StreamWrapper &);
+    Operation op, double, double, double, RoundingMode,
+    testutils::StreamWrapper &);
 template void explain_unary_operation_single_output_error<long double>(
-    Operation op, long double, long double, testutils::StreamWrapper &);
+    Operation op, long double, long double, double, RoundingMode,
+    testutils::StreamWrapper &);
 
 template <typename T>
 void explain_unary_operation_two_outputs_error(
     Operation op, T input, const BinaryOutput<T> &libc_result,
-    testutils::StreamWrapper &OS) {
-  MPFRNumber mpfrInput(input);
-  FPBits<T> inputBits(input);
+    double ulp_tolerance, RoundingMode rounding, testutils::StreamWrapper &OS) {
+  unsigned int precision = get_precision<T>(ulp_tolerance);
+  MPFRNumber mpfrInput(input, precision);
   int mpfrIntResult;
-  MPFRNumber mpfr_result =
-      unary_operation_two_outputs(op, input, mpfrIntResult);
+  MPFRNumber mpfr_result = unary_operation_two_outputs(op, input, mpfrIntResult,
+                                                       precision, rounding);
 
   if (mpfrIntResult != libc_result.i) {
     OS << "MPFR integral result: " << mpfrIntResult << '\n'
        << "Libc integral result: " << libc_result.i << '\n';
   } else {
     OS << "Integral result from libc matches integral result from MPFR.\n";
   }
 
void explain_unary_operation_two_outputs_error(
   __llvm_libc::fputil::testing::describeValue(
       "             MPFR rounded: ", mpfr_result.as<T>(), OS);
   OS << '\n'
      << "                ULP error: "
      << std::to_string(mpfr_result.ulp(libc_result.f)) << '\n';
 }
 
 template void explain_unary_operation_two_outputs_error<float>(
-    Operation, float, const BinaryOutput<float> &, testutils::StreamWrapper &);
-template void
-explain_unary_operation_two_outputs_error<double>(Operation, double,
-                                                  const BinaryOutput<double> &,
-                                                  testutils::StreamWrapper &);
-template void explain_unary_operation_two_outputs_error<long double>(
-    Operation, long double, const BinaryOutput<long double> &,
+    Operation, float, const BinaryOutput<float> &, double, RoundingMode,
+template void explain_unary_operation_two_outputs_error<double>(
+    Operation, double, const BinaryOutput<double> &, double, RoundingMode,
     testutils::StreamWrapper &);
+template void explain_unary_operation_two_outputs_error<long double>(
+    Operation, long double, const BinaryOutput<long double> &, double,
+    RoundingMode, testutils::StreamWrapper &);
 
 template <typename T>
 void explain_binary_operation_two_outputs_error(
     Operation op, const BinaryInput<T> &input,
-    const BinaryOutput<T> &libc_result, testutils::StreamWrapper &OS) {
-  MPFRNumber mpfrX(input.x);
-  MPFRNumber mpfrY(input.y);
-  FPBits<T> xbits(input.x);
-  FPBits<T> ybits(input.y);
+    const BinaryOutput<T> &libc_result, double ulp_tolerance,
+    RoundingMode rounding, testutils::StreamWrapper &OS) {
+  unsigned int precision = get_precision<T>(ulp_tolerance);
+  MPFRNumber mpfrX(input.x, precision);
+  MPFRNumber mpfrY(input.y, precision);
   int mpfrIntResult;
-  MPFRNumber mpfr_result =
-      binary_operation_two_outputs(op, input.x, input.y, mpfrIntResult);
+  MPFRNumber mpfr_result = binary_operation_two_outputs(
+      op, input.x, input.y, mpfrIntResult, precision, rounding);
   MPFRNumber mpfrMatchValue(libc_result.f);
 
   OS << "Input decimal: x: " << mpfrX.str() << " y: " << mpfrY.str() << '\n'
      << "MPFR integral result: " << mpfrIntResult << '\n'
      << "Libc integral result: " << libc_result.i << '\n'
      << "Libc floating point result: " << mpfrMatchValue.str() << '\n'
      << "               MPFR result: " << mpfr_result.str() << '\n';
   __llvm_libc::fputil::testing::describeValue(
       "Libc floating point result bits: ", libc_result.f, OS);
   __llvm_libc::fputil::testing::describeValue(
       "              MPFR rounded bits: ", mpfr_result.as<T>(), OS);
   OS << "ULP error: " << std::to_string(mpfr_result.ulp(libc_result.f)) << '\n';
 }
 
 template void explain_binary_operation_two_outputs_error<float>(
-    Operation, const BinaryInput<float> &, const BinaryOutput<float> &,
-    testutils::StreamWrapper &);
+    Operation, const BinaryInput<float> &, const BinaryOutput<float> &, double,
+    RoundingMode, testutils::StreamWrapper &);
 template void explain_binary_operation_two_outputs_error<double>(
     Operation, const BinaryInput<double> &, const BinaryOutput<double> &,
-    testutils::StreamWrapper &);
+    double, RoundingMode, testutils::StreamWrapper &);
 template void explain_binary_operation_two_outputs_error<long double>(
     Operation, const BinaryInput<long double> &,
-    const BinaryOutput<long double> &, testutils::StreamWrapper &);
+    const BinaryOutput<long double> &, double, RoundingMode,
+    testutils::StreamWrapper &);
 
 template <typename T>
-void explain_binary_operation_one_output_error(Operation op,
-                                               const BinaryInput<T> &input,
-                                               T libc_result,
-                                               testutils::StreamWrapper &OS) {
-  MPFRNumber mpfrX(input.x);
-  MPFRNumber mpfrY(input.y);
+void explain_binary_operation_one_output_error(
+    Operation op, const BinaryInput<T> &input, T libc_result,
+    double ulp_tolerance, RoundingMode rounding, testutils::StreamWrapper &OS) {
+  unsigned int precision = get_precision<T>(ulp_tolerance);
+  MPFRNumber mpfrX(input.x, precision);
+  MPFRNumber mpfrY(input.y, precision);
   FPBits<T> xbits(input.x);
   FPBits<T> ybits(input.y);
-  MPFRNumber mpfr_result = binary_operation_one_output(op, input.x, input.y);
+  MPFRNumber mpfr_result =
+      binary_operation_one_output(op, input.x, input.y, precision, rounding);
   MPFRNumber mpfrMatchValue(libc_result);
 
   OS << "Input decimal: x: " << mpfrX.str() << " y: " << mpfrY.str() << '\n';
   __llvm_libc::fputil::testing::describeValue("First input bits: ", input.x,
                                               OS);
   __llvm_libc::fputil::testing::describeValue("Second input bits: ", input.y,
                                               OS);
 
   OS << "Libc result: " << mpfrMatchValue.str() << '\n'
      << "MPFR result: " << mpfr_result.str() << '\n';
   __llvm_libc::fputil::testing::describeValue(
       "Libc floating point result bits: ", libc_result, OS);
   __llvm_libc::fputil::testing::describeValue(
       "              MPFR rounded bits: ", mpfr_result.as<T>(), OS);
   OS << "ULP error: " << std::to_string(mpfr_result.ulp(libc_result)) << '\n';
 }
 
 template void explain_binary_operation_one_output_error<float>(
-    Operation, const BinaryInput<float> &, float, testutils::StreamWrapper &);
+    Operation, const BinaryInput<float> &, float, double, RoundingMode,
+    testutils::StreamWrapper &);
 template void explain_binary_operation_one_output_error<double>(
-    Operation, const BinaryInput<double> &, double, testutils::StreamWrapper &);
-template void explain_binary_operation_one_output_error<long double>(
-    Operation, const BinaryInput<long double> &, long double,
+    Operation, const BinaryInput<double> &, double, double, RoundingMode,
     testutils::StreamWrapper &);
+template void explain_binary_operation_one_output_error<long double>(
+    Operation, const BinaryInput<long double> &, long double, double,
+    RoundingMode, testutils::StreamWrapper &);
 
 template <typename T>
-void explain_ternary_operation_one_output_error(Operation op,
-                                                const TernaryInput<T> &input,
-                                                T libc_result,
-                                                testutils::StreamWrapper &OS) {
-  MPFRNumber mpfrX(input.x, Precision<T>::VALUE);
-  MPFRNumber mpfrY(input.y, Precision<T>::VALUE);
-  MPFRNumber mpfrZ(input.z, Precision<T>::VALUE);
+void explain_ternary_operation_one_output_error(
+    Operation op, const TernaryInput<T> &input, T libc_result,
+    double ulp_tolerance, RoundingMode rounding, testutils::StreamWrapper &OS) {
+  unsigned int precision = get_precision<T>(ulp_tolerance);
+  MPFRNumber mpfrX(input.x, precision);
+  MPFRNumber mpfrY(input.y, precision);
+  MPFRNumber mpfrZ(input.z, precision);
   FPBits<T> xbits(input.x);
   FPBits<T> ybits(input.y);
   FPBits<T> zbits(input.z);
-  MPFRNumber mpfr_result =
-      ternary_operation_one_output(op, input.x, input.y, input.z);
+  MPFRNumber mpfr_result = ternary_operation_one_output(
+      op, input.x, input.y, input.z, precision, rounding);
   MPFRNumber mpfrMatchValue(libc_result);
 
   OS << "Input decimal: x: " << mpfrX.str() << " y: " << mpfrY.str()
      << " z: " << mpfrZ.str() << '\n';
   __llvm_libc::fputil::testing::describeValue("First input bits: ", input.x,
                                               OS);
   __llvm_libc::fputil::testing::describeValue("Second input bits: ", input.y,
                                               OS);
   __llvm_libc::fputil::testing::describeValue("Third input bits: ", input.z,
                                               OS);
 
   OS << "Libc result: " << mpfrMatchValue.str() << '\n'
      << "MPFR result: " << mpfr_result.str() << '\n';
   __llvm_libc::fputil::testing::describeValue(
       "Libc floating point result bits: ", libc_result, OS);
   __llvm_libc::fputil::testing::describeValue(
       "              MPFR rounded bits: ", mpfr_result.as<T>(), OS);
   OS << "ULP error: " << std::to_string(mpfr_result.ulp(libc_result)) << '\n';
 }
 
 template void explain_ternary_operation_one_output_error<float>(
-    Operation, const TernaryInput<float> &, float, testutils::StreamWrapper &);
+    Operation, const TernaryInput<float> &, float, double, RoundingMode,
+    testutils::StreamWrapper &);
 template void explain_ternary_operation_one_output_error<double>(
-    Operation, const TernaryInput<double> &, double,
+    Operation, const TernaryInput<double> &, double, double, RoundingMode,
     testutils::StreamWrapper &);
 template void explain_ternary_operation_one_output_error<long double>(
-    Operation, const TernaryInput<long double> &, long double,
-    testutils::StreamWrapper &);
+    Operation, const TernaryInput<long double> &, long double, double,
+    RoundingMode, testutils::StreamWrapper &);
 
 template <typename T>
 bool compare_unary_operation_single_output(Operation op, T input, T libc_result,
-                                           double ulp_error) {
-  // If the ulp error is exactly 0.5 (i.e a tie), we would check that the result
-  // is rounded to the nearest even.
-  MPFRNumber mpfr_result = unary_operation(op, input);
+                                           double ulp_tolerance,
+                                           RoundingMode rounding) {
+  unsigned int precision = get_precision<T>(ulp_tolerance);
+  MPFRNumber mpfr_result;
+  mpfr_result = unary_operation(op, input, precision, rounding);
   double ulp = mpfr_result.ulp(libc_result);
-  bool bits_are_even = ((FPBits<T>(libc_result).uintval() & 1) == 0);
-  return (ulp < ulp_error) ||
-         ((ulp == ulp_error) && ((ulp != 0.5) || bits_are_even));
+  return (ulp <= ulp_tolerance);
 }
 
 template bool compare_unary_operation_single_output<float>(Operation, float,
-                                                           float, double);
+                                                           float, double,
+                                                           RoundingMode);
 template bool compare_unary_operation_single_output<double>(Operation, double,
-                                                            double, double);
-template bool compare_unary_operation_single_output<long double>(Operation,
-                                                                 long double,
-                                                                 long double,
-                                                                 double);
+                                                            double, double,
+                                                            RoundingMode);
+template bool compare_unary_operation_single_output<long double>(
+    Operation, long double, long double, double, RoundingMode);
 
 template <typename T>
 bool compare_unary_operation_two_outputs(Operation op, T input,
                                          const BinaryOutput<T> &libc_result,
-                                         double ulp_error) {
+                                         double ulp_tolerance,
+                                         RoundingMode rounding) {
   int mpfrIntResult;
-  MPFRNumber mpfr_result =
-      unary_operation_two_outputs(op, input, mpfrIntResult);
+  unsigned int precision = get_precision<T>(ulp_tolerance);
+  MPFRNumber mpfr_result = unary_operation_two_outputs(op, input, mpfrIntResult,
+                                                       precision, rounding);
   double ulp = mpfr_result.ulp(libc_result.f);
 
   if (mpfrIntResult != libc_result.i)
     return false;
 
-  bool bits_are_even = ((FPBits<T>(libc_result.f).uintval() & 1) == 0);
-  return (ulp < ulp_error) ||
-         ((ulp == ulp_error) && ((ulp != 0.5) || bits_are_even));
+  return (ulp <= ulp_tolerance);
 }
 
-template bool
-compare_unary_operation_two_outputs<float>(Operation, float,
-                                           const BinaryOutput<float> &, double);
+template bool compare_unary_operation_two_outputs<float>(
+    Operation, float, const BinaryOutput<float> &, double, RoundingMode);
 template bool compare_unary_operation_two_outputs<double>(
-    Operation, double, const BinaryOutput<double> &, double);
+    Operation, double, const BinaryOutput<double> &, double, RoundingMode);
 template bool compare_unary_operation_two_outputs<long double>(
-    Operation, long double, const BinaryOutput<long double> &, double);
+    Operation, long double, const BinaryOutput<long double> &, double,
+    RoundingMode);
 
 template <typename T>
 bool compare_binary_operation_two_outputs(Operation op,
                                           const BinaryInput<T> &input,
                                           const BinaryOutput<T> &libc_result,
-                                          double ulp_error) {
+                                          double ulp_tolerance,
+                                          RoundingMode rounding) {
   int mpfrIntResult;
-  MPFRNumber mpfr_result =
-      binary_operation_two_outputs(op, input.x, input.y, mpfrIntResult);
+  unsigned int precision = get_precision<T>(ulp_tolerance);
+  MPFRNumber mpfr_result = binary_operation_two_outputs(
+      op, input.x, input.y, mpfrIntResult, precision, rounding);
   double ulp = mpfr_result.ulp(libc_result.f);
 
   if (mpfrIntResult != libc_result.i) {
     if (op == Operation::RemQuo) {
       if ((0x7 & mpfrIntResult) != (0x7 & libc_result.i))
         return false;
     } else {
       return false;
     }
   }
 
-  bool bits_are_even = ((FPBits<T>(libc_result.f).uintval() & 1) == 0);
-  return (ulp < ulp_error) ||
-         ((ulp == ulp_error) && ((ulp != 0.5) || bits_are_even));
+  return (ulp <= ulp_tolerance);
 }
 
 template bool compare_binary_operation_two_outputs<float>(
-    Operation, const BinaryInput<float> &, const BinaryOutput<float> &, double);
+    Operation, const BinaryInput<float> &, const BinaryOutput<float> &, double,
+    RoundingMode);
 template bool compare_binary_operation_two_outputs<double>(
     Operation, const BinaryInput<double> &, const BinaryOutput<double> &,
-    double);
+    double, RoundingMode);
 template bool compare_binary_operation_two_outputs<long double>(
     Operation, const BinaryInput<long double> &,
-    const BinaryOutput<long double> &, double);
+    const BinaryOutput<long double> &, double, RoundingMode);
 
 template <typename T>
 bool compare_binary_operation_one_output(Operation op,
                                          const BinaryInput<T> &input,
-                                         T libc_result, double ulp_error) {
-  MPFRNumber mpfr_result = binary_operation_one_output(op, input.x, input.y);
+                                         T libc_result, double ulp_tolerance,
+                                         RoundingMode rounding) {
+  unsigned int precision = get_precision<T>(ulp_tolerance);
+  MPFRNumber mpfr_result =
+      binary_operation_one_output(op, input.x, input.y, precision, rounding);
   double ulp = mpfr_result.ulp(libc_result);
 
-  bool bits_are_even = ((FPBits<T>(libc_result).uintval() & 1) == 0);
-  return (ulp < ulp_error) ||
-         ((ulp == ulp_error) && ((ulp != 0.5) || bits_are_even));
+  return (ulp <= ulp_tolerance);
 }
 
 template bool compare_binary_operation_one_output<float>(
-    Operation, const BinaryInput<float> &, float, double);
+    Operation, const BinaryInput<float> &, float, double, RoundingMode);
 template bool compare_binary_operation_one_output<double>(
-    Operation, const BinaryInput<double> &, double, double);
+    Operation, const BinaryInput<double> &, double, double, RoundingMode);
 template bool compare_binary_operation_one_output<long double>(
-    Operation, const BinaryInput<long double> &, long double, double);
+    Operation, const BinaryInput<long double> &, long double, double,
+    RoundingMode);
 
 template <typename T>
 bool compare_ternary_operation_one_output(Operation op,
                                           const TernaryInput<T> &input,
-                                          T libc_result, double ulp_error) {
-  MPFRNumber mpfr_result =
-      ternary_operation_one_output(op, input.x, input.y, input.z);
+                                          T libc_result, double ulp_tolerance,
+                                          RoundingMode rounding) {
+  unsigned int precision = get_precision<T>(ulp_tolerance);
+  MPFRNumber mpfr_result = ternary_operation_one_output(
+      op, input.x, input.y, input.z, precision, rounding);
   double ulp = mpfr_result.ulp(libc_result);
 
-  bool bits_are_even = ((FPBits<T>(libc_result).uintval() & 1) == 0);
-  return (ulp < ulp_error) ||
-         ((ulp == ulp_error) && ((ulp != 0.5) || bits_are_even));
+  return (ulp <= ulp_tolerance);
 }
 
 template bool compare_ternary_operation_one_output<float>(
-    Operation, const TernaryInput<float> &, float, double);
+    Operation, const TernaryInput<float> &, float, double, RoundingMode);
 template bool compare_ternary_operation_one_output<double>(
-    Operation, const TernaryInput<double> &, double, double);
+    Operation, const TernaryInput<double> &, double, double, RoundingMode);
 template bool compare_ternary_operation_one_output<long double>(
-    Operation, const TernaryInput<long double> &, long double, double);
-
-static mpfr_rnd_t get_mpfr_rounding_mode(RoundingMode mode) {
-  switch (mode) {
-  case RoundingMode::Upward:
-    return MPFR_RNDU;
-    break;
-  case RoundingMode::Downward:
-    return MPFR_RNDD;
-    break;
-  case RoundingMode::TowardZero:
-    return MPFR_RNDZ;
-    break;
-  case RoundingMode::Nearest:
-    return MPFR_RNDN;
-    break;
-  }
-}
+    Operation, const TernaryInput<long double> &, long double, double,
+    RoundingMode);
 
 } // namespace internal
 
 template <typename T> bool round_to_long(T x, long &result) {
   MPFRNumber mpfr(x);
-  return mpfr.roung_to_long(result);
+  return mpfr.round_to_long(result);
 }
 
 template bool round_to_long<float>(float, long &);
 template bool round_to_long<double>(double, long &);
 template bool round_to_long<long double>(long double, long &);
 
 template <typename T> bool round_to_long(T x, RoundingMode mode, long &result) {
   MPFRNumber mpfr(x);
-  return mpfr.roung_to_long(internal::get_mpfr_rounding_mode(mode), result);
+  return mpfr.round_to_long(get_mpfr_rounding_mode(mode), result);
 }
 
 template bool round_to_long<float>(float, RoundingMode, long &);
 template bool round_to_long<double>(double, RoundingMode, long &);
 template bool round_to_long<long double>(long double, RoundingMode, long &);
 
 template <typename T> T round(T x, RoundingMode mode) {
   MPFRNumber mpfr(x);
-  MPFRNumber result = mpfr.rint(internal::get_mpfr_rounding_mode(mode));
+  MPFRNumber result = mpfr.rint(get_mpfr_rounding_mode(mode));
   return result.as<T>();
 }
 
 template float round<float>(float, RoundingMode);
 template double round<double>(double, RoundingMode);
 template long double round<long double>(long double, RoundingMode);
 
 } // namespace mpfr
 } // namespace testing
 } // namespace __llvm_libc