[libc] Add implementations long double fabsl and truncl functions.

[sivachandra]

Summary

Current implementations of single precision and double precision
floating point operations operate on bits of the integer type of
same size. The code made use of magic masks which were listed as
literal integer values. This is not possible in the case of long
double type as the mantissa of quad-precision long double type used
on non-x86 architectures is wider that the widest integer type for
which we can list literal values. So, in this patch, to avoid
using magic masks specified with literal values, we use packed
bit-field struct types and let the compiler generate the masks.
This new scheme allows us to implement long double flavors of the
various floating point operations. To keep the size of the patch
small, only the implementations of fabs and trunc have been
switched to the new scheme. In following patches, all exisiting
implementations will be switched to the new scheme.

[sivachandra]

Fix few header guards.

[sivachandra]

Fix few typos.

[sivachandra]

Increase mpfr precision. This allows to to enable fabsl and
truncl for aarch64 as well.

[asteinhauser]

Clang-tidy went completely crazy, or those warnings are expected?
Have you tested it in Visual Studio?

libc/test/src/math/fabsl_test.cpp

29

fabsl(NaN) == NaN test would be handy.

libc/test/src/math/truncl_test.cpp

28

truncl(NaN) == NaN test

37

Add some test where truncl(x) != x, e.g. truncl(2.5) == 2.0.

libc/utils/FPUtil/FPBits.h

34

This should be moved to MantissaWidth<long double> (10 lines below) if for visual studio long double and double are equivalent. You can hardly have 15 bytes for exponent and 52 bits for mantissa.

[sivachandra]

Address comments.

libc/utils/FPUtil/FPBits.h

34

When we start adding MSVC support, we will have to enclose this in separate #define and friends. Without MSVC support, this is correct as is because all architectures use 15 bit exponent for long double.

libc/config/linux/aarch64/entrypoints.txt

