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

[sivachandra]

Summary

Depends on D90805.

[sivachandra]

Add missing license header and header guard for the new header file.

libc/config/linux/aarch64/entrypoints.txt

set(TARGET_LIBM_ENTRYPOINTS
     libc.src.math.fmaxl
     libc.src.math.fmin
     libc.src.math.fminf
     libc.src.math.fminl
     libc.src.math.frexp
     libc.src.math.frexpf
     libc.src.math.frexpl
     libc.src.math.hypotf
+    libc.src.math.ilogb
+    libc.src.math.ilogbf
+    libc.src.math.ilogbl
     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/config/linux/api.td

def MathAPI : PublicAPI<"math.h"> {
   let Macros = [
     SimpleMacroDef<"MATH_ERRNO", "1">,
     SimpleMacroDef<"MATH_ERREXCEPT", "2">,
     MathErrHandlingMacro,
 
     SimpleMacroDef<"INFINITY", "__builtin_inff()">,
     SimpleMacroDef<"NAN", "__builtin_nanf(\"\")">,
 
+    SimpleMacroDef<"FP_ILOGB0", "(-__INT_MAX__ - 1)">, // INT_MIN
+    SimpleMacroDef<"FP_ILOGBNAN", "__INT_MAX__">,
+
     IsFiniteMacro,
     IsInfMacro,
     IsNanMacro,
   ];
   let TypeDeclarations = [
     DoubleT,
     FloatT,
   ];

libc/config/linux/x86_64/entrypoints.txt

set(TARGET_LIBM_ENTRYPOINTS
     libc.src.math.fminl
     libc.src.math.fmax
     libc.src.math.fmaxf
     libc.src.math.fmaxl
     libc.src.math.frexp
     libc.src.math.frexpf
     libc.src.math.frexpl
     libc.src.math.hypotf
+    libc.src.math.ilogb
+    libc.src.math.ilogbf
+    libc.src.math.ilogbl
     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.remainderf
     libc.src.math.remainder

libc/spec/stdc.td

HeaderSpec Math = HeaderSpec<
       [
           Macro<"MATH_ERRNO">,
           Macro<"MATH_ERREXCEPT">,
           Macro<"math_errhandling">,
 
           Macro<"INFINITY">,
           Macro<"NAN">,
 
+          Macro<"FP_ILOGB0">,
+          Macro<"FP_ILOGBNAN">,
+
           Macro<"isfinite">,
           Macro<"isinf">,
           Macro<"isnan">,
       ],
       [
           NamedType<"float_t">,
           NamedType<"double_t">,
       ],
HeaderSpec Math = HeaderSpec<
           FunctionSpec<"fmaxl", RetValSpec<LongDoubleType>, [ArgSpec<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<"hypotf", RetValSpec<FloatType>, [ArgSpec<FloatType>, ArgSpec<FloatType>]>,
 
+          FunctionSpec<"ilogb", RetValSpec<IntType>, [ArgSpec<DoubleType>]>,
+          FunctionSpec<"ilogbf", RetValSpec<IntType>, [ArgSpec<FloatType>]>,
+          FunctionSpec<"ilogbl", RetValSpec<IntType>, [ArgSpec<LongDoubleType>]>,
+
           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>]>,
 

libc/src/math/CMakeLists.txt

HDRS
     frexpl.h
   DEPENDS
     libc.utils.FPUtil.fputil
   COMPILE_OPTIONS
     -O2
 )
 
 add_entrypoint_object(
+  ilogb
+  SRCS
+    ilogb.cpp
+  HDRS
+    ilogb.h
+  DEPENDS
+    libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
+)
+
+add_entrypoint_object(
+  ilogbf
+  SRCS
+    ilogbf.cpp
+  HDRS
+    ilogbf.h
+  DEPENDS
+    libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
+)
+
+add_entrypoint_object(
+  ilogbl
+  SRCS
+    ilogbl.cpp
+  HDRS
+    ilogbl.h
+  DEPENDS
+    libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
+)
+
+add_entrypoint_object(
   logb
   SRCS
     logb.cpp
   HDRS
     logb.h
   DEPENDS
     libc.utils.FPUtil.fputil
   COMPILE_OPTIONS

libc/src/math/ilogb.h

+//===-- Implementation header for ilogb -------------------------*- 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_ILOGB_H
+#define LLVM_LIBC_SRC_MATH_ILOGB_H
+
+namespace __llvm_libc {
+
+int ilogb(double x);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_MATH_ILOGB_H

libc/src/math/ilogb.cpp

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

libc/src/math/ilogbf.h

+//===-- Implementation header for ilogbf ------------------------*- 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_ILOGBF_H
+#define LLVM_LIBC_SRC_MATH_ILOGBF_H
+
+namespace __llvm_libc {
+
+int ilogbf(float x);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_MATH_ILOGBF_H

libc/src/math/ilogbf.cpp

+//===-- Implementation of ilogbf 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 {
+
+int LLVM_LIBC_ENTRYPOINT(ilogbf)(float x) { return fputil::ilogb(x); }
+
+} // namespace __llvm_libc

libc/src/math/ilogbl.h

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

libc/src/math/ilogbl.cpp

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

libc/test/src/math/CMakeLists.txt

SRCS
     frexpl_test.cpp
   DEPENDS
     libc.include.math
     libc.src.math.frexpl
     libc.utils.FPUtil.fputil
 )
 
 add_fp_unittest(
+  ilogb_test
+  SUITE
+    libc_math_unittests
+  SRCS
+    ilogb_test.cpp
+  HDRS
+    ILogbTest.h
+  DEPENDS
+    libc.include.math
+    libc.src.math.ilogb
+    libc.utils.FPUtil.fputil
+)
+
+add_fp_unittest(
+  ilogbf_test
+  SUITE
+    libc_math_unittests
+  SRCS
+    ilogbf_test.cpp
+  HDRS
+    ILogbTest.h
+  DEPENDS
+    libc.include.math
+    libc.src.math.ilogbf
+    libc.utils.FPUtil.fputil
+)
+
+add_fp_unittest(
+  ilogbl_test
+  SUITE
+    libc_math_unittests
+  SRCS
+    ilogbl_test.cpp
+  HDRS
+    ILogbTest.h
+  DEPENDS
+    libc.include.math
+    libc.src.math.ilogbl
+    libc.utils.FPUtil.fputil
+)
+
+add_fp_unittest(
   logb_test
   SUITE
     libc_math_unittests
   SRCS
     logb_test.cpp
   DEPENDS
     libc.include.math
     libc.src.math.logb

libc/test/src/math/ILogbTest.h

+
+#include "include/math.h"
+#include "utils/FPUtil/FPBits.h"
+#include "utils/FPUtil/ManipulationFunctions.h"
+#include "utils/UnitTest/Test.h"
+
+#include <limits.h>
+
+class ILogbTest : public __llvm_libc::testing::Test {
+public:
+  template <typename T> struct ILogbFunc { typedef int (*Func)(T); };
+
+  template <typename T>
+  void testSpecialNumbers(typename ILogbFunc<T>::Func func) {
+    EXPECT_EQ(FP_ILOGB0, func(__llvm_libc::fputil::FPBits<T>::zero()));
+    EXPECT_EQ(FP_ILOGB0, func(__llvm_libc::fputil::FPBits<T>::negZero()));
+
+    EXPECT_EQ(FP_ILOGBNAN, func(__llvm_libc::fputil::FPBits<T>::buildNaN(1)));
+
+    EXPECT_EQ(INT_MAX, func(__llvm_libc::fputil::FPBits<T>::inf()));
+    EXPECT_EQ(INT_MAX, func(__llvm_libc::fputil::FPBits<T>::negInf()));
+  }
+
+  template <typename T> void testPowersOfTwo(typename ILogbFunc<T>::Func func) {
+    EXPECT_EQ(0, func(T(1.0)));
+    EXPECT_EQ(0, func(T(-1.0)));
+
+    EXPECT_EQ(1, func(T(2.0)));
+    EXPECT_EQ(1, func(T(-2.0)));
+
+    EXPECT_EQ(2, func(T(4.0)));
+    EXPECT_EQ(2, func(T(-4.0)));
+
+    EXPECT_EQ(3, func(T(8.0)));
+    EXPECT_EQ(3, func(-8.0));
+
+    EXPECT_EQ(4, func(16.0));
+    EXPECT_EQ(4, func(-16.0));
+
+    EXPECT_EQ(5, func(32.0));
+    EXPECT_EQ(5, func(-32.0));
+  }
+
+  template <typename T>
+  void testSomeIntegers(typename ILogbFunc<T>::Func func) {
+    EXPECT_EQ(1, func(T(3.0)));
+    EXPECT_EQ(1, func(T(-3.0)));
+
+    EXPECT_EQ(2, func(T(7.0)));
+    EXPECT_EQ(2, func(T(-7.0)));
+
+    EXPECT_EQ(3, func(T(10.0)));
+    EXPECT_EQ(3, func(T(-10.0)));
+
+    EXPECT_EQ(4, func(T(31.0)));
+    EXPECT_EQ(4, func(-31.0));
+
+    EXPECT_EQ(5, func(55.0));
+    EXPECT_EQ(5, func(-55.0));
+  }
+
+  template <typename T>
+  void testSubnormalRange(typename ILogbFunc<T>::Func func) {
+    using FPBits = __llvm_libc::fputil::FPBits<T>;
+    using UIntType = typename FPBits::UIntType;
+    constexpr UIntType count = 1000001;
+    constexpr UIntType step =
+        (FPBits::maxSubnormal - FPBits::minSubnormal) / count;
+    for (UIntType v = FPBits::minSubnormal; v <= FPBits::maxSubnormal;
+         v += step) {
+      T x = FPBits(v);
+      if (isnan(x) || isinf(x) || x == 0.0)
+        continue;
+
+      int exponent;
+      __llvm_libc::fputil::frexp(x, exponent);
+      ASSERT_EQ(exponent, func(x) + 1);
+    }
+  }
+
+  template <typename T> void testNormalRange(typename ILogbFunc<T>::Func func) {
+    using FPBits = __llvm_libc::fputil::FPBits<T>;
+    using UIntType = typename FPBits::UIntType;
+    constexpr UIntType count = 1000001;
+    constexpr UIntType step = (FPBits::maxNormal - FPBits::minNormal) / count;
+    for (UIntType v = FPBits::minNormal; v <= FPBits::maxNormal; v += step) {
+      T x = FPBits(v);
+      if (isnan(x) || isinf(x) || x == 0.0)
+        continue;
+
+      int exponent;
+      __llvm_libc::fputil::frexp(x, exponent);
+      ASSERT_EQ(exponent, func(x) + 1);
+    }
+  }
+};

libc/test/src/math/ilogb_test.cpp

+//===-- Unittests for ilogb -----------------------------------------------===//
+//
+// 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 "ILogbTest.h"
+
+#include "include/math.h"
+#include "src/math/ilogb.h"
+#include "utils/CPP/Functional.h"
+#include "utils/FPUtil/FPBits.h"
+#include "utils/FPUtil/ManipulationFunctions.h"
+#include "utils/FPUtil/TestHelpers.h"
+#include "utils/UnitTest/Test.h"
+
+#include <limits.h>
+
+using RunContext = __llvm_libc::testing::RunContext;
+
+TEST_F(ILogbTest, SpecialNumbers_ilogb) {
+  testSpecialNumbers<double>(&__llvm_libc::ilogb);
+}
+
+TEST_F(ILogbTest, PowersOfTwo_ilogb) {
+  testPowersOfTwo<double>(&__llvm_libc::ilogb);
+}
+
+TEST_F(ILogbTest, SomeIntegers_ilogb) {
+  testSomeIntegers<double>(&__llvm_libc::ilogb);
+}
+
+TEST_F(ILogbTest, SubnormalRange_ilogb) {
+  testSubnormalRange<double>(&__llvm_libc::ilogb);
+}
+
+TEST_F(ILogbTest, NormalRange_ilogb) {
+  testNormalRange<double>(&__llvm_libc::ilogb);
+}

libc/test/src/math/ilogbf_test.cpp

+//===-- Unittests for ilogbf ----------------------------------------------===//
+//
+// 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 "ILogbTest.h"
+
+#include "include/math.h"
+#include "src/math/ilogbf.h"
+#include "utils/CPP/Functional.h"
+#include "utils/FPUtil/FPBits.h"
+#include "utils/FPUtil/ManipulationFunctions.h"
+#include "utils/FPUtil/TestHelpers.h"
+#include "utils/UnitTest/Test.h"
+
+#include <limits.h>
+
+using RunContext = __llvm_libc::testing::RunContext;
+
+TEST_F(ILogbTest, SpecialNumbers_ilogbf) {
+  testSpecialNumbers<float>(&__llvm_libc::ilogbf);
+}
+
+TEST_F(ILogbTest, PowersOfTwo_ilogbf) {
+  testPowersOfTwo<float>(&__llvm_libc::ilogbf);
+}
+
+TEST_F(ILogbTest, SomeIntegers_ilogbf) {
+  testSomeIntegers<float>(&__llvm_libc::ilogbf);
+}
+
+TEST_F(ILogbTest, SubnormalRange_ilogbf) {
+  testSubnormalRange<float>(&__llvm_libc::ilogbf);
+}
+
+TEST_F(ILogbTest, NormalRange_ilogbf) {
+  testNormalRange<float>(&__llvm_libc::ilogbf);
+}

libc/test/src/math/ilogbl_test.cpp

+//===-- Unittests for ilogbl ----------------------------------------------===//
+//
+// 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 "ILogbTest.h"
+
+#include "include/math.h"
+#include "src/math/ilogbl.h"
+#include "utils/CPP/Functional.h"
+#include "utils/FPUtil/FPBits.h"
+#include "utils/FPUtil/ManipulationFunctions.h"
+#include "utils/FPUtil/TestHelpers.h"
+#include "utils/UnitTest/Test.h"
+
+#include <limits.h>
+
+using RunContext = __llvm_libc::testing::RunContext;
+
+TEST_F(ILogbTest, SpecialNumbers_ilogbl) {
+  testSpecialNumbers<long double>(&__llvm_libc::ilogbl);
+}
+
+TEST_F(ILogbTest, PowersOfTwo_ilogbl) {
+  testPowersOfTwo<long double>(&__llvm_libc::ilogbl);
+}
+
+TEST_F(ILogbTest, SomeIntegers_ilogbl) {
+  testSomeIntegers<long double>(&__llvm_libc::ilogbl);
+}
+
+TEST_F(ILogbTest, SubnormalRange_ilogbl) {
+  testSubnormalRange<long double>(&__llvm_libc::ilogbl);
+}
+
+TEST_F(ILogbTest, NormalRange_ilogbl) {
+  testNormalRange<long double>(&__llvm_libc::ilogbl);
+}

libc/utils/FPUtil/CMakeLists.txt

HDRS
     FloatOperations.h
     FloatProperties.h
     FPBits.h
     BasicOperations.h
     ManipulationFunctions.h
     NearestIntegerOperations.h
     NormalFloat.h
   DEPENDS
+    libc.include.math
     libc.utils.CPP.standalone_cpp
 )
 
 add_llvm_library(
   LibcFPTestHelpers
     TestHelpers.cpp
     TestHelpers.h
 )
 target_include_directories(LibcFPTestHelpers PUBLIC ${LIBC_SOURCE_DIR})
 target_link_libraries(LibcFPTestHelpers LibcUnitTest LLVMSupport)
 add_dependencies(
   LibcFPTestHelpers
   LibcUnitTest
   libc.utils.CPP.standalone_cpp
   libc.utils.FPUtil.fputil
 )

libc/utils/FPUtil/ManipulationFunctions.h

 //===-- Floating-point manipulation functions -------------------*- 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_MANIPULATION_FUNCTIONS_H
 #define LLVM_LIBC_UTILS_FPUTIL_MANIPULATION_FUNCTIONS_H
 
 #include "FPBits.h"
 #include "NearestIntegerOperations.h"
 #include "NormalFloat.h"
 
+#include "include/math.h"
 #include "utils/CPP/TypeTraits.h"
 
+#include <limits.h>
+
 namespace __llvm_libc {
 namespace fputil {
 
 template <typename T,
           cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
 static inline T frexp(T x, int &exp) {
   FPBits<T> bits(x);
   if (bits.isInfOrNaN())

 static inline T copysign(T x, T y) {
   FPBits<T> xbits(x);
   xbits.sign = FPBits<T>(y).sign;
   return xbits;
 }
 
 template <typename T,
           cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
+static inline int ilogb(T x) {
+  // TODO: Raise appropriate floating point exceptions and set errno to the
+  // an appropriate error value wherever relevant.
+  FPBits<T> bits(x);
+  if (bits.isZero()) {
+    return FP_ILOGB0;
+  } else if (bits.isNaN()) {
+    return FP_ILOGBNAN;
+  } else if (bits.isInf()) {
+    return INT_MAX;
+  }
+
+  NormalFloat<T> normal(bits);
+  // The C standard does not specify the return value when an exponent is
+  // out of int range. However, XSI conformance required that INT_MAX or
+  // INT_MIN are returned.
+  // NOTE: It is highly unlikely that exponent will be out of int range as
+  // the exponent is only 15 bits wide even for the 128-bit floating point
+  // format.
+  if (normal.exponent > INT_MAX)
+    return INT_MAX;
+  else if (normal.exponent < INT_MIN)
+    return INT_MIN;
+  else
+    return normal.exponent;
+}
+
+template <typename T,
+          cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
 static inline T logb(T x) {
   FPBits<T> bits(x);
   if (bits.isZero()) {
     // TODO(Floating point exception): Raise div-by-zero exception.
     // TODO(errno): POSIX requires setting errno to ERANGE.
     return FPBits<T>::negInf();
   } else if (bits.isNaN()) {
     return x;