Daily bump.
[official-gcc.git] / gcc / dominance.c
blobfdd94d2c14bdda60cabd3d9d4b780fbe3e88b707
1 /* Calculate (post)dominators in slightly super-linear time.
2 Copyright (C) 2000, 2003, 2004, 2005, 2006, 2007 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 "toplev.h"
44 #include "et-forest.h"
45 #include "timevar.h"
46 #include "vecprim.h"
47 #include "pointer-set.h"
48 #include "graphds.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 representant
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;
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, (unsigned int) last_basic_block + 1, 0);
163 init_ar (di->dfs_to_bb, basic_block, num, 0);
165 di->dfsnum = 1;
166 di->nodes = 0;
168 switch (dir)
170 case CDI_DOMINATORS:
171 di->fake_exit_edge = NULL;
172 break;
173 case CDI_POST_DOMINATORS:
174 di->fake_exit_edge = BITMAP_ALLOC (NULL);
175 break;
176 default:
177 gcc_unreachable ();
178 break;
182 #undef init_ar
184 /* Map dominance calculation type to array index used for various
185 dominance information arrays. This version is simple -- it will need
186 to be modified, obviously, if additional values are added to
187 cdi_direction. */
189 static unsigned int
190 dom_convert_dir_to_idx (enum cdi_direction dir)
192 gcc_assert (dir == CDI_DOMINATORS || dir == CDI_POST_DOMINATORS);
193 return dir - 1;
196 /* Free all allocated memory in DI, but not DI itself. */
198 static void
199 free_dom_info (struct dom_info *di)
201 free (di->dfs_parent);
202 free (di->path_min);
203 free (di->key);
204 free (di->dom);
205 free (di->bucket);
206 free (di->next_bucket);
207 free (di->set_chain);
208 free (di->set_size);
209 free (di->set_child);
210 free (di->dfs_order);
211 free (di->dfs_to_bb);
212 BITMAP_FREE (di->fake_exit_edge);
215 /* The nonrecursive variant of creating a DFS tree. DI is our working
216 structure, BB the starting basic block for this tree and REVERSE
217 is true, if predecessors should be visited instead of successors of a
218 node. After this is done all nodes reachable from BB were visited, have
219 assigned their dfs number and are linked together to form a tree. */
221 static void
222 calc_dfs_tree_nonrec (struct dom_info *di, basic_block bb, bool reverse)
224 /* We call this _only_ if bb is not already visited. */
225 edge e;
226 TBB child_i, my_i = 0;
227 edge_iterator *stack;
228 edge_iterator ei, einext;
229 int sp;
230 /* Start block (ENTRY_BLOCK_PTR for forward problem, EXIT_BLOCK for backward
231 problem). */
232 basic_block en_block;
233 /* Ending block. */
234 basic_block ex_block;
236 stack = XNEWVEC (edge_iterator, n_basic_blocks + 1);
237 sp = 0;
239 /* Initialize our border blocks, and the first edge. */
240 if (reverse)
242 ei = ei_start (bb->preds);
243 en_block = EXIT_BLOCK_PTR;
244 ex_block = ENTRY_BLOCK_PTR;
246 else
248 ei = ei_start (bb->succs);
249 en_block = ENTRY_BLOCK_PTR;
250 ex_block = EXIT_BLOCK_PTR;
253 /* When the stack is empty we break out of this loop. */
254 while (1)
256 basic_block bn;
258 /* This loop traverses edges e in depth first manner, and fills the
259 stack. */
260 while (!ei_end_p (ei))
262 e = ei_edge (ei);
264 /* Deduce from E the current and the next block (BB and BN), and the
265 next edge. */
266 if (reverse)
268 bn = e->src;
270 /* If the next node BN is either already visited or a border
271 block the current edge is useless, and simply overwritten
272 with the next edge out of the current node. */
273 if (bn == ex_block || di->dfs_order[bn->index])
275 ei_next (&ei);
276 continue;
278 bb = e->dest;
279 einext = ei_start (bn->preds);
281 else
283 bn = e->dest;
284 if (bn == ex_block || di->dfs_order[bn->index])
286 ei_next (&ei);
287 continue;
289 bb = e->src;
290 einext = ei_start (bn->succs);
293 gcc_assert (bn != en_block);
295 /* Fill the DFS tree info calculatable _before_ recursing. */
296 if (bb != en_block)
297 my_i = di->dfs_order[bb->index];
298 else
299 my_i = di->dfs_order[last_basic_block];
300 child_i = di->dfs_order[bn->index] = di->dfsnum++;
301 di->dfs_to_bb[child_i] = bn;
302 di->dfs_parent[child_i] = my_i;
304 /* Save the current point in the CFG on the stack, and recurse. */
305 stack[sp++] = ei;
306 ei = einext;
309 if (!sp)
310 break;
311 ei = stack[--sp];
313 /* OK. The edge-list was exhausted, meaning normally we would
314 end the recursion. After returning from the recursive call,
315 there were (may be) other statements which were run after a
316 child node was completely considered by DFS. Here is the
317 point to do it in the non-recursive variant.
318 E.g. The block just completed is in e->dest for forward DFS,
319 the block not yet completed (the parent of the one above)
320 in e->src. This could be used e.g. for computing the number of
321 descendants or the tree depth. */
322 ei_next (&ei);
324 free (stack);
327 /* The main entry for calculating the DFS tree or forest. DI is our working
328 structure and REVERSE is true, if we are interested in the reverse flow
329 graph. In that case the result is not necessarily a tree but a forest,
330 because there may be nodes from which the EXIT_BLOCK is unreachable. */
332 static void
333 calc_dfs_tree (struct dom_info *di, bool reverse)
335 /* The first block is the ENTRY_BLOCK (or EXIT_BLOCK if REVERSE). */
336 basic_block begin = reverse ? EXIT_BLOCK_PTR : ENTRY_BLOCK_PTR;
337 di->dfs_order[last_basic_block] = di->dfsnum;
338 di->dfs_to_bb[di->dfsnum] = begin;
339 di->dfsnum++;
341 calc_dfs_tree_nonrec (di, begin, reverse);
343 if (reverse)
345 /* In the post-dom case we may have nodes without a path to EXIT_BLOCK.
346 They are reverse-unreachable. In the dom-case we disallow such
347 nodes, but in post-dom we have to deal with them.
349 There are two situations in which this occurs. First, noreturn
350 functions. Second, infinite loops. In the first case we need to
351 pretend that there is an edge to the exit block. In the second
352 case, we wind up with a forest. We need to process all noreturn
353 blocks before we know if we've got any infinite loops. */
355 basic_block b;
356 bool saw_unconnected = false;
358 FOR_EACH_BB_REVERSE (b)
360 if (EDGE_COUNT (b->succs) > 0)
362 if (di->dfs_order[b->index] == 0)
363 saw_unconnected = true;
364 continue;
366 bitmap_set_bit (di->fake_exit_edge, b->index);
367 di->dfs_order[b->index] = di->dfsnum;
368 di->dfs_to_bb[di->dfsnum] = b;
369 di->dfs_parent[di->dfsnum] = di->dfs_order[last_basic_block];
370 di->dfsnum++;
371 calc_dfs_tree_nonrec (di, b, reverse);
374 if (saw_unconnected)
376 FOR_EACH_BB_REVERSE (b)
378 if (di->dfs_order[b->index])
379 continue;
380 bitmap_set_bit (di->fake_exit_edge, b->index);
381 di->dfs_order[b->index] = di->dfsnum;
382 di->dfs_to_bb[di->dfsnum] = b;
383 di->dfs_parent[di->dfsnum] = di->dfs_order[last_basic_block];
384 di->dfsnum++;
385 calc_dfs_tree_nonrec (di, b, reverse);
390 di->nodes = di->dfsnum - 1;
392 /* This aborts e.g. when there is _no_ path from ENTRY to EXIT at all. */
393 gcc_assert (di->nodes == (unsigned int) n_basic_blocks - 1);
396 /* Compress the path from V to the root of its set and update path_min at the
397 same time. After compress(di, V) set_chain[V] is the root of the set V is
398 in and path_min[V] is the node with the smallest key[] value on the path
399 from V to that root. */
401 static void
402 compress (struct dom_info *di, TBB v)
404 /* Btw. It's not worth to unrecurse compress() as the depth is usually not
405 greater than 5 even for huge graphs (I've not seen call depth > 4).
406 Also performance wise compress() ranges _far_ behind eval(). */
407 TBB parent = di->set_chain[v];
408 if (di->set_chain[parent])
410 compress (di, parent);
411 if (di->key[di->path_min[parent]] < di->key[di->path_min[v]])
412 di->path_min[v] = di->path_min[parent];
413 di->set_chain[v] = di->set_chain[parent];
417 /* Compress the path from V to the set root of V if needed (when the root has
418 changed since the last call). Returns the node with the smallest key[]
419 value on the path from V to the root. */
421 static inline TBB
422 eval (struct dom_info *di, TBB v)
424 /* The representant of the set V is in, also called root (as the set
425 representation is a tree). */
426 TBB rep = di->set_chain[v];
428 /* V itself is the root. */
429 if (!rep)
430 return di->path_min[v];
432 /* Compress only if necessary. */
433 if (di->set_chain[rep])
435 compress (di, v);
436 rep = di->set_chain[v];
439 if (di->key[di->path_min[rep]] >= di->key[di->path_min[v]])
440 return di->path_min[v];
441 else
442 return di->path_min[rep];
445 /* This essentially merges the two sets of V and W, giving a single set with
446 the new root V. The internal representation of these disjoint sets is a
447 balanced tree. Currently link(V,W) is only used with V being the parent
448 of W. */
450 static void
451 link_roots (struct dom_info *di, TBB v, TBB w)
453 TBB s = w;
455 /* Rebalance the tree. */
456 while (di->key[di->path_min[w]] < di->key[di->path_min[di->set_child[s]]])
458 if (di->set_size[s] + di->set_size[di->set_child[di->set_child[s]]]
459 >= 2 * di->set_size[di->set_child[s]])
461 di->set_chain[di->set_child[s]] = s;
462 di->set_child[s] = di->set_child[di->set_child[s]];
464 else
466 di->set_size[di->set_child[s]] = di->set_size[s];
467 s = di->set_chain[s] = di->set_child[s];
471 di->path_min[s] = di->path_min[w];
472 di->set_size[v] += di->set_size[w];
473 if (di->set_size[v] < 2 * di->set_size[w])
475 TBB tmp = s;
476 s = di->set_child[v];
477 di->set_child[v] = tmp;
480 /* Merge all subtrees. */
481 while (s)
483 di->set_chain[s] = v;
484 s = di->set_child[s];
488 /* This calculates the immediate dominators (or post-dominators if REVERSE is
489 true). DI is our working structure and should hold the DFS forest.
490 On return the immediate dominator to node V is in di->dom[V]. */
492 static void
493 calc_idoms (struct dom_info *di, bool reverse)
495 TBB v, w, k, par;
496 basic_block en_block;
497 edge_iterator ei, einext;
499 if (reverse)
500 en_block = EXIT_BLOCK_PTR;
501 else
502 en_block = ENTRY_BLOCK_PTR;
504 /* Go backwards in DFS order, to first look at the leafs. */
505 v = di->nodes;
506 while (v > 1)
508 basic_block bb = di->dfs_to_bb[v];
509 edge e;
511 par = di->dfs_parent[v];
512 k = v;
514 ei = (reverse) ? ei_start (bb->succs) : ei_start (bb->preds);
516 if (reverse)
518 /* If this block has a fake edge to exit, process that first. */
519 if (bitmap_bit_p (di->fake_exit_edge, bb->index))
521 einext = ei;
522 einext.index = 0;
523 goto do_fake_exit_edge;
527 /* Search all direct predecessors for the smallest node with a path
528 to them. That way we have the smallest node with also a path to
529 us only over nodes behind us. In effect we search for our
530 semidominator. */
531 while (!ei_end_p (ei))
533 TBB k1;
534 basic_block b;
536 e = ei_edge (ei);
537 b = (reverse) ? e->dest : e->src;
538 einext = ei;
539 ei_next (&einext);
541 if (b == en_block)
543 do_fake_exit_edge:
544 k1 = di->dfs_order[last_basic_block];
546 else
547 k1 = di->dfs_order[b->index];
549 /* Call eval() only if really needed. If k1 is above V in DFS tree,
550 then we know, that eval(k1) == k1 and key[k1] == k1. */
551 if (k1 > v)
552 k1 = di->key[eval (di, k1)];
553 if (k1 < k)
554 k = k1;
556 ei = einext;
559 di->key[v] = k;
560 link_roots (di, par, v);
561 di->next_bucket[v] = di->bucket[k];
562 di->bucket[k] = v;
564 /* Transform semidominators into dominators. */
565 for (w = di->bucket[par]; w; w = di->next_bucket[w])
567 k = eval (di, w);
568 if (di->key[k] < di->key[w])
569 di->dom[w] = k;
570 else
571 di->dom[w] = par;
573 /* We don't need to cleanup next_bucket[]. */
574 di->bucket[par] = 0;
575 v--;
578 /* Explicitly define the dominators. */
579 di->dom[1] = 0;
580 for (v = 2; v <= di->nodes; v++)
581 if (di->dom[v] != di->key[v])
582 di->dom[v] = di->dom[di->dom[v]];
585 /* Assign dfs numbers starting from NUM to NODE and its sons. */
587 static void
588 assign_dfs_numbers (struct et_node *node, int *num)
590 struct et_node *son;
592 node->dfs_num_in = (*num)++;
594 if (node->son)
596 assign_dfs_numbers (node->son, num);
597 for (son = node->son->right; son != node->son; son = son->right)
598 assign_dfs_numbers (son, num);
601 node->dfs_num_out = (*num)++;
604 /* Compute the data necessary for fast resolving of dominator queries in a
605 static dominator tree. */
607 static void
608 compute_dom_fast_query (enum cdi_direction dir)
610 int num = 0;
611 basic_block bb;
612 unsigned int dir_index = dom_convert_dir_to_idx (dir);
614 gcc_assert (dom_info_available_p (dir));
616 if (dom_computed[dir_index] == DOM_OK)
617 return;
619 FOR_ALL_BB (bb)
621 if (!bb->dom[dir_index]->father)
622 assign_dfs_numbers (bb->dom[dir_index], &num);
625 dom_computed[dir_index] = DOM_OK;
628 /* The main entry point into this module. DIR is set depending on whether
629 we want to compute dominators or postdominators. */
631 void
632 calculate_dominance_info (enum cdi_direction dir)
634 struct dom_info di;
635 basic_block b;
636 unsigned int dir_index = dom_convert_dir_to_idx (dir);
637 bool reverse = (dir == CDI_POST_DOMINATORS) ? true : false;
639 if (dom_computed[dir_index] == DOM_OK)
640 return;
642 timevar_push (TV_DOMINANCE);
643 if (!dom_info_available_p (dir))
645 gcc_assert (!n_bbs_in_dom_tree[dir_index]);
647 FOR_ALL_BB (b)
649 b->dom[dir_index] = et_new_tree (b);
651 n_bbs_in_dom_tree[dir_index] = n_basic_blocks;
653 init_dom_info (&di, dir);
654 calc_dfs_tree (&di, reverse);
655 calc_idoms (&di, reverse);
657 FOR_EACH_BB (b)
659 TBB d = di.dom[di.dfs_order[b->index]];
661 if (di.dfs_to_bb[d])
662 et_set_father (b->dom[dir_index], di.dfs_to_bb[d]->dom[dir_index]);
665 free_dom_info (&di);
666 dom_computed[dir_index] = DOM_NO_FAST_QUERY;
669 compute_dom_fast_query (dir);
671 timevar_pop (TV_DOMINANCE);
674 /* Free dominance information for direction DIR. */
675 void
676 free_dominance_info (enum cdi_direction dir)
678 basic_block bb;
679 unsigned int dir_index = dom_convert_dir_to_idx (dir);
681 if (!dom_info_available_p (dir))
682 return;
684 FOR_ALL_BB (bb)
686 et_free_tree_force (bb->dom[dir_index]);
687 bb->dom[dir_index] = NULL;
689 et_free_pools ();
691 n_bbs_in_dom_tree[dir_index] = 0;
693 dom_computed[dir_index] = DOM_NONE;
696 /* Return the immediate dominator of basic block BB. */
697 basic_block
698 get_immediate_dominator (enum cdi_direction dir, basic_block bb)
700 unsigned int dir_index = dom_convert_dir_to_idx (dir);
701 struct et_node *node = bb->dom[dir_index];
703 gcc_assert (dom_computed[dir_index]);
705 if (!node->father)
706 return NULL;
708 return node->father->data;
711 /* Set the immediate dominator of the block possibly removing
712 existing edge. NULL can be used to remove any edge. */
713 inline void
714 set_immediate_dominator (enum cdi_direction dir, basic_block bb,
715 basic_block dominated_by)
717 unsigned int dir_index = dom_convert_dir_to_idx (dir);
718 struct et_node *node = bb->dom[dir_index];
720 gcc_assert (dom_computed[dir_index]);
722 if (node->father)
724 if (node->father->data == dominated_by)
725 return;
726 et_split (node);
729 if (dominated_by)
730 et_set_father (node, dominated_by->dom[dir_index]);
732 if (dom_computed[dir_index] == DOM_OK)
733 dom_computed[dir_index] = DOM_NO_FAST_QUERY;
736 /* Returns the list of basic blocks immediately dominated by BB, in the
737 direction DIR. */
738 VEC (basic_block, heap) *
739 get_dominated_by (enum cdi_direction dir, basic_block bb)
741 int n;
742 unsigned int dir_index = dom_convert_dir_to_idx (dir);
743 struct et_node *node = bb->dom[dir_index], *son = node->son, *ason;
744 VEC (basic_block, heap) *bbs = NULL;
746 gcc_assert (dom_computed[dir_index]);
748 if (!son)
749 return NULL;
751 VEC_safe_push (basic_block, heap, bbs, son->data);
752 for (ason = son->right, n = 1; ason != son; ason = ason->right)
753 VEC_safe_push (basic_block, heap, bbs, ason->data);
755 return bbs;
758 /* Returns the list of basic blocks that are immediately dominated (in
759 direction DIR) by some block between N_REGION ones stored in REGION,
760 except for blocks in the REGION itself. */
762 VEC (basic_block, heap) *
763 get_dominated_by_region (enum cdi_direction dir, basic_block *region,
764 unsigned n_region)
766 unsigned i;
767 basic_block dom;
768 VEC (basic_block, heap) *doms = NULL;
770 for (i = 0; i < n_region; i++)
771 region[i]->flags |= BB_DUPLICATED;
772 for (i = 0; i < n_region; i++)
773 for (dom = first_dom_son (dir, region[i]);
774 dom;
775 dom = next_dom_son (dir, dom))
776 if (!(dom->flags & BB_DUPLICATED))
777 VEC_safe_push (basic_block, heap, doms, dom);
778 for (i = 0; i < n_region; i++)
779 region[i]->flags &= ~BB_DUPLICATED;
781 return doms;
784 /* Redirect all edges pointing to BB to TO. */
785 void
786 redirect_immediate_dominators (enum cdi_direction dir, basic_block bb,
787 basic_block to)
789 unsigned int dir_index = dom_convert_dir_to_idx (dir);
790 struct et_node *bb_node, *to_node, *son;
792 bb_node = bb->dom[dir_index];
793 to_node = to->dom[dir_index];
795 gcc_assert (dom_computed[dir_index]);
797 if (!bb_node->son)
798 return;
800 while (bb_node->son)
802 son = bb_node->son;
804 et_split (son);
805 et_set_father (son, to_node);
808 if (dom_computed[dir_index] == DOM_OK)
809 dom_computed[dir_index] = DOM_NO_FAST_QUERY;
812 /* Find first basic block in the tree dominating both BB1 and BB2. */
813 basic_block
814 nearest_common_dominator (enum cdi_direction dir, basic_block bb1, basic_block bb2)
816 unsigned int dir_index = dom_convert_dir_to_idx (dir);
818 gcc_assert (dom_computed[dir_index]);
820 if (!bb1)
821 return bb2;
822 if (!bb2)
823 return bb1;
825 return et_nca (bb1->dom[dir_index], bb2->dom[dir_index])->data;
829 /* Find the nearest common dominator for the basic blocks in BLOCKS,
830 using dominance direction DIR. */
832 basic_block
833 nearest_common_dominator_for_set (enum cdi_direction dir, bitmap blocks)
835 unsigned i, first;
836 bitmap_iterator bi;
837 basic_block dom;
839 first = bitmap_first_set_bit (blocks);
840 dom = BASIC_BLOCK (first);
841 EXECUTE_IF_SET_IN_BITMAP (blocks, 0, i, bi)
842 if (dom != BASIC_BLOCK (i))
843 dom = nearest_common_dominator (dir, dom, BASIC_BLOCK (i));
845 return dom;
848 /* Given a dominator tree, we can determine whether one thing
849 dominates another in constant time by using two DFS numbers:
851 1. The number for when we visit a node on the way down the tree
852 2. The number for when we visit a node on the way back up the tree
854 You can view these as bounds for the range of dfs numbers the
855 nodes in the subtree of the dominator tree rooted at that node
856 will contain.
858 The dominator tree is always a simple acyclic tree, so there are
859 only three possible relations two nodes in the dominator tree have
860 to each other:
862 1. Node A is above Node B (and thus, Node A dominates node B)
871 In the above case, DFS_Number_In of A will be <= DFS_Number_In of
872 B, and DFS_Number_Out of A will be >= DFS_Number_Out of B. This is
873 because we must hit A in the dominator tree *before* B on the walk
874 down, and we will hit A *after* B on the walk back up
876 2. Node A is below node B (and thus, node B dominates node A)
885 In the above case, DFS_Number_In of A will be >= DFS_Number_In of
886 B, and DFS_Number_Out of A will be <= DFS_Number_Out of B.
888 This is because we must hit A in the dominator tree *after* B on
889 the walk down, and we will hit A *before* B on the walk back up
891 3. Node A and B are siblings (and thus, neither dominates the other)
899 In the above case, DFS_Number_In of A will *always* be <=
900 DFS_Number_In of B, and DFS_Number_Out of A will *always* be <=
901 DFS_Number_Out of B. This is because we will always finish the dfs
902 walk of one of the subtrees before the other, and thus, the dfs
903 numbers for one subtree can't intersect with the range of dfs
904 numbers for the other subtree. If you swap A and B's position in
905 the dominator tree, the comparison changes direction, but the point
906 is that both comparisons will always go the same way if there is no
907 dominance relationship.
909 Thus, it is sufficient to write
911 A_Dominates_B (node A, node B)
913 return DFS_Number_In(A) <= DFS_Number_In(B)
914 && DFS_Number_Out (A) >= DFS_Number_Out(B);
917 A_Dominated_by_B (node A, node B)
919 return DFS_Number_In(A) >= DFS_Number_In(A)
920 && DFS_Number_Out (A) <= DFS_Number_Out(B);
921 } */
923 /* Return TRUE in case BB1 is dominated by BB2. */
924 bool
925 dominated_by_p (enum cdi_direction dir, const_basic_block bb1, const_basic_block bb2)
927 unsigned int dir_index = dom_convert_dir_to_idx (dir);
928 struct et_node *n1 = bb1->dom[dir_index], *n2 = bb2->dom[dir_index];
930 gcc_assert (dom_computed[dir_index]);
932 if (dom_computed[dir_index] == DOM_OK)
933 return (n1->dfs_num_in >= n2->dfs_num_in
934 && n1->dfs_num_out <= n2->dfs_num_out);
936 return et_below (n1, n2);
939 /* Returns the entry dfs number for basic block BB, in the direction DIR. */
941 unsigned
942 bb_dom_dfs_in (enum cdi_direction dir, basic_block bb)
944 unsigned int dir_index = dom_convert_dir_to_idx (dir);
945 struct et_node *n = bb->dom[dir_index];
947 gcc_assert (dom_computed[dir_index] == DOM_OK);
948 return n->dfs_num_in;
951 /* Returns the exit dfs number for basic block BB, in the direction DIR. */
953 unsigned
954 bb_dom_dfs_out (enum cdi_direction dir, basic_block bb)
956 unsigned int dir_index = dom_convert_dir_to_idx (dir);
957 struct et_node *n = bb->dom[dir_index];
959 gcc_assert (dom_computed[dir_index] == DOM_OK);
960 return n->dfs_num_out;
963 /* Verify invariants of dominator structure. */
964 void
965 verify_dominators (enum cdi_direction dir)
967 int err = 0;
968 basic_block bb, imm_bb, imm_bb_correct;
969 struct dom_info di;
970 bool reverse = (dir == CDI_POST_DOMINATORS) ? true : false;
972 gcc_assert (dom_info_available_p (dir));
974 init_dom_info (&di, dir);
975 calc_dfs_tree (&di, reverse);
976 calc_idoms (&di, reverse);
978 FOR_EACH_BB (bb)
980 imm_bb = get_immediate_dominator (dir, bb);
981 if (!imm_bb)
983 error ("dominator of %d status unknown", bb->index);
984 err = 1;
987 imm_bb_correct = di.dfs_to_bb[di.dom[di.dfs_order[bb->index]]];
988 if (imm_bb != imm_bb_correct)
990 error ("dominator of %d should be %d, not %d",
991 bb->index, imm_bb_correct->index, imm_bb->index);
992 err = 1;
996 free_dom_info (&di);
997 gcc_assert (!err);
1000 /* Determine immediate dominator (or postdominator, according to DIR) of BB,
1001 assuming that dominators of other blocks are correct. We also use it to
1002 recompute the dominators in a restricted area, by iterating it until it
1003 reaches a fixed point. */
1005 basic_block
1006 recompute_dominator (enum cdi_direction dir, basic_block bb)
1008 unsigned int dir_index = dom_convert_dir_to_idx (dir);
1009 basic_block dom_bb = NULL;
1010 edge e;
1011 edge_iterator ei;
1013 gcc_assert (dom_computed[dir_index]);
1015 if (dir == CDI_DOMINATORS)
1017 FOR_EACH_EDGE (e, ei, bb->preds)
1019 if (!dominated_by_p (dir, e->src, bb))
1020 dom_bb = nearest_common_dominator (dir, dom_bb, e->src);
1023 else
1025 FOR_EACH_EDGE (e, ei, bb->succs)
1027 if (!dominated_by_p (dir, e->dest, bb))
1028 dom_bb = nearest_common_dominator (dir, dom_bb, e->dest);
1032 return dom_bb;
1035 /* Use simple heuristics (see iterate_fix_dominators) to determine dominators
1036 of BBS. We assume that all the immediate dominators except for those of the
1037 blocks in BBS are correct. If CONSERVATIVE is true, we also assume that the
1038 currently recorded immediate dominators of blocks in BBS really dominate the
1039 blocks. The basic blocks for that we determine the dominator are removed
1040 from BBS. */
1042 static void
1043 prune_bbs_to_update_dominators (VEC (basic_block, heap) *bbs,
1044 bool conservative)
1046 unsigned i;
1047 bool single;
1048 basic_block bb, dom = NULL;
1049 edge_iterator ei;
1050 edge e;
1052 for (i = 0; VEC_iterate (basic_block, bbs, i, bb);)
1054 if (bb == ENTRY_BLOCK_PTR)
1055 goto succeed;
1057 if (single_pred_p (bb))
1059 set_immediate_dominator (CDI_DOMINATORS, bb, single_pred (bb));
1060 goto succeed;
1063 if (!conservative)
1064 goto fail;
1066 single = true;
1067 dom = NULL;
1068 FOR_EACH_EDGE (e, ei, bb->preds)
1070 if (dominated_by_p (CDI_DOMINATORS, e->src, bb))
1071 continue;
1073 if (!dom)
1074 dom = e->src;
1075 else
1077 single = false;
1078 dom = nearest_common_dominator (CDI_DOMINATORS, dom, e->src);
1082 gcc_assert (dom != NULL);
1083 if (single
1084 || find_edge (dom, bb))
1086 set_immediate_dominator (CDI_DOMINATORS, bb, dom);
1087 goto succeed;
1090 fail:
1091 i++;
1092 continue;
1094 succeed:
1095 VEC_unordered_remove (basic_block, bbs, i);
1099 /* Returns root of the dominance tree in the direction DIR that contains
1100 BB. */
1102 static basic_block
1103 root_of_dom_tree (enum cdi_direction dir, basic_block bb)
1105 return et_root (bb->dom[dom_convert_dir_to_idx (dir)])->data;
1108 /* See the comment in iterate_fix_dominators. Finds the immediate dominators
1109 for the sons of Y, found using the SON and BROTHER arrays representing
1110 the dominance tree of graph G. BBS maps the vertices of G to the basic
1111 blocks. */
1113 static void
1114 determine_dominators_for_sons (struct graph *g, VEC (basic_block, heap) *bbs,
1115 int y, int *son, int *brother)
1117 bitmap gprime;
1118 int i, a, nc;
1119 VEC (int, heap) **sccs;
1120 basic_block bb, dom, ybb;
1121 unsigned si;
1122 edge e;
1123 edge_iterator ei;
1125 if (son[y] == -1)
1126 return;
1127 if (y == (int) VEC_length (basic_block, bbs))
1128 ybb = ENTRY_BLOCK_PTR;
1129 else
1130 ybb = VEC_index (basic_block, bbs, y);
1132 if (brother[son[y]] == -1)
1134 /* Handle the common case Y has just one son specially. */
1135 bb = VEC_index (basic_block, bbs, son[y]);
1136 set_immediate_dominator (CDI_DOMINATORS, bb,
1137 recompute_dominator (CDI_DOMINATORS, bb));
1138 identify_vertices (g, y, son[y]);
1139 return;
1142 gprime = BITMAP_ALLOC (NULL);
1143 for (a = son[y]; a != -1; a = brother[a])
1144 bitmap_set_bit (gprime, a);
1146 nc = graphds_scc (g, gprime);
1147 BITMAP_FREE (gprime);
1149 sccs = XCNEWVEC (VEC (int, heap) *, nc);
1150 for (a = son[y]; a != -1; a = brother[a])
1151 VEC_safe_push (int, heap, sccs[g->vertices[a].component], a);
1153 for (i = nc - 1; i >= 0; i--)
1155 dom = NULL;
1156 for (si = 0; VEC_iterate (int, sccs[i], si, a); si++)
1158 bb = VEC_index (basic_block, bbs, a);
1159 FOR_EACH_EDGE (e, ei, bb->preds)
1161 if (root_of_dom_tree (CDI_DOMINATORS, e->src) != ybb)
1162 continue;
1164 dom = nearest_common_dominator (CDI_DOMINATORS, dom, e->src);
1168 gcc_assert (dom != NULL);
1169 for (si = 0; VEC_iterate (int, sccs[i], si, a); si++)
1171 bb = VEC_index (basic_block, bbs, a);
1172 set_immediate_dominator (CDI_DOMINATORS, bb, dom);
1176 for (i = 0; i < nc; i++)
1177 VEC_free (int, heap, sccs[i]);
1178 free (sccs);
1180 for (a = son[y]; a != -1; a = brother[a])
1181 identify_vertices (g, y, a);
1184 /* Recompute dominance information for basic blocks in the set BBS. The
1185 function assumes that the immediate dominators of all the other blocks
1186 in CFG are correct, and that there are no unreachable blocks.
1188 If CONSERVATIVE is true, we additionally assume that all the ancestors of
1189 a block of BBS in the current dominance tree dominate it. */
1191 void
1192 iterate_fix_dominators (enum cdi_direction dir, VEC (basic_block, heap) *bbs,
1193 bool conservative)
1195 unsigned i;
1196 basic_block bb, dom;
1197 struct graph *g;
1198 int n, y;
1199 size_t dom_i;
1200 edge e;
1201 edge_iterator ei;
1202 struct pointer_map_t *map;
1203 int *parent, *son, *brother;
1204 unsigned int dir_index = dom_convert_dir_to_idx (dir);
1206 /* We only support updating dominators. There are some problems with
1207 updating postdominators (need to add fake edges from infinite loops
1208 and noreturn functions), and since we do not currently use
1209 iterate_fix_dominators for postdominators, any attempt to handle these
1210 problems would be unused, untested, and almost surely buggy. We keep
1211 the DIR argument for consistency with the rest of the dominator analysis
1212 interface. */
1213 gcc_assert (dir == CDI_DOMINATORS);
1214 gcc_assert (dom_computed[dir_index]);
1216 /* The algorithm we use takes inspiration from the following papers, although
1217 the details are quite different from any of them:
1219 [1] G. Ramalingam, T. Reps, An Incremental Algorithm for Maintaining the
1220 Dominator Tree of a Reducible Flowgraph
1221 [2] V. C. Sreedhar, G. R. Gao, Y.-F. Lee: Incremental computation of
1222 dominator trees
1223 [3] K. D. Cooper, T. J. Harvey and K. Kennedy: A Simple, Fast Dominance
1224 Algorithm
1226 First, we use the following heuristics to decrease the size of the BBS
1227 set:
1228 a) if BB has a single predecessor, then its immediate dominator is this
1229 predecessor
1230 additionally, if CONSERVATIVE is true:
1231 b) if all the predecessors of BB except for one (X) are dominated by BB,
1232 then X is the immediate dominator of BB
1233 c) if the nearest common ancestor of the predecessors of BB is X and
1234 X -> BB is an edge in CFG, then X is the immediate dominator of BB
1236 Then, we need to establish the dominance relation among the basic blocks
1237 in BBS. We split the dominance tree by removing the immediate dominator
1238 edges from BBS, creating a forest F. We form a graph G whose vertices
1239 are BBS and ENTRY and X -> Y is an edge of G if there exists an edge
1240 X' -> Y in CFG such that X' belongs to the tree of the dominance forest
1241 whose root is X. We then determine dominance tree of G. Note that
1242 for X, Y in BBS, X dominates Y in CFG if and only if X dominates Y in G.
1243 In this step, we can use arbitrary algorithm to determine dominators.
1244 We decided to prefer the algorithm [3] to the algorithm of
1245 Lengauer and Tarjan, since the set BBS is usually small (rarely exceeding
1246 10 during gcc bootstrap), and [3] should perform better in this case.
1248 Finally, we need to determine the immediate dominators for the basic
1249 blocks of BBS. If the immediate dominator of X in G is Y, then
1250 the immediate dominator of X in CFG belongs to the tree of F rooted in
1251 Y. We process the dominator tree T of G recursively, starting from leaves.
1252 Suppose that X_1, X_2, ..., X_k are the sons of Y in T, and that the
1253 subtrees of the dominance tree of CFG rooted in X_i are already correct.
1254 Let G' be the subgraph of G induced by {X_1, X_2, ..., X_k}. We make
1255 the following observations:
1256 (i) the immediate dominator of all blocks in a strongly connected
1257 component of G' is the same
1258 (ii) if X has no predecessors in G', then the immediate dominator of X
1259 is the nearest common ancestor of the predecessors of X in the
1260 subtree of F rooted in Y
1261 Therefore, it suffices to find the topological ordering of G', and
1262 process the nodes X_i in this order using the rules (i) and (ii).
1263 Then, we contract all the nodes X_i with Y in G, so that the further
1264 steps work correctly. */
1266 if (!conservative)
1268 /* Split the tree now. If the idoms of blocks in BBS are not
1269 conservatively correct, setting the dominators using the
1270 heuristics in prune_bbs_to_update_dominators could
1271 create cycles in the dominance "tree", and cause ICE. */
1272 for (i = 0; VEC_iterate (basic_block, bbs, i, bb); i++)
1273 set_immediate_dominator (CDI_DOMINATORS, bb, NULL);
1276 prune_bbs_to_update_dominators (bbs, conservative);
1277 n = VEC_length (basic_block, bbs);
1279 if (n == 0)
1280 return;
1282 if (n == 1)
1284 bb = VEC_index (basic_block, bbs, 0);
1285 set_immediate_dominator (CDI_DOMINATORS, bb,
1286 recompute_dominator (CDI_DOMINATORS, bb));
1287 return;
1290 /* Construct the graph G. */
1291 map = pointer_map_create ();
1292 for (i = 0; VEC_iterate (basic_block, bbs, i, bb); i++)
1294 /* If the dominance tree is conservatively correct, split it now. */
1295 if (conservative)
1296 set_immediate_dominator (CDI_DOMINATORS, bb, NULL);
1297 *pointer_map_insert (map, bb) = (void *) (size_t) i;
1299 *pointer_map_insert (map, ENTRY_BLOCK_PTR) = (void *) (size_t) n;
1301 g = new_graph (n + 1);
1302 for (y = 0; y < g->n_vertices; y++)
1303 g->vertices[y].data = BITMAP_ALLOC (NULL);
1304 for (i = 0; VEC_iterate (basic_block, bbs, i, bb); i++)
1306 FOR_EACH_EDGE (e, ei, bb->preds)
1308 dom = root_of_dom_tree (CDI_DOMINATORS, e->src);
1309 if (dom == bb)
1310 continue;
1312 dom_i = (size_t) *pointer_map_contains (map, dom);
1314 /* Do not include parallel edges to G. */
1315 if (bitmap_bit_p (g->vertices[dom_i].data, i))
1316 continue;
1318 bitmap_set_bit (g->vertices[dom_i].data, i);
1319 add_edge (g, dom_i, i);
1322 for (y = 0; y < g->n_vertices; y++)
1323 BITMAP_FREE (g->vertices[y].data);
1324 pointer_map_destroy (map);
1326 /* Find the dominator tree of G. */
1327 son = XNEWVEC (int, n + 1);
1328 brother = XNEWVEC (int, n + 1);
1329 parent = XNEWVEC (int, n + 1);
1330 graphds_domtree (g, n, parent, son, brother);
1332 /* Finally, traverse the tree and find the immediate dominators. */
1333 for (y = n; son[y] != -1; y = son[y])
1334 continue;
1335 while (y != -1)
1337 determine_dominators_for_sons (g, bbs, y, son, brother);
1339 if (brother[y] != -1)
1341 y = brother[y];
1342 while (son[y] != -1)
1343 y = son[y];
1345 else
1346 y = parent[y];
1349 free (son);
1350 free (brother);
1351 free (parent);
1353 free_graph (g);
1356 void
1357 add_to_dominance_info (enum cdi_direction dir, basic_block bb)
1359 unsigned int dir_index = dom_convert_dir_to_idx (dir);
1361 gcc_assert (dom_computed[dir_index]);
1362 gcc_assert (!bb->dom[dir_index]);
1364 n_bbs_in_dom_tree[dir_index]++;
1366 bb->dom[dir_index] = et_new_tree (bb);
1368 if (dom_computed[dir_index] == DOM_OK)
1369 dom_computed[dir_index] = DOM_NO_FAST_QUERY;
1372 void
1373 delete_from_dominance_info (enum cdi_direction dir, basic_block bb)
1375 unsigned int dir_index = dom_convert_dir_to_idx (dir);
1377 gcc_assert (dom_computed[dir_index]);
1379 et_free_tree (bb->dom[dir_index]);
1380 bb->dom[dir_index] = NULL;
1381 n_bbs_in_dom_tree[dir_index]--;
1383 if (dom_computed[dir_index] == DOM_OK)
1384 dom_computed[dir_index] = DOM_NO_FAST_QUERY;
1387 /* Returns the first son of BB in the dominator or postdominator tree
1388 as determined by DIR. */
1390 basic_block
1391 first_dom_son (enum cdi_direction dir, basic_block bb)
1393 unsigned int dir_index = dom_convert_dir_to_idx (dir);
1394 struct et_node *son = bb->dom[dir_index]->son;
1396 return son ? son->data : NULL;
1399 /* Returns the next dominance son after BB in the dominator or postdominator
1400 tree as determined by DIR, or NULL if it was the last one. */
1402 basic_block
1403 next_dom_son (enum cdi_direction dir, basic_block bb)
1405 unsigned int dir_index = dom_convert_dir_to_idx (dir);
1406 struct et_node *next = bb->dom[dir_index]->right;
1408 return next->father->son == next ? NULL : next->data;
1411 /* Return dominance availability for dominance info DIR. */
1413 enum dom_state
1414 dom_info_state (enum cdi_direction dir)
1416 unsigned int dir_index = dom_convert_dir_to_idx (dir);
1418 return dom_computed[dir_index];
1421 /* Set the dominance availability for dominance info DIR to NEW_STATE. */
1423 void
1424 set_dom_info_availability (enum cdi_direction dir, enum dom_state new_state)
1426 unsigned int dir_index = dom_convert_dir_to_idx (dir);
1428 dom_computed[dir_index] = new_state;
1431 /* Returns true if dominance information for direction DIR is available. */
1433 bool
1434 dom_info_available_p (enum cdi_direction dir)
1436 unsigned int dir_index = dom_convert_dir_to_idx (dir);
1438 return dom_computed[dir_index] != DOM_NONE;
1441 void
1442 debug_dominance_info (enum cdi_direction dir)
1444 basic_block bb, bb2;
1445 FOR_EACH_BB (bb)
1446 if ((bb2 = get_immediate_dominator (dir, bb)))
1447 fprintf (stderr, "%i %i\n", bb->index, bb2->index);
1450 /* Prints to stderr representation of the dominance tree (for direction DIR)
1451 rooted in ROOT, indented by INDENT tabulators. If INDENT_FIRST is false,
1452 the first line of the output is not indented. */
1454 static void
1455 debug_dominance_tree_1 (enum cdi_direction dir, basic_block root,
1456 unsigned indent, bool indent_first)
1458 basic_block son;
1459 unsigned i;
1460 bool first = true;
1462 if (indent_first)
1463 for (i = 0; i < indent; i++)
1464 fprintf (stderr, "\t");
1465 fprintf (stderr, "%d\t", root->index);
1467 for (son = first_dom_son (dir, root);
1468 son;
1469 son = next_dom_son (dir, son))
1471 debug_dominance_tree_1 (dir, son, indent + 1, !first);
1472 first = false;
1475 if (first)
1476 fprintf (stderr, "\n");
1479 /* Prints to stderr representation of the dominance tree (for direction DIR)
1480 rooted in ROOT. */
1482 void
1483 debug_dominance_tree (enum cdi_direction dir, basic_block root)
1485 debug_dominance_tree_1 (dir, root, 0, false);