llvm.org GIT mirror llvm / 2073b0a
[PM] Pull the generic graph algorithms and data structures for dominator trees into the Support library. These are all expressed in terms of the generic GraphTraits and CFG, with no reliance on any concrete IR types. Putting them in support clarifies that and makes the fact that the static analyzer in Clang uses them much more sane. When moving the Dominators.h file into the IR library I claimed that this was the right home for it but not something I planned to work on. Oops. So why am I doing this? It happens to be one step toward breaking the requirement that IR verification can only be performed from inside of a pass context, which completely blocks the implementation of verification for the new pass manager infrastructure. Fixing it will also allow removing the concept of the "preverify" step (WTF???) and allow the verifier to cleanly flag functions which fail verification in a way that precludes even computing dominance information. Currently, that results in a fatal error even when you ask the verifier to not fatally error. It's awesome like that. The yak shaving will continue... git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@199095 91177308-0d34-0410-b5e6-96231b3b80d8 Chandler Carruth 6 years ago
11 changed file(s) with 1021 addition(s) and 989 deletion(s). Raw diff Collapse all Expand all
1717 #include "llvm/CodeGen/MachineBasicBlock.h"
1818 #include "llvm/CodeGen/MachineFunction.h"
1919 #include "llvm/CodeGen/MachineFunctionPass.h"
20 #include "llvm/IR/DominatorInternals.h"
21 #include "llvm/IR/Dominators.h"
20 #include "llvm/Support/GenericDomTreeConstruction.h"
21 #include "llvm/Support/GenericDomTree.h"
2222
2323 namespace llvm {
2424
+0
-289
include/llvm/IR/DominatorInternals.h less more
None //===- DominatorInternals.h - Dominator Calculation --------------*- C++ -*-==//
1 //
2 // The LLVM Compiler Infrastructure
3 //
4 // This file is distributed under the University of Illinois Open Source
5 // License. See LICENSE.TXT for details.
6 //
7 //===----------------------------------------------------------------------===//
8
9 #ifndef LLVM_IR_DOMINATOR_INTERNALS_H
10 #define LLVM_IR_DOMINATOR_INTERNALS_H
11
12 #include "llvm/ADT/SmallPtrSet.h"
13 #include "llvm/IR/Dominators.h"
14
15 //===----------------------------------------------------------------------===//
16 //
17 // DominatorTree construction - This pass constructs immediate dominator
18 // information for a flow-graph based on the algorithm described in this
19 // document:
20 //
21 // A Fast Algorithm for Finding Dominators in a Flowgraph
22 // T. Lengauer & R. Tarjan, ACM TOPLAS July 1979, pgs 121-141.
23 //
24 // This implements the O(n*log(n)) versions of EVAL and LINK, because it turns
25 // out that the theoretically slower O(n*log(n)) implementation is actually
26 // faster than the almost-linear O(n*alpha(n)) version, even for large CFGs.
27 //
28 //===----------------------------------------------------------------------===//
29
30 namespace llvm {
31
32 template
33 unsigned DFSPass(DominatorTreeBase& DT,
34 typename GraphT::NodeType* V, unsigned N) {
35 // This is more understandable as a recursive algorithm, but we can't use the
36 // recursive algorithm due to stack depth issues. Keep it here for
37 // documentation purposes.
38 #if 0
39 InfoRec &VInfo = DT.Info[DT.Roots[i]];
40 VInfo.DFSNum = VInfo.Semi = ++N;
41 VInfo.Label = V;
42
43 Vertex.push_back(V); // Vertex[n] = V;
44
45 for (succ_iterator SI = succ_begin(V), E = succ_end(V); SI != E; ++SI) {
46 InfoRec &SuccVInfo = DT.Info[*SI];
47 if (SuccVInfo.Semi == 0) {
48 SuccVInfo.Parent = V;
49 N = DTDFSPass(DT, *SI, N);
50 }
51 }
52 #else
53 bool IsChildOfArtificialExit = (N != 0);
54
55 SmallVector
56 typename GraphT::ChildIteratorType>, 32> Worklist;
57 Worklist.push_back(std::make_pair(V, GraphT::child_begin(V)));
58 while (!Worklist.empty()) {
59 typename GraphT::NodeType* BB = Worklist.back().first;
60 typename GraphT::ChildIteratorType NextSucc = Worklist.back().second;
61
62 typename DominatorTreeBase::InfoRec &BBInfo =
63 DT.Info[BB];
64
65 // First time we visited this BB?
66 if (NextSucc == GraphT::child_begin(BB)) {
67 BBInfo.DFSNum = BBInfo.Semi = ++N;
68 BBInfo.Label = BB;
69
70 DT.Vertex.push_back(BB); // Vertex[n] = V;
71
72 if (IsChildOfArtificialExit)
73 BBInfo.Parent = 1;
74
75 IsChildOfArtificialExit = false;
76 }
77
78 // store the DFS number of the current BB - the reference to BBInfo might
79 // get invalidated when processing the successors.
80 unsigned BBDFSNum = BBInfo.DFSNum;
81
82 // If we are done with this block, remove it from the worklist.
83 if (NextSucc == GraphT::child_end(BB)) {
84 Worklist.pop_back();
85 continue;
86 }
87
88 // Increment the successor number for the next time we get to it.
89 ++Worklist.back().second;
90
91 // Visit the successor next, if it isn't already visited.
92 typename GraphT::NodeType* Succ = *NextSucc;
93
94 typename DominatorTreeBase::InfoRec &SuccVInfo =
95 DT.Info[Succ];
96 if (SuccVInfo.Semi == 0) {
97 SuccVInfo.Parent = BBDFSNum;
98 Worklist.push_back(std::make_pair(Succ, GraphT::child_begin(Succ)));
99 }
100 }
101 #endif
102 return N;
103 }
104
105 template
106 typename GraphT::NodeType*
107 Eval(DominatorTreeBase& DT,
108 typename GraphT::NodeType *VIn, unsigned LastLinked) {
109 typename DominatorTreeBase::InfoRec &VInInfo =
110 DT.Info[VIn];
111 if (VInInfo.DFSNum < LastLinked)
112 return VIn;
113
114 SmallVector Work;
115 SmallPtrSet Visited;
116
117 if (VInInfo.Parent >= LastLinked)
118 Work.push_back(VIn);
119
120 while (!Work.empty()) {
121 typename GraphT::NodeType* V = Work.back();
122 typename DominatorTreeBase::InfoRec &VInfo =
123 DT.Info[V];
124 typename GraphT::NodeType* VAncestor = DT.Vertex[VInfo.Parent];
125
126 // Process Ancestor first
127 if (Visited.insert(VAncestor) && VInfo.Parent >= LastLinked) {
128 Work.push_back(VAncestor);
129 continue;
130 }
131 Work.pop_back();
132
133 // Update VInfo based on Ancestor info
134 if (VInfo.Parent < LastLinked)
135 continue;
136
137 typename DominatorTreeBase::InfoRec &VAInfo =
138 DT.Info[VAncestor];
139 typename GraphT::NodeType* VAncestorLabel = VAInfo.Label;
140 typename GraphT::NodeType* VLabel = VInfo.Label;
141 if (DT.Info[VAncestorLabel].Semi < DT.Info[VLabel].Semi)
142 VInfo.Label = VAncestorLabel;
143 VInfo.Parent = VAInfo.Parent;
144 }
145
146 return VInInfo.Label;
147 }
148
149 template
150 void Calculate(DominatorTreeBase::NodeType>& DT,
151 FuncT& F) {
152 typedef GraphTraits GraphT;
153
154 unsigned N = 0;
155 bool MultipleRoots = (DT.Roots.size() > 1);
156 if (MultipleRoots) {
157 typename DominatorTreeBase::InfoRec &BBInfo =
158 DT.Info[NULL];
159 BBInfo.DFSNum = BBInfo.Semi = ++N;
160 BBInfo.Label = NULL;
161
162 DT.Vertex.push_back(NULL); // Vertex[n] = V;
163 }
164
165 // Step #1: Number blocks in depth-first order and initialize variables used
166 // in later stages of the algorithm.
167 for (unsigned i = 0, e = static_cast(DT.Roots.size());
168 i != e; ++i)
169 N = DFSPass(DT, DT.Roots[i], N);
170
171 // it might be that some blocks did not get a DFS number (e.g., blocks of
172 // infinite loops). In these cases an artificial exit node is required.
173 MultipleRoots |= (DT.isPostDominator() && N != GraphTraits::size(&F));
174
175 // When naively implemented, the Lengauer-Tarjan algorithm requires a separate
176 // bucket for each vertex. However, this is unnecessary, because each vertex
177 // is only placed into a single bucket (that of its semidominator), and each
178 // vertex's bucket is processed before it is added to any bucket itself.
179 //
180 // Instead of using a bucket per vertex, we use a single array Buckets that
181 // has two purposes. Before the vertex V with preorder number i is processed,
182 // Buckets[i] stores the index of the first element in V's bucket. After V's
183 // bucket is processed, Buckets[i] stores the index of the next element in the
184 // bucket containing V, if any.
185 SmallVector Buckets;
186 Buckets.resize(N + 1);
187 for (unsigned i = 1; i <= N; ++i)
188 Buckets[i] = i;
189
190 for (unsigned i = N; i >= 2; --i) {
191 typename GraphT::NodeType* W = DT.Vertex[i];
192 typename DominatorTreeBase::InfoRec &WInfo =
193 DT.Info[W];
194
195 // Step #2: Implicitly define the immediate dominator of vertices
196 for (unsigned j = i; Buckets[j] != i; j = Buckets[j]) {
197 typename GraphT::NodeType* V = DT.Vertex[Buckets[j]];
198 typename GraphT::NodeType* U = Eval(DT, V, i + 1);
199 DT.IDoms[V] = DT.Info[U].Semi < i ? U : W;
200 }
201
202 // Step #3: Calculate the semidominators of all vertices
203
204 // initialize the semi dominator to point to the parent node
205 WInfo.Semi = WInfo.Parent;
206 typedef GraphTraits > InvTraits;
207 for (typename InvTraits::ChildIteratorType CI =
208 InvTraits::child_begin(W),
209 E = InvTraits::child_end(W); CI != E; ++CI) {
210 typename InvTraits::NodeType *N = *CI;
211 if (DT.Info.count(N)) { // Only if this predecessor is reachable!
212 unsigned SemiU = DT.Info[Eval(DT, N, i + 1)].Semi;
213 if (SemiU < WInfo.Semi)
214 WInfo.Semi = SemiU;
215 }
216 }
217
218 // If V is a non-root vertex and sdom(V) = parent(V), then idom(V) is
219 // necessarily parent(V). In this case, set idom(V) here and avoid placing
220 // V into a bucket.
221 if (WInfo.Semi == WInfo.Parent) {
222 DT.IDoms[W] = DT.Vertex[WInfo.Parent];
223 } else {
224 Buckets[i] = Buckets[WInfo.Semi];
225 Buckets[WInfo.Semi] = i;
226 }
227 }
228
229 if (N >= 1) {
230 typename GraphT::NodeType* Root = DT.Vertex[1];
231 for (unsigned j = 1; Buckets[j] != 1; j = Buckets[j]) {
232 typename GraphT::NodeType* V = DT.Vertex[Buckets[j]];
233 DT.IDoms[V] = Root;
234 }
235 }
236
237 // Step #4: Explicitly define the immediate dominator of each vertex
238 for (unsigned i = 2; i <= N; ++i) {
239 typename GraphT::NodeType* W = DT.Vertex[i];
240 typename GraphT::NodeType*& WIDom = DT.IDoms[W];
241 if (WIDom != DT.Vertex[DT.Info[W].Semi])
242 WIDom = DT.IDoms[WIDom];
243 }
244
245 if (DT.Roots.empty()) return;
246
247 // Add a node for the root. This node might be the actual root, if there is
248 // one exit block, or it may be the virtual exit (denoted by (BasicBlock *)0)
249 // which postdominates all real exits if there are multiple exit blocks, or
250 // an infinite loop.
251 typename GraphT::NodeType* Root = !MultipleRoots ? DT.Roots[0] : 0;
252
253 DT.DomTreeNodes[Root] = DT.RootNode =
254 new DomTreeNodeBase(Root, 0);
255
256 // Loop over all of the reachable blocks in the function...
257 for (unsigned i = 2; i <= N; ++i) {
258 typename GraphT::NodeType* W = DT.Vertex[i];
259
260 DomTreeNodeBase *BBNode = DT.DomTreeNodes[W];
261 if (BBNode) continue; // Haven't calculated this node yet?
262
263 typename GraphT::NodeType* ImmDom = DT.getIDom(W);
264
265 assert(ImmDom || DT.DomTreeNodes[NULL]);
266
267 // Get or calculate the node for the immediate dominator
268 DomTreeNodeBase *IDomNode =
269 DT.getNodeForBlock(ImmDom);
270
271 // Add a new tree node for this BasicBlock, and link it as a child of
272 // IDomNode
273 DomTreeNodeBase *C =
274 new DomTreeNodeBase(W, IDomNode);
275 DT.DomTreeNodes[W] = IDomNode->addChild(C);
276 }
277
278 // Free temporary memory used to construct idom's
279 DT.IDoms.clear();
280 DT.Info.clear();
281 std::vector().swap(DT.Vertex);
282
283 DT.updateDFSNumbers();
284 }
285
286 }
287
288 #endif
1919 #include "llvm/ADT/GraphTraits.h"
2020 #include "llvm/ADT/SmallPtrSet.h"
2121 #include "llvm/ADT/SmallVector.h"
22 #include "llvm/IR/BasicBlock.h"
2223 #include "llvm/IR/Function.h"
2324 #include "llvm/Pass.h"
2425 #include "llvm/Support/CFG.h"
26 #include "llvm/Support/GenericDomTree.h"
2527 #include "llvm/Support/Compiler.h"
2628 #include "llvm/Support/raw_ostream.h"
2729 #include
2830
2931 namespace llvm {
3032
31 //===----------------------------------------------------------------------===//
32 /// DominatorBase - Base class that other, more interesting dominator analyses
33 /// inherit from.
34 ///
35 template
36 class DominatorBase {
37 protected:
38 std::vector Roots;
39 const bool IsPostDominators;
40 inline explicit DominatorBase(bool isPostDom) :
41 Roots(), IsPostDominators(isPostDom) {}
42 public:
43
44 /// getRoots - Return the root blocks of the current CFG. This may include
45 /// multiple blocks if we are computing post dominators. For forward
46 /// dominators, this will always be a single block (the entry node).
47 ///
48 inline const std::vector &getRoots() const { return Roots; }
49
50 /// isPostDominator - Returns true if analysis based of postdoms
51 ///
52 bool isPostDominator() const { return IsPostDominators; }
53 };
54
55
56 //===----------------------------------------------------------------------===//
57 // DomTreeNode - Dominator Tree Node
58 template class DominatorTreeBase;
59 struct PostDominatorTree;
60 class MachineBasicBlock;
61
62 template
63 class DomTreeNodeBase {
64 NodeT *TheBB;
65 DomTreeNodeBase *IDom;
66 std::vector *> Children;
67 int DFSNumIn, DFSNumOut;
68
69 template friend class DominatorTreeBase;
70 friend struct PostDominatorTree;
71 public:
72 typedef typename std::vector *>::iterator iterator;
73 typedef typename std::vector *>::const_iterator
74 const_iterator;
75
76 iterator begin() { return Children.begin(); }
77 iterator end() { return Children.end(); }
78 const_iterator begin() const { return Children.begin(); }
79 const_iterator end() const { return Children.end(); }
80
81 NodeT *getBlock() const { return TheBB; }
82 DomTreeNodeBase *getIDom() const { return IDom; }
83 const std::vector*> &getChildren() const {
84 return Children;
85 }
86
87 DomTreeNodeBase(NodeT *BB, DomTreeNodeBase *iDom)
88 : TheBB(BB), IDom(iDom), DFSNumIn(-1), DFSNumOut(-1) { }
89
90 DomTreeNodeBase *addChild(DomTreeNodeBase *C) {
91 Children.push_back(C);
92 return C;
93 }
94
95 size_t getNumChildren() const {
96 return Children.size();
97 }
98
99 void clearAllChildren() {
100 Children.clear();
101 }
102
103 bool compare(const DomTreeNodeBase *Other) const {
104 if (getNumChildren() != Other->getNumChildren())
105 return true;
106
107 SmallPtrSet OtherChildren;
108 for (const_iterator I = Other->begin(), E = Other->end(); I != E; ++I) {
109 const NodeT *Nd = (*I)->getBlock();
110 OtherChildren.insert(Nd);
111 }
112
113 for (const_iterator I = begin(), E = end(); I != E; ++I) {
114 const NodeT *N = (*I)->getBlock();
115 if (OtherChildren.count(N) == 0)
116 return true;
117 }
118 return false;
119 }
120
121 void setIDom(DomTreeNodeBase *NewIDom) {
122 assert(IDom && "No immediate dominator?");
123 if (IDom != NewIDom) {
124 typename std::vector*>::iterator I =
125 std::find(IDom->Children.begin(), IDom->Children.end(), this);
126 assert(I != IDom->Children.end() &&
127 "Not in immediate dominator children set!");
128 // I am no longer your child...
129 IDom->Children.erase(I);
130
131 // Switch to new dominator
132 IDom = NewIDom;
133 IDom->Children.push_back(this);
134 }
135 }
136
137 /// getDFSNumIn/getDFSNumOut - These are an internal implementation detail, do
138 /// not call them.
139 unsigned getDFSNumIn() const { return DFSNumIn; }
140 unsigned getDFSNumOut() const { return DFSNumOut; }
141 private:
142 // Return true if this node is dominated by other. Use this only if DFS info
143 // is valid.
144 bool DominatedBy(const DomTreeNodeBase *other) const {
145 return this->DFSNumIn >= other->DFSNumIn &&
146 this->DFSNumOut <= other->DFSNumOut;
147 }
148 };
149
15033 EXTERN_TEMPLATE_INSTANTIATION(class DomTreeNodeBase);
151 EXTERN_TEMPLATE_INSTANTIATION(class DomTreeNodeBase);
152
153 template
154 inline raw_ostream &operator<<(raw_ostream &o,
155 const DomTreeNodeBase *Node) {
156 if (Node->getBlock())
157 Node->getBlock()->printAsOperand(o, false);
158 else
159 o << " <>";
160
161 o << " {" << Node->getDFSNumIn() << "," << Node->getDFSNumOut() << "}";
162
163 return o << "\n";
164 }
165
166 template
167 inline void PrintDomTree(const DomTreeNodeBase *N, raw_ostream &o,
168 unsigned Lev) {
169 o.indent(2*Lev) << "[" << Lev << "] " << N;
170 for (typename DomTreeNodeBase::const_iterator I = N->begin(),
171 E = N->end(); I != E; ++I)
172 PrintDomTree(*I, o, Lev+1);
173 }
34 EXTERN_TEMPLATE_INSTANTIATION(class DominatorTreeBase);
17435
17536 typedef DomTreeNodeBase DomTreeNode;
176
177 //===----------------------------------------------------------------------===//
178 /// DominatorTree - Calculate the immediate dominator tree for a function.
179 ///
180
181 template
182 void Calculate(DominatorTreeBase::NodeType>& DT,
183 FuncT& F);
184
185 template
186 class DominatorTreeBase : public DominatorBase {
187 bool dominatedBySlowTreeWalk(const DomTreeNodeBase *A,
188 const DomTreeNodeBase *B) const {
189 assert(A != B);
190 assert(isReachableFromEntry(B));
191 assert(isReachableFromEntry(A));
192
193 const DomTreeNodeBase *IDom;
194 while ((IDom = B->getIDom()) != 0 && IDom != A && IDom != B)
195 B = IDom; // Walk up the tree
196 return IDom != 0;
197 }
198
199 protected:
200 typedef DenseMap*> DomTreeNodeMapType;
201 DomTreeNodeMapType DomTreeNodes;
202 DomTreeNodeBase *RootNode;
203
204 bool DFSInfoValid;
205 unsigned int SlowQueries;
206 // Information record used during immediate dominators computation.
207 struct InfoRec {
208 unsigned DFSNum;
209 unsigned Parent;
210 unsigned Semi;
211 NodeT *Label;
212
213 InfoRec() : DFSNum(0), Parent(0), Semi(0), Label(0) {}
214 };
215
216 DenseMap IDoms;
217
218 // Vertex - Map the DFS number to the BasicBlock*
219 std::vector Vertex;
220
221 // Info - Collection of information used during the computation of idoms.
222 DenseMap Info;
223
224 void reset() {
225 for (typename DomTreeNodeMapType::iterator I = this->DomTreeNodes.begin(),
226 E = DomTreeNodes.end(); I != E; ++I)
227 delete I->second;
228 DomTreeNodes.clear();
229 IDoms.clear();
230 this->Roots.clear();
231 Vertex.clear();
232 RootNode = 0;
233 }
234
235 // NewBB is split and now it has one successor. Update dominator tree to
236 // reflect this change.
237 template
238 void Split(DominatorTreeBase& DT,
239 typename GraphT::NodeType* NewBB) {
240 assert(std::distance(GraphT::child_begin(NewBB),
241 GraphT::child_end(NewBB)) == 1 &&
242 "NewBB should have a single successor!");
243 typename GraphT::NodeType* NewBBSucc = *GraphT::child_begin(NewBB);
244
245 std::vector PredBlocks;
246 typedef GraphTraits > InvTraits;
247 for (typename InvTraits::ChildIteratorType PI =
248 InvTraits::child_begin(NewBB),
249 PE = InvTraits::child_end(NewBB); PI != PE; ++PI)
250 PredBlocks.push_back(*PI);
251
252 assert(!PredBlocks.empty() && "No predblocks?");
253
254 bool NewBBDominatesNewBBSucc = true;
255 for (typename InvTraits::ChildIteratorType PI =
256 InvTraits::child_begin(NewBBSucc),
257 E = InvTraits::child_end(NewBBSucc); PI != E; ++PI) {
258 typename InvTraits::NodeType *ND = *PI;
259 if (ND != NewBB && !DT.dominates(NewBBSucc, ND) &&
260 DT.isReachableFromEntry(ND)) {
261 NewBBDominatesNewBBSucc = false;
262 break;
263 }
264 }
265
266 // Find NewBB's immediate dominator and create new dominator tree node for
267 // NewBB.
268 NodeT *NewBBIDom = 0;
269 unsigned i = 0;
270 for (i = 0; i < PredBlocks.size(); ++i)
271 if (DT.isReachableFromEntry(PredBlocks[i])) {
272 NewBBIDom = PredBlocks[i];
273 break;
274 }
275
276 // It's possible that none of the predecessors of NewBB are reachable;
277 // in that case, NewBB itself is unreachable, so nothing needs to be
278 // changed.
279 if (!NewBBIDom)
280 return;
281
282 for (i = i + 1; i < PredBlocks.size(); ++i) {
283 if (DT.isReachableFromEntry(PredBlocks[i]))
284 NewBBIDom = DT.findNearestCommonDominator(NewBBIDom, PredBlocks[i]);
285 }
286
287 // Create the new dominator tree node... and set the idom of NewBB.
288 DomTreeNodeBase *NewBBNode = DT.addNewBlock(NewBB, NewBBIDom);
289
290 // If NewBB strictly dominates other blocks, then it is now the immediate
291 // dominator of NewBBSucc. Update the dominator tree as appropriate.
292 if (NewBBDominatesNewBBSucc) {
293 DomTreeNodeBase *NewBBSuccNode = DT.getNode(NewBBSucc);
294 DT.changeImmediateDominator(NewBBSuccNode, NewBBNode);
295 }
296 }
297
298 public:
299 explicit DominatorTreeBase(bool isPostDom)
300 : DominatorBase(isPostDom), DFSInfoValid(false), SlowQueries(0) {}
301 virtual ~DominatorTreeBase() { reset(); }
302
303 /// compare - Return false if the other dominator tree base matches this
304 /// dominator tree base. Otherwise return true.
305 bool compare(DominatorTreeBase &Other) const {
306
307 const DomTreeNodeMapType &OtherDomTreeNodes = Other.DomTreeNodes;
308 if (DomTreeNodes.size() != OtherDomTreeNodes.size())
309 return true;
310
311 for (typename DomTreeNodeMapType::const_iterator
312 I = this->DomTreeNodes.begin(),
313 E = this->DomTreeNodes.end(); I != E; ++I) {
314 NodeT *BB = I->first;
315 typename DomTreeNodeMapType::const_iterator OI = OtherDomTreeNodes.find(BB);
316 if (OI == OtherDomTreeNodes.end())
317 return true;
318
319 DomTreeNodeBase* MyNd = I->second;
320 DomTreeNodeBase* OtherNd = OI->second;
321
322 if (MyNd->compare(OtherNd))
323 return true;
324 }
325
326 return false;
327 }
328
329 virtual void releaseMemory() { reset(); }
330
331 /// getNode - return the (Post)DominatorTree node for the specified basic
332 /// block. This is the same as using operator[] on this class.
333 ///
334 inline DomTreeNodeBase *getNode(NodeT *BB) const {
335 return DomTreeNodes.lookup(BB);
336 }
337
338 /// getRootNode - This returns the entry node for the CFG of the function. If
339 /// this tree represents the post-dominance relations for a function, however,
340 /// this root may be a node with the block == NULL. This is the case when
341 /// there are multiple exit nodes from a particular function. Consumers of
342 /// post-dominance information must be capable of dealing with this
343 /// possibility.
344 ///
345 DomTreeNodeBase *getRootNode() { return RootNode; }
346 const DomTreeNodeBase *getRootNode() const { return RootNode; }
347
348 /// Get all nodes dominated by R, including R itself.
349 void getDescendants(NodeT *R, SmallVectorImpl &Result) const {
350 Result.clear();
351 const DomTreeNodeBase *RN = getNode(R);
352 if (RN == NULL)
353 return; // If R is unreachable, it will not be present in the DOM tree.
354 SmallVector *, 8> WL;
355 WL.push_back(RN);
356
357 while (!WL.empty()) {
358 const DomTreeNodeBase *N = WL.pop_back_val();
359 Result.push_back(N->getBlock());
360 WL.append(N->begin(), N->end());
361 }
362 }
363
364 /// properlyDominates - Returns true iff A dominates B and A != B.
365 /// Note that this is not a constant time operation!
366 ///
367 bool properlyDominates(const DomTreeNodeBase *A,
368 const DomTreeNodeBase *B) {
369 if (A == 0 || B == 0)
370 return false;
371 if (A == B)
372 return false;
373 return dominates(A, B);
374 }
375
376 bool properlyDominates(const NodeT *A, const NodeT *B);
377
378 /// isReachableFromEntry - Return true if A is dominated by the entry
379 /// block of the function containing it.
380 bool isReachableFromEntry(const NodeT* A) const {
381 assert(!this->isPostDominator() &&
382 "This is not implemented for post dominators");
383 return isReachableFromEntry(getNode(const_cast(A)));
384 }
385
386 inline bool isReachableFromEntry(const DomTreeNodeBase *A) const {
387 return A;
388 }
389
390 /// dominates - Returns true iff A dominates B. Note that this is not a
391 /// constant time operation!
392 ///
393 inline bool dominates(const DomTreeNodeBase *A,
394 const DomTreeNodeBase *B) {
395 // A node trivially dominates itself.
396 if (B == A)
397 return true;
398
399 // An unreachable node is dominated by anything.
400 if (!isReachableFromEntry(B))
401 return true;
402
403 // And dominates nothing.
404 if (!isReachableFromEntry(A))
405 return false;
406
407 // Compare the result of the tree walk and the dfs numbers, if expensive
408 // checks are enabled.
409 #ifdef XDEBUG
410 assert((!DFSInfoValid ||
411 (dominatedBySlowTreeWalk(A, B) == B->DominatedBy(A))) &&
412 "Tree walk disagrees with dfs numbers!");
413 #endif
414
415 if (DFSInfoValid)
416 return B->DominatedBy(A);
417
418 // If we end up with too many slow queries, just update the
419 // DFS numbers on the theory that we are going to keep querying.
420 SlowQueries++;
421 if (SlowQueries > 32) {
422 updateDFSNumbers();
423 return B->DominatedBy(A);
424 }
425
426 return dominatedBySlowTreeWalk(A, B);
427 }
428
429 bool dominates(const NodeT *A, const NodeT *B);
430
431 NodeT *getRoot() const {
432 assert(this->Roots.size() == 1 && "Should always have entry node!");
433 return this->Roots[0];
434 }
435
436 /// findNearestCommonDominator - Find nearest common dominator basic block
437 /// for basic block A and B. If there is no such block then return NULL.
438 NodeT *findNearestCommonDominator(NodeT *A, NodeT *B) {
439 assert(A->getParent() == B->getParent() &&
440 "Two blocks are not in same function");
441
442 // If either A or B is a entry block then it is nearest common dominator
443 // (for forward-dominators).
444 if (!this->isPostDominator()) {
445 NodeT &Entry = A->getParent()->front();
446 if (A == &Entry || B == &Entry)
447 return &Entry;
448 }
449
450 // If B dominates A then B is nearest common dominator.
451 if (dominates(B, A))
452 return B;
453
454 // If A dominates B then A is nearest common dominator.
455 if (dominates(A, B))
456 return A;
457
458 DomTreeNodeBase *NodeA = getNode(A);
459 DomTreeNodeBase *NodeB = getNode(B);
460
461 // Collect NodeA dominators set.
462 SmallPtrSet*, 16> NodeADoms;
463 NodeADoms.insert(NodeA);
464 DomTreeNodeBase *IDomA = NodeA->getIDom();
465 while (IDomA) {
466 NodeADoms.insert(IDomA);
467 IDomA = IDomA->getIDom();
468 }
469
470 // Walk NodeB immediate dominators chain and find common dominator node.
471 DomTreeNodeBase *IDomB = NodeB->getIDom();
472 while (IDomB) {
473 if (NodeADoms.count(IDomB) != 0)
474 return IDomB->getBlock();
475
476 IDomB = IDomB->getIDom();
477 }
478
479 return NULL;
480 }
481
482 const NodeT *findNearestCommonDominator(const NodeT *A, const NodeT *B) {
483 // Cast away the const qualifiers here. This is ok since
484 // const is re-introduced on the return type.
485 return findNearestCommonDominator(const_cast(A),
486 const_cast(B));
487 }
488
489 //===--------------------------------------------------------------------===//
490 // API to update (Post)DominatorTree information based on modifications to
491 // the CFG...
492
493 /// addNewBlock - Add a new node to the dominator tree information. This
494 /// creates a new node as a child of DomBB dominator node,linking it into
495 /// the children list of the immediate dominator.
496 DomTreeNodeBase *addNewBlock(NodeT *BB, NodeT *DomBB) {
497 assert(getNode(BB) == 0 && "Block already in dominator tree!");
498 DomTreeNodeBase *IDomNode = getNode(DomBB);
499 assert(IDomNode && "Not immediate dominator specified for block!");
500 DFSInfoValid = false;
501 return DomTreeNodes[BB] =
502 IDomNode->addChild(new DomTreeNodeBase(BB, IDomNode));
503 }
504
505 /// changeImmediateDominator - This method is used to update the dominator
506 /// tree information when a node's immediate dominator changes.
507 ///
508 void changeImmediateDominator(DomTreeNodeBase *N,
509 DomTreeNodeBase *NewIDom) {
510 assert(N && NewIDom && "Cannot change null node pointers!");
511 DFSInfoValid = false;
512 N->setIDom(NewIDom);
513 }
514
515 void changeImmediateDominator(NodeT *BB, NodeT *NewBB) {
516 changeImmediateDominator(getNode(BB), getNode(NewBB));
517 }
518
519 /// eraseNode - Removes a node from the dominator tree. Block must not
520 /// dominate any other blocks. Removes node from its immediate dominator's
521 /// children list. Deletes dominator node associated with basic block BB.
522 void eraseNode(NodeT *BB) {
523 DomTreeNodeBase *Node = getNode(BB);
524 assert(Node && "Removing node that isn't in dominator tree.");
525 assert(Node->getChildren().empty() && "Node is not a leaf node.");
526
527 // Remove node from immediate dominator's children list.
528 DomTreeNodeBase *IDom = Node->getIDom();
529 if (IDom) {
530 typename std::vector*>::iterator I =
531 std::find(IDom->Children.begin(), IDom->Children.end(), Node);
532 assert(I != IDom->Children.end() &&
533 "Not in immediate dominator children set!");
534 // I am no longer your child...
535 IDom->Children.erase(I);
536 }
537
538 DomTreeNodes.erase(BB);
539 delete Node;
540 }
541
542 /// removeNode - Removes a node from the dominator tree. Block must not
543 /// dominate any other blocks. Invalidates any node pointing to removed
544 /// block.
545 void removeNode(NodeT *BB) {
546 assert(getNode(BB) && "Removing node that isn't in dominator tree.");
547 DomTreeNodes.erase(BB);
548 }
549
550 /// splitBlock - BB is split and now it has one successor. Update dominator
551 /// tree to reflect this change.
552 void splitBlock(NodeT* NewBB) {
553 if (this->IsPostDominators)
554 this->Split, GraphTraits > >(*this, NewBB);
555 else
556 this->Split >(*this, NewBB);
557 }
558
559 /// print - Convert to human readable form
560 ///
561 void print(raw_ostream &o) const {
562 o << "=============================--------------------------------\n";
563 if (this->isPostDominator())
564 o << "Inorder PostDominator Tree: ";
565 else
566 o << "Inorder Dominator Tree: ";
567 if (!this->DFSInfoValid)
568 o << "DFSNumbers invalid: " << SlowQueries << " slow queries.";
569 o << "\n";
570
571 // The postdom tree can have a null root if there are no returns.
572 if (getRootNode())
573 PrintDomTree(getRootNode(), o, 1);
574 }
575
576 protected:
577 template
578 friend typename GraphT::NodeType* Eval(
579 DominatorTreeBase& DT,
580 typename GraphT::NodeType* V,
581 unsigned LastLinked);
582
583 template
584 friend unsigned DFSPass(DominatorTreeBase& DT,
585 typename GraphT::NodeType* V,
586 unsigned N);
587
588 template
589 friend void Calculate(DominatorTreeBase::NodeType>& DT,
590 FuncT& F);
591
592 /// updateDFSNumbers - Assign In and Out numbers to the nodes while walking
593 /// dominator tree in dfs order.
594 void updateDFSNumbers() {
595 unsigned DFSNum = 0;
596
597 SmallVector*,
598 typename DomTreeNodeBase::iterator>, 32> WorkStack;
599
600 DomTreeNodeBase *ThisRoot = getRootNode();
601
602 if (!ThisRoot)
603 return;
604
605 // Even in the case of multiple exits that form the post dominator root
606 // nodes, do not iterate over all exits, but start from the virtual root
607 // node. Otherwise bbs, that are not post dominated by any exit but by the
608 // virtual root node, will never be assigned a DFS number.
609 WorkStack.push_back(std::make_pair(ThisRoot, ThisRoot->begin()));
610 ThisRoot->DFSNumIn = DFSNum++;
611
612 while (!WorkStack.empty()) {
613 DomTreeNodeBase *Node = WorkStack.back().first;
614 typename DomTreeNodeBase::iterator ChildIt =
615 WorkStack.back().second;
616
617 // If we visited all of the children of this node, "recurse" back up the
618 // stack setting the DFOutNum.
619 if (ChildIt == Node->end()) {
620 Node->DFSNumOut = DFSNum++;
621 WorkStack.pop_back();
622 } else {
623 // Otherwise, recursively visit this child.
624 DomTreeNodeBase *Child = *ChildIt;
625 ++WorkStack.back().second;
626
627 WorkStack.push_back(std::make_pair(Child, Child->begin()));
628 Child->DFSNumIn = DFSNum++;
629 }
630 }
631
632 SlowQueries = 0;
633 DFSInfoValid = true;
634 }
635
636 DomTreeNodeBase *getNodeForBlock(NodeT *BB) {
637 if (DomTreeNodeBase *Node = getNode(BB))
638 return Node;
639
640 // Haven't calculated this node yet? Get or calculate the node for the
641 // immediate dominator.
642 NodeT *IDom = getIDom(BB);
643
644 assert(IDom || this->DomTreeNodes[NULL]);
645 DomTreeNodeBase *IDomNode = getNodeForBlock(IDom);
646
647 // Add a new tree node for this BasicBlock, and link it as a child of
648 // IDomNode
649 DomTreeNodeBase *C = new DomTreeNodeBase(BB, IDomNode);
650 return this->DomTreeNodes[BB] = IDomNode->addChild(C);
651 }
652
653 inline NodeT *getIDom(NodeT *BB) const {
654 return IDoms.lookup(BB);
655 }
656
657 inline void addRoot(NodeT* BB) {
658 this->Roots.push_back(BB);
659 }
660
661 public:
662 /// recalculate - compute a dominator tree for the given function
663 template
664 void recalculate(FT& F) {
665 typedef GraphTraits TraitsTy;
666 reset();
667 this->Vertex.push_back(0);
668
669 if (!this->IsPostDominators) {
670 // Initialize root
671 NodeT *entry = TraitsTy::getEntryNode(&F);
672 this->Roots.push_back(entry);
673 this->IDoms[entry] = 0;
674 this->DomTreeNodes[entry] = 0;
675
676 Calculate(*this, F);
677 } else {
678 // Initialize the roots list
679 for (typename TraitsTy::nodes_iterator I = TraitsTy::nodes_begin(&F),
680 E = TraitsTy::nodes_end(&F); I != E; ++I) {
681 if (TraitsTy::child_begin(I) == TraitsTy::child_end(I))
682 addRoot(I);
683
684 // Prepopulate maps so that we don't get iterator invalidation issues later.
685 this->IDoms[I] = 0;
686 this->DomTreeNodes[I] = 0;
687 }
688
689 Calculate >(*this, F);
690 }
691 }
692 };
693
694 // These two functions are declared out of line as a workaround for building
695 // with old (< r147295) versions of clang because of pr11642.
696 template
697 bool DominatorTreeBase::dominates(const NodeT *A, const NodeT *B) {
698 if (A == B)
699 return true;
700
701 // Cast away the const qualifiers here. This is ok since
702 // this function doesn't actually return the values returned
703 // from getNode.
704 return dominates(getNode(const_cast(A)),
705 getNode(const_cast(B)));
706 }
707 template
708 bool
709 DominatorTreeBase::properlyDominates(const NodeT *A, const NodeT *B) {
710 if (A == B)
711 return false;
712
713 // Cast away the const qualifiers here. This is ok since
714 // this function doesn't actually return the values returned
715 // from getNode.
716 return dominates(getNode(const_cast(A)),
717 getNode(const_cast(B)));
718 }
719
720 EXTERN_TEMPLATE_INSTANTIATION(class DominatorTreeBase);
72137
72238 class BasicBlockEdge {
72339 const BasicBlock *Start;
4848 FunctionPass *
4949 createVerifierPass(VerifierFailureAction action = AbortProcessAction);
5050
51 /// \brief Check a function for errors, useful for use when debugging a
52 /// pass.
53 bool verifyFunction(const Function &F,
54 VerifierFailureAction action = AbortProcessAction);
55
5156 /// \brief Check a module for errors.
5257 ///
5358 /// If there are no errors, the function returns false. If an error is found,
5863 VerifierFailureAction action = AbortProcessAction,
5964 std::string *ErrorInfo = 0);
6065
61 /// \brief Check a function for errors, useful for use when debugging a
62 /// pass.
63 bool verifyFunction(const Function &F,
64 VerifierFailureAction action = AbortProcessAction);
65
6666 } // End llvm namespace
6767
6868 #endif
0 //===- GenericDomTree.h - Generic dominator trees for graphs ----*- C++ -*-===//
1 //
2 // The LLVM Compiler Infrastructure
3 //
4 // This file is distributed under the University of Illinois Open Source
5 // License. See LICENSE.TXT for details.
6 //
7 //===----------------------------------------------------------------------===//
8 /// \file
9 ///
10 /// This file defines a set of templates that efficiently compute a dominator
11 /// tree over a generic graph. This is used typically in LLVM for fast
12 /// dominance queries on the CFG, but is fully generic w.r.t. the underlying
13 /// graph types.
14 ///
15 //===----------------------------------------------------------------------===//
16
17 #ifndef LLVM_SUPPORT_GENERIC_DOM_TREE_H
18 #define LLVM_SUPPORT_GENERIC_DOM_TREE_H
19
20 #include "llvm/ADT/DenseMap.h"
21 #include "llvm/ADT/DepthFirstIterator.h"
22 #include "llvm/ADT/GraphTraits.h"
23 #include "llvm/ADT/SmallPtrSet.h"
24 #include "llvm/ADT/SmallVector.h"
25 #include "llvm/Support/CFG.h"
26 #include "llvm/Support/Compiler.h"
27 #include "llvm/Support/raw_ostream.h"
28 #include
29
30 namespace llvm {
31
32 //===----------------------------------------------------------------------===//
33 /// DominatorBase - Base class that other, more interesting dominator analyses
34 /// inherit from.
35 ///
36 template
37 class DominatorBase {
38 protected:
39 std::vector Roots;
40 const bool IsPostDominators;
41 inline explicit DominatorBase(bool isPostDom) :
42 Roots(), IsPostDominators(isPostDom) {}
43 public:
44
45 /// getRoots - Return the root blocks of the current CFG. This may include
46 /// multiple blocks if we are computing post dominators. For forward
47 /// dominators, this will always be a single block (the entry node).
48 ///
49 inline const std::vector &getRoots() const { return Roots; }
50
51 /// isPostDominator - Returns true if analysis based of postdoms
52 ///
53 bool isPostDominator() const { return IsPostDominators; }
54 };
55
56
57 //===----------------------------------------------------------------------===//
58 // DomTreeNodeBase - Dominator Tree Node
59 template class DominatorTreeBase;
60 struct PostDominatorTree;
61
62 template
63 class DomTreeNodeBase {
64 NodeT *TheBB;
65 DomTreeNodeBase *IDom;
66 std::vector *> Children;
67 int DFSNumIn, DFSNumOut;
68
69 template friend class DominatorTreeBase;
70 friend struct PostDominatorTree;
71 public:
72 typedef typename std::vector *>::iterator iterator;
73 typedef typename std::vector *>::const_iterator
74 const_iterator;
75
76 iterator begin() { return Children.begin(); }
77 iterator end() { return Children.end(); }
78 const_iterator begin() const { return Children.begin(); }
79 const_iterator end() const { return Children.end(); }
80
81 NodeT *getBlock() const { return TheBB; }
82 DomTreeNodeBase *getIDom() const { return IDom; }
83 const std::vector*> &getChildren() const {
84 return Children;
85 }
86
87 DomTreeNodeBase(NodeT *BB, DomTreeNodeBase *iDom)
88 : TheBB(BB), IDom(iDom), DFSNumIn(-1), DFSNumOut(-1) { }
89
90 DomTreeNodeBase *addChild(DomTreeNodeBase *C) {
91 Children.push_back(C);
92 return C;
93 }
94
95 size_t getNumChildren() const {
96 return Children.size();
97 }
98
99 void clearAllChildren() {
100 Children.clear();
101 }
102
103 bool compare(const DomTreeNodeBase *Other) const {
104 if (getNumChildren() != Other->getNumChildren())
105 return true;
106
107 SmallPtrSet OtherChildren;
108 for (const_iterator I = Other->begin(), E = Other->end(); I != E; ++I) {
109 const NodeT *Nd = (*I)->getBlock();
110 OtherChildren.insert(Nd);
111 }
112
113 for (const_iterator I = begin(), E = end(); I != E; ++I) {
114 const NodeT *N = (*I)->getBlock();
115 if (OtherChildren.count(N) == 0)
116 return true;
117 }
118 return false;
119 }
120
121 void setIDom(DomTreeNodeBase *NewIDom) {
122 assert(IDom && "No immediate dominator?");
123 if (IDom != NewIDom) {
124 typename std::vector*>::iterator I =
125 std::find(IDom->Children.begin(), IDom->Children.end(), this);
126 assert(I != IDom->Children.end() &&
127 "Not in immediate dominator children set!");
128 // I am no longer your child...
129 IDom->Children.erase(I);
130
131 // Switch to new dominator
132 IDom = NewIDom;
133 IDom->Children.push_back(this);
134 }
135 }
136
137 /// getDFSNumIn/getDFSNumOut - These are an internal implementation detail, do
138 /// not call them.
139 unsigned getDFSNumIn() const { return DFSNumIn; }
140 unsigned getDFSNumOut() const { return DFSNumOut; }
141 private:
142 // Return true if this node is dominated by other. Use this only if DFS info
143 // is valid.
144 bool DominatedBy(const DomTreeNodeBase *other) const {
145 return this->DFSNumIn >= other->DFSNumIn &&
146 this->DFSNumOut <= other->DFSNumOut;
147 }
148 };
149
150 template
151 inline raw_ostream &operator<<(raw_ostream &o,
152 const DomTreeNodeBase *Node) {
153 if (Node->getBlock())
154 Node->getBlock()->printAsOperand(o, false);
155 else
156 o << " <>";
157
158 o << " {" << Node->getDFSNumIn() << "," << Node->getDFSNumOut() << "}";
159
160 return o << "\n";
161 }
162
163 template
164 inline void PrintDomTree(const DomTreeNodeBase *N, raw_ostream &o,
165 unsigned Lev) {
166 o.indent(2*Lev) << "[" << Lev << "] " << N;
167 for (typename DomTreeNodeBase::const_iterator I = N->begin(),
168 E = N->end(); I != E; ++I)
169 PrintDomTree(*I, o, Lev+1);
170 }
171
172 //===----------------------------------------------------------------------===//
173 /// DominatorTree - Calculate the immediate dominator tree for a function.
174 ///
175
176 template
177 void Calculate(DominatorTreeBase::NodeType>& DT,
178 FuncT& F);
179
180 template
181 class DominatorTreeBase : public DominatorBase {
182 bool dominatedBySlowTreeWalk(const DomTreeNodeBase *A,
183 const DomTreeNodeBase *B) const {
184 assert(A != B);
185 assert(isReachableFromEntry(B));
186 assert(isReachableFromEntry(A));
187
188 const DomTreeNodeBase *IDom;
189 while ((IDom = B->getIDom()) != 0 && IDom != A && IDom != B)
190 B = IDom; // Walk up the tree
191 return IDom != 0;
192 }
193
194 protected:
195 typedef DenseMap*> DomTreeNodeMapType;
196 DomTreeNodeMapType DomTreeNodes;
197 DomTreeNodeBase *RootNode;
198
199 bool DFSInfoValid;
200 unsigned int SlowQueries;
201 // Information record used during immediate dominators computation.
202 struct InfoRec {
203 unsigned DFSNum;
204 unsigned Parent;
205 unsigned Semi;
206 NodeT *Label;
207
208 InfoRec() : DFSNum(0), Parent(0), Semi(0), Label(0) {}
209 };
210
211 DenseMap IDoms;
212
213 // Vertex - Map the DFS number to the NodeT*
214 std::vector Vertex;
215
216 // Info - Collection of information used during the computation of idoms.
217 DenseMap Info;
218
219 void reset() {
220 for (typename DomTreeNodeMapType::iterator I = this->DomTreeNodes.begin(),
221 E = DomTreeNodes.end(); I != E; ++I)
222 delete I->second;
223 DomTreeNodes.clear();
224 IDoms.clear();
225 this->Roots.clear();
226 Vertex.clear();
227 RootNode = 0;
228 }
229
230 // NewBB is split and now it has one successor. Update dominator tree to
231 // reflect this change.
232 template
233 void Split(DominatorTreeBase& DT,
234 typename GraphT::NodeType* NewBB) {
235 assert(std::distance(GraphT::child_begin(NewBB),
236 GraphT::child_end(NewBB)) == 1 &&
237 "NewBB should have a single successor!");
238 typename GraphT::NodeType* NewBBSucc = *GraphT::child_begin(NewBB);
239
240 std::vector PredBlocks;
241 typedef GraphTraits > InvTraits;
242 for (typename InvTraits::ChildIteratorType PI =
243 InvTraits::child_begin(NewBB),
244 PE = InvTraits::child_end(NewBB); PI != PE; ++PI)
245 PredBlocks.push_back(*PI);
246
247 assert(!PredBlocks.empty() && "No predblocks?");
248
249 bool NewBBDominatesNewBBSucc = true;
250 for (typename InvTraits::ChildIteratorType PI =
251 InvTraits::child_begin(NewBBSucc),
252 E = InvTraits::child_end(NewBBSucc); PI != E; ++PI) {
253 typename InvTraits::NodeType *ND = *PI;
254 if (ND != NewBB && !DT.dominates(NewBBSucc, ND) &&
255 DT.isReachableFromEntry(ND)) {
256 NewBBDominatesNewBBSucc = false;
257 break;
258 }
259 }
260
261 // Find NewBB's immediate dominator and create new dominator tree node for
262 // NewBB.
263 NodeT *NewBBIDom = 0;
264 unsigned i = 0;
265 for (i = 0; i < PredBlocks.size(); ++i)
266 if (DT.isReachableFromEntry(PredBlocks[i])) {
267 NewBBIDom = PredBlocks[i];
268 break;
269 }
270
271 // It's possible that none of the predecessors of NewBB are reachable;
272 // in that case, NewBB itself is unreachable, so nothing needs to be
273 // changed.
274 if (!NewBBIDom)
275 return;
276
277 for (i = i + 1; i < PredBlocks.size(); ++i) {
278 if (DT.isReachableFromEntry(PredBlocks[i]))
279 NewBBIDom = DT.findNearestCommonDominator(NewBBIDom, PredBlocks[i]);
280 }
281
282 // Create the new dominator tree node... and set the idom of NewBB.
283 DomTreeNodeBase *NewBBNode = DT.addNewBlock(NewBB, NewBBIDom);
284
285 // If NewBB strictly dominates other blocks, then it is now the immediate
286 // dominator of NewBBSucc. Update the dominator tree as appropriate.
287 if (NewBBDominatesNewBBSucc) {
288 DomTreeNodeBase *NewBBSuccNode = DT.getNode(NewBBSucc);
289 DT.changeImmediateDominator(NewBBSuccNode, NewBBNode);
290 }
291 }
292
293 public:
294 explicit DominatorTreeBase(bool isPostDom)
295 : DominatorBase(isPostDom), DFSInfoValid(false), SlowQueries(0) {}
296 virtual ~DominatorTreeBase() { reset(); }
297
298 /// compare - Return false if the other dominator tree base matches this
299 /// dominator tree base. Otherwise return true.
300 bool compare(DominatorTreeBase &Other) const {
301
302 const DomTreeNodeMapType &OtherDomTreeNodes = Other.DomTreeNodes;
303 if (DomTreeNodes.size() != OtherDomTreeNodes.size())
304 return true;
305
306 for (typename DomTreeNodeMapType::const_iterator
307 I = this->DomTreeNodes.begin(),
308 E = this->DomTreeNodes.end(); I != E; ++I) {
309 NodeT *BB = I->first;
310 typename DomTreeNodeMapType::const_iterator OI = OtherDomTreeNodes.find(BB);
311 if (OI == OtherDomTreeNodes.end())
312 return true;
313
314 DomTreeNodeBase* MyNd = I->second;
315 DomTreeNodeBase* OtherNd = OI->second;
316
317 if (MyNd->compare(OtherNd))
318 return true;
319 }
320
321 return false;
322 }
323
324 virtual void releaseMemory() { reset(); }
325
326 /// getNode - return the (Post)DominatorTree node for the specified basic
327 /// block. This is the same as using operator[] on this class.
328 ///
329 inline DomTreeNodeBase *getNode(NodeT *BB) const {
330 return DomTreeNodes.lookup(BB);
331 }
332
333 /// getRootNode - This returns the entry node for the CFG of the function. If
334 /// this tree represents the post-dominance relations for a function, however,
335 /// this root may be a node with the block == NULL. This is the case when
336 /// there are multiple exit nodes from a particular function. Consumers of
337 /// post-dominance information must be capable of dealing with this
338 /// possibility.
339 ///
340 DomTreeNodeBase *getRootNode() { return RootNode; }
341 const DomTreeNodeBase *getRootNode() const { return RootNode; }
342
343 /// Get all nodes dominated by R, including R itself.
344 void getDescendants(NodeT *R, SmallVectorImpl &Result) const {
345 Result.clear();
346 const DomTreeNodeBase *RN = getNode(R);
347 if (RN == NULL)
348 return; // If R is unreachable, it will not be present in the DOM tree.
349 SmallVector *, 8> WL;
350 WL.push_back(RN);
351
352 while (!WL.empty()) {
353 const DomTreeNodeBase *N = WL.pop_back_val();
354 Result.push_back(N->getBlock());
355 WL.append(N->begin(), N->end());
356 }
357 }
358
359 /// properlyDominates - Returns true iff A dominates B and A != B.
360 /// Note that this is not a constant time operation!
361 ///
362 bool properlyDominates(const DomTreeNodeBase *A,
363 const DomTreeNodeBase *B) {
364 if (A == 0 || B == 0)
365 return false;
366 if (A == B)
367 return false;
368 return dominates(A, B);
369 }
370
371 bool properlyDominates(const NodeT *A, const NodeT *B);
372
373 /// isReachableFromEntry - Return true if A is dominated by the entry
374 /// block of the function containing it.
375 bool isReachableFromEntry(const NodeT* A) const {
376 assert(!this->isPostDominator() &&
377 "This is not implemented for post dominators");
378 return isReachableFromEntry(getNode(const_cast(A)));
379 }
380
381 inline bool isReachableFromEntry(const DomTreeNodeBase *A) const {
382 return A;
383 }
384
385 /// dominates - Returns true iff A dominates B. Note that this is not a
386 /// constant time operation!
387 ///
388 inline bool dominates(const DomTreeNodeBase *A,
389 const DomTreeNodeBase *B) {
390 // A node trivially dominates itself.
391 if (B == A)
392 return true;
393
394 // An unreachable node is dominated by anything.
395 if (!isReachableFromEntry(B))
396 return true;
397
398 // And dominates nothing.
399 if (!isReachableFromEntry(A))
400 return false;
401
402 // Compare the result of the tree walk and the dfs numbers, if expensive
403 // checks are enabled.
404 #ifdef XDEBUG
405 assert((!DFSInfoValid ||
406 (dominatedBySlowTreeWalk(A, B) == B->DominatedBy(A))) &&
407 "Tree walk disagrees with dfs numbers!");
408 #endif
409
410 if (DFSInfoValid)
411 return B->DominatedBy(A);
412
413 // If we end up with too many slow queries, just update the
414 // DFS numbers on the theory that we are going to keep querying.
415 SlowQueries++;
416 if (SlowQueries > 32) {
417 updateDFSNumbers();
418 return B->DominatedBy(A);
419 }
420
421 return dominatedBySlowTreeWalk(A, B);
422 }
423
424 bool dominates(const NodeT *A, const NodeT *B);
425
426 NodeT *getRoot() const {
427 assert(this->Roots.size() == 1 && "Should always have entry node!");
428 return this->Roots[0];
429 }
430
431 /// findNearestCommonDominator - Find nearest common dominator basic block
432 /// for basic block A and B. If there is no such block then return NULL.
433 NodeT *findNearestCommonDominator(NodeT *A, NodeT *B) {
434 assert(A->getParent() == B->getParent() &&
435 "Two blocks are not in same function");
436
437 // If either A or B is a entry block then it is nearest common dominator
438 // (for forward-dominators).
439 if (!this->isPostDominator()) {
440 NodeT &Entry = A->getParent()->front();
441 if (A == &Entry || B == &Entry)
442 return &Entry;
443 }
444
445 // If B dominates A then B is nearest common dominator.
446 if (dominates(B, A))
447 return B;
448
449 // If A dominates B then A is nearest common dominator.
450 if (dominates(A, B))
451 return A;
452
453 DomTreeNodeBase *NodeA = getNode(A);
454 DomTreeNodeBase *NodeB = getNode(B);
455
456 // Collect NodeA dominators set.
457 SmallPtrSet*, 16> NodeADoms;
458 NodeADoms.insert(NodeA);
459 DomTreeNodeBase *IDomA = NodeA->getIDom();
460 while (IDomA) {
461 NodeADoms.insert(IDomA);
462 IDomA = IDomA->getIDom();
463 }
464
465 // Walk NodeB immediate dominators chain and find common dominator node.
466 DomTreeNodeBase *IDomB = NodeB->getIDom();
467 while (IDomB) {
468 if (NodeADoms.count(IDomB) != 0)
469 return IDomB->getBlock();
470
471 IDomB = IDomB->getIDom();
472 }
473
474 return NULL;
475 }
476
477 const NodeT *findNearestCommonDominator(const NodeT *A, const NodeT *B) {
478 // Cast away the const qualifiers here. This is ok since
479 // const is re-introduced on the return type.
480 return findNearestCommonDominator(const_cast(A),
481 const_cast(B));
482 }
483
484 //===--------------------------------------------------------------------===//
485 // API to update (Post)DominatorTree information based on modifications to
486 // the CFG...
487
488 /// addNewBlock - Add a new node to the dominator tree information. This
489 /// creates a new node as a child of DomBB dominator node,linking it into
490 /// the children list of the immediate dominator.
491 DomTreeNodeBase *addNewBlock(NodeT *BB, NodeT *DomBB) {
492 assert(getNode(BB) == 0 && "Block already in dominator tree!");
493 DomTreeNodeBase *IDomNode = getNode(DomBB);
494 assert(IDomNode && "Not immediate dominator specified for block!");
495 DFSInfoValid = false;
496 return DomTreeNodes[BB] =
497 IDomNode->addChild(new DomTreeNodeBase(BB, IDomNode));
498 }
499
500 /// changeImmediateDominator - This method is used to update the dominator
501 /// tree information when a node's immediate dominator changes.
502 ///
503 void changeImmediateDominator(DomTreeNodeBase *N,
504 DomTreeNodeBase *NewIDom) {
505 assert(N && NewIDom && "Cannot change null node pointers!");
506 DFSInfoValid = false;
507 N->setIDom(NewIDom);
508 }
509
510 void changeImmediateDominator(NodeT *BB, NodeT *NewBB) {
511 changeImmediateDominator(getNode(BB), getNode(NewBB));
512 }
513
514 /// eraseNode - Removes a node from the dominator tree. Block must not
515 /// dominate any other blocks. Removes node from its immediate dominator's
516 /// children list. Deletes dominator node associated with basic block BB.
517 void eraseNode(NodeT *BB) {
518 DomTreeNodeBase *Node = getNode(BB);
519 assert(Node && "Removing node that isn't in dominator tree.");
520 assert(Node->getChildren().empty() && "Node is not a leaf node.");
521
522 // Remove node from immediate dominator's children list.
523 DomTreeNodeBase *IDom = Node->getIDom();
524 if (IDom) {
525 typename std::vector*>::iterator I =
526 std::find(IDom->Children.begin(), IDom->Children.end(), Node);
527 assert(I != IDom->Children.end() &&
528 "Not in immediate dominator children set!");
529 // I am no longer your child...
530 IDom->Children.erase(I);
531 }
532
533 DomTreeNodes.erase(BB);
534 delete Node;
535 }
536
537 /// removeNode - Removes a node from the dominator tree. Block must not
538 /// dominate any other blocks. Invalidates any node pointing to removed
539 /// block.
540 void removeNode(NodeT *BB) {
541 assert(getNode(BB) && "Removing node that isn't in dominator tree.");
542 DomTreeNodes.erase(BB);
543 }
544
545 /// splitBlock - BB is split and now it has one successor. Update dominator
546 /// tree to reflect this change.
547 void splitBlock(NodeT* NewBB) {
548 if (this->IsPostDominators)
549 this->Split, GraphTraits > >(*this, NewBB);
550 else
551 this->Split >(*this, NewBB);
552 }
553
554 /// print - Convert to human readable form
555 ///
556 void print(raw_ostream &o) const {
557 o << "=============================--------------------------------\n";
558 if (this->isPostDominator())
559 o << "Inorder PostDominator Tree: ";
560 else
561 o << "Inorder Dominator Tree: ";
562 if (!this->DFSInfoValid)
563 o << "DFSNumbers invalid: " << SlowQueries << " slow queries.";
564 o << "\n";
565
566 // The postdom tree can have a null root if there are no returns.
567 if (getRootNode())
568 PrintDomTree(getRootNode(), o, 1);
569 }
570
571 protected:
572 template
573 friend typename GraphT::NodeType* Eval(
574 DominatorTreeBase& DT,
575 typename GraphT::NodeType* V,
576 unsigned LastLinked);
577
578 template
579 friend unsigned DFSPass(DominatorTreeBase& DT,
580 typename GraphT::NodeType* V,
581 unsigned N);
582
583 template
584 friend void Calculate(DominatorTreeBase::NodeType>& DT,
585 FuncT& F);
586
587 /// updateDFSNumbers - Assign In and Out numbers to the nodes while walking
588 /// dominator tree in dfs order.
589 void updateDFSNumbers() {
590 unsigned DFSNum = 0;
591
592 SmallVector*,
593 typename DomTreeNodeBase::iterator>, 32> WorkStack;
594
595 DomTreeNodeBase *ThisRoot = getRootNode();
596
597 if (!ThisRoot)
598 return;
599
600 // Even in the case of multiple exits that form the post dominator root
601 // nodes, do not iterate over all exits, but start from the virtual root
602 // node. Otherwise bbs, that are not post dominated by any exit but by the
603 // virtual root node, will never be assigned a DFS number.
604 WorkStack.push_back(std::make_pair(ThisRoot, ThisRoot->begin()));
605 ThisRoot->DFSNumIn = DFSNum++;
606
607 while (!WorkStack.empty()) {
608 DomTreeNodeBase *Node = WorkStack.back().first;
609 typename DomTreeNodeBase::iterator ChildIt =
610 WorkStack.back().second;
611
612 // If we visited all of the children of this node, "recurse" back up the
613 // stack setting the DFOutNum.
614 if (ChildIt == Node->end()) {
615 Node->DFSNumOut = DFSNum++;
616 WorkStack.pop_back();
617 } else {
618 // Otherwise, recursively visit this child.
619 DomTreeNodeBase *Child = *ChildIt;
620 ++WorkStack.back().second;
621
622 WorkStack.push_back(std::make_pair(Child, Child->begin()));
623 Child->DFSNumIn = DFSNum++;
624 }
625 }
626
627 SlowQueries = 0;
628 DFSInfoValid = true;
629 }
630
631 DomTreeNodeBase *getNodeForBlock(NodeT *BB) {
632 if (DomTreeNodeBase *Node = getNode(BB))
633 return Node;
634
635 // Haven't calculated this node yet? Get or calculate the node for the
636 // immediate dominator.
637 NodeT *IDom = getIDom(BB);
638
639 assert(IDom || this->DomTreeNodes[NULL]);
640 DomTreeNodeBase *IDomNode = getNodeForBlock(IDom);
641
642 // Add a new tree node for this NodeT, and link it as a child of
643 // IDomNode
644 DomTreeNodeBase *C = new DomTreeNodeBase(BB, IDomNode);
645 return this->DomTreeNodes[BB] = IDomNode->addChild(C);
646 }
647
648 inline NodeT *getIDom(NodeT *BB) const {
649 return IDoms.lookup(BB);
650 }
651
652 inline void addRoot(NodeT* BB) {
653 this->Roots.push_back(BB);
654 }
655
656 public:
657 /// recalculate - compute a dominator tree for the given function
658 template
659 void recalculate(FT& F) {
660 typedef GraphTraits TraitsTy;
661 reset();
662 this->Vertex.push_back(0);
663
664 if (!this->IsPostDominators) {
665 // Initialize root
666 NodeT *entry = TraitsTy::getEntryNode(&F);
667 this->Roots.push_back(entry);
668 this->IDoms[entry] = 0;
669 this->DomTreeNodes[entry] = 0;
670
671 Calculate(*this, F);
672 } else {
673 // Initialize the roots list
674 for (typename TraitsTy::nodes_iterator I = TraitsTy::nodes_begin(&F),
675 E = TraitsTy::nodes_end(&F); I != E; ++I) {
676 if (TraitsTy::child_begin(I) == TraitsTy::child_end(I))
677 addRoot(I);
678
679 // Prepopulate maps so that we don't get iterator invalidation issues later.
680 this->IDoms[I] = 0;
681 this->DomTreeNodes[I] = 0;
682 }
683
684 Calculate >(*this, F);
685 }
686 }
687 };
688
689 // These two functions are declared out of line as a workaround for building
690 // with old (< r147295) versions of clang because of pr11642.
691 template
692 bool DominatorTreeBase::dominates(const NodeT *A, const NodeT *B) {
693 if (A == B)
694 return true;
695
696 // Cast away the const qualifiers here. This is ok since
697 // this function doesn't actually return the values returned
698 // from getNode.
699 return dominates(getNode(const_cast(A)),
700 getNode(const_cast(B)));
701 }
702 template
703 bool
704 DominatorTreeBase::properlyDominates(const NodeT *A, const NodeT *B) {
705 if (A == B)
706 return false;
707
708 // Cast away the const qualifiers here. This is ok since
709 // this function doesn't actually return the values returned
710 // from getNode.
711 return dominates(getNode(const_cast(A)),
712 getNode(const_cast(B)));
713 }
714
715 }
716
717 #endif
0 //===- GenericDomTreeConstruction.h - Dominator Calculation ------*- C++ -*-==//
1 //
2 // The LLVM Compiler Infrastructure
3 //
4 // This file is distributed under the University of Illinois Open Source
5 // License. See LICENSE.TXT for details.
6 //
7 //===----------------------------------------------------------------------===//
8 /// \file
9 ///
10 /// Generic dominator tree construction - This file provides rouitens to
11 /// constructs immediate dominator information for a flow-graph based on the
12 /// algorithm described in this document:
13 ///
14 /// A Fast Algorithm for Finding Dominators in a Flowgraph
15 /// T. Lengauer & R. Tarjan, ACM TOPLAS July 1979, pgs 121-141.
16 ///
17 /// This implements the O(n*log(n)) versions of EVAL and LINK, because it turns
18 /// out that the theoretically slower O(n*log(n)) implementation is actually
19 /// faster than the almost-linear O(n*alpha(n)) version, even for large CFGs.
20 ///
21 //===----------------------------------------------------------------------===//
22
23
24 #ifndef LLVM_SUPPORT_GENERIC_DOM_TREE_CONSTRUCTION_H
25 #define LLVM_SUPPORT_GENERIC_DOM_TREE_CONSTRUCTION_H
26
27 #include "llvm/ADT/SmallPtrSet.h"
28 #include "llvm/Support/GenericDomTree.h"
29
30 namespace llvm {
31
32 template
33 unsigned DFSPass(DominatorTreeBase& DT,
34 typename GraphT::NodeType* V, unsigned N) {
35 // This is more understandable as a recursive algorithm, but we can't use the
36 // recursive algorithm due to stack depth issues. Keep it here for
37 // documentation purposes.
38 #if 0
39 InfoRec &VInfo = DT.Info[DT.Roots[i]];
40 VInfo.DFSNum = VInfo.Semi = ++N;
41 VInfo.Label = V;
42
43 Vertex.push_back(V); // Vertex[n] = V;
44
45 for (succ_iterator SI = succ_begin(V), E = succ_end(V); SI != E; ++SI) {
46 InfoRec &SuccVInfo = DT.Info[*SI];
47 if (SuccVInfo.Semi == 0) {
48 SuccVInfo.Parent = V;
49 N = DTDFSPass(DT, *SI, N);
50 }
51 }
52 #else
53 bool IsChildOfArtificialExit = (N != 0);
54
55 SmallVector
56 typename GraphT::ChildIteratorType>, 32> Worklist;
57 Worklist.push_back(std::make_pair(V, GraphT::child_begin(V)));
58 while (!Worklist.empty()) {
59 typename GraphT::NodeType* BB = Worklist.back().first;
60 typename GraphT::ChildIteratorType NextSucc = Worklist.back().second;
61
62 typename DominatorTreeBase::InfoRec &BBInfo =
63 DT.Info[BB];
64
65 // First time we visited this BB?
66 if (NextSucc == GraphT::child_begin(BB)) {
67 BBInfo.DFSNum = BBInfo.Semi = ++N;
68 BBInfo.Label = BB;
69
70 DT.Vertex.push_back(BB); // Vertex[n] = V;
71
72 if (IsChildOfArtificialExit)
73 BBInfo.Parent = 1;
74
75 IsChildOfArtificialExit = false;
76 }
77
78 // store the DFS number of the current BB - the reference to BBInfo might
79 // get invalidated when processing the successors.
80 unsigned BBDFSNum = BBInfo.DFSNum;
81
82 // If we are done with this block, remove it from the worklist.
83 if (NextSucc == GraphT::child_end(BB)) {
84 Worklist.pop_back();
85 continue;
86 }
87
88 // Increment the successor number for the next time we get to it.
89 ++Worklist.back().second;
90
91 // Visit the successor next, if it isn't already visited.
92 typename GraphT::NodeType* Succ = *NextSucc;
93
94 typename DominatorTreeBase::InfoRec &SuccVInfo =
95 DT.Info[Succ];
96 if (SuccVInfo.Semi == 0) {
97 SuccVInfo.Parent = BBDFSNum;
98 Worklist.push_back(std::make_pair(Succ, GraphT::child_begin(Succ)));
99 }
100 }
101 #endif
102 return N;
103 }
104
105 template
106 typename GraphT::NodeType*
107 Eval(DominatorTreeBase& DT,
108 typename GraphT::NodeType *VIn, unsigned LastLinked) {
109 typename DominatorTreeBase::InfoRec &VInInfo =
110 DT.Info[VIn];
111 if (VInInfo.DFSNum < LastLinked)
112 return VIn;
113
114 SmallVector Work;
115 SmallPtrSet Visited;
116
117 if (VInInfo.Parent >= LastLinked)
118 Work.push_back(VIn);
119
120 while (!Work.empty()) {
121 typename GraphT::NodeType* V = Work.back();
122 typename DominatorTreeBase::InfoRec &VInfo =
123 DT.Info[V];
124 typename GraphT::NodeType* VAncestor = DT.Vertex[VInfo.Parent];
125
126 // Process Ancestor first
127 if (Visited.insert(VAncestor) && VInfo.Parent >= LastLinked) {
128 Work.push_back(VAncestor);
129 continue;
130 }
131 Work.pop_back();
132
133 // Update VInfo based on Ancestor info
134 if (VInfo.Parent < LastLinked)
135 continue;
136
137 typename DominatorTreeBase::InfoRec &VAInfo =
138 DT.Info[VAncestor];
139 typename GraphT::NodeType* VAncestorLabel = VAInfo.Label;
140 typename GraphT::NodeType* VLabel = VInfo.Label;
141 if (DT.Info[VAncestorLabel].Semi < DT.Info[VLabel].Semi)
142 VInfo.Label = VAncestorLabel;
143 VInfo.Parent = VAInfo.Parent;
144 }
145
146 return VInInfo.Label;
147 }
148
149 template
150 void Calculate(DominatorTreeBase::NodeType>& DT,
151 FuncT& F) {
152 typedef GraphTraits GraphT;
153
154 unsigned N = 0;
155 bool MultipleRoots = (DT.Roots.size() > 1);
156 if (MultipleRoots) {
157 typename DominatorTreeBase::InfoRec &BBInfo =
158 DT.Info[NULL];
159 BBInfo.DFSNum = BBInfo.Semi = ++N;
160 BBInfo.Label = NULL;
161
162 DT.Vertex.push_back(NULL); // Vertex[n] = V;
163 }
164
165 // Step #1: Number blocks in depth-first order and initialize variables used
166 // in later stages of the algorithm.
167 for (unsigned i = 0, e = static_cast(DT.Roots.size());
168 i != e; ++i)
169 N = DFSPass(DT, DT.Roots[i], N);
170
171 // it might be that some blocks did not get a DFS number (e.g., blocks of
172 // infinite loops). In these cases an artificial exit node is required.
173 MultipleRoots |= (DT.isPostDominator() && N != GraphTraits::size(&F));
174
175 // When naively implemented, the Lengauer-Tarjan algorithm requires a separate
176 // bucket for each vertex. However, this is unnecessary, because each vertex
177 // is only placed into a single bucket (that of its semidominator), and each
178 // vertex's bucket is processed before it is added to any bucket itself.
179 //
180 // Instead of using a bucket per vertex, we use a single array Buckets that
181 // has two purposes. Before the vertex V with preorder number i is processed,
182 // Buckets[i] stores the index of the first element in V's bucket. After V's
183 // bucket is processed, Buckets[i] stores the index of the next element in the
184 // bucket containing V, if any.
185 SmallVector Buckets;
186 Buckets.resize(N + 1);
187 for (unsigned i = 1; i <= N; ++i)
188 Buckets[i] = i;
189
190 for (unsigned i = N; i >= 2; --i) {
191 typename GraphT::NodeType* W = DT.Vertex[i];
192 typename DominatorTreeBase::InfoRec &WInfo =
193 DT.Info[W];
194
195 // Step #2: Implicitly define the immediate dominator of vertices
196 for (unsigned j = i; Buckets[j] != i; j = Buckets[j]) {
197 typename GraphT::NodeType* V = DT.Vertex[Buckets[j]];
198 typename GraphT::NodeType* U = Eval(DT, V, i + 1);
199 DT.IDoms[V] = DT.Info[U].Semi < i ? U : W;
200 }
201
202 // Step #3: Calculate the semidominators of all vertices
203
204 // initialize the semi dominator to point to the parent node
205 WInfo.Semi = WInfo.Parent;
206 typedef GraphTraits > InvTraits;
207 for (typename InvTraits::ChildIteratorType CI =
208 InvTraits::child_begin(W),
209 E = InvTraits::child_end(W); CI != E; ++CI) {
210 typename InvTraits::NodeType *N = *CI;
211 if (DT.Info.count(N)) { // Only if this predecessor is reachable!
212 unsigned SemiU = DT.Info[Eval(DT, N, i + 1)].Semi;
213 if (SemiU < WInfo.Semi)
214 WInfo.Semi = SemiU;
215 }
216 }
217
218 // If V is a non-root vertex and sdom(V) = parent(V), then idom(V) is
219 // necessarily parent(V). In this case, set idom(V) here and avoid placing
220 // V into a bucket.
221 if (WInfo.Semi == WInfo.Parent) {
222 DT.IDoms[W] = DT.Vertex[WInfo.Parent];
223 } else {
224 Buckets[i] = Buckets[WInfo.Semi];
225 Buckets[WInfo.Semi] = i;
226 }
227 }
228
229 if (N >= 1) {
230 typename GraphT::NodeType* Root = DT.Vertex[1];
231 for (unsigned j = 1; Buckets[j] != 1; j = Buckets[j]) {
232 typename GraphT::NodeType* V = DT.Vertex[Buckets[j]];
233 DT.IDoms[V] = Root;
234 }
235 }
236
237 // Step #4: Explicitly define the immediate dominator of each vertex
238 for (unsigned i = 2; i <= N; ++i) {
239 typename GraphT::NodeType* W = DT.Vertex[i];
240 typename GraphT::NodeType*& WIDom = DT.IDoms[W];
241 if (WIDom != DT.Vertex[DT.Info[W].Semi])
242 WIDom = DT.IDoms[WIDom];
243 }
244
245 if (DT.Roots.empty()) return;
246
247 // Add a node for the root. This node might be the actual root, if there is
248 // one exit block, or it may be the virtual exit (denoted by (BasicBlock *)0)
249 // which postdominates all real exits if there are multiple exit blocks, or
250 // an infinite loop.
251 typename GraphT::NodeType* Root = !MultipleRoots ? DT.Roots[0] : 0;
252
253 DT.DomTreeNodes[Root] = DT.RootNode =
254 new DomTreeNodeBase(Root, 0);
255
256 // Loop over all of the reachable blocks in the function...
257 for (unsigned i = 2; i <= N; ++i) {
258 typename GraphT::NodeType* W = DT.Vertex[i];
259
260 DomTreeNodeBase *BBNode = DT.DomTreeNodes[W];
261 if (BBNode) continue; // Haven't calculated this node yet?
262
263 typename GraphT::NodeType* ImmDom = DT.getIDom(W);
264
265 assert(ImmDom || DT.DomTreeNodes[NULL]);
266
267 // Get or calculate the node for the immediate dominator
268 DomTreeNodeBase *IDomNode =
269 DT.getNodeForBlock(ImmDom);
270
271 // Add a new tree node for this BasicBlock, and link it as a child of
272 // IDomNode
273 DomTreeNodeBase *C =
274 new DomTreeNodeBase(W, IDomNode);
275 DT.DomTreeNodes[W] = IDomNode->addChild(C);
276 }
277
278 // Free temporary memory used to construct idom's
279 DT.IDoms.clear();
280 DT.Info.clear();
281 std::vector().swap(DT.Vertex);
282
283 DT.updateDFSNumbers();
284 }
285
286 }
287
288 #endif
1515 #include "llvm/Analysis/PostDominators.h"
1616 #include "llvm/ADT/DepthFirstIterator.h"
1717 #include "llvm/ADT/SetOperations.h"
18 #include "llvm/IR/DominatorInternals.h"
18 #include "llvm/Support/GenericDomTreeConstruction.h"
1919 #include "llvm/IR/Instructions.h"
2020 #include "llvm/Support/CFG.h"
2121 #include "llvm/Support/Debug.h"
2020 #include "llvm/CodeGen/MachineInstrBuilder.h"
2121 #include "llvm/CodeGen/MachineModuleInfo.h"
2222 #include "llvm/CodeGen/Passes.h"
23 #include "llvm/IR/DominatorInternals.h"
2423 #include "llvm/IR/Dominators.h"
2524 #include "llvm/IR/IntrinsicInst.h"
2625 #include "llvm/IR/Module.h"
1717 #include "llvm/ADT/DepthFirstIterator.h"
1818 #include "llvm/ADT/SmallPtrSet.h"
1919 #include "llvm/ADT/SmallVector.h"
20 #include "llvm/IR/DominatorInternals.h"
2120 #include "llvm/IR/Instructions.h"
2221 #include "llvm/Support/CFG.h"
2322 #include "llvm/Support/CommandLine.h"
2423 #include "llvm/Support/Compiler.h"
2524 #include "llvm/Support/Debug.h"
25 #include "llvm/Support/GenericDomTreeConstruction.h"
2626 #include "llvm/Support/raw_ostream.h"
2727 #include
2828 using namespace llvm;
5555 //===----------------------------------------------------------------------===//
5656 //
5757 // Provide public access to DominatorTree information. Implementation details
58 // can be found in DominatorInternals.h.
58 // can be found in Dominators.h, GenericDomTree.h, and
59 // GenericDomTreeConstruction.h.
5960 //
6061 //===----------------------------------------------------------------------===//
6162
2525 #include "llvm/CodeGen/MachineLoopInfo.h"
2626 #include "llvm/CodeGen/MachinePostDominators.h"
2727 #include "llvm/CodeGen/MachineRegisterInfo.h"
28 #include "llvm/IR/DominatorInternals.h"
2928 #include "llvm/IR/Dominators.h"
3029 #include "llvm/Support/Debug.h"
3130 #include "llvm/Support/raw_ostream.h"
2222 #include "llvm/IR/Constants.h"
2323 #include "llvm/IR/DataLayout.h"
2424 #include "llvm/IR/DerivedTypes.h"
25 #include "llvm/IR/DominatorInternals.h"
2625 #include "llvm/IR/Dominators.h"
2726 #include "llvm/IR/Function.h"
2827 #include "llvm/IR/IRBuilder.h"