SmallVector: Resolve a long-standing fixme by using the existing unitialized_copy...

[oota-llvm.git] / include / llvm / ADT / ArrayRef.h

diff --git a/include/llvm/ADT/ArrayRef.h b/include/llvm/ADT/ArrayRef.h
index be7cb51b60fec36428a8672158320b30d39c8c66..8c14a423c8f50614ff30856b19d11c96774b359e 100644 (file)
--- a/include/llvm/ADT/ArrayRef.h
+++ b/include/llvm/ADT/ArrayRef.h
@@ -11,8 +11,8 @@
 #define LLVM_ADT_ARRAYREF_H
 
 #include "llvm/ADT/None.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
-#include "llvm/Support/Allocator.h"
 #include <vector>
 
 namespace llvm {
@@ -44,6 +44,19 @@ namespace llvm {
     /// The number of elements.
     size_type Length;
 
+    /// \brief A dummy "optional" type that is only created by implicit
+    /// conversion from a reference to T.
+    ///
+    /// This type must *only* be used in a function argument or as a copy of
+    /// a function argument, as otherwise it will hold a pointer to a temporary
+    /// past that temporaries' lifetime.
+    struct TRefOrNothing {
+      const T *TPtr;
+
+      TRefOrNothing() : TPtr(nullptr) {}
+      TRefOrNothing(const T &TRef) : TPtr(&TRef) {}
+    };
+
   public:
     /// @name Constructors
     /// @{
@@ -91,6 +104,14 @@ namespace llvm {
       Length(Vec.size()) {}
 #endif
 
+    /// Construct an ArrayRef<const T*> from ArrayRef<T*>. This uses SFINAE to
+    /// ensure that only ArrayRefs of pointers can be converted.
+    template <typename U>
+    ArrayRef(const ArrayRef<U *> &A,
+             typename std::enable_if<
+                 std::is_convertible<U *const *, T const *>::value>::type* = 0)
+      : Data(A.data()), Length(A.size()) {}
+
     /// @}
     /// @name Simple Operations
     /// @{
@@ -121,9 +142,9 @@ 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);
+    // copy - Allocate copy in Allocator and return ArrayRef<T> to it.
+    template <typename Allocator> ArrayRef<T> copy(Allocator &A) {
+      T *Buff = A.template Allocate<T>(Length);
       std::copy(begin(), end(), Buff);
       return ArrayRef<T>(Buff, Length);
     }
@@ -132,8 +153,11 @@ namespace llvm {
     bool equals(ArrayRef RHS) const {
       if (Length != RHS.Length)
         return false;
-      for (size_type i = 0; i != Length; i++)
-        if (Data[i] != RHS.Data[i])
+      // Don't use std::equal(), since it asserts in MSVC on nullptr iterators.
+      for (auto L = begin(), LE = end(), R = RHS.begin(); L != LE; ++L, ++R)
+        // Match std::equal() in using == (instead of !=) to minimize API
+        // requirements of ArrayRef'ed types.
+        if (!(*L == *R))
           return false;
       return true;
     }
@@ -151,6 +175,12 @@ namespace llvm {
       return ArrayRef<T>(data()+N, M);
     }
 
+    // \brief Drop the last \p N elements of the array.
+    ArrayRef<T> drop_back(unsigned N = 1) const {
+      assert(size() >= N && "Dropping more elements than exist");
+      return slice(0, size() - N);
+    }
+
     /// @}
     /// @name Operator Overloads
     /// @{
@@ -173,6 +203,47 @@ namespace llvm {
       return std::vector<T>(Data, Data+Length);
     }
 
+    /// @}
+    /// @{
+    /// @name Convenience methods
+
+    /// @brief Predicate for testing that the array equals the exact sequence of
+    /// arguments.
+    ///
+    /// Will return false if the size is not equal to the exact number of
+    /// arguments given or if the array elements don't equal the argument
+    /// elements in order. Currently supports up to 16 arguments, but can
+    /// easily be extended.
+    bool equals(TRefOrNothing Arg0 = TRefOrNothing(),
+                TRefOrNothing Arg1 = TRefOrNothing(),
+                TRefOrNothing Arg2 = TRefOrNothing(),
+                TRefOrNothing Arg3 = TRefOrNothing(),
+                TRefOrNothing Arg4 = TRefOrNothing(),
+                TRefOrNothing Arg5 = TRefOrNothing(),
+                TRefOrNothing Arg6 = TRefOrNothing(),
+                TRefOrNothing Arg7 = TRefOrNothing(),
+                TRefOrNothing Arg8 = TRefOrNothing(),
+                TRefOrNothing Arg9 = TRefOrNothing(),
+                TRefOrNothing Arg10 = TRefOrNothing(),
+                TRefOrNothing Arg11 = TRefOrNothing(),
+                TRefOrNothing Arg12 = TRefOrNothing(),
+                TRefOrNothing Arg13 = TRefOrNothing(),
+                TRefOrNothing Arg14 = TRefOrNothing(),
+                TRefOrNothing Arg15 = TRefOrNothing()) {
+      TRefOrNothing Args[] = {Arg0,  Arg1,  Arg2,  Arg3, Arg4,  Arg5,
+                              Arg6,  Arg7,  Arg8,  Arg9, Arg10, Arg11,
+                              Arg12, Arg13, Arg14, Arg15};
+      if (size() > array_lengthof(Args))
+        return false;
+
+      for (unsigned i = 0, e = size(); i != e; ++i)
+        if (Args[i].TPtr == nullptr || (*this)[i] != *Args[i].TPtr)
+          return false;
+
+      // Either the size is exactly as many args, or the next arg must be null.
+      return size() == array_lengthof(Args) || Args[size()].TPtr == nullptr;
+    }
+
     /// @}
   };
 
@@ -221,7 +292,7 @@ namespace llvm {
 
     /// Construct an MutableArrayRef from a C array.
     template <size_t N>
-    /*implicit*/ MutableArrayRef(T (&Arr)[N])
+    /*implicit*/ LLVM_CONSTEXPR MutableArrayRef(T (&Arr)[N])
       : ArrayRef<T>(Arr) {}
 
     T *data() const { return const_cast<T*>(ArrayRef<T>::data()); }