[libc] Capture floating point encoding and arrange it sequentially in memory

[hedingarcia]

Summary

Redefined FPBits.h and LongDoubleBitsX86 so its implementation works for the Windows
and Linux platform while maintaining a packed memory alignment of the precision floating
point numbers. For its size in memory to be the same as the data type of the float point number.
This change was necessary because the previous attribute((packed)) specification in the struct was not working
for Windows like it was for Linux and consequently static_asserts in the FPBits.h file were failing.

[hedingarcia]

Fixed error signaled when running the tests for LdExpTest.h by ensuring that the value passed to set mantissa
did not lead to overload to the exponent value in FPBits.h and LongDoubleBitsX86.h.
Added asserts to detect those unintentional overflows in setMantissa() and setExponent().

[aeubanks]

the title should say something about creating a custom packed int, the getter and setter part is a small detail that shouldn't be in the title

libc/utils/FPUtil/FPBits.h

21–22

since we're basically just forwarding MantissaWidth to FloatProperties::mantissaWidth, we can delete all the specializations below and do

template <typename T> struct MantissaWidth {
    static constexpr unsigned value = FloatProperties<T>::mantissaWidth;
};

Or even better, delete these and and only use FloatProperties::mantissaWidth. But maybe that can be done in a follow up patch.

45

I think we don't need the __llvm_libc::fputil:: since we're arleady inside that namespace

45–78

we should replace all uses of integer with encoding.valueFP

48

I don't really like valueFP, how about something like bits

54

these comments should probably be deleted, they're not super useful

79

this is very confusing, can we just use mantissaWidth?

91

bool?

[hedingarcia]

[libc] Fix of the patch, refactored FPBits.h to have template structs

Made one template struct for MantissaWidth, one for ExponentWidth, and another for FPUIntType.
Removed namespaced calls, comments and changed variable name valueFP to bits in FPBits.h and LongDoubleBitsX86.h.
Changed the return data type of getSign() from bool to uint8_t.

[aeubanks]

the commit message is a bit verbose:

• no need to say that the patch was fixed
• no need to say that you updated all getters/setters of exponent/mantissa/sign, that is a direct and obvious consequence of FPBits work
• no need to say that we're using FloatProperties.h, that's obvious if you look at the patch
• the ultimate reason for this patch isn't that static_asserts are failing, it's that attribute((packed)) isn't portable and doesn't work on Windows

in general the commit message should be more of a "why" rather than a "what are the steps I took to create this patch"; try to figure out exactly what a reader of this patch needs to know and don't over-explain details since that clutters the message
if something tricky is being done then that should be explained of course, but most of this patch is self-explanatory if you know the reasoning behind the change

libc/utils/FPUtil/FPBits.h

56

@sivachandra is this the right way to assert?

83

not sure if this should be a bool or a uint8_t...
let's see what the others say

[hedingarcia]

libc/utils/FPUtil/FPBits.h

79

