[libc] Add implementations of lround[f|l] and llround[f|l].

[sivachandra]

Summary

A new function to MPFRWrapper has been added, which is used to set up
the unit tests.

[sivachandra]

Remove aarch64 entrypoints as we do not yet have exception support for aarch64.

[sivachandra]

Add an explicit overflow test.

[lntue]

libc/utils/FPUtil/NearestIntegerOperations.h

168

For overflow values, I think it makes more sense to saturate to LONG_(MIN/MAX), LLONG_(MIN/MAX) accordingly, as I doubt most user codes will check for FE_INVALID, and a small floating point error making the results jump between INT_(MIN/MAX) and 0 might be surprising.

[sivachandra]

Return max integer or min integer value on overflow.

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.llround
+    libc.src.math.llroundf
+    libc.src.math.llroundl
     libc.src.math.logb
     libc.src.math.logbf
     libc.src.math.logbl
+    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/spec/spec.td

 class RestrictedPtrType<Type type> : Type {
   Type PointeeType = type;
 }
 
 // Builtin types.
 def VarArgType : Type {}
 def VoidType : NamedType<"void">;
 def IntType : NamedType<"int">;
+def LongType : NamedType<"long">;
+def LongLongType : NamedType<"long long">;
 def FloatType : NamedType<"float">;
 def DoubleType : NamedType<"double">;
 def LongDoubleType : NamedType<"long double">;
 def CharType : NamedType<"char">;
 
 // Common types
 def VoidPtr : PtrType<VoidType>;
 def ConstVoidPtr : ConstType<VoidPtr>;

libc/spec/stdc.td

HeaderSpec Math = HeaderSpec<
           FunctionSpec<"remquof", RetValSpec<FloatType>, [ArgSpec<FloatType>, ArgSpec<FloatType>, ArgSpec<IntPtr>]>,
           FunctionSpec<"remquo", RetValSpec<DoubleType>, [ArgSpec<DoubleType>, ArgSpec<DoubleType>, ArgSpec<IntPtr>]>,
           FunctionSpec<"remquol", RetValSpec<LongDoubleType>, [ArgSpec<LongDoubleType>, ArgSpec<LongDoubleType>, ArgSpec<IntPtr>]>,
 
           FunctionSpec<"round", RetValSpec<DoubleType>, [ArgSpec<DoubleType>]>,
           FunctionSpec<"roundf", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
           FunctionSpec<"roundl", RetValSpec<LongDoubleType>, [ArgSpec<LongDoubleType>]>,
 
+          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<"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
     roundl.h
   DEPENDS
     libc.utils.FPUtil.fputil
   COMPILE_OPTIONS
     -O2
 )
 
+add_entrypoint_object(
+  lround
+  SRCS
+    lround.cpp
+  HDRS
+    lround.h
+  DEPENDS
+    libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
+)
+
+add_entrypoint_object(
+  lroundf
+  SRCS
+    lroundf.cpp
+  HDRS
+    lroundf.h
+  DEPENDS
+    libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
+)
+
+add_entrypoint_object(
+  lroundl
+  SRCS
+    lroundl.cpp
+  HDRS
+    lroundl.h
+  DEPENDS
+    libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
+)
+
+add_entrypoint_object(
+  llround
+  SRCS
+    llround.cpp
+  HDRS
+    llround.h
+  DEPENDS
+    libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
+)
+
+add_entrypoint_object(
+  llroundf
+  SRCS
+    llroundf.cpp
+  HDRS
+    llroundf.h
+  DEPENDS
+    libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
+)
+
+add_entrypoint_object(
+  llroundl
+  SRCS
+    llroundl.cpp
+  HDRS
+    llroundl.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/llround.h

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

libc/src/math/llround.cpp

+//===-- Implementation of llround 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(llround)(double x) {
+  return fputil::roundToSignedInteger<double, long long>(x);
+}
+
+} // namespace __llvm_libc

libc/src/math/llroundf.h

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

libc/src/math/llroundf.cpp

+//===-- Implementation of llroundf 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(llroundf)(float x) {
+  return fputil::roundToSignedInteger<float, long long>(x);
+}
+
+} // namespace __llvm_libc

libc/src/math/llroundl.h

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

libc/src/math/llroundl.cpp

