[libc] Add long double flavors of the floating point manipulation functions.

[sivachandra]

Summary

Specifically: copysignl, frexpl, logbl and modfl have been added.

[asteinhauser]

Good job. Are the -O2 options necessary for the correctness or it's just an optimization?

[sivachandra]

In D82357#2110607, @asteinhauser wrote:

Are the -O2 options necessary for the correctness or it's just an optimization?

At -O2, the static inline functions actually get inlined and we can compare the code size et al with implementations from another libc. It does not affect the correctness.

libc/config/linux/api.td

def MathAPI : PublicAPI<"math.h"> {
   ];
   let TypeDeclarations = [
     DoubleT,
     FloatT,
   ];
   let Functions = [
    "copysign",
    "copysignf",
+   "copysignl",
    "ceil",
    "ceilf",
    "cosf",
    "fabs",
    "fabsf",
    "fabsl",
    "floor",
    "floorf",
    "frexp",
    "frexpf",
+   "frexpl",
    "logb",
    "logbf",
+   "logbl",
    "modf",
    "modff",
+   "modfl",
    "expf",
    "exp2f",
    "round",
    "roundf",
    "sincosf",
    "sinf",
    "trunc",
    "truncf",

libc/config/linux/x86_64/entrypoints.txt

set(TARGET_LIBC_ENTRYPOINTS
     # unistd.h entrypoints
     libc.src.unistd.write
 )
 
 set(TARGET_LIBM_ENTRYPOINTS
     # math.h entrypoints
     libc.src.math.copysign
     libc.src.math.copysignf
+    libc.src.math.copysignl
     libc.src.math.ceil
     libc.src.math.ceilf
     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.floor
     libc.src.math.floorf
     libc.src.math.frexp
     libc.src.math.frexpf
+    libc.src.math.frexpl
     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.src.math.sincosf
     libc.src.math.sinf
     libc.src.math.trunc
     libc.src.math.truncf
     libc.src.math.truncl
 )

libc/spec/spec.td

 def LongDoubleType : NamedType<"long double">;
 def CharType : NamedType<"char">;
 
 // Common types
 def VoidPtr : PtrType<VoidType>;
 def ConstVoidPtr : ConstType<VoidPtr>;
 def SizeTType : NamedType<"size_t">;
 def FloatPtr : PtrType<FloatType>;
+def LongDoublePtr : PtrType<LongDoubleType>;
 
 // _Noreturn is really not a type, but it is convenient to treat it as a type.
 def NoReturn : NamedType<"_Noreturn void">;
 
 class Macro<string name> {
   string Name = name;
 }
 

libc/spec/stdc.td

HeaderSpec Math = HeaderSpec<
       [
           NamedType<"float_t">,
           NamedType<"double_t">,
       ],
       [], // Enumerations
       [
           FunctionSpec<"copysign", RetValSpec<DoubleType>, [ArgSpec<DoubleType>, ArgSpec<DoubleType>]>,
           FunctionSpec<"copysignf", RetValSpec<FloatType>, [ArgSpec<FloatType>, ArgSpec<FloatType>]>,
+          FunctionSpec<"copysignl", RetValSpec<LongDoubleType>, [ArgSpec<LongDoubleType>, ArgSpec<LongDoubleType>]>,
 
           FunctionSpec<"ceil", RetValSpec<DoubleType>, [ArgSpec<DoubleType>]>,
           FunctionSpec<"ceilf", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
 
           FunctionSpec<"fabs", RetValSpec<DoubleType>, [ArgSpec<DoubleType>]>,
           FunctionSpec<"fabsf", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
           FunctionSpec<"fabsl", RetValSpec<LongDoubleType>, [ArgSpec<LongDoubleType>]>,
 
           FunctionSpec<"floor", RetValSpec<DoubleType>, [ArgSpec<DoubleType>]>,
           FunctionSpec<"floorf", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
 
           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<"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>]>,
 
           FunctionSpec<"cosf", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
           FunctionSpec<"sinf", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
 
           FunctionSpec<"expf", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
           FunctionSpec<"exp2f", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
 
           FunctionSpec<"round", RetValSpec<DoubleType>, [ArgSpec<DoubleType>]>,

libc/src/math/CMakeLists.txt

 add_entrypoint_object(
   copysign
   SRCS
     copysign.cpp
   HDRS
     copysign.h
   DEPENDS
     libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
 )
 
 add_entrypoint_object(
   copysignf
   SRCS
     copysignf.cpp
   HDRS
     copysignf.h
   DEPENDS
     libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
+)
+
+add_entrypoint_object(
+  copysignl
+  SRCS
+    copysignl.cpp
+  HDRS
+    copysignl.h
+  DEPENDS
+    libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
 )
 
 add_entrypoint_object(
   frexp
   SRCS
     frexp.cpp
   HDRS
     frexp.h
   DEPENDS
     libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
 )
 
 add_entrypoint_object(
   frexpf
   SRCS
     frexpf.cpp
   HDRS
     frexpf.h
   DEPENDS
     libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
+)
+
+add_entrypoint_object(
+  frexpl
+  SRCS
+    frexpl.cpp
+  HDRS
+    frexpl.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
+    -O2
 )
 
 add_entrypoint_object(
   logbf
   SRCS
     logbf.cpp
   HDRS
     logbf.h
   DEPENDS
     libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
+)
+
+add_entrypoint_object(
+  logbl
+  SRCS
+    logbl.cpp
+  HDRS
+    logbl.h
+  DEPENDS
+    libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
 )
 
 add_entrypoint_object(
   modf
   SRCS
     modf.cpp
   HDRS
     modf.h
   DEPENDS
     libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
 )
 
 add_entrypoint_object(
   modff
   SRCS
     modff.cpp
   HDRS
     modff.h
   DEPENDS
     libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
+)
+
+add_entrypoint_object(
+  modfl
+  SRCS
+    modfl.cpp
+  HDRS
+    modfl.h
+  DEPENDS
+    libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
 )

libc/src/math/copysignl.h

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

libc/src/math/copysignl.cpp

+//===-- Implementation of copysignl 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(copysignl)(long double x, long double y) {
+  return fputil::copysign(x, y);
+}
+
+} // namespace __llvm_libc

