[libc] Add the remaining long double flavors of nearest integer functions.

[sivachandra]

Summary

Specifically: ceill, floorl and roundl have been added.

[tschuett]

Did you miss the aarch64 entry points?

[asteinhauser]

libc/test/src/math/ceill_test.cpp

24

ASSERT_EQ(a, b) here and in the all following ASSERT_TRUE(a == b).

31

ASSERT_TRUE(a) instead of ASSERT_TRUE(a != 0). Eventually use ASSERT_NE(a, 0) if 0 does not autoconvert to false.

[sivachandra]

• Add the functions to aarch64 config.
• Use ASSERT_EQ/NE where possible.

[sivachandra]

In D82591#2115239, @tschuett wrote:

Did you miss the aarch64 entry points?

Yes and no :)
The most convenient way for me to verify the patch on aarch64 is to upload the patch and then use arc patch to apply it on the aarch64 machine. So, I did not add them to the aarch64 config in the first round as I had not tested them on aarch64. But, added now as I have now tested on aarch64 as well.

libc/test/src/math/ceill_test.cpp

24

Our unittest framework supports only integer types to me checked with ASSERT_EQ and ASSERT_NE. But, I took your suggestion and converted wherever I could.

libc/config/linux/aarch64/entrypoints.txt

 
 set(TARGET_LIBM_ENTRYPOINTS
     # math.h entrypoints
     libc.src.math.copysign
     libc.src.math.copysignf
     libc.src.math.copysignl
     libc.src.math.ceil
     libc.src.math.ceilf
+    libc.src.math.ceill
     libc.src.math.cosf
     libc.src.math.expf
     libc.src.math.exp2f
     libc.src.math.fabs
     libc.src.math.fabsf
     libc.src.math.fabsl
     libc.src.math.floor
     libc.src.math.floorf
+    libc.src.math.floorl
     libc.src.math.frexp
     libc.src.math.frexpf
     libc.src.math.frexpl
     libc.src.math.logb
     libc.src.math.logbf
     libc.src.math.logbl
     libc.src.math.modf
     libc.src.math.modff
     libc.src.math.modfl
     libc.src.math.round
     libc.src.math.roundf
+    libc.src.math.roundl
     libc.src.math.sincosf
     libc.src.math.sinf
     libc.src.math.trunc
     libc.src.math.truncf
     libc.src.math.truncl
 )

libc/config/linux/api.td

let TypeDeclarations = [
     FloatT,
   ];
   let Functions = [
    "copysign",
    "copysignf",
    "copysignl",
    "ceil",
    "ceilf",
+   "ceill",
    "cosf",
    "fabs",
    "fabsf",
    "fabsl",
    "floor",
    "floorf",
+   "floorl",
    "frexp",
    "frexpf",
    "frexpl",
    "logb",
    "logbf",
    "logbl",
    "modf",
    "modff",
    "modfl",
    "expf",
    "exp2f",
    "round",
    "roundf",
+   "roundl",
    "sincosf",
    "sinf",
    "trunc",
    "truncf",
    "truncl",
   ];
 }
 

libc/config/linux/x86_64/entrypoints.txt

 
 set(TARGET_LIBM_ENTRYPOINTS
     # math.h entrypoints
     libc.src.math.copysign
     libc.src.math.copysignf
     libc.src.math.copysignl
     libc.src.math.ceil
     libc.src.math.ceilf
+    libc.src.math.ceill
     libc.src.math.cosf
     libc.src.math.expf
     libc.src.math.exp2f
     libc.src.math.fabs
     libc.src.math.fabsf
     libc.src.math.fabsl
     libc.src.math.floor
     libc.src.math.floorf
+    libc.src.math.floorl
     libc.src.math.frexp
     libc.src.math.frexpf
     libc.src.math.frexpl
     libc.src.math.logb
     libc.src.math.logbf
     libc.src.math.logbl
     libc.src.math.modf
     libc.src.math.modff
     libc.src.math.modfl
     libc.src.math.round
     libc.src.math.roundf
+    libc.src.math.roundl
     libc.src.math.sincosf
     libc.src.math.sinf
     libc.src.math.trunc
     libc.src.math.truncf
     libc.src.math.truncl
 )

