Merge pull request #76836 from gottesmm/thunk_lowering

[sil] Add thunk lowering and the thunk instruction.

Author: gottesmm

SwiftCompilerSources/Sources/SIL/Instruction.swift

@@ -1601,3 +1601,6 @@ final public class CheckedCastAddrBranchInst : TermInst {
     }
   }
 }
+
+final public class ThunkInst : Instruction {
+}

SwiftCompilerSources/Sources/SIL/Registration.swift

@@ -256,4 +256,5 @@ public func registerSILClasses() {
   register(AwaitAsyncContinuationInst.self)
   register(CheckedCastBranchInst.self)
   register(CheckedCastAddrBranchInst.self)
+  register(ThunkInst.self)
 }

docs/SIL.rst

@@ -8107,6 +8107,40 @@ passed to a function (materializeForSet) which escapes the closure in a way not
 expressed by the convert's users. The mandatory pass must ensure the lifetime
 in a conservative way.
 
+
+thunk
+`````
+::
+
+  sil-instruction ::= 'thunk' sil-thunk-attr* sil-value sil-apply-substitution-list? () sil-type
+  sil-thunk-attr ::= '[' thunk-kind ']'
+  sil-thunk-kind ::= identity
+
+  %1 = thunk [identity] %0() : $@convention(thin) (T) -> U
+  // %0 must be of a function type $T -> U
+  // %1 will be of type @callee_guaranteed (T) -> U since we are creating an
+  // "identity" thunk.
+  
+  %1 = thunk [identity] %0<T>() : $@convention(thin) (τ_0_0) -> ()
+  // %0 must be of a function type $T -> ()
+  // %1 will be of type @callee_guaranteed <τ_0_0> (τ_0_0) -> () since we are creating a
+  // "identity" thunk.
+
+Takes in a function and depending on the kind produces a new function result
+that is ``@callee_guaranteed``. The specific way that the function type of the
+input is modified by this instruction depends on the specific sil-thunk-kind of
+the instruction. So for instance, the hop_to_mainactor_if_needed thunk just
+returns a callee_guaranteed version of the input function... but one could
+imagine a "reabstracted" thunk kind that would produce the appropriate
+reabstracted thunk kind.
+
+This instructions is lowered to a true think in Lowered SIL by the ThunkLowering
+pass.
+
+It is assumed that like `partial_apply`_, if we need a substitution map, it will be
+attached to `thunk`_. This ensures that we have the substitution
+map already created if we need to create a `partial_apply`_.
+
 classify_bridge_object
 ``````````````````````
 ::

include/swift/AST/DiagnosticsParse.def

@@ -2165,5 +2165,11 @@ ERROR(sending_repeated,none,
 ERROR(sending_cannot_be_used_with_borrowing,none,
       "'%0' cannot be used together with 'borrowing'", (StringRef))
 
+ERROR(sil_thunkinst_failed_to_parse_kind,none,
+      "'%0' is not a valid thunk kind supported by ThunkInst", (StringRef))
+
+ERROR(sil_failed_to_parse_sil_optional,none,
+      "Expected SIL optional value of the form '[' NAME ']'", ())
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

include/swift/AST/Types.h

@@ -5027,6 +5027,11 @@ class SILFunctionType final
     return getCalleeConvention() == ParameterConvention::Direct_Guaranteed;
   }
 
+  /// Return a copy of this SILFunctionType with its CalleConvention changed to
+  /// \p newCalleeConvention.
+  CanSILFunctionType
+  getWithCalleeConvention(ParameterConvention newCalleeConvention);
+
   /// Is this some kind of coroutine?
   bool isCoroutine() const {
     return getCoroutineKind() != SILCoroutineKind::None;

include/swift/SIL/SILBuilder.h

@@ -1240,6 +1240,17 @@ class SILBuilder {
         WithoutActuallyEscaping, forwardingOwnershipKind));
   }
 
+  ThunkInst *createThunk(SILLocation Loc, SILValue Op, ThunkInst::Kind kind,
+                         SubstitutionMap substitutionMap = {}) {
+    return insert(ThunkInst::create(getSILDebugLocation(Loc), Op, getModule(),
+                                    F, kind, substitutionMap));
+  }
+
+  ThunkInst *createIdentityThunk(SILLocation Loc, SILValue Op,
+                                 SubstitutionMap substitutionMap = {}) {
+    return createThunk(Loc, Op, ThunkInst::Kind::Identity, substitutionMap);
+  }
+
   ConvertEscapeToNoEscapeInst *
   createConvertEscapeToNoEscape(SILLocation Loc, SILValue Op, SILType Ty,
                                 bool lifetimeGuaranteed) {

include/swift/SIL/SILCloner.h

@@ -1783,6 +1783,15 @@ SILCloner<ImplClass>::visitConvertFunctionInst(ConvertFunctionInst *Inst) {
                     : ValueOwnershipKind(OwnershipKind::None)));
 }
 
+template <typename ImplClass>
+void SILCloner<ImplClass>::visitThunkInst(ThunkInst *Inst) {
+  getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
+  recordClonedInstruction(
+      Inst, getBuilder().createThunk(getOpLocation(Inst->getLoc()),
+                                     getOpValue(Inst->getOperand()),
+                                     Inst->getThunkKind()));
+}
+
 template <typename ImplClass>
 void SILCloner<ImplClass>::visitConvertEscapeToNoEscapeInst(
     ConvertEscapeToNoEscapeInst *Inst) {

include/swift/SIL/SILInstruction.h

@@ -5868,6 +5868,78 @@ class ConvertFunctionInst final
   bool onlyConvertsSendable() const;
 };
 
+class ThunkInst final
+    : public UnaryInstructionWithTypeDependentOperandsBase<
+          SILInstructionKind::ThunkInst, ThunkInst, SingleValueInstruction> {
+public:
+  struct Kind {
+    enum InnerTy {
+      Invalid = 0,
+
+      /// A thunk that just calls the passed in function. Used for testing
+      /// purposes of the underlying thunking machinery.
+      Identity = 1,
+
+      MaxValue = Identity,
+    };
+
+    InnerTy innerTy;
+
+    Kind() : innerTy(InnerTy::Invalid) {}
+    Kind(InnerTy innerTy) : innerTy(innerTy) {}
+    Kind(unsigned inputInnerTy) : innerTy(InnerTy(inputInnerTy)) {
+      assert(inputInnerTy <= MaxValue && "Invalid value");
+    }
+
+    operator InnerTy() const { return innerTy; }
+
+    /// Given the current enum state returned the derived output function from
+    /// \p inputFunction.
+    CanSILFunctionType getDerivedFunctionType(SILFunction *fn,
+                                              CanSILFunctionType inputFunction,
+                                              SubstitutionMap subMap) const;
+
+    SILType getDerivedFunctionType(SILFunction *fn, SILType inputFunctionType,
+                                   SubstitutionMap subMap) const {
+      auto fType = inputFunctionType.castTo<SILFunctionType>();
+      return SILType::getPrimitiveType(
+          getDerivedFunctionType(fn, fType, subMap),
+          inputFunctionType.getCategory());
+    }
+  };
+
+  /// The type of thunk we are supposed to produce.
+  Kind kind;
+
+  /// The substitutions being applied to the callee when we generate thunks for
+  /// it. E.x.: if we generate a partial_apply, this will be the substitution
+  /// map used to generate the partial_apply.
+  SubstitutionMap substitutions;
+
+private:
+  friend SILBuilder;
+
+  ThunkInst(SILDebugLocation debugLoc, SILValue operand,
+            ArrayRef<SILValue> typeDependentOperands, SILType outputType,
+            Kind kind, SubstitutionMap subs)
+      : UnaryInstructionWithTypeDependentOperandsBase(
+            debugLoc, operand, typeDependentOperands, outputType),
+        kind(kind), substitutions(subs) {}
+
+  static ThunkInst *create(SILDebugLocation debugLoc, SILValue operand,
+                           SILModule &mod, SILFunction *func, Kind kind,
+                           SubstitutionMap subs);
+
+public:
+  Kind getThunkKind() const { return kind; }
+
+  SubstitutionMap getSubstitutionMap() const { return substitutions; }
+
+  CanSILFunctionType getOrigCalleeType() const {
+    return getOperand()->getType().castTo<SILFunctionType>();
+  }
+};
+
 /// ConvertEscapeToNoEscapeInst - Change the type of a escaping function value
 /// to a trivial function type (@noescape T -> U).
 class ConvertEscapeToNoEscapeInst final

include/swift/SIL/SILModule.h

@@ -644,6 +644,13 @@ class SILModule {
     return {functions.begin(), functions.end()};
   }
 
+  /// Move \p fn to be in the function list before \p moveBefore.
+  void moveBefore(SILModule::iterator moveBefore, SILFunction *fn);
+
+  /// Move \p fn to be in the function list after \p moveAfter. It is assumed
+  /// that \p moveAfter is not end.
+  void moveAfter(SILModule::iterator moveAfter, SILFunction *fn);
+
   const_iterator zombies_begin() const { return zombieFunctions.begin(); }
   const_iterator zombies_end() const { return zombieFunctions.end(); }
 

include/swift/SIL/SILNodes.def

@@ -405,6 +405,8 @@ ABSTRACT_VALUE_AND_INST(SingleValueInstruction, ValueBase, SILInstruction)
 #include "swift/AST/ReferenceStorage.def"
     SINGLE_VALUE_INST(ConvertFunctionInst, convert_function,
                       SingleValueInstruction, None, DoesNotRelease)
+    SINGLE_VALUE_INST(ThunkInst, thunk,
+                      SingleValueInstruction, MayHaveSideEffects, MayRelease)
     SINGLE_VALUE_INST(ConvertEscapeToNoEscapeInst, convert_escape_to_noescape,
                       SingleValueInstruction, None, DoesNotRelease)
     SINGLE_VALUE_INST(RefToBridgeObjectInst, ref_to_bridge_object,