Onboard signbitf to llvmlibc math functions.

[renyichen]

Summary

signbitf is implemented here with get_sign util.

Unit tests added. Different from existing functions, signbit output type is bool, so MPFRUtils expose the MPFR signbit function for unit test comparison instead of using (EXPECT/ASSERT)_MPFR_MATCH.

[renyichen]

Exhaustive/Performance tests might not be applicable for signbit. If desired, we may patch it here.

[renyichen]

clang-format

[lntue]

libc/src/math/generic/CMakeLists.txt

1393

-O3 should be fine.

1395

Please fix

[sivachandra]

libc/spec/stdc.td

467

Is signbitf really specified by the C standard? For that matter, any standard at all? I think standards only specify a generic signbit macro which can be implemented as:

#define signbit(x) __builtin_signbit(x)

[renyichen]

fputil vs builtin functions.

libc/spec/stdc.td

467

I see (I should but didn't check the C standard). I probably should implement this in a separate code change-list.

Thanks for the insight and I have several questions (which does not necessarily make sense =p): do we plan to implement a bunch of functions that rely on builtin_functions (isnan, isfinite, is_greater etc)? If so, can we rely on the builtin_functions in terms of existence/correctness/speed of builtin functions given that llvmlibc has its own fputils?

[sivachandra]

libc/spec/stdc.td

467

For items like isnan, signbit etc., all that needs to be done is to read one bit from the encoded floating point object. So, the builtins should not create recursive calls back to the libc. What will they call even if they want to as there is no equivalent libc function? It could be that a particular builtin is not implemented for a certain target. We can revisit your patch if and when we encounter such a target.

[renyichen]

libc/spec/stdc.td

467

Thanks for the explanation! I talked with lntue@ offline, and decided to leave isnan, signbit etc as they are for now and try to implement other functions.

libc/config/linux/aarch64/entrypoints.txt

set(TARGET_LIBM_ENTRYPOINTS
     libc.src.math.remquo
     libc.src.math.remquol
     libc.src.math.rint
     libc.src.math.rintf
     libc.src.math.rintl
     libc.src.math.round
     libc.src.math.roundf
     libc.src.math.roundl
+    libc.src.math.signbitf
     libc.src.math.sincosf
     libc.src.math.sinhf
     libc.src.math.sinf
     libc.src.math.sqrt
     libc.src.math.sqrtf
     libc.src.math.sqrtl
     libc.src.math.tanf
     libc.src.math.tanhf

libc/config/linux/x86_64/entrypoints.txt

set(TARGET_LIBM_ENTRYPOINTS
     libc.src.math.remquo
     libc.src.math.remquol
     libc.src.math.rint
     libc.src.math.rintf
     libc.src.math.rintl
     libc.src.math.round
     libc.src.math.roundf
     libc.src.math.roundl
+    libc.src.math.signbitf
     libc.src.math.sin
     libc.src.math.sincosf
     libc.src.math.sinhf
     libc.src.math.sinf
     libc.src.math.sqrt
     libc.src.math.sqrtf
     libc.src.math.sqrtl
     libc.src.math.tan

libc/spec/stdc.td

HeaderSpec Math = HeaderSpec<
           FunctionSpec<"lrint", RetValSpec<LongType>, [ArgSpec<DoubleType>]>,
           FunctionSpec<"lrintf", RetValSpec<LongType>, [ArgSpec<FloatType>]>,
           FunctionSpec<"lrintl", RetValSpec<LongType>, [ArgSpec<LongDoubleType>]>,
 
           FunctionSpec<"llrint", RetValSpec<LongLongType>, [ArgSpec<DoubleType>]>,
           FunctionSpec<"llrintf", RetValSpec<LongLongType>, [ArgSpec<FloatType>]>,
           FunctionSpec<"llrintl", RetValSpec<LongLongType>, [ArgSpec<LongDoubleType>]>,
 
+          FunctionSpec<"signbitf", RetValSpec<BoolType>, [ArgSpec<FloatType>]>,
+
           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/__support/FPUtil/ManipulationFunctions.h

if (x == iptr) {
       return bits.get_sign() ? T(FPBits<T>::neg_zero()) : T(FPBits<T>::zero());
     } else {
       return x - iptr;
     }
   }
 }
 
 template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0>
+static inline T signbit(T x) {
+  return FPBits<T>(x).get_sign();
+}
+
+template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0>
 static inline T copysign(T x, T y) {
   FPBits<T> xbits(x);
   xbits.set_sign(FPBits<T>(y).get_sign());
   return T(xbits);
 }
 
 template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0>
 static inline int ilogb(T x) {

libc/src/math/CMakeLists.txt

 add_math_entrypoint_object(rint)
 add_math_entrypoint_object(rintf)
 add_math_entrypoint_object(rintl)
 
 add_math_entrypoint_object(round)
 add_math_entrypoint_object(roundf)
 add_math_entrypoint_object(roundl)
 
+add_math_entrypoint_object(signbitf)
+
 add_math_entrypoint_object(sincosf)
 
 add_math_entrypoint_object(sin)
 add_math_entrypoint_object(sinf)
 add_math_entrypoint_object(sinhf)
 
 add_math_entrypoint_object(sqrt)
 add_math_entrypoint_object(sqrtf)

libc/src/math/generic/CMakeLists.txt

add_entrypoint_object(
   HDRS
     ../pow.h
   DEPENDS
     .expf
     .logf
   COMPILE_OPTIONS
     -O3
 )
+
+add_entrypoint_object(
+  signbitf
+  SRCS
+    signbitf.cpp
+  HDRS
+    ../signbitf.h
+  DEPENDS
+    libc.src.__support.FPUtil.manipulation_functions
+  COMPILE_OPTIONS
+    -O2
+)
 No newline at end of file

libc/src/math/generic/signbitf.cpp

+//===-- Implementation of signbitf 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/math/signbitf.h"
+#include "src/__support/FPUtil/ManipulationFunctions.h"
+#include "src/__support/common.h"
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(bool, signbitf, (float x)) { return fputil::signbit(x); }
+
+} // namespace __llvm_libc

libc/src/math/signbitf.h

+//===-- Implementation header for signbitf ----------------------*- 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_SIGNBITF_H
+#define LLVM_LIBC_SRC_MATH_SIGNBITF_H
+
+namespace __llvm_libc {
+
+bool signbitf(float x);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_MATH_SIGNBITF_H

libc/test/src/math/CMakeLists.txt

 add_fp_unittest(
   pow_test
   NEED_MPFR
   SUITE
     libc_math_unittests
   SRCS
     pow_test.cpp
   DEPENDS
     libc.include.errno
     libc.src.errno.errno
     libc.src.math.pow
 )
 
+add_fp_unittest(
+  signbitf_test
+  NEED_MPFR
+  SUITE
+    libc_math_unittests
+  SRCS
+    signbitf_test.cpp
+  HDRS
+    SignBitTest.h
+  DEPENDS
+    libc.include.math
+    libc.src.math.signbitf
+    libc.src.__support.FPUtil.fp_bits
+)
+
 add_subdirectory(generic)
 add_subdirectory(exhaustive)
 add_subdirectory(differential_testing)

libc/test/src/math/SignBitTest.h

+//===-- Utility class to test signbit[f|l] ----------------------*- 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 "utils/MPFRWrapper/MPFRUtils.h"
+#include "utils/UnitTest/FPMatcher.h"
+#include "utils/UnitTest/Test.h"
+
+#include <math.h>
+
+namespace mpfr = __llvm_libc::testing::mpfr;
+
+template <typename T> class SignBitTest : public __llvm_libc::testing::Test {
+
+  DECLARE_SPECIAL_CONSTANTS(T)
+
+public:
+  typedef bool (*SignBitFunc)(T);
+
+  void testSpecialNumbers(SignBitFunc func) {
+    EXPECT_EQ(true, func(-1.0));
+    EXPECT_EQ(false, func(1.0));
+
+    EXPECT_EQ(true, func(neg_inf));
+    EXPECT_EQ(false, func(inf));
+
+    EXPECT_EQ(true, func(neg_zero));
+    EXPECT_EQ(false, func(zero));
+  }
+
+  void testRange(SignBitFunc func) {
+    constexpr UIntType COUNT = 10000000;
+    constexpr UIntType STEP = UIntType(-1) / COUNT;
+    for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
+      T x = T(FPBits(v));
+      if (isnan(x) || isinf(x))
+        continue;
+
+      ASSERT_EQ(mpfr::signbit(x), func(x));
+    }
+  }
+};
+
+#define LIST_SIGNBIT_TESTS(T, func)                                            \
+  using LlvmLibcSignBitTest = SignBitTest<T>;                                  \
+  TEST_F(LlvmLibcSignBitTest, SpecialNumbers) { testSpecialNumbers(&func); }   \
+  TEST_F(LlvmLibcSignBitTest, Range) { testRange(&func); }

libc/test/src/math/signbitf_test.cpp

+//===-- Unittests for copysignf -------------------------------------------===//
+//
+// 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 "SignBitTest.h"
+
+#include "src/math/signbitf.h"
+
+LIST_SIGNBIT_TESTS(float, __llvm_libc::signbitf)

libc/utils/MPFRWrapper/MPFRUtils.h

return internal::MPFRMatcher<op, /*is_silent*/ true, InputType, OutputType>(
       input, ulp_tolerance, rounding);
 }
 
 template <typename T> T round(T x, RoundingMode mode);
 
 template <typename T> bool round_to_long(T x, long &result);
 template <typename T> bool round_to_long(T x, RoundingMode mode, long &result);
 