set(TARGET_LIBM_ENTRYPOINTS
     libc.src.math.copysignf
     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.logb
     libc.src.math.logbf
     libc.src.math.modf
     libc.src.math.modff
     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/config/linux/api.td

def MathAPI : PublicAPI<"math.h"> {
   let Functions = [
    "copysign",
    "copysignf",
    "ceil",
    "ceilf",
    "cosf",
    "fabs",
    "fabsf",
+   "fabsl",
    "floor",
    "floorf",
    "frexp",
    "frexpf",
    "logb",
    "logbf",
    "modf",
    "modff",
    "expf",
    "exp2f",
    "round",
    "roundf",
    "sincosf",
    "sinf",
    "trunc",
    "truncf",
+   "truncl",
   ];
 }
 
 def StringAPI : PublicAPI<"string.h"> {
   let Functions = [
     "bzero",
     "memcpy",
     "memmove",

libc/config/linux/x86_64/entrypoints.txt

set(TARGET_LIBM_ENTRYPOINTS
     libc.src.math.copysignf
     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.logb
     libc.src.math.logbf
     libc.src.math.modf
     libc.src.math.modff
     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/stdc.td

HeaderSpec Math = HeaderSpec<
           FunctionSpec<"copysign", RetValSpec<DoubleType>, [ArgSpec<DoubleType>, ArgSpec<DoubleType>]>,
           FunctionSpec<"copysignf", RetValSpec<FloatType>, [ArgSpec<FloatType>, ArgSpec<FloatType>]>,
 
           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<"logb", RetValSpec<DoubleType>, [ArgSpec<DoubleType>]>,
           FunctionSpec<"logbf", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
 
           FunctionSpec<"modf", RetValSpec<DoubleType>, [ArgSpec<DoubleType>, ArgSpec<DoublePtr>]>,
           FunctionSpec<"modff", RetValSpec<FloatType>, [ArgSpec<FloatType>, ArgSpec<FloatPtr>]>,
 
           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>]>,
           FunctionSpec<"roundf", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
 
           FunctionSpec<"trunc", RetValSpec<DoubleType>, [ArgSpec<DoubleType>]>,
           FunctionSpec<"truncf", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
+          FunctionSpec<"truncl", RetValSpec<LongDoubleType>, [ArgSpec<LongDoubleType>]>,
       ]
   >;
 
   HeaderSpec StdIO = HeaderSpec<
       "stdio.h",
       [], // Macros
       [ // Types
           SizeTType,

libc/src/math/CMakeLists.txt

 add_entrypoint_object(
   fabs
   SRCS
     fabs.cpp
   HDRS
     fabs.h
   DEPENDS
     libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
 )
 
 add_entrypoint_object(
   fabsf
   SRCS
     fabsf.cpp
   HDRS
     fabsf.h
   DEPENDS
     libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
+)
+
+add_entrypoint_object(
+  fabsl
+  SRCS
+    fabsl.cpp
+  HDRS
+    fabsl.h
+  DEPENDS
+    libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
 )
 
 add_entrypoint_object(
   trunc
   SRCS
     trunc.cpp
   HDRS
     trunc.h
   DEPENDS
     libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
 )
 
 add_entrypoint_object(
   truncf
   SRCS
     truncf.cpp
   HDRS
     truncf.h
   DEPENDS
     libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
+)
+
+add_entrypoint_object(
+  truncl
+  SRCS
+    truncl.cpp
+  HDRS
+    truncl.h
+  DEPENDS
+    libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
 )
 
 add_entrypoint_object(
   ceil
   SRCS
     ceil.cpp
   HDRS
     ceil.h
   DEPENDS
     libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
 )
 
 add_entrypoint_object(
   ceilf
   SRCS
     ceilf.cpp
   HDRS
     ceilf.h
   DEPENDS
     libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
 )
 
 add_entrypoint_object(
   floor
   SRCS
     floor.cpp
   HDRS
     floor.h
   DEPENDS
     libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
 )
 
 add_entrypoint_object(
   floorf
   SRCS
     floorf.cpp
   HDRS
     floorf.h
   DEPENDS
     libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
 )
 
 add_entrypoint_object(
   round
   SRCS
     round.cpp
   HDRS
     round.h

libc/src/math/fabsl.h

-//===-- Basic operations on floating point numbers --------------*- C++ -*-===//
+//===-- 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
 //
 //===----------------------------------------------------------------------===//
 
-#include "FloatOperations.h"
+#ifndef LLVM_LIBC_SRC_MATH_FABSL_H
+#define LLVM_LIBC_SRC_MATH_FABSL_H
 
 namespace __llvm_libc {
-namespace fputil {
 
-template <typename T,
-          cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
-static inline T abs(T x) {
-  return valueFromBits(absBits(x));
-}
+long double fabsl(long double x);
 
-} // namespace fputil
 } // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_MATH_FABSL_H

libc/src/math/fabsl.cpp

-//===-- Basic operations on floating point numbers --------------*- C++ -*-===//
+//===-- 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 "FloatOperations.h"
+#include "src/__support/common.h"
+#include "utils/FPUtil/BasicOperations.h"
 
 namespace __llvm_libc {
-namespace fputil {
 
-template <typename T,
-          cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
-static inline T abs(T x) {
-  return valueFromBits(absBits(x));
+long double LLVM_LIBC_ENTRYPOINT(fabsl)(long double x) {
+  return fputil::abs(x);
 }
 
-} // namespace fputil
 } // namespace __llvm_libc

libc/src/math/truncl.h

-//===-- Basic operations on floating point numbers --------------*- C++ -*-===//
+//===-- Implementation header for truncl ------------------------*- 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 "FloatOperations.h"
+#ifndef LLVM_LIBC_SRC_MATH_TRUNCL_H
+#define LLVM_LIBC_SRC_MATH_TRUNCL_H
 
 namespace __llvm_libc {
-namespace fputil {
 
-template <typename T,
-          cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
-static inline T abs(T x) {
-  return valueFromBits(absBits(x));
-}
+long double truncl(long double x);
 
-} // namespace fputil
 } // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_MATH_TRUNCL_H

libc/src/math/truncl.cpp

-//===-- Basic operations on floating point numbers --------------*- C++ -*-===//
+//===-- Implementation of truncl 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 "FloatOperations.h"
+#include "src/__support/common.h"
+#include "utils/FPUtil/NearestIntegerOperations.h"
 
 namespace __llvm_libc {
-namespace fputil {
 
-template <typename T,
-          cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
-static inline T abs(T x) {
-  return valueFromBits(absBits(x));
+long double LLVM_LIBC_ENTRYPOINT(truncl)(long double x) {
+  return fputil::trunc(x);
 }
 
-} // namespace fputil
 } // namespace __llvm_libc

libc/test/src/math/CMakeLists.txt

SRCS
     fabsf_test.cpp
   DEPENDS
     libc.include.math
     libc.src.math.fabsf
     libc.utils.FPUtil.fputil
 )
 
 add_math_unittest(
+  fabsl_test
+  NEED_MPFR
+  SUITE
+    libc_math_unittests
+  SRCS
+    fabsl_test.cpp
+  DEPENDS
+    libc.include.math
+    libc.src.math.fabsl
+    libc.utils.FPUtil.fputil
+)
+
+add_math_unittest(
   trunc_test
   NEED_MPFR
   SUITE
     libc_math_unittests
   SRCS
     trunc_test.cpp
   DEPENDS
     libc.include.math
SRCS
     truncf_test.cpp
   DEPENDS
     libc.include.math
     libc.src.math.truncf
     libc.utils.FPUtil.fputil
 )
 
 add_math_unittest(
+  truncl_test
+  NEED_MPFR
+  SUITE
+    libc_math_unittests
+  SRCS
+    truncl_test.cpp
+  DEPENDS
+    libc.include.math
+    libc.src.math.truncl
+    libc.utils.FPUtil.fputil
+)
+
+add_math_unittest(
   ceil_test
   NEED_MPFR
   SUITE
     libc_math_unittests
   SRCS
     ceil_test.cpp
   DEPENDS
     libc.include.math

libc/test/src/math/fabsl_test.cpp

+//===-- Unittests for fabsl -----------------------------------------------===//
+//
+// 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/fabsl.h"
+#include "utils/FPUtil/FPBits.h"
+#include "utils/MPFRWrapper/MPFRUtils.h"
+#include "utils/UnitTest/Test.h"
+
+using FPBits = __llvm_libc::fputil::FPBits<long double>;
+
+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};
+
+TEST(FabslTest, SpecialNumbers) {
+  EXPECT_TRUE(FPBits::zero() == __llvm_libc::fabsl(FPBits::zero()));
+  EXPECT_TRUE(FPBits::zero() == __llvm_libc::fabsl(FPBits::negZero()));
+
+  EXPECT_TRUE(FPBits::inf() == __llvm_libc::fabsl(FPBits::inf()));
+  EXPECT_TRUE(FPBits::inf() == __llvm_libc::fabsl(FPBits::negInf()));
+}
+
+TEST(FabslTest, InLongDoubleRange) {
+  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))
+      continue;
+    ASSERT_MPFR_MATCH(mpfr::Operation::Abs, x, __llvm_libc::fabsl(x),
+                      tolerance);
+  }
+}

libc/test/src/math/truncl_test.cpp

+//===-- Unittests for truncl ----------------------------------------------===//
+//
+// 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/truncl.h"
+#include "utils/FPUtil/FPBits.h"
+#include "utils/MPFRWrapper/MPFRUtils.h"
+#include "utils/UnitTest/Test.h"
+
+using FPBits = __llvm_libc::fputil::FPBits<long double>;
+
+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};
+
+TEST(TrunclTest, SpecialNumbers) {
+  EXPECT_TRUE(FPBits::zero() == __llvm_libc::truncl(FPBits::zero()));
+  EXPECT_TRUE(FPBits::negZero() == __llvm_libc::truncl(FPBits::negZero()));
+
+  EXPECT_TRUE(FPBits::inf() == __llvm_libc::truncl(FPBits::inf()));
+  EXPECT_TRUE(FPBits::negInf() == __llvm_libc::truncl(FPBits::negInf()));
+}
+
+TEST(TrunclTest, RoundedNumbers) {
+  EXPECT_TRUE(FPBits(1.0l) == __llvm_libc::truncl(1.0l));
+  EXPECT_TRUE(FPBits(-1.0l) == __llvm_libc::truncl(-1.0l));
+  EXPECT_TRUE(FPBits(10.0l) == __llvm_libc::truncl(10.0l));
+  EXPECT_TRUE(FPBits(-10.0l) == __llvm_libc::truncl(-10.0l));
+  EXPECT_TRUE(FPBits(1234.0l) == __llvm_libc::truncl(1234.0l));
+  EXPECT_TRUE(FPBits(-1234.0l) == __llvm_libc::truncl(-1234.0l));
+}
+
+extern "C" long double truncl(long double);
+TEST(TrunclTest, InLongDoubleRange) {
+  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))
+      continue;
+
+    ASSERT_MPFR_MATCH(mpfr::Operation::Trunc, x, __llvm_libc::truncl(x),
+                      tolerance);
+  }
+}