The reason why we cannot use mantissaWidth is because in the 80-bit long double implementation the value for that field is 63 instead of 64. An explicit bit is considered in the 63 bit as the integer part of the significand (https://en.wikipedia.org/wiki/Extended_precision ). This exception leads to that long expression in getExponent(), because with only the value of mantissaWidth the shift will still require to move one bit in order to return all the bits of the exponent.

[aeubanks]

libc/utils/FPUtil/FPBits.h

79

I thought that only applied to the version in LongDoubleBitsX86

[hedingarcia]

libc/utils/FPUtil/FPBits.h

79

Yes, however should the same implementation in LongDoubleBitsX86.h be kept the same even in FPBits.h?

[hedingarcia]

[libc] Fixing shift in getExponent() and setExponent()

Refactoring the previous shift to retrieve and set the exponent
with the mantissaWidth value in FPBits.h

[hedingarcia]

libc/utils/FPUtil/FPBits.h

79

I see what you mean now, yes since LongDoubleBitsX86.h takes care of the long double implementation, this file only should take in consideration that explicit bit. FPBits.h does not have to work around this case since it is used for single and double. Thank you for catching that detail.

[aeubanks]

mostly looks good

libc/utils/FPUtil/FPBits.h

44–45

FloatProp::BitsType seems more consistent (you can move the using FloatProp here)

55

the next assert will never fail with this line (same for setExponent())

[hedingarcia]

[libc] Rearranging alias declarations and removing asserts

[sivachandra]

Sorry for the delay in the review. I have gone through the history and it mostly looks good. I have a few comments about the cosmetics.

libc/utils/FPUtil/FPBits.h

29–30

Can this struct be removed now?

44–78

I would actually prefer if we got rid of encoding completely [1]. Adding the new methods to FPBits directly would reduce the verbosity when calling them. The integer value is currently called integer, but as @aeubanks suggests elsewhere, bits is more appropriate may be. However, to reduce the churn, you can choose to keep it as integer or bits depending on whats convenient to you.

[1] - We had a separate encoding field because it was essentially that when we could use bit-fields. Moreover, it helped us distinguish it with the other fields. With that gone, we can choose to remove it and eliminate that "complexity" and verbosity.

45

For consistency, I would name UIntType as BitsType here as well. But, you can choose to add a TODO here and do that "cleanup" in a follow up change.

53

Why are these methods required? Probably because you got rid of the integer field of FPBits? If you add the rest of the methods to FPBits directly (see below), this should not be required as the integer / bits value can be directly set or read.

56

Not sure what line this pertains to. But, after this change, the only assert that would be required is something like:

assert(sizeof(T) == sizeof(UIntVal), ...);

69

You should probably name this method unbiasedExponent to distinguish it from the real exponent value returned by getExponent().

83

To which line was this comment originally for?

[aeubanks]

libc/utils/FPUtil/FPBits.h

29–30

I'd say clean this, along with Exponent/MantissaWidth up in a later patch, there are lots of uses of these

56

oh, I think the code was deleted for some reason

I spent a while debugging a failure Hedin was running into. Turns out sometimes when setting the mantissa/exponent, it was actually larger than the max value (IIRC at the very bottom of NormalFloat.h). With the struct bitfield it automatically took care of that, but here we needed to mask out the extra bits. The question is whether to do that in the setter or do that in the caller. If we do that in the setter we preserve the existing behavior. But I'm slightly in favor of forcing callers to handle that and adding an assert in the setter that the bits don't overflow. This is probably a bit faster since we don't have to do the bitmask on every setter, and may catch future issues.

The question about the assert was, is assert(cond); the right way to assert? As in in debug modes it'll run the assert and crash, and in release modes the assert won't be there for perf reasons. Is <assert.h> the right thing to include?

83

this was for getSign()

[sivachandra]

libc/utils/FPUtil/FPBits.h

56

Ah, OK! I should have said static_assert in my comment. The general rule we follow is:

1. Include freestanding C headers if required.
2. Include the header file corresponding to the implementation if required. So, in fputils, we can include math.h.
3. Do not include other libc public headers unless they are related.

Some of the above are checked by the libc lint rules implemented as part of clang-tidy. They are only run on the full build builders: https://lab.llvm.org/buildbot/#/workers/120

So, we cannot include assert.h or use assert. Whether the value should be checked in the caller or the setter, there are a few algorithms which assume the setters are doing it (there is a deliberate intention to overflow the mantissa.) So, I would say do the masking in the setter to retain functionality. In practice, it isn't a big runtime penalty as the setting usually happens at the very end of a complex algorithm.

[hedingarcia]

[libc] Removed encoding/FPUIntType struct and renamed getExponent()

Eliminated encoding struct and moved its data and member fields into FPBits.
Removed the FPUIntType struct since it was not being referenced.

[aeubanks]

lgtm besides the question for Siva of uint8_t vs bool for getSign()

[sivachandra]

In D105561#2872036, @aeubanks wrote:

lgtm besides the question for Siva of uint8_t vs bool for getSign()

Logically, it doesn't matter. Are there benefits wrt compiler driven optimizations? If yes, then suggest the one which should be preferred?

Otherwise, LGTM as well. Thanks for patiently resolving the comments.

[aeubanks]

In D105561#2872173, @sivachandra wrote:

In D105561#2872036, @aeubanks wrote:

lgtm besides the question for Siva of uint8_t vs bool for getSign()

Logically, it doesn't matter. Are there benefits wrt compiler driven optimizations? If yes, then suggest the one which should be preferred?

Otherwise, LGTM as well. Thanks for patiently resolving the comments.

Probably bool is better since the compiler can assume it's only 0 or 1.

[hedingarcia]

In D105561#2872187, @aeubanks wrote:

Probably bool is better since the compiler can assume it's only 0 or 1.

Okay, I will change the return type to bool.

[hedingarcia]

[libc] Changed the return type of getSign()

[aeubanks]

lgtm

[lntue]

libc/utils/FPUtil/FPBits.h

76

Sorry for late comments! Since you already updated to get* and set*, can you also add getBits and setBits? I think they would be a better than the current uintval() (and technically no equivalent of setBits).

libc/utils/FPUtil/NextAfterLongDoubleX86.h

53

I'm a bit curious about generated assembly of this line. @sivachandra : can we check if there is any regression with this one? I think no regression for O2 and O3 would be good enough.

[hedingarcia]

libc/utils/FPUtil/FPBits.h

76

These get/setBits members were used previously with a different name but now they are not required anymore since bits value can be directly set or read from FPBits.

libc/utils/FPUtil/NextAfterLongDoubleX86.h

53

The object files generated before and after this patch are the same, at least after running the check there was no difference between the files at O2 optimization level.

[amccarth]

libc/utils/FPUtil/FPBits.h

49

I'm rather surprised that this change was necessary. When working with a specific bit layout, using a unsigned integer type and bitwise operations can be a good idea--I don't think the language standards give many guarantees about how the bits are allocated (e.g., MSB first or LSB first?). But I'm not sure why the compiler (we are talking about clang here, right?) didn't pack the structures the same way on all platforms.

Perhaps when targeting Windows, clang is trying too hard to be compatible with MSVC. With MSVC, when defining bit fields, they will pack by default--but only if the underlying types are all the same. Since the old types were UIntType,, uint16_t, and uint8_t--all of which have different alignment requirements--MSVC doesn't pack those. But if they had all been defined as uint32_t, MSVC would certainly have done the right thing.

And thus, maybe clang would have as well.

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.getUnbiasedExponent(), 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.getUnbiasedExponent(),
+              uint16_t(xBits.getUnbiasedExponent() - 1));
+    ASSERT_EQ(resultBits.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.getUnbiasedExponent(), xBits.getUnbiasedExponent());
+    ASSERT_EQ(resultBits.getMantissa(), xBits.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.getUnbiasedExponent(),
+              uint16_t(xBits.getUnbiasedExponent() - 1));
+    ASSERT_EQ(resultBits.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.getUnbiasedExponent(), xBits.getUnbiasedExponent());
+    ASSERT_EQ(resultBits.getMantissa(), xBits.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.setUnbiasedExponent(exponentLimit + FPBits::exponentBias);
+    bits.setSign(1);
+    bits.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.setUnbiasedExponent(exponentLimit + FPBits::exponentBias);
+    bits.setSign(1);
+    bits.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.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.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.getSign() != bity.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.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.getSign() != bity.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.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.getSign() == ybits.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.setSign(0);
+  ybits.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 <stdint.h>
 
 namespace __llvm_libc {
 namespace fputil {
 
-template <typename T> struct MantissaWidth {};
-template <> struct MantissaWidth<float> {
-  static constexpr unsigned value = 23;
-};
-template <> struct MantissaWidth<double> {
-  static constexpr unsigned value = 52;
-};
-
-template <typename T> struct ExponentWidth {};
-template <> struct ExponentWidth<float> {
-  static constexpr unsigned value = 8;
-};
-template <> struct ExponentWidth<double> {
-  static constexpr unsigned value = 11;
-};
-template <> struct ExponentWidth<long double> {
-  static constexpr unsigned value = 15;
+template <typename T> struct MantissaWidth {
+  static constexpr unsigned value = FloatProperties<T>::mantissaWidth;
 };
 
-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 <typename T> struct ExponentWidth {
+  static constexpr unsigned value = FloatProperties<T>::exponentWidth;
 };
-template <> struct FPUIntType<long double> {
-  using Type = FPUIntType<double>::Type;
-};
-#elif !defined(SPECIAL_X86_LONG_DOUBLE)
-template <> struct MantissaWidth<long double> {
-  static constexpr unsigned value = 112;
-};
-template <> struct FPUIntType<long double> { using Type = __uint128_t; };
-#endif
 
 // A generic class to represent single precision, double precision, and quad
 // precision IEEE 754 floating point formats.
 // On most platforms, the 'float' type corresponds to single precision floating
 // point numbers, the 'double' type corresponds to double precision floating
 // point numers, and the 'long double' type corresponds to the quad precision
 // floating numbers. On x86 platforms however, the 'long double' type maps to
 // an x87 floating point format. This format is an IEEE 754 extension format.
 // It is handled as an explicit specialization of this class.
 template <typename T> 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;
+  using FloatProp = FloatProperties<T>;
+  // TODO: Change UintType name to BitsType for consistency.
+  using UIntType = typename FloatProp::BitsType;
 
-  struct __attribute__((packed)) {
-    UIntType mantissa : MantissaWidth<T>::value;
-    uint16_t exponent : ExponentWidth<T>::value;
-    uint8_t sign : 1;
-  } encoding;
-  UIntType integer;
+  UIntType bits;
+
+  void setMantissa(UIntType mantVal) {
+    mantVal &= (FloatProp::mantissaMask);
+    bits &= ~(FloatProp::mantissaMask);
+    bits |= mantVal;
+  }
+
+  UIntType getMantissa() const { return bits & FloatProp::mantissaMask; }
+
+  void setUnbiasedExponent(UIntType expVal) {
+    expVal = (expVal << (FloatProp::mantissaWidth)) & FloatProp::exponentMask;
+    bits &= ~(FloatProp::exponentMask);
+    bits |= expVal;
+  }
+
+  uint16_t getUnbiasedExponent() const {
+    return uint16_t((bits & FloatProp::exponentMask) >>
+                    (FloatProp::mantissaWidth));
+  }
+
+  void setSign(bool signVal) {
+    bits &= ~(FloatProp::signMask);
+    UIntType sign = UIntType(signVal) << (FloatProp::bitWidth - 1);
+    bits |= sign;
+  }
+
+  bool getSign() const {
+    return ((bits & FloatProp::signMask) >> (FloatProp::bitWidth - 1));
+  }
   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_assert(sizeof(T) == sizeof(UIntType),
+                "Data type and integral representation 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, int> = 0>
   explicit FPBits(XType x) : val(x) {}
 
   template <typename XType,
             cpp::EnableIfType<cpp::IsSame<XType, UIntType>::Value, int> = 0>
-  explicit FPBits(XType x) : integer(x) {}
+  explicit FPBits(XType x) : bits(x) {}
 
-  FPBits() : integer(0) {}
+  FPBits() : bits(0) {}
 
   explicit operator T() { return val; }
 
-  UIntType uintval() const { return integer; }
+  UIntType uintval() const { return bits; }
 
-  int getExponent() const { return int(encoding.exponent) - exponentBias; }
+  int getExponent() const { return int(getUnbiasedExponent()) - exponentBias; }
 
   bool isZero() const {
-    return encoding.mantissa == 0 && encoding.exponent == 0;
+    return getMantissa() == 0 && getUnbiasedExponent() == 0;
   }
 
   bool isInf() const {
-    return encoding.mantissa == 0 && encoding.exponent == maxExponent;
+    return getMantissa() == 0 && getUnbiasedExponent() == maxExponent;
   }
 
   bool isNaN() const {
-    return encoding.exponent == maxExponent && encoding.mantissa != 0;
+    return getUnbiasedExponent() == maxExponent && getMantissa() != 0;
   }
 
-  bool isInfOrNaN() const { return encoding.exponent == maxExponent; }
+  bool isInfOrNaN() const { return getUnbiasedExponent() == 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.setUnbiasedExponent(maxExponent);
     return bits;
   }
 
   static FPBits<T> negInf() {
     FPBits<T> bits = inf();
-    bits.encoding.sign = 1;
+    bits.setSign(1);
     return bits;
   }
 
   static T buildNaN(UIntType v) {
     FPBits<T> bits = inf();
-    bits.encoding.mantissa = v;
+    bits.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.getUnbiasedExponent() >=
+       y_bits.getUnbiasedExponent() + 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.getUnbiasedExponent() >=
+              x_bits.getUnbiasedExponent() + MantissaWidth<T>::value + 2) ||
              (x == 0)) {
-    y_bits.encoding.sign = 0;
+    y_bits.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.getUnbiasedExponent();
+    a_mant = x_bits.getMantissa();
+    b_exp = y_bits.getUnbiasedExponent();
+    b_mant = y_bits.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.getUnbiasedExponent();
+    a_mant = y_bits.getMantissa();
+    b_exp = x_bits.getUnbiasedExponent();
+    b_mant = x_bits.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;
-  } encoding;
-  UIntType integer;
+  using FloatProp = FloatProperties<long double>;
+
+  UIntType bits;
+
+  void setMantissa(UIntType mantVal) {
+    mantVal &= (FloatProp::mantissaMask);
+    bits &= ~(FloatProp::mantissaMask);
+    bits |= mantVal;
+  }
+
+  UIntType getMantissa() const { return bits & FloatProp::mantissaMask; }
+
+  void setUnbiasedExponent(UIntType expVal) {
+    expVal = (expVal << (FloatProp::bitWidth - 1 - FloatProp::exponentWidth)) &
+             FloatProp::exponentMask;
+    bits &= ~(FloatProp::exponentMask);
+    bits |= expVal;
+  }
+
+  uint16_t getUnbiasedExponent() const {
+    return uint16_t((bits & FloatProp::exponentMask) >>
+                    (FloatProp::bitWidth - 1 - FloatProp::exponentWidth));
+  }
+
+  void setImplicitBit(bool implicitVal) {
+    bits &= ~(UIntType(1) << FloatProp::mantissaWidth);
+    bits |= (UIntType(implicitVal) << FloatProp::mantissaWidth);
+  }
+
+  bool getImplicitBit() const {
+    return ((bits & (UIntType(1) << FloatProp::mantissaWidth)) >>
+            FloatProp::mantissaWidth);
+  }
+
+  void setSign(bool signVal) {
+    bits &= ~(FloatProp::signMask);
+    UIntType sign1 = UIntType(signVal) << (FloatProp::bitWidth - 1);
+    bits |= sign1;
+  }
+
+  bool getSign() const {
+    return ((bits & FloatProp::signMask) >> (FloatProp::bitWidth - 1));
+  }
+
   long double val;
 
-  FPBits() : integer(0) {}
+  FPBits() : bits(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) {}
+  explicit FPBits(XType x) : bits(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;
+    return bits & mask;
   }
 
   int getExponent() const {
-    if (encoding.exponent == 0)
+    if (getUnbiasedExponent() == 0)
       return int(1) - exponentBias;
-    return int(encoding.exponent) - exponentBias;
+    return int(getUnbiasedExponent()) - exponentBias;
   }
 
   bool isZero() const {
-    return encoding.exponent == 0 && encoding.mantissa == 0 &&
-           encoding.implicitBit == 0;
+    return getUnbiasedExponent() == 0 && getMantissa() == 0 &&
+           getImplicitBit() == 0;
   }
 
   bool isInf() const {
-    return encoding.exponent == maxExponent && encoding.mantissa == 0 &&
-           encoding.implicitBit == 1;
+    return getUnbiasedExponent() == maxExponent && getMantissa() == 0 &&
+           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 (getUnbiasedExponent() == maxExponent) {
+      return (getImplicitBit() == 0) || getMantissa() != 0;
+    } else if (getUnbiasedExponent() != 0) {
+      return getImplicitBit() == 0;
     }
     return false;
   }
 
   bool isInfOrNaN() const {
-    return (encoding.exponent == maxExponent) ||
-           (encoding.exponent != 0 && encoding.implicitBit == 0);
+    return (getUnbiasedExponent() == maxExponent) ||
+           (getUnbiasedExponent() != 0 && 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.setSign(1);
     return bits;
   }
 
   static FPBits<long double> inf() {
     FPBits<long double> bits(0.0l);
-    bits.encoding.exponent = maxExponent;
-    bits.encoding.implicitBit = 1;
+    bits.setUnbiasedExponent(maxExponent);
+    bits.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.setUnbiasedExponent(maxExponent);
+    bits.setImplicitBit(1);
+    bits.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.setUnbiasedExponent(maxExponent);
+    bits.setImplicitBit(1);
+    bits.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.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())
-                                : T(FPBits<T>::zero());
+      return bits.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.setSign(FPBits<T>(y).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.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.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.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.setMantissa((bits.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.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.setMantissa((bits.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.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.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.getMantissa() & (UIntType(1) << (trimSize - 1));
+  bits.setMantissa((bits.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.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.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.setMantissa((bits.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.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.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.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.getSign() ? IntegerMin : IntegerMax;
   } else if (exponent == exponentLimit) {
-    if (bits.encoding.sign == 0 || bits.encoding.mantissa != 0) {
+    if (bits.getSign() == 0 || bits.getMantissa() != 0) {
       setDomainErrorAndRaiseInvalid();
-      return bits.encoding.sign ? IntegerMin : IntegerMax;
+      return bits.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.getImplicitBit() == 1 && fromBits.getUnbiasedExponent() == 0) {
+    fromBits.setUnbiasedExponent(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.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.setUnbiasedExponent(fromBits.getUnbiasedExponent() + 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.setMantissa(mantissaMask);
         // from == 0 is handled separately so decrementing the exponent will not
         // lead to underflow.
-        --fromBits.encoding.exponent;
+        fromBits.setUnbiasedExponent(fromBits.getUnbiasedExponent() - 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.setMantissa(mantissaMask);
         // from == 0 is handled separately so decrementing the exponent will not
         // lead to underflow.
-        --fromBits.encoding.exponent;
+        fromBits.setUnbiasedExponent(fromBits.getUnbiasedExponent() - 1);
         return fromBits;
       } else {
         --intVal;
       }
     } else {
       if (intVal == FPBits::maxSubnormal) {
         intVal = FPBits::minNormal;
       } else if ((intVal & mantissaMask) == mantissaMask) {
-        fromBits.encoding.mantissa = 0;
+        fromBits.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.setUnbiasedExponent(fromBits.getUnbiasedExponent() + 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.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.setUnbiasedExponent(0);
+        result.setMantissa(mantissa >> shift);
+        UIntType newMantissa = result.getMantissa();
         if (shiftOutValue > halfwayValue) {
           newMantissa += 1;
         } else if (shiftOutValue == halfwayValue) {
           // Round to even.
-          if (result.encoding.mantissa & 0x1)
+          if (result.getMantissa() & 0x1)
             newMantissa += 1;
         }
-        result.encoding.mantissa = newMantissa;
+        result.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.setUnbiasedExponent(1);
         return T(result);
       } else {
         return T(result);
       }
     }
 
-    result.encoding.exponent = exponent + FPBits<T>::exponentBias;
-    result.encoding.mantissa = mantissa;
+    result.setUnbiasedExponent(exponent + FPBits<T>::exponentBias);
+    result.setMantissa(mantissa);
     return T(result);
   }
 
 private:
   void initFromBits(FPBits<T> bits) {
-    sign = bits.encoding.sign;
+    sign = bits.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.getUnbiasedExponent() == 0) {
+      unsigned shift = evaluateNormalizationShift(bits.getMantissa());
+      mantissa = UIntType(bits.getMantissa()) << shift;
       exponent = 1 - FPBits<T>::exponentBias - shift;
     } else {
-      exponent = bits.encoding.exponent - FPBits<T>::exponentBias;
-      mantissa = one | bits.encoding.mantissa;
+      exponent = bits.getUnbiasedExponent() - FPBits<T>::exponentBias;
+      mantissa = one | bits.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.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.getUnbiasedExponent() == 0) {
+    if (bits.getImplicitBit() == 0) {
       // Since we ignore zero value, the mantissa in this case is non-zero.
-      int normalizationShift =
-          evaluateNormalizationShift(bits.encoding.mantissa);
+      int normalizationShift = evaluateNormalizationShift(bits.getMantissa());
       exponent = -16382 - normalizationShift;
-      mantissa = (bits.encoding.mantissa << normalizationShift);
+      mantissa = (bits.getMantissa() << normalizationShift);
     } else {
       exponent = -16382;
-      mantissa = one | bits.encoding.mantissa;
+      mantissa = one | bits.getMantissa();
     }
   } else {
-    if (bits.encoding.implicitBit == 0) {
+    if (bits.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.getUnbiasedExponent() - 16383;
+      mantissa = one | bits.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.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.setUnbiasedExponent(0);
+      result.setMantissa(mantissa >> shift);
+      UIntType newMantissa = result.getMantissa();
       if (shiftOutValue > halfwayValue) {
         newMantissa += 1;
       } else if (shiftOutValue == halfwayValue) {
         // Round to even.
-        if (result.encoding.mantissa & 0x1)
+        if (result.getMantissa() & 0x1)
           newMantissa += 1;
       }
-      result.encoding.mantissa = newMantissa;
+      result.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.setUnbiasedExponent(1);
+        result.setImplicitBit(1);
       } else {
-        result.encoding.implicitBit = 0;
+        result.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.setUnbiasedExponent(biasedExponent);
+  result.setMantissa(mantissa);
+  result.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.getSign() && (bits.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.getSign()) {
     // sqrt( negative numbers ) = NaN
     return FPBits<T>::buildNaN(One >> 1);
   } else {
     int xExp = bits.getExponent();
-    UIntType xMant = bits.encoding.mantissa;
+    UIntType xMant = bits.getMantissa();
 
     // Step 1a: Normalize denormal input and append hiddent bit to the mantissa
-    if (bits.encoding.exponent == 0) {
+    if (bits.getUnbiasedExponent() == 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.getSign() && (bits.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.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.getMantissa();
 
     // Step 1a: Normalize denormal input
-    if (bits.encoding.implicitBit) {
+    if (bits.getImplicitBit()) {
       xMant |= One;
-    } else if (bits.encoding.exponent == 0) {
+    } else if (bits.getUnbiasedExponent() == 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.setUnbiasedExponent(xExp);
+    out.setImplicitBit(1);
+    out.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.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.getSign() ? '1' : '0') << ", "
            << "Exponent: 0x"
-           << uintToHex<uint16_t>(bits.encoding.exponent, exponentWidthInHex)
+           << uintToHex<uint16_t>(bits.getUnbiasedExponent(),
+                                  exponentWidthInHex)
            << ", "
            << "Mantissa: 0x"
            << uintToHex<typename fputil::FPBits<ValType>::UIntType>(
-                  bits.encoding.mantissa, mantissaWidthInHex);
+                  bits.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

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.encoding.exponent >= bitz.encoding.exponent)
+        (bit_prod.getUnbiasedExponent() >= bitz.getUnbiasedExponent())
             ? ((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.getMantissa() & 0xfff'ffffULL) == 0)) {
+      if (bit_sum.getSign() != t.getSign()) {
+        bit_sum.setMantissa(bit_sum.getMantissa() + 1);
+      } else if (bit_sum.getMantissa()) {
+        bit_sum.setMantissa(bit_sum.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