[libc] Add Uint128 type as a fallback when __uint128_t is not available.

[sivachandra]

Summary

Also, the unused specializations of __int128_t have been removed.

[lntue]

libc/src/__support/CPP/Limits.h

77–88

Can you just include "Uint128.h" and only specialize the template for UInt128 so that there is no need for #ifdef here?

libc/src/__support/CPP/TypeTraits.h

59–62

Can you just include "Uint128.h" and only specialize the template for UInt128 so that there is no need for #ifdef here?

libc/test/src/__support/high_precision_decimal_test.cpp

354

#ifdef's are not needed in this test anymore.

libc/test/src/__support/str_to_float_test.cpp

317

Not needed anymore.

libc/utils/UnitTest/CMakeLists.txt

8

Too many tests using uint128 implicitly I guess?

libc/utils/UnitTest/LibcTest.cpp

59–69

Combine the specializations with UInt128.

257–271

Combine the specializations with UInt128.

[sivachandra]

Address comments.

libc/src/__support/CPP/Limits.h

77–88

I have added comments now to explain why we need both specializations. Essentially, we need both so that we can uniitest UInt<128> on platfroms where UInt128 resolves to __uint128_t.

libc/src/__support/CPP/TypeTraits.h

59–62

Same reason as above; added comments here as well.

libc/utils/UnitTest/CMakeLists.txt

8

This change isn't changing the situation. The deps were incomplete previously.

libc/utils/UnitTest/LibcTest.cpp

59–69

Same reason as above. Added a comment now.

257–271

Ditto.

[sivachandra]

I have landed this now unblock other work. I am happy to do follow up changes as required.

libc/src/__support/CMakeLists.txt

HDRS
     str_to_float.h
   DEPENDS
     .str_to_integer
     .ctype_utils
     .high_precision_decimal
     libc.include.errno
     libc.src.errno.errno
     libc.src.__support.CPP.limits
+    libc.src.__support.CPP.uint128
     libc.src.__support.FPUtil.fputil
 )
 
 add_header_library(
   integer_operations
   HDRS
     integer_operations.h
 )

libc/src/__support/CPP/CMakeLists.txt

 add_header_library(
   array
   HDRS
     Array.h
 )
 
 add_header_library(
+  uint
+  HDRS
+    UInt.h
+  DEPENDS
+    .array
+)
+
+add_header_library(
+  uint128
+  HDRS
+    UInt128.h
+  DEPENDS
+    .uint
+)
+
+add_header_library(
   array_ref
   HDRS
     ArrayRef.h
 )
 
 add_header_library(
   bit
   HDRS
add_header_library(
   HDRS
     Functional.h
 )
 
 add_header_library(
   limits
   HDRS
     Limits.h
+  DEPENDS
+    .uint
 )
 
 add_header_library(
   string_view
   HDRS
     StringView.h
 )
 
 add_header_library(
   type_traits
   HDRS
     TypeTraits.h
+  DEPENDS
+    .uint
 )
 
 add_header_library(
   utility
   HDRS
     Utility.h
 )
 
HDRS
     blockstore.h
 )
 
 add_header_library(
   error
   HDRS
     error.h
 )
-
-add_header_library(
-  uint
-  HDRS
-    UInt.h
-  DEPENDS
-    libc.src.__support.CPP.array
-)

libc/src/__support/CPP/Limits.h

 //===-- A self contained equivalent of std::limits --------------*- 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_SRC_SUPPORT_CPP_LIMITS_H
 #define LLVM_LIBC_SRC_SUPPORT_CPP_LIMITS_H
 
+#include "UInt.h"
+
 #include <limits.h>
 
 namespace __llvm_libc {
 namespace cpp {
 
 template <class T> class NumericLimits {
 public:
   static constexpr T max();
public:
   static constexpr char max() { return CHAR_MAX; }
   static constexpr char min() { return CHAR_MIN; }
 };
 template <> class NumericLimits<unsigned char> {
 public:
   static constexpr unsigned char max() { return UCHAR_MAX; }
   static constexpr unsigned char min() { return 0; }
 };
+template <> class NumericLimits<UInt<128>> {
+public:
+  static constexpr UInt<128> max() { return ~UInt<128>(0); }
+  static constexpr UInt<128> min() { return 0; }
+};
 #ifdef __SIZEOF_INT128__
 template <> class NumericLimits<__uint128_t> {
 public:
   static constexpr __uint128_t max() { return ~__uint128_t(0); }
   static constexpr __uint128_t min() { return 0; }
 };
-template <> class NumericLimits<__int128_t> {
-public:
-  static constexpr __int128_t max() { return ~__uint128_t(0) >> 1; }
-  static constexpr __int128_t min() { return __int128_t(1) << 127; }
-};
 #endif
+
 } // namespace cpp
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_CPP_LIMITS_H

libc/src/__support/CPP/TypeTraits.h

template <typename Type> struct IsIntegral {
   using TypeNoCV = RemoveCVType<Type>;
   static constexpr bool Value =
       IsSameV<char, TypeNoCV> || IsSameV<signed char, TypeNoCV> ||
       IsSameV<unsigned char, TypeNoCV> || IsSameV<short, TypeNoCV> ||
       IsSameV<unsigned short, TypeNoCV> || IsSameV<int, TypeNoCV> ||
       IsSameV<unsigned int, TypeNoCV> || IsSameV<long, TypeNoCV> ||
       IsSameV<unsigned long, TypeNoCV> || IsSameV<long long, TypeNoCV> ||
       IsSameV<unsigned long long, TypeNoCV> || IsSameV<bool, TypeNoCV> ||
-      IsSameV<UInt<128>, TypeNoCV>
+      IsSameV<__llvm_libc::cpp::UInt<128>, TypeNoCV>
 #ifdef __SIZEOF_INT128__
-      || IsSameV<__uint128_t, TypeNoCV> || IsSameV<__int128_t, TypeNoCV>
+      || IsSameV<__uint128_t, TypeNoCV>
 #endif
       ;
 };
 
 template <typename Type> struct IsEnum {
   static constexpr bool Value = __is_enum(Type);
 };
 
 template <typename T> struct IsPointerTypeNoCV : public FalseValue {};

libc/src/__support/CPP/UInt.h

public:
   }
 
   constexpr UInt<Bits> operator<<(size_t s) const {
     UInt<Bits> result(*this);
     result.shift_left(s);
     return result;
   }
 
+  constexpr UInt<Bits> &operator<<=(size_t s) {
+    shift_left(s);
+    return *this;
+  }
+
   constexpr void shift_right(size_t s) {
     const size_t drop = s / 64;  // Number of words to drop
     const size_t shift = s % 64; // Bit shift in the remaining words.
     const uint64_t mask = (uint64_t(1) << shift) - 1;
 
     for (size_t i = 0; drop > 0 && i < WordCount; ++i) {
       if (i + drop < WordCount)
         val[i] = val[i + drop];
public:
   }
 
   constexpr UInt<Bits> operator>>(size_t s) const {
     UInt<Bits> result(*this);
     result.shift_right(s);
     return result;
   }
 
+  constexpr UInt<Bits> &operator>>=(size_t s) {
+    shift_right(s);
+    return *this;
+  }
+
   constexpr UInt<Bits> operator&(const UInt<Bits> &other) const {
     UInt<Bits> result;
     for (size_t i = 0; i < WordCount; ++i)
       result.val[i] = val[i] & other.val[i];
     return result;
   }
 
   constexpr UInt<Bits> operator|(const UInt<Bits> &other) const {
     UInt<Bits> result;
     for (size_t i = 0; i < WordCount; ++i)
       result.val[i] = val[i] | other.val[i];
     return result;
   }
 
   constexpr UInt<Bits> operator^(const UInt<Bits> &other) const {
     UInt<Bits> result;
     for (size_t i = 0; i < WordCount; ++i)
       result.val[i] = val[i] ^ other.val[i];
     return result;
   }
 
+  constexpr UInt<Bits> operator~() const {
+    UInt<Bits> result;
+    for (size_t i = 0; i < WordCount; ++i)
+      result.val[i] = ~val[i];
+    return result;
+  }
+
   constexpr bool operator==(const UInt<Bits> &other) const {
     for (size_t i = 0; i < WordCount; ++i) {
       if (val[i] != other.val[i])
         return false;
     }
     return true;
   }
 
constexpr UInt<128> UInt<128>::operator*(const UInt<128> &other) const {
   result[0] = new_low;
   result[1] = new_high;
   return result;
 }
 
 } // namespace cpp
 } // namespace __llvm_libc
 
-/* TODO: determine the best way to support uint128 using this class.
-#if !defined(__SIZEOF_INT128__)
-using __uint128_t = __llvm_libc::internal::UInt<128>;
-#endif // uint128 is not defined, define it with this class.
-*/
-
 #endif // LLVM_LIBC_UTILS_CPP_UINT_H

libc/src/__support/CPP/UInt128.h

+//===-- A 128 bit unsigned int type -----------------------------*- 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_SRC_SUPPORT_CPP_UINT128_H
+#define LLVM_LIBC_SRC_SUPPORT_CPP_UINT128_H
+
+#include "UInt.h"
+
+#if !defined(__SIZEOF_INT128__)
+using UInt128 = __llvm_libc::internal::UInt<128>;
+#else
+using UInt128 = __uint128_t;
+#endif
+
+#endif // LLVM_LIBC_SRC_SUPPORT_CPP_UINT128_H

