DI: Rip out the old 'self consumed' analysis now that it's dead

Author: slavapestov

lib/SILOptimizer/Mandatory/DIMemoryUseCollectorOwnership.cpp

@@ -430,54 +430,6 @@ void DIElementUseInfo::trackStoreToSelf(SILInstruction *I) {
   StoresToSelf.push_back(I);
 }
 
-void DIElementUseInfo::trackFailableInitCall(
-    const DIMemoryObjectInfo &MemoryInfo, SILInstruction *I) {
-  // If we have a store to self inside the normal BB, we have a 'real'
-  // try_apply. Otherwise, this is a 'try? self.init()' or similar,
-  // and there is a store after.
-  if (auto *TAI = dyn_cast<TryApplyInst>(I)) {
-    trackFailureBlock(MemoryInfo, TAI, TAI->getNormalBB());
-    return;
-  }
-
-  if (auto *AI = dyn_cast<ApplyInst>(I)) {
-    // See if this is an optional initializer.
-    for (auto Op : AI->getUses()) {
-      SILInstruction *User = Op->getUser();
-
-      if (!isa<SelectEnumInst>(User) && !isa<SelectEnumAddrInst>(User))
-        continue;
-
-      auto value = cast<SingleValueInstruction>(User);
-
-      if (!value->hasOneUse())
-        continue;
-
-      User = value->use_begin()->getUser();
-      if (auto *CBI = dyn_cast<CondBranchInst>(User)) {
-        trackFailureBlock(MemoryInfo, CBI, CBI->getTrueBB());
-        return;
-      }
-    }
-  }
-}
-
-/// We have to detect if the self box contents were consumed. Do this by
-/// checking for a store into the self box in the success branch.  Once we rip
-/// this out of SILGen, DI will be able to figure this out in a more logical
-/// manner.
-void DIElementUseInfo::trackFailureBlock(const DIMemoryObjectInfo &TheMemory,
-                                         TermInst *TI, SILBasicBlock *BB) {
-  for (auto &II : *BB) {
-    if (auto *SI = dyn_cast<StoreInst>(&II)) {
-      if (SI->getDest() == TheMemory.MemoryInst) {
-        FailableInits.push_back(TI);
-        return;
-      }
-    }
-  }
-}
-
 //===----------------------------------------------------------------------===//
 //                          Scalarization Logic
 //===----------------------------------------------------------------------===//
@@ -1426,7 +1378,6 @@ void ElementUseCollector::collectClassSelfUses(
         (isSelfInitUse(User) || isSuperInitUse(User))) {
       if (isSelfOperand(Op, User)) {
         Kind = DIUseKind::SelfInit;
-        UseInfo.trackFailableInitCall(TheMemory, User);
       }
     }
 
@@ -1708,7 +1659,6 @@ void DelegatingInitElementUseCollector::collectDelegatingClassInitSelfLoadUses(
         (isSelfInitUse(User) || isSuperInitUse(User))) {
       if (isSelfOperand(Op, User)) {
         Kind = DIUseKind::SelfInit;
-        UseInfo.trackFailableInitCall(TheMemory, User);
       }
     }
 

lib/SILOptimizer/Mandatory/DIMemoryUseCollectorOwnership.h

