[libc] Add implementations of nextafter[f|l] functions.

[sivachandra]

Summary

A differential fuzzer for these functions has also been added.
Along the way, a small correction has been done to the normal/subnormal
limits of x86 long double values.

[sivachandra]

Add a TODO about raising floating point exceptions in a later pass.

[sivachandra]

Add test source file missed previously.

[sivachandra]

Add nextafter* to the list of aarch64 entrypoints.

[lntue]

libc/utils/FPUtil/ManipulationFunctions.h

162–177

We can reduce the if-else chain a bit as follows:

if (from != T(0.0)) {
  if ((from < to) == (from > T(0.0)) {
    ++intVal;
  } else {
    --intVal;
  }
} else {
  intVal = (to.bitsAsUInt() & signMask) + UIntType(1);
}

[sivachandra]

Address comments.

libc/config/linux/x86_64/entrypoints.txt

set(TARGET_LIBM_ENTRYPOINTS
     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.nextafter
+    libc.src.math.nextafterf
+    libc.src.math.nextafterl
     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/fuzzing/math/CMakeLists.txt

DEPENDS
     libc.src.math.roundf
     libc.src.math.roundl
     libc.src.math.trunc
     libc.src.math.truncf
     libc.src.math.truncl
     libc.utils.FPUtil.fputil
     libc.utils.CPP.standalone_cpp
 )
+
+add_libc_fuzzer(
+  nextafter_differential_fuzz
+  SRCS
+    nextafter_differential_fuzz.cpp
+  HDRS
+    TwoInputSingleOutputDiff.h
+  DEPENDS
+    libc.src.math.nextafter
+    libc.src.math.nextafterf
+    libc.src.math.nextafterl
+)

libc/fuzzing/math/Compare.h

 //===-- Template functions to compare scalar values -------------*- 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_FUZZING_MATH_COMPARE_H
 #define LLVM_LIBC_FUZZING_MATH_COMPARE_H
 
 #include "utils/CPP/TypeTraits.h"
+#include "utils/FPUtil/FPBits.h"
 
 template <typename T>
 __llvm_libc::cpp::EnableIfType<__llvm_libc::cpp::IsFloatingPointType<T>::Value,
                                bool>
 ValuesEqual(T x1, T x2) {
   __llvm_libc::fputil::FPBits<T> bits1(x1);
   __llvm_libc::fputil::FPBits<T> bits2(x2);
   // If either is NaN, we want both to be NaN.

libc/fuzzing/math/nextafter_differential_fuzz.cpp

+//===-- nextafter_differential_fuzz.cpp
+//---------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+///
+/// Differential fuzz test for llvm-libc nextafter implementation.
+///
+//===----------------------------------------------------------------------===//
+
+#include "fuzzing/math/TwoInputSingleOutputDiff.h"
+
+#include "src/math/nextafter.h"
+#include "src/math/nextafterf.h"
+#include "src/math/nextafterl.h"
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+  TwoInputSingleOutputDiff<float, float>(&__llvm_libc::nextafterf,
+                                         &::nextafterf, data, size);
+  TwoInputSingleOutputDiff<double, double>(&__llvm_libc::nextafter,
+                                           &::nextafter, data, size);
+  return 0;
+}

libc/spec/stdc.td

HeaderSpec Math = HeaderSpec<
 
           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>]>,
+
+          FunctionSpec<"nextafterf", RetValSpec<FloatType>, [ArgSpec<FloatType>, ArgSpec<FloatType>]>,
+          FunctionSpec<"nextafter", RetValSpec<DoubleType>, [ArgSpec<DoubleType>, ArgSpec<DoubleType>]>,
+          FunctionSpec<"nextafterl", RetValSpec<LongDoubleType>, [ArgSpec<LongDoubleType>, ArgSpec<LongDoubleType>]>,
       ]
   >;
 
   HeaderSpec StdIO = HeaderSpec<
       "stdio.h",
       [], // Macros
       [ // Types
           SizeTType,

libc/src/math/CMakeLists.txt

SRCS
     hypot.cpp
   HDRS
     hypot.h
   DEPENDS
     libc.utils.FPUtil.fputil
   COMPILE_OPTIONS
     -O2
 )
+
+add_entrypoint_object(
+  nextafter
+  SRCS
+    nextafter.cpp
+  HDRS
+    nextafter.h
+  DEPENDS
+    libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
+)
+
+add_entrypoint_object(
+  nextafterf
+  SRCS
+    nextafterf.cpp
+  HDRS
+    nextafterf.h
+  DEPENDS
+    libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
+)
+
+add_entrypoint_object(
+  nextafterl
+  SRCS
+    nextafterl.cpp
+  HDRS
+    nextafterl.h
+  DEPENDS
+    libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
+)
+

