SIL: Use StackList in BasicBlockWorklist and BasicBlockSetVector

plus: I moved both data structures into a separate header file.

Author: eeckstein

include/swift/SIL/BasicBlockBits.h

@@ -14,8 +14,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef SWIFT_SIL_SILBITFIELD_H
-#define SWIFT_SIL_SILBITFIELD_H
+#ifndef SWIFT_SIL_BASICBLOCKBITS_H
+#define SWIFT_SIL_BASICBLOCKBITS_H
 
 #include "swift/SIL/SILFunction.h"
 #include "llvm/ADT/SmallVector.h"
@@ -173,101 +173,6 @@ class BasicBlockSet {
   void erase(SILBasicBlock *block) { flag.reset(block); }
 };
 
-/// An implementation of `llvm::SetVector<SILBasicBlock *,
-///                                       SmallVector<SILBasicBlock *, N>,
-///                                       BasicBlockSet>`.
-///
-/// Unfortunately it's not possible to use `llvm::SetVector` directly because
-/// the BasicBlockSet constructor needs a `SILFunction` argument.
-///
-/// Note: This class does not provide a `remove` method intentinally, because
-/// it would have a O(n) complexity.
-template <unsigned N> class BasicBlockSetVector {
-  using Vector = llvm::SmallVector<SILBasicBlock *, N>;
-
-  Vector vector;
-  BasicBlockSet set;
-  
-public:
-  using iterator = typename Vector::const_iterator;
-
-  BasicBlockSetVector(SILFunction *function) : set(function) {}
-
-  iterator begin() const { return vector.begin(); }
-  iterator end() const { return vector.end(); }
-
-  unsigned size() const { return vector.size(); }
-  bool empty() const { return vector.empty(); }
-
-  bool contains(SILBasicBlock *block) const { return set.contains(block); }
-
-  /// Returns true if \p block was not contained in the set before inserting.
-  bool insert(SILBasicBlock *block) {
-    if (set.insert(block)) {
-      vector.push_back(block);
-      return true;
-    }
-    return false;
-  }
-};
-
-/// A utility for processing basic blocks in a worklist.
-///
-/// It is basically a combination of a block vector and a block set. It can be
-/// used for typical worklist-processing algorithms.
-template <unsigned N> class BasicBlockWorklist {
-  llvm::SmallVector<SILBasicBlock *, N> worklist;
-  BasicBlockSet visited;
-  
-public:
-  /// Construct an empty worklist.
-  BasicBlockWorklist(SILFunction *function) : visited(function) {}
-
-  /// Initialize the worklist with \p initialBlock.
-  BasicBlockWorklist(SILBasicBlock *initialBlock)
-      : visited(initialBlock->getParent()) {
-    push(initialBlock);
-  }
-
-  /// Pops the last added element from the worklist or returns null, if the
-  /// worklist is empty.
-  SILBasicBlock *pop() {
-    if (worklist.empty())
-      return nullptr;
-    return worklist.pop_back_val();
-  }
-
-  /// Pushes \p block onto the worklist if \p block has never been push before.
-  bool pushIfNotVisited(SILBasicBlock *block) {
-    if (visited.insert(block)) {
-      worklist.push_back(block);
-      return true;
-    }
-    return false;
-  }
-
-  /// Like `pushIfNotVisited`, but requires that \p block has never been on the
-  /// worklist before.
-  void push(SILBasicBlock *block) {
-    assert(!visited.contains(block));
-    visited.insert(block);
-    worklist.push_back(block);
-  }
-
-  /// Like `pop`, but marks the returned block as "unvisited". This means, that
-  /// the block can be pushed onto the worklist again.
-  SILBasicBlock *popAndForget() {
-    if (worklist.empty())
-      return nullptr;
-    SILBasicBlock *block = worklist.pop_back_val();
-    visited.erase(block);
-    return block;
-  }
-
-  /// Returns true if \p block was visited, i.e. has been added to the worklist.
-  bool isVisited(SILBasicBlock *block) const { return visited.contains(block); }
-};
-
 } // namespace swift
 
 #endif

