[libc][NFC] Use STL case for array

[gchatelet]

Summary

Migrating all private STL code to the standard STL case but keeping it under the CPP namespace to avoid confusion.

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_SRC_SUPPORT_CPP_ARRAYREF_H
 #define LLVM_LIBC_SRC_SUPPORT_CPP_ARRAYREF_H
 
-#include "Array.h"
+#include "array.h"
 #include "type_traits.h" // RemoveCVType
 
 #include <stddef.h> // For size_t.
 
 namespace __llvm_libc {
 namespace cpp {
 
 // The implementations of ArrayRef and MutableArrayRef in this file are based
private:
   using Impl::Impl;
 
 public:
   // Construct an ArrayRef from void * pointer.
   // |Length| is the byte length of the array pointed to by |Data|.
   ArrayRef(const void *Data, size_t Length)
       : Impl(reinterpret_cast<const T *>(Data), Length / sizeof(T)) {}
 
-  // From Array.
-  template <size_t N> ArrayRef(const Array<T, N> &Arr) : Impl(Arr.Data, N) {}
+  // From array.
+  template <size_t N> ArrayRef(const array<T, N> &Arr) : Impl(Arr.Data, N) {}
 };
 
 template <typename T>
 struct MutableArrayRef : public internal::ArrayRefBase<T> {
 private:
   static_assert(
       is_same_v<T, remove_cv_t<T>>,
       "MutableArrayRef must have a non-const, non-volatile value_type");
   using Impl = internal::ArrayRefBase<T>;
   using Impl::Impl;
 
 public:
   // Construct an ArrayRef from void * pointer.
   // |Length| is the byte length of the array pointed to by |Data|.
   MutableArrayRef(void *Data, size_t Length)
       : Impl(reinterpret_cast<T *>(Data), Length / sizeof(T)) {}
 
-  // From Array.
-  template <size_t N> MutableArrayRef(Array<T, N> &Arr) : Impl(Arr.Data, N) {}
+  // From array.
+  template <size_t N> MutableArrayRef(array<T, N> &Arr) : Impl(Arr.Data, N) {}
 
   operator ArrayRef<T>() const {
     return ArrayRef<T>(this->data(), this->size());
   }
 };
 
 } // namespace cpp
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_CPP_ARRAYREF_H