libc/spec/stdc.td

HeaderSpec Math = HeaderSpec<
       [], // Enumerations
       [
           FunctionSpec<"copysign", RetValSpec<DoubleType>, [ArgSpec<DoubleType>, ArgSpec<DoubleType>]>,
           FunctionSpec<"copysignf", RetValSpec<FloatType>, [ArgSpec<FloatType>, ArgSpec<FloatType>]>,
           FunctionSpec<"copysignl", RetValSpec<LongDoubleType>, [ArgSpec<LongDoubleType>, ArgSpec<LongDoubleType>]>,
 
           FunctionSpec<"ceil", RetValSpec<DoubleType>, [ArgSpec<DoubleType>]>,
           FunctionSpec<"ceilf", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
+          FunctionSpec<"ceill", RetValSpec<LongDoubleType>, [ArgSpec<LongDoubleType>]>,
 
           FunctionSpec<"fabs", RetValSpec<DoubleType>, [ArgSpec<DoubleType>]>,
           FunctionSpec<"fabsf", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
           FunctionSpec<"fabsl", RetValSpec<LongDoubleType>, [ArgSpec<LongDoubleType>]>,
 
           FunctionSpec<"floor", RetValSpec<DoubleType>, [ArgSpec<DoubleType>]>,
           FunctionSpec<"floorf", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
+          FunctionSpec<"floorl", RetValSpec<LongDoubleType>, [ArgSpec<LongDoubleType>]>,
 
           FunctionSpec<"frexp", RetValSpec<DoubleType>, [ArgSpec<DoubleType>, ArgSpec<IntPtr>]>,
           FunctionSpec<"frexpf", RetValSpec<FloatType>, [ArgSpec<FloatType>, ArgSpec<IntPtr>]>,
           FunctionSpec<"frexpl", RetValSpec<LongDoubleType>, [ArgSpec<LongDoubleType>, ArgSpec<IntPtr>]>,
 
           FunctionSpec<"logb", RetValSpec<DoubleType>, [ArgSpec<DoubleType>]>,
           FunctionSpec<"logbf", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
           FunctionSpec<"logbl", RetValSpec<LongDoubleType>, [ArgSpec<LongDoubleType>]>,
 
           FunctionSpec<"modf", RetValSpec<DoubleType>, [ArgSpec<DoubleType>, ArgSpec<DoublePtr>]>,
           FunctionSpec<"modff", RetValSpec<FloatType>, [ArgSpec<FloatType>, ArgSpec<FloatPtr>]>,
           FunctionSpec<"modfl", RetValSpec<LongDoubleType>, [ArgSpec<LongDoubleType>, ArgSpec<LongDoublePtr>]>,
 
           FunctionSpec<"cosf", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
           FunctionSpec<"sinf", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
 
           FunctionSpec<"expf", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
           FunctionSpec<"exp2f", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
 
           FunctionSpec<"round", RetValSpec<DoubleType>, [ArgSpec<DoubleType>]>,
           FunctionSpec<"roundf", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
+          FunctionSpec<"roundl", RetValSpec<LongDoubleType>, [ArgSpec<LongDoubleType>]>,
 
           FunctionSpec<"trunc", RetValSpec<DoubleType>, [ArgSpec<DoubleType>]>,
           FunctionSpec<"truncf", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
           FunctionSpec<"truncl", RetValSpec<LongDoubleType>, [ArgSpec<LongDoubleType>]>,
       ]
   >;
 
   HeaderSpec StdIO = HeaderSpec<

libc/src/math/CMakeLists.txt

