Make ExecutorRef two words.

Author: rjmccall

include/swift/ABI/Executor.h

@@ -18,6 +18,7 @@
 #define SWIFT_ABI_EXECUTOR_H
 
 #include <inttypes.h>
+#include "swift/ABI/Actor.h"
 #include "swift/ABI/HeapObject.h"
 #include "swift/Runtime/Casting.h"
 
@@ -31,79 +32,89 @@ class Job;
 SWIFT_EXPORT_FROM(swift_Concurrency)
 Metadata* MainActorMetadata;
 
-/// An ExecutorRef isn't necessarily just a pointer to an executor
-/// object; it may have other bits set.
+/// 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.
 class ExecutorRef {
-  static constexpr uintptr_t IsDefaultActor = 1;
-  static constexpr uintptr_t PointerMask = 7;
-
-  uintptr_t Value;
+  HeapObject *Identity; // Not necessarily Swift reference-countable
+  uintptr_t Implementation;
 
-  constexpr ExecutorRef(uintptr_t value) : Value(value) {}
+  constexpr ExecutorRef(HeapObject *identity, uintptr_t implementation)
+    : Identity(identity), Implementation(implementation) {}
 
 public:
   /// A generic execution environment.  When running in a generic
   /// environment, it's presumed to be okay to switch synchronously
   /// to an actor.  As an executor request, this represents a request
   /// to drop whatever the current actor is.
   constexpr static ExecutorRef generic() {
-    return ExecutorRef(0);
+    return ExecutorRef(nullptr, 0);
   }
 
   /// FIXME: only exists for the quick-and-dirty MainActor implementation.
   /// NOTE: I didn't go with Executor::forMainActor(DefaultActor*) because
   /// __swift_run_job_main_executor can't take more than one argument.
-  constexpr static ExecutorRef mainExecutor() {
-    return ExecutorRef(2);
+  static ExecutorRef mainExecutor() {
+    auto identity = getMainActorIdentity();
+    return ExecutorRef(identity, 0);
+  }
+  static HeapObject *getMainActorIdentity() {
+    return reinterpret_cast<HeapObject*>(
+                                   ExecutorRefFlags::MainActorIdentity);
   }
 
   /// Given a pointer to a default actor, return an executor reference
   /// for it.
   static ExecutorRef forDefaultActor(DefaultActor *actor) {
     assert(actor);
-    return ExecutorRef(reinterpret_cast<uintptr_t>(actor) | IsDefaultActor);
+    return ExecutorRef(actor, unsigned(ExecutorRefFlags::DefaultActor));
+  }
+
+  HeapObject *getIdentity() const {
+    return Identity;
   }
 
   /// Is this the generic executor reference?
   bool isGeneric() const {
-    return Value == 0;
+    return Identity == 0;
   }
 
   /// FIXME: only exists for the quick-and-dirty MainActor implementation.
   bool isMainExecutor() const {
-    if (Value == ExecutorRef::mainExecutor().Value)
+    if (Identity == getMainActorIdentity())
       return true;
 
-    HeapObject *heapObj = reinterpret_cast<HeapObject*>(Value & ~PointerMask);
-
-    if (heapObj == nullptr || MainActorMetadata == nullptr)
+    if (Identity == nullptr || MainActorMetadata == nullptr)
       return false;
 
-    Metadata const* metadata = swift_getObjectType(heapObj);
+    Metadata const* metadata = swift_getObjectType(Identity);
     return metadata == MainActorMetadata;
   }
 
   /// Is this a default-actor executor reference?
   bool isDefaultActor() const {
-    return Value & IsDefaultActor;
+    return Implementation & unsigned(ExecutorRefFlags::DefaultActor);
   }
   DefaultActor *getDefaultActor() const {
     assert(isDefaultActor());
-    return reinterpret_cast<DefaultActor*>(Value & ~PointerMask);
-  }
-
-  uintptr_t getRawValue() const {
-    return Value;
+    return reinterpret_cast<DefaultActor*>(Identity);
   }
 
   /// Do we have to do any work to start running as the requested
   /// executor?
   bool mustSwitchToRun(ExecutorRef newExecutor) const {
-    return *this != newExecutor;
+    return Identity != newExecutor.Identity;
   }
 
   bool operator==(ExecutorRef other) const {
-    return Value == other.Value
+    return Identity == other.Identity
     /// FIXME: only exists for the quick-and-dirty MainActor implementation.
           || (isMainExecutor() && other.isMainExecutor());
   }

include/swift/ABI/MetadataValues.h

@@ -2166,6 +2166,20 @@ 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,
+
+  /// TODO: remove this
+  MainActorIdentity = 0x2,
+};
+
 } // end namespace swift
 
 #endif // SWIFT_ABI_METADATAVALUES_H

