Fix layering StringRef copy using BumpPtrAllocator.

Now to copy a string into a BumpPtrAllocator and get a StringRef to the copy:

   StringRef myCopy = myStr.copy(myAllocator);
   



git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@200885 91177308-0d34-0410-b5e6-96231b3b80d8

include/llvm/ADT/ArrayRef.h

@@ -12,6 +12,7 @@
 
 #include "llvm/ADT/None.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/Support/Allocator.h"
 #include <vector>
 
 namespace llvm {
@@ -120,6 +121,13 @@ namespace llvm {
       return Data[Length-1];
     }
 
+    // copy - Allocate copy in BumpPtrAllocator and return ArrayRef<T> to it.
+    ArrayRef<T> copy(BumpPtrAllocator &Allocator) {
+      T *Buff = Allocator.Allocate<T>(Length);
+      std::copy(begin(), end(), Buff);
+      return ArrayRef<T>(Buff, Length);
+    }
+
     /// equals - Check for element-wise equality.
     bool equals(ArrayRef RHS) const {
       if (Length != RHS.Length)

include/llvm/ADT/StringRef.h

@@ -11,6 +11,7 @@
 #define LLVM_ADT_STRINGREF_H
 
 #include "llvm/Support/type_traits.h"
+#include "llvm/Support/Allocator.h"
 #include <algorithm>
 #include <cassert>
 #include <cstring>
@@ -124,6 +125,13 @@ namespace llvm {
       return Data[Length-1];
     }
 
+    // copy - Allocate copy in BumpPtrAllocator and return StringRef to it.
+    StringRef copy(BumpPtrAllocator &Allocator) {
+      char *S = Allocator.Allocate<char>(Length);
+      std::copy(begin(), end(), S);
+      return StringRef(S, Length);
+    }
+
     /// equals - Check for string equality, this is more efficient than
     /// compare() when the relative ordering of inequal strings isn't needed.
     bool equals(StringRef RHS) const {

include/llvm/Support/Allocator.h

@@ -14,8 +14,6 @@
 #ifndef LLVM_SUPPORT_ALLOCATOR_H
 #define LLVM_SUPPORT_ALLOCATOR_H
 
-#include "llvm/ADT/ArrayRef.h"
-#include "llvm/ADT/StringRef.h"
 #include "llvm/Support/AlignOf.h"
 #include "llvm/Support/DataTypes.h"
 #include "llvm/Support/MathExtras.h"
@@ -181,40 +179,6 @@ public:
 
   void PrintStats() const;
   
-  
-  /// Allocate space and copy content into it.
-  void *allocateCopy(const void *Src, size_t Size, size_t Alignment=1) {
-    void *P = Allocate(Size, Alignment);
-    memcpy(P, Src, Size);
-    return P;
-  }
-  
-  /// Allocate space for an array of type T, and use std::copy()
-  /// to copy the array contents.
-  template <typename T>
-  typename enable_if<isPodLike<T>, T*>::type
-  allocateCopy(const T Src[], size_t Num) {
-    T *P = Allocate<T>(Num);
-    std::copy(Src, &Src[Num], P);
-    return P;
-  }
-
-  /// Copy a StringRef by allocating copy in BumpPtrAllocator.
-  StringRef allocateCopy(StringRef Str) {
-    size_t Length = Str.size();
-    char *P = allocateCopy<char>(Str.data(), Length);
-    return StringRef(P, Length);
-  }
-
-  /// Copy a ArrayRef<T> by allocating copy in BumpPtrAllocator.
-  template <typename T>
-  typename enable_if<isPodLike<T>, ArrayRef<T> >::type
-  allocateCopy(ArrayRef<T> Src) {
-    size_t Length = Src.size();
-    T *P = allocateCopy<T>(Src.data(), Length);
-    return makeArrayRef(P, Length);
-  }
-
   /// Compute the total physical memory allocated by this allocator.
   size_t getTotalMemory() const;
 };

unittests/ADT/ArrayRefTest.cpp

@@ -0,0 +1,33 @@
+//===- llvm/unittest/ADT/ArrayRefTest.cpp - ArrayRef unit tests -----------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/Support/Allocator.h"
+#include "llvm/Support/raw_ostream.h"
+#include "gtest/gtest.h"
+using namespace llvm;
+
+namespace llvm {
+
+TEST(ArrayRefTest, AllocatorCopy) {
+  BumpPtrAllocator Alloc;
+  static const uint16_t Words1[] = { 1, 4, 200, 37 };
+  ArrayRef<uint16_t> Array1 = makeArrayRef(Words1, 4);
+  static const uint16_t Words2[] = { 11, 4003, 67, 64000, 13 };
+  ArrayRef<uint16_t> Array2 = makeArrayRef(Words2, 5);
+  ArrayRef<uint16_t> Array1c = Array1.copy(Alloc);
+  ArrayRef<uint16_t> Array2c = Array2.copy(Alloc);;
+  EXPECT_TRUE(Array1.equals(Array1c));
+  EXPECT_NE(Array1.data(), Array1c.data());
+  EXPECT_TRUE(Array2.equals(Array2c));
+  EXPECT_NE(Array2.data(), Array2c.data());
+}
+
+
+} // end anonymous namespace

unittests/ADT/CMakeLists.txt

@@ -5,6 +5,7 @@ set(LLVM_LINK_COMPONENTS
 set(ADTSources
   APFloatTest.cpp
   APIntTest.cpp
+  ArrayRefTest.cpp
   BitVectorTest.cpp
   DAGDeltaAlgorithmTest.cpp
   DeltaAlgorithmTest.cpp

unittests/ADT/StringRefTest.cpp

@@ -11,6 +11,7 @@
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
+#include "llvm/Support/Allocator.h"
 #include "llvm/Support/raw_ostream.h"
 #include "gtest/gtest.h"
 using namespace llvm;
@@ -531,4 +532,18 @@ TEST(StringRefTest, joinStrings) {
   EXPECT_TRUE(v2_join3);
 }
 
+
+TEST(StringRefTest, AllocatorCopy) {
+  BumpPtrAllocator Alloc;
+  StringRef Str1 = "hello";
+  StringRef Str2 = "bye";
+  StringRef Str1c = Str1.copy(Alloc);
+  StringRef Str2c = Str2.copy(Alloc);
+  EXPECT_TRUE(Str1.equals(Str1c));
+  EXPECT_NE(Str1.data(), Str1c.data());
+  EXPECT_TRUE(Str2.equals(Str2c));
+  EXPECT_NE(Str2.data(), Str2c.data());
+}
+
+
 } // end anonymous namespace

unittests/Support/AllocatorTest.cpp

@@ -147,32 +147,4 @@ TEST(AllocatorTest, TestBigAlignment) {
   EXPECT_LE(Ptr + 3000, ((uintptr_t)Slab) + Slab->Size);
 }
 
-TEST(AllocatorTest, CopyStringRef) {
-  BumpPtrAllocator Alloc;
-  StringRef Str1 = "hello";
-  StringRef Str2 = "bye";
-  StringRef Str1c = Alloc.allocateCopy(Str1);
-  StringRef Str2c = Alloc.allocateCopy(Str2);
-  EXPECT_TRUE(Str1.equals(Str1c));
-  EXPECT_NE(Str1.data(), Str1c.data());
-  EXPECT_TRUE(Str2.equals(Str2c));
-  EXPECT_NE(Str2.data(), Str2c.data());
-}
-
-TEST(AllocatorTest, CopyArrayRef) {
-  BumpPtrAllocator Alloc;
-  static const uint16_t Words1[] = { 1, 4, 200, 37 };
-  ArrayRef<uint16_t> Array1 = makeArrayRef(Words1, 4);
-  static const uint16_t Words2[] = { 11, 4003, 67, 64000, 13 };
-  ArrayRef<uint16_t> Array2 = makeArrayRef(Words2, 5);
-  ArrayRef<uint16_t> Array1c = Alloc.allocateCopy(Array1);
-  ArrayRef<uint16_t> Array2c = Alloc.allocateCopy(Array2);
-  EXPECT_TRUE(Array1.equals(Array1c));
-  EXPECT_NE(Array1.data(), Array1c.data());
-  EXPECT_TRUE(Array2.equals(Array2c));
-  EXPECT_NE(Array2.data(), Array2c.data());
-}
-
-
-
 }  // anonymous namespace