Merge pull request #37965 from rjmccall/dispatch-main-q

Use &_dispatch_main_q as the identity of the main actor.

Author: rjmccall

include/swift/ABI/Executor.h

@@ -82,6 +82,15 @@ class ExecutorRef {
     return ExecutorRef(actor, 0);
   }
 
+  /// Given a pointer to a serial executor and its SerialExecutor
+  /// conformance, return an executor reference for it.
+  static ExecutorRef forOrdinary(HeapObject *identity,
+                           const SerialExecutorWitnessTable *witnessTable) {
+    assert(identity);
+    assert(witnessTable);
+    return ExecutorRef(identity, reinterpret_cast<uintptr_t>(witnessTable));
+  }
+
   HeapObject *getIdentity() const {
     return Identity;
   }
@@ -112,6 +121,9 @@ class ExecutorRef {
     return Identity != newExecutor.Identity;
   }
 
+  /// Is this executor the main executor?
+  bool isMainExecutor() const;
+
   bool operator==(ExecutorRef other) const {
     return Identity == other.Identity;
   }

include/swift/Basic/Compiler.h

@@ -137,4 +137,29 @@
 #define SWIFT_POINTER_IS_4_BYTES 1
 #endif
 
+// Produce a string literal for the raw argument tokens.
+#define SWIFT_STRINGIZE_RAW(TOK) #TOK
+
+// Produce a string literal for the macro-expanded argument tokens.
+#define SWIFT_STRINGIZE_EXPANDED(TOK) SWIFT_STRINGIZE_RAW(TOK)
+
+#if defined(__USER_LABEL_PREFIX__)
+#define SWIFT_SYMBOL_PREFIX_STRING \
+  SWIFT_STRINGIZE_EXPANDED(__USER_LABEL_PREFIX__)
+#else
+// Clang and GCC always define __USER_LABEL_PREFIX__, so this should
+// only come up with MSVC, and Windows doesn't use a prefix.
+#define SWIFT_SYMBOL_PREFIX_STRING ""
+#endif
+
+// An attribute to override the symbol name of a declaration.
+// This does not compensate for platform symbol prefixes; for that,
+// use SWIFT_ASM_LABEL_WITH_PREFIX.
+//
+// This only actually works on Clang or GCC; MSVC does not provide
+// an attribute to change the asm label.
+#define SWIFT_ASM_LABEL_RAW(STRING) __asm__(STRING)
+#define SWIFT_ASM_LABEL_WITH_PREFIX(STRING) \
+  SWIFT_ASM_LABEL_RAW(SWIFT_SYMBOL_PREFIX_STRING STRING)
+
 #endif // SWIFT_BASIC_COMPILER_H

include/swift/Basic/Features.def

@@ -51,5 +51,6 @@ LANGUAGE_FEATURE(BuiltinTaskGroup, 0, "TaskGroup builtins", true)
 LANGUAGE_FEATURE(InheritActorContext, 0, "@_inheritActorContext attribute", true)
 LANGUAGE_FEATURE(ImplicitSelfCapture, 0, "@_implicitSelfCapture attribute", true)
 LANGUAGE_FEATURE(BuiltinBuildExecutor, 0, "Executor-building builtins", true)
+LANGUAGE_FEATURE(BuiltinBuildMainExecutor, 0, "MainActor executor building builtin", true)
 
 #undef LANGUAGE_FEATURE

include/swift/Runtime/Concurrency.h

@@ -563,6 +563,10 @@ void swift_task_enqueueGlobalWithDelay(unsigned long long delay, Job *job);
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 void swift_task_enqueueMainExecutor(Job *job);
 
+/// Enqueue the given job on the main executor.
+SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
+void swift_task_enqueueOnDispatchQueue(Job *job, HeapObject *queue);
+
 /// A hook to take over global enqueuing.
 typedef SWIFT_CC(swift) void (*swift_task_enqueueGlobal_original)(Job *job);
 SWIFT_EXPORT_FROM(swift_Concurrency)
@@ -680,6 +684,10 @@ AsyncTask *swift_task_getCurrent(void);
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 ExecutorRef swift_task_getCurrentExecutor(void);
 
+/// Return the main-actor executor reference.
+SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
+ExecutorRef swift_task_getMainExecutor(void);
+
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 bool swift_task_isCurrentExecutor(ExecutorRef executor);
 

include/swift/Runtime/RuntimeFunctions.def

@@ -1666,6 +1666,14 @@ FUNCTION(TaskGetCurrentExecutor,
          ARGS(),
          ATTRS(NoUnwind, ArgMemOnly))
 