libc/utils/FPUtil/BasicOperations.h

 //===-- Basic operations on floating point numbers --------------*- 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 "FloatOperations.h"
+#ifndef LLVM_LIBC_UTILS_FPUTIL_BASIC_OPERATIONS_H
+#define LLVM_LIBC_UTILS_FPUTIL_BASIC_OPERATIONS_H
+
+#include "FPBits.h"
+
+#include "utils/CPP/TypeTraits.h"
 
 namespace __llvm_libc {
 namespace fputil {
 
 template <typename T,
           cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
 static inline T abs(T x) {
-  return valueFromBits(absBits(x));
+  FPBits<T> bits(x);
+  bits.sign = 0;
+  return T(bits);
 }
 
 } // namespace fputil
 } // namespace __llvm_libc
+
+#endif // LLVM_LIBC_UTILS_FPUTIL_BASIC_OPERATIONS_H

libc/utils/FPUtil/CMakeLists.txt

+if(${LIBC_TARGET_MACHINE} MATCHES "^x86.*")
+  set(LONG_DOUBLE_HDR LongDoubleBitsX86.h)
+else()
+  set(LONG_DOUBLE_HDR)
+endif()
+
 add_header_library(
   fputil
   HDRS
+    ${LONG_DOUBLE_HDR}
     BitPatterns.h
     FloatOperations.h
     FloatProperties.h
+    FPBits.h
     ManipulationFunctions.h
-  DEPS
+  DEPENDS
     libc.utils.CPP.standalone_cpp
 )

