Daily bump.
[official-gcc.git] / gcc / dominance.c
blobff0dfe6714f91b7198e9d2f802acca833d64802c
1 /* Calculate (post)dominators in slightly super-linear time.
2 Copyright (C) 2000-2014 Free Software Foundation, Inc.
3 Contributed by Michael Matz (matz@ifh.de).
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
10 any later version.
12 GCC is distributed in the hope that it will be useful, but WITHOUT
13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
14 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
15 License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
21 /* This file implements the well known algorithm from Lengauer and Tarjan
22 to compute the dominators in a control flow graph. A basic block D is said
23 to dominate another block X, when all paths from the entry node of the CFG
24 to X go also over D. The dominance relation is a transitive reflexive
25 relation and its minimal transitive reduction is a tree, called the
26 dominator tree. So for each block X besides the entry block exists a
27 block I(X), called the immediate dominator of X, which is the parent of X
28 in the dominator tree.
30 The algorithm computes this dominator tree implicitly by computing for
31 each block its immediate dominator. We use tree balancing and path
32 compression, so it's the O(e*a(e,v)) variant, where a(e,v) is the very
33 slowly growing functional inverse of the Ackerman function. */
35 #include "config.h"
36 #include "system.h"
37 #include "coretypes.h"
38 #include "tm.h"
39 #include "rtl.h"
40 #include "hard-reg-set.h"
41 #include "obstack.h"
42 #include "basic-block.h"
43 #include "diagnostic-core.h"
44 #include "et-forest.h"
45 #include "timevar.h"
46 #include "pointer-set.h"
47 #include "graphds.h"
48 #include "bitmap.h"
50 /* We name our nodes with integers, beginning with 1. Zero is reserved for
51 'undefined' or 'end of list'. The name of each node is given by the dfs
52 number of the corresponding basic block. Please note, that we include the
53 artificial ENTRY_BLOCK (or EXIT_BLOCK in the post-dom case) in our lists to
54 support multiple entry points. Its dfs number is of course 1. */
56 /* Type of Basic Block aka. TBB */
57 typedef unsigned int TBB;
59 /* We work in a poor-mans object oriented fashion, and carry an instance of
60 this structure through all our 'methods'. It holds various arrays
61 reflecting the (sub)structure of the flowgraph. Most of them are of type
62 TBB and are also indexed by TBB. */
64 struct dom_info
66 /* The parent of a node in the DFS tree. */
67 TBB *dfs_parent;
68 /* For a node x key[x] is roughly the node nearest to the root from which
69 exists a way to x only over nodes behind x. Such a node is also called
70 semidominator. */
71 TBB *key;
72 /* The value in path_min[x] is the node y on the path from x to the root of
73 the tree x is in with the smallest key[y]. */
74 TBB *path_min;
75 /* bucket[x] points to the first node of the set of nodes having x as key. */
76 TBB *bucket;
77 /* And next_bucket[x] points to the next node. */
78 TBB *next_bucket;
79 /* After the algorithm is done, dom[x] contains the immediate dominator
80 of x. */
81 TBB *dom;
83 /* The following few fields implement the structures needed for disjoint
84 sets. */
85 /* set_chain[x] is the next node on the path from x to the representative
86 of the set containing x. If set_chain[x]==0 then x is a root. */
87 TBB *set_chain;
88 /* set_size[x] is the number of elements in the set named by x. */
89 unsigned int *set_size;
90 /* set_child[x] is used for balancing the tree representing a set. It can
91 be understood as the next sibling of x. */
92 TBB *set_child;
94 /* If b is the number of a basic block (BB->index), dfs_order[b] is the
95 number of that node in DFS order counted from 1. This is an index
96 into most of the other arrays in this structure. */
97 TBB *dfs_order;
98 /* If x is the DFS-index of a node which corresponds with a basic block,
99 dfs_to_bb[x] is that basic block. Note, that in our structure there are
100 more nodes that basic blocks, so only dfs_to_bb[dfs_order[bb->index]]==bb
101 is true for every basic block bb, but not the opposite. */
102 basic_block *dfs_to_bb;
104 /* This is the next free DFS number when creating the DFS tree. */
105 unsigned int dfsnum;
106 /* The number of nodes in the DFS tree (==dfsnum-1). */
107 unsigned int nodes;
109 /* Blocks with bits set here have a fake edge to EXIT. These are used
110 to turn a DFS forest into a proper tree. */
111 bitmap fake_exit_edge;
114 static void init_dom_info (struct dom_info *, enum cdi_direction);
115 static void free_dom_info (struct dom_info *);
116 static void calc_dfs_tree_nonrec (struct dom_info *, basic_block, bool);
117 static void calc_dfs_tree (struct dom_info *, bool);
118 static void compress (struct dom_info *, TBB);
119 static TBB eval (struct dom_info *, TBB);
120 static void link_roots (struct dom_info *, TBB, TBB);
121 static void calc_idoms (struct dom_info *, bool);
122 void debug_dominance_info (enum cdi_direction);
123 void debug_dominance_tree (enum cdi_direction, basic_block);
125 /* Helper macro for allocating and initializing an array,
126 for aesthetic reasons. */
127 #define init_ar(var, type, num, content) \
128 do \
130 unsigned int i = 1; /* Catch content == i. */ \
131 if (! (content)) \
132 (var) = XCNEWVEC (type, num); \
133 else \
135 (var) = XNEWVEC (type, (num)); \
136 for (i = 0; i < num; i++) \
137 (var)[i] = (content); \
140 while (0)
142 /* Allocate all needed memory in a pessimistic fashion (so we round up).
143 This initializes the contents of DI, which already must be allocated. */
145 static void
146 init_dom_info (struct dom_info *di, enum cdi_direction dir)
148 /* We need memory for n_basic_blocks nodes. */
149 unsigned int num = n_basic_blocks_for_fn (cfun);
150 init_ar (di->dfs_parent, TBB, num, 0);
151 init_ar (di->path_min, TBB, num, i);
152 init_ar (di->key, TBB, num, i);
153 init_ar (di->dom, TBB, num, 0);
155 init_ar (di->bucket, TBB, num, 0);
156 init_ar (di->next_bucket, TBB, num, 0);
158 init_ar (di->set_chain, TBB, num, 0);
159 init_ar (di->set_size, unsigned int, num, 1);
160 init_ar (di->set_child, TBB, num, 0);
162 init_ar (di->dfs_order, TBB,
163 (unsigned int) last_basic_block_for_fn (cfun) + 1, 0);
164 init_ar (di->dfs_to_bb, basic_block, num, 0);
166 di->dfsnum = 1;
167 di->nodes = 0;
169 switch (dir)
171 case CDI_DOMINATORS:
172 di->fake_exit_edge = NULL;
173 break;
174 case CDI_POST_DOMINATORS:
175 di->fake_exit_edge = BITMAP_ALLOC (NULL);
176 break;
177 default:
178 gcc_unreachable ();
179 break;
183 #undef init_ar
185 /* Map dominance calculation type to array index used for various
186 dominance information arrays. This version is simple -- it will need
187 to be modified, obviously, if additional values are added to
188 cdi_direction. */
190 static unsigned int
191 dom_convert_dir_to_idx (enum cdi_direction dir)
193 gcc_checking_assert (dir == CDI_DOMINATORS || dir == CDI_POST_DOMINATORS);
194 return dir - 1;
197 /* Free all allocated memory in DI, but not DI itself. */
199 static void
200 free_dom_info (struct dom_info *di)
202 free (di->dfs_parent);
203 free (di->path_min);
204 free (di->key);
205 free (di->dom);
206 free (di->bucket);
207 free (di->next_bucket);
208 free (di->set_chain);
209 free (di->set_size);
210 free (di->set_child);
211 free (di->dfs_order);
212 free (di->dfs_to_bb);
213 BITMAP_FREE (di->fake_exit_edge);
216 /* The nonrecursive variant of creating a DFS tree. DI is our working
217 structure, BB the starting basic block for this tree and REVERSE
218 is true, if predecessors should be visited instead of successors of a
219 node. After this is done all nodes reachable from BB were visited, have
220 assigned their dfs number and are linked together to form a tree. */
222 static void
223 calc_dfs_tree_nonrec (struct dom_info *di, basic_block bb, bool reverse)
225 /* We call this _only_ if bb is not already visited. */
226 edge e;
227 TBB child_i, my_i = 0;
228 edge_iterator *stack;
229 edge_iterator ei, einext;
230 int sp;
231 /* Start block (the entry block for forward problem, exit block for backward
232 problem). */
233 basic_block en_block;
234 /* Ending block. */
235 basic_block ex_block;
237 stack = XNEWVEC (edge_iterator, n_basic_blocks_for_fn (cfun) + 1);
238 sp = 0;
240 /* Initialize our border blocks, and the first edge. */
241 if (reverse)
243 ei = ei_start (bb->preds);
244 en_block = EXIT_BLOCK_PTR_FOR_FN (cfun);
245 ex_block = ENTRY_BLOCK_PTR_FOR_FN (cfun);
247 else
249 ei = ei_start (bb->succs);
250 en_block = ENTRY_BLOCK_PTR_FOR_FN (cfun);
251 ex_block = EXIT_BLOCK_PTR_FOR_FN (cfun);
254 /* When the stack is empty we break out of this loop. */
255 while (1)
257 basic_block bn;
259 /* This loop traverses edges e in depth first manner, and fills the
260 stack. */
261 while (!ei_end_p (ei))
263 e = ei_edge (ei);
265 /* Deduce from E the current and the next block (BB and BN), and the
266 next edge. */
267 if (reverse)
269 bn = e->src;
271 /* If the next node BN is either already visited or a border
272 block the current edge is useless, and simply overwritten
273 with the next edge out of the current node. */
274 if (bn == ex_block || di->dfs_order[bn->index])
276 ei_next (&ei);
277 continue;
279 bb = e->dest;
280 einext = ei_start (bn->preds);
282 else
284 bn = e->dest;
285 if (bn == ex_block || di->dfs_order[bn->index])
287 ei_next (&ei);
288 continue;
290 bb = e->src;
291 einext = ei_start (bn->succs);
294 gcc_assert (bn != en_block);
296 /* Fill the DFS tree info calculatable _before_ recursing. */
297 if (bb != en_block)
298 my_i = di->dfs_order[bb->index];
299 else
300 my_i = di->dfs_order[last_basic_block_for_fn (cfun)];
301 child_i = di->dfs_order[bn->index] = di->dfsnum++;
302 di->dfs_to_bb[child_i] = bn;
303 di->dfs_parent[child_i] = my_i;
305 /* Save the current point in the CFG on the stack, and recurse. */
306 stack[sp++] = ei;
307 ei = einext;
310 if (!sp)
311 break;
312 ei = stack[--sp];
314 /* OK. The edge-list was exhausted, meaning normally we would
315 end the recursion. After returning from the recursive call,
316 there were (may be) other statements which were run after a
317 child node was completely considered by DFS. Here is the
318 point to do it in the non-recursive variant.
319 E.g. The block just completed is in e->dest for forward DFS,
320 the block not yet completed (the parent of the one above)
321 in e->src. This could be used e.g. for computing the number of
322 descendants or the tree depth. */
323 ei_next (&ei);
325 free (stack);
328 /* The main entry for calculating the DFS tree or forest. DI is our working
329 structure and REVERSE is true, if we are interested in the reverse flow
330 graph. In that case the result is not necessarily a tree but a forest,
331 because there may be nodes from which the EXIT_BLOCK is unreachable. */
333 static void
334 calc_dfs_tree (struct dom_info *di, bool reverse)
336 /* The first block is the ENTRY_BLOCK (or EXIT_BLOCK if REVERSE). */
337 basic_block begin = (reverse
338 ? EXIT_BLOCK_PTR_FOR_FN (cfun) : ENTRY_BLOCK_PTR_FOR_FN (cfun));
339 di->dfs_order[last_basic_block_for_fn (cfun)] = di->dfsnum;
340 di->dfs_to_bb[di->dfsnum] = begin;
341 di->dfsnum++;
343 calc_dfs_tree_nonrec (di, begin, reverse);
345 if (reverse)
347 /* In the post-dom case we may have nodes without a path to EXIT_BLOCK.
348 They are reverse-unreachable. In the dom-case we disallow such
349 nodes, but in post-dom we have to deal with them.
351 There are two situations in which this occurs. First, noreturn
352 functions. Second, infinite loops. In the first case we need to
353 pretend that there is an edge to the exit block. In the second
354 case, we wind up with a forest. We need to process all noreturn
355 blocks before we know if we've got any infinite loops. */
357 basic_block b;
358 bool saw_unconnected = false;
360 FOR_EACH_BB_REVERSE_FN (b, cfun)
362 if (EDGE_COUNT (b->succs) > 0)
364 if (di->dfs_order[b->index] == 0)
365 saw_unconnected = true;
366 continue;
368 bitmap_set_bit (di->fake_exit_edge, b->index);
369 di->dfs_order[b->index] = di->dfsnum;
370 di->dfs_to_bb[di->dfsnum] = b;
371 di->dfs_parent[di->dfsnum] =
372 di->dfs_order[last_basic_block_for_fn (cfun)];
373 di->dfsnum++;
374 calc_dfs_tree_nonrec (di, b, reverse);
377 if (saw_unconnected)
379 FOR_EACH_BB_REVERSE_FN (b, cfun)
381 basic_block b2;
382 if (di->dfs_order[b->index])
383 continue;
384 b2 = dfs_find_deadend (b);
385 gcc_checking_assert (di->dfs_order[b2->index] == 0);
386 bitmap_set_bit (di->fake_exit_edge, b2->index);
387 di->dfs_order[b2->index] = di->dfsnum;
388 di->dfs_to_bb[di->dfsnum] = b2;
389 di->dfs_parent[di->dfsnum] =
390 di->dfs_order[last_basic_block_for_fn (cfun)];
391 di->dfsnum++;
392 calc_dfs_tree_nonrec (di, b2, reverse);
393 gcc_checking_assert (di->dfs_order[b->index]);
398 di->nodes = di->dfsnum - 1;
400 /* This aborts e.g. when there is _no_ path from ENTRY to EXIT at all. */
401 gcc_assert (di->nodes == (unsigned int) n_basic_blocks_for_fn (cfun) - 1);
404 /* Compress the path from V to the root of its set and update path_min at the
405 same time. After compress(di, V) set_chain[V] is the root of the set V is
406 in and path_min[V] is the node with the smallest key[] value on the path
407 from V to that root. */
409 static void
410 compress (struct dom_info *di, TBB v)
412 /* Btw. It's not worth to unrecurse compress() as the depth is usually not
413 greater than 5 even for huge graphs (I've not seen call depth > 4).
414 Also performance wise compress() ranges _far_ behind eval(). */
415 TBB parent = di->set_chain[v];
416 if (di->set_chain[parent])
418 compress (di, parent);
419 if (di->key[di->path_min[parent]] < di->key[di->path_min[v]])
420 di->path_min[v] = di->path_min[parent];
421 di->set_chain[v] = di->set_chain[parent];
425 /* Compress the path from V to the set root of V if needed (when the root has
426 changed since the last call). Returns the node with the smallest key[]
427 value on the path from V to the root. */
429 static inline TBB
430 eval (struct dom_info *di, TBB v)
432 /* The representative of the set V is in, also called root (as the set
433 representation is a tree). */
434 TBB rep = di->set_chain[v];
436 /* V itself is the root. */
437 if (!rep)
438 return di->path_min[v];
440 /* Compress only if necessary. */
441 if (di->set_chain[rep])
443 compress (di, v);
444 rep = di->set_chain[v];
447 if (di->key[di->path_min[rep]] >= di->key[di->path_min[v]])
448 return di->path_min[v];
449 else
450 return di->path_min[rep];
453 /* This essentially merges the two sets of V and W, giving a single set with
454 the new root V. The internal representation of these disjoint sets is a
455 balanced tree. Currently link(V,W) is only used with V being the parent
456 of W. */
458 static void
459 link_roots (struct dom_info *di, TBB v, TBB w)
461 TBB s = w;
463 /* Rebalance the tree. */
464 while (di->key[di->path_min[w]] < di->key[di->path_min[di->set_child[s]]])
466 if (di->set_size[s] + di->set_size[di->set_child[di->set_child[s]]]
467 >= 2 * di->set_size[di->set_child[s]])
469 di->set_chain[di->set_child[s]] = s;
470 di->set_child[s] = di->set_child[di->set_child[s]];
472 else
474 di->set_size[di->set_child[s]] = di->set_size[s];
475 s = di->set_chain[s] = di->set_child[s];
479 di->path_min[s] = di->path_min[w];
480 di->set_size[v] += di->set_size[w];
481 if (di->set_size[v] < 2 * di->set_size[w])
483 TBB tmp = s;
484 s = di->set_child[v];
485 di->set_child[v] = tmp;
488 /* Merge all subtrees. */
489 while (s)
491 di->set_chain[s] = v;
492 s = di->set_child[s];
496 /* This calculates the immediate dominators (or post-dominators if REVERSE is
497 true). DI is our working structure and should hold the DFS forest.
498 On return the immediate dominator to node V is in di->dom[V]. */
500 static void
501 calc_idoms (struct dom_info *di, bool reverse)
503 TBB v, w, k, par;
504 basic_block en_block;
505 edge_iterator ei, einext;
507 if (reverse)
508 en_block = EXIT_BLOCK_PTR_FOR_FN (cfun);
509 else
510 en_block = ENTRY_BLOCK_PTR_FOR_FN (cfun);
512 /* Go backwards in DFS order, to first look at the leafs. */
513 v = di->nodes;
514 while (v > 1)
516 basic_block bb = di->dfs_to_bb[v];
517 edge e;
519 par = di->dfs_parent[v];
520 k = v;
522 ei = (reverse) ? ei_start (bb->succs) : ei_start (bb->preds);
524 if (reverse)
526 /* If this block has a fake edge to exit, process that first. */
527 if (bitmap_bit_p (di->fake_exit_edge, bb->index))
529 einext = ei;
530 einext.index = 0;
531 goto do_fake_exit_edge;
535 /* Search all direct predecessors for the smallest node with a path
536 to them. That way we have the smallest node with also a path to
537 us only over nodes behind us. In effect we search for our
538 semidominator. */
539 while (!ei_end_p (ei))
541 TBB k1;
542 basic_block b;
544 e = ei_edge (ei);
545 b = (reverse) ? e->dest : e->src;
546 einext = ei;
547 ei_next (&einext);
549 if (b == en_block)
551 do_fake_exit_edge:
552 k1 = di->dfs_order[last_basic_block_for_fn (cfun)];
554 else
555 k1 = di->dfs_order[b->index];
557 /* Call eval() only if really needed. If k1 is above V in DFS tree,
558 then we know, that eval(k1) == k1 and key[k1] == k1. */
559 if (k1 > v)
560 k1 = di->key[eval (di, k1)];
561 if (k1 < k)
562 k = k1;
564 ei = einext;
567 di->key[v] = k;
568 link_roots (di, par, v);
569 di->next_bucket[v] = di->bucket[k];
570 di->bucket[k] = v;
572 /* Transform semidominators into dominators. */
573 for (w = di->bucket[par]; w; w = di->next_bucket[w])
575 k = eval (di, w);
576 if (di->key[k] < di->key[w])
577 di->dom[w] = k;
578 else
579 di->dom[w] = par;
581 /* We don't need to cleanup next_bucket[]. */
582 di->bucket[par] = 0;
583 v--;
586 /* Explicitly define the dominators. */
587 di->dom[1] = 0;
588 for (v = 2; v <= di->nodes; v++)
589 if (di->dom[v] != di->key[v])
590 di->dom[v] = di->dom[di->dom[v]];
593 /* Assign dfs numbers starting from NUM to NODE and its sons. */
595 static void
596 assign_dfs_numbers (struct et_node *node, int *num)
598 struct et_node *son;
600 node->dfs_num_in = (*num)++;
602 if (node->son)
604 assign_dfs_numbers (node->son, num);
605 for (son = node->son->right; son != node->son; son = son->right)
606 assign_dfs_numbers (son, num);
609 node->dfs_num_out = (*num)++;
612 /* Compute the data necessary for fast resolving of dominator queries in a
613 static dominator tree. */
615 static void
616 compute_dom_fast_query (enum cdi_direction dir)
618 int num = 0;
619 basic_block bb;
620 unsigned int dir_index = dom_convert_dir_to_idx (dir);
622 gcc_checking_assert (dom_info_available_p (dir));
624 if (dom_computed[dir_index] == DOM_OK)
625 return;
627 FOR_ALL_BB_FN (bb, cfun)
629 if (!bb->dom[dir_index]->father)
630 assign_dfs_numbers (bb->dom[dir_index], &num);
633 dom_computed[dir_index] = DOM_OK;
636 /* The main entry point into this module. DIR is set depending on whether
637 we want to compute dominators or postdominators. */
639 void
640 calculate_dominance_info (enum cdi_direction dir)
642 struct dom_info di;
643 basic_block b;
644 unsigned int dir_index = dom_convert_dir_to_idx (dir);
645 bool reverse = (dir == CDI_POST_DOMINATORS) ? true : false;
647 if (dom_computed[dir_index] == DOM_OK)
648 return;
650 timevar_push (TV_DOMINANCE);
651 if (!dom_info_available_p (dir))
653 gcc_assert (!n_bbs_in_dom_tree[dir_index]);
655 FOR_ALL_BB_FN (b, cfun)
657 b->dom[dir_index] = et_new_tree (b);
659 n_bbs_in_dom_tree[dir_index] = n_basic_blocks_for_fn (cfun);
661 init_dom_info (&di, dir);
662 calc_dfs_tree (&di, reverse);
663 calc_idoms (&di, reverse);
665 FOR_EACH_BB_FN (b, cfun)
667 TBB d = di.dom[di.dfs_order[b->index]];
669 if (di.dfs_to_bb[d])
670 et_set_father (b->dom[dir_index], di.dfs_to_bb[d]->dom[dir_index]);
673 free_dom_info (&di);
674 dom_computed[dir_index] = DOM_NO_FAST_QUERY;
677 compute_dom_fast_query (dir);
679 timevar_pop (TV_DOMINANCE);
682 /* Free dominance information for direction DIR. */
683 void
684 free_dominance_info (enum cdi_direction dir)
686 basic_block bb;
687 unsigned int dir_index = dom_convert_dir_to_idx (dir);
689 if (!dom_info_available_p (dir))
690 return;
692 FOR_ALL_BB_FN (bb, cfun)
694 et_free_tree_force (bb->dom[dir_index]);
695 bb->dom[dir_index] = NULL;
697 et_free_pools ();
699 n_bbs_in_dom_tree[dir_index] = 0;
701 dom_computed[dir_index] = DOM_NONE;
704 /* Return the immediate dominator of basic block BB. */
705 basic_block
706 get_immediate_dominator (enum cdi_direction dir, basic_block bb)
708 unsigned int dir_index = dom_convert_dir_to_idx (dir);
709 struct et_node *node = bb->dom[dir_index];
711 gcc_checking_assert (dom_computed[dir_index]);
713 if (!node->father)
714 return NULL;
716 return (basic_block) node->father->data;
719 /* Set the immediate dominator of the block possibly removing
720 existing edge. NULL can be used to remove any edge. */
721 void
722 set_immediate_dominator (enum cdi_direction dir, basic_block bb,
723 basic_block dominated_by)
725 unsigned int dir_index = dom_convert_dir_to_idx (dir);
726 struct et_node *node = bb->dom[dir_index];
728 gcc_checking_assert (dom_computed[dir_index]);
730 if (node->father)
732 if (node->father->data == dominated_by)
733 return;
734 et_split (node);
737 if (dominated_by)
738 et_set_father (node, dominated_by->dom[dir_index]);
740 if (dom_computed[dir_index] == DOM_OK)
741 dom_computed[dir_index] = DOM_NO_FAST_QUERY;
744 /* Returns the list of basic blocks immediately dominated by BB, in the
745 direction DIR. */
746 vec<basic_block>
747 get_dominated_by (enum cdi_direction dir, basic_block bb)
749 unsigned int dir_index = dom_convert_dir_to_idx (dir);
750 struct et_node *node = bb->dom[dir_index], *son = node->son, *ason;
751 vec<basic_block> bbs = vNULL;
753 gcc_checking_assert (dom_computed[dir_index]);
755 if (!son)
756 return vNULL;
758 bbs.safe_push ((basic_block) son->data);
759 for (ason = son->right; ason != son; ason = ason->right)
760 bbs.safe_push ((basic_block) ason->data);
762 return bbs;
765 /* Returns the list of basic blocks that are immediately dominated (in
766 direction DIR) by some block between N_REGION ones stored in REGION,
767 except for blocks in the REGION itself. */
769 vec<basic_block>
770 get_dominated_by_region (enum cdi_direction dir, basic_block *region,
771 unsigned n_region)
773 unsigned i;
774 basic_block dom;
775 vec<basic_block> doms = vNULL;
777 for (i = 0; i < n_region; i++)
778 region[i]->flags |= BB_DUPLICATED;
779 for (i = 0; i < n_region; i++)
780 for (dom = first_dom_son (dir, region[i]);
781 dom;
782 dom = next_dom_son (dir, dom))
783 if (!(dom->flags & BB_DUPLICATED))
784 doms.safe_push (dom);
785 for (i = 0; i < n_region; i++)
786 region[i]->flags &= ~BB_DUPLICATED;
788 return doms;
791 /* Returns the list of basic blocks including BB dominated by BB, in the
792 direction DIR up to DEPTH in the dominator tree. The DEPTH of zero will
793 produce a vector containing all dominated blocks. The vector will be sorted
794 in preorder. */
796 vec<basic_block>
797 get_dominated_to_depth (enum cdi_direction dir, basic_block bb, int depth)
799 vec<basic_block> bbs = vNULL;
800 unsigned i;
801 unsigned next_level_start;
803 i = 0;
804 bbs.safe_push (bb);
805 next_level_start = 1; /* = bbs.length (); */
809 basic_block son;
811 bb = bbs[i++];
812 for (son = first_dom_son (dir, bb);
813 son;
814 son = next_dom_son (dir, son))
815 bbs.safe_push (son);
817 if (i == next_level_start && --depth)
818 next_level_start = bbs.length ();
820 while (i < next_level_start);
822 return bbs;
825 /* Returns the list of basic blocks including BB dominated by BB, in the
826 direction DIR. The vector will be sorted in preorder. */
828 vec<basic_block>
829 get_all_dominated_blocks (enum cdi_direction dir, basic_block bb)
831 return get_dominated_to_depth (dir, bb, 0);
834 /* Redirect all edges pointing to BB to TO. */
835 void
836 redirect_immediate_dominators (enum cdi_direction dir, basic_block bb,
837 basic_block to)
839 unsigned int dir_index = dom_convert_dir_to_idx (dir);
840 struct et_node *bb_node, *to_node, *son;
842 bb_node = bb->dom[dir_index];
843 to_node = to->dom[dir_index];
845 gcc_checking_assert (dom_computed[dir_index]);
847 if (!bb_node->son)
848 return;
850 while (bb_node->son)
852 son = bb_node->son;
854 et_split (son);
855 et_set_father (son, to_node);
858 if (dom_computed[dir_index] == DOM_OK)
859 dom_computed[dir_index] = DOM_NO_FAST_QUERY;
862 /* Find first basic block in the tree dominating both BB1 and BB2. */
863 basic_block
864 nearest_common_dominator (enum cdi_direction dir, basic_block bb1, basic_block bb2)
866 unsigned int dir_index = dom_convert_dir_to_idx (dir);
868 gcc_checking_assert (dom_computed[dir_index]);
870 if (!bb1)
871 return bb2;
872 if (!bb2)
873 return bb1;
875 return (basic_block) et_nca (bb1->dom[dir_index], bb2->dom[dir_index])->data;
879 /* Find the nearest common dominator for the basic blocks in BLOCKS,
880 using dominance direction DIR. */
882 basic_block
883 nearest_common_dominator_for_set (enum cdi_direction dir, bitmap blocks)
885 unsigned i, first;
886 bitmap_iterator bi;
887 basic_block dom;
889 first = bitmap_first_set_bit (blocks);
890 dom = BASIC_BLOCK_FOR_FN (cfun, first);
891 EXECUTE_IF_SET_IN_BITMAP (blocks, 0, i, bi)
892 if (dom != BASIC_BLOCK_FOR_FN (cfun, i))
893 dom = nearest_common_dominator (dir, dom, BASIC_BLOCK_FOR_FN (cfun, i));
895 return dom;
898 /* Given a dominator tree, we can determine whether one thing
899 dominates another in constant time by using two DFS numbers:
901 1. The number for when we visit a node on the way down the tree
902 2. The number for when we visit a node on the way back up the tree
904 You can view these as bounds for the range of dfs numbers the
905 nodes in the subtree of the dominator tree rooted at that node
906 will contain.
908 The dominator tree is always a simple acyclic tree, so there are
909 only three possible relations two nodes in the dominator tree have
910 to each other:
912 1. Node A is above Node B (and thus, Node A dominates node B)
921 In the above case, DFS_Number_In of A will be <= DFS_Number_In of
922 B, and DFS_Number_Out of A will be >= DFS_Number_Out of B. This is
923 because we must hit A in the dominator tree *before* B on the walk
924 down, and we will hit A *after* B on the walk back up
926 2. Node A is below node B (and thus, node B dominates node A)
935 In the above case, DFS_Number_In of A will be >= DFS_Number_In of
936 B, and DFS_Number_Out of A will be <= DFS_Number_Out of B.
938 This is because we must hit A in the dominator tree *after* B on
939 the walk down, and we will hit A *before* B on the walk back up
941 3. Node A and B are siblings (and thus, neither dominates the other)
949 In the above case, DFS_Number_In of A will *always* be <=
950 DFS_Number_In of B, and DFS_Number_Out of A will *always* be <=
951 DFS_Number_Out of B. This is because we will always finish the dfs
952 walk of one of the subtrees before the other, and thus, the dfs
953 numbers for one subtree can't intersect with the range of dfs
954 numbers for the other subtree. If you swap A and B's position in
955 the dominator tree, the comparison changes direction, but the point
956 is that both comparisons will always go the same way if there is no
957 dominance relationship.
959 Thus, it is sufficient to write
961 A_Dominates_B (node A, node B)
963 return DFS_Number_In(A) <= DFS_Number_In(B)
964 && DFS_Number_Out (A) >= DFS_Number_Out(B);
967 A_Dominated_by_B (node A, node B)
969 return DFS_Number_In(A) >= DFS_Number_In(A)
970 && DFS_Number_Out (A) <= DFS_Number_Out(B);
971 } */
973 /* Return TRUE in case BB1 is dominated by BB2. */
974 bool
975 dominated_by_p (enum cdi_direction dir, const_basic_block bb1, const_basic_block bb2)
977 unsigned int dir_index = dom_convert_dir_to_idx (dir);
978 struct et_node *n1 = bb1->dom[dir_index], *n2 = bb2->dom[dir_index];
980 gcc_checking_assert (dom_computed[dir_index]);
982 if (dom_computed[dir_index] == DOM_OK)
983 return (n1->dfs_num_in >= n2->dfs_num_in
984 && n1->dfs_num_out <= n2->dfs_num_out);
986 return et_below (n1, n2);
989 /* Returns the entry dfs number for basic block BB, in the direction DIR. */
991 unsigned
992 bb_dom_dfs_in (enum cdi_direction dir, basic_block bb)
994 unsigned int dir_index = dom_convert_dir_to_idx (dir);
995 struct et_node *n = bb->dom[dir_index];
997 gcc_checking_assert (dom_computed[dir_index] == DOM_OK);
998 return n->dfs_num_in;
1001 /* Returns the exit dfs number for basic block BB, in the direction DIR. */
1003 unsigned
1004 bb_dom_dfs_out (enum cdi_direction dir, basic_block bb)
1006 unsigned int dir_index = dom_convert_dir_to_idx (dir);
1007 struct et_node *n = bb->dom[dir_index];
1009 gcc_checking_assert (dom_computed[dir_index] == DOM_OK);
1010 return n->dfs_num_out;
1013 /* Verify invariants of dominator structure. */
1014 DEBUG_FUNCTION void
1015 verify_dominators (enum cdi_direction dir)
1017 int err = 0;
1018 basic_block bb, imm_bb, imm_bb_correct;
1019 struct dom_info di;
1020 bool reverse = (dir == CDI_POST_DOMINATORS) ? true : false;
1022 gcc_assert (dom_info_available_p (dir));
1024 init_dom_info (&di, dir);
1025 calc_dfs_tree (&di, reverse);
1026 calc_idoms (&di, reverse);
1028 FOR_EACH_BB_FN (bb, cfun)
1030 imm_bb = get_immediate_dominator (dir, bb);
1031 if (!imm_bb)
1033 error ("dominator of %d status unknown", bb->index);
1034 err = 1;
1037 imm_bb_correct = di.dfs_to_bb[di.dom[di.dfs_order[bb->index]]];
1038 if (imm_bb != imm_bb_correct)
1040 error ("dominator of %d should be %d, not %d",
1041 bb->index, imm_bb_correct->index, imm_bb->index);
1042 err = 1;
1046 free_dom_info (&di);
1047 gcc_assert (!err);
1050 /* Determine immediate dominator (or postdominator, according to DIR) of BB,
1051 assuming that dominators of other blocks are correct. We also use it to
1052 recompute the dominators in a restricted area, by iterating it until it
1053 reaches a fixed point. */
1055 basic_block
1056 recompute_dominator (enum cdi_direction dir, basic_block bb)
1058 unsigned int dir_index = dom_convert_dir_to_idx (dir);
1059 basic_block dom_bb = NULL;
1060 edge e;
1061 edge_iterator ei;
1063 gcc_checking_assert (dom_computed[dir_index]);
1065 if (dir == CDI_DOMINATORS)
1067 FOR_EACH_EDGE (e, ei, bb->preds)
1069 if (!dominated_by_p (dir, e->src, bb))
1070 dom_bb = nearest_common_dominator (dir, dom_bb, e->src);
1073 else
1075 FOR_EACH_EDGE (e, ei, bb->succs)
1077 if (!dominated_by_p (dir, e->dest, bb))
1078 dom_bb = nearest_common_dominator (dir, dom_bb, e->dest);
1082 return dom_bb;
1085 /* Use simple heuristics (see iterate_fix_dominators) to determine dominators
1086 of BBS. We assume that all the immediate dominators except for those of the
1087 blocks in BBS are correct. If CONSERVATIVE is true, we also assume that the
1088 currently recorded immediate dominators of blocks in BBS really dominate the
1089 blocks. The basic blocks for that we determine the dominator are removed
1090 from BBS. */
1092 static void
1093 prune_bbs_to_update_dominators (vec<basic_block> bbs,
1094 bool conservative)
1096 unsigned i;
1097 bool single;
1098 basic_block bb, dom = NULL;
1099 edge_iterator ei;
1100 edge e;
1102 for (i = 0; bbs.iterate (i, &bb);)
1104 if (bb == ENTRY_BLOCK_PTR_FOR_FN (cfun))
1105 goto succeed;
1107 if (single_pred_p (bb))
1109 set_immediate_dominator (CDI_DOMINATORS, bb, single_pred (bb));
1110 goto succeed;
1113 if (!conservative)
1114 goto fail;
1116 single = true;
1117 dom = NULL;
1118 FOR_EACH_EDGE (e, ei, bb->preds)
1120 if (dominated_by_p (CDI_DOMINATORS, e->src, bb))
1121 continue;
1123 if (!dom)
1124 dom = e->src;
1125 else
1127 single = false;
1128 dom = nearest_common_dominator (CDI_DOMINATORS, dom, e->src);
1132 gcc_assert (dom != NULL);
1133 if (single
1134 || find_edge (dom, bb))
1136 set_immediate_dominator (CDI_DOMINATORS, bb, dom);
1137 goto succeed;
1140 fail:
1141 i++;
1142 continue;
1144 succeed:
1145 bbs.unordered_remove (i);
1149 /* Returns root of the dominance tree in the direction DIR that contains
1150 BB. */
1152 static basic_block
1153 root_of_dom_tree (enum cdi_direction dir, basic_block bb)
1155 return (basic_block) et_root (bb->dom[dom_convert_dir_to_idx (dir)])->data;
1158 /* See the comment in iterate_fix_dominators. Finds the immediate dominators
1159 for the sons of Y, found using the SON and BROTHER arrays representing
1160 the dominance tree of graph G. BBS maps the vertices of G to the basic
1161 blocks. */
1163 static void
1164 determine_dominators_for_sons (struct graph *g, vec<basic_block> bbs,
1165 int y, int *son, int *brother)
1167 bitmap gprime;
1168 int i, a, nc;
1169 vec<int> *sccs;
1170 basic_block bb, dom, ybb;
1171 unsigned si;
1172 edge e;
1173 edge_iterator ei;
1175 if (son[y] == -1)
1176 return;
1177 if (y == (int) bbs.length ())
1178 ybb = ENTRY_BLOCK_PTR_FOR_FN (cfun);
1179 else
1180 ybb = bbs[y];
1182 if (brother[son[y]] == -1)
1184 /* Handle the common case Y has just one son specially. */
1185 bb = bbs[son[y]];
1186 set_immediate_dominator (CDI_DOMINATORS, bb,
1187 recompute_dominator (CDI_DOMINATORS, bb));
1188 identify_vertices (g, y, son[y]);
1189 return;
1192 gprime = BITMAP_ALLOC (NULL);
1193 for (a = son[y]; a != -1; a = brother[a])
1194 bitmap_set_bit (gprime, a);
1196 nc = graphds_scc (g, gprime);
1197 BITMAP_FREE (gprime);
1199 /* ??? Needed to work around the pre-processor confusion with
1200 using a multi-argument template type as macro argument. */
1201 typedef vec<int> vec_int_heap;
1202 sccs = XCNEWVEC (vec_int_heap, nc);
1203 for (a = son[y]; a != -1; a = brother[a])
1204 sccs[g->vertices[a].component].safe_push (a);
1206 for (i = nc - 1; i >= 0; i--)
1208 dom = NULL;
1209 FOR_EACH_VEC_ELT (sccs[i], si, a)
1211 bb = bbs[a];
1212 FOR_EACH_EDGE (e, ei, bb->preds)
1214 if (root_of_dom_tree (CDI_DOMINATORS, e->src) != ybb)
1215 continue;
1217 dom = nearest_common_dominator (CDI_DOMINATORS, dom, e->src);
1221 gcc_assert (dom != NULL);
1222 FOR_EACH_VEC_ELT (sccs[i], si, a)
1224 bb = bbs[a];
1225 set_immediate_dominator (CDI_DOMINATORS, bb, dom);
1229 for (i = 0; i < nc; i++)
1230 sccs[i].release ();
1231 free (sccs);
1233 for (a = son[y]; a != -1; a = brother[a])
1234 identify_vertices (g, y, a);
1237 /* Recompute dominance information for basic blocks in the set BBS. The
1238 function assumes that the immediate dominators of all the other blocks
1239 in CFG are correct, and that there are no unreachable blocks.
1241 If CONSERVATIVE is true, we additionally assume that all the ancestors of
1242 a block of BBS in the current dominance tree dominate it. */
1244 void
1245 iterate_fix_dominators (enum cdi_direction dir, vec<basic_block> bbs,
1246 bool conservative)
1248 unsigned i;
1249 basic_block bb, dom;
1250 struct graph *g;
1251 int n, y;
1252 size_t dom_i;
1253 edge e;
1254 edge_iterator ei;
1255 pointer_map<int> *map;
1256 int *parent, *son, *brother;
1257 unsigned int dir_index = dom_convert_dir_to_idx (dir);
1259 /* We only support updating dominators. There are some problems with
1260 updating postdominators (need to add fake edges from infinite loops
1261 and noreturn functions), and since we do not currently use
1262 iterate_fix_dominators for postdominators, any attempt to handle these
1263 problems would be unused, untested, and almost surely buggy. We keep
1264 the DIR argument for consistency with the rest of the dominator analysis
1265 interface. */
1266 gcc_checking_assert (dir == CDI_DOMINATORS && dom_computed[dir_index]);
1268 /* The algorithm we use takes inspiration from the following papers, although
1269 the details are quite different from any of them:
1271 [1] G. Ramalingam, T. Reps, An Incremental Algorithm for Maintaining the
1272 Dominator Tree of a Reducible Flowgraph
1273 [2] V. C. Sreedhar, G. R. Gao, Y.-F. Lee: Incremental computation of
1274 dominator trees
1275 [3] K. D. Cooper, T. J. Harvey and K. Kennedy: A Simple, Fast Dominance
1276 Algorithm
1278 First, we use the following heuristics to decrease the size of the BBS
1279 set:
1280 a) if BB has a single predecessor, then its immediate dominator is this
1281 predecessor
1282 additionally, if CONSERVATIVE is true:
1283 b) if all the predecessors of BB except for one (X) are dominated by BB,
1284 then X is the immediate dominator of BB
1285 c) if the nearest common ancestor of the predecessors of BB is X and
1286 X -> BB is an edge in CFG, then X is the immediate dominator of BB
1288 Then, we need to establish the dominance relation among the basic blocks
1289 in BBS. We split the dominance tree by removing the immediate dominator
1290 edges from BBS, creating a forest F. We form a graph G whose vertices
1291 are BBS and ENTRY and X -> Y is an edge of G if there exists an edge
1292 X' -> Y in CFG such that X' belongs to the tree of the dominance forest
1293 whose root is X. We then determine dominance tree of G. Note that
1294 for X, Y in BBS, X dominates Y in CFG if and only if X dominates Y in G.
1295 In this step, we can use arbitrary algorithm to determine dominators.
1296 We decided to prefer the algorithm [3] to the algorithm of
1297 Lengauer and Tarjan, since the set BBS is usually small (rarely exceeding
1298 10 during gcc bootstrap), and [3] should perform better in this case.
1300 Finally, we need to determine the immediate dominators for the basic
1301 blocks of BBS. If the immediate dominator of X in G is Y, then
1302 the immediate dominator of X in CFG belongs to the tree of F rooted in
1303 Y. We process the dominator tree T of G recursively, starting from leaves.
1304 Suppose that X_1, X_2, ..., X_k are the sons of Y in T, and that the
1305 subtrees of the dominance tree of CFG rooted in X_i are already correct.
1306 Let G' be the subgraph of G induced by {X_1, X_2, ..., X_k}. We make
1307 the following observations:
1308 (i) the immediate dominator of all blocks in a strongly connected
1309 component of G' is the same
1310 (ii) if X has no predecessors in G', then the immediate dominator of X
1311 is the nearest common ancestor of the predecessors of X in the
1312 subtree of F rooted in Y
1313 Therefore, it suffices to find the topological ordering of G', and
1314 process the nodes X_i in this order using the rules (i) and (ii).
1315 Then, we contract all the nodes X_i with Y in G, so that the further
1316 steps work correctly. */
1318 if (!conservative)
1320 /* Split the tree now. If the idoms of blocks in BBS are not
1321 conservatively correct, setting the dominators using the
1322 heuristics in prune_bbs_to_update_dominators could
1323 create cycles in the dominance "tree", and cause ICE. */
1324 FOR_EACH_VEC_ELT (bbs, i, bb)
1325 set_immediate_dominator (CDI_DOMINATORS, bb, NULL);
1328 prune_bbs_to_update_dominators (bbs, conservative);
1329 n = bbs.length ();
1331 if (n == 0)
1332 return;
1334 if (n == 1)
1336 bb = bbs[0];
1337 set_immediate_dominator (CDI_DOMINATORS, bb,
1338 recompute_dominator (CDI_DOMINATORS, bb));
1339 return;
1342 /* Construct the graph G. */
1343 map = new pointer_map<int>;
1344 FOR_EACH_VEC_ELT (bbs, i, bb)
1346 /* If the dominance tree is conservatively correct, split it now. */
1347 if (conservative)
1348 set_immediate_dominator (CDI_DOMINATORS, bb, NULL);
1349 *map->insert (bb) = i;
1351 *map->insert (ENTRY_BLOCK_PTR_FOR_FN (cfun)) = n;
1353 g = new_graph (n + 1);
1354 for (y = 0; y < g->n_vertices; y++)
1355 g->vertices[y].data = BITMAP_ALLOC (NULL);
1356 FOR_EACH_VEC_ELT (bbs, i, bb)
1358 FOR_EACH_EDGE (e, ei, bb->preds)
1360 dom = root_of_dom_tree (CDI_DOMINATORS, e->src);
1361 if (dom == bb)
1362 continue;
1364 dom_i = *map->contains (dom);
1366 /* Do not include parallel edges to G. */
1367 if (!bitmap_set_bit ((bitmap) g->vertices[dom_i].data, i))
1368 continue;
1370 add_edge (g, dom_i, i);
1373 for (y = 0; y < g->n_vertices; y++)
1374 BITMAP_FREE (g->vertices[y].data);
1375 delete map;
1377 /* Find the dominator tree of G. */
1378 son = XNEWVEC (int, n + 1);
1379 brother = XNEWVEC (int, n + 1);
1380 parent = XNEWVEC (int, n + 1);
1381 graphds_domtree (g, n, parent, son, brother);
1383 /* Finally, traverse the tree and find the immediate dominators. */
1384 for (y = n; son[y] != -1; y = son[y])
1385 continue;
1386 while (y != -1)
1388 determine_dominators_for_sons (g, bbs, y, son, brother);
1390 if (brother[y] != -1)
1392 y = brother[y];
1393 while (son[y] != -1)
1394 y = son[y];
1396 else
1397 y = parent[y];
1400 free (son);
1401 free (brother);
1402 free (parent);
1404 free_graph (g);
1407 void
1408 add_to_dominance_info (enum cdi_direction dir, basic_block bb)
1410 unsigned int dir_index = dom_convert_dir_to_idx (dir);
1412 gcc_checking_assert (dom_computed[dir_index] && !bb->dom[dir_index]);
1414 n_bbs_in_dom_tree[dir_index]++;
1416 bb->dom[dir_index] = et_new_tree (bb);
1418 if (dom_computed[dir_index] == DOM_OK)
1419 dom_computed[dir_index] = DOM_NO_FAST_QUERY;
1422 void
1423 delete_from_dominance_info (enum cdi_direction dir, basic_block bb)
1425 unsigned int dir_index = dom_convert_dir_to_idx (dir);
1427 gcc_checking_assert (dom_computed[dir_index]);
1429 et_free_tree (bb->dom[dir_index]);
1430 bb->dom[dir_index] = NULL;
1431 n_bbs_in_dom_tree[dir_index]--;
1433 if (dom_computed[dir_index] == DOM_OK)
1434 dom_computed[dir_index] = DOM_NO_FAST_QUERY;
1437 /* Returns the first son of BB in the dominator or postdominator tree
1438 as determined by DIR. */
1440 basic_block
1441 first_dom_son (enum cdi_direction dir, basic_block bb)
1443 unsigned int dir_index = dom_convert_dir_to_idx (dir);
1444 struct et_node *son = bb->dom[dir_index]->son;
1446 return (basic_block) (son ? son->data : NULL);
1449 /* Returns the next dominance son after BB in the dominator or postdominator
1450 tree as determined by DIR, or NULL if it was the last one. */
1452 basic_block
1453 next_dom_son (enum cdi_direction dir, basic_block bb)
1455 unsigned int dir_index = dom_convert_dir_to_idx (dir);
1456 struct et_node *next = bb->dom[dir_index]->right;
1458 return (basic_block) (next->father->son == next ? NULL : next->data);
1461 /* Return dominance availability for dominance info DIR. */
1463 enum dom_state
1464 dom_info_state (enum cdi_direction dir)
1466 unsigned int dir_index = dom_convert_dir_to_idx (dir);
1468 return dom_computed[dir_index];
1471 /* Set the dominance availability for dominance info DIR to NEW_STATE. */
1473 void
1474 set_dom_info_availability (enum cdi_direction dir, enum dom_state new_state)
1476 unsigned int dir_index = dom_convert_dir_to_idx (dir);
1478 dom_computed[dir_index] = new_state;
1481 /* Returns true if dominance information for direction DIR is available. */
1483 bool
1484 dom_info_available_p (enum cdi_direction dir)
1486 unsigned int dir_index = dom_convert_dir_to_idx (dir);
1488 return dom_computed[dir_index] != DOM_NONE;
1491 DEBUG_FUNCTION void
1492 debug_dominance_info (enum cdi_direction dir)
1494 basic_block bb, bb2;
1495 FOR_EACH_BB_FN (bb, cfun)
1496 if ((bb2 = get_immediate_dominator (dir, bb)))
1497 fprintf (stderr, "%i %i\n", bb->index, bb2->index);
1500 /* Prints to stderr representation of the dominance tree (for direction DIR)
1501 rooted in ROOT, indented by INDENT tabulators. If INDENT_FIRST is false,
1502 the first line of the output is not indented. */
1504 static void
1505 debug_dominance_tree_1 (enum cdi_direction dir, basic_block root,
1506 unsigned indent, bool indent_first)
1508 basic_block son;
1509 unsigned i;
1510 bool first = true;
1512 if (indent_first)
1513 for (i = 0; i < indent; i++)
1514 fprintf (stderr, "\t");
1515 fprintf (stderr, "%d\t", root->index);
1517 for (son = first_dom_son (dir, root);
1518 son;
1519 son = next_dom_son (dir, son))
1521 debug_dominance_tree_1 (dir, son, indent + 1, !first);
1522 first = false;
1525 if (first)
1526 fprintf (stderr, "\n");
1529 /* Prints to stderr representation of the dominance tree (for direction DIR)
1530 rooted in ROOT. */
1532 DEBUG_FUNCTION void
1533 debug_dominance_tree (enum cdi_direction dir, basic_block root)
1535 debug_dominance_tree_1 (dir, root, 0, false);