+// ExecutorRef swift_task_getMainExecutor();
+FUNCTION(TaskGetMainExecutor,
+         swift_task_getMainExecutor, SwiftCC,
+         ConcurrencyAvailability,
+         RETURNS(SwiftExecutorTy),
+         ARGS(),
+         ATTRS(NoUnwind, ArgMemOnly))
+
 // void swift_defaultActor_initialize(DefaultActor *actor);
 FUNCTION(DefaultActorInitialize,
          swift_defaultActor_initialize, SwiftCC,

lib/AST/ASTPrinter.cpp

@@ -2768,6 +2768,10 @@ static bool usesFeatureBuiltinBuildExecutor(Decl *decl) {
   return false;
 }
 
+static bool usesFeatureBuiltinBuildMainExecutor(Decl *decl) {
+  return false;
+}
+
 static bool usesFeatureBuiltinContinuation(Decl *decl) {
   return false;
 }

lib/IRGen/GenConcurrency.cpp

@@ -127,7 +127,12 @@ const LoadableTypeInfo &TypeConverter::getExecutorTypeInfo() {
 
 void irgen::emitBuildMainActorExecutorRef(IRGenFunction &IGF,
                                           Explosion &out) {
-  // FIXME
+  auto call = IGF.Builder.CreateCall(IGF.IGM.getTaskGetMainExecutorFn(),
+                                     {});
+  call->setDoesNotThrow();
+  call->setCallingConv(IGF.IGM.SwiftCC);
+
+  IGF.emitAllExtractValues(call, IGF.IGM.SwiftExecutorTy, out);
 }
 
 void irgen::emitBuildDefaultActorExecutorRef(IRGenFunction &IGF,

stdlib/public/Concurrency/Actor.cpp

@@ -321,8 +321,7 @@ static bool swift_task_isCurrentExecutorImpl(ExecutorRef executor) {
     return currentTracking->getActiveExecutor() == executor;
   }
 
-  return executor == _swift_task_getMainExecutor()
-      && isExecutingOnMainThread();
+  return executor.isMainExecutor() && isExecutingOnMainThread();
 }
 
 /// Logging level for unexpected executors:
@@ -365,7 +364,7 @@ void swift::swift_task_reportUnexpectedExecutor(
 
   const char *functionIsolation;
   const char *whereExpected;
-  if (executor == _swift_task_getMainExecutor()) {
+  if (executor.isMainExecutor()) {
     functionIsolation = "@MainActor function";
     whereExpected = "the main thread";
   } else {

stdlib/public/Concurrency/Actor.swift

@@ -51,12 +51,3 @@ public func _defaultActorDestroy(_ actor: AnyObject)
 @_silgen_name("swift_task_enqueueMainExecutor")
 @usableFromInline
 internal func _enqueueOnMain(_ job: UnownedJob)
-
-// Used by the concurrency runtime
-@available(SwiftStdlib 5.5, *)
-extension SerialExecutor {
-  @_silgen_name("_swift_task_getMainExecutor")
-  internal func _getMainExecutor() -> UnownedSerialExecutor {
-    return MainActor.shared.unownedExecutor
-  }
-}

stdlib/public/Concurrency/Executor.swift

@@ -92,3 +92,27 @@ func _checkExpectedExecutor(_filenameStart: Builtin.RawPointer,
   _reportUnexpectedExecutor(
     _filenameStart, _filenameLength, _filenameIsASCII, _line, _executor)
 }
+
+@available(SwiftStdlib 5.5, *)
+@_silgen_name("swift_task_enqueueOnDispatchQueue")
+internal func _enqueueOnDispatchQueue(_ job: UnownedJob, queue: AnyObject)
+
+/// Used by the runtime solely for the witness table it produces.
+/// FIXME: figure out some way to achieve that which doesn't generate
+/// all the other metadata
+///
+/// Expected to work for any primitive dispatch queue; note that this
+/// means a dispatch_queue_t, which is not the same as DispatchQueue
+/// on platforms where that is an instance of a wrapper class.
+@available(SwiftStdlib 5.5, *)
+internal class DispatchQueueShim: UnsafeSendable, SerialExecutor {
+  @inlinable
+  func enqueue(_ job: UnownedJob) {
+    _enqueueOnDispatchQueue(job, queue: self)
+  }
+
+  @inlinable
+  func asUnownedSerialExecutor() -> UnownedSerialExecutor {
+    return UnownedSerialExecutor(ordinary: self)
+  }
+}