[libc] clean up FPUtil long doubles

[michaelrj]

Summary

Add quietNaNMask consts to FloatProperties and make LongDoubleBitsX86
clear the extra bits that aren't set when initializing with an 80 bit
long double.

libc/src/__support/FPUtil/FloatProperties.h

static constexpr uint32_t exponentWidth =
       FloatProperties<double>::exponentWidth;
   static constexpr BitsType mantissaMask =
       FloatProperties<double>::mantissaMask;
   static constexpr BitsType signMask = FloatProperties<double>::signMask;
   static constexpr BitsType exponentMask =
       FloatProperties<double>::exponentMask;
   static constexpr uint32_t exponentBias =
       FloatProperties<double>::exponentBias;
+
+  // If a number x is a NAN, then it is a quiet NAN if:
+  //   QuietNaNMask & bits(x) != 0
+  // Else, it is a signalling NAN.
+  static constexpr BitsType quietNaNMask =
+      FloatProperties<double>::quietNaNMask;
 };
 #elif defined(SPECIAL_X86_LONG_DOUBLE)
 // Properties for numbers represented in 80 bits long double on non-Windows x86
 // platforms.
 template <> struct FloatProperties<long double> {
   typedef __uint128_t BitsType;
   static_assert(sizeof(BitsType) == sizeof(long double),
                 "Unexpected size of 'long double' type.");
 
   static constexpr uint32_t bitWidth = (sizeof(BitsType) << 3) - 48;
 
   static constexpr uint32_t mantissaWidth = 63;
   static constexpr uint32_t exponentWidth = 15;
   static constexpr BitsType mantissaMask = (BitsType(1) << mantissaWidth) - 1;
   static constexpr BitsType signMask = BitsType(1)
                                        << (exponentWidth + mantissaWidth + 1);
   static constexpr BitsType exponentMask = ((BitsType(1) << exponentWidth) - 1)
                                            << (mantissaWidth + 1);
   static constexpr uint32_t exponentBias = 16383;
+
+  // If a number x is a NAN, then it is a quiet NAN if:
+  //   QuietNaNMask & bits(x) != 0
+  // Else, it is a signalling NAN.
+  static constexpr BitsType quietNaNMask = BitsType(1) << (mantissaWidth - 1);
 };
 #else
 // Properties for numbers represented in 128 bits long double on non x86
 // platform.
 template <> struct FloatProperties<long double> {
   typedef __uint128_t BitsType;
   static_assert(sizeof(BitsType) == sizeof(long double),
                 "Unexpected size of 'long double' type.");
 
   static constexpr uint32_t bitWidth = sizeof(BitsType) << 3;
 
   static constexpr uint32_t mantissaWidth = 112;
   static constexpr uint32_t exponentWidth = 15;
   static constexpr BitsType mantissaMask = (BitsType(1) << mantissaWidth) - 1;
   static constexpr BitsType signMask = BitsType(1)
                                        << (exponentWidth + mantissaWidth);
   static constexpr BitsType exponentMask = ~(signMask | mantissaMask);
   static constexpr uint32_t exponentBias = 16383;
+
+  // If a number x is a NAN, then it is a quiet NAN if:
+  //   QuietNaNMask & bits(x) != 0
+  // Else, it is a signalling NAN.
+  static constexpr BitsType quietNaNMask = BitsType(1) << (mantissaWidth - 1);
 };
 #endif
 
 // Define the float type corresponding to the BitsType.
 template <typename BitsType> struct FloatType;
 
 template <> struct FloatType<uint32_t> {
   static_assert(sizeof(uint32_t) == sizeof(float),

libc/src/__support/FPUtil/LongDoubleBitsX86.h

template <> union FPBits<long double> {
   }
 
   long double val;
 
   FPBits() : bits(0) {}
 
   template <typename XType,
             cpp::EnableIfType<cpp::IsSame<long double, XType>::Value, int> = 0>
-  explicit FPBits(XType x) : val(x) {}
+  explicit FPBits(XType x) : val(x) {
+    // bits starts uninitialized, and setting it to a long double only
+    // overwrites the first 80 bits. This clears those upper bits.
+    bits = bits & ((UIntType(1) << 80) - 1);
+  }
 
   template <typename XType,
             cpp::EnableIfType<cpp::IsSame<XType, UIntType>::Value, int> = 0>
   explicit FPBits(XType x) : bits(x) {}
 
   operator long double() { return val; }
 
   UIntType uintval() {