mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-19 04:29:21 +00:00
2a3876d885
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@42314 91177308-0d34-0410-b5e6-96231b3b80d8
116 lines
4.2 KiB
C++
116 lines
4.2 KiB
C++
//==- PostDominatorCalculation.h - Post-Dominator Calculation ----*- C++ -*-==//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file was developed by Owen Anderson and is distributed under
|
|
// the University of Illinois Open Source License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// PostDominatorTree calculation implementation.
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_ANALYSIS_POST_DOMINATOR_CALCULATION_H
|
|
#define LLVM_ANALYSIS_POST_DOMINATOR_CALCULATION_H
|
|
|
|
#include "llvm/Analysis/PostDominators.h"
|
|
|
|
namespace llvm {
|
|
|
|
void PDTcalculate(PostDominatorTree& PDT, Function &F) {
|
|
// 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) {
|
|
TerminatorInst *Insn = I->getTerminator();
|
|
if (Insn->getNumSuccessors() == 0) {
|
|
// Unreachable block is not a root node.
|
|
if (!isa<UnreachableInst>(Insn))
|
|
PDT.Roots.push_back(I);
|
|
}
|
|
|
|
// Prepopulate maps so that we don't get iterator invalidation issues later.
|
|
PDT.IDoms[I] = 0;
|
|
PDT.DomTreeNodes[I] = 0;
|
|
}
|
|
|
|
PDT.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 = PDT.Roots.size(); i != e; ++i)
|
|
N = PDT.DFSPass(PDT.Roots[i], N);
|
|
|
|
for (unsigned i = N; i >= 2; --i) {
|
|
BasicBlock *W = PDT.Vertex[i];
|
|
PostDominatorTree::InfoRec &WInfo = PDT.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 (PDT.Info.count(*SI)) { // Only if this predecessor is reachable!
|
|
unsigned SemiU = PDT.Info[Eval(PDT, *SI)].Semi;
|
|
if (SemiU < WInfo.Semi)
|
|
WInfo.Semi = SemiU;
|
|
}
|
|
|
|
PDT.Info[PDT.Vertex[WInfo.Semi]].Bucket.push_back(W);
|
|
|
|
BasicBlock *WParent = WInfo.Parent;
|
|
Link(PDT, WParent, W, WInfo);
|
|
|
|
// Step #3: Implicitly define the immediate dominator of vertices
|
|
std::vector<BasicBlock*> &WParentBucket = PDT.Info[WParent].Bucket;
|
|
while (!WParentBucket.empty()) {
|
|
BasicBlock *V = WParentBucket.back();
|
|
WParentBucket.pop_back();
|
|
BasicBlock *U = Eval(PDT, V);
|
|
PDT.IDoms[V] = PDT.Info[U].Semi < PDT.Info[V].Semi ? U : WParent;
|
|
}
|
|
}
|
|
|
|
// Step #4: Explicitly define the immediate dominator of each vertex
|
|
for (unsigned i = 2; i <= N; ++i) {
|
|
BasicBlock *W = PDT.Vertex[i];
|
|
BasicBlock *&WIDom = PDT.IDoms[W];
|
|
if (WIDom != PDT.Vertex[PDT.Info[W].Semi])
|
|
WIDom = PDT.IDoms[WIDom];
|
|
}
|
|
|
|
if (PDT.Roots.empty()) return;
|
|
|
|
// Add a node for the root. This node might be the actual root, if there is
|
|
// one exit block, or it may be the virtual exit (denoted by (BasicBlock *)0)
|
|
// which postdominates all real exits if there are multiple exit blocks.
|
|
BasicBlock *Root = PDT.Roots.size() == 1 ? PDT.Roots[0] : 0;
|
|
PDT.DomTreeNodes[Root] = PDT.RootNode = new DomTreeNode(Root, 0);
|
|
|
|
// Loop over all of the reachable blocks in the function...
|
|
for (Function::iterator I = F.begin(), E = F.end(); I != E; ++I)
|
|
if (BasicBlock *ImmPostDom = PDT.getIDom(I)) { // Reachable block.
|
|
DomTreeNode *&BBNode = PDT.DomTreeNodes[I];
|
|
if (!BBNode) { // Haven't calculated this node yet?
|
|
// Get or calculate the node for the immediate dominator
|
|
DomTreeNode *IPDomNode = PDT.getNodeForBlock(ImmPostDom);
|
|
|
|
// Add a new tree node for this BasicBlock, and link it as a child of
|
|
// IDomNode
|
|
DomTreeNode *C = new DomTreeNode(I, IPDomNode);
|
|
PDT.DomTreeNodes[I] = C;
|
|
BBNode = IPDomNode->addChild(C);
|
|
}
|
|
}
|
|
|
|
// Free temporary memory used to construct idom's
|
|
PDT.IDoms.clear();
|
|
PDT.Info.clear();
|
|
std::vector<BasicBlock*>().swap(PDT.Vertex);
|
|
|
|
// Start out with the DFS numbers being invalid. Let them be computed if
|
|
// demanded.
|
|
PDT.DFSInfoValid = false;
|
|
}
|
|
|
|
}
|
|
#endif
|