Merge pull request swiftlang#32359 from jckarter/enable-prune-vtables

Add PruneVTables to the performance optimizer passes.

Author: jckarter

include/swift/SIL/SILVTable.h

@@ -64,7 +64,8 @@ class SILVTableEntry {
     // Please update the PointerIntPair above if you add/remove enums.
   };
 
-  SILVTableEntry() : ImplAndKind(nullptr, Kind::Normal) {}
+  SILVTableEntry() : ImplAndKind(nullptr, Kind::Normal),
+                     IsNonOverridden(false) {}
 
   SILVTableEntry(SILDeclRef Method, SILFunction *Implementation, Kind TheKind,
                  bool NonOverridden)
@@ -80,6 +81,19 @@ class SILVTableEntry {
   void setNonOverridden(bool value) { IsNonOverridden = value; }
 
   SILFunction *getImplementation() const { return ImplAndKind.getPointer(); }
+  
+  void print(llvm::raw_ostream &os) const;
+  
+  bool operator==(const SILVTableEntry &e) const {
+    return Method == e.Method
+      && getImplementation() == e.getImplementation()
+      && getKind() == e.getKind()
+      && isNonOverridden() == e.isNonOverridden();
+  }
+  
+  bool operator!=(const SILVTableEntry &e) const {
+    return !(*this == e);
+  }
 };
 
 /// A mapping from each dynamically-dispatchable method of a class to the
@@ -140,9 +154,13 @@ class SILVTable final : public SILAllocated<SILVTable>,
   }
 
   /// Return all of the method entries mutably.
+  /// If you do modify entries, make sure to invoke `updateVTableCache` to update the
+  /// SILModule's cache entry.
   MutableArrayRef<Entry> getMutableEntries() {
     return {getTrailingObjects<SILVTableEntry>(), NumEntries};
   }
+                          
+  void updateVTableCache(const Entry &entry);
 
   /// Look up the implementation function for the given method.
   Optional<Entry> getEntry(SILModule &M, SILDeclRef method) const;

lib/IRGen/ClassMetadataVisitor.h

@@ -103,6 +103,10 @@ template <class Impl> class ClassMetadataVisitor
   /// of a generic-layout class.
   void noteEndOfFieldOffsets(ClassDecl *whichClass) {}
 
+  /// Notes the existence of a formally virtual method that has been elided from the
+  /// reified vtable because it has no overrides.
+  void noteNonoverriddenMethod(SILDeclRef method) {}
+        
 private:
   /// Add fields associated with the given class and its bases.
   void addClassMembers(ClassDecl *theClass) {
@@ -173,8 +177,11 @@ template <class Impl> class ClassMetadataVisitor
     // Does this method require a reified runtime vtable entry?
     if (!VTable || methodRequiresReifiedVTableEntry(IGM, VTable, declRef)) {
       asImpl().addReifiedVTableEntry(declRef);
+    } else {
+      asImpl().noteNonoverriddenMethod(declRef);
     }
   }
