Add builtins to initialize and destroy a default-actor member.

It would be more abstractly correct if this got DI support so
that we destroy the member if the constructor terminates
abnormally, but we can get to that later.

Author: rjmccall

include/swift/Runtime/RuntimeFunctions.def

@@ -1528,6 +1528,22 @@ FUNCTION(TaskSwitchFunc,
          ARGS(SwiftTaskPtrTy, SwiftExecutorPtrTy, SwiftExecutorPtrTy),
          ATTRS(NoUnwind))
 
+// void swift_defaultActor_initialize(DefaultActor *actor);
+FUNCTION(DefaultActorInitialize,
+         swift_defaultActor_initialize, SwiftCC,
+         ConcurrencyAvailability,
+         RETURNS(VoidTy),
+         ARGS(RefCountedPtrTy),
+         ATTRS(NoUnwind))
+
+// void swift_defaultActor_destroy(DefaultActor *actor);
+FUNCTION(DefaultActorDestroy,
+         swift_defaultActor_destroy, SwiftCC,
+         ConcurrencyAvailability,
+         RETURNS(VoidTy),
+         ARGS(RefCountedPtrTy),
+         ATTRS(NoUnwind))
+
 // AutoDiffLinearMapContext *swift_autoDiffCreateLinearMapContext(size_t);
 FUNCTION(AutoDiffCreateLinearMapContext,
          swift_autoDiffCreateLinearMapContext, SwiftCC,

lib/IRGen/GenBuiltin.cpp

@@ -266,6 +266,22 @@ void irgen::emitBuiltinCall(IRGenFunction &IGF, const BuiltinInfo &Builtin,
     return;
   }
 
+  if (Builtin.ID == BuiltinValueKind::InitializeDefaultActor ||
+      Builtin.ID == BuiltinValueKind::DestroyDefaultActor) {
+    auto fn = Builtin.ID == BuiltinValueKind::InitializeDefaultActor
+                ? IGF.IGM.getDefaultActorInitializeFn()
+                : IGF.IGM.getDefaultActorDestroyFn();
+    auto actor = args.claimNext();
+    actor = IGF.Builder.CreateBitCast(actor, IGF.IGM.RefCountedPtrTy);
+    auto call = IGF.Builder.CreateCall(fn, {actor});
+    call->setCallingConv(IGF.IGM.SwiftCC);
+    call->setDoesNotThrow();
+    return;
+  }
+
+  if (Builtin.ID == BuiltinValueKind::DestroyDefaultActor) {
+  }
+
   // If this is an LLVM IR intrinsic, lower it to an intrinsic call.
   const IntrinsicInfo &IInfo = IGF.getSILModule().getIntrinsicInfo(FnId);
   llvm::Intrinsic::ID IID = IInfo.ID;

lib/SIL/IR/OperandOwnership.cpp

@@ -879,6 +879,8 @@ CONSTANT_OWNERSHIP_BUILTIN(None, NonLifetimeEnding, AutoDiffCreateLinearMapConte
 CONSTANT_OWNERSHIP_BUILTIN(Guaranteed, NonLifetimeEnding, AutoDiffAllocateSubcontext)
 CONSTANT_OWNERSHIP_BUILTIN(Guaranteed, NonLifetimeEnding, AutoDiffProjectTopLevelSubcontext)
 CONSTANT_OWNERSHIP_BUILTIN(Owned, LifetimeEnding, ConvertTaskToJob)
+CONSTANT_OWNERSHIP_BUILTIN(Guaranteed, NonLifetimeEnding, InitializeDefaultActor)
+CONSTANT_OWNERSHIP_BUILTIN(Guaranteed, NonLifetimeEnding, DestroyDefaultActor)
 
 #undef CONSTANT_OWNERSHIP_BUILTIN
 

lib/SIL/IR/ValueOwnership.cpp

@@ -546,6 +546,8 @@ CONSTANT_OWNERSHIP_BUILTIN(None, CancelAsyncTask)
 CONSTANT_OWNERSHIP_BUILTIN(Owned, CreateAsyncTask)
 CONSTANT_OWNERSHIP_BUILTIN(Owned, CreateAsyncTaskFuture)
 CONSTANT_OWNERSHIP_BUILTIN(None, ConvertTaskToJob)
+CONSTANT_OWNERSHIP_BUILTIN(None, InitializeDefaultActor)
+CONSTANT_OWNERSHIP_BUILTIN(None, DestroyDefaultActor)
 CONSTANT_OWNERSHIP_BUILTIN(Owned, AutoDiffCreateLinearMapContext)
 CONSTANT_OWNERSHIP_BUILTIN(None, AutoDiffProjectTopLevelSubcontext)
 CONSTANT_OWNERSHIP_BUILTIN(None, AutoDiffAllocateSubcontext)

lib/SIL/Utils/MemAccessUtils.cpp

@@ -1807,6 +1807,8 @@ static void visitBuiltinAddress(BuiltinInst *builtin,
     case BuiltinValueKind::CreateAsyncTaskFuture:
     case BuiltinValueKind::AutoDiffCreateLinearMapContext:
     case BuiltinValueKind::AutoDiffAllocateSubcontext:
+    case BuiltinValueKind::InitializeDefaultActor:
+    case BuiltinValueKind::DestroyDefaultActor:
       return;
 
     // General memory access to a pointer in first operand position.

lib/SIL/Verifier/SILVerifier.cpp

@@ -1782,13 +1782,27 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
       return;
     }
 
+    auto builtinKind = BI->getBuiltinKind();
+
     // Check that 'getCurrentAsyncTask' only occurs within an async function.
-    if (BI->getBuiltinKind() &&
-        *BI->getBuiltinKind() == BuiltinValueKind::GetCurrentAsyncTask) {
+    if (builtinKind == BuiltinValueKind::GetCurrentAsyncTask) {
       require(F.isAsync(),
           "getCurrentAsyncTask builtin can only be used in an async function");
       return;
     }
+
+    if (builtinKind == BuiltinValueKind::InitializeDefaultActor ||
+        builtinKind == BuiltinValueKind::DestroyDefaultActor) {
+      auto arguments = BI->getArguments();
+      require(arguments.size() == 1,
+              "default-actor builtin can only operate on a single object");
+      auto argType = arguments[0]->getType().getASTType();
+      auto argClass = argType.getClassOrBoundGenericClass();
+      require((argClass && argClass->isRootDefaultActor()) ||
+              isa<BuiltinNativeObjectType>(argType),
+              "default-actor builtin can only operate on default actors");
+      return;
+    }
   }
 
   void checkFunctionRefBaseInst(FunctionRefBaseInst *FRI) {

lib/SILGen/SILGenConstructor.cpp

@@ -650,6 +650,19 @@ void SILGenFunction::emitClassConstructorAllocator(ConstructorDecl *ctor) {
                  initedSelfValue);
 }
 
+static void emitDefaultActorInitialization(SILGenFunction &SGF,
+                                           SILLocation loc,
+                                           ManagedValue self) {
+  auto &ctx = SGF.getASTContext();
+  auto builtinName = ctx.getIdentifier(
+    getBuiltinName(BuiltinValueKind::InitializeDefaultActor));
+  auto resultTy = SGF.SGM.Types.getEmptyTupleType();
+
+  FullExpr scope(SGF.Cleanups, CleanupLocation::get(loc));
+  SGF.B.createBuiltin(loc, builtinName, resultTy, /*subs*/{},
+                      { self.borrow(SGF, loc).getValue() });
+}
+
 void SILGenFunction::emitClassConstructorInitializer(ConstructorDecl *ctor) {
   MagicFunctionName = SILGenModule::getMagicFunctionName(ctor);
 
@@ -719,6 +732,13 @@ void SILGenFunction::emitClassConstructorInitializer(ConstructorDecl *ctor) {
     B.createDebugValue(PrologueLoc, selfArg.getValue(), DbgVar);
   }
 
+  // Initialize the default-actor instance.
+  if (selfClassDecl->isRootDefaultActor() && !isDelegating) {
+    SILLocation PrologueLoc(selfDecl);
+    PrologueLoc.markAsPrologue();
+    emitDefaultActorInitialization(*this, PrologueLoc, selfArg);
+  }
+
   if (!ctor->hasStubImplementation()) {
     assert(selfTy.hasReferenceSemantics() &&
            "can't emit a value type ctor here");

lib/SILGen/SILGenDestructor.cpp

@@ -193,6 +193,15 @@ void SILGenFunction::emitClassMemberDestruction(ManagedValue selfValue,
       B.createEndAccess(cleanupLoc, addr, false /*is aborting*/);
     }
   }
+
+  if (cd->isRootDefaultActor()) {
+    auto builtinName = getASTContext().getIdentifier(
+      getBuiltinName(BuiltinValueKind::DestroyDefaultActor));
+    auto resultTy = SGM.Types.getEmptyTupleType();
+
+    B.createBuiltin(cleanupLoc, builtinName, resultTy, /*subs*/{},
+                    { selfValue.getValue() });
+  }
 }
 
 

lib/SILOptimizer/Mandatory/DefiniteInitialization.cpp

@@ -2026,6 +2026,18 @@ void LifetimeChecker::processUninitializedReleaseOfBox(
   Destroys.push_back(B.createDeallocBox(Release->getLoc(), MUI));
 }
 
+static void emitDefaultActorDestroy(SILBuilder &B, SILLocation loc,
+                                    SILValue self) {
+  auto builtinName = B.getASTContext().getIdentifier(
+    getBuiltinName(BuiltinValueKind::DestroyDefaultActor));
+  auto resultTy = B.getModule().Types.getEmptyTupleType();
+
+  self = B.createBeginBorrow(loc, self);
+  B.createBuiltin(loc, builtinName, resultTy, /*subs*/{},
+                  { self });
+  B.createEndBorrow(loc, self);
+}
+
 void LifetimeChecker::processUninitializedRelease(SILInstruction *Release,
                                                   bool consumed,
                                              SILBasicBlock::iterator InsertPt) {
@@ -2076,6 +2088,15 @@ void LifetimeChecker::processUninitializedRelease(SILInstruction *Release,
     else
       Metatype = B.createMetatype(Loc, SILMetatypeTy);
 
+    // If this is a root default actor, destroy the default-actor state.
+    // SILGen ensures that this is unconditionally initialized, so we
+    // don't need to track it specially.
+    if (!TheMemory.isDelegatingInit()) {
+      auto classDecl = TheMemory.getASTType().getClassOrBoundGenericClass();
+      if (classDecl && classDecl->isRootDefaultActor())
+        emitDefaultActorDestroy(B, Loc, Pointer);
+    }
+
     // We've already destroyed any instance variables initialized by this
     // constructor, now destroy instance variables initialized by subclass
     // constructors that delegated to us, and finally free the memory.

lib/SILOptimizer/Transforms/AccessEnforcementReleaseSinking.cpp

@@ -170,6 +170,8 @@ static bool isBarrier(SILInstruction *inst) {
     case BuiltinValueKind::CreateAsyncTask:
     case BuiltinValueKind::CreateAsyncTaskFuture:
     case BuiltinValueKind::ConvertTaskToJob:
+    case BuiltinValueKind::InitializeDefaultActor:
+    case BuiltinValueKind::DestroyDefaultActor:
     case BuiltinValueKind::AutoDiffProjectTopLevelSubcontext:
     case BuiltinValueKind::AutoDiffAllocateSubcontext:
       return true;