+//===-- Implementation of llroundl 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(llroundl)(long double x) {
+  return fputil::roundToSignedInteger<long double, long long>(x);
+}
+
+} // namespace __llvm_libc

libc/src/math/lround.h

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

libc/src/math/lround.cpp

+//===-- Implementation of lround 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(lround)(double x) {
+  return fputil::roundToSignedInteger<double, long>(x);
+}
+
+} // namespace __llvm_libc

libc/src/math/lroundf.h

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

libc/src/math/lroundf.cpp

+//===-- Implementation of lroundf 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(lroundf)(float x) {
+  return fputil::roundToSignedInteger<float, long>(x);
+}
+
+} // namespace __llvm_libc

libc/src/math/lroundl.h

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

libc/src/math/lroundl.cpp

+//===-- Implementation of lroundl 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(lroundl)(long double x) {
+  return fputil::roundToSignedInteger<long double, long>(x);
+}
+
+} // namespace __llvm_libc

libc/test/src/math/CMakeLists.txt

SRCS
     roundl_test.cpp
   DEPENDS
     libc.include.math
     libc.src.math.roundl
     libc.utils.FPUtil.fputil
 )
 
 add_fp_unittest(
+  lround_test
+  NEED_MPFR
+  SUITE
+    libc_math_unittests
+  SRCS
+    lround_test.cpp
+  HDRS
+    RoundToIntegerTest.h
+  DEPENDS
+    libc.include.errno
+    libc.include.math
+    libc.src.errno.__errno_location
+    libc.src.fenv.feclearexcept
+    libc.src.fenv.feraiseexcept
+    libc.src.fenv.fetestexcept
+    libc.src.math.lround
+    libc.utils.FPUtil.fputil
+)
+
+add_fp_unittest(
+  lroundf_test
+  NEED_MPFR
+  SUITE
+    libc_math_unittests
+  SRCS
+    lroundf_test.cpp
+  HDRS
+    RoundToIntegerTest.h
+  DEPENDS
+    libc.include.errno
+    libc.include.math
+    libc.src.errno.__errno_location
+    libc.src.fenv.feclearexcept
+    libc.src.fenv.feraiseexcept
+    libc.src.fenv.fetestexcept
+    libc.src.math.lroundf
+    libc.utils.FPUtil.fputil
+)
+
+add_fp_unittest(
+  lroundl_test
+  NEED_MPFR
+  SUITE
+    libc_math_unittests
+  SRCS
+    lroundl_test.cpp
+  HDRS
+    RoundToIntegerTest.h
+  DEPENDS
+    libc.include.errno
+    libc.include.math
+    libc.src.errno.__errno_location
+    libc.src.fenv.feclearexcept
+    libc.src.fenv.feraiseexcept
+    libc.src.fenv.fetestexcept
+    libc.src.math.lroundl
+    libc.utils.FPUtil.fputil
+)
+
+add_fp_unittest(
+  llround_test
+  NEED_MPFR
+  SUITE
+    libc_math_unittests
+  SRCS
+    llround_test.cpp
+  HDRS
+    RoundToIntegerTest.h
+  DEPENDS
+    libc.include.errno
+    libc.include.math
+    libc.src.errno.__errno_location
+    libc.src.fenv.feclearexcept
+    libc.src.fenv.feraiseexcept
+    libc.src.fenv.fetestexcept
+    libc.src.math.llround
+    libc.utils.FPUtil.fputil
+)
+
+add_fp_unittest(
+  llroundf_test
+  NEED_MPFR
+  SUITE
+    libc_math_unittests
+  SRCS
+    llroundf_test.cpp
+  HDRS
+    RoundToIntegerTest.h
+  DEPENDS
+    libc.include.errno
+    libc.include.math
+    libc.src.errno.__errno_location
+    libc.src.fenv.feclearexcept
+    libc.src.fenv.feraiseexcept
+    libc.src.fenv.fetestexcept
+    libc.src.math.llroundf
+    libc.utils.FPUtil.fputil
+)
+
+add_fp_unittest(
+  llroundl_test
+  NEED_MPFR
+  SUITE
+    libc_math_unittests
+  SRCS
+    llroundl_test.cpp
+  HDRS
+    RoundToIntegerTest.h
+  DEPENDS
+    libc.include.errno
+    libc.include.math
+    libc.src.errno.__errno_location
+    libc.src.fenv.feclearexcept
+    libc.src.fenv.feraiseexcept
+    libc.src.fenv.fetestexcept
+    libc.src.math.llroundl
+    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/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/CPP/TypeTraits.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>
+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);
+#endif
+
+    ASSERT_EQ(func(input), expected);
+
+    if (expectError) {
+#if math_errhandling & MATH_ERREXCEPT
+      ASSERT_EQ(__llvm_libc::fetestexcept(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);
+#endif
+#if math_errhandling & MATH_ERRNO
+      ASSERT_EQ(llvmlibc_errno, 0);
+#endif
+    }
+  }
+
+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) {
+    testOneInput(func, inf, IntegerMax, true);
+    testOneInput(func, negInf, IntegerMin, true);
+    testOneInput(func, nan, IntegerMax, true);
+  }
+
+  void testRoundNumbers(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);
+
+    // The rest of this 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
+    // the remaining tests 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 = 0;
+
+    F x = bits;
+    long mpfrResult;
+    bool erangeflag = mpfr::RoundToLong(x, mpfrResult);
+    ASSERT_FALSE(erangeflag);
+    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);
+  }
+
+  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);
+    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);
+      // All subnormal numbers should round to zero.
+      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 (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>;                 \
+  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); }
+
+#endif // LLVM_LIBC_TEST_SRC_MATH_ROUNDTOINTEGERTEST_H