libc/src/math/frexpl.h

+//===-- Implementation header for frexpl ------------------------*- 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_FREXPL_H
+#define LLVM_LIBC_SRC_MATH_FREXPL_H
+
+namespace __llvm_libc {
+
+long double frexpl(long double x, int *exp);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_MATH_FREXPL_H

libc/src/math/frexpl.cpp

+//===-- Implementation of frexpl 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(frexpl)(long double x, int *exp) {
+  return fputil::frexp(x, *exp);
+}
+
+} // namespace __llvm_libc

libc/src/math/logbl.h

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

libc/src/math/logbl.cpp

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

libc/src/math/modfl.h

+//===-- Implementation header for modfl -------------------------*- 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_MODFL_H
+#define LLVM_LIBC_SRC_MATH_MODFL_H
+
+namespace __llvm_libc {
+
+long double modfl(long double x, long double *iptr);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_MATH_MODFL_H

libc/src/math/modfl.cpp

+//===-- Implementation of modfl 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(modfl)(long double x, long double *iptr) {
+  return fputil::modf(x, *iptr);
+}
+
+} // namespace __llvm_libc

libc/test/src/math/CMakeLists.txt

SRCS
     copysignf_test.cpp
   DEPENDS
     libc.include.math
     libc.src.math.copysignf
     libc.utils.FPUtil.fputil
 )
 
 add_math_unittest(
+  copysignl_test
+  SUITE
+    libc_math_unittests
+  SRCS
+    copysignl_test.cpp
+  DEPENDS
+    libc.include.math
+    libc.src.math.copysignl
+    libc.utils.FPUtil.fputil
+)
+
+add_math_unittest(
   frexp_test
   SUITE
     libc_math_unittests
   SRCS
     frexp_test.cpp
   DEPENDS
     libc.include.math
     libc.src.math.frexp
     libc.utils.FPUtil.fputil
 )
 
 add_math_unittest(
   frexpf_test
   SUITE
     libc_math_unittests
   SRCS
     frexpf_test.cpp
   DEPENDS
     libc.include.math
     libc.src.math.frexpf
     libc.utils.FPUtil.fputil
 )
 
 add_math_unittest(
+  frexpl_test
+  SUITE
+    libc_math_unittests
+  SRCS
+    frexpl_test.cpp
+  DEPENDS
+    libc.include.math
+    libc.src.math.frexpl
+    libc.utils.FPUtil.fputil
+)
+
+add_math_unittest(
   logb_test
   SUITE
     libc_math_unittests
   SRCS
     logb_test.cpp
   DEPENDS
     libc.include.math
     libc.src.math.logb
     libc.utils.FPUtil.fputil
 )
 
 add_math_unittest(
   logbf_test
   SUITE
     libc_math_unittests
   SRCS
     logbf_test.cpp
   DEPENDS
     libc.include.math
     libc.src.math.logbf
     libc.utils.FPUtil.fputil
 )
 
 add_math_unittest(
+  logbl_test
+  SUITE
+    libc_math_unittests
+  SRCS
+    logbl_test.cpp
+  DEPENDS
+    libc.include.math
+    libc.src.math.logbl
+    libc.utils.FPUtil.fputil
+)
+
+add_math_unittest(
   modf_test
   SUITE
     libc_math_unittests
   SRCS
     modf_test.cpp
   DEPENDS
     libc.include.math
     libc.src.math.modf
     libc.utils.FPUtil.fputil
 )
 
 add_math_unittest(
   modff_test
   SUITE
     libc_math_unittests
   SRCS
     modff_test.cpp
   DEPENDS
     libc.include.math
     libc.src.math.modff
     libc.utils.FPUtil.fputil
 )
