IRGen: Elide nonoverridden entries from public resilient vtables.

A formally virtual method still needs to provide the ABI of an overridable
method, including a dispatch thunk, method descriptor, and support in the
method lookup function for the class to handle `super.` calls from clients.

Author: jckarter

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,28 @@ 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);
+  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 = IGF.Builder.CreateBitCast(methodInfo.getDirectImpl(),
+                                           signature.getType()->getPointerTo());
 
-  return FunctionPointer(fnPtr, authInfo, signature);
+    auto authInfo = PointerAuthInfo::forFunctionPointer(IGF.IGM, methodType);
+    return FunctionPointer(fnPtr, authInfo, 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() {
@@ -5108,13 +5139,27 @@ bool irgen::methodRequiresReifiedVTableEntry(IRGenModule &IGM,
                                              const SILVTable *vtable,
                                              SILDeclRef method) {
   auto 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()));
 
   // 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;
   }
 
@@ -5123,12 +5168,25 @@ bool irgen::methodRequiresReifiedVTableEntry(IRGenModule &IGM,
   // 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;
+    // 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()) {
+      LLVM_DEBUG(llvm::dbgs() << "vtable entry in "
+                              << vtable->getClass()->getName()
+                              << " for ";
+                 method.print(llvm::dbgs());
+                 llvm::dbgs() << " is in 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;
 }

lib/IRGen/GenThunk.cpp

@@ -17,11 +17,13 @@
 //===----------------------------------------------------------------------===//
 
 #include "Callee.h"
+#include "ClassMetadataVisitor.h"
 #include "Explosion.h"
 #include "GenDecl.h"
 #include "GenClass.h"
 #include "GenHeap.h"
 #include "GenOpaque.h"
+#include "GenPointerAuth.h"
 #include "GenProto.h"
 #include "IRGenFunction.h"
 #include "IRGenModule.h"
@@ -171,6 +173,65 @@ void IRGenModule::emitMethodLookupFunction(ClassDecl *classDecl) {
   auto *description = getAddrOfTypeContextDescriptor(classDecl,
                                                      RequireMetadata);
 
+  // Check for lookups of nonoverridden methods first.
+  class LookUpNonoverriddenMethods
+    : public ClassMetadataScanner<LookUpNonoverriddenMethods> {
+  
+    IRGenFunction &IGF;
+    llvm::Value *methodArg;
+      
+  public:
+    LookUpNonoverriddenMethods(IRGenFunction &IGF,
+                               ClassDecl *classDecl,
+                               llvm::Value *methodArg)
+      : ClassMetadataScanner(IGF.IGM, classDecl), IGF(IGF),
+        methodArg(methodArg) {}
+      
+    void noteNonoverriddenMethod(SILDeclRef method) {
+      // The method lookup function would be used only for `super.` calls
+      // from other modules, so we only need to look at public-visibility
+      // methods here.
+      if (!hasPublicVisibility(method.getLinkage(NotForDefinition))) {
+        return;
+      }
+      
+      auto methodDesc = IGM.getAddrOfMethodDescriptor(method, NotForDefinition);
+      
+      auto isMethod = IGF.Builder.CreateICmpEQ(methodArg, methodDesc);
+      
+      auto falseBB = IGF.createBasicBlock("");
+      auto trueBB = IGF.createBasicBlock("");
+
+      IGF.Builder.CreateCondBr(isMethod, trueBB, falseBB);
+      
+      IGF.Builder.emitBlock(trueBB);
+      // Since this method is nonoverridden, we can produce a static result.
+      auto entry = VTable->getEntry(IGM.getSILModule(), method);
+      llvm::Value *impl = IGM.getAddrOfSILFunction(entry->getImplementation(),
+                                                   NotForDefinition);
+      // Sign using the discriminator we would include in the method
+      // descriptor.
+      if (auto &schema = IGM.getOptions().PointerAuth.SwiftClassMethods) {
+        auto discriminator =
+          PointerAuthInfo::getOtherDiscriminator(IGM, schema, method);
+        
+        impl = emitPointerAuthSign(IGF, impl,
+                            PointerAuthInfo(schema.getKey(), discriminator));
+      }
+      impl = IGF.Builder.CreateBitCast(impl, IGM.Int8PtrTy);
+      IGF.Builder.CreateRet(impl);
+      
+      IGF.Builder.emitBlock(falseBB);
+      // Continue emission on the false branch.
+    }
+      
+    void noteResilientSuperclass() {}
+    void noteStartOfImmediateMembers(ClassDecl *clas) {}
+  };
+  
+  LookUpNonoverriddenMethods(IGF, classDecl, method).layout();
+  
+  // Use the runtime to look up vtable entries.
   auto *result = IGF.Builder.CreateCall(getLookUpClassMethodFn(),
                                         {metadata, method, description});
   IGF.Builder.CreateRet(result);

lib/IRGen/IRGenModule.h

@@ -106,6 +106,7 @@ namespace swift {
   class SILModule;
   class SILProperty;
   class SILType;
+  class SILVTable;
   class SILWitnessTable;
   class SourceLoc;
   class SourceFile;
@@ -1373,6 +1374,8 @@ private:                            \
                                             llvm::Constant *definition);
   llvm::Constant *getAddrOfMethodDescriptor(SILDeclRef declRef,
                                             ForDefinition_t forDefinition);
+  void emitNonoverriddenMethodDescriptor(const SILVTable *VTable,
+                                         SILDeclRef declRef);
 
   Address getAddrOfEnumCase(EnumElementDecl *Case,
                             ForDefinition_t forDefinition);