Add a builtin to convert a Task* to a Job*.

Author: rjmccall

include/swift/AST/Builtins.def

@@ -621,6 +621,11 @@ BUILTIN_MISC_OPERATION(AtomicStore, "atomicstore", "", Special)
 /// AtomicRMW has type (Builtin.RawPointer, T) -> T.
 BUILTIN_MISC_OPERATION(AtomicRMW, "atomicrmw", "", IntegerOrRawPointer)
 
+/// convertTaskToJob : (Builtin.NativePointer) -> Builtin.Job
+///
+/// Convert a task pointer into a job pointer.
+BUILTIN_MISC_OPERATION(ConvertTaskToJob, "convertTaskToJob", "n", Special)
+
 /// ExtractElement has type (Vector<N, T>, Int32) -> T
 BUILTIN_MISC_OPERATION(ExtractElement, "extractelement", "n", Special)
 

lib/AST/Builtins.cpp

@@ -16,6 +16,7 @@
 
 #include "swift/AST/Builtins.h"
 #include "swift/AST/ASTContext.h"
+#include "swift/AST/ASTSynthesis.h"
 #include "swift/AST/FileUnit.h"
 #include "swift/AST/Module.h"
 #include "swift/AST/ParameterList.h"
@@ -180,6 +181,28 @@ getBuiltinFunction(Identifier Id, ArrayRef<Type> argTypes, Type ResType) {
   return FD;
 }
 