+
+add_math_unittest(
+  modfl_test
+  SUITE
+    libc_math_unittests
+  SRCS
+    modfl_test.cpp
+  DEPENDS
+    libc.include.math
+    libc.src.math.modfl
+    libc.utils.FPUtil.fputil
+)

libc/test/src/math/copysignl_test.cpp

+//===-- Unittests for copysignl
+//--------------------------------------------===//
+//
+// 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/copysignl.h"
+#include "utils/FPUtil/FPBits.h"
+#include "utils/UnitTest/Test.h"
+
+using FPBits = __llvm_libc::fputil::FPBits<long double>;
+
+TEST(CopysignlTest, SpecialNumbers) {
+  EXPECT_TRUE(FPBits::negZero() ==
+              __llvm_libc::copysignl(FPBits::zero(), -1.0l));
+  EXPECT_TRUE(FPBits::zero() ==
+              __llvm_libc::copysignl(FPBits::negZero(), 1.0l));
+
+  EXPECT_TRUE(FPBits::negZero() ==
+              __llvm_libc::copysignl(FPBits::zero(), -1.0l));
+  EXPECT_TRUE(FPBits::zero() ==
+              __llvm_libc::copysignl(FPBits::negZero(), 1.0l));
+
+  EXPECT_TRUE(
+      FPBits(__llvm_libc::copysignl(FPBits::buildNaN(1), -1.0l)).isNaN());
+}
+
+TEST(CopysignlTest, InDoubleRange) {
+  using UIntType = FPBits::UIntType;
+  constexpr UIntType count = 10000000;
+  constexpr UIntType step = UIntType(-1) / count;
+  for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
+    long double x = FPBits(v);
+    if (isnan(x) || isinf(x) || x == 0)
+      continue;
+
+    long double res1 = __llvm_libc::copysignl(x, -x);
+    ASSERT_TRUE(res1 == -x);
+
+    long double res2 = __llvm_libc::copysignl(x, x);
+    ASSERT_TRUE(res2 == x);
+  }
+}

libc/test/src/math/frexpl_test.cpp

