Index: include/lld/Core/Simple.h
===================================================================
--- include/lld/Core/Simple.h
+++ include/lld/Core/Simple.h
@@ -20,8 +20,6 @@
 #include "lld/Core/LinkingContext.h"
 #include "lld/Core/Reference.h"
 #include "lld/Core/UndefinedAtom.h"
-#include "llvm/ADT/ilist.h"
-#include "llvm/ADT/ilist_node.h"
 
 namespace lld {
 
@@ -80,16 +78,13 @@
 class SimpleReference : public Reference {
 public:
   SimpleReference(Reference::KindNamespace ns, Reference::KindArch arch,
-                  Reference::KindValue value, uint64_t off, const Atom *t,
+                  Reference::KindValue val, uint64_t off, const Atom *t,
                   Reference::Addend a)
-      : Reference(ns, arch, value), _target(t), _offsetInAtom(off), _addend(a),
-        _next(nullptr), _prev(nullptr) {
-  }
+      : Reference(ns, arch, val), _target(t), _offsetInAtom(off), _addend(a) {}
+
   SimpleReference()
       : Reference(Reference::KindNamespace::all, Reference::KindArch::all, 0),
-        _target(nullptr), _offsetInAtom(0), _addend(0), _next(nullptr),
-        _prev(nullptr) {
-  }
+        _target(nullptr), _offsetInAtom(0), _addend(0) {}
 
   uint64_t offsetInAtom() const override { return _offsetInAtom; }
 
@@ -101,62 +96,15 @@
   Addend addend() const override { return _addend; }
   void setAddend(Addend a) override { _addend = a; }
   void setTarget(const Atom *newAtom) override { _target = newAtom; }
-  SimpleReference *getNext() const { return _next; }
-  SimpleReference *getPrev() const { return _prev; }
-  void setNext(SimpleReference *n) { _next = n; }
-  void setPrev(SimpleReference *p) { _prev = p; }
 
 private:
   const Atom *_target;
   uint64_t _offsetInAtom;
   Addend _addend;
-  SimpleReference *_next;
-  SimpleReference *_prev;
 };
 
 }
 
-// ilist will lazily create a sentinal (so end() can return a node past the
-// end of the list). We need this trait so that the sentinal is allocated
-// via the BumpPtrAllocator.
-namespace llvm {
-template<>
-struct ilist_sentinel_traits<lld::SimpleReference> {
-
-  ilist_sentinel_traits() : _allocator(nullptr) { }
-
-  void setAllocator(llvm::BumpPtrAllocator *alloc) {
-    _allocator = alloc;
-  }
-
-  lld::SimpleReference *createSentinel() const {
-    return new (*_allocator) lld::SimpleReference();
-  }
-
-  static void destroySentinel(lld::SimpleReference*) {}
-
-  static lld::SimpleReference *provideInitialHead() { return nullptr; }
-
-  lld::SimpleReference *ensureHead(lld::SimpleReference *&head) const {
-    if (!head) {
-      head = createSentinel();
-      noteHead(head, head);
-      ilist_traits<lld::SimpleReference>::setNext(head, nullptr);
-      return head;
-    }
-    return ilist_traits<lld::SimpleReference>::getPrev(head);
-  }
-
-  void noteHead(lld::SimpleReference *newHead,
-                lld::SimpleReference *sentinel) const {
-    ilist_traits<lld::SimpleReference>::setPrev(newHead, sentinel);
-  }
-
-private:
-  mutable llvm::BumpPtrAllocator *_allocator;
-};
-}
-
 namespace lld {
 
 class SimpleDefinedAtom : public DefinedAtom {
@@ -164,7 +112,6 @@
   explicit SimpleDefinedAtom(const File &f) : _file(f) {
     static uint32_t lastOrdinal = 0;
     _ordinal = lastOrdinal++;
-    _references.setAllocator(&f.allocator());
   }
 
   const File &file() const override { return _file; }
@@ -193,23 +140,22 @@
   }
 
   DefinedAtom::reference_iterator begin() const override {
-    const void *it = reinterpret_cast<const void *>(&*_references.begin());
+    const void *it = reinterpret_cast<void *>(0);
     return reference_iterator(*this, it);
   }
 
   DefinedAtom::reference_iterator end() const override {
-    const void *it = reinterpret_cast<const void *>(&*_references.end());
+    const void *it = reinterpret_cast<void *>(_references.size());
     return reference_iterator(*this, it);
   }
 
   const Reference *derefIterator(const void *it) const override {
-    return reinterpret_cast<const Reference*>(it);
+    return _references[reinterpret_cast<uintptr_t>(it)];
   }
 
   void incrementIterator(const void *&it) const override {
-    const SimpleReference* node = reinterpret_cast<const SimpleReference*>(it);
-    const SimpleReference* next = node->getNext();
-    it = reinterpret_cast<const void*>(next);
+    uintptr_t i = reinterpret_cast<uintptr_t>(it);
+    it = reinterpret_cast<const void*>(i + 1);
   }
 
   void addReference(Reference::KindNamespace ns, Reference::KindArch arch,
@@ -223,13 +169,7 @@
 
   /// Sort references in a canonical order (by offset, then by kind).
   void sortReferences() const {
-    // Cannot sort a linked  list, so move elements into a temporary vector,
-    // sort the vector, then reconstruct the list.
-    llvm::SmallVector<SimpleReference *, 16> elements;
-    for (SimpleReference &node : _references) {
-      elements.push_back(&node);
-    }
-    std::sort(elements.begin(), elements.end(),
+    std::sort(_references.begin(), _references.end(),
         [] (const SimpleReference *lhs, const SimpleReference *rhs) -> bool {
           uint64_t lhsOffset = lhs->offsetInAtom();
           uint64_t rhsOffset = rhs->offsetInAtom();
@@ -241,19 +181,13 @@
             return (lhs->kindArch() < rhs->kindArch());
           return (lhs->kindValue() < rhs->kindValue());
         });
-    _references.clearAndLeakNodesUnsafely();
-    for (SimpleReference *node : elements) {
-      _references.push_back(node);
-    }
   }
   void setOrdinal(uint64_t ord) { _ordinal = ord; }
 
 private:
-  typedef llvm::ilist<SimpleReference> RefList;
-
   const File &_file;
   uint64_t _ordinal;
-  mutable RefList _references;
+  mutable std::vector<SimpleReference *> _references;
 };
 
 class SimpleUndefinedAtom : public UndefinedAtom {