SILOptimizer: use BasicBlockSet instead of SmallPtrSet in various transformations.

It reduces compile time.

Author: eeckstein

lib/SIL/Verifier/SILVerifier.cpp

@@ -33,6 +33,7 @@
 #include "swift/SIL/OwnershipUtils.h"
 #include "swift/SIL/PostOrder.h"
 #include "swift/SIL/PrettyStackTrace.h"
+#include "swift/SIL/SILBitfield.h"
 #include "swift/SIL/SILDebugScope.h"
 #include "swift/SIL/SILFunction.h"
 #include "swift/SIL/SILModule.h"
@@ -5110,7 +5111,7 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
   }
 
   bool isUnreachableAlongAllPathsStartingAt(
-      SILBasicBlock *StartBlock, SmallPtrSetImpl<SILBasicBlock *> &Visited) {
+      SILBasicBlock *StartBlock, BasicBlockSet &Visited) {
     if (isa<UnreachableInst>(StartBlock->getTerminator()))
       return true;
     else if (isa<ReturnInst>(StartBlock->getTerminator()))
@@ -5120,7 +5121,7 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
 
     // Recursively check all successors.
     for (auto *SuccBB : StartBlock->getSuccessorBlocks())
-      if (!Visited.insert(SuccBB).second)
+      if (!Visited.insert(SuccBB))
         if (!isUnreachableAlongAllPathsStartingAt(SuccBB, Visited))
           return false;
 
@@ -5304,7 +5305,7 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
             // this successor bb.  (FIXME: Why? Infinite loops should still
             // preserve consistency...)
             auto isUnreachable = [&] {
-              SmallPtrSet<SILBasicBlock *, 16> visited;
+              BasicBlockSet visited(F);
               return isUnreachableAlongAllPathsStartingAt(succBB, visited);
             };
 
@@ -5471,7 +5472,7 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
     // This ensures that any open_existential instructions, which
     // open archetypes, are seen before the uses of these archetypes.
     llvm::ReversePostOrderTraversal<SILFunction *> RPOT(F);
-    llvm::DenseSet<SILBasicBlock *> VisitedBBs;
+    BasicBlockSet VisitedBBs(F);
     for (auto Iter = RPOT.begin(), E = RPOT.end(); Iter != E; ++Iter) {
       auto *BB = *Iter;
       VisitedBBs.insert(BB);
@@ -5481,7 +5482,7 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
     // Visit all basic blocks that were not visited during the RPOT traversal,
     // e.g. unreachable basic blocks.
     for (auto &BB : *F) {
-      if (VisitedBBs.count(&BB))
+      if (VisitedBBs.contains(&BB))
         continue;
       visitSILBasicBlock(&BB);
     }

lib/SILOptimizer/LoopTransforms/ArrayPropertyOpt.cpp

@@ -62,6 +62,7 @@
 #include "swift/SIL/InstructionUtils.h"
 #include "swift/SIL/Projection.h"
 #include "swift/SIL/LoopInfo.h"
+#include "swift/SIL/SILBitfield.h"
 #include "swift/SIL/SILCloner.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/Support/CommandLine.h"
@@ -86,18 +87,20 @@ class ArrayPropertiesAnalysis {
   llvm::DenseMap<SILFunction *, uint32_t> InstCountCache;
   llvm::SmallSet<SILValue, 16> HoistableArray;
 
-  SmallPtrSet<SILBasicBlock *, 16> ReachingBlocks;
-  SmallPtrSet<SILBasicBlock *, 16> CachedExitingBlocks;
+  BasicBlockSet ReachingBlocks;
+  SmallVector<SILBasicBlock *, 16> CachedExitingBlocks;
 
   // This controls the max instructions the analysis can scan before giving up
   const uint32_t AnalysisThreshold = 5000;
   // This controls the max threshold for instruction count in the loop
   const uint32_t LoopInstCountThreshold = 500;
 
+  bool reachingBlocksComputed = false;
+
 public:
   ArrayPropertiesAnalysis(SILLoop *L, DominanceAnalysis *DA)
       : Fun(L->getHeader()->getParent()), Loop(L), Preheader(nullptr),
-        DomTree(DA->get(Fun)) {}
+        DomTree(DA->get(Fun)), ReachingBlocks(Fun) {}
 
   /// Check if it is profitable to specialize a loop when you see an apply
   /// instruction. We consider it is not profitable to specialize the loop when:
@@ -239,18 +242,19 @@ class ArrayPropertiesAnalysis {
     return V;
   }
 
-  SmallPtrSetImpl<SILBasicBlock *> &getReachingBlocks() {
-    if (ReachingBlocks.empty()) {
+  BasicBlockSet &getReachingBlocks() {
+    if (!reachingBlocksComputed) {
       SmallVector<SILBasicBlock *, 8> Worklist;
       ReachingBlocks.insert(Preheader);
       Worklist.push_back(Preheader);
       while (!Worklist.empty()) {
         SILBasicBlock *BB = Worklist.pop_back_val();
         for (auto PI = BB->pred_begin(), PE = BB->pred_end(); PI != PE; ++PI) {
-          if (ReachingBlocks.insert(*PI).second)
+          if (ReachingBlocks.insert(*PI))
             Worklist.push_back(*PI);
         }
       }
+      reachingBlocksComputed = true;
     }
     return ReachingBlocks;
   }
@@ -279,7 +283,7 @@ class ArrayPropertiesAnalysis {
 
         // Check if this escape can reach the current loop.
         if (!Loop->contains(UseInst->getParent()) &&
-            !getReachingBlocks().count(UseInst->getParent())) {
+            !getReachingBlocks().contains(UseInst->getParent())) {
           continue;
         }
         LLVM_DEBUG(llvm::dbgs()
@@ -356,12 +360,10 @@ class ArrayPropertiesAnalysis {
     return false;
   }
 
-  SmallPtrSetImpl<SILBasicBlock *> &getLoopExitingBlocks() {
+  SmallVectorImpl<SILBasicBlock *> &getLoopExitingBlocks() {
     if (!CachedExitingBlocks.empty())
       return CachedExitingBlocks;
-    SmallVector<SILBasicBlock *, 16> ExitingBlocks;
-    Loop->getExitingBlocks(ExitingBlocks);
-    CachedExitingBlocks.insert(ExitingBlocks.begin(), ExitingBlocks.end());
+    Loop->getExitingBlocks(CachedExitingBlocks);
     return CachedExitingBlocks;
   }
 

lib/SILOptimizer/LoopTransforms/COWArrayOpt.cpp

@@ -25,6 +25,7 @@
 #include "swift/SIL/SILArgument.h"
 #include "swift/SIL/SILBuilder.h"
 #include "swift/SIL/SILInstruction.h"
+#include "swift/SIL/SILBitfield.h"
 #include "swift/SILOptimizer/Analysis/ARCAnalysis.h"
 #include "swift/SILOptimizer/Analysis/AliasAnalysis.h"
 #include "swift/SILOptimizer/Analysis/ArraySemantic.h"
@@ -116,7 +117,9 @@ class COWArrayOpt {
   std::pair<bool, bool> CachedSafeLoop;
 
   // Set of all blocks that may reach the loop, not including loop blocks.
-  llvm::SmallPtrSet<SILBasicBlock*,32> ReachingBlocks;
+  BasicBlockSet ReachingBlocks;
+
+  bool reachingBlocksComputed = false;
 
   /// Transient per-Array user set.
   ///
@@ -152,13 +155,13 @@ class COWArrayOpt {
   COWArrayOpt(RCIdentityFunctionInfo *RCIA, SILLoop *L, DominanceAnalysis *DA)
       : RCIA(RCIA), Function(L->getHeader()->getParent()), Loop(L),
         Preheader(L->getLoopPreheader()), DomTree(DA->get(Function)),
-        ColdBlocks(DA), CachedSafeLoop(false, false) {}
+        ColdBlocks(DA), CachedSafeLoop(false, false), ReachingBlocks(Function) {}
 
   bool run();
 
 private:
   bool checkUniqueArrayContainer(SILValue ArrayContainer);
-  SmallPtrSetImpl<SILBasicBlock*> &getReachingBlocks();
+  BasicBlockSet &getReachingBlocks();
   bool isRetainReleasedBeforeMutate(SILInstruction *RetainInst,
                                     bool IsUniquelyIdentifiedArray = true);
   bool checkSafeArrayAddressUses(UserList &AddressUsers);
@@ -268,18 +271,19 @@ bool COWArrayOpt::checkUniqueArrayContainer(SILValue ArrayContainer) {
 }
 
 /// Lazily compute blocks that may reach the loop.
-SmallPtrSetImpl<SILBasicBlock*> &COWArrayOpt::getReachingBlocks() {
-  if (ReachingBlocks.empty()) {
+BasicBlockSet &COWArrayOpt::getReachingBlocks() {
+  if (!reachingBlocksComputed) {
     SmallVector<SILBasicBlock*, 8> Worklist;
     ReachingBlocks.insert(Preheader);
     Worklist.push_back(Preheader);
     while (!Worklist.empty()) {
       SILBasicBlock *BB = Worklist.pop_back_val();
       for (auto PI = BB->pred_begin(), PE = BB->pred_end(); PI != PE; ++PI) {
-        if (ReachingBlocks.insert(*PI).second)
+        if (ReachingBlocks.insert(*PI))
           Worklist.push_back(*PI);
       }
     }
+    reachingBlocksComputed = true;
   }
   return ReachingBlocks;
 }
@@ -404,7 +408,7 @@ bool COWArrayOpt::checkSafeArrayAddressUses(UserList &AddressUsers) {
 
       // Check of this escape can reach the current loop.
       if (!Loop->contains(UseInst->getParent()) &&
-          !getReachingBlocks().count(UseInst->getParent())) {
+          !getReachingBlocks().contains(UseInst->getParent())) {
         continue;
       }
 

lib/SILOptimizer/LoopTransforms/LICM.cpp

@@ -19,6 +19,7 @@
 #include "swift/SIL/SILArgument.h"
 #include "swift/SIL/SILBuilder.h"
 #include "swift/SIL/SILInstruction.h"
+#include "swift/SIL/SILBitfield.h"
 #include "swift/SILOptimizer/Analysis/AccessedStorageAnalysis.h"
 #include "swift/SILOptimizer/Analysis/AliasAnalysis.h"
 #include "swift/SILOptimizer/Analysis/Analysis.h"
@@ -1195,7 +1196,7 @@ static bool
 storesCommonlyDominateLoopExits(AccessPath accessPath,
                                 SILLoop *loop,
                                 ArrayRef<SILBasicBlock *> exitingBlocks) {
-  SmallPtrSet<SILBasicBlock *, 16> stores;
+  BasicBlockSet stores(loop->getHeader()->getParent());
   SmallVector<Operand *, 8> uses;
   // Collect as many recognizable stores as possible. It's ok if not all stores
   // are collected.
@@ -1208,7 +1209,7 @@ storesCommonlyDominateLoopExits(AccessPath accessPath,
   SILBasicBlock *header = loop->getHeader();
   // If a store is in the loop header, we already know that it's dominating all
   // loop exits.
-  if (stores.count(header) != 0)
+  if (stores.contains(header))
     return true;
 
   // Also a store in the pre-header dominates all exists. Although the situation
@@ -1243,21 +1244,21 @@ storesCommonlyDominateLoopExits(AccessPath accessPath,
   //   exit:
   //     store %phi to %addr
   //
-  if (stores.count(loop->getLoopPreheader()) != 0)
+  if (stores.contains(loop->getLoopPreheader()))
     return true;
 
   // Propagate the store-is-not-alive flag through the control flow in the loop,
   // starting at the header.
-  SmallPtrSet<SILBasicBlock *, 16> storesNotAlive;
+  BasicBlockSet storesNotAlive(loop->getHeader()->getParent());
   storesNotAlive.insert(header);
   bool changed = false;
   do {
     changed = false;
     for (SILBasicBlock *block : loop->blocks()) {
-      bool storeAlive = (storesNotAlive.count(block) == 0);
-      if (storeAlive && stores.count(block) == 0 &&
+      bool storeAlive = !storesNotAlive.contains(block);
+      if (storeAlive && !stores.contains(block) &&
           std::any_of(block->pred_begin(), block->pred_end(),
-            [&](SILBasicBlock *b) { return storesNotAlive.count(b) != 0; })) {
+            [&](SILBasicBlock *b) { return storesNotAlive.contains(b); })) {
         storesNotAlive.insert(block);
         changed = true;
       }
@@ -1272,7 +1273,7 @@ storesCommonlyDominateLoopExits(AccessPath accessPath,
   for (SILBasicBlock *eb : exitingBlocks) {
     // Ignore loop exits to blocks which end in an unreachable.
     if (!std::any_of(eb->succ_begin(), eb->succ_end(), isUnreachableBlock) &&
-        storesNotAlive.count(eb) != 0) {
+        storesNotAlive.contains(eb)) {
       return false;
     }
   }

lib/SILOptimizer/Mandatory/AccessEnforcementSelection.cpp

@@ -37,6 +37,7 @@
 #include "swift/SIL/SILFunction.h"
 #include "swift/SIL/SILUndef.h"
 #include "swift/SIL/InstructionUtils.h"
+#include "swift/SIL/SILBitfield.h"
 #include "swift/SILOptimizer/Analysis/ClosureScope.h"
 #include "swift/SILOptimizer/Analysis/PostOrderAnalysis.h"
 #include "swift/SILOptimizer/PassManager/Transforms.h"
@@ -402,7 +403,7 @@ bool SelectEnforcement::hasPotentiallyEscapedAtAnyReachableBlock(
   BeginAccessInst *access, BlockSetVector &blocksAccessedAcross) {
 
   assert(Worklist.empty());
-  SmallPtrSet<SILBasicBlock*, 8> visited;
+  BasicBlockSet visited(access->getFunction());
 
   // Don't follow any paths that lead to an end_access.
   for (auto endAccess : access->getEndAccesses())
@@ -412,22 +413,22 @@ bool SelectEnforcement::hasPotentiallyEscapedAtAnyReachableBlock(
   for (SILBasicBlock *bb : blocksAccessedAcross) {
     for (SILBasicBlock *succBB : bb->getSuccessorBlocks()) {
       if (blocksAccessedAcross.count(succBB)) continue;
-      if (visited.insert(succBB).second)
+      if (visited.insert(succBB))
         Worklist.push_back(succBB);
     }
   }
 
   while (!Worklist.empty()) {
     SILBasicBlock *bb = Worklist.pop_back_val();
-    assert(visited.count(bb));
+    assert(visited.contains(bb));
 
     // If we're tracking information for this block, there's an escape.
     if (StateMap.count(bb))
       return true;
 
     // Add all reachable successors.
     for (SILBasicBlock *succ : bb->getSuccessors()) {
-      if (visited.insert(succ).second)
+      if (visited.insert(succ))
         Worklist.push_back(succ);
     }
   }

lib/SILOptimizer/Mandatory/ClosureLifetimeFixup.cpp

@@ -18,6 +18,7 @@
 #include "swift/SIL/SILArgument.h"
 #include "swift/SIL/SILBuilder.h"
 #include "swift/SIL/SILInstruction.h"
+#include "swift/SIL/SILBitfield.h"
 #include "swift/SILOptimizer/PassManager/Passes.h"
 #include "swift/SILOptimizer/PassManager/Transforms.h"
 #include "swift/SILOptimizer/Utils/CFGOptUtils.h"
@@ -103,7 +104,7 @@ static SILInstruction *getDeinitSafeClosureDestructionPoint(SILBasicBlock *bb) {
 static void findReachableExitBlocks(SILInstruction *i,
                                     SmallVectorImpl<SILBasicBlock *> &result) {
   SmallVector<SILBasicBlock *, 32> worklist;
-  SmallPtrSet<SILBasicBlock *, 8> visitedBlocks;
+  BasicBlockSet visitedBlocks(i->getFunction());
 
   visitedBlocks.insert(i->getParent());
   worklist.push_back(i->getParent());
@@ -116,7 +117,7 @@ static void findReachableExitBlocks(SILInstruction *i,
     }
     llvm::copy_if(bb->getSuccessorBlocks(), std::back_inserter(worklist),
                   [&](SILBasicBlock *bb) {
-      return visitedBlocks.insert(bb).second;
+      return visitedBlocks.insert(bb);
     });
   }
 }