[libc][cpp] Add a constructor to ArrayRef to construct from void * data.

[sivachandra]

Summary

Also modified operator[] to return a reference to the array element.

libc/src/__support/CPP/ArrayRef.h

public:
   QualifiedT *data() const { return Data; }
   size_t size() const { return Length; }
 
   auto begin() const { return data(); }
   auto end() const { return data() + size(); }
 
   bool empty() const { return size() == 0; }
 
-  auto operator[](size_t Index) const { return data()[Index]; }
+  auto &operator[](size_t Index) const { return data()[Index]; }
 
   // slice(n, m) - Chop off the first N elements of the array, and keep M
   // elements in the array.
   auto slice(size_t N, size_t M) const { return ArrayRefBase(data() + N, M); }
   // slice(n) - Chop off the first N elements of the array.
   auto slice(size_t N) const { return slice(N, size() - N); }
 
   // Drop the first \p N elements of the array.

 template <typename T> struct ArrayRef : public internal::ArrayRefBase<const T> {
 private:
   static_assert(IsSameV<T, RemoveCVType<T>>,
                 "ArrayRef must have a non-const, non-volatile value_type");
   using Impl = internal::ArrayRefBase<const T>;
   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) {}
 };
 
 template <typename T>
 struct MutableArrayRef : public internal::ArrayRefBase<T> {
 private:
   static_assert(
       IsSameV<T, RemoveCVType<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) {}
 
   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/test/src/__support/CPP/arrayref_test.cpp

ParamType arrayref(values);
     EXPECT_TRUE(arrayref.take_back(2).equals(values));
   }
   {
     value_type values[] = {1, 2, 3};
     EXPECT_TRUE(arrayref.take_back(3).equals(values));
   }
 }
 
+TEST(LlvmLibcArrayRefTest, ConstructFromVoidPtr) {
+  unsigned data[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+  void *ptr = data;
+  const void *const_ptr = data;
+  ArrayRef<unsigned> ref(const_ptr, sizeof(data));
+  MutableArrayRef<unsigned> mutable_ref(ptr, sizeof(data));
+  ASSERT_EQ(ref.size(), sizeof(data) / sizeof(unsigned));
+  ASSERT_EQ(mutable_ref.size(), sizeof(data) / sizeof(unsigned));
+
+  unsigned val = 123;
+  for (size_t i = 0; i < sizeof(data) / sizeof(unsigned); ++i)
+    mutable_ref[i] = val;
+
+  for (size_t i = 0; i < sizeof(data) / sizeof(unsigned); ++i)
+    ASSERT_EQ(ref[i], val);
+}
+
 } // namespace cpp
 } // namespace __llvm_libc