diff --git a/lib/Sema/SemaDeclCXX.cpp b/lib/Sema/SemaDeclCXX.cpp
index 9fbe14a..0bb1974 100644
--- a/lib/Sema/SemaDeclCXX.cpp
+++ b/lib/Sema/SemaDeclCXX.cpp
@@ -10860,38 +10860,105 @@ void Sema::MarkVirtualMemberExceptionSpecsNeeded(SourceLocation Loc,
       ResolveExceptionSpec(Loc, (*I)->getType()->castAs<FunctionProtoType>());
 }
 
-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();
-       I != E; ++I) {
-    for (OverridingMethods::const_iterator OI = I->second.begin(),
-                                           OE = I->second.end();
+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;
+    }
+  };
+}
+
+static void
+MarkOwnVirtualMembersReferenced(Sema &S,
+                                SourceLocation Loc,
+                                const CXXRecordDecl *RD,
+                                CXXFinalOverriderMap &FinalOverriders) {
+  // Use RD's method iterator instead of CXXFinalOverriderMap's to have a
+  // deterministic order.
+  for (CXXRecordDecl::method_iterator I = RD->method_begin(),
+       E = RD->method_end(); I != E; ++I) {
+    const CXXMethodDecl *MD = *I;
+
+    if (!MD->isVirtual())
+      continue;
+
+    const OverridingMethods &Methods = FinalOverriders[MD];
+    llvm::SmallVector<SubobjectAndMethod, 4> MethodVector;
+    for (OverridingMethods::const_iterator OI = Methods.begin(),
+                                           OE = Methods.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) {
+      S.MarkFunctionReferenced(Loc, I->getMethod());
     }
   }
+}
+
+static void
+MarkOverriddenVirtualMembersReferenced(Sema &S,
+                                       SourceLocation Loc,
+                                       const CXXRecordDecl *RD,
+                                       CXXFinalOverriderMap &FinalOverriders) {
+  MarkOwnVirtualMembersReferenced(S, Loc, RD, FinalOverriders);
+
+  for (CXXRecordDecl::base_class_const_iterator i = RD->bases_begin(),
+           e = RD->bases_end(); i != e; ++i) {
+    if (i->isVirtual())
+      continue;
+
+    const CXXRecordDecl *Base =
+      cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
+    MarkOwnVirtualMembersReferenced(S, Loc, Base, FinalOverriders);
+  }
+}
+
+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);
 
   // Only classes that have virtual bases need a VTT.
-  if (RD->getNumVBases() == 0)
+  if (RD->getNumVBases() == 0) {
+    MarkOverriddenVirtualMembersReferenced(*this, Loc, RD, FinalOverriders);
     return;
+  }
+
+  MarkOwnVirtualMembersReferenced(*this, Loc, RD, FinalOverriders);
 
   for (CXXRecordDecl::base_class_const_iterator i = RD->bases_begin(),
            e = RD->bases_end(); i != e; ++i) {
     const CXXRecordDecl *Base =
         cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
-    if (Base->getNumVBases() == 0)
+    if (Base->getNumVBases() != 0) {
+      MarkVirtualMembersReferenced(Loc, Base);
+      continue;
+    }
+    if (i->isVirtual())
       continue;
-    MarkVirtualMembersReferenced(Loc, Base);
+    MarkOverriddenVirtualMembersReferenced(*this, Loc, Base, FinalOverriders);
   }
 }