HDRS
     ceilf.h
   DEPENDS
     libc.utils.FPUtil.fputil
   COMPILE_OPTIONS
     -O2
 )
 
 add_entrypoint_object(
+  ceill
+  SRCS
+    ceill.cpp
+  HDRS
+    ceill.h
+  DEPENDS
+    libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
+)
+
+add_entrypoint_object(
   floor
   SRCS
     floor.cpp
   HDRS
     floor.h
   DEPENDS
     libc.utils.FPUtil.fputil
   COMPILE_OPTIONS
     -O2
 )
 
 add_entrypoint_object(
   floorf
   SRCS
     floorf.cpp
   HDRS
     floorf.h
   DEPENDS
     libc.utils.FPUtil.fputil
   COMPILE_OPTIONS
     -O2
 )
 
 add_entrypoint_object(
+  floorl
+  SRCS
+    floorl.cpp
+  HDRS
+    floorl.h
+  DEPENDS
+    libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
+)
+
+add_entrypoint_object(
   round
   SRCS
     round.cpp
   HDRS
     round.h
   DEPENDS
     libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
 )
 
 add_entrypoint_object(
   roundf
   SRCS
     roundf.cpp
   HDRS
     roundf.h
   DEPENDS
     libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
+)
+
+add_entrypoint_object(
+  roundl
+  SRCS
+    roundl.cpp
+  HDRS
+    roundl.h
+  DEPENDS
+    libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
 )
 
 add_object_library(
   exp_utils
   HDRS
     exp_utils.h
   SRCS
     exp_utils.cpp

libc/src/math/ceill.h

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

libc/src/math/ceill.cpp

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

libc/src/math/floorl.h

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

libc/src/math/floorl.cpp

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

libc/src/math/roundl.h

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

libc/src/math/roundl.cpp

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

libc/test/src/math/CMakeLists.txt

SRCS
     ceilf_test.cpp
   DEPENDS
     libc.include.math
     libc.src.math.ceilf
     libc.utils.FPUtil.fputil
 )
 
 add_math_unittest(
+  ceill_test
+  NEED_MPFR
+  SUITE
+    libc_math_unittests
+  SRCS
+    ceill_test.cpp
+  DEPENDS
+    libc.include.math
+    libc.src.math.ceill
+    libc.utils.FPUtil.fputil
+)
+
+add_math_unittest(
   floor_test
   NEED_MPFR
   SUITE
     libc_math_unittests
   SRCS
     floor_test.cpp
   DEPENDS
     libc.include.math
SRCS
     floorf_test.cpp
   DEPENDS
     libc.include.math
     libc.src.math.floorf
     libc.utils.FPUtil.fputil
 )
 
 add_math_unittest(
+  floorl_test
+  NEED_MPFR
+  SUITE
+    libc_math_unittests
+  SRCS
+    floorl_test.cpp
+  DEPENDS
+    libc.include.math
+    libc.src.math.floorl
+    libc.utils.FPUtil.fputil
+)
+
+add_math_unittest(
   round_test
   NEED_MPFR
   SUITE
     libc_math_unittests
   SRCS
     round_test.cpp
   DEPENDS
     libc.include.math
SRCS
     roundf_test.cpp
   DEPENDS
     libc.include.math
     libc.src.math.roundf
     libc.utils.FPUtil.fputil
 )
 
 add_math_unittest(
+  roundl_test
+  NEED_MPFR
+  SUITE
+    libc_math_unittests
+  SRCS
+    roundl_test.cpp
+  DEPENDS
+    libc.include.math
+    libc.src.math.roundl
+    libc.utils.FPUtil.fputil
+)
+
+add_math_unittest(
   expf_test
   NEED_MPFR
   SUITE
     libc_math_unittests
   SRCS
     expf_test.cpp
   DEPENDS
     libc.include.errno

libc/test/src/math/ceill_test.cpp

+//===-- Unittests for ceill -----------------------------------------------===//
+//
+// 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 "include/math.h"
+#include "src/math/ceill.h"
+#include "utils/FPUtil/FPBits.h"
+#include "utils/MPFRWrapper/MPFRUtils.h"
+#include "utils/UnitTest/Test.h"
+
+using FPBits = __llvm_libc::fputil::FPBits<long double>;
+
+namespace mpfr = __llvm_libc::testing::mpfr;
+
+// Zero tolerance; As in, exact match with MPFR result.
+static constexpr mpfr::Tolerance tolerance{mpfr::Tolerance::doublePrecision, 0,
+                                           0};
+TEST(CeillTest, SpecialNumbers) {
+  ASSERT_TRUE(FPBits::zero() == __llvm_libc::ceill(FPBits::zero()));
+  ASSERT_TRUE(FPBits::negZero() == __llvm_libc::ceill(FPBits::negZero()));
+
+  ASSERT_TRUE(FPBits::inf() == __llvm_libc::ceill(FPBits::inf()));
+  ASSERT_TRUE(FPBits::negInf() == __llvm_libc::ceill(FPBits::negInf()));
+
+  long double nan = FPBits::buildNaN(1);
+  ASSERT_NE(isnan(nan), 0);
+  ASSERT_NE(isnan(__llvm_libc::ceill(nan)), 0);
+}
+
+TEST(CeillTest, RoundedNumbers) {
+  ASSERT_TRUE(FPBits(1.0l) == __llvm_libc::ceill(1.0l));
+  ASSERT_TRUE(FPBits(-1.0l) == __llvm_libc::ceill(-1.0l));
+  ASSERT_TRUE(FPBits(10.0l) == __llvm_libc::ceill(10.0l));
+  ASSERT_TRUE(FPBits(-10.0l) == __llvm_libc::ceill(-10.0l));
+  ASSERT_TRUE(FPBits(1234.0l) == __llvm_libc::ceill(1234.0l));
+  ASSERT_TRUE(FPBits(-1234.0l) == __llvm_libc::ceill(-1234.0l));
+}
+
+TEST(CeillTest, Fractions) {
+  ASSERT_TRUE(FPBits(2.0l) == __llvm_libc::ceill(1.3l));
+  ASSERT_TRUE(FPBits(-1.0l) == __llvm_libc::ceill(-1.3l));
+  ASSERT_TRUE(FPBits(2.0l) == __llvm_libc::ceill(1.5l));
+  ASSERT_TRUE(FPBits(-1.0l) == __llvm_libc::ceill(-1.5l));
+  ASSERT_TRUE(FPBits(2.0l) == __llvm_libc::ceill(1.75l));
+  ASSERT_TRUE(FPBits(-1.0l) == __llvm_libc::ceill(-1.75l));
+  ASSERT_TRUE(FPBits(11.0l) == __llvm_libc::ceill(10.32l));
+  ASSERT_TRUE(FPBits(-10.0l) == __llvm_libc::ceill(-10.32l));
+  ASSERT_TRUE(FPBits(11.0l) == __llvm_libc::ceill(10.65l));
+  ASSERT_TRUE(FPBits(-10.0l) == __llvm_libc::ceill(-10.65l));
+  ASSERT_TRUE(FPBits(1235.0l) == __llvm_libc::ceill(1234.18l));
+  ASSERT_TRUE(FPBits(-1234.0l) == __llvm_libc::ceill(-1234.18l));
+  ASSERT_TRUE(FPBits(1235.0l) == __llvm_libc::ceill(1234.96l));
+  ASSERT_TRUE(FPBits(-1234.0l) == __llvm_libc::ceill(-1234.96l));
+}
+
+TEST(CeillTest, InLongDoubleRange) {
+  using UIntType = FPBits::UIntType;
+  constexpr UIntType count = 10000000;
+  constexpr UIntType step = UIntType(-1) / count;
+  for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
+    long double x = FPBits(v);
+    if (isnan(x) || isinf(x))
+      continue;
+
+    ASSERT_MPFR_MATCH(mpfr::Operation::Ceil, x, __llvm_libc::ceill(x),
+                      tolerance);
+  }
+}

