[libc][NFC] Move utils/CPP to src/__support/CPP.

[sivachandra]

Summary

The idea is to move all pieces related to the actual libc sources to the
"src" directory. This allows downstream users to ship and build just the
"src" directory.

[sivachandra]

Fix header guards.

libc/fuzzing/math/CMakeLists.txt

DEPENDS
     libc.src.math.remquol
     libc.src.math.round
     libc.src.math.roundf
     libc.src.math.roundl
     libc.src.math.trunc
     libc.src.math.truncf
     libc.src.math.truncl
     libc.src.__support.FPUtil.fputil
-    libc.utils.CPP.standalone_cpp
+    libc.src.__support.CPP.standalone_cpp
 )
 
 add_libc_fuzzer(
   nextafter_differential_fuzz
   SRCS
     nextafter_differential_fuzz.cpp
   HDRS
     TwoInputSingleOutputDiff.h
   DEPENDS
     libc.src.math.nextafter
     libc.src.math.nextafterf
     libc.src.math.nextafterl
 )

libc/fuzzing/math/Compare.h

 //===-- Template functions to compare scalar values -------------*- 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_FUZZING_MATH_COMPARE_H
 #define LLVM_LIBC_FUZZING_MATH_COMPARE_H
 
+#include "src/__support/CPP/TypeTraits.h"
 #include "src/__support/FPUtil/FPBits.h"
-#include "utils/CPP/TypeTraits.h"
 
 template <typename T>
 __llvm_libc::cpp::EnableIfType<__llvm_libc::cpp::IsFloatingPointType<T>::Value,
                                bool>
 ValuesEqual(T x1, T x2) {
   __llvm_libc::fputil::FPBits<T> bits1(x1);
   __llvm_libc::fputil::FPBits<T> bits2(x2);
   // If either is NaN, we want both to be NaN.

libc/src/__support/CMakeLists.txt

+add_subdirectory(CPP)
+
 add_header_library(
   common
   HDRS
     common.h
     endian.h
     sanitizer.h
 )
 
add_header_library(
   HDRS
     str_conv_utils.h
     str_to_float.h
   DEPENDS
     .ctype_utils
     .high_precision_decimal
     libc.include.errno
     libc.src.errno.__errno_location
-    libc.utils.CPP.standalone_cpp
+    libc.src.__support.CPP.standalone_cpp
     libc.src.__support.FPUtil.fputil
 )
 
 add_header_library(
   integer_operations
   HDRS
     integer_operations.h
 )
 
 add_subdirectory(FPUtil)

libc/src/__support/CPP/Array.h

 //===-- A self contained equivalent of std::array ---------------*- 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_ARRAY_H
-#define LLVM_LIBC_UTILS_CPP_ARRAY_H
+#ifndef LLVM_LIBC_SRC_SUPPORT_CPP_ARRAY_H
+#define LLVM_LIBC_SRC_SUPPORT_CPP_ARRAY_H
 
 #include <stddef.h> // For size_t.
 
 namespace __llvm_libc {
 namespace cpp {
 
 template <class T, size_t N> struct Array {
   static_assert(N != 0, "Cannot create a __llvm_libc::cpp::Array of size 0.");
template <class T, size_t N> struct Array {
 
   constexpr iterator end() { return Data + N; }
   const_iterator end() const { return Data + N; }
 };
 
 } // namespace cpp
 } // namespace __llvm_libc
 
-#endif // LLVM_LIBC_UTILS_CPP_ARRAY_H
+#endif // LLVM_LIBC_SRC_SUPPORT_CPP_ARRAY_H

libc/src/__support/CPP/ArrayRef.h

 //===-- Self contained ArrayRef 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_UTILS_CPP_ARRAYREF_H
-#define LLVM_LIBC_UTILS_CPP_ARRAYREF_H
+#ifndef LLVM_LIBC_SRC_SUPPORT_CPP_ARRAYREF_H
+#define LLVM_LIBC_SRC_SUPPORT_CPP_ARRAYREF_H
 
 #include "Array.h"
 #include "TypeTraits.h" //RemoveCVType
 
 #include <stddef.h> // For size_t.
 
 namespace __llvm_libc {
 namespace cpp {

 public:
   // From Array.
   template <size_t N> MutableArrayRef(Array<T, N> &Arr) : Impl(Arr.Data, N) {}
 };
 
 } // namespace cpp
 } // namespace __llvm_libc
 
-#endif // LLVM_LIBC_UTILS_CPP_ARRAYREF_H
+#endif // LLVM_LIBC_SRC_SUPPORT_CPP_ARRAYREF_H

libc/src/__support/CPP/Bitset.h

 //===-- A self contained equivalent of std::bitset --------------*- 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_BITSET_H
-#define LLVM_LIBC_UTILS_CPP_BITSET_H
+#ifndef LLVM_LIBC_SRC_SUPPORT_CPP_BITSET_H
+#define LLVM_LIBC_SRC_SUPPORT_CPP_BITSET_H
 
 #include <stddef.h> // For size_t.
 #include <stdint.h> // For uintptr_t.
 
 namespace __llvm_libc {
 namespace cpp {
 
 template <size_t NumberOfBits> struct Bitset {
private:
   static constexpr size_t BitsPerByte = 8;
   static constexpr size_t BitsPerUnit = BitsPerByte * sizeof(uintptr_t);
   uintptr_t Data[(NumberOfBits + BitsPerUnit - 1) / BitsPerUnit] = {0};
 };
 
 } // namespace cpp
 } // namespace __llvm_libc
 
-#endif // LLVM_LIBC_UTILS_CPP_BITSET_H
+#endif // LLVM_LIBC_SRC_SUPPORT_CPP_BITSET_H

libc/src/__support/CPP/Functional.h

 //===-- Self contained functional header ------------------------*- 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_FUNCTIONAL_H
-#define LLVM_LIBC_UTILS_CPP_FUNCTIONAL_H
+#ifndef LLVM_LIBC_SRC_SUPPORT_CPP_FUNCTIONAL_H
+#define LLVM_LIBC_SRC_SUPPORT_CPP_FUNCTIONAL_H
 
 namespace __llvm_libc {
 namespace cpp {
 
 template <typename Func> class Function;
 
 template <typename Ret, typename... Params> class Function<Ret(Params...)> {
   Ret (*func)(Params...) = nullptr;
 
 public:
   constexpr Function() = default;
   template <typename Func> constexpr Function(Func &&f) : func(f) {}
 
   constexpr Ret operator()(Params... params) { return func(params...); }
 };
 
 } // namespace cpp
 } // namespace __llvm_libc
 
-#endif // LLVM_LIBC_UTILS_CPP_FUNCTIONAL_H
+#endif // LLVM_LIBC_SRC_SUPPORT_CPP_FUNCTIONAL_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_UTILS_CPP_LIMITS_H
-#define LLVM_LIBC_UTILS_CPP_LIMITS_H
+#ifndef LLVM_LIBC_SRC_SUPPORT_CPP_LIMITS_H
+#define LLVM_LIBC_SRC_SUPPORT_CPP_LIMITS_H
 
 #include <limits.h>
 
 namespace __llvm_libc {
 namespace cpp {
 
 template <class T> class NumericLimits {
 public:

 public:
   static constexpr __int128_t max() { return ~__uint128_t(0) >> 1; }
   static constexpr __int128_t min() { return __int128_t(1) << 127; }
 };
 
 } // namespace cpp
 } // namespace __llvm_libc
 
-#endif // LLVM_LIBC_UTILS_CPP_LIMITS_H
+#endif // LLVM_LIBC_SRC_SUPPORT_CPP_LIMITS_H

libc/src/__support/CPP/StringView.h

 //===-- Standalone implementation std::string_view --------------*- 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_STRINGVIEW_H
-#define LLVM_LIBC_UTILS_CPP_STRINGVIEW_H
+#ifndef LLVM_LIBC_SRC_SUPPORT_CPP_STRINGVIEW_H
+#define LLVM_LIBC_SRC_SUPPORT_CPP_STRINGVIEW_H
 
 #include <stddef.h>
 
 namespace __llvm_libc {
 namespace cpp {
 
 // This is very simple alternate of the std::string_view class. There is no
 // bounds check performed in any of the methods. The callers are expected to
bool equals(StringView Other) const {
     }
     return true;
   }
 };
 
 } // namespace cpp
 } // namespace __llvm_libc
 
