Default actors carry a null witness-table pointer in Builtin.Executor.

Previously, they were storing a low-bit flag that indicated that they
were a default actor.  Using an extra inhabitant frees up the low bit
for future use without being conspicuously more expensive to check.

Author: rjmccall

include/swift/ABI/Executor.h

@@ -29,24 +29,36 @@ class DefaultActor;
 class Job;
 class SerialExecutorWitnessTable;
 
-/// FIXME: only exists for the quick-and-dirty MainActor implementation.
-SWIFT_EXPORT_FROM(swift_Concurrency)
-Metadata* MainActorMetadata;
-
 /// An unmanaged reference to an executor.
 ///
-/// The representation is two words: identity and implementation.
-/// The identity word is a reference to the executor object; for
-/// default actors, this is the actor object.  The implementation
-/// word describes how the executor works; it carries a witness table
-/// as well as a small number of bits indicating various special
-/// implementation properties.  As an exception to both of these
-/// rules, a null identity represents a generic executor and
-/// implies a null implementation word.
+/// This type corresponds to the type Optional<Builtin.Executor> in
+/// Swift.  The representation of nil in Optional<Builtin.Executor>
+/// aligns with what this type calls the generic executor, so the
+/// notional subtype of this type which is never generic corresponds
+/// to the type Builtin.Executor.
+///
+/// An executor reference is divided into two pieces:
+///
+/// - The identity, which is just a (potentially ObjC) object
+///   reference; when this is null, the reference is generic.
+///   Equality of executor references is based solely on equality
+///   of identity.
+///
+/// - The implementation, which is an optional reference to a
+///   witness table for the SerialExecutor protocol.  When this
+///   is null, but the identity is non-null, the reference is to
+///   a default actor.  The low bits of the implementation pointer
+///   are reserved for the use of marking interesting properties
+///   about the executor's implementation.  The runtime masks these
+///   bits off before accessing the witness table, so setting them
+///   in the future should back-deploy as long as the witness table
+///   reference is still present.
 class ExecutorRef {
   HeapObject *Identity; // Not necessarily Swift reference-countable
   uintptr_t Implementation;
 
+  // We future-proof the ABI here by masking the low bits off the
+  // implementation pointer before using it as a witness table.
   enum: uintptr_t {
     WitnessTableMask = ~uintptr_t(alignof(void*) - 1)
   };
@@ -67,7 +79,7 @@ class ExecutorRef {
   /// for it.
   static ExecutorRef forDefaultActor(DefaultActor *actor) {
     assert(actor);
-    return ExecutorRef(actor, unsigned(ExecutorRefFlags::DefaultActor));
+    return ExecutorRef(actor, 0);
   }
 
   HeapObject *getIdentity() const {
@@ -81,7 +93,7 @@ class ExecutorRef {
 
   /// Is this a default-actor executor reference?
   bool isDefaultActor() const {
-    return Implementation & unsigned(ExecutorRefFlags::DefaultActor);
+    return !isGeneric() && Implementation == 0;
   }
   DefaultActor *getDefaultActor() const {
     assert(isDefaultActor());

include/swift/ABI/MetadataValues.h

@@ -2187,17 +2187,6 @@ enum class ContinuationStatus : size_t {
   Resumed = 2
 };
 
-/// Flags describing the executor implementation that are stored
-/// in the ExecutorRef.
-enum class ExecutorRefFlags : size_t {
-  // The number of bits available here is very limited because it's
-  // potentially just the alignment bits of a protocol witness table
-  // pointer
-
-  /// The executor is a default actor.
-  DefaultActor = 0x1
-};
-
 } // end namespace swift
 
 #endif // SWIFT_ABI_METADATAVALUES_H

lib/IRGen/GenConcurrency.cpp

@@ -133,12 +133,10 @@ void irgen::emitBuildMainActorExecutorRef(IRGenFunction &IGF,
 void irgen::emitBuildDefaultActorExecutorRef(IRGenFunction &IGF,
                                              llvm::Value *actor,
                                              Explosion &out) {
-  unsigned flags = unsigned(ExecutorRefFlags::DefaultActor);
-
+  // The implementation word of a default actor is just a null pointer.
   llvm::Value *identity =
     IGF.Builder.CreatePtrToInt(actor, IGF.IGM.ExecutorFirstTy);
-  llvm::Value *impl =
-    llvm::ConstantInt::get(IGF.IGM.ExecutorSecondTy, flags);
+  llvm::Value *impl = llvm::ConstantInt::get(IGF.IGM.ExecutorSecondTy, 0);
 
   out.add(identity);
   out.add(impl);
@@ -149,6 +147,8 @@ void irgen::emitBuildOrdinarySerialExecutorRef(IRGenFunction &IGF,
                                                CanType executorType,
                                        ProtocolConformanceRef executorConf,
                                                Explosion &out) {
+  // The implementation word of an "ordinary" serial executor is
+  // just the witness table pointer with no flags set.
   llvm::Value *identity =
     IGF.Builder.CreatePtrToInt(executor, IGF.IGM.ExecutorFirstTy);
   llvm::Value *impl =

test/IRGen/async/builtin_executor.sil

@@ -8,6 +8,19 @@ import Builtin
 import Swift
 import _Concurrency
 
+final actor MyDefaultActor {
+  @_semantics("defaultActor")
+  nonisolated var unownedExecutor: UnownedSerialExecutor { get }
+}
+sil_vtable MyDefaultActor {}
+
+actor MyCustomActor : SerialExecutor {
+  final nonisolated var unownedExecutor: UnownedSerialExecutor { get }
+  final nonisolated func enqueue(_ job: UnownedJob)
+  final nonisolated func asUnownedSerialExecutor() -> UnownedSerialExecutor
+}
+sil_vtable MyCustomActor {}
+
 // CHECK: define{{.*}} swiftcc { [[INT]], [[INT]] } @test_none()
 sil @test_none : $() -> Optional<Builtin.Executor> {
 bb0:
@@ -19,9 +32,33 @@ bb0:
 // CHECK: define{{.*}} swiftcc { [[INT]], [[INT]] } @test_some([[INT]] %0, [[INT]] %1)
 sil @test_some : $(Builtin.Executor) -> Optional<Builtin.Executor> {
 bb0(%0 : $Builtin.Executor):
-  // CHECK:      [[T0:%.*]] = insertvalue { [[INT]], [[INT]] } undef, [[INT]] %0, 0
-  // CHECK-NEXT: [[T1:%.*]] = insertvalue { [[INT]], [[INT]] } [[T0]], [[INT]] %1, 1
-  // CHECK-NEXT: ret { [[INT]], [[INT]] } [[T1]]
+  // CHECK:      [[ONE:%.*]] = insertvalue { [[INT]], [[INT]] } undef, [[INT]] %0, 0
+  // CHECK-NEXT: [[TWO:%.*]] = insertvalue { [[INT]], [[INT]] } [[ONE]], [[INT]] %1, 1
+  // CHECK-NEXT: ret { [[INT]], [[INT]] } [[TWO]]
   %1 = enum $Optional<Builtin.Executor>, #Optional.some, %0 : $Builtin.Executor
   return %1 : $Optional<Builtin.Executor>
 }
+
+// CHECK: define{{.*}} swiftcc { [[INT]], [[INT]] } @test_build_default_actor(%T4test14MyDefaultActorC* %0)
+sil @test_build_default_actor : $(@guaranteed MyDefaultActor) -> Builtin.Executor {
+bb0(%0 : $MyDefaultActor):
+  // CHECK:      [[T0:%.*]] = ptrtoint %T4test14MyDefaultActorC* %0 to [[INT]]
+  // CHECK-NEXT: [[ONE:%.*]] = insertvalue { [[INT]], [[INT]] } undef, [[INT]] [[T0]], 0
+  // CHECK-NEXT: [[TWO:%.*]] = insertvalue { [[INT]], [[INT]] } [[ONE]], [[INT]] 0, 1
+  // CHECK-NEXT: ret { [[INT]], [[INT]] } [[TWO]]
+  %1 = builtin "buildDefaultActorExecutorRef"<MyDefaultActor>(%0 : $MyDefaultActor) : $Builtin.Executor
+  return %1 : $Builtin.Executor
+}
+
+// CHECK: define{{.*}} swiftcc { [[INT]], [[INT]] } @test_build_custom_actor(%T4test13MyCustomActorC* %0)
+sil @test_build_custom_actor : $(@guaranteed MyCustomActor) -> Builtin.Executor {
+bb0(%0 : $MyCustomActor):
+  // CHECK:      [[T0:%.*]] = ptrtoint %T4test13MyCustomActorC* %0 to [[INT]]
+  // CHECK-NEXT: [[T1:%.*]] = call i8** @"$s4test13MyCustomActorCACs14SerialExecutorAAWl"()
+  // CHECK-NEXT: [[T2:%.*]] = ptrtoint i8** [[T1]] to [[INT]]
+  // CHECK:      [[ONE:%.*]] = insertvalue { [[INT]], [[INT]] } undef, [[INT]] [[T0]], 0
+  // CHECK-NEXT: [[TWO:%.*]] = insertvalue { [[INT]], [[INT]] } [[ONE]], [[INT]] [[T2]], 1
+  // CHECK-NEXT: ret { [[INT]], [[INT]] } [[TWO]]
+  %1 = builtin "buildOrdinarySerialExecutorRef"<MyCustomActor>(%0 : $MyCustomActor) : $Builtin.Executor
+  return %1 : $Builtin.Executor
+}