Use the new BasicBlockWorklist utility in various places in the compiler.

It's a refactoring which simplifies the code.
NFC.

Author: eeckstein

lib/IRGen/IRGenSIL.cpp

@@ -2017,16 +2017,10 @@ void IRGenSILFunction::emitSILFunction() {
 
   // Invariant: for every block in the work queue, we have visited all
   // of its dominators.
-  BasicBlockSet visitedBlocks(CurSILFn);
-  SmallVector<SILBasicBlock*, 8> workQueue; // really a stack
-
-  // Queue up the entry block, for which the invariant trivially holds.
-  visitedBlocks.insert(&*CurSILFn->begin());
-  workQueue.push_back(&*CurSILFn->begin());
-
-  while (!workQueue.empty()) {
-    auto bb = workQueue.pop_back_val();
+  // Start with the entry block, for which the invariant trivially holds.
+  BasicBlockWorklist<32> workQueue(&*CurSILFn->getEntryBlock());
 
+  while (SILBasicBlock *bb = workQueue.pop()) {
     // Emit the block.
     visitSILBasicBlock(bb);
 
@@ -2052,15 +2046,14 @@ void IRGenSILFunction::emitSILFunction() {
     // Therefore the invariant holds of all the successors, and we can
     // queue them up if we haven't already visited them.
     for (auto *succBB : bb->getSuccessorBlocks()) {
-      if (visitedBlocks.insert(succBB))
-        workQueue.push_back(succBB);
+      workQueue.pushIfNotVisited(succBB);
     }
   }
 
   // If there are dead blocks in the SIL function, we might have left
   // invalid blocks in the IR.  Do another pass and kill them off.
   for (SILBasicBlock &bb : *CurSILFn)
-    if (!visitedBlocks.contains(&bb))
+    if (!workQueue.isVisited(&bb))
       LoweredBBs[&bb].bb->eraseFromParent();
 
 }

lib/SILOptimizer/Mandatory/ClosureLifetimeFixup.cpp

@@ -103,22 +103,16 @@ static SILInstruction *getDeinitSafeClosureDestructionPoint(SILBasicBlock *bb) {
 
 static void findReachableExitBlocks(SILInstruction *i,
                                     SmallVectorImpl<SILBasicBlock *> &result) {
-  SmallVector<SILBasicBlock *, 32> worklist;
-  BasicBlockSet visitedBlocks(i->getFunction());
+  BasicBlockWorklist<32> worklist(i->getParent());
 
-  visitedBlocks.insert(i->getParent());
-  worklist.push_back(i->getParent());
-
-  while (!worklist.empty()) {
-    auto *bb = worklist.pop_back_val();
+  while (SILBasicBlock *bb = worklist.pop()) {
     if (bb->getTerminator()->isFunctionExiting()) {
       result.push_back(bb);
       continue;
     }
-    llvm::copy_if(bb->getSuccessorBlocks(), std::back_inserter(worklist),
-                  [&](SILBasicBlock *bb) {
-      return visitedBlocks.insert(bb);
-    });
+    for (SILBasicBlock *succ : bb->getSuccessors()) {
+      worklist.pushIfNotVisited(succ);
+    }
   }
 }
 

lib/SILOptimizer/Mandatory/MandatoryCombine.cpp

@@ -206,19 +206,10 @@ static llvm::cl::opt<bool> EnableCanonicalizationAndTrivialDCE(
                    "dead code and canonicalizing SIL"));
 
 void MandatoryCombiner::addReachableCodeToWorklist(SILFunction &function) {
-  SmallVector<SILBasicBlock *, 32> blockWorklist;
-  BasicBlockSet blockAlreadyAddedToWorklist(&function);
+  BasicBlockWorklist<32> blockWorklist(function.getEntryBlock());
   SmallVector<SILInstruction *, 128> initialInstructionWorklist;
 
-  {
-    auto *firstBlock = &*function.begin();
-    blockWorklist.push_back(firstBlock);
-    blockAlreadyAddedToWorklist.insert(firstBlock);
-  }
-
-  while (!blockWorklist.empty()) {
-    auto *block = blockWorklist.pop_back_val();
-
+  while (SILBasicBlock *block = blockWorklist.pop()) {
     for (auto iterator = block->begin(), end = block->end(); iterator != end;) {
       auto *instruction = &*iterator;
       ++iterator;
@@ -236,11 +227,9 @@ void MandatoryCombiner::addReachableCodeToWorklist(SILFunction &function) {
       initialInstructionWorklist.push_back(instruction);
     }
 
-    llvm::copy_if(block->getSuccessorBlocks(),
-                  std::back_inserter(blockWorklist),
-                  [&](SILBasicBlock *block) -> bool {
-                    return blockAlreadyAddedToWorklist.insert(block);
-                  });
+    for (SILBasicBlock *succ : block->getSuccessors()) {
+      blockWorklist.pushIfNotVisited(succ);
+    }
   }
 
   worklist.addInitialGroup(initialInstructionWorklist);

lib/SILOptimizer/SILCombiner/SILCombine.cpp

@@ -61,17 +61,10 @@ static llvm::cl::opt<bool> EnableSinkingOwnedForwardingInstToUses(
 /// worklist (this significantly speeds up SILCombine on code where many
 /// instructions are dead or constant).
 void SILCombiner::addReachableCodeToWorklist(SILBasicBlock *BB) {
-  llvm::SmallVector<SILBasicBlock *, 256> Worklist;
+  BasicBlockWorklist<256> Worklist(BB);
   llvm::SmallVector<SILInstruction *, 128> InstrsForSILCombineWorklist;
-  BasicBlockSet Visited(BB->getParent());
-
-  Worklist.push_back(BB);
-  do {
-    BB = Worklist.pop_back_val();
-
-    // We have now visited this block!  If we've already been here, ignore it.
-    if (!Visited.insert(BB)) continue;
 
+  while (SILBasicBlock *BB = Worklist.pop()) {
     for (SILBasicBlock::iterator BBI = BB->begin(), E = BB->end(); BBI != E; ) {
       SILInstruction *Inst = &*BBI;
       ++BBI;
@@ -98,9 +91,10 @@ void SILCombiner::addReachableCodeToWorklist(SILBasicBlock *BB) {
     }
 
     // Recursively visit successors.
-    for (auto SI = BB->succ_begin(), SE = BB->succ_end(); SI != SE; ++SI)
-      Worklist.push_back(*SI);
-  } while (!Worklist.empty());
+    for (SILBasicBlock *Succ : BB->getSuccessors()) {
+      Worklist.pushIfNotVisited(Succ);
+    }
+  }
 
   // Once we've found all of the instructions to add to the worklist, add them
   // in reverse order. This way SILCombine will visit from the top of the

lib/SILOptimizer/Transforms/ARCCodeMotion.cpp

@@ -554,24 +554,16 @@ void RetainCodeMotionContext::convergeCodeMotionDataFlow() {
   // Process each basic block with the genset and killset. Every time the
   // BBSetOut of a basic block changes, the optimization is rerun on its
   // successors. 
-  llvm::SmallVector<SILBasicBlock *, 16> WorkList;
-  BasicBlockSet HandledBBs(BlockStates.getFunction());
+  BasicBlockWorklist<16> WorkList(BlockStates.getFunction());
   // Push into reverse post order so that we can pop from the back and get
   // post order.
   for (SILBasicBlock *B : PO->getReversePostOrder()) {
-    WorkList.push_back(B);
-    HandledBBs.insert(B);
+    WorkList.push(B);
   }
-  while (!WorkList.empty()) {
-    SILBasicBlock *BB = WorkList.pop_back_val();
-    HandledBBs.erase(BB);
+  while (SILBasicBlock *BB = WorkList.popAndForget()) {
     if (processBBWithGenKillSet(BB)) {
       for (SILBasicBlock *succ : BB->getSuccessors()) {
-        // We do not push basic block into the worklist if its already 
-        // in the worklist.
-        if (HandledBBs.contains(succ))
-          continue;
-        WorkList.push_back(succ);
+        WorkList.pushIfNotVisited(succ);
       }
     }
   }
@@ -974,24 +966,16 @@ void ReleaseCodeMotionContext::convergeCodeMotionDataFlow() {
   // Process each basic block with the gen and kill set. Every time the
   // BBSetIn of a basic block changes, the optimization is rerun on its
   // predecessors.
-  llvm::SmallVector<SILBasicBlock *, 16> WorkList;
-  BasicBlockSet HandledBBs(BlockStates.getFunction());
+  BasicBlockWorklist<16> WorkList(BlockStates.getFunction());
   // Push into reverse post order so that we can pop from the back and get
   // post order.
   for (SILBasicBlock *B : PO->getPostOrder()) {
-    WorkList.push_back(B);
-    HandledBBs.insert(B);
+    WorkList.push(B);
   }
-  while (!WorkList.empty()) {
-    SILBasicBlock *BB = WorkList.pop_back_val();
-    HandledBBs.erase(BB);
+  while (SILBasicBlock *BB = WorkList.popAndForget()) {
     if (processBBWithGenKillSet(BB)) {
       for (auto X : BB->getPredecessorBlocks()) {
-        // We do not push basic block into the worklist if its already 
-        // in the worklist.
-        if (HandledBBs.contains(X))
-          continue;
-        WorkList.push_back(X);
+        WorkList.pushIfNotVisited(X);
       }
     }
   }

lib/SILOptimizer/Transforms/DeadStoreElimination.cpp

@@ -1165,24 +1165,16 @@ void DSEContext::runIterativeDSE() {
   // Process each basic block with the gen and kill set. Every time the
   // BBWriteSetIn of a basic block changes, the optimization is rerun on its
   // predecessors.
-  llvm::SmallVector<SILBasicBlock *, 16> WorkList;
-  BasicBlockSet HandledBBs(F);
+  BasicBlockWorklist<16> WorkList(F);
   // Push into reverse post order so that we can pop from the back and get
   // post order.
   for (SILBasicBlock *B : PO->getReversePostOrder()) {
-    WorkList.push_back(B);
-    HandledBBs.insert(B);
+    WorkList.push(B);
   }
-  while (!WorkList.empty()) {
-    SILBasicBlock *BB = WorkList.pop_back_val();
-    HandledBBs.erase(BB);
+  while (SILBasicBlock *BB = WorkList.popAndForget()) {
     if (processBasicBlockWithGenKillSet(BB)) {
       for (SILBasicBlock *pred : BB->getPredecessorBlocks()) {
-        // We do not push basic block into the worklist if its already 
-        // in the worklist.
-        if (HandledBBs.contains(pred))
-          continue;
-        WorkList.push_back(pred);
+        WorkList.pushIfNotVisited(pred);
       }
     }
   }

lib/SILOptimizer/Transforms/Outliner.cpp

@@ -1234,18 +1234,12 @@ class OutlinePatterns {
 /// functions.
 bool tryOutline(SILOptFunctionBuilder &FuncBuilder, SILFunction *Fun,
                 SmallVectorImpl<SILFunction *> &FunctionsAdded) {
-  BasicBlockSet Visited(Fun);
-  SmallVector<SILBasicBlock *, 128> Worklist;
+  BasicBlockWorklist<128> Worklist(Fun->getEntryBlock());
   OutlinePatterns patterns(FuncBuilder);
   bool changed = false;
 
   // Traverse the function.
-  Worklist.push_back(&*Fun->begin());
-  while (!Worklist.empty()) {
-
-    SILBasicBlock *CurBlock = Worklist.pop_back_val();
-    if (!Visited.insert(CurBlock)) continue;
-
+  while (SILBasicBlock *CurBlock = Worklist.pop()) {
     SILBasicBlock::iterator CurInst = CurBlock->begin();
 
     // Go over the instructions trying to match and replace patterns.
@@ -1260,8 +1254,9 @@ bool tryOutline(SILOptFunctionBuilder &FuncBuilder, SILFunction *Fun,
          assert(LastInst->getParent() == CurBlock);
          changed = true;
        } else if (isa<TermInst>(CurInst)) {
-         std::copy(CurBlock->succ_begin(), CurBlock->succ_end(),
-                   std::back_inserter(Worklist));
+         for (SILBasicBlock *succ : CurBlock->getSuccessors()) {
+           Worklist.pushIfNotVisited(succ);
+         }
          ++CurInst;
        } else {
          ++CurInst;

lib/SILOptimizer/Transforms/RedundantLoadElimination.cpp

@@ -1280,21 +1280,16 @@ BlockState::ValueState BlockState::getValueStateAtEndOfBlock(RLEContext &Ctx,
 SILValue RLEContext::computePredecessorLocationValue(SILBasicBlock *BB,
                                                      LSLocation &L) {
   llvm::SmallVector<std::pair<SILBasicBlock *, SILValue>, 8> Values;
-  BasicBlockSet HandledBBs(Fn);
-  llvm::SmallVector<SILBasicBlock *, 8> WorkList;
+  BasicBlockWorklist<16> WorkList(Fn);
 
   // Push in all the predecessors to get started.
   for (auto Pred : BB->getPredecessorBlocks()) {
-    WorkList.push_back(Pred);
+    WorkList.pushIfNotVisited(Pred);
   }
 
-  while (!WorkList.empty()) {
-    auto *CurBB = WorkList.pop_back_val();
+  while (SILBasicBlock *CurBB = WorkList.pop()) {
     BlockState &Forwarder = getBlockState(CurBB);
 
-    // Mark this basic block as processed.
-    HandledBBs.insert(CurBB);
-
     // There are 3 cases that can happen here.
     //
     // 1. The current basic block contains concrete values for the entire
@@ -1316,9 +1311,7 @@ SILValue RLEContext::computePredecessorLocationValue(SILBasicBlock *BB,
     // locations, collect in this block's predecessors.
     if (Forwarder.isCoverValues(*this, L)) {
       for (auto Pred : CurBB->getPredecessorBlocks()) {
-        if (HandledBBs.contains(Pred))
-          continue;
-        WorkList.push_back(Pred);
+        WorkList.pushIfNotVisited(Pred);
       }
       continue;
     }
@@ -1450,33 +1443,24 @@ void RLEContext::processBasicBlocksWithGenKillSet() {
   // Process each basic block with the gen and kill set. Every time the
   // ForwardSetOut of a basic block changes, the optimization is rerun on its
   // successors.
-  llvm::SmallVector<SILBasicBlock *, 16> WorkList;
-  BasicBlockSet HandledBBs(Fn);
+  BasicBlockWorklist<16> WorkList(Fn);
 
   // Push into the worklist in post order so that we can pop from the back and
   // get reverse post order.
   for (SILBasicBlock *BB : PO->getPostOrder()) {
-    WorkList.push_back(BB);
-    HandledBBs.insert(BB);
+    WorkList.push(BB);
   }
-  while (!WorkList.empty()) {
-    SILBasicBlock *BB = WorkList.pop_back_val();
+  while (SILBasicBlock *BB = WorkList.popAndForget()) {
     LLVM_DEBUG(llvm::dbgs() << "PROCESS " << printCtx.getID(BB)
                             << " with Gen/Kill.\n");
-    HandledBBs.erase(BB);
-
     // Intersection.
     BlockState &Forwarder = getBlockState(BB);
     // Compute the ForwardSetIn at the beginning of the basic block.
     Forwarder.mergePredecessorAvailSet(*this);
 
     if (Forwarder.processBasicBlockWithGenKillSet()) {
       for (SILBasicBlock *succ : BB->getSuccessors()) {
-        // We do not push basic block into the worklist if its already
-        // in the worklist.
-        if (HandledBBs.contains(succ))
-          continue;
-        WorkList.push_back(succ);
+        WorkList.pushIfNotVisited(succ);
       }
     }
     LLVM_DEBUG(Forwarder.dump(*this));

lib/SILOptimizer/Transforms/SimplifyCFG.cpp

@@ -1262,23 +1262,15 @@ TrampolineDest::TrampolineDest(SILBasicBlock *sourceBB,
 #ifndef NDEBUG
 /// Is the block reachable from the entry.
 static bool isReachable(SILBasicBlock *Block) {
-  BasicBlockSet Visited(Block->getParent());
-  llvm::SmallVector<SILBasicBlock *, 16> Worklist;
-  SILBasicBlock *EntryBB = &*Block->getParent()->begin();
-  Worklist.push_back(EntryBB);
-  Visited.insert(EntryBB);
-
-  while (!Worklist.empty()) {
-    auto *CurBB = Worklist.back();
-    Worklist.pop_back();
+  BasicBlockWorklist<16> Worklist(Block->getParent()->getEntryBlock());
 
+  while (SILBasicBlock *CurBB = Worklist.pop()) {
     if (CurBB == Block)
       return true;
 
-    for (auto &Succ : CurBB->getSuccessors())
-      // Second is true if the insertion took place.
-      if (Visited.insert(Succ))
-        Worklist.push_back(Succ);
+    for (SILBasicBlock *Succ : CurBB->getSuccessors()) {
+      Worklist.pushIfNotVisited(Succ);
+    }
   }
 
   return false;