Merge pull request #82270 from al45tair/fix-embedded-concurrency

[Concurrency][Embedded] Make sure Embedded Swift links Impl functions.

Teach the Embedded Swift compiler to include the Impl functions for the functions that provide Concurrency hooks.

Also enable `MainActor` when building Embedded Swift stdlib for WASI.

Author: MaxDesiatov

include/swift/SIL/SILModule.h

@@ -867,6 +867,11 @@ class SILModule {
   /// Returns true if linking succeeded, false otherwise.
   bool linkFunction(SILFunction *F, LinkingMode LinkMode);
 
+  /// Attempt to deserialize witness table for protocol conformance \p PC.
+  ///
+  /// Returns true if linking succeeded, false otherwise.
+  bool linkWitnessTable(ProtocolConformance *PC, LinkingMode LinkMode);
+
   /// Check if a given function exists in any of the modules.
   /// i.e. it can be linked by linkFunction.
   bool hasFunction(StringRef Name);

lib/SIL/IR/SILModule.cpp

@@ -433,6 +433,10 @@ bool SILModule::linkFunction(SILFunction *F, SILModule::LinkingMode Mode) {
   return SILLinkerVisitor(*this, Mode).processFunction(F);
 }
 
+bool SILModule::linkWitnessTable(ProtocolConformance *PC, SILModule::LinkingMode Mode) {
+  return SILLinkerVisitor(*this, Mode).processConformance(ProtocolConformanceRef(PC));
+}
+
 bool SILModule::hasFunction(StringRef Name) {
   if (lookUpFunction(Name))
     return true;

lib/SILOptimizer/UtilityPasses/Link.cpp

@@ -10,6 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "swift/AST/ProtocolConformance.h"
 #include "swift/SILOptimizer/PassManager/Passes.h"
 #include "swift/SILOptimizer/PassManager/Transforms.h"
 #include "swift/SIL/SILModule.h"
@@ -48,6 +49,7 @@ class SILLinker : public SILModuleTransform {
     // (swift_retain, etc.). Link them in so they can be referenced in IRGen.
     if (M.getOptions().EmbeddedSwift && LinkEmbeddedRuntime) {
       linkEmbeddedRuntimeFromStdlib();
+      linkEmbeddedConcurrency();
     }
 
     // In embedded Swift, we need to explicitly link any @_used globals and
@@ -80,6 +82,32 @@ class SILLinker : public SILModuleTransform {
       linkEmbeddedRuntimeFunctionByName("swift_retainCount", { RefCounting });
   }
 
+  void linkEmbeddedConcurrency() {
+    using namespace RuntimeConstants;
+
+    // Note: we ignore errors here, because, depending on the exact situation
+    //
+    //    (a) We might not have Concurrency anyway, and
+    //
+    //    (b) The Impl function might be implemented in C++.
+    //
+    // Also, the hook Impl functions are marked as internal, unlike the
+    // runtime functions, which are public.
+
+#define SWIFT_CONCURRENCY_HOOK(RETURNS, NAME, ...)                  \
+  linkUsedFunctionByName(#NAME "Impl", SILLinkage::HiddenExternal)
+#define SWIFT_CONCURRENCY_HOOK0(RETURNS, NAME)                      \
+  linkUsedFunctionByName(#NAME "Impl", SILLinkage::HiddenExternal)
+
+    #include "swift/Runtime/ConcurrencyHooks.def"
+
+    linkUsedFunctionByName("swift_task_asyncMainDrainQueueImpl",
+                           SILLinkage::HiddenExternal);
+    linkUsedFunctionByName("swift_createDefaultExecutors",
+                           SILLinkage::HiddenExternal);
+    linkEmbeddedRuntimeWitnessTables();
+  }
+
   void linkEmbeddedRuntimeFunctionByName(StringRef name,
                                          ArrayRef<RuntimeEffect> effects) {
     SILModule &M = *getModule();
@@ -96,6 +124,23 @@ class SILLinker : public SILModuleTransform {
     linkUsedFunctionByName(name, SILLinkage::PublicExternal);
   }
 
+  void linkEmbeddedRuntimeWitnessTables() {
+    SILModule &M = *getModule();
+
+    auto *mainActor = M.getASTContext().getMainActorDecl();
+    if (mainActor) {
+      for (auto *PC : mainActor->getAllConformances()) {
+        auto *ProtoDecl = PC->getProtocol();
+        if (ProtoDecl->getName().str() == "Actor") {
+          M.linkWitnessTable(PC, SILModule::LinkingMode::LinkAll);
+          if (auto *WT = M.lookUpWitnessTable(PC)) {
+            WT->setLinkage(SILLinkage::Public);
+          }
+        }
+      }
+    }
+  }
+
   SILFunction *linkUsedFunctionByName(StringRef name,
                                       std::optional<SILLinkage> Linkage) {
     SILModule &M = *getModule();
@@ -134,7 +179,7 @@ class SILLinker : public SILModuleTransform {
     // linked global variable.
     if (GV->isDefinition())
       GV->setLinkage(SILLinkage::Public);
-    
+
     return GV;
   }
 

stdlib/public/Concurrency/Executor.swift

@@ -36,11 +36,11 @@ public protocol Executor: AnyObject, Sendable {
   func enqueue(_ job: consuming ExecutorJob)
   #endif // !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
 
-  #if !$Embedded
+  #if os(WASI) || !$Embedded
   /// `true` if this is the main executor.
   @available(StdlibDeploymentTarget 6.2, *)
   var isMainExecutor: Bool { get }
-  #endif
+  #endif // os(WASI) || !$Embedded
 }
 
 @available(StdlibDeploymentTarget 6.2, *)
@@ -144,13 +144,12 @@ extension Executor where Self: Equatable {
 }
 
 extension Executor {
-
-  #if !$Embedded
+  #if os(WASI) || !$Embedded
   // This defaults to `false` so that existing third-party Executor
   // implementations will work as expected.
   @available(StdlibDeploymentTarget 6.2, *)
   public var isMainExecutor: Bool { false }
-  #endif
+  #endif // os(WASI) || !$Embedded
 
 }
 
@@ -368,10 +367,10 @@ public protocol SerialExecutor: Executor {
 @available(StdlibDeploymentTarget 6.0, *)
 extension SerialExecutor {
 
-  #if !$Embedded && !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
+  #if os(WASI) || (!$Embedded && !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY)
   @available(StdlibDeploymentTarget 6.2, *)
   public var isMainExecutor: Bool { return MainActor.executor._isSameExecutor(self) }
-  #endif
+  #endif // os(WASI) || (!$Embedded && !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY)
 
   @available(StdlibDeploymentTarget 6.0, *)
   public func checkIsolated() {
@@ -579,11 +578,11 @@ public protocol MainExecutor: RunLoopExecutor, SerialExecutor {
 /// executors.
 @available(StdlibDeploymentTarget 6.2, *)
 public protocol ExecutorFactory {
-  #if !$Embedded
+  #if os(WASI) || !$Embedded
   /// Constructs and returns the main executor, which is started implicitly
   /// by the `async main` entry point and owns the "main" thread.
   static var mainExecutor: any MainExecutor { get }
-  #endif
+  #endif // os(WASI) || !$Embedded
 
   /// Constructs and returns the default or global executor, which is the
   /// default place in which we run tasks.
@@ -596,9 +595,9 @@ typealias DefaultExecutorFactory = PlatformExecutorFactory
 @available(StdlibDeploymentTarget 6.2, *)
 @_silgen_name("swift_createExecutors")
 public func _createExecutors<F: ExecutorFactory>(factory: F.Type) {
-  #if !$Embedded && !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
+  #if os(WASI) || (!$Embedded && !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY)
   MainActor._executor = factory.mainExecutor
-  #endif
+  #endif // os(WASI) || (!$Embedded && !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY)
   Task._defaultExecutor = factory.defaultExecutor
 }