// Provide iterator ranges for the graph traits nodes and children
template <class GraphType>
iterator_range<typename GraphTraits<GraphType>::nodes_iterator>
-graph_nodes(const GraphType &G) {
+nodes(const GraphType &G) {
return make_range(GraphTraits<GraphType>::nodes_begin(G),
GraphTraits<GraphType>::nodes_end(G));
}
template <class GraphType>
iterator_range<typename GraphTraits<Inverse<GraphType>>::nodes_iterator>
-inverse_graph_nodes(const GraphType &G) {
+inverse_nodes(const GraphType &G) {
return make_range(GraphTraits<Inverse<GraphType>>::nodes_begin(G),
GraphTraits<Inverse<GraphType>>::nodes_end(G));
}
template <class GraphType>
iterator_range<typename GraphTraits<GraphType>::ChildIteratorType>
-graph_children(const typename GraphTraits<GraphType>::NodeRef &G) {
+children(const typename GraphTraits<GraphType>::NodeRef &G) {
return make_range(GraphTraits<GraphType>::child_begin(G),
GraphTraits<GraphType>::child_end(G));
}
template <class GraphType>
iterator_range<typename GraphTraits<Inverse<GraphType>>::ChildIteratorType>
-inverse_graph_children(const typename GraphTraits<GraphType>::NodeRef &G) {
+inverse_children(const typename GraphTraits<GraphType>::NodeRef &G) {
return make_range(GraphTraits<Inverse<GraphType>>::child_begin(G),
GraphTraits<Inverse<GraphType>>::child_end(G));
}
Calculate<FT, NodeT *>(*this, F);
} else {
// Initialize the roots list
- for (auto *Node : graph_nodes(&F))
+ for (auto *Node : nodes(&F))
if (TraitsTy::child_begin(Node) == TraitsTy::child_end(Node))
addRoot(Node);
// initialize the semi dominator to point to the parent node
WInfo.Semi = WInfo.Parent;
- for (const auto &N : inverse_graph_children<NodeT>(W))
+ for (const auto &N : inverse_children<NodeT>(W))
if (DT.Info.count(N)) { // Only if this predecessor is reachable!
unsigned SemiU = DT.Info[Eval<GraphT>(DT, N, i + 1)].Semi;
if (SemiU < WInfo.Semi)
BasicBlock *BB = Node->getBlock();
// Succ is the successor in the direction we are calculating IDF, so it is
// successor for IDF, and predecessor for Reverse IDF.
- for (auto *Succ : graph_children<NodeTy>(BB)) {
+ for (auto *Succ : children<NodeTy>(BB)) {
DomTreeNode *SuccNode = DT.getNode(Succ);
// Quickly skip all CFG edges that are also dominator tree edges instead
}
// walk through all the block in func to check for unreachable
- for (auto *MBB : graph_nodes(MF)) {
+ for (auto *MBB : nodes(MF)) {
SccNum = getSCCNum(MBB);
if (SccNum == INVALIDSCCNUM)
dbgs() << "unreachable block BB" << MBB->getNumber() << "\n";
MachineBasicBlock *ExitBlk = *ExitBlks.begin();
assert(ExitBlk && "Loop has several exit block");
MBBVector LatchBlks;
- for (auto *LB : inverse_graph_children<MachineBasicBlock*>(LoopHeader))
+ for (auto *LB : inverse_children<MachineBasicBlock*>(LoopHeader))
if (LoopRep->contains(LB))
LatchBlks.push_back(LB);
RegisterSet NewAVs = AVs;
NewAVs.insert(Defs);
- for (auto *DTN : graph_children<MachineDomTreeNode*>(MDT->getNode(&B)))
+ for (auto *DTN : children<MachineDomTreeNode*>(MDT->getNode(&B)))
Changed |= visitBlock(*(DTN->getBlock()), T, NewAVs);
if (!T.TopDown)
bool DeadCodeElimination::runOnNode(MachineDomTreeNode *N) {
bool Changed = false;
- for (auto *DTN : graph_children<MachineDomTreeNode*>(N))
+ for (auto *DTN : children<MachineDomTreeNode*>(N))
Changed |= runOnNode(DTN);
MachineBasicBlock *B = N->getBlock();
// visited".
Order.push_back(Root);
- for (auto *DTN : graph_children<DomTreeNode*>(DT->getNode(Root)))
+ for (auto *DTN : children<DomTreeNode*>(DT->getNode(Root)))
getBlockTraversalOrder(DTN->getBlock(), Order);
}
for (unsigned i = 0; i < BO.size(); ++i) {
BasicBlock *B = cast<BasicBlock>(BO[i]);
- for (auto DTN : graph_children<DomTreeNode*>(DT->getNode(B)))
+ for (auto DTN : children<DomTreeNode*>(DT->getNode(B)))
BO.push_back(DTN->getBlock());
}
bool HexagonGenExtract::visitBlock(BasicBlock *B) {
// Depth-first, bottom-up traversal.
- for (auto *DTN : graph_children<DomTreeNode*>(DT->getNode(B)))
+ for (auto *DTN : children<DomTreeNode*>(DT->getNode(B)))
visitBlock(DTN->getBlock());
// Allow limiting the number of generated extracts for debugging purposes.
BlockDefs.insert(InsDefs);
}
- for (auto *DTN : graph_children<MachineDomTreeNode*>(MDT->getNode(B))) {
+ for (auto *DTN : children<MachineDomTreeNode*>(MDT->getNode(B))) {
MachineBasicBlock *SB = DTN->getBlock();
collectInBlock(SB, AVs);
}
bool HexagonGenInsert::removeDeadCode(MachineDomTreeNode *N) {
bool Changed = false;
- for (auto *DTN : graph_children<MachineDomTreeNode*>(N))
+ for (auto *DTN : children<MachineDomTreeNode*>(N))
Changed |= removeDeadCode(DTN);
MachineBasicBlock *B = N->getBlock();