diff --git a/include/clang/AST/CXXInheritance.h b/include/clang/AST/CXXInheritance.h
index ee6eba7..d0a4378 100644
--- a/include/clang/AST/CXXInheritance.h
+++ b/include/clang/AST/CXXInheritance.h
@@ -357,8 +357,61 @@ 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;
+  }
+  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;
+    }
+    KeyT getKey() {
+      return WrappedI->first;
+    }
+    ValueT& getValue() {
+      unsigned Pos = WrappedI->second;
+      return VecRef[Pos];
+    }
+  };
+  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/AST/CXXInheritance.cpp b/lib/AST/CXXInheritance.cpp
index 3884e4e..37e587b 100644
--- a/lib/AST/CXXInheritance.cpp
+++ b/lib/AST/CXXInheritance.cpp
@@ -532,8 +532,8 @@ void FinalOverriderCollector::Collect(const CXXRecordDecl *RD,
            OM != OMEnd;
            ++OM) {
         const CXXMethodDecl *CanonOM
-          = cast<CXXMethodDecl>(OM->first->getCanonicalDecl());
-        Overriders[CanonOM].add(OM->second);
+          = cast<CXXMethodDecl>(OM.getKey()->getCanonicalDecl());
+        Overriders[CanonOM].add(OM.getValue());
       }
     }
   }
@@ -633,8 +633,8 @@ CXXRecordDecl::getFinalOverriders(CXXFinalOverriderMap &FinalOverriders) const {
                            OMEnd = FinalOverriders.end();
        OM != OMEnd;
        ++OM) {
-    for (OverridingMethods::iterator SO = OM->second.begin(), 
-                                  SOEnd = OM->second.end();
+    for (OverridingMethods::iterator SO = OM.getValue().begin(),
+                                  SOEnd = OM.getValue().end();
          SO != SOEnd; 
          ++SO) {
       SmallVector<UniqueVirtualMethod, 4> &Overriding = SO->second;
diff --git a/lib/AST/DeclCXX.cpp b/lib/AST/DeclCXX.cpp
index 2f21e4c..afffe7d 100644
--- a/lib/AST/DeclCXX.cpp
+++ b/lib/AST/DeclCXX.cpp
@@ -1235,8 +1235,8 @@ void CXXRecordDecl::completeDefinition(CXXFinalOverriderMap *FinalOverriders) {
     for (CXXFinalOverriderMap::iterator M = FinalOverriders->begin(), 
                                      MEnd = FinalOverriders->end();
          M != MEnd && !Done; ++M) {
-      for (OverridingMethods::iterator SO = M->second.begin(), 
-                                    SOEnd = M->second.end();
+      for (OverridingMethods::iterator SO = M.getValue().begin(),
+                                    SOEnd = M.getValue().end();
            SO != SOEnd && !Done; ++SO) {
         assert(SO->second.size() > 0 && 
                "All virtual functions have overridding virtual functions");
diff --git a/lib/AST/VTableBuilder.cpp b/lib/AST/VTableBuilder.cpp
index 104530f..67d9046 100644
--- a/lib/AST/VTableBuilder.cpp
+++ b/lib/AST/VTableBuilder.cpp
@@ -171,8 +171,8 @@ FinalOverriders::FinalOverriders(const CXXRecordDecl *MostDerivedClass,
 
   for (CXXFinalOverriderMap::const_iterator I = FinalOverriders.begin(),
        E = FinalOverriders.end(); I != E; ++I) {
-    const CXXMethodDecl *MD = I->first;
-    const OverridingMethods& Methods = I->second;
+    const CXXMethodDecl *MD = I.getKey();
+    const OverridingMethods& Methods = I.getValue();
 
     for (OverridingMethods::const_iterator I = Methods.begin(),
          E = Methods.end(); I != E; ++I) {
diff --git a/lib/Sema/SemaDecl.cpp b/lib/Sema/SemaDecl.cpp
index d310abf..4e50450 100644
--- a/lib/Sema/SemaDecl.cpp
+++ b/lib/Sema/SemaDecl.cpp
@@ -10118,8 +10118,8 @@ void Sema::ActOnFields(Scope* S,
             for (CXXFinalOverriderMap::iterator M = FinalOverriders.begin(), 
                                              MEnd = FinalOverriders.end();
                  M != MEnd; ++M) {
-              for (OverridingMethods::iterator SO = M->second.begin(), 
-                                            SOEnd = M->second.end();
+              for (OverridingMethods::iterator SO = M.getValue().begin(),
+                                            SOEnd = M.getValue().end();
                    SO != SOEnd; ++SO) {
                 assert(SO->second.size() > 0 && 
                        "Virtual function without overridding functions?");
@@ -10131,15 +10131,15 @@ void Sema::ActOnFields(Scope* S,
                 //   class subobject has more than one final overrider the
                 //   program is ill-formed.
                 Diag(Record->getLocation(), diag::err_multiple_final_overriders)
-                  << (NamedDecl *)M->first << Record;
-                Diag(M->first->getLocation(), 
+                  << (NamedDecl *)M.getKey() << Record;
+                Diag(M.getKey()->getLocation(),
                      diag::note_overridden_virtual_function);
                 for (OverridingMethods::overriding_iterator 
                           OM = SO->second.begin(), 
                        OMEnd = SO->second.end();
                      OM != OMEnd; ++OM)
                   Diag(OM->Method->getLocation(), diag::note_final_overrider)
-                    << (NamedDecl *)M->first << OM->Method->getParent();
+                    << (NamedDecl *)M.getKey() << OM->Method->getParent();
                 
                 Record->setInvalidDecl();
               }
diff --git a/lib/Sema/SemaDeclCXX.cpp b/lib/Sema/SemaDeclCXX.cpp
index 9fbe14a..b2f9c48 100644
--- a/lib/Sema/SemaDeclCXX.cpp
+++ b/lib/Sema/SemaDeclCXX.cpp
@@ -3546,8 +3546,8 @@ void Sema::DiagnoseAbstractType(const CXXRecordDecl *RD) {
                                    MEnd = FinalOverriders.end();
        M != MEnd; 
        ++M) {
-    for (OverridingMethods::iterator SO = M->second.begin(), 
-                                  SOEnd = M->second.end();
+    for (OverridingMethods::iterator SO = M.getValue().begin(),
+                                  SOEnd = M.getValue().end();
          SO != SOEnd; ++SO) {
       // C++ [class.abstract]p4:
       //   A class is abstract if it contains or inherits at least one
@@ -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());
     }
   }