[libc] Make FPBits a union.

[sivachandra]

Summary

This helps us avoid the uncomfortable reinterpret-casts. Avoiding the
reinterpret casts prevents us from tripping the sanitizers as well.

libc/fuzzing/math/Compare.h

 ValuesEqual(T x1, T x2) {
   __llvm_libc::fputil::FPBits<T> bits1(x1);
   __llvm_libc::fputil::FPBits<T> bits2(x2);
   // If either is NaN, we want both to be NaN.
   if (bits1.isNaN() || bits2.isNaN())
     return bits2.isNaN() && bits2.isNaN();
 
   // For all other values, we want the values to be bitwise equal.
-  return bits1.bitsAsUInt() == bits2.bitsAsUInt();
+  return bits1.uintval() == bits2.uintval();
 }
 
 template <typename T>
 __llvm_libc::cpp::EnableIfType<__llvm_libc::cpp::IsIntegral<T>::Value, bool>
 ValuesEqual(T x1, T x2) {
   return x1 == x1;
 }
 
 #endif // LLVM_LIBC_FUZZING_MATH_COMPARE_H

libc/fuzzing/math/RemQuoDiff.h

if (isinf(remainder2) != isinf(remainder1))
     __builtin_trap();
 
   // Compare only the 3 LS bits of the quotient.
   if ((q1 & 0x7) != (q2 & 0x7))
     __builtin_trap();
 
   __llvm_libc::fputil::FPBits<T> bits1(remainder1);
   __llvm_libc::fputil::FPBits<T> bits2(remainder2);
-  if (bits1.bitsAsUInt() != bits2.bitsAsUInt())
+  if (bits1.uintval() != bits2.uintval())
     __builtin_trap();
 }

libc/src/math/generic/fmaf.cpp

if (!(bit_sum.isInfOrNaN() || bit_sum.isZero())) {
     // Dekker's 2Sum algorithm to find t such that sum - t = prod + z exactly,
     // assuming the (default) rounding mode is round-to-the-nearest,
     // tie-to-even.  Moreover, t satisfies the condition that t < eps(sum),
     // i.e., t.exponent < sum.exponent - 52. So if t is not 0, meaning rounding
     // occurs when computing the sum, we just need to use t to adjust (any) last
     // bit of sum, so that the sticky bits used when rounding sum to float are
     // correct (when it matters).
     fputil::FPBits<double> t(
-        (bit_prod.exponent >= bitz.exponent)
-            ? ((static_cast<double>(bit_sum) - bit_prod) - bitz)
-            : ((static_cast<double>(bit_sum) - bitz) - bit_prod));
+        (bit_prod.encoding.exponent >= bitz.encoding.exponent)
+            ? ((double(bit_sum) - double(bit_prod)) - double(bitz))
+            : ((double(bit_sum) - double(bitz)) - double(bit_prod)));
 
     // Update sticky bits if t != 0.0 and the least (52 - 23 - 1 = 28) bits are
     // zero.
