[libc] Add implementations of rounding functions which depend rounding mode.

[sivachandra]

Summary

Namely, implementations for rint, rintf, rintl, lrint, lrintf, lrintl,
llrint, llrintf and llrintl have been added.

libc/config/linux/x86_64/entrypoints.txt

set(TARGET_LIBM_ENTRYPOINTS
     libc.src.math.hypot
     libc.src.math.hypotf
     libc.src.math.ilogb
     libc.src.math.ilogbf
     libc.src.math.ilogbl
     libc.src.math.ldexp
     libc.src.math.ldexpf
     libc.src.math.ldexpl
+    libc.src.math.llrint
+    libc.src.math.llrintf
+    libc.src.math.llrintl
     libc.src.math.llround
     libc.src.math.llroundf
     libc.src.math.llroundl
     libc.src.math.logb
     libc.src.math.logbf
     libc.src.math.logbl
+    libc.src.math.lrint
+    libc.src.math.lrintf
+    libc.src.math.lrintl
     libc.src.math.lround
     libc.src.math.lroundf
     libc.src.math.lroundl
     libc.src.math.modf
     libc.src.math.modff
     libc.src.math.modfl
     libc.src.math.remainderf
     libc.src.math.remainder
     libc.src.math.remainderl
     libc.src.math.remquof
     libc.src.math.remquo
     libc.src.math.remquol
+    libc.src.math.rint
+    libc.src.math.rintf
+    libc.src.math.rintl
     libc.src.math.round
     libc.src.math.roundf
     libc.src.math.roundl
     libc.src.math.sincosf
     libc.src.math.sinf
     libc.src.math.sqrt
     libc.src.math.sqrtf
     libc.src.math.sqrtl
     libc.src.math.trunc
     libc.src.math.truncf
     libc.src.math.truncl
 )

libc/spec/stdc.td

HeaderSpec Math = HeaderSpec<
           FunctionSpec<"lround", RetValSpec<LongType>, [ArgSpec<DoubleType>]>,
           FunctionSpec<"lroundf", RetValSpec<LongType>, [ArgSpec<FloatType>]>,
           FunctionSpec<"lroundl", RetValSpec<LongType>, [ArgSpec<LongDoubleType>]>,
 
           FunctionSpec<"llround", RetValSpec<LongLongType>, [ArgSpec<DoubleType>]>,
           FunctionSpec<"llroundf", RetValSpec<LongLongType>, [ArgSpec<FloatType>]>,
           FunctionSpec<"llroundl", RetValSpec<LongLongType>, [ArgSpec<LongDoubleType>]>,
 
+          FunctionSpec<"rint", RetValSpec<DoubleType>, [ArgSpec<DoubleType>]>,
+          FunctionSpec<"rintf", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
+          FunctionSpec<"rintl", RetValSpec<LongDoubleType>, [ArgSpec<LongDoubleType>]>,
+
+          FunctionSpec<"lrint", RetValSpec<LongType>, [ArgSpec<DoubleType>]>,
+          FunctionSpec<"lrintf", RetValSpec<LongType>, [ArgSpec<FloatType>]>,
+          FunctionSpec<"lrintl", RetValSpec<LongType>, [ArgSpec<LongDoubleType>]>,
+
+          FunctionSpec<"llrint", RetValSpec<LongLongType>, [ArgSpec<DoubleType>]>,
+          FunctionSpec<"llrintf", RetValSpec<LongLongType>, [ArgSpec<FloatType>]>,
+          FunctionSpec<"llrintl", RetValSpec<LongLongType>, [ArgSpec<LongDoubleType>]>,
+
           FunctionSpec<"sqrt", RetValSpec<DoubleType>, [ArgSpec<DoubleType>]>,
           FunctionSpec<"sqrtf", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
           FunctionSpec<"sqrtl", RetValSpec<LongDoubleType>, [ArgSpec<LongDoubleType>]>,
 
           FunctionSpec<"trunc", RetValSpec<DoubleType>, [ArgSpec<DoubleType>]>,
           FunctionSpec<"truncf", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
           FunctionSpec<"truncl", RetValSpec<LongDoubleType>, [ArgSpec<LongDoubleType>]>,
       ]

libc/src/math/CMakeLists.txt

add_entrypoint_object(
   HDRS
     llroundl.h
   DEPENDS
     libc.utils.FPUtil.fputil
   COMPILE_OPTIONS
     -O2
 )
 