libc/src/math/nextafter.h

+//===-- Implementation header for nextafter ---------------------*- 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_NEXTAFTER_H
+#define LLVM_LIBC_SRC_MATH_NEXTAFTER_H
+
+namespace __llvm_libc {
+
+double nextafter(double x, double y);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_MATH_NEXTAFTER_H

libc/src/math/nextafter.cpp

+//===-- Implementation of nextafter 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/ManipulationFunctions.h"
+
+namespace __llvm_libc {
+
+double LLVM_LIBC_ENTRYPOINT(nextafter)(double x, double y) {
+  return fputil::nextafter(x, y);
+}
+
+} // namespace __llvm_libc

libc/src/math/nextafterf.h

+//===-- Implementation header for nextafterf --------------------*- 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_NEXTAFTERF_H
+#define LLVM_LIBC_SRC_MATH_NEXTAFTERF_H
+
+namespace __llvm_libc {
+
+float nextafterf(float x, float y);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_MATH_NEXTAFTERF_H

libc/src/math/nextafterf.cpp

+//===-- Implementation of nextafterf 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/ManipulationFunctions.h"
+
+namespace __llvm_libc {
+
+float LLVM_LIBC_ENTRYPOINT(nextafterf)(float x, float y) {
+  return fputil::nextafter(x, y);
+}
+
+} // namespace __llvm_libc

libc/src/math/nextafterl.h

+//===-- Implementation header for nextafterl --------------------*- 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_NEXTAFTERL_H
+#define LLVM_LIBC_SRC_MATH_NEXTAFTERL_H
+
+namespace __llvm_libc {
+
+long double nextafterl(long double x, long double y);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_MATH_NEXTAFTERL_H

libc/src/math/nextafterl.cpp

+//===-- Implementation of nextafterl 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/ManipulationFunctions.h"
+
+namespace __llvm_libc {
+
+long double LLVM_LIBC_ENTRYPOINT(nextafterl)(long double x, long double y) {
+  return fputil::nextafter(x, y);
+}
+
+} // namespace __llvm_libc

libc/test/src/math/CMakeLists.txt

SUITE
     libc_math_unittests
   SRCS
     hypot_test.cpp
   DEPENDS
     libc.include.math
     libc.src.math.hypot
     libc.utils.FPUtil.fputil
 )
+
+add_fp_unittest(
+  nextafter_test
+  SUITE
+    libc_math_unittests
+  SRCS
+    nextafter_test.cpp
+  HDRS
+    NextAfterTest.h
+  DEPENDS
+    libc.include.math
+    libc.src.math.nextafter
+    libc.utils.FPUtil.fputil
+)
+
+add_fp_unittest(
+  nextafterf_test
+  SUITE
+    libc_math_unittests
+  SRCS
+    nextafterf_test.cpp
+  HDRS
+    NextAfterTest.h
+  DEPENDS
+    libc.include.math
+    libc.src.math.nextafterf
+    libc.utils.FPUtil.fputil
+)
+
+add_fp_unittest(
+  nextafterl_test
+  SUITE
+    libc_math_unittests
+  SRCS
+    nextafterl_test.cpp
+  HDRS
+    NextAfterTest.h
+  DEPENDS
+    libc.include.math
+    libc.src.math.nextafterl
+    libc.utils.FPUtil.fputil
+)

libc/test/src/math/NextAfterTest.h

+//===-- Utility class to test different flavors of nextafter ----*- 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_NEXTAFTERTEST_H
+#define LLVM_LIBC_TEST_SRC_MATH_NEXTAFTERTEST_H
+
+#include "utils/CPP/TypeTraits.h"
+#include "utils/FPUtil/BasicOperations.h"
+#include "utils/FPUtil/FPBits.h"
+#include "utils/FPUtil/TestHelpers.h"
+#include "utils/UnitTest/Test.h"
+#include <math.h>
+
+template <typename T>
+class NextAfterTestTemplate : public __llvm_libc::testing::Test {
+  using FPBits = __llvm_libc::fputil::FPBits<T>;
+  using MantissaWidth = __llvm_libc::fputil::MantissaWidth<T>;
+  using UIntType = typename FPBits::UIntType;
+
+#if (defined(__x86_64__) || defined(__i386__))
+  static constexpr int bitWidthOfType =
+      __llvm_libc::cpp::IsSame<T, long double>::Value ? 80 : (sizeof(T) * 8);
+#else
+  static constexpr int bitWidthOfType = sizeof(T) * 8;
+#endif
+
+  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);
+  const UIntType minSubnormal = FPBits::minSubnormal;
+  const UIntType maxSubnormal = FPBits::maxSubnormal;
+  const UIntType minNormal = FPBits::minNormal;
+  const UIntType maxNormal = FPBits::maxNormal;
+
+public:
+  typedef T (*NextAfterFunc)(T, T);
+
+  void testNaN(NextAfterFunc func) {
+    ASSERT_FP_EQ(func(nan, 0), nan);
+    ASSERT_FP_EQ(func(0, nan), nan);
+  }
+
+  void testBoundaries(NextAfterFunc func) {
+    ASSERT_FP_EQ(func(zero, negZero), negZero);
+    ASSERT_FP_EQ(func(negZero, zero), zero);
+
+    // 'from' is zero|negZero.
+    T x = zero;
+    T result = func(x, T(1));
+    UIntType expectedBits = 1;
+    T expected = *reinterpret_cast<T *>(&expectedBits);
+    ASSERT_FP_EQ(result, expected);
+
+    result = func(x, T(-1));
+    expectedBits = (UIntType(1) << (bitWidthOfType - 1)) + 1;
+    expected = *reinterpret_cast<T *>(&expectedBits);
+    ASSERT_FP_EQ(result, expected);
+
+    x = negZero;
+    result = func(x, 1);
+    expectedBits = 1;
+    expected = *reinterpret_cast<T *>(&expectedBits);
+    ASSERT_FP_EQ(result, expected);
+
+    result = func(x, -1);
+    expectedBits = (UIntType(1) << (bitWidthOfType - 1)) + 1;
+    expected = *reinterpret_cast<T *>(&expectedBits);
+    ASSERT_FP_EQ(result, expected);
+
+    // 'from' is max subnormal value.
+    x = *reinterpret_cast<const T *>(&maxSubnormal);
+    result = func(x, 1);
+    expected = *reinterpret_cast<const T *>(&minNormal);
+    ASSERT_FP_EQ(result, expected);
+
+    result = func(x, 0);
+    expectedBits = maxSubnormal - 1;
+    expected = *reinterpret_cast<T *>(&expectedBits);
+    ASSERT_FP_EQ(result, expected);
+
+    x = -x;
+
+    result = func(x, -1);
+    expectedBits = (UIntType(1) << (bitWidthOfType - 1)) + minNormal;
+    expected = *reinterpret_cast<T *>(&expectedBits);
+    ASSERT_FP_EQ(result, expected);
+
+    result = func(x, 0);
+    expectedBits = (UIntType(1) << (bitWidthOfType - 1)) + maxSubnormal - 1;
+    expected = *reinterpret_cast<T *>(&expectedBits);
+    ASSERT_FP_EQ(result, expected);
+
+    // 'from' is min subnormal value.
+    x = *reinterpret_cast<const T *>(&minSubnormal);
+    result = func(x, 1);
+    expectedBits = minSubnormal + 1;
+    expected = *reinterpret_cast<T *>(&expectedBits);
+    ASSERT_FP_EQ(result, expected);
+    ASSERT_FP_EQ(func(x, 0), 0);
+
+    x = -x;
+    result = func(x, -1);
+    expectedBits = (UIntType(1) << (bitWidthOfType - 1)) + minSubnormal + 1;
+    expected = *reinterpret_cast<T *>(&expectedBits);
+    ASSERT_FP_EQ(result, expected);
+    ASSERT_FP_EQ(func(x, 0), T(-0.0));
+
+    // 'from' is min normal.
+    x = *reinterpret_cast<const T *>(&minNormal);
+    result = func(x, 0);
+    expectedBits = maxSubnormal;
+    expected = *reinterpret_cast<T *>(&expectedBits);
+    ASSERT_FP_EQ(result, expected);
+
+    result = func(x, inf);
+    expectedBits = minNormal + 1;
+    expected = *reinterpret_cast<T *>(&expectedBits);
+    ASSERT_FP_EQ(result, expected);
+
+    x = -x;
+    result = func(x, 0);
+    expectedBits = (UIntType(1) << (bitWidthOfType - 1)) + maxSubnormal;
+    expected = *reinterpret_cast<T *>(&expectedBits);
+    ASSERT_FP_EQ(result, expected);
+
+    result = func(x, -inf);
+    expectedBits = (UIntType(1) << (bitWidthOfType - 1)) + minNormal + 1;
+    expected = *reinterpret_cast<T *>(&expectedBits);
+    ASSERT_FP_EQ(result, expected);
+
+    // 'from' is max normal and 'to' is infinity.
+    x = *reinterpret_cast<const T *>(&maxNormal);
+    result = func(x, inf);
+    ASSERT_FP_EQ(result, inf);
+
+    result = func(-x, -inf);
+    ASSERT_FP_EQ(result, -inf);
+
+    // 'from' is infinity.
+    x = inf;
+    result = func(x, 0);
+    expectedBits = maxNormal;
+    expected = *reinterpret_cast<T *>(&expectedBits);
+    ASSERT_FP_EQ(result, expected);
+    ASSERT_FP_EQ(func(x, inf), inf);
+
+    x = negInf;
+    result = func(x, 0);
+    expectedBits = (UIntType(1) << (bitWidthOfType - 1)) + maxNormal;
+    expected = *reinterpret_cast<T *>(&expectedBits);
+    ASSERT_FP_EQ(result, expected);
+    ASSERT_FP_EQ(func(x, negInf), negInf);
+
+    // 'from' is a power of 2.
+    x = T(32.0);
+    result = func(x, 0);
+    FPBits xBits = FPBits(x);
+    FPBits resultBits = FPBits(result);
+    ASSERT_EQ(resultBits.exponent, uint16_t(xBits.exponent - 1));
+    ASSERT_EQ(resultBits.mantissa, (UIntType(1) << MantissaWidth::value) - 1);
+
+    result = func(x, T(33.0));
+    resultBits = FPBits(result);
+    ASSERT_EQ(resultBits.exponent, xBits.exponent);
+    ASSERT_EQ(resultBits.mantissa, xBits.mantissa + UIntType(1));
+
+    x = -x;
+
+    result = func(x, 0);
+    resultBits = FPBits(result);
+    ASSERT_EQ(resultBits.exponent, uint16_t(xBits.exponent - 1));
+    ASSERT_EQ(resultBits.mantissa, (UIntType(1) << MantissaWidth::value) - 1);
+
+    result = func(x, T(-33.0));
+    resultBits = FPBits(result);
+    ASSERT_EQ(resultBits.exponent, xBits.exponent);
+    ASSERT_EQ(resultBits.mantissa, xBits.mantissa + UIntType(1));
+  }
+};
+
+#define LIST_NEXTAFTER_TESTS(T, func)                                          \
+  using NextAfterTest = NextAfterTestTemplate<T>;                              \
+  TEST_F(NextAfterTest, TestNaN) { testNaN(&func); }                           \
+  TEST_F(NextAfterTest, TestBoundaries) { testBoundaries(&func); }
+
+#endif // LLVM_LIBC_TEST_SRC_MATH_NEXTAFTERTEST_H

libc/test/src/math/nextafter_test.cpp

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

libc/test/src/math/nextafterf_test.cpp

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

libc/utils/FPUtil/LongDoubleBitsX86.h

 template <> struct __attribute__((packed)) FPBits<long double> {
   using UIntType = __uint128_t;
 
   static constexpr int exponentBias = 0x3FFF;
   static constexpr int maxExponent = 0x7FFF;
   static constexpr UIntType minSubnormal = UIntType(1);
   // Subnormal numbers include the implicit bit in x86 long double formats.
   static constexpr UIntType maxSubnormal =
-      (UIntType(1) << (MantissaWidth<long double>::value + 1)) - 1;
+      (UIntType(1) << (MantissaWidth<long double>::value)) - 1;
   static constexpr UIntType minNormal =
       (UIntType(3) << MantissaWidth<long double>::value);
   static constexpr UIntType maxNormal =
       ((UIntType(maxExponent) - 1) << (MantissaWidth<long double>::value + 1)) |
       (UIntType(1) << MantissaWidth<long double>::value) | maxSubnormal;
 
   UIntType mantissa : MantissaWidth<long double>::value;
   uint8_t implicitBit : 1;

libc/utils/FPUtil/ManipulationFunctions.h

if (exp < -expLimit)
     return bits.sign ? FPBits<T>::negZero() : FPBits<T>::zero();
 
   // For all other values, NormalFloat to T conversion handles it the right way.
   NormalFloat<T> normal(bits);
   normal.exponent += exp;
   return normal;
 }
 
+template <typename T,
+          cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
+static inline T nextafter(T from, T to) {
+  FPBits<T> fromBits(from);
+  if (fromBits.isNaN())
+    return from;
+
+  FPBits<T> toBits(to);
+  if (toBits.isNaN())
+    return to;
+
+  if (from == to)
+    return to;
+
+  using UIntType = typename FPBits<T>::UIntType;
+  auto intVal = fromBits.bitsAsUInt();
+  if (from < T(0.0)) {
+    if (from > to)
+      ++intVal;
+    else
+      --intVal;
+  } else if (from == T(0.0)) {
+    if (from > to)
+      intVal = (UIntType(1) << (sizeof(UIntType) * 8 - 1)) + 1;
+    else
+      intVal = 1;
+  } else {
+    if (from > to)
+      --intVal;
+    else
+      ++intVal;
+  }
+
+  return *reinterpret_cast<T *>(&intVal);
+  // TODO: Raise floating point exceptions as required by the standard.
+}
+
 } // namespace fputil
 } // namespace __llvm_libc
 