@@ -278,21 +278,13 @@ struct DIMemoryUse {
 struct DIElementUseInfo {
   SmallVector<DIMemoryUse, 16> Uses;
   SmallVector<SILInstruction *, 4> Releases;
-  TinyPtrVector<TermInst *> FailableInits;
   TinyPtrVector<SILInstruction *> StoresToSelf;
 
   void trackUse(DIMemoryUse Use) { Uses.push_back(Use); }
 
   void trackDestroy(SILInstruction *Destroy) { Releases.push_back(Destroy); }
 
   void trackStoreToSelf(SILInstruction *I);
-
-  void trackFailableInitCall(const DIMemoryObjectInfo &TheMemory,
-                             SILInstruction *I);
-
-private:
-  void trackFailureBlock(const DIMemoryObjectInfo &TheMemory, TermInst *TI,
-                         SILBasicBlock *BB);
 };
 
 /// collectDIElementUsesFrom - Analyze all uses of the specified allocation

lib/SILOptimizer/Mandatory/DefiniteInitialization.cpp

@@ -363,15 +363,6 @@ namespace {
     /// plus the information merged-in from the predecessor blocks.
     AvailabilitySet OutAvailability;
 
-    /// Keep track of blocks where the contents of the self box are not valid
-    /// because we're in an error path dominated by a self.init or super.init
-    /// delegation.
-    Optional<DIKind> LocalSelfConsumed;
-
-    /// The live out information of the block. This is the LocalSelfConsumed
-    /// plus the information merged-in from the predecessor blocks.
-    Optional<DIKind> OutSelfConsumed;
-
     /// Keep track of blocks where the contents of the self box are stored to
     /// as a result of a successful self.init or super.init call.
     Optional<DIKind> LocalSelfInitialized;
@@ -391,10 +382,6 @@ namespace {
     void setUnknownToNotAvailable() {
       LocalAvailability.changeUnsetElementsTo(DIKind::No);
       OutAvailability.changeUnsetElementsTo(DIKind::No);
-      if (!LocalSelfConsumed.hasValue())
-        LocalSelfConsumed = DIKind::No;
-      if (!OutSelfConsumed.hasValue())
-        OutSelfConsumed = DIKind::No;
       if (!LocalSelfInitialized.hasValue())
         LocalSelfInitialized = DIKind::No;
       if (!OutSelfInitialized.hasValue())
@@ -441,15 +428,6 @@ namespace {
         }
       }
 
-      Optional<DIKind> temp;
-      if (transferAvailability(Pred.OutSelfConsumed,
-                               OutSelfConsumed,
-                               LocalSelfConsumed,
-                               temp)) {
-        changed = true;
-        OutSelfConsumed = temp;
-      }
-
       Optional<DIKind> result;
       if (transferAvailability(Pred.OutSelfInitialized,
                                OutSelfInitialized,
@@ -474,13 +452,6 @@ namespace {
       }
     }
 
-    /// Mark the block as a failure path, indicating the self value has been
-    /// consumed.
-    void markFailure(bool partial) {
-      LocalSelfConsumed = (partial ? DIKind::Partial : DIKind::Yes);
-      OutSelfConsumed = LocalSelfConsumed;
-    }
-
     /// Mark the block as storing to self, indicating the self box has been
     /// initialized.
     void markStoreToSelf() {
@@ -490,8 +461,7 @@ namespace {
 
     /// If true, we're not done with our dataflow analysis yet.
     bool containsUndefinedValues() {
-      return (!OutSelfConsumed.hasValue() ||
-              !OutSelfInitialized.hasValue() ||
+      return (!OutSelfInitialized.hasValue() ||
               OutAvailability.containsUnknownElements());
     }
   };
@@ -515,7 +485,6 @@ namespace {
     DIMemoryObjectInfo TheMemory;
 
     SmallVectorImpl<DIMemoryUse> &Uses;
-    TinyPtrVector<TermInst *> &FailableInits;
     TinyPtrVector<SILInstruction *> &StoresToSelf;
     SmallVectorImpl<SILInstruction *> &Destroys;
     std::vector<ConditionalDestroy> ConditionalDestroys;
@@ -566,7 +535,6 @@ namespace {
     int getAnyUninitializedMemberAtInst(SILInstruction *Inst, unsigned FirstElt,
                                         unsigned NumElts);
 
-    DIKind getSelfConsumedAtInst(SILInstruction *Inst);
     DIKind getSelfInitializedAtInst(SILInstruction *Inst);
 
     bool isInitializedAtUse(const DIMemoryUse &Use,
@@ -601,7 +569,6 @@ namespace {
     void putIntoWorkList(SILBasicBlock *BB, WorkListType &WorkList);
     void computePredsLiveOut(SILBasicBlock *BB);
     void getOutAvailability(SILBasicBlock *BB, AvailabilitySet &Result);
-    void getOutSelfConsumed(SILBasicBlock *BB, Optional<DIKind> &Result);
     void getOutSelfInitialized(SILBasicBlock *BB, Optional<DIKind> &Result);
 
     bool shouldEmitError(SILInstruction *Inst);
@@ -620,8 +587,8 @@ namespace {
 LifetimeChecker::LifetimeChecker(const DIMemoryObjectInfo &TheMemory,
                                  DIElementUseInfo &UseInfo)
     : Module(TheMemory.MemoryInst->getModule()), TheMemory(TheMemory),
-      Uses(UseInfo.Uses), FailableInits(UseInfo.FailableInits),
-      StoresToSelf(UseInfo.StoresToSelf), Destroys(UseInfo.Releases) {
+      Uses(UseInfo.Uses), StoresToSelf(UseInfo.StoresToSelf),
+      Destroys(UseInfo.Releases) {
 
   // The first step of processing an element is to collect information about the
   // element into data structures we use later.
@@ -653,16 +620,6 @@ LifetimeChecker::LifetimeChecker(const DIMemoryObjectInfo &TheMemory,
     getBlockInfo(bb).markStoreToSelf();
   }
 
-  // Mark blocks where the self value has been consumed.
-  for (auto *I : FailableInits) {
-    auto *bb = I->getSuccessors()[1].getBB();
-
-    // Horrible hack. Failing inits create critical edges, where all
-    // 'return nil's end up. We'll split the edge later.
-    bool criticalEdge = isCriticalEdge(I, 1);
-    getBlockInfo(bb).markFailure(criticalEdge);
-  }
-
   // If isn't really a use, but we account for the alloc_box/mark_uninitialized
   // as a use so we see it in our dataflow walks.
   NonLoadUses[TheMemory.MemoryInst] = ~0U;
@@ -2535,14 +2492,6 @@ getOutAvailability(SILBasicBlock *BB, AvailabilitySet &Result) {
   DEBUG(llvm::dbgs() << "    Result: " << Result << "\n");
 }
 
-void LifetimeChecker::
-getOutSelfConsumed(SILBasicBlock *BB, Optional<DIKind> &Result) {
-  computePredsLiveOut(BB);
-
-  for (auto *Pred : BB->getPredecessorBlocks())
-    Result = mergeKinds(Result, getBlockInfo(Pred).OutSelfConsumed);
-}
-
 void LifetimeChecker::
 getOutSelfInitialized(SILBasicBlock *BB, Optional<DIKind> &Result) {
   computePredsLiveOut(BB);
@@ -2685,32 +2634,6 @@ int LifetimeChecker::getAnyUninitializedMemberAtInst(SILInstruction *Inst,
   return -1;
 }
 
-/// getSelfConsumedAtInst - Compute the liveness state for any number of tuple
-/// elements at the specified instruction.  The elements are returned as an
-/// AvailabilitySet.  Elements outside of the range specified may not be
-/// computed correctly.
-DIKind LifetimeChecker::
-getSelfConsumedAtInst(SILInstruction *Inst) {
-  DEBUG(llvm::dbgs() << "Get self consumed at " << *Inst);
-
-  SILBasicBlock *InstBB = Inst->getParent();
-  auto &BlockInfo = getBlockInfo(InstBB);
-
-  if (BlockInfo.LocalSelfConsumed.hasValue())
-    return *BlockInfo.LocalSelfConsumed;
-
-  Optional<DIKind> Result;
-  getOutSelfConsumed(InstBB, Result);
-
-  // If the result wasn't computed, we must be analyzing code within
-  // an unreachable cycle that is not dominated by "TheMemory".  Just force
-  // the result to unconsumed so that clients don't have to handle this.
-  if (!Result.hasValue())
-    Result = DIKind::No;
-
-  return *Result;
-}
-
 /// getSelfInitializedAtInst - Check if the self box in an initializer has
 /// a fully initialized value at the specified instruction.
 ///