+//===-- Unittests for frexpl ----------------------------------------------===//
+//
+// 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/frexpl.h"
+#include "utils/FPUtil/BasicOperations.h"
+#include "utils/FPUtil/FPBits.h"
+#include "utils/UnitTest/Test.h"
+
+#include <iostream>
+
+using FPBits = __llvm_libc::fputil::FPBits<long double>;
+
+TEST(FrexplTest, SpecialNumbers) {
+  int exponent;
+
+  EXPECT_TRUE(FPBits::inf() == __llvm_libc::frexpl(FPBits::inf(), &exponent));
+  EXPECT_TRUE(FPBits::negInf() ==
+              __llvm_libc::frexpl(FPBits::negInf(), &exponent));
+
+  EXPECT_TRUE(FPBits::zero() == __llvm_libc::frexpl(FPBits::zero(), &exponent));
+  EXPECT_EQ(exponent, 0);
+
+  EXPECT_TRUE(FPBits::negZero() ==
+              __llvm_libc::frexpl(FPBits::negZero(), &exponent));
+  EXPECT_EQ(exponent, 0);
+
+  EXPECT_TRUE(
+      FPBits(__llvm_libc::frexpl(FPBits::buildNaN(1), &exponent)).isNaN());
+}
+
+TEST(FrexplTest, PowersOfTwo) {
+  int exponent;
+
+  EXPECT_TRUE(0.5l == __llvm_libc::frexpl(1.0l, &exponent));
+  EXPECT_EQ(exponent, 1);
+  EXPECT_TRUE(-0.5l == __llvm_libc::frexpl(-1.0l, &exponent));
+  EXPECT_EQ(exponent, 1);
+
+  EXPECT_TRUE(0.5l == __llvm_libc::frexpl(2.0l, &exponent));
+  EXPECT_EQ(exponent, 2);
+  EXPECT_TRUE(-0.5l == __llvm_libc::frexpl(-2.0l, &exponent));
+  EXPECT_EQ(exponent, 2);
+
+  EXPECT_TRUE(0.5l == __llvm_libc::frexpl(4.0l, &exponent));
+  EXPECT_EQ(exponent, 3);
+  EXPECT_TRUE(-0.5l == __llvm_libc::frexpl(-4.0l, &exponent));
+  EXPECT_EQ(exponent, 3);
+
+  EXPECT_TRUE(0.5l == __llvm_libc::frexpl(8.0l, &exponent));
+  EXPECT_EQ(exponent, 4);
+  EXPECT_TRUE(-0.5l == __llvm_libc::frexpl(-8.0l, &exponent));
+  EXPECT_EQ(exponent, 4);
+
+  EXPECT_TRUE(0.5l == __llvm_libc::frexpl(16.0l, &exponent));
+  EXPECT_EQ(exponent, 5);
+  EXPECT_TRUE(-0.5l == __llvm_libc::frexpl(-16.0l, &exponent));
+  EXPECT_EQ(exponent, 5);
+
+  EXPECT_TRUE(0.5l == __llvm_libc::frexpl(32.0l, &exponent));
+  EXPECT_EQ(exponent, 6);
+  EXPECT_TRUE(-0.5l == __llvm_libc::frexpl(-32.0l, &exponent));
+  EXPECT_EQ(exponent, 6);
+}
+
+TEST(FrexplTest, SomeIntegers) {
+  int exponent;
+
+  EXPECT_TRUE(0.75l == __llvm_libc::frexpl(24.0l, &exponent));
+  EXPECT_EQ(exponent, 5);
+  EXPECT_TRUE(-0.75l == __llvm_libc::frexpl(-24.0l, &exponent));
+  EXPECT_EQ(exponent, 5);
+
+  EXPECT_TRUE(0.625l == __llvm_libc::frexpl(40.0l, &exponent));
+  EXPECT_EQ(exponent, 6);
+  EXPECT_TRUE(-0.625l == __llvm_libc::frexpl(-40.0l, &exponent));
+  EXPECT_EQ(exponent, 6);
+
+  EXPECT_TRUE(0.78125l == __llvm_libc::frexpl(800.0l, &exponent));
+  EXPECT_EQ(exponent, 10);
+  EXPECT_TRUE(-0.78125l == __llvm_libc::frexpl(-800.0l, &exponent));
+  EXPECT_EQ(exponent, 10);
+}
+
+TEST(FrexplTest, LongDoubleRange) {
+  using UIntType = FPBits::UIntType;
+  constexpr UIntType count = 10000000;
+  constexpr UIntType step = UIntType(-1) / count;
+  for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
+    long double x = FPBits(v);
+    if (isnan(x) || isinf(x) || x == 0.0l)
+      continue;
+
+    int exponent;
+    long double frac = __llvm_libc::frexpl(x, &exponent);
+
+    ASSERT_TRUE(__llvm_libc::fputil::abs(frac) < 1.0l);
+    ASSERT_TRUE(__llvm_libc::fputil::abs(frac) >= 0.5l);
+  }
+}

