[libc] Add implementations of fdim[f|l].

[lntue]

Summary

Implementing fdim, fdimf, and fdiml for llvm-libc.

[sivachandra]

libc/test/src/math/FDimTest.h

15

To be consistent with other places, do not put the test classes in the any namespace.

24

Can you move this declaration out of the method? This way, other methods can also use them without redeclarations?

libc/test/src/math/fdim_test.cpp

17

We don't need these. I will clean it up in the ilogb tests.

libc/utils/FPUtil/BasicOperations.h

78

The operation x - y can lead to overflow or underflow. Shouldn't we detect that and return the appropriate value as specified by the standard? Or, should we assume that the machine instruction does the right thing?

[lntue]

[libc] Add implementations of fdim[f|l].

[lntue]

[libc] Add implementations of fdim[f|l].

[lntue]

Update constants for FDimTest.

[lntue]

libc/test/src/math/FDimTest.h

24

FPBits class cannot be constexpr yet, so we cannot have these constants as static members of the class yet. I moved them out as const members instead.

libc/utils/FPUtil/BasicOperations.h

78

We are assuming CPU's supporting IEEE 754 arithmetic, so the machine instruction will do the right thing. For example the spec specified to return HUGE_VAL in case of overflow, which is resolved to inf for IEEE 754 standard.

[sivachandra]

libc/test/src/math/FDimTest.h

24

LGTM.

libc/utils/FPUtil/BasicOperations.h

78

SGTM. So, in general, out position is:

If we use a language operator for a floating point operation, then we assume that the machine instruction (or instructions) implementing the operator conform to the IEEE-754 standard.

Does that sound reasonable?

[lntue]

libc/utils/FPUtil/BasicOperations.h

78

SGTM

libc/config/linux/aarch64/entrypoints.txt

