Merge pull request #5939 from gottesmm/standardize_silbasicblock_more

[gardening] Standardize SILBasicBlock successor/predecessor methods that deal with blocks rather than the full successor data structure to have the suffix 'Block'.

Author: gottesmm

include/swift/SIL/SILBasicBlock.h

@@ -211,18 +211,18 @@ public llvm::ilist_node<SILBasicBlock>, public SILAllocated<SILBasicBlock> {
   const_succ_iterator succ_begin() const { return getSuccessors().begin(); }
   const_succ_iterator succ_end() const { return getSuccessors().end(); }
 
-  SILBasicBlock *getSingleSuccessor() {
+  SILBasicBlock *getSingleSuccessorBlock() {
     if (succ_empty() || std::next(succ_begin()) != succ_end())
       return nullptr;
     return *succ_begin();
   }
 
-  const SILBasicBlock *getSingleSuccessor() const {
-    return const_cast<SILBasicBlock *>(this)->getSingleSuccessor();
+  const SILBasicBlock *getSingleSuccessorBlock() const {
+    return const_cast<SILBasicBlock *>(this)->getSingleSuccessorBlock();
   }
 
   /// \brief Returns true if \p BB is a successor of this block.
-  bool isSuccessor(SILBasicBlock *BB) const {
+  bool isSuccessorBlock(SILBasicBlock *BB) const {
     auto Range = getSuccessorBlocks();
     return any_of(Range, [&BB](const SILBasicBlock *SuccBB) -> bool {
       return BB == SuccBB;
@@ -256,26 +256,30 @@ public llvm::ilist_node<SILBasicBlock>, public SILAllocated<SILBasicBlock> {
   pred_iterator pred_begin() const { return pred_iterator(PredList); }
   pred_iterator pred_end() const { return pred_iterator(); }
 
-  iterator_range<pred_iterator> getPreds() const {
-    return {pred_begin(), pred_end() };
+  iterator_range<pred_iterator> getPredecessorBlocks() const {
+    return {pred_begin(), pred_end()};
   }
 
-  bool isPredecessor(SILBasicBlock *BB) const {
-    return any_of(getPreds(), [&BB](const SILBasicBlock *PredBB) -> bool {
-      return BB == PredBB;
-    });
+  bool isPredecessorBlock(SILBasicBlock *BB) const {
+    return any_of(
+        getPredecessorBlocks(),
+        [&BB](const SILBasicBlock *PredBB) -> bool { return BB == PredBB; });
   }
 
-  SILBasicBlock *getSinglePredecessor() {
+  SILBasicBlock *getSinglePredecessorBlock() {
     if (pred_empty() || std::next(pred_begin()) != pred_end())
       return nullptr;
     return *pred_begin();
   }
 
-  const SILBasicBlock *getSinglePredecessor() const {
-    return const_cast<SILBasicBlock *>(this)->getSinglePredecessor();
+  const SILBasicBlock *getSinglePredecessorBlock() const {
+    return const_cast<SILBasicBlock *>(this)->getSinglePredecessorBlock();
   }
 
+  //===--------------------------------------------------------------------===//
+  // Debugging
+  //===--------------------------------------------------------------------===//
+
   /// Pretty-print the SILBasicBlock.
   void dump() const;
 

include/swift/SILOptimizer/Utils/SCCVisitor.h

@@ -154,7 +154,7 @@ class SCCVisitor {
       auto *BB = A->getParent();
       auto Index = A->getIndex();
 
-      for (auto *Pred : BB->getPreds())
+      for (auto *Pred : BB->getPredecessorBlocks())
         getArgsForTerminator(Pred->getTerminator(), BB, Index, Operands);
       return;
     }

lib/IRGen/IRGenSIL.cpp

@@ -2041,7 +2041,7 @@ void IRGenSILFunction::visitFullApplySite(FullApplySite site) {
     // Zero the error slot to maintain the invariant that it always
     // contains null.  This will frequently become a dead store.
     auto nullError = llvm::Constant::getNullValue(errorValue->getType());
-    if (!tryApplyInst->getErrorBB()->getSinglePredecessor()) {
+    if (!tryApplyInst->getErrorBB()->getSinglePredecessorBlock()) {
       // Only do that here if we can't move the store to the error block.
       // See below.
       Builder.CreateStore(nullError, errorSlot);
@@ -2059,8 +2059,8 @@ void IRGenSILFunction::visitFullApplySite(FullApplySite site) {
     // Set up the PHI nodes on the error edge.
     assert(errorDest.phis.size() == 1);
     errorDest.phis[0]->addIncoming(errorValue, Builder.GetInsertBlock());
-    
-    if (tryApplyInst->getErrorBB()->getSinglePredecessor()) {
+
+    if (tryApplyInst->getErrorBB()->getSinglePredecessorBlock()) {
       // Zeroing out the error slot only in the error block increases the chance
       // that it will become a dead store.
       auto origBB = Builder.GetInsertBlock();

lib/SIL/InstructionUtils.cpp

@@ -86,7 +86,7 @@ SILValue swift::stripSinglePredecessorArgs(SILValue V) {
 
     // First try and grab the single predecessor of our parent BB. If we don't
     // have one, bail.
-    SILBasicBlock *Pred = BB->getSinglePredecessor();
+    SILBasicBlock *Pred = BB->getSinglePredecessorBlock();
     if (!Pred)
       return V;
 

lib/SIL/SILArgument.cpp

@@ -86,7 +86,7 @@ static SILValue getIncomingValueForPred(const SILBasicBlock *BB,
 
 SILValue SILArgument::getSingleIncomingValue() const {
   const SILBasicBlock *Parent = getParent();
-  const SILBasicBlock *PredBB = Parent->getSinglePredecessor();
+  const SILBasicBlock *PredBB = Parent->getSinglePredecessorBlock();
   if (!PredBB)
     return SILValue();
   return getIncomingValueForPred(Parent, PredBB, getIndex());
@@ -99,7 +99,7 @@ bool SILArgument::getIncomingValues(llvm::SmallVectorImpl<SILValue> &OutArray) {
     return false;
 
   unsigned Index = getIndex();
-  for (SILBasicBlock *Pred : getParent()->getPreds()) {
+  for (SILBasicBlock *Pred : getParent()->getPredecessorBlocks()) {
     SILValue Value = getIncomingValueForPred(Parent, Pred, Index);
     if (!Value)
       return false;
@@ -117,7 +117,7 @@ bool SILArgument::getIncomingValues(
     return false;
 
   unsigned Index = getIndex();
-  for (SILBasicBlock *Pred : getParent()->getPreds()) {
+  for (SILBasicBlock *Pred : getParent()->getPredecessorBlocks()) {
     SILValue Value = getIncomingValueForPred(Parent, Pred, Index);
     if (!Value)
       return false;
@@ -142,7 +142,7 @@ SILValue SILArgument::getIncomingValue(unsigned BBIndex) {
   // We use this funky loop since predecessors are stored in a linked list but
   // we want array like semantics.
   unsigned BBCount = 0;
-  for (SILBasicBlock *Pred : Parent->getPreds()) {
+  for (SILBasicBlock *Pred : Parent->getPredecessorBlocks()) {
     // If BBCount is not BBIndex, continue.
     if (BBCount < BBIndex) {
       BBCount++;

lib/SIL/SILPrinter.cpp

@@ -523,7 +523,7 @@ class SILPrinter : public SILVisitor<SILPrinter> {
       *this << "// Preds:";
 
       llvm::SmallVector<ID, 32> PredIDs;
-      for (auto *BBI : BB->getPreds())
+      for (auto *BBI : BB->getPredecessorBlocks())
         PredIDs.push_back(getID(BBI));
 
       // Display the pred ids sorted to give a stable use order in the printer's

lib/SIL/SILVerifier.cpp

@@ -3397,7 +3397,7 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
       // And its destination block has more than one predecessor.
       SILBasicBlock *DestBB = SrcSuccs[EdgeIdx];
       assert(!DestBB->pred_empty() && "There should be a predecessor");
-      if (DestBB->getSinglePredecessor())
+      if (DestBB->getSinglePredecessorBlock())
         return false;
 
       return true;
@@ -3437,16 +3437,16 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
     // have this basic block in its predecessor/successor list.
     for (const auto *SuccBB : BB->getSuccessorBlocks()) {
       bool FoundSelfInSuccessor = false;
-      if (SuccBB->isPredecessor(BB)) {
+      if (SuccBB->isPredecessorBlock(BB)) {
         FoundSelfInSuccessor = true;
         break;
       }
       require(FoundSelfInSuccessor, "Must be a predecessor of each successor.");
     }
 
-    for (const SILBasicBlock *PredBB : BB->getPreds()) {
+    for (const SILBasicBlock *PredBB : BB->getPredecessorBlocks()) {
       bool FoundSelfInPredecessor = false;
-      if (PredBB->isSuccessor(BB)) {
+      if (PredBB->isSuccessorBlock(BB)) {
         FoundSelfInPredecessor = true;
         break;
       }

lib/SILGen/SILGenPattern.cpp

@@ -1989,7 +1989,7 @@ void PatternMatchEmission::emitSharedCaseBlocks() {
     // predecessor.  We rely on the SIL CFG here, because unemitted shared case
     // blocks might fallthrough into this one.
     if (!hasFallthroughTo && caseBlock->getCaseLabelItems().size() == 1) {
-      SILBasicBlock *predBB = caseBB->getSinglePredecessor();
+      SILBasicBlock *predBB = caseBB->getSinglePredecessorBlock();
       assert(predBB && "Should only have 1 predecessor because it isn't shared");
       assert(isa<BranchInst>(predBB->getTerminator()) &&
              "Should have uncond branch to shared block");

lib/SILOptimizer/ARC/GlobalARCSequenceDataflow.cpp

@@ -123,7 +123,7 @@ void ARCSequenceDataflowEvaluator::mergePredecessors(
   ARCBBState &BBState = DataHandle.getState();
 
   // For each successor of BB...
-  for (SILBasicBlock *PredBB : BB->getPreds()) {
+  for (SILBasicBlock *PredBB : BB->getPredecessorBlocks()) {
 
     // Try to look up the data handle for it. If we don't have any such state,
     // then the predecessor must be unreachable from the entrance and thus is
@@ -295,7 +295,7 @@ bool ARCSequenceDataflowEvaluator::processBBBottomUp(
   // that this block could not have multiple predecessors since otherwise, the
   // edge would be broken.
   llvm::TinyPtrVector<SILInstruction *> PredTerminators;
-  for (SILBasicBlock *PredBB : BB.getPreds()) {
+  for (SILBasicBlock *PredBB : BB.getPredecessorBlocks()) {
     auto *TermInst = PredBB->getTerminator();
     if (!isARCSignificantTerminator(TermInst))
       continue;

lib/SILOptimizer/Analysis/ARCAnalysis.cpp

@@ -622,7 +622,8 @@ findMatchingRetains(SILBasicBlock *BB) {
     // Did not find a retain in this block, try to go to its predecessors.
     if (Kind.first == FindRetainKind::None) {
       // We can not find a retain in a block with no predecessors.
-      if (R.first->getPreds().begin() == R.first->getPreds().end()) {
+      if (R.first->getPredecessorBlocks().begin() ==
+          R.first->getPredecessorBlocks().end()) {
         EpilogueRetainInsts.clear();
         return;
       }
@@ -636,7 +637,7 @@ findMatchingRetains(SILBasicBlock *BB) {
       if (SA && SA->getParent() != R.first)
         SA = nullptr;
 
-      for (auto X : R.first->getPreds()) {
+      for (auto X : R.first->getPredecessorBlocks()) {
         if (HandledBBs.find(X) != HandledBBs.end())
           continue;
         // Try to use the predecessor edge-value.
@@ -875,7 +876,7 @@ static void propagateLiveness(llvm::SmallPtrSetImpl<SILBasicBlock *> &LiveIn,
   // First populate a worklist of predecessors.
   llvm::SmallVector<SILBasicBlock *, 64> Worklist;
   for (auto *BB : LiveIn)
-    for (auto Pred : BB->getPreds())
+    for (auto Pred : BB->getPredecessorBlocks())
       Worklist.push_back(Pred);
 
   // Now propagate liveness backwards until we hit the alloc_box.
@@ -887,7 +888,7 @@ static void propagateLiveness(llvm::SmallPtrSetImpl<SILBasicBlock *> &LiveIn,
     if (BB == DefBB || !LiveIn.insert(BB).second)
       continue;
 
-    for (auto Pred : BB->getPreds())
+    for (auto Pred : BB->getPredecessorBlocks())
       Worklist.push_back(Pred);
   }
 }

lib/SILOptimizer/Analysis/EpilogueARCAnalysis.cpp

@@ -46,7 +46,7 @@ void EpilogueARCContext::initializeDataflow() {
     SILArgument *A = dyn_cast<SILArgument>(CArg);
     if (A && !A->isFunctionArg()) {
       // Find predecessor and break the SILArgument to predecessors.
-      for (auto X : A->getParent()->getPreds()) {
+      for (auto X : A->getParent()->getPredecessorBlocks()) {
         // Try to find the predecessor edge-value.
         SILValue IA = A->getIncomingValue(X);
         EpilogueARCBlockStates[X]->LocalArg = IA;

lib/SILOptimizer/Analysis/EscapeAnalysis.cpp

@@ -989,7 +989,7 @@ static bool linkBBArgs(SILBasicBlock *BB) {
     return false;
   // We don't need to link to the try_apply's normal result argument, because
   // we handle it separately in setAllEscaping() and mergeCalleeGraph().
-  if (SILBasicBlock *SinglePred = BB->getSinglePredecessor()) {
+  if (SILBasicBlock *SinglePred = BB->getSinglePredecessorBlock()) {
     auto *TAI = dyn_cast<TryApplyInst>(SinglePred->getTerminator());
     if (TAI && BB == TAI->getNormalBB())
       return false;

lib/SILOptimizer/Analysis/LoopRegionAnalysis.cpp

@@ -204,7 +204,7 @@ void LoopRegionFunctionInfo::verify() {
       // If R and OtherR are blocks, then OtherR should be a successor of the
       // real block.
       if (R->isBlock() && OtherR->isBlock())
-        assert(R->getBlock()->isSuccessor(OtherR->getBlock()) &&
+        assert(R->getBlock()->isSuccessorBlock(OtherR->getBlock()) &&
                "Expected either R was not a block or OtherR was a CFG level "
                "successor of R.");
     }
@@ -298,7 +298,7 @@ void LoopRegionFunctionInfo::initializeBlockRegionSuccessors(
 void LoopRegionFunctionInfo::markIrreducibleLoopPredecessorsOfNonLoopHeader(
     BlockTy *NonHeaderBB, RegionTy *NonHeaderBBRegion,
     PostOrderFunctionInfo *PI) {
-  for (BlockTy *Pred : NonHeaderBB->getPreds()) {
+  for (BlockTy *Pred : NonHeaderBB->getPredecessorBlocks()) {
     // If we do not have an RPO number for a predecessor, it is because the
     // predecessor is unreachable and a pass did not clean up after
     // itself. Just ignore it, it will be cleaned up by simplify-cfg.

lib/SILOptimizer/Analysis/RCIdentityAnalysis.cpp

@@ -166,7 +166,7 @@ static llvm::Optional<bool> proveNonPayloadedEnumCase(SILBasicBlock *BB,
                                                       SILValue RCIdentity) {
   // Then see if BB has one predecessor... if it does not, return None so we
   // keep searching up the domtree.
-  SILBasicBlock *SinglePred = BB->getSinglePredecessor();
+  SILBasicBlock *SinglePred = BB->getSinglePredecessorBlock();
   if (!SinglePred)
     return None;
 

lib/SILOptimizer/Analysis/SimplifyInstruction.cpp

@@ -230,8 +230,8 @@ SILValue InstSimplifier::visitEnumInst(EnumInst *EI) {
     SILBasicBlock *EnumBlock = EI->getParent();
     if (EnumArg->getParent() != EnumBlock)
       return SILValue();
-    
-    auto *Pred = EnumBlock->getSinglePredecessor();
+
+    auto *Pred = EnumBlock->getSinglePredecessorBlock();
     if (!Pred)
       return SILValue();
 
@@ -257,7 +257,7 @@ SILValue InstSimplifier::visitEnumInst(EnumInst *EI) {
   //
   // we'll return %0
   auto *BB = EI->getParent();
-  auto *Pred = BB->getSinglePredecessor();
+  auto *Pred = BB->getSinglePredecessorBlock();
   if (!Pred)
     return SILValue();
 

lib/SILOptimizer/IPO/GlobalPropertyOpt.cpp

@@ -400,7 +400,7 @@ void GlobalPropertyOpt::scanInstructions() {
         bool hasPreds = false;
         SILType Type = BBArg->getType();
         if (isArrayType(Type) || isTupleWithArray(Type.getSwiftRValueType())) {
-          for (auto *Pred : BB.getPreds()) {
+          for (auto *Pred : BB.getPredecessorBlocks()) {
             hasPreds = true;
             auto *Term = Pred->getTerminator();
             SILValue PredArg;

lib/SILOptimizer/LoopTransforms/ArrayBoundsCheckOpts.cpp

@@ -668,7 +668,7 @@ static bool isRangeChecked(SILValue Start, SILValue End,
     return true;
 
   // Look for a branch on EQ around the Preheader.
-  auto *PreheaderPred = Preheader->getSinglePredecessor();
+  auto *PreheaderPred = Preheader->getSinglePredecessorBlock();
   if (!PreheaderPred)
     return false;
   auto *CondBr = dyn_cast<CondBranchInst>(PreheaderPred->getTerminator());
@@ -1182,9 +1182,9 @@ static bool hoistBoundsChecks(SILLoop *Loop, DominanceInfo *DT, SILLoopInfo *LI,
       return Changed;
 
     // Look back a split edge.
-    if (!Loop->isLoopExiting(Latch) && Latch->getSinglePredecessor() &&
-        Loop->isLoopExiting(Latch->getSinglePredecessor()))
-      Latch = Latch->getSinglePredecessor();
+    if (!Loop->isLoopExiting(Latch) && Latch->getSinglePredecessorBlock() &&
+        Loop->isLoopExiting(Latch->getSinglePredecessorBlock()))
+      Latch = Latch->getSinglePredecessorBlock();
     if (Loop->isLoopExiting(Latch) && Latch->getSuccessors().size() == 2) {
       ExitingBlk = Latch;
       ExitBlk = Loop->contains(Latch->getSuccessors()[0])

lib/SILOptimizer/LoopTransforms/COWArrayOpt.cpp

@@ -1965,7 +1965,7 @@ class RegionCloner : public SILCloner<RegionCloner> {
     // inside the cloned region. The SSAUpdater can't handle critical non
     // cond_br edges.
     for (auto *BB : OutsideBBs) {
-      SmallVector<SILBasicBlock*, 8> Preds(BB->getPreds());
+      SmallVector<SILBasicBlock *, 8> Preds(BB->getPredecessorBlocks());
       for (auto *Pred : Preds)
         if (!isa<CondBranchInst>(Pred->getTerminator()) &&
             !isa<BranchInst>(Pred->getTerminator()))
@@ -2120,7 +2120,8 @@ class ArrayPropertiesSpecializer {
 
   SILLoop *getLoop() {
     auto *LoopInfo = LoopAnalysis->get(HoistableLoopPreheader->getParent());
-    return LoopInfo->getLoopFor(HoistableLoopPreheader->getSingleSuccessor());
+    return LoopInfo->getLoopFor(
+        HoistableLoopPreheader->getSingleSuccessorBlock());
   }
 
 protected:
@@ -2234,7 +2235,7 @@ void ArrayPropertiesSpecializer::specializeLoopNest() {
       HoistableLoopPreheader->getTerminator(), DomTree, nullptr);
 
   // Get the exit blocks of the original loop.
-  auto *Header = CheckBlock->getSingleSuccessor();
+  auto *Header = CheckBlock->getSingleSuccessorBlock();
   assert(Header);
 
   // Our loop info is not really completely valid anymore since the cloner does

lib/SILOptimizer/LoopTransforms/LoopRotate.cpp

@@ -233,10 +233,11 @@ static bool isSingleBlockLoop(SILLoop *L) {
   if (BackEdge == Header)
     BackEdge = Blocks[0];
 
-  if (!BackEdge->getSingleSuccessor())
+  if (!BackEdge->getSingleSuccessorBlock())
     return false;
 
-  assert(BackEdge->getSingleSuccessor() == Header && "Loop not well formed");
+  assert(BackEdge->getSingleSuccessorBlock() == Header &&
+         "Loop not well formed");
 
   // Check whether the back-edge block is just a split-edge.
   return ++BackEdge->begin() == BackEdge->end();
@@ -315,7 +316,7 @@ bool swift::rotateLoop(SILLoop *L, DominanceInfo *DT, SILLoopInfo *LI,
   // We don't want to rotate such that we merge two headers of separate loops
   // into one. This can be turned into an assert again once we have guaranteed
   // preheader insertions.
-  if (!NewHeader->getSinglePredecessor() && Header != Latch)
+  if (!NewHeader->getSinglePredecessorBlock() && Header != Latch)
     return false;
 
   // Now that we know we can perform the rotation - move the instructions that