libc/src/__support/FPUtil/CMakeLists.txt

 #TODO(michaelrj): separate the fputil library into individual targets.
 add_header_library(
   fputil
   HDRS
     FEnvImpl.h
     BasicOperations.h
     DivisionAndRemainderOperations.h
     FloatProperties.h
     FPBits.h
     BasicOperations.h
     ManipulationFunctions.h
     NearestIntegerOperations.h
     NormalFloat.h
     PlatformDefs.h
-    UInt.h
     builtin_wrappers.h
   DEPENDS
     libc.include.math
     libc.include.errno
     libc.include.fenv
     libc.src.__support.common
-    libc.src.__support.CPP.type_traits
     libc.src.__support.CPP.bit
+    libc.src.__support.CPP.type_traits
+    libc.src.__support.CPP.uint128
     libc.src.errno.errno
 )
 
 add_header_library(
   xfloat
   HDRS
     XFloat.h
   DEPENDS

libc/src/__support/FPUtil/FloatProperties.h

 //===-- Properties of floating point numbers --------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_SUPPORT_FPUTIL_FLOAT_PROPERTIES_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_FLOAT_PROPERTIES_H
 
 #include "PlatformDefs.h"
+
+#include "src/__support/CPP/UInt128.h"
+
 #include <stdint.h>
 
 namespace __llvm_libc {
 namespace fputil {
 
 template <typename T> struct FloatProperties {};
 
 template <> struct FloatProperties<float> {
template <> struct FloatProperties<long double> {
   // Else, it is a signalling NAN.
   static constexpr BitsType QUIET_NAN_MASK =
       FloatProperties<double>::QUIET_NAN_MASK;
 };
 #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;
+  typedef UInt128 BitsType;
   static_assert(sizeof(BitsType) == sizeof(long double),
                 "Unexpected size of 'long double' type.");
 
   static constexpr uint32_t BIT_WIDTH = (sizeof(BitsType) * 8) - 48;
   static constexpr BitsType FULL_WIDTH_MASK = ((BitsType(1) << BIT_WIDTH) - 1);
 
   static constexpr uint32_t MANTISSA_WIDTH = 63;
   static constexpr uint32_t EXPONENT_WIDTH = 15;
template <> struct FloatProperties<long double> {
   // Else, it is a signalling NAN.
   static constexpr BitsType QUIET_NAN_MASK = BitsType(1)
                                              << (MANTISSA_WIDTH - 1);
 };
 #else
 // Properties for numbers represented in 128 bits long double on non x86
 // platform.
 template <> struct FloatProperties<long double> {
-  typedef __uint128_t BitsType;
+  typedef UInt128 BitsType;
   static_assert(sizeof(BitsType) == sizeof(long double),
                 "Unexpected size of 'long double' type.");
 
   static constexpr uint32_t BIT_WIDTH = sizeof(BitsType) << 3;
 
   static constexpr uint32_t MANTISSA_WIDTH = 112;
   static constexpr uint32_t EXPONENT_WIDTH = 15;
   static constexpr BitsType MANTISSA_MASK = (BitsType(1) << MANTISSA_WIDTH) - 1;

libc/src/__support/FPUtil/Hypot.h

 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_HYPOT_H
 
 #include "BasicOperations.h"
 #include "FEnvImpl.h"
 #include "FPBits.h"
 #include "builtin_wrappers.h"
 #include "src/__support/CPP/Bit.h"
 #include "src/__support/CPP/TypeTraits.h"
+#include "src/__support/CPP/UInt128.h"
 
 namespace __llvm_libc {
 namespace fputil {
 
 namespace internal {
 
 template <typename T>
 static inline T find_leading_one(T mant, int &shift_length) {
   shift_length = 0;
   if (mant > 0) {
     shift_length = (sizeof(mant) * 8) - 1 - clz(mant);
   }
   return T(1) << shift_length;
 }
 
 } // namespace internal
 
 template <typename T> struct DoubleLength;
 
 template <> struct DoubleLength<uint16_t> { using Type = uint32_t; };
 
 template <> struct DoubleLength<uint32_t> { using Type = uint64_t; };
 
-template <> struct DoubleLength<uint64_t> { using Type = __uint128_t; };
+template <> struct DoubleLength<uint64_t> {
+  using Type = UInt128;
+};
 
 // Correctly rounded IEEE 754 HYPOT(x, y) with round to nearest, ties to even.
 //
 // Algorithm:
 //   -  Let a = max(|x|, |y|), b = min(|x|, |y|), then we have that:
 //          a <= sqrt(a^2 + b^2) <= min(a + b, a*sqrt(2))
 //   1. So if b < eps(a)/2, then HYPOT(x, y) = a.
 //

libc/src/__support/FPUtil/generic/CMakeLists.txt

 add_header_library(
   sqrt
   HDRS
     sqrt.h
     sqrt_80_bit_long_double.h
+  DEPENDS
+    libc.src.__support.CPP.uint128
 )
 
 add_header_library(
   fma
   HDRS
     FMA.h
+  DEPENDS
+    libc.src.__support.CPP.uint128
 )

libc/src/__support/FPUtil/generic/FMA.h

 //===-- Common header for FMA implementations -------------------*- 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_SRC_SUPPORT_FPUTIL_GENERIC_FMA_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_GENERIC_FMA_H
 
 #include "src/__support/CPP/Bit.h"
 #include "src/__support/CPP/TypeTraits.h"
+#include "src/__support/CPP/UInt128.h"
 #include "src/__support/FPUtil/FEnvImpl.h"
 #include "src/__support/FPUtil/FPBits.h"
 #include "src/__support/FPUtil/FloatProperties.h"
 #include "src/__support/FPUtil/builtin_wrappers.h"
 #include "src/__support/common.h"
 
 namespace __llvm_libc {
 namespace fputil {
template <> inline float fma<float>(float x, float y, float z) {
 
   return static_cast<float>(static_cast<double>(bit_sum));
 }
 
 namespace internal {
 
 // Extract the sticky bits and shift the `mantissa` to the right by
 // `shift_length`.
-static inline bool shift_mantissa(int shift_length, __uint128_t &mant) {
+static inline bool shift_mantissa(int shift_length, UInt128 &mant) {
   if (shift_length >= 128) {
     mant = 0;
     return true; // prod_mant is non-zero.
   }
-  __uint128_t mask = (__uint128_t(1) << shift_length) - 1;
+  UInt128 mask = (UInt128(1) << shift_length) - 1;
   bool sticky_bits = (mant & mask) != 0;
   mant >>= shift_length;
   return sticky_bits;
 }
 
 } // namespace internal
 
 template <> inline double fma<double>(double x, double y, double z) {
template <> inline double fma<double>(double x, double y, double z) {
   y_exp += y_bits.get_unbiased_exponent();
   z_exp += z_bits.get_unbiased_exponent();
 
   if (unlikely(x_exp == FPBits::MAX_EXPONENT || y_exp == FPBits::MAX_EXPONENT ||
                z_exp == FPBits::MAX_EXPONENT))
     return x * y + z;
 
   // Extract mantissa and append hidden leading bits.
-  __uint128_t x_mant = x_bits.get_mantissa() | FPBits::MIN_NORMAL;
-  __uint128_t y_mant = y_bits.get_mantissa() | FPBits::MIN_NORMAL;
-  __uint128_t z_mant = z_bits.get_mantissa() | FPBits::MIN_NORMAL;
+  UInt128 x_mant = x_bits.get_mantissa() | FPBits::MIN_NORMAL;
+  UInt128 y_mant = y_bits.get_mantissa() | FPBits::MIN_NORMAL;
+  UInt128 z_mant = z_bits.get_mantissa() | FPBits::MIN_NORMAL;
 
   // If the exponent of the product x*y > the exponent of z, then no extra
   // precision beside the entire product x*y is needed.  On the other hand, when
   // the exponent of z >= the exponent of the product x*y, the worst-case that
   // we need extra precision is when there is cancellation and the most
   // significant bit of the product is aligned exactly with the second most
   // significant bit of z:
   //      z :    10aa...a
   // - prod :     1bb...bb....b
   // In that case, in order to store the exact result, we need at least
   //   (Length of prod) - (MantissaLength of z) = 2*(52 + 1) - 52 = 54.
   // Overall, before aligning the mantissas and exponents, we can simply left-
   // shift the mantissa of z by at least 54, and left-shift the product of x*y
   // by (that amount - 52).  After that, it is enough to align the least
   // significant bit, given that we keep track of the round and sticky bits
   // after the least significant bit.
   // We pick shifting z_mant by 64 bits so that technically we can simply use
   // the original mantissa as high part when constructing 128-bit z_mant. So the
   // mantissa of prod will be left-shifted by 64 - 54 = 10 initially.
 
-  __uint128_t prod_mant = x_mant * y_mant << 10;
+  UInt128 prod_mant = x_mant * y_mant << 10;
   int prod_lsb_exp =
       x_exp + y_exp -
       (FPBits::EXPONENT_BIAS + 2 * MantissaWidth<double>::VALUE + 10);
 
   z_mant <<= 64;
   int z_lsb_exp = z_exp - (MantissaWidth<double>::VALUE + 64);
   bool round_bit = false;
   bool sticky_bits = false;

libc/src/__support/FPUtil/generic/sqrt.h

 //===-- Square root of IEEE 754 floating point numbers ----------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_SUPPORT_FPUTIL_GENERIC_SQRT_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_GENERIC_SQRT_H
 
 #include "sqrt_80_bit_long_double.h"
 #include "src/__support/CPP/Bit.h"
 #include "src/__support/CPP/TypeTraits.h"
+#include "src/__support/CPP/UInt128.h"
 #include "src/__support/FPUtil/FEnvImpl.h"
 #include "src/__support/FPUtil/FPBits.h"
 #include "src/__support/FPUtil/PlatformDefs.h"
 #include "src/__support/FPUtil/builtin_wrappers.h"
 
 namespace __llvm_libc {
 namespace fputil {
 

 
 #ifdef LONG_DOUBLE_IS_DOUBLE
 template <>
 inline void normalize<long double>(int &exponent, uint64_t &mantissa) {
   normalize<double>(exponent, mantissa);
 }
 #elif !defined(SPECIAL_X86_LONG_DOUBLE)
 template <>
-inline void normalize<long double>(int &exponent, __uint128_t &mantissa) {
+inline void normalize<long double>(int &exponent, UInt128 &mantissa) {
   const uint64_t hi_bits = static_cast<uint64_t>(mantissa >> 64);
   const int shift = hi_bits ? (clz(hi_bits) - 15)
                             : (clz(static_cast<uint64_t>(mantissa)) + 49);
   exponent -= shift;
   mantissa <<= shift;
 }
 #endif
 

libc/src/__support/FPUtil/generic/sqrt_80_bit_long_double.h

 //===-- Square root of x86 long double numbers ------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_SUPPORT_FPUTIL_GENERIC_SQRT_80_BIT_LONG_DOUBLE_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_GENERIC_SQRT_80_BIT_LONG_DOUBLE_H
 
+#include "src/__support/CPP/UInt128.h"
 #include "src/__support/FPUtil/FEnvImpl.h"
 #include "src/__support/FPUtil/FPBits.h"
 #include "src/__support/FPUtil/PlatformDefs.h"
 #include "src/__support/FPUtil/builtin_wrappers.h"
 
 namespace __llvm_libc {
 namespace fputil {
 namespace x86 {
 
-inline void normalize(int &exponent, __uint128_t &mantissa) {
+inline void normalize(int &exponent, UInt128 &mantissa) {
   const int shift =
       clz(static_cast<uint64_t>(mantissa)) -
       (8 * sizeof(uint64_t) - 1 - MantissaWidth<long double>::VALUE);
   exponent -= shift;
   mantissa <<= shift;
 }
 
 // if constexpr statement in sqrt.h still requires x86::sqrt to be declared

libc/src/__support/FPUtil/x86_64/LongDoubleBits.h

 //===-- Bit representation of x86 long double numbers -----------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_SUPPORT_FPUTIL_X86_64_LONG_DOUBLE_BITS_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_X86_64_LONG_DOUBLE_BITS_H
 
 #include "src/__support/CPP/Bit.h"
+#include "src/__support/CPP/UInt128.h"
 #include "src/__support/architectures.h"
 
 #if !defined(LLVM_LIBC_ARCH_X86)
 #error "Invalid include"
 #endif
 
 #include "src/__support/FPUtil/FPBits.h"
 
 #include <stdint.h>
 
 namespace __llvm_libc {
 namespace fputil {
 
 template <unsigned Width> struct Padding;
 
 // i386 padding.
 template <> struct Padding<4> { static constexpr unsigned VALUE = 16; };
 
 // x86_64 padding.
 template <> struct Padding<8> { static constexpr unsigned VALUE = 48; };
 
 template <> struct FPBits<long double> {
-  using UIntType = __uint128_t;
+  using UIntType = UInt128;
 
   static constexpr int EXPONENT_BIAS = 0x3FFF;
   static constexpr int MAX_EXPONENT = 0x7FFF;
   static constexpr UIntType MIN_SUBNORMAL = UIntType(1);
   // Subnormal numbers include the implicit bit in x86 long double formats.
   static constexpr UIntType MAX_SUBNORMAL =
       (UIntType(1) << (MantissaWidth<long double>::VALUE)) - 1;
   static constexpr UIntType MIN_NORMAL =

libc/src/__support/str_to_float.h

 //===-- String to float conversion utils ------------------------*- 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 LIBC_SRC_SUPPORT_STR_TO_FLOAT_H
 #define LIBC_SRC_SUPPORT_STR_TO_FLOAT_H
 
 #include "src/__support/CPP/Limits.h"
+#include "src/__support/CPP/UInt128.h"
 #include "src/__support/FPUtil/FPBits.h"
 #include "src/__support/FPUtil/builtin_wrappers.h"
 #include "src/__support/ctype_utils.h"
 #include "src/__support/detailed_powers_of_ten.h"
 #include "src/__support/high_precision_decimal.h"
 #include "src/__support/str_to_integer.h"
 #include <errno.h>
 

 template <> uint32_t inline leading_zeroes<uint32_t>(uint32_t inputNumber) {
   return inputNumber == 0 ? 32 : fputil::clz(inputNumber);
 }
 
 template <> uint32_t inline leading_zeroes<uint64_t>(uint64_t inputNumber) {
   return inputNumber == 0 ? 64 : fputil::clz(inputNumber);
 }
 
-static inline uint64_t low64(__uint128_t num) {
+static inline uint64_t low64(const UInt128 &num) {
   return static_cast<uint64_t>(num & 0xffffffffffffffff);
 }
 
-static inline uint64_t high64(__uint128_t num) {
+static inline uint64_t high64(const UInt128 &num) {
   return static_cast<uint64_t>(num >> 64);
 }
 
 template <class T> inline void set_implicit_bit(fputil::FPBits<T> &result) {
   return;
 }
 
 #if defined(SPECIAL_X86_LONG_DOUBLE)
eisel_lemire(typename fputil::FPBits<T>::UIntType mantissa, int32_t exp10,
 
   uint32_t exp2 = exp10_to_exp2(exp10) + BITS_IN_MANTISSA +
                   fputil::FloatProperties<T>::EXPONENT_BIAS - clz;
 
   // Multiplication
   const uint64_t *power_of_ten =
       DETAILED_POWERS_OF_TEN[exp10 - DETAILED_POWERS_OF_TEN_MIN_EXP_10];
 
-  __uint128_t first_approx = static_cast<__uint128_t>(mantissa) *
-                             static_cast<__uint128_t>(power_of_ten[1]);
+  UInt128 first_approx =
+      static_cast<UInt128>(mantissa) * static_cast<UInt128>(power_of_ten[1]);
 
   // Wider Approximation
-  __uint128_t final_approx;
+  UInt128 final_approx;
   // The halfway constant is used to check if the bits that will be shifted away
   // intially are all 1. For doubles this is 64 (bitstype size) - 52 (final
   // mantissa size) - 3 (we shift away the last two bits separately for
   // accuracy, and the most significant bit is ignored.) = 9 bits. Similarly,
   // it's 6 bits for floats in this case.
   const uint64_t halfway_constant =
       (uint64_t(1) << (BITS_IN_MANTISSA -
                        fputil::FloatProperties<T>::MANTISSA_WIDTH - 3)) -
       1;
   if ((high64(first_approx) & halfway_constant) == halfway_constant &&
       low64(first_approx) + mantissa < mantissa) {
-    __uint128_t low_bits = static_cast<__uint128_t>(mantissa) *
-                           static_cast<__uint128_t>(power_of_ten[0]);
-    __uint128_t second_approx =
-        first_approx + static_cast<__uint128_t>(high64(low_bits));
+    UInt128 low_bits =
+        static_cast<UInt128>(mantissa) * static_cast<UInt128>(power_of_ten[0]);
+    UInt128 second_approx =
+        first_approx + static_cast<UInt128>(high64(low_bits));
 
     if ((high64(second_approx) & halfway_constant) == halfway_constant &&
         low64(second_approx) + 1 == 0 &&
         low64(low_bits) + mantissa < mantissa) {
       return false;
     }
     final_approx = second_approx;
   } else {
inline bool eisel_lemire<long double>(
   // Multiplication
   const uint64_t *power_of_ten =
       DETAILED_POWERS_OF_TEN[exp10 - DETAILED_POWERS_OF_TEN_MIN_EXP_10];
 
   // Since the input mantissa is more than 64 bits, we have to multiply with the
   // full 128 bits of the power of ten to get an approximation with the same
   // number of significant bits. This means that we only get the one
   // approximation, and that approximation is 256 bits long.
-  __uint128_t approx_upper = static_cast<__uint128_t>(high64(mantissa)) *
-                             static_cast<__uint128_t>(power_of_ten[1]);
+  UInt128 approx_upper = static_cast<UInt128>(high64(mantissa)) *
+                         static_cast<UInt128>(power_of_ten[1]);
 
-  __uint128_t approx_middle = static_cast<__uint128_t>(high64(mantissa)) *
-                                  static_cast<__uint128_t>(power_of_ten[0]) +
-                              static_cast<__uint128_t>(low64(mantissa)) *
-                                  static_cast<__uint128_t>(power_of_ten[1]);
-
-  __uint128_t approx_lower = static_cast<__uint128_t>(low64(mantissa)) *
-                             static_cast<__uint128_t>(power_of_ten[0]);
-
-  __uint128_t final_approx_lower =
-      approx_lower + (static_cast<__uint128_t>(low64(approx_middle)) << 64);
-  __uint128_t final_approx_upper = approx_upper + high64(approx_middle) +
-                                   (final_approx_lower < approx_lower ? 1 : 0);
+  UInt128 approx_middle = static_cast<UInt128>(high64(mantissa)) *
+                              static_cast<UInt128>(power_of_ten[0]) +
+                          static_cast<UInt128>(low64(mantissa)) *
+                              static_cast<UInt128>(power_of_ten[1]);
+
+  UInt128 approx_lower = static_cast<UInt128>(low64(mantissa)) *
+                         static_cast<UInt128>(power_of_ten[0]);
+
+  UInt128 final_approx_lower =
+      approx_lower + (static_cast<UInt128>(low64(approx_middle)) << 64);
+  UInt128 final_approx_upper = approx_upper + high64(approx_middle) +
 
   // The halfway constant is used to check if the bits that will be shifted away
   // intially are all 1. For 80 bit floats this is 128 (bitstype size) - 64
   // (final mantissa size) - 3 (we shift away the last two bits separately for
   // accuracy, and the most significant bit is ignored.) = 61 bits. Similarly,
   // it's 12 bits for 128 bit floats in this case.
-  constexpr __uint128_t HALFWAY_CONSTANT =
-      (__uint128_t(1) << (BITS_IN_MANTISSA -
-                          fputil::FloatProperties<long double>::MANTISSA_WIDTH -
-                          3)) -
+  constexpr UInt128 HALFWAY_CONSTANT =
+      (UInt128(1) << (BITS_IN_MANTISSA -
       1;
 
   if ((final_approx_upper & HALFWAY_CONSTANT) == HALFWAY_CONSTANT &&
       final_approx_lower + mantissa < mantissa) {
     return false;
   }
 
   // Shifting to 65 bits for 80 bit floats and 113 bits for 128 bit floats

libc/test/src/__support/CMakeLists.txt

 add_libc_unittest(
   high_precision_decimal_test
   SUITE
     libc_support_unittests
   SRCS
   high_precision_decimal_test.cpp
   DEPENDS
     libc.src.__support.high_precision_decimal
+    libc.src.__support.CPP.uint128
 )
 
 add_libc_unittest(
   str_to_float_test
   SUITE
     libc_support_unittests
   SRCS
     str_to_float_test.cpp
   DEPENDS
     libc.src.__support.str_to_float
+    libc.src.__support.CPP.uint128
 )
 
 add_libc_unittest(
   arg_list_test
   SUITE
     libc_support_unittests
   SRCS
     arg_list_test.cpp

libc/test/src/__support/CPP/CMakeLists.txt

 add_libc_unittest(
   limits_test
   SUITE
     libc_cpp_utils_unittests
   SRCS
     limits_test.cpp
   DEPENDS
     libc.src.__support.CPP.limits
+    libc.src.__support.CPP.uint
 )
 
 add_libc_unittest(
   arrayref_test
   SUITE
     libc_cpp_utils_unittests
   SRCS
     arrayref_test.cpp

libc/test/src/__support/CPP/limits_test.cpp

 //===-- Unittests for Limits ----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/__support/CPP/Limits.h"
+#include "src/__support/CPP/UInt.h"
 #include "utils/UnitTest/Test.h"
 
 // This just checks against the C spec, almost all implementations will surpass
 // this.
 TEST(LlvmLibcLimitsTest, LimitsFollowSpec) {
   ASSERT_EQ(__llvm_libc::cpp::NumericLimits<int>::max(), INT_MAX);
   ASSERT_EQ(__llvm_libc::cpp::NumericLimits<int>::min(), INT_MIN);
 
   ASSERT_EQ(__llvm_libc::cpp::NumericLimits<unsigned int>::max(), UINT_MAX);
 
   ASSERT_EQ(__llvm_libc::cpp::NumericLimits<long>::max(), LONG_MAX);
   ASSERT_EQ(__llvm_libc::cpp::NumericLimits<long>::min(), LONG_MIN);
 
   ASSERT_EQ(__llvm_libc::cpp::NumericLimits<unsigned long>::max(), ULONG_MAX);
 
   ASSERT_EQ(__llvm_libc::cpp::NumericLimits<long long>::max(), LLONG_MAX);
   ASSERT_EQ(__llvm_libc::cpp::NumericLimits<long long>::min(), LLONG_MIN);
 
   ASSERT_EQ(__llvm_libc::cpp::NumericLimits<unsigned long long>::max(),
             ULLONG_MAX);
 }
 
+TEST(LlvmLibcLimitsTest, UInt128Limits) {
+  auto umax128 =
+      __llvm_libc::cpp::NumericLimits<__llvm_libc::cpp::UInt<128>>::max();
+  auto umax64 = __llvm_libc::cpp::UInt<128>(
+      __llvm_libc::cpp::NumericLimits<uint64_t>::max());
+  EXPECT_GT(umax128, umax64);
+  ASSERT_EQ(~__llvm_libc::cpp::UInt<128>(0), umax128);
 #ifdef __SIZEOF_INT128__
-// This checks that the current environment supports 128 bit integers.
-TEST(LlvmLibcLimitsTest, Int128Works) {
-  __int128_t max128 = ~__uint128_t(0) >> 1;
-  __int128_t min128 = (__int128_t(1) << 127);
-  EXPECT_GT(__llvm_libc::cpp::NumericLimits<__int128_t>::max(),
-            __int128_t(__llvm_libc::cpp::NumericLimits<long long>::max()));
-  ASSERT_EQ(__llvm_libc::cpp::NumericLimits<__int128_t>::max(), max128);
-
-  EXPECT_LT(__llvm_libc::cpp::NumericLimits<__int128_t>::min(),
-            __int128_t(__llvm_libc::cpp::NumericLimits<long long>::min()));
-  ASSERT_EQ(__llvm_libc::cpp::NumericLimits<__int128_t>::min(), min128);
-
-  __uint128_t umax128 = ~__uint128_t(0);
-  EXPECT_GT(
-      __llvm_libc::cpp::NumericLimits<__uint128_t>::max(),
-      __uint128_t(__llvm_libc::cpp::NumericLimits<unsigned long long>::max()));
-  ASSERT_EQ(__llvm_libc::cpp::NumericLimits<__uint128_t>::max(), umax128);
-}
+  ASSERT_EQ(~__uint128_t(0),
+            __llvm_libc::cpp::NumericLimits<__uint128_t>::max());
 #endif
+}

libc/test/src/__support/high_precision_decimal_test.cpp

 //===-- Unittests for high_precision_decimal ------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "src/__support/CPP/UInt128.h"
 #include "src/__support/high_precision_decimal.h"
 
 #include "utils/UnitTest/Test.h"
 
 TEST(LlvmLibcHighPrecisionDecimalTest, BasicInit) {
   __llvm_libc::internal::HighPrecisionDecimal hpd =
       __llvm_libc::internal::HighPrecisionDecimal("1.2345");
   uint8_t *digits = hpd.get_digits();

 }
 
 TEST(LlvmLibcHighPrecisionDecimalTest, RoundingTest) {
   __llvm_libc::internal::HighPrecisionDecimal hpd =
       __llvm_libc::internal::HighPrecisionDecimal("1.2345");
 
   EXPECT_EQ(hpd.round_to_integer_type<uint32_t>(), uint32_t(1));
   EXPECT_EQ(hpd.round_to_integer_type<uint64_t>(), uint64_t(1));
-#ifdef __SIZEOF_INT128__
-  EXPECT_EQ(hpd.round_to_integer_type<__uint128_t>(), __uint128_t(1));
-#endif
+  EXPECT_EQ(hpd.round_to_integer_type<UInt128>(), UInt128(1));
 
   hpd.shift(1); // shift left 1 to get 2.469 (rounds to 2)
 
   EXPECT_EQ(hpd.round_to_integer_type<uint32_t>(), uint32_t(2));
   EXPECT_EQ(hpd.round_to_integer_type<uint64_t>(), uint64_t(2));
 #ifdef __SIZEOF_INT128__
-  EXPECT_EQ(hpd.round_to_integer_type<__uint128_t>(), __uint128_t(2));
+  EXPECT_EQ(hpd.round_to_integer_type<UInt128>(), UInt128(2));
 #endif
 
   hpd.shift(1); // shift left 1 to get 4.938 (rounds to 5)
 
   EXPECT_EQ(hpd.round_to_integer_type<uint32_t>(), uint32_t(5));
   EXPECT_EQ(hpd.round_to_integer_type<uint64_t>(), uint64_t(5));
 #ifdef __SIZEOF_INT128__
-  EXPECT_EQ(hpd.round_to_integer_type<__uint128_t>(), __uint128_t(5));
+  EXPECT_EQ(hpd.round_to_integer_type<UInt128>(), UInt128(5));
 #endif
 
   // 2.5 is right between two integers, so we round to even (2)
   hpd = __llvm_libc::internal::HighPrecisionDecimal("2.5");
 
   EXPECT_EQ(hpd.round_to_integer_type<uint32_t>(), uint32_t(2));
   EXPECT_EQ(hpd.round_to_integer_type<uint64_t>(), uint64_t(2));
 #ifdef __SIZEOF_INT128__
-  EXPECT_EQ(hpd.round_to_integer_type<__uint128_t>(), __uint128_t(2));
+  EXPECT_EQ(hpd.round_to_integer_type<UInt128>(), UInt128(2));
 #endif
 
   // unless it's marked as having truncated, which means it's actually slightly
   // higher, forcing a round up (3)
   hpd.set_truncated(true);
 
   EXPECT_EQ(hpd.round_to_integer_type<uint32_t>(), uint32_t(3));
   EXPECT_EQ(hpd.round_to_integer_type<uint64_t>(), uint64_t(3));
 #ifdef __SIZEOF_INT128__
-  EXPECT_EQ(hpd.round_to_integer_type<__uint128_t>(), __uint128_t(3));
+  EXPECT_EQ(hpd.round_to_integer_type<UInt128>(), UInt128(3));
 #endif
 
   // Check that the larger int types are being handled properly (overflow is not
   // handled, so int types that are too small are ignored for this test.)
 
   // 1099511627776 = 2^40
   hpd = __llvm_libc::internal::HighPrecisionDecimal("1099511627776");
 
   EXPECT_EQ(hpd.round_to_integer_type<uint64_t>(), uint64_t(1099511627776));
 #ifdef __SIZEOF_INT128__
-  EXPECT_EQ(hpd.round_to_integer_type<__uint128_t>(),
-            __uint128_t(1099511627776));
+  EXPECT_EQ(hpd.round_to_integer_type<UInt128>(), UInt128(1099511627776));
 
   // 1267650600228229401496703205376 = 2^100
   hpd = __llvm_libc::internal::HighPrecisionDecimal(
       "1267650600228229401496703205376");
 
-  __uint128_t result = __uint128_t(1) << 100;
+  UInt128 result = UInt128(1) << 100;
 
-  EXPECT_EQ(hpd.round_to_integer_type<__uint128_t>(), result);
+  EXPECT_EQ(hpd.round_to_integer_type<UInt128>(), result);
 #endif
 }

libc/test/src/__support/str_to_float_test.cpp

 //===-- Unittests for str_to_float ----------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "src/__support/CPP/UInt128.h"
 #include "src/__support/FPUtil/FPBits.h"
 #include "src/__support/str_to_float.h"
 
 #include "utils/UnitTest/Test.h"
 
 class LlvmLibcStrToFloatTest : public __llvm_libc::testing::Test {
 public:
   template <class T>

 #elif defined(SPECIAL_X86_LONG_DOUBLE)
 TEST_F(LlvmLibcStrToFloatTest, EiselLemireFloat80Simple) {
   eisel_lemire_test<long double>(123, 0, 0xf600000000000000, 16389);
   eisel_lemire_test<long double>(12345678901234568192u, 0, 0xab54a98ceb1f0c00,
                                  16446);
 }
 
 TEST_F(LlvmLibcStrToFloatTest, EiselLemireFloat80LongerMantissa) {
-  eisel_lemire_test<long double>((__uint128_t(0x1234567812345678) << 64) +
-                                     __uint128_t(0x1234567812345678),
+  eisel_lemire_test<long double>((UInt128(0x1234567812345678) << 64) +
+                                     UInt128(0x1234567812345678),
                                  0, 0x91a2b3c091a2b3c1, 16507);
-  eisel_lemire_test<long double>((__uint128_t(0x1234567812345678) << 64) +
-                                     __uint128_t(0x1234567812345678),
+  eisel_lemire_test<long double>((UInt128(0x1234567812345678) << 64) +
+                                     UInt128(0x1234567812345678),
                                  300, 0xd97757de56adb65c, 17503);
-  eisel_lemire_test<long double>((__uint128_t(0x1234567812345678) << 64) +
-                                     __uint128_t(0x1234567812345678),
+  eisel_lemire_test<long double>((UInt128(0x1234567812345678) << 64) +
+                                     UInt128(0x1234567812345678),
                                  -300, 0xc30feb9a7618457d, 15510);
 }
 
 // These tests check numbers at the edge of the DETAILED_POWERS_OF_TEN table.
 // This doesn't reach very far into the range for long doubles, since it's sized
 // for doubles and their 11 exponent bits, and not for long doubles and their
 // 15 exponent bits. This is a known tradeoff, and was made because a proper
 // long double table would be approximately 16 times longer (specifically the
 // maximum exponent would need to be about 5000, leading to a 10,000 entry
 // table). This would have significant memory and storage costs all the time to
 // speed up a relatively uncommon path.
 TEST_F(LlvmLibcStrToFloatTest, EiselLemireFloat80TableLimits) {
   eisel_lemire_test<long double>(1, 347, 0xd13eb46469447567, 17535);
   eisel_lemire_test<long double>(1, -348, 0xfa8fd5a0081c0288, 15226);
 }
 
 TEST_F(LlvmLibcStrToFloatTest, EiselLemireFloat80Fallback) {
   uint32_t outputExp2 = 0;
-  __uint128_t quadOutputMantissa = 0;
+  UInt128 quadOutputMantissa = 0;
 
   // This number is halfway between two possible results, and the algorithm
   // can't determine which is correct.
   ASSERT_FALSE(__llvm_libc::internal::eisel_lemire<long double>(
       12345678901234567890u, 1, &quadOutputMantissa, &outputExp2));
 
   // These numbers' exponents are out of range for the current powers of ten
   // table.
   ASSERT_FALSE(__llvm_libc::internal::eisel_lemire<long double>(
       1, 1000, &quadOutputMantissa, &outputExp2));
   ASSERT_FALSE(__llvm_libc::internal::eisel_lemire<long double>(
       1, -1000, &quadOutputMantissa, &outputExp2));
 }
 #elif defined(__SIZEOF_INT128__)
 TEST_F(LlvmLibcStrToFloatTest, EiselLemireFloat128Simple) {
-  eisel_lemire_test<long double>(123, 0, (__uint128_t(0x1ec0000000000) << 64),
+  eisel_lemire_test<long double>(123, 0, (UInt128(0x1ec0000000000) << 64),
                                  16389);
-  eisel_lemire_test<long double>(12345678901234568192u, 0,
-                                 (__uint128_t(0x156a95319d63e) << 64) +
-                                     __uint128_t(0x1800000000000000),
-                                 16446);
+  eisel_lemire_test<long double>(
+      12345678901234568192u, 0,
+      (UInt128(0x156a95319d63e) << 64) + UInt128(0x1800000000000000), 16446);
 }
 
 TEST_F(LlvmLibcStrToFloatTest, EiselLemireFloat128LongerMantissa) {
   eisel_lemire_test<long double>(
-      (__uint128_t(0x1234567812345678) << 64) + __uint128_t(0x1234567812345678),
-      0, (__uint128_t(0x1234567812345) << 64) + __uint128_t(0x6781234567812345),
-      16507);
+      (UInt128(0x1234567812345678) << 64) + UInt128(0x1234567812345678), 0,
+      (UInt128(0x1234567812345) << 64) + UInt128(0x6781234567812345), 16507);
   eisel_lemire_test<long double>(
-      (__uint128_t(0x1234567812345678) << 64) + __uint128_t(0x1234567812345678),
-      300,
-      (__uint128_t(0x1b2eeafbcad5b) << 64) + __uint128_t(0x6cb8b4451dfcde19),
-      17503);
+      (UInt128(0x1234567812345678) << 64) + UInt128(0x1234567812345678), 300,
+      (UInt128(0x1b2eeafbcad5b) << 64) + UInt128(0x6cb8b4451dfcde19), 17503);
   eisel_lemire_test<long double>(
-      (__uint128_t(0x1234567812345678) << 64) + __uint128_t(0x1234567812345678),
-      -300,
-      (__uint128_t(0x1861fd734ec30) << 64) + __uint128_t(0x8afa7189f0f7595f),
-      15510);
+      (UInt128(0x1234567812345678) << 64) + UInt128(0x1234567812345678), -300,
+      (UInt128(0x1861fd734ec30) << 64) + UInt128(0x8afa7189f0f7595f), 15510);
 }
 
 TEST_F(LlvmLibcStrToFloatTest, EiselLemireFloat128Fallback) {
   uint32_t outputExp2 = 0;
-  __uint128_t quadOutputMantissa = 0;
+  UInt128 quadOutputMantissa = 0;
 
   ASSERT_FALSE(__llvm_libc::internal::eisel_lemire<long double>(
-      (__uint128_t(0x5ce0e9a56015fec5) << 64) + __uint128_t(0xaadfa328ae39b333),
-      1, &quadOutputMantissa, &outputExp2));
+      (UInt128(0x5ce0e9a56015fec5) << 64) + UInt128(0xaadfa328ae39b333), 1,
+      &quadOutputMantissa, &outputExp2));
 }
 #endif

libc/test/src/__support/uint128_test.cpp

 //===-- Unittests for the 128 bit integer class ---------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/__support/CPP/UInt.h"
 
 #include "utils/UnitTest/Test.h"
 
-using UInt128 = __llvm_libc::cpp::UInt<128>;
+// We want to test __llvm_libc::cpp::UInt<128> explicitly. So, for convenience,
+// we use a sugar which does not conflict with the UInt128 type which can
+// resolve to __uint128_t if the platform has it.
+using LL_UInt128 = __llvm_libc::cpp::UInt<128>;
 
 TEST(LlvmLibcUInt128ClassTest, BasicInit) {
-  UInt128 empty;
-  UInt128 half_val(12345);
-  UInt128 full_val({12345, 67890});
+  LL_UInt128 empty;
+  LL_UInt128 half_val(12345);
+  LL_UInt128 full_val({12345, 67890});
   ASSERT_TRUE(half_val != full_val);
 }
 
 TEST(LlvmLibcUInt128ClassTest, AdditionTests) {
-  UInt128 val1(12345);
-  UInt128 val2(54321);
-  UInt128 result1(66666);
+  LL_UInt128 val1(12345);
+  LL_UInt128 val2(54321);
+  LL_UInt128 result1(66666);
   EXPECT_EQ(val1 + val2, result1);
   EXPECT_EQ((val1 + val2), (val2 + val1)); // addition is reciprocal
 
   // Test overflow
-  UInt128 val3({0xf000000000000001, 0});
-  UInt128 val4({0x100000000000000f, 0});
-  UInt128 result2({0x10, 0x1});
+  LL_UInt128 val3({0xf000000000000001, 0});
+  LL_UInt128 val4({0x100000000000000f, 0});
+  LL_UInt128 result2({0x10, 0x1});
   EXPECT_EQ(val3 + val4, result2);
   EXPECT_EQ(val3 + val4, val4 + val3);
 }
 
 TEST(LlvmLibcUInt128ClassTest, MultiplicationTests) {
-  UInt128 val1({5, 0});
-  UInt128 val2({10, 0});
-  UInt128 result1({50, 0});
+  LL_UInt128 val1({5, 0});
+  LL_UInt128 val2({10, 0});
+  LL_UInt128 result1({50, 0});
   EXPECT_EQ((val1 * val2), result1);
   EXPECT_EQ((val1 * val2), (val2 * val1)); // multiplication is reciprocal
 
   // Check that the multiplication works accross the whole number
-  UInt128 val3({0xf, 0});
-  UInt128 val4({0x1111111111111111, 0x1111111111111111});
-  UInt128 result2({0xffffffffffffffff, 0xffffffffffffffff});
+  LL_UInt128 val3({0xf, 0});
+  LL_UInt128 val4({0x1111111111111111, 0x1111111111111111});
+  LL_UInt128 result2({0xffffffffffffffff, 0xffffffffffffffff});
   EXPECT_EQ((val3 * val4), result2);
   EXPECT_EQ((val3 * val4), (val4 * val3));
 
   // Check that multiplication doesn't reorder the bits.
-  UInt128 val5({2, 0});
-  UInt128 val6({0x1357024675316420, 0x0123456776543210});
-  UInt128 result3({0x26ae048cea62c840, 0x02468aceeca86420});
+  LL_UInt128 val5({2, 0});
+  LL_UInt128 val6({0x1357024675316420, 0x0123456776543210});
+  LL_UInt128 result3({0x26ae048cea62c840, 0x02468aceeca86420});
 
   EXPECT_EQ((val5 * val6), result3);
   EXPECT_EQ((val5 * val6), (val6 * val5));
 
   // Make sure that multiplication handles overflow correctly.
-  UInt128 val7(2);
-  UInt128 val8({0x8000800080008000, 0x8000800080008000});
-  UInt128 result4({0x0001000100010000, 0x0001000100010001});
+  LL_UInt128 val7(2);
+  LL_UInt128 val8({0x8000800080008000, 0x8000800080008000});
+  LL_UInt128 result4({0x0001000100010000, 0x0001000100010001});
   EXPECT_EQ((val7 * val8), result4);
   EXPECT_EQ((val7 * val8), (val8 * val7));
 
   // val9 is the 128 bit mantissa of 1e60 as a float, val10 is the mantissa for
   // 1e-60. They almost cancel on the high bits, but the result we're looking
   // for is just the low bits. The full result would be
   // 0x7fffffffffffffffffffffffffffffff3a4f32d17f40d08f917cf11d1e039c50
-  UInt128 val9({0x01D762422C946590, 0x9F4F2726179A2245});
-  UInt128 val10({0x3792F412CB06794D, 0xCDB02555653131B6});
-  UInt128 result5({0x917cf11d1e039c50, 0x3a4f32d17f40d08f});
+  LL_UInt128 val9({0x01D762422C946590, 0x9F4F2726179A2245});
+  LL_UInt128 val10({0x3792F412CB06794D, 0xCDB02555653131B6});
+  LL_UInt128 result5({0x917cf11d1e039c50, 0x3a4f32d17f40d08f});
   EXPECT_EQ((val9 * val10), result5);
   EXPECT_EQ((val9 * val10), (val10 * val9));
 }
 
 TEST(LlvmLibcUInt128ClassTest, ShiftLeftTests) {
-  UInt128 val1(0x0123456789abcdef);
-  UInt128 result1(0x123456789abcdef0);
+  LL_UInt128 val1(0x0123456789abcdef);
+  LL_UInt128 result1(0x123456789abcdef0);
   EXPECT_EQ((val1 << 4), result1);
 
-  UInt128 val2({0x13579bdf02468ace, 0x123456789abcdef0});
-  UInt128 result2({0x02468ace00000000, 0x9abcdef013579bdf});
+  LL_UInt128 val2({0x13579bdf02468ace, 0x123456789abcdef0});
+  LL_UInt128 result2({0x02468ace00000000, 0x9abcdef013579bdf});
   EXPECT_EQ((val2 << 32), result2);
+  LL_UInt128 val22 = val2;
+  val22 <<= 32;
+  EXPECT_EQ(val22, result2);
 
-  UInt128 result3({0, 0x13579bdf02468ace});
+  LL_UInt128 result3({0, 0x13579bdf02468ace});
   EXPECT_EQ((val2 << 64), result3);
 
-  UInt128 result4({0, 0x02468ace00000000});
+  LL_UInt128 result4({0, 0x02468ace00000000});
   EXPECT_EQ((val2 << 96), result4);
 
-  UInt128 result5({0, 0x2468ace000000000});
+  LL_UInt128 result5({0, 0x2468ace000000000});
   EXPECT_EQ((val2 << 100), result5);
 
-  UInt128 result6({0, 0});
+  LL_UInt128 result6({0, 0});
   EXPECT_EQ((val2 << 128), result6);
   EXPECT_EQ((val2 << 256), result6);
 }
 
 TEST(LlvmLibcUInt128ClassTest, ShiftRightTests) {
-  UInt128 val1(0x0123456789abcdef);
-  UInt128 result1(0x00123456789abcde);
+  LL_UInt128 val1(0x0123456789abcdef);
+  LL_UInt128 result1(0x00123456789abcde);
   EXPECT_EQ((val1 >> 4), result1);
 
-  UInt128 val2({0x13579bdf02468ace, 0x123456789abcdef0});
-  UInt128 result2({0x9abcdef013579bdf, 0x0000000012345678});
+  LL_UInt128 val2({0x13579bdf02468ace, 0x123456789abcdef0});
+  LL_UInt128 result2({0x9abcdef013579bdf, 0x0000000012345678});
   EXPECT_EQ((val2 >> 32), result2);
+  LL_UInt128 val22 = val2;
+  val22 >>= 32;
+  EXPECT_EQ(val22, result2);
 
-  UInt128 result3({0x123456789abcdef0, 0});
+  LL_UInt128 result3({0x123456789abcdef0, 0});
   EXPECT_EQ((val2 >> 64), result3);
 
-  UInt128 result4({0x0000000012345678, 0});
+  LL_UInt128 result4({0x0000000012345678, 0});
   EXPECT_EQ((val2 >> 96), result4);
 
-  UInt128 result5({0x0000000001234567, 0});
+  LL_UInt128 result5({0x0000000001234567, 0});
   EXPECT_EQ((val2 >> 100), result5);
 
-  UInt128 result6({0, 0});
+  LL_UInt128 result6({0, 0});
   EXPECT_EQ((val2 >> 128), result6);
   EXPECT_EQ((val2 >> 256), result6);
 }
 
 TEST(LlvmLibcUInt128ClassTest, AndTests) {
-  UInt128 base({0xffff00000000ffff, 0xffffffff00000000});
-  UInt128 val128({0xf0f0f0f00f0f0f0f, 0xff00ff0000ff00ff});
+  LL_UInt128 base({0xffff00000000ffff, 0xffffffff00000000});
+  LL_UInt128 val128({0xf0f0f0f00f0f0f0f, 0xff00ff0000ff00ff});
   uint64_t val64 = 0xf0f0f0f00f0f0f0f;
   int val32 = 0x0f0f0f0f;
-  UInt128 result128({0xf0f0000000000f0f, 0xff00ff0000000000});
-  UInt128 result64(0xf0f0000000000f0f);
-  UInt128 result32(0x00000f0f);
+  LL_UInt128 result128({0xf0f0000000000f0f, 0xff00ff0000000000});
+  LL_UInt128 result64(0xf0f0000000000f0f);
+  LL_UInt128 result32(0x00000f0f);
   EXPECT_EQ((base & val128), result128);
   EXPECT_EQ((base & val64), result64);
   EXPECT_EQ((base & val32), result32);
 }
 
 TEST(LlvmLibcUInt128ClassTest, OrTests) {
-  UInt128 base({0xffff00000000ffff, 0xffffffff00000000});
-  UInt128 val128({0xf0f0f0f00f0f0f0f, 0xff00ff0000ff00ff});
+  LL_UInt128 base({0xffff00000000ffff, 0xffffffff00000000});
+  LL_UInt128 val128({0xf0f0f0f00f0f0f0f, 0xff00ff0000ff00ff});
   uint64_t val64 = 0xf0f0f0f00f0f0f0f;
   int val32 = 0x0f0f0f0f;
-  UInt128 result128({0xfffff0f00f0fffff, 0xffffffff00ff00ff});
-  UInt128 result64({0xfffff0f00f0fffff, 0xffffffff00000000});
-  UInt128 result32({0xffff00000f0fffff, 0xffffffff00000000});
+  LL_UInt128 result128({0xfffff0f00f0fffff, 0xffffffff00ff00ff});
+  LL_UInt128 result64({0xfffff0f00f0fffff, 0xffffffff00000000});
+  LL_UInt128 result32({0xffff00000f0fffff, 0xffffffff00000000});
   EXPECT_EQ((base | val128), result128);
   EXPECT_EQ((base | val64), result64);
   EXPECT_EQ((base | val32), result32);
 }
 
 TEST(LlvmLibcUInt128ClassTest, EqualsTests) {
-  UInt128 a1({0xffffffff00000000, 0xffff00000000ffff});
-  UInt128 a2({0xffffffff00000000, 0xffff00000000ffff});
-  UInt128 b({0xff00ff0000ff00ff, 0xf0f0f0f00f0f0f0f});
-  UInt128 a_reversed({0xffff00000000ffff, 0xffffffff00000000});
-  UInt128 a_upper(0xffff00000000ffff);
-  UInt128 a_lower(0xffffffff00000000);
+  LL_UInt128 a1({0xffffffff00000000, 0xffff00000000ffff});
+  LL_UInt128 a2({0xffffffff00000000, 0xffff00000000ffff});
+  LL_UInt128 b({0xff00ff0000ff00ff, 0xf0f0f0f00f0f0f0f});
+  LL_UInt128 a_reversed({0xffff00000000ffff, 0xffffffff00000000});
+  LL_UInt128 a_upper(0xffff00000000ffff);
+  LL_UInt128 a_lower(0xffffffff00000000);
   ASSERT_TRUE(a1 == a1);
   ASSERT_TRUE(a1 == a2);
   ASSERT_FALSE(a1 == b);
   ASSERT_FALSE(a1 == a_reversed);
   ASSERT_FALSE(a1 == a_lower);
   ASSERT_FALSE(a1 == a_upper);
   ASSERT_TRUE(a_lower != a_upper);
 }
 
 TEST(LlvmLibcUInt128ClassTest, ComparisonTests) {
-  UInt128 a({0xffffffff00000000, 0xffff00000000ffff});
-  UInt128 b({0xff00ff0000ff00ff, 0xf0f0f0f00f0f0f0f});
+  LL_UInt128 a({0xffffffff00000000, 0xffff00000000ffff});
+  LL_UInt128 b({0xff00ff0000ff00ff, 0xf0f0f0f00f0f0f0f});
   EXPECT_GT(a, b);
   EXPECT_GE(a, b);
   EXPECT_LT(b, a);
   EXPECT_LE(b, a);
 
-  UInt128 x(0xffffffff00000000);
-  UInt128 y(0x00000000ffffffff);
+  LL_UInt128 x(0xffffffff00000000);
+  LL_UInt128 y(0x00000000ffffffff);
   EXPECT_GT(x, y);
   EXPECT_GE(x, y);
   EXPECT_LT(y, x);
   EXPECT_LE(y, x);
 
   EXPECT_LE(a, a);
   EXPECT_GE(a, a);
 }

libc/test/src/stdlib/CMakeLists.txt

 
 add_libc_unittest(
   strtold_test
   SUITE
     libc_stdlib_unittests
   SRCS
     strtold_test.cpp
   DEPENDS
+    libc.src.__support.CPP.uint128
     libc.src.stdlib.strtold
 )
 
 add_libc_unittest(
   strtoll_test
   SUITE
     libc_stdlib_unittests
   SRCS

libc/test/src/stdlib/strtold_test.cpp

 //===-- Unittests for strtold ---------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "src/__support/CPP/UInt128.h"
 #include "src/__support/FPUtil/FPBits.h"
 #include "src/stdlib/strtold.h"
 
 #include "utils/UnitTest/Test.h"
 
 #include <errno.h>
 #include <limits.h>
 #include <stddef.h>
 
 #if defined(LONG_DOUBLE_IS_DOUBLE)
 #define SELECT_CONST(val, _, __) val
 #elif defined(SPECIAL_X86_LONG_DOUBLE)
 #define SELECT_CONST(_, val, __) val
 #else
 #define SELECT_CONST(_, __, val) val
 #endif
 
 class LlvmLibcStrToLDTest : public __llvm_libc::testing::Test {
 public:
 #if defined(LONG_DOUBLE_IS_DOUBLE)
   void run_test(const char *inputString, const ptrdiff_t expectedStrLen,
                 const uint64_t expectedRawData, const int expectedErrno = 0)
 #else
   void run_test(const char *inputString, const ptrdiff_t expectedStrLen,
-                const __uint128_t expectedRawData, const int expectedErrno = 0)
+                const UInt128 expectedRawData, const int expectedErrno = 0)
 #endif
   {
     // expectedRawData64 is the expected long double result as a uint64_t,
     // organized according to the IEEE754 double precision format:
     //
     // +-- 1 Sign Bit                        +-- 52 Mantissa bits
     // |                                     |
     // |           +-------------------------+------------------------+
     // |           |                                                  |
     // SEEEEEEEEEEEMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
     //  |         |
     //  +----+----+
     //       |
     //       +-- 11 Exponent Bits
 
-    // expectedRawData80 is the expected long double result as a __uint128_t,
+    // expectedRawData80 is the expected long double result as a UInt128,
     // organized according to the x86 extended precision format:
     //
     // +-- 1 Sign Bit
     // |
     // |               +-- 1 Integer part bit (1 unless this is a subnormal)
     // |               |
     // SEEEEEEEEEEEEEEEIMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM...M
     //  |             | |                                                      |
     //  +------+------+ +---------------------------+--------------------------+
     //         |                                    |
     //         +-- 15 Exponent Bits                 +-- 63 Mantissa bits
 
-    // expectedRawData128 is the expected long double result as a __uint128_t,
+    // expectedRawData128 is the expected long double result as a UInt128,
     // organized according to IEEE754 quadruple precision format:
     //
     // +-- 1 Sign Bit                               +-- 112 Mantissa bits
     // |                                            |
     // |               +----------------------------+--------------------------+
     // |               |                                                       |
     // SEEEEEEEEEEEEEEEMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM...M
     //  |             |
#endif
     EXPECT_EQ(actual_fp.get_mantissa(), expected_fp.get_mantissa());
     EXPECT_EQ(errno, expected_errno);
   }
 };
 
 TEST_F(LlvmLibcStrToLDTest, SimpleTest) {
   run_test("123", 3,
            SELECT_CONST(uint64_t(0x405ec00000000000),
-                        __uint128_t(0x4005f60000) << 40,
-                        __uint128_t(0x4005ec0000000000) << 64));
+                        UInt128(0x4005f60000) << 40,
+                        UInt128(0x4005ec0000000000) << 64));
 
   // This should fail on Eisel-Lemire, forcing a fallback to simple decimal
   // conversion.
   run_test("12345678901234549760", 20,
            SELECT_CONST(uint64_t(0x43e56a95319d63d8),
-                        (__uint128_t(0x403eab54a9) << 40) +
-                            __uint128_t(0x8ceb1ec400),
-                        (__uint128_t(0x403e56a95319d63d) << 64) +
-                            __uint128_t(0x8800000000000000)));
+                        (UInt128(0x403eab54a9) << 40) + UInt128(0x8ceb1ec400),
+                        (UInt128(0x403e56a95319d63d) << 64) +
+                            UInt128(0x8800000000000000)));
 
   // Found while looking for difficult test cases here:
   // https://github.com/nigeltao/parse-number-fxx-test-data/blob/main/more-test-cases/golang-org-issue-36657.txt
   run_test("1090544144181609348835077142190", 31,
            SELECT_CONST(uint64_t(0x462b8779f2474dfb),
-                        (__uint128_t(0x4062dc3bcf) << 40) +
-                            __uint128_t(0x923a6fd402),
-                        (__uint128_t(0x4062b8779f2474df) << 64) +
-                            __uint128_t(0xa804bfd8c6d5c000)));
+                        (UInt128(0x4062dc3bcf) << 40) + UInt128(0x923a6fd402),
+                        (UInt128(0x4062b8779f2474df) << 64) +
+                            UInt128(0xa804bfd8c6d5c000)));
 
   run_test("0x123", 5,
            SELECT_CONST(uint64_t(0x4072300000000000),
-                        (__uint128_t(0x4007918000) << 40),
-                        (__uint128_t(0x4007230000000000) << 64)));
+                        (UInt128(0x4007918000) << 40),
+                        (UInt128(0x4007230000000000) << 64)));
 }
 
 // These are tests that have caused problems for doubles in the past.
 TEST_F(LlvmLibcStrToLDTest, Float64SpecificFailures) {
   run_test("3E70000000000000", 16,
            SELECT_CONST(uint64_t(0x7FF0000000000000),
-                        (__uint128_t(0x7fff800000) << 40),
-                        (__uint128_t(0x7fff000000000000) << 64)),
+                        (UInt128(0x7fff800000) << 40),
+                        (UInt128(0x7fff000000000000) << 64)),
            ERANGE);
   run_test("358416272e-33", 13,
            SELECT_CONST(uint64_t(0x3adbbb2a68c9d0b9),
-                        (__uint128_t(0x3fadddd953) << 40) +
-                            __uint128_t(0x464e85c400),
-                        (__uint128_t(0x3fadbbb2a68c9d0b) << 64) +
-                            __uint128_t(0x8800e7969e1c5fc8)));
+                        (UInt128(0x3fadddd953) << 40) + UInt128(0x464e85c400),
+                        (UInt128(0x3fadbbb2a68c9d0b) << 64) +
+                            UInt128(0x8800e7969e1c5fc8)));
   run_test("2.16656806400000023841857910156251e9", 36,
            SELECT_CONST(uint64_t(0x41e0246690000001),
-                        (__uint128_t(0x401e812334) << 40) +
-                            __uint128_t(0x8000000400),
-                        (__uint128_t(0x401e024669000000) << 64) +
-                            __uint128_t(0x800000000000018)));
+                        (UInt128(0x401e812334) << 40) + UInt128(0x8000000400),
+                        (UInt128(0x401e024669000000) << 64) +
+                            UInt128(0x800000000000018)));
   run_test("27949676547093071875", 20,
            SELECT_CONST(uint64_t(0x43f83e132bc608c9),
-                        (__uint128_t(0x403fc1f099) << 40) +
-                            __uint128_t(0x5e30464402),
-                        (__uint128_t(0x403f83e132bc608c) << 64) +
-                            __uint128_t(0x8803000000000000)));
+                        (UInt128(0x403fc1f099) << 40) + UInt128(0x5e30464402),
+                        (UInt128(0x403f83e132bc608c) << 64) +
+                            UInt128(0x8803000000000000)));
 }
 
 TEST_F(LlvmLibcStrToLDTest, MaxSizeNumbers) {
   run_test("1.1897314953572317650e4932", 26,
            SELECT_CONST(uint64_t(0x7FF0000000000000),
-                        (__uint128_t(0x7ffeffffff) << 40) +
-                            __uint128_t(0xffffffffff),
-                        (__uint128_t(0x7ffeffffffffffff) << 64) +
-                            __uint128_t(0xfffd57322e3f8675)),
+                        (UInt128(0x7ffeffffff) << 40) + UInt128(0xffffffffff),
+                        (UInt128(0x7ffeffffffffffff) << 64) +
+                            UInt128(0xfffd57322e3f8675)),
            SELECT_CONST(ERANGE, 0, 0));
   run_test("1.18973149535723176508e4932", 27,
            SELECT_CONST(uint64_t(0x7FF0000000000000),
-                        (__uint128_t(0x7fff800000) << 40),
-                        (__uint128_t(0x7ffeffffffffffff) << 64) +
-                            __uint128_t(0xffffd2478338036c)),
+                        (UInt128(0x7fff800000) << 40),
+                        (UInt128(0x7ffeffffffffffff) << 64) +
+                            UInt128(0xffffd2478338036c)),
            SELECT_CONST(ERANGE, ERANGE, 0));
 }
 
 // These tests check subnormal behavior for 80 bit and 128 bit floats. They will
 // be too small for 64 bit floats.
 TEST_F(LlvmLibcStrToLDTest, SubnormalTests) {
   run_test("1e-4950", 7,
-           SELECT_CONST(uint64_t(0), (__uint128_t(0x00000000000000000003)),
-                        (__uint128_t(0x000000000000000000057c9647e1a018))),
+           SELECT_CONST(uint64_t(0), (UInt128(0x00000000000000000003)),
+                        (UInt128(0x000000000000000000057c9647e1a018))),
            ERANGE);
   run_test("1.89e-4951", 10,
-           SELECT_CONST(uint64_t(0), (__uint128_t(0x00000000000000000001)),
-                        (__uint128_t(0x0000000000000000000109778a006738))),
+           SELECT_CONST(uint64_t(0), (UInt128(0x00000000000000000001)),
+                        (UInt128(0x0000000000000000000109778a006738))),
            ERANGE);
   run_test("4e-4966", 7,
-           SELECT_CONST(uint64_t(0), (__uint128_t(0)),
-                        (__uint128_t(0x00000000000000000000000000000001))),
+           SELECT_CONST(uint64_t(0), (UInt128(0)),
+                        (UInt128(0x00000000000000000000000000000001))),
            ERANGE);
 }
 
 TEST_F(LlvmLibcStrToLDTest, SmallNormalTests) {
-  run_test(
-      "3.37e-4932", 10,
-      SELECT_CONST(uint64_t(0),
-                   (__uint128_t(0x1804cf7) << 40) + __uint128_t(0x908850712),
-                   (__uint128_t(0x10099ee12110a) << 64) +
-                       __uint128_t(0xe24b75c0f50dc0c)),
+  run_test("3.37e-4932", 10,
+           SELECT_CONST(
+               uint64_t(0), (UInt128(0x1804cf7) << 40) + UInt128(0x908850712),
+               (UInt128(0x10099ee12110a) << 64) + UInt128(0xe24b75c0f50dc0c)),
            SELECT_CONST(ERANGE, 0, 0));
 }
 
 TEST_F(LlvmLibcStrToLDTest, ComplexHexadecimalTests) {
   run_test("0x1p16383", 9,
-           SELECT_CONST(0x7ff0000000000000, (__uint128_t(0x7ffe800000) << 40),
-                        (__uint128_t(0x7ffe000000000000) << 64)),
+           SELECT_CONST(0x7ff0000000000000, (UInt128(0x7ffe800000) << 40),
+                        (UInt128(0x7ffe000000000000) << 64)),
            SELECT_CONST(ERANGE, 0, 0));
   run_test("0x123456789abcdef", 17,
            SELECT_CONST(0x43723456789abcdf,
-                        (__uint128_t(0x403791a2b3) << 40) +
-                            __uint128_t(0xc4d5e6f780),
-                        (__uint128_t(0x403723456789abcd) << 64) +
-                            __uint128_t(0xef00000000000000)));
+                        (UInt128(0x403791a2b3) << 40) + UInt128(0xc4d5e6f780),
+                        (UInt128(0x403723456789abcd) << 64) +
+                            UInt128(0xef00000000000000)));
   run_test("0x123456789abcdef0123456789ABCDEF", 33,
            SELECT_CONST(0x47723456789abcdf,
-                        (__uint128_t(0x407791a2b3) << 40) +
-                            __uint128_t(0xc4d5e6f781),
-                        (__uint128_t(0x407723456789abcd) << 64) +
-                            __uint128_t(0xef0123456789abce)));
+                        (UInt128(0x407791a2b3) << 40) + UInt128(0xc4d5e6f781),
+                        (UInt128(0x407723456789abcd) << 64) +
+                            UInt128(0xef0123456789abce)));
 }
 
 TEST_F(LlvmLibcStrToLDTest, InfTests) {
   run_test("INF", 3,
-           SELECT_CONST(0x7ff0000000000000, (__uint128_t(0x7fff800000) << 40),
-                        (__uint128_t(0x7fff000000000000) << 64)));
+           SELECT_CONST(0x7ff0000000000000, (UInt128(0x7fff800000) << 40),
+                        (UInt128(0x7fff000000000000) << 64)));
   run_test("INFinity", 8,
-           SELECT_CONST(0x7ff0000000000000, (__uint128_t(0x7fff800000) << 40),
-                        (__uint128_t(0x7fff000000000000) << 64)));
+           SELECT_CONST(0x7ff0000000000000, (UInt128(0x7fff800000) << 40),
+                        (UInt128(0x7fff000000000000) << 64)));
   run_test("-inf", 4,
-           SELECT_CONST(0xfff0000000000000, (__uint128_t(0xffff800000) << 40),
-                        (__uint128_t(0xffff000000000000) << 64)));
+           SELECT_CONST(0xfff0000000000000, (UInt128(0xffff800000) << 40),
+                        (UInt128(0xffff000000000000) << 64)));
 }
 
 TEST_F(LlvmLibcStrToLDTest, NaNTests) {
   run_test("NaN", 3,
-           SELECT_CONST(0x7ff8000000000000, (__uint128_t(0x7fffc00000) << 40),
-                        (__uint128_t(0x7fff800000000000) << 64)));
+           SELECT_CONST(0x7ff8000000000000, (UInt128(0x7fffc00000) << 40),
+                        (UInt128(0x7fff800000000000) << 64)));
   run_test("-nAn", 4,
-           SELECT_CONST(0xfff8000000000000, (__uint128_t(0xffffc00000) << 40),
-                        (__uint128_t(0xffff800000000000) << 64)));
+           SELECT_CONST(0xfff8000000000000, (UInt128(0xffffc00000) << 40),
+                        (UInt128(0xffff800000000000) << 64)));
   run_test("NaN()", 5,
-           SELECT_CONST(0x7ff8000000000000, (__uint128_t(0x7fffc00000) << 40),
-                        (__uint128_t(0x7fff800000000000) << 64)));
+           SELECT_CONST(0x7ff8000000000000, (UInt128(0x7fffc00000) << 40),
+                        (UInt128(0x7fff800000000000) << 64)));
   run_test("NaN(1234)", 9,
            SELECT_CONST(0x7ff80000000004d2,
-                        (__uint128_t(0x7fffc00000) << 40) + __uint128_t(0x4d2),
-                        (__uint128_t(0x7fff800000000000) << 64) +
-                            __uint128_t(0x4d2)));
+                        (UInt128(0x7fffc00000) << 40) + UInt128(0x4d2),
+                        (UInt128(0x7fff800000000000) << 64) + UInt128(0x4d2)));
   run_test("NaN(0xffffffffffff)", 19,
            SELECT_CONST(0x7ff8ffffffffffff,
-                        (__uint128_t(0x7fffc000ff) << 40) +
-                            __uint128_t(0xffffffffff),
-                        (__uint128_t(0x7fff800000000000) << 64) +
-                            __uint128_t(0xffffffffffff)));
+                        (UInt128(0x7fffc000ff) << 40) + UInt128(0xffffffffff),
+                        (UInt128(0x7fff800000000000) << 64) +
+                            UInt128(0xffffffffffff)));
   run_test("NaN(0xfffffffffffff)", 20,
            SELECT_CONST(0x7fffffffffffffff,
-                        (__uint128_t(0x7fffc00fff) << 40) +
-                            __uint128_t(0xffffffffff),
-                        (__uint128_t(0x7fff800000000000) << 64) +
-                            __uint128_t(0xfffffffffffff)));
+                        (UInt128(0x7fffc00fff) << 40) + UInt128(0xffffffffff),
+                        (UInt128(0x7fff800000000000) << 64) +
+                            UInt128(0xfffffffffffff)));
   run_test("NaN(0xffffffffffffffff)", 23,
            SELECT_CONST(0x7fffffffffffffff,
-                        (__uint128_t(0x7fffffffff) << 40) +
-                            __uint128_t(0xffffffffff),
-                        (__uint128_t(0x7fff800000000000) << 64) +
-                            __uint128_t(0xffffffffffffffff)));
+                        (UInt128(0x7fffffffff) << 40) + UInt128(0xffffffffff),
+                        (UInt128(0x7fff800000000000) << 64) +
+                            UInt128(0xffffffffffffffff)));
   run_test("NaN( 1234)", 3,
-           SELECT_CONST(0x7ff8000000000000, (__uint128_t(0x7fffc00000) << 40),
-                        (__uint128_t(0x7fff800000000000) << 64)));
+           SELECT_CONST(0x7ff8000000000000, (UInt128(0x7fffc00000) << 40),
+                        (UInt128(0x7fff800000000000) << 64)));
 }