libc/test/src/math/logbl_test.cpp

+//===-- Unittests for logbl -----------------------------------------------===//
+//
+// 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/logbl.h"
+#include "utils/FPUtil/FPBits.h"
+#include "utils/FPUtil/ManipulationFunctions.h"
+#include "utils/UnitTest/Test.h"
+
+using FPBits = __llvm_libc::fputil::FPBits<long double>;
+
+TEST(logblTest, SpecialNumbers) {
+  EXPECT_TRUE(FPBits::inf() == __llvm_libc::logbl(FPBits::inf()));
+  EXPECT_TRUE(FPBits::inf() == __llvm_libc::logbl(FPBits::negInf()));
+
+  EXPECT_TRUE(FPBits::negInf() == __llvm_libc::logbl(FPBits::zero()));
+  EXPECT_TRUE(FPBits::negInf() == __llvm_libc::logbl(FPBits::negZero()));
+
+  EXPECT_TRUE(FPBits(__llvm_libc::logbl(FPBits::buildNaN(1))).isNaN());
+}
+
+TEST(logblTest, PowersOfTwo) {
+  EXPECT_TRUE(0.0l == __llvm_libc::logbl(1.0l));
+  EXPECT_TRUE(0.0l == __llvm_libc::logbl(-1.0l));
+
+  EXPECT_TRUE(1.0l == __llvm_libc::logbl(2.0l));
+  EXPECT_TRUE(1.0l == __llvm_libc::logbl(-2.0l));
+
+  EXPECT_TRUE(2.0l == __llvm_libc::logbl(4.0l));
+  EXPECT_TRUE(2.0l == __llvm_libc::logbl(-4.0l));
+
+  EXPECT_TRUE(3.0l == __llvm_libc::logbl(8.0l));
+  EXPECT_TRUE(3.0l == __llvm_libc::logbl(-8.0l));
+
+  EXPECT_TRUE(4.0l == __llvm_libc::logbl(16.0l));
+  EXPECT_TRUE(4.0l == __llvm_libc::logbl(-16.0l));
+
+  EXPECT_TRUE(5.0l == __llvm_libc::logbl(32.0l));
+  EXPECT_TRUE(5.0l == __llvm_libc::logbl(-32.0l));
+}
+
+TEST(LogbTest, SomeIntegers) {
+  EXPECT_TRUE(1.0l == __llvm_libc::logbl(3.0l));
+  EXPECT_TRUE(1.0l == __llvm_libc::logbl(-3.0l));
+
+  EXPECT_TRUE(2.0l == __llvm_libc::logbl(7.0l));
+  EXPECT_TRUE(2.0l == __llvm_libc::logbl(-7.0l));
+
+  EXPECT_TRUE(3.0l == __llvm_libc::logbl(10.0l));
+  EXPECT_TRUE(3.0l == __llvm_libc::logbl(-10.0l));
+
+  EXPECT_TRUE(4.0l == __llvm_libc::logbl(31.0l));
+  EXPECT_TRUE(4.0l == __llvm_libc::logbl(-31.0l));
+
+  EXPECT_TRUE(5.0l == __llvm_libc::logbl(55.0l));
+  EXPECT_TRUE(5.0l == __llvm_libc::logbl(-55.0l));
+}
+
+TEST(LogblTest, LongDoubleRange) {
+  using UIntType = FPBits::UIntType;
+  constexpr UIntType count = 10000000;
+  constexpr UIntType step = UIntType(-1) / count;
+  for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
+    long double x = FPBits(v);
+    if (isnan(x) || isinf(x) || x == 0.0l)
+      continue;
+
+    int exponent;
+    __llvm_libc::fputil::frexp(x, exponent);
+    ASSERT_TRUE((long double)(exponent) == __llvm_libc::logbl(x) + 1.0l);
+  }
+}

