Merge pull request #41272 from rjmccall/revert-hop-to-generic-executor-5.6

[5.6] Revert the partial SE-0338 implementation

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()) {
-      emitPrologGlobalActorHop(loc, isolation->getGlobalActor());
+      emitHopToTargetActor(loc, *isolation, None);
     }
   }
 

lib/SILGen/SILGenConstructor.cpp

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

lib/SILGen/SILGenFunction.cpp

@@ -922,7 +922,36 @@ void SILGenFunction::emitAsyncMainThreadStart(SILDeclRef entryPoint) {
       JobType, {}, {task});
   jobResult = wrapCallArgs(jobResult, swiftJobRunFuncDecl, 0);
 
-  SILValue mainExecutor = emitMainExecutor(moduleLoc);
+  // 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, {}, {});
   mainExecutor = wrapCallArgs(mainExecutor, swiftJobRunFuncDecl, 1);
 
   // Run first part synchronously

lib/SILGen/SILGenFunction.h

@@ -874,22 +874,11 @@ 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,10 +2944,11 @@ 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.
-  // Treat this thunk as if it were isolated to that global actor.
+  ExecutorBreadcrumb prevExecutor;
   if (outputSubstType->isAsync() && !inputSubstType->isAsync()) {
     if (Type globalActor = inputSubstType->getGlobalActor()) {
-      SGF.emitPrologGlobalActorHop(loc, globalActor);
+      prevExecutor = SGF.emitHopToTargetActor(
+          loc, ActorIsolation::forGlobalActor(globalActor, false), None);
     }
   }
 
@@ -2994,6 +2995,9 @@ 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

@@ -660,13 +660,6 @@ 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) {
@@ -686,54 +679,6 @@ 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();
@@ -873,8 +818,19 @@ void ExecutorBreadcrumb::emit(SILGenFunction &SGF, SILLocation loc) {
 }
 
 SILValue SILGenFunction::emitGetCurrentExecutor(SILLocation loc) {
-  assert(ExpectedExecutor && "prolog failed to set up expected executor?");
-  return ExpectedExecutor;
+  // 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(), { });
 }
 
 static void emitIndirectResultParameters(SILGenFunction &SGF,

test/Concurrency/Runtime/class_resilience.swift

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

test/Concurrency/Runtime/protocol_resilience.swift

@@ -15,6 +15,10 @@
 // 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,12 +7,11 @@ 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 [[GENERIC_EXEC]] : $Optional<Builtin.Executor>
+// CHECK-NEXT:  hop_to_executor [[OLD]] : $Optional<Builtin.Executor>
 // CHECK: } // end sil function '$s4test6check1ySi11OtherActors0C11ModuleActorCYaF'
 func check1(_ actor: OtherModuleActor) async -> Int {
   return await actor.a
@@ -22,25 +21,20 @@ 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 [[GENERIC_EXEC]] : $Optional<Builtin.Executor>
+// CHECK:       hop_to_executor [[OLD]] : $Optional<Builtin.Executor>
 // CHECK: } // end sil function '$s4test6check4y11OtherActors17SomeSendableClassCSgAC0C11ModuleActorCSgYaF'
 func check4(_ actor: OtherModuleActor?) async -> SomeSendableClass? {
   return await actor?.d

test/Concurrency/throwing.swift

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