IRGen: Keep vtables entries inherited from fragile base classes.

If a subclass is resilient, but has a fragile base class, we need to preserve the ABI-exposed vtable entries
inherited from the base class.

Author: jckarter

lib/IRGen/GenMeta.cpp

@@ -5138,7 +5138,8 @@ void IRGenModule::emitOpaqueTypeDecl(OpaqueTypeDecl *D) {
 bool irgen::methodRequiresReifiedVTableEntry(IRGenModule &IGM,
                                              const SILVTable *vtable,
                                              SILDeclRef method) {
-  auto entry = vtable->getEntry(IGM.getSILModule(), method);
+  Optional<SILVTable::Entry> entry
+    = vtable->getEntry(IGM.getSILModule(), method);
   LLVM_DEBUG(llvm::dbgs() << "looking at vtable:\n";
              vtable->print(llvm::dbgs()));
   if (!entry) {
@@ -5150,7 +5151,8 @@ bool irgen::methodRequiresReifiedVTableEntry(IRGenModule &IGM,
     return true;
   }
   LLVM_DEBUG(llvm::dbgs() << "entry: ";
-             entry->print(llvm::dbgs()));
+             entry->print(llvm::dbgs());
+             llvm::dbgs() << "\n");
 
   // We may be able to elide the vtable entry, ABI permitting, if it's not
   // overridden.
@@ -5163,21 +5165,25 @@ bool irgen::methodRequiresReifiedVTableEntry(IRGenModule &IGM,
     return true;
   }
 
-  // Does the ABI require a vtable entry to exist? If the class is public,
+  // Does the ABI require a vtable entry to exist? If the class the vtable
+  // entry originates from is public,
   // and it's either marked fragile or part of a non-resilient module, then
   // other modules will directly address vtable offsets and we can't remove
   // vtable entries.
-  if (vtable->getClass()->getEffectiveAccess() >= AccessLevel::Public) {
+  auto originatingClass =
+    cast<ClassDecl>(method.getOverriddenVTableEntry().getDecl()->getDeclContext());
+
+  if (originatingClass->getEffectiveAccess() >= AccessLevel::Public) {
     // If the class is public,
     // and it's either marked fragile or part of a non-resilient module, then
     // other modules will directly address vtable offsets and we can't remove
     // vtable entries.
-    if (!vtable->getClass()->isResilient()) {
+    if (!originatingClass->isResilient()) {
       LLVM_DEBUG(llvm::dbgs() << "vtable entry in "
                               << vtable->getClass()->getName()
                               << " for ";
                  method.print(llvm::dbgs());
-                 llvm::dbgs() << " is in a public fragile class\n");
+                 llvm::dbgs() << " originates from a public fragile class\n");
       return true;
     }
   }

test/IRGen/vtable_non_overridden.sil

@@ -138,6 +138,35 @@ sil_vtable PublicFragileB {
 // CHECK-SAME:     @PublicFragileB_bar
 // CHECK-SAME:     @PublicFragileA_bas
 
+sil @PublicResilientSubclassOfFragile_bar : $@convention(method) (@guaranteed PublicResilientSubclassOfFragile) -> ()
+sil @PublicResilientSubclassOfFragile_init : $@convention(method) (@thick PublicResilientSubclassOfFragile.Type) -> @owned PublicResilientSubclassOfFragile
+sil @PublicResilientSubclassOfFragile_dealloc : $@convention(method) (@owned PublicResilientSubclassOfFragile) -> ()
+
+public class PublicResilientSubclassOfFragile: PublicFragileA {
+  override func bar()
+}
+
+sil_vtable PublicResilientSubclassOfFragile {
+  #PublicResilientSubclassOfFragile.deinit!deallocator : @PublicResilientSubclassOfFragile_dealloc
+  #PublicFragileA.init!allocator : @PublicResilientSubclassOfFragile_init [override]
+  #PublicFragileA.foo : @PublicFragileA_foo [inherited] [nonoverridden]
+  #PublicFragileA.bar : @PublicResilientSubclassOfFragile_bar [override]
+  #PublicFragileA.bas : @PublicFragileA_bas [inherited] [nonoverridden]
+}
+
+// -- all entries from fragile base class should be preserved in public method descriptor table
+// CHECK-LABEL: @"$s21vtable_non_overridden32PublicResilientSubclassOfFragileCMn" =
+// CHECK-SAME:     i32 2, %swift.method_override_descriptor
+// CHECK-SAME:     @PublicResilientSubclassOfFragile_bar
+// CHECK-SAME:     @PublicResilientSubclassOfFragile_init
+
+// -- all entries from fragile base class should be preserved in public vtable
+// CHECK-LABEL: @"$s21vtable_non_overridden32PublicResilientSubclassOfFragileCMf" = 
+// CHECK-SAME:     @PublicResilientSubclassOfFragile_init
+// CHECK-SAME:     @PublicFragileA_foo
+// CHECK-SAME:     @PublicResilientSubclassOfFragile_bar
+// CHECK-SAME:     @PublicFragileA_bas
+
 public class PublicA {
   init()
   public func foo()