include/swift/Runtime/RuntimeFunctions.def

@@ -1595,7 +1595,7 @@ FUNCTION(TaskSwitchFunc,
          swift_task_switch, SwiftAsyncCC,
          ConcurrencyAvailability,
          RETURNS(VoidTy),
-         ARGS(SwiftContextPtrTy, Int8PtrTy, SwiftExecutorPtrTy),
+         ARGS(SwiftContextPtrTy, Int8PtrTy, ExecutorFirstTy, ExecutorSecondTy),
          ATTRS(NoUnwind))
 
 // AsyncTask *swift_continuation_init(AsyncContext *continuationContext,
@@ -1636,7 +1636,7 @@ FUNCTION(ContinuationThrowingResumeWithError,
 FUNCTION(TaskGetCurrentExecutor,
          swift_task_getCurrentExecutor, SwiftCC,
          ConcurrencyAvailability,
-         RETURNS(IntPtrTy),
+         RETURNS(SwiftExecutorTy),
          ARGS(),
          ATTRS(NoUnwind, ArgMemOnly))
 

lib/IRGen/CMakeLists.txt

@@ -16,6 +16,7 @@ add_swift_host_library(swiftIRGen STATIC
   GenConstant.cpp
   GenControl.cpp
   GenCoverage.cpp
+  GenConcurrency.cpp
   GenDecl.cpp
   GenDiffFunc.cpp
   GenDiffWitness.cpp

lib/IRGen/GenBuiltin.cpp

@@ -28,6 +28,7 @@
 #include "Explosion.h"
 #include "GenCall.h"
 #include "GenCast.h"
+#include "GenConcurrency.h"
 #include "GenPointerAuth.h"
 #include "GenIntegerLiteral.h"
 #include "IRGenFunction.h"
@@ -221,11 +222,7 @@ void irgen::emitBuiltinCall(IRGenFunction &IGF, const BuiltinInfo &Builtin,
 
   // getCurrentActor has no arguments.
   if (Builtin.ID == BuiltinValueKind::GetCurrentExecutor) {
-    auto *call = IGF.Builder.CreateCall(IGF.IGM.getTaskGetCurrentExecutorFn(),
-                                        {});
-    call->setDoesNotThrow();
-    call->setCallingConv(IGF.IGM.SwiftCC);
-    out.add(call);
+    emitGetCurrentExecutor(IGF, out);
     return;
   }
 
@@ -307,10 +304,8 @@ void irgen::emitBuiltinCall(IRGenFunction &IGF, const BuiltinInfo &Builtin,
   }
 
   if (Builtin.ID == BuiltinValueKind::BuildSerialExecutorRef) {
-    auto executor = args.claimNext();
-    executor = IGF.Builder.CreateBitCast(executor,
-                                         IGF.IGM.SwiftExecutorPtrTy);
-    out.add(executor);
+    auto actor = args.claimNext();
+    emitBuildSerialExecutorRef(IGF, actor, argTypes[0], out);
     return;
   }
 

lib/IRGen/GenCall.cpp

@@ -1971,12 +1971,19 @@ void irgen::extractScalarResults(IRGenFunction &IGF, llvm::Type *bodyType,
     returned = IGF.coerceValue(returned, bodyType, IGF.IGM.DataLayout);
 
   if (auto *structType = dyn_cast<llvm::StructType>(bodyType))
-    for (unsigned i = 0, e = structType->getNumElements(); i != e; ++i)
-      out.add(IGF.Builder.CreateExtractValue(returned, i));
+    IGF.emitAllExtractValues(returned, structType, out);
   else
     out.add(returned);
 }
 
+void IRGenFunction::emitAllExtractValues(llvm::Value *value,
+                                         llvm::StructType *structType,
+                                         Explosion &out) {
+  assert(value->getType() == structType);
+  for (unsigned i = 0, e = structType->getNumElements(); i != e; ++i)
+    out.add(Builder.CreateExtractValue(value, i));
+}
+
 std::pair<llvm::Value *, llvm::Value *> irgen::getAsyncFunctionAndSize(
     IRGenFunction &IGF, SILFunctionTypeRepresentation representation,
     FunctionPointer functionPointer, llvm::Value *thickContext,

lib/IRGen/GenConcurrency.cpp

@@ -0,0 +1,172 @@
+//===--- GenConcurrency.cpp - IRGen for concurrency features --------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+//  This file implements IR generation for concurrency features (other than
+//  basic async function lowering, which is more spread out).
+//
+//===----------------------------------------------------------------------===//
+
+#include "GenConcurrency.h"
+
+#include "BitPatternBuilder.h"
+#include "ExtraInhabitants.h"
+#include "GenType.h"
+#include "IRGenFunction.h"
+#include "IRGenModule.h"
+#include "LoadableTypeInfo.h"
+#include "ScalarPairTypeInfo.h"
+#include "swift/ABI/MetadataValues.h"
+
+using namespace swift;
+using namespace irgen;
+
+namespace {
+
+/// A TypeInfo implementation for Builtin.Executor.
+class ExecutorTypeInfo :
+  public TrivialScalarPairTypeInfo<ExecutorTypeInfo, LoadableTypeInfo> {
+
+public:
+  ExecutorTypeInfo(llvm::StructType *storageType,
+                   Size size, Alignment align, SpareBitVector &&spareBits)
+      : TrivialScalarPairTypeInfo(storageType, size, std::move(spareBits),
+                                  align, IsPOD, IsFixedSize) {}
+
+  static Size getFirstElementSize(IRGenModule &IGM) {
+    return IGM.getPointerSize();
+  }
+  static StringRef getFirstElementLabel() {
+    return ".identity";
+  }
+
+  TypeLayoutEntry *buildTypeLayoutEntry(IRGenModule &IGM,
+                                        SILType T) const override {
+    return IGM.typeLayoutCache.getOrCreateScalarEntry(*this, T);
+  }
+
+  static Size getSecondElementOffset(IRGenModule &IGM) {
+    return IGM.getPointerSize();
+  }
+  static Size getSecondElementSize(IRGenModule &IGM) {
+    return IGM.getPointerSize();
+  }
+  static StringRef getSecondElementLabel() {
+    return ".impl";
+  }
+
+  // The identity pointer is a heap object reference, but it's
+  // nullable because of the generic executor.
+  bool mayHaveExtraInhabitants(IRGenModule &IGM) const override {
+    return true;
+  }
+
+  PointerInfo getPointerInfo(IRGenModule &IGM) const {
+    return PointerInfo::forHeapObject(IGM).withNullable(IsNullable);
+  }
+  unsigned getFixedExtraInhabitantCount(IRGenModule &IGM) const override {
+    return getPointerInfo(IGM).getExtraInhabitantCount(IGM);
+  }
+  APInt getFixedExtraInhabitantValue(IRGenModule &IGM,
+                                     unsigned bits,
+                                     unsigned index) const override {
+    return getPointerInfo(IGM)
+          .getFixedExtraInhabitantValue(IGM, bits, index, 0);
+  }
+  llvm::Value *getExtraInhabitantIndex(IRGenFunction &IGF, Address src,
+                                       SILType T,
+                                       bool isOutlined) const override {
+    src = projectFirstElement(IGF, src);
+    return getPointerInfo(IGF.IGM).getExtraInhabitantIndex(IGF, src);
+  }
+  APInt getFixedExtraInhabitantMask(IRGenModule &IGM) const override {
+    auto pointerSize = IGM.getPointerSize();
+    auto mask = BitPatternBuilder(IGM.Triple.isLittleEndian());
+    mask.appendSetBits(pointerSize.getValueInBits());
+    mask.appendClearBits(pointerSize.getValueInBits());
+    return mask.build().getValue();
+  }
+  void storeExtraInhabitant(IRGenFunction &IGF, llvm::Value *index,
+                            Address dest, SILType T,
+                            bool isOutlined) const override {
+    dest = projectFirstElement(IGF, dest);
+    getPointerInfo(IGF.IGM).storeExtraInhabitant(IGF, index, dest);
+  }
+};
+
+} // end anonymous namespace
+
+const LoadableTypeInfo &IRGenModule::getExecutorTypeInfo() {
+  return Types.getExecutorTypeInfo();
+}
+
+const LoadableTypeInfo &TypeConverter::getExecutorTypeInfo() {
+  if (ExecutorTI) return *ExecutorTI;
+
+  auto ty = IGM.SwiftExecutorTy;
+
+  SpareBitVector spareBits;
+  spareBits.append(IGM.getHeapObjectSpareBits());
+  spareBits.appendClearBits(IGM.getPointerSize().getValueInBits());
+
+  ExecutorTI =
+    new ExecutorTypeInfo(ty, IGM.getPointerSize() * 2,
+                         IGM.getPointerAlignment(),
+                         std::move(spareBits));
+  ExecutorTI->NextConverted = FirstType;
+  FirstType = ExecutorTI;
+  return *ExecutorTI;
+}
+
+void irgen::emitBuildSerialExecutorRef(IRGenFunction &IGF,
+                                       llvm::Value *actor,
+                                       SILType actorType,
+                                       Explosion &out) {
+  auto cls = actorType.getClassOrBoundGenericClass();
+
+  // HACK: if the actor type is Swift.MainActor, treat it specially.
+  if (cls && cls->getNameStr() == "MainActor" &&
+      cls->getDeclContext()->isModuleScopeContext() &&
+      cls->getModuleContext()->getName().str() == SWIFT_CONCURRENCY_NAME) {
+    llvm::Value *identity = llvm::ConstantInt::get(IGF.IGM.SizeTy,
+                              unsigned(ExecutorRefFlags::MainActorIdentity));
+    identity = IGF.Builder.CreateIntToPtr(identity, IGF.IGM.ExecutorFirstTy);
+    out.add(identity);
+
+    llvm::Value *impl = IGF.IGM.getSize(Size(0));
+    out.add(impl);
+    return;
+  }
+
+  llvm::Value *identity =
+    IGF.Builder.CreateBitCast(actor, IGF.IGM.ExecutorFirstTy);
+  llvm::Value *impl = IGF.IGM.getSize(Size(0));
+
+  unsigned flags = 0;
+
+  // FIXME: this isn't how we should be doing any of this
+  flags |= unsigned(ExecutorRefFlags::DefaultActor);
+
+  if (flags) {
+    impl = IGF.Builder.CreateOr(impl, IGF.IGM.getSize(Size(flags)));
+  }
+  out.add(identity);
+  out.add(impl);
+}
+
+void irgen::emitGetCurrentExecutor(IRGenFunction &IGF, Explosion &out) {
+  auto *call = IGF.Builder.CreateCall(IGF.IGM.getTaskGetCurrentExecutorFn(),
+                                      {});
+  call->setDoesNotThrow();
+  call->setCallingConv(IGF.IGM.SwiftCC);
+
+  IGF.emitAllExtractValues(call, IGF.IGM.SwiftExecutorTy, out);
+}