diff --git a/include/clang/AST/CXXInheritance.h b/include/clang/AST/CXXInheritance.h
index ee6eba7..2f5149c 100644
--- a/include/clang/AST/CXXInheritance.h
+++ b/include/clang/AST/CXXInheritance.h
@@ -357,8 +357,69 @@ public:
 /// 0 represents the virtua base class subobject of that type, while
 /// subobject numbers greater than 0 refer to non-virtual base class
 /// subobjects of that type.
-class CXXFinalOverriderMap 
-  : public llvm::DenseMap<const CXXMethodDecl *, OverridingMethods> { };
+class CXXFinalOverriderMap {
+  typedef const CXXMethodDecl * KeyT;
+  typedef OverridingMethods ValueT;
+  typedef llvm::DenseMap<KeyT, unsigned> MapType;
+  typedef std::vector<ValueT> VectorType;
+  MapType Map;
+  VectorType Vector;
+public:
+  CXXFinalOverriderMap() {
+    Vector.resize(1); // position 0 is dummy
+  }
+  ArrayRef<ValueT> getValues() {
+    return Vector;
+  }
+  struct FakePair {
+    KeyT &first;
+    ValueT &second;
+    FakePair(KeyT &K, ValueT &V) : first(K), second(V) {
+    }
+    FakePair *operator->() {
+      return this;
+    }
+  };
+
+  class iterator {
+    MapType::iterator WrappedI;
+    VectorType &VecRef;
+  public:
+    explicit iterator(MapType::iterator I, VectorType &V) :
+      WrappedI(I), VecRef(V) {
+    }
+    bool operator!=(const iterator &RHS) const {
+      return WrappedI != RHS.WrappedI;
+    }
+    iterator &operator++() {  // Preincrement
+      ++WrappedI;
+      return *this;
+    }
+    FakePair operator->() {
+      unsigned Pos = WrappedI->second;
+      FakePair Ret(WrappedI->first, VecRef[Pos]);
+      return Ret;
+    }
+  };
+  typedef iterator const_iterator;
+  iterator begin() {
+    return iterator(Map.begin(), this->Vector);
+  }
+  iterator end() {
+    return iterator(Map.end(), this->Vector);
+  }
+  bool empty() const {
+    return Map.empty();
+  }
+  ValueT &operator[](const KeyT &Key) {
+    unsigned &I = Map[Key];
+    if (I == 0) {
+      Vector.push_back(ValueT());
+      I = Vector.size() - 1;
+    }
+    return Vector[I];
+  }
+};
 
 /// \brief A set of all the primary bases for a class.
 class CXXIndirectPrimaryBaseSet
diff --git a/lib/Sema/SemaDeclCXX.cpp b/lib/Sema/SemaDeclCXX.cpp
index 9fbe14a..a87ff3a 100644
--- a/lib/Sema/SemaDeclCXX.cpp
+++ b/lib/Sema/SemaDeclCXX.cpp
@@ -10860,24 +10860,52 @@ void Sema::MarkVirtualMemberExceptionSpecsNeeded(SourceLocation Loc,
       ResolveExceptionSpec(Loc, (*I)->getType()->castAs<FunctionProtoType>());
 }
 
+namespace {
+  class SubobjectAndMethod {
+    unsigned Subobject;
+    CXXMethodDecl *Method;
+  public:
+    SubobjectAndMethod(unsigned S, CXXMethodDecl *M) : Subobject(S), Method(M) {
+    }
+    bool operator<(const SubobjectAndMethod& Other) const {
+      assert(Subobject != Other.Subobject);
+      return Subobject < Other.Subobject;
+    }
+    CXXMethodDecl *getMethod() {
+      return Method;
+    }
+  };
+}
+
 void Sema::MarkVirtualMembersReferenced(SourceLocation Loc,
                                         const CXXRecordDecl *RD) {
   // Mark all functions which will appear in RD's vtable as used.
   CXXFinalOverriderMap FinalOverriders;
   RD->getFinalOverriders(FinalOverriders);
-  for (CXXFinalOverriderMap::const_iterator I = FinalOverriders.begin(),
-                                            E = FinalOverriders.end();
+  ArrayRef<OverridingMethods> Values = FinalOverriders.getValues();
+
+  for (ArrayRef<OverridingMethods>::const_iterator I = Values.begin(),
+                                                   E = Values.end();
        I != E; ++I) {
-    for (OverridingMethods::const_iterator OI = I->second.begin(),
-                                           OE = I->second.end();
+    llvm::SmallVector<SubobjectAndMethod, 4> MethodVector;
+    for (OverridingMethods::const_iterator OI = I->begin(), OE = I->end();
          OI != OE; ++OI) {
-      assert(OI->second.size() > 0 && "no final overrider");
+      assert(OI->second.size() == 1 && "Final overrider is not unique!");
       CXXMethodDecl *Overrider = OI->second.front().Method;
 
       // C++ [basic.def.odr]p2:
       //   [...] A virtual member function is used if it is not pure. [...]
-      if (!Overrider->isPure())
-        MarkFunctionReferenced(Loc, Overrider);
+      if (Overrider->isPure())
+        continue;
+      SubobjectAndMethod M(OI->first, Overrider);
+      MethodVector.push_back(M);
+    }
+
+    // Get a deterministic order
+    llvm::array_pod_sort(MethodVector.begin(), MethodVector.end());
+    for (SmallVectorImpl<SubobjectAndMethod>::iterator I = MethodVector.begin(),
+           E = MethodVector.end(); I != E; ++I) {
+      MarkFunctionReferenced(Loc, I->getMethod());
     }
   }