1 /* Calculate (post)dominators in slightly super-linear time.
2 Copyright (C) 2000-2015 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)
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. */
37 #include "coretypes.h"
40 #include "hard-reg-set.h"
45 #include "dominance.h"
48 #include "basic-block.h"
49 #include "diagnostic-core.h"
50 #include "alloc-pool.h"
51 #include "et-forest.h"
56 /* We name our nodes with integers, beginning with 1. Zero is reserved for
57 'undefined' or 'end of list'. The name of each node is given by the dfs
58 number of the corresponding basic block. Please note, that we include the
59 artificial ENTRY_BLOCK (or EXIT_BLOCK in the post-dom case) in our lists to
60 support multiple entry points. Its dfs number is of course 1. */
62 /* Type of Basic Block aka. TBB */
63 typedef unsigned int TBB
;
65 /* We work in a poor-mans object oriented fashion, and carry an instance of
66 this structure through all our 'methods'. It holds various arrays
67 reflecting the (sub)structure of the flowgraph. Most of them are of type
68 TBB and are also indexed by TBB. */
72 /* The parent of a node in the DFS tree. */
74 /* For a node x key[x] is roughly the node nearest to the root from which
75 exists a way to x only over nodes behind x. Such a node is also called
78 /* The value in path_min[x] is the node y on the path from x to the root of
79 the tree x is in with the smallest key[y]. */
81 /* bucket[x] points to the first node of the set of nodes having x as key. */
83 /* And next_bucket[x] points to the next node. */
85 /* After the algorithm is done, dom[x] contains the immediate dominator
89 /* The following few fields implement the structures needed for disjoint
91 /* set_chain[x] is the next node on the path from x to the representative
92 of the set containing x. If set_chain[x]==0 then x is a root. */
94 /* set_size[x] is the number of elements in the set named by x. */
95 unsigned int *set_size
;
96 /* set_child[x] is used for balancing the tree representing a set. It can
97 be understood as the next sibling of x. */
100 /* If b is the number of a basic block (BB->index), dfs_order[b] is the
101 number of that node in DFS order counted from 1. This is an index
102 into most of the other arrays in this structure. */
104 /* If x is the DFS-index of a node which corresponds with a basic block,
105 dfs_to_bb[x] is that basic block. Note, that in our structure there are
106 more nodes that basic blocks, so only dfs_to_bb[dfs_order[bb->index]]==bb
107 is true for every basic block bb, but not the opposite. */
108 basic_block
*dfs_to_bb
;
110 /* This is the next free DFS number when creating the DFS tree. */
112 /* The number of nodes in the DFS tree (==dfsnum-1). */
115 /* Blocks with bits set here have a fake edge to EXIT. These are used
116 to turn a DFS forest into a proper tree. */
117 bitmap fake_exit_edge
;
120 static void init_dom_info (struct dom_info
*, enum cdi_direction
);
121 static void free_dom_info (struct dom_info
*);
122 static void calc_dfs_tree_nonrec (struct dom_info
*, basic_block
, bool);
123 static void calc_dfs_tree (struct dom_info
*, bool);
124 static void compress (struct dom_info
*, TBB
);
125 static TBB
eval (struct dom_info
*, TBB
);
126 static void link_roots (struct dom_info
*, TBB
, TBB
);
127 static void calc_idoms (struct dom_info
*, bool);
128 void debug_dominance_info (enum cdi_direction
);
129 void debug_dominance_tree (enum cdi_direction
, basic_block
);
131 /* Helper macro for allocating and initializing an array,
132 for aesthetic reasons. */
133 #define init_ar(var, type, num, content) \
136 unsigned int i = 1; /* Catch content == i. */ \
138 (var) = XCNEWVEC (type, num); \
141 (var) = XNEWVEC (type, (num)); \
142 for (i = 0; i < num; i++) \
143 (var)[i] = (content); \
148 /* Allocate all needed memory in a pessimistic fashion (so we round up).
149 This initializes the contents of DI, which already must be allocated. */
152 init_dom_info (struct dom_info
*di
, enum cdi_direction dir
)
154 /* We need memory for n_basic_blocks nodes. */
155 unsigned int num
= n_basic_blocks_for_fn (cfun
);
156 init_ar (di
->dfs_parent
, TBB
, num
, 0);
157 init_ar (di
->path_min
, TBB
, num
, i
);
158 init_ar (di
->key
, TBB
, num
, i
);
159 init_ar (di
->dom
, TBB
, num
, 0);
161 init_ar (di
->bucket
, TBB
, num
, 0);
162 init_ar (di
->next_bucket
, TBB
, num
, 0);
164 init_ar (di
->set_chain
, TBB
, num
, 0);
165 init_ar (di
->set_size
, unsigned int, num
, 1);
166 init_ar (di
->set_child
, TBB
, num
, 0);
168 init_ar (di
->dfs_order
, TBB
,
169 (unsigned int) last_basic_block_for_fn (cfun
) + 1, 0);
170 init_ar (di
->dfs_to_bb
, basic_block
, num
, 0);
178 di
->fake_exit_edge
= NULL
;
180 case CDI_POST_DOMINATORS
:
181 di
->fake_exit_edge
= BITMAP_ALLOC (NULL
);
191 /* Map dominance calculation type to array index used for various
192 dominance information arrays. This version is simple -- it will need
193 to be modified, obviously, if additional values are added to
197 dom_convert_dir_to_idx (enum cdi_direction dir
)
199 gcc_checking_assert (dir
== CDI_DOMINATORS
|| dir
== CDI_POST_DOMINATORS
);
203 /* Free all allocated memory in DI, but not DI itself. */
206 free_dom_info (struct dom_info
*di
)
208 free (di
->dfs_parent
);
213 free (di
->next_bucket
);
214 free (di
->set_chain
);
216 free (di
->set_child
);
217 free (di
->dfs_order
);
218 free (di
->dfs_to_bb
);
219 BITMAP_FREE (di
->fake_exit_edge
);
222 /* The nonrecursive variant of creating a DFS tree. DI is our working
223 structure, BB the starting basic block for this tree and REVERSE
224 is true, if predecessors should be visited instead of successors of a
225 node. After this is done all nodes reachable from BB were visited, have
226 assigned their dfs number and are linked together to form a tree. */
229 calc_dfs_tree_nonrec (struct dom_info
*di
, basic_block bb
, bool reverse
)
231 /* We call this _only_ if bb is not already visited. */
233 TBB child_i
, my_i
= 0;
234 edge_iterator
*stack
;
235 edge_iterator ei
, einext
;
237 /* Start block (the entry block for forward problem, exit block for backward
239 basic_block en_block
;
241 basic_block ex_block
;
243 stack
= XNEWVEC (edge_iterator
, n_basic_blocks_for_fn (cfun
) + 1);
246 /* Initialize our border blocks, and the first edge. */
249 ei
= ei_start (bb
->preds
);
250 en_block
= EXIT_BLOCK_PTR_FOR_FN (cfun
);
251 ex_block
= ENTRY_BLOCK_PTR_FOR_FN (cfun
);
255 ei
= ei_start (bb
->succs
);
256 en_block
= ENTRY_BLOCK_PTR_FOR_FN (cfun
);
257 ex_block
= EXIT_BLOCK_PTR_FOR_FN (cfun
);
260 /* When the stack is empty we break out of this loop. */
265 /* This loop traverses edges e in depth first manner, and fills the
267 while (!ei_end_p (ei
))
271 /* Deduce from E the current and the next block (BB and BN), and the
277 /* If the next node BN is either already visited or a border
278 block the current edge is useless, and simply overwritten
279 with the next edge out of the current node. */
280 if (bn
== ex_block
|| di
->dfs_order
[bn
->index
])
286 einext
= ei_start (bn
->preds
);
291 if (bn
== ex_block
|| di
->dfs_order
[bn
->index
])
297 einext
= ei_start (bn
->succs
);
300 gcc_assert (bn
!= en_block
);
302 /* Fill the DFS tree info calculatable _before_ recursing. */
304 my_i
= di
->dfs_order
[bb
->index
];
306 my_i
= di
->dfs_order
[last_basic_block_for_fn (cfun
)];
307 child_i
= di
->dfs_order
[bn
->index
] = di
->dfsnum
++;
308 di
->dfs_to_bb
[child_i
] = bn
;
309 di
->dfs_parent
[child_i
] = my_i
;
311 /* Save the current point in the CFG on the stack, and recurse. */
320 /* OK. The edge-list was exhausted, meaning normally we would
321 end the recursion. After returning from the recursive call,
322 there were (may be) other statements which were run after a
323 child node was completely considered by DFS. Here is the
324 point to do it in the non-recursive variant.
325 E.g. The block just completed is in e->dest for forward DFS,
326 the block not yet completed (the parent of the one above)
327 in e->src. This could be used e.g. for computing the number of
328 descendants or the tree depth. */
334 /* The main entry for calculating the DFS tree or forest. DI is our working
335 structure and REVERSE is true, if we are interested in the reverse flow
336 graph. In that case the result is not necessarily a tree but a forest,
337 because there may be nodes from which the EXIT_BLOCK is unreachable. */
340 calc_dfs_tree (struct dom_info
*di
, bool reverse
)
342 /* The first block is the ENTRY_BLOCK (or EXIT_BLOCK if REVERSE). */
343 basic_block begin
= (reverse
344 ? EXIT_BLOCK_PTR_FOR_FN (cfun
) : ENTRY_BLOCK_PTR_FOR_FN (cfun
));
345 di
->dfs_order
[last_basic_block_for_fn (cfun
)] = di
->dfsnum
;
346 di
->dfs_to_bb
[di
->dfsnum
] = begin
;
349 calc_dfs_tree_nonrec (di
, begin
, reverse
);
353 /* In the post-dom case we may have nodes without a path to EXIT_BLOCK.
354 They are reverse-unreachable. In the dom-case we disallow such
355 nodes, but in post-dom we have to deal with them.
357 There are two situations in which this occurs. First, noreturn
358 functions. Second, infinite loops. In the first case we need to
359 pretend that there is an edge to the exit block. In the second
360 case, we wind up with a forest. We need to process all noreturn
361 blocks before we know if we've got any infinite loops. */
364 bool saw_unconnected
= false;
366 FOR_EACH_BB_REVERSE_FN (b
, cfun
)
368 if (EDGE_COUNT (b
->succs
) > 0)
370 if (di
->dfs_order
[b
->index
] == 0)
371 saw_unconnected
= true;
374 bitmap_set_bit (di
->fake_exit_edge
, b
->index
);
375 di
->dfs_order
[b
->index
] = di
->dfsnum
;
376 di
->dfs_to_bb
[di
->dfsnum
] = b
;
377 di
->dfs_parent
[di
->dfsnum
] =
378 di
->dfs_order
[last_basic_block_for_fn (cfun
)];
380 calc_dfs_tree_nonrec (di
, b
, reverse
);
385 FOR_EACH_BB_REVERSE_FN (b
, cfun
)
388 if (di
->dfs_order
[b
->index
])
390 b2
= dfs_find_deadend (b
);
391 gcc_checking_assert (di
->dfs_order
[b2
->index
] == 0);
392 bitmap_set_bit (di
->fake_exit_edge
, b2
->index
);
393 di
->dfs_order
[b2
->index
] = di
->dfsnum
;
394 di
->dfs_to_bb
[di
->dfsnum
] = b2
;
395 di
->dfs_parent
[di
->dfsnum
] =
396 di
->dfs_order
[last_basic_block_for_fn (cfun
)];
398 calc_dfs_tree_nonrec (di
, b2
, reverse
);
399 gcc_checking_assert (di
->dfs_order
[b
->index
]);
404 di
->nodes
= di
->dfsnum
- 1;
406 /* This aborts e.g. when there is _no_ path from ENTRY to EXIT at all. */
407 gcc_assert (di
->nodes
== (unsigned int) n_basic_blocks_for_fn (cfun
) - 1);
410 /* Compress the path from V to the root of its set and update path_min at the
411 same time. After compress(di, V) set_chain[V] is the root of the set V is
412 in and path_min[V] is the node with the smallest key[] value on the path
413 from V to that root. */
416 compress (struct dom_info
*di
, TBB v
)
418 /* Btw. It's not worth to unrecurse compress() as the depth is usually not
419 greater than 5 even for huge graphs (I've not seen call depth > 4).
420 Also performance wise compress() ranges _far_ behind eval(). */
421 TBB parent
= di
->set_chain
[v
];
422 if (di
->set_chain
[parent
])
424 compress (di
, parent
);
425 if (di
->key
[di
->path_min
[parent
]] < di
->key
[di
->path_min
[v
]])
426 di
->path_min
[v
] = di
->path_min
[parent
];
427 di
->set_chain
[v
] = di
->set_chain
[parent
];
431 /* Compress the path from V to the set root of V if needed (when the root has
432 changed since the last call). Returns the node with the smallest key[]
433 value on the path from V to the root. */
436 eval (struct dom_info
*di
, TBB v
)
438 /* The representative of the set V is in, also called root (as the set
439 representation is a tree). */
440 TBB rep
= di
->set_chain
[v
];
442 /* V itself is the root. */
444 return di
->path_min
[v
];
446 /* Compress only if necessary. */
447 if (di
->set_chain
[rep
])
450 rep
= di
->set_chain
[v
];
453 if (di
->key
[di
->path_min
[rep
]] >= di
->key
[di
->path_min
[v
]])
454 return di
->path_min
[v
];
456 return di
->path_min
[rep
];
459 /* This essentially merges the two sets of V and W, giving a single set with
460 the new root V. The internal representation of these disjoint sets is a
461 balanced tree. Currently link(V,W) is only used with V being the parent
465 link_roots (struct dom_info
*di
, TBB v
, TBB w
)
469 /* Rebalance the tree. */
470 while (di
->key
[di
->path_min
[w
]] < di
->key
[di
->path_min
[di
->set_child
[s
]]])
472 if (di
->set_size
[s
] + di
->set_size
[di
->set_child
[di
->set_child
[s
]]]
473 >= 2 * di
->set_size
[di
->set_child
[s
]])
475 di
->set_chain
[di
->set_child
[s
]] = s
;
476 di
->set_child
[s
] = di
->set_child
[di
->set_child
[s
]];
480 di
->set_size
[di
->set_child
[s
]] = di
->set_size
[s
];
481 s
= di
->set_chain
[s
] = di
->set_child
[s
];
485 di
->path_min
[s
] = di
->path_min
[w
];
486 di
->set_size
[v
] += di
->set_size
[w
];
487 if (di
->set_size
[v
] < 2 * di
->set_size
[w
])
490 s
= di
->set_child
[v
];
491 di
->set_child
[v
] = tmp
;
494 /* Merge all subtrees. */
497 di
->set_chain
[s
] = v
;
498 s
= di
->set_child
[s
];
502 /* This calculates the immediate dominators (or post-dominators if REVERSE is
503 true). DI is our working structure and should hold the DFS forest.
504 On return the immediate dominator to node V is in di->dom[V]. */
507 calc_idoms (struct dom_info
*di
, bool reverse
)
510 basic_block en_block
;
511 edge_iterator ei
, einext
;
514 en_block
= EXIT_BLOCK_PTR_FOR_FN (cfun
);
516 en_block
= ENTRY_BLOCK_PTR_FOR_FN (cfun
);
518 /* Go backwards in DFS order, to first look at the leafs. */
522 basic_block bb
= di
->dfs_to_bb
[v
];
525 par
= di
->dfs_parent
[v
];
528 ei
= (reverse
) ? ei_start (bb
->succs
) : ei_start (bb
->preds
);
532 /* If this block has a fake edge to exit, process that first. */
533 if (bitmap_bit_p (di
->fake_exit_edge
, bb
->index
))
537 goto do_fake_exit_edge
;
541 /* Search all direct predecessors for the smallest node with a path
542 to them. That way we have the smallest node with also a path to
543 us only over nodes behind us. In effect we search for our
545 while (!ei_end_p (ei
))
551 b
= (reverse
) ? e
->dest
: e
->src
;
558 k1
= di
->dfs_order
[last_basic_block_for_fn (cfun
)];
561 k1
= di
->dfs_order
[b
->index
];
563 /* Call eval() only if really needed. If k1 is above V in DFS tree,
564 then we know, that eval(k1) == k1 and key[k1] == k1. */
566 k1
= di
->key
[eval (di
, k1
)];
574 link_roots (di
, par
, v
);
575 di
->next_bucket
[v
] = di
->bucket
[k
];
578 /* Transform semidominators into dominators. */
579 for (w
= di
->bucket
[par
]; w
; w
= di
->next_bucket
[w
])
582 if (di
->key
[k
] < di
->key
[w
])
587 /* We don't need to cleanup next_bucket[]. */
592 /* Explicitly define the dominators. */
594 for (v
= 2; v
<= di
->nodes
; v
++)
595 if (di
->dom
[v
] != di
->key
[v
])
596 di
->dom
[v
] = di
->dom
[di
->dom
[v
]];
599 /* Assign dfs numbers starting from NUM to NODE and its sons. */
602 assign_dfs_numbers (struct et_node
*node
, int *num
)
606 node
->dfs_num_in
= (*num
)++;
610 assign_dfs_numbers (node
->son
, num
);
611 for (son
= node
->son
->right
; son
!= node
->son
; son
= son
->right
)
612 assign_dfs_numbers (son
, num
);
615 node
->dfs_num_out
= (*num
)++;
618 /* Compute the data necessary for fast resolving of dominator queries in a
619 static dominator tree. */
622 compute_dom_fast_query (enum cdi_direction dir
)
626 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
628 gcc_checking_assert (dom_info_available_p (dir
));
630 if (dom_computed
[dir_index
] == DOM_OK
)
633 FOR_ALL_BB_FN (bb
, cfun
)
635 if (!bb
->dom
[dir_index
]->father
)
636 assign_dfs_numbers (bb
->dom
[dir_index
], &num
);
639 dom_computed
[dir_index
] = DOM_OK
;
642 /* The main entry point into this module. DIR is set depending on whether
643 we want to compute dominators or postdominators. */
646 calculate_dominance_info (enum cdi_direction dir
)
650 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
651 bool reverse
= (dir
== CDI_POST_DOMINATORS
) ? true : false;
653 if (dom_computed
[dir_index
] == DOM_OK
)
656 timevar_push (TV_DOMINANCE
);
657 if (!dom_info_available_p (dir
))
659 gcc_assert (!n_bbs_in_dom_tree
[dir_index
]);
661 FOR_ALL_BB_FN (b
, cfun
)
663 b
->dom
[dir_index
] = et_new_tree (b
);
665 n_bbs_in_dom_tree
[dir_index
] = n_basic_blocks_for_fn (cfun
);
667 init_dom_info (&di
, dir
);
668 calc_dfs_tree (&di
, reverse
);
669 calc_idoms (&di
, reverse
);
671 FOR_EACH_BB_FN (b
, cfun
)
673 TBB d
= di
.dom
[di
.dfs_order
[b
->index
]];
676 et_set_father (b
->dom
[dir_index
], di
.dfs_to_bb
[d
]->dom
[dir_index
]);
680 dom_computed
[dir_index
] = DOM_NO_FAST_QUERY
;
683 compute_dom_fast_query (dir
);
685 timevar_pop (TV_DOMINANCE
);
688 /* Free dominance information for direction DIR. */
690 free_dominance_info (function
*fn
, enum cdi_direction dir
)
693 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
695 if (!dom_info_available_p (fn
, dir
))
698 FOR_ALL_BB_FN (bb
, fn
)
700 et_free_tree_force (bb
->dom
[dir_index
]);
701 bb
->dom
[dir_index
] = NULL
;
705 fn
->cfg
->x_n_bbs_in_dom_tree
[dir_index
] = 0;
707 fn
->cfg
->x_dom_computed
[dir_index
] = DOM_NONE
;
711 free_dominance_info (enum cdi_direction dir
)
713 free_dominance_info (cfun
, dir
);
716 /* Return the immediate dominator of basic block BB. */
718 get_immediate_dominator (enum cdi_direction dir
, basic_block bb
)
720 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
721 struct et_node
*node
= bb
->dom
[dir_index
];
723 gcc_checking_assert (dom_computed
[dir_index
]);
728 return (basic_block
) node
->father
->data
;
731 /* Set the immediate dominator of the block possibly removing
732 existing edge. NULL can be used to remove any edge. */
734 set_immediate_dominator (enum cdi_direction dir
, basic_block bb
,
735 basic_block dominated_by
)
737 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
738 struct et_node
*node
= bb
->dom
[dir_index
];
740 gcc_checking_assert (dom_computed
[dir_index
]);
744 if (node
->father
->data
== dominated_by
)
750 et_set_father (node
, dominated_by
->dom
[dir_index
]);
752 if (dom_computed
[dir_index
] == DOM_OK
)
753 dom_computed
[dir_index
] = DOM_NO_FAST_QUERY
;
756 /* Returns the list of basic blocks immediately dominated by BB, in the
759 get_dominated_by (enum cdi_direction dir
, basic_block bb
)
761 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
762 struct et_node
*node
= bb
->dom
[dir_index
], *son
= node
->son
, *ason
;
763 vec
<basic_block
> bbs
= vNULL
;
765 gcc_checking_assert (dom_computed
[dir_index
]);
770 bbs
.safe_push ((basic_block
) son
->data
);
771 for (ason
= son
->right
; ason
!= son
; ason
= ason
->right
)
772 bbs
.safe_push ((basic_block
) ason
->data
);
777 /* Returns the list of basic blocks that are immediately dominated (in
778 direction DIR) by some block between N_REGION ones stored in REGION,
779 except for blocks in the REGION itself. */
782 get_dominated_by_region (enum cdi_direction dir
, basic_block
*region
,
787 vec
<basic_block
> doms
= vNULL
;
789 for (i
= 0; i
< n_region
; i
++)
790 region
[i
]->flags
|= BB_DUPLICATED
;
791 for (i
= 0; i
< n_region
; i
++)
792 for (dom
= first_dom_son (dir
, region
[i
]);
794 dom
= next_dom_son (dir
, dom
))
795 if (!(dom
->flags
& BB_DUPLICATED
))
796 doms
.safe_push (dom
);
797 for (i
= 0; i
< n_region
; i
++)
798 region
[i
]->flags
&= ~BB_DUPLICATED
;
803 /* Returns the list of basic blocks including BB dominated by BB, in the
804 direction DIR up to DEPTH in the dominator tree. The DEPTH of zero will
805 produce a vector containing all dominated blocks. The vector will be sorted
809 get_dominated_to_depth (enum cdi_direction dir
, basic_block bb
, int depth
)
811 vec
<basic_block
> bbs
= vNULL
;
813 unsigned next_level_start
;
817 next_level_start
= 1; /* = bbs.length (); */
824 for (son
= first_dom_son (dir
, bb
);
826 son
= next_dom_son (dir
, son
))
829 if (i
== next_level_start
&& --depth
)
830 next_level_start
= bbs
.length ();
832 while (i
< next_level_start
);
837 /* Returns the list of basic blocks including BB dominated by BB, in the
838 direction DIR. The vector will be sorted in preorder. */
841 get_all_dominated_blocks (enum cdi_direction dir
, basic_block bb
)
843 return get_dominated_to_depth (dir
, bb
, 0);
846 /* Redirect all edges pointing to BB to TO. */
848 redirect_immediate_dominators (enum cdi_direction dir
, basic_block bb
,
851 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
852 struct et_node
*bb_node
, *to_node
, *son
;
854 bb_node
= bb
->dom
[dir_index
];
855 to_node
= to
->dom
[dir_index
];
857 gcc_checking_assert (dom_computed
[dir_index
]);
867 et_set_father (son
, to_node
);
870 if (dom_computed
[dir_index
] == DOM_OK
)
871 dom_computed
[dir_index
] = DOM_NO_FAST_QUERY
;
874 /* Find first basic block in the tree dominating both BB1 and BB2. */
876 nearest_common_dominator (enum cdi_direction dir
, basic_block bb1
, basic_block bb2
)
878 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
880 gcc_checking_assert (dom_computed
[dir_index
]);
887 return (basic_block
) et_nca (bb1
->dom
[dir_index
], bb2
->dom
[dir_index
])->data
;
891 /* Find the nearest common dominator for the basic blocks in BLOCKS,
892 using dominance direction DIR. */
895 nearest_common_dominator_for_set (enum cdi_direction dir
, bitmap blocks
)
901 first
= bitmap_first_set_bit (blocks
);
902 dom
= BASIC_BLOCK_FOR_FN (cfun
, first
);
903 EXECUTE_IF_SET_IN_BITMAP (blocks
, 0, i
, bi
)
904 if (dom
!= BASIC_BLOCK_FOR_FN (cfun
, i
))
905 dom
= nearest_common_dominator (dir
, dom
, BASIC_BLOCK_FOR_FN (cfun
, i
));
910 /* Given a dominator tree, we can determine whether one thing
911 dominates another in constant time by using two DFS numbers:
913 1. The number for when we visit a node on the way down the tree
914 2. The number for when we visit a node on the way back up the tree
916 You can view these as bounds for the range of dfs numbers the
917 nodes in the subtree of the dominator tree rooted at that node
920 The dominator tree is always a simple acyclic tree, so there are
921 only three possible relations two nodes in the dominator tree have
924 1. Node A is above Node B (and thus, Node A dominates node B)
933 In the above case, DFS_Number_In of A will be <= DFS_Number_In of
934 B, and DFS_Number_Out of A will be >= DFS_Number_Out of B. This is
935 because we must hit A in the dominator tree *before* B on the walk
936 down, and we will hit A *after* B on the walk back up
938 2. Node A is below node B (and thus, node B dominates node A)
947 In the above case, DFS_Number_In of A will be >= DFS_Number_In of
948 B, and DFS_Number_Out of A will be <= DFS_Number_Out of B.
950 This is because we must hit A in the dominator tree *after* B on
951 the walk down, and we will hit A *before* B on the walk back up
953 3. Node A and B are siblings (and thus, neither dominates the other)
961 In the above case, DFS_Number_In of A will *always* be <=
962 DFS_Number_In of B, and DFS_Number_Out of A will *always* be <=
963 DFS_Number_Out of B. This is because we will always finish the dfs
964 walk of one of the subtrees before the other, and thus, the dfs
965 numbers for one subtree can't intersect with the range of dfs
966 numbers for the other subtree. If you swap A and B's position in
967 the dominator tree, the comparison changes direction, but the point
968 is that both comparisons will always go the same way if there is no
969 dominance relationship.
971 Thus, it is sufficient to write
973 A_Dominates_B (node A, node B)
975 return DFS_Number_In(A) <= DFS_Number_In(B)
976 && DFS_Number_Out (A) >= DFS_Number_Out(B);
979 A_Dominated_by_B (node A, node B)
981 return DFS_Number_In(A) >= DFS_Number_In(B)
982 && DFS_Number_Out (A) <= DFS_Number_Out(B);
985 /* Return TRUE in case BB1 is dominated by BB2. */
987 dominated_by_p (enum cdi_direction dir
, const_basic_block bb1
, const_basic_block bb2
)
989 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
990 struct et_node
*n1
= bb1
->dom
[dir_index
], *n2
= bb2
->dom
[dir_index
];
992 gcc_checking_assert (dom_computed
[dir_index
]);
994 if (dom_computed
[dir_index
] == DOM_OK
)
995 return (n1
->dfs_num_in
>= n2
->dfs_num_in
996 && n1
->dfs_num_out
<= n2
->dfs_num_out
);
998 return et_below (n1
, n2
);
1001 /* Returns the entry dfs number for basic block BB, in the direction DIR. */
1004 bb_dom_dfs_in (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_in
;
1013 /* Returns the exit dfs number for basic block BB, in the direction DIR. */
1016 bb_dom_dfs_out (enum cdi_direction dir
, basic_block bb
)
1018 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
1019 struct et_node
*n
= bb
->dom
[dir_index
];
1021 gcc_checking_assert (dom_computed
[dir_index
] == DOM_OK
);
1022 return n
->dfs_num_out
;
1025 /* Verify invariants of dominator structure. */
1027 verify_dominators (enum cdi_direction dir
)
1030 basic_block bb
, imm_bb
, imm_bb_correct
;
1032 bool reverse
= (dir
== CDI_POST_DOMINATORS
) ? true : false;
1034 gcc_assert (dom_info_available_p (dir
));
1036 init_dom_info (&di
, dir
);
1037 calc_dfs_tree (&di
, reverse
);
1038 calc_idoms (&di
, reverse
);
1040 FOR_EACH_BB_FN (bb
, cfun
)
1042 imm_bb
= get_immediate_dominator (dir
, bb
);
1045 error ("dominator of %d status unknown", bb
->index
);
1049 imm_bb_correct
= di
.dfs_to_bb
[di
.dom
[di
.dfs_order
[bb
->index
]]];
1050 if (imm_bb
!= imm_bb_correct
)
1052 error ("dominator of %d should be %d, not %d",
1053 bb
->index
, imm_bb_correct
->index
, imm_bb
->index
);
1058 free_dom_info (&di
);
1062 /* Determine immediate dominator (or postdominator, according to DIR) of BB,
1063 assuming that dominators of other blocks are correct. We also use it to
1064 recompute the dominators in a restricted area, by iterating it until it
1065 reaches a fixed point. */
1068 recompute_dominator (enum cdi_direction dir
, basic_block bb
)
1070 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
1071 basic_block dom_bb
= NULL
;
1075 gcc_checking_assert (dom_computed
[dir_index
]);
1077 if (dir
== CDI_DOMINATORS
)
1079 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
1081 if (!dominated_by_p (dir
, e
->src
, bb
))
1082 dom_bb
= nearest_common_dominator (dir
, dom_bb
, e
->src
);
1087 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
1089 if (!dominated_by_p (dir
, e
->dest
, bb
))
1090 dom_bb
= nearest_common_dominator (dir
, dom_bb
, e
->dest
);
1097 /* Use simple heuristics (see iterate_fix_dominators) to determine dominators
1098 of BBS. We assume that all the immediate dominators except for those of the
1099 blocks in BBS are correct. If CONSERVATIVE is true, we also assume that the
1100 currently recorded immediate dominators of blocks in BBS really dominate the
1101 blocks. The basic blocks for that we determine the dominator are removed
1105 prune_bbs_to_update_dominators (vec
<basic_block
> bbs
,
1110 basic_block bb
, dom
= NULL
;
1114 for (i
= 0; bbs
.iterate (i
, &bb
);)
1116 if (bb
== ENTRY_BLOCK_PTR_FOR_FN (cfun
))
1119 if (single_pred_p (bb
))
1121 set_immediate_dominator (CDI_DOMINATORS
, bb
, single_pred (bb
));
1130 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
1132 if (dominated_by_p (CDI_DOMINATORS
, e
->src
, bb
))
1140 dom
= nearest_common_dominator (CDI_DOMINATORS
, dom
, e
->src
);
1144 gcc_assert (dom
!= NULL
);
1146 || find_edge (dom
, bb
))
1148 set_immediate_dominator (CDI_DOMINATORS
, bb
, dom
);
1157 bbs
.unordered_remove (i
);
1161 /* Returns root of the dominance tree in the direction DIR that contains
1165 root_of_dom_tree (enum cdi_direction dir
, basic_block bb
)
1167 return (basic_block
) et_root (bb
->dom
[dom_convert_dir_to_idx (dir
)])->data
;
1170 /* See the comment in iterate_fix_dominators. Finds the immediate dominators
1171 for the sons of Y, found using the SON and BROTHER arrays representing
1172 the dominance tree of graph G. BBS maps the vertices of G to the basic
1176 determine_dominators_for_sons (struct graph
*g
, vec
<basic_block
> bbs
,
1177 int y
, int *son
, int *brother
)
1182 basic_block bb
, dom
, ybb
;
1189 if (y
== (int) bbs
.length ())
1190 ybb
= ENTRY_BLOCK_PTR_FOR_FN (cfun
);
1194 if (brother
[son
[y
]] == -1)
1196 /* Handle the common case Y has just one son specially. */
1198 set_immediate_dominator (CDI_DOMINATORS
, bb
,
1199 recompute_dominator (CDI_DOMINATORS
, bb
));
1200 identify_vertices (g
, y
, son
[y
]);
1204 gprime
= BITMAP_ALLOC (NULL
);
1205 for (a
= son
[y
]; a
!= -1; a
= brother
[a
])
1206 bitmap_set_bit (gprime
, a
);
1208 nc
= graphds_scc (g
, gprime
);
1209 BITMAP_FREE (gprime
);
1211 /* ??? Needed to work around the pre-processor confusion with
1212 using a multi-argument template type as macro argument. */
1213 typedef vec
<int> vec_int_heap
;
1214 sccs
= XCNEWVEC (vec_int_heap
, nc
);
1215 for (a
= son
[y
]; a
!= -1; a
= brother
[a
])
1216 sccs
[g
->vertices
[a
].component
].safe_push (a
);
1218 for (i
= nc
- 1; i
>= 0; i
--)
1221 FOR_EACH_VEC_ELT (sccs
[i
], si
, a
)
1224 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
1226 if (root_of_dom_tree (CDI_DOMINATORS
, e
->src
) != ybb
)
1229 dom
= nearest_common_dominator (CDI_DOMINATORS
, dom
, e
->src
);
1233 gcc_assert (dom
!= NULL
);
1234 FOR_EACH_VEC_ELT (sccs
[i
], si
, a
)
1237 set_immediate_dominator (CDI_DOMINATORS
, bb
, dom
);
1241 for (i
= 0; i
< nc
; i
++)
1245 for (a
= son
[y
]; a
!= -1; a
= brother
[a
])
1246 identify_vertices (g
, y
, a
);
1249 /* Recompute dominance information for basic blocks in the set BBS. The
1250 function assumes that the immediate dominators of all the other blocks
1251 in CFG are correct, and that there are no unreachable blocks.
1253 If CONSERVATIVE is true, we additionally assume that all the ancestors of
1254 a block of BBS in the current dominance tree dominate it. */
1257 iterate_fix_dominators (enum cdi_direction dir
, vec
<basic_block
> bbs
,
1261 basic_block bb
, dom
;
1267 int *parent
, *son
, *brother
;
1268 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
1270 /* We only support updating dominators. There are some problems with
1271 updating postdominators (need to add fake edges from infinite loops
1272 and noreturn functions), and since we do not currently use
1273 iterate_fix_dominators for postdominators, any attempt to handle these
1274 problems would be unused, untested, and almost surely buggy. We keep
1275 the DIR argument for consistency with the rest of the dominator analysis
1277 gcc_checking_assert (dir
== CDI_DOMINATORS
&& dom_computed
[dir_index
]);
1279 /* The algorithm we use takes inspiration from the following papers, although
1280 the details are quite different from any of them:
1282 [1] G. Ramalingam, T. Reps, An Incremental Algorithm for Maintaining the
1283 Dominator Tree of a Reducible Flowgraph
1284 [2] V. C. Sreedhar, G. R. Gao, Y.-F. Lee: Incremental computation of
1286 [3] K. D. Cooper, T. J. Harvey and K. Kennedy: A Simple, Fast Dominance
1289 First, we use the following heuristics to decrease the size of the BBS
1291 a) if BB has a single predecessor, then its immediate dominator is this
1293 additionally, if CONSERVATIVE is true:
1294 b) if all the predecessors of BB except for one (X) are dominated by BB,
1295 then X is the immediate dominator of BB
1296 c) if the nearest common ancestor of the predecessors of BB is X and
1297 X -> BB is an edge in CFG, then X is the immediate dominator of BB
1299 Then, we need to establish the dominance relation among the basic blocks
1300 in BBS. We split the dominance tree by removing the immediate dominator
1301 edges from BBS, creating a forest F. We form a graph G whose vertices
1302 are BBS and ENTRY and X -> Y is an edge of G if there exists an edge
1303 X' -> Y in CFG such that X' belongs to the tree of the dominance forest
1304 whose root is X. We then determine dominance tree of G. Note that
1305 for X, Y in BBS, X dominates Y in CFG if and only if X dominates Y in G.
1306 In this step, we can use arbitrary algorithm to determine dominators.
1307 We decided to prefer the algorithm [3] to the algorithm of
1308 Lengauer and Tarjan, since the set BBS is usually small (rarely exceeding
1309 10 during gcc bootstrap), and [3] should perform better in this case.
1311 Finally, we need to determine the immediate dominators for the basic
1312 blocks of BBS. If the immediate dominator of X in G is Y, then
1313 the immediate dominator of X in CFG belongs to the tree of F rooted in
1314 Y. We process the dominator tree T of G recursively, starting from leaves.
1315 Suppose that X_1, X_2, ..., X_k are the sons of Y in T, and that the
1316 subtrees of the dominance tree of CFG rooted in X_i are already correct.
1317 Let G' be the subgraph of G induced by {X_1, X_2, ..., X_k}. We make
1318 the following observations:
1319 (i) the immediate dominator of all blocks in a strongly connected
1320 component of G' is the same
1321 (ii) if X has no predecessors in G', then the immediate dominator of X
1322 is the nearest common ancestor of the predecessors of X in the
1323 subtree of F rooted in Y
1324 Therefore, it suffices to find the topological ordering of G', and
1325 process the nodes X_i in this order using the rules (i) and (ii).
1326 Then, we contract all the nodes X_i with Y in G, so that the further
1327 steps work correctly. */
1331 /* Split the tree now. If the idoms of blocks in BBS are not
1332 conservatively correct, setting the dominators using the
1333 heuristics in prune_bbs_to_update_dominators could
1334 create cycles in the dominance "tree", and cause ICE. */
1335 FOR_EACH_VEC_ELT (bbs
, i
, bb
)
1336 set_immediate_dominator (CDI_DOMINATORS
, bb
, NULL
);
1339 prune_bbs_to_update_dominators (bbs
, conservative
);
1348 set_immediate_dominator (CDI_DOMINATORS
, bb
,
1349 recompute_dominator (CDI_DOMINATORS
, bb
));
1353 /* Construct the graph G. */
1354 hash_map
<basic_block
, int> map (251);
1355 FOR_EACH_VEC_ELT (bbs
, i
, bb
)
1357 /* If the dominance tree is conservatively correct, split it now. */
1359 set_immediate_dominator (CDI_DOMINATORS
, bb
, NULL
);
1362 map
.put (ENTRY_BLOCK_PTR_FOR_FN (cfun
), n
);
1364 g
= new_graph (n
+ 1);
1365 for (y
= 0; y
< g
->n_vertices
; y
++)
1366 g
->vertices
[y
].data
= BITMAP_ALLOC (NULL
);
1367 FOR_EACH_VEC_ELT (bbs
, i
, bb
)
1369 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
1371 dom
= root_of_dom_tree (CDI_DOMINATORS
, e
->src
);
1375 dom_i
= *map
.get (dom
);
1377 /* Do not include parallel edges to G. */
1378 if (!bitmap_set_bit ((bitmap
) g
->vertices
[dom_i
].data
, i
))
1381 add_edge (g
, dom_i
, i
);
1384 for (y
= 0; y
< g
->n_vertices
; y
++)
1385 BITMAP_FREE (g
->vertices
[y
].data
);
1387 /* Find the dominator tree of G. */
1388 son
= XNEWVEC (int, n
+ 1);
1389 brother
= XNEWVEC (int, n
+ 1);
1390 parent
= XNEWVEC (int, n
+ 1);
1391 graphds_domtree (g
, n
, parent
, son
, brother
);
1393 /* Finally, traverse the tree and find the immediate dominators. */
1394 for (y
= n
; son
[y
] != -1; y
= son
[y
])
1398 determine_dominators_for_sons (g
, bbs
, y
, son
, brother
);
1400 if (brother
[y
] != -1)
1403 while (son
[y
] != -1)
1418 add_to_dominance_info (enum cdi_direction dir
, basic_block bb
)
1420 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
1422 gcc_checking_assert (dom_computed
[dir_index
] && !bb
->dom
[dir_index
]);
1424 n_bbs_in_dom_tree
[dir_index
]++;
1426 bb
->dom
[dir_index
] = et_new_tree (bb
);
1428 if (dom_computed
[dir_index
] == DOM_OK
)
1429 dom_computed
[dir_index
] = DOM_NO_FAST_QUERY
;
1433 delete_from_dominance_info (enum cdi_direction dir
, basic_block bb
)
1435 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
1437 gcc_checking_assert (dom_computed
[dir_index
]);
1439 et_free_tree (bb
->dom
[dir_index
]);
1440 bb
->dom
[dir_index
] = NULL
;
1441 n_bbs_in_dom_tree
[dir_index
]--;
1443 if (dom_computed
[dir_index
] == DOM_OK
)
1444 dom_computed
[dir_index
] = DOM_NO_FAST_QUERY
;
1447 /* Returns the first son of BB in the dominator or postdominator tree
1448 as determined by DIR. */
1451 first_dom_son (enum cdi_direction dir
, basic_block bb
)
1453 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
1454 struct et_node
*son
= bb
->dom
[dir_index
]->son
;
1456 return (basic_block
) (son
? son
->data
: NULL
);
1459 /* Returns the next dominance son after BB in the dominator or postdominator
1460 tree as determined by DIR, or NULL if it was the last one. */
1463 next_dom_son (enum cdi_direction dir
, basic_block bb
)
1465 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
1466 struct et_node
*next
= bb
->dom
[dir_index
]->right
;
1468 return (basic_block
) (next
->father
->son
== next
? NULL
: next
->data
);
1471 /* Return dominance availability for dominance info DIR. */
1474 dom_info_state (function
*fn
, enum cdi_direction dir
)
1479 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
1480 return fn
->cfg
->x_dom_computed
[dir_index
];
1484 dom_info_state (enum cdi_direction dir
)
1486 return dom_info_state (cfun
, dir
);
1489 /* Set the dominance availability for dominance info DIR to NEW_STATE. */
1492 set_dom_info_availability (enum cdi_direction dir
, enum dom_state new_state
)
1494 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
1496 dom_computed
[dir_index
] = new_state
;
1499 /* Returns true if dominance information for direction DIR is available. */
1502 dom_info_available_p (function
*fn
, enum cdi_direction dir
)
1504 return dom_info_state (fn
, dir
) != DOM_NONE
;
1508 dom_info_available_p (enum cdi_direction dir
)
1510 return dom_info_available_p (cfun
, dir
);
1514 debug_dominance_info (enum cdi_direction dir
)
1516 basic_block bb
, bb2
;
1517 FOR_EACH_BB_FN (bb
, cfun
)
1518 if ((bb2
= get_immediate_dominator (dir
, bb
)))
1519 fprintf (stderr
, "%i %i\n", bb
->index
, bb2
->index
);
1522 /* Prints to stderr representation of the dominance tree (for direction DIR)
1523 rooted in ROOT, indented by INDENT tabulators. If INDENT_FIRST is false,
1524 the first line of the output is not indented. */
1527 debug_dominance_tree_1 (enum cdi_direction dir
, basic_block root
,
1528 unsigned indent
, bool indent_first
)
1535 for (i
= 0; i
< indent
; i
++)
1536 fprintf (stderr
, "\t");
1537 fprintf (stderr
, "%d\t", root
->index
);
1539 for (son
= first_dom_son (dir
, root
);
1541 son
= next_dom_son (dir
, son
))
1543 debug_dominance_tree_1 (dir
, son
, indent
+ 1, !first
);
1548 fprintf (stderr
, "\n");
1551 /* Prints to stderr representation of the dominance tree (for direction DIR)
1555 debug_dominance_tree (enum cdi_direction dir
, basic_block root
)
1557 debug_dominance_tree_1 (dir
, root
, 0, false);