include/swift/SIL/BasicBlockDatastructures.h

@@ -0,0 +1,120 @@
+//===--- BasicBlockDatastructures.h -----------------------------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2021 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines efficient data structures for working with BasicBlocks.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_SIL_BASICBLOCKDATASTRUCTURES_H
+#define SWIFT_SIL_BASICBLOCKDATASTRUCTURES_H
+
+#include "swift/SIL/StackList.h"
+#include "swift/SIL/BasicBlockBits.h"
+
+namespace swift {
+
+/// An implementation of `llvm::SetVector<SILBasicBlock *,
+///                                       StackList<SILBasicBlock *>,
+///                                       BasicBlockSet>`.
+///
+/// Unfortunately it's not possible to use `llvm::SetVector` directly because
+/// the BasicBlockSet and StackList constructors needs a `SILFunction` argument.
+///
+/// Note: This class does not provide a `remove` method intentinally, because
+/// it would have a O(n) complexity.
+class BasicBlockSetVector {
+  StackList<SILBasicBlock *> vector;
+  BasicBlockSet set;
+  
+public:
+  using iterator = typename StackList<SILBasicBlock *>::iterator;
+
+  BasicBlockSetVector(SILFunction *function) : vector(function), set(function) {}
+
+  iterator begin() const { return vector.begin(); }
+  iterator end() const { return vector.end(); }
+
+  bool empty() const { return vector.empty(); }
+
+  bool contains(SILBasicBlock *block) const { return set.contains(block); }
+
+  /// Returns true if \p block was not contained in the set before inserting.
+  bool insert(SILBasicBlock *block) {
+    if (set.insert(block)) {
+      vector.push_back(block);
+      return true;
+    }
+    return false;
+  }
+};
+
+/// A utility for processing basic blocks in a worklist.
+///
+/// It is basically a combination of a block vector and a block set. It can be
+/// used for typical worklist-processing algorithms.
+class BasicBlockWorklist {
+  StackList<SILBasicBlock *> worklist;
+  BasicBlockSet visited;
+  
+public:
+  /// Construct an empty worklist.
+  BasicBlockWorklist(SILFunction *function)
+    : worklist(function), visited(function) {}
+
+  /// Initialize the worklist with \p initialBlock.
+  BasicBlockWorklist(SILBasicBlock *initialBlock)
+      : BasicBlockWorklist(initialBlock->getParent()) {
+    push(initialBlock);
+  }
+
+  /// Pops the last added element from the worklist or returns null, if the
+  /// worklist is empty.
+  SILBasicBlock *pop() {
+    if (worklist.empty())
+      return nullptr;
+    return worklist.pop_back_val();
+  }
+
+  /// Pushes \p block onto the worklist if \p block has never been push before.
+  bool pushIfNotVisited(SILBasicBlock *block) {
+    if (visited.insert(block)) {
+      worklist.push_back(block);
+      return true;
+    }
+    return false;
+  }
+
+  /// Like `pushIfNotVisited`, but requires that \p block has never been on the
+  /// worklist before.
+  void push(SILBasicBlock *block) {
+    assert(!visited.contains(block));
+    visited.insert(block);
+    worklist.push_back(block);
+  }
+
+  /// Like `pop`, but marks the returned block as "unvisited". This means, that
+  /// the block can be pushed onto the worklist again.
+  SILBasicBlock *popAndForget() {
+    if (worklist.empty())
+      return nullptr;
+    SILBasicBlock *block = worklist.pop_back_val();
+    visited.erase(block);
+    return block;
+  }
+
+  /// Returns true if \p block was visited, i.e. has been added to the worklist.
+  bool isVisited(SILBasicBlock *block) const { return visited.contains(block); }
+};
+
+} // namespace swift
+
+#endif