+template <typename T> bool signbit(T x);
+
 } // namespace mpfr
 } // namespace testing
 } // namespace __llvm_libc
 
 // GET_MPFR_DUMMY_ARG is going to be added to the end of GET_MPFR_MACRO as a
 // simple way to avoid the compiler warning `gnu-zero-variadic-macro-arguments`.
 #define GET_MPFR_DUMMY_ARG(...) 0
 

libc/utils/MPFRWrapper/MPFRUtils.cpp

MPFRNumber mod_pi_over_4() const {
     MPFRNumber result(0.0, 1280);
     MPFRNumber pi_over_4(0.0, 1280);
     mpfr_const_pi(pi_over_4.value, MPFR_RNDN);
     mpfr_mul_d(pi_over_4.value, pi_over_4.value, 0.25, MPFR_RNDN);
     mpfr_fmod(result.value, value, pi_over_4.value, MPFR_RNDN);
     return result;
   }
 
+  bool signbit() const { return mpfr_signbit(value); }
+
   MPFRNumber sin() const {
     MPFRNumber result(*this);
     mpfr_sin(result.value, value, mpfr_rounding);
     return result;
   }
 
   MPFRNumber sinh() const {
     MPFRNumber result(*this);
template <typename T> T round(T x, RoundingMode mode) {
   MPFRNumber result = mpfr.rint(get_mpfr_rounding_mode(mode));
   return result.as<T>();
 }
 
 template float round<float>(float, RoundingMode);
 template double round<double>(double, RoundingMode);
 template long double round<long double>(long double, RoundingMode);
 
+template <typename T> bool signbit(T x) {
+  MPFRNumber mpfr(x);
+  return mpfr.signbit();
+}
+
+template bool signbit<float>(float);
+template bool signbit<double>(double);
+template bool signbit<long double>(long double);
+
 } // namespace mpfr
 } // namespace testing
 } // namespace __llvm_libc