libc/test/src/math/modfl_test.cpp

+//===-- Unittests for modfl -----------------------------------------------===//
+//
+// 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/modfl.h"
+#include "utils/FPUtil/BasicOperations.h"
+#include "utils/FPUtil/FPBits.h"
+#include "utils/FPUtil/NearestIntegerOperations.h"
+#include "utils/UnitTest/Test.h"
+
+using FPBits = __llvm_libc::fputil::FPBits<long double>;
+
+TEST(modflTest, SpecialNumbers) {
+  long double integral;
+
+  EXPECT_TRUE(FPBits::zero() == __llvm_libc::modfl(FPBits::inf(), &integral));
+  EXPECT_TRUE(FPBits::inf() == integral);
+
+  EXPECT_TRUE(FPBits::negZero() ==
+              __llvm_libc::modfl(FPBits::negInf(), &integral));
+  EXPECT_TRUE(FPBits::negInf() == integral);
+
+  EXPECT_TRUE(FPBits::zero() == __llvm_libc::modfl(FPBits::zero(), &integral));
+  EXPECT_TRUE(integral == 0.0l);
+
+  EXPECT_TRUE(FPBits::negZero() ==
+              __llvm_libc::modfl(FPBits::negZero(), &integral));
+  EXPECT_TRUE(integral == 0.0l);
+
+  EXPECT_TRUE(
+      FPBits(__llvm_libc::modfl(FPBits::buildNaN(1), &integral)).isNaN());
+}
+
+TEST(modflTest, Integers) {
+  long double integral;
+
+  EXPECT_TRUE(FPBits::zero() == __llvm_libc::modfl(1.0l, &integral));
+  EXPECT_TRUE(integral == 1.0l);
+
+  EXPECT_TRUE(FPBits::negZero() == __llvm_libc::modfl(-1.0l, &integral));
+  EXPECT_TRUE(integral == -1.0l);
+
+  EXPECT_TRUE(FPBits::zero() == __llvm_libc::modfl(10.0l, &integral));
+  EXPECT_TRUE(integral == 10.0l);
+
+  EXPECT_TRUE(FPBits::negZero() == __llvm_libc::modfl(-10.0l, &integral));
+  EXPECT_TRUE(integral == -10.0l);
+
+  EXPECT_TRUE(FPBits::zero() == __llvm_libc::modfl(12345.0l, &integral));
+  EXPECT_TRUE(integral == 12345.0l);
+
+  EXPECT_TRUE(FPBits::negZero() == __llvm_libc::modfl(-12345.0l, &integral));
+  EXPECT_TRUE(integral == -12345.0l);
+}
+
+TEST(ModfTest, Fractions) {
+  long double integral;
+
+  EXPECT_TRUE(0.5l == __llvm_libc::modfl(1.5l, &integral));
+  EXPECT_TRUE(integral == 1.0l);
+
+  EXPECT_TRUE(-0.5l == __llvm_libc::modfl(-1.5l, &integral));
+  EXPECT_TRUE(integral == -1.0l);
+
+  EXPECT_TRUE(0.75l == __llvm_libc::modfl(10.75l, &integral));
+  EXPECT_TRUE(integral == 10.0l);
+
+  EXPECT_TRUE(-0.75l == __llvm_libc::modfl(-10.75l, &integral));
+  EXPECT_TRUE(integral == -10.0l);
+
+  EXPECT_TRUE(0.125l == __llvm_libc::modfl(100.125l, &integral));
+  EXPECT_TRUE(integral == 100.0l);
+
+  EXPECT_TRUE(-0.125l == __llvm_libc::modfl(-100.125l, &integral));
+  EXPECT_TRUE(integral == -100.0l);
+}
+
+TEST(ModflTest, LongDoubleRange) {
+  using UIntType = FPBits::UIntType;
+  constexpr UIntType count = 10000000;
+  constexpr UIntType step = UIntType(-1) / count;
+  for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
+    long double x = FPBits(v);
+    if (isnan(x) || isinf(x) || x == 0.0l)
+      continue;
+
+    long double integral;
+    long double frac = __llvm_libc::modfl(x, &integral);
+    ASSERT_TRUE(__llvm_libc::fputil::abs(frac) < 1.0l);
+    ASSERT_TRUE(__llvm_libc::fputil::trunc(x) == integral);
+    ASSERT_TRUE(integral + frac == x);
+  }
+}

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
 //
 //===----------------------------------------------------------------------===//
 
