[semantic-sil] Update capture promotion for moving mark_uninitialized onto alloc_box instead of project_box and move the fixup pass behind it.

rdar://31521023

Author: gottesmm

lib/SILOptimizer/IPO/CapturePromotion.cpp

@@ -991,18 +991,7 @@ static bool isProjectBoxNonEscapingUse(ProjectBoxInst *PBI,
                                        EscapeMutationScanningState &State) {
   DEBUG(llvm::dbgs() << "    Found project box: " << *PBI);
 
-  // Check for mutations of the address component.
-  SILValue Addr = PBI;
-
-  // If the AllocBox is used by a mark_uninitialized, scan the MUI for
-  // interesting uses.
-  if (Addr->hasOneUse()) {
-    SILInstruction *SingleAddrUser = Addr->use_begin()->getUser();
-    if (isa<MarkUninitializedInst>(SingleAddrUser))
-      Addr = SILValue(SingleAddrUser);
-  }
-
-  for (Operand *AddrOp : Addr->getUses()) {
+  for (Operand *AddrOp : PBI->getUses()) {
     if (!isNonEscapingUse(AddrOp, State)) {
       DEBUG(llvm::dbgs() << "    FAIL! Has escaping user of addr:"
                          << *AddrOp->getUser());
@@ -1015,11 +1004,13 @@ static bool isProjectBoxNonEscapingUse(ProjectBoxInst *PBI,
 
 static bool scanUsesForEscapesAndMutations(Operand *Op,
                                            EscapeMutationScanningState &State) {
-  if (auto *PAI = dyn_cast<PartialApplyInst>(Op->getUser())) {
+  SILInstruction *User = Op->getUser();
+
+  if (auto *PAI = dyn_cast<PartialApplyInst>(User)) {
     return isPartialApplyNonEscapingUser(Op, PAI, State);
   }
 
-  if (auto *PBI = dyn_cast<ProjectBoxInst>(Op->getUser())) {
+  if (auto *PBI = dyn_cast<ProjectBoxInst>(User)) {
     // It is assumed in later code that we will only have 1 project_box. This
     // can be seen since there is no code for reasoning about multiple
     // boxes. Just put in the restriction so we are consistent.
@@ -1029,20 +1020,16 @@ static bool scanUsesForEscapesAndMutations(Operand *Op,
     return isProjectBoxNonEscapingUse(PBI, State);
   }
 
-  // Given a top level copy value use, check all of its user operands as if
-  // they were apart of the use list of the base operand.
-  //
-  // This is because even though we are copying the box, a copy of the box is
-  // just a retain + bitwise copy of the pointer. This has nothing to do with
-  // whether or not the address escapes in some way.
+  // Given a top level copy value use or mark_uninitialized, check all of its
+  // user operands as if they were apart of the use list of the base operand.
   //
   // This is a separate code path from the non escaping user visitor check since
   // we want to be more conservative around non-top level copies (i.e. a copy
   // derived from a projection like instruction). In fact such a thing may not
   // even make any sense!
-  if (auto *CVI = dyn_cast<CopyValueInst>(Op->getUser())) {
-    return all_of(CVI->getUses(), [&State](Operand *CopyOp) -> bool {
-      return scanUsesForEscapesAndMutations(CopyOp, State);
+  if (isa<CopyValueInst>(User) || isa<MarkUninitializedInst>(User)) {
+    return all_of(User->getUses(), [&State](Operand *UserOp) -> bool {
+      return scanUsesForEscapesAndMutations(UserOp, State);
     });
   }
 
@@ -1171,36 +1158,18 @@ static SILValue getOrCreateProjectBoxHelper(SILValue PartialOperand) {
     return B.createProjectBox(CVI->getLoc(), CVI, 0);
   }
 
-  // Otherwise, handle the alloc_box case.
-  auto *ABI = cast<AllocBoxInst>(PartialOperand);
-  // Load and copy from the address value, passing the result as an argument
-  // to the new closure.
-  //
-  // *NOTE* This code assumes that we only have one project box user. We
-  // enforce this with the assert below.
-  assert(count_if(ABI->getUses(), [](Operand *Op) -> bool {
-           return isa<ProjectBoxInst>(Op->getUser());
-         }) == 1);
-
-  // If the address is marked uninitialized, load through the mark, so
-  // that DI can reason about it.
-  for (Operand *BoxValueUse : ABI->getUses()) {
-    auto *PBI = dyn_cast<ProjectBoxInst>(BoxValueUse->getUser());
-    if (!PBI)
-      continue;
-
-    auto *OptIter = PBI->getSingleUse();
-    if (!OptIter)
-      continue;
-
-    if (!isa<MarkUninitializedInst>(OptIter->getUser()))
-      continue;
-
-    return OptIter->getUser();
+  // Otherwise, handle the alloc_box case. If we have a mark_uninitialized on
+  // the box, we create the project value through that.
+  SILInstruction *Box = cast<AllocBoxInst>(PartialOperand);
+  if (auto *Op = Box->getSingleUse()) {
+    if (auto *MUI = dyn_cast<MarkUninitializedInst>(Op->getUser())) {
+      Box = MUI;
+    }
   }
 
-  // Otherwise, just return a project_box.
-  return getOrCreateProjectBox(ABI, 0);
+  // Just return a project_box.
+  SILBuilder B(std::next(Box->getIterator()));
+  return B.createProjectBox(Box->getLoc(), Box, 0);
 }
 
 /// \brief Given a partial_apply instruction and a set of promotable indices,

lib/SILOptimizer/PassManager/PassPipeline.cpp

@@ -74,12 +74,12 @@ static void addOwnershipModelEliminatorPipeline(SILPassPipelinePlan &P) {
 static void addMandatoryOptPipeline(SILPassPipelinePlan &P,
                                     const SILOptions &Options) {
   P.startPipeline("Guaranteed Passes");
-  P.addMarkUninitializedFixup();
   if (Options.EnableMandatorySemanticARCOpts) {
     P.addSemanticARCOpts();
   }
   P.addDiagnoseStaticExclusivity();
   P.addCapturePromotion();
+  P.addMarkUninitializedFixup();
   P.addAllocBoxToStack();
   P.addNoReturnFolding();
   P.addOwnershipModelEliminator();

test/SILOptimizer/capture_promotion_ownership.sil

@@ -34,8 +34,10 @@ sil @dummy_func : $@convention(thin) (Int, Int, Int) -> Int
 sil @test_capture_promotion : $@convention(thin) () -> @owned @callee_owned () -> Int {
 bb0:
   // CHECK: [[BOX1:%.*]] = alloc_box $<τ_0_0> { var τ_0_0 } <Foo>
+  // CHECK: [[MARKED_BOX1:%.*]] = mark_uninitialized [var] [[BOX1]]
   %1 = alloc_box $<τ_0_0> { var τ_0_0 } <Foo>
-  %1a = project_box %1 : $<τ_0_0> { var τ_0_0 } <Foo>, 0
+  %1ab = mark_uninitialized [var] %1 : $<τ_0_0> { var τ_0_0 } <Foo>
+  %1a = project_box %1ab : $<τ_0_0> { var τ_0_0 } <Foo>, 0
   %2 = function_ref @foo_allocating_init : $@convention(thin) (@thick Foo.Type) -> @owned Foo
   %3 = metatype $@thick Foo.Type
   %4 = apply %2(%3) : $@convention(thin) (@thick Foo.Type) -> @owned Foo
@@ -58,7 +60,7 @@ bb0:
   %15 = apply %12(%14, %13) : $@convention(thin) (Builtin.Word, @thin Int.Type) -> Int
   store %15 to [trivial] %11a : $*Int
 
-// CHECK: [[BOX1_COPY:%.*]] = copy_value [[BOX1]]
+// CHECK: [[BOX1_COPY:%.*]] = copy_value [[MARKED_BOX1]]
 // CHECK: [[BOX1_COPY_PB:%.*]] = project_box [[BOX1_COPY]]
 // CHECK: [[BOX2_COPY:%.*]] = copy_value [[BOX2]]
 // CHECK: [[BOX2_COPY_PB:%.*]] = project_box [[BOX2_COPY]]
@@ -87,14 +89,14 @@ bb0:
 // CHECK-NEXT: {{.*}} = partial_apply [[CLOSURE_PROMOTE]]([[LOADFOO]], [[LOADBAZ]], [[LOADINT]])
 
   %17 = function_ref @closure0 : $@convention(thin) (@owned <τ_0_0> { var τ_0_0 } <Foo>, @owned <τ_0_0> { var τ_0_0 } <Baz>, @owned <τ_0_0> { var τ_0_0 } <Int>) -> Int
-  %18 = copy_value %1 : $<τ_0_0> { var τ_0_0 } <Foo>
+  %18 = copy_value %1ab : $<τ_0_0> { var τ_0_0 } <Foo>
   %19 = copy_value %6 : $<τ_0_0> { var τ_0_0 } <Baz>
   %20 = copy_value %11 : $<τ_0_0> { var τ_0_0 } <Int>
   %21 = partial_apply %17(%18, %19, %20) : $@convention(thin) (@owned <τ_0_0> { var τ_0_0 } <Foo>, @owned <τ_0_0> { var τ_0_0 } <Baz>, @owned <τ_0_0> { var τ_0_0 } <Int>) -> Int
 
   destroy_value %11 : $<τ_0_0> { var τ_0_0 } <Int>
   destroy_value %6 : $<τ_0_0> { var τ_0_0 } <Baz>
-  destroy_value %1 : $<τ_0_0> { var τ_0_0 } <Foo>
+  destroy_value %1ab : $<τ_0_0> { var τ_0_0 } <Foo>
 
   return %21 : $@callee_owned () -> Int
 }