[WIP] Emitting available_externally vtables if all inline virtual functions are emitted

include/clang/AST/VTableBuilder.h

public:
   }
 
   bool isFunctionPointerKind() const {
     return isFunctionPointerKind(getKind());
   }
 
   bool isRTTIKind() const { return isRTTIKind(getKind()); }
 
+  GlobalDecl getGlobalDecl() const {
+    assert(isUsedFunctionPointerKind() &&
+        "GlobalDecl can be created only from virtual function");
+    if (getKind() == CK_FunctionPointer)
+      return GlobalDecl(getFunctionDecl());
+
+    auto *DtorDecl = cast<CXXDestructorDecl>(getFunctionDecl());
+    if (getKind() == CK_CompleteDtorPointer)
+      return GlobalDecl(DtorDecl, CXXDtorType::Dtor_Complete);
+    return GlobalDecl(DtorDecl, CXXDtorType::Dtor_Deleting);
+  }
+
 private:
   static bool isFunctionPointerKind(Kind ComponentKind) {
     return isUsedFunctionPointerKind(ComponentKind) ||
            ComponentKind == CK_UnusedFunctionPointer;
   }
   static bool isUsedFunctionPointerKind(Kind ComponentKind) {
     return ComponentKind == CK_FunctionPointer ||
            isDestructorKind(ComponentKind);

lib/CodeGen/ItaniumCXXABI.cpp

 #include "clang/AST/Mangle.h"
 #include "clang/AST/Type.h"
 #include "clang/AST/StmtCXX.h"
 #include "llvm/IR/CallSite.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/Value.h"
-
+#include <iostream>
 using namespace clang;
 using namespace CodeGen;
 
 namespace {
 class ItaniumCXXABI : public CodeGen::CGCXXABI {
   /// VTables - All the vtables which have been defined.
   llvm::DenseMap<const CXXRecordDecl *, llvm::GlobalVariable *> VTables;
 
public:
   RTTIUniquenessKind
   classifyRTTIUniqueness(QualType CanTy,
                          llvm::GlobalValue::LinkageTypes Linkage) const;
   friend class ItaniumRTTIBuilder;
 
   void emitCXXStructor(const CXXMethodDecl *MD, StructorType Type) override;
 
  private:
-   bool hasAnyVirtualInlineFunction(const CXXRecordDecl *RD) const {
+
+  SmallVector<GlobalDecl, 5> getVirtualFunctions(const CXXRecordDecl *RD) const {
+    SmallVector<GlobalDecl, 5> VFunctions;
     const auto &VtableLayout =
         CGM.getItaniumVTableContext().getVTableLayout(RD);
 
     for (const auto &VtableComponent : VtableLayout.vtable_components()) {
-      // Skip empty slot.
+      // Skip slots without virtual functions.
       if (!VtableComponent.isUsedFunctionPointerKind())
         continue;
+      VFunctions.push_back(VtableComponent.getGlobalDecl());
+    }
+    return VFunctions;
+  }
 
-      const CXXMethodDecl *Method = VtableComponent.getFunctionDecl();
-      if (Method->getCanonicalDecl()->isInlined())
+  bool hasAnyUnusedVirtualInlineFunction(const CXXRecordDecl *RD) const {
+    std::cerr << "entering\n";
+    for (GlobalDecl VFunction : getVirtualFunctions(RD)) {
+      const auto * VFunctionDecl = cast<CXXMethodDecl>(VFunction.getDecl());
+      //VFunctionDecl->dumpColor();
+      if (!VFunctionDecl->getCanonicalDecl()->isInlined())
+        continue;
+
+      StringRef Name = CGM.getMangledName(VFunction);
+      std::cerr << std::string(Name) << std::endl;
+      auto *Entry = CGM.GetGlobalValue(Name);
+      /*if (!Entry)
+        std::cerr << "no entry\n";
+      else
+        std::cerr<< "entry with decl=" << Entry->isDeclaration() << std::endl;*/
+
+      // If function doesn't exist or doesn't have a definition.
+      if (!Entry || Entry->isDeclaration())
         return true;
     }
     return false;
   }
 
   bool isVTableHidden(const CXXRecordDecl *RD) const {
     const auto &VtableLayout =
             CGM.getItaniumVTableContext().getVTableLayout(RD);

 }
 
 bool ItaniumCXXABI::canSpeculativelyEmitVTable(const CXXRecordDecl *RD) const {
   // We don't emit available_externally vtables if we are in -fapple-kext mode
   // because kext mode does not permit devirtualization.
   if (CGM.getLangOpts().AppleKext)
     return false;
 
-  // If we don't have any inline virtual functions, and if vtable is not hidden,
-  // then we are safe to emit available_externally copy of vtable.
+  // If we don't have any not emitted inline virtual functions and if vtable is
+  // not hidden, then we are safe to emit available_externally copy of vtable.
   // FIXME we can still emit a copy of the vtable if we
   // can emit definition of the inline functions.
-  return !hasAnyVirtualInlineFunction(RD) && !isVTableHidden(RD);
+  return !hasAnyUnusedVirtualInlineFunction(RD) && !isVTableHidden(RD);
 }
 static llvm::Value *performTypeAdjustment(CodeGenFunction &CGF,
                                           Address InitialPtr,
                                           int64_t NonVirtualAdjustment,
                                           int64_t VirtualAdjustment,
                                           bool IsReturnAdjustment) {
   if (!NonVirtualAdjustment && !VirtualAdjustment)
     return InitialPtr.getPointer();

test/CodeGenCXX/vtable-available-externally.cpp

void test() {
   S *s = new S;
   s->doStuff();
 
   S2 *s2 = new S2;
   s2->doStuff();
 }
 }
 
+namespace Test17 {
+
+struct A {
+  virtual void foo();
+  virtual ~A() {};
+};
+
+struct B : A {
+  virtual void foo();
+  virtual ~B() {};
+};
+
+void B::foo() {}
+void test() {
+  A a; // This will force emit of A's destructor.
+}
+}