libc/utils/UnitTest/CMakeLists.txt

 add_library(
   LibcUnitTest
   Test.h
   LibcTest.cpp
   LibcTest.h
 )
 target_include_directories(LibcUnitTest PUBLIC ${LIBC_SOURCE_DIR})
-add_dependencies(LibcUnitTest libc.src.__support.CPP.type_traits)
+add_dependencies(LibcUnitTest libc.src.__support.CPP.type_traits libc.src.__support.CPP.uint128)
 target_link_libraries(LibcUnitTest PUBLIC libc_test_utils)
 
 add_library(
   LibcUnitTestMain
   LibcTestMain.cpp
 )
 
 target_include_directories(LibcUnitTestMain PUBLIC ${LIBC_SOURCE_DIR})
LibcPrintfHelpers
     PrintfMatcher.h
     PrintfMatcher.cpp
 )
 target_include_directories(LibcPrintfHelpers PUBLIC ${LIBC_SOURCE_DIR})
 target_link_libraries(LibcPrintfHelpers LibcUnitTest)
 add_dependencies(
   LibcPrintfHelpers
   LibcUnitTest
-  libc.utils.UnitTest.string_utils
+  libc.src.__support.CPP.uint128
   libc.src.stdio.printf_core.core_structs
+  libc.utils.UnitTest.string_utils
 )

