Merge pull request swiftlang#28963 from gottesmm/mark_uninit_fixup_removal

Author: swift-ci

lib/SIL/SILVerifier.cpp

@@ -2206,10 +2206,6 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
             // outside by the allocating initializer and we pass in the to be
             // initialized value as a SILArgument.
             || isa<SILArgument>(Src)
-            // FIXME: Once the MarkUninitializedFixup pass is eliminated,
-            // mark_uninitialized should never be applied to a project_box. So
-            // at that point, this should be eliminated.
-            || isa<ProjectBoxInst>(Src)
             // FIXME: We only support pointer to address here to not break LLDB. It is
             // important that long term we get rid of this since this is a situation
             // where LLDB is breaking SILGen/DI invariants by not creating a new

lib/SILOptimizer/IPO/CapturePromotion.cpp

@@ -1197,7 +1197,7 @@ constructClonedFunction(SILOptFunctionBuilder &FuncBuilder,
 /// 2. We only see a mark_uninitialized when paired with an (alloc_box,
 ///    project_box). e.x.:
 ///
-///       (mark_uninitialized (project_box (alloc_box)))
+///       (project_box (mark_uninitialized (alloc_box)))
 ///
 /// The asserts are to make sure that if the initial safety condition check
 /// is changed, this code is changed as well.
@@ -1209,15 +1209,16 @@ static SILValue getOrCreateProjectBoxHelper(SILValue PartialOperand) {
   }
 
   // Otherwise, handle the alloc_box case. If we have a mark_uninitialized on
-  // the box, we create the project value through that.
+  // the box, we know that we will have a project_box of that value due to SIL
+  // verifier invariants.
   SingleValueInstruction *Box = cast<AllocBoxInst>(PartialOperand);
-  if (auto *Op = Box->getSingleUse()) {
-    if (auto *MUI = dyn_cast<MarkUninitializedInst>(Op->getUser())) {
-      Box = MUI;
+  if (auto *MUI = Box->getSingleUserOfType<MarkUninitializedInst>()) {
+    if (auto *PBI = MUI->getSingleUserOfType<ProjectBoxInst>()) {
+      return PBI;
     }
   }
 
-  // Just return a project_box.
+  // Otherwise, create a new project_box.
   SILBuilderWithScope B(std::next(Box->getIterator()));
   return B.createProjectBox(Box->getLoc(), Box, 0);
 }

lib/SILOptimizer/Mandatory/DIMemoryUseCollector.cpp

@@ -50,10 +50,9 @@ static void gatherDestroysOfContainer(const DIMemoryObjectInfo &memoryInfo,
   //
   // TODO: This should really be tracked separately from other destroys so that
   // we distinguish the lifetime of the container from the value itself.
-  assert(isa<MarkUninitializedInst>(uninitMemory));
-  auto *pbi = cast<ProjectBoxInst>(uninitMemory->getOperand(0));
-  auto *abi = cast<AllocBoxInst>(pbi->getOperand());
-  for (auto *user : abi->getUsersOfType<DestroyValueInst>()) {
+  assert(isa<ProjectBoxInst>(uninitMemory));
+  auto *mui = cast<MarkUninitializedInst>(uninitMemory->getOperand(0));
+  for (auto *user : mui->getUsersOfType<DestroyValueInst>()) {
     useInfo.trackDestroy(user);
   }
 }
@@ -97,7 +96,11 @@ static std::pair<SILType, bool>
 computeMemorySILType(MarkUninitializedInst *MemoryInst) {
   // Compute the type of the memory object.
   auto *MUI = MemoryInst;
-  SILType MemorySILType = MUI->getType().getObjectType();
+  SILValue Address = MUI;
+  if (auto *PBI = Address->getSingleUserOfType<ProjectBoxInst>()) {
+    Address = PBI;
+  }
+  SILType MemorySILType = Address->getType().getObjectType();
 
   // If this is a let variable we're initializing, remember this so we don't
   // allow reassignment.
@@ -1712,9 +1715,6 @@ void ClassInitElementUseCollector::collectClassInitSelfUses() {
 
   assert(StoresOfArgumentToSelf == 1 &&
          "The 'self' argument should have been stored into the box exactly once");
-
-  // Gather the uses of the
-  gatherDestroysOfContainer(TheMemory, UseInfo);
 }
 
 void ClassInitElementUseCollector::collectClassInitSelfLoadUses(
@@ -1818,6 +1818,7 @@ void swift::ownership::collectDIElementUsesFrom(
   if (shouldPerformClassInitSelf(MemoryInfo)) {
     ClassInitElementUseCollector UseCollector(MemoryInfo, UseInfo);
     UseCollector.collectClassInitSelfUses();
+    gatherDestroysOfContainer(MemoryInfo, UseInfo);
     return;
   }
 
@@ -1829,6 +1830,7 @@ void swift::ownership::collectDIElementUsesFrom(
            "delegating inits only have 1 bit");
     collectDelegatingInitUses(MemoryInfo, UseInfo,
                               MemoryInfo.getUninitializedValue());
+    gatherDestroysOfContainer(MemoryInfo, UseInfo);
     return;
   }
 

lib/SILOptimizer/Mandatory/DIMemoryUseCollector.h

@@ -98,6 +98,11 @@ class DIMemoryObjectInfo {
   /// instruction. For alloc_box though it returns the project_box associated
   /// with the memory info.
   SingleValueInstruction *getUninitializedValue() const {
+    if (auto *mui = dyn_cast<MarkUninitializedInst>(MemoryInst)) {
+      if (auto *pbi = mui->getSingleUserOfType<ProjectBoxInst>()) {
+        return pbi;
+      }
+    }
     return MemoryInst;
   }
 
@@ -209,10 +214,9 @@ class DIMemoryObjectInfo {
 
   /// Given an element number (in the flattened sense) return a pointer to a
   /// leaf element of the specified number.
-  SILValue
-  emitElementAddress(unsigned TupleEltNo, SILLocation Loc, SILBuilder &B,
-                     llvm::SmallVectorImpl<std::pair<SILValue, SILValue>>
-                         &EndBorrowList) const;
+  SILValue emitElementAddress(
+      unsigned TupleEltNo, SILLocation Loc, SILBuilder &B,
+      SmallVectorImpl<std::pair<SILValue, SILValue>> &EndBorrowList) const;
 
   /// Return the swift type of the specified element.
   SILType getElementType(unsigned EltNo) const;

lib/SILOptimizer/Mandatory/DefiniteInitialization.cpp

@@ -477,10 +477,14 @@ namespace {
     void processUninitializedRelease(SILInstruction *Release,
                                      bool consumed,
                                      SILBasicBlock::iterator InsertPt);
-    void processUninitializedReleaseOfBox(AllocBoxInst *ABI,
+
+    /// Process a mark_uninitialized of an alloc_box that is uninitialized and
+    /// needs a dealloc_box.
+    void processUninitializedReleaseOfBox(MarkUninitializedInst *MUI,
                                           SILInstruction *Release,
                                           bool consumed,
                                           SILBasicBlock::iterator InsertPt);
+
     void deleteDeadRelease(unsigned ReleaseID);
 
     void processNonTrivialRelease(unsigned ReleaseID);
@@ -791,6 +795,7 @@ void LifetimeChecker::doIt() {
   // thereof) is not initialized on some path, the bad things happen.  Process
   // releases to adjust for this.
   if (!TheMemory.hasTrivialType()) {
+    // NOTE: This array may increase in size!
     for (unsigned i = 0, e = Destroys.size(); i != e; ++i)
       processNonTrivialRelease(i);
   }
@@ -1941,12 +1946,13 @@ void LifetimeChecker::updateInstructionForInitState(DIMemoryUse &Use) {
 }
 
 void LifetimeChecker::processUninitializedReleaseOfBox(
-    AllocBoxInst *ABI, SILInstruction *Release, bool consumed,
+    MarkUninitializedInst *MUI, SILInstruction *Release, bool consumed,
     SILBasicBlock::iterator InsertPt) {
-  assert(ABI == Release->getOperand(0));
+  assert(isa<AllocBoxInst>(MUI->getOperand()));
+  assert(MUI == Release->getOperand(0));
   SILBuilderWithScope B(Release);
   B.setInsertionPoint(InsertPt);
-  Destroys.push_back(B.createDeallocBox(Release->getLoc(), ABI));
+  Destroys.push_back(B.createDeallocBox(Release->getLoc(), MUI));
 }
 
 void LifetimeChecker::processUninitializedRelease(SILInstruction *Release,
@@ -1956,8 +1962,10 @@ void LifetimeChecker::processUninitializedRelease(SILInstruction *Release,
   // dealloc_partial_ref to free the memory.  If this is a derived class, we
   // may have to do a load of the 'self' box to get the class reference.
   if (!TheMemory.isClassInitSelf()) {
-    if (auto *ABI = dyn_cast<AllocBoxInst>(Release->getOperand(0))) {
-      return processUninitializedReleaseOfBox(ABI, Release, consumed, InsertPt);
+    if (auto *MUI = dyn_cast<MarkUninitializedInst>(Release->getOperand(0))) {
+      if (isa<AllocBoxInst>(MUI->getOperand())) {
+        return processUninitializedReleaseOfBox(MUI, Release, consumed, InsertPt);
+      }
     }
     return;
   }
@@ -1972,9 +1980,14 @@ void LifetimeChecker::processUninitializedRelease(SILInstruction *Release,
   // If we see an alloc_box as the pointer, then we're deallocating a 'box' for
   // self. Make sure that the box gets deallocated (not released) since the
   // pointer it contains will be manually cleaned up.
-  auto *ABI = dyn_cast<AllocBoxInst>(Release->getOperand(0));
-  if (ABI)
-    Pointer = getOrCreateProjectBox(ABI, 0);
+  auto *MUI = dyn_cast<MarkUninitializedInst>(Release->getOperand(0));
+
+  if (MUI && isa<AllocBoxInst>(MUI->getOperand())) {
+    Pointer = MUI->getSingleUserOfType<ProjectBoxInst>();
+    assert(Pointer);
+  } else {
+    MUI = nullptr;
+  }
 
   if (!consumed) {
     if (Pointer->getType().isAddress())
@@ -1999,8 +2012,8 @@ void LifetimeChecker::processUninitializedRelease(SILInstruction *Release,
   }
 
   // dealloc_box the self box if necessary.
-  if (ABI) {
-    auto DB = B.createDeallocBox(Loc, ABI);
+  if (MUI) {
+    auto DB = B.createDeallocBox(Loc, MUI);
     Destroys.push_back(DB);
   }
 }

lib/SILOptimizer/PassManager/PassPipeline.cpp

@@ -74,7 +74,6 @@ static void addOwnershipModelEliminatorPipeline(SILPassPipelinePlan &P) {
 /// Passes for performing definite initialization. Must be run together in this
 /// order.
 static void addDefiniteInitialization(SILPassPipelinePlan &P) {
-  P.addMarkUninitializedFixup();
   P.addDefiniteInitialization();
   P.addRawSILInstLowering();
 }