Add a Builtin.Executor type to abstract executor references.

rjmccall · rjmccall · commit 0f152af85f22 · 2021-03-28T04:31:49.000-04:00
diff --git a/docs/ABI/Mangling.rst b/docs/ABI/Mangling.rst
@@ -517,6 +517,7 @@ Types
   type ::= 'BB'                              // Builtin.UnsafeValueBuffer
   type ::= 'Bc'                              // Builtin.RawUnsafeContinuation
   type ::= 'BD'                              // Builtin.DefaultActorStorage
+  type ::= 'Be'                              // Builtin.ExecutorRef
   type ::= 'Bf' NATURAL '_'                  // Builtin.Float<n>
   type ::= 'Bi' NATURAL '_'                  // Builtin.Int<n>
   type ::= 'BI'                              // Builtin.IntLiteral
diff --git a/include/swift/AST/ASTSynthesis.h b/include/swift/AST/ASTSynthesis.h
@@ -41,6 +41,7 @@ enum SingletonTypeSynthesizer {
   _any,
   _bridgeObject,
   _error,
+  _executor,
   _job,
   _nativeObject,
   _never,
@@ -54,6 +55,7 @@ inline Type synthesizeType(SynthesisContext &SC,
   case _any: return SC.Context.TheAnyType;
   case _bridgeObject: return SC.Context.TheBridgeObjectType;
   case _error: return SC.Context.getExceptionType();
+  case _executor: return SC.Context.TheExecutorType;
   case _job: return SC.Context.TheJobType;
   case _nativeObject: return SC.Context.TheNativeObjectType;
   case _never: return SC.Context.getNeverType();
diff --git a/include/swift/AST/Builtins.def b/include/swift/AST/Builtins.def
@@ -736,7 +736,7 @@ BUILTIN_MISC_OPERATION(DestroyDefaultActor, "destroyDefaultActor", "", Special)
   BUILTIN_MISC_OPERATION(Id, Name, Attrs, Overload)
 #endif
 
-// getCurrentExecutor: () async -> Builtin.Word
+// getCurrentExecutor: () async -> Builtin.Executor
 //
 // Retrieve the ExecutorRef on which the current asynchronous
 // function is executing.
diff --git a/include/swift/AST/TypeNodes.def b/include/swift/AST/TypeNodes.def
@@ -103,6 +103,7 @@ ABSTRACT_TYPE(Builtin, Type)
     BUILTIN_TYPE(BuiltinInteger, AnyBuiltinIntegerType)
     BUILTIN_TYPE(BuiltinIntegerLiteral, AnyBuiltinIntegerType)
     TYPE_RANGE(AnyBuiltinInteger, BuiltinInteger, BuiltinIntegerLiteral)
+  BUILTIN_TYPE(BuiltinExecutor, BuiltinType)
   BUILTIN_TYPE(BuiltinFloat, BuiltinType)
   BUILTIN_TYPE(BuiltinJob, BuiltinType)
   BUILTIN_TYPE(BuiltinRawPointer, BuiltinType)
@@ -181,6 +182,7 @@ LAST_TYPE(Dictionary) // Sugared types are last to make isa<SugarType>() fast.
 #ifdef SINGLETON_TYPE
 SINGLETON_TYPE(IntegerLiteral, BuiltinIntegerLiteral)
 SINGLETON_TYPE(Job, BuiltinJob)
+SINGLETON_TYPE(Executor, BuiltinExecutor)
 SINGLETON_TYPE(RawPointer, BuiltinRawPointer)
 SINGLETON_TYPE(RawUnsafeContinuation, BuiltinRawUnsafeContinuation)
 SINGLETON_TYPE(NativeObject, BuiltinNativeObject)
diff --git a/include/swift/AST/Types.h b/include/swift/AST/Types.h
@@ -1416,6 +1416,19 @@ class BuiltinRawUnsafeContinuationType : public BuiltinType {
 };
 DEFINE_EMPTY_CAN_TYPE_WRAPPER(BuiltinRawUnsafeContinuationType, BuiltinType);
 
+/// BuiltinExecutorType - The builtin executor-ref type.  In C, this
+/// is the ExecutorRef struct type.
+class BuiltinExecutorType : public BuiltinType {
+  friend class ASTContext;
+  BuiltinExecutorType(const ASTContext &C)
+    : BuiltinType(TypeKind::BuiltinExecutor, C) {}
+public:
+  static bool classof(const TypeBase *T) {
+    return T->getKind() == TypeKind::BuiltinExecutor;
+  }
+};
+DEFINE_EMPTY_CAN_TYPE_WRAPPER(BuiltinExecutorType, BuiltinType);
+
 /// BuiltinJobType - The builtin job type.  In C, this is a
 /// non-null Job*.  This pointer is completely unmanaged (the unscheduled
 /// job is self-owning), but has more spare bits than Builtin.RawPointer.
diff --git a/include/swift/Strings.h b/include/swift/Strings.h
@@ -122,6 +122,9 @@ constexpr static BuiltinNameStringLiteral BUILTIN_TYPE_NAME_UNSAFEVALUEBUFFER =
 /// The name of the Builtin type for Job
 constexpr static BuiltinNameStringLiteral BUILTIN_TYPE_NAME_JOB = {
     "Builtin.Job"};
+/// The name of the Builtin type for ExecutorRef
+constexpr static BuiltinNameStringLiteral BUILTIN_TYPE_NAME_EXECUTOR = {
+    "Builtin.ExecutorRef"};
 /// The name of the Builtin type for DefaultActorStorage
 constexpr static BuiltinNameStringLiteral BUILTIN_TYPE_NAME_DEFAULTACTORSTORAGE = {
     "Builtin.DefaultActorStorage"};
diff --git a/lib/AST/ASTDumper.cpp b/lib/AST/ASTDumper.cpp
@@ -3577,6 +3577,7 @@ namespace {
 
     TRIVIAL_TYPE_PRINTER(BuiltinIntegerLiteral, builtin_integer_literal)
     TRIVIAL_TYPE_PRINTER(BuiltinJob, builtin_job)
+    TRIVIAL_TYPE_PRINTER(BuiltinExecutor, builtin_executor_ref)
     TRIVIAL_TYPE_PRINTER(BuiltinDefaultActorStorage, builtin_default_actor_storage)
     TRIVIAL_TYPE_PRINTER(BuiltinRawPointer, builtin_raw_pointer)
     TRIVIAL_TYPE_PRINTER(BuiltinRawUnsafeContinuation, builtin_raw_unsafe_continuation)
diff --git a/lib/AST/ASTMangler.cpp b/lib/AST/ASTMangler.cpp
@@ -1047,6 +1047,8 @@ void ASTMangler::appendType(Type type, const ValueDecl *forDecl) {
       return appendOperator("BI");
     case TypeKind::BuiltinJob:
       return appendOperator("Bj");
+    case TypeKind::BuiltinExecutor:
+      return appendOperator("Be");
     case TypeKind::BuiltinDefaultActorStorage:
       return appendOperator("BD");
     case TypeKind::BuiltinRawPointer:
diff --git a/lib/AST/ASTPrinter.cpp b/lib/AST/ASTPrinter.cpp
@@ -4407,6 +4407,7 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
   ASTPRINTER_PRINT_BUILTINTYPE(BuiltinRawPointerType)
   ASTPRINTER_PRINT_BUILTINTYPE(BuiltinRawUnsafeContinuationType)
   ASTPRINTER_PRINT_BUILTINTYPE(BuiltinJobType)
+  ASTPRINTER_PRINT_BUILTINTYPE(BuiltinExecutorType)
   ASTPRINTER_PRINT_BUILTINTYPE(BuiltinDefaultActorStorageType)
   ASTPRINTER_PRINT_BUILTINTYPE(BuiltinNativeObjectType)
   ASTPRINTER_PRINT_BUILTINTYPE(BuiltinBridgeObjectType)
diff --git a/lib/AST/Builtins.cpp b/lib/AST/Builtins.cpp
@@ -1351,10 +1351,9 @@ static ValueDecl *getGetCurrentAsyncTask(ASTContext &ctx, Identifier id) {
 }
 
 static ValueDecl *getGetCurrentExecutor(ASTContext &ctx, Identifier id) {
-  BuiltinFunctionBuilder builder(ctx);
-  builder.setResult(makeConcrete(BuiltinIntegerType::getWordType(ctx)));
-  builder.setAsync();
-  return builder.build(id);
+  return getBuiltinFunction(ctx, id, _async(_thin),
+                            _parameters(),
+                            _executor);
 }
 
 static ValueDecl *getCancelAsyncTask(ASTContext &ctx, Identifier id) {
@@ -2692,6 +2691,9 @@ StringRef BuiltinType::getTypeName(SmallVectorImpl<char> &result,
   case BuiltinTypeKind::BuiltinJob:
     printer << MAYBE_GET_NAMESPACED_BUILTIN(BUILTIN_TYPE_NAME_JOB);
     break;
+  case BuiltinTypeKind::BuiltinExecutor:
+    printer << MAYBE_GET_NAMESPACED_BUILTIN(BUILTIN_TYPE_NAME_EXECUTOR);
+    break;
   case BuiltinTypeKind::BuiltinDefaultActorStorage:
     printer << MAYBE_GET_NAMESPACED_BUILTIN(BUILTIN_TYPE_NAME_DEFAULTACTORSTORAGE);
     break;
diff --git a/lib/AST/Type.cpp b/lib/AST/Type.cpp
@@ -212,6 +212,7 @@ bool CanType::isReferenceTypeImpl(CanType type, const GenericSignatureImpl *sig,
   case TypeKind::BuiltinRawPointer:
   case TypeKind::BuiltinRawUnsafeContinuation:
   case TypeKind::BuiltinJob:
+  case TypeKind::BuiltinExecutor:
   case TypeKind::BuiltinDefaultActorStorage:
   case TypeKind::BuiltinUnsafeValueBuffer:
   case TypeKind::BuiltinVector:
@@ -5097,6 +5098,7 @@ ReferenceCounting TypeBase::getReferenceCounting() {
   case TypeKind::BuiltinRawPointer:
   case TypeKind::BuiltinRawUnsafeContinuation:
   case TypeKind::BuiltinJob:
+  case TypeKind::BuiltinExecutor:
   case TypeKind::BuiltinDefaultActorStorage:
   case TypeKind::BuiltinUnsafeValueBuffer:
   case TypeKind::BuiltinVector:
diff --git a/lib/IRGen/GenType.cpp b/lib/IRGen/GenType.cpp
@@ -1549,17 +1549,17 @@ const TypeInfo &TypeConverter::getTaskContinuationFunctionPtrTypeInfo() {
 }
 
 const TypeInfo &IRGenModule::getSwiftExecutorPtrTypeInfo() {
-  return Types.getSwiftExecutorPtrTypeInfo();
+  return Types.getExecutorTypeInfo();
 }
 
-const TypeInfo &TypeConverter::getSwiftExecutorPtrTypeInfo() {
-  if (SwiftExecutorPtrTI) return *SwiftExecutorPtrTI;
-  SwiftExecutorPtrTI = createUnmanagedStorageType(IGM.SwiftExecutorPtrTy,
-                                                  ReferenceCounting::Unknown,
-                                                  /*isOptional*/ false);
-  SwiftExecutorPtrTI->NextConverted = FirstType;
-  FirstType = SwiftExecutorPtrTI;
-  return *SwiftExecutorPtrTI;
+const LoadableTypeInfo &TypeConverter::getExecutorTypeInfo() {
+  if (ExecutorTI) return *ExecutorTI;
+  ExecutorTI = createPrimitive(IGM.SwiftExecutorPtrTy,
+                               IGM.getPointerSize(),
+                               IGM.getPointerAlignment());
+  ExecutorTI->NextConverted = FirstType;
+  FirstType = ExecutorTI;
+  return *ExecutorTI;
 }
 
 const LoadableTypeInfo &
@@ -2081,6 +2081,8 @@ const TypeInfo *TypeConverter::convertType(CanType ty) {
     return &getRawUnsafeContinuationTypeInfo();
   case TypeKind::BuiltinJob:
     return &getJobTypeInfo();
+  case TypeKind::BuiltinExecutor:
+    return &getExecutorTypeInfo();
   case TypeKind::BuiltinIntegerLiteral:
     return &getIntegerLiteralTypeInfo();
   case TypeKind::BuiltinFloat:
diff --git a/lib/IRGen/GenType.h b/lib/IRGen/GenType.h
@@ -105,11 +105,11 @@ class TypeConverter {
   const LoadableTypeInfo *RawPointerTI = nullptr;
   const LoadableTypeInfo *RawUnsafeContinuationTI = nullptr;
   const LoadableTypeInfo *JobTI = nullptr;
+  const LoadableTypeInfo *ExecutorTI = nullptr;
   const LoadableTypeInfo *WitnessTablePtrTI = nullptr;
   const TypeInfo *TypeMetadataPtrTI = nullptr;
   const TypeInfo *SwiftContextPtrTI = nullptr;
   const TypeInfo *TaskContinuationFunctionPtrTI = nullptr;
-  const TypeInfo *SwiftExecutorPtrTI = nullptr;
   const TypeInfo *ObjCClassPtrTI = nullptr;
   const LoadableTypeInfo *EmptyTI = nullptr;
   const LoadableTypeInfo *IntegerLiteralTI = nullptr;
@@ -184,10 +184,10 @@ class TypeConverter {
   const LoadableTypeInfo &getRawPointerTypeInfo();
   const LoadableTypeInfo &getRawUnsafeContinuationTypeInfo();
   const LoadableTypeInfo &getJobTypeInfo();
+  const LoadableTypeInfo &getExecutorTypeInfo();
   const TypeInfo &getTypeMetadataPtrTypeInfo();
   const TypeInfo &getSwiftContextPtrTypeInfo();
   const TypeInfo &getTaskContinuationFunctionPtrTypeInfo();
-  const TypeInfo &getSwiftExecutorPtrTypeInfo();
   const TypeInfo &getObjCClassPtrTypeInfo();
   const LoadableTypeInfo &getWitnessTablePtrTypeInfo();
   const LoadableTypeInfo &getEmptyTypeInfo();
diff --git a/lib/IRGen/IRGenDebugInfo.cpp b/lib/IRGen/IRGenDebugInfo.cpp
@@ -1339,6 +1339,13 @@ class IRGenDebugInfoImpl : public IRGenDebugInfo {
                                         MangledName);
     }
 
+    case TypeKind::BuiltinExecutor: {
+      unsigned PtrSize = CI.getTargetInfo().getPointerWidth(0);
+      return DBuilder.createPointerType(nullptr, PtrSize, 0,
+                                        /* DWARFAddressSpace */ None,
+                                        MangledName);
+    }
+
     case TypeKind::DynamicSelf: {
       // Self. We don't have a way to represent instancetype in DWARF,
       // so we emit the static type instead. This is similar to what we
diff --git a/lib/IRGen/MetadataRequest.cpp b/lib/IRGen/MetadataRequest.cpp
@@ -1309,6 +1309,12 @@ namespace {
       return emitDirectMetadataRef(type);
     }
 
+    MetadataResponse
+    visitBuiltinExecutorType(CanBuiltinExecutorType type,
+                             DynamicMetadataRequest request) {
+      return emitDirectMetadataRef(type);
+    }
+
     MetadataResponse
     visitBuiltinFloatType(CanBuiltinFloatType type,
                           DynamicMetadataRequest request) {
diff --git a/lib/SIL/IR/TypeLowering.cpp b/lib/SIL/IR/TypeLowering.cpp
@@ -245,6 +245,7 @@ namespace {
     IMPL(BuiltinRawPointer, Trivial)
     IMPL(BuiltinRawUnsafeContinuation, Trivial)
     IMPL(BuiltinJob, Trivial)
+    IMPL(BuiltinExecutor, Trivial)
     IMPL(BuiltinNativeObject, Reference)
     IMPL(BuiltinBridgeObject, Reference)
     IMPL(BuiltinVector, Trivial)
diff --git a/lib/SILGen/SILGenProlog.cpp b/lib/SILGen/SILGenProlog.cpp
@@ -616,7 +616,7 @@ SILValue SILGenFunction::emitGetCurrentExecutor(SILLocation loc) {
   return B.createBuiltin(
       loc,
       ctx.getIdentifier(getBuiltinName(BuiltinValueKind::GetCurrentExecutor)),
-      getLoweredType(BuiltinIntegerType::getWordType(ctx)),
+      getLoweredType(ctx.TheExecutorType),
       SubstitutionMap(), { });
 }
 
