[NFCI] Improve efficiency of isPotentiallyReachableFromManyDomTree.

[nicholas]

Summary

df_iterator is intended for directed acyclic graphs, and as such keeps a list of visited nodes to not reenter. There is no need for that complexity when visiting a tree, such as DominatorTree. This reduces the amount of work done for each dominated node.

[kuhar]

IMO you could introduce df_iterator_tree_storage by a slight modification to the default one:

// df_iterator_storage - A private class which is used to figure out where to
// store the visited set.
template<class SetType, bool External>   // Non-external set
class df_iterator_storage {
public:
  SetType Visited;
};

Where your custom SetType does nothing on insertion and always returns that count is 0. Then you could potentially give it an alias like df_tree_iterator, or some better name.

llvm/lib/Analysis/CFG.cpp

do {
     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;
     }
 
     // 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; ++I) {
-      for (auto Succ : successors(I->getBlock())) {
+    DT.forEachDescendant(DTN, [&](DomTreeNode *Dominated) {
+      for (auto Succ : successors(Dominated->getBlock())) {
         DomTreeNode *DTSucc = DT.getNode(Succ);
         if (!DT.dominates(DTN, DTSucc))
           Worklist.push_back(DTSucc);
       }
-    }
+    });
   } while (!Worklist.empty());
 
   // We have exhausted all possible paths and are certain that 'To' can not be
   // reached from 'From'.
   return false;
 }
 
 static bool isPotentiallyReachableFromManyBasicBlock(