-//===----------------------------------------------------------------------===//
-// ImmediatePostDominators Implementation
-//===----------------------------------------------------------------------===//
-
-static RegisterAnalysis<ImmediatePostDominators>
-D("postidom", "Immediate Post-Dominators Construction", true);
-
-unsigned ImmediatePostDominators::DFSPass(BasicBlock *V, InfoRec &VInfo,
- unsigned N) {
- VInfo.Semi = ++N;
- VInfo.Label = V;
-
- Vertex.push_back(V); // Vertex[n] = V;
- //Info[V].Ancestor = 0; // Ancestor[n] = 0
- //Child[V] = 0; // Child[v] = 0
- VInfo.Size = 1; // Size[v] = 1
-
- // For PostDominators, we want to walk predecessors rather than successors
- // as we do in forward Dominators.
- for (pred_iterator PI = pred_begin(V), PE = pred_end(V); PI != PE; ++PI) {
- InfoRec &SuccVInfo = Info[*PI];
- if (SuccVInfo.Semi == 0) {
- SuccVInfo.Parent = V;
- N = DFSPass(*PI, SuccVInfo, N);
- }
- }
- return N;
-}
-
-void ImmediatePostDominators::Compress(BasicBlock *V, InfoRec &VInfo) {
- BasicBlock *VAncestor = VInfo.Ancestor;
- InfoRec &VAInfo = Info[VAncestor];
- if (VAInfo.Ancestor == 0)
- return;
-
- Compress(VAncestor, VAInfo);
-
- BasicBlock *VAncestorLabel = VAInfo.Label;
- BasicBlock *VLabel = VInfo.Label;
- if (Info[VAncestorLabel].Semi < Info[VLabel].Semi)
- VInfo.Label = VAncestorLabel;
-
- VInfo.Ancestor = VAInfo.Ancestor;
-}
-
-BasicBlock *ImmediatePostDominators::Eval(BasicBlock *V) {
- InfoRec &VInfo = Info[V];
-
- // Higher-complexity but faster implementation
- if (VInfo.Ancestor == 0)
- return V;
- Compress(V, VInfo);
- return VInfo.Label;
-}
-
-void ImmediatePostDominators::Link(BasicBlock *V, BasicBlock *W,
- InfoRec &WInfo) {
- // Higher-complexity but faster implementation
- WInfo.Ancestor = V;
-}
-
-bool ImmediatePostDominators::runOnFunction(Function &F) {
- IDoms.clear(); // Reset from the last time we were run...
- Roots.clear();
-
- // Step #0: Scan the function looking for the root nodes of the post-dominance
- // relationships. These blocks, which have no successors, end with return and
- // unwind instructions.
- for (Function::iterator I = F.begin(), E = F.end(); I != E; ++I)
- if (succ_begin(I) == succ_end(I))
- Roots.push_back(I);
-
- Vertex.push_back(0);
-
- // Step #1: Number blocks in depth-first order and initialize variables used
- // in later stages of the algorithm.
- unsigned N = 0;
- for (unsigned i = 0, e = Roots.size(); i != e; ++i)
- N = DFSPass(Roots[i], Info[Roots[i]], N);
-
- for (unsigned i = N; i >= 2; --i) {
- BasicBlock *W = Vertex[i];
- InfoRec &WInfo = Info[W];
-
- // Step #2: Calculate the semidominators of all vertices
- for (succ_iterator SI = succ_begin(W), SE = succ_end(W); SI != SE; ++SI)
- if (Info.count(*SI)) { // Only if this predecessor is reachable!
- unsigned SemiU = Info[Eval(*SI)].Semi;
- if (SemiU < WInfo.Semi)
- WInfo.Semi = SemiU;
- }
-
- Info[Vertex[WInfo.Semi]].Bucket.push_back(W);
-
- BasicBlock *WParent = WInfo.Parent;
- Link(WParent, W, WInfo);
-
- // Step #3: Implicitly define the immediate dominator of vertices
- std::vector<BasicBlock*> &WParentBucket = Info[WParent].Bucket;
- while (!WParentBucket.empty()) {
- BasicBlock *V = WParentBucket.back();
- WParentBucket.pop_back();
- BasicBlock *U = Eval(V);
- IDoms[V] = Info[U].Semi < Info[V].Semi ? U : WParent;
- }
- }
-
- // Step #4: Explicitly define the immediate dominator of each vertex
- for (unsigned i = 2; i <= N; ++i) {
- BasicBlock *W = Vertex[i];
- BasicBlock *&WIDom = IDoms[W];
- if (WIDom != Vertex[Info[W].Semi])
- WIDom = IDoms[WIDom];
- }
-
- // Free temporary memory used to construct idom's
- Info.clear();
- std::vector<BasicBlock*>().swap(Vertex);
-
- return false;
-}
-
-//===----------------------------------------------------------------------===//
-// PostDominatorSet Implementation
-//===----------------------------------------------------------------------===//
-
-static RegisterAnalysis<PostDominatorSet>
-B("postdomset", "Post-Dominator Set Construction", true);
-
-// Postdominator set construction. This converts the specified function to only
-// have a single exit node (return stmt), then calculates the post dominance
-// sets for the function.
-//
-bool PostDominatorSet::runOnFunction(Function &F) {
- // Scan the function looking for the root nodes of the post-dominance
- // relationships. These blocks end with return and unwind instructions.
- // While we are iterating over the function, we also initialize all of the
- // domsets to empty.
- Roots.clear();
- for (Function::iterator I = F.begin(), E = F.end(); I != E; ++I)
- if (succ_begin(I) == succ_end(I))
- Roots.push_back(I);
-
- // If there are no exit nodes for the function, postdomsets are all empty.
- // This can happen if the function just contains an infinite loop, for
- // example.
- ImmediatePostDominators &IPD = getAnalysis<ImmediatePostDominators>();
- Doms.clear(); // Reset from the last time we were run...
- if (Roots.empty()) return false;
-
- // If we have more than one root, we insert an artificial "null" exit, which
- // has "virtual edges" to each of the real exit nodes.
- //if (Roots.size() > 1)
- // Doms[0].insert(0);
-
- // Root nodes only dominate themselves.
- for (unsigned i = 0, e = Roots.size(); i != e; ++i)
- Doms[Roots[i]].insert(Roots[i]);
-
- // Loop over all of the blocks in the function, calculating dominator sets for
- // each function.
- for (Function::iterator I = F.begin(), E = F.end(); I != E; ++I)
- if (BasicBlock *IPDom = IPD[I]) { // Get idom if block is reachable
- DomSetType &DS = Doms[I];
- assert(DS.empty() && "PostDomset already filled in for this block?");
- DS.insert(I); // Blocks always dominate themselves
-
- // Insert all dominators into the set...
- while (IPDom) {
- // If we have already computed the dominator sets for our immediate post
- // dominator, just use it instead of walking all the way up to the root.
- DomSetType &IPDS = Doms[IPDom];
- if (!IPDS.empty()) {
- DS.insert(IPDS.begin(), IPDS.end());
- break;
- } else {
- DS.insert(IPDom);
- IPDom = IPD[IPDom];
- }
- }
- } else {
- // Ensure that every basic block has at least an empty set of nodes. This
- // is important for the case when there is unreachable blocks.
- Doms[I];
- }
-
- return false;
-}
-