libc/test/src/math/floorl_test.cpp

+//===-- Unittests for floorl ----------------------------------------------===//
+//
+// 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 "include/math.h"
+#include "src/math/floorl.h"
+#include "utils/FPUtil/FPBits.h"
+#include "utils/MPFRWrapper/MPFRUtils.h"
+#include "utils/UnitTest/Test.h"
+
+using FPBits = __llvm_libc::fputil::FPBits<long double>;
+
+namespace mpfr = __llvm_libc::testing::mpfr;
+
+// Zero tolerance; As in, exact match with MPFR result.
+static constexpr mpfr::Tolerance tolerance{mpfr::Tolerance::doublePrecision, 0,
+                                           0};
+TEST(FloorlTest, SpecialNumbers) {
+  ASSERT_TRUE(FPBits::zero() == __llvm_libc::floorl(FPBits::zero()));
+  ASSERT_TRUE(FPBits::negZero() == __llvm_libc::floorl(FPBits::negZero()));
+
+  ASSERT_TRUE(FPBits::inf() == __llvm_libc::floorl(FPBits::inf()));
+  ASSERT_TRUE(FPBits::negInf() == __llvm_libc::floorl(FPBits::negInf()));
+
+  long double nan = FPBits::buildNaN(1);
+  ASSERT_NE(isnan(nan), 0);
+  ASSERT_NE(isnan(__llvm_libc::floorl(nan)), 0);
+}
+
+TEST(FloorlTest, RoundedNumbers) {
+  ASSERT_TRUE(FPBits(1.0l) == __llvm_libc::floorl(1.0l));
+  ASSERT_TRUE(FPBits(-1.0l) == __llvm_libc::floorl(-1.0l));
+  ASSERT_TRUE(FPBits(10.0l) == __llvm_libc::floorl(10.0l));
+  ASSERT_TRUE(FPBits(-10.0l) == __llvm_libc::floorl(-10.0l));
+  ASSERT_TRUE(FPBits(1234.0l) == __llvm_libc::floorl(1234.0l));
+  ASSERT_TRUE(FPBits(-1234.0l) == __llvm_libc::floorl(-1234.0l));
+}
+
+TEST(FloorlTest, Fractions) {
+  ASSERT_TRUE(FPBits(1.0l) == __llvm_libc::floorl(1.3l));
+  ASSERT_TRUE(FPBits(-2.0l) == __llvm_libc::floorl(-1.3l));
+  ASSERT_TRUE(FPBits(1.0l) == __llvm_libc::floorl(1.5l));
+  ASSERT_TRUE(FPBits(-2.0l) == __llvm_libc::floorl(-1.5l));
+  ASSERT_TRUE(FPBits(1.0l) == __llvm_libc::floorl(1.75l));
+  ASSERT_TRUE(FPBits(-2.0l) == __llvm_libc::floorl(-1.75l));
+  ASSERT_TRUE(FPBits(10.0l) == __llvm_libc::floorl(10.32l));
+  ASSERT_TRUE(FPBits(-11.0l) == __llvm_libc::floorl(-10.32l));
+  ASSERT_TRUE(FPBits(10.0l) == __llvm_libc::floorl(10.65l));
+  ASSERT_TRUE(FPBits(-11.0l) == __llvm_libc::floorl(-10.65l));
+  ASSERT_TRUE(FPBits(1234.0l) == __llvm_libc::floorl(1234.18l));
+  ASSERT_TRUE(FPBits(-1235.0l) == __llvm_libc::floorl(-1234.18l));
+  ASSERT_TRUE(FPBits(1234.0l) == __llvm_libc::floorl(1234.96l));
+  ASSERT_TRUE(FPBits(-1235.0l) == __llvm_libc::floorl(-1234.96l));
+}
+
+TEST(FloorlTest, InLongDoubleRange) {
+  using UIntType = FPBits::UIntType;
+  constexpr UIntType count = 10000000;
+  constexpr UIntType step = UIntType(-1) / count;
+  for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
+    long double x = FPBits(v);
+    if (isnan(x) || isinf(x))
+      continue;
+
+    ASSERT_MPFR_MATCH(mpfr::Operation::Floor, x, __llvm_libc::floorl(x),
+                      tolerance);
+  }
+}

