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"
49 #include "dominance.h"
52 #include "basic-block.h"
53 #include "diagnostic-core.h"
54 #include "alloc-pool.h"
55 #include "et-forest.h"
61 /* We name our nodes with integers, beginning with 1. Zero is reserved for
62 'undefined' or 'end of list'. The name of each node is given by the dfs
63 number of the corresponding basic block. Please note, that we include the
64 artificial ENTRY_BLOCK (or EXIT_BLOCK in the post-dom case) in our lists to
65 support multiple entry points. Its dfs number is of course 1. */
67 /* Type of Basic Block aka. TBB */
68 typedef unsigned int TBB
;
70 /* We work in a poor-mans object oriented fashion, and carry an instance of
71 this structure through all our 'methods'. It holds various arrays
72 reflecting the (sub)structure of the flowgraph. Most of them are of type
73 TBB and are also indexed by TBB. */
77 /* The parent of a node in the DFS tree. */
79 /* For a node x key[x] is roughly the node nearest to the root from which
80 exists a way to x only over nodes behind x. Such a node is also called
83 /* The value in path_min[x] is the node y on the path from x to the root of
84 the tree x is in with the smallest key[y]. */
86 /* bucket[x] points to the first node of the set of nodes having x as key. */
88 /* And next_bucket[x] points to the next node. */
90 /* After the algorithm is done, dom[x] contains the immediate dominator
94 /* The following few fields implement the structures needed for disjoint
96 /* set_chain[x] is the next node on the path from x to the representative
97 of the set containing x. If set_chain[x]==0 then x is a root. */
99 /* set_size[x] is the number of elements in the set named by x. */
100 unsigned int *set_size
;
101 /* set_child[x] is used for balancing the tree representing a set. It can
102 be understood as the next sibling of x. */
105 /* If b is the number of a basic block (BB->index), dfs_order[b] is the
106 number of that node in DFS order counted from 1. This is an index
107 into most of the other arrays in this structure. */
109 /* If x is the DFS-index of a node which corresponds with a basic block,
110 dfs_to_bb[x] is that basic block. Note, that in our structure there are
111 more nodes that basic blocks, so only dfs_to_bb[dfs_order[bb->index]]==bb
112 is true for every basic block bb, but not the opposite. */
113 basic_block
*dfs_to_bb
;
115 /* This is the next free DFS number when creating the DFS tree. */
117 /* The number of nodes in the DFS tree (==dfsnum-1). */
120 /* Blocks with bits set here have a fake edge to EXIT. These are used
121 to turn a DFS forest into a proper tree. */
122 bitmap fake_exit_edge
;
125 static void init_dom_info (struct dom_info
*, enum cdi_direction
);
126 static void free_dom_info (struct dom_info
*);
127 static void calc_dfs_tree_nonrec (struct dom_info
*, basic_block
, bool);
128 static void calc_dfs_tree (struct dom_info
*, bool);
129 static void compress (struct dom_info
*, TBB
);
130 static TBB
eval (struct dom_info
*, TBB
);
131 static void link_roots (struct dom_info
*, TBB
, TBB
);
132 static void calc_idoms (struct dom_info
*, bool);
133 void debug_dominance_info (enum cdi_direction
);
134 void debug_dominance_tree (enum cdi_direction
, basic_block
);
136 /* Helper macro for allocating and initializing an array,
137 for aesthetic reasons. */
138 #define init_ar(var, type, num, content) \
141 unsigned int i = 1; /* Catch content == i. */ \
143 (var) = XCNEWVEC (type, num); \
146 (var) = XNEWVEC (type, (num)); \
147 for (i = 0; i < num; i++) \
148 (var)[i] = (content); \
153 /* Allocate all needed memory in a pessimistic fashion (so we round up).
154 This initializes the contents of DI, which already must be allocated. */
157 init_dom_info (struct dom_info
*di
, enum cdi_direction dir
)
159 /* We need memory for n_basic_blocks nodes. */
160 unsigned int num
= n_basic_blocks_for_fn (cfun
);
161 init_ar (di
->dfs_parent
, TBB
, num
, 0);
162 init_ar (di
->path_min
, TBB
, num
, i
);
163 init_ar (di
->key
, TBB
, num
, i
);
164 init_ar (di
->dom
, TBB
, num
, 0);
166 init_ar (di
->bucket
, TBB
, num
, 0);
167 init_ar (di
->next_bucket
, TBB
, num
, 0);
169 init_ar (di
->set_chain
, TBB
, num
, 0);
170 init_ar (di
->set_size
, unsigned int, num
, 1);
171 init_ar (di
->set_child
, TBB
, num
, 0);
173 init_ar (di
->dfs_order
, TBB
,
174 (unsigned int) last_basic_block_for_fn (cfun
) + 1, 0);
175 init_ar (di
->dfs_to_bb
, basic_block
, num
, 0);
183 di
->fake_exit_edge
= NULL
;
185 case CDI_POST_DOMINATORS
:
186 di
->fake_exit_edge
= BITMAP_ALLOC (NULL
);
196 /* Map dominance calculation type to array index used for various
197 dominance information arrays. This version is simple -- it will need
198 to be modified, obviously, if additional values are added to
202 dom_convert_dir_to_idx (enum cdi_direction dir
)
204 gcc_checking_assert (dir
== CDI_DOMINATORS
|| dir
== CDI_POST_DOMINATORS
);
208 /* Free all allocated memory in DI, but not DI itself. */
211 free_dom_info (struct dom_info
*di
)
213 free (di
->dfs_parent
);
218 free (di
->next_bucket
);
219 free (di
->set_chain
);
221 free (di
->set_child
);
222 free (di
->dfs_order
);
223 free (di
->dfs_to_bb
);
224 BITMAP_FREE (di
->fake_exit_edge
);
227 /* The nonrecursive variant of creating a DFS tree. DI is our working
228 structure, BB the starting basic block for this tree and REVERSE
229 is true, if predecessors should be visited instead of successors of a
230 node. After this is done all nodes reachable from BB were visited, have
231 assigned their dfs number and are linked together to form a tree. */
234 calc_dfs_tree_nonrec (struct dom_info
*di
, basic_block bb
, bool reverse
)
236 /* We call this _only_ if bb is not already visited. */
238 TBB child_i
, my_i
= 0;
239 edge_iterator
*stack
;
240 edge_iterator ei
, einext
;
242 /* Start block (the entry block for forward problem, exit block for backward
244 basic_block en_block
;
246 basic_block ex_block
;
248 stack
= XNEWVEC (edge_iterator
, n_basic_blocks_for_fn (cfun
) + 1);
251 /* Initialize our border blocks, and the first edge. */
254 ei
= ei_start (bb
->preds
);
255 en_block
= EXIT_BLOCK_PTR_FOR_FN (cfun
);
256 ex_block
= ENTRY_BLOCK_PTR_FOR_FN (cfun
);
260 ei
= ei_start (bb
->succs
);
261 en_block
= ENTRY_BLOCK_PTR_FOR_FN (cfun
);
262 ex_block
= EXIT_BLOCK_PTR_FOR_FN (cfun
);
265 /* When the stack is empty we break out of this loop. */
270 /* This loop traverses edges e in depth first manner, and fills the
272 while (!ei_end_p (ei
))
276 /* Deduce from E the current and the next block (BB and BN), and the
282 /* If the next node BN is either already visited or a border
283 block the current edge is useless, and simply overwritten
284 with the next edge out of the current node. */
285 if (bn
== ex_block
|| di
->dfs_order
[bn
->index
])
291 einext
= ei_start (bn
->preds
);
296 if (bn
== ex_block
|| di
->dfs_order
[bn
->index
])
302 einext
= ei_start (bn
->succs
);
305 gcc_assert (bn
!= en_block
);
307 /* Fill the DFS tree info calculatable _before_ recursing. */
309 my_i
= di
->dfs_order
[bb
->index
];
311 my_i
= di
->dfs_order
[last_basic_block_for_fn (cfun
)];
312 child_i
= di
->dfs_order
[bn
->index
] = di
->dfsnum
++;
313 di
->dfs_to_bb
[child_i
] = bn
;
314 di
->dfs_parent
[child_i
] = my_i
;
316 /* Save the current point in the CFG on the stack, and recurse. */
325 /* OK. The edge-list was exhausted, meaning normally we would
326 end the recursion. After returning from the recursive call,
327 there were (may be) other statements which were run after a
328 child node was completely considered by DFS. Here is the
329 point to do it in the non-recursive variant.
330 E.g. The block just completed is in e->dest for forward DFS,
331 the block not yet completed (the parent of the one above)
332 in e->src. This could be used e.g. for computing the number of
333 descendants or the tree depth. */
339 /* The main entry for calculating the DFS tree or forest. DI is our working
340 structure and REVERSE is true, if we are interested in the reverse flow
341 graph. In that case the result is not necessarily a tree but a forest,
342 because there may be nodes from which the EXIT_BLOCK is unreachable. */
345 calc_dfs_tree (struct dom_info
*di
, bool reverse
)
347 /* The first block is the ENTRY_BLOCK (or EXIT_BLOCK if REVERSE). */
348 basic_block begin
= (reverse
349 ? EXIT_BLOCK_PTR_FOR_FN (cfun
) : ENTRY_BLOCK_PTR_FOR_FN (cfun
));
350 di
->dfs_order
[last_basic_block_for_fn (cfun
)] = di
->dfsnum
;
351 di
->dfs_to_bb
[di
->dfsnum
] = begin
;
354 calc_dfs_tree_nonrec (di
, begin
, reverse
);
358 /* In the post-dom case we may have nodes without a path to EXIT_BLOCK.
359 They are reverse-unreachable. In the dom-case we disallow such
360 nodes, but in post-dom we have to deal with them.
362 There are two situations in which this occurs. First, noreturn
363 functions. Second, infinite loops. In the first case we need to
364 pretend that there is an edge to the exit block. In the second
365 case, we wind up with a forest. We need to process all noreturn
366 blocks before we know if we've got any infinite loops. */
369 bool saw_unconnected
= false;
371 FOR_EACH_BB_REVERSE_FN (b
, cfun
)
373 if (EDGE_COUNT (b
->succs
) > 0)
375 if (di
->dfs_order
[b
->index
] == 0)
376 saw_unconnected
= true;
379 bitmap_set_bit (di
->fake_exit_edge
, b
->index
);
380 di
->dfs_order
[b
->index
] = di
->dfsnum
;
381 di
->dfs_to_bb
[di
->dfsnum
] = b
;
382 di
->dfs_parent
[di
->dfsnum
] =
383 di
->dfs_order
[last_basic_block_for_fn (cfun
)];
385 calc_dfs_tree_nonrec (di
, b
, reverse
);
390 FOR_EACH_BB_REVERSE_FN (b
, cfun
)
393 if (di
->dfs_order
[b
->index
])
395 b2
= dfs_find_deadend (b
);
396 gcc_checking_assert (di
->dfs_order
[b2
->index
] == 0);
397 bitmap_set_bit (di
->fake_exit_edge
, b2
->index
);
398 di
->dfs_order
[b2
->index
] = di
->dfsnum
;
399 di
->dfs_to_bb
[di
->dfsnum
] = b2
;
400 di
->dfs_parent
[di
->dfsnum
] =
401 di
->dfs_order
[last_basic_block_for_fn (cfun
)];
403 calc_dfs_tree_nonrec (di
, b2
, reverse
);
404 gcc_checking_assert (di
->dfs_order
[b
->index
]);
409 di
->nodes
= di
->dfsnum
- 1;
411 /* This aborts e.g. when there is _no_ path from ENTRY to EXIT at all. */
412 gcc_assert (di
->nodes
== (unsigned int) n_basic_blocks_for_fn (cfun
) - 1);
415 /* Compress the path from V to the root of its set and update path_min at the
416 same time. After compress(di, V) set_chain[V] is the root of the set V is
417 in and path_min[V] is the node with the smallest key[] value on the path
418 from V to that root. */
421 compress (struct dom_info
*di
, TBB v
)
423 /* Btw. It's not worth to unrecurse compress() as the depth is usually not
424 greater than 5 even for huge graphs (I've not seen call depth > 4).
425 Also performance wise compress() ranges _far_ behind eval(). */
426 TBB parent
= di
->set_chain
[v
];
427 if (di
->set_chain
[parent
])
429 compress (di
, parent
);
430 if (di
->key
[di
->path_min
[parent
]] < di
->key
[di
->path_min
[v
]])
431 di
->path_min
[v
] = di
->path_min
[parent
];
432 di
->set_chain
[v
] = di
->set_chain
[parent
];
436 /* Compress the path from V to the set root of V if needed (when the root has
437 changed since the last call). Returns the node with the smallest key[]
438 value on the path from V to the root. */
441 eval (struct dom_info
*di
, TBB v
)
443 /* The representative of the set V is in, also called root (as the set
444 representation is a tree). */
445 TBB rep
= di
->set_chain
[v
];
447 /* V itself is the root. */
449 return di
->path_min
[v
];
451 /* Compress only if necessary. */
452 if (di
->set_chain
[rep
])
455 rep
= di
->set_chain
[v
];
458 if (di
->key
[di
->path_min
[rep
]] >= di
->key
[di
->path_min
[v
]])
459 return di
->path_min
[v
];
461 return di
->path_min
[rep
];
464 /* This essentially merges the two sets of V and W, giving a single set with
465 the new root V. The internal representation of these disjoint sets is a
466 balanced tree. Currently link(V,W) is only used with V being the parent
470 link_roots (struct dom_info
*di
, TBB v
, TBB w
)
474 /* Rebalance the tree. */
475 while (di
->key
[di
->path_min
[w
]] < di
->key
[di
->path_min
[di
->set_child
[s
]]])
477 if (di
->set_size
[s
] + di
->set_size
[di
->set_child
[di
->set_child
[s
]]]
478 >= 2 * di
->set_size
[di
->set_child
[s
]])
480 di
->set_chain
[di
->set_child
[s
]] = s
;
481 di
->set_child
[s
] = di
->set_child
[di
->set_child
[s
]];
485 di
->set_size
[di
->set_child
[s
]] = di
->set_size
[s
];
486 s
= di
->set_chain
[s
] = di
->set_child
[s
];
490 di
->path_min
[s
] = di
->path_min
[w
];
491 di
->set_size
[v
] += di
->set_size
[w
];
492 if (di
->set_size
[v
] < 2 * di
->set_size
[w
])
495 s
= di
->set_child
[v
];
496 di
->set_child
[v
] = tmp
;
499 /* Merge all subtrees. */
502 di
->set_chain
[s
] = v
;
503 s
= di
->set_child
[s
];
507 /* This calculates the immediate dominators (or post-dominators if REVERSE is
508 true). DI is our working structure and should hold the DFS forest.
509 On return the immediate dominator to node V is in di->dom[V]. */
512 calc_idoms (struct dom_info
*di
, bool reverse
)
515 basic_block en_block
;
516 edge_iterator ei
, einext
;
519 en_block
= EXIT_BLOCK_PTR_FOR_FN (cfun
);
521 en_block
= ENTRY_BLOCK_PTR_FOR_FN (cfun
);
523 /* Go backwards in DFS order, to first look at the leafs. */
527 basic_block bb
= di
->dfs_to_bb
[v
];
530 par
= di
->dfs_parent
[v
];
533 ei
= (reverse
) ? ei_start (bb
->succs
) : ei_start (bb
->preds
);
537 /* If this block has a fake edge to exit, process that first. */
538 if (bitmap_bit_p (di
->fake_exit_edge
, bb
->index
))
542 goto do_fake_exit_edge
;
546 /* Search all direct predecessors for the smallest node with a path
547 to them. That way we have the smallest node with also a path to
548 us only over nodes behind us. In effect we search for our
550 while (!ei_end_p (ei
))
556 b
= (reverse
) ? e
->dest
: e
->src
;
563 k1
= di
->dfs_order
[last_basic_block_for_fn (cfun
)];
566 k1
= di
->dfs_order
[b
->index
];
568 /* Call eval() only if really needed. If k1 is above V in DFS tree,
569 then we know, that eval(k1) == k1 and key[k1] == k1. */
571 k1
= di
->key
[eval (di
, k1
)];
579 link_roots (di
, par
, v
);
580 di
->next_bucket
[v
] = di
->bucket
[k
];
583 /* Transform semidominators into dominators. */
584 for (w
= di
->bucket
[par
]; w
; w
= di
->next_bucket
[w
])
587 if (di
->key
[k
] < di
->key
[w
])
592 /* We don't need to cleanup next_bucket[]. */
597 /* Explicitly define the dominators. */
599 for (v
= 2; v
<= di
->nodes
; v
++)
600 if (di
->dom
[v
] != di
->key
[v
])
601 di
->dom
[v
] = di
->dom
[di
->dom
[v
]];
604 /* Assign dfs numbers starting from NUM to NODE and its sons. */
607 assign_dfs_numbers (struct et_node
*node
, int *num
)
611 node
->dfs_num_in
= (*num
)++;
615 assign_dfs_numbers (node
->son
, num
);
616 for (son
= node
->son
->right
; son
!= node
->son
; son
= son
->right
)
617 assign_dfs_numbers (son
, num
);
620 node
->dfs_num_out
= (*num
)++;
623 /* Compute the data necessary for fast resolving of dominator queries in a
624 static dominator tree. */
627 compute_dom_fast_query (enum cdi_direction dir
)
631 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
633 gcc_checking_assert (dom_info_available_p (dir
));
635 if (dom_computed
[dir_index
] == DOM_OK
)
638 FOR_ALL_BB_FN (bb
, cfun
)
640 if (!bb
->dom
[dir_index
]->father
)
641 assign_dfs_numbers (bb
->dom
[dir_index
], &num
);
644 dom_computed
[dir_index
] = DOM_OK
;
647 /* The main entry point into this module. DIR is set depending on whether
648 we want to compute dominators or postdominators. */
651 calculate_dominance_info (enum cdi_direction dir
)
655 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
656 bool reverse
= (dir
== CDI_POST_DOMINATORS
) ? true : false;
658 if (dom_computed
[dir_index
] == DOM_OK
)
661 timevar_push (TV_DOMINANCE
);
662 if (!dom_info_available_p (dir
))
664 gcc_assert (!n_bbs_in_dom_tree
[dir_index
]);
666 FOR_ALL_BB_FN (b
, cfun
)
668 b
->dom
[dir_index
] = et_new_tree (b
);
670 n_bbs_in_dom_tree
[dir_index
] = n_basic_blocks_for_fn (cfun
);
672 init_dom_info (&di
, dir
);
673 calc_dfs_tree (&di
, reverse
);
674 calc_idoms (&di
, reverse
);
676 FOR_EACH_BB_FN (b
, cfun
)
678 TBB d
= di
.dom
[di
.dfs_order
[b
->index
]];
681 et_set_father (b
->dom
[dir_index
], di
.dfs_to_bb
[d
]->dom
[dir_index
]);
685 dom_computed
[dir_index
] = DOM_NO_FAST_QUERY
;
688 compute_dom_fast_query (dir
);
690 timevar_pop (TV_DOMINANCE
);
693 /* Free dominance information for direction DIR. */
695 free_dominance_info (function
*fn
, enum cdi_direction dir
)
698 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
700 if (!dom_info_available_p (fn
, dir
))
703 FOR_ALL_BB_FN (bb
, fn
)
705 et_free_tree_force (bb
->dom
[dir_index
]);
706 bb
->dom
[dir_index
] = NULL
;
710 fn
->cfg
->x_n_bbs_in_dom_tree
[dir_index
] = 0;
712 fn
->cfg
->x_dom_computed
[dir_index
] = DOM_NONE
;
716 free_dominance_info (enum cdi_direction dir
)
718 free_dominance_info (cfun
, dir
);
721 /* Return the immediate dominator of basic block BB. */
723 get_immediate_dominator (enum cdi_direction dir
, basic_block bb
)
725 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
726 struct et_node
*node
= bb
->dom
[dir_index
];
728 gcc_checking_assert (dom_computed
[dir_index
]);
733 return (basic_block
) node
->father
->data
;
736 /* Set the immediate dominator of the block possibly removing
737 existing edge. NULL can be used to remove any edge. */
739 set_immediate_dominator (enum cdi_direction dir
, basic_block bb
,
740 basic_block dominated_by
)
742 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
743 struct et_node
*node
= bb
->dom
[dir_index
];
745 gcc_checking_assert (dom_computed
[dir_index
]);
749 if (node
->father
->data
== dominated_by
)
755 et_set_father (node
, dominated_by
->dom
[dir_index
]);
757 if (dom_computed
[dir_index
] == DOM_OK
)
758 dom_computed
[dir_index
] = DOM_NO_FAST_QUERY
;
761 /* Returns the list of basic blocks immediately dominated by BB, in the
764 get_dominated_by (enum cdi_direction dir
, basic_block bb
)
766 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
767 struct et_node
*node
= bb
->dom
[dir_index
], *son
= node
->son
, *ason
;
768 vec
<basic_block
> bbs
= vNULL
;
770 gcc_checking_assert (dom_computed
[dir_index
]);
775 bbs
.safe_push ((basic_block
) son
->data
);
776 for (ason
= son
->right
; ason
!= son
; ason
= ason
->right
)
777 bbs
.safe_push ((basic_block
) ason
->data
);
782 /* Returns the list of basic blocks that are immediately dominated (in
783 direction DIR) by some block between N_REGION ones stored in REGION,
784 except for blocks in the REGION itself. */
787 get_dominated_by_region (enum cdi_direction dir
, basic_block
*region
,
792 vec
<basic_block
> doms
= vNULL
;
794 for (i
= 0; i
< n_region
; i
++)
795 region
[i
]->flags
|= BB_DUPLICATED
;
796 for (i
= 0; i
< n_region
; i
++)
797 for (dom
= first_dom_son (dir
, region
[i
]);
799 dom
= next_dom_son (dir
, dom
))
800 if (!(dom
->flags
& BB_DUPLICATED
))
801 doms
.safe_push (dom
);
802 for (i
= 0; i
< n_region
; i
++)
803 region
[i
]->flags
&= ~BB_DUPLICATED
;
808 /* Returns the list of basic blocks including BB dominated by BB, in the
809 direction DIR up to DEPTH in the dominator tree. The DEPTH of zero will
810 produce a vector containing all dominated blocks. The vector will be sorted
814 get_dominated_to_depth (enum cdi_direction dir
, basic_block bb
, int depth
)
816 vec
<basic_block
> bbs
= vNULL
;
818 unsigned next_level_start
;
822 next_level_start
= 1; /* = bbs.length (); */
829 for (son
= first_dom_son (dir
, bb
);
831 son
= next_dom_son (dir
, son
))
834 if (i
== next_level_start
&& --depth
)
835 next_level_start
= bbs
.length ();
837 while (i
< next_level_start
);
842 /* Returns the list of basic blocks including BB dominated by BB, in the
843 direction DIR. The vector will be sorted in preorder. */
846 get_all_dominated_blocks (enum cdi_direction dir
, basic_block bb
)
848 return get_dominated_to_depth (dir
, bb
, 0);
851 /* Redirect all edges pointing to BB to TO. */
853 redirect_immediate_dominators (enum cdi_direction dir
, basic_block bb
,
856 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
857 struct et_node
*bb_node
, *to_node
, *son
;
859 bb_node
= bb
->dom
[dir_index
];
860 to_node
= to
->dom
[dir_index
];
862 gcc_checking_assert (dom_computed
[dir_index
]);
872 et_set_father (son
, to_node
);
875 if (dom_computed
[dir_index
] == DOM_OK
)
876 dom_computed
[dir_index
] = DOM_NO_FAST_QUERY
;
879 /* Find first basic block in the tree dominating both BB1 and BB2. */
881 nearest_common_dominator (enum cdi_direction dir
, basic_block bb1
, basic_block bb2
)
883 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
885 gcc_checking_assert (dom_computed
[dir_index
]);
892 return (basic_block
) et_nca (bb1
->dom
[dir_index
], bb2
->dom
[dir_index
])->data
;
896 /* Find the nearest common dominator for the basic blocks in BLOCKS,
897 using dominance direction DIR. */
900 nearest_common_dominator_for_set (enum cdi_direction dir
, bitmap blocks
)
906 first
= bitmap_first_set_bit (blocks
);
907 dom
= BASIC_BLOCK_FOR_FN (cfun
, first
);
908 EXECUTE_IF_SET_IN_BITMAP (blocks
, 0, i
, bi
)
909 if (dom
!= BASIC_BLOCK_FOR_FN (cfun
, i
))
910 dom
= nearest_common_dominator (dir
, dom
, BASIC_BLOCK_FOR_FN (cfun
, i
));
915 /* Given a dominator tree, we can determine whether one thing
916 dominates another in constant time by using two DFS numbers:
918 1. The number for when we visit a node on the way down the tree
919 2. The number for when we visit a node on the way back up the tree
921 You can view these as bounds for the range of dfs numbers the
922 nodes in the subtree of the dominator tree rooted at that node
925 The dominator tree is always a simple acyclic tree, so there are
926 only three possible relations two nodes in the dominator tree have
929 1. Node A is above Node B (and thus, Node A dominates node B)
938 In the above case, DFS_Number_In of A will be <= DFS_Number_In of
939 B, and DFS_Number_Out of A will be >= DFS_Number_Out of B. This is
940 because we must hit A in the dominator tree *before* B on the walk
941 down, and we will hit A *after* B on the walk back up
943 2. Node A is below node B (and thus, node B dominates node A)
952 In the above case, DFS_Number_In of A will be >= DFS_Number_In of
953 B, and DFS_Number_Out of A will be <= DFS_Number_Out of B.
955 This is because we must hit A in the dominator tree *after* B on
956 the walk down, and we will hit A *before* B on the walk back up
958 3. Node A and B are siblings (and thus, neither dominates the other)
966 In the above case, DFS_Number_In of A will *always* be <=
967 DFS_Number_In of B, and DFS_Number_Out of A will *always* be <=
968 DFS_Number_Out of B. This is because we will always finish the dfs
969 walk of one of the subtrees before the other, and thus, the dfs
970 numbers for one subtree can't intersect with the range of dfs
971 numbers for the other subtree. If you swap A and B's position in
972 the dominator tree, the comparison changes direction, but the point
973 is that both comparisons will always go the same way if there is no
974 dominance relationship.
976 Thus, it is sufficient to write
978 A_Dominates_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 A_Dominated_by_B (node A, node B)
986 return DFS_Number_In(A) >= DFS_Number_In(B)
987 && DFS_Number_Out (A) <= DFS_Number_Out(B);
990 /* Return TRUE in case BB1 is dominated by BB2. */
992 dominated_by_p (enum cdi_direction dir
, const_basic_block bb1
, const_basic_block bb2
)
994 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
995 struct et_node
*n1
= bb1
->dom
[dir_index
], *n2
= bb2
->dom
[dir_index
];
997 gcc_checking_assert (dom_computed
[dir_index
]);
999 if (dom_computed
[dir_index
] == DOM_OK
)
1000 return (n1
->dfs_num_in
>= n2
->dfs_num_in
1001 && n1
->dfs_num_out
<= n2
->dfs_num_out
);
1003 return et_below (n1
, n2
);
1006 /* Returns the entry dfs number for basic block BB, in the direction DIR. */
1009 bb_dom_dfs_in (enum cdi_direction dir
, basic_block bb
)
1011 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
1012 struct et_node
*n
= bb
->dom
[dir_index
];
1014 gcc_checking_assert (dom_computed
[dir_index
] == DOM_OK
);
1015 return n
->dfs_num_in
;
1018 /* Returns the exit dfs number for basic block BB, in the direction DIR. */
1021 bb_dom_dfs_out (enum cdi_direction dir
, basic_block bb
)
1023 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
1024 struct et_node
*n
= bb
->dom
[dir_index
];
1026 gcc_checking_assert (dom_computed
[dir_index
] == DOM_OK
);
1027 return n
->dfs_num_out
;
1030 /* Verify invariants of dominator structure. */
1032 verify_dominators (enum cdi_direction dir
)
1035 basic_block bb
, imm_bb
, imm_bb_correct
;
1037 bool reverse
= (dir
== CDI_POST_DOMINATORS
) ? true : false;
1039 gcc_assert (dom_info_available_p (dir
));
1041 init_dom_info (&di
, dir
);
1042 calc_dfs_tree (&di
, reverse
);
1043 calc_idoms (&di
, reverse
);
1045 FOR_EACH_BB_FN (bb
, cfun
)
1047 imm_bb
= get_immediate_dominator (dir
, bb
);
1050 error ("dominator of %d status unknown", bb
->index
);
1054 imm_bb_correct
= di
.dfs_to_bb
[di
.dom
[di
.dfs_order
[bb
->index
]]];
1055 if (imm_bb
!= imm_bb_correct
)
1057 error ("dominator of %d should be %d, not %d",
1058 bb
->index
, imm_bb_correct
->index
, imm_bb
->index
);
1063 free_dom_info (&di
);
1067 /* Determine immediate dominator (or postdominator, according to DIR) of BB,
1068 assuming that dominators of other blocks are correct. We also use it to
1069 recompute the dominators in a restricted area, by iterating it until it
1070 reaches a fixed point. */
1073 recompute_dominator (enum cdi_direction dir
, basic_block bb
)
1075 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
1076 basic_block dom_bb
= NULL
;
1080 gcc_checking_assert (dom_computed
[dir_index
]);
1082 if (dir
== CDI_DOMINATORS
)
1084 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
1086 if (!dominated_by_p (dir
, e
->src
, bb
))
1087 dom_bb
= nearest_common_dominator (dir
, dom_bb
, e
->src
);
1092 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
1094 if (!dominated_by_p (dir
, e
->dest
, bb
))
1095 dom_bb
= nearest_common_dominator (dir
, dom_bb
, e
->dest
);
1102 /* Use simple heuristics (see iterate_fix_dominators) to determine dominators
1103 of BBS. We assume that all the immediate dominators except for those of the
1104 blocks in BBS are correct. If CONSERVATIVE is true, we also assume that the
1105 currently recorded immediate dominators of blocks in BBS really dominate the
1106 blocks. The basic blocks for that we determine the dominator are removed
1110 prune_bbs_to_update_dominators (vec
<basic_block
> bbs
,
1115 basic_block bb
, dom
= NULL
;
1119 for (i
= 0; bbs
.iterate (i
, &bb
);)
1121 if (bb
== ENTRY_BLOCK_PTR_FOR_FN (cfun
))
1124 if (single_pred_p (bb
))
1126 set_immediate_dominator (CDI_DOMINATORS
, bb
, single_pred (bb
));
1135 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
1137 if (dominated_by_p (CDI_DOMINATORS
, e
->src
, bb
))
1145 dom
= nearest_common_dominator (CDI_DOMINATORS
, dom
, e
->src
);
1149 gcc_assert (dom
!= NULL
);
1151 || find_edge (dom
, bb
))
1153 set_immediate_dominator (CDI_DOMINATORS
, bb
, dom
);
1162 bbs
.unordered_remove (i
);
1166 /* Returns root of the dominance tree in the direction DIR that contains
1170 root_of_dom_tree (enum cdi_direction dir
, basic_block bb
)
1172 return (basic_block
) et_root (bb
->dom
[dom_convert_dir_to_idx (dir
)])->data
;
1175 /* See the comment in iterate_fix_dominators. Finds the immediate dominators
1176 for the sons of Y, found using the SON and BROTHER arrays representing
1177 the dominance tree of graph G. BBS maps the vertices of G to the basic
1181 determine_dominators_for_sons (struct graph
*g
, vec
<basic_block
> bbs
,
1182 int y
, int *son
, int *brother
)
1187 basic_block bb
, dom
, ybb
;
1194 if (y
== (int) bbs
.length ())
1195 ybb
= ENTRY_BLOCK_PTR_FOR_FN (cfun
);
1199 if (brother
[son
[y
]] == -1)
1201 /* Handle the common case Y has just one son specially. */
1203 set_immediate_dominator (CDI_DOMINATORS
, bb
,
1204 recompute_dominator (CDI_DOMINATORS
, bb
));
1205 identify_vertices (g
, y
, son
[y
]);
1209 gprime
= BITMAP_ALLOC (NULL
);
1210 for (a
= son
[y
]; a
!= -1; a
= brother
[a
])
1211 bitmap_set_bit (gprime
, a
);
1213 nc
= graphds_scc (g
, gprime
);
1214 BITMAP_FREE (gprime
);
1216 /* ??? Needed to work around the pre-processor confusion with
1217 using a multi-argument template type as macro argument. */
1218 typedef vec
<int> vec_int_heap
;
1219 sccs
= XCNEWVEC (vec_int_heap
, nc
);
1220 for (a
= son
[y
]; a
!= -1; a
= brother
[a
])
1221 sccs
[g
->vertices
[a
].component
].safe_push (a
);
1223 for (i
= nc
- 1; i
>= 0; i
--)
1226 FOR_EACH_VEC_ELT (sccs
[i
], si
, a
)
1229 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
1231 if (root_of_dom_tree (CDI_DOMINATORS
, e
->src
) != ybb
)
1234 dom
= nearest_common_dominator (CDI_DOMINATORS
, dom
, e
->src
);
1238 gcc_assert (dom
!= NULL
);
1239 FOR_EACH_VEC_ELT (sccs
[i
], si
, a
)
1242 set_immediate_dominator (CDI_DOMINATORS
, bb
, dom
);
1246 for (i
= 0; i
< nc
; i
++)
1250 for (a
= son
[y
]; a
!= -1; a
= brother
[a
])
1251 identify_vertices (g
, y
, a
);
1254 /* Recompute dominance information for basic blocks in the set BBS. The
1255 function assumes that the immediate dominators of all the other blocks
1256 in CFG are correct, and that there are no unreachable blocks.
1258 If CONSERVATIVE is true, we additionally assume that all the ancestors of
1259 a block of BBS in the current dominance tree dominate it. */
1262 iterate_fix_dominators (enum cdi_direction dir
, vec
<basic_block
> bbs
,
1266 basic_block bb
, dom
;
1272 int *parent
, *son
, *brother
;
1273 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
1275 /* We only support updating dominators. There are some problems with
1276 updating postdominators (need to add fake edges from infinite loops
1277 and noreturn functions), and since we do not currently use
1278 iterate_fix_dominators for postdominators, any attempt to handle these
1279 problems would be unused, untested, and almost surely buggy. We keep
1280 the DIR argument for consistency with the rest of the dominator analysis
1282 gcc_checking_assert (dir
== CDI_DOMINATORS
&& dom_computed
[dir_index
]);
1284 /* The algorithm we use takes inspiration from the following papers, although
1285 the details are quite different from any of them:
1287 [1] G. Ramalingam, T. Reps, An Incremental Algorithm for Maintaining the
1288 Dominator Tree of a Reducible Flowgraph
1289 [2] V. C. Sreedhar, G. R. Gao, Y.-F. Lee: Incremental computation of
1291 [3] K. D. Cooper, T. J. Harvey and K. Kennedy: A Simple, Fast Dominance
1294 First, we use the following heuristics to decrease the size of the BBS
1296 a) if BB has a single predecessor, then its immediate dominator is this
1298 additionally, if CONSERVATIVE is true:
1299 b) if all the predecessors of BB except for one (X) are dominated by BB,
1300 then X is the immediate dominator of BB
1301 c) if the nearest common ancestor of the predecessors of BB is X and
1302 X -> BB is an edge in CFG, then X is the immediate dominator of BB
1304 Then, we need to establish the dominance relation among the basic blocks
1305 in BBS. We split the dominance tree by removing the immediate dominator
1306 edges from BBS, creating a forest F. We form a graph G whose vertices
1307 are BBS and ENTRY and X -> Y is an edge of G if there exists an edge
1308 X' -> Y in CFG such that X' belongs to the tree of the dominance forest
1309 whose root is X. We then determine dominance tree of G. Note that
1310 for X, Y in BBS, X dominates Y in CFG if and only if X dominates Y in G.
1311 In this step, we can use arbitrary algorithm to determine dominators.
1312 We decided to prefer the algorithm [3] to the algorithm of
1313 Lengauer and Tarjan, since the set BBS is usually small (rarely exceeding
1314 10 during gcc bootstrap), and [3] should perform better in this case.
1316 Finally, we need to determine the immediate dominators for the basic
1317 blocks of BBS. If the immediate dominator of X in G is Y, then
1318 the immediate dominator of X in CFG belongs to the tree of F rooted in
1319 Y. We process the dominator tree T of G recursively, starting from leaves.
1320 Suppose that X_1, X_2, ..., X_k are the sons of Y in T, and that the
1321 subtrees of the dominance tree of CFG rooted in X_i are already correct.
1322 Let G' be the subgraph of G induced by {X_1, X_2, ..., X_k}. We make
1323 the following observations:
1324 (i) the immediate dominator of all blocks in a strongly connected
1325 component of G' is the same
1326 (ii) if X has no predecessors in G', then the immediate dominator of X
1327 is the nearest common ancestor of the predecessors of X in the
1328 subtree of F rooted in Y
1329 Therefore, it suffices to find the topological ordering of G', and
1330 process the nodes X_i in this order using the rules (i) and (ii).
1331 Then, we contract all the nodes X_i with Y in G, so that the further
1332 steps work correctly. */
1336 /* Split the tree now. If the idoms of blocks in BBS are not
1337 conservatively correct, setting the dominators using the
1338 heuristics in prune_bbs_to_update_dominators could
1339 create cycles in the dominance "tree", and cause ICE. */
1340 FOR_EACH_VEC_ELT (bbs
, i
, bb
)
1341 set_immediate_dominator (CDI_DOMINATORS
, bb
, NULL
);
1344 prune_bbs_to_update_dominators (bbs
, conservative
);
1353 set_immediate_dominator (CDI_DOMINATORS
, bb
,
1354 recompute_dominator (CDI_DOMINATORS
, bb
));
1358 /* Construct the graph G. */
1359 hash_map
<basic_block
, int> map (251);
1360 FOR_EACH_VEC_ELT (bbs
, i
, bb
)
1362 /* If the dominance tree is conservatively correct, split it now. */
1364 set_immediate_dominator (CDI_DOMINATORS
, bb
, NULL
);
1367 map
.put (ENTRY_BLOCK_PTR_FOR_FN (cfun
), n
);
1369 g
= new_graph (n
+ 1);
1370 for (y
= 0; y
< g
->n_vertices
; y
++)
1371 g
->vertices
[y
].data
= BITMAP_ALLOC (NULL
);
1372 FOR_EACH_VEC_ELT (bbs
, i
, bb
)
1374 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
1376 dom
= root_of_dom_tree (CDI_DOMINATORS
, e
->src
);
1380 dom_i
= *map
.get (dom
);
1382 /* Do not include parallel edges to G. */
1383 if (!bitmap_set_bit ((bitmap
) g
->vertices
[dom_i
].data
, i
))
1386 add_edge (g
, dom_i
, i
);
1389 for (y
= 0; y
< g
->n_vertices
; y
++)
1390 BITMAP_FREE (g
->vertices
[y
].data
);
1392 /* Find the dominator tree of G. */
1393 son
= XNEWVEC (int, n
+ 1);
1394 brother
= XNEWVEC (int, n
+ 1);
1395 parent
= XNEWVEC (int, n
+ 1);
1396 graphds_domtree (g
, n
, parent
, son
, brother
);
1398 /* Finally, traverse the tree and find the immediate dominators. */
1399 for (y
= n
; son
[y
] != -1; y
= son
[y
])
1403 determine_dominators_for_sons (g
, bbs
, y
, son
, brother
);
1405 if (brother
[y
] != -1)
1408 while (son
[y
] != -1)
1423 add_to_dominance_info (enum cdi_direction dir
, basic_block bb
)
1425 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
1427 gcc_checking_assert (dom_computed
[dir_index
] && !bb
->dom
[dir_index
]);
1429 n_bbs_in_dom_tree
[dir_index
]++;
1431 bb
->dom
[dir_index
] = et_new_tree (bb
);
1433 if (dom_computed
[dir_index
] == DOM_OK
)
1434 dom_computed
[dir_index
] = DOM_NO_FAST_QUERY
;
1438 delete_from_dominance_info (enum cdi_direction dir
, basic_block bb
)
1440 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
1442 gcc_checking_assert (dom_computed
[dir_index
]);
1444 et_free_tree (bb
->dom
[dir_index
]);
1445 bb
->dom
[dir_index
] = NULL
;
1446 n_bbs_in_dom_tree
[dir_index
]--;
1448 if (dom_computed
[dir_index
] == DOM_OK
)
1449 dom_computed
[dir_index
] = DOM_NO_FAST_QUERY
;
1452 /* Returns the first son of BB in the dominator or postdominator tree
1453 as determined by DIR. */
1456 first_dom_son (enum cdi_direction dir
, basic_block bb
)
1458 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
1459 struct et_node
*son
= bb
->dom
[dir_index
]->son
;
1461 return (basic_block
) (son
? son
->data
: NULL
);
1464 /* Returns the next dominance son after BB in the dominator or postdominator
1465 tree as determined by DIR, or NULL if it was the last one. */
1468 next_dom_son (enum cdi_direction dir
, basic_block bb
)
1470 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
1471 struct et_node
*next
= bb
->dom
[dir_index
]->right
;
1473 return (basic_block
) (next
->father
->son
== next
? NULL
: next
->data
);
1476 /* Return dominance availability for dominance info DIR. */
1479 dom_info_state (function
*fn
, enum cdi_direction dir
)
1484 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
1485 return fn
->cfg
->x_dom_computed
[dir_index
];
1489 dom_info_state (enum cdi_direction dir
)
1491 return dom_info_state (cfun
, dir
);
1494 /* Set the dominance availability for dominance info DIR to NEW_STATE. */
1497 set_dom_info_availability (enum cdi_direction dir
, enum dom_state new_state
)
1499 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
1501 dom_computed
[dir_index
] = new_state
;
1504 /* Returns true if dominance information for direction DIR is available. */
1507 dom_info_available_p (function
*fn
, enum cdi_direction dir
)
1509 return dom_info_state (fn
, dir
) != DOM_NONE
;
1513 dom_info_available_p (enum cdi_direction dir
)
1515 return dom_info_available_p (cfun
, dir
);
1519 debug_dominance_info (enum cdi_direction dir
)
1521 basic_block bb
, bb2
;
1522 FOR_EACH_BB_FN (bb
, cfun
)
1523 if ((bb2
= get_immediate_dominator (dir
, bb
)))
1524 fprintf (stderr
, "%i %i\n", bb
->index
, bb2
->index
);
1527 /* Prints to stderr representation of the dominance tree (for direction DIR)
1528 rooted in ROOT, indented by INDENT tabulators. If INDENT_FIRST is false,
1529 the first line of the output is not indented. */
1532 debug_dominance_tree_1 (enum cdi_direction dir
, basic_block root
,
1533 unsigned indent
, bool indent_first
)
1540 for (i
= 0; i
< indent
; i
++)
1541 fprintf (stderr
, "\t");
1542 fprintf (stderr
, "%d\t", root
->index
);
1544 for (son
= first_dom_son (dir
, root
);
1546 son
= next_dom_son (dir
, son
))
1548 debug_dominance_tree_1 (dir
, son
, indent
+ 1, !first
);
1553 fprintf (stderr
, "\n");
1556 /* Prints to stderr representation of the dominance tree (for direction DIR)
1560 debug_dominance_tree (enum cdi_direction dir
, basic_block root
)
1562 debug_dominance_tree_1 (dir
, root
, 0, false);