[NFC][libc] Move Uint implementation to parent directory

[orex]

libc/test/src/CMakeLists.txt

34

Hello. Sorry for disturbing in closed review, but commenting this line completely disable all math tests in LLVM for me. Can you provide any additional verification that this is really necessary and math tests should be enabled somehow in a different way?

[sivachandra]

libc/test/src/CMakeLists.txt

34

I think it just a miss so I have landed this: https://github.com/llvm/llvm-project/commit/3a5ec60ae3d8d7da70440ade8e767d25532538f4

[gchatelet]

Oh. Shoot! Thx for catching it @orex and for the fix @sivachandra .

libc/src/__support/CMakeLists.txt

DEPENDS
     .str_to_integer
 )
 
 add_header_library(
   str_to_float
   HDRS
     str_to_float.h
   DEPENDS
-    .str_to_integer
     .ctype_utils
     .high_precision_decimal
+    .str_to_integer
+    .uint128
     libc.include.errno
-    libc.src.errno.errno
     libc.src.__support.CPP.limits
-    libc.src.__support.CPP.uint128
     libc.src.__support.FPUtil.fputil
+    libc.src.errno.errno
 )
 
 add_header_library(
   integer_operations
   HDRS
     integer_operations.h
 )
 
 add_header_library(
   arg_list
   HDRS
     arg_list.h
 )
 
 add_header_library(
   fixedvector
   HDRS
     fixedvector.h
   DEPENDS
     libc.src.__support.CPP.array
 )
 
+add_header_library(
+  uint
+  HDRS
+    UInt.h
+  DEPENDS
+    libc.src.__support.CPP.array
+)
+
+add_header_library(
+  uint128
+  HDRS
+    UInt128.h
+  DEPENDS
+    .uint
+)
+
 add_subdirectory(FPUtil)
 add_subdirectory(OSUtil)
 
 # Thread support is used by other "File". So, we add the "threads"
 # before "File".
 add_subdirectory(threads)
 
 add_subdirectory(File)

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(
   bit
   HDRS
     bit.h
 )
 
 add_header_library(
   bitset
   HDRS
     bitset.h
 )
 
 add_header_library(
   functional
   HDRS
     functional.h
 )
 
 add_header_library(
   limits
   HDRS
     limits.h
-  DEPENDS
-    .uint
 )
 
 add_header_library(
   span
   HDRS
     span.h
   DEPENDS
     .array
add_header_library(
   HDRS
     optional.h
 )
 
 add_header_library(
   type_traits
   HDRS
     type_traits.h
-  DEPENDS
-    .uint
 )
 
 add_header_library(
   utility
   HDRS
     utility.h
 )
 

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 numeric_limits {
 public:
   static constexpr T max();
public:
   static constexpr char max() { return CHAR_MAX; }
   static constexpr char min() { return CHAR_MIN; }
 };
 template <> class numeric_limits<unsigned char> {
 public:
   static constexpr unsigned char max() { return UCHAR_MAX; }
   static constexpr unsigned char min() { return 0; }
 };
-// This specialization enables two things:
-// 1. On platforms where UInt128 resolves to UInt<128>, this specialization
-//    provides limits of UInt128.
-// 2. On platforms where UInt128 resolves to __uint128_t, this specialization
-//    allows us to unittest UInt<128>.
-template <> class numeric_limits<UInt<128>> {
-public:
-  static constexpr UInt<128> max() { return ~UInt<128>(0); }
-  static constexpr UInt<128> min() { return 0; }
-};
 #ifdef __SIZEOF_INT128__
 // On platform where UInt128 resolves to __uint128_t, this specialization
 // provides the limits of UInt128.
 template <> class numeric_limits<__uint128_t> {
 public:
   static constexpr __uint128_t max() { return ~__uint128_t(0); }
   static constexpr __uint128_t min() { return 0; }
 };
 #endif
 
 } // namespace cpp
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_CPP_LIMITS_H

libc/src/__support/CPP/type_traits.h

 //===-- Self contained C++ type traits --------------------------*- 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_TYPETRAITS_H
 #define LLVM_LIBC_SRC_SUPPORT_CPP_TYPETRAITS_H
 
