Update to latest LLVM code (#88)

* Update to latest LLVM code.

* Add LLVM's raw_ostream.

* MathExtras.h: Include cmath for log2.

wpiutil/include/llvm/SmallVector.h

@@ -177,33 +177,12 @@ protected:
     }
   }
 
-  /// Use move-assignment to move the range [I, E) onto the
-  /// objects starting with "Dest".  This is just <memory>'s
-  /// std::move, but not all stdlibs actually provide that.
-  template<typename It1, typename It2>
-  static It2 move(It1 I, It1 E, It2 Dest) {
-    for (; I != E; ++I, ++Dest)
-      *Dest = ::std::move(*I);
-    return Dest;
-  }
-
-  /// Use move-assignment to move the range
-  /// [I, E) onto the objects ending at "Dest", moving objects
-  /// in reverse order.  This is just <algorithm>'s
-  /// std::move_backward, but not all stdlibs actually provide that.
-  template<typename It1, typename It2>
-  static It2 move_backward(It1 I, It1 E, It2 Dest) {
-    while (I != E)
-      *--Dest = ::std::move(*--E);
-    return Dest;
-  }
-
   /// Move the range [I, E) into the uninitialized memory starting with "Dest",
   /// constructing elements as needed.
   template<typename It1, typename It2>
   static void uninitialized_move(It1 I, It1 E, It2 Dest) {
-    for (; I != E; ++I, ++Dest)
-      ::new ((void*) &*Dest) T(::std::move(*I));
+    std::uninitialized_copy(std::make_move_iterator(I),
+                            std::make_move_iterator(E), Dest);
   }
 
   /// Copy the range [I, E) onto the uninitialized memory starting with "Dest",
@@ -276,20 +255,6 @@ protected:
   // No need to do a destroy loop for POD's.
   static void destroy_range(T *, T *) {}
 
-  /// Use move-assignment to move the range [I, E) onto the
-  /// objects starting with "Dest".  For PODs, this is just memcpy.
-  template<typename It1, typename It2>
-  static It2 move(It1 I, It1 E, It2 Dest) {
-    return ::std::copy(I, E, Dest);
-  }
-
-  /// Use move-assignment to move the range [I, E) onto the objects ending at
-  /// "Dest", moving objects in reverse order.
-  template<typename It1, typename It2>
-  static It2 move_backward(It1 I, It1 E, It2 Dest) {
-    return ::std::copy_backward(I, E, Dest);
-  }
-
   /// Move the range [I, E) onto the uninitialized memory
   /// starting with "Dest", constructing elements into it as needed.
   template<typename It1, typename It2>
@@ -315,8 +280,10 @@ protected:
                                            T2>::value>::type * = nullptr) {
     // Use memcpy for PODs iterated by pointers (which includes SmallVector
     // iterators): std::uninitialized_copy optimizes to memmove, but we can
-    // use memcpy here.
-    memcpy(Dest, I, (E-I)*sizeof(T));
+    // use memcpy here. Note that I and E are iterators and thus might be
+    // invalid for memcpy if they are equal.
+    if (I != E)
+      memcpy(Dest, I, (E - I) * sizeof(T));
   }
 
   /// Double the size of the allocated memory, guaranteeing space for at
@@ -347,6 +314,7 @@ class SmallVectorImpl : public SmallVectorTemplateBase<T, isPodLike<T>::value> {
   SmallVectorImpl(const SmallVectorImpl&) = delete;
 public:
   typedef typename SuperClass::iterator iterator;
+  typedef typename SuperClass::const_iterator const_iterator;
   typedef typename SuperClass::size_type size_type;
 
 protected:
@@ -450,26 +418,33 @@ public:
     append(IL);
   }
 