-#include "BitPatterns.h"
-#include "ClassificationFunctions.h"
-#include "FloatOperations.h"
-#include "FloatProperties.h"
+#include "FPBits.h"
 #include "NearestIntegerOperations.h"
 
 #include "utils/CPP/TypeTraits.h"
 
 #ifndef LLVM_LIBC_UTILS_FPUTIL_MANIPULATION_FUNCTIONS_H
 #define LLVM_LIBC_UTILS_FPUTIL_MANIPULATION_FUNCTIONS_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) {
-  using Properties = FloatProperties<T>;
-  using BitsType = typename Properties::BitsType;
+#if defined(__x86_64__) || defined(__i386__)
+template <typename T> struct Standard754Type {
+  static constexpr bool Value =
+      cpp::IsSame<float, cpp::RemoveCVType<T>>::Value ||
+      cpp::IsSame<double, cpp::RemoveCVType<T>>::Value;
+};
+#else
+template <typename T> struct Standard754Type {
+  static constexpr bool Value = cpp::IsFloatingPointType<T>::Value;
+};
+#endif
+
+template <typename T> static inline T frexp_impl(FPBits<T> &bits, int &exp) {
+  exp = bits.getExponent() + 1;
+  static constexpr uint16_t resultExponent = FPBits<T>::exponentBias - 1;
+  bits.exponent = resultExponent;
+  return bits;
+}
 