+#if (defined(__x86_64__) || defined(__i386__))
+#include "NextAfterLongDoubleX86.h"
+#endif // defined(__x86_64__) || defined(__i386__)
+
 #endif // LLVM_LIBC_UTILS_FPUTIL_MANIPULATION_FUNCTIONS_H

libc/utils/FPUtil/NextAfterLongDoubleX86.h

+//===-- nextafter implementation for x86 long double numbers ----*- 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_NEXT_AFTER_LONG_DOUBLE_X86_H
+#define LLVM_LIBC_UTILS_FPUTIL_NEXT_AFTER_LONG_DOUBLE_X86_H
+
+#include "FPBits.h"
+
+#include <stdint.h>
+
+namespace __llvm_libc {
+namespace fputil {
+
+static inline long double nextafter(long double from, long double to) {
+  using FPBits = FPBits<long double>;
+  FPBits fromBits(from);
+  if (fromBits.isNaN())
+    return from;
+
+  FPBits toBits(to);
+  if (toBits.isNaN())
+    return to;
+
+  if (from == to)
+    return to;
+
+  // Convert pseudo subnormal number to normal number.
+  if (fromBits.implicitBit == 1 && fromBits.exponent == 0) {
+    fromBits.exponent = 1;
+  }
+
+  using UIntType = FPBits::UIntType;
+  constexpr UIntType signVal = (UIntType(1) << 79);
+  constexpr UIntType mantissaMask =
+      (UIntType(1) << MantissaWidth<long double>::value) - 1;
+  auto intVal = fromBits.bitsAsUInt();
+  if (from < 0.0l) {
+    if (from > to) {
+      if (intVal == (signVal + FPBits::maxSubnormal)) {
+        // We deal with normal/subnormal boundary separately to avoid
+        // dealing with the implicit bit.
+        intVal = signVal + FPBits::minNormal;
+      } else if ((intVal & mantissaMask) == mantissaMask) {
+        fromBits.mantissa = 0;
+        // Incrementing exponent might overflow the value to infinity,
+        // which is what is expected. Since NaNs are handling separately,
+        // it will never overflow "beyond" infinity.
+        ++fromBits.exponent;
+        return fromBits;
+      } else {
+        ++intVal;
+      }
+    } else {
+      if (intVal == (signVal + FPBits::minNormal)) {
+        // We deal with normal/subnormal boundary separately to avoid
+        // dealing with the implicit bit.
+        intVal = signVal + FPBits::maxSubnormal;
+      } else if ((intVal & mantissaMask) == 0) {
+        fromBits.mantissa = mantissaMask;
+        // from == 0 is handled separately so decrementing the exponent will not
+        // lead to underflow.
+        --fromBits.exponent;
+        return fromBits;
+      } else {
+        --intVal;
+      }
+    }
+  } else if (from == 0.0l) {
+    if (from > to)
+      intVal = signVal + 1;
+    else
+      intVal = 1;
+  } else {
+    if (from > to) {
+      if (intVal == FPBits::minNormal) {
+        intVal = FPBits::maxSubnormal;
+      } else if ((intVal & mantissaMask) == 0) {
+        fromBits.mantissa = mantissaMask;
+        // from == 0 is handled separately so decrementing the exponent will not
+        // lead to underflow.
+        --fromBits.exponent;
+        return fromBits;
+      } else {
+        --intVal;
+      }
+    } else {
+      if (intVal == FPBits::maxSubnormal) {
+        intVal = FPBits::minNormal;
+      } else if ((intVal & mantissaMask) == mantissaMask) {
+        fromBits.mantissa = 0;
+        // Incrementing exponent might overflow the value to infinity,
+        // which is what is expected. Since NaNs are handling separately,
+        // it will never overflow "beyond" infinity.
+        ++fromBits.exponent;
+        return fromBits;
+      } else {
+        ++intVal;
+      }
+    }
+  }
+
+  return *reinterpret_cast<long double *>(&intVal);
+  // TODO: Raise floating point exceptions as required by the standard.
+}
+
+} // namespace fputil
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_UTILS_FPUTIL_NEXT_AFTER_LONG_DOUBLE_X86_H