+  
 
   void addFieldEntries(Decl *field) {
     if (auto var = dyn_cast<VarDecl>(field)) {

lib/IRGen/GenClass.cpp

@@ -2512,18 +2512,26 @@ FunctionPointer irgen::emitVirtualMethodValue(IRGenFunction &IGF,
   // Find the vtable entry we're interested in.
   auto methodInfo =
     IGF.IGM.getClassMetadataLayout(classDecl).getMethodInfo(IGF, method);
-  auto offset = methodInfo.getOffset();
-
-  auto slot = IGF.emitAddressAtOffset(metadata, offset,
-                                      signature.getType()->getPointerTo(),
-                                      IGF.IGM.getPointerAlignment());
-  auto fnPtr = IGF.emitInvariantLoad(slot);
-
-  auto &schema = IGF.getOptions().PointerAuth.SwiftClassMethods;
-  auto authInfo =
-    PointerAuthInfo::emit(IGF, schema, slot.getAddress(), method);
-
-  return FunctionPointer(fnPtr, authInfo, signature);
+  switch (methodInfo.getKind()) {
+  case ClassMetadataLayout::MethodInfo::Kind::Offset: {
+    auto offset = methodInfo.getOffsett();
+
+    auto slot = IGF.emitAddressAtOffset(metadata, offset,
+                                        signature.getType()->getPointerTo(),
+                                        IGF.IGM.getPointerAlignment());
+    auto fnPtr = IGF.emitInvariantLoad(slot);
+    auto &schema = IGF.getOptions().PointerAuth.SwiftClassMethods;
+    auto authInfo =
+      PointerAuthInfo::emit(IGF, schema, slot.getAddress(), method);
+    return FunctionPointer(fnPtr, authInfo, signature);
+  }
+  case ClassMetadataLayout::MethodInfo::Kind::DirectImpl: {
+    auto fnPtr = llvm::ConstantExpr::getBitCast(methodInfo.getDirectImpl(),
+                                           signature.getType()->getPointerTo());
+    return FunctionPointer::forDirect(fnPtr, signature);
+  }
+  }
+  
 }
 
 FunctionPointer

lib/IRGen/GenMeta.cpp

@@ -263,6 +263,55 @@ static Flags getMethodDescriptorFlags(ValueDecl *fn) {
   return Flags(kind).withIsInstance(!fn->isStatic());
 }
 
+static void buildMethodDescriptorFields(IRGenModule &IGM,
+                             const SILVTable *VTable,
+                             SILDeclRef fn,
+                             ConstantStructBuilder &descriptor) {
+  auto *func = cast<AbstractFunctionDecl>(fn.getDecl());
+  // Classify the method.
+  using Flags = MethodDescriptorFlags;
+  auto flags = getMethodDescriptorFlags<Flags>(func);
+
+  // Remember if the declaration was dynamic.
+  if (func->shouldUseObjCDispatch())
+    flags = flags.withIsDynamic(true);
+
+  // Include the pointer-auth discriminator.
+  if (auto &schema = IGM.getOptions().PointerAuth.SwiftClassMethods) {
+    auto discriminator =
+      PointerAuthInfo::getOtherDiscriminator(IGM, schema, fn);
+    flags = flags.withExtraDiscriminator(discriminator->getZExtValue());
+  }
+
+  // TODO: final? open?
+  descriptor.addInt(IGM.Int32Ty, flags.getIntValue());
+
+  if (auto entry = VTable->getEntry(IGM.getSILModule(), fn)) {
+    assert(entry->getKind() == SILVTable::Entry::Kind::Normal);
+    auto *implFn = IGM.getAddrOfSILFunction(entry->getImplementation(),
+                                            NotForDefinition);
+    descriptor.addRelativeAddress(implFn);
+  } else {
+    // The method is removed by dead method elimination.
+    // It should be never called. We add a pointer to an error function.
+    descriptor.addRelativeAddressOrNull(nullptr);
+  }
+}
+
+void IRGenModule::emitNonoverriddenMethodDescriptor(const SILVTable *VTable,
+                                                    SILDeclRef declRef) {
+ 
+  ConstantInitBuilder ib(*this);
+  ConstantStructBuilder sb(ib.beginStruct(MethodDescriptorStructTy));
+
+  buildMethodDescriptorFields(*this, VTable, declRef, sb);
+  
+  auto init = sb.finishAndCreateFuture();
+  
+  auto entity = LinkEntity::forMethodDescriptor(declRef);
+  getAddrOfLLVMVariable(entity, init, DebugTypeInfo());
+}
+
 namespace {
   template<class Impl>
   class ContextDescriptorBuilderBase {
@@ -1416,6 +1465,7 @@ namespace {
 
     SILVTable *VTable;
     bool Resilient;
+    bool HasNonoverriddenMethods = false;
 
     SmallVector<SILDeclRef, 8> VTableEntries;
     SmallVector<std::pair<SILDeclRef, SILDeclRef>, 8> OverrideTableEntries;
@@ -1442,7 +1492,7 @@ namespace {
     void addMethod(SILDeclRef fn) {
       if (!VTable || methodRequiresReifiedVTableEntry(IGM, VTable, fn)) {
         VTableEntries.push_back(fn);
-      } else if (getType()->getEffectiveAccess() >= AccessLevel::Public) {
+      } else if (hasPublicVisibility(fn.getLinkage(NotForDefinition))) {
         // Emit a stub method descriptor and lookup function for nonoverridden
         // methods so that resilient code sequences can still use them.
         emitNonoverriddenMethod(fn);
@@ -1539,14 +1589,15 @@ 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))
+      // and has a non-empty vtable, as well as no elided methods.
+      if (IGM.hasResilientMetadata(getType(), ResilienceExpansion::Minimal)
+          && (HasNonoverriddenMethods || !VTableEntries.empty()))
         IGM.emitMethodLookupFunction(getType());
 
+      if (VTableEntries.empty())
+        return;
+      
       auto offset = MetadataLayout->hasResilientSuperclass()
                       ? MetadataLayout->getRelativeVTableOffset()
                       : MetadataLayout->getStaticVTableOffset();
@@ -1564,51 +1615,31 @@ namespace {
                       B.getAddrOfCurrentPosition(IGM.MethodDescriptorStructTy));
 
       // Actually build the descriptor.
-      auto *func = cast<AbstractFunctionDecl>(fn.getDecl());
       auto descriptor = B.beginStruct(IGM.MethodDescriptorStructTy);
-
-      // Classify the method.
-      using Flags = MethodDescriptorFlags;
-      auto flags = getMethodDescriptorFlags<Flags>(func);
-
-      // Remember if the declaration was dynamic.
-      if (func->shouldUseObjCDispatch())
-        flags = flags.withIsDynamic(true);
-
-      // Include the pointer-auth discriminator.
-      if (auto &schema = IGM.getOptions().PointerAuth.SwiftClassMethods) {
-        auto discriminator =
-          PointerAuthInfo::getOtherDiscriminator(IGM, schema, fn);
-        flags = flags.withExtraDiscriminator(discriminator->getZExtValue());
-      }
-
-      // TODO: final? open?
-      descriptor.addInt(IGM.Int32Ty, flags.getIntValue());
-
-      if (auto entry = VTable->getEntry(IGM.getSILModule(), fn)) {
-        assert(entry->getKind() == SILVTable::Entry::Kind::Normal);
-        auto *implFn = IGM.getAddrOfSILFunction(entry->getImplementation(),
-                                                NotForDefinition);
-        descriptor.addRelativeAddress(implFn);
-      } else {
-        // The method is removed by dead method elimination.
-        // It should be never called. We add a pointer to an error function.
-        descriptor.addRelativeAddressOrNull(nullptr);
-      }
-
+      buildMethodDescriptorFields(IGM, VTable, fn, descriptor);
       descriptor.finishAndAddTo(B);
 
       // Emit method dispatch thunk if the class is resilient.
+      auto *func = cast<AbstractFunctionDecl>(fn.getDecl());
       if (Resilient &&
           func->getEffectiveAccess() >= AccessLevel::Public) {
         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.
+      HasNonoverriddenMethods = true;
+      // Although this method is non-overridden and therefore left out of the
+      // vtable, we still need to maintain the ABI of a potentially-overridden
+      // method for external clients.
+      
+      // Emit method dispatch thunk.
+      IGM.emitDispatchThunk(fn);
+      // Emit a freestanding method descriptor structure. This doesn't have to
+      // exist in the table in the class's context descriptor since it isn't
+      // in the vtable, but external clients need to be able to link against the
+      // symbol.
+      IGM.emitNonoverriddenMethodDescriptor(VTable, fn);
     }
 
     void addOverrideTable() {
@@ -5107,28 +5138,61 @@ 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) {
+    LLVM_DEBUG(llvm::dbgs() << "vtable entry in "
+                            << vtable->getClass()->getName()
+                            << " for ";
+               method.print(llvm::dbgs());
+               llvm::dbgs() << " is not available\n");
     return true;
   }
+  LLVM_DEBUG(llvm::dbgs() << "entry: ";
+             entry->print(llvm::dbgs());
+             llvm::dbgs() << "\n");
 
   // We may be able to elide the vtable entry, ABI permitting, if it's not
   // overridden.
   if (!entry->isNonOverridden()) {
+    LLVM_DEBUG(llvm::dbgs() << "vtable entry in "
+                            << vtable->getClass()->getName()
+                            << " for ";
+               method.print(llvm::dbgs());
+               llvm::dbgs() << " is overridden\n");
     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) {
-    // 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;
+  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 (!originatingClass->isResilient()) {
+      LLVM_DEBUG(llvm::dbgs() << "vtable entry in "
+                              << vtable->getClass()->getName()
+                              << " for ";
+                 method.print(llvm::dbgs());
+                 llvm::dbgs() << " originates from a public fragile class\n");
+      return true;
+    }
   }
 
   // Otherwise, we can leave this method out of the runtime vtable.
+  LLVM_DEBUG(llvm::dbgs() << "vtable entry in "
+                          << vtable->getClass()->getName()
+                          << " for ";
+             method.print(llvm::dbgs());
+             llvm::dbgs() << " can be elided\n");
   return false;
 }