-#include "UInt.h"
-
 namespace __llvm_libc {
 namespace cpp {
 
 template <bool B, typename T> struct enable_if;
 template <typename T> struct enable_if<true, T> { using type = T; };
 template <bool B, typename T = void>
 using enable_if_t = typename enable_if<B, T>::type;
 

 template <typename T> using remove_cv_t = typename remove_cv<T>::type;
 
 template <typename T> struct is_integral {
 private:
   using unqualified_type = remove_cv_t<T>;
 
 public:
   static constexpr bool value =
+#ifdef __SIZEOF_INT128__
+      is_same_v<__int128_t, unqualified_type> ||
+      is_same_v<__uint128_t, unqualified_type> ||
+#endif
       is_same_v<char, unqualified_type> ||
       is_same_v<signed char, unqualified_type> ||
       is_same_v<unsigned char, unqualified_type> ||
       is_same_v<short, unqualified_type> ||
       is_same_v<unsigned short, unqualified_type> ||
       is_same_v<int, unqualified_type> ||
       is_same_v<unsigned int, unqualified_type> ||
       is_same_v<long, unqualified_type> ||
       is_same_v<unsigned long, unqualified_type> ||
       is_same_v<long long, unqualified_type> ||
       is_same_v<unsigned long long, unqualified_type> ||
-      is_same_v<bool, unqualified_type> ||
-      // We need to include UInt<128> and __uint128_t when available because
-      // we want to unittest UInt<128>. If we include only UInt128, then on
-      // platform where it resolves to __uint128_t, we cannot unittest
-      // UInt<128>.
-      is_same_v<__llvm_libc::cpp::UInt<128>, unqualified_type>
-#ifdef __SIZEOF_INT128__
-      || is_same_v<__int128_t, unqualified_type> ||
-      is_same_v<__uint128_t, unqualified_type>
-#endif
-      ;
+      is_same_v<bool, unqualified_type>;
 };
 template <typename T>
 inline constexpr bool is_integral_v = is_integral<T>::value;
 
 template <typename T> struct is_enum {
   static constexpr bool value = __is_enum(T);
 };
 

libc/src/__support/FPUtil/CMakeLists.txt

HDRS
     BasicOperations.h
     ManipulationFunctions.h
     NearestIntegerOperations.h
     NormalFloat.h
     PlatformDefs.h
     builtin_wrappers.h
     except_value_utils.h
   DEPENDS
-    libc.include.math
     libc.include.errno
     libc.include.fenv
+    libc.include.math
     libc.src.__support.common
     libc.src.__support.CPP.bit
     libc.src.__support.CPP.type_traits
-    libc.src.__support.CPP.uint128
+    libc.src.__support.uint128
     libc.src.errno.errno
 )
 
 add_header_library(
   xfloat
   HDRS
     XFloat.h
   DEPENDS
     .fputil #FPBits and NormalFloat
-    libc.src.__support.CPP.uint
+    libc.src.__support.uint
 )
 
 add_header_library(
   sqrt
   HDRS
     sqrt.h
   DEPENDS
     .fputil

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 "src/__support/UInt128.h"
 
 #include <stdint.h>
 
 namespace __llvm_libc {
 namespace fputil {
 
 template <typename T> struct FloatProperties {};
 

libc/src/__support/FPUtil/Hypot.h

 //===-- Implementation of hypotf function ---------------------------------===//
 //
 // 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_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/UInt128.h"
 #include "src/__support/CPP/bit.h"
 #include "src/__support/CPP/type_traits.h"
+#include "src/__support/UInt128.h"
 
 namespace __llvm_libc {
 namespace fputil {
 
 namespace internal {
 
 template <typename T>
 static inline T find_leading_one(T mant, int &shift_length) {

libc/src/__support/FPUtil/XFloat.h

 //===-- Utility class to manipulate wide floats. ----------------*- 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 "FPBits.h"
 #include "NormalFloat.h"
-#include "src/__support/CPP/UInt.h"
+#include "src/__support/UInt.h"
 
 #include <stdint.h>
 
 namespace __llvm_libc {
 namespace fputil {
 
 // Store and manipulate positive double precision numbers at |Precision| bits.
 template <size_t Precision> class XFloat {

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
+    libc.src.__support.uint128
 )
 
 add_header_library(
   fma
   HDRS
     FMA.h
   DEPENDS
-    libc.src.__support.CPP.uint128
+    libc.src.__support.uint128
 )
 
 add_header_library(
   fmod
   HDRS
     FMod.h
 )

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/UInt128.h"
 #include "src/__support/CPP/type_traits.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/UInt128.h"
 #include "src/__support/common.h"
 
 namespace __llvm_libc {
 namespace fputil {
 namespace generic {
 
 template <typename T> static inline T fma(T x, T y, T z);
 

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/UInt128.h"
 #include "src/__support/CPP/bit.h"
 #include "src/__support/CPP/type_traits.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"
+#include "src/__support/UInt128.h"
 
 namespace __llvm_libc {
 namespace fputil {
 
 namespace internal {
 
 template <typename T> struct SpecialLongDouble {
   static constexpr bool VALUE = false;

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"
+#include "src/__support/UInt128.h"
 
 namespace __llvm_libc {
 namespace fputil {
 namespace x86 {
 
 inline void normalize(int &exponent, UInt128 &mantissa) {
   const int shift =
       unsafe_clz(static_cast<uint64_t>(mantissa)) -

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/UInt128.h"
 #include "src/__support/CPP/bit.h"
+#include "src/__support/UInt128.h"
 #include "src/__support/architectures.h"
 
 #if !defined(LLVM_LIBC_ARCH_X86)
 #error "Invalid include"
 #endif
 
 #include "src/__support/FPUtil/FPBits.h"
 

libc/src/__support/UInt.h

 //===-- A class to manipulate wide integers. --------------------*- 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_CPP_UINT_H
 #define LLVM_LIBC_UTILS_CPP_UINT_H
 
-#include "array.h"
+#include "src/__support/CPP/array.h"
+#include "src/__support/CPP/limits.h"
+#include "src/__support/CPP/type_traits.h"
 
 #include <stddef.h> // For size_t
 #include <stdint.h>
 
-namespace __llvm_libc {
-namespace cpp {
+namespace __llvm_libc::cpp {
 
 template <size_t Bits> class UInt {
 
   static_assert(Bits > 0 && Bits % 64 == 0,
                 "Number of bits in UInt should be a multiple of 64.");
   static constexpr size_t WordCount = Bits / 64;
   uint64_t val[WordCount];
 
uint64_t new_high = high(temp_low_middle) + high(temp_middle_1) +
                       high(temp_middle_2) + temp_high +
                       (low(temp_high_overflow) << 32);
   UInt<128> result(0);
   result[0] = new_low;
   result[1] = new_high;
   return result;
 }
 
-} // namespace cpp
-} // namespace __llvm_libc
+// Provides limits of UInt<128>.
+template <> class numeric_limits<UInt<128>> {
+public:
+  static constexpr UInt<128> max() { return ~UInt<128>(0); }
+  static constexpr UInt<128> min() { return 0; }
+};
+
+// Provides is_integral of UInt<128>.
+template <> struct is_integral<UInt<128>> : public cpp::true_type {};
+
+} // namespace __llvm_libc::cpp
 
 #endif // LLVM_LIBC_UTILS_CPP_UINT_H

libc/src/__support/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::cpp::UInt<128>;
 #else
 using UInt128 = __uint128_t;
 #endif
 
 #endif // LLVM_LIBC_SRC_SUPPORT_CPP_UINT128_H

libc/src/__support/integer_to_string.h

 //===-- Utilities to convert integral values to string ----------*- 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_INTEGER_TO_STRING_H
 #define LLVM_LIBC_SRC_SUPPORT_INTEGER_TO_STRING_H
 
+#include <stdint.h>
+
 #include "src/__support/CPP/string_view.h"
 #include "src/__support/CPP/optional.h"
 #include "src/__support/CPP/span.h"
 #include "src/__support/CPP/type_traits.h"
 
 namespace __llvm_libc {
 
 // Convert integer values to their string representation.

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/UInt128.h"
 #include "src/__support/CPP/limits.h"
 #include "src/__support/FPUtil/FPBits.h"
 #include "src/__support/FPUtil/builtin_wrappers.h"
+#include "src/__support/UInt128.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>
 
 namespace __llvm_libc {
 namespace internal {

libc/src/math/generic/CMakeLists.txt

add_object_library(
   dp_trig
   SRCS
     dp_trig.cpp
   HDRS
     dp_trig.h
   DEPENDS
     libc.src.__support.FPUtil.fputil #FPBits and ManipulationFunction
     libc.src.__support.FPUtil.xfloat
-    libc.src.__support.CPP.uint
+    libc.src.__support.uint
   COMPILE_OPTIONS
    -O3
 )
 
 add_entrypoint_object(
   fmod
   SRCS
     fmod.cpp

libc/test/src/CMakeLists.txt

function(add_fp_unittest name)
   )
 endfunction(add_fp_unittest)
 
 add_subdirectory(__support)
 add_subdirectory(ctype)
 add_subdirectory(errno)
 add_subdirectory(fenv)
 add_subdirectory(inttypes)
-add_subdirectory(math)
+# add_subdirectory(math)
 add_subdirectory(string)
 add_subdirectory(stdlib)
 add_subdirectory(stdio)
 
 if(${LIBC_TARGET_OS} STREQUAL "linux")
   add_subdirectory(fcntl)
   add_subdirectory(sys)
   add_subdirectory(unistd)

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
+    libc.src.__support.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
+    libc.src.__support.uint128
 )
 
 add_libc_unittest(
   integer_to_string_test
   SUITE
     libc_support_unittests
   SRCS
     integer_to_string_test.cpp

 
 add_libc_unittest(
   uint128_test
   SUITE
     libc_support_unittests
   SRCS
     uint128_test.cpp
   DEPENDS
-    libc.src.__support.CPP.uint
+    libc.src.__support.uint
 )
 
 add_libc_unittest(
   fixedvector_test
   SUITE
     libc_support_unittests
   SRCS
     fixedvector_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
+    libc.src.__support.uint
 )
 
 add_libc_unittest(
   vector_test
   SUITE
     libc_cpp_utils_unittests
   SRCS
     vector_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/UInt.h"
 #include "src/__support/CPP/limits.h"
+#include "src/__support/UInt.h"
 #include "utils/UnitTest/Test.h"
 
 namespace __llvm_libc {
 
 // This just checks against the C spec, almost all implementations will surpass
 // this.
 TEST(LlvmLibcLimitsTest, LimitsFollowSpec) {
   ASSERT_EQ(cpp::numeric_limits<int>::max(), INT_MAX);

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/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();

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/UInt128.h"
 #include "src/__support/str_to_float.h"
 
 #include "utils/UnitTest/Test.h"
 
 class LlvmLibcStrToFloatTest : public __llvm_libc::testing::Test {
 public:
   template <class T>
   void clinger_fast_path_test(

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 "src/__support/UInt.h"
 
 #include "utils/UnitTest/Test.h"
 
 // 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>;
 

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.__support.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/__support/UInt128.h"
 #include "src/stdlib/strtold.h"
 
 #include "utils/UnitTest/Test.h"
 
 #include <errno.h>
 #include <limits.h>
 #include <stddef.h>
 

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 libc.src.__support.CPP.uint128)
+add_dependencies(LibcUnitTest libc.src.__support.CPP.type_traits libc.src.__support.uint128)
 target_link_libraries(LibcUnitTest PUBLIC libc_test_utils)
 
 add_library(
   LibcUnitTestMain
   LibcTestMain.cpp
 )
 
 target_include_directories(LibcUnitTestMain PUBLIC ${LIBC_SOURCE_DIR})

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/UInt128.h"
 #include "src/__support/CPP/string_view.h"
+#include "src/__support/UInt128.h"
 #include "utils/testutils/ExecuteFunction.h"
 #include <cassert>
 #include <iostream>
 #include <string>
 
 namespace __llvm_libc {
 namespace testing {
 

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", "__support_cpp_uint"],
+    deps = [":libc_root"],
 )
 
 cc_library(
     name = "__support_cpp_optional",
     hdrs = ["src/__support/CPP/optional.h"],
     deps = [":libc_root"],
 )
 

 
 cc_library(
     name = "__support_cpp_string_view",
     hdrs = ["src/__support/CPP/string_view.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/type_traits.h",
-    ],
-    deps = [":libc_root","__support_cpp_uint"],
+    hdrs = ["src/__support/CPP/type_traits.h"],
+    deps = [":libc_root"],
 )
 
 cc_library(
     name = "__support_cpp_utility",
     hdrs = ["src/__support/CPP/utility.h"],
     deps = [
         ":__support_cpp_type_traits",
         ":libc_root",
cc_library(
     hdrs = ["src/__support/CPP/atomic.h"],
     deps = [
         ":__support_cpp_type_traits",
         ":libc_root",
     ],
 )
 
 cc_library(
+    name = "__support_uint",
+    hdrs = ["src/__support/UInt.h"],
+    deps = [
+        "__support_cpp_array",
+        "__support_cpp_limits",
+        "__support_cpp_type_traits",
+        ":libc_root",
+    ],
+)
+
+cc_library(
+    name = "__support_cpp_uint128",
+    hdrs = ["src/__support/UInt128.h"],
+    deps = [
+        ":__support_uint",
+        ":libc_root",
+    ],
+)
+
+cc_library(
     name = "__support_integer_operations",
     hdrs = ["src/__support/integer_operations.h"],
     deps = [":__support_cpp_type_traits"],
 )
 
 cc_library(
     name = "__support_ctype_utils",
     hdrs = ["src/__support/ctype_utils.h"],

 
 cc_library(
     name = "sincosf_utils",
     hdrs = ["src/math/generic/sincosf_utils.h"],
     deps = [
         ":__support_common",
         ":__support_fputil",
         ":__support_fputil_polyeval",
-        ":range_reduction",
         ":libc_root",
+        ":range_reduction",
     ],
 )
 
 libc_math_function(
     name = "expm1f",
     additional_deps = [
         ":__support_fputil_fma",
         ":__support_fputil_nearest_integer",