-#endif // LLVM_LIBC_UTILS_CPP_STRINGVIEW_H
+#endif // LLVM_LIBC_SRC_SUPPORT_CPP_STRINGVIEW_H

libc/src/__support/CPP/TypeTraits.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_UTILS_CPP_TYPETRAITS_H
-#define LLVM_LIBC_UTILS_CPP_TYPETRAITS_H
+#ifndef LLVM_LIBC_SRC_SUPPORT_CPP_TYPETRAITS_H
+#define LLVM_LIBC_SRC_SUPPORT_CPP_TYPETRAITS_H
 
 namespace __llvm_libc {
 namespace cpp {
 
 template <bool B, typename T> struct EnableIf;
 template <typename T> struct EnableIf<true, T> { typedef T Type; };
 
 template <bool B, typename T>

 template <typename Type> struct IsArithmetic {
   static constexpr bool Value =
       IsIntegral<Type>::Value || IsFloatingPointType<Type>::Value;
 };
 
 } // namespace cpp
 } // namespace __llvm_libc
 
-#endif // LLVM_LIBC_UTILS_CPP_TYPETRAITS_H
+#endif // LLVM_LIBC_SRC_SUPPORT_CPP_TYPETRAITS_H

libc/src/__support/FPUtil/BasicOperations.h

 //===-- Basic operations on 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_BASIC_OPERATIONS_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_BASIC_OPERATIONS_H
 
 #include "FPBits.h"
 
