IRGen: Don't reify internal vtable entries that are marked overridden.

Private and internal classes shouldn't have ABI constraints on their concrete vtable layout, so if methods
don't have overrides in practice, we can elide their vtable entries.

Author: jckarter

include/swift/SIL/SILModule.h

@@ -595,7 +595,7 @@ class SILModule {
                                       bool deserializeLazily=true);
 
   /// Look up the VTable mapped to the given ClassDecl. Returns null on failure.
-  SILVTable *lookUpVTable(const ClassDecl *C);
+  SILVTable *lookUpVTable(const ClassDecl *C, bool deserializeLazily = true);
 
   /// Attempt to lookup the function corresponding to \p Member in the class
   /// hierarchy of \p Class.

include/swift/SIL/SILVTable.h

@@ -49,13 +49,12 @@ class SILVTableEntry {
   /// The function which implements the method for the class and the entry kind.
   llvm::PointerIntPair<SILFunction *, 2, unsigned> ImplAndKind;
 
+  bool IsNonOverridden;
+
 public:
   enum Kind : uint8_t {
     /// The vtable entry is for a method defined directly in this class.
     Normal,
-    /// The vtable entry is for a method defined directly in this class, and is
-    /// never overridden by subclasses.
-    NormalNonOverridden,
     /// The vtable entry is inherited from the superclass.
     Inherited,
     /// The vtable entry is inherited from the superclass, and overridden
@@ -67,14 +66,19 @@ class SILVTableEntry {
 
   SILVTableEntry() : ImplAndKind(nullptr, Kind::Normal) {}
 
-  SILVTableEntry(SILDeclRef Method, SILFunction *Implementation, Kind TheKind)
-      : Method(Method), ImplAndKind(Implementation, TheKind) {}
+  SILVTableEntry(SILDeclRef Method, SILFunction *Implementation, Kind TheKind,
+                 bool NonOverridden)
+      : Method(Method), ImplAndKind(Implementation, TheKind),
+        IsNonOverridden(NonOverridden) {}
 
   SILDeclRef getMethod() const { return Method; }
 
   Kind getKind() const { return Kind(ImplAndKind.getInt()); }
   void setKind(Kind kind) { ImplAndKind.setInt(kind); }
 
+  bool isNonOverridden() const { return IsNonOverridden; }
+  void setNonOverridden(bool value) { IsNonOverridden = value; }
+
   SILFunction *getImplementation() const { return ImplAndKind.getPointer(); }
 };
 

lib/IRGen/ClassMetadataVisitor.h

@@ -21,6 +21,8 @@
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/SubstitutionMap.h"
 #include "swift/SIL/SILDeclRef.h"
+#include "swift/SIL/SILModule.h"
+#include "swift/SIL/SILVTable.h"
 #include "swift/SIL/SILVTableVisitor.h"
 #include "IRGen.h"
 #include "NominalMetadataVisitor.h"
@@ -30,6 +32,15 @@ namespace irgen {
 
 class IRGenModule;
 
+/// Returns true if the given SILVTable entry needs to be reified as a runtime
+/// vtable entry.
+///
+/// Methods that have no overrides, and no ABI constraints that require a
+/// vtable to be present, can be left out of the runtime vtable for classes.
+bool methodRequiresReifiedVTableEntry(IRGenModule &IGM,
+                                      const SILVTable *vtable,
+                                      SILDeclRef method);
+
 /// A CRTP class for laying out class metadata.  Note that this does
 /// *not* handle the metadata template stuff.
 template <class Impl> class ClassMetadataVisitor
@@ -43,9 +54,13 @@ template <class Impl> class ClassMetadataVisitor
 
   /// The most-derived class.
   ClassDecl *const Target;
+        
+  /// SILVTable entry for the class.
+  const SILVTable *VTable;
 
   ClassMetadataVisitor(IRGenModule &IGM, ClassDecl *target)
-    : super(IGM), Target(target) {}
+    : super(IGM), Target(target),
+      VTable(IGM.getSILModule().lookUpVTable(target, /*deserialize*/ false)) {}
 
 public:
   void layout() {
@@ -152,8 +167,15 @@ template <class Impl> class ClassMetadataVisitor
     // Add vtable entries.
     asImpl().addVTableEntries(theClass);
   }
-  
-private:
+
+  friend SILVTableVisitor<Impl>;
+  void addMethod(SILDeclRef declRef) {
+    // Does this method require a reified runtime vtable entry?
+    if (methodRequiresReifiedVTableEntry(IGM, VTable, declRef)) {
+      asImpl().addReifiedVTableEntry(declRef);
+    }
+  }
+        
   void addFieldEntries(Decl *field) {
     if (auto var = dyn_cast<VarDecl>(field)) {
       asImpl().addFieldOffset(var);
@@ -194,7 +216,7 @@ class ClassMetadataScanner : public ClassMetadataVisitor<Impl> {
   void addClassAddressPoint() { addInt32(); }
   void addClassCacheData() { addPointer(); addPointer(); }
   void addClassDataPointer() { addPointer(); }
-  void addMethod(SILDeclRef declRef) {
+  void addReifiedVTableEntry(SILDeclRef declRef) {
     addPointer();
   }
   void addMethodOverride(SILDeclRef baseRef, SILDeclRef declRef) {}

lib/IRGen/GenMeta.cpp

@@ -1437,7 +1437,13 @@ namespace {
     }
 
     void addMethod(SILDeclRef fn) {
-      VTableEntries.push_back(fn);
+      if (methodRequiresReifiedVTableEntry(IGM, VTable, fn)) {
+        VTableEntries.push_back(fn);
+      } else if (getType()->getEffectiveAccess() >= AccessLevel::Public) {
+        // Emit a stub method descriptor and lookup function for nonoverridden
+        // methods so that resilient code sequences can still use them.
+        emitNonoverriddenMethod(fn);
+      }
     }
 
     void addMethodOverride(SILDeclRef baseRef, SILDeclRef declRef) {
@@ -1521,9 +1527,6 @@ namespace {
     }
 
     void addVTable() {
-      if (VTableEntries.empty())
-        return;
-      
       LLVM_DEBUG(
         llvm::dbgs() << "VTable entries for " << getType()->getName() << ":\n";
         for (auto entry : VTableEntries) {
@@ -1533,6 +1536,9 @@ namespace {
         }
       );
 
+      if (VTableEntries.empty())
+        return;
+      
       // Only emit a method lookup function if the class is resilient
       // and has a non-empty vtable.
       if (IGM.hasResilientMetadata(getType(), ResilienceExpansion::Minimal))
@@ -1595,8 +1601,25 @@ namespace {
         IGM.emitDispatchThunk(fn);
       }
     }
+    
+    void emitNonoverriddenMethod(SILDeclRef fn) {
+      // TODO: Emit a freestanding method descriptor structure, and a method
+      // lookup function, to present the ABI of an overridable method even
+      // though the method has no real overrides currently.
+    }
 
     void addOverrideTable() {
+      LLVM_DEBUG(
+        llvm::dbgs() << "Override Table entries for " << getType()->getName() << ":\n";
+        for (auto entry : OverrideTableEntries) {
+          llvm::dbgs() << "  ";
+          entry.first.print(llvm::dbgs());
+          llvm::dbgs() << " -> ";
+          entry.second.print(llvm::dbgs());
+          llvm::dbgs() << '\n';
+        }
+      );
+
       if (OverrideTableEntries.empty())
         return;
 
@@ -2702,12 +2725,12 @@ namespace {
     using super::asImpl;
     using super::IGM;
     using super::Target;
+    using super::VTable;
 
     ConstantStructBuilder &B;
 
     const ClassLayout &FieldLayout;
     const ClassMetadataLayout &MetadataLayout;
-    const SILVTable *VTable;
 
     Size AddressPoint;
 
@@ -2717,8 +2740,7 @@ namespace {
                              const ClassLayout &fieldLayout)
       : super(IGM, theClass), B(builder),
         FieldLayout(fieldLayout),
-        MetadataLayout(IGM.getClassMetadataLayout(theClass)),
-        VTable(IGM.getSILModule().lookUpVTable(theClass)) {}
+        MetadataLayout(IGM.getClassMetadataLayout(theClass)) {}
 
   public:
     SILType getLoweredType() {
@@ -2854,7 +2876,7 @@ namespace {
                            PointerAuthEntity::Special::HeapDestructor);
       } else {
         // In case the optimizer removed the function. See comment in
-        // addMethod().
+        // addReifiedVTableEntry().
         B.addNullPointer(IGM.FunctionPtrTy);
       }
     }
@@ -2973,7 +2995,7 @@ namespace {
       B.add(data);
     }
 
-    void addMethod(SILDeclRef fn) {
+    void addReifiedVTableEntry(SILDeclRef fn) {
       // Find the vtable entry.
       assert(VTable && "no vtable?!");
       auto entry = VTable->getEntry(IGM.getSILModule(), fn);
@@ -5075,3 +5097,33 @@ void IRGenModule::emitOpaqueTypeDecl(OpaqueTypeDecl *D) {
   // Emit the opaque type descriptor.
   OpaqueTypeDescriptorBuilder(*this, D).emit();
 }
+
+bool irgen::methodRequiresReifiedVTableEntry(IRGenModule &IGM,
+                                             const SILVTable *vtable,
+                                             SILDeclRef method) {
+  auto &M = IGM.getSILModule();
+  auto entry = vtable->getEntry(IGM.getSILModule(), method);
+  if (!entry) {
+    return true;
+  }
+  
+  // We may be able to elide the vtable entry, ABI permitting, if it's not
+  // overridden.
+  if (!entry->isNonOverridden()) {
+    return true;
+  }
+  
+  // Does the ABI require a vtable entry to exist? 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()->getEffectiveAccess() >= AccessLevel::Public) {
+    // TODO: Check whether we use a resilient ABI to access this
+    // class's methods. We can drop unnecessary vtable entries if we do;
+    // otherwise fixed vtable offsets are part of the ABI.
+    return true;
+  }
+    
+  // Otherwise, we can leave this method out of the runtime vtable.
+  return false;
+}

lib/IRGen/MetadataLayout.cpp

@@ -330,12 +330,12 @@ ClassMetadataLayout::ClassMetadataLayout(IRGenModule &IGM, ClassDecl *decl)
       super::addGenericArgument(requirement, forClass);
     }
 
-    void addMethod(SILDeclRef fn) {
+    void addReifiedVTableEntry(SILDeclRef fn) {
       if (fn.getDecl()->getDeclContext() == Target) {
         ++Layout.NumImmediateMembers;
         Layout.MethodInfos.try_emplace(fn, getNextOffset());
       }
-      super::addMethod(fn);
+      super::addReifiedVTableEntry(fn);
     }
 
     void noteStartOfFieldOffsets(ClassDecl *forClass) {

lib/SIL/IR/SILModule.cpp

@@ -476,7 +476,8 @@ void SILModule::eraseGlobalVariable(SILGlobalVariable *G) {
   getSILGlobalList().erase(G);
 }
 
-SILVTable *SILModule::lookUpVTable(const ClassDecl *C) {
+SILVTable *SILModule::lookUpVTable(const ClassDecl *C,
+                                   bool deserializeLazily) {
   if (!C)
     return nullptr;
 
@@ -485,6 +486,9 @@ SILVTable *SILModule::lookUpVTable(const ClassDecl *C) {
   if (R != VTableMap.end())
     return R->second;
 
+  if (!deserializeLazily)
+    return nullptr;
+
   // If that fails, try to deserialize it. If that fails, return nullptr.
   SILVTable *Vtbl = getSILLoader()->lookupVTable(C);
   if (!Vtbl)

lib/SIL/IR/SILPrinter.cpp

@@ -3131,16 +3131,17 @@ void SILVTable::print(llvm::raw_ostream &OS, bool Verbose) const {
     switch (entry.getKind()) {
     case SILVTable::Entry::Kind::Normal:
       break;
-    case SILVTable::Entry::Kind::NormalNonOverridden:
-      OS << " [nonoverridden]";
-      break;
     case SILVTable::Entry::Kind::Inherited:
       OS << " [inherited]";
       break;
     case SILVTable::Entry::Kind::Override:
       OS << " [override]";
       break;
     }
+    if (entry.isNonOverridden()) {
+      OS << " [nonoverridden]";
+    }
+
     OS << "\t// " << demangleSymbol(entry.getImplementation()->getName());
     OS << "\n";
   }

lib/SIL/Parser/ParseSIL.cpp

@@ -6083,7 +6083,8 @@ bool SILParserState::parseSILVTable(Parser &P) {
       }
 
       auto Kind = SILVTable::Entry::Kind::Normal;
-      if (P.Tok.is(tok::l_square)) {
+      bool NonOverridden = false;
+      while (P.Tok.is(tok::l_square)) {
         P.consumeToken(tok::l_square);
         if (P.Tok.isNot(tok::identifier)) {
           P.diagnose(P.Tok.getLoc(), diag::sil_vtable_bad_entry_kind);
@@ -6098,7 +6099,7 @@ bool SILParserState::parseSILVTable(Parser &P) {
           Kind = SILVTable::Entry::Kind::Inherited;
         } else if (P.Tok.getText() == "nonoverridden") {
           P.consumeToken();
-          Kind = SILVTable::Entry::Kind::NormalNonOverridden;
+          NonOverridden = true;
         } else {
           P.diagnose(P.Tok.getLoc(), diag::sil_vtable_bad_entry_kind);
           return true;
@@ -6108,7 +6109,7 @@ bool SILParserState::parseSILVTable(Parser &P) {
           return true;
       }
 
-      vtableEntries.emplace_back(Ref, Func, Kind);
+      vtableEntries.emplace_back(Ref, Func, Kind, NonOverridden);
     } while (P.Tok.isNot(tok::r_brace) && P.Tok.isNot(tok::eof));
   }
 

lib/SIL/Verifier/SILVerifier.cpp

@@ -5425,7 +5425,6 @@ void SILVTable::verify(const SILModule &M) const {
       bool validKind;
       switch (entry.getKind()) {
       case Entry::Normal:
-      case Entry::NormalNonOverridden:
         validKind = true;
         break;
 
@@ -5450,21 +5449,26 @@ void SILVTable::verify(const SILModule &M) const {
 
       switch (entry.getKind()) {
       case Entry::Normal:
-      case Entry::NormalNonOverridden:
         assert(!superEntry && "non-root vtable entry must be inherited or override");
         break;
 
       case Entry::Inherited:
+        if (!superEntry)
+          break;
+
+        assert(entry.isNonOverridden() == superEntry->isNonOverridden()
+               && "inherited vtable entry must share overridden-ness of superclass entry");
         break;
 
       case Entry::Override:
+        assert(!entry.isNonOverridden()
+               && "override entry can't claim to be nonoverridden");
         if (!superEntry)
           break;
 
         // The superclass entry must not prohibit overrides.
-        assert(
-            superEntry->getKind() != Entry::NormalNonOverridden &&
-            "vtable entry overrides an entry that claims to have no overrides");
+        assert(!superEntry->isNonOverridden()
+               && "vtable entry overrides an entry that claims to have no overrides");
         // TODO: Check the root vtable entry for the method too.
         break;
       }