lib/IRGen/IRGenSIL.cpp

@@ -32,7 +32,7 @@
 #include "swift/SIL/InstructionUtils.h"
 #include "swift/SIL/MemAccessUtils.h"
 #include "swift/SIL/PrettyStackTrace.h"
-#include "swift/SIL/BasicBlockBits.h"
+#include "swift/SIL/BasicBlockDatastructures.h"
 #include "swift/SIL/SILDebugScope.h"
 #include "swift/SIL/SILDeclRef.h"
 #include "swift/SIL/SILLinkage.h"
@@ -2242,7 +2242,7 @@ void IRGenSILFunction::emitSILFunction() {
   // Invariant: for every block in the work queue, we have visited all
   // of its dominators.
   // Start with the entry block, for which the invariant trivially holds.
-  BasicBlockWorklist<32> workQueue(&*CurSILFn->getEntryBlock());
+  BasicBlockWorklist workQueue(&*CurSILFn->getEntryBlock());
 
   while (SILBasicBlock *bb = workQueue.pop()) {
     // Emit the block.

lib/SIL/Verifier/MemoryLifetimeVerifier.cpp

@@ -16,7 +16,7 @@
 #include "swift/SIL/SILBasicBlock.h"
 #include "swift/SIL/SILFunction.h"
 #include "swift/SIL/ApplySite.h"
-#include "swift/SIL/BasicBlockBits.h"
+#include "swift/SIL/BasicBlockDatastructures.h"
 #include "llvm/Support/CommandLine.h"
 
 using namespace swift;
@@ -148,7 +148,7 @@ bool MemoryLifetimeVerifier::isEnumTrivialAt(int locIdx,
   SILBasicBlock *startBlock = atInst->getParent();
 
   // Start at atInst an walk up the control flow.
-  BasicBlockWorklist<32> worklist(startBlock);
+  BasicBlockWorklist worklist(startBlock);
   while (SILBasicBlock *block = worklist.pop()) {
     auto start = (block == atInst->getParent() ? atInst->getReverseIterator()
                                                : block->rbegin());

lib/SILOptimizer/Mandatory/ClosureLifetimeFixup.cpp

@@ -18,7 +18,7 @@
 #include "swift/SIL/SILArgument.h"
 #include "swift/SIL/SILBuilder.h"
 #include "swift/SIL/SILInstruction.h"
-#include "swift/SIL/BasicBlockBits.h"
+#include "swift/SIL/BasicBlockDatastructures.h"
 #include "swift/SILOptimizer/PassManager/Passes.h"
 #include "swift/SILOptimizer/PassManager/Transforms.h"
 #include "swift/SILOptimizer/Utils/CFGOptUtils.h"
@@ -103,7 +103,7 @@ static SILInstruction *getDeinitSafeClosureDestructionPoint(SILBasicBlock *bb) {
 
 static void findReachableExitBlocks(SILInstruction *i,
                                     SmallVectorImpl<SILBasicBlock *> &result) {
-  BasicBlockWorklist<32> worklist(i->getParent());
+  BasicBlockWorklist worklist(i->getParent());
 
   while (SILBasicBlock *bb = worklist.pop()) {
     if (bb->getTerminator()->isFunctionExiting()) {

lib/SILOptimizer/Mandatory/DiagnoseUnreachable.cpp

@@ -23,7 +23,7 @@
 #include "swift/SIL/SILBuilder.h"
 #include "swift/SIL/SILUndef.h"
 #include "swift/SIL/TerminatorUtils.h"
-#include "swift/SIL/BasicBlockBits.h"
+#include "swift/SIL/BasicBlockDatastructures.h"
 #include "swift/SILOptimizer/PassManager/Passes.h"
 #include "swift/SILOptimizer/PassManager/Transforms.h"
 #include "swift/SILOptimizer/Utils/BasicBlockOptUtils.h"
@@ -84,7 +84,7 @@ class UnreachableUserCodeReportingState {
   ///
   /// This is a SetVector since several blocks may lead to the same error
   /// report and we iterate through these when producing the diagnostic.
-  BasicBlockSetVector<16> PossiblyUnreachableBlocks;
+  BasicBlockSetVector PossiblyUnreachableBlocks;
 
   /// The set of blocks in which we reported unreachable code errors.
   /// These are used to ensure that we don't issue duplicate reports.

lib/SILOptimizer/Mandatory/MandatoryCombine.cpp

@@ -31,7 +31,7 @@
 #include "swift/SIL/BasicBlockUtils.h"
 #include "swift/SIL/SILInstructionWorklist.h"
 #include "swift/SIL/SILVisitor.h"
-#include "swift/SIL/BasicBlockBits.h"
+#include "swift/SIL/BasicBlockDatastructures.h"
 #include "swift/SILOptimizer/PassManager/Passes.h"
 #include "swift/SILOptimizer/PassManager/Transforms.h"
 #include "swift/SILOptimizer/Utils/CanonicalizeInstruction.h"
@@ -206,7 +206,7 @@ static llvm::cl::opt<bool> EnableCanonicalizationAndTrivialDCE(
                    "dead code and canonicalizing SIL"));
 
 void MandatoryCombiner::addReachableCodeToWorklist(SILFunction &function) {
-  BasicBlockWorklist<32> blockWorklist(function.getEntryBlock());
+  BasicBlockWorklist blockWorklist(function.getEntryBlock());
   SmallVector<SILInstruction *, 128> initialInstructionWorklist;
 
   while (SILBasicBlock *block = blockWorklist.pop()) {

lib/SILOptimizer/SILCombiner/SILCombine.cpp

@@ -24,7 +24,7 @@
 #include "swift/SIL/DebugUtils.h"
 #include "swift/SIL/SILBuilder.h"
 #include "swift/SIL/SILVisitor.h"
-#include "swift/SIL/BasicBlockBits.h"
+#include "swift/SIL/BasicBlockDatastructures.h"
 #include "swift/SILOptimizer/Analysis/AliasAnalysis.h"
 #include "swift/SILOptimizer/Analysis/SimplifyInstruction.h"
 #include "swift/SILOptimizer/PassManager/Passes.h"
@@ -67,7 +67,7 @@ static llvm::cl::opt<bool> EnableSILCombineCanonicalize(
 /// worklist (this significantly speeds up SILCombine on code where many
 /// instructions are dead or constant).
 void SILCombiner::addReachableCodeToWorklist(SILBasicBlock *BB) {
-  BasicBlockWorklist<256> Worklist(BB);
+  BasicBlockWorklist Worklist(BB);
   llvm::SmallVector<SILInstruction *, 128> InstrsForSILCombineWorklist;
 
   while (SILBasicBlock *BB = Worklist.pop()) {

lib/SILOptimizer/Transforms/ARCCodeMotion.cpp

@@ -72,7 +72,7 @@
 #define DEBUG_TYPE "sil-rr-code-motion"
 #include "swift/SIL/InstructionUtils.h"
 #include "swift/SIL/SILBuilder.h"
-#include "swift/SIL/BasicBlockBits.h"
+#include "swift/SIL/BasicBlockDatastructures.h"
 #include "swift/SIL/BasicBlockData.h"
 #include "swift/SILOptimizer/Analysis/ARCAnalysis.h"
 #include "swift/SILOptimizer/Analysis/AliasAnalysis.h"
@@ -554,7 +554,7 @@ 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. 
-  BasicBlockWorklist<16> WorkList(BlockStates.getFunction());
+  BasicBlockWorklist 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()) {
@@ -966,7 +966,7 @@ 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.
-  BasicBlockWorklist<16> WorkList(BlockStates.getFunction());
+  BasicBlockWorklist 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()) {