SILGen: Emit a thunk that wraps the call to a back deployed function. The thunk calls the original function if it is available at runtime and otherwise falls back to calling a copy that is emitted into the client (not yet implemented).

tshortli · tshortli · commit 97e8e31b5cfc · 2022-02-17T11:28:12.000-08:00
diff --git a/lib/SIL/IR/SILDeclRef.cpp b/lib/SIL/IR/SILDeclRef.cpp
@@ -317,6 +317,11 @@ SILLinkage SILDeclRef::getLinkage(ForDefinition_t forDefinition) const {
       return maybeAddExternal(SILLinkage::PublicNonABI);
   }
 
+  // Back deployment thunks are emitted into the client and therefore have
+  // PublicNonABI linkage.
+  if (isBackDeployedThunk())
+    return maybeAddExternal(SILLinkage::PublicNonABI);
+
   enum class Limit {
     /// No limit.
     None,
diff --git a/lib/SILGen/CMakeLists.txt b/lib/SILGen/CMakeLists.txt
@@ -11,6 +11,7 @@ add_swift_host_library(swiftSILGen STATIC
   SwitchEnumBuilder.cpp
   SILGen.cpp
   SILGenApply.cpp
+  SILGenBackDeploy.cpp
   SILGenBridging.cpp
   SILGenBuilder.cpp
   SILGenBuiltin.cpp
diff --git a/lib/SILGen/SILGen.cpp b/lib/SILGen/SILGen.cpp
@@ -853,6 +853,23 @@ void SILGenModule::emitFunctionDefinition(SILDeclRef constant, SILFunction *f) {
     return;
   }
 
+  if (constant.isBackDeployedThunk()) {
+    auto loc = constant.getAsRegularLocation();
+    loc.markAutoGenerated();
+    auto *dc = loc.getAsDeclContext();
+    assert(dc);
+
+    preEmitFunction(constant, f, loc);
+    PrettyStackTraceSILFunction X("silgen emitBackDeployedThunk", f);
+    f->setBare(IsBare);
+    f->setThunk(IsThunk);
+
+    SILGenFunction(*this, *f, dc).emitBackDeployedThunk(constant);
+
+    postEmitFunction(constant, f);
+    return;
+  }
+
   switch (constant.kind) {
   case SILDeclRef::Kind::Func: {
     if (auto *ce = constant.getAbstractClosureExpr()) {
@@ -1383,6 +1400,12 @@ void SILGenModule::emitAbstractFuncDecl(AbstractFunctionDecl *AFD) {
     auto thunk = SILDeclRef(AFD).asDistributed();
     emitDistributedThunk(thunk);
   }
+
+  if (AFD->isBackDeployed()) {
+    // FIXME(backDeploy): Emit client copy of back deployed function
+    auto thunk = SILDeclRef(AFD).asBackDeployed();
+    emitBackDeployedThunk(thunk);
+  }
 }
 
 void SILGenModule::emitFunction(FuncDecl *fd) {
diff --git a/lib/SILGen/SILGen.h b/lib/SILGen/SILGen.h
@@ -335,7 +335,12 @@ class LLVM_LIBRARY_VISIBILITY SILGenModule : public ASTVisitor<SILGenModule> {
 
   /// Emits a thunk from an actor function to a potentially distributed call.
   void emitDistributedThunk(SILDeclRef thunk);
-  
+
+  /// Emits a thunk that calls either the original function if it is available
+  /// or otherwise calls a copy of the function that was emitted into the
+  /// calling module.
+  void emitBackDeployedThunk(SILDeclRef thunk);
+
   void preEmitFunction(SILDeclRef constant, SILFunction *F, SILLocation L);
   void postEmitFunction(SILDeclRef constant, SILFunction *F);
   
diff --git a/lib/SILGen/SILGenApply.cpp b/lib/SILGen/SILGenApply.cpp
@@ -1030,6 +1030,11 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
   }
 
   void processClassMethod(DeclRefExpr *e, AbstractFunctionDecl *afd) {
+    // FIXME(backDeploy): Investigate support for back deployed class method
+    // calls
+    assert(!afd->isBackDeployed() &&
+           "back deployed method calls are unsupported");
+
     ArgumentSource selfArgSource(selfApply->getBase());
     setSelfParam(std::move(selfArgSource));
 
@@ -1119,6 +1124,10 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
     auto constant = SILDeclRef(e->getDecl());
     if (callSite && callSite->shouldApplyDistributedThunk()) {
       constant = constant.asDistributed(true);
+    } else if (e->getDecl()->getAttrs().hasAttribute<BackDeployAttr>()) {
+      // If we're calling a back deployed function we need to call through
+      // a thunk instead that handles availability.
+      constant = constant.asBackDeployed(true);
     } else {
       constant = constant.asForeign(
                    !isConstructorWithGeneratedAllocatorThunk(e->getDecl())
@@ -5137,6 +5146,8 @@ RValue SILGenFunction::emitApplyMethod(SILLocation loc, ConcreteDeclRef declRef,
 
   if (call->isDistributed()) {
     callRef = callRef.asDistributed(true);
+  } else if (call->isBackDeployed()) {
+    callRef = callRef.asBackDeployed(true);
   }
 
   auto declRefConstant = getConstantInfo(getTypeExpansionContext(), callRef);
diff --git a/lib/SILGen/SILGenBackDeploy.cpp b/lib/SILGen/SILGenBackDeploy.cpp
@@ -0,0 +1,198 @@
+//===--- SILGenBackDeploy.cpp - SILGen for back deployment ----------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2022 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "SILGenFunction.h"
+#include "SILGenFunctionBuilder.h"
+#include "Scope.h"
+#include "swift/SIL/SILDeclRef.h"
+
+using namespace swift;
+using namespace Lowering;
+
+/// Emit the following branch SIL instruction:
+/// \verbatim
+/// if #available(OSVersion) {
+///   <availableBB>
+/// } else {
+///   <unavailableBB>
+/// }
+/// \endverbatim
+static void emitBackDeployIfAvailableCondition(SILGenFunction &SGF,
+                                               AbstractFunctionDecl *AFD,
+                                               SILLocation loc,
+                                               SILBasicBlock *availableBB,
+                                               SILBasicBlock *unavailableBB) {
+  PlatformKind platform = targetPlatform(SGF.SGM.getASTContext().LangOpts);
+  auto introduced = AFD->getIntroducedOSVersion(platform);
+  VersionRange OSVersion = VersionRange::empty();
+  if (introduced.hasValue()) {
+    OSVersion = VersionRange::allGTE(*introduced);
+  }
+
+  SILValue booleanTestValue;
+  if (OSVersion.isEmpty() || OSVersion.isAll()) {
+    // If there's no check for the current platform, this condition is
+    // trivially true.
+    SILType i1 = SILType::getBuiltinIntegerType(1, SGF.getASTContext());
+    booleanTestValue = SGF.B.createIntegerLiteral(loc, i1, 1);
+  } else {
+    booleanTestValue = SGF.emitOSVersionRangeCheck(loc, OSVersion);
+  }
+
+  SGF.B.createCondBranch(loc, booleanTestValue, availableBB, unavailableBB);
+}
+
+/// Emits a function or method application, forwarding parameters.
+SILValue emitBackDeployForwardApply(SILGenFunction &SGF,
+                                    AbstractFunctionDecl *AFD, SILLocation loc,
+                                    SILDeclRef function,
+                                    SmallVector<SILValue, 8> &params,
+                                    SILBasicBlock *rethrowBB) {
+  TypeExpansionContext TEC = SGF.getTypeExpansionContext();
+  auto fnType = SGF.SGM.Types.getConstantOverrideType(TEC, function);
+  auto silFnType =
+      SILType::getPrimitiveObjectType(fnType).castTo<SILFunctionType>();
+  SILFunctionConventions fnConv(silFnType, SGF.SGM.M);
+
+  if (silFnType->hasErrorResult())
+    assert(rethrowBB && "must provide rethrow basic block");
+
+  bool isClassMethod = false;
+  if (auto classDecl = dyn_cast<ClassDecl>(AFD->getDeclContext())) {
+    if (!classDecl->isFinal() && !AFD->isFinal() &&
+        !AFD->hasForcedStaticDispatch())
+      isClassMethod = true;
+  }
+
+  SILBasicBlock *normalBB = SGF.createBasicBlock();
+  SILBasicBlock *errorBB = rethrowBB ? SGF.createBasicBlock() : nullptr;
+
+  SILValue functionRef;
+  if (isClassMethod) {
+    auto selfValue = ManagedValue::forUnmanaged(SGF.F.getSelfArgument());
+    functionRef =
+        SGF.emitClassMethodRef(loc, selfValue.getValue(), function, fnType);
+  } else {
+    functionRef = SGF.emitGlobalFunctionRef(loc, function);
+  }
+  auto subs = SGF.F.getForwardingSubstitutionMap();
+
+  if (errorBB) {
+    SGF.B.createTryApply(loc, functionRef, subs, params, normalBB, errorBB);
+  } else {
+    auto result = SGF.B.createApply(loc, functionRef, subs, params);
+    SGF.B.createBranch(loc, normalBB, {result});
+  }
+
+  if (errorBB) {
+    SGF.B.emitBlock(errorBB);
+    SILValue error = errorBB->createPhiArgument(fnConv.getSILErrorType(TEC),
+                                                OwnershipKind::Owned);
+    SGF.B.createBranch(loc, rethrowBB, {error});
+  }
+
+  SGF.B.emitBlock(normalBB);
+  return normalBB->createPhiArgument(fnConv.getSILResultType(TEC),
+                                     OwnershipKind::Owned);
+}
+
+void SILGenFunction::emitBackDeployedThunk(SILDeclRef thunk) {
+  // Generate code equivalent to:
+  //
+  //  func X_thunk(...) async throws -> ... {
+  //    if #available(...) {
+  //      return try await X(...)
+  //    } else {
+  //      return try await X_clientCopy(...)
+  //    }
+  //  }
+
+  assert(thunk.isBackDeployed);
+
+  // Get a reference to the original declaration. We'll call the original
+  // declaration at runtime if it is available.
+  SILDeclRef original = thunk.asBackDeployed(false);
+  auto AFD = cast<AbstractFunctionDecl>(thunk.getDecl());
+
+  // Use the same generic environment as the original entry point.
+  F.setGenericEnvironment(SGM.Types.getConstantGenericEnvironment(original));
+
+  auto loc = thunk.getAsRegularLocation();
+  loc.markAutoGenerated();
+  Scope scope(Cleanups, CleanupLocation(loc));
+
+  auto methodTy =
+      SGM.Types.getConstantOverrideType(getTypeExpansionContext(), thunk);
+  auto derivativeFnSILTy = SILType::getPrimitiveObjectType(methodTy);
+  auto silFnType = derivativeFnSILTy.castTo<SILFunctionType>();
+  SILFunctionConventions fnConv(silFnType, SGM.M);
+  auto resultType = fnConv.getSILResultType(getTypeExpansionContext());
+
+  // Gather params for forwarding.
+  SmallVector<SILValue, 8> paramsForForwarding;
+  bindParametersForForwarding(AFD->getParameters(), paramsForForwarding);
+  if (auto *selfDecl = AFD->getImplicitSelfDecl())
+    bindParameterForForwarding(selfDecl, paramsForForwarding);
+
+  auto rethrowBB =
+      silFnType->hasErrorResult() ? createBasicBlock("rethrowBB") : nullptr;
+  auto returnBB = createBasicBlock("returnBB");
+
+  SILBasicBlock *availableBB = createBasicBlock("availableBB");
+  SILBasicBlock *unavailableBB = createBasicBlock("unavailableBB");
+
+  //  if #available(...) {
+  //    <availableBB>
+  //  } else {
+  //    <unavailableBB>
+  //  }
+  emitBackDeployIfAvailableCondition(*this, AFD, loc, availableBB,
+                                     unavailableBB);
+
+  // <availableBB>:
+  //   return (try)? (await)? (self.)?X(...)
+  {
+    B.emitBlock(availableBB);
+    SILValue result = emitBackDeployForwardApply(
+        *this, AFD, loc, original, paramsForForwarding, rethrowBB);
+    B.createBranch(loc, returnBB, {result});
+  }
+
+  // <unavailableBB>:
+  //   return (try)? (await)? (self.)?X_clientCopy(...)
+  {
+    B.emitBlock(unavailableBB);
+    // FIXME(backDeploy): Emit a forward apply of client copy of function
+    ManagedValue undef = emitUndef(resultType);
+    B.createBranch(loc, returnBB, {undef});
+  }
+
+  // Emit return logic.
+  {
+    B.emitBlock(returnBB);
+    SILValue result =
+        returnBB->createPhiArgument(resultType, OwnershipKind::Owned);
+
+    B.createReturn(loc, result);
+  }
+
+  // Emit the rethrow logic.
+  if (rethrowBB) {
+    B.emitBlock(rethrowBB);
+    SILValue error = rethrowBB->createPhiArgument(
+        fnConv.getSILErrorType(getTypeExpansionContext()),
+        OwnershipKind::Owned);
+
+    Cleanups.emitCleanupsForReturn(CleanupLocation(loc), IsForUnwind);
+    B.createThrow(loc, error);
+  }
+}
diff --git a/lib/SILGen/SILGenFunction.h b/lib/SILGen/SILGenFunction.h
@@ -2034,6 +2034,15 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
                                            CanSILFunctionType toType,
                                            bool reorderSelf);
 
+  //===--------------------------------------------------------------------===//
+  // Back Deployment thunks
+  //===--------------------------------------------------------------------===//
+
+  /// Invokes the original, back deployed declaration if it is available at
+  /// runtime. Otherwise, invoke a copy of the original function emitted
+  /// locally.
+  void emitBackDeployedThunk(SILDeclRef thunk);
+
   //===---------------------------------------------------------------------===//
   // Distributed Actors
   //===---------------------------------------------------------------------===//
diff --git a/lib/SILGen/SILGenThunk.cpp b/lib/SILGen/SILGenThunk.cpp
@@ -112,6 +112,12 @@ void SILGenModule::emitDistributedThunk(SILDeclRef thunk) {
   emitFunctionDefinition(thunk, getFunction(thunk, ForDefinition));
 }
 
+void SILGenModule::emitBackDeployedThunk(SILDeclRef thunk) {
+  // Thunks are always emitted by need, so don't need delayed emission.
+  assert(thunk.isBackDeployedThunk() && "back deployed thunks only");
+  emitFunctionDefinition(thunk, getFunction(thunk, ForDefinition));
+}
+
 SILValue
 SILGenFunction::emitGlobalFunctionRef(SILLocation loc, SILDeclRef constant,
                                       SILConstantInfo constantInfo,
diff --git a/test/SILGen/back_deploy_attribute.swift b/test/SILGen/back_deploy_attribute.swift