+template <class ExtInfoS, class ParamsS, class ResultS>
+static FuncDecl *
+getBuiltinFunction(ASTContext &ctx, Identifier id,
+                   const ExtInfoS &extInfoS, const ParamsS &paramsS,
+                   const ResultS &resultS) {
+  ModuleDecl *M = ctx.TheBuiltinModule;
+  DeclContext *DC = &M->getMainFile(FileUnitKind::Builtin);
+
+  SynthesisContext SC(ctx, DC);
+  auto params = synthesizeParameterList(SC, paramsS);
+  auto extInfo = synthesizeExtInfo(SC, extInfoS);
+  auto resultType = synthesizeType(SC, resultS);
+
+  DeclName name(ctx, id, params);
+  auto *FD = FuncDecl::createImplicit(
+      ctx, StaticSpellingKind::None, name, /*NameLoc=*/SourceLoc(),
+      extInfo.isAsync(), extInfo.isThrowing(),
+      /*GenericParams=*/nullptr, params, resultType, DC);
+  FD->setAccess(AccessLevel::Public);
+  return FD;
+}
+
 namespace {
 
 enum class BuiltinThrowsKind : uint8_t {
@@ -1409,6 +1432,13 @@ static ValueDecl *getCreateAsyncTaskFuture(ASTContext &ctx, Identifier id) {
   return builder.build(id);
 }
 
+static ValueDecl *getConvertTaskToJob(ASTContext &ctx, Identifier id) {
+  return getBuiltinFunction(ctx, id,
+                            _thin,
+                            _parameters(_owned(_nativeObject)),
+                            _job);
+}
+
 static ValueDecl *getAutoDiffCreateLinearMapContext(ASTContext &ctx,
                                                     Identifier id) {
   return getBuiltinFunction(
@@ -2589,6 +2619,9 @@ ValueDecl *swift::getBuiltinValueDecl(ASTContext &Context, Identifier Id) {
   case BuiltinValueKind::CreateAsyncTaskFuture:
     return getCreateAsyncTaskFuture(Context, Id);
 
+  case BuiltinValueKind::ConvertTaskToJob:
+    return getConvertTaskToJob(Context, Id);
+
   case BuiltinValueKind::PoundAssert:
     return getPoundAssert(Context, Id);
 

lib/IRGen/GenBuiltin.cpp

@@ -255,6 +255,16 @@ void irgen::emitBuiltinCall(IRGenFunction &IGF, const BuiltinInfo &Builtin,
     return;
   }
 
+  if (Builtin.ID == BuiltinValueKind::ConvertTaskToJob) {
+    auto task = args.claimNext();
+    // The job object starts immediately past the heap-object header.
+    auto bytes = IGF.Builder.CreateBitCast(task, IGF.IGM.Int8PtrTy);
+    auto offset = IGF.IGM.RefCountedStructSize;
+    bytes = IGF.Builder.CreateInBoundsGEP(bytes, IGF.IGM.getSize(offset));
+    auto job = IGF.Builder.CreateBitCast(bytes, IGF.IGM.SwiftJobPtrTy);
+    out.add(job);
+    return;
+  }
 
   // If this is an LLVM IR intrinsic, lower it to an intrinsic call.
   const IntrinsicInfo &IInfo = IGF.getSILModule().getIntrinsicInfo(FnId);

lib/IRGen/GenType.cpp

@@ -1662,8 +1662,7 @@ const LoadableTypeInfo &TypeConverter::getJobTypeInfo() {
   // they're valid until they are scheduled, and then they're responsible
   // for destroying themselves.  (Jobs are often interior pointers into
   // an AsyncTask*, but that's not guaranteed.)
-  auto ty = llvm::StructType::create(IGM.getLLVMContext(), "swift.job")
-              ->getPointerTo();
+  auto ty = IGM.SwiftJobPtrTy;
   auto pointeeAlign = Alignment(2 * IGM.getPointerAlignment().getValue());
   JobTI = createAlignedPointerTypeInfo(IGM, ty, pointeeAlign);
   JobTI->NextConverted = FirstType;

lib/IRGen/IRGenModule.cpp

@@ -610,6 +610,11 @@ IRGenModule::IRGenModule(IRGenerator &irgen,
   SwiftContextPtrTy = SwiftContextTy->getPointerTo(DefaultAS);
   SwiftTaskPtrTy = SwiftTaskTy->getPointerTo(DefaultAS);
   SwiftExecutorPtrTy = SwiftExecutorTy->getPointerTo(DefaultAS);
+  SwiftJobTy = createStructType(*this, "swift.job", {
+    SizeTy,               // flags
+    Int8PtrTy             // execution function pointer
+  });
+  SwiftJobPtrTy = SwiftJobTy->getPointerTo();
 
   // using TaskContinuationFunction =
   //   SWIFT_CC(swift)

lib/IRGen/IRGenModule.h

@@ -726,10 +726,12 @@ class IRGenModule {
   llvm::StructType *AsyncFunctionPointerTy; // { i32, i32 }
   llvm::StructType *SwiftContextTy;
   llvm::StructType *SwiftTaskTy;
+  llvm::StructType *SwiftJobTy;
   llvm::StructType *SwiftExecutorTy;
   llvm::PointerType *AsyncFunctionPointerPtrTy;
   llvm::PointerType *SwiftContextPtrTy;
   llvm::PointerType *SwiftTaskPtrTy;
+  llvm::PointerType *SwiftJobPtrTy;
   llvm::PointerType *SwiftExecutorPtrTy;
   llvm::FunctionType *TaskContinuationFunctionTy;
   llvm::PointerType *TaskContinuationFunctionPtrTy;

lib/SIL/IR/OperandOwnership.cpp

@@ -878,6 +878,7 @@ CONSTANT_OWNERSHIP_BUILTIN(Guaranteed, NonLifetimeEnding, CreateAsyncTaskFuture)
 CONSTANT_OWNERSHIP_BUILTIN(None, NonLifetimeEnding, AutoDiffCreateLinearMapContext)
 CONSTANT_OWNERSHIP_BUILTIN(Guaranteed, NonLifetimeEnding, AutoDiffAllocateSubcontext)
 CONSTANT_OWNERSHIP_BUILTIN(Guaranteed, NonLifetimeEnding, AutoDiffProjectTopLevelSubcontext)
+CONSTANT_OWNERSHIP_BUILTIN(Owned, LifetimeEnding, ConvertTaskToJob)
 
 #undef CONSTANT_OWNERSHIP_BUILTIN
 

lib/SIL/IR/ValueOwnership.cpp

@@ -545,6 +545,7 @@ CONSTANT_OWNERSHIP_BUILTIN(None, GetCurrentAsyncTask)
 CONSTANT_OWNERSHIP_BUILTIN(None, CancelAsyncTask)
 CONSTANT_OWNERSHIP_BUILTIN(Owned, CreateAsyncTask)
 CONSTANT_OWNERSHIP_BUILTIN(Owned, CreateAsyncTaskFuture)
+CONSTANT_OWNERSHIP_BUILTIN(None, ConvertTaskToJob)
 CONSTANT_OWNERSHIP_BUILTIN(Owned, AutoDiffCreateLinearMapContext)
 CONSTANT_OWNERSHIP_BUILTIN(None, AutoDiffProjectTopLevelSubcontext)
 CONSTANT_OWNERSHIP_BUILTIN(None, AutoDiffAllocateSubcontext)

lib/SILOptimizer/Transforms/AccessEnforcementReleaseSinking.cpp

@@ -169,6 +169,7 @@ static bool isBarrier(SILInstruction *inst) {
     case BuiltinValueKind::CancelAsyncTask:
     case BuiltinValueKind::CreateAsyncTask:
     case BuiltinValueKind::CreateAsyncTaskFuture:
+    case BuiltinValueKind::ConvertTaskToJob:
     case BuiltinValueKind::AutoDiffProjectTopLevelSubcontext:
     case BuiltinValueKind::AutoDiffAllocateSubcontext:
       return true;

test/IRGen/builtins.swift

@@ -839,5 +839,15 @@ func globalStringTablePointerUse(_ str: String) -> Builtin.RawPointer {
 }
 
 
+// CHECK-LABEL: define {{.*}}convertTaskToJob
+// CHECK:      call %swift.refcounted* @swift_retain(%swift.refcounted* returned %0)
+// CHECK-NEXT: [[T0:%.*]] = bitcast %swift.refcounted* %0 to i8*
+// CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds i8, i8* [[T0]], i64 16
+// CHECK-NEXT: [[T2:%.*]] = bitcast i8* [[T1]] to %swift.job*
+// CHECK-NEXT: ret %swift.job* [[T2]]
+func convertTaskToJob(_ task: Builtin.NativeObject) -> Builtin.Job {
+  return Builtin.convertTaskToJob(task)
+}
+
 
 // CHECK: ![[R]] = !{i64 0, i64 9223372036854775807}