[libc] Add implementation of fabs and fabsf.

[sivachandra]

Summary

Depends on D79724.

[phosek]

LGTM

libc/config/linux/api.td

let Macros = [
     IsNanMacro,
   ];
   let TypeDeclarations = [
     DoubleT,
     FloatT,
   ];
   let Functions = [
    "cosf",
+   "fabs",
+   "fabsf",
    "round",
    "sincosf",
    "sinf",
   ];
 }
 
 def StringAPI : PublicAPI<"string.h"> {
   let Functions = [

libc/lib/CMakeLists.txt

DEPENDS
     libc.src.unistd.write
 )
 
 add_entrypoint_library(
   llvmlibm
   DEPENDS
     # math.h entrypoints
     libc.src.math.cosf
+    libc.src.math.fabs
+    libc.src.math.fabsf
     libc.src.math.round
     libc.src.math.sincosf
     libc.src.math.sinf
 )
 
 add_redirector_library(
   llvmlibc_redirectors
   DEPENDS
     round_redirector
 )

libc/spec/stdc.td

HeaderSpec Math = HeaderSpec<
           Macro<"isnan">,
       ],
       [
           NamedType<"float_t">,
           NamedType<"double_t">,
       ],
       [], // Enumerations
       [
+          FunctionSpec<"fabs", RetValSpec<DoubleType>, [ArgSpec<DoubleType>]>,
+          FunctionSpec<"fabsf", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
+
           FunctionSpec<"cosf", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
           FunctionSpec<"sinf", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
 
           FunctionSpec<"round", RetValSpec<DoubleType>, [ArgSpec<DoubleType>]>,
       ]
   >;
 
   HeaderSpec StdIO = HeaderSpec<

libc/src/math/CMakeLists.txt

SRCS
     sincosf.cpp
   HDRS
     sincosf.h
   DEPENDS
     .sincosf_utils
     libc.include.math
     libc.src.errno.__errno_location
 )
+
+add_entrypoint_object(
+  fabs
+  SRCS
+    fabs.cpp
+  HDRS
+    fabs.h
+  DEPENDS
+    libc.utils.FPUtil.fputil
+)
+
+add_entrypoint_object(
+  fabsf
+  SRCS
+    fabsf.cpp
+  HDRS
+    fabsf.h
+  DEPENDS
+    libc.utils.FPUtil.fputil
+)

libc/src/math/fabs.h

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

libc/src/math/fabs.cpp

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

libc/src/math/fabsf.h

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

libc/src/math/fabsf.cpp

+//===-- Implementation of fabsf 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/FloatOperations.h"
+
+namespace __llvm_libc {
+
+float LLVM_LIBC_ENTRYPOINT(fabsf)(float x) { return fputil::abs(x); }
+
+} // namespace __llvm_libc

libc/test/src/math/CMakeLists.txt

add_math_unittest(
   HDRS
     sdcomp26094.h
   DEPENDS
     libc.include.errno
     libc.src.math.sincosf
     libc.utils.CPP.standalone_cpp
     libc.utils.FPUtil.fputil
 )
+
+add_math_unittest(
+  fabs_test
+  NEED_MPFR
+  SUITE
+    libc_math_unittests
+  SRCS
+    fabs_test.cpp
+  DEPENDS
+    libc.include.math
+    libc.src.math.fabs
+    libc.utils.FPUtil.fputil
+)
+
+add_math_unittest(
+  fabsf_test
+  NEED_MPFR
+  SUITE
+    libc_math_unittests
+  SRCS
+    fabsf_test.cpp
+  DEPENDS
+    libc.include.math
+    libc.src.math.fabsf
+    libc.utils.FPUtil.fputil
+)

libc/test/src/math/fabs_test.cpp

+//===-- Unittests for fabs ------------------------------------------------===//
+//
+// 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/fabs.h"
+#include "utils/FPUtil/BitPatterns.h"
+#include "utils/FPUtil/FloatOperations.h"
+#include "utils/FPUtil/FloatProperties.h"
+#include "utils/MPFRWrapper/MPFRUtils.h"
+#include "utils/UnitTest/Test.h"
+
+using __llvm_libc::fputil::valueAsBits;
+using __llvm_libc::fputil::valueFromBits;
+
+using BitPatterns = __llvm_libc::fputil::BitPatterns<double>;
+using Properties = __llvm_libc::fputil::FloatProperties<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(FabsTest, SpecialNumbers) {
+  EXPECT_EQ(
+      BitPatterns::aQuietNaN,
+      valueAsBits(__llvm_libc::fabs(valueFromBits(BitPatterns::aQuietNaN))));
+  EXPECT_EQ(BitPatterns::aQuietNaN, valueAsBits(__llvm_libc::fabs(valueFromBits(
+                                        BitPatterns::aNegativeQuietNaN))));
+
+  EXPECT_EQ(BitPatterns::aSignallingNaN,
+            valueAsBits(
+                __llvm_libc::fabs(valueFromBits(BitPatterns::aSignallingNaN))));
+  EXPECT_EQ(BitPatterns::aSignallingNaN,
+            valueAsBits(__llvm_libc::fabs(
+                valueFromBits(BitPatterns::aNegativeSignallingNaN))));
+
+  EXPECT_EQ(BitPatterns::inf,
+            valueAsBits(__llvm_libc::fabs(valueFromBits(BitPatterns::inf))));
+  EXPECT_EQ(BitPatterns::inf,
+            valueAsBits(__llvm_libc::fabs(valueFromBits(BitPatterns::negInf))));
+
+  EXPECT_EQ(BitPatterns::zero,
+            valueAsBits(__llvm_libc::fabs(valueFromBits(BitPatterns::zero))));
+  EXPECT_EQ(BitPatterns::zero, valueAsBits(__llvm_libc::fabs(
+                                   valueFromBits(BitPatterns::negZero))));
+}
+
+TEST(FabsTest, InDoubleRange) {
+  using BitsType = Properties::BitsType;
+  constexpr BitsType count = 1000000;
+  constexpr BitsType step = UINT64_MAX / count;
+  for (BitsType i = 0, v = 0; i <= count; ++i, v += step) {
+    double x = valueFromBits(v);
+    if (isnan(x) || isinf(x))
+      continue;
+    ASSERT_MPFR_MATCH(mpfr::OP_Abs, x, __llvm_libc::fabs(x), tolerance);
+  }
+}