libc/utils/FPUtil/FPBits.h

+//===-- Abstract class for bit manipulation of float numbers. ---*- 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_FP_BITS_H
+#define LLVM_LIBC_UTILS_FPUTIL_FP_BITS_H
+
+#include "utils/CPP/TypeTraits.h"
+
+#include <stdint.h>
+
+namespace __llvm_libc {
+namespace fputil {
+
+template <typename T> struct MantissaWidth {};
+template <> struct MantissaWidth<float> {
+  static constexpr unsigned value = 23;
+};
+template <> struct MantissaWidth<double> {
+  static constexpr unsigned value = 52;
+};
+
+template <typename T> struct ExponentWidth {};
+template <> struct ExponentWidth<float> {
+  static constexpr unsigned value = 8;
+};
+template <> struct ExponentWidth<double> {
+  static constexpr unsigned value = 11;
+};
+template <> struct ExponentWidth<long double> {
+  static constexpr unsigned value = 15;
+};
+
+template <typename T> struct FPUIntType {};
+template <> struct FPUIntType<float> { using Type = uint32_t; };
+template <> struct FPUIntType<double> { using Type = uint64_t; };
+
+#if !(defined(__x86_64__) || defined(__i386__))
+// TODO: This has to be extended for visual studio where long double and
+// double are equivalent.
+template <> struct MantissaWidth<long double> {
+  static constexpr unsigned value = 112;
+};
+
+template <> struct FPUIntType<long double> { using Type = __uint128_t; };
+#endif
+
+// A generic class to represent single precision, double precision, and quad
+// precision IEEE 754 floating point formats.
+// On most platforms, the 'float' type corresponds to single precision floating
+// point numbers, the 'double' type corresponds to double precision floating
+// point numers, and the 'long double' type corresponds to the quad precision
+// floating numbers. On x86 platforms however, the 'long double' type maps to
+// an x87 floating point format. This format is an IEEE 754 extension format.
+// It is handled as an explicit specialization of this class.
+template <typename T> struct __attribute__((packed)) FPBits {
+  static_assert(cpp::IsFloatingPointType<T>::Value,
+                "FPBits instantiated with invalid type.");
+
+  // Reinterpreting bits as an integer value and interpreting the bits of an
+  // integer value as a floating point value is used in tests. So, a convenient
+  // type is provided for such reinterpretations.
+  using UIntType = typename FPUIntType<T>::Type;
+
+  UIntType mantissa : MantissaWidth<T>::value;
+  uint16_t exponent : ExponentWidth<T>::value;
+  uint8_t sign : 1;
+
+  static constexpr int exponentBias = (1 << (ExponentWidth<T>::value - 1)) - 1;
+  static constexpr int maxExponent = (1 << ExponentWidth<T>::value) - 1;
+
+  // We don't want accidental type promotions/conversions so we require exact
+  // type match.
+  template <typename XType,
+            cpp::EnableIfType<cpp::IsSame<T, XType>::Value, int> = 0>
+  explicit FPBits(XType x) {
+    *this = *reinterpret_cast<FPBits<T> *>(&x);
+  }
+
+  operator T() { return *reinterpret_cast<T *>(this); }
+
+  int getExponent() const { return int(exponent) - exponentBias; }
+
+  bool isZero() const { return mantissa == 0 && exponent == 0; }
+
+  bool isInf() const { return mantissa == 0 && exponent == maxExponent; }
+
+  bool isNaN() const { return exponent == maxExponent && mantissa != 0; }
+
+  bool isInfOrNaN() const { return exponent == maxExponent; }
+
+  // Methods below this are used by tests.
+  // The to and from integer bits converters are only used in tests. Hence,
+  // the potential software implementations of UIntType will not slow real
+  // code.
+
+  template <typename XType,
+            cpp::EnableIfType<cpp::IsSame<UIntType, XType>::Value, int> = 0>
+  explicit FPBits<long double>(XType x) {
+    // The last 4 bytes of v are ignored in case of i386.
+    *this = *reinterpret_cast<FPBits<T> *>(&x);
+  }
+
+  UIntType bitsAsUInt() const {
+    return *reinterpret_cast<const UIntType *>(this);
+  }
+
+  static FPBits<T> zero() { return FPBits(T(0.0)); }
+
+  static FPBits<T> negZero() {
+    FPBits<T> bits(T(0.0));
+    bits.sign = 1;
+    return bits;
+  }
+
+  static FPBits<T> inf() {
+    FPBits<T> bits(T(0.0));
+    bits.exponent = maxExponent;
+    return bits;
+  }
+
+  static FPBits<T> negInf() {
+    FPBits<T> bits(T(0.0));
+    bits.exponent = maxExponent;
+    bits.sign = 1;
+    return bits;
+  }
+};
+
+} // namespace fputil
+} // namespace __llvm_libc
+
+#if defined(__x86_64__) || defined(__i386__)
+#include "utils/FPUtil/LongDoubleBitsX86.h"
+#endif
+
+#endif // LLVM_LIBC_UTILS_FPUTIL_FP_BITS_H

