mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-11-22 10:42:39 +01:00
Add new anaysis routines for building dominator related information
llvm-svn: 122
This commit is contained in:
Chris Lattner
parent
be2224f993
commit
4a9f31a0a7
190
include/llvm/Analysis/Dominators.h
Normal file
190
include/llvm/Analysis/Dominators.h
Normal file
@ -0,0 +1,190 @@
|
||||
//===- llvm/Analysis/DominatorSet.h - Dominator Set Calculation --*- C++ -*--=//
|
||||
//
|
||||
// This file defines the following classes:
|
||||
// 1. DominatorSet: Calculates the [reverse] dominator set for a method
|
||||
// 2. ImmediateDominators: Calculates and holds the immediate dominator tree
|
||||
// for a method.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#ifndef LLVM_DOMINATOR_SET_H
|
||||
#define LLVM_DOMINATOR_SET_H
|
||||
|
||||
#include <set>
|
||||
#include <map>
|
||||
#include <vector>
|
||||
class Method;
|
||||
class BasicBlock;
|
||||
|
||||
namespace cfg {
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// DominatorSet - Maintain a set<const BasicBlock*> for every basic block in a
|
||||
// method, that represents the blocks that dominate the block.
|
||||
//
|
||||
class DominatorSet {
|
||||
public:
|
||||
typedef set<const BasicBlock*> DomSetType; // Dom set for a bb
|
||||
typedef map<const BasicBlock *, DomSetType> DomSetMapType; // Map of dom sets
|
||||
private:
|
||||
DomSetMapType Doms;
|
||||
const BasicBlock *Root;
|
||||
public:
|
||||
// DominatorSet ctor - Build either the dominator set or the post-dominator
|
||||
// set for a method...
|
||||
//
|
||||
DominatorSet(const Method *M, bool PostDomSet = false);
|
||||
|
||||
// Accessor interface:
|
||||
typedef DomSetMapType::const_iterator const_iterator;
|
||||
inline const_iterator begin() const { return Doms.begin(); }
|
||||
inline const_iterator end() const { return Doms.end(); }
|
||||
inline const_iterator find(const BasicBlock* B) const { return Doms.find(B); }
|
||||
inline const BasicBlock *getRoot() const { return Root; }
|
||||
|
||||
// getDominators - Return the set of basic blocks that dominate the specified
|
||||
// block.
|
||||
//
|
||||
inline const DomSetType &getDominators(const BasicBlock *BB) const {
|
||||
const_iterator I = find(BB);
|
||||
assert(I != end() && "BB not in method!");
|
||||
return I->second;
|
||||
}
|
||||
|
||||
// dominates - Return true if A dominates B.
|
||||
//
|
||||
inline bool dominates(const BasicBlock *A, const BasicBlock *B) const {
|
||||
return getDominators(B).count(A) != 0;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// ImmediateDominators - Calculate the immediate dominator for each node in a
|
||||
// method.
|
||||
//
|
||||
class ImmediateDominators {
|
||||
map<const BasicBlock*, const BasicBlock*> IDoms;
|
||||
const BasicBlock *Root;
|
||||
void calcIDoms(const DominatorSet &DS);
|
||||
public:
|
||||
|
||||
// ImmediateDominators ctor - Calculate the idom mapping, for a method, or
|
||||
// from a dominator set calculated for something else...
|
||||
//
|
||||
inline ImmediateDominators(const DominatorSet &DS) : Root(DS.getRoot()) {
|
||||
calcIDoms(DS); // Can be used to make rev-idoms
|
||||
}
|
||||
|
||||
// Accessor interface:
|
||||
typedef map<const BasicBlock*, const BasicBlock*> IDomMapType;
|
||||
typedef IDomMapType::const_iterator const_iterator;
|
||||
inline const_iterator begin() const { return IDoms.begin(); }
|
||||
inline const_iterator end() const { return IDoms.end(); }
|
||||
inline const_iterator find(const BasicBlock* B) const { return IDoms.find(B);}
|
||||
inline const BasicBlock *getRoot() const { return Root; }
|
||||
|
||||
// operator[] - Return the idom for the specified basic block. The start
|
||||
// node returns null, because it does not have an immediate dominator.
|
||||
//
|
||||
inline const BasicBlock *operator[](const BasicBlock *BB) const {
|
||||
map<const BasicBlock*, const BasicBlock*>::const_iterator I =
|
||||
IDoms.find(BB);
|
||||
return I != IDoms.end() ? I->second : 0;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// DominatorTree - Calculate the immediate dominator tree for a method.
|
||||
//
|
||||
class DominatorTree {
|
||||
class Node;
|
||||
const BasicBlock *Root;
|
||||
map<const BasicBlock*, Node*> Nodes;
|
||||
void calculate(const DominatorSet &DS);
|
||||
typedef map<const BasicBlock*, Node*> NodeMapType;
|
||||
public:
|
||||
class Node : public vector<Node*> {
|
||||
friend class DominatorTree;
|
||||
const BasicBlock *TheNode;
|
||||
Node * const IDom;
|
||||
public:
|
||||
inline const BasicBlock *getNode() const { return TheNode; }
|
||||
inline Node *getIDom() const { return IDom; }
|
||||
inline const vector<Node*> &getChildren() const { return *this; }
|
||||
|
||||
// dominates - Returns true iff this dominates N. Note that this is not a
|
||||
// constant time operation!
|
||||
inline bool dominates(const Node *N) const {
|
||||
const Node *IDom;
|
||||
while ((IDom = N->getIDom()) != 0 && IDom != this)
|
||||
N = IDom; // Walk up the tree
|
||||
return IDom != 0;
|
||||
}
|
||||
|
||||
private:
|
||||
inline Node(const BasicBlock *node, Node *iDom)
|
||||
: TheNode(node), IDom(iDom) {}
|
||||
inline Node *addChild(Node *C) { push_back(C); return C; }
|
||||
};
|
||||
|
||||
public:
|
||||
// DominatorTree ctors - Compute a dominator tree, given various amounts of
|
||||
// previous knowledge...
|
||||
//inline DominatorTree(const Method *M) { calculate(DominatorSet(M)); }
|
||||
inline DominatorTree(const DominatorSet &DS) : Root(DS.getRoot()) {
|
||||
calculate(DS);
|
||||
}
|
||||
|
||||
DominatorTree(const ImmediateDominators &IDoms);
|
||||
~DominatorTree();
|
||||
|
||||
inline const BasicBlock *getRoot() const { return Root; }
|
||||
inline const Node *operator[](const BasicBlock *BB) const {
|
||||
NodeMapType::const_iterator i = Nodes.find(BB);
|
||||
return (i != Nodes.end()) ? i->second : 0;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// DominanceFrontier - Calculate the dominance frontiers for a method.
|
||||
//
|
||||
class DominanceFrontier {
|
||||
typedef set<const BasicBlock*> DomSetType; // Dom set for a bb
|
||||
typedef map<const BasicBlock *, DomSetType> DomSetMapType; // Map of dom sets
|
||||
private:
|
||||
DomSetMapType Frontiers;
|
||||
const BasicBlock *Root;
|
||||
const DomSetType &calcDomFrontier(const DominatorTree &DT,
|
||||
const DominatorTree::Node *Node);
|
||||
public:
|
||||
DominanceFrontier(const DominatorSet &DS) : Root(DS.getRoot()) {
|
||||
const DominatorTree DT(DS);
|
||||
calcDomFrontier(DT, DT[Root]);
|
||||
}
|
||||
DominanceFrontier(const ImmediateDominators &ID) : Root(ID.getRoot()) {
|
||||
const DominatorTree DT(ID);
|
||||
calcDomFrontier(DT, DT[Root]);
|
||||
}
|
||||
DominanceFrontier(const DominatorTree &DT) : Root(DT.getRoot()) {
|
||||
calcDomFrontier(DT, DT[Root]);
|
||||
}
|
||||
|
||||
// Accessor interface:
|
||||
typedef DomSetMapType::const_iterator const_iterator;
|
||||
inline const_iterator begin() const { return Frontiers.begin(); }
|
||||
inline const_iterator end() const { return Frontiers.end(); }
|
||||
inline const_iterator find(const BasicBlock* B) const { return Frontiers.find(B);}
|
||||
inline const BasicBlock *getRoot() const { return Root; }
|
||||
|
||||
};
|
||||
|
||||
} // End namespace cfg
|
||||
|
||||
#endif
|
||||
Loading…
Reference in New Issue
Block a user