libc/test/src/math/fabsf_test.cpp

+//===-- Unittests for fabsf -----------------------------------------------===//
+//
+// 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/fabsf.h"
+#include "utils/FPUtil/BitPatterns.h"
+#include "utils/FPUtil/FloatOperations.h"
+#include "utils/FPUtil/FloatProperties.h"
+#include "utils/MPFRWrapper/MPFRUtils.h"
+#include "utils/UnitTest/Test.h"
+
+using __llvm_libc::fputil::valueAsBits;
+using __llvm_libc::fputil::valueFromBits;
+
+using BitPatterns = __llvm_libc::fputil::BitPatterns<float>;
+using Properties = __llvm_libc::fputil::FloatProperties<float>;
+
+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};
+
+namespace mpfr = __llvm_libc::testing::mpfr;
+TEST(FabsfTest, SpecialNumbers) {
+  EXPECT_EQ(
+      BitPatterns::aQuietNaN,
+      valueAsBits(__llvm_libc::fabsf(valueFromBits(BitPatterns::aQuietNaN))));
+  EXPECT_EQ(BitPatterns::aQuietNaN,
+            valueAsBits(__llvm_libc::fabsf(
+                valueFromBits(BitPatterns::aNegativeQuietNaN))));
+
+  EXPECT_EQ(BitPatterns::aSignallingNaN,
+            valueAsBits(__llvm_libc::fabsf(
+                valueFromBits(BitPatterns::aSignallingNaN))));
+  EXPECT_EQ(BitPatterns::aSignallingNaN,
+            valueAsBits(__llvm_libc::fabsf(
+                valueFromBits(BitPatterns::aNegativeSignallingNaN))));
+
+  EXPECT_EQ(BitPatterns::inf,
+            valueAsBits(__llvm_libc::fabsf(valueFromBits(BitPatterns::inf))));
+  EXPECT_EQ(BitPatterns::inf, valueAsBits(__llvm_libc::fabsf(
+                                  valueFromBits(BitPatterns::negInf))));
+
+  EXPECT_EQ(BitPatterns::zero,
+            valueAsBits(__llvm_libc::fabsf(valueFromBits(BitPatterns::zero))));
+  EXPECT_EQ(BitPatterns::zero, valueAsBits(__llvm_libc::fabsf(
+                                   valueFromBits(BitPatterns::negZero))));
+}
+
+TEST(FabsfTest, InFloatRange) {
+  using BitsType = Properties::BitsType;
+  constexpr BitsType count = 1000000;
+  constexpr BitsType step = UINT32_MAX / count;
+  for (BitsType i = 0, v = 0; i <= count; ++i, v += step) {
+    double x = valueFromBits(v);
+    if (isnan(x) || isinf(x))
+      continue;
+    ASSERT_MPFR_MATCH(mpfr::OP_Abs, x, __llvm_libc::fabsf(x), tolerance);
+  }
+}

libc/utils/FPUtil/FloatOperations.h

 static inline bool isNegativeQuietNaN(T x) {
   using Properties = FloatProperties<T>;
   using BitsType = typename FloatProperties<T>::BitsType;
   BitsType bits = valueAsBits(x);
   return ((bits & BitPatterns<T>::negInf) == BitPatterns<T>::negInf) &&
          ((bits & Properties::quietNaNMask) != 0);
 }
 
+// Return the absolute value of x.
+template <typename T,
+          cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
+static inline T abs(T x) {
+  return valueFromBits(absBits(x));
+}
+
 } // namespace fputil
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_UTILS_FPUTIL_FLOAT_OPERATIONS_H

libc/utils/MPFRWrapper/MPFRUtils.h

struct Tolerance {
 
   // The bits in the tolerance value. The tolerance value will be
   // sum(bits[width - i] * 2 ^ (- basePrecision - i)) for |i| in
   // range [1, width].
   uint32_t bits;
 };
 
 enum Operation {
+  OP_Abs,
   OP_Cos,
   OP_Sin,
 };
 
 namespace internal {
 
 template <typename T>
 bool compare(Operation op, T input, T libcOutput, const Tolerance &t);

libc/utils/MPFRWrapper/MPFRUtils.cpp

public:
   }
 
   template <typename XType,
             cpp::EnableIfType<cpp::IsFloatingPointType<XType>::Value, int> = 0>
   MPFRNumber(Operation op, XType rawValue) {
     mpfr_init2(value, mpfrPrecision);
     MPFRNumber mpfrInput(rawValue);
     switch (op) {
+    case OP_Abs:
+      mpfr_abs(value, mpfrInput.value, MPFR_RNDN);
+      break;
     case OP_Cos:
       mpfr_cos(value, mpfrInput.value, MPFR_RNDN);
       break;
     case OP_Sin:
       mpfr_sin(value, mpfrInput.value, MPFR_RNDN);
       break;
     }
   }