libc/utils/FPUtil/FloatOperations.h

 //===-- Common operations on floating point numbers -------------*- 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_FLOAT_OPERATIONS_H
 #define LLVM_LIBC_UTILS_FPUTIL_FLOAT_OPERATIONS_H
 
 #include "BitPatterns.h"
 #include "FloatProperties.h"
 
 #include "utils/CPP/TypeTraits.h"
 
 namespace __llvm_libc {
 namespace fputil {
 
 // Return the bits of a float value.
 template <typename T,
           cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
 static inline typename FloatProperties<T>::BitsType valueAsBits(T x) {

 
 // Return the zero adjusted exponent value of x.
 template <typename T,
           cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
 static inline int getExponent(T x) {
   return getExponentFromBits(valueAsBits(x));
 }
 
-
 } // namespace fputil
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_UTILS_FPUTIL_FLOAT_OPERATIONS_H

libc/utils/FPUtil/LongDoubleBitsX86.h

+//===-- Bit representation of x86 long double numbers -----------*- 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_LONG_DOUBLE_BITS_X86_H
+#define LLVM_LIBC_UTILS_FPUTIL_LONG_DOUBLE_BITS_X86_H
+
+#include "utils/FPUtil/FPBits.h"
+
+#include <stdint.h>
+
+namespace __llvm_libc {
+namespace fputil {
+
+template <> struct MantissaWidth<long double> {
+  static constexpr unsigned value = 63;
+};
+
+template <unsigned Width> struct Padding;
+
+// i386 padding.
+template <> struct Padding<4> { static constexpr unsigned Value = 16; };
+
+// x86_64 padding.
+template <> struct Padding<8> { static constexpr unsigned Value = 48; };
+
+template <> struct __attribute__((packed)) FPBits<long double> {
+  using UIntType = __uint128_t;
+
+  static constexpr int exponentBias = 0x3FFF;
+  static constexpr int maxExponent = 0x7FFF;
+
+  UIntType mantissa : MantissaWidth<long double>::value;
+  uint8_t implicitBit : 1;
+  uint16_t exponent : ExponentWidth<long double>::value;
+  uint8_t sign : 1;
+  uint64_t padding : Padding<sizeof(uintptr_t)>::Value;
+
+  template <typename XType,
+            cpp::EnableIfType<cpp::IsSame<long double, XType>::Value, int> = 0>
+  explicit FPBits<long double>(XType x) {
+    *this = *reinterpret_cast<FPBits<long double> *>(&x);
+  }
+
+  operator long double() { return *reinterpret_cast<long double *>(this); }
+
+  int getExponent() const {
+    if (exponent == 0)
+      return int(1) - exponentBias;
+    return int(exponent) - exponentBias;
+  }
+
+  bool isZero() const {
+    return exponent == 0 && mantissa == 0 && implicitBit == 0;
+  }
+
+  bool isInf() const {
+    return exponent == maxExponent && mantissa == 0 && implicitBit == 1;
+  }
+
+  bool isNaN() const { return exponent == maxExponent && mantissa != 0; }
+
+  bool isInfOrNaN() const { return exponent == maxExponent; }
+
+  // Methods below this are used by tests.
+
+  template <typename XType,
+            cpp::EnableIfType<cpp::IsSame<UIntType, XType>::Value, int> = 0>
+  explicit FPBits<long double>(XType x) {
+    // The last 4 bytes of v are ignored in case of i386.
+    *this = *reinterpret_cast<FPBits<long double> *>(&x);
+  }
+
+  UIntType bitsAsUInt() const {
+    // We cannot just return the bits as is as it will lead to reading
+    // out of bounds in case of i386. So, we first copy the wider value
+    // before returning the value. This makes the last 4 bytes are always
+    // zero in case i386.
+    UIntType result = UIntType(0);
+    *reinterpret_cast<FPBits<long double> *>(&result) = *this;
+    return result;
+  }
+
+  static FPBits<long double> zero() { return FPBits<long double>(0.0l); }
+
+  static FPBits<long double> negZero() {
+    FPBits<long double> bits(0.0l);
+    bits.sign = 1;
+    return bits;
+  }
+
+  static FPBits<long double> inf() {
+    FPBits<long double> bits(0.0l);
+    bits.exponent = maxExponent;
+    bits.implicitBit = 1;
+    return bits;
+  }
+
+  static FPBits<long double> negInf() {
+    FPBits<long double> bits(0.0l);
+    bits.exponent = maxExponent;
+    bits.implicitBit = 1;
+    bits.sign = 1;
+    return bits;
+  }
+};
+
+static_assert(
+    sizeof(FPBits<long double>) == sizeof(long double),
+    "Internal long double representation does not match the machine format.");
+
+} // namespace fputil
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_UTILS_FPUTIL_LONG_DOUBLE_BITS_X86_H

libc/utils/FPUtil/NearestIntegerOperations.h

 //===-- Nearest integer floating-point operations ---------------*- 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_NEAREST_INTEGER_OPERATIONS_H
 #define LLVM_LIBC_UTILS_FPUTIL_NEAREST_INTEGER_OPERATIONS_H
 
 #include "ClassificationFunctions.h"
+#include "FPBits.h"
 #include "FloatOperations.h"
 #include "FloatProperties.h"
 
 #include "utils/CPP/TypeTraits.h"
 
 namespace __llvm_libc {
 namespace fputil {
 
 template <typename T,
           cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
 static inline T trunc(T x) {
-  using Properties = FloatProperties<T>;
-  using BitsType = typename FloatProperties<T>::BitsType;
+  FPBits<T> bits(x);
 
-  BitsType bits = valueAsBits(x);
-
-  // If x is infinity, NaN or zero, return it.
-  if (bitsAreInfOrNaN(bits) || bitsAreZero(bits))
+  // If x is infinity or NaN, return it.
+  // If it is zero also we should return it as is, but the logic
+  // later in this function takes care of it. But not doing a zero
+  // check, we improve the run time of non-zero values.
+  if (bits.isInfOrNaN())
     return x;
 
-  int exponent = getExponentFromBits(bits);
+  int exponent = bits.getExponent();
 
   // If the exponent is greater than the most negative mantissa
   // exponent, then x is already an integer.
-  if (exponent >= static_cast<int>(Properties::mantissaWidth))
+  if (exponent >= static_cast<int>(MantissaWidth<T>::value))
     return x;
 
   // If the exponent is such that abs(x) is less than 1, then return 0.
   if (exponent <= -1) {
-    if (Properties::signMask & bits)
+    if (bits.sign)
       return T(-0.0);
     else
       return T(0.0);
   }
 
-  uint32_t trimSize = Properties::mantissaWidth - exponent;
-  return valueFromBits((bits >> trimSize) << trimSize);
+  int trimSize = MantissaWidth<T>::value - exponent;
+  bits.mantissa = (bits.mantissa >> trimSize) << trimSize;
+  return bits;
 }
 
 template <typename T,
           cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
 static inline T ceil(T x) {
   using Properties = FloatProperties<T>;
   using BitsType = typename FloatProperties<T>::BitsType;
 

libc/utils/MPFRWrapper/MPFRUtils.cpp

 //===-- Utils which wrap MPFR ---------------------------------------------===//
 //
 // 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 "MPFRUtils.h"
 
-#include "utils/FPUtil/FloatOperations.h"
+#include "utils/FPUtil/FPBits.h"
 
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 
 #include <mpfr.h>
 #include <stdint.h>
 #include <string>
 
+template <typename T> using FPBits = __llvm_libc::fputil::FPBits<T>;
+
 namespace __llvm_libc {
 namespace testing {
 namespace mpfr {
 
 class MPFRNumber {
   // A precision value which allows sufficiently large additional
-  // precision even compared to double precision floating point values.
-  static constexpr unsigned int mpfrPrecision = 96;
+  // precision even compared to quad-precision floating point values.
+  static constexpr unsigned int mpfrPrecision = 128;
 
   mpfr_t value;
 
 public:
   MPFRNumber() { mpfr_init2(value, mpfrPrecision); }
 
   // We use explicit EnableIf specializations to disallow implicit
   // conversions. Implicit conversions can potentially lead to loss of
   // precision.
   template <typename XType,
             cpp::EnableIfType<cpp::IsSame<float, XType>::Value, int> = 0>
   explicit MPFRNumber(XType x) {
     mpfr_init2(value, mpfrPrecision);
     mpfr_set_flt(value, x, MPFR_RNDN);
   }
 
   template <typename XType,
             cpp::EnableIfType<cpp::IsSame<double, XType>::Value, int> = 0>
   explicit MPFRNumber(XType x) {
     mpfr_init2(value, mpfrPrecision);
     mpfr_set_d(value, x, MPFR_RNDN);
   }
 
   template <typename XType,
+            cpp::EnableIfType<cpp::IsSame<long double, XType>::Value, int> = 0>
+  explicit MPFRNumber(XType x) {
+    mpfr_init2(value, mpfrPrecision);
+    mpfr_set_ld(value, x, MPFR_RNDN);
+  }
+
+  template <typename XType,
             cpp::EnableIfType<cpp::IsIntegral<XType>::Value, int> = 0>
   explicit MPFRNumber(XType x) {
     mpfr_init2(value, mpfrPrecision);
     mpfr_set_sj(value, x, MPFR_RNDN);
   }
 
   template <typename XType> MPFRNumber(XType x, const Tolerance &t) {
     mpfr_init2(value, mpfrPrecision);
     mpfr_set_zero(value, 1); // Set to positive zero.
-    MPFRNumber xExponent(fputil::getExponent(x));
+    MPFRNumber xExponent(fputil::FPBits<XType>(x).getExponent());
     // E = 2^E
     mpfr_exp2(xExponent.value, xExponent.value, MPFR_RNDN);
     uint32_t bitMask = 1 << (t.width - 1);
     for (int n = -t.basePrecision; bitMask > 0; bitMask >>= 1) {
       --n;
       if (t.bits & bitMask) {
         // delta = -n
         MPFRNumber delta(n);
public:
   double asDouble() const { return mpfr_get_d(value, MPFR_RNDN); }
   void dump(const char *msg) const { mpfr_printf("%s%.128Rf\n", msg, value); }
 };
 
 namespace internal {
 
 template <typename T>
 void MPFRMatcher<T>::explainError(testutils::StreamWrapper &OS) {
-  using fputil::valueAsBits;
-
   MPFRNumber mpfrResult(operation, input);
   MPFRNumber mpfrInput(input);
   MPFRNumber mpfrMatchValue(matchValue);
   MPFRNumber mpfrToleranceValue(matchValue, tolerance);
+  FPBits<T> inputBits(input);
+  FPBits<T> matchBits(matchValue);
+  // TODO: Call to llvm::utohexstr implicitly converts __uint128_t values to
+  // uint64_t values. This can be fixed using a custom wrapper for
+  // llvm::utohexstr to handle __uint128_t values correctly.
   OS << "Match value not within tolerance value of MPFR result:\n"
      << "  Input decimal: " << mpfrInput.str() << '\n'
-     << "     Input bits: 0x" << llvm::utohexstr(valueAsBits(input)) << '\n'
+     << "     Input bits: 0x" << llvm::utohexstr(inputBits.bitsAsUInt()) << '\n'
      << "  Match decimal: " << mpfrMatchValue.str() << '\n'
-     << "     Match bits: 0x" << llvm::utohexstr(valueAsBits(matchValue))
-     << '\n'
+     << "     Match bits: 0x" << llvm::utohexstr(matchBits.bitsAsUInt()) << '\n'
      << "    MPFR result: " << mpfrResult.str() << '\n'
      << "Tolerance value: " << mpfrToleranceValue.str() << '\n';
 }
 
 template void MPFRMatcher<float>::explainError(testutils::StreamWrapper &);
 template void MPFRMatcher<double>::explainError(testutils::StreamWrapper &);
+template void
+MPFRMatcher<long double>::explainError(testutils::StreamWrapper &);
 
 template <typename T>
 bool compare(Operation op, T input, T libcResult, const Tolerance &t) {
   MPFRNumber mpfrResult(op, input);
   MPFRNumber mpfrLibcResult(libcResult);
   MPFRNumber mpfrToleranceValue(libcResult, t);
 
   return mpfrResult.isEqual(mpfrLibcResult, mpfrToleranceValue);
 };
 
 template bool compare<float>(Operation, float, float, const Tolerance &);
 template bool compare<double>(Operation, double, double, const Tolerance &);
+template bool compare<long double>(Operation, long double, long double,
+                                   const Tolerance &);
 
 } // namespace internal
 
 } // namespace mpfr
 } // namespace testing
 } // namespace __llvm_libc