-    if (!t.isZero() && ((bit_sum.mantissa & 0xfff'ffffULL) == 0)) {
-      if (bit_sum.sign != t.sign) {
-        ++bit_sum.mantissa;
-      } else if (bit_sum.mantissa) {
-        --bit_sum.mantissa;
+    if (!t.isZero() && ((bit_sum.encoding.mantissa & 0xfff'ffffULL) == 0)) {
+      if (bit_sum.encoding.sign != t.encoding.sign) {
+        ++bit_sum.encoding.mantissa;
+      } else if (bit_sum.encoding.mantissa) {
+        --bit_sum.encoding.mantissa;
       }
     }
   }
 
   return static_cast<float>(static_cast<double>(bit_sum));
 }
 
 } // namespace __llvm_libc

libc/test/src/math/LdExpTest.h

void testNormalOperation(LdExpFunc func) {
     // Start with a normal number high exponent but pass a very low number for
     // exp. The result should be a subnormal number.
     x = NormalFloat(FPBits::exponentBias, NormalFloat::one, 0);
     int exp = -FPBits::maxExponent - 5;
     T result = func(x, exp);
     FPBits resultBits(result);
     ASSERT_FALSE(resultBits.isZero());
     // Verify that the result is indeed subnormal.
-    ASSERT_EQ(resultBits.exponent, uint16_t(0));
+    ASSERT_EQ(resultBits.encoding.exponent, uint16_t(0));
     // But if the exp is so less that normalization leads to zero, then
     // the result should be zero.
     result = func(x, -FPBits::maxExponent - int(mantissaWidth) - 5);
     ASSERT_TRUE(FPBits(result).isZero());
 
     // Start with a subnormal number but pass a very high number for exponent.
     // The result should not be infinity.
     x = NormalFloat(-FPBits::exponentBias + 1, NormalFloat::one >> 10, 0);

libc/test/src/math/NextAfterTest.h

void testBoundaries(NextAfterFunc func) {
     ASSERT_FP_EQ(result, expected);
     ASSERT_FP_EQ(func(x, negInf), negInf);
 
     // 'from' is a power of 2.
     x = T(32.0);
     result = func(x, 0);
     FPBits xBits = FPBits(x);
     FPBits resultBits = FPBits(result);
-    ASSERT_EQ(resultBits.exponent, uint16_t(xBits.exponent - 1));
-    ASSERT_EQ(resultBits.mantissa, (UIntType(1) << MantissaWidth::value) - 1);
+    ASSERT_EQ(resultBits.encoding.exponent,
+              uint16_t(xBits.encoding.exponent - 1));
+    ASSERT_EQ(resultBits.encoding.mantissa,
+              (UIntType(1) << MantissaWidth::value) - 1);
 
     result = func(x, T(33.0));
     resultBits = FPBits(result);
-    ASSERT_EQ(resultBits.exponent, xBits.exponent);
-    ASSERT_EQ(resultBits.mantissa, xBits.mantissa + UIntType(1));
+    ASSERT_EQ(resultBits.encoding.exponent, xBits.encoding.exponent);
+    ASSERT_EQ(resultBits.encoding.mantissa,
+              xBits.encoding.mantissa + UIntType(1));
 
     x = -x;
 
     result = func(x, 0);
     resultBits = FPBits(result);
-    ASSERT_EQ(resultBits.exponent, uint16_t(xBits.exponent - 1));
-    ASSERT_EQ(resultBits.mantissa, (UIntType(1) << MantissaWidth::value) - 1);
+    ASSERT_EQ(resultBits.encoding.exponent,
+              uint16_t(xBits.encoding.exponent - 1));
+    ASSERT_EQ(resultBits.encoding.mantissa,
+              (UIntType(1) << MantissaWidth::value) - 1);
 
     result = func(x, T(-33.0));
     resultBits = FPBits(result);
-    ASSERT_EQ(resultBits.exponent, xBits.exponent);
-    ASSERT_EQ(resultBits.mantissa, xBits.mantissa + UIntType(1));
+    ASSERT_EQ(resultBits.encoding.exponent, xBits.encoding.exponent);
+    ASSERT_EQ(resultBits.encoding.mantissa,
+              xBits.encoding.mantissa + UIntType(1));
   }
 };
 
 #define LIST_NEXTAFTER_TESTS(T, func)                                          \
   using LlvmLibcNextAfterTest = NextAfterTestTemplate<T>;                      \
   TEST_F(LlvmLibcNextAfterTest, TestNaN) { testNaN(&func); }                   \
   TEST_F(LlvmLibcNextAfterTest, TestBoundaries) { testBoundaries(&func); }
 
 #endif // LLVM_LIBC_TEST_SRC_MATH_NEXTAFTERTEST_H

libc/test/src/math/RoundToIntegerTest.h

void doRoundNumbersTest(RoundToIntegerFunc func) {
     // long.
     if (sizeof(I) > sizeof(long))
       return;
 
     constexpr int exponentLimit = sizeof(I) * 8 - 1;
     // We start with 1.0 so that the implicit bit for x86 long doubles
     // is set.
     FPBits bits(F(1.0));
-    bits.exponent = exponentLimit + FPBits::exponentBias;
-    bits.sign = 1;
-    bits.mantissa = 0;
+    bits.encoding.exponent = exponentLimit + FPBits::exponentBias;
+    bits.encoding.sign = 1;
+    bits.encoding.mantissa = 0;
 
     F x = bits;
     long mpfrResult;
     bool erangeflag = mpfr::RoundToLong(x, mpfrResult);
     ASSERT_FALSE(erangeflag);
     testOneInput(func, x, mpfrResult, false);
   }
 
void testIntegerOverflow(RoundToIntegerFunc func) {
     // that of long.
     if (sizeof(I) > sizeof(long))
       return;
 
     constexpr int exponentLimit = sizeof(I) * 8 - 1;
     // We start with 1.0 so that the implicit bit for x86 long doubles
     // is set.
     FPBits bits(F(1.0));
-    bits.exponent = exponentLimit + FPBits::exponentBias;
-    bits.sign = 1;
-    bits.mantissa = UIntType(0x1)
-                    << (__llvm_libc::fputil::MantissaWidth<F>::value - 1);
+    bits.encoding.exponent = exponentLimit + FPBits::exponentBias;
+    bits.encoding.sign = 1;
+    bits.encoding.mantissa =
+        UIntType(0x1) << (__llvm_libc::fputil::MantissaWidth<F>::value - 1);
 
     F x = bits;
     if (TestModes) {
       for (int m : roundingModes) {
         __llvm_libc::fputil::setRound(m);
         long mpfrLongResult;
         bool erangeflag =
             mpfr::RoundToLong(x, toMPFRRoundingMode(m), mpfrLongResult);

libc/test/src/math/sqrt_test.cpp

TEST(LlvmLibcSqrtTest, SpecialValues) {
   ASSERT_FP_EQ(1.0, __llvm_libc::sqrt(1.0));
   ASSERT_FP_EQ(2.0, __llvm_libc::sqrt(4.0));
   ASSERT_FP_EQ(3.0, __llvm_libc::sqrt(9.0));
 }
 
 TEST(LlvmLibcSqrtTest, DenormalValues) {
   for (UIntType mant = 1; mant < HiddenBit; mant <<= 1) {
     FPBits denormal(0.0);
-    denormal.mantissa = mant;
+    denormal.encoding.mantissa = mant;
 
     ASSERT_MPFR_MATCH(mpfr::Operation::Sqrt, double(denormal),
                       __llvm_libc::sqrt(denormal), 0.5);
   }
 
   constexpr UIntType count = 1'000'001;
   constexpr UIntType step = HiddenBit / count;
   for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {

libc/test/src/math/sqrtf_test.cpp

TEST(LlvmLibcSqrtfTest, SpecialValues) {
   ASSERT_FP_EQ(1.0f, __llvm_libc::sqrtf(1.0f));
   ASSERT_FP_EQ(2.0f, __llvm_libc::sqrtf(4.0f));
   ASSERT_FP_EQ(3.0f, __llvm_libc::sqrtf(9.0f));
 }
 
 TEST(LlvmLibcSqrtfTest, DenormalValues) {
   for (UIntType mant = 1; mant < HiddenBit; mant <<= 1) {
     FPBits denormal(0.0f);
-    denormal.mantissa = mant;
+    denormal.encoding.mantissa = mant;
 
     ASSERT_MPFR_MATCH(mpfr::Operation::Sqrt, float(denormal),
                       __llvm_libc::sqrtf(denormal), 0.5);
   }
 
   constexpr UIntType count = 1'000'001;
   constexpr UIntType step = HiddenBit / count;
   for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {

libc/test/src/math/sqrtl_test.cpp

TEST(LlvmLibcSqrtlTest, SpecialValues) {
   ASSERT_FP_EQ(1.0L, __llvm_libc::sqrtl(1.0L));
   ASSERT_FP_EQ(2.0L, __llvm_libc::sqrtl(4.0L));
   ASSERT_FP_EQ(3.0L, __llvm_libc::sqrtl(9.0L));
 }
 
 TEST(LlvmLibcSqrtlTest, DenormalValues) {
   for (UIntType mant = 1; mant < HiddenBit; mant <<= 1) {
     FPBits denormal(0.0L);
-    denormal.mantissa = mant;
+    denormal.encoding.mantissa = mant;
 
     ASSERT_MPFR_MATCH(mpfr::Operation::Sqrt, static_cast<long double>(denormal),
                       __llvm_libc::sqrtl(denormal), 0.5);
   }
 
   constexpr UIntType count = 1'000'001;
   constexpr UIntType step = HiddenBit / count;
   for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {

libc/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) {
   FPBits<T> bits(x);
-  bits.sign = 0;
+  bits.encoding.sign = 0;
   return T(bits);
 }
 
 template <typename T,
           cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
 static inline T fmin(T x, T y) {
   FPBits<T> bitx(x), bity(y);
 
   if (bitx.isNaN()) {
     return y;
   } else if (bity.isNaN()) {
     return x;
-  } else if (bitx.sign != bity.sign) {
+  } else if (bitx.encoding.sign != bity.encoding.sign) {
     // To make sure that fmin(+0, -0) == -0 == fmin(-0, +0), whenever x and
     // y has different signs and both are not NaNs, we return the number
     // with negative sign.
-    return (bitx.sign ? x : y);
+    return (bitx.encoding.sign ? x : y);
   } else {
     return (x < y ? x : y);
   }
 }
 
 template <typename T,
           cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
 static inline T fmax(T x, T y) {
   FPBits<T> bitx(x), bity(y);
 
   if (bitx.isNaN()) {
     return y;
   } else if (bity.isNaN()) {
     return x;
-  } else if (bitx.sign != bity.sign) {
+  } else if (bitx.encoding.sign != bity.encoding.sign) {
     // To make sure that fmax(+0, -0) == +0 == fmax(-0, +0), whenever x and
     // y has different signs and both are not NaNs, we return the number
     // with positive sign.
-    return (bitx.sign ? y : x);
+    return (bitx.encoding.sign ? y : x);
   } else {
     return (x > y ? x : y);
   }
 }
 
 template <typename T,
           cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
 static inline T fdim(T x, T y) {

libc/utils/FPUtil/DivisionAndRemainderOperations.h

if (xbits.isZero()) {
     return __llvm_libc::fputil::copysign(T(0.0), x);
   }
 
   if (ybits.isInf()) {
     q = 0;
     return x;
   }
 
-  bool resultSign = (xbits.sign == ybits.sign ? false : true);
+  bool resultSign = (xbits.encoding.sign == ybits.encoding.sign ? false : true);
 
   // Once we know the sign of the result, we can just operate on the absolute
   // values. The correct sign can be applied to the result after the result
   // is evaluated.
-  xbits.sign = ybits.sign = 0;
+  xbits.encoding.sign = ybits.encoding.sign = 0;
 
   NormalFloat<T> normalx(xbits), normaly(ybits);
   int exp = normalx.exponent - normaly.exponent;
   typename NormalFloat<T>::UIntType mx = normalx.mantissa,
                                     my = normaly.mantissa;
 
   q = 0;
   while (exp >= 0) {

libc/utils/FPUtil/FPBits.h

 // 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 {
+template <typename T> union 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;
 
+  struct __attribute__((packed)) {
     UIntType mantissa : MantissaWidth<T>::value;
     uint16_t exponent : ExponentWidth<T>::value;
     uint8_t sign : 1;
+  } encoding;
+  UIntType integer;
+  T val;
+
+  static_assert(sizeof(encoding) == sizeof(UIntType),
+                "Encoding and integral representation have different sizes.");
+  static_assert(sizeof(integer) == sizeof(UIntType),
+                "Integral representation and value type have different sizes.");
 
   static constexpr int exponentBias = (1 << (ExponentWidth<T>::value - 1)) - 1;
   static constexpr int maxExponent = (1 << ExponentWidth<T>::value) - 1;
 
   static constexpr UIntType minSubnormal = UIntType(1);
   static constexpr UIntType maxSubnormal =
       (UIntType(1) << MantissaWidth<T>::value) - 1;
   static constexpr UIntType minNormal =
       (UIntType(1) << MantissaWidth<T>::value);
   static constexpr UIntType maxNormal =
       ((UIntType(maxExponent) - 1) << MantissaWidth<T>::value) | maxSubnormal;
 
   // We don't want accidental type promotions/conversions so we require exact
   // type match.
   template <typename XType,
-            cpp::EnableIfType<cpp::IsSame<T, XType>::Value ||
-                                  (cpp::IsIntegral<XType>::Value &&
-                                   (sizeof(XType) == sizeof(UIntType))),
-                              int> = 0>
-  explicit FPBits(XType x) {
-    *this = *reinterpret_cast<FPBits<T> *>(&x);
-  }
+            cpp::EnableIfType<cpp::IsSame<T, XType>::Value, int> = 0>
+  explicit FPBits(XType x) : val(x) {}
 
-  operator T() { return *reinterpret_cast<T *>(this); }
+  template <typename XType,
+            cpp::EnableIfType<cpp::IsSame<XType, UIntType>::Value, int> = 0>
+  explicit FPBits(XType x) : integer(x) {}
 
-  int getExponent() const { return int(exponent) - exponentBias; }
+  FPBits() : integer(0) {}
 
-  bool isZero() const { return mantissa == 0 && exponent == 0; }
+  operator T() { return val; }
 
-  bool isInf() const { return mantissa == 0 && exponent == maxExponent; }
+  UIntType uintval() const { return integer; }
 
-  bool isNaN() const { return exponent == maxExponent && mantissa != 0; }
+  int getExponent() const { return int(encoding.exponent) - exponentBias; }
 
-  bool isInfOrNaN() const { return exponent == maxExponent; }
+  bool isZero() const {
+    return encoding.mantissa == 0 && encoding.exponent == 0;
+  }
 
-  // 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.
+  bool isInf() const {
+    return encoding.mantissa == 0 && encoding.exponent == maxExponent;
+  }
 
-  UIntType bitsAsUInt() const {
-    return *reinterpret_cast<const UIntType *>(this);
+  bool isNaN() const {
+    return encoding.exponent == maxExponent && encoding.mantissa != 0;
   }
 
-  static FPBits<T> zero() { return FPBits(T(0.0)); }
+  bool isInfOrNaN() const { return encoding.exponent == maxExponent; }
+
+  static FPBits<T> zero() { return FPBits(); }
 
   static FPBits<T> negZero() {
-    FPBits<T> bits(T(0.0));
-    bits.sign = 1;
-    return bits;
+    return FPBits(UIntType(1) << (sizeof(UIntType) * 8 - 1));
   }
 
   static FPBits<T> inf() {
-    FPBits<T> bits(T(0.0));
-    bits.exponent = maxExponent;
+    FPBits<T> bits;
+    bits.encoding.exponent = maxExponent;
     return bits;
   }
 
   static FPBits<T> negInf() {
-    FPBits<T> bits(T(0.0));
-    bits.exponent = maxExponent;
-    bits.sign = 1;
+    FPBits<T> bits = inf();
+    bits.encoding.sign = 1;
     return bits;
   }
 
   static T buildNaN(UIntType v) {
-    FPBits<T> bits(T(0.0));
-    bits.exponent = maxExponent;
-    bits.mantissa = v;
+    FPBits<T> bits = inf();
+    bits.encoding.mantissa = v;
     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/Hypot.h

if (y_bits.isNaN()) {
     return y;
   }
 
   uint16_t a_exp, b_exp, out_exp;
   UIntType a_mant, b_mant;
   DUIntType a_mant_sq, b_mant_sq;
   bool sticky_bits;
 
-  if ((x_bits.exponent >= y_bits.exponent + MantissaWidth<T>::value + 2) ||
+  if ((x_bits.encoding.exponent >=
+       y_bits.encoding.exponent + MantissaWidth<T>::value + 2) ||
       (y == 0)) {
     return abs(x);
-  } else if ((y_bits.exponent >=
-              x_bits.exponent + MantissaWidth<T>::value + 2) ||
+  } else if ((y_bits.encoding.exponent >=
+              x_bits.encoding.exponent + MantissaWidth<T>::value + 2) ||
              (x == 0)) {
-    y_bits.sign = 0;
+    y_bits.encoding.sign = 0;
     return abs(y);
   }
 
   if (x >= y) {
-    a_exp = x_bits.exponent;
-    a_mant = x_bits.mantissa;
-    b_exp = y_bits.exponent;
-    b_mant = y_bits.mantissa;
+    a_exp = x_bits.encoding.exponent;
+    a_mant = x_bits.encoding.mantissa;
+    b_exp = y_bits.encoding.exponent;
+    b_mant = y_bits.encoding.mantissa;
   } else {
-    a_exp = y_bits.exponent;
-    a_mant = y_bits.mantissa;
-    b_exp = x_bits.exponent;
-    b_mant = x_bits.mantissa;
+    a_exp = y_bits.encoding.exponent;
+    a_mant = y_bits.encoding.mantissa;
+    b_exp = x_bits.encoding.exponent;
+    b_mant = x_bits.encoding.mantissa;
   }
 
   out_exp = a_exp;
 
   // Add an extra bit to simplify the final rounding bit computation.
   constexpr UIntType one = UIntType(1) << (MantissaWidth<T>::value + 1);
 
   a_mant <<= 1;

libc/utils/FPUtil/LongDoubleBitsX86.h

 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> {
+template <> union FPBits<long double> {
   using UIntType = __uint128_t;
 
   static constexpr int exponentBias = 0x3FFF;
   static constexpr int maxExponent = 0x7FFF;
   static constexpr UIntType minSubnormal = UIntType(1);
   // Subnormal numbers include the implicit bit in x86 long double formats.
   static constexpr UIntType maxSubnormal =
       (UIntType(1) << (MantissaWidth<long double>::value)) - 1;
   static constexpr UIntType minNormal =
       (UIntType(3) << MantissaWidth<long double>::value);
   static constexpr UIntType maxNormal =
       ((UIntType(maxExponent) - 1) << (MantissaWidth<long double>::value + 1)) |
       (UIntType(1) << MantissaWidth<long double>::value) | maxSubnormal;
 
+  struct __attribute__((packed)) {
     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;
+  } encoding;
+  UIntType integer;
+  long double val;
+
+  FPBits() : integer(0) {}
 
   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);
-  }
+  explicit FPBits<long double>(XType x) : val(x) {}
 
-  operator long double() { return *reinterpret_cast<long double *>(this); }
+  template <typename XType,
+            cpp::EnableIfType<cpp::IsSame<XType, UIntType>::Value, int> = 0>
+  explicit FPBits(XType x) : integer(x) {}
+
+  operator long double() { return val; }
+
+  UIntType uintval() {
+    // We zero the padding bits as they can contain garbage.
+    static constexpr UIntType mask =
+        (UIntType(1) << (sizeof(long double) * 8 -
+                         Padding<sizeof(uintptr_t)>::value)) -
+        1;
+    return integer & mask;
+  }
 
   int getExponent() const {
-    if (exponent == 0)
+    if (encoding.exponent == 0)
       return int(1) - exponentBias;
-    return int(exponent) - exponentBias;
+    return int(encoding.exponent) - exponentBias;
   }
 
   bool isZero() const {
-    return exponent == 0 && mantissa == 0 && implicitBit == 0;
+    return encoding.exponent == 0 && encoding.mantissa == 0 &&
+           encoding.implicitBit == 0;
   }
 
   bool isInf() const {
-    return exponent == maxExponent && mantissa == 0 && implicitBit == 1;
+    return encoding.exponent == maxExponent && encoding.mantissa == 0 &&
+           encoding.implicitBit == 1;
   }
 
   bool isNaN() const {
-    if (exponent == maxExponent) {
-      return (implicitBit == 0) || mantissa != 0;
-    } else if (exponent != 0) {
-      return implicitBit == 0;
+    if (encoding.exponent == maxExponent) {
+      return (encoding.implicitBit == 0) || encoding.mantissa != 0;
+    } else if (encoding.exponent != 0) {
+      return encoding.implicitBit == 0;
     }
     return false;
   }
 
   bool isInfOrNaN() const {
-    return (exponent == maxExponent) || (exponent != 0 && implicitBit == 0);
+    return (encoding.exponent == maxExponent) ||
+           (encoding.exponent != 0 && encoding.implicitBit == 0);
   }
 
   // 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;
-
-    // Even though we zero out |result| before copying the long double value,
-    // there can be garbage bits in the padding. So, we zero the padding bits
-    // in |result|.
-    static constexpr UIntType mask =
-        (UIntType(1) << (sizeof(long double) * 8 -
-                         Padding<sizeof(uintptr_t)>::value)) -
-        1;
-    return result & mask;
-  }
-
   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;
+    bits.encoding.sign = 1;
     return bits;
   }
 
   static FPBits<long double> inf() {
     FPBits<long double> bits(0.0l);
-    bits.exponent = maxExponent;
-    bits.implicitBit = 1;
+    bits.encoding.exponent = maxExponent;
+    bits.encoding.implicitBit = 1;
     return bits;
   }
 
   static FPBits<long double> negInf() {
     FPBits<long double> bits(0.0l);
-    bits.exponent = maxExponent;
-    bits.implicitBit = 1;
-    bits.sign = 1;
+    bits.encoding.exponent = maxExponent;
+    bits.encoding.implicitBit = 1;
+    bits.encoding.sign = 1;
     return bits;
   }
 
   static long double buildNaN(UIntType v) {
     FPBits<long double> bits(0.0l);
-    bits.exponent = maxExponent;
-    bits.implicitBit = 1;
-    bits.mantissa = v;
+    bits.encoding.exponent = maxExponent;
+    bits.encoding.implicitBit = 1;
+    bits.encoding.mantissa = v;
     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/ManipulationFunctions.h

template <typename T,
           cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
 static inline T modf(T x, T &iptr) {
   FPBits<T> bits(x);
   if (bits.isZero() || bits.isNaN()) {
     iptr = x;
     return x;
   } else if (bits.isInf()) {
     iptr = x;
-    return bits.sign ? FPBits<T>::negZero() : FPBits<T>::zero();
+    return bits.encoding.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.sign ? FPBits<T>::negZero() : FPBits<T>::zero();
+      return bits.encoding.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) {
   FPBits<T> xbits(x);
-  xbits.sign = FPBits<T>(y).sign;
+  xbits.encoding.sign = FPBits<T>(y).encoding.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.
static inline T ldexp(T x, int exp) {
   // NormalFloat uses int32_t to store the true exponent value. We should ensure
   // that adding |exp| to it does not lead to integer rollover. But, if |exp|
   // value is larger the exponent range for type T, then we can return infinity
   // early. Because the result of the ldexp operation can be a subnormal number,
   // we need to accommodate the (mantissaWidht + 1) worth of shift in
   // calculating the limit.
   int expLimit = FPBits<T>::maxExponent + MantissaWidth<T>::value + 1;
   if (exp > expLimit)
-    return bits.sign ? FPBits<T>::negInf() : FPBits<T>::inf();
+    return bits.encoding.sign ? FPBits<T>::negInf() : FPBits<T>::inf();
 
   // Similarly on the negative side we return zero early if |exp| is too small.
   if (exp < -expLimit)
-    return bits.sign ? FPBits<T>::negZero() : FPBits<T>::zero();
+    return bits.encoding.sign ? FPBits<T>::negZero() : FPBits<T>::zero();
 
   // For all other values, NormalFloat to T conversion handles it the right way.
   NormalFloat<T> normal(bits);
   normal.exponent += exp;
   return normal;
 }
 
 template <typename T,
           cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
 static inline T nextafter(T from, T to) {
   FPBits<T> fromBits(from);
   if (fromBits.isNaN())
     return from;
 
   FPBits<T> toBits(to);
   if (toBits.isNaN())
     return to;
 
   if (from == to)
     return to;
 
   using UIntType = typename FPBits<T>::UIntType;
-  auto intVal = fromBits.bitsAsUInt();
+  UIntType intVal = fromBits.uintval();
   UIntType signMask = (UIntType(1) << (sizeof(T) * 8 - 1));
   if (from != T(0.0)) {
     if ((from < to) == (from > T(0.0))) {
       ++intVal;
     } else {
       --intVal;
     }
   } else {
-    intVal = (toBits.bitsAsUInt() & signMask) + UIntType(1);
+    intVal = (UIntType(toBits) & signMask) + UIntType(1);
   }
 
   return *reinterpret_cast<T *>(&intVal);
   // TODO: Raise floating point exceptions as required by the standard.
 }
 
 } // namespace fputil
 } // namespace __llvm_libc
 
 #if (defined(__x86_64__) || defined(__i386__))
 #include "NextAfterLongDoubleX86.h"
 #endif // defined(__x86_64__) || defined(__i386__)
 
 #endif // LLVM_LIBC_UTILS_FPUTIL_MANIPULATION_FUNCTIONS_H

libc/utils/FPUtil/NearestIntegerOperations.h

static inline T trunc(T x) {
 
   // If the exponent is greater than the most negative mantissa
   // exponent, then x is already an integer.
   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 (bits.sign)
+    if (bits.encoding.sign)
       return T(-0.0);
     else
       return T(0.0);
   }
 
   int trimSize = MantissaWidth<T>::value - exponent;
-  bits.mantissa = (bits.mantissa >> trimSize) << trimSize;
+  bits.encoding.mantissa = (bits.encoding.mantissa >> trimSize) << trimSize;
   return bits;
 }
 
 template <typename T,
           cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
 static inline T ceil(T x) {
   FPBits<T> bits(x);
 
   // If x is infinity NaN or zero, return it.
   if (bits.isInfOrNaN() || bits.isZero())
     return x;
 
-  bool isNeg = bits.sign;
+  bool isNeg = bits.encoding.sign;
   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>(MantissaWidth<T>::value))
     return x;
 
   if (exponent <= -1) {
     if (isNeg)
       return T(-0.0);
     else
       return T(1.0);
   }
 
   uint32_t trimSize = MantissaWidth<T>::value - exponent;
-  bits.mantissa = (bits.mantissa >> trimSize) << trimSize;
+  bits.encoding.mantissa = (bits.encoding.mantissa >> trimSize) << trimSize;
   T truncValue = T(bits);
 
   // If x is already an integer, return it.
   if (truncValue == x)
     return x;
 
   // If x is negative, the ceil operation is equivalent to the trunc operation.
   if (isNeg)
     return truncValue;
 
   return truncValue + T(1.0);
 }
 
 template <typename T,
           cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
 static inline T floor(T x) {
   FPBits<T> bits(x);
-  if (bits.sign) {
+  if (bits.encoding.sign) {
     return -ceil(-x);
   } else {
     return trunc(x);
   }
 }
 
 template <typename T,
           cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
 static inline T round(T x) {
   using UIntType = typename FPBits<T>::UIntType;
   FPBits<T> bits(x);
 
   // If x is infinity NaN or zero, return it.
   if (bits.isInfOrNaN() || bits.isZero())
     return x;
 
-  bool isNeg = bits.sign;
+  bool isNeg = bits.encoding.sign;
   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>(MantissaWidth<T>::value))
     return x;
 
   if (exponent == -1) {
     // Absolute value of x is greater than equal to 0.5 but less than 1.
     if (isNeg)
       return T(-1.0);
     else
       return T(1.0);
   }
 
   if (exponent <= -2) {
     // Absolute value of x is less than 0.5.
     if (isNeg)
       return T(-0.0);
     else
       return T(0.0);
   }
 
   uint32_t trimSize = MantissaWidth<T>::value - exponent;
-  bool halfBitSet = bits.mantissa & (UIntType(1) << (trimSize - 1));
-  bits.mantissa = (bits.mantissa >> trimSize) << trimSize;
+  bool halfBitSet = bits.encoding.mantissa & (UIntType(1) << (trimSize - 1));
+  bits.encoding.mantissa = (bits.encoding.mantissa >> trimSize) << trimSize;
   T truncValue = T(bits);
 
   // If x is already an integer, return it.
   if (truncValue == x)
     return x;
 
   if (!halfBitSet) {
     // Franctional part is less than 0.5 so round value is the

 static inline T roundUsingCurrentRoundingMode(T x) {
   using UIntType = typename FPBits<T>::UIntType;
   FPBits<T> bits(x);
 
   // If x is infinity NaN or zero, return it.
   if (bits.isInfOrNaN() || bits.isZero())
     return x;
 
-  bool isNeg = bits.sign;
+  bool isNeg = bits.encoding.sign;
   int exponent = bits.getExponent();
   int roundingMode = getRound();
 
   // If the exponent is greater than the most negative mantissa
   // exponent, then x is already an integer.
   if (exponent >= static_cast<int>(MantissaWidth<T>::value))
     return x;
 
   if (exponent <= -1) {
     switch (roundingMode) {
     case FE_DOWNWARD:
       return isNeg ? T(-1.0) : T(0.0);
     case FE_UPWARD:
       return isNeg ? T(-0.0) : T(1.0);
     case FE_TOWARDZERO:
       return isNeg ? T(-0.0) : T(0.0);
     case FE_TONEAREST:
-      if (exponent <= -2 || bits.mantissa == 0)
+      if (exponent <= -2 || bits.encoding.mantissa == 0)
         return isNeg ? T(-0.0) : T(0.0); // abs(x) <= 0.5
       else
         return isNeg ? T(-1.0) : T(1.0); // abs(x) > 0.5
     default:
       __builtin_unreachable();
     }
   }
 
   uint32_t trimSize = MantissaWidth<T>::value - exponent;
   FPBits<T> newBits = bits;
-  newBits.mantissa = (bits.mantissa >> trimSize) << trimSize;
+  newBits.encoding.mantissa = (bits.encoding.mantissa >> trimSize) << trimSize;
   T truncValue = T(newBits);
 
   // If x is already an integer, return it.
   if (truncValue == x)
     return x;
 
-  UIntType trimValue = bits.mantissa & ((UIntType(1) << trimSize) - 1);
+  UIntType trimValue = bits.encoding.mantissa & ((UIntType(1) << trimSize) - 1);
   UIntType halfValue = (UIntType(1) << (trimSize - 1));
   // If exponent is 0, trimSize will be equal to the mantissa width, and
   // truncIsOdd` will not be correct. So, we handle it as a special case
   // below.
-  UIntType truncIsOdd = newBits.mantissa & (UIntType(1) << trimSize);
+  UIntType truncIsOdd = newBits.encoding.mantissa & (UIntType(1) << trimSize);
 
   switch (roundingMode) {
   case FE_DOWNWARD:
     return isNeg ? truncValue - T(1.0) : truncValue;
   case FE_UPWARD:
     return isNeg ? truncValue : truncValue + T(1.0);
   case FE_TOWARDZERO:
     return truncValue;

 #endif
 #if math_errhandling & MATH_ERREXCEPT
     raiseExcept(FE_INVALID);
 #endif
   };
 
   if (bits.isInfOrNaN()) {
     setDomainErrorAndRaiseInvalid();
-    return bits.sign ? IntegerMin : IntegerMax;
+    return bits.encoding.sign ? IntegerMin : IntegerMax;
   }
 
   int exponent = bits.getExponent();
   constexpr int exponentLimit = sizeof(I) * 8 - 1;
   if (exponent > exponentLimit) {
     setDomainErrorAndRaiseInvalid();
-    return bits.sign ? IntegerMin : IntegerMax;
+    return bits.encoding.sign ? IntegerMin : IntegerMax;
   } else if (exponent == exponentLimit) {
-    if (bits.sign == 0 || bits.mantissa != 0) {
+    if (bits.encoding.sign == 0 || bits.encoding.mantissa != 0) {
       setDomainErrorAndRaiseInvalid();
-      return bits.sign ? IntegerMin : IntegerMax;
+      return bits.encoding.sign ? IntegerMin : IntegerMax;
     }
     // If the control reaches here, then it means that the rounded
     // value is the most negative number for the signed integer type I.
   }
 
   // For all other cases, if `x` can fit in the integer type `I`,
   // we just return `x`. Implicit conversion will convert the
   // floating point value to the exact integer value.

libc/utils/FPUtil/NextAfterLongDoubleX86.h

static inline long double nextafter(long double from, long double to) {
   FPBits toBits(to);
   if (toBits.isNaN())
     return to;
 
   if (from == to)
     return to;
 
   // Convert pseudo subnormal number to normal number.
-  if (fromBits.implicitBit == 1 && fromBits.exponent == 0) {
-    fromBits.exponent = 1;
+  if (fromBits.encoding.implicitBit == 1 && fromBits.encoding.exponent == 0) {
+    fromBits.encoding.exponent = 1;
   }
 
   using UIntType = FPBits::UIntType;
   constexpr UIntType signVal = (UIntType(1) << 79);
   constexpr UIntType mantissaMask =
       (UIntType(1) << MantissaWidth<long double>::value) - 1;
-  auto intVal = fromBits.bitsAsUInt();
+  UIntType intVal = fromBits.uintval();
   if (from < 0.0l) {
     if (from > to) {
       if (intVal == (signVal + FPBits::maxSubnormal)) {
         // We deal with normal/subnormal boundary separately to avoid
         // dealing with the implicit bit.
         intVal = signVal + FPBits::minNormal;
       } else if ((intVal & mantissaMask) == mantissaMask) {
-        fromBits.mantissa = 0;
+        fromBits.encoding.mantissa = 0;
         // Incrementing exponent might overflow the value to infinity,
         // which is what is expected. Since NaNs are handling separately,
         // it will never overflow "beyond" infinity.
-        ++fromBits.exponent;
+        ++fromBits.encoding.exponent;
         return fromBits;
       } else {
         ++intVal;
       }
     } else {
       if (intVal == (signVal + FPBits::minNormal)) {
         // We deal with normal/subnormal boundary separately to avoid
         // dealing with the implicit bit.
         intVal = signVal + FPBits::maxSubnormal;
       } else if ((intVal & mantissaMask) == 0) {
-        fromBits.mantissa = mantissaMask;
+        fromBits.encoding.mantissa = mantissaMask;
         // from == 0 is handled separately so decrementing the exponent will not
         // lead to underflow.
-        --fromBits.exponent;
+        --fromBits.encoding.exponent;
         return fromBits;
       } else {
         --intVal;
       }
     }
   } else if (from == 0.0l) {
     if (from > to)
       intVal = signVal + 1;
     else
       intVal = 1;
   } else {
     if (from > to) {
       if (intVal == FPBits::minNormal) {
         intVal = FPBits::maxSubnormal;
       } else if ((intVal & mantissaMask) == 0) {
-        fromBits.mantissa = mantissaMask;
+        fromBits.encoding.mantissa = mantissaMask;
         // from == 0 is handled separately so decrementing the exponent will not
         // lead to underflow.
-        --fromBits.exponent;
+        --fromBits.encoding.exponent;
         return fromBits;
       } else {
         --intVal;
       }
     } else {
       if (intVal == FPBits::maxSubnormal) {
         intVal = FPBits::minNormal;
       } else if ((intVal & mantissaMask) == mantissaMask) {
-        fromBits.mantissa = 0;
+        fromBits.encoding.mantissa = 0;
         // Incrementing exponent might overflow the value to infinity,
         // which is what is expected. Since NaNs are handling separately,
         // it will never overflow "beyond" infinity.
-        ++fromBits.exponent;
+        ++fromBits.encoding.exponent;
         return fromBits;
       } else {
         ++intVal;
       }
     }
   }
 
   return *reinterpret_cast<long double *>(&intVal);
   // TODO: Raise floating point exceptions as required by the standard.
 }
 
 } // namespace fputil
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_UTILS_FPUTIL_NEXT_AFTER_LONG_DOUBLE_X86_H

libc/utils/FPUtil/NormalFloat.h

operator T() const {
     int biasedExponent = exponent + FPBits<T>::exponentBias;
     // Max exponent is of the form 0xFF...E. That is why -2 and not -1.
     constexpr int maxExponentValue = (1 << ExponentWidth<T>::value) - 2;
     if (biasedExponent > maxExponentValue) {
       return sign ? FPBits<T>::negInf() : FPBits<T>::inf();
     }
 
     FPBits<T> result(T(0.0));
-    result.sign = sign;
+    result.encoding.sign = sign;
 
     constexpr int subnormalExponent = -FPBits<T>::exponentBias + 1;
     if (exponent < subnormalExponent) {
       unsigned shift = subnormalExponent - exponent;
       // Since exponent > subnormalExponent, shift is strictly greater than
       // zero.
       if (shift <= MantissaWidth<T>::value + 1) {
         // Generate a subnormal number. Might lead to loss of precision.
         // We round to nearest and round halfway cases to even.
         const UIntType shiftOutMask = (UIntType(1) << shift) - 1;
         const UIntType shiftOutValue = mantissa & shiftOutMask;
         const UIntType halfwayValue = UIntType(1) << (shift - 1);
-        result.exponent = 0;
-        result.mantissa = mantissa >> shift;
-        UIntType newMantissa = result.mantissa;
+        result.encoding.exponent = 0;
+        result.encoding.mantissa = mantissa >> shift;
+        UIntType newMantissa = result.encoding.mantissa;
         if (shiftOutValue > halfwayValue) {
           newMantissa += 1;
         } else if (shiftOutValue == halfwayValue) {
           // Round to even.
-          if (result.mantissa & 0x1)
+          if (result.encoding.mantissa & 0x1)
             newMantissa += 1;
         }
-        result.mantissa = newMantissa;
+        result.encoding.mantissa = newMantissa;
         // Adding 1 to mantissa can lead to overflow. This can only happen if
         // mantissa was all ones (0b111..11). For such a case, we will carry
         // the overflow into the exponent.
         if (newMantissa == one)
-          result.exponent = 1;
+          result.encoding.exponent = 1;
         return result;
       } else {
         return result;
       }
     }
 
-    result.exponent = exponent + FPBits<T>::exponentBias;
-    result.mantissa = mantissa;
+    result.encoding.exponent = exponent + FPBits<T>::exponentBias;
+    result.encoding.mantissa = mantissa;
     return result;
   }
 
 private:
   void initFromBits(FPBits<T> bits) {
-    sign = bits.sign;
+    sign = bits.encoding.sign;
 
     if (bits.isInfOrNaN() || bits.isZero()) {
       // Ignore special bit patterns. Implementations deal with them separately
       // anyway so this should not be a problem.
       exponent = 0;
       mantissa = 0;
       return;
     }
 
     // Normalize subnormal numbers.
-    if (bits.exponent == 0) {
-      unsigned shift = evaluateNormalizationShift(bits.mantissa);
-      mantissa = UIntType(bits.mantissa) << shift;
+    if (bits.encoding.exponent == 0) {
+      unsigned shift = evaluateNormalizationShift(bits.encoding.mantissa);
+      mantissa = UIntType(bits.encoding.mantissa) << shift;
       exponent = 1 - FPBits<T>::exponentBias - shift;
     } else {
-      exponent = bits.exponent - FPBits<T>::exponentBias;
-      mantissa = one | bits.mantissa;
+      exponent = bits.encoding.exponent - FPBits<T>::exponentBias;
+      mantissa = one | bits.encoding.mantissa;
     }
   }
 
   unsigned evaluateNormalizationShift(UIntType m) {
     unsigned shift = 0;
     for (; (one & m) == 0 && (shift < MantissaWidth<T>::value);
          m <<= 1, ++shift)
       ;
     return shift;
   }
 };
 
 #if defined(__x86_64__) || defined(__i386__)
 template <>
 inline void NormalFloat<long double>::initFromBits(FPBits<long double> bits) {
-  sign = bits.sign;
+  sign = bits.encoding.sign;
 
   if (bits.isInfOrNaN() || bits.isZero()) {
     // Ignore special bit patterns. Implementations deal with them separately
     // anyway so this should not be a problem.
     exponent = 0;
     mantissa = 0;
     return;
   }
 
-  if (bits.exponent == 0) {
-    if (bits.implicitBit == 0) {
+  if (bits.encoding.exponent == 0) {
+    if (bits.encoding.implicitBit == 0) {
       // Since we ignore zero value, the mantissa in this case is non-zero.
-      int normalizationShift = evaluateNormalizationShift(bits.mantissa);
+      int normalizationShift =
+          evaluateNormalizationShift(bits.encoding.mantissa);
       exponent = -16382 - normalizationShift;
-      mantissa = (bits.mantissa << normalizationShift);
+      mantissa = (bits.encoding.mantissa << normalizationShift);
     } else {
       exponent = -16382;
-      mantissa = one | bits.mantissa;
+      mantissa = one | bits.encoding.mantissa;
     }
   } else {
-    if (bits.implicitBit == 0) {
+    if (bits.encoding.implicitBit == 0) {
       // Invalid number so just store 0 similar to a NaN.
       exponent = 0;
       mantissa = 0;
     } else {
-      exponent = bits.exponent - 16383;
-      mantissa = one | bits.mantissa;
+      exponent = bits.encoding.exponent - 16383;
+      mantissa = one | bits.encoding.mantissa;
     }
   }
 }
 
 template <> inline NormalFloat<long double>::operator long double() const {
   int biasedExponent = exponent + FPBits<long double>::exponentBias;
   // Max exponent is of the form 0xFF...E. That is why -2 and not -1.
   constexpr int maxExponentValue = (1 << ExponentWidth<long double>::value) - 2;
   if (biasedExponent > maxExponentValue) {
     return sign ? FPBits<long double>::negInf() : FPBits<long double>::inf();
   }
 
   FPBits<long double> result(0.0l);
-  result.sign = sign;
+  result.encoding.sign = sign;
 
   constexpr int subnormalExponent = -FPBits<long double>::exponentBias + 1;
   if (exponent < subnormalExponent) {
     unsigned shift = subnormalExponent - exponent;
     if (shift <= MantissaWidth<long double>::value + 1) {
       // Generate a subnormal number. Might lead to loss of precision.
       // We round to nearest and round halfway cases to even.
       const UIntType shiftOutMask = (UIntType(1) << shift) - 1;
       const UIntType shiftOutValue = mantissa & shiftOutMask;
       const UIntType halfwayValue = UIntType(1) << (shift - 1);
-      result.exponent = 0;
-      result.mantissa = mantissa >> shift;
-      UIntType newMantissa = result.mantissa;
+      result.encoding.exponent = 0;
+      result.encoding.mantissa = mantissa >> shift;
+      UIntType newMantissa = result.encoding.mantissa;
       if (shiftOutValue > halfwayValue) {
         newMantissa += 1;
       } else if (shiftOutValue == halfwayValue) {
         // Round to even.
-        if (result.mantissa & 0x1)
+        if (result.encoding.mantissa & 0x1)
           newMantissa += 1;
       }
-      result.mantissa = newMantissa;
+      result.encoding.mantissa = newMantissa;
       // Adding 1 to mantissa can lead to overflow. This can only happen if
       // mantissa was all ones (0b111..11). For such a case, we will carry
       // the overflow into the exponent and set the implicit bit to 1.
       if (newMantissa == one) {
-        result.exponent = 1;
-        result.implicitBit = 1;
+        result.encoding.exponent = 1;
+        result.encoding.implicitBit = 1;
       } else {
-        result.implicitBit = 0;
+        result.encoding.implicitBit = 0;
       }
       return result;
     } else {
       return result;
     }
   }
 
-  result.exponent = biasedExponent;
-  result.mantissa = mantissa;
-  result.implicitBit = 1;
+  result.encoding.exponent = biasedExponent;
+  result.encoding.mantissa = mantissa;
+  result.encoding.implicitBit = 1;
   return result;
 }
 #endif
 
 } // namespace fputil
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_UTILS_FPUTIL_NORMAL_FLOAT_H

libc/utils/FPUtil/Sqrt.h

template <typename T,
           cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
 static inline T sqrt(T x) {
   using UIntType = typename FPBits<T>::UIntType;
   constexpr UIntType One = UIntType(1) << MantissaWidth<T>::value;
 
   FPBits<T> bits(x);
 
   if (bits.isInfOrNaN()) {
-    if (bits.sign && (bits.mantissa == 0)) {
+    if (bits.encoding.sign && (bits.encoding.mantissa == 0)) {
       // sqrt(-Inf) = NaN
       return FPBits<T>::buildNaN(One >> 1);
     } else {
       // sqrt(NaN) = NaN
       // sqrt(+Inf) = +Inf
       return x;
     }
   } else if (bits.isZero()) {
     // sqrt(+0) = +0
     // sqrt(-0) = -0
     return x;
-  } else if (bits.sign) {
+  } else if (bits.encoding.sign) {
     // sqrt( negative numbers ) = NaN
     return FPBits<T>::buildNaN(One >> 1);
   } else {
     int xExp = bits.getExponent();
-    UIntType xMant = bits.mantissa;
+    UIntType xMant = bits.encoding.mantissa;
 
     // Step 1a: Normalize denormal input and append hiddent bit to the mantissa
-    if (bits.exponent == 0) {
+    if (bits.encoding.exponent == 0) {
       ++xExp; // let xExp be the correct exponent of One bit.
       internal::normalize<T>(xExp, xMant);
     } else {
       xMant |= One;
     }
 
     // Step 1b: Make sure the exponent is even.
     if (xExp & 1) {

libc/utils/FPUtil/SqrtLongDoubleX86.h

 template <> inline long double sqrt<long double, 0>(long double x) {
   using UIntType = typename FPBits<long double>::UIntType;
   constexpr UIntType One = UIntType(1)
                            << int(MantissaWidth<long double>::value);
 
   FPBits<long double> bits(x);
 
   if (bits.isInfOrNaN()) {
-    if (bits.sign && (bits.mantissa == 0)) {
+    if (bits.encoding.sign && (bits.encoding.mantissa == 0)) {
       // sqrt(-Inf) = NaN
       return FPBits<long double>::buildNaN(One >> 1);
     } else {
       // sqrt(NaN) = NaN
       // sqrt(+Inf) = +Inf
       return x;
     }
   } else if (bits.isZero()) {
     // sqrt(+0) = +0
     // sqrt(-0) = -0
     return x;
-  } else if (bits.sign) {
+  } else if (bits.encoding.sign) {
     // sqrt( negative numbers ) = NaN
     return FPBits<long double>::buildNaN(One >> 1);
   } else {
     int xExp = bits.getExponent();
-    UIntType xMant = bits.mantissa;
+    UIntType xMant = bits.encoding.mantissa;
 
     // Step 1a: Normalize denormal input
-    if (bits.implicitBit) {
+    if (bits.encoding.implicitBit) {
       xMant |= One;
-    } else if (bits.exponent == 0) {
+    } else if (bits.encoding.exponent == 0) {
       internal::normalize<long double>(xExp, xMant);
     }
 
     // Step 1b: Make sure the exponent is even.
     if (xExp & 1) {
       --xExp;
       xMant <<= 1;
     }
if (bits.isInfOrNaN()) {
 
     // Round to nearest, ties to even
     if (rb && (lsb || (r != 0))) {
       ++y;
     }
 
     // Extract output
     FPBits<long double> out(0.0L);
-    out.exponent = xExp;
-    out.implicitBit = 1;
-    out.mantissa = (y & (One - 1));
+    out.encoding.exponent = xExp;
+    out.encoding.implicitBit = 1;
+    out.encoding.mantissa = (y & (One - 1));
 
     return out;
   }
 }
 #endif // defined(__x86_64__) || defined(__i386__)
 
 } // namespace fputil
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_UTILS_FPUTIL_SQRT_LONG_DOUBLE_X86_H

libc/utils/FPUtil/TestHelpers.h

 public:
   FPMatcher(T expectedValue) : expected(expectedValue) {}
 
   bool match(T actualValue) {
     actual = actualValue;
     fputil::FPBits<T> actualBits(actual), expectedBits(expected);
     if (Condition == __llvm_libc::testing::Cond_EQ)
       return (actualBits.isNaN() && expectedBits.isNaN()) ||
-             (actualBits.bitsAsUInt() == expectedBits.bitsAsUInt());
+             (actualBits.uintval() == expectedBits.uintval());
 
     // If condition == Cond_NE.
     if (actualBits.isNaN())
       return !expectedBits.isNaN();
     return expectedBits.isNaN() ||
-           (actualBits.bitsAsUInt() != expectedBits.bitsAsUInt());
+           (actualBits.uintval() != expectedBits.uintval());
   }
 
   void explainError(testutils::StreamWrapper &stream) override {
     describeValue("Expected floating point value: ", expected, stream);
     describeValue("  Actual floating point value: ", actual, stream);
   }
 };
 

libc/utils/FPUtil/TestHelpers.cpp

 describeValue(const char *label, ValType value,
               testutils::StreamWrapper &stream) {
   stream << label;
 
   FPBits<ValType> bits(value);
   if (bits.isNaN()) {
     stream << "(NaN)";
   } else if (bits.isInf()) {
-    if (bits.sign)
+    if (bits.encoding.sign)
       stream << "(-Infinity)";
     else
       stream << "(+Infinity)";
   } else {
     constexpr int exponentWidthInHex =
         (fputil::ExponentWidth<ValType>::value - 1) / 4 + 1;
     constexpr int mantissaWidthInHex =
         (fputil::MantissaWidth<ValType>::value - 1) / 4 + 1;
 
-    stream << "Sign: " << (bits.sign ? '1' : '0') << ", "
+    stream << "Sign: " << (bits.encoding.sign ? '1' : '0') << ", "
            << "Exponent: 0x"
-           << uintToHex<uint16_t>(bits.exponent, exponentWidthInHex) << ", "
+           << uintToHex<uint16_t>(bits.encoding.exponent, exponentWidthInHex)
+           << ", "
            << "Mantissa: 0x"
            << uintToHex<typename fputil::FPBits<ValType>::UIntType>(
-                  bits.mantissa, mantissaWidthInHex);
+                  bits.encoding.mantissa, mantissaWidthInHex);
   }
 
   stream << '\n';
 }
 
 template void describeValue<float>(const char *, float,
                                    testutils::StreamWrapper &);
 template void describeValue<double>(const char *, double,
                                     testutils::StreamWrapper &);
 template void describeValue<long double>(const char *, long double,
                                          testutils::StreamWrapper &);
 
 } // namespace testing
 } // namespace fputil
 } // namespace __llvm_libc

libc/utils/MPFRWrapper/MPFRUtils.cpp

cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, double> ulp(T input) {
     fputil::FPBits<T> bits(input);
     MPFRNumber mpfrInput(input);
 
     // abs(value - input)
     mpfr_sub(mpfrInput.value, value, mpfrInput.value, MPFR_RNDN);
     mpfr_abs(mpfrInput.value, mpfrInput.value, MPFR_RNDN);
 
     // get eps(input)
-    int epsExponent = bits.exponent - fputil::FPBits<T>::exponentBias -
+    int epsExponent = bits.encoding.exponent - fputil::FPBits<T>::exponentBias -
                       fputil::MantissaWidth<T>::value;
-    if (bits.exponent == 0) {
+    if (bits.encoding.exponent == 0) {
       // correcting denormal exponent
       ++epsExponent;
-    } else if ((bits.mantissa == 0) && (bits.exponent > 1) &&
+    } else if ((bits.encoding.mantissa == 0) && (bits.encoding.exponent > 1) &&
                mpfr_less_p(value, mpfrInput.value)) {
       // when the input is exactly 2^n, distance (epsilon) between the input
       // and the next floating point number is different from the distance to
       // the previous floating point number.  So in that case, if the correct
       // value from MPFR is smaller than the input, we use the smaller epsilon
       --epsExponent;
     }
 

 
 template <typename T>
 bool compareUnaryOperationSingleOutput(Operation op, T input, T libcResult,
                                        double ulpError) {
   // If the ulp error is exactly 0.5 (i.e a tie), we would check that the result
   // is rounded to the nearest even.
   MPFRNumber mpfrResult = unaryOperation(op, input);
   double ulp = mpfrResult.ulp(libcResult);
-  bool bitsAreEven = ((FPBits<T>(libcResult).bitsAsUInt() & 1) == 0);
+  bool bitsAreEven = ((FPBits<T>(libcResult).uintval() & 1) == 0);
   return (ulp < ulpError) ||
          ((ulp == ulpError) && ((ulp != 0.5) || bitsAreEven));
 }
 
 template bool compareUnaryOperationSingleOutput<float>(Operation, float, float,
                                                        double);
 template bool compareUnaryOperationSingleOutput<double>(Operation, double,
                                                         double, double);
 template bool compareUnaryOperationSingleOutput<long double>(Operation,
                                                              long double,
                                                              long double,
                                                              double);
 
 template <typename T>
 bool compareUnaryOperationTwoOutputs(Operation op, T input,
                                      const BinaryOutput<T> &libcResult,
                                      double ulpError) {
   int mpfrIntResult;
   MPFRNumber mpfrResult = unaryOperationTwoOutputs(op, input, mpfrIntResult);
   double ulp = mpfrResult.ulp(libcResult.f);
 
   if (mpfrIntResult != libcResult.i)
     return false;
 
-  bool bitsAreEven = ((FPBits<T>(libcResult.f).bitsAsUInt() & 1) == 0);
+  bool bitsAreEven = ((FPBits<T>(libcResult.f).uintval() & 1) == 0);
   return (ulp < ulpError) ||
          ((ulp == ulpError) && ((ulp != 0.5) || bitsAreEven));
 }
 
 template bool
 compareUnaryOperationTwoOutputs<float>(Operation, float,
                                        const BinaryOutput<float> &, double);
 template bool
if (mpfrIntResult != libcResult.i) {
     if (op == Operation::RemQuo) {
       if ((0x7 & mpfrIntResult) != (0x7 & libcResult.i))
         return false;
     } else {
       return false;
     }
   }
 
-  bool bitsAreEven = ((FPBits<T>(libcResult.f).bitsAsUInt() & 1) == 0);
+  bool bitsAreEven = ((FPBits<T>(libcResult.f).uintval() & 1) == 0);
   return (ulp < ulpError) ||
          ((ulp == ulpError) && ((ulp != 0.5) || bitsAreEven));
 }
 
 template bool
 compareBinaryOperationTwoOutputs<float>(Operation, const BinaryInput<float> &,
                                         const BinaryOutput<float> &, double);
 template bool
 compareBinaryOperationTwoOutputs<double>(Operation, const BinaryInput<double> &,
                                          const BinaryOutput<double> &, double);
 template bool compareBinaryOperationTwoOutputs<long double>(
     Operation, const BinaryInput<long double> &,
     const BinaryOutput<long double> &, double);
 
 template <typename T>
 bool compareBinaryOperationOneOutput(Operation op, const BinaryInput<T> &input,
                                      T libcResult, double ulpError) {
   MPFRNumber mpfrResult = binaryOperationOneOutput(op, input.x, input.y);
   double ulp = mpfrResult.ulp(libcResult);
 
-  bool bitsAreEven = ((FPBits<T>(libcResult).bitsAsUInt() & 1) == 0);
+  bool bitsAreEven = ((FPBits<T>(libcResult).uintval() & 1) == 0);
   return (ulp < ulpError) ||
          ((ulp == ulpError) && ((ulp != 0.5) || bitsAreEven));
 }
 
 template bool compareBinaryOperationOneOutput<float>(Operation,
                                                      const BinaryInput<float> &,
                                                      float, double);
 template bool
 compareBinaryOperationOneOutput<double>(Operation, const BinaryInput<double> &,
                                         double, double);
 template bool compareBinaryOperationOneOutput<long double>(
     Operation, const BinaryInput<long double> &, long double, double);
 
 template <typename T>
 bool compareTernaryOperationOneOutput(Operation op,
                                       const TernaryInput<T> &input,
                                       T libcResult, double ulpError) {
   MPFRNumber mpfrResult =
       ternaryOperationOneOutput(op, input.x, input.y, input.z);
   double ulp = mpfrResult.ulp(libcResult);
 
-  bool bitsAreEven = ((FPBits<T>(libcResult).bitsAsUInt() & 1) == 0);
+  bool bitsAreEven = ((FPBits<T>(libcResult).uintval() & 1) == 0);
   return (ulp < ulpError) ||
          ((ulp == ulpError) && ((ulp != 0.5) || bitsAreEven));
 }
 
 template bool
 compareTernaryOperationOneOutput<float>(Operation, const TernaryInput<float> &,
                                         float, double);
 template bool compareTernaryOperationOneOutput<double>(