Merge pull request #13822 from slavapestov/protocol-dispatch-thunks

Protocol dispatch thunks

Author: slavapestov

include/swift/IRGen/Linking.h

@@ -108,6 +108,18 @@ class LinkEntity {
 #define LINKENTITY_GET_FIELD(value, field) ((value & field##Mask) >> field##Shift)
 
   enum class Kind {
+    /// A method dispatch thunk.  The pointer is a FuncDecl* inside a protocol
+    /// or a class.
+    DispatchThunk,
+
+    /// A method dispatch thunk for an initializing constructor.  The pointer
+    /// is a ConstructorDecl* inside a class.
+    DispatchThunkInitializer,
+
+    /// A method dispatch thunk for an allocating constructor.  The pointer is a
+    /// ConstructorDecl* inside a protocol or a class.
+    DispatchThunkAllocator,
+
     /// A field offset.  The pointer is a VarDecl*.
     FieldOffset,
 
@@ -227,15 +239,6 @@ class LinkEntity {
   };
   friend struct llvm::DenseMapInfo<LinkEntity>;
 
-  static bool isFunction(ValueDecl *decl) {
-    return (isa<FuncDecl>(decl) || isa<EnumElementDecl>(decl) ||
-            isa<ConstructorDecl>(decl));
-  }
-
-  static bool hasGetterSetter(ValueDecl *decl) {
-    return (isa<VarDecl>(decl) || isa<SubscriptDecl>(decl));
-  }
-
   Kind getKind() const {
     return Kind(LINKENTITY_GET_FIELD(Data, Kind));
   }
@@ -362,6 +365,36 @@ class LinkEntity {
   LinkEntity() = default;
 
 public:
+  static LinkEntity forDispatchThunk(SILDeclRef declRef) {
+    assert(!declRef.isForeign &&
+           !declRef.isDirectReference &&
+           !declRef.isCurried);
+
+    LinkEntity::Kind kind;
+
+    auto *decl = declRef.getDecl();
+    assert(isa<ClassDecl>(decl->getDeclContext()) ||
+           isa<ProtocolDecl>(decl->getDeclContext()));
+
+    switch (declRef.kind) {
+    case SILDeclRef::Kind::Func:
+      kind = Kind::DispatchThunk;
+      break;
+    case SILDeclRef::Kind::Initializer:
+      kind = Kind::DispatchThunkInitializer;
+      break;
+    case SILDeclRef::Kind::Allocator:
+      kind = Kind::DispatchThunkAllocator;
+      break;
+    default:
+      llvm_unreachable("Bad SILDeclRef for dispatch thunk");
+    }
+
+    LinkEntity entity;
+    entity.setForDecl(kind, decl);
+    return entity;
+  }
+
   static LinkEntity forFieldOffset(VarDecl *decl, bool isIndirect) {
     LinkEntity entity;
     entity.Pointer = decl;

lib/IRGen/CMakeLists.txt

@@ -28,6 +28,7 @@ add_swift_library(swiftIRGen STATIC
   GenProto.cpp
   GenReflection.cpp
   GenStruct.cpp
+  GenThunk.cpp
   GenTuple.cpp
   GenType.cpp
   GenValueWitness.cpp

lib/IRGen/GenDecl.cpp

@@ -1213,6 +1213,18 @@ SILLinkage LinkEntity::getLinkage(ForDefinition_t forDefinition) const {
   };
 
   switch (getKind()) {
+  case Kind::DispatchThunk:
+  case Kind::DispatchThunkInitializer:
+  case Kind::DispatchThunkAllocator: {
+    auto *decl = getDecl();
+
+    // Protocol requirements don't have their own access control
+    if (auto *proto = dyn_cast<ProtocolDecl>(decl->getDeclContext()))
+      decl = proto;
+
+    return getSILLinkage(getDeclLinkage(decl), forDefinition);
+  }
+
   // Most type metadata depend on the formal linkage of their type.
   case Kind::ValueWitnessTable: {
     auto type = getType();
@@ -1363,6 +1375,11 @@ static bool isAvailableExternally(IRGenModule &IGM, Type type) {
 
 bool LinkEntity::isAvailableExternally(IRGenModule &IGM) const {
   switch (getKind()) {
+  case Kind::DispatchThunk:
+  case Kind::DispatchThunkInitializer:
+  case Kind::DispatchThunkAllocator:
+    return ::isAvailableExternally(IGM, getDecl());
+
   case Kind::ValueWitnessTable:
   case Kind::TypeMetadata:
     return ::isAvailableExternally(IGM, getType());
@@ -1485,7 +1502,7 @@ getIRLinkage(const UniversalLinkageInfo &info, SILLinkage linkage,
 
 /// Given that we're going to define a global value but already have a
 /// forward-declaration of it, update its linkage.
-static void updateLinkageForDefinition(IRGenModule &IGM,
+void irgen::updateLinkageForDefinition(IRGenModule &IGM,
                                        llvm::GlobalValue *global,
                                        const LinkEntity &entity) {
   // TODO: there are probably cases where we can avoid redoing the

lib/IRGen/GenDecl.h

@@ -18,6 +18,7 @@
 #define SWIFT_IRGEN_GENDECL_H
 
 #include "swift/Basic/OptimizationMode.h"
+#include "swift/SIL/SILLocation.h"
 #include "llvm/IR/CallingConv.h"
 #include "DebugTypeInfo.h"
 #include "IRGen.h"
@@ -30,9 +31,14 @@ namespace llvm {
 namespace swift {
 namespace irgen {
   class IRGenModule;
+  class LinkEntity;
   class LinkInfo;
   class Signature;
 
+  void updateLinkageForDefinition(IRGenModule &IGM,
+                                  llvm::GlobalValue *global,
+                                  const LinkEntity &entity);
+
   llvm::Function *createFunction(IRGenModule &IGM,
                                  LinkInfo &linkInfo,
                                  const Signature &signature,

lib/IRGen/GenMeta.cpp

@@ -5524,6 +5524,18 @@ void IRGenModule::emitProtocolDecl(ProtocolDecl *protocol) {
 
   // Note that we emitted this protocol.
   SwiftProtocols.push_back(protocol);
+
+  // If the protocol is resilient, emit dispatch thunks.
+  if (isResilient(protocol, ResilienceExpansion::Minimal)) {
+    for (auto *member : protocol->getMembers()) {
+      if (auto *funcDecl = dyn_cast<FuncDecl>(member)) {
+        emitDispatchThunk(SILDeclRef(funcDecl));
+      }
+      if (auto *ctorDecl = dyn_cast<ConstructorDecl>(member)) {
+        emitDispatchThunk(SILDeclRef(ctorDecl, SILDeclRef::Kind::Allocator));
+      }
+    }
+  }
 }
 
 /// \brief Load a reference to the protocol descriptor for the given protocol.
@@ -5555,5 +5567,5 @@ llvm::Value *irgen::emitMetatypeInstanceType(IRGenFunction &IGF,
   // The instance type field of MetatypeMetadata is immediately after
   // the isa field.
   return emitInvariantLoadFromMetadataAtIndex(IGF, metatypeMetadata, 1,
-                                     IGF.IGM.TypeMetadataPtrTy);
+                                              IGF.IGM.TypeMetadataPtrTy);
 }

lib/IRGen/GenProto.cpp

@@ -266,7 +266,8 @@ PolymorphicConvention::enumerateRequirements(const RequirementCallback &callback
   return enumerateGenericSignatureRequirements(Generics, callback);
 }
 
-void PolymorphicConvention::enumerateUnfulfilledRequirements(const RequirementCallback &callback) {
+void PolymorphicConvention::
+enumerateUnfulfilledRequirements(const RequirementCallback &callback) {
   enumerateRequirements([&](GenericRequirement requirement) {
     if (requirement.Protocol) {
       if (!Fulfillments.getWitnessTable(requirement.TypeParameter,
@@ -589,8 +590,9 @@ void EmitPolymorphicParameters::bindParameterSources(const GetParameterFn &getPa
   }
 }
 
-void EmitPolymorphicParameters::bindParameterSource(SILParameterInfo param, unsigned paramIndex,
-                         const GetParameterFn &getParameter) {
+void EmitPolymorphicParameters::
+bindParameterSource(SILParameterInfo param, unsigned paramIndex,
+                    const GetParameterFn &getParameter) {
   // Ignore indirect parameters for now.  This is potentially dumb.
   if (IGF.IGM.silConv.isSILIndirect(param))
     return;
@@ -3077,33 +3079,39 @@ void irgen::expandTrailingWitnessSignature(IRGenModule &IGM,
 
 FunctionPointer
 irgen::emitWitnessMethodValue(IRGenFunction &IGF,
-                              CanType baseTy,
-                              llvm::Value **baseMetadataCache,
-                              SILDeclRef member,
-                              ProtocolConformanceRef conformance,
-                              CanSILFunctionType fnType) {
-  auto fn = cast<AbstractFunctionDecl>(member.getDecl());
-  auto fnProto = cast<ProtocolDecl>(fn->getDeclContext());
-
-  assert(conformance.getRequirement() == fnProto);
+                              llvm::Value *wtable,
+                              SILDeclRef member) {
+  auto *fn = cast<AbstractFunctionDecl>(member.getDecl());
+  auto proto = cast<ProtocolDecl>(fn->getDeclContext());
 
-  // Find the witness table.
-  llvm::Value *wtable = emitWitnessTableRef(IGF, baseTy, baseMetadataCache,
-                                            conformance);
+  assert(!IGF.IGM.isResilient(proto, ResilienceExpansion::Maximal));
 
   // Find the witness we're interested in.
-  auto &fnProtoInfo = IGF.IGM.getProtocolInfo(conformance.getRequirement());
+  auto &fnProtoInfo = IGF.IGM.getProtocolInfo(proto);
   auto index = fnProtoInfo.getFunctionIndex(fn);
   llvm::Value *witnessFnPtr =
     emitInvariantLoadOfOpaqueWitness(IGF, wtable, index);
 
+  auto fnType = IGF.IGM.getSILTypes().getConstantFunctionType(member);
   Signature signature = IGF.IGM.getSignature(fnType);
   witnessFnPtr = IGF.Builder.CreateBitCast(witnessFnPtr,
-                                         signature.getType()->getPointerTo());
+                                           signature.getType()->getPointerTo());
 
   return FunctionPointer(witnessFnPtr, signature);
 }
 
+FunctionPointer
+irgen::emitWitnessMethodValue(IRGenFunction &IGF,
+                              CanType baseTy,
+                              llvm::Value **baseMetadataCache,
+                              SILDeclRef member,
+                              ProtocolConformanceRef conformance) {
+  llvm::Value *wtable = emitWitnessTableRef(IGF, baseTy, baseMetadataCache,
+                                            conformance);
+
+  return emitWitnessMethodValue(IGF, wtable, member);
+}
+
 Signature IRGenModule::getAssociatedTypeMetadataAccessFunctionSignature() {
   auto &fnType = AssociatedTypeMetadataAccessFunctionTy;
   if (!fnType) {

lib/IRGen/GenProto.h

@@ -52,15 +52,20 @@ namespace irgen {
   /// Set an LLVM value name for the given protocol witness table.
   void setProtocolWitnessTableName(IRGenModule &IGM, llvm::Value *value,
                                    CanType type, ProtocolDecl *protocol);
-  
+
+  /// Extract the method pointer from the given witness table
+  /// as a function value.
+  FunctionPointer emitWitnessMethodValue(IRGenFunction &IGF,
+                                         llvm::Value *wtable,
+                                         SILDeclRef member);
+
   /// Extract the method pointer from an archetype's witness table
   /// as a function value.
   FunctionPointer emitWitnessMethodValue(IRGenFunction &IGF,
                                          CanType baseTy,
                                          llvm::Value **baseMetadataCache,
                                          SILDeclRef member,
-                                         ProtocolConformanceRef conformance,
-                                         CanSILFunctionType fnType);
+                                         ProtocolConformanceRef conformance);
 
   /// Given a type T and an associated type X of some protocol P to
   /// which T conforms, return the type metadata for T.X.

lib/IRGen/GenThunk.cpp

@@ -0,0 +1,81 @@
+//===--- GenThunk.cpp - IR Generation for Method Dispatch Thunks ----------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+//  This file implements IR generation for class and protocol method dispatch
+//  thunks, which are used in resilient builds to hide vtable and witness table
+//  offsets from clients.
+//
+//===----------------------------------------------------------------------===//
+
+#include "Callee.h"
+#include "Explosion.h"
+#include "GenDecl.h"
+#include "GenOpaque.h"
+#include "GenProto.h"
+#include "IRGenFunction.h"
+#include "IRGenModule.h"
+#include "ProtocolInfo.h"
+#include "Signature.h"
+#include "swift/IRGen/Linking.h"
+#include "llvm/IR/Function.h"
+
+using namespace swift;
+using namespace irgen;
+
+/// Find the entry point for a method dispatch thunk.
+llvm::Function *
+IRGenModule::getAddrOfDispatchThunk(SILDeclRef declRef,
+                                    ForDefinition_t forDefinition) {
+  LinkEntity entity = LinkEntity::forDispatchThunk(declRef);
+
+  llvm::Function *&entry = GlobalFuncs[entity];
+  if (entry) {
+    if (forDefinition) updateLinkageForDefinition(*this, entry, entity);
+    return entry;
+  }
+
+  auto fnType = getSILModule().Types.getConstantFunctionType(declRef);
+  Signature signature = getSignature(fnType);
+  LinkInfo link = LinkInfo::get(*this, entity, forDefinition);
+
+  return createFunction(*this, link, signature);
+}
+
+static FunctionPointer lookupMethod(IRGenFunction &IGF,
+                                    SILDeclRef declRef) {
+  // Find the witness table.
+  llvm::Value *wtable = (IGF.CurFn->arg_end() - 1);
+
+  // Find the witness we're interested in.
+  return emitWitnessMethodValue(IGF, wtable, declRef);
+}
+
+llvm::Function *IRGenModule::emitDispatchThunk(SILDeclRef declRef) {
+  auto *f = getAddrOfDispatchThunk(declRef, ForDefinition);
+
+  IRGenFunction IGF(*this, f);
+
+  // Look up the method.
+  auto fn = lookupMethod(IGF, declRef);
+
+  // Call the witness, forwarding all of the parameters.
+  auto params = IGF.collectParameters();
+  auto result = IGF.Builder.CreateCall(fn, params.claimAll());
+
+  // Return the result, if we have one.
+  if (result->getType()->isVoidTy())
+    IGF.Builder.CreateRetVoid();
+  else
+    IGF.Builder.CreateRet(result);
+
+  return f;
+}

lib/IRGen/IRGenModule.h

@@ -1046,6 +1046,11 @@ private:                            \
   /// Cast the given constant to i8*.
   llvm::Constant *getOpaquePtr(llvm::Constant *pointer);
 
+  llvm::Function *getAddrOfDispatchThunk(SILDeclRef declRef,
+                                         ForDefinition_t forDefinition);
+
+  llvm::Function *emitDispatchThunk(SILDeclRef declRef);
+
   Address getAddrOfFieldOffset(VarDecl *D, bool isIndirect,
                                ForDefinition_t forDefinition);
   llvm::Function *getAddrOfValueWitness(CanType concreteType,

lib/IRGen/IRGenSIL.cpp

@@ -5243,13 +5243,22 @@ void IRGenSILFunction::visitWitnessMethodInst(swift::WitnessMethodInst *i) {
   ProtocolConformanceRef conformance = i->getConformance();
   SILDeclRef member = i->getMember();
 
-  auto fnType = i->getType().castTo<SILFunctionType>();
+  if (IGM.isResilient(conformance.getRequirement(),
+                      ResilienceExpansion::Maximal)) {
+    auto *fnPtr = IGM.getAddrOfDispatchThunk(member, NotForDefinition);
+    auto fnType = IGM.getSILTypes().getConstantFunctionType(member);
+    auto sig = IGM.getSignature(fnType);
+    auto fn = FunctionPointer::forDirect(fnPtr, sig);
+
+    setLoweredFunctionPointer(i, fn);
+    return;
+  }
 
   // It would be nice if this weren't discarded.
   llvm::Value *baseMetadataCache = nullptr;
 
   auto fn = emitWitnessMethodValue(*this, baseTy, &baseMetadataCache,
-                                   member, conformance, fnType);
+                                   member, conformance);
 
   setLoweredFunctionPointer(i, fn);
 }