libc/test/src/math/roundl_test.cpp

+//===-- Unittests for roundl ----------------------------------------------===//
+//
+// 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 "include/math.h"
+#include "src/math/roundl.h"
+#include "utils/FPUtil/FPBits.h"
+#include "utils/MPFRWrapper/MPFRUtils.h"
+#include "utils/UnitTest/Test.h"
+
+using FPBits = __llvm_libc::fputil::FPBits<long double>;
+
+namespace mpfr = __llvm_libc::testing::mpfr;
+
+// Zero tolerance; As in, exact match with MPFR result.
+static constexpr mpfr::Tolerance tolerance{mpfr::Tolerance::floatPrecision, 0,
+                                           0};
+TEST(RoundlTest, SpecialNumbers) {
+  ASSERT_TRUE(FPBits::zero() == __llvm_libc::roundl(FPBits::zero()));
+  ASSERT_TRUE(FPBits::negZero() == __llvm_libc::roundl(FPBits::negZero()));
+
+  ASSERT_TRUE(FPBits::inf() == __llvm_libc::roundl(FPBits::inf()));
+  ASSERT_TRUE(FPBits::negInf() == __llvm_libc::roundl(FPBits::negInf()));
+
+  long double nan = FPBits::buildNaN(1);
+  ASSERT_NE(isnan(nan), 0);
+  ASSERT_NE(isnan(__llvm_libc::roundl(nan)), 0);
+}
+
+TEST(RoundlTest, RoundedNumbers) {
+  ASSERT_TRUE(FPBits(1.0l) == __llvm_libc::roundl(1.0l));
+  ASSERT_TRUE(FPBits(-1.0l) == __llvm_libc::roundl(-1.0l));
+  ASSERT_TRUE(FPBits(10.0l) == __llvm_libc::roundl(10.0l));
+  ASSERT_TRUE(FPBits(-10.0l) == __llvm_libc::roundl(-10.0l));
+  ASSERT_TRUE(FPBits(1234.0l) == __llvm_libc::roundl(1234.0l));
+  ASSERT_TRUE(FPBits(-1234.0l) == __llvm_libc::roundl(-1234.0l));
+}
+
+TEST(RoundlTest, Fractions) {
+  ASSERT_TRUE(FPBits(1.0l) == __llvm_libc::roundl(1.3l));
+  ASSERT_TRUE(FPBits(-1.0l) == __llvm_libc::roundl(-1.3l));
+  ASSERT_TRUE(FPBits(2.0l) == __llvm_libc::roundl(1.5l));
+  ASSERT_TRUE(FPBits(-2.0l) == __llvm_libc::roundl(-1.5l));
+  ASSERT_TRUE(FPBits(2.0l) == __llvm_libc::roundl(1.75l));
+  ASSERT_TRUE(FPBits(-2.0l) == __llvm_libc::roundl(-1.75l));
+  ASSERT_TRUE(FPBits(10.0l) == __llvm_libc::roundl(10.32l));
+  ASSERT_TRUE(FPBits(-10.0l) == __llvm_libc::roundl(-10.32l));
+  ASSERT_TRUE(FPBits(11.0l) == __llvm_libc::roundl(10.65l));
+  ASSERT_TRUE(FPBits(-11.0l) == __llvm_libc::roundl(-10.65l));
+  ASSERT_TRUE(FPBits(1234.0l) == __llvm_libc::roundl(1234.38l));
+  ASSERT_TRUE(FPBits(-1234.0l) == __llvm_libc::roundl(-1234.38l));
+  ASSERT_TRUE(FPBits(1235.0l) == __llvm_libc::roundl(1234.96l));
+  ASSERT_TRUE(FPBits(-1235.0l) == __llvm_libc::roundl(-1234.96l));
+}
+
+TEST(RoundlTest, InLongDoubleRange) {
+  using UIntType = FPBits::UIntType;
+  constexpr UIntType count = 10000000;
+  constexpr UIntType step = UIntType(-1) / count;
+  for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
+    long double x = FPBits(v);
+    if (isnan(x) || isinf(x))
+      continue;
+
+    ASSERT_MPFR_MATCH(mpfr::Operation::Round, x, __llvm_libc::roundl(x),
+                      tolerance);
+  }
+}

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 "ClassificationFunctions.h"
 #include "FPBits.h"