set(TARGET_LIBM_ENTRYPOINTS
     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.fdim
+    libc.src.math.fdimf
+    libc.src.math.fdiml
     libc.src.math.floor
     libc.src.math.floorf
     libc.src.math.floorl
     libc.src.math.fmax
     libc.src.math.fmaxf
     libc.src.math.fmaxl
     libc.src.math.fmin
     libc.src.math.fminf

libc/config/linux/x86_64/entrypoints.txt

set(TARGET_LIBM_ENTRYPOINTS
     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.fdim
+    libc.src.math.fdimf
+    libc.src.math.fdiml
     libc.src.math.floor
     libc.src.math.floorf
     libc.src.math.floorl
     libc.src.math.fmin
     libc.src.math.fminf
     libc.src.math.fminl
     libc.src.math.fmax
     libc.src.math.fmaxf

libc/spec/stdc.td

HeaderSpec Math = HeaderSpec<
           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<"fdim", RetValSpec<DoubleType>, [ArgSpec<DoubleType>]>,
+          FunctionSpec<"fdimf", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
+          FunctionSpec<"fdiml", RetValSpec<LongDoubleType>, [ArgSpec<LongDoubleType>]>,
+
           FunctionSpec<"floor", RetValSpec<DoubleType>, [ArgSpec<DoubleType>]>,
           FunctionSpec<"floorf", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
           FunctionSpec<"floorl", RetValSpec<LongDoubleType>, [ArgSpec<LongDoubleType>]>,
 
           FunctionSpec<"fmin", RetValSpec<DoubleType>, [ArgSpec<DoubleType>, ArgSpec<DoubleType>]>,
           FunctionSpec<"fminf", RetValSpec<FloatType>, [ArgSpec<FloatType>, ArgSpec<FloatType>]>,
           FunctionSpec<"fminl", RetValSpec<LongDoubleType>, [ArgSpec<LongDoubleType>, ArgSpec<LongDoubleType>]>,
 

libc/src/math/CMakeLists.txt

SRCS
     hypotf.cpp
   HDRS
     hypotf.h
   DEPENDS
     libc.utils.FPUtil.fputil
   COMPILE_OPTIONS
     -O2
 )
+
+add_entrypoint_object(
+  fdim
+  SRCS
+    fdim.cpp
+  HDRS
+    fdim.h
+  DEPENDS
+    libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
+)
+
+add_entrypoint_object(
+  fdimf
+  SRCS
+    fdimf.cpp
+  HDRS
+    fdimf.h
+  DEPENDS
+    libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
+)
+
+add_entrypoint_object(
+  fdiml
+  SRCS
+    fdiml.cpp
+  HDRS
+    fdiml.h
+  DEPENDS
+    libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
+)

libc/src/math/fdim.h

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

libc/src/math/fdim.cpp

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

libc/src/math/fdimf.h

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

libc/src/math/fdimf.cpp

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

libc/src/math/fdiml.h

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

libc/src/math/fdiml.cpp

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

libc/test/src/math/CMakeLists.txt

SRCS
     modfl_test.cpp
   DEPENDS
     libc.include.math
     libc.src.math.modfl
     libc.utils.FPUtil.fputil
 )
 
 add_fp_unittest(
+  fdimf_test
+  SUITE
+    libc_math_unittests
+  SRCS
+    fdimf_test.cpp
+  HDRS
+    FDimTest.h
+  DEPENDS
+    libc.include.math
+    libc.src.math.fdimf
+    libc.utils.FPUtil.fputil
+)
+
+add_fp_unittest(
+  fdim_test
+  SUITE
+    libc_math_unittests
+  SRCS
+    fdim_test.cpp
+  HDRS
+    FDimTest.h
+  DEPENDS
+    libc.include.math
+    libc.src.math.fdim
+    libc.utils.FPUtil.fputil
+)
+
+add_fp_unittest(
+  fdiml_test
+  SUITE
+    libc_math_unittests
+  SRCS
+    fdiml_test.cpp
+  HDRS
+    FDimTest.h
+  DEPENDS
+    libc.include.math
+    libc.src.math.fdiml
+    libc.utils.FPUtil.fputil
+)
+
+add_fp_unittest(
   fminf_test
   SUITE
     libc_math_unittests
   SRCS
     fminf_test.cpp
   DEPENDS
     libc.include.math
     libc.src.math.fminf

libc/test/src/math/FDimTest.h

+//===-- Utility class to test different flavors of fdim ---------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===---------------------------------------------------------------------===//
+
+#include "include/math.h"
+#include "utils/FPUtil/BasicOperations.h"
+#include "utils/FPUtil/FPBits.h"
+#include "utils/FPUtil/TestHelpers.h"
+#include "utils/UnitTest/Test.h"
+
+namespace __llvm_libc {
+namespace testing {
+template <typename T> class FDimTest : public __llvm_libc::testing::Test {
+public:
+  using FuncPtr = T (*)(T, T);
+  using FPBits = __llvm_libc::fputil::FPBits<T>;
+  using UIntType = typename FPBits::UIntType;
+
+  void testNaNArg(FuncPtr func) {
+    DECLARE_SPECIAL_CONSTANTS(T)
+    EXPECT_FP_EQ(nan, func(nan, inf));
+    EXPECT_FP_EQ(nan, func(negInf, nan));
+    EXPECT_FP_EQ(nan, func(nan, zero));
+    EXPECT_FP_EQ(nan, func(negZero, nan));
+    EXPECT_FP_EQ(nan, func(nan, T(-1.2345)));
+    EXPECT_FP_EQ(nan, func(T(1.2345), nan));
+    EXPECT_NE(isnan(func(nan, nan)), 0);
+  }
+
+  void testInfArg(FuncPtr func) {
+    const T zero = FPBits::zero();
+    const T negZero = FPBits::negZero();
+    const T inf = FPBits::inf();
+    const T negInf = FPBits::negInf();
+    EXPECT_FP_EQ(zero, func(negInf, inf));
+    EXPECT_FP_EQ(inf, func(inf, zero));
+    EXPECT_FP_EQ(zero, func(negZero, inf));
+    EXPECT_FP_EQ(inf, func(inf, T(1.2345)));
+    EXPECT_FP_EQ(zero, func(T(-1.2345), inf));
+  }
+
+  void testNegInfArg(FuncPtr func) {
+    const T zero = FPBits::zero();
+    const T negZero = FPBits::negZero();
+    const T inf = FPBits::inf();
+    const T negInf = FPBits::negInf();
+    EXPECT_FP_EQ(inf, func(inf, negInf));
+    EXPECT_FP_EQ(zero, func(negInf, zero));
+    EXPECT_FP_EQ(inf, func(negZero, negInf));
+    EXPECT_FP_EQ(zero, func(negInf, T(-1.2345)));
+    EXPECT_FP_EQ(inf, func(T(1.2345), negInf));
+  }
+
+  void testBothZero(FuncPtr func) {
+    const T zero = FPBits::zero();
+    const T negZero = FPBits::negZero();
+    EXPECT_FP_EQ(zero, func(zero, zero));
+    EXPECT_FP_EQ(zero, func(zero, negZero));
+    EXPECT_FP_EQ(zero, func(negZero, zero));
+    EXPECT_FP_EQ(zero, func(negZero, negZero));
+  }
+
+  void testInRange(FuncPtr func) {
+    const T zero = FPBits::zero();
+    constexpr UIntType count = 10000001;
+    constexpr UIntType step = UIntType(-1) / count;
+    for (UIntType i = 0, v = 0, w = UIntType(-1); i <= count;
+         ++i, v += step, w -= step) {
+      T x = FPBits(v), y = FPBits(w);
+      if (isnan(x) || isinf(x))
+        continue;
+      if (isnan(y) || isinf(y))
+        continue;
+
+      if (x > y) {
+        EXPECT_FP_EQ(x - y, func(x, y));
+      } else {
+        EXPECT_FP_EQ(zero, func(x, y));
+      }
+    }
+  }
+};
+
+} // namespace testing
+} // namespace __llvm_libc

libc/test/src/math/fdim_test.cpp

+//===-- Unittests for fdim ------------------------------------------------===//
+//
+// 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 "FDimTest.h"
+
+#include "include/math.h"
+#include "src/math/fdim.h"
+#include "utils/FPUtil/FPBits.h"
+#include "utils/FPUtil/TestHelpers.h"
+#include "utils/UnitTest/Test.h"
+
+using RunContext = __llvm_libc::testing::RunContext;
+
+using FDimTest = __llvm_libc::testing::FDimTest<double>;
+
+TEST_F(FDimTest, NaNArg_fdim) { testNaNArg(&__llvm_libc::fdim); }
+
+TEST_F(FDimTest, InfArg_fdim) { testInfArg(&__llvm_libc::fdim); }
+
+TEST_F(FDimTest, NegInfArg_fdim) { testNegInfArg(&__llvm_libc::fdim); }
+
+TEST_F(FDimTest, BothZero_fdim) { testBothZero(&__llvm_libc::fdim); }
+
+TEST_F(FDimTest, InDoubleRange_fdim) { testInRange(&__llvm_libc::fdim); }

libc/test/src/math/fdimf_test.cpp

+//===-- Unittests for fdimf -----------------------------------------------===//
+//
+// 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 "FDimTest.h"
+
+#include "include/math.h"
+#include "src/math/fdimf.h"
+#include "utils/FPUtil/FPBits.h"
+#include "utils/FPUtil/TestHelpers.h"
+#include "utils/UnitTest/Test.h"
+
+using RunContext = __llvm_libc::testing::RunContext;
+
+using FDimTest = __llvm_libc::testing::FDimTest<float>;
+
+TEST_F(FDimTest, NaNArg_fdimf) { testNaNArg(&__llvm_libc::fdimf); }
+
+TEST_F(FDimTest, InfArg_fdimf) { testInfArg(&__llvm_libc::fdimf); }
+
+TEST_F(FDimTest, NegInfArg_fdimf) { testNegInfArg(&__llvm_libc::fdimf); }
+
+TEST_F(FDimTest, BothZero_fdimf) { testBothZero(&__llvm_libc::fdimf); }
+
+TEST_F(FDimTest, InFloatRange_fdimf) { testInRange(&__llvm_libc::fdimf); }

libc/test/src/math/fdiml_test.cpp

+//===-- Unittests for fdiml -----------------------------------------------===//
+//
+// 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 "FDimTest.h"
+
+#include "include/math.h"
+#include "src/math/fdiml.h"
+#include "utils/FPUtil/FPBits.h"
+#include "utils/FPUtil/TestHelpers.h"
+#include "utils/UnitTest/Test.h"
+
+using RunContext = __llvm_libc::testing::RunContext;
+
+using FDimTest = __llvm_libc::testing::FDimTest<long double>;
+
+TEST_F(FDimTest, NaNArg_fdiml) { testNaNArg(&__llvm_libc::fdiml); }
+
+TEST_F(FDimTest, InfArg_fdiml) { testInfArg(&__llvm_libc::fdiml); }
+
+TEST_F(FDimTest, NegInfArg_fdiml) { testNegInfArg(&__llvm_libc::fdiml); }
+
+TEST_F(FDimTest, BothZero_fdiml) { testBothZero(&__llvm_libc::fdiml); }
+
+TEST_F(FDimTest, InLongDoubleRange_fdiml) { testInRange(&__llvm_libc::fdiml); }

libc/utils/FPUtil/BasicOperations.h

if (bitx.isNaN()) {
     // y has different signs and both are not NaNs, we return the number
     // with positive sign.
     return (bitx.sign ? y : x);
   } else {
     return (x > y ? x : y);
   }
 }
 
+template <typename T,
+          cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
+static inline T fdim(T x, T y) {
+  FPBits<T> bitx(x), bity(y);
+
+  if (bitx.isNaN()) {
+    return x;
+  }
+
+  if (bity.isNaN()) {
+    return y;
+  }
+
+  return (x > y ? x - y : 0);
+}
+
 } // namespace fputil
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_UTILS_FPUTIL_BASIC_OPERATIONS_H