Hop to the generic executor in non-actor-isolated async functions.

Async functions are now expected to set ExpectedExecutor in their
prologue (and, generally, immediately hop to it).  I updated the
prologue code for a bunch of function emission, most of which was
uninteresting.  Top-level code was not returning to the main
executor, which is now fixed; fortunately, we weren't assuming
that we were on the main executor yet.

We had some code that only kicked in when an ExpectedExecutor
wasn't set which made us capture the current executor before
a hop and then return to it later.  This code has been removed;
there's no situation in which save-and-return is the semantically
correct thing to do given the possibility of hop optimization.
I suspect it could also have led to crashes if the current
executor is being kept alive only because it's currently running
code.  If we ever add async functions that are supposed to inherit
their caller's executor, we should have the caller pass the right
executor down to it.

This is the first half of SE-0338; the second, sendability
enforcement, is much more complicated, and Doug has volunteered
to do it.

Fixes rdar://79284465, as well as some tests that were XFAILed
on Windows.

Author: rjmccall

lib/SILGen/SILGenBridging.cpp

@@ -1588,7 +1588,7 @@ void SILGenFunction::emitNativeToForeignThunk(SILDeclRef thunk) {
     // A hop is only needed in the thunk if it is global-actor isolated.
     // Native, instance-isolated async methods will hop in the prologue.
     if (isolation && isolation->isGlobalActor()) {
-      emitHopToTargetActor(loc, *isolation, None);
+      emitPrologGlobalActorHop(loc, isolation->getGlobalActor());
     }
   }
 

lib/SILGen/SILGenConstructor.cpp