-  iterator erase(iterator I) {
+  iterator erase(const_iterator CI) {
+    // Just cast away constness because this is a non-const member function.
+    iterator I = const_cast<iterator>(CI);
+
     assert(I >= this->begin() && "Iterator to erase is out of bounds.");
     assert(I < this->end() && "Erasing at past-the-end iterator.");
 
     iterator N = I;
     // Shift all elts down one.
-    this->move(I+1, this->end(), I);
+    std::move(I+1, this->end(), I);
     // Drop the last elt.
     this->pop_back();
     return(N);
   }
 
-  iterator erase(iterator S, iterator E) {
+  iterator erase(const_iterator CS, const_iterator CE) {
+    // Just cast away constness because this is a non-const member function.
+    iterator S = const_cast<iterator>(CS);
+    iterator E = const_cast<iterator>(CE);
+
     assert(S >= this->begin() && "Range to erase is out of bounds.");
     assert(S <= E && "Trying to erase invalid range.");
     assert(E <= this->end() && "Trying to erase past the end.");
 
     iterator N = S;
     // Shift all elts down.
-    iterator I = this->move(E, this->end(), S);
+    iterator I = std::move(E, this->end(), S);
     // Drop the last elts.
     this->destroy_range(I, this->end());
     this->setEnd(I);
@@ -493,7 +468,7 @@ public:
 
     ::new ((void*) this->end()) T(::std::move(this->back()));
     // Push everything else over.
-    this->move_backward(I, this->end()-1, this->end());
+    std::move_backward(I, this->end()-1, this->end());
     this->setEnd(this->end()+1);
 
     // If we just moved the element we're inserting, be sure to update
@@ -522,7 +497,7 @@ public:
     }
     ::new ((void*) this->end()) T(std::move(this->back()));
     // Push everything else over.
-    this->move_backward(I, this->end()-1, this->end());
+    std::move_backward(I, this->end()-1, this->end());
     this->setEnd(this->end()+1);
 
     // If we just moved the element we're inserting, be sure to update
@@ -563,7 +538,7 @@ public:
              std::move_iterator<iterator>(this->end()));
 
       // Copy the existing elements that get replaced.
-      this->move_backward(I, OldEnd-NumToInsert, OldEnd);
+      std::move_backward(I, OldEnd-NumToInsert, OldEnd);
 
       std::fill_n(I, NumToInsert, Elt);
       return I;
@@ -617,7 +592,7 @@ public:
              std::move_iterator<iterator>(this->end()));
 
       // Copy the existing elements that get replaced.
-      this->move_backward(I, OldEnd-NumToInsert, OldEnd);
+      std::move_backward(I, OldEnd-NumToInsert, OldEnd);
 
       std::copy(From, To, I);
       return I;
@@ -798,7 +773,7 @@ SmallVectorImpl<T> &SmallVectorImpl<T>::operator=(SmallVectorImpl<T> &&RHS) {
     // Assign common elements.
     iterator NewEnd = this->begin();
     if (RHSSize)
-      NewEnd = this->move(RHS.begin(), RHS.end(), NewEnd);
+      NewEnd = std::move(RHS.begin(), RHS.end(), NewEnd);
 
     // Destroy excess elements and trim the bounds.
     this->destroy_range(NewEnd, this->end());
@@ -822,7 +797,7 @@ SmallVectorImpl<T> &SmallVectorImpl<T>::operator=(SmallVectorImpl<T> &&RHS) {
     this->grow(RHSSize);
   } else if (CurSize) {
     // Otherwise, use assignment for the already-constructed elements.
-    this->move(RHS.begin(), RHS.begin()+CurSize, this->begin());
+    std::move(RHS.begin(), RHS.begin()+CurSize, this->begin());
   }
 
   // Move-construct the new elements in place.
@@ -924,7 +899,7 @@ static inline size_t capacity_in_bytes(const SmallVector<T, N> &X) {
   return X.capacity_in_bytes();
 }
 
-} // namespace llvm
+} // End llvm namespace
 
 namespace std {
   /// Implement std::swap in terms of SmallVector swap.
@@ -940,6 +915,6 @@ namespace std {
   swap(llvm::SmallVector<T, N> &LHS, llvm::SmallVector<T, N> &RHS) {
     LHS.swap(RHS);
   }
-} // namespace std
+}
 
 #endif