UseListOrder: Use std::vector

I initially used a `SmallVector<>` for `UseListOrder::Shuffle`, which
was a silly choice.  When I realized my error I quickly rolled a custom
data structure.

This commit simplifies it to a `std::vector<>`.  Now that I've had a
chance to measure performance, this data structure isn't part of a
bottleneck, so the additional complexity is unnecessary.

This is part of PR5680.

llvm-svn: 214979

diff --git a/llvm/include/llvm/IR/UseListOrder.h b/llvm/include/llvm/IR/UseListOrder.h
index 8a2a109..c4e4761 100644 (file)
--- a/llvm/include/llvm/IR/UseListOrder.h
+++ b/llvm/include/llvm/IR/UseListOrder.h
@@ -25,67 +25,11 @@ class Module;
 class Function;
 class Value;
 
-/// \brief Structure to hold a use-list shuffle vector.
-///
-/// Stores most use-lists locally, but large use-lists use an extra heap entry.
-/// Costs two fewer pointers than the equivalent \a SmallVector.
-class UseListShuffleVector {
-  unsigned Size;
-  union {
-    unsigned *Ptr;
-    unsigned Array[6];
-  } Storage;
-
-  bool isSmall() const { return Size <= 6; }
-  unsigned *data() { return isSmall() ? Storage.Array : Storage.Ptr; }
-  const unsigned *data() const {
-    return isSmall() ? Storage.Array : Storage.Ptr;
-  }
-
-  void destroy() {
-    if (!isSmall())
-      delete[] Storage.Ptr;
-  }
-  void moveUnchecked(UseListShuffleVector &X) {
-    std::memcpy(this, &X, sizeof(UseListShuffleVector));
-    X.Size = 0;
-  }
-
-  UseListShuffleVector(const UseListShuffleVector &X) LLVM_DELETED_FUNCTION;
-  UseListShuffleVector &
-  operator=(const UseListShuffleVector &X) LLVM_DELETED_FUNCTION;
-
-public:
-  UseListShuffleVector() : Size(0) {}
-  UseListShuffleVector(UseListShuffleVector &&X) { moveUnchecked(X); }
-  UseListShuffleVector &operator=(UseListShuffleVector &&X) {
-    destroy();
-    moveUnchecked(X);
-    return *this;
-  }
-  explicit UseListShuffleVector(size_t Size) : Size(Size) {
-    if (!isSmall())
-      Storage.Ptr = new unsigned[Size];
-  }
-  ~UseListShuffleVector() { destroy(); }
-
-  typedef unsigned *iterator;
-  typedef const unsigned *const_iterator;
-
-  size_t size() const { return Size; }
-  iterator begin() { return data(); }
-  iterator end() { return begin() + size(); }
-  const_iterator begin() const { return data(); }
-  const_iterator end() const { return begin() + size(); }
-  unsigned &operator[](size_t I) { return data()[I]; }
-  unsigned operator[](size_t I) const { return data()[I]; }
-};
-
 /// \brief Structure to hold a use-list order.
 struct UseListOrder {
   const Value *V;
   const Function *F;
-  UseListShuffleVector Shuffle;
+  std::vector<unsigned> Shuffle;
 
   UseListOrder(const Value *V, const Function *F, size_t ShuffleSize)
       : V(V), F(F), Shuffle(ShuffleSize) {}