libc/src/__support/CPP/CMakeLists.txt

 add_header_library(
   array
   HDRS
-    Array.h
+    array.h
 )
 
 add_header_library(
   uint
   HDRS
     UInt.h
   DEPENDS
     .array

libc/src/__support/CPP/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 "array.h"
 
 #include <stddef.h> // For size_t
 #include <stdint.h>
 
 namespace __llvm_libc {
 namespace cpp {
 
 template <size_t Bits> class UInt {
public:
 
   // Initialize the first word to |v| and the rest to 0.
   constexpr UInt(uint64_t v) {
     val[0] = v;
     for (size_t i = 1; i < WordCount; ++i) {
       val[i] = 0;
     }
   }
-  constexpr explicit UInt(const cpp::Array<uint64_t, WordCount> &words) {
+  constexpr explicit UInt(const cpp::array<uint64_t, WordCount> &words) {
     for (size_t i = 0; i < WordCount; ++i)
       val[i] = words[i];
   }
 
   constexpr explicit operator uint64_t() const { return val[0]; }
 
   constexpr explicit operator uint32_t() const {
     return uint32_t(uint64_t(*this));
public:
   // 64-bit words of this number and |x| in to 32-bit halves but peforming
   // the operations using 64-bit numbers. This ensures that we don't lose the
   // carry bits.
   // Returns the carry value produced by the multiplication operation.
   constexpr uint64_t mul(uint64_t x) {
     uint64_t x_lo = low(x);
     uint64_t x_hi = high(x);
 
-    cpp::Array<uint64_t, WordCount + 1> row1;
+    cpp::array<uint64_t, WordCount + 1> row1;
     uint64_t carry = 0;
     for (size_t i = 0; i < WordCount; ++i) {
       uint64_t l = low(val[i]);
       uint64_t h = high(val[i]);
       uint64_t p1 = x_lo * l;
       uint64_t p2 = x_lo * h;
 
       uint64_t res_lo = low(p1) + carry;
       carry = high(res_lo);
       uint64_t res_hi = high(p1) + low(p2) + carry;
       carry = high(res_hi) + high(p2);
 
       res_lo = low(res_lo);
       res_hi = low(res_hi);
       row1[i] = res_lo + (res_hi << 32);
     }
     row1[WordCount] = carry;
 
-    cpp::Array<uint64_t, WordCount + 1> row2;
+    cpp::array<uint64_t, WordCount + 1> row2;
     row2[0] = 0;
     carry = 0;
     for (size_t i = 0; i < WordCount; ++i) {
       uint64_t l = low(val[i]);
       uint64_t h = high(val[i]);
       uint64_t p1 = x_hi * l;
       uint64_t p2 = x_hi * h;
 

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_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 {
+  static_assert(N != 0, "Cannot create a __llvm_libc::cpp::array of size 0.");
 
   T Data[N];
 
   using iterator = T *;
   using const_iterator = const T *;
 
   constexpr T *data() { return Data; }
   constexpr const T *data() const { return Data; }

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

TYPED_TEST(LlvmLibcArrayRefTest, ConstructFromCArray, Types) {
   EXPECT_EQ(arrayref[0], 1);
   EXPECT_EQ(arrayref[1], 2);
   EXPECT_EQ((const_pointer)arrayref.data(), (const_pointer)values);
 }
 
 TYPED_TEST(LlvmLibcArrayRefTest, ConstructFromLibcArray, Types) {
   using value_type = typename ParamType::value_type;
   using const_pointer = typename ParamType::const_pointer;
-  Array<value_type, 2> values = {1, 2};
+  array<value_type, 2> values = {1, 2};
   ParamType arrayref(values);
   EXPECT_FALSE(arrayref.empty());
   EXPECT_EQ(arrayref.size(), size_t(2));
   EXPECT_EQ(arrayref[0], 1);
   EXPECT_EQ(arrayref[1], 2);
   EXPECT_EQ((const_pointer)arrayref.data(), (const_pointer)values.data());
 }
 

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/math/cosf.h"
 #include "test/src/math/sdcomp26094.h"
 #include "utils/MPFRWrapper/MPFRUtils.h"
 #include "utils/UnitTest/FPMatcher.h"
 #include "utils/UnitTest/Test.h"
 #include <math.h>
 

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 "src/__support/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> SDCOMP26094_VALUES{
+static constexpr __llvm_libc::cpp::array<uint32_t, 10> SDCOMP26094_VALUES{
     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/math/sincosf.h"
 #include "test/src/math/sdcomp26094.h"
 #include "utils/MPFRWrapper/MPFRUtils.h"
 #include "utils/UnitTest/FPMatcher.h"
 #include "utils/UnitTest/Test.h"
 #include <math.h>
 

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/math/sinf.h"
 #include "test/src/math/sdcomp26094.h"
 #include "utils/MPFRWrapper/MPFRUtils.h"
 #include "utils/UnitTest/FPMatcher.h"
 #include "utils/UnitTest/Test.h"
 #include <math.h>
 

libc/test/src/stdlib/atexit_test.cpp

 //===-- Unittests for atexit ----------------------------------------------===//
 //
 // 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/CPP/Utility.h"
+#include "src/__support/CPP/array.h"
 #include "src/stdlib/atexit.h"
 #include "src/stdlib/exit.h"
 #include "utils/UnitTest/Test.h"
 
 static int a;
 TEST(LlvmLibcAtExit, Basic) {
   // In case tests ever run multiple times.
   a = 0;
TEST(LlvmLibcAtExit, AtExitCallsSysExit) {
   auto test = [] {
     __llvm_libc::atexit(+[] { _Exit(1); });
     __llvm_libc::exit(0);
   };
   EXPECT_EXITS(test, 1);
 }
 
 static int size;
-static __llvm_libc::cpp::Array<int, 256> arr;
+static __llvm_libc::cpp::array<int, 256> arr;
 
 template <int... Ts>
 void register_atexit_handlers(__llvm_libc::cpp::IntegerSequence<int, Ts...>) {
   (__llvm_libc::atexit(+[] { arr[size++] = Ts; }), ...);
 }
 
 template <int count> constexpr auto getTest() {
   return [] {

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/UnitTest/Test.h"
 
-using __llvm_libc::cpp::Array;
+using __llvm_libc::cpp::array;
 using __llvm_libc::cpp::ArrayRef;
-using Data = Array<char, 2048>;
+using Data = array<char, 2048>;
 
 static const ArrayRef<char> k_deadcode("DEADC0DE", 8);
 
 // Returns a Data object filled with a repetition of `filler`.
 Data get_data(ArrayRef<char> filler) {
   Data out;
   for (size_t i = 0; i < out.size(); ++i)
     out[i] = filler[i % filler.size()];

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/UnitTest/Test.h"
 
-using __llvm_libc::cpp::Array;
+using __llvm_libc::cpp::array;
 using __llvm_libc::cpp::ArrayRef;
-using Data = Array<char, 2048>;
+using Data = array<char, 2048>;
 
 static const ArrayRef<char> k_numbers("0123456789", 10);
 static const ArrayRef<char> k_deadcode("DEADC0DE", 8);
 
 // Returns a Data object filled with a repetition of `filler`.
 Data get_data(ArrayRef<char> filler) {
   Data out;
   for (size_t i = 0; i < out.size(); ++i)

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/UnitTest/MemoryMatcher.h"
 #include "utils/UnitTest/Test.h"
 
-using __llvm_libc::cpp::Array;
+using __llvm_libc::cpp::array;
 using __llvm_libc::cpp::ArrayRef;
 using __llvm_libc::cpp::MutableArrayRef;
 
 TEST(LlvmLibcMemmoveTest, MoveZeroByte) {
   char Buffer[] = {'a', 'b', 'y', 'z'};
   const char Expected[] = {'a', 'b', 'y', 'z'};
   void *const Dst = Buffer;
   void *const Ret = __llvm_libc::memmove(Dst, Buffer + 2, 0);

 }
 
 void Randomize(MutableArrayRef<char> Buffer) {
   for (auto &current : Buffer)
     current = GetRandomChar();
 }
 
 TEST(LlvmLibcMemmoveTest, Thorough) {
-  using LargeBuffer = Array<char, 3 * kMaxSize>;
+  using LargeBuffer = array<char, 3 * kMaxSize>;
   LargeBuffer GroundTruth;
   Randomize(GroundTruth);
   for (int Size = 0; Size < kMaxSize; ++Size) {
     for (int Offset = -Size; Offset < Size; ++Offset) {
       LargeBuffer Buffer = GroundTruth;
       LargeBuffer Expected = GroundTruth;
       size_t DstOffset = kMaxSize;
       size_t SrcOffset = kMaxSize + Offset;

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

 #define LLVM_LIBC_USE_BUILTIN_MEMCPY_INLINE 0
 #define LLVM_LIBC_USE_BUILTIN_MEMSET_INLINE 0
 
 #include "utils/UnitTest/Test.h"
-#include <src/__support/CPP/Array.h>
+#include <src/__support/CPP/array.h>
 #include <src/string/memory_utils/algorithm.h>
 #include <src/string/memory_utils/backends.h>
 
 #include <sstream>
 
 namespace __llvm_libc {
 
-struct alignas(64) Buffer : cpp::Array<char, 128> {
+struct alignas(64) Buffer : cpp::array<char, 128> {
   bool contains(const char *ptr) const {
     return ptr >= data() && ptr < (data() + size());
   }
   size_t getOffset(const char *ptr) const { return ptr - data(); }
   void fill(char c) {
     for (auto itr = begin(); itr != end(); ++itr)
       *itr = c;
   }

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

 //===-- Unittests for backends --------------------------------------------===//
 //
 // 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/CPP/ArrayRef.h"
 #include "src/__support/CPP/Bit.h"
+#include "src/__support/CPP/array.h"
 #include "src/__support/architectures.h"
 #include "src/string/memory_utils/backends.h"
 #include "utils/UnitTest/Test.h"
 #include <string.h>
 
 namespace __llvm_libc {
 
-template <size_t Size> using Buffer = cpp::Array<char, Size>;
+template <size_t Size> using Buffer = cpp::array<char, Size>;
 
 static char GetRandomChar() {
   // Implementation of C++ minstd_rand seeded with 123456789.
   // https://en.cppreference.com/w/cpp/numeric/random
   // "Minimum standard", recommended by Park, Miller, and Stockmeyer in 1993
   static constexpr const uint64_t a = 48271;
   static constexpr const uint64_t c = 0;
   static constexpr const uint64_t m = 2147483647;

 #endif                           // defined(LLVM_LIBC_ARCH_X86)
     Conf<Scalar64BitBackend, 1>, //
     Conf<Scalar64BitBackend, 2>, //
     Conf<Scalar64BitBackend, 4>, //
     Conf<Scalar64BitBackend, 8>  //
     >;
 
 TYPED_TEST(LlvmLibcMemoryBackend, splat, FunctionTypes) {
-  for (auto value : cpp::Array<uint8_t, 3>{0u, 1u, 255u}) {
+  for (auto value : cpp::array<uint8_t, 3>{0u, 1u, 255u}) {
     alignas(64) const auto stored = ParamType::splat(bit_cast<ubyte>(value));
     for (size_t i = 0; i < ParamType::SIZE; ++i)
       EXPECT_EQ(bit_cast<uint8_t>(stored[i]), value);
   }
 }
 
 TYPED_TEST(LlvmLibcMemoryBackend, notEquals, FunctionTypes) {
   alignas(64) const auto a = GetRandomBuffer<ParamType::SIZE>();

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/__support/CPP/ArrayRef.h"
+#include "src/__support/CPP/array.h"
 #include "src/string/memory_utils/elements.h"
 #include "utils/UnitTest/Test.h"
 
 namespace __llvm_libc {
 
 // Registering Types
 using FixedSizeTypes = testing::TypeList<
 #if defined(__SSE2__)
char GetRandomChar() {
   return seed;
 }
 
 void Randomize(cpp::MutableArrayRef<char> buffer) {
   for (auto &current : buffer)
     current = GetRandomChar();
 }
 
-template <typename Element> using Buffer = cpp::Array<char, Element::SIZE>;
+template <typename Element> using Buffer = cpp::array<char, Element::SIZE>;
 
 template <typename Element> Buffer<Element> GetRandomBuffer() {
   Buffer<Element> buffer;
   Randomize(buffer);
   return buffer;
 }
 
 TYPED_TEST(LlvmLibcMemoryElements, copy, FixedSizeTypes) {
   Buffer<ParamType> Dst;
   const auto buffer = GetRandomBuffer<ParamType>();
   copy<ParamType>(Dst.data(), buffer.data());
   for (size_t i = 0; i < ParamType::SIZE; ++i)
     EXPECT_EQ(Dst[i], buffer[i]);
 }
 
 template <typename T> T copy(const T &Input) {
   T Output;
   for (size_t I = 0; I < Input.size(); ++I)
     Output[I] = Input[I];
   return Output;
 }
 
 TYPED_TEST(LlvmLibcMemoryElements, Move, FixedSizeTypes) {
   constexpr size_t SIZE = ParamType::SIZE;
-  using LargeBuffer = cpp::Array<char, SIZE * 2>;
+  using LargeBuffer = cpp::array<char, SIZE * 2>;
   LargeBuffer GroundTruth;
   Randomize(GroundTruth);
   // Forward, we move the SIZE first bytes from offset 0 to SIZE.
   for (size_t Offset = 0; Offset < SIZE; ++Offset) {
     LargeBuffer Buffer = copy(GroundTruth);
     move<ParamType>(&Buffer[Offset], &Buffer[0]);
     for (size_t I = 0; I < SIZE; ++I)
       EXPECT_EQ(Buffer[I + Offset], GroundTruth[I]);
for (size_t i = 0; i < ParamType::SIZE; ++i) {
     const auto *greater = copy.data();
     EXPECT_LT(three_way_compare<ParamType>(less, greater), 0);
     EXPECT_GT(three_way_compare<ParamType>(greater, less), 0);
   }
 }
 
 TYPED_TEST(LlvmLibcMemoryElements, Splat, FixedSizeTypes) {
   Buffer<ParamType> Dst;
-  const cpp::Array<char, 3> values = {char(0x00), char(0x7F), char(0xFF)};
+  const cpp::array<char, 3> values = {char(0x00), char(0x7F), char(0xFF)};
   for (char value : values) {
     splat_set<ParamType>(Dst.data(), value);
     for (size_t i = 0; i < ParamType::SIZE; ++i)
       EXPECT_EQ(Dst[i], value);
   }
 }
 
 } // namespace __llvm_libc

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/__support/CPP/array.h"
 #include "src/string/memory_utils/elements.h"
 #include "utils/UnitTest/Test.h"
 
 #include <stdio.h>
 #include <string.h>
 
 namespace __llvm_libc {
 
 static constexpr const size_t kMaxBuffer = 32;
 
-struct BufferAccess : cpp::Array<char, kMaxBuffer + 1> {
+struct BufferAccess : cpp::array<char, kMaxBuffer + 1> {
   BufferAccess() { Reset(); }
   void Reset() {
     for (auto &value : *this)
       value = '0';
     this->operator[](kMaxBuffer) = '\0';
   }
   void Touch(ptrdiff_t offset, size_t size) {
     if (offset < 0)
       return;
     for (size_t i = 0; i < size; ++i)
       ++(*this)[offset + i];
   }
   operator const char *() const { return this->data(); }
 };
 
 struct Buffer {
   ptrdiff_t Offset(const char *ptr) const {
     const bool contained = ptr >= data.begin() && ptr < data.end();
     return contained ? ptr - data.begin() : -1;
   }
   void Reset() {
     reads.Reset();
     writes.Reset();
   }
-  cpp::Array<char, kMaxBuffer> data;
+  cpp::array<char, kMaxBuffer> data;
   BufferAccess __attribute__((aligned(64))) reads;
   BufferAccess __attribute__((aligned(64))) writes;
 };
 
 struct MemoryAccessObserver {
   void ObserveRead(const char *ptr, size_t size) {
     Buffer1.reads.Touch(Buffer1.Offset(ptr), size);
     Buffer2.reads.Touch(Buffer2.Offset(ptr), size);

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/__support/CPP/array.h"
 #include "src/string/memory_utils/utils.h"
 #include "utils/UnitTest/Test.h"
 
 namespace __llvm_libc {
 
 TEST(LlvmLibcUtilsTest, IsPowerOfTwoOrZero) {
-  static const cpp::Array<bool, 65> kExpectedValues{
+  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
       1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 32-47
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 48-63
       1                                               // 64
   };
   for (size_t i = 0; i < kExpectedValues.size(); ++i)
     EXPECT_EQ(is_power2_or_zero(i), kExpectedValues[i]);
 }
 
 TEST(LlvmLibcUtilsTest, IsPowerOfTwo) {
-  static const cpp::Array<bool, 65> kExpectedValues{
+  static const cpp::array<bool, 65> kExpectedValues{
       0, 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
       1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 32-47
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 48-63
       1                                               // 64
   };
   for (size_t i = 0; i < kExpectedValues.size(); ++i)
     EXPECT_EQ(is_power2(i), kExpectedValues[i]);
 }
 
 TEST(LlvmLibcUtilsTest, Log2) {
-  static const cpp::Array<size_t, 65> kExpectedValues{
+  static const cpp::array<size_t, 65> kExpectedValues{
       0, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, // 0-15
       4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, // 16-31
       5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, // 32-47
       5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, // 48-63
       6                                               // 64
   };
   for (size_t i = 0; i < kExpectedValues.size(); ++i)
     EXPECT_EQ(log2(i), kExpectedValues[i]);
 }
 
 TEST(LlvmLibcUtilsTest, LEPowerOf2) {
-  static const cpp::Array<size_t, 65> kExpectedValues{
+  static const cpp::array<size_t, 65> kExpectedValues{
       0,  1,  2,  2,  4,  4,  4,  4,  8,  8,  8,  8,  8,  8,  8,  8,  // 0-15
       16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, // 16-31
       32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, // 32-47
       32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, // 48-63
       64                                                              // 64
   };
   for (size_t i = 0; i < kExpectedValues.size(); ++i)
     EXPECT_EQ(le_power2(i), kExpectedValues[i]);
 }
 
 TEST(LlvmLibcUtilsTest, GEPowerOf2) {
-  static const cpp::Array<size_t, 66> kExpectedValues{
+  static const cpp::array<size_t, 66> kExpectedValues{
       0,  1,  2,  4,  4,  8,  8,  8,  8,  16, 16, 16, 16, 16, 16, 16, // 0-15
       16, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, // 16-31
       32, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, // 32-47
       64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, // 48-63
       64, 128                                                         // 64-65
   };
   for (size_t i = 0; i < kExpectedValues.size(); ++i)
     EXPECT_EQ(ge_power2(i), kExpectedValues[i]);

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/UnitTest/Test.h"
 
-using __llvm_libc::cpp::Array;
+using __llvm_libc::cpp::array;
 using __llvm_libc::cpp::ArrayRef;
-using Data = Array<char, 2048>;
+using Data = array<char, 2048>;
 
 static const ArrayRef<char> k_deadcode("DEADC0DE", 8);
 
 // Returns a Data object filled with a repetition of `filler`.
 Data get_data(ArrayRef<char> filler) {
   Data out;
   for (size_t i = 0; i < out.size(); ++i)
     out[i] = filler[i % filler.size()];

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

hdrs = [
         "src/__support/common.h",
         "src/__support/endian.h",
         "src/__support/sanitizer.h",
     ],
 )
 
 cc_library(
     name = "__support_cpp_array",
-    hdrs = ["src/__support/CPP/Array.h"],
+    hdrs = ["src/__support/CPP/array.h"],
     deps = [":libc_root"],
 )
 
 cc_library(
     name = "__support_cpp_array_ref",
     hdrs = ["src/__support/CPP/ArrayRef.h"],
     deps = [
         ":__support_cpp_array",