[NFCI] Use less memory by storing the Loop* as visited instead of storing each BasicBlock* in the block as visited.

llvm/lib/Analysis/CFG.cpp

bool llvm::isPotentiallyReachableFromMany(
   const Loop *StopLoop = LI ? getOutermostLoop(LI, StopBB) : nullptr;
 
   const DomTreeNode *StopNode = DT ? DT->getNode(StopBB) : nullptr;
 
   // Limit the number of blocks we visit. The goal is to avoid run-away compile
   // times on large CFGs without hampering sensible code. Arbitrarily chosen.
   unsigned Limit = 32;
   SmallPtrSet<const BasicBlock*, 32> Visited;
+  SmallPtrSet<const Loop*, 32> VisitedLoops;
   do {
     BasicBlock *BB = Worklist.pop_back_val();
     if (!Visited.insert(BB).second)
       continue;
     if (BB == StopBB)
       return true;
     if (ExclusionSet && ExclusionSet->count(BB))
       continue;
 
     DomTreeNode *DTN = StopNode ? DT->getNode(BB) : nullptr;
     if (StopNode && DTN && DT->dominates(DTN, StopNode))
       return true;
 
     const Loop *Outer = nullptr;
     if (LI) {
       Outer = getOutermostLoop(LI, BB);
+
       // If we're in a loop with a hole, not all blocks in the loop are
       // reachable from all other blocks. That implies we can't simply jump to
       // the loop's exit blocks, as that exit might need to pass through an
       // excluded block. Clear Outer so we process BB's successors.
       if (LoopsWithHoles.count(Outer))
         Outer = nullptr;
+
+      if (Outer && !VisitedLoops.insert(Outer).second)
+        continue;
+
       if (StopLoop && Outer == StopLoop)
         return true;
     }
 
     if (!--Limit) {
       // We haven't been able to prove it one way or the other. Conservatively
       // answer true -- that there is potentially a path.
       return true;
     }
 
     if (Outer) {
       // All blocks in a single loop are reachable from all other blocks. From
       // any of these blocks, we can skip directly to the exits of the loop,
       // ignoring any other blocks inside the loop body.
-      Visited.insert(Outer->block_begin(), Outer->block_end());
       Outer->getExitBlocks(Worklist);
     } else if (DTN) {
       // The dominance check effectively visits all blocks dominated by BB. Skip
       // over the domtree-descendants of the block to visit their successors.
       for (auto I = df_begin(DTN), E = df_end(DTN); I != E;) {
         for (auto Succ : successors(I->getBlock())) {
           if (!DT->dominates(DTN, DT->getNode(Succ)))
             Worklist.push_back(Succ);