-#include "FloatOperations.h"
-#include "FloatProperties.h"
 
 #include "utils/CPP/TypeTraits.h"
 
 namespace __llvm_libc {
 namespace fputil {
 
 template <typename T,
           cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
static inline T trunc(T x) {
   int trimSize = MantissaWidth<T>::value - exponent;
   bits.mantissa = (bits.mantissa >> trimSize) << trimSize;
   return bits;
 }
 
 template <typename T,
           cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
 static inline T ceil(T x) {
-  using Properties = FloatProperties<T>;
-  using BitsType = typename FloatProperties<T>::BitsType;
-
-  BitsType bits = valueAsBits(x);
+  FPBits<T> bits(x);
 
   // If x is infinity NaN or zero, return it.
-  if (bitsAreInfOrNaN(bits) || bitsAreZero(bits))
+  if (bits.isInfOrNaN() || bits.isZero())
     return x;
 
-  bool isNeg = bits & Properties::signMask;
-  int exponent = getExponentFromBits(bits);
+  bool isNeg = bits.sign;
+  int exponent = bits.getExponent();
 
   // If the exponent is greater than the most negative mantissa
   // exponent, then x is already an integer.
-  if (exponent >= static_cast<int>(Properties::mantissaWidth))
+  if (exponent >= static_cast<int>(MantissaWidth<T>::value))
     return x;
 
   if (exponent <= -1) {
     if (isNeg)
       return T(-0.0);
     else
       return T(1.0);
   }
 
-  uint32_t trimSize = Properties::mantissaWidth - exponent;
+  uint32_t trimSize = MantissaWidth<T>::value - exponent;
+  bits.mantissa = (bits.mantissa >> trimSize) << trimSize;
+  T truncValue = T(bits);
+
   // If x is already an integer, return it.
-  if ((bits << (Properties::bitWidth - trimSize)) == 0)
+  if (truncValue == x)
     return x;
 
-  BitsType truncBits = (bits >> trimSize) << trimSize;
-  T truncValue = valueFromBits(truncBits);
-
   // If x is negative, the ceil operation is equivalent to the trunc operation.
   if (isNeg)
     return truncValue;
 
   return truncValue + T(1.0);
 }
 
 template <typename T,
           cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
 static inline T floor(T x) {
-  auto bits = valueAsBits(x);
-  if (FloatProperties<T>::signMask & bits) {
+  FPBits<T> bits(x);
+  if (bits.sign) {
     return -ceil(-x);
   } else {
     return trunc(x);
   }
 }
 
 template <typename T,
           cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
 static inline T round(T x) {
-  using Properties = FloatProperties<T>;
-  using BitsType = typename FloatProperties<T>::BitsType;
-
-  BitsType bits = valueAsBits(x);
+  using UIntType = typename FPBits<T>::UIntType;
+  FPBits<T> bits(x);
 
-  // If x is infinity, NaN or zero, return it.
-  if (bitsAreInfOrNaN(bits) || bitsAreZero(bits))
+  // If x is infinity NaN or zero, return it.
+  if (bits.isInfOrNaN() || bits.isZero())
     return x;
 
-  bool isNeg = bits & Properties::signMask;
-  int exponent = getExponentFromBits(bits);
+  bool isNeg = bits.sign;
+  int exponent = bits.getExponent();
 
   // If the exponent is greater than the most negative mantissa
   // exponent, then x is already an integer.
-  if (exponent >= static_cast<int>(Properties::mantissaWidth))
+  if (exponent >= static_cast<int>(MantissaWidth<T>::value))
     return x;
 
   if (exponent == -1) {
     // Absolute value of x is greater than equal to 0.5 but less than 1.
     if (isNeg)
       return T(-1.0);
     else
       return T(1.0);
   }
 
   if (exponent <= -2) {
     // Absolute value of x is less than 0.5.
     if (isNeg)
       return T(-0.0);
     else
       return T(0.0);
   }
 
-  uint32_t trimSize = Properties::mantissaWidth - exponent;
+  uint32_t trimSize = MantissaWidth<T>::value - exponent;
+  bool halfBitSet = bits.mantissa & (UIntType(1) << (trimSize - 1));
+  bits.mantissa = (bits.mantissa >> trimSize) << trimSize;
+  T truncValue = T(bits);
+
   // If x is already an integer, return it.
-  if ((bits << (Properties::bitWidth - trimSize)) == 0)
+  if (truncValue == x)
     return x;
 
-  BitsType truncBits = (bits >> trimSize) << trimSize;
-  T truncValue = valueFromBits(truncBits);
-
-  if ((bits & (BitsType(1) << (trimSize - 1))) == 0) {
+  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);
   }
-
-  if (isNeg)
-    return truncValue - T(1.0);
-  else
-    return truncValue + T(1.0);
 }
 
 } // namespace fputil
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_UTILS_FPUTIL_NEAREST_INTEGER_OPERATIONS_H