[Concurrency] SIL: add hop_to_executor instruction

This instructions ensures that all instructions, which need to run on the specified executor actually run on that executor.
For details see the description in SIL.rst.

Author: eeckstein

docs/SIL.rst

@@ -2885,6 +2885,27 @@ initialized with the resume value, and that value is then owned by the current
 function. If ``await_async_continuation`` instead resumes to its ``error``
 successor, then the memory remains uninitialized.
 
+hop_to_executor
+```````````````
+
+::
+
+  sil-instruction ::= 'hop_to_executor' sil-operand
+
+  hop_to_executor %0 : $T
+
+  // $T must conform to the Actor protocol
+
+Ensures that all instructions, which need to run on the actor's executor
+actually run on that executor.
+This instruction can only be used inside an ``@async`` function.
+
+Checks if the current executor is the one which is bound to the operand actor.
+If not, begins a suspension point and enqueues the continuation to the executor
+which is bound to the operand actor.
+
+The operand is a guaranteed operand, i.e. not consumed.
+
 dealloc_stack
 `````````````
 ::

include/swift/SIL/SILBuilder.h

@@ -1935,6 +1935,10 @@ class SILBuilder {
         getSILDebugLocation(Loc), Operand, Index));
   }
 
+  //===--------------------------------------------------------------------===//
+  // Concurrency instructions
+  //===--------------------------------------------------------------------===//
+
   GetAsyncContinuationInst *createGetAsyncContinuation(SILLocation Loc,
                                                        SILType ContinuationTy) {
     return insert(new (getModule()) GetAsyncContinuationInst(getSILDebugLocation(Loc),
@@ -1949,6 +1953,11 @@ class SILBuilder {
                                                                  ContinuationTy));
   }
 
+  HopToExecutorInst *createHopToExecutor(SILLocation Loc, SILValue Actor) {
+    return insert(new (getModule()) HopToExecutorInst(getSILDebugLocation(Loc),
+                                                      Actor, hasOwnership()));
+  }
+
   //===--------------------------------------------------------------------===//
   // Terminator SILInstruction Creation Methods
   //===--------------------------------------------------------------------===//

include/swift/SIL/SILCloner.h

@@ -2964,6 +2964,17 @@ ::visitAwaitAsyncContinuationInst(AwaitAsyncContinuationInst *Inst) {
                               : nullptr));
 }
 
+template <typename ImplClass>
+void SILCloner<ImplClass>
+::visitHopToExecutorInst(HopToExecutorInst *Inst) {
+  getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
+  recordClonedInstruction(Inst,
+                          getBuilder().createHopToExecutor(
+                            getOpLocation(Inst->getLoc()),
+                            getOpValue(Inst->getActor())));
+}
+
+
 } // end namespace swift
 
 #endif

include/swift/SIL/SILInstruction.h

@@ -3102,6 +3102,21 @@ class GetAsyncContinuationAddrInst final
   {}
 };
 
+/// Begins a suspension point and enqueues the continuation to the executor
+/// which is bound to the operand actor.
+class HopToExecutorInst
+    : public UnaryInstructionBase<SILInstructionKind::HopToExecutorInst,
+                                  NonValueInstruction>
+{
+  friend SILBuilder;
+
+  HopToExecutorInst(SILDebugLocation DebugLoc, SILValue Actor, bool HasOwnership)
+      : UnaryInstructionBase(DebugLoc, Actor) { }
+
+public:
+  SILValue getActor() const { return getOperand(); }
+};
+
 /// Instantiates a key path object.
 class KeyPathInst final
     : public InstructionBase<SILInstructionKind::KeyPathInst,

include/swift/SIL/SILNodes.def

@@ -834,6 +834,9 @@ NON_VALUE_INST(BindMemoryInst, bind_memory,
 NON_VALUE_INST(FixLifetimeInst, fix_lifetime,
                SILInstruction, MayHaveSideEffects, DoesNotRelease)
 
+NON_VALUE_INST(HopToExecutorInst, hop_to_executor,
+               SILInstruction, MayHaveSideEffects, DoesNotRelease)
+
 NON_VALUE_INST(DestroyValueInst, destroy_value,
                SILInstruction, MayHaveSideEffects, MayRelease)
 NON_VALUE_INST(EndBorrowInst, end_borrow,

lib/IRGen/IRGenSIL.cpp

@@ -1136,6 +1136,10 @@ class IRGenSILFunction :
     llvm_unreachable("not implemented");
   }
 
+  void visitHopToExecutorInst(HopToExecutorInst *i) {
+    //TODO(async)
+  }
+
   void visitKeyPathInst(KeyPathInst *I);
 
   void visitDifferentiableFunctionInst(DifferentiableFunctionInst *i);

lib/SIL/IR/OperandOwnership.cpp

@@ -193,6 +193,7 @@ CONSTANT_OWNERSHIP_INST(None, MustBeLive, EndAccess)
 CONSTANT_OWNERSHIP_INST(None, MustBeLive, EndApply)
 CONSTANT_OWNERSHIP_INST(None, MustBeLive, EndUnpairedAccess)
 CONSTANT_OWNERSHIP_INST(None, MustBeLive, GetAsyncContinuationAddr)
+CONSTANT_OWNERSHIP_INST(None, MustBeLive, HopToExecutor)
 CONSTANT_OWNERSHIP_INST(None, MustBeLive, IndexAddr)
 CONSTANT_OWNERSHIP_INST(None, MustBeLive, IndexRawPointer)
 CONSTANT_OWNERSHIP_INST(None, MustBeLive, InitBlockStorageHeader)

lib/SIL/IR/SILPrinter.cpp

@@ -2096,6 +2096,10 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
     }
   }
 
+  void visitHopToExecutorInst(HopToExecutorInst *HTEI) {
+    *this << getIDAndType(HTEI->getActor());
+  }
+
   void visitSwitchValueInst(SwitchValueInst *SII) {
     *this << getIDAndType(SII->getOperand());
     for (unsigned i = 0, e = SII->getNumCases(); i < e; ++i) {

lib/SIL/Parser/ParseSIL.cpp

@@ -2951,6 +2951,7 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
     UNARY_INSTRUCTION(EndBorrow)
     UNARY_INSTRUCTION(DestructureStruct)
     UNARY_INSTRUCTION(DestructureTuple)
+    UNARY_INSTRUCTION(HopToExecutor)
     REFCOUNTING_INSTRUCTION(UnmanagedReleaseValue)
     REFCOUNTING_INSTRUCTION(UnmanagedRetainValue)
     REFCOUNTING_INSTRUCTION(UnmanagedAutoreleaseValue)

lib/SILOptimizer/UtilityPasses/SerializeSILPass.cpp

@@ -339,6 +339,7 @@ static bool hasOpaqueArchetype(TypeExpansionContext context,
   case SILInstructionKind::GetAsyncContinuationInst:
   case SILInstructionKind::GetAsyncContinuationAddrInst:
   case SILInstructionKind::AwaitAsyncContinuationInst:
+  case SILInstructionKind::HopToExecutorInst:
     // Handle by operand and result check.
     break;