libc/utils/UnitTest/LibcTest.cpp

 //===-- Implementation of the base class for libc unittests----------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "LibcTest.h"
 
-#include "src/__support/CPP/UInt.h"
+#include "src/__support/CPP/UInt128.h"
 #include "utils/testutils/ExecuteFunction.h"
 #include <cassert>
 #include <iostream>
 #include <string>
 
 namespace __llvm_libc {
 namespace testing {
 

 // When the value is of integral type, just display it as normal.
 template <typename ValType>
 cpp::EnableIfType<cpp::IsIntegral<ValType>::Value, std::string>
 describeValue(ValType Value) {
   return std::to_string(Value);
 }
 
 std::string describeValue(std::string Value) { return std::string(Value); }
-#ifdef __SIZEOF_INT128__
-// When the value is __uint128_t, also show its hexadecimal digits.
-// Using template to force exact match, prevent ambiguous promotion.
-std::string describeValue128(__uint128_t Value) {
-  std::string S(sizeof(__uint128_t) * 2, '0');
+
+// When the value is UInt128, show its hexadecimal digits.
+template <typename UInt128Type>
+std::string describeValue128(UInt128Type Value) {
+  std::string S(sizeof(UInt128) * 2, '0');
 
   for (auto I = S.rbegin(), End = S.rend(); I != End; ++I, Value >>= 4) {
     unsigned char Mod = static_cast<unsigned char>(Value) & 15;
     *I = Mod < 10 ? '0' + Mod : 'a' + Mod - 10;
   }
 
   return "0x" + S;
 }
 
-template <> std::string describeValue<__int128_t>(__int128_t Value) {
-  return describeValue128(Value);
-}
+#ifdef __SIZEOF_INT128__
 template <> std::string describeValue<__uint128_t>(__uint128_t Value) {
   return describeValue128(Value);
 }
 #endif
 
-// When the value is UInt<128>, also show its hexadecimal digits.
 template <>
 std::string
 describeValue<__llvm_libc::cpp::UInt<128>>(__llvm_libc::cpp::UInt<128> Value) {
-  std::string S(sizeof(__llvm_libc::cpp::UInt<128>) * 2, '0');
-
-  for (auto I = S.rbegin(), End = S.rend(); I != End; ++I, Value = Value >> 4) {
-    unsigned char Mod = static_cast<unsigned char>(Value) & 15;
-    *I = Mod < 10 ? '0' + Mod : 'a' + Mod - 10;
-  }
-
-  return "0x" + S;
+  return describeValue128(Value);
 }
 
 template <typename ValType>
 void explainDifference(ValType LHS, ValType RHS, const char *LHSStr,
                        const char *RHSStr, const char *File, unsigned long Line,
                        std::string OpString) {
   size_t OffsetLength = OpString.size() > 2 ? OpString.size() - 2 : 0;
   std::string Offset(OffsetLength, ' ');
 
template bool test<long>(RunContext *Ctx, TestCondition Cond, long LHS,
                          long RHS, const char *LHSStr, const char *RHSStr,
                          const char *File, unsigned long Line);
 
 template bool test<long long>(RunContext *Ctx, TestCondition Cond,
                               long long LHS, long long RHS, const char *LHSStr,
                               const char *RHSStr, const char *File,
                               unsigned long Line);
 
-#ifdef __SIZEOF_INT128__
-template bool test<__int128_t>(RunContext *Ctx, TestCondition Cond,
-                               __int128_t LHS, __int128_t RHS,
-                               const char *LHSStr, const char *RHSStr,
-                               const char *File, unsigned long Line);
-#endif
-template bool test<__llvm_libc::cpp::UInt<128>>(
-    RunContext *Ctx, TestCondition Cond, __llvm_libc::cpp::UInt<128> LHS,
-    __llvm_libc::cpp::UInt<128> RHS, const char *LHSStr, const char *RHSStr,
-    const char *File, unsigned long Line);
-
 template bool test<unsigned char>(RunContext *Ctx, TestCondition Cond,
                                   unsigned char LHS, unsigned char RHS,
                                   const char *LHSStr, const char *RHSStr,
                                   const char *File, unsigned long Line);
 
 template bool test<unsigned short>(RunContext *Ctx, TestCondition Cond,
                                    unsigned short LHS, unsigned short RHS,
                                    const char *LHSStr, const char *RHSStr,
template bool test<bool>(RunContext *Ctx, TestCondition Cond, bool LHS,
                          const char *File, unsigned long Line);
 
 template bool test<unsigned long long>(RunContext *Ctx, TestCondition Cond,
                                        unsigned long long LHS,
                                        unsigned long long RHS,
                                        const char *LHSStr, const char *RHSStr,
                                        const char *File, unsigned long Line);
 
 #ifdef __SIZEOF_INT128__
+// When builtin __uint128_t type is available, include its specialization
+// also.
 template bool test<__uint128_t>(RunContext *Ctx, TestCondition Cond,
                                 __uint128_t LHS, __uint128_t RHS,
                                 const char *LHSStr, const char *RHSStr,
                                 const char *File, unsigned long Line);
 #endif
 
+template bool test<__llvm_libc::cpp::UInt<128>>(
+    RunContext *Ctx, TestCondition Cond, __llvm_libc::cpp::UInt<128> LHS,
+    __llvm_libc::cpp::UInt<128> RHS, const char *LHSStr, const char *RHSStr,
+    const char *File, unsigned long Line);
+
 } // namespace internal
 
 bool Test::testStrEq(const char *LHS, const char *RHS, const char *LHSStr,
                      const char *RHSStr, const char *File, unsigned long Line) {
   return internal::test(Ctx, Cond_EQ, LHS ? std::string(LHS) : std::string(),
                         RHS ? std::string(RHS) : std::string(), LHSStr, RHSStr,
                         File, Line);
 }
 

libc/utils/UnitTest/PrintfMatcher.cpp

 //===-- PrintfMatcher.cpp ---------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "PrintfMatcher.h"
+
+#include "src/__support/CPP/UInt128.h"
 #include "src/stdio/printf_core/core_structs.h"
 
 #include "utils/UnitTest/StringUtils.h"
 
 #include <stdint.h>
 
 namespace __llvm_libc {
 namespace printf_core {
if (form.has_conv) {
     stream << "\n";
     stream << "\tconversion name: " << form.conv_name << "\n";
     if (form.conv_name == 'p' || form.conv_name == 'n' || form.conv_name == 's')
       stream << "\tpointer value: "
              << int_to_hex<uintptr_t>(
                     reinterpret_cast<uintptr_t>(form.conv_val_ptr))
              << "\n";
     else if (form.conv_name != '%')
-      stream << "\tvalue: " << int_to_hex<__uint128_t>(form.conv_val_raw)
-             << "\n";
+      stream << "\tvalue: " << int_to_hex<UInt128>(form.conv_val_raw) << "\n";
   }
 }
 } // anonymous namespace
 
 void FormatSectionMatcher::explainError(testutils::StreamWrapper &stream) {
   stream << "expected format section: ";
   display(stream, expected);
   stream << '\n';
   stream << "actual format section  : ";
   display(stream, actual);
   stream << '\n';
 }
 
 } // namespace testing
 } // namespace printf_core
 } // namespace __llvm_libc

utils/bazel/llvm-project-overlay/libc/BUILD.bazel

cc_library(
     name = "__support_cpp_functional",
     hdrs = ["src/__support/CPP/Functional.h"],
     deps = [":libc_root"],
 )
 
 cc_library(
     name = "__support_cpp_limits",
     hdrs = ["src/__support/CPP/Limits.h"],
-    deps = [":libc_root"],
+    deps = [":libc_root", "__support_cpp_uint"],
 )
 
 cc_library(
     name = "__support_cpp_string_view",
     hdrs = ["src/__support/CPP/StringView.h"],
     deps = [":libc_root"],
 )
 
 cc_library(
     name = "__support_cpp_uint",
     hdrs = [
         "src/__support/CPP/UInt.h",
     ],
     deps = [":libc_root","__support_cpp_array"],
 )
 
 cc_library(
+    name = "__support_cpp_uint128",
+    hdrs = [
+        "src/__support/CPP/UInt128.h",
+    ],
+    deps = [":libc_root",":__support_cpp_uint"],
+)
+
+cc_library(
     name = "__support_cpp_type_traits",
     hdrs = [
         "src/__support/CPP/TypeTraits.h",
     ],
     deps = [":libc_root","__support_cpp_uint"],
 )
 
 cc_library(

 
 cc_library(
     name = "__support_fputil",
     hdrs = fputil_hdrs,
     deps = [
         ":__support_common",
         ":__support_cpp_bit",
         ":__support_cpp_type_traits",
+        ":__support_cpp_uint128",
         ":libc_root",
     ],
 )
 
 sqrt_common_hdrs = [
     "src/__support/FPUtil/sqrt.h",
     "src/__support/FPUtil/generic/sqrt.h",
     "src/__support/FPUtil/generic/sqrt_80_bit_long_double.h",

 
 cc_library(
     name = "__support_fputil_sqrt",
     hdrs = sqrt_hdrs,
     deps = [
         ":__support_common",
         ":__support_cpp_bit",
         ":__support_cpp_type_traits",
+        ":__support_cpp_uint128",
         ":__support_fputil",
         ":libc_root",
     ],
 )
 
 fma_common_hdrs = [
     "src/__support/FPUtil/FMA.h",
     "src/__support/FPUtil/generic/FMA.h",
cc_library(
     hdrs = fma_common_hdrs,
     # These are conditionally included and will #error out if the platform
     # doesn't support FMA, so they can't be compiled on their own.
     textual_hdrs = fma_platform_hdrs,
     deps = [
         ":__support_common",
         ":__support_cpp_bit",
         ":__support_cpp_type_traits",
+        ":__support_cpp_uint128",
         ":__support_fputil",
         ":libc_root",
     ],
 )
 
 cc_library(
     name = "__support_fputil_multiply_add",
     hdrs = [