SILLinker: de-serialize Executor witness tables for the xExecutorRef builtins

Fixes unresolved symbol linker errors in embedded mode.
rdar://148538336

Author: eeckstein

lib/SIL/IR/Linker.cpp

@@ -429,6 +429,24 @@ void SILLinkerVisitor::visitInitExistentialRefInst(
   }
 }
 
+void SILLinkerVisitor::visitBuiltinInst(BuiltinInst *bi) {
+  switch (bi->getBuiltinInfo().ID) {
+    case BuiltinValueKind::BuildOrdinaryTaskExecutorRef:
+    case BuiltinValueKind::BuildOrdinarySerialExecutorRef:
+    case BuiltinValueKind::BuildComplexEqualitySerialExecutorRef:
+      if (Mod.getOptions().EmbeddedSwift) {
+        // Those builtins act like init_existential_ref instructions and therefore
+        // it's important to have the Executor witness tables available in embedded
+        // mode.
+        auto executorConf = bi->getSubstitutions().getConformances()[0];
+        visitProtocolConformance(executorConf, true);
+      }
+      break;
+    default:
+      break;
+  }
+}
+
 void SILLinkerVisitor::visitAllocRefDynamicInst(AllocRefDynamicInst *ARI) {
   if (!isLinkAll())
     return;

lib/SIL/IR/Linker.h

@@ -129,6 +129,7 @@ class SILLinkerVisitor : public SILInstructionVisitor<SILLinkerVisitor, void> {
   }
   void visitInitExistentialAddrInst(InitExistentialAddrInst *IEI);
   void visitInitExistentialRefInst(InitExistentialRefInst *IERI);
+  void visitBuiltinInst(BuiltinInst *bi);
   void visitAllocRefInst(AllocRefInst *ARI);
   void visitAllocRefDynamicInst(AllocRefDynamicInst *ARI);
   void visitMetatypeInst(MetatypeInst *MI);

test/embedded/concurrency-modules.swift

@@ -0,0 +1,62 @@
+// RUN: %empty-directory(%t)
+// RUN: %{python} %utils/split_file.py -o %t %s
+
+// RUN: %target-swift-frontend -emit-module -o %t/MyModule.swiftmodule %t/MyModule.swift -enable-experimental-feature Embedded -parse-as-library
+// RUN: %target-swift-frontend -c -I %t %t/Main.swift -enable-experimental-feature Embedded -o %t/a.o -parse-as-library
+// RUN: %target-clang %t/a.o -o %t/a.out -L%swift_obj_root/lib/swift/embedded/%target-cpu-apple-macos -lswift_Concurrency -lswift_ConcurrencyDefaultExecutor -dead_strip
+// RUN: %target-run %t/a.out | %FileCheck %s
+
+// REQUIRES: swift_in_compiler
+// REQUIRES: executable_test
+// REQUIRES: OS=macosx || OS=linux-gnu
+// REQUIRES: swift_feature_Embedded
+
+// BEGIN MyModule.swift
+
+import _Concurrency
+
+nonisolated(unsafe) var glob: UnsafeMutableRawPointer? = nil
+nonisolated(unsafe) var job: UnownedJob? = nil
+
+public final class MyCustomExecutor: SerialExecutor, @unchecked Sendable {
+    private init() {}
+
+    nonisolated(unsafe)
+    public static var shared: MyCustomExecutor = MyCustomExecutor()
+
+    public static func installGlobalExecutor() {
+        let fn: @convention(thin) () -> () = {
+            MyCustomExecutor.shared.unsafeEnqueue(job!)
+        }
+        glob = unsafeBitCast(fn, to: UnsafeMutableRawPointer?.self)
+    }
+
+    private func enqueue(_ job: UnownedJob, withDelay nanoseconds: UInt64) {}
+
+    private func unsafeEnqueue(_ job: UnownedJob) {
+        job.runSynchronously(on: self.asUnownedSerialExecutor())
+    }
+
+    public func enqueue(_ job: consuming ExecutorJob) {
+        unsafeEnqueue(UnownedJob(job))
+    }
+
+    public func asUnownedSerialExecutor() -> UnownedSerialExecutor {
+        return UnownedSerialExecutor(ordinary: self)
+    }
+}
+
+// BEGIN Main.swift
+
+import MyModule
+import _Concurrency
+
+@main
+struct Entrypoint {
+    static func main() async {
+        MyCustomExecutor.installGlobalExecutor()
+        print("OK!")
+    }
+}
+
+// CHECK: OK!