Merge pull request #36874 from DougGregor/dynamic-data-race-actor-isolation

[Concurrency] Introduce runtime detection of data races.

Author: DougGregor

docs/SIL.rst

@@ -3319,6 +3319,24 @@ lowered by the SIL pipeline, so that IR generation only operands of type
 
 The operand is a guaranteed operand, i.e. not consumed.
 
+extract_executor
+```````````````
+
+::
+
+  sil-instruction ::= 'extract_executor' sil-operand
+
+  %1 = extract_executor %0 : $T
+  // $T must be Builtin.Executor or conform to the Actor protocol
+  // %1 will be of type Builtin.Executor
+
+Extracts the executor from the executor or actor operand. SIL generation
+emits this instruction to produce executor values when needed (e.g.,
+to provide to a runtime function). It will be lowered away by the SIL
+pipeline.
+
+The operand is a guaranteed operand, i.e. not consumed.
+
 dealloc_stack
 `````````````
 ::

include/swift/Runtime/Concurrency.h

@@ -577,6 +577,13 @@ AsyncTask *swift_task_getCurrent(void);
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 ExecutorRef swift_task_getCurrentExecutor(void);
 
+SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
+bool swift_task_isCurrentExecutor(ExecutorRef executor);
+
+SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
+void swift_task_reportUnexpectedExecutor(
+    const unsigned char *file, uintptr_t fileLength, bool fileIsASCII,
+    uintptr_t line, ExecutorRef executor);
 }
 
 #pragma clang diagnostic pop

include/swift/SIL/SILBuilder.h

@@ -2168,6 +2168,13 @@ class SILBuilder {
                                                       Actor, hasOwnership()));
   }
 
+  ExtractExecutorInst *createExtractExecutor(SILLocation Loc, SILValue Actor) {
+    auto resultType = SILType::getPrimitiveObjectType(getASTContext().TheExecutorType);
+    return insert(new (getModule()) ExtractExecutorInst(getSILDebugLocation(Loc),
+                                                        Actor, hasOwnership(),
+                                                        resultType));
+  }
+
   //===--------------------------------------------------------------------===//
   // Terminator SILInstruction Creation Methods
   //===--------------------------------------------------------------------===//

include/swift/SIL/SILCloner.h

@@ -3056,6 +3056,15 @@ ::visitHopToExecutorInst(HopToExecutorInst *Inst) {
                             getOpValue(Inst->getTargetExecutor())));
 }
 
+template <typename ImplClass>
+void SILCloner<ImplClass>
+::visitExtractExecutorInst(ExtractExecutorInst *Inst) {
+  getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
+  recordClonedInstruction(Inst,
+                          getBuilder().createExtractExecutor(
+                            getOpLocation(Inst->getLoc()),
+                            getOpValue(Inst->getExpectedExecutor())));
+}
 
 } // end namespace swift
 

include/swift/SIL/SILInstruction.h

@@ -3468,6 +3468,21 @@ class HopToExecutorInst
   SILValue getTargetExecutor() const { return getOperand(); }
 };
 
+/// Extract the ex that the code is executing on the operand executor already.
+class ExtractExecutorInst
+    : public UnaryInstructionBase<SILInstructionKind::ExtractExecutorInst,
+                                  SingleValueInstruction>
+{
+  friend SILBuilder;
+
+  ExtractExecutorInst(SILDebugLocation debugLoc, SILValue executor,
+                      bool hasOwnership, SILType Ty)
+      : UnaryInstructionBase(debugLoc, executor, Ty) { }
+
+public:
+  SILValue getExpectedExecutor() const { return getOperand(); }
+};
+
 /// Instantiates a key path object.
 class KeyPathInst final
     : public InstructionBase<SILInstructionKind::KeyPathInst,

include/swift/SIL/SILNodes.def

@@ -831,6 +831,8 @@ NON_VALUE_INST(FixLifetimeInst, fix_lifetime,
 
 NON_VALUE_INST(HopToExecutorInst, hop_to_executor,
                SILInstruction, MayHaveSideEffects, DoesNotRelease)
+SINGLE_VALUE_INST(ExtractExecutorInst, extract_executor,
+                  SILInstruction, MayRead, DoesNotRelease)
 
 NON_VALUE_INST(DestroyValueInst, destroy_value,
                SILInstruction, MayHaveSideEffects, MayRelease)

lib/IRGen/IRGenSIL.cpp

@@ -1329,6 +1329,9 @@ class IRGenSILFunction :
   void visitAwaitAsyncContinuationInst(AwaitAsyncContinuationInst *i);
 
   void visitHopToExecutorInst(HopToExecutorInst *i);
+  void visitExtractExecutorInst(ExtractExecutorInst *i) {
+    llvm_unreachable("extract_executor should never be seen in Lowered SIL");
+  }
 
   void visitKeyPathInst(KeyPathInst *I);
 

lib/SIL/IR/OperandOwnership.cpp

@@ -254,6 +254,7 @@ OPERAND_OWNERSHIP(InteriorPointer, RefTailAddr)
 OPERAND_OWNERSHIP(InteriorPointer, OpenExistentialBox)
 // FIXME: HopToExecutorInst should be an instantaneous use.
 OPERAND_OWNERSHIP(InteriorPointer, HopToExecutor)
+OPERAND_OWNERSHIP(InteriorPointer, ExtractExecutor)
 
 // Instructions that propagate a value value within a borrow scope.
 OPERAND_OWNERSHIP(ForwardingBorrow, TupleExtract)

lib/SIL/IR/SILPrinter.cpp

@@ -2145,6 +2145,10 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
     *this << getIDAndType(HTEI->getTargetExecutor());
   }
 
+  void visitExtractExecutorInst(ExtractExecutorInst *AEI) {
+    *this << getIDAndType(AEI->getExpectedExecutor());
+  }
+
   void visitSwitchValueInst(SwitchValueInst *SII) {
     *this << getIDAndType(SII->getOperand());
     for (unsigned i = 0, e = SII->getNumCases(); i < e; ++i) {

lib/SIL/IR/ValueOwnership.cpp

@@ -151,6 +151,8 @@ CONSTANT_OWNERSHIP_INST(Unowned, ValueToBridgeObject)
 CONSTANT_OWNERSHIP_INST(None, GetAsyncContinuation)
 CONSTANT_OWNERSHIP_INST(None, GetAsyncContinuationAddr)
 CONSTANT_OWNERSHIP_INST(None, ThinToThickFunction)
+CONSTANT_OWNERSHIP_INST(None, ExtractExecutor)
+
 #undef CONSTANT_OWNERSHIP_INST
 
 #define CONSTANT_OR_NONE_OWNERSHIP_INST(OWNERSHIP, INST)                       \