[libc] Modify the struct that captures floating point encoding to have setters and getters

[hedingarcia]

Summary

Redefined FPBits.h and LongDoubleBitsX86 to have structs that adjust the value of the bit
representation of a float by using setters and getters functions and use values such as
bit masks from FloatProperties.h. Subsequent files that made reference to the instance
of the struct, by targeting its specific variables(like mantissa, exponent, and sign),
were fixed to call these functions to modify its value indirectly. This implementation was
done to make sure the struct works for Windows and Linux platform maintaining pack memory
alignment of the struct so its size in memory is the same as the data type of the float point number.

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.encoding.exponent, uint16_t(0));
+    ASSERT_EQ(resultBits.encoding.getExponent(), 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.encoding.exponent,
-              uint16_t(xBits.encoding.exponent - 1));
-    ASSERT_EQ(resultBits.encoding.mantissa,
+    ASSERT_EQ(resultBits.encoding.getExponent(),
+              uint16_t(xBits.encoding.getExponent() - 1));
+    ASSERT_EQ(resultBits.encoding.getMantissa(),
               (UIntType(1) << MantissaWidth::value) - 1);
 
     result = func(x, T(33.0));
     resultBits = FPBits(result);
-    ASSERT_EQ(resultBits.encoding.exponent, xBits.encoding.exponent);
-    ASSERT_EQ(resultBits.encoding.mantissa,
-              xBits.encoding.mantissa + UIntType(1));
+    ASSERT_EQ(resultBits.encoding.getExponent(), xBits.encoding.getExponent());
+    ASSERT_EQ(resultBits.encoding.getMantissa(),
+              xBits.encoding.getMantissa() + UIntType(1));
 
     x = -x;
 
     result = func(x, 0);
     resultBits = FPBits(result);
-    ASSERT_EQ(resultBits.encoding.exponent,
-              uint16_t(xBits.encoding.exponent - 1));
-    ASSERT_EQ(resultBits.encoding.mantissa,
+    ASSERT_EQ(resultBits.encoding.getExponent(),
+              uint16_t(xBits.encoding.getExponent() - 1));
+    ASSERT_EQ(resultBits.encoding.getMantissa(),
               (UIntType(1) << MantissaWidth::value) - 1);
 
     result = func(x, T(-33.0));
     resultBits = FPBits(result);
-    ASSERT_EQ(resultBits.encoding.exponent, xBits.encoding.exponent);
-    ASSERT_EQ(resultBits.encoding.mantissa,
-              xBits.encoding.mantissa + UIntType(1));
+    ASSERT_EQ(resultBits.encoding.getExponent(), xBits.encoding.getExponent());
+    ASSERT_EQ(resultBits.encoding.getMantissa(),
+              xBits.encoding.getMantissa() + 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.encoding.exponent = exponentLimit + FPBits::exponentBias;
-    bits.encoding.sign = 1;
-    bits.encoding.mantissa = 0;
+    bits.encoding.setExponent(exponentLimit + FPBits::exponentBias);
+    bits.encoding.setSign(1);
+    bits.encoding.setMantissa(0);
 
     F x = F(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.encoding.exponent = exponentLimit + FPBits::exponentBias;
-    bits.encoding.sign = 1;
-    bits.encoding.mantissa =
-        UIntType(0x1) << (__llvm_libc::fputil::MantissaWidth<F>::value - 1);
+    bits.encoding.setExponent(exponentLimit + FPBits::exponentBias);
+    bits.encoding.setSign(1);
+    bits.encoding.setMantissa(UIntType(0x1) << (__llvm_libc::fputil::MantissaWidth<F>::value - 1));
 
     F x = F(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/SqrtTest.h

void testSpecialNumbers(SqrtFunc func) {
     ASSERT_FP_EQ(T(1.0), func(T(1.0)));
     ASSERT_FP_EQ(T(2.0), func(T(4.0)));
     ASSERT_FP_EQ(T(3.0), func(T(9.0)));
   }
 
   void testDenormalValues(SqrtFunc func) {
     for (UIntType mant = 1; mant < HiddenBit; mant <<= 1) {
       FPBits denormal(T(0.0));
-      denormal.encoding.mantissa = mant;
+      denormal.encoding.setMantissa(mant);
 
       ASSERT_MPFR_MATCH(mpfr::Operation::Sqrt, T(denormal), func(T(denormal)),
                         T(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.encoding.sign = 0;
+  bits.encoding.setSign(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.encoding.sign != bity.encoding.sign) {
+  } else if (bitx.encoding.getSign() != bity.encoding.getSign()) {
     // 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.encoding.sign ? x : y);
+    return (bitx.encoding.getSign() ? 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.encoding.sign != bity.encoding.sign) {
+  } else if (bitx.encoding.getSign() != bity.encoding.getSign()) {
     // 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.encoding.sign ? y : x);
+    return (bitx.encoding.getSign() ? 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.encoding.sign == ybits.encoding.sign ? false : true);
+  bool resultSign =
+      (xbits.encoding.getSign() == ybits.encoding.getSign() ? 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.encoding.sign = ybits.encoding.sign = 0;
+  xbits.encoding.setSign(0);
+  ybits.encoding.setSign(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

 //===-- 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 "PlatformDefs.h"
 
 #include "utils/CPP/TypeTraits.h"
 
+#include "FloatProperties.h"
+#include <assert.h>
 #include <stdint.h>
 
 namespace __llvm_libc {
 namespace fputil {
 
 template <typename T> struct MantissaWidth {};
 template <> struct MantissaWidth<float> {
-  static constexpr unsigned value = 23;
+  static constexpr unsigned value = FloatProperties<float>::mantissaWidth;
 };
 template <> struct MantissaWidth<double> {
-  static constexpr unsigned value = 52;
+  static constexpr unsigned value = FloatProperties<double>::mantissaWidth;
 };
 
 template <typename T> struct ExponentWidth {};
 template <> struct ExponentWidth<float> {
-  static constexpr unsigned value = 8;
+  static constexpr unsigned value = FloatProperties<float>::exponentWidth;
 };
 template <> struct ExponentWidth<double> {
-  static constexpr unsigned value = 11;
+  static constexpr unsigned value = FloatProperties<double>::exponentWidth;
 };
 template <> struct ExponentWidth<long double> {
-  static constexpr unsigned value = 15;
+  static constexpr unsigned value = FloatProperties<long double>::exponentWidth;
 };
 
 template <typename T> struct FPUIntType {};
 template <> struct FPUIntType<float> { using Type = uint32_t; };
 template <> struct FPUIntType<double> { using Type = uint64_t; };
 
 #ifdef LONG_DOUBLE_IS_DOUBLE
 template <> struct MantissaWidth<long double> {
   static constexpr unsigned value = MantissaWidth<double>::value;
 };
 template <> struct FPUIntType<long double> {
   using Type = FPUIntType<double>::Type;
 };
-#elif !defined(SPECIAL_X86_LONG_DOUBLE)
+#elif defined(SPECIAL_X86_LONG_DOUBLE)
 template <> struct MantissaWidth<long double> {
-  static constexpr unsigned value = 112;
+  static constexpr unsigned value = FloatProperties<long double>::mantissaWidth;
+};
+template <> struct FPUIntType<long double> { using Type = __uint128_t; };
+#else
+template <> struct MantissaWidth<long double> {
+  static constexpr unsigned value = FloatProperties<long double>::mantissaWidth;
 };
 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> 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;
+  struct {
+    using FloatProp = typename __llvm_libc::fputil::FloatProperties<T>;
+
+  private:
+    UIntType valueFP;
+
+  public:
+    UIntType getValue() { return valueFP; }
+    void setValue(UIntType valueFP) { this->valueFP = valueFP; }
+
+    // Clean and check the value given with its mask so it does not lead to
+    // overflow. Then invert the bit mask to clear the old value.
+    void setMantissa(UIntType mantVal) {
+      mantVal &= (FloatProp::mantissaMask);
+      assert((mantVal & ~(FloatProp::mantissaMask)) == 0);
+      valueFP &= ~(FloatProp::mantissaMask);
+      valueFP |= mantVal;
+    }
+
+    UIntType getMantissa() const { return valueFP & FloatProp::mantissaMask; }
+
+    // Clean and check the value given with its mask so it does not lead to
+    // overflow. Use the number of bitwidth for the Exponent's position.
+    void setExponent(UIntType expVal) {
+      expVal =
+          (expVal << (FloatProp::bitWidth - 1 - FloatProp::exponentWidth)) &
+          FloatProp::exponentMask;
+      assert((expVal & ~(FloatProp::exponentMask)) == 0);
+      valueFP &= ~(FloatProp::exponentMask);
+      valueFP |= expVal;
+    }
+
+    // Move to the end of the bit sequence.
+    uint16_t getExponent() const {
+      return uint16_t((valueFP & FloatProp::exponentMask) >>
+                      (FloatProp::bitWidth - 1 - FloatProp::exponentWidth));
+    }
+
+    // Will be assigned to the highest order bit.
+    void setSign(bool signVal) {
+      valueFP &= ~(FloatProp::signMask);
+      UIntType sign = UIntType(signVal) << (FloatProp::bitWidth - 1);
+      valueFP |= sign;
+    }
+
+    // Move to the end of the bit sequence so a single value is returned.
+    bool getSign() const {
+      return uint8_t((valueFP & FloatProp::signMask) >>
+                     (FloatProp::bitWidth - 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.");
template <typename T> union FPBits {
   explicit FPBits(XType x) : integer(x) {}
 
   FPBits() : integer(0) {}
 
   explicit operator T() { return val; }
 
   UIntType uintval() const { return integer; }
 
-  int getExponent() const { return int(encoding.exponent) - exponentBias; }
+  int getExponent() const { return int(encoding.getExponent()) - exponentBias; }
 
   bool isZero() const {
-    return encoding.mantissa == 0 && encoding.exponent == 0;
+    return encoding.getMantissa() == 0 && encoding.getExponent() == 0;
   }
 
   bool isInf() const {
-    return encoding.mantissa == 0 && encoding.exponent == maxExponent;
+    return encoding.getMantissa() == 0 && encoding.getExponent() == maxExponent;
   }
 
   bool isNaN() const {
-    return encoding.exponent == maxExponent && encoding.mantissa != 0;
+    return encoding.getExponent() == maxExponent && encoding.getMantissa() != 0;
   }
 
-  bool isInfOrNaN() const { return encoding.exponent == maxExponent; }
+  bool isInfOrNaN() const { return encoding.getExponent() == maxExponent; }
 
   static FPBits<T> zero() { return FPBits(); }
 
   static FPBits<T> negZero() {
     return FPBits(UIntType(1) << (sizeof(UIntType) * 8 - 1));
   }
 
   static FPBits<T> inf() {
     FPBits<T> bits;
-    bits.encoding.exponent = maxExponent;
+    bits.encoding.setExponent(maxExponent);
     return bits;
   }
 
   static FPBits<T> negInf() {
     FPBits<T> bits = inf();
-    bits.encoding.sign = 1;
+    bits.encoding.setSign(1);
     return bits;
   }
 
   static T buildNaN(UIntType v) {
     FPBits<T> bits = inf();
-    bits.encoding.mantissa = v;
+    bits.encoding.setMantissa(v);
     return T(bits);
   }
 };
 
 } // namespace fputil
 } // namespace __llvm_libc
 
 #ifdef SPECIAL_X86_LONG_DOUBLE
 #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.encoding.exponent >=
-       y_bits.encoding.exponent + MantissaWidth<T>::value + 2) ||
+  if ((x_bits.encoding.getExponent() >=
+       y_bits.encoding.getExponent() + MantissaWidth<T>::value + 2) ||
       (y == 0)) {
     return abs(x);
-  } else if ((y_bits.encoding.exponent >=
-              x_bits.encoding.exponent + MantissaWidth<T>::value + 2) ||
+  } else if ((y_bits.encoding.getExponent() >=
+              x_bits.encoding.getExponent() + MantissaWidth<T>::value + 2) ||
              (x == 0)) {
-    y_bits.encoding.sign = 0;
+    y_bits.encoding.setSign(0);
     return abs(y);
   }
 
   if (x >= y) {
-    a_exp = x_bits.encoding.exponent;
-    a_mant = x_bits.encoding.mantissa;
-    b_exp = y_bits.encoding.exponent;
-    b_mant = y_bits.encoding.mantissa;
+    a_exp = x_bits.encoding.getExponent();
+    a_mant = x_bits.encoding.getMantissa();
+    b_exp = y_bits.encoding.getExponent();
+    b_mant = y_bits.encoding.getMantissa();
   } else {
-    a_exp = y_bits.encoding.exponent;
-    a_mant = y_bits.encoding.mantissa;
-    b_exp = x_bits.encoding.exponent;
-    b_mant = x_bits.encoding.mantissa;
+    a_exp = y_bits.encoding.getExponent();
+    a_mant = y_bits.encoding.getMantissa();
+    b_exp = x_bits.encoding.getExponent();
+    b_mant = x_bits.encoding.getMantissa();
   }
 
   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

 
 #include "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 <> 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;
+  struct {
+    using FloatProp =
+        typename __llvm_libc::fputil::FloatProperties<long double>;
+
+  private:
+    UIntType valueFP;
+
+  public:
+    UIntType getValue() { return valueFP; }
+    void setValue(UIntType valueFP) { this->valueFP = valueFP; }
+
+    // Clean and check the value given with its mask so it does not lead to
+    // overflow. Then invert the bit mask to clear the old value.
+    void setMantissa(UIntType mantVal) {
+      mantVal &= (FloatProp::mantissaMask);
+      assert((mantVal & ~(FloatProp::mantissaMask)) == 0);
+      valueFP &= ~(FloatProp::mantissaMask);
+      valueFP |= mantVal;
+    }
+
+    UIntType getMantissa() const { return valueFP & FloatProp::mantissaMask; }
+
+    // Clean and check the value given with its mask so it does not lead to
+    // overflow. Use the number of bitwidth for the Exponent's position.
+    void setExponent(UIntType expVal) {
+      expVal =
+          (expVal << (FloatProp::bitWidth - 1 - FloatProp::exponentWidth)) &
+          FloatProp::exponentMask;
+      assert((expVal & ~(FloatProp::exponentMask)) == 0);
+      valueFP &= ~(FloatProp::exponentMask);
+      valueFP |= expVal;
+    }
+
+    // Move to the end of the bit sequence.
+    uint16_t getExponent() const {
+      return uint16_t((valueFP & FloatProp::exponentMask) >>
+                      (FloatProp::bitWidth - 1 - FloatProp::exponentWidth));
+    }
+
+    // Move it after the greatest mantissa bit.
+    void setImplicitBit(bool implicitVal) {
+      valueFP &= ~(UIntType(1) << FloatProp::mantissaWidth);
+      valueFP |= (UIntType(implicitVal) << FloatProp::mantissaWidth);
+    }
+
+    bool getImplicitBit() const {
+      return uint8_t((valueFP & (UIntType(1) << FloatProp::mantissaWidth)) >>
+                     FloatProp::mantissaWidth);
+    }
+
+    // Will be assigned to the highest order bit.
+    void setSign(bool signVal) {
+      valueFP &= ~(FloatProp::signMask);
+      UIntType sign1 = UIntType(signVal) << (FloatProp::bitWidth - 1);
+      valueFP |= sign1;
+    }
+
+    // Move to the end of the bit sequence so a single value is returned.
+    bool getSign() const {
+      return uint8_t((valueFP & FloatProp::signMask) >>
+                     (FloatProp::bitWidth - 1));
+    }
+
   } 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) : val(x) {}
+  explicit FPBits(XType x) : val(x) {}
 
   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 (encoding.exponent == 0)
+    if (encoding.getExponent() == 0)
       return int(1) - exponentBias;
-    return int(encoding.exponent) - exponentBias;
+    return int(encoding.getExponent()) - exponentBias;
   }
 
   bool isZero() const {
-    return encoding.exponent == 0 && encoding.mantissa == 0 &&
-           encoding.implicitBit == 0;
+    return encoding.getExponent() == 0 && encoding.getMantissa() == 0 &&
+           encoding.getImplicitBit() == 0;
   }
 
   bool isInf() const {
-    return encoding.exponent == maxExponent && encoding.mantissa == 0 &&
-           encoding.implicitBit == 1;
+    return encoding.getExponent() == maxExponent &&
+           encoding.getMantissa() == 0 && encoding.getImplicitBit() == 1;
   }
 
   bool isNaN() const {
-    if (encoding.exponent == maxExponent) {
-      return (encoding.implicitBit == 0) || encoding.mantissa != 0;
-    } else if (encoding.exponent != 0) {
-      return encoding.implicitBit == 0;
+    if (encoding.getExponent() == maxExponent) {
+      return (encoding.getImplicitBit() == 0) || encoding.getMantissa() != 0;
+    } else if (encoding.getExponent() != 0) {
+      return encoding.getImplicitBit() == 0;
     }
     return false;
   }
 
   bool isInfOrNaN() const {
-    return (encoding.exponent == maxExponent) ||
-           (encoding.exponent != 0 && encoding.implicitBit == 0);
+    return (encoding.getExponent() == maxExponent) ||
+           (encoding.getExponent() != 0 && encoding.getImplicitBit() == 0);
   }
 
   // Methods below this are used by tests.
 
   static FPBits<long double> zero() { return FPBits<long double>(0.0l); }
 
   static FPBits<long double> negZero() {
     FPBits<long double> bits(0.0l);
-    bits.encoding.sign = 1;
+    bits.encoding.setSign(1);
     return bits;
   }
 
   static FPBits<long double> inf() {
     FPBits<long double> bits(0.0l);
-    bits.encoding.exponent = maxExponent;
-    bits.encoding.implicitBit = 1;
+    bits.encoding.setExponent(maxExponent);
+    bits.encoding.setImplicitBit(1);
     return bits;
   }
 
   static FPBits<long double> negInf() {
     FPBits<long double> bits(0.0l);
-    bits.encoding.exponent = maxExponent;
-    bits.encoding.implicitBit = 1;
-    bits.encoding.sign = 1;
+    bits.encoding.setExponent(maxExponent);
+    bits.encoding.setImplicitBit(1);
+    bits.encoding.setSign(1);
     return bits;
   }
 
   static long double buildNaN(UIntType v) {
     FPBits<long double> bits(0.0l);
-    bits.encoding.exponent = maxExponent;
-    bits.encoding.implicitBit = 1;
-    bits.encoding.mantissa = v;
+    bits.encoding.setExponent(maxExponent);
+    bits.encoding.setImplicitBit(1);
+    bits.encoding.setMantissa(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.encoding.sign ? T(FPBits<T>::negZero()) : T(FPBits<T>::zero());
+    return bits.encoding.getSign() ? T(FPBits<T>::negZero())
+                                   : T(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.encoding.sign ? T(FPBits<T>::negZero())
+      return bits.encoding.getSign() ? T(FPBits<T>::negZero())
                                      : T(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.encoding.sign = FPBits<T>(y).encoding.sign;
+  xbits.encoding.setSign(FPBits<T>(y).encoding.getSign());
   return T(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.encoding.sign ? T(FPBits<T>::negInf()) : T(FPBits<T>::inf());
+    return bits.encoding.getSign() ? T(FPBits<T>::negInf())
+                                   : T(FPBits<T>::inf());
 
   // Similarly on the negative side we return zero early if |exp| is too small.
   if (exp < -expLimit)
-    return bits.encoding.sign ? T(FPBits<T>::negZero()) : T(FPBits<T>::zero());
+    return bits.encoding.getSign() ? T(FPBits<T>::negZero())
+                                   : T(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,

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.encoding.sign)
+    if (bits.encoding.getSign())
       return T(-0.0);
     else
       return T(0.0);
   }
 
   int trimSize = MantissaWidth<T>::value - exponent;
-  bits.encoding.mantissa = (bits.encoding.mantissa >> trimSize) << trimSize;
+  bits.encoding.setMantissa((bits.encoding.getMantissa() >> trimSize)
+                            << trimSize);
   return T(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.encoding.sign;
+  bool isNeg = bits.encoding.getSign();
   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.encoding.mantissa = (bits.encoding.mantissa >> trimSize) << trimSize;
+  bits.encoding.setMantissa((bits.encoding.getMantissa() >> 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.encoding.sign) {
+  if (bits.encoding.getSign()) {
     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.encoding.sign;
+  bool isNeg = bits.encoding.getSign();
   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.encoding.mantissa & (UIntType(1) << (trimSize - 1));
-  bits.encoding.mantissa = (bits.encoding.mantissa >> trimSize) << trimSize;
+  bool halfBitSet =
+      bits.encoding.getMantissa() & (UIntType(1) << (trimSize - 1));
+  bits.encoding.setMantissa((bits.encoding.getMantissa() >> 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.encoding.sign;
+  bool isNeg = bits.encoding.getSign();
   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.encoding.mantissa == 0)
+      if (exponent <= -2 || bits.encoding.getMantissa() == 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.encoding.mantissa = (bits.encoding.mantissa >> trimSize) << trimSize;
+  newBits.encoding.setMantissa((bits.encoding.getMantissa() >> trimSize)
+                               << trimSize);
   T truncValue = T(newBits);
 
   // If x is already an integer, return it.
   if (truncValue == x)
     return x;
 
-  UIntType trimValue = bits.encoding.mantissa & ((UIntType(1) << trimSize) - 1);
+  UIntType trimValue =
+      bits.encoding.getMantissa() & ((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.encoding.mantissa & (UIntType(1) << trimSize);
+  UIntType truncIsOdd =
+      newBits.encoding.getMantissa() & (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.encoding.sign ? IntegerMin : IntegerMax;
+    return bits.encoding.getSign() ? IntegerMin : IntegerMax;
   }
 
   int exponent = bits.getExponent();
   constexpr int exponentLimit = sizeof(I) * 8 - 1;
   if (exponent > exponentLimit) {
     setDomainErrorAndRaiseInvalid();
-    return bits.encoding.sign ? IntegerMin : IntegerMax;
+    return bits.encoding.getSign() ? IntegerMin : IntegerMax;
   } else if (exponent == exponentLimit) {
-    if (bits.encoding.sign == 0 || bits.encoding.mantissa != 0) {
+    if (bits.encoding.getSign() == 0 || bits.encoding.getMantissa() != 0) {
       setDomainErrorAndRaiseInvalid();
-      return bits.encoding.sign ? IntegerMin : IntegerMax;
+      return bits.encoding.getSign() ? 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.encoding.implicitBit == 1 && fromBits.encoding.exponent == 0) {
-    fromBits.encoding.exponent = 1;
+  if (fromBits.encoding.getImplicitBit() == 1 &&
+      fromBits.encoding.getExponent() == 0) {
+    fromBits.encoding.setExponent(1);
   }
 
   using UIntType = FPBits::UIntType;
   constexpr UIntType signVal = (UIntType(1) << 79);
   constexpr UIntType mantissaMask =
       (UIntType(1) << MantissaWidth<long double>::value) - 1;
   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.encoding.mantissa = 0;
+        fromBits.encoding.setMantissa(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.encoding.exponent;
+        fromBits.encoding.setExponent(fromBits.encoding.getExponent() + 1);
         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.encoding.mantissa = mantissaMask;
+        fromBits.encoding.setMantissa(mantissaMask);
         // from == 0 is handled separately so decrementing the exponent will not
         // lead to underflow.
-        --fromBits.encoding.exponent;
+        fromBits.encoding.setExponent(fromBits.encoding.getExponent() - 1);
         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.encoding.mantissa = mantissaMask;
+        fromBits.encoding.setMantissa(mantissaMask);
         // from == 0 is handled separately so decrementing the exponent will not
         // lead to underflow.
-        --fromBits.encoding.exponent;
+        fromBits.encoding.setExponent(fromBits.encoding.getExponent() - 1);
         return fromBits;
       } else {
         --intVal;
       }
     } else {
       if (intVal == FPBits::maxSubnormal) {
         intVal = FPBits::minNormal;
       } else if ((intVal & mantissaMask) == mantissaMask) {
-        fromBits.encoding.mantissa = 0;
+        fromBits.encoding.setMantissa(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.encoding.exponent;
+        fromBits.encoding.setExponent(fromBits.encoding.getExponent() + 1);
         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 ? T(FPBits<T>::negInf()) : T(FPBits<T>::inf());
     }
 
     FPBits<T> result(T(0.0));
-    result.encoding.sign = sign;
+    result.encoding.setSign(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.encoding.exponent = 0;
-        result.encoding.mantissa = mantissa >> shift;
-        UIntType newMantissa = result.encoding.mantissa;
+        result.encoding.setExponent(0);
+        result.encoding.setMantissa(mantissa >> shift);
+        UIntType newMantissa = result.encoding.getMantissa();
         if (shiftOutValue > halfwayValue) {
           newMantissa += 1;
         } else if (shiftOutValue == halfwayValue) {
           // Round to even.
-          if (result.encoding.mantissa & 0x1)
+          if (result.encoding.getMantissa() & 0x1)
             newMantissa += 1;
         }
-        result.encoding.mantissa = newMantissa;
+        result.encoding.setMantissa(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.encoding.exponent = 1;
+          result.encoding.setExponent(1);
         return T(result);
       } else {
         return T(result);
       }
     }
 
-    result.encoding.exponent = exponent + FPBits<T>::exponentBias;
-    result.encoding.mantissa = mantissa;
+    result.encoding.setExponent(exponent + FPBits<T>::exponentBias);
+    result.encoding.setMantissa(mantissa);
     return T(result);
   }
 
 private:
   void initFromBits(FPBits<T> bits) {
-    sign = bits.encoding.sign;
+    sign = bits.encoding.getSign();
 
     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.encoding.exponent == 0) {
-      unsigned shift = evaluateNormalizationShift(bits.encoding.mantissa);
-      mantissa = UIntType(bits.encoding.mantissa) << shift;
+    if (bits.encoding.getExponent() == 0) {
+      unsigned shift = evaluateNormalizationShift(bits.encoding.getMantissa());
+      mantissa = UIntType(bits.encoding.getMantissa()) << shift;
       exponent = 1 - FPBits<T>::exponentBias - shift;
     } else {
-      exponent = bits.encoding.exponent - FPBits<T>::exponentBias;
-      mantissa = one | bits.encoding.mantissa;
+      exponent = bits.encoding.getExponent() - FPBits<T>::exponentBias;
+      mantissa = one | bits.encoding.getMantissa();
     }
   }
 
   unsigned evaluateNormalizationShift(UIntType m) {
     unsigned shift = 0;
     for (; (one & m) == 0 && (shift < MantissaWidth<T>::value);
          m <<= 1, ++shift)
       ;
     return shift;
   }
 };
 
 #ifdef SPECIAL_X86_LONG_DOUBLE
 template <>
 inline void NormalFloat<long double>::initFromBits(FPBits<long double> bits) {
-  sign = bits.encoding.sign;
+  sign = bits.encoding.getSign();
 
   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.encoding.exponent == 0) {
-    if (bits.encoding.implicitBit == 0) {
+  if (bits.encoding.getExponent() == 0) {
+    if (bits.encoding.getImplicitBit() == 0) {
       // Since we ignore zero value, the mantissa in this case is non-zero.
       int normalizationShift =
-          evaluateNormalizationShift(bits.encoding.mantissa);
+          evaluateNormalizationShift(bits.encoding.getMantissa());
       exponent = -16382 - normalizationShift;
-      mantissa = (bits.encoding.mantissa << normalizationShift);
+      mantissa = (bits.encoding.getMantissa() << normalizationShift);
     } else {
       exponent = -16382;
-      mantissa = one | bits.encoding.mantissa;
+      mantissa = one | bits.encoding.getMantissa();
     }
   } else {
-    if (bits.encoding.implicitBit == 0) {
+    if (bits.encoding.getImplicitBit() == 0) {
       // Invalid number so just store 0 similar to a NaN.
       exponent = 0;
       mantissa = 0;
     } else {
-      exponent = bits.encoding.exponent - 16383;
-      mantissa = one | bits.encoding.mantissa;
+      exponent = bits.encoding.getExponent() - 16383;
+      mantissa = one | bits.encoding.getMantissa();
     }
   }
 }
 
 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.encoding.sign = sign;
+  result.encoding.setSign(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.encoding.exponent = 0;
-      result.encoding.mantissa = mantissa >> shift;
-      UIntType newMantissa = result.encoding.mantissa;
+      result.encoding.setExponent(0);
+      result.encoding.setMantissa(mantissa >> shift);
+      UIntType newMantissa = result.encoding.getMantissa();
       if (shiftOutValue > halfwayValue) {
         newMantissa += 1;
       } else if (shiftOutValue == halfwayValue) {
         // Round to even.
-        if (result.encoding.mantissa & 0x1)
+        if (result.encoding.getMantissa() & 0x1)
           newMantissa += 1;
       }
-      result.encoding.mantissa = newMantissa;
+      result.encoding.setMantissa(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.encoding.exponent = 1;
-        result.encoding.implicitBit = 1;
+        result.encoding.setExponent(1);
+        result.encoding.setImplicitBit(1);
       } else {
-        result.encoding.implicitBit = 0;
+        result.encoding.setImplicitBit(0);
       }
       return static_cast<long double>(result);
     } else {
       return static_cast<long double>(result);
     }
   }
 
-  result.encoding.exponent = biasedExponent;
-  result.encoding.mantissa = mantissa;
-  result.encoding.implicitBit = 1;
+  result.encoding.setExponent(biasedExponent);
+  result.encoding.setMantissa(mantissa);
+  result.encoding.setImplicitBit(1);
   return static_cast<long double>(result);
 }
 #endif // SPECIAL_X86_LONG_DOUBLE
 
 } // 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.encoding.sign && (bits.encoding.mantissa == 0)) {
+    if (bits.encoding.getSign() && (bits.encoding.getMantissa() == 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.encoding.sign) {
+  } else if (bits.encoding.getSign()) {
     // sqrt( negative numbers ) = NaN
     return FPBits<T>::buildNaN(One >> 1);
   } else {
     int xExp = bits.getExponent();
-    UIntType xMant = bits.encoding.mantissa;
+    UIntType xMant = bits.encoding.getMantissa();
 
     // Step 1a: Normalize denormal input and append hiddent bit to the mantissa
-    if (bits.encoding.exponent == 0) {
+    if (bits.encoding.getExponent() == 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.encoding.sign && (bits.encoding.mantissa == 0)) {
+    if (bits.encoding.getSign() && (bits.encoding.getMantissa() == 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.encoding.sign) {
+  } else if (bits.encoding.getSign()) {
     // sqrt( negative numbers ) = NaN
     return FPBits<long double>::buildNaN(One >> 1);
   } else {
     int xExp = bits.getExponent();
-    UIntType xMant = bits.encoding.mantissa;
+    UIntType xMant = bits.encoding.getMantissa();
 
     // Step 1a: Normalize denormal input
-    if (bits.encoding.implicitBit) {
+    if (bits.encoding.getImplicitBit()) {
       xMant |= One;
-    } else if (bits.encoding.exponent == 0) {
+    } else if (bits.encoding.getExponent() == 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.encoding.exponent = xExp;
-    out.encoding.implicitBit = 1;
-    out.encoding.mantissa = (y & (One - 1));
+    out.encoding.setExponent(xExp);
+    out.encoding.setImplicitBit(1);
+    out.encoding.setMantissa((y & (One - 1)));
 
     return out;
   }
 }
 
 } // namespace fputil
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_UTILS_FPUTIL_SQRT_LONG_DOUBLE_X86_H

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.encoding.sign)
+    if (bits.encoding.getSign())
       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.encoding.sign ? '1' : '0') << ", "
+    stream << "Sign: " << (bits.encoding.getSign() ? '1' : '0') << ", "
            << "Exponent: 0x"
-           << uintToHex<uint16_t>(bits.encoding.exponent, exponentWidthInHex)
+           << uintToHex<uint16_t>(bits.encoding.getExponent(),
+                                  exponentWidthInHex)
            << ", "
            << "Mantissa: 0x"
            << uintToHex<typename fputil::FPBits<ValType>::UIntType>(
-                  bits.encoding.mantissa, mantissaWidthInHex);
+                  bits.encoding.getMantissa(), 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/FPUtil/generic/FMA.h

 
 template <typename T>
 static inline cpp::EnableIfType<cpp::IsSame<T, float>::Value, T> fma(T x, T y,
                                                                      T z) {
   // Product is exact.
   double prod = static_cast<double>(x) * static_cast<double>(y);
   double z_d = static_cast<double>(z);
   double sum = prod + z_d;
   fputil::FPBits<double> bit_prod(prod), bitz(z_d), bit_sum(sum);
 
   if (!(bit_sum.isInfOrNaN() || bit_sum.isZero())) {
     // Since the sum is computed in double precision, rounding might happen
     // (for instance, when bitz.exponent > bit_prod.exponent + 5, or
     // bit_prod.exponent > bitz.exponent + 40).  In that case, when we round
     // the sum back to float, double rounding error might occur.
     // A concrete example of this phenomenon is as follows:
     //   x = y = 1 + 2^(-12), z = 2^(-53)
     // The exact value of x*y + z is 1 + 2^(-11) + 2^(-24) + 2^(-53)
     // So when rounding to float, fmaf(x, y, z) = 1 + 2^(-11) + 2^(-23)
     // On the other hand, with the default rounding mode,
     //   double(x*y + z) = 1 + 2^(-11) + 2^(-24)
     // and casting again to float gives us:
     //   float(double(x*y + z)) = 1 + 2^(-11).
     //
     // In order to correct this possible double rounding error, first we use
     // 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.encoding.exponent >= bitz.encoding.exponent)
+        (bit_prod.encoding.getExponent() >= bitz.encoding.getExponent())
             ? ((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.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;
+    if (!t.isZero() &&
+        ((bit_sum.encoding.getMantissa() & 0xfff'ffffULL) == 0)) {
+      if (bit_sum.encoding.getSign() != t.encoding.getSign()) {
+        bit_sum.encoding.setMantissa(bit_sum.encoding.getMantissa() + 1);
+      } else if (bit_sum.encoding.getMantissa()) {
+        bit_sum.encoding.setMantissa(bit_sum.encoding.getMantissa() - 1);
       }
     }
   }
 
   return static_cast<float>(static_cast<double>(bit_sum));
 }
 
 } // namespace generic
 } // namespace fputil
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_UTILS_FPUTIL_GENERIC_FMA_H