+add_entrypoint_object(
+  rint
+  SRCS
+    rint.cpp
+  HDRS
+    rint.h
+  DEPENDS
+    libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
+)
+
+add_entrypoint_object(
+  rintf
+  SRCS
+    rintf.cpp
+  HDRS
+    rintf.h
+  DEPENDS
+    libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
+)
+
+add_entrypoint_object(
+  rintl
+  SRCS
+    rintl.cpp
+  HDRS
+    rintl.h
+  DEPENDS
+    libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
+)
+
+add_entrypoint_object(
+  lrint
+  SRCS
+    lrint.cpp
+  HDRS
+    lrint.h
+  DEPENDS
+    libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
+)
+
+add_entrypoint_object(
+  lrintf
+  SRCS
+    lrintf.cpp
+  HDRS
+    lrintf.h
+  DEPENDS
+    libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
+)
+
+add_entrypoint_object(
+  lrintl
+  SRCS
+    lrintl.cpp
+  HDRS
+    lrintl.h
+  DEPENDS
+    libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
+)
+
+add_entrypoint_object(
+  llrint
+  SRCS
+    llrint.cpp
+  HDRS
+    llrint.h
+  DEPENDS
+    libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
+)
+
+add_entrypoint_object(
+  llrintf
+  SRCS
+    llrintf.cpp
+  HDRS
+    llrintf.h
+  DEPENDS
+    libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
+)
+
+add_entrypoint_object(
+  llrintl
+  SRCS
+    llrintl.cpp
+  HDRS
+    llrintl.h
+  DEPENDS
+    libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
+)
+
 add_object_library(
   exp_utils
   HDRS
     exp_utils.h
   SRCS
     exp_utils.cpp
   DEPENDS
     .math_utils

libc/src/math/llrint.h

+//===-- Implementation header for llrint ------------------------*- 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_LLRINT_H
+#define LLVM_LIBC_SRC_MATH_LLRINT_H
+
+namespace __llvm_libc {
+
+long long llrint(double x);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_MATH_LLRINT_H

libc/src/math/llrint.cpp

+//===-- Implementation of llrint 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/__support/common.h"
+#include "utils/FPUtil/NearestIntegerOperations.h"
+
+namespace __llvm_libc {
+
+long long LLVM_LIBC_ENTRYPOINT(llrint)(double x) {
+  return fputil::roundToSignedIntegerUsingCurrentRoundingMode<double,
+                                                              long long>(x);
+}
+
+} // namespace __llvm_libc

libc/src/math/llrintf.h

+//===-- Implementation header for llrintf -----------------------*- 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_LLRINTF_H
+#define LLVM_LIBC_SRC_MATH_LLRINTF_H
+
+namespace __llvm_libc {
+
+long long llrintf(float x);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_MATH_LLRINTF_H

libc/src/math/llrintf.cpp

+//===-- Implementation of llrintf 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/__support/common.h"
+#include "utils/FPUtil/NearestIntegerOperations.h"
+
+namespace __llvm_libc {
+
+long long LLVM_LIBC_ENTRYPOINT(llrintf)(float x) {
+  return fputil::roundToSignedIntegerUsingCurrentRoundingMode<float, long long>(
+      x);
+}
+
+} // namespace __llvm_libc

libc/src/math/llrintl.h

+//===-- Implementation header for llrintl -----------------------*- 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_LLRINTL_H
+#define LLVM_LIBC_SRC_MATH_LLRINTL_H
+
+namespace __llvm_libc {
+
+long long llrintl(long double x);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_MATH_LLRINTL_H

libc/src/math/llrintl.cpp

+//===-- Implementation of llrintl 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/__support/common.h"
+#include "utils/FPUtil/NearestIntegerOperations.h"
+
+namespace __llvm_libc {
+
+long long LLVM_LIBC_ENTRYPOINT(llrintl)(long double x) {
+  return fputil::roundToSignedIntegerUsingCurrentRoundingMode<long double,
+                                                              long long>(x);
+}
+
+} // namespace __llvm_libc

libc/src/math/lrint.h

+//===-- Implementation header for lrint -------------------------*- 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_LRINT_H
+#define LLVM_LIBC_SRC_MATH_LRINT_H
+
+namespace __llvm_libc {
+
+long lrint(double x);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_MATH_LRINT_H

libc/src/math/lrint.cpp

+//===-- Implementation of lrint 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/__support/common.h"
+#include "utils/FPUtil/NearestIntegerOperations.h"
+
+namespace __llvm_libc {
+
+long LLVM_LIBC_ENTRYPOINT(lrint)(double x) {
+  return fputil::roundToSignedIntegerUsingCurrentRoundingMode<double, long>(x);
+}
+
+} // namespace __llvm_libc

libc/src/math/lrintf.h

+//===-- Implementation header for lrintf ------------------------*- 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_LRINTF_H
+#define LLVM_LIBC_SRC_MATH_LRINTF_H
+
+namespace __llvm_libc {
+
+long lrintf(float x);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_MATH_LRINTF_H

libc/src/math/lrintf.cpp

+//===-- Implementation of lrintf 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/__support/common.h"
+#include "utils/FPUtil/NearestIntegerOperations.h"
+
+namespace __llvm_libc {
+
+long LLVM_LIBC_ENTRYPOINT(lrintf)(float x) {
+  return fputil::roundToSignedIntegerUsingCurrentRoundingMode<float, long>(x);
+}
+
+} // namespace __llvm_libc

libc/src/math/lrintl.h

+//===-- Implementation header for lrintl ------------------------*- 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_LRINTL_H
+#define LLVM_LIBC_SRC_MATH_LRINTL_H
+
+namespace __llvm_libc {
+
+long lrintl(long double x);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_MATH_LRINTL_H

libc/src/math/lrintl.cpp

+//===-- Implementation of lrintl 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/__support/common.h"
+#include "utils/FPUtil/NearestIntegerOperations.h"
+
+namespace __llvm_libc {
+
+long LLVM_LIBC_ENTRYPOINT(lrintl)(long double x) {
+  return fputil::roundToSignedIntegerUsingCurrentRoundingMode<long double,
+                                                              long>(x);
+}
+
+} // namespace __llvm_libc

libc/src/math/rint.h

+//===-- Implementation header for rint --------------------------*- 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_RINT_H
+#define LLVM_LIBC_SRC_MATH_RINT_H
+
+namespace __llvm_libc {
+
+double rint(double x);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_MATH_RINT_H

libc/src/math/rint.cpp

+//===-- Implementation of rint 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/__support/common.h"
+#include "utils/FPUtil/NearestIntegerOperations.h"
+
+namespace __llvm_libc {
+
+double LLVM_LIBC_ENTRYPOINT(rint)(double x) {
+  return fputil::roundUsingCurrentRoundingMode(x);
+}
+
+} // namespace __llvm_libc

libc/src/math/rintf.h

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

libc/src/math/rintf.cpp

+//===-- Implementation of rintf 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/__support/common.h"
+#include "utils/FPUtil/NearestIntegerOperations.h"
+
+namespace __llvm_libc {
+
+float LLVM_LIBC_ENTRYPOINT(rintf)(float x) {
+  return fputil::roundUsingCurrentRoundingMode(x);
+}
+
+} // namespace __llvm_libc

libc/src/math/rintl.h

+//===-- Implementation header for rintl -------------------------*- 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_RINTL_H
+#define LLVM_LIBC_SRC_MATH_RINTL_H
+
+namespace __llvm_libc {
+
+long double rintl(long double x);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_MATH_RINTL_H

libc/src/math/rintl.cpp

+//===-- Implementation of rintl 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/__support/common.h"
+#include "utils/FPUtil/NearestIntegerOperations.h"
+
+namespace __llvm_libc {
+
+long double LLVM_LIBC_ENTRYPOINT(rintl)(long double x) {
+  return fputil::roundUsingCurrentRoundingMode(x);
+}
+
+} // namespace __llvm_libc

libc/test/src/math/CMakeLists.txt

DEPENDS
     libc.src.fenv.feclearexcept
     libc.src.fenv.feraiseexcept
     libc.src.fenv.fetestexcept
     libc.src.math.llroundl
     libc.utils.FPUtil.fputil
 )
 
 add_fp_unittest(
+  rint_test
+  NEED_MPFR
+  SUITE
+    libc_math_unittests
+  SRCS
+    rint_test.cpp
+  HDRS
+    RIntTest.h
+  DEPENDS
+    libc.include.math
+    libc.src.math.rint
+    libc.utils.FPUtil.fputil
+)
+
+add_fp_unittest(
+  rintf_test
+  NEED_MPFR
+  SUITE
+    libc_math_unittests
+  SRCS
+    rintf_test.cpp
+  HDRS
+    RIntTest.h
+  DEPENDS
+    libc.include.math
+    libc.src.math.rintf
+    libc.utils.FPUtil.fputil
+)
+
+add_fp_unittest(
+  rintl_test
+  NEED_MPFR
+  SUITE
+    libc_math_unittests
+  SRCS
+    rintl_test.cpp
+  HDRS
+    RIntTest.h
+  DEPENDS
+    libc.include.math
+    libc.src.math.rintl
+    libc.utils.FPUtil.fputil
+)
+
+add_fp_unittest(
+  lrint_test
+  NEED_MPFR
+  SUITE
+    libc_math_unittests
+  SRCS
+    lrint_test.cpp
+  HDRS
+    RoundToIntegerTest.h
+  DEPENDS
+    libc.include.math
+    libc.src.math.lrint
+    libc.utils.FPUtil.fputil
+)
+
+add_fp_unittest(
+  lrintf_test
+  NEED_MPFR
+  SUITE
+    libc_math_unittests
+  SRCS
+    lrintf_test.cpp
+  HDRS
+    RoundToIntegerTest.h
+  DEPENDS
+    libc.include.math
+    libc.src.math.lrintf
+    libc.utils.FPUtil.fputil
+)
+
+add_fp_unittest(
+  lrintl_test
+  NEED_MPFR
+  SUITE
+    libc_math_unittests
+  SRCS
+    lrintl_test.cpp
+  HDRS
+    RoundToIntegerTest.h
+  DEPENDS
+    libc.include.math
+    libc.src.math.lrintl
+    libc.utils.FPUtil.fputil
+)
+
+add_fp_unittest(
+  llrint_test
+  NEED_MPFR
+  SUITE
+    libc_math_unittests
+  SRCS
+    llrint_test.cpp
+  HDRS
+    RoundToIntegerTest.h
+  DEPENDS
+    libc.include.math
+    libc.src.math.llrint
+    libc.utils.FPUtil.fputil
+)
+
+add_fp_unittest(
+  llrintf_test
+  NEED_MPFR
+  SUITE
+    libc_math_unittests
+  SRCS
+    llrintf_test.cpp
+  HDRS
+    RoundToIntegerTest.h
+  DEPENDS
+    libc.include.math
+    libc.src.math.llrintf
+    libc.utils.FPUtil.fputil
+)
+
+add_fp_unittest(
+  llrintl_test
+  NEED_MPFR
+  SUITE
+    libc_math_unittests
+  SRCS
+    llrintl_test.cpp
+  HDRS
+    RoundToIntegerTest.h
+  DEPENDS
+    libc.include.math
+    libc.src.math.llrintl
+    libc.utils.FPUtil.fputil
+)
+
+add_fp_unittest(
   expf_test
   NEED_MPFR
   SUITE
     libc_math_unittests
   SRCS
     expf_test.cpp
   DEPENDS
     libc.include.errno

libc/test/src/math/RIntTest.h

+//===-- Utility class to test different flavors of rint ---------*- 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_TEST_SRC_MATH_RINTTEST_H
+#define LLVM_LIBC_TEST_SRC_MATH_RINTTEST_H
+
+#include "utils/FPUtil/FEnv.h"
+#include "utils/FPUtil/FPBits.h"
+#include "utils/FPUtil/TestHelpers.h"
+#include "utils/MPFRWrapper/MPFRUtils.h"
+#include "utils/UnitTest/Test.h"
+
+#include <fenv.h>
+#include <math.h>
+#include <stdio.h>
+
+namespace mpfr = __llvm_libc::testing::mpfr;
+
+static constexpr int roundingModes[4] = {FE_UPWARD, FE_DOWNWARD, FE_TOWARDZERO,
+                                         FE_TONEAREST};
+
+template <typename T>
+class RIntTestTemplate : public __llvm_libc::testing::Test {
+public:
+  typedef T (*RIntFunc)(T);
+
+private:
+  using FPBits = __llvm_libc::fputil::FPBits<T>;
+  using UIntType = typename FPBits::UIntType;
+
+  const T zero = FPBits::zero();
+  const T negZero = FPBits::negZero();
+  const T inf = FPBits::inf();
+  const T negInf = FPBits::negInf();
+  const T nan = FPBits::buildNaN(1);
+
+  static inline mpfr::RoundingMode toMPFRRoundingMode(int mode) {
+    switch (mode) {
+    case FE_UPWARD:
+      return mpfr::RoundingMode::Upward;
+    case FE_DOWNWARD:
+      return mpfr::RoundingMode::Downward;
+    case FE_TOWARDZERO:
+      return mpfr::RoundingMode::TowardZero;
+    case FE_TONEAREST:
+      return mpfr::RoundingMode::Nearest;
+    default:
+      __builtin_unreachable();
+    }
+  }
+
+public:
+  void testSpecialNumbers(RIntFunc func) {
+    for (int mode : roundingModes) {
+      __llvm_libc::fputil::setRound(mode);
+      ASSERT_FP_EQ(inf, func(inf));
+      ASSERT_FP_EQ(negInf, func(negInf));
+      ASSERT_FP_EQ(nan, func(nan));
+      ASSERT_FP_EQ(zero, func(zero));
+      ASSERT_FP_EQ(negZero, func(negZero));
+    }
+  }
+
+  void testRoundNumbers(RIntFunc func) {
+    for (int mode : roundingModes) {
+      __llvm_libc::fputil::setRound(mode);
+      mpfr::RoundingMode mpfrMode = toMPFRRoundingMode(mode);
+      ASSERT_FP_EQ(func(T(1.0)), mpfr::Round(T(1.0), mpfrMode));
+      ASSERT_FP_EQ(func(T(-1.0)), mpfr::Round(T(-1.0), mpfrMode));
+      ASSERT_FP_EQ(func(T(10.0)), mpfr::Round(T(10.0), mpfrMode));
+      ASSERT_FP_EQ(func(T(-10.0)), mpfr::Round(T(-10.0), mpfrMode));
+      ASSERT_FP_EQ(func(T(1234.0)), mpfr::Round(T(1234.0), mpfrMode));
+      ASSERT_FP_EQ(func(T(-1234.0)), mpfr::Round(T(-1234.0), mpfrMode));
+    }
+  }
+
+  void testFractions(RIntFunc func) {
+    for (int mode : roundingModes) {
+      __llvm_libc::fputil::setRound(mode);
+      mpfr::RoundingMode mpfrMode = toMPFRRoundingMode(mode);
+      ASSERT_FP_EQ(func(T(0.5)), mpfr::Round(T(0.5), mpfrMode));
+      ASSERT_FP_EQ(func(T(-0.5)), mpfr::Round(T(-0.5), mpfrMode));
+      ASSERT_FP_EQ(func(T(0.115)), mpfr::Round(T(0.115), mpfrMode));
+      ASSERT_FP_EQ(func(T(-0.115)), mpfr::Round(T(-0.115), mpfrMode));
+      ASSERT_FP_EQ(func(T(0.715)), mpfr::Round(T(0.715), mpfrMode));
+      ASSERT_FP_EQ(func(T(-0.715)), mpfr::Round(T(-0.715), mpfrMode));
+    }
+  }
+
+  void testSubnormalRange(RIntFunc func) {
+    constexpr UIntType count = 1000001;
+    constexpr UIntType step =
+        (FPBits::maxSubnormal - FPBits::minSubnormal) / count;
+    for (UIntType i = FPBits::minSubnormal; i <= FPBits::maxSubnormal;
+         i += step) {
+      T x = FPBits(i);
+      for (int mode : roundingModes) {
+        __llvm_libc::fputil::setRound(mode);
+        mpfr::RoundingMode mpfrMode = toMPFRRoundingMode(mode);
+        ASSERT_FP_EQ(func(x), mpfr::Round(x, mpfrMode));
+      }
+    }
+  }
+
+  void testNormalRange(RIntFunc func) {
+    constexpr UIntType count = 1000001;
+    constexpr UIntType step = (FPBits::maxNormal - FPBits::minNormal) / count;
+    for (UIntType i = FPBits::minNormal; i <= FPBits::maxNormal; i += step) {
+      T x = FPBits(i);
+      // In normal range on x86 platforms, the long double implicit 1 bit can be
+      // zero making the numbers NaN. We will skip them.
+      if (isnan(x)) {
+        continue;
+      }
+
+      for (int mode : roundingModes) {
+        __llvm_libc::fputil::setRound(mode);
+        mpfr::RoundingMode mpfrMode = toMPFRRoundingMode(mode);
+        ASSERT_FP_EQ(func(x), mpfr::Round(x, mpfrMode));
+      }
+    }
+  }
+};
+
+#define LIST_RINT_TESTS(F, func)                                               \
+  using RIntTest = RIntTestTemplate<F>;                                        \
+  TEST_F(RIntTest, specialNumbers) { testSpecialNumbers(&func); }              \
+  TEST_F(RIntTest, RoundNumbers) { testRoundNumbers(&func); }                  \
+  TEST_F(RIntTest, Fractions) { testFractions(&func); }                        \
+  TEST_F(RIntTest, SubnormalRange) { testSubnormalRange(&func); }              \
+  TEST_F(RIntTest, NormalRange) { testNormalRange(&func); }
+
+#endif // LLVM_LIBC_TEST_SRC_MATH_RINTTEST_H

libc/test/src/math/RoundToIntegerTest.h

 //===-- Utility class to test different flavors of [l|ll]round --*- 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_TEST_SRC_MATH_ROUNDTOINTEGERTEST_H
 #define LLVM_LIBC_TEST_SRC_MATH_ROUNDTOINTEGERTEST_H
 
 #include "src/errno/llvmlibc_errno.h"
-#include "src/fenv/feclearexcept.h"
-#include "src/fenv/feraiseexcept.h"
-#include "src/fenv/fetestexcept.h"
 #include "utils/FPUtil/FPBits.h"
 #include "utils/MPFRWrapper/MPFRUtils.h"
 #include "utils/UnitTest/Test.h"
 
 #include <math.h>
 #if math_errhandling & MATH_ERRNO
 #include <errno.h>
 #endif
 #if math_errhandling & MATH_ERREXCEPT
 #include "utils/FPUtil/FEnv.h"
 #endif
 
 namespace mpfr = __llvm_libc::testing::mpfr;
 
-template <typename F, typename I>
+static constexpr int roundingModes[4] = {FE_UPWARD, FE_DOWNWARD, FE_TOWARDZERO,
+                                         FE_TONEAREST};
+
+template <typename F, typename I, bool TestModes = false>
 class RoundToIntegerTestTemplate : public __llvm_libc::testing::Test {
 public:
   typedef I (*RoundToIntegerFunc)(F);
 
 private:
   using FPBits = __llvm_libc::fputil::FPBits<F>;
   using UIntType = typename FPBits::UIntType;
 
   const F zero = __llvm_libc::fputil::FPBits<F>::zero();
   const F negZero = __llvm_libc::fputil::FPBits<F>::negZero();
   const F inf = __llvm_libc::fputil::FPBits<F>::inf();
   const F negInf = __llvm_libc::fputil::FPBits<F>::negInf();
   const F nan = __llvm_libc::fputil::FPBits<F>::buildNaN(1);
   static constexpr I IntegerMin = I(1) << (sizeof(I) * 8 - 1);
   static constexpr I IntegerMax = -(IntegerMin + 1);
 
   void testOneInput(RoundToIntegerFunc func, F input, I expected,
                     bool expectError) {
 #if math_errhandling & MATH_ERRNO
     llvmlibc_errno = 0;
 #endif
 #if math_errhandling & MATH_ERREXCEPT
-    __llvm_libc::feclearexcept(FE_ALL_EXCEPT);
+    __llvm_libc::fputil::clearExcept(FE_ALL_EXCEPT);
 #endif
 
     ASSERT_EQ(func(input), expected);
 
     if (expectError) {
 #if math_errhandling & MATH_ERREXCEPT
-      ASSERT_EQ(__llvm_libc::fetestexcept(FE_ALL_EXCEPT), FE_INVALID);
+      ASSERT_EQ(__llvm_libc::fputil::testExcept(FE_ALL_EXCEPT), FE_INVALID);
 #endif
 #if math_errhandling & MATH_ERRNO
       ASSERT_EQ(llvmlibc_errno, EDOM);
 #endif
     } else {
 #if math_errhandling & MATH_ERREXCEPT
-      ASSERT_EQ(__llvm_libc::fetestexcept(FE_ALL_EXCEPT), 0);
+      ASSERT_EQ(__llvm_libc::fputil::testExcept(FE_ALL_EXCEPT), 0);
 #endif
 #if math_errhandling & MATH_ERRNO
       ASSERT_EQ(llvmlibc_errno, 0);
 #endif
     }
   }
 
+  static inline mpfr::RoundingMode toMPFRRoundingMode(int mode) {
+    switch (mode) {
+    case FE_UPWARD:
+      return mpfr::RoundingMode::Upward;
+    case FE_DOWNWARD:
+      return mpfr::RoundingMode::Downward;
+    case FE_TOWARDZERO:
+      return mpfr::RoundingMode::TowardZero;
+    case FE_TONEAREST:
+      return mpfr::RoundingMode::Nearest;
+    default:
+      __builtin_unreachable();
+    }
+  }
+
 public:
   void SetUp() override {
 #if math_errhandling & MATH_ERREXCEPT
     // We will disable all exceptions so that the test will not
     // crash with SIGFPE. We can still use fetestexcept to check
     // if the appropriate flag was raised.
     __llvm_libc::fputil::disableExcept(FE_ALL_EXCEPT);
 #endif
   }
 
-  void testInfinityAndNaN(RoundToIntegerFunc func) {
+  void doInfinityAndNaNTest(RoundToIntegerFunc func) {
     testOneInput(func, inf, IntegerMax, true);
     testOneInput(func, negInf, IntegerMin, true);
     testOneInput(func, nan, IntegerMax, true);
   }
 
-  void testRoundNumbers(RoundToIntegerFunc func) {
+  void testInfinityAndNaN(RoundToIntegerFunc func) {
+    if (TestModes) {
+      for (int mode : roundingModes) {
+        __llvm_libc::fputil::setRound(mode);
+        doInfinityAndNaNTest(func);
+      }
+    } else {
+      doInfinityAndNaNTest(func);
+    }
+  }
+
+  void doRoundNumbersTest(RoundToIntegerFunc func) {
     testOneInput(func, zero, I(0), false);
     testOneInput(func, negZero, I(0), false);
     testOneInput(func, F(1.0), I(1), false);
     testOneInput(func, F(-1.0), I(-1), false);
     testOneInput(func, F(10.0), I(10), false);
     testOneInput(func, F(-10.0), I(-10), false);
     testOneInput(func, F(1234.0), I(1234), false);
     testOneInput(func, F(-1234.0), I(-1234), false);
void doRoundNumbersTest(RoundToIntegerFunc func) {
 
     F x = bits;
     long mpfrResult;
     bool erangeflag = mpfr::RoundToLong(x, mpfrResult);
     ASSERT_FALSE(erangeflag);
     testOneInput(func, x, mpfrResult, false);
   }
 
+  void testRoundNumbers(RoundToIntegerFunc func) {
+    if (TestModes) {
+      for (int mode : roundingModes) {
+        __llvm_libc::fputil::setRound(mode);
+        doRoundNumbersTest(func);
+      }
+    } else {
+      doRoundNumbersTest(func);
+    }
+  }
+
+  void doFractionsTest(RoundToIntegerFunc func, int mode) {
+    constexpr F fractions[] = {0.5, -0.5, 0.115, -0.115, 0.715, -0.715};
+    for (F x : fractions) {
+      long mpfrLongResult;
+      bool erangeflag;
+      if (TestModes)
+        erangeflag =
+            mpfr::RoundToLong(x, toMPFRRoundingMode(mode), mpfrLongResult);
+      else
+        erangeflag = mpfr::RoundToLong(x, mpfrLongResult);
+      ASSERT_FALSE(erangeflag);
+      I mpfrResult = mpfrLongResult;
+      testOneInput(func, x, mpfrResult, false);
+    }
+  }
+
   void testFractions(RoundToIntegerFunc func) {
-    testOneInput(func, F(0.5), I(1), false);
-    testOneInput(func, F(-0.5), I(-1), false);
-    testOneInput(func, F(0.115), I(0), false);
-    testOneInput(func, F(-0.115), I(0), false);
-    testOneInput(func, F(0.715), I(1), false);
-    testOneInput(func, F(-0.715), I(-1), false);
+    if (TestModes) {
+      for (int mode : roundingModes) {
+        __llvm_libc::fputil::setRound(mode);
+        doFractionsTest(func, mode);
+      }
+    } else {
+      // Passing 0 for mode has no effect as it is not used in doFractionsTest
+      // when `TestModes` is false;
+      doFractionsTest(func, 0);
+    }
   }
 
   void testIntegerOverflow(RoundToIntegerFunc func) {
     // This function compares with an equivalent MPFR function which rounds
     // floating point numbers to long values. There is no MPFR function to
     // round to long long or wider integer values. So, we will peform the
     // comparisons in this function only if the width of I less than equal to
     // that of long.
     if (sizeof(I) > sizeof(long))
       return;
 
     constexpr int exponentLimit = sizeof(I) * 8 - 1;
     // We start with 1.0 so that the implicit bit for x86 long doubles
     // is set.
     FPBits bits(F(1.0));
     bits.exponent = exponentLimit + FPBits::exponentBias;
     bits.sign = 1;
     bits.mantissa = UIntType(0x1)
                     << (__llvm_libc::fputil::MantissaWidth<F>::value - 1);
 
     F x = bits;
-    long mpfrResult;
-    bool erangeflag = mpfr::RoundToLong(x, mpfrResult);
+    if (TestModes) {
+      for (int m : roundingModes) {
+        __llvm_libc::fputil::setRound(m);
+        long mpfrLongResult;
+        bool erangeflag =
+            mpfr::RoundToLong(x, toMPFRRoundingMode(m), mpfrLongResult);
+        ASSERT_TRUE(erangeflag);
+        testOneInput(func, x, IntegerMin, true);
+      }
+    } else {
+      long mpfrLongResult;
+      bool erangeflag = mpfr::RoundToLong(x, mpfrLongResult);
       ASSERT_TRUE(erangeflag);
       testOneInput(func, x, IntegerMin, true);
     }
+  }
 
   void testSubnormalRange(RoundToIntegerFunc func) {
-    // This function compares with an equivalent MPFR function which rounds
-    // floating point numbers to long values. There is no MPFR function to
-    // round to long long or wider integer values. So, we will peform the
-    // comparisons in this function only if the width of I less than equal to
-    // that of long.
-    if (sizeof(I) > sizeof(long))
-      return;
-
     constexpr UIntType count = 1000001;
     constexpr UIntType step =
         (FPBits::maxSubnormal - FPBits::minSubnormal) / count;
     for (UIntType i = FPBits::minSubnormal; i <= FPBits::maxSubnormal;
          i += step) {
       F x = FPBits(i);
+      if (x == F(0.0))
+        continue;
       // All subnormal numbers should round to zero.
+      if (TestModes) {
+        if (x > 0) {
+          __llvm_libc::fputil::setRound(FE_UPWARD);
+          testOneInput(func, x, I(1), false);
+          __llvm_libc::fputil::setRound(FE_DOWNWARD);
+          testOneInput(func, x, I(0), false);
+          __llvm_libc::fputil::setRound(FE_TOWARDZERO);
+          testOneInput(func, x, I(0), false);
+          __llvm_libc::fputil::setRound(FE_TONEAREST);
+          testOneInput(func, x, I(0), false);
+        } else {
+          __llvm_libc::fputil::setRound(FE_UPWARD);
+          testOneInput(func, x, I(0), false);
+          __llvm_libc::fputil::setRound(FE_DOWNWARD);
+          testOneInput(func, x, I(-1), false);
+          __llvm_libc::fputil::setRound(FE_TOWARDZERO);
+          testOneInput(func, x, I(0), false);
+          __llvm_libc::fputil::setRound(FE_TONEAREST);
+          testOneInput(func, x, I(0), false);
+        }
+      } else {
         testOneInput(func, x, 0L, false);
       }
     }
+  }
 
   void testNormalRange(RoundToIntegerFunc func) {
     // This function compares with an equivalent MPFR function which rounds
     // floating point numbers to long values. There is no MPFR function to
     // round to long long or wider integer values. So, we will peform the
     // comparisons in this function only if the width of I less than equal to
     // that of long.
     if (sizeof(I) > sizeof(long))
       return;
 
     constexpr UIntType count = 1000001;
     constexpr UIntType step = (FPBits::maxNormal - FPBits::minNormal) / count;
     for (UIntType i = FPBits::minNormal; i <= FPBits::maxNormal; i += step) {
       F x = FPBits(i);
       // In normal range on x86 platforms, the long double implicit 1 bit can be
       // zero making the numbers NaN. We will skip them.
       if (isnan(x)) {
         continue;
       }
 
-      long mpfrResult;
-      bool erangeflag = mpfr::RoundToLong(x, mpfrResult);
+      if (TestModes) {
+        for (int m : roundingModes) {
+          long mpfrLongResult;
+          bool erangeflag =
+              mpfr::RoundToLong(x, toMPFRRoundingMode(m), mpfrLongResult);
+          I mpfrResult = mpfrLongResult;
+          __llvm_libc::fputil::setRound(m);
+          if (erangeflag)
+            testOneInput(func, x, x > 0 ? IntegerMax : IntegerMin, true);
+          else
+            testOneInput(func, x, mpfrResult, false);
+        }
+      } else {
+        long mpfrLongResult;
+        bool erangeflag = mpfr::RoundToLong(x, mpfrLongResult);
+        I mpfrResult = mpfrLongResult;
         if (erangeflag)
           testOneInput(func, x, x > 0 ? IntegerMax : IntegerMin, true);
         else
           testOneInput(func, x, mpfrResult, false);
       }
     }
+  }
 };
 
-#define LIST_ROUND_TO_INTEGER_TESTS(F, I, func)                                \
-  using RoundToIntegerTest = RoundToIntegerTestTemplate<F, I>;                 \
+#define LIST_ROUND_TO_INTEGER_TESTS_HELPER(F, I, func, TestModes)              \
+  using RoundToIntegerTest = RoundToIntegerTestTemplate<F, I, TestModes>;      \
   TEST_F(RoundToIntegerTest, InfinityAndNaN) { testInfinityAndNaN(&func); }    \
   TEST_F(RoundToIntegerTest, RoundNumbers) { testRoundNumbers(&func); }        \
   TEST_F(RoundToIntegerTest, Fractions) { testFractions(&func); }              \
   TEST_F(RoundToIntegerTest, IntegerOverflow) { testIntegerOverflow(&func); }  \
   TEST_F(RoundToIntegerTest, SubnormalRange) { testSubnormalRange(&func); }    \
   TEST_F(RoundToIntegerTest, NormalRange) { testNormalRange(&func); }
 
+#define LIST_ROUND_TO_INTEGER_TESTS(F, I, func)                                \
+  LIST_ROUND_TO_INTEGER_TESTS_HELPER(F, I, func, false)
+
+#define LIST_ROUND_TO_INTEGER_TESTS_WITH_MODES(F, I, func)                     \
+  LIST_ROUND_TO_INTEGER_TESTS_HELPER(F, I, func, true)
+
 #endif // LLVM_LIBC_TEST_SRC_MATH_ROUNDTOINTEGERTEST_H

libc/test/src/math/llrint_test.cpp

+//===-- Unittests for llrint ----------------------------------------------===//
+//
+// 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 "RoundToIntegerTest.h"
+
+#include "src/math/llrint.h"
+
+LIST_ROUND_TO_INTEGER_TESTS_WITH_MODES(double, long long, __llvm_libc::llrint)

libc/test/src/math/llrintf_test.cpp

+//===-- Unittests for llrintf ---------------------------------------------===//
+//
+// 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 "RoundToIntegerTest.h"
+
+#include "src/math/llrintf.h"
+
+LIST_ROUND_TO_INTEGER_TESTS_WITH_MODES(float, long long, __llvm_libc::llrintf)

libc/test/src/math/llrintl_test.cpp

+//===-- Unittests for llrintl ---------------------------------------------===//
+//
+// 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 "RoundToIntegerTest.h"
+
+#include "src/math/llrintl.h"
+
+LIST_ROUND_TO_INTEGER_TESTS_WITH_MODES(long double, long long,
+                                       __llvm_libc::llrintl)

libc/test/src/math/lrint_test.cpp

+//===-- Unittests for lrint -----------------------------------------------===//
+//
+// 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 "RoundToIntegerTest.h"
+
+#include "src/math/lrint.h"
+
+LIST_ROUND_TO_INTEGER_TESTS_WITH_MODES(double, long, __llvm_libc::lrint)

libc/test/src/math/lrintf_test.cpp

+//===-- Unittests for lrintf ----------------------------------------------===//
+//
+// 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 "RoundToIntegerTest.h"
+
+#include "src/math/lrintf.h"
+
+LIST_ROUND_TO_INTEGER_TESTS_WITH_MODES(float, long, __llvm_libc::lrintf)

libc/test/src/math/lrintl_test.cpp

+//===-- Unittests for lrintl ----------------------------------------------===//
+//
+// 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 "RoundToIntegerTest.h"
+
+#include "src/math/lrintl.h"
+
+LIST_ROUND_TO_INTEGER_TESTS_WITH_MODES(long double, long, __llvm_libc::lrintl)

libc/test/src/math/rint_test.cpp

+//===-- Unittests for rint ------------------------------------------------===//
+//
+// 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 "RIntTest.h"
+
+#include "src/math/rint.h"
+
+LIST_RINT_TESTS(double, __llvm_libc::rint)

libc/test/src/math/rintf_test.cpp

+//===-- Unittests for rintf -----------------------------------------------===//
+//
+// 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 "RIntTest.h"
+
+#include "src/math/rintf.h"
+
+LIST_RINT_TESTS(float, __llvm_libc::rintf)

libc/test/src/math/rintl_test.cpp

+//===-- Unittests for rintl -----------------------------------------------===//
+//
+// 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 "RIntTest.h"
+
+#include "src/math/rintl.h"
+
+LIST_RINT_TESTS(long double, __llvm_libc::rintl)

libc/utils/FPUtil/NearestIntegerOperations.h

 //===-- Nearest integer floating-point operations ---------------*- 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_UTILS_FPUTIL_NEAREST_INTEGER_OPERATIONS_H
 #define LLVM_LIBC_UTILS_FPUTIL_NEAREST_INTEGER_OPERATIONS_H
 
+#include "FEnv.h"
 #include "FPBits.h"
 
 #include "utils/CPP/TypeTraits.h"
 
 #include <math.h>
-#if math_errhandling & MATH_ERREXCEPT
-#include "FEnv.h"
-#endif
 #if math_errhandling & MATH_ERRNO
 #include "src/errno/llvmlibc_errno.h"
 #include <errno.h>
 #endif
 
 namespace __llvm_libc {
 namespace fputil {
 
if (!halfBitSet) {
     // Franctional part is less than 0.5 so round value is the
     // same as the trunc value.
     return truncValue;
   } else {
     return isNeg ? truncValue - T(1.0) : truncValue + T(1.0);
   }
 }
 
+template <typename T,
+          cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
+static inline T roundUsingCurrentRoundingMode(T x) {
+  using UIntType = typename FPBits<T>::UIntType;
+  FPBits<T> bits(x);
+
+  // If x is infinity NaN or zero, return it.
+  if (bits.isInfOrNaN() || bits.isZero())
+    return x;
+
+  bool isNeg = bits.sign;
+  int exponent = bits.getExponent();
+  int roundingMode = getRound();
+
+  // If the exponent is greater than the most negative mantissa
+  // exponent, then x is already an integer.
+  if (exponent >= static_cast<int>(MantissaWidth<T>::value))
+    return x;
+
+  if (exponent <= -1) {
+    switch (roundingMode) {
+    case FE_DOWNWARD:
+      return isNeg ? T(-1.0) : T(0.0);
+    case FE_UPWARD:
+      return isNeg ? T(-0.0) : T(1.0);
+    case FE_TOWARDZERO:
+      return isNeg ? T(-0.0) : T(0.0);
+    case FE_TONEAREST:
+      if (exponent <= -2 || bits.mantissa == 0)
+        return isNeg ? T(-0.0) : T(0.0); // abs(x) <= 0.5
+      else
+        return isNeg ? T(-1.0) : T(1.0); // abs(x) > 0.5
+    default:
+      __builtin_unreachable();
+    }
+  }
+
+  uint32_t trimSize = MantissaWidth<T>::value - exponent;
+  FPBits<T> newBits = bits;
+  newBits.mantissa = (bits.mantissa >> trimSize) << trimSize;
+  T truncValue = T(newBits);
+
+  // If x is already an integer, return it.
+  if (truncValue == x)
+    return x;
+
+  UIntType trimValue = bits.mantissa & ((UIntType(1) << trimSize) - 1);
+  UIntType halfValue = (UIntType(1) << (trimSize - 1));
+  // If exponent is 0, trimSize will be equal to the mantissa width, and
+  // truncIsOdd` will not be correct. So, we handle it as a special case
+  // below.
+  UIntType truncIsOdd = newBits.mantissa & (UIntType(1) << trimSize);
+
+  switch (roundingMode) {
+  case FE_DOWNWARD:
+    return isNeg ? truncValue - T(1.0) : truncValue;
+  case FE_UPWARD:
+    return isNeg ? truncValue : truncValue + T(1.0);
+  case FE_TOWARDZERO:
+    return truncValue;
+  case FE_TONEAREST:
+    if (trimValue > halfValue) {
+      return isNeg ? truncValue - T(1.0) : truncValue + T(1.0);
+    } else if (trimValue == halfValue) {
+      if (exponent == 0)
+        return isNeg ? T(-2.0) : T(2.0);
+      if (truncIsOdd)
+        return isNeg ? truncValue - T(1.0) : truncValue + T(1.0);
+      else
+        return truncValue;
+    } else {
+      return truncValue;
+    }
+  default:
+    __builtin_unreachable();
+  }
+}
+
+namespace internal {
+
 template <typename F, typename I,
           cpp::EnableIfType<cpp::IsFloatingPointType<F>::Value &&
                                 cpp::IsIntegral<I>::Value,
                             int> = 0>
-static inline I roundToSignedInteger(F x) {
+static inline I roundedFloatToSignedInteger(F x) {
   constexpr I IntegerMin = (I(1) << (sizeof(I) * 8 - 1));
   constexpr I IntegerMax = -(IntegerMin + 1);
-
-  using FPBits = FPBits<F>;
-  F roundedValue = round(x);
-  FPBits bits(roundedValue);
+  FPBits<F> bits(x);
   auto setDomainErrorAndRaiseInvalid = []() {
 #if math_errhandling & MATH_ERRNO
     llvmlibc_errno = EDOM;
 #endif
 #if math_errhandling & MATH_ERREXCEPT
     raiseExcept(FE_INVALID);
 #endif
   };
 
   if (bits.isInfOrNaN()) {
-    // Result of round is infinity or NaN only if x is infinity
-    // or NaN.
     setDomainErrorAndRaiseInvalid();
     return bits.sign ? IntegerMin : IntegerMax;
   }
 
   int exponent = bits.getExponent();
   constexpr int exponentLimit = sizeof(I) * 8 - 1;
   if (exponent > exponentLimit) {
     setDomainErrorAndRaiseInvalid();
     return bits.sign ? IntegerMin : IntegerMax;
   } else if (exponent == exponentLimit) {
     if (bits.sign == 0 || bits.mantissa != 0) {
       setDomainErrorAndRaiseInvalid();
       return bits.sign ? IntegerMin : IntegerMax;
     }
     // If the control reaches here, then it means that the rounded
     // value is the most negative number for the signed integer type I.
   }
 
-  // For all other cases, if |roundedValue| can fit in the integer type |I|,
-  // we just return the roundedValue. Implicit conversion will convert the
+  // For all other cases, if `x` can fit in the integer type `I`,
+  // we just return `x`. Implicit conversion will convert the
   // floating point value to the exact integer value.
-  return roundedValue;
+  return x;
+}
+
+} // namespace internal
+
+template <typename F, typename I,
+          cpp::EnableIfType<cpp::IsFloatingPointType<F>::Value &&
+                                cpp::IsIntegral<I>::Value,
+                            int> = 0>
+static inline I roundToSignedInteger(F x) {
+  return internal::roundedFloatToSignedInteger<F, I>(round(x));
+}
+
+template <typename F, typename I,
+          cpp::EnableIfType<cpp::IsFloatingPointType<F>::Value &&
+                                cpp::IsIntegral<I>::Value,
+                            int> = 0>
+static inline I roundToSignedIntegerUsingCurrentRoundingMode(F x) {
+  return internal::roundedFloatToSignedInteger<F, I>(
+      roundUsingCurrentRoundingMode(x));
 }
 
 } // namespace fputil
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_UTILS_FPUTIL_NEAREST_INTEGER_OPERATIONS_H

libc/utils/MPFRWrapper/MPFRUtils.h

 template <Operation op, typename InputType, typename OutputType>
 __attribute__((no_sanitize("address")))
 cpp::EnableIfType<isValidOperation<op, InputType, OutputType>(),
                   internal::MPFRMatcher<op, InputType, OutputType>>
 getMPFRMatcher(InputType input, OutputType outputUnused, double t) {
   return internal::MPFRMatcher<op, InputType, OutputType>(input, t);
 }
 
+enum class RoundingMode : uint8_t { Upward, Downward, TowardZero, Nearest };
+
+template <typename T> T Round(T x, RoundingMode mode);
+
 template <typename T> bool RoundToLong(T x, long &result);
+template <typename T> bool RoundToLong(T x, RoundingMode mode, long &result);
 
 } // namespace mpfr
 } // namespace testing
 } // namespace __llvm_libc
 
 #define EXPECT_MPFR_MATCH(op, input, matchValue, tolerance)                    \
   EXPECT_THAT(matchValue, __llvm_libc::testing::mpfr::getMPFRMatcher<op>(      \
                               input, matchValue, tolerance))
 
 #define ASSERT_MPFR_MATCH(op, input, matchValue, tolerance)                    \
   ASSERT_THAT(matchValue, __llvm_libc::testing::mpfr::getMPFRMatcher<op>(      \
                               input, matchValue, tolerance))
 
 #endif // LLVM_LIBC_UTILS_TESTUTILS_MPFRUTILS_H

libc/utils/MPFRWrapper/MPFRUtils.cpp

bool roundToLong(long &result) const {
     // 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 roundToLong(mpfr_rnd_t rnd, long &result) const {
+    MPFRNumber rint_result;
+    mpfr_rint(rint_result.value, value, rnd);
+    return rint_result.roundToLong(result);
+  }
+
+  MPFRNumber rint(mpfr_rnd_t rnd) const {
+    MPFRNumber result;
+    mpfr_rint(result.value, value, rnd);
+    return result;
+  }
+
   MPFRNumber sin() const {
     MPFRNumber result;
     mpfr_sin(result.value, value, MPFR_RNDN);
     return result;
   }
 
   MPFRNumber sqrt() const {
     MPFRNumber result;
template bool compareBinaryOperationOneOutput<float>(Operation,
                                                      const BinaryInput<float> &,
                                                      float, double);
 template bool
 compareBinaryOperationOneOutput<double>(Operation, const BinaryInput<double> &,
                                         double, double);
 template bool compareBinaryOperationOneOutput<long double>(
     Operation, const BinaryInput<long double> &, long double, double);
 
+static mpfr_rnd_t getMPFRRoundingMode(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;
+  }
+}
+
 } // namespace internal
 
 template <typename T> bool RoundToLong(T x, long &result) {
   MPFRNumber mpfr(x);
   return mpfr.roundToLong(result);
 }
 
 template bool RoundToLong<float>(float, long &);
 template bool RoundToLong<double>(double, long &);
 template bool RoundToLong<long double>(long double, long &);
 
+template <typename T> bool RoundToLong(T x, RoundingMode mode, long &result) {
+  MPFRNumber mpfr(x);
+  return mpfr.roundToLong(internal::getMPFRRoundingMode(mode), result);
+}
+
+template bool RoundToLong<float>(float, RoundingMode, long &);
+template bool RoundToLong<double>(double, RoundingMode, long &);
+template bool RoundToLong<long double>(long double, RoundingMode, long &);
+
+template <typename T> T Round(T x, RoundingMode mode) {
+  MPFRNumber mpfr(x);
+  MPFRNumber result = mpfr.rint(internal::getMPFRRoundingMode(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