libc/test/src/math/llround_test.cpp

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

libc/test/src/math/llroundf_test.cpp

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

libc/test/src/math/llroundl_test.cpp

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

libc/test/src/math/lround_test.cpp

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

libc/test/src/math/lroundf_test.cpp

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

libc/test/src/math/lroundl_test.cpp

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

libc/utils/FPUtil/CMakeLists.txt

HDRS
     FloatProperties.h
     FPBits.h
     BasicOperations.h
     ManipulationFunctions.h
     NearestIntegerOperations.h
     NormalFloat.h
   DEPENDS
     libc.include.math
+    libc.include.errno
+    libc.include.fenv
+    libc.src.errno.__errno_location
     libc.utils.CPP.standalone_cpp
 )
 
 add_llvm_library(
   LibcFPTestHelpers
     TestHelpers.cpp
     TestHelpers.h
 )
 target_include_directories(LibcFPTestHelpers PUBLIC ${LIBC_SOURCE_DIR})
 target_link_libraries(LibcFPTestHelpers LibcUnitTest LLVMSupport)
 add_dependencies(
   LibcFPTestHelpers
   LibcUnitTest
   libc.utils.CPP.standalone_cpp
   libc.utils.FPUtil.fputil
 )

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 "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 {
 
 template <typename T,
           cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
 static inline T trunc(T x) {
   FPBits<T> bits(x);
 
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 F, typename I,
+          cpp::EnableIfType<cpp::IsFloatingPointType<F>::Value &&
+                                cpp::IsIntegral<I>::Value,
+                            int> = 0>
+static inline I roundToSignedInteger(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);
+  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
+  // floating point value to the exact integer value.
+  return roundedValue;
+}
+
 } // 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);
 }
 
+template <typename T> bool RoundToLong(T x, 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

 #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
 // case, a file named `CustomMPFRIncluder.h` should be added through which the
 // MPFR header can be included in manner allowed in that repo.
 #include "CustomMPFRIncluder.h"
 #else
 #include <mpfr.h>
 #endif
 
 template <typename T> using FPBits = __llvm_libc::fputil::FPBits<T>;
 
 namespace __llvm_libc {
 namespace testing {
 namespace mpfr {
 
public:
   }
 
   MPFRNumber round() const {
     MPFRNumber result;
     mpfr_round(result.value, value);
     return result;
   }
 
+  bool roundToLong(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();
+  }
+
   MPFRNumber sin() const {
     MPFRNumber result;
     mpfr_sin(result.value, value, MPFR_RNDN);
     return result;
   }
 
   MPFRNumber sqrt() const {
     MPFRNumber result;

 template bool
 compareBinaryOperationOneOutput<double>(Operation, const BinaryInput<double> &,
                                         double, double);
 template bool compareBinaryOperationOneOutput<long double>(
     Operation, const BinaryInput<long double> &, long double, double);
 
 } // 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 &);
+
 } // namespace mpfr
 } // namespace testing
 } // namespace __llvm_libc