-#include "utils/CPP/TypeTraits.h"
+#include "src/__support/CPP/TypeTraits.h"
 
 namespace __llvm_libc {
 namespace fputil {
 
 template <typename T,
           cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
 static inline T abs(T x) {
   FPBits<T> bits(x);

libc/src/__support/FPUtil/CMakeLists.txt

HDRS
     PolyEval.h
     UInt.h
     XFloat.h
   DEPENDS
     libc.include.math
     libc.include.errno
     libc.include.fenv
     libc.src.__support.common
-    libc.utils.CPP.standalone_cpp
+    libc.src.__support.CPP.standalone_cpp
 )
 
 add_library(
   LibcFPTestHelpers
     FPExceptMatcher.cpp
     FPExceptMatcher.h
     TestHelpers.cpp
     TestHelpers.h
 )
 target_include_directories(LibcFPTestHelpers PUBLIC ${LIBC_SOURCE_DIR})
 target_link_libraries(LibcFPTestHelpers LibcUnitTest)
 add_dependencies(
   LibcFPTestHelpers
   LibcUnitTest
-  libc.utils.CPP.standalone_cpp
+  libc.src.__support.CPP.standalone_cpp
   libc.src.__support.FPUtil.fputil
 )

libc/src/__support/FPUtil/DivisionAndRemainderOperations.h

 //===-- Floating point divsion and remainder operations ---------*- 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_DIVISION_AND_REMAINDER_OPERATIONS_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_DIVISION_AND_REMAINDER_OPERATIONS_H
 
 #include "FPBits.h"
 #include "ManipulationFunctions.h"
 #include "NormalFloat.h"
 
-#include "utils/CPP/TypeTraits.h"
+#include "src/__support/CPP/TypeTraits.h"
 
 namespace __llvm_libc {
 namespace fputil {
 
 static constexpr int quotientLSBBits = 3;
 
 // The implementation is a bit-by-bit algorithm which uses integer division
 // to evaluate the quotient and remainder.

libc/src/__support/FPUtil/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_FMA_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_FMA_H
 
-#include "utils/CPP/TypeTraits.h"
+#include "src/__support/CPP/TypeTraits.h"
 
 #ifdef __x86_64__
 #include "x86_64/FMA.h"
 #elif defined(__aarch64__)
 #include "aarch64/FMA.h"
 #else
 #include "generic/FMA.h"
 

libc/src/__support/FPUtil/FPBits.h

 //===-- Abstract class for bit manipulation of float numbers. ---*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_SUPPORT_FPUTIL_FP_BITS_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_FP_BITS_H
 
 #include "PlatformDefs.h"
 
-#include "utils/CPP/TypeTraits.h"
+#include "src/__support/CPP/TypeTraits.h"
 
 #include "FloatProperties.h"
 #include <stdint.h>
 
 namespace __llvm_libc {
 namespace fputil {
 
 template <typename T> struct MantissaWidth {

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 "FPBits.h"
-#include "utils/CPP/TypeTraits.h"
+#include "src/__support/CPP/TypeTraits.h"
 
 namespace __llvm_libc {
 namespace fputil {
 
 namespace internal {
 
 template <typename T> static inline T findLeadingOne(T mant, int &shift_length);
 

libc/src/__support/FPUtil/ManipulationFunctions.h

 //===-- Floating-point manipulation functions -------------------*- 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_MANIPULATION_FUNCTIONS_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_MANIPULATION_FUNCTIONS_H
 
 #include "FPBits.h"
 #include "NearestIntegerOperations.h"
 #include "NormalFloat.h"
 #include "PlatformDefs.h"
 
-#include "utils/CPP/TypeTraits.h"
+#include "src/__support/CPP/TypeTraits.h"
 
 #include <limits.h>
 #include <math.h>
 
 namespace __llvm_libc {
 namespace fputil {
 
 template <typename T,

libc/src/__support/FPUtil/NearestIntegerOperations.h

 //===-- Nearest integer floating-point operations ---------------*- 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_NEAREST_INTEGER_OPERATIONS_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_NEAREST_INTEGER_OPERATIONS_H
 
 #include "FEnvUtils.h"
 #include "FPBits.h"
 
-#include "utils/CPP/TypeTraits.h"
+#include "src/__support/CPP/TypeTraits.h"
 
 #include <math.h>
 #if math_errhandling & MATH_ERRNO
 #include <errno.h>
 #endif
 
 namespace __llvm_libc {
 namespace fputil {

libc/src/__support/FPUtil/NormalFloat.h

 //===-- A class to store a normalized floating point number -----*- 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_NORMAL_FLOAT_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_NORMAL_FLOAT_H
 
 #include "FPBits.h"
 
-#include "utils/CPP/TypeTraits.h"
+#include "src/__support/CPP/TypeTraits.h"
 
 #include <stdint.h>
 
 namespace __llvm_libc {
 namespace fputil {
 
 // A class which stores the normalized form of a floating point value.
 // The special IEEE-754 bits patterns of Zero, infinity and NaNs are

libc/src/__support/FPUtil/PolyEval.h

 //===-- Common header for PolyEval 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_POLYEVAL_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_POLYEVAL_H
 
-#include "utils/CPP/TypeTraits.h"
+#include "src/__support/CPP/TypeTraits.h"
 
 // Evaluate polynomial using Horner's Scheme:
 // With polyeval(x, a_0, a_1, ..., a_n) = a_n * x^n + ... + a_1 * x + a_0, we
 // evaluated it as:  a_0 + x * (a_1 + x * ( ... (a_(n-1) + x * a_n) ... ) ) ).
 // We will use fma instructions if available.
 // Example: to evaluate x^3 + 2*x^2 + 3*x + 4, call
 //   polyeval( x, 4.0, 3.0, 2.0, 1.0 )
 

libc/src/__support/FPUtil/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_SQRT_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_SQRT_H
 
 #include "FPBits.h"
 #include "PlatformDefs.h"
 
-#include "utils/CPP/TypeTraits.h"
+#include "src/__support/CPP/TypeTraits.h"
 
 namespace __llvm_libc {
 namespace fputil {
 
 namespace internal {
 
 template <typename T>
 static inline void normalize(int &exponent,

libc/src/__support/FPUtil/SqrtLongDoubleX86.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_SQRT_LONG_DOUBLE_X86_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_SQRT_LONG_DOUBLE_X86_H
 
 #include "FPBits.h"
 #include "Sqrt.h"
 
-#include "utils/CPP/TypeTraits.h"
+#include "src/__support/CPP/TypeTraits.h"
 
 namespace __llvm_libc {
 namespace fputil {
 
 namespace internal {
 
 template <>
 inline void normalize<long double>(int &exponent, __uint128_t &mantissa) {

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

 //===-- Aarch64 implementations of the fma function -------------*- 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_AARCH64_FMA_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_AARCH64_FMA_H
 
-#include "utils/CPP/TypeTraits.h"
+#include "src/__support/CPP/TypeTraits.h"
 
 namespace __llvm_libc {
 namespace fputil {
 
 template <typename T>
 cpp::EnableIfType<cpp::IsSame<T, float>::Value, T> fma(T x, T y, T z) {
   float result;
   __asm__ __volatile__("fmadd %s0, %s1, %s2, %s3\n\t"

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 "utils/CPP/TypeTraits.h"
+#include "src/__support/CPP/TypeTraits.h"
 
 namespace __llvm_libc {
 namespace fputil {
 namespace generic {
 
 template <typename T>
 static inline cpp::EnableIfType<cpp::IsSame<T, float>::Value, T> fma(T x, T y,
                                                                      T z) {

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

 //===-- x86_64 implementations of the fma function --------------*- 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_FMA_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_X86_64_FMA_H
 
-#include "utils/CPP/TypeTraits.h"
+#include "src/__support/CPP/TypeTraits.h"
 
 namespace __llvm_libc {
 namespace fputil {
 
 template <typename T>
 static inline cpp::EnableIfType<cpp::IsSame<T, float>::Value, T> fma(T x, T y,
                                                                      T z) {
   float result = x;

libc/src/__support/integer_operations.h

 //===-- Utils for abs and friends -------------------------------*- 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_STDLIB_ABS_UTILS_H
 #define LLVM_LIBC_SRC_STDLIB_ABS_UTILS_H
 
-#include "utils/CPP/TypeTraits.h"
+#include "src/__support/CPP/TypeTraits.h"
 
 namespace __llvm_libc {
 
 template <typename T>
 static constexpr cpp::EnableIfType<cpp::IsIntegral<T>::Value, T>
 integerAbs(T n) {
   return (n < 0) ? -n : n;
 }

libc/src/__support/str_conv_utils.h

 //===-- Stdlib 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_STDLIB_STDLIB_UTILS_H
 #define LIBC_SRC_STDLIB_STDLIB_UTILS_H
 
+#include "src/__support/CPP/Limits.h"
 #include "src/__support/ctype_utils.h"
-#include "utils/CPP/Limits.h"
 #include <errno.h>
 #include <limits.h>
 
 namespace __llvm_libc {
 namespace internal {
 
 // Returns a pointer to the first character in src that is not a whitespace
 // character (as determined by isspace())

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/FPUtil/FPBits.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_conv_utils.h"
-#include "utils/CPP/Limits.h"
 #include <errno.h>
 
 namespace __llvm_libc {
 namespace internal {
 
 // Shifts right and rounds according to the following rules:
 // 1) If the part being cut off is more than 2^(amountToShift - 1) then round
 // up

libc/src/math/generic/math_utils.h

 //===-- Collection of utils for implementing math functions -----*- 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_MATH_MATH_UTILS_H
 #define LLVM_LIBC_SRC_MATH_MATH_UTILS_H
 
+#include "src/__support/CPP/TypeTraits.h"
 #include "src/__support/common.h"
-#include "utils/CPP/TypeTraits.h"
 #include <errno.h>
 #include <math.h>
 
 #include <stdint.h>
 
 namespace __llvm_libc {
 
 static inline uint32_t as_uint32_bits(float x) {

libc/src/string/CMakeLists.txt

 add_subdirectory(memory_utils)
 
 add_header_library(
   string_utils
   HDRS
     string_utils.h
   DEPENDS
-    libc.utils.CPP.standalone_cpp
+    libc.src.__support.CPP.standalone_cpp
 )
 
 add_entrypoint_object(
   memccpy
   SRCS
     memccpy.cpp
   HDRS
     memccpy.h

 
 add_entrypoint_object(
   strspn
   SRCS
     strspn.cpp
   HDRS
     strspn.h
   DEPENDS
-    libc.utils.CPP.standalone_cpp
+    libc.src.__support.CPP.standalone_cpp
 )
 
 add_entrypoint_object(
   strstr
   SRCS
     strstr.cpp
   HDRS
     strstr.h

libc/src/string/string_utils.h

 //===-- String 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_STRING_STRING_UTILS_H
 #define LIBC_SRC_STRING_STRING_UTILS_H
 
+#include "src/__support/CPP/Bitset.h"
 #include "src/__support/common.h"
-#include "utils/CPP/Bitset.h"
 #include <stddef.h> // size_t
 
 namespace __llvm_libc {
 namespace internal {
 
 // Returns the length of a string, denoted by the first occurrence
 // of a null terminator.
 static inline size_t string_length(const char *src) {

libc/src/string/strspn.cpp

 //===-- Implementation of strspn ------------------------------------------===//
 //
 // 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/string/strspn.h"
 
+#include "src/__support/CPP/Bitset.h"
 #include "src/__support/common.h"
-#include "utils/CPP/Bitset.h"
 #include <stddef.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(size_t, strspn, (const char *src, const char *segment)) {
   const char *initial = src;
   cpp::Bitset<256> bitset;
 
   for (; *segment; ++segment)
     bitset.set(*segment);
   for (; *src && bitset.test(*src); ++src)
     ;
   return src - initial;
 }
 
 } // namespace __llvm_libc

libc/test/config/linux/x86_64/syscall_test.cpp

 //===-- Unittests for x86_64 syscalls -------------------------------------===//
 //
 // 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 "config/linux/syscall.h"
 #include "utils/UnitTest/Test.h"
 
-#include "utils/CPP/Functional.h"
+#include "src/__support/CPP/Functional.h"
 
 TEST(LlvmLibcX86_64_SyscallTest, APITest) {
   // We only do a signature test here. Actual functionality tests are
   // done by the unit tests of the syscall wrappers like mmap.
 
   using __llvm_libc::cpp::Function;
 
   Function<long(long)> f([](long n) { return __llvm_libc::syscall(n); });

libc/test/src/CMakeLists.txt

set_target_properties(
   PROPERTIES
   INCLUDE_DIRECTORIES ""
 )
 # Only include we need is the include for cpp::IsSame and our generated
 # public headers.
 target_include_directories(
   libc-integration-test BEFORE
   PRIVATE
-    "${LIBC_SOURCE_DIR}/utils/CPP"
+    "${LIBC_SOURCE_DIR}/src/__support/CPP"
     "${LIBC_BUILD_DIR}/include"
 )
 target_compile_options(
   libc-integration-test
   PRIVATE
   -ffreestanding
 )
 target_link_options(

libc/test/src/math/CMakeLists.txt

 add_libc_testsuite(libc_math_unittests)
 
 add_fp_unittest(
   cosf_test
   NEED_MPFR
   SUITE
     libc_math_unittests
   SRCS
     cosf_test.cpp
   HDRS
     sdcomp26094.h
   DEPENDS
     libc.include.errno
     libc.src.math.cosf
-    libc.utils.CPP.standalone_cpp
+    libc.src.__support.CPP.standalone_cpp
     libc.src.__support.FPUtil.fputil
 )
 
 add_fp_unittest(
   cos_test
   NEED_MPFR
   SUITE
     libc_math_unittests
SUITE
     libc_math_unittests
   SRCS
     sinf_test.cpp
   HDRS
     sdcomp26094.h
   DEPENDS
     libc.include.errno
     libc.src.math.sinf
-    libc.utils.CPP.standalone_cpp
+    libc.src.__support.CPP.standalone_cpp
     libc.src.__support.FPUtil.fputil
 )
 
 add_fp_unittest(
   sin_test
   NEED_MPFR
   SUITE
     libc_math_unittests
SUITE
     libc_math_unittests
   SRCS
     sincosf_test.cpp
   HDRS
     sdcomp26094.h
   DEPENDS
     libc.include.errno
     libc.src.math.sincosf
-    libc.utils.CPP.standalone_cpp
+    libc.src.__support.CPP.standalone_cpp
     libc.src.__support.FPUtil.fputil
 )
 
 add_fp_unittest(
   fabs_test
   NEED_MPFR
   SUITE
     libc_math_unittests

libc/test/src/math/NextAfterTest.h

 //===-- Utility class to test different flavors of nextafter ----*- 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_TEST_SRC_MATH_NEXTAFTERTEST_H
 #define LLVM_LIBC_TEST_SRC_MATH_NEXTAFTERTEST_H
 
+#include "src/__support/CPP/TypeTraits.h"
 #include "src/__support/FPUtil/BasicOperations.h"
 #include "src/__support/FPUtil/FPBits.h"
 #include "src/__support/FPUtil/TestHelpers.h"
-#include "utils/CPP/TypeTraits.h"
 #include "utils/UnitTest/Test.h"
 #include <math.h>
 
 template <typename T>
 class NextAfterTestTemplate : public __llvm_libc::testing::Test {
   using FPBits = __llvm_libc::fputil::FPBits<T>;
   using MantissaWidth = __llvm_libc::fputil::MantissaWidth<T>;
   using UIntType = typename FPBits::UIntType;

libc/test/src/math/cosf_test.cpp

 //===-- Unittests for cosf ------------------------------------------------===//
 //
 // 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/Array.h"
 #include "src/__support/FPUtil/FPBits.h"
 #include "src/__support/FPUtil/TestHelpers.h"
 #include "src/math/cosf.h"
 #include "test/src/math/sdcomp26094.h"
-#include "utils/CPP/Array.h"
 #include "utils/MPFRWrapper/MPFRUtils.h"
 #include "utils/UnitTest/Test.h"
 #include <math.h>
 
 #include <errno.h>
 #include <stdint.h>
 
 using __llvm_libc::testing::sdcomp26094Values;

libc/test/src/math/sdcomp26094.h

 //===-- SDCOMP-26094 specific items -----------------------------*- 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_TEST_SRC_MATH_SDCOMP26094_H
 #define LLVM_LIBC_TEST_SRC_MATH_SDCOMP26094_H
 
-#include "utils/CPP/Array.h"
+#include "src/__support/CPP/Array.h"
 
 #include <stdint.h>
 
 namespace __llvm_libc {
 namespace testing {
 
 static constexpr __llvm_libc::cpp::Array<uint32_t, 10> sdcomp26094Values{
     0x46427f1b, 0x4647e568, 0x46428bac, 0x4647f1f9, 0x4647fe8a,
     0x45d8d7f1, 0x45d371a4, 0x45ce0b57, 0x45d35882, 0x45cdf235,
 };
 
 } // namespace testing
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_TEST_SRC_MATH_SDCOMP26094_H

libc/test/src/math/sincosf_test.cpp

 //===-- Unittests for sincosf ---------------------------------------------===//
 //
 // 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/Array.h"
 #include "src/__support/FPUtil/FPBits.h"
 #include "src/__support/FPUtil/TestHelpers.h"
 #include "src/math/sincosf.h"
 #include "test/src/math/sdcomp26094.h"
-#include "utils/CPP/Array.h"
 #include "utils/MPFRWrapper/MPFRUtils.h"
 #include "utils/UnitTest/Test.h"
 #include <math.h>
 
 #include <errno.h>
 #include <stdint.h>
 
 using __llvm_libc::testing::sdcomp26094Values;

libc/test/src/math/sinf_test.cpp

 //===-- Unittests for sinf ------------------------------------------------===//
 //
 // 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/Array.h"
 #include "src/__support/FPUtil/FPBits.h"
 #include "src/__support/FPUtil/TestHelpers.h"
 #include "src/math/sinf.h"
 #include "test/src/math/sdcomp26094.h"
-#include "utils/CPP/Array.h"
 #include "utils/MPFRWrapper/MPFRUtils.h"
 #include "utils/UnitTest/Test.h"
 #include <math.h>
 
 #include <errno.h>
 #include <stdint.h>
 
 using __llvm_libc::testing::sdcomp26094Values;

libc/test/src/stdio/fwrite_test.cpp

 //===-- Unittests for fwrite ----------------------------------------------===//
 //
 // 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/Array.h"
 #include "src/stdio/FILE.h"
 #include "src/stdio/fwrite.h"
-#include "utils/CPP/Array.h"
 #include "utils/UnitTest/Test.h"
 
 TEST(LlvmLibcStdio, FWriteBasic) {
   struct StrcpyFile : __llvm_libc::FILE {
     char *buf;
   } f;
   char array[6];
   f.buf = array;

libc/test/src/string/bzero_test.cpp

 //===-- Unittests for bzero -----------------------------------------------===//
 //
 // 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/ArrayRef.h"
 #include "src/string/bzero.h"
-#include "utils/CPP/ArrayRef.h"
 #include "utils/UnitTest/Test.h"
 
 using __llvm_libc::cpp::Array;
 using __llvm_libc::cpp::ArrayRef;
 using Data = Array<char, 2048>;
 
 static const ArrayRef<char> kDeadcode("DEADC0DE", 8);
 

libc/test/src/string/memccpy_test.cpp

 //===-- Unittests for memccpy ---------------------------------------------===//
 //
 // 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/ArrayRef.h"
 #include "src/string/memccpy.h"
-#include "utils/CPP/ArrayRef.h"
 #include "utils/UnitTest/Test.h"
 #include <stddef.h> // For size_t.
 
 class LlvmLibcMemccpyTest : public __llvm_libc::testing::Test {
 public:
   void check_memccpy(__llvm_libc::cpp::MutableArrayRef<char> dst,
                      const __llvm_libc::cpp::ArrayRef<char> src, int end,
                      size_t count,

libc/test/src/string/memcpy_test.cpp

 //===-- Unittests for memcpy ----------------------------------------------===//
 //
 // 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/ArrayRef.h"
 #include "src/string/memcpy.h"
-#include "utils/CPP/ArrayRef.h"
 #include "utils/UnitTest/Test.h"
 
 using __llvm_libc::cpp::Array;
 using __llvm_libc::cpp::ArrayRef;
 using Data = Array<char, 2048>;
 
 static const ArrayRef<char> kNumbers("0123456789", 10);
 static const ArrayRef<char> kDeadcode("DEADC0DE", 8);

libc/test/src/string/memmove_test.cpp

 //===-- Unittests for memmove ---------------------------------------------===//
 //
 // 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/ArrayRef.h"
 #include "src/string/memmove.h"
-#include "utils/CPP/ArrayRef.h"
 #include "utils/UnitTest/Test.h"
 
 class LlvmLibcMemmoveTest : public __llvm_libc::testing::Test {
 public:
   void check_memmove(void *dst, const void *src, size_t count,
                      const unsigned char *str,
                      const __llvm_libc::cpp::ArrayRef<unsigned char> expected) {
     void *result = __llvm_libc::memmove(dst, src, count);

libc/test/src/string/memory_utils/CMakeLists.txt

 add_libc_unittest(
   utils_test
   SUITE
     libc_string_unittests
   SRCS
     elements_test.cpp
     memory_access_test.cpp
     utils_test.cpp
   DEPENDS
     libc.src.string.memory_utils.memory_utils
-    libc.utils.CPP.standalone_cpp
+    libc.src.__support.CPP.standalone_cpp
   COMPILE_OPTIONS
     ${LIBC_COMPILE_OPTIONS_NATIVE}
     -ffreestanding
 )

libc/test/src/string/memory_utils/elements_test.cpp

 //===-- Unittests for memory_utils ----------------------------------------===//
 //
 // 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/Array.h"
 #include "src/string/memory_utils/elements.h"
-#include "utils/CPP/Array.h"
 #include "utils/UnitTest/Test.h"
 
 namespace __llvm_libc {
 
 // Registering Types
 using FixedSizeTypes = testing::TypeList<
 #ifdef __SSE2__
     x86::Vector128, //

libc/test/src/string/memory_utils/memory_access_test.cpp

 //===-- Unittests for memory_utils ----------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #define LLVM_LIBC_UNITTEST_OBSERVE 1
 
+#include "src/__support/CPP/Array.h"
+#include "src/__support/CPP/ArrayRef.h"
 #include "src/string/memory_utils/elements.h"
-#include "utils/CPP/Array.h"
-#include "utils/CPP/ArrayRef.h"
 #include "utils/UnitTest/Test.h"
 
 #include <stdio.h>
 #include <string.h>
 
 namespace __llvm_libc {
 
 static constexpr const size_t kMaxBuffer = 32;

libc/test/src/string/memory_utils/utils_test.cpp

 //===-- Unittests for memory_utils ----------------------------------------===//
 //
 // 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/Array.h"
 #include "src/string/memory_utils/utils.h"
-#include "utils/CPP/Array.h"
 #include "utils/UnitTest/Test.h"
 
 namespace __llvm_libc {
 
 TEST(LlvmLibcUtilsTest, IsPowerOfTwoOrZero) {
   static const cpp::Array<bool, 65> kExpectedValues{
       1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, // 0-15
       1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 16-31

libc/test/src/string/memset_test.cpp

 //===-- Unittests for memset ----------------------------------------------===//
 //
 // 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/ArrayRef.h"
 #include "src/string/memset.h"
-#include "utils/CPP/ArrayRef.h"
 #include "utils/UnitTest/Test.h"
 
 using __llvm_libc::cpp::Array;
 using __llvm_libc::cpp::ArrayRef;
 using Data = Array<char, 2048>;
 
 static const ArrayRef<char> kDeadcode("DEADC0DE", 8);
 

libc/test/src/string/strncpy_test.cpp

 //===-- Unittests for strncpy ---------------------------------------------===//
 //
 // 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/ArrayRef.h"
 #include "src/string/strncpy.h"
-#include "utils/CPP/ArrayRef.h"
 #include "utils/UnitTest/Test.h"
 #include <stddef.h> // For size_t.
 
 class LlvmLibcStrncpyTest : public __llvm_libc::testing::Test {
 public:
   void check_strncpy(__llvm_libc::cpp::MutableArrayRef<char> dst,
                      const __llvm_libc::cpp::ArrayRef<char> src, size_t n,
                      const __llvm_libc::cpp::ArrayRef<char> expected) {

libc/test/utils/CPP/CMakeLists.txt

 add_libc_testsuite(libc_cpp_utils_unittests)
 
 add_libc_unittest(
   bitset_test
   SUITE
     libc_cpp_utils_unittests
   SRCS
     bitset_test.cpp
   DEPENDS
-    libc.utils.CPP.standalone_cpp
+    libc.src.__support.CPP.standalone_cpp
 )
 
 add_libc_unittest(
   stringview_test
   SUITE
     libc_cpp_utils_unittests
   SRCS
     stringview_test.cpp
   DEPENDS
-    libc.utils.CPP.standalone_cpp
+    libc.src.__support.CPP.standalone_cpp
 )
 
 add_libc_unittest(
   limits_test
   SUITE
     libc_cpp_utils_unittests
   SRCS
     limits_test.cpp
   DEPENDS
-    libc.utils.CPP.standalone_cpp
+    libc.src.__support.CPP.standalone_cpp
 )
 
 add_libc_unittest(
   arrayref_test
   SUITE
     libc_cpp_utils_unittests
   SRCS
     arrayref_test.cpp
   DEPENDS
-    libc.utils.CPP.standalone_cpp
+    libc.src.__support.CPP.standalone_cpp
 )

libc/test/utils/CPP/arrayref_test.cpp

 //===-- Unittests for ArrayRef --------------------------------------------===//
 //
 // 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 "utils/CPP/ArrayRef.h"
+#include "src/__support/CPP/ArrayRef.h"
 #include "utils/UnitTest/Test.h"
 
 namespace __llvm_libc {
 namespace cpp {
 
 // The following tests run on both 'ArrayRef' and 'MutableArrayRef'.
 using Types = testing::TypeList<ArrayRef<int>, MutableArrayRef<int>>;
 

libc/test/utils/CPP/bitset_test.cpp

 //===-- Unittests for Bitset ----------------------------------------------===//
 //
 // 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 "utils/CPP/Bitset.h"
+#include "src/__support/CPP/Bitset.h"
 #include "utils/UnitTest/Test.h"
 
 TEST(LlvmLibcBitsetTest, SetBitForSizeEqualToOne) {
   __llvm_libc::cpp::Bitset<1> bitset;
   EXPECT_FALSE(bitset.test(0));
   bitset.set(0);
   EXPECT_TRUE(bitset.test(0));
 }

libc/test/utils/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 "utils/CPP/Limits.h"
+#include "src/__support/CPP/Limits.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);
 

libc/test/utils/CPP/stringview_test.cpp

 //===-- Unittests for StringView ------------------------------------------===//
 //
 // 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 "utils/CPP/StringView.h"
+#include "src/__support/CPP/StringView.h"
 #include "utils/UnitTest/Test.h"
 
 TEST(LlvmLibcStringViewTest, InitializeCheck) {
   __llvm_libc::cpp::StringView v;
   ASSERT_EQ(v.size(), size_t(0));
   ASSERT_TRUE(v.data() == nullptr);
 
   v = __llvm_libc::cpp::StringView("");

libc/test/utils/UnitTest/CMakeLists.txt

 add_libc_testsuite(libc_unittest_tests)
 
 add_libc_unittest(
   testfilter_test
   SUITE
     libc_unittest_tests
   SRCS
     testfilter_test.cpp
   DEPENDS
-    libc.utils.CPP.standalone_cpp
+    libc.src.__support.CPP.standalone_cpp
 )

libc/utils/CMakeLists.txt

-add_subdirectory(CPP)
 add_subdirectory(MPFRWrapper)
 add_subdirectory(testutils)
 add_subdirectory(UnitTest)
 
 if(LLVM_LIBC_FULL_BUILD)
   add_subdirectory(tools)
 endif()

libc/utils/MPFRWrapper/CMakeLists.txt

 if(LIBC_TESTS_CAN_USE_MPFR)
   add_library(libcMPFRWrapper
     MPFRUtils.cpp
     MPFRUtils.h
   )
-  add_dependencies(libcMPFRWrapper libc.utils.CPP.standalone_cpp libc.src.__support.FPUtil.fputil LibcUnitTest)
+  add_dependencies(libcMPFRWrapper libc.src.__support.CPP.standalone_cpp libc.src.__support.FPUtil.fputil LibcUnitTest)
   if(EXISTS ${LLVM_LIBC_MPFR_INSTALL_PATH})
     target_include_directories(libcMPFRWrapper PUBLIC ${LLVM_LIBC_MPFR_INSTALL_PATH}/include)
     target_link_directories(libcMPFRWrapper PUBLIC ${LLVM_LIBC_MPFR_INSTALL_PATH}/lib)
   endif()
   target_link_libraries(libcMPFRWrapper LibcFPTestHelpers LibcUnitTest mpfr gmp)
 else()
   message(WARNING "Math tests using MPFR will be skipped.")
 endif()

libc/utils/MPFRWrapper/MPFRUtils.h

 //===-- MPFRUtils.h ---------------------------------------------*- 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_TESTUTILS_MPFRUTILS_H
 #define LLVM_LIBC_UTILS_TESTUTILS_MPFRUTILS_H
 
-#include "utils/CPP/TypeTraits.h"
+#include "src/__support/CPP/TypeTraits.h"
 #include "utils/UnitTest/Test.h"
 
 #include <stdint.h>
 
 namespace __llvm_libc {
 namespace testing {
 namespace mpfr {
 

libc/utils/MPFRWrapper/MPFRUtils.cpp

 //===-- Utils which wrap MPFR ---------------------------------------------===//
 //
 // 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 "MPFRUtils.h"
 
+#include "src/__support/CPP/StringView.h"
 #include "src/__support/FPUtil/FPBits.h"
 #include "src/__support/FPUtil/TestHelpers.h"
-#include "utils/CPP/StringView.h"
 
 #include <cmath>
 #include <memory>
 #include <stdint.h>
 #include <string>
 
 #ifdef CUSTOM_MPFR_INCLUDER
 // Some downstream repos are monoliths carrying MPFR sources in their third

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

libc/utils/UnitTest/LibcTest.h

 //===-- Base class for libc unittests ---------------------------*- 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_UNITTEST_LIBCTEST_H
 #define LLVM_LIBC_UTILS_UNITTEST_LIBCTEST_H
 
-// This file can only include headers from utils/CPP/ or utils/testutils. No
-// other headers should be included.
+// This file can only include headers from src/__support/CPP/ or
+// utils/testutils. No other headers should be included.
 
 #include "PlatformDefs.h"
 
-#include "utils/CPP/TypeTraits.h"
+#include "src/__support/CPP/TypeTraits.h"
 #include "utils/testutils/ExecuteFunction.h"
 #include "utils/testutils/StreamWrapper.h"
 
 namespace __llvm_libc {
 namespace testing {
 
 class RunContext;