-  auto bits = valueAsBits(x);
-  if (bitsAreInfOrNaN(bits))
+template <typename T, cpp::EnableIfType<Standard754Type<T>::Value, int> = 0>
+static inline T frexp(T x, int &exp) {
+  FPBits<T> bits(x);
+  if (bits.isInfOrNaN())
     return x;
-  if (bitsAreZero(bits)) {
+  if (bits.isZero()) {
     exp = 0;
     return x;
   }
 
-  exp = getExponentFromBits(bits) + 1;
+  return frexp_impl(bits, exp);
+}
+
+#if defined(__x86_64__) || defined(__i386__)
+static inline long double frexp(long double x, int &exp) {
+  FPBits<long double> bits(x);
+  if (bits.isInfOrNaN())
+    return x;
+  if (bits.isZero()) {
+    exp = 0;
+    return x;
+  }
 
-  static constexpr BitsType resultExponent =
-      Properties::exponentOffset - BitsType(1);
-  // Capture the sign and mantissa part.
-  bits &= (Properties::mantissaMask | Properties::signMask);
-  // Insert the new exponent.
-  bits |= (resultExponent << Properties::mantissaWidth);
+  if (bits.exponent != 0 || bits.implicitBit == 1)
+    return frexp_impl(bits, exp);
 
-  return valueFromBits(bits);
+  exp = bits.getExponent();
+  int shiftCount = 0;
+  uint64_t fullMantissa = *reinterpret_cast<uint64_t *>(&bits);
+  static constexpr uint64_t msBitMask = uint64_t(1) << 63;
+  for (; (fullMantissa & msBitMask) == uint64_t(0);
+       fullMantissa <<= 1, ++shiftCount) {
+    // This for loop will terminate as fullMantissa is != 0. If it were 0,
+    // then x will be NaN and handled before control reaches here.
+    // When the loop terminates, fullMantissa will represent the full mantissa
+    // of a normal long double value. That is, the implicit bit has the value
+    // of 1.
+  }
+
+  exp = exp - shiftCount + 1;
+  *reinterpret_cast<uint64_t *>(&bits) = fullMantissa;
+  bits.exponent = FPBits<long double>::exponentBias - 1;
+  return bits;
 }
+#endif
 
 template <typename T,
           cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
 static inline T modf(T x, T &iptr) {
-  auto bits = valueAsBits(x);
-  if (bitsAreZero(bits) || bitsAreNaN(bits)) {
+  FPBits<T> bits(x);
+  if (bits.isZero() || bits.isNaN()) {
     iptr = x;
     return x;
-  } else if (bitsAreInf(bits)) {
+  } else if (bits.isInf()) {
     iptr = x;
-    return bits & FloatProperties<T>::signMask
-               ? valueFromBits(BitPatterns<T>::negZero)
-               : valueFromBits(BitPatterns<T>::zero);
+    return bits.sign ? FPBits<T>::negZero() : FPBits<T>::zero();
   } else {
     iptr = trunc(x);
     if (x == iptr) {
       // If x is already an integer value, then return zero with the right
       // sign.
-      return bits & FloatProperties<T>::signMask
-                 ? valueFromBits(BitPatterns<T>::negZero)
-                 : valueFromBits(BitPatterns<T>::zero);
+      return bits.sign ? FPBits<T>::negZero() : FPBits<T>::zero();
     } else {
       return x - iptr;
     }
   }
 }
 
 template <typename T,
           cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
 static inline T copysign(T x, T y) {
-  constexpr auto signMask = FloatProperties<T>::signMask;
-  auto xbits = valueAsBits(x);
-  auto ybits = valueAsBits(y);
-  return valueFromBits((xbits & ~signMask) | (ybits & signMask));
+  FPBits<T> xbits(x);
+  xbits.sign = FPBits<T>(y).sign;
+  return xbits;
 }
 
-template <typename T,
-          cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
+template <typename T> static inline T logb_impl(const FPBits<T> &bits) {
+  return bits.getExponent();
+}
+
+template <typename T, cpp::EnableIfType<Standard754Type<T>::Value, int> = 0>
 static inline T logb(T x) {
-  auto bits = valueAsBits(x);
-  if (bitsAreZero(bits)) {
+  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 valueFromBits(BitPatterns<T>::negInf);
-  } else if (bitsAreInf(bits)) {
-    return valueFromBits(BitPatterns<T>::inf);
-  } else if (bitsAreNaN(bits)) {
+    return FPBits<T>::negInf();
+  } else if (bits.isNaN()) {
     return x;
-  } else {
-    return getExponentFromBits(bits);
-  }
+  } else if (bits.isInf()) {
+    // Return positive infinity.
+    return FPBits<T>::inf();
+  }
+
+  return logb_impl(bits);
+
+#if defined(__x86_64__) || defined(__i386__)
+static inline long double logb(long double x) {
+  FPBits<long double> bits(x);
+  if (bits.isZero()) {
+    // TODO(Floating point exception): Raise div-by-zero exception.
+    // TODO(errno): POSIX requires setting errno to ERANGE.
+    return FPBits<long double>::negInf();
+  } else if (bits.isNaN()) {
+    return x;
+  } else if (bits.isInf()) {
+    // Return positive infinity.
+    return FPBits<long double>::inf();
+  }
+
+  if (bits.exponent != 0 || bits.implicitBit == 1)
+    return logb_impl(bits);
+
+  int exp = bits.getExponent();
+  int shiftCount = 0;
+  uint64_t fullMantissa = *reinterpret_cast<uint64_t *>(&bits);
+  static constexpr uint64_t msBitMask = uint64_t(1) << 63;
+  for (; (fullMantissa & msBitMask) == uint64_t(0);
+       fullMantissa <<= 1, ++shiftCount) {
+    // This for loop will terminate as fullMantissa is != 0. If it were 0,
+    // then x will be NaN and handled before control reaches here.
+    // When the loop terminates, fullMantissa will represent the full mantissa
+    // of a normal long double value. That is, the implicit bit has the value
+    // of 1.
+  }
+
+  return exp - shiftCount;
 }
+#endif
 
 } // namespace fputil
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_UTILS_FPUTIL_MANIPULATION_FUNCTIONS_H