LLVM  6.0.0svn
SCCIterator.h
Go to the documentation of this file.
1 //===- ADT/SCCIterator.h - Strongly Connected Comp. Iter. -------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 /// \file
10 ///
11 /// This builds on the llvm/ADT/GraphTraits.h file to find the strongly
12 /// connected components (SCCs) of a graph in O(N+E) time using Tarjan's DFS
13 /// algorithm.
14 ///
15 /// The SCC iterator has the important property that if a node in SCC S1 has an
16 /// edge to a node in SCC S2, then it visits S1 *after* S2.
17 ///
18 /// To visit S1 *before* S2, use the scc_iterator on the Inverse graph. (NOTE:
19 /// This requires some simple wrappers and is not supported yet.)
20 ///
21 //===----------------------------------------------------------------------===//
22 
23 #ifndef LLVM_ADT_SCCITERATOR_H
24 #define LLVM_ADT_SCCITERATOR_H
25 
26 #include "llvm/ADT/DenseMap.h"
27 #include "llvm/ADT/GraphTraits.h"
28 #include "llvm/ADT/iterator.h"
29 #include <cassert>
30 #include <cstddef>
31 #include <iterator>
32 #include <vector>
33 
34 namespace llvm {
35 
36 /// \brief Enumerate the SCCs of a directed graph in reverse topological order
37 /// of the SCC DAG.
38 ///
39 /// This is implemented using Tarjan's DFS algorithm using an internal stack to
40 /// build up a vector of nodes in a particular SCC. Note that it is a forward
41 /// iterator and thus you cannot backtrack or re-visit nodes.
42 template <class GraphT, class GT = GraphTraits<GraphT>>
44  scc_iterator<GraphT, GT>, std::forward_iterator_tag,
45  const std::vector<typename GT::NodeRef>, ptrdiff_t> {
46  using NodeRef = typename GT::NodeRef;
47  using ChildItTy = typename GT::ChildIteratorType;
48  using SccTy = std::vector<NodeRef>;
49  using reference = typename scc_iterator::reference;
50 
51  /// Element of VisitStack during DFS.
52  struct StackElement {
53  NodeRef Node; ///< The current node pointer.
54  ChildItTy NextChild; ///< The next child, modified inplace during DFS.
55  unsigned MinVisited; ///< Minimum uplink value of all children of Node.
56 
57  StackElement(NodeRef Node, const ChildItTy &Child, unsigned Min)
58  : Node(Node), NextChild(Child), MinVisited(Min) {}
59 
60  bool operator==(const StackElement &Other) const {
61  return Node == Other.Node &&
62  NextChild == Other.NextChild &&
63  MinVisited == Other.MinVisited;
64  }
65  };
66 
67  /// The visit counters used to detect when a complete SCC is on the stack.
68  /// visitNum is the global counter.
69  ///
70  /// nodeVisitNumbers are per-node visit numbers, also used as DFS flags.
71  unsigned visitNum;
72  DenseMap<NodeRef, unsigned> nodeVisitNumbers;
73 
74  /// Stack holding nodes of the SCC.
75  std::vector<NodeRef> SCCNodeStack;
76 
77  /// The current SCC, retrieved using operator*().
78  SccTy CurrentSCC;
79 
80  /// DFS stack, Used to maintain the ordering. The top contains the current
81  /// node, the next child to visit, and the minimum uplink value of all child
82  std::vector<StackElement> VisitStack;
83 
84  /// A single "visit" within the non-recursive DFS traversal.
85  void DFSVisitOne(NodeRef N);
86 
87  /// The stack-based DFS traversal; defined below.
88  void DFSVisitChildren();
89 
90  /// Compute the next SCC using the DFS traversal.
91  void GetNextSCC();
92 
93  scc_iterator(NodeRef entryN) : visitNum(0) {
94  DFSVisitOne(entryN);
95  GetNextSCC();
96  }
97 
98  /// End is when the DFS stack is empty.
99  scc_iterator() = default;
100 
101 public:
102  static scc_iterator begin(const GraphT &G) {
103  return scc_iterator(GT::getEntryNode(G));
104  }
105  static scc_iterator end(const GraphT &) { return scc_iterator(); }
106 
107  /// \brief Direct loop termination test which is more efficient than
108  /// comparison with \c end().
109  bool isAtEnd() const {
110  assert(!CurrentSCC.empty() || VisitStack.empty());
111  return CurrentSCC.empty();
112  }
113 
114  bool operator==(const scc_iterator &x) const {
115  return VisitStack == x.VisitStack && CurrentSCC == x.CurrentSCC;
116  }
117 
119  GetNextSCC();
120  return *this;
121  }
122 
123  reference operator*() const {
124  assert(!CurrentSCC.empty() && "Dereferencing END SCC iterator!");
125  return CurrentSCC;
126  }
127 
128  /// \brief Test if the current SCC has a loop.
129  ///
130  /// If the SCC has more than one node, this is trivially true. If not, it may
131  /// still contain a loop if the node has an edge back to itself.
132  bool hasLoop() const;
133 
134  /// This informs the \c scc_iterator that the specified \c Old node
135  /// has been deleted, and \c New is to be used in its place.
136  void ReplaceNode(NodeRef Old, NodeRef New) {
137  assert(nodeVisitNumbers.count(Old) && "Old not in scc_iterator?");
138  nodeVisitNumbers[New] = nodeVisitNumbers[Old];
139  nodeVisitNumbers.erase(Old);
140  }
141 };
142 
143 template <class GraphT, class GT>
145  ++visitNum;
146  nodeVisitNumbers[N] = visitNum;
147  SCCNodeStack.push_back(N);
148  VisitStack.push_back(StackElement(N, GT::child_begin(N), visitNum));
149 #if 0 // Enable if needed when debugging.
150  dbgs() << "TarjanSCC: Node " << N <<
151  " : visitNum = " << visitNum << "\n";
152 #endif
153 }
154 
155 template <class GraphT, class GT>
157  assert(!VisitStack.empty());
158  while (VisitStack.back().NextChild != GT::child_end(VisitStack.back().Node)) {
159  // TOS has at least one more child so continue DFS
160  NodeRef childN = *VisitStack.back().NextChild++;
161  typename DenseMap<NodeRef, unsigned>::iterator Visited =
162  nodeVisitNumbers.find(childN);
163  if (Visited == nodeVisitNumbers.end()) {
164  // this node has never been seen.
165  DFSVisitOne(childN);
166  continue;
167  }
168 
169  unsigned childNum = Visited->second;
170  if (VisitStack.back().MinVisited > childNum)
171  VisitStack.back().MinVisited = childNum;
172  }
173 }
174 
175 template <class GraphT, class GT> void scc_iterator<GraphT, GT>::GetNextSCC() {
176  CurrentSCC.clear(); // Prepare to compute the next SCC
177  while (!VisitStack.empty()) {
178  DFSVisitChildren();
179 
180  // Pop the leaf on top of the VisitStack.
181  NodeRef visitingN = VisitStack.back().Node;
182  unsigned minVisitNum = VisitStack.back().MinVisited;
183  assert(VisitStack.back().NextChild == GT::child_end(visitingN));
184  VisitStack.pop_back();
185 
186  // Propagate MinVisitNum to parent so we can detect the SCC starting node.
187  if (!VisitStack.empty() && VisitStack.back().MinVisited > minVisitNum)
188  VisitStack.back().MinVisited = minVisitNum;
189 
190 #if 0 // Enable if needed when debugging.
191  dbgs() << "TarjanSCC: Popped node " << visitingN <<
192  " : minVisitNum = " << minVisitNum << "; Node visit num = " <<
193  nodeVisitNumbers[visitingN] << "\n";
194 #endif
195 
196  if (minVisitNum != nodeVisitNumbers[visitingN])
197  continue;
198 
199  // A full SCC is on the SCCNodeStack! It includes all nodes below
200  // visitingN on the stack. Copy those nodes to CurrentSCC,
201  // reset their minVisit values, and return (this suspends
202  // the DFS traversal till the next ++).
203  do {
204  CurrentSCC.push_back(SCCNodeStack.back());
205  SCCNodeStack.pop_back();
206  nodeVisitNumbers[CurrentSCC.back()] = ~0U;
207  } while (CurrentSCC.back() != visitingN);
208  return;
209  }
210 }
211 
212 template <class GraphT, class GT>
214  assert(!CurrentSCC.empty() && "Dereferencing END SCC iterator!");
215  if (CurrentSCC.size() > 1)
216  return true;
217  NodeRef N = CurrentSCC.front();
218  for (ChildItTy CI = GT::child_begin(N), CE = GT::child_end(N); CI != CE;
219  ++CI)
220  if (*CI == N)
221  return true;
222  return false;
223  }
224 
225 /// \brief Construct the begin iterator for a deduced graph type T.
226 template <class T> scc_iterator<T> scc_begin(const T &G) {
227  return scc_iterator<T>::begin(G);
228 }
229 
230 /// \brief Construct the end iterator for a deduced graph type T.
231 template <class T> scc_iterator<T> scc_end(const T &G) {
232  return scc_iterator<T>::end(G);
233 }
234 
235 } // end namespace llvm
236 
237 #endif // LLVM_ADT_SCCITERATOR_H
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
void ReplaceNode(NodeRef Old, NodeRef New)
This informs the scc_iterator that the specified Old node has been deleted, and New is to be used in ...
Definition: SCCIterator.h:136
scc_iterator & operator++()
Definition: SCCIterator.h:118
ELFYAML::ELF_STO Other
Definition: ELFYAML.cpp:736
scc_iterator< T > scc_begin(const T &G)
Construct the begin iterator for a deduced graph type T.
Definition: SCCIterator.h:226
bool isAtEnd() const
Direct loop termination test which is more efficient than comparison with end().
Definition: SCCIterator.h:109
CRTP base class which implements the entire standard iterator facade in terms of a minimal subset of ...
Definition: iterator.h:68
reference operator*() const
Definition: SCCIterator.h:123
iterator find(const_arg_type_t< KeyT > Val)
Definition: DenseMap.h:146
bool erase(const KeyT &Val)
Definition: DenseMap.h:268
scc_iterator< T > scc_end(const T &G)
Construct the end iterator for a deduced graph type T.
Definition: SCCIterator.h:231
bool operator==(const scc_iterator &x) const
Definition: SCCIterator.h:114
const DataFlowGraph & G
Definition: RDFGraph.cpp:211
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
static scc_iterator end(const GraphT &)
Definition: SCCIterator.h:105
#define N
size_type count(const_arg_type_t< KeyT > Val) const
Return 1 if the specified key is in the map, 0 otherwise.
Definition: DenseMap.h:141
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
bool hasLoop() const
Test if the current SCC has a loop.
Definition: SCCIterator.h:213
static scc_iterator begin(const GraphT &G)
Definition: SCCIterator.h:102
Enumerate the SCCs of a directed graph in reverse topological order of the SCC DAG.
Definition: SCCIterator.h:43