SIL: use BasicBlockSet instead of SmallPtrSet in findJointPostDominatingSet

This allows putting the set as local variables into the function itself (where they are used) and removing them from JointPostDominanceSetComputer.

Author: eeckstein

include/swift/SIL/BasicBlockUtils.h

@@ -14,6 +14,7 @@
 #define SWIFT_SIL_BASICBLOCKUTILS_H
 
 #include "swift/SIL/SILValue.h"
+#include "swift/SIL/SILBitfield.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
@@ -98,13 +99,6 @@ struct JointPostDominanceSetComputer {
   /// The worklist that drives the algorithm.
   SmallVector<SILBasicBlock *, 32> worklist;
 
-  /// A set that guards our worklist. Any block before it is added to worklist
-  /// should be checked against visitedBlocks.
-  SmallPtrSet<SILBasicBlock *, 32> visitedBlocks;
-
-  /// The set of blocks where we begin our walk.
-  SmallPtrSet<SILBasicBlock *, 8> initialBlocks;
-
   /// A subset of our initial blocks that we found as a predecessor of another
   /// block along our walk.
   SmallVector<SILBasicBlock *, 8> reachableInputBlocks;
@@ -113,7 +107,7 @@ struct JointPostDominanceSetComputer {
   /// visited yet are placed in here. At the end of our worklist, any blocks
   /// that remain here are "leaking blocks" that together with our initial set
   /// would provide a jointly-postdominating set of our dominating value.
-  SmallSetVector<SILBasicBlock *, 8> blocksThatLeakIfNeverVisited;
+  SmallVector<SILBasicBlock *, 32> blocksThatLeakIfNeverVisited;
 
   DeadEndBlocks &deadEndBlocks;
 
@@ -122,8 +116,6 @@ struct JointPostDominanceSetComputer {
 
   void clear() {
     worklist.clear();
-    visitedBlocks.clear();
-    initialBlocks.clear();
     reachableInputBlocks.clear();
     blocksThatLeakIfNeverVisited.clear();
   }

lib/SIL/Utils/BasicBlockUtils.cpp

@@ -416,6 +416,17 @@ void JointPostDominanceSetComputer::findJointPostDominatingSet(
   // always clean up any resources that we use!
   SWIFT_DEFER { clear(); };
 
+  /// A set that guards our worklist. Any block before it is added to worklist
+  /// should be checked against visitedBlocks.
+  SILFunction *function = dominatingBlock->getParent();
+  BasicBlockSet visitedBlocks(function);
+
+  /// The set of blocks where we begin our walk.
+  BasicBlockSet initialBlocks(function);
+
+  /// True for blocks which are in blocksThatLeakIfNeverVisited.
+  BasicBlockFlag isLeakingBlock(function);
+
   // Otherwise, we need to compute our joint post dominating set. We do this by
   // performing a backwards walk up the CFG tracking back liveness until we find
   // our dominating block. As we walk up, we keep track of any successor blocks
@@ -429,7 +440,7 @@ void JointPostDominanceSetComputer::findJointPostDominatingSet(
 
     // We require dominatedBlockSet to be a set and thus assert if we hit it to
     // flag user error to our caller.
-    bool succeededInserting = visitedBlocks.insert(block).second;
+    bool succeededInserting = visitedBlocks.insert(block);
     (void)succeededInserting;
     assert(succeededInserting &&
            "Repeat Elt: dominatedBlockSet should be a set?!");
@@ -441,19 +452,16 @@ void JointPostDominanceSetComputer::findJointPostDominatingSet(
   while (!worklist.empty()) {
     auto *block = worklist.pop_back_val();
 
-    // First remove block from blocksThatLeakIfNeverVisited if it is there since
-    // we know that it isn't leaking since we are visiting it now.
-    blocksThatLeakIfNeverVisited.remove(block);
-
     // Then if our block is not one of our initial blocks, add the block's
     // successors to blocksThatLeakIfNeverVisited.
-    if (!initialBlocks.count(block)) {
+    if (!initialBlocks.contains(block)) {
       for (auto *succBlock : block->getSuccessorBlocks()) {
-        if (visitedBlocks.count(succBlock))
+        if (visitedBlocks.contains(succBlock))
           continue;
         if (deadEndBlocks.isDeadEnd(succBlock))
           continue;
-        blocksThatLeakIfNeverVisited.insert(succBlock);
+        blocksThatLeakIfNeverVisited.push_back(succBlock);
+        isLeakingBlock.set(succBlock);
       }
     }
 
@@ -465,25 +473,28 @@ void JointPostDominanceSetComputer::findJointPostDominatingSet(
     // our initial blocks (signaling a loop) and then add it to the worklist if
     // we haven't visited it already.
     for (auto *predBlock : block->getPredecessorBlocks()) {
-      if (initialBlocks.count(predBlock)) {
+      if (initialBlocks.contains(predBlock)) {
         reachableInputBlocks.push_back(predBlock);
         for (auto *succBlock : predBlock->getSuccessorBlocks()) {
-          if (visitedBlocks.count(succBlock))
+          if (visitedBlocks.contains(succBlock))
             continue;
           if (deadEndBlocks.isDeadEnd(succBlock))
             continue;
-          blocksThatLeakIfNeverVisited.insert(succBlock);
+          if (!isLeakingBlock.testAndSet(succBlock))
+            blocksThatLeakIfNeverVisited.push_back(succBlock);
         }
       }
-      if (visitedBlocks.insert(predBlock).second)
+      if (visitedBlocks.insert(predBlock))
         worklist.push_back(predBlock);
     }
   }
 
-  // After our worklist has emptied, any blocks left in
+  // After our worklist has emptied, any not visited blocks in
   // blocksThatLeakIfNeverVisited are "leaking blocks".
-  for (auto *leakingBlock : blocksThatLeakIfNeverVisited)
-    foundJointPostDomSetCompletionBlocks(leakingBlock);
+  for (auto *leakingBlock : blocksThatLeakIfNeverVisited) {
+    if (!visitedBlocks.contains(leakingBlock))
+      foundJointPostDomSetCompletionBlocks(leakingBlock);
+  }
 
   // Then unique our list of reachable input blocks and pass them to our
   // callback.