mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-10-19 19:12:56 +02:00
Strip trailing whitespace from blank lines.
llvm-svn: 80259
This commit is contained in:
Dan Gohman
parent
6cd12a9f7f
commit
e4b0f12a19
@ -82,12 +82,12 @@ public:
|
||||
typedef typename std::vector<DomTreeNodeBase<NodeT> *>::iterator iterator;
|
||||
typedef typename std::vector<DomTreeNodeBase<NodeT> *>::const_iterator
|
||||
const_iterator;
|
||||
|
||||
|
||||
iterator begin() { return Children.begin(); }
|
||||
iterator end() { return Children.end(); }
|
||||
const_iterator begin() const { return Children.begin(); }
|
||||
const_iterator end() const { return Children.end(); }
|
||||
|
||||
|
||||
NodeT *getBlock() const { return TheBB; }
|
||||
DomTreeNodeBase<NodeT> *getIDom() const { return IDom; }
|
||||
const std::vector<DomTreeNodeBase<NodeT>*> &getChildren() const {
|
||||
@ -96,7 +96,7 @@ public:
|
||||
|
||||
DomTreeNodeBase(NodeT *BB, DomTreeNodeBase<NodeT> *iDom)
|
||||
: TheBB(BB), IDom(iDom), DFSNumIn(-1), DFSNumOut(-1) { }
|
||||
|
||||
|
||||
DomTreeNodeBase<NodeT> *addChild(DomTreeNodeBase<NodeT> *C) {
|
||||
Children.push_back(C);
|
||||
return C;
|
||||
@ -109,7 +109,7 @@ public:
|
||||
void clearAllChildren() {
|
||||
Children.clear();
|
||||
}
|
||||
|
||||
|
||||
bool compare(DomTreeNodeBase<NodeT> *Other) {
|
||||
if (getNumChildren() != Other->getNumChildren())
|
||||
return true;
|
||||
@ -143,7 +143,7 @@ public:
|
||||
IDom->Children.push_back(this);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/// getDFSNumIn/getDFSNumOut - These are an internal implementation detail, do
|
||||
/// not call them.
|
||||
unsigned getDFSNumIn() const { return DFSNumIn; }
|
||||
@ -167,9 +167,9 @@ static raw_ostream &operator<<(raw_ostream &o,
|
||||
WriteAsOperand(o, Node->getBlock(), false);
|
||||
else
|
||||
o << " <<exit node>>";
|
||||
|
||||
|
||||
o << " {" << Node->getDFSNumIn() << "," << Node->getDFSNumOut() << "}";
|
||||
|
||||
|
||||
return o << "\n";
|
||||
}
|
||||
|
||||
@ -233,7 +233,7 @@ protected:
|
||||
Vertex.clear();
|
||||
RootNode = 0;
|
||||
}
|
||||
|
||||
|
||||
// NewBB is split and now it has one successor. Update dominator tree to
|
||||
// reflect this change.
|
||||
template<class N, class GraphT>
|
||||
@ -320,7 +320,7 @@ public:
|
||||
|
||||
DomTreeNodeBase<NodeT>* MyNd = I->second;
|
||||
DomTreeNodeBase<NodeT>* OtherNd = OI->second;
|
||||
|
||||
|
||||
if (MyNd->compare(OtherNd))
|
||||
return true;
|
||||
}
|
||||
@ -378,7 +378,7 @@ public:
|
||||
&& "This is not implemented for post dominators");
|
||||
return dominates(&A->getParent()->front(), A);
|
||||
}
|
||||
|
||||
|
||||
/// dominates - Returns true iff A dominates B. Note that this is not a
|
||||
/// constant time operation!
|
||||
///
|
||||
@ -407,10 +407,10 @@ public:
|
||||
inline bool dominates(NodeT *A, NodeT *B) {
|
||||
if (A == B)
|
||||
return true;
|
||||
|
||||
|
||||
return dominates(getNode(A), getNode(B));
|
||||
}
|
||||
|
||||
|
||||
NodeT *getRoot() const {
|
||||
assert(this->Roots.size() == 1 && "Should always have entry node!");
|
||||
return this->Roots[0];
|
||||
@ -522,7 +522,7 @@ public:
|
||||
assert(getNode(BB) && "Removing node that isn't in dominator tree.");
|
||||
DomTreeNodes.erase(BB);
|
||||
}
|
||||
|
||||
|
||||
/// splitBlock - BB is split and now it has one successor. Update dominator
|
||||
/// tree to reflect this change.
|
||||
void splitBlock(NodeT* NewBB) {
|
||||
@ -546,7 +546,7 @@ public:
|
||||
|
||||
PrintDomTree<NodeT>(getRootNode(), o, 1);
|
||||
}
|
||||
|
||||
|
||||
protected:
|
||||
template<class GraphT>
|
||||
friend void Compress(DominatorTreeBase<typename GraphT::NodeType>& DT,
|
||||
@ -561,16 +561,16 @@ protected:
|
||||
friend void Link(DominatorTreeBase<typename GraphT::NodeType>& DT,
|
||||
unsigned DFSNumV, typename GraphT::NodeType* W,
|
||||
typename DominatorTreeBase<typename GraphT::NodeType>::InfoRec &WInfo);
|
||||
|
||||
|
||||
template<class GraphT>
|
||||
friend unsigned DFSPass(DominatorTreeBase<typename GraphT::NodeType>& DT,
|
||||
typename GraphT::NodeType* V,
|
||||
unsigned N);
|
||||
|
||||
|
||||
template<class FuncT, class N>
|
||||
friend void Calculate(DominatorTreeBase<typename GraphTraits<N>::NodeType>& DT,
|
||||
FuncT& F);
|
||||
|
||||
|
||||
/// updateDFSNumbers - Assign In and Out numbers to the nodes while walking
|
||||
/// dominator tree in dfs order.
|
||||
void updateDFSNumbers() {
|
||||
@ -598,17 +598,17 @@ protected:
|
||||
// Otherwise, recursively visit this child.
|
||||
DomTreeNodeBase<NodeT> *Child = *ChildIt;
|
||||
++WorkStack.back().second;
|
||||
|
||||
|
||||
WorkStack.push_back(std::make_pair(Child, Child->begin()));
|
||||
Child->DFSNumIn = DFSNum++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
SlowQueries = 0;
|
||||
DFSInfoValid = true;
|
||||
}
|
||||
|
||||
|
||||
DomTreeNodeBase<NodeT> *getNodeForBlock(NodeT *BB) {
|
||||
typename DomTreeNodeMapType::iterator I = this->DomTreeNodes.find(BB);
|
||||
if (I != this->DomTreeNodes.end() && I->second)
|
||||
@ -626,31 +626,31 @@ protected:
|
||||
DomTreeNodeBase<NodeT> *C = new DomTreeNodeBase<NodeT>(BB, IDomNode);
|
||||
return this->DomTreeNodes[BB] = IDomNode->addChild(C);
|
||||
}
|
||||
|
||||
|
||||
inline NodeT *getIDom(NodeT *BB) const {
|
||||
typename DenseMap<NodeT*, NodeT*>::const_iterator I = IDoms.find(BB);
|
||||
return I != IDoms.end() ? I->second : 0;
|
||||
}
|
||||
|
||||
|
||||
inline void addRoot(NodeT* BB) {
|
||||
this->Roots.push_back(BB);
|
||||
}
|
||||
|
||||
|
||||
public:
|
||||
/// recalculate - compute a dominator tree for the given function
|
||||
template<class FT>
|
||||
void recalculate(FT& F) {
|
||||
if (!this->IsPostDominators) {
|
||||
reset();
|
||||
|
||||
|
||||
// Initialize roots
|
||||
this->Roots.push_back(&F.front());
|
||||
this->IDoms[&F.front()] = 0;
|
||||
this->DomTreeNodes[&F.front()] = 0;
|
||||
this->Vertex.push_back(0);
|
||||
|
||||
|
||||
Calculate<FT, NodeT*>(*this, F);
|
||||
|
||||
|
||||
updateDFSNumbers();
|
||||
} else {
|
||||
reset(); // Reset from the last time we were run...
|
||||
@ -667,7 +667,7 @@ public:
|
||||
}
|
||||
|
||||
this->Vertex.push_back(0);
|
||||
|
||||
|
||||
Calculate<FT, Inverse<NodeT*> >(*this, F);
|
||||
}
|
||||
}
|
||||
@ -683,18 +683,18 @@ class DominatorTree : public FunctionPass {
|
||||
public:
|
||||
static char ID; // Pass ID, replacement for typeid
|
||||
DominatorTreeBase<BasicBlock>* DT;
|
||||
|
||||
|
||||
DominatorTree() : FunctionPass(&ID) {
|
||||
DT = new DominatorTreeBase<BasicBlock>(false);
|
||||
}
|
||||
|
||||
|
||||
~DominatorTree() {
|
||||
DT->releaseMemory();
|
||||
delete DT;
|
||||
}
|
||||
|
||||
|
||||
DominatorTreeBase<BasicBlock>& getBase() { return *DT; }
|
||||
|
||||
|
||||
/// getRoots - Return the root blocks of the current CFG. This may include
|
||||
/// multiple blocks if we are computing post dominators. For forward
|
||||
/// dominators, this will always be a single block (the entry node).
|
||||
@ -702,11 +702,11 @@ public:
|
||||
inline const std::vector<BasicBlock*> &getRoots() const {
|
||||
return DT->getRoots();
|
||||
}
|
||||
|
||||
|
||||
inline BasicBlock *getRoot() const {
|
||||
return DT->getRoot();
|
||||
}
|
||||
|
||||
|
||||
inline DomTreeNode *getRootNode() const {
|
||||
return DT->getRootNode();
|
||||
}
|
||||
@ -716,10 +716,10 @@ public:
|
||||
inline bool compare(DominatorTree &Other) const {
|
||||
DomTreeNode *R = getRootNode();
|
||||
DomTreeNode *OtherR = Other.getRootNode();
|
||||
|
||||
|
||||
if (!R || !OtherR || R->getBlock() != OtherR->getBlock())
|
||||
return true;
|
||||
|
||||
|
||||
if (DT->compare(Other.getBase()))
|
||||
return true;
|
||||
|
||||
@ -727,19 +727,19 @@ public:
|
||||
}
|
||||
|
||||
virtual bool runOnFunction(Function &F);
|
||||
|
||||
|
||||
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
|
||||
AU.setPreservesAll();
|
||||
}
|
||||
|
||||
|
||||
inline bool dominates(DomTreeNode* A, DomTreeNode* B) const {
|
||||
return DT->dominates(A, B);
|
||||
}
|
||||
|
||||
|
||||
inline bool dominates(BasicBlock* A, BasicBlock* B) const {
|
||||
return DT->dominates(A, B);
|
||||
}
|
||||
|
||||
|
||||
// dominates - Return true if A dominates B. This performs the
|
||||
// special checks necessary if A and B are in the same basic block.
|
||||
bool dominates(Instruction *A, Instruction *B) const {
|
||||
@ -763,72 +763,72 @@ public:
|
||||
// return &*I == B;
|
||||
//}
|
||||
}
|
||||
|
||||
|
||||
inline bool properlyDominates(const DomTreeNode* A, DomTreeNode* B) const {
|
||||
return DT->properlyDominates(A, B);
|
||||
}
|
||||
|
||||
|
||||
inline bool properlyDominates(BasicBlock* A, BasicBlock* B) const {
|
||||
return DT->properlyDominates(A, B);
|
||||
}
|
||||
|
||||
|
||||
/// findNearestCommonDominator - Find nearest common dominator basic block
|
||||
/// for basic block A and B. If there is no such block then return NULL.
|
||||
inline BasicBlock *findNearestCommonDominator(BasicBlock *A, BasicBlock *B) {
|
||||
return DT->findNearestCommonDominator(A, B);
|
||||
}
|
||||
|
||||
|
||||
inline DomTreeNode *operator[](BasicBlock *BB) const {
|
||||
return DT->getNode(BB);
|
||||
}
|
||||
|
||||
|
||||
/// getNode - return the (Post)DominatorTree node for the specified basic
|
||||
/// block. This is the same as using operator[] on this class.
|
||||
///
|
||||
inline DomTreeNode *getNode(BasicBlock *BB) const {
|
||||
return DT->getNode(BB);
|
||||
}
|
||||
|
||||
|
||||
/// addNewBlock - Add a new node to the dominator tree information. This
|
||||
/// creates a new node as a child of DomBB dominator node,linking it into
|
||||
/// the children list of the immediate dominator.
|
||||
inline DomTreeNode *addNewBlock(BasicBlock *BB, BasicBlock *DomBB) {
|
||||
return DT->addNewBlock(BB, DomBB);
|
||||
}
|
||||
|
||||
|
||||
/// changeImmediateDominator - This method is used to update the dominator
|
||||
/// tree information when a node's immediate dominator changes.
|
||||
///
|
||||
inline void changeImmediateDominator(BasicBlock *N, BasicBlock* NewIDom) {
|
||||
DT->changeImmediateDominator(N, NewIDom);
|
||||
}
|
||||
|
||||
|
||||
inline void changeImmediateDominator(DomTreeNode *N, DomTreeNode* NewIDom) {
|
||||
DT->changeImmediateDominator(N, NewIDom);
|
||||
}
|
||||
|
||||
|
||||
/// eraseNode - Removes a node from the dominator tree. Block must not
|
||||
/// domiante any other blocks. Removes node from its immediate dominator's
|
||||
/// children list. Deletes dominator node associated with basic block BB.
|
||||
inline void eraseNode(BasicBlock *BB) {
|
||||
DT->eraseNode(BB);
|
||||
}
|
||||
|
||||
|
||||
/// splitBlock - BB is split and now it has one successor. Update dominator
|
||||
/// tree to reflect this change.
|
||||
inline void splitBlock(BasicBlock* NewBB) {
|
||||
DT->splitBlock(NewBB);
|
||||
}
|
||||
|
||||
|
||||
bool isReachableFromEntry(BasicBlock* A) {
|
||||
return DT->isReachableFromEntry(A);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
virtual void releaseMemory() {
|
||||
DT->releaseMemory();
|
||||
}
|
||||
|
||||
|
||||
virtual void print(raw_ostream &OS, const Module* M= 0) const;
|
||||
};
|
||||
|
||||
@ -839,7 +839,7 @@ public:
|
||||
template <> struct GraphTraits<DomTreeNode *> {
|
||||
typedef DomTreeNode NodeType;
|
||||
typedef NodeType::iterator ChildIteratorType;
|
||||
|
||||
|
||||
static NodeType *getEntryNode(NodeType *N) {
|
||||
return N;
|
||||
}
|
||||
@ -871,7 +871,7 @@ protected:
|
||||
DomSetMapType Frontiers;
|
||||
std::vector<BasicBlock*> Roots;
|
||||
const bool IsPostDominators;
|
||||
|
||||
|
||||
public:
|
||||
DominanceFrontierBase(void *ID, bool isPostDom)
|
||||
: FunctionPass(ID), IsPostDominators(isPostDom) {}
|
||||
@ -881,7 +881,7 @@ public:
|
||||
/// dominators, this will always be a single block (the entry node).
|
||||
///
|
||||
inline const std::vector<BasicBlock*> &getRoots() const { return Roots; }
|
||||
|
||||
|
||||
/// isPostDominator - Returns true if analysis based of postdoms
|
||||
///
|
||||
bool isPostDominator() const { return IsPostDominators; }
|
||||
|
||||
Loading…
Reference in New Issue
Block a user