@@ -672,13 +672,17 @@ static void emitDefaultActorInitialization(
 void SILGenFunction::emitConstructorPrologActorHop(
                                            SILLocation loc,
                                            Optional<ActorIsolation> maybeIso) {
-  if (!maybeIso)
-    return;
-
-  if (auto executor = emitExecutor(loc, *maybeIso, None)) {
-    ExpectedExecutor = *executor;
-    B.createHopToExecutor(loc.asAutoGenerated(), *executor, /*mandatory*/ false);
+  loc = loc.asAutoGenerated();
+  if (maybeIso) {
+    if (auto executor = emitExecutor(loc, *maybeIso, None)) {
+      ExpectedExecutor = *executor;
+    }
   }
+
+  if (!ExpectedExecutor)
+    ExpectedExecutor = emitGenericExecutor(loc);
+
+  B.createHopToExecutor(loc, ExpectedExecutor, /*mandatory*/ false);
 }
 
 // MARK: class constructor

lib/SILGen/SILGenFunction.cpp

@@ -922,36 +922,7 @@ void SILGenFunction::emitAsyncMainThreadStart(SILDeclRef entryPoint) {
       JobType, {}, {task});
   jobResult = wrapCallArgs(jobResult, swiftJobRunFuncDecl, 0);
 
-  // Get main executor
-  FuncDecl *getMainExecutorFuncDecl = SGM.getGetMainExecutor();
-  if (!getMainExecutorFuncDecl) {
-    // If it doesn't exist due to an SDK-compiler mismatch, we can conjure one
-    // up instead of crashing:
-    // @available(SwiftStdlib 5.1, *)
-    // @_silgen_name("swift_task_getMainExecutor")
-    // internal func _getMainExecutor() -> Builtin.Executor
-
-    ParameterList *emptyParams = ParameterList::createEmpty(getASTContext());
-    getMainExecutorFuncDecl = FuncDecl::createImplicit(
-        getASTContext(), StaticSpellingKind::None,
-        DeclName(
-            getASTContext(),
-            DeclBaseName(getASTContext().getIdentifier("_getMainExecutor")),
-            /*Arguments*/ emptyParams),
-        {}, /*async*/ false, /*throws*/ false, {}, emptyParams,
-        getASTContext().TheExecutorType,
-        entryPoint.getDecl()->getModuleContext());
-    getMainExecutorFuncDecl->getAttrs().add(
-        new (getASTContext())
-            SILGenNameAttr("swift_task_getMainExecutor", /*implicit*/ true));
-  }
-
-  SILFunction *getMainExeutorSILFunc = SGM.getFunction(
-      SILDeclRef(getMainExecutorFuncDecl, SILDeclRef::Kind::Func),
-      NotForDefinition);
-  SILValue getMainExeutorFunc =
-      B.createFunctionRefFor(moduleLoc, getMainExeutorSILFunc);
-  SILValue mainExecutor = B.createApply(moduleLoc, getMainExeutorFunc, {}, {});
+  SILValue mainExecutor = emitMainExecutor(moduleLoc);
   mainExecutor = wrapCallArgs(mainExecutor, swiftJobRunFuncDecl, 1);
 
   // Run first part synchronously

lib/SILGen/SILGenFunction.h

@@ -874,11 +874,22 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
   void emitConstructorPrologActorHop(SILLocation loc,
                                      Optional<ActorIsolation> actorIso);
 
+  /// Set the given global actor as the isolation for this function
+  /// (generally a thunk) and hop to it.
+  void emitPrologGlobalActorHop(SILLocation loc, Type globalActor);
+
   /// Emit the executor for the given actor isolation.
   Optional<SILValue> emitExecutor(SILLocation loc,
                                   ActorIsolation isolation,
                                   Optional<ManagedValue> maybeSelf);
 
+  /// Emit the executor value that corresponds to the generic (concurrent)
+  /// executor.
+  SILValue emitGenericExecutor(SILLocation loc);
+
+  /// Emit the executor value that corresponds to the main actor.
+  SILValue emitMainExecutor(SILLocation loc);
+
   /// Emit a precondition check to ensure that the function is executing in
   /// the expected isolation context.
   void emitPreconditionCheckExpectedExecutor(

lib/SILGen/SILGenPoly.cpp

@@ -2944,11 +2944,10 @@ static void buildThunkBody(SILGenFunction &SGF, SILLocation loc,
 
   // If the input is synchronous and global-actor-qualified, and the
   // output is asynchronous, hop to the executor expected by the input.
-  ExecutorBreadcrumb prevExecutor;
+  // Treat this thunk as if it were isolated to that global actor.
   if (outputSubstType->isAsync() && !inputSubstType->isAsync()) {
     if (Type globalActor = inputSubstType->getGlobalActor()) {
-      prevExecutor = SGF.emitHopToTargetActor(
-          loc, ActorIsolation::forGlobalActor(globalActor, false), None);
+      SGF.emitPrologGlobalActorHop(loc, globalActor);
     }
   }
 
@@ -2995,9 +2994,6 @@ static void buildThunkBody(SILGenFunction &SGF, SILLocation loc,
   // Reabstract the result.
   SILValue outerResult = resultPlanner.execute(innerResult);
 
-  // If we hopped to the target's executor, then we need to hop back.
-  prevExecutor.emit(SGF, loc);
-
   scope.pop();
   SGF.B.createReturn(loc, outerResult);
 }

lib/SILGen/SILGenProlog.cpp

@@ -552,7 +552,7 @@ void SILGenFunction::emitProlog(CaptureInfo captureInfo,
     return false;
   };
 
-  // Initialize ExpectedExecutor if the function is an actor-isolated
+  // Initialize ExpectedExecutor if the function is an async
   // function or closure.
   bool wantDataRaceChecks = getOptions().EnableActorDataRaceChecks &&
       !F.isAsync() &&
@@ -642,6 +642,13 @@ void SILGenFunction::emitProlog(CaptureInfo captureInfo,
       }
     }
   }
+
+  // In async functions, the generic executor is our expected executor
+  // if we don't have any sort of isolation.
+  if (!ExpectedExecutor && F.isAsync()) {
+    ExpectedExecutor = emitGenericExecutor(
+      RegularLocation::getAutoGeneratedLocation(F.getLocation()));
+  }
 
   // Jump to the expected executor.
   if (ExpectedExecutor) {
@@ -661,6 +668,54 @@ void SILGenFunction::emitProlog(CaptureInfo captureInfo,
   }
 }
 
+SILValue SILGenFunction::emitMainExecutor(SILLocation loc) {
+  // Get main executor
+  FuncDecl *getMainExecutorFuncDecl = SGM.getGetMainExecutor();
+  if (!getMainExecutorFuncDecl) {
+    // If it doesn't exist due to an SDK-compiler mismatch, we can conjure one
+    // up instead of crashing:
+    // @available(SwiftStdlib 5.1, *)
+    // @_silgen_name("swift_task_getMainExecutor")
+    // internal func _getMainExecutor() -> Builtin.Executor
+    auto &ctx = getASTContext();
+
+    ParameterList *emptyParams = ParameterList::createEmpty(ctx);
+    getMainExecutorFuncDecl = FuncDecl::createImplicit(
+        ctx, StaticSpellingKind::None,
+        DeclName(
+            ctx,
+            DeclBaseName(ctx.getIdentifier("_getMainExecutor")),
+            /*Arguments*/ emptyParams),
+        {}, /*async*/ false, /*throws*/ false, {}, emptyParams,
+        ctx.TheExecutorType,
+        getModule().getSwiftModule());
+    getMainExecutorFuncDecl->getAttrs().add(
+        new (ctx)
+            SILGenNameAttr("swift_task_getMainExecutor", /*implicit*/ true));
+  }
+
+  auto fn = SGM.getFunction(
+      SILDeclRef(getMainExecutorFuncDecl, SILDeclRef::Kind::Func),
+      NotForDefinition);
+  SILValue fnRef = B.createFunctionRefFor(loc, fn);
+  return B.createApply(loc, fnRef, {}, {});
+}
+
+SILValue SILGenFunction::emitGenericExecutor(SILLocation loc) {
+  // The generic executor is encoded as the nil value of
+  // Optional<Builtin.SerialExecutor>.
+  auto ty = SILType::getOptionalType(
+              SILType::getPrimitiveObjectType(
+                getASTContext().TheExecutorType));
+  return B.createOptionalNone(loc, ty);
+}
+
+void SILGenFunction::emitPrologGlobalActorHop(SILLocation loc,
+                                              Type globalActor) {
+  ExpectedExecutor = emitLoadGlobalActorExecutor(globalActor);
+  B.createHopToExecutor(loc, ExpectedExecutor, /*mandatory*/ false);
+}
+
 SILValue SILGenFunction::emitLoadGlobalActorExecutor(Type globalActor) {
   CanType actorType = CanType(globalActor);
   NominalTypeDecl *nominal = actorType->getNominalOrBoundGenericNominal();
@@ -800,19 +855,8 @@ void ExecutorBreadcrumb::emit(SILGenFunction &SGF, SILLocation loc) {
 }
 
 SILValue SILGenFunction::emitGetCurrentExecutor(SILLocation loc) {
-  // If this is an actor method, then the actor is the only executor we should
-  // be running on (if we aren't setting up for a cross-actor call).
-  if (ExpectedExecutor)
-    return ExpectedExecutor;
-  
-  // Otherwise, we'll have to ask the current task what executor it's running
-  // on.
-  auto &ctx = getASTContext();
-  return B.createBuiltin(
-      loc,
-      ctx.getIdentifier(getBuiltinName(BuiltinValueKind::GetCurrentExecutor)),
-      getLoweredType(OptionalType::get(ctx.TheExecutorType)),
-      SubstitutionMap(), { });
+  assert(ExpectedExecutor && "prolog failed to set up expected executor?");
+  return ExpectedExecutor;
 }
 
 static void emitIndirectResultParameters(SILGenFunction &SGF,

test/Concurrency/Runtime/class_resilience.swift

@@ -15,9 +15,6 @@
 // REQUIRES: concurrency_runtime
 // UNSUPPORTED: back_deployment_runtime
 
-// XFAIL: windows
-// XFAIL: openbsd
-
 import StdlibUnittest
 import resilient_class
 

test/Concurrency/Runtime/protocol_resilience.swift

@@ -15,10 +15,6 @@
 // REQUIRES: concurrency_runtime
 // UNSUPPORTED: back_deployment_runtime
 
-// XFAIL: windows
-// UNSUPPORTED: linux
-// UNSUPPORTED: openbsd
-
 import StdlibUnittest
 import resilient_protocol
 

test/Concurrency/cross_module_let_sil.swift

@@ -7,11 +7,12 @@ import OtherActors
 
 // CHECK-LABEL: sil hidden [ossa] @$s4test6check1ySi11OtherActors0C11ModuleActorCYaF : $@convention(thin) @async (@guaranteed OtherModuleActor) -> Int {
 // CHECK:     bb0([[SELF:%[0-9]+]] : @guaranteed $OtherModuleActor):
+// CHECK:       [[GENERIC_EXEC:%.*]] = enum $Optional<Builtin.Executor>, #Optional.none
+// CHECK-NEXT:  hop_to_executor [[GENERIC_EXEC]] : $Optional<Builtin.Executor>
 // CHECK:       [[REF:%[0-9]+]] = ref_element_addr [[SELF]] : $OtherModuleActor, #OtherModuleActor.a
-// CHECK:       [[OLD:%[0-9]+]] = builtin "getCurrentExecutor"() : $Optional<Builtin.Executor>
 // CHECK:       hop_to_executor [[SELF]] : $OtherModuleActor
 // CHECK-NEXT:  load [trivial] [[REF]]
-// CHECK-NEXT:  hop_to_executor [[OLD]] : $Optional<Builtin.Executor>
+// CHECK-NEXT:  hop_to_executor [[GENERIC_EXEC]] : $Optional<Builtin.Executor>
 // CHECK: } // end sil function '$s4test6check1ySi11OtherActors0C11ModuleActorCYaF'
 func check1(_ actor: OtherModuleActor) async -> Int {
   return await actor.a
@@ -21,20 +22,25 @@ func check2(_ actor: isolated OtherModuleActor) -> Int {
   return actor.a
 }
 
+// CHECK-LABEL: sil hidden [ossa] @$s4test6check3ySi11OtherActors0C11ModuleActorCYaF : $@convention(thin) @async (@guaranteed OtherModuleActor) -> Int {
+// CHECK:     bb0([[SELF:%[0-9]+]] : @guaranteed $OtherModuleActor):
+// CHECK:       [[GENERIC_EXEC:%.*]] = enum $Optional<Builtin.Executor>, #Optional.none
+// CHECK-NEXT:  hop_to_executor [[GENERIC_EXEC]] : $Optional<Builtin.Executor>
 func check3(_ actor: OtherModuleActor) async -> Int {
   return actor.b
 }
 
 // CHECK-LABEL: sil hidden [ossa] @$s4test6check4y11OtherActors17SomeSendableClassCSgAC0C11ModuleActorCSgYaF : $@convention(thin) @async (@guaranteed Optional<OtherModuleActor>) -> @owned Optional<SomeSendableClass> {
 // CHECK:  bb0({{%[0-9]+}} : @guaranteed $Optional<OtherModuleActor>):
+// CHECK:       [[GENERIC_EXEC:%.*]] = enum $Optional<Builtin.Executor>, #Optional.none
+// CHECK-NEXT:  hop_to_executor [[GENERIC_EXEC]] : $Optional<Builtin.Executor>
 // CHECK:       switch_enum {{%[0-9]+}} : $Optional<OtherModuleActor>, case #Optional.some!enumelt: [[SOME:bb[0-9]+]], case #Optional.none!enumelt: {{bb[0-9]+}}
 
 // CHECK:  [[SOME]]({{%[0-9]+}} : @owned $OtherModuleActor):
 // CHECK:       [[REF:%[0-9]+]] = ref_element_addr {{%[0-9]+}} : $OtherModuleActor, #OtherModuleActor.d
-// CHECK:       [[OLD:%[0-9]+]] = builtin "getCurrentExecutor"() : $Optional<Builtin.Executor>
 // CHECK:       hop_to_executor {{%[0-9]+}} : $OtherModuleActor
 // CHECK-NEXT:  load [copy] [[REF]]
-// CHECK:       hop_to_executor [[OLD]] : $Optional<Builtin.Executor>
+// CHECK:       hop_to_executor [[GENERIC_EXEC]] : $Optional<Builtin.Executor>
 // CHECK: } // end sil function '$s4test6check4y11OtherActors17SomeSendableClassCSgAC0C11ModuleActorCSgYaF'
 func check4(_ actor: OtherModuleActor?) async -> SomeSendableClass? {
   return await actor?.d

test/Concurrency/throwing.swift

@@ -6,9 +6,6 @@
 // REQUIRES: concurrency_runtime
 // UNSUPPORTED: back_deployment_runtime
 
-// SR-15252
-// XFAIL: OS=windows-msvc
-
 import _Concurrency
 import StdlibUnittest