]>
git.ipfire.org Git - thirdparty/gcc.git/blob - gcc/dominance.c
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"
44 #include "dominance.h"
47 #include "basic-block.h"
48 #include "diagnostic-core.h"
49 #include "alloc-pool.h"
50 #include "et-forest.h"
55 /* We name our nodes with integers, beginning with 1. Zero is reserved for
56 'undefined' or 'end of list'. The name of each node is given by the dfs
57 number of the corresponding basic block. Please note, that we include the
58 artificial ENTRY_BLOCK (or EXIT_BLOCK in the post-dom case) in our lists to
59 support multiple entry points. Its dfs number is of course 1. */
61 /* Type of Basic Block aka. TBB */
62 typedef unsigned int TBB
;
64 /* We work in a poor-mans object oriented fashion, and carry an instance of
65 this structure through all our 'methods'. It holds various arrays
66 reflecting the (sub)structure of the flowgraph. Most of them are of type
67 TBB and are also indexed by TBB. */
71 /* The parent of a node in the DFS tree. */
73 /* For a node x key[x] is roughly the node nearest to the root from which
74 exists a way to x only over nodes behind x. Such a node is also called
77 /* The value in path_min[x] is the node y on the path from x to the root of
78 the tree x is in with the smallest key[y]. */
80 /* bucket[x] points to the first node of the set of nodes having x as key. */
82 /* And next_bucket[x] points to the next node. */
84 /* After the algorithm is done, dom[x] contains the immediate dominator
88 /* The following few fields implement the structures needed for disjoint
90 /* set_chain[x] is the next node on the path from x to the representative
91 of the set containing x. If set_chain[x]==0 then x is a root. */
93 /* set_size[x] is the number of elements in the set named by x. */
94 unsigned int *set_size
;
95 /* set_child[x] is used for balancing the tree representing a set. It can
96 be understood as the next sibling of x. */
99 /* If b is the number of a basic block (BB->index), dfs_order[b] is the
100 number of that node in DFS order counted from 1. This is an index
101 into most of the other arrays in this structure. */
103 /* If x is the DFS-index of a node which corresponds with a basic block,
104 dfs_to_bb[x] is that basic block. Note, that in our structure there are
105 more nodes that basic blocks, so only dfs_to_bb[dfs_order[bb->index]]==bb
106 is true for every basic block bb, but not the opposite. */
107 basic_block
*dfs_to_bb
;
109 /* This is the next free DFS number when creating the DFS tree. */
111 /* The number of nodes in the DFS tree (==dfsnum-1). */
114 /* Blocks with bits set here have a fake edge to EXIT. These are used
115 to turn a DFS forest into a proper tree. */
116 bitmap fake_exit_edge
;
119 static void init_dom_info (struct dom_info
*, enum cdi_direction
);
120 static void free_dom_info (struct dom_info
*);
121 static void calc_dfs_tree_nonrec (struct dom_info
*, basic_block
, bool);
122 static void calc_dfs_tree (struct dom_info
*, bool);
123 static void compress (struct dom_info
*, TBB
);
124 static TBB
eval (struct dom_info
*, TBB
);
125 static void link_roots (struct dom_info
*, TBB
, TBB
);
126 static void calc_idoms (struct dom_info
*, bool);
127 void debug_dominance_info (enum cdi_direction
);
128 void debug_dominance_tree (enum cdi_direction
, basic_block
);
130 /* Helper macro for allocating and initializing an array,
131 for aesthetic reasons. */
132 #define init_ar(var, type, num, content) \
135 unsigned int i = 1; /* Catch content == i. */ \
137 (var) = XCNEWVEC (type, num); \
140 (var) = XNEWVEC (type, (num)); \
141 for (i = 0; i < num; i++) \
142 (var)[i] = (content); \
147 /* Allocate all needed memory in a pessimistic fashion (so we round up).
148 This initializes the contents of DI, which already must be allocated. */
151 init_dom_info (struct dom_info
*di
, enum cdi_direction dir
)
153 /* We need memory for n_basic_blocks nodes. */
154 unsigned int num
= n_basic_blocks_for_fn (cfun
);
155 init_ar (di
->dfs_parent
, TBB
, num
, 0);
156 init_ar (di
->path_min
, TBB
, num
, i
);
157 init_ar (di
->key
, TBB
, num
, i
);
158 init_ar (di
->dom
, TBB
, num
, 0);
160 init_ar (di
->bucket
, TBB
, num
, 0);
161 init_ar (di
->next_bucket
, TBB
, num
, 0);
163 init_ar (di
->set_chain
, TBB
, num
, 0);
164 init_ar (di
->set_size
, unsigned int, num
, 1);
165 init_ar (di
->set_child
, TBB
, num
, 0);
167 init_ar (di
->dfs_order
, TBB
,
168 (unsigned int) last_basic_block_for_fn (cfun
) + 1, 0);
169 init_ar (di
->dfs_to_bb
, basic_block
, num
, 0);
177 di
->fake_exit_edge
= NULL
;
179 case CDI_POST_DOMINATORS
:
180 di
->fake_exit_edge
= BITMAP_ALLOC (NULL
);
190 /* Map dominance calculation type to array index used for various
191 dominance information arrays. This version is simple -- it will need
192 to be modified, obviously, if additional values are added to
196 dom_convert_dir_to_idx (enum cdi_direction dir
)
198 gcc_checking_assert (dir
== CDI_DOMINATORS
|| dir
== CDI_POST_DOMINATORS
);
202 /* Free all allocated memory in DI, but not DI itself. */
205 free_dom_info (struct dom_info
*di
)
207 free (di
->dfs_parent
);
212 free (di
->next_bucket
);
213 free (di
->set_chain
);
215 free (di
->set_child
);
216 free (di
->dfs_order
);
217 free (di
->dfs_to_bb
);
218 BITMAP_FREE (di
->fake_exit_edge
);
221 /* The nonrecursive variant of creating a DFS tree. DI is our working
222 structure, BB the starting basic block for this tree and REVERSE
223 is true, if predecessors should be visited instead of successors of a
224 node. After this is done all nodes reachable from BB were visited, have
225 assigned their dfs number and are linked together to form a tree. */
228 calc_dfs_tree_nonrec (struct dom_info
*di
, basic_block bb
, bool reverse
)
230 /* We call this _only_ if bb is not already visited. */
232 TBB child_i
, my_i
= 0;
233 edge_iterator
*stack
;
234 edge_iterator ei
, einext
;
236 /* Start block (the entry block for forward problem, exit block for backward
238 basic_block en_block
;
240 basic_block ex_block
;
242 stack
= XNEWVEC (edge_iterator
, n_basic_blocks_for_fn (cfun
) + 1);
245 /* Initialize our border blocks, and the first edge. */
248 ei
= ei_start (bb
->preds
);
249 en_block
= EXIT_BLOCK_PTR_FOR_FN (cfun
);
250 ex_block
= ENTRY_BLOCK_PTR_FOR_FN (cfun
);
254 ei
= ei_start (bb
->succs
);
255 en_block
= ENTRY_BLOCK_PTR_FOR_FN (cfun
);
256 ex_block
= EXIT_BLOCK_PTR_FOR_FN (cfun
);
259 /* When the stack is empty we break out of this loop. */
264 /* This loop traverses edges e in depth first manner, and fills the
266 while (!ei_end_p (ei
))
270 /* Deduce from E the current and the next block (BB and BN), and the
276 /* If the next node BN is either already visited or a border
277 block the current edge is useless, and simply overwritten
278 with the next edge out of the current node. */
279 if (bn
== ex_block
|| di
->dfs_order
[bn
->index
])
285 einext
= ei_start (bn
->preds
);
290 if (bn
== ex_block
|| di
->dfs_order
[bn
->index
])
296 einext
= ei_start (bn
->succs
);
299 gcc_assert (bn
!= en_block
);
301 /* Fill the DFS tree info calculatable _before_ recursing. */
303 my_i
= di
->dfs_order
[bb
->index
];
305 my_i
= di
->dfs_order
[last_basic_block_for_fn (cfun
)];
306 child_i
= di
->dfs_order
[bn
->index
] = di
->dfsnum
++;
307 di
->dfs_to_bb
[child_i
] = bn
;
308 di
->dfs_parent
[child_i
] = my_i
;
310 /* Save the current point in the CFG on the stack, and recurse. */
319 /* OK. The edge-list was exhausted, meaning normally we would
320 end the recursion. After returning from the recursive call,
321 there were (may be) other statements which were run after a
322 child node was completely considered by DFS. Here is the
323 point to do it in the non-recursive variant.
324 E.g. The block just completed is in e->dest for forward DFS,
325 the block not yet completed (the parent of the one above)
326 in e->src. This could be used e.g. for computing the number of
327 descendants or the tree depth. */
333 /* The main entry for calculating the DFS tree or forest. DI is our working
334 structure and REVERSE is true, if we are interested in the reverse flow
335 graph. In that case the result is not necessarily a tree but a forest,
336 because there may be nodes from which the EXIT_BLOCK is unreachable. */
339 calc_dfs_tree (struct dom_info
*di
, bool reverse
)
341 /* The first block is the ENTRY_BLOCK (or EXIT_BLOCK if REVERSE). */
342 basic_block begin
= (reverse
343 ? EXIT_BLOCK_PTR_FOR_FN (cfun
) : ENTRY_BLOCK_PTR_FOR_FN (cfun
));
344 di
->dfs_order
[last_basic_block_for_fn (cfun
)] = di
->dfsnum
;
345 di
->dfs_to_bb
[di
->dfsnum
] = begin
;
348 calc_dfs_tree_nonrec (di
, begin
, reverse
);
352 /* In the post-dom case we may have nodes without a path to EXIT_BLOCK.
353 They are reverse-unreachable. In the dom-case we disallow such
354 nodes, but in post-dom we have to deal with them.
356 There are two situations in which this occurs. First, noreturn
357 functions. Second, infinite loops. In the first case we need to
358 pretend that there is an edge to the exit block. In the second
359 case, we wind up with a forest. We need to process all noreturn
360 blocks before we know if we've got any infinite loops. */
363 bool saw_unconnected
= false;
365 FOR_EACH_BB_REVERSE_FN (b
, cfun
)
367 if (EDGE_COUNT (b
->succs
) > 0)
369 if (di
->dfs_order
[b
->index
] == 0)
370 saw_unconnected
= true;
373 bitmap_set_bit (di
->fake_exit_edge
, b
->index
);
374 di
->dfs_order
[b
->index
] = di
->dfsnum
;
375 di
->dfs_to_bb
[di
->dfsnum
] = b
;
376 di
->dfs_parent
[di
->dfsnum
] =
377 di
->dfs_order
[last_basic_block_for_fn (cfun
)];
379 calc_dfs_tree_nonrec (di
, b
, reverse
);
384 FOR_EACH_BB_REVERSE_FN (b
, cfun
)
387 if (di
->dfs_order
[b
->index
])
389 b2
= dfs_find_deadend (b
);
390 gcc_checking_assert (di
->dfs_order
[b2
->index
] == 0);
391 bitmap_set_bit (di
->fake_exit_edge
, b2
->index
);
392 di
->dfs_order
[b2
->index
] = di
->dfsnum
;
393 di
->dfs_to_bb
[di
->dfsnum
] = b2
;
394 di
->dfs_parent
[di
->dfsnum
] =
395 di
->dfs_order
[last_basic_block_for_fn (cfun
)];
397 calc_dfs_tree_nonrec (di
, b2
, reverse
);
398 gcc_checking_assert (di
->dfs_order
[b
->index
]);
403 di
->nodes
= di
->dfsnum
- 1;
405 /* This aborts e.g. when there is _no_ path from ENTRY to EXIT at all. */
406 gcc_assert (di
->nodes
== (unsigned int) n_basic_blocks_for_fn (cfun
) - 1);
409 /* Compress the path from V to the root of its set and update path_min at the
410 same time. After compress(di, V) set_chain[V] is the root of the set V is
411 in and path_min[V] is the node with the smallest key[] value on the path
412 from V to that root. */
415 compress (struct dom_info
*di
, TBB v
)
417 /* Btw. It's not worth to unrecurse compress() as the depth is usually not
418 greater than 5 even for huge graphs (I've not seen call depth > 4).
419 Also performance wise compress() ranges _far_ behind eval(). */
420 TBB parent
= di
->set_chain
[v
];
421 if (di
->set_chain
[parent
])
423 compress (di
, parent
);
424 if (di
->key
[di
->path_min
[parent
]] < di
->key
[di
->path_min
[v
]])
425 di
->path_min
[v
] = di
->path_min
[parent
];
426 di
->set_chain
[v
] = di
->set_chain
[parent
];
430 /* Compress the path from V to the set root of V if needed (when the root has
431 changed since the last call). Returns the node with the smallest key[]
432 value on the path from V to the root. */
435 eval (struct dom_info
*di
, TBB v
)
437 /* The representative of the set V is in, also called root (as the set
438 representation is a tree). */
439 TBB rep
= di
->set_chain
[v
];
441 /* V itself is the root. */
443 return di
->path_min
[v
];
445 /* Compress only if necessary. */
446 if (di
->set_chain
[rep
])
449 rep
= di
->set_chain
[v
];
452 if (di
->key
[di
->path_min
[rep
]] >= di
->key
[di
->path_min
[v
]])
453 return di
->path_min
[v
];
455 return di
->path_min
[rep
];
458 /* This essentially merges the two sets of V and W, giving a single set with
459 the new root V. The internal representation of these disjoint sets is a
460 balanced tree. Currently link(V,W) is only used with V being the parent
464 link_roots (struct dom_info
*di
, TBB v
, TBB w
)
468 /* Rebalance the tree. */
469 while (di
->key
[di
->path_min
[w
]] < di
->key
[di
->path_min
[di
->set_child
[s
]]])
471 if (di
->set_size
[s
] + di
->set_size
[di
->set_child
[di
->set_child
[s
]]]
472 >= 2 * di
->set_size
[di
->set_child
[s
]])
474 di
->set_chain
[di
->set_child
[s
]] = s
;
475 di
->set_child
[s
] = di
->set_child
[di
->set_child
[s
]];
479 di
->set_size
[di
->set_child
[s
]] = di
->set_size
[s
];
480 s
= di
->set_chain
[s
] = di
->set_child
[s
];
484 di
->path_min
[s
] = di
->path_min
[w
];
485 di
->set_size
[v
] += di
->set_size
[w
];
486 if (di
->set_size
[v
] < 2 * di
->set_size
[w
])
489 s
= di
->set_child
[v
];
490 di
->set_child
[v
] = tmp
;
493 /* Merge all subtrees. */
496 di
->set_chain
[s
] = v
;
497 s
= di
->set_child
[s
];
501 /* This calculates the immediate dominators (or post-dominators if REVERSE is
502 true). DI is our working structure and should hold the DFS forest.
503 On return the immediate dominator to node V is in di->dom[V]. */
506 calc_idoms (struct dom_info
*di
, bool reverse
)
509 basic_block en_block
;
510 edge_iterator ei
, einext
;
513 en_block
= EXIT_BLOCK_PTR_FOR_FN (cfun
);
515 en_block
= ENTRY_BLOCK_PTR_FOR_FN (cfun
);
517 /* Go backwards in DFS order, to first look at the leafs. */
521 basic_block bb
= di
->dfs_to_bb
[v
];
524 par
= di
->dfs_parent
[v
];
527 ei
= (reverse
) ? ei_start (bb
->succs
) : ei_start (bb
->preds
);
531 /* If this block has a fake edge to exit, process that first. */
532 if (bitmap_bit_p (di
->fake_exit_edge
, bb
->index
))
536 goto do_fake_exit_edge
;
540 /* Search all direct predecessors for the smallest node with a path
541 to them. That way we have the smallest node with also a path to
542 us only over nodes behind us. In effect we search for our
544 while (!ei_end_p (ei
))
550 b
= (reverse
) ? e
->dest
: e
->src
;
557 k1
= di
->dfs_order
[last_basic_block_for_fn (cfun
)];
560 k1
= di
->dfs_order
[b
->index
];
562 /* Call eval() only if really needed. If k1 is above V in DFS tree,
563 then we know, that eval(k1) == k1 and key[k1] == k1. */
565 k1
= di
->key
[eval (di
, k1
)];
573 link_roots (di
, par
, v
);
574 di
->next_bucket
[v
] = di
->bucket
[k
];
577 /* Transform semidominators into dominators. */
578 for (w
= di
->bucket
[par
]; w
; w
= di
->next_bucket
[w
])
581 if (di
->key
[k
] < di
->key
[w
])
586 /* We don't need to cleanup next_bucket[]. */
591 /* Explicitly define the dominators. */
593 for (v
= 2; v
<= di
->nodes
; v
++)
594 if (di
->dom
[v
] != di
->key
[v
])
595 di
->dom
[v
] = di
->dom
[di
->dom
[v
]];
598 /* Assign dfs numbers starting from NUM to NODE and its sons. */
601 assign_dfs_numbers (struct et_node
*node
, int *num
)
605 node
->dfs_num_in
= (*num
)++;
609 assign_dfs_numbers (node
->son
, num
);
610 for (son
= node
->son
->right
; son
!= node
->son
; son
= son
->right
)
611 assign_dfs_numbers (son
, num
);
614 node
->dfs_num_out
= (*num
)++;
617 /* Compute the data necessary for fast resolving of dominator queries in a
618 static dominator tree. */
621 compute_dom_fast_query (enum cdi_direction dir
)
625 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
627 gcc_checking_assert (dom_info_available_p (dir
));
629 if (dom_computed
[dir_index
] == DOM_OK
)
632 FOR_ALL_BB_FN (bb
, cfun
)
634 if (!bb
->dom
[dir_index
]->father
)
635 assign_dfs_numbers (bb
->dom
[dir_index
], &num
);
638 dom_computed
[dir_index
] = DOM_OK
;
641 /* The main entry point into this module. DIR is set depending on whether
642 we want to compute dominators or postdominators. */
645 calculate_dominance_info (enum cdi_direction dir
)
649 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
650 bool reverse
= (dir
== CDI_POST_DOMINATORS
) ? true : false;
652 if (dom_computed
[dir_index
] == DOM_OK
)
655 timevar_push (TV_DOMINANCE
);
656 if (!dom_info_available_p (dir
))
658 gcc_assert (!n_bbs_in_dom_tree
[dir_index
]);
660 FOR_ALL_BB_FN (b
, cfun
)
662 b
->dom
[dir_index
] = et_new_tree (b
);
664 n_bbs_in_dom_tree
[dir_index
] = n_basic_blocks_for_fn (cfun
);
666 init_dom_info (&di
, dir
);
667 calc_dfs_tree (&di
, reverse
);
668 calc_idoms (&di
, reverse
);
670 FOR_EACH_BB_FN (b
, cfun
)
672 TBB d
= di
.dom
[di
.dfs_order
[b
->index
]];
675 et_set_father (b
->dom
[dir_index
], di
.dfs_to_bb
[d
]->dom
[dir_index
]);
679 dom_computed
[dir_index
] = DOM_NO_FAST_QUERY
;
682 compute_dom_fast_query (dir
);
684 timevar_pop (TV_DOMINANCE
);
687 /* Free dominance information for direction DIR. */
689 free_dominance_info (function
*fn
, enum cdi_direction dir
)
692 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
694 if (!dom_info_available_p (fn
, dir
))
697 FOR_ALL_BB_FN (bb
, fn
)
699 et_free_tree_force (bb
->dom
[dir_index
]);
700 bb
->dom
[dir_index
] = NULL
;
704 fn
->cfg
->x_n_bbs_in_dom_tree
[dir_index
] = 0;
706 fn
->cfg
->x_dom_computed
[dir_index
] = DOM_NONE
;
710 free_dominance_info (enum cdi_direction dir
)
712 free_dominance_info (cfun
, dir
);
715 /* Return the immediate dominator of basic block BB. */
717 get_immediate_dominator (enum cdi_direction dir
, basic_block bb
)
719 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
720 struct et_node
*node
= bb
->dom
[dir_index
];
722 gcc_checking_assert (dom_computed
[dir_index
]);
727 return (basic_block
) node
->father
->data
;
730 /* Set the immediate dominator of the block possibly removing
731 existing edge. NULL can be used to remove any edge. */
733 set_immediate_dominator (enum cdi_direction dir
, basic_block bb
,
734 basic_block dominated_by
)
736 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
737 struct et_node
*node
= bb
->dom
[dir_index
];
739 gcc_checking_assert (dom_computed
[dir_index
]);
743 if (node
->father
->data
== dominated_by
)
749 et_set_father (node
, dominated_by
->dom
[dir_index
]);
751 if (dom_computed
[dir_index
] == DOM_OK
)
752 dom_computed
[dir_index
] = DOM_NO_FAST_QUERY
;
755 /* Returns the list of basic blocks immediately dominated by BB, in the
758 get_dominated_by (enum cdi_direction dir
, basic_block bb
)
760 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
761 struct et_node
*node
= bb
->dom
[dir_index
], *son
= node
->son
, *ason
;
762 vec
<basic_block
> bbs
= vNULL
;
764 gcc_checking_assert (dom_computed
[dir_index
]);
769 bbs
.safe_push ((basic_block
) son
->data
);
770 for (ason
= son
->right
; ason
!= son
; ason
= ason
->right
)
771 bbs
.safe_push ((basic_block
) ason
->data
);
776 /* Returns the list of basic blocks that are immediately dominated (in
777 direction DIR) by some block between N_REGION ones stored in REGION,
778 except for blocks in the REGION itself. */
781 get_dominated_by_region (enum cdi_direction dir
, basic_block
*region
,
786 vec
<basic_block
> doms
= vNULL
;
788 for (i
= 0; i
< n_region
; i
++)
789 region
[i
]->flags
|= BB_DUPLICATED
;
790 for (i
= 0; i
< n_region
; i
++)
791 for (dom
= first_dom_son (dir
, region
[i
]);
793 dom
= next_dom_son (dir
, dom
))
794 if (!(dom
->flags
& BB_DUPLICATED
))
795 doms
.safe_push (dom
);
796 for (i
= 0; i
< n_region
; i
++)
797 region
[i
]->flags
&= ~BB_DUPLICATED
;
802 /* Returns the list of basic blocks including BB dominated by BB, in the
803 direction DIR up to DEPTH in the dominator tree. The DEPTH of zero will
804 produce a vector containing all dominated blocks. The vector will be sorted
808 get_dominated_to_depth (enum cdi_direction dir
, basic_block bb
, int depth
)
810 vec
<basic_block
> bbs
= vNULL
;
812 unsigned next_level_start
;
816 next_level_start
= 1; /* = bbs.length (); */
823 for (son
= first_dom_son (dir
, bb
);
825 son
= next_dom_son (dir
, son
))
828 if (i
== next_level_start
&& --depth
)
829 next_level_start
= bbs
.length ();
831 while (i
< next_level_start
);
836 /* Returns the list of basic blocks including BB dominated by BB, in the
837 direction DIR. The vector will be sorted in preorder. */
840 get_all_dominated_blocks (enum cdi_direction dir
, basic_block bb
)
842 return get_dominated_to_depth (dir
, bb
, 0);
845 /* Redirect all edges pointing to BB to TO. */
847 redirect_immediate_dominators (enum cdi_direction dir
, basic_block bb
,
850 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
851 struct et_node
*bb_node
, *to_node
, *son
;
853 bb_node
= bb
->dom
[dir_index
];
854 to_node
= to
->dom
[dir_index
];
856 gcc_checking_assert (dom_computed
[dir_index
]);
866 et_set_father (son
, to_node
);
869 if (dom_computed
[dir_index
] == DOM_OK
)
870 dom_computed
[dir_index
] = DOM_NO_FAST_QUERY
;
873 /* Find first basic block in the tree dominating both BB1 and BB2. */
875 nearest_common_dominator (enum cdi_direction dir
, basic_block bb1
, basic_block bb2
)
877 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
879 gcc_checking_assert (dom_computed
[dir_index
]);
886 return (basic_block
) et_nca (bb1
->dom
[dir_index
], bb2
->dom
[dir_index
])->data
;
890 /* Find the nearest common dominator for the basic blocks in BLOCKS,
891 using dominance direction DIR. */
894 nearest_common_dominator_for_set (enum cdi_direction dir
, bitmap blocks
)
900 first
= bitmap_first_set_bit (blocks
);
901 dom
= BASIC_BLOCK_FOR_FN (cfun
, first
);
902 EXECUTE_IF_SET_IN_BITMAP (blocks
, 0, i
, bi
)
903 if (dom
!= BASIC_BLOCK_FOR_FN (cfun
, i
))
904 dom
= nearest_common_dominator (dir
, dom
, BASIC_BLOCK_FOR_FN (cfun
, i
));
909 /* Given a dominator tree, we can determine whether one thing
910 dominates another in constant time by using two DFS numbers:
912 1. The number for when we visit a node on the way down the tree
913 2. The number for when we visit a node on the way back up the tree
915 You can view these as bounds for the range of dfs numbers the
916 nodes in the subtree of the dominator tree rooted at that node
919 The dominator tree is always a simple acyclic tree, so there are
920 only three possible relations two nodes in the dominator tree have
923 1. Node A is above Node B (and thus, Node A dominates node B)
932 In the above case, DFS_Number_In of A will be <= DFS_Number_In of
933 B, and DFS_Number_Out of A will be >= DFS_Number_Out of B. This is
934 because we must hit A in the dominator tree *before* B on the walk
935 down, and we will hit A *after* B on the walk back up
937 2. Node A is below node B (and thus, node B dominates node A)
946 In the above case, DFS_Number_In of A will be >= DFS_Number_In of
947 B, and DFS_Number_Out of A will be <= DFS_Number_Out of B.
949 This is because we must hit A in the dominator tree *after* B on
950 the walk down, and we will hit A *before* B on the walk back up
952 3. Node A and B are siblings (and thus, neither dominates the other)
960 In the above case, DFS_Number_In of A will *always* be <=
961 DFS_Number_In of B, and DFS_Number_Out of A will *always* be <=
962 DFS_Number_Out of B. This is because we will always finish the dfs
963 walk of one of the subtrees before the other, and thus, the dfs
964 numbers for one subtree can't intersect with the range of dfs
965 numbers for the other subtree. If you swap A and B's position in
966 the dominator tree, the comparison changes direction, but the point
967 is that both comparisons will always go the same way if there is no
968 dominance relationship.
970 Thus, it is sufficient to write
972 A_Dominates_B (node A, node B)
974 return DFS_Number_In(A) <= DFS_Number_In(B)
975 && DFS_Number_Out (A) >= DFS_Number_Out(B);
978 A_Dominated_by_B (node A, node B)
980 return DFS_Number_In(A) >= DFS_Number_In(B)
981 && DFS_Number_Out (A) <= DFS_Number_Out(B);
984 /* Return TRUE in case BB1 is dominated by BB2. */
986 dominated_by_p (enum cdi_direction dir
, const_basic_block bb1
, const_basic_block bb2
)
988 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
989 struct et_node
*n1
= bb1
->dom
[dir_index
], *n2
= bb2
->dom
[dir_index
];
991 gcc_checking_assert (dom_computed
[dir_index
]);
993 if (dom_computed
[dir_index
] == DOM_OK
)
994 return (n1
->dfs_num_in
>= n2
->dfs_num_in
995 && n1
->dfs_num_out
<= n2
->dfs_num_out
);
997 return et_below (n1
, n2
);
1000 /* Returns the entry dfs number for basic block BB, in the direction DIR. */
1003 bb_dom_dfs_in (enum cdi_direction dir
, basic_block bb
)
1005 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
1006 struct et_node
*n
= bb
->dom
[dir_index
];
1008 gcc_checking_assert (dom_computed
[dir_index
] == DOM_OK
);
1009 return n
->dfs_num_in
;
1012 /* Returns the exit dfs number for basic block BB, in the direction DIR. */
1015 bb_dom_dfs_out (enum cdi_direction dir
, basic_block bb
)
1017 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
1018 struct et_node
*n
= bb
->dom
[dir_index
];
1020 gcc_checking_assert (dom_computed
[dir_index
] == DOM_OK
);
1021 return n
->dfs_num_out
;
1024 /* Verify invariants of dominator structure. */
1026 verify_dominators (enum cdi_direction dir
)
1029 basic_block bb
, imm_bb
, imm_bb_correct
;
1031 bool reverse
= (dir
== CDI_POST_DOMINATORS
) ? true : false;
1033 gcc_assert (dom_info_available_p (dir
));
1035 init_dom_info (&di
, dir
);
1036 calc_dfs_tree (&di
, reverse
);
1037 calc_idoms (&di
, reverse
);
1039 FOR_EACH_BB_FN (bb
, cfun
)
1041 imm_bb
= get_immediate_dominator (dir
, bb
);
1044 error ("dominator of %d status unknown", bb
->index
);
1048 imm_bb_correct
= di
.dfs_to_bb
[di
.dom
[di
.dfs_order
[bb
->index
]]];
1049 if (imm_bb
!= imm_bb_correct
)
1051 error ("dominator of %d should be %d, not %d",
1052 bb
->index
, imm_bb_correct
->index
, imm_bb
->index
);
1057 free_dom_info (&di
);
1061 /* Determine immediate dominator (or postdominator, according to DIR) of BB,
1062 assuming that dominators of other blocks are correct. We also use it to
1063 recompute the dominators in a restricted area, by iterating it until it
1064 reaches a fixed point. */
1067 recompute_dominator (enum cdi_direction dir
, basic_block bb
)
1069 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
1070 basic_block dom_bb
= NULL
;
1074 gcc_checking_assert (dom_computed
[dir_index
]);
1076 if (dir
== CDI_DOMINATORS
)
1078 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
1080 if (!dominated_by_p (dir
, e
->src
, bb
))
1081 dom_bb
= nearest_common_dominator (dir
, dom_bb
, e
->src
);
1086 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
1088 if (!dominated_by_p (dir
, e
->dest
, bb
))
1089 dom_bb
= nearest_common_dominator (dir
, dom_bb
, e
->dest
);
1096 /* Use simple heuristics (see iterate_fix_dominators) to determine dominators
1097 of BBS. We assume that all the immediate dominators except for those of the
1098 blocks in BBS are correct. If CONSERVATIVE is true, we also assume that the
1099 currently recorded immediate dominators of blocks in BBS really dominate the
1100 blocks. The basic blocks for that we determine the dominator are removed
1104 prune_bbs_to_update_dominators (vec
<basic_block
> bbs
,
1109 basic_block bb
, dom
= NULL
;
1113 for (i
= 0; bbs
.iterate (i
, &bb
);)
1115 if (bb
== ENTRY_BLOCK_PTR_FOR_FN (cfun
))
1118 if (single_pred_p (bb
))
1120 set_immediate_dominator (CDI_DOMINATORS
, bb
, single_pred (bb
));
1129 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
1131 if (dominated_by_p (CDI_DOMINATORS
, e
->src
, bb
))
1139 dom
= nearest_common_dominator (CDI_DOMINATORS
, dom
, e
->src
);
1143 gcc_assert (dom
!= NULL
);
1145 || find_edge (dom
, bb
))
1147 set_immediate_dominator (CDI_DOMINATORS
, bb
, dom
);
1156 bbs
.unordered_remove (i
);
1160 /* Returns root of the dominance tree in the direction DIR that contains
1164 root_of_dom_tree (enum cdi_direction dir
, basic_block bb
)
1166 return (basic_block
) et_root (bb
->dom
[dom_convert_dir_to_idx (dir
)])->data
;
1169 /* See the comment in iterate_fix_dominators. Finds the immediate dominators
1170 for the sons of Y, found using the SON and BROTHER arrays representing
1171 the dominance tree of graph G. BBS maps the vertices of G to the basic
1175 determine_dominators_for_sons (struct graph
*g
, vec
<basic_block
> bbs
,
1176 int y
, int *son
, int *brother
)
1181 basic_block bb
, dom
, ybb
;
1188 if (y
== (int) bbs
.length ())
1189 ybb
= ENTRY_BLOCK_PTR_FOR_FN (cfun
);
1193 if (brother
[son
[y
]] == -1)
1195 /* Handle the common case Y has just one son specially. */
1197 set_immediate_dominator (CDI_DOMINATORS
, bb
,
1198 recompute_dominator (CDI_DOMINATORS
, bb
));
1199 identify_vertices (g
, y
, son
[y
]);
1203 gprime
= BITMAP_ALLOC (NULL
);
1204 for (a
= son
[y
]; a
!= -1; a
= brother
[a
])
1205 bitmap_set_bit (gprime
, a
);
1207 nc
= graphds_scc (g
, gprime
);
1208 BITMAP_FREE (gprime
);
1210 /* ??? Needed to work around the pre-processor confusion with
1211 using a multi-argument template type as macro argument. */
1212 typedef vec
<int> vec_int_heap
;
1213 sccs
= XCNEWVEC (vec_int_heap
, nc
);
1214 for (a
= son
[y
]; a
!= -1; a
= brother
[a
])
1215 sccs
[g
->vertices
[a
].component
].safe_push (a
);
1217 for (i
= nc
- 1; i
>= 0; i
--)
1220 FOR_EACH_VEC_ELT (sccs
[i
], si
, a
)
1223 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
1225 if (root_of_dom_tree (CDI_DOMINATORS
, e
->src
) != ybb
)
1228 dom
= nearest_common_dominator (CDI_DOMINATORS
, dom
, e
->src
);
1232 gcc_assert (dom
!= NULL
);
1233 FOR_EACH_VEC_ELT (sccs
[i
], si
, a
)
1236 set_immediate_dominator (CDI_DOMINATORS
, bb
, dom
);
1240 for (i
= 0; i
< nc
; i
++)
1244 for (a
= son
[y
]; a
!= -1; a
= brother
[a
])
1245 identify_vertices (g
, y
, a
);
1248 /* Recompute dominance information for basic blocks in the set BBS. The
1249 function assumes that the immediate dominators of all the other blocks
1250 in CFG are correct, and that there are no unreachable blocks.
1252 If CONSERVATIVE is true, we additionally assume that all the ancestors of
1253 a block of BBS in the current dominance tree dominate it. */
1256 iterate_fix_dominators (enum cdi_direction dir
, vec
<basic_block
> bbs
,
1260 basic_block bb
, dom
;
1266 int *parent
, *son
, *brother
;
1267 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
1269 /* We only support updating dominators. There are some problems with
1270 updating postdominators (need to add fake edges from infinite loops
1271 and noreturn functions), and since we do not currently use
1272 iterate_fix_dominators for postdominators, any attempt to handle these
1273 problems would be unused, untested, and almost surely buggy. We keep
1274 the DIR argument for consistency with the rest of the dominator analysis
1276 gcc_checking_assert (dir
== CDI_DOMINATORS
&& dom_computed
[dir_index
]);
1278 /* The algorithm we use takes inspiration from the following papers, although
1279 the details are quite different from any of them:
1281 [1] G. Ramalingam, T. Reps, An Incremental Algorithm for Maintaining the
1282 Dominator Tree of a Reducible Flowgraph
1283 [2] V. C. Sreedhar, G. R. Gao, Y.-F. Lee: Incremental computation of
1285 [3] K. D. Cooper, T. J. Harvey and K. Kennedy: A Simple, Fast Dominance
1288 First, we use the following heuristics to decrease the size of the BBS
1290 a) if BB has a single predecessor, then its immediate dominator is this
1292 additionally, if CONSERVATIVE is true:
1293 b) if all the predecessors of BB except for one (X) are dominated by BB,
1294 then X is the immediate dominator of BB
1295 c) if the nearest common ancestor of the predecessors of BB is X and
1296 X -> BB is an edge in CFG, then X is the immediate dominator of BB
1298 Then, we need to establish the dominance relation among the basic blocks
1299 in BBS. We split the dominance tree by removing the immediate dominator
1300 edges from BBS, creating a forest F. We form a graph G whose vertices
1301 are BBS and ENTRY and X -> Y is an edge of G if there exists an edge
1302 X' -> Y in CFG such that X' belongs to the tree of the dominance forest
1303 whose root is X. We then determine dominance tree of G. Note that
1304 for X, Y in BBS, X dominates Y in CFG if and only if X dominates Y in G.
1305 In this step, we can use arbitrary algorithm to determine dominators.
1306 We decided to prefer the algorithm [3] to the algorithm of
1307 Lengauer and Tarjan, since the set BBS is usually small (rarely exceeding
1308 10 during gcc bootstrap), and [3] should perform better in this case.
1310 Finally, we need to determine the immediate dominators for the basic
1311 blocks of BBS. If the immediate dominator of X in G is Y, then
1312 the immediate dominator of X in CFG belongs to the tree of F rooted in
1313 Y. We process the dominator tree T of G recursively, starting from leaves.
1314 Suppose that X_1, X_2, ..., X_k are the sons of Y in T, and that the
1315 subtrees of the dominance tree of CFG rooted in X_i are already correct.
1316 Let G' be the subgraph of G induced by {X_1, X_2, ..., X_k}. We make
1317 the following observations:
1318 (i) the immediate dominator of all blocks in a strongly connected
1319 component of G' is the same
1320 (ii) if X has no predecessors in G', then the immediate dominator of X
1321 is the nearest common ancestor of the predecessors of X in the
1322 subtree of F rooted in Y
1323 Therefore, it suffices to find the topological ordering of G', and
1324 process the nodes X_i in this order using the rules (i) and (ii).
1325 Then, we contract all the nodes X_i with Y in G, so that the further
1326 steps work correctly. */
1330 /* Split the tree now. If the idoms of blocks in BBS are not
1331 conservatively correct, setting the dominators using the
1332 heuristics in prune_bbs_to_update_dominators could
1333 create cycles in the dominance "tree", and cause ICE. */
1334 FOR_EACH_VEC_ELT (bbs
, i
, bb
)
1335 set_immediate_dominator (CDI_DOMINATORS
, bb
, NULL
);
1338 prune_bbs_to_update_dominators (bbs
, conservative
);
1347 set_immediate_dominator (CDI_DOMINATORS
, bb
,
1348 recompute_dominator (CDI_DOMINATORS
, bb
));
1352 /* Construct the graph G. */
1353 hash_map
<basic_block
, int> map (251);
1354 FOR_EACH_VEC_ELT (bbs
, i
, bb
)
1356 /* If the dominance tree is conservatively correct, split it now. */
1358 set_immediate_dominator (CDI_DOMINATORS
, bb
, NULL
);
1361 map
.put (ENTRY_BLOCK_PTR_FOR_FN (cfun
), n
);
1363 g
= new_graph (n
+ 1);
1364 for (y
= 0; y
< g
->n_vertices
; y
++)
1365 g
->vertices
[y
].data
= BITMAP_ALLOC (NULL
);
1366 FOR_EACH_VEC_ELT (bbs
, i
, bb
)
1368 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
1370 dom
= root_of_dom_tree (CDI_DOMINATORS
, e
->src
);
1374 dom_i
= *map
.get (dom
);
1376 /* Do not include parallel edges to G. */
1377 if (!bitmap_set_bit ((bitmap
) g
->vertices
[dom_i
].data
, i
))
1380 add_edge (g
, dom_i
, i
);
1383 for (y
= 0; y
< g
->n_vertices
; y
++)
1384 BITMAP_FREE (g
->vertices
[y
].data
);
1386 /* Find the dominator tree of G. */
1387 son
= XNEWVEC (int, n
+ 1);
1388 brother
= XNEWVEC (int, n
+ 1);
1389 parent
= XNEWVEC (int, n
+ 1);
1390 graphds_domtree (g
, n
, parent
, son
, brother
);
1392 /* Finally, traverse the tree and find the immediate dominators. */
1393 for (y
= n
; son
[y
] != -1; y
= son
[y
])
1397 determine_dominators_for_sons (g
, bbs
, y
, son
, brother
);
1399 if (brother
[y
] != -1)
1402 while (son
[y
] != -1)
1417 add_to_dominance_info (enum cdi_direction dir
, basic_block bb
)
1419 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
1421 gcc_checking_assert (dom_computed
[dir_index
] && !bb
->dom
[dir_index
]);
1423 n_bbs_in_dom_tree
[dir_index
]++;
1425 bb
->dom
[dir_index
] = et_new_tree (bb
);
1427 if (dom_computed
[dir_index
] == DOM_OK
)
1428 dom_computed
[dir_index
] = DOM_NO_FAST_QUERY
;
1432 delete_from_dominance_info (enum cdi_direction dir
, basic_block bb
)
1434 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
1436 gcc_checking_assert (dom_computed
[dir_index
]);
1438 et_free_tree (bb
->dom
[dir_index
]);
1439 bb
->dom
[dir_index
] = NULL
;
1440 n_bbs_in_dom_tree
[dir_index
]--;
1442 if (dom_computed
[dir_index
] == DOM_OK
)
1443 dom_computed
[dir_index
] = DOM_NO_FAST_QUERY
;
1446 /* Returns the first son of BB in the dominator or postdominator tree
1447 as determined by DIR. */
1450 first_dom_son (enum cdi_direction dir
, basic_block bb
)
1452 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
1453 struct et_node
*son
= bb
->dom
[dir_index
]->son
;
1455 return (basic_block
) (son
? son
->data
: NULL
);
1458 /* Returns the next dominance son after BB in the dominator or postdominator
1459 tree as determined by DIR, or NULL if it was the last one. */
1462 next_dom_son (enum cdi_direction dir
, basic_block bb
)
1464 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
1465 struct et_node
*next
= bb
->dom
[dir_index
]->right
;
1467 return (basic_block
) (next
->father
->son
== next
? NULL
: next
->data
);
1470 /* Return dominance availability for dominance info DIR. */
1473 dom_info_state (function
*fn
, enum cdi_direction dir
)
1478 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
1479 return fn
->cfg
->x_dom_computed
[dir_index
];
1483 dom_info_state (enum cdi_direction dir
)
1485 return dom_info_state (cfun
, dir
);
1488 /* Set the dominance availability for dominance info DIR to NEW_STATE. */
1491 set_dom_info_availability (enum cdi_direction dir
, enum dom_state new_state
)
1493 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
1495 dom_computed
[dir_index
] = new_state
;
1498 /* Returns true if dominance information for direction DIR is available. */
1501 dom_info_available_p (function
*fn
, enum cdi_direction dir
)
1503 return dom_info_state (fn
, dir
) != DOM_NONE
;
1507 dom_info_available_p (enum cdi_direction dir
)
1509 return dom_info_available_p (cfun
, dir
);
1513 debug_dominance_info (enum cdi_direction dir
)
1515 basic_block bb
, bb2
;
1516 FOR_EACH_BB_FN (bb
, cfun
)
1517 if ((bb2
= get_immediate_dominator (dir
, bb
)))
1518 fprintf (stderr
, "%i %i\n", bb
->index
, bb2
->index
);
1521 /* Prints to stderr representation of the dominance tree (for direction DIR)
1522 rooted in ROOT, indented by INDENT tabulators. If INDENT_FIRST is false,
1523 the first line of the output is not indented. */
1526 debug_dominance_tree_1 (enum cdi_direction dir
, basic_block root
,
1527 unsigned indent
, bool indent_first
)
1534 for (i
= 0; i
< indent
; i
++)
1535 fprintf (stderr
, "\t");
1536 fprintf (stderr
, "%d\t", root
->index
);
1538 for (son
= first_dom_son (dir
, root
);
1540 son
= next_dom_son (dir
, son
))
1542 debug_dominance_tree_1 (dir
, son
, indent
+ 1, !first
);
1547 fprintf (stderr
, "\n");
1550 /* Prints to stderr representation of the dominance tree (for direction DIR)
1554 debug_dominance_tree (enum cdi_direction dir
, basic_block root
)
1556 debug_dominance_tree_1 (dir
, root
, 0, false);