1 /* Calculate (post)dominators in slightly super-linear time.
2 Copyright (C) 2000, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
3 Free Software Foundation, Inc.
4 Contributed by Michael Matz (matz@ifh.de).
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GCC is distributed in the hope that it will be useful, but WITHOUT
14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
15 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
16 License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
22 /* This file implements the well known algorithm from Lengauer and Tarjan
23 to compute the dominators in a control flow graph. A basic block D is said
24 to dominate another block X, when all paths from the entry node of the CFG
25 to X go also over D. The dominance relation is a transitive reflexive
26 relation and its minimal transitive reduction is a tree, called the
27 dominator tree. So for each block X besides the entry block exists a
28 block I(X), called the immediate dominator of X, which is the parent of X
29 in the dominator tree.
31 The algorithm computes this dominator tree implicitly by computing for
32 each block its immediate dominator. We use tree balancing and path
33 compression, so it's the O(e*a(e,v)) variant, where a(e,v) is the very
34 slowly growing functional inverse of the Ackerman function. */
38 #include "coretypes.h"
41 #include "hard-reg-set.h"
43 #include "basic-block.h"
44 #include "diagnostic-core.h"
45 #include "et-forest.h"
48 #include "pointer-set.h"
52 /* We name our nodes with integers, beginning with 1. Zero is reserved for
53 'undefined' or 'end of list'. The name of each node is given by the dfs
54 number of the corresponding basic block. Please note, that we include the
55 artificial ENTRY_BLOCK (or EXIT_BLOCK in the post-dom case) in our lists to
56 support multiple entry points. Its dfs number is of course 1. */
58 /* Type of Basic Block aka. TBB */
59 typedef unsigned int TBB
;
61 /* We work in a poor-mans object oriented fashion, and carry an instance of
62 this structure through all our 'methods'. It holds various arrays
63 reflecting the (sub)structure of the flowgraph. Most of them are of type
64 TBB and are also indexed by TBB. */
68 /* The parent of a node in the DFS tree. */
70 /* For a node x key[x] is roughly the node nearest to the root from which
71 exists a way to x only over nodes behind x. Such a node is also called
74 /* The value in path_min[x] is the node y on the path from x to the root of
75 the tree x is in with the smallest key[y]. */
77 /* bucket[x] points to the first node of the set of nodes having x as key. */
79 /* And next_bucket[x] points to the next node. */
81 /* After the algorithm is done, dom[x] contains the immediate dominator
85 /* The following few fields implement the structures needed for disjoint
87 /* set_chain[x] is the next node on the path from x to the representative
88 of the set containing x. If set_chain[x]==0 then x is a root. */
90 /* set_size[x] is the number of elements in the set named by x. */
91 unsigned int *set_size
;
92 /* set_child[x] is used for balancing the tree representing a set. It can
93 be understood as the next sibling of x. */
96 /* If b is the number of a basic block (BB->index), dfs_order[b] is the
97 number of that node in DFS order counted from 1. This is an index
98 into most of the other arrays in this structure. */
100 /* If x is the DFS-index of a node which corresponds with a basic block,
101 dfs_to_bb[x] is that basic block. Note, that in our structure there are
102 more nodes that basic blocks, so only dfs_to_bb[dfs_order[bb->index]]==bb
103 is true for every basic block bb, but not the opposite. */
104 basic_block
*dfs_to_bb
;
106 /* This is the next free DFS number when creating the DFS tree. */
108 /* The number of nodes in the DFS tree (==dfsnum-1). */
111 /* Blocks with bits set here have a fake edge to EXIT. These are used
112 to turn a DFS forest into a proper tree. */
113 bitmap fake_exit_edge
;
116 static void init_dom_info (struct dom_info
*, enum cdi_direction
);
117 static void free_dom_info (struct dom_info
*);
118 static void calc_dfs_tree_nonrec (struct dom_info
*, basic_block
, bool);
119 static void calc_dfs_tree (struct dom_info
*, bool);
120 static void compress (struct dom_info
*, TBB
);
121 static TBB
eval (struct dom_info
*, TBB
);
122 static void link_roots (struct dom_info
*, TBB
, TBB
);
123 static void calc_idoms (struct dom_info
*, bool);
124 void debug_dominance_info (enum cdi_direction
);
125 void debug_dominance_tree (enum cdi_direction
, basic_block
);
127 /* Helper macro for allocating and initializing an array,
128 for aesthetic reasons. */
129 #define init_ar(var, type, num, content) \
132 unsigned int i = 1; /* Catch content == i. */ \
134 (var) = XCNEWVEC (type, num); \
137 (var) = XNEWVEC (type, (num)); \
138 for (i = 0; i < num; i++) \
139 (var)[i] = (content); \
144 /* Allocate all needed memory in a pessimistic fashion (so we round up).
145 This initializes the contents of DI, which already must be allocated. */
148 init_dom_info (struct dom_info
*di
, enum cdi_direction dir
)
150 /* We need memory for n_basic_blocks nodes. */
151 unsigned int num
= n_basic_blocks
;
152 init_ar (di
->dfs_parent
, TBB
, num
, 0);
153 init_ar (di
->path_min
, TBB
, num
, i
);
154 init_ar (di
->key
, TBB
, num
, i
);
155 init_ar (di
->dom
, TBB
, num
, 0);
157 init_ar (di
->bucket
, TBB
, num
, 0);
158 init_ar (di
->next_bucket
, TBB
, num
, 0);
160 init_ar (di
->set_chain
, TBB
, num
, 0);
161 init_ar (di
->set_size
, unsigned int, num
, 1);
162 init_ar (di
->set_child
, TBB
, num
, 0);
164 init_ar (di
->dfs_order
, TBB
, (unsigned int) last_basic_block
+ 1, 0);
165 init_ar (di
->dfs_to_bb
, basic_block
, num
, 0);
173 di
->fake_exit_edge
= NULL
;
175 case CDI_POST_DOMINATORS
:
176 di
->fake_exit_edge
= BITMAP_ALLOC (NULL
);
186 /* Map dominance calculation type to array index used for various
187 dominance information arrays. This version is simple -- it will need
188 to be modified, obviously, if additional values are added to
192 dom_convert_dir_to_idx (enum cdi_direction dir
)
194 gcc_checking_assert (dir
== CDI_DOMINATORS
|| dir
== CDI_POST_DOMINATORS
);
198 /* Free all allocated memory in DI, but not DI itself. */
201 free_dom_info (struct dom_info
*di
)
203 free (di
->dfs_parent
);
208 free (di
->next_bucket
);
209 free (di
->set_chain
);
211 free (di
->set_child
);
212 free (di
->dfs_order
);
213 free (di
->dfs_to_bb
);
214 BITMAP_FREE (di
->fake_exit_edge
);
217 /* The nonrecursive variant of creating a DFS tree. DI is our working
218 structure, BB the starting basic block for this tree and REVERSE
219 is true, if predecessors should be visited instead of successors of a
220 node. After this is done all nodes reachable from BB were visited, have
221 assigned their dfs number and are linked together to form a tree. */
224 calc_dfs_tree_nonrec (struct dom_info
*di
, basic_block bb
, bool reverse
)
226 /* We call this _only_ if bb is not already visited. */
228 TBB child_i
, my_i
= 0;
229 edge_iterator
*stack
;
230 edge_iterator ei
, einext
;
232 /* Start block (ENTRY_BLOCK_PTR for forward problem, EXIT_BLOCK for backward
234 basic_block en_block
;
236 basic_block ex_block
;
238 stack
= XNEWVEC (edge_iterator
, n_basic_blocks
+ 1);
241 /* Initialize our border blocks, and the first edge. */
244 ei
= ei_start (bb
->preds
);
245 en_block
= EXIT_BLOCK_PTR
;
246 ex_block
= ENTRY_BLOCK_PTR
;
250 ei
= ei_start (bb
->succs
);
251 en_block
= ENTRY_BLOCK_PTR
;
252 ex_block
= EXIT_BLOCK_PTR
;
255 /* When the stack is empty we break out of this loop. */
260 /* This loop traverses edges e in depth first manner, and fills the
262 while (!ei_end_p (ei
))
266 /* Deduce from E the current and the next block (BB and BN), and the
272 /* If the next node BN is either already visited or a border
273 block the current edge is useless, and simply overwritten
274 with the next edge out of the current node. */
275 if (bn
== ex_block
|| di
->dfs_order
[bn
->index
])
281 einext
= ei_start (bn
->preds
);
286 if (bn
== ex_block
|| di
->dfs_order
[bn
->index
])
292 einext
= ei_start (bn
->succs
);
295 gcc_assert (bn
!= en_block
);
297 /* Fill the DFS tree info calculatable _before_ recursing. */
299 my_i
= di
->dfs_order
[bb
->index
];
301 my_i
= di
->dfs_order
[last_basic_block
];
302 child_i
= di
->dfs_order
[bn
->index
] = di
->dfsnum
++;
303 di
->dfs_to_bb
[child_i
] = bn
;
304 di
->dfs_parent
[child_i
] = my_i
;
306 /* Save the current point in the CFG on the stack, and recurse. */
315 /* OK. The edge-list was exhausted, meaning normally we would
316 end the recursion. After returning from the recursive call,
317 there were (may be) other statements which were run after a
318 child node was completely considered by DFS. Here is the
319 point to do it in the non-recursive variant.
320 E.g. The block just completed is in e->dest for forward DFS,
321 the block not yet completed (the parent of the one above)
322 in e->src. This could be used e.g. for computing the number of
323 descendants or the tree depth. */
329 /* The main entry for calculating the DFS tree or forest. DI is our working
330 structure and REVERSE is true, if we are interested in the reverse flow
331 graph. In that case the result is not necessarily a tree but a forest,
332 because there may be nodes from which the EXIT_BLOCK is unreachable. */
335 calc_dfs_tree (struct dom_info
*di
, bool reverse
)
337 /* The first block is the ENTRY_BLOCK (or EXIT_BLOCK if REVERSE). */
338 basic_block begin
= reverse
? EXIT_BLOCK_PTR
: ENTRY_BLOCK_PTR
;
339 di
->dfs_order
[last_basic_block
] = di
->dfsnum
;
340 di
->dfs_to_bb
[di
->dfsnum
] = begin
;
343 calc_dfs_tree_nonrec (di
, begin
, reverse
);
347 /* In the post-dom case we may have nodes without a path to EXIT_BLOCK.
348 They are reverse-unreachable. In the dom-case we disallow such
349 nodes, but in post-dom we have to deal with them.
351 There are two situations in which this occurs. First, noreturn
352 functions. Second, infinite loops. In the first case we need to
353 pretend that there is an edge to the exit block. In the second
354 case, we wind up with a forest. We need to process all noreturn
355 blocks before we know if we've got any infinite loops. */
358 bool saw_unconnected
= false;
360 FOR_EACH_BB_REVERSE (b
)
362 if (EDGE_COUNT (b
->succs
) > 0)
364 if (di
->dfs_order
[b
->index
] == 0)
365 saw_unconnected
= true;
368 bitmap_set_bit (di
->fake_exit_edge
, b
->index
);
369 di
->dfs_order
[b
->index
] = di
->dfsnum
;
370 di
->dfs_to_bb
[di
->dfsnum
] = b
;
371 di
->dfs_parent
[di
->dfsnum
] = di
->dfs_order
[last_basic_block
];
373 calc_dfs_tree_nonrec (di
, b
, reverse
);
378 FOR_EACH_BB_REVERSE (b
)
381 if (di
->dfs_order
[b
->index
])
383 b2
= dfs_find_deadend (b
);
384 gcc_checking_assert (di
->dfs_order
[b2
->index
] == 0);
385 bitmap_set_bit (di
->fake_exit_edge
, b2
->index
);
386 di
->dfs_order
[b2
->index
] = di
->dfsnum
;
387 di
->dfs_to_bb
[di
->dfsnum
] = b2
;
388 di
->dfs_parent
[di
->dfsnum
] = di
->dfs_order
[last_basic_block
];
390 calc_dfs_tree_nonrec (di
, b2
, reverse
);
391 gcc_checking_assert (di
->dfs_order
[b
->index
]);
396 di
->nodes
= di
->dfsnum
- 1;
398 /* This aborts e.g. when there is _no_ path from ENTRY to EXIT at all. */
399 gcc_assert (di
->nodes
== (unsigned int) n_basic_blocks
- 1);
402 /* Compress the path from V to the root of its set and update path_min at the
403 same time. After compress(di, V) set_chain[V] is the root of the set V is
404 in and path_min[V] is the node with the smallest key[] value on the path
405 from V to that root. */
408 compress (struct dom_info
*di
, TBB v
)
410 /* Btw. It's not worth to unrecurse compress() as the depth is usually not
411 greater than 5 even for huge graphs (I've not seen call depth > 4).
412 Also performance wise compress() ranges _far_ behind eval(). */
413 TBB parent
= di
->set_chain
[v
];
414 if (di
->set_chain
[parent
])
416 compress (di
, parent
);
417 if (di
->key
[di
->path_min
[parent
]] < di
->key
[di
->path_min
[v
]])
418 di
->path_min
[v
] = di
->path_min
[parent
];
419 di
->set_chain
[v
] = di
->set_chain
[parent
];
423 /* Compress the path from V to the set root of V if needed (when the root has
424 changed since the last call). Returns the node with the smallest key[]
425 value on the path from V to the root. */
428 eval (struct dom_info
*di
, TBB v
)
430 /* The representative of the set V is in, also called root (as the set
431 representation is a tree). */
432 TBB rep
= di
->set_chain
[v
];
434 /* V itself is the root. */
436 return di
->path_min
[v
];
438 /* Compress only if necessary. */
439 if (di
->set_chain
[rep
])
442 rep
= di
->set_chain
[v
];
445 if (di
->key
[di
->path_min
[rep
]] >= di
->key
[di
->path_min
[v
]])
446 return di
->path_min
[v
];
448 return di
->path_min
[rep
];
451 /* This essentially merges the two sets of V and W, giving a single set with
452 the new root V. The internal representation of these disjoint sets is a
453 balanced tree. Currently link(V,W) is only used with V being the parent
457 link_roots (struct dom_info
*di
, TBB v
, TBB w
)
461 /* Rebalance the tree. */
462 while (di
->key
[di
->path_min
[w
]] < di
->key
[di
->path_min
[di
->set_child
[s
]]])
464 if (di
->set_size
[s
] + di
->set_size
[di
->set_child
[di
->set_child
[s
]]]
465 >= 2 * di
->set_size
[di
->set_child
[s
]])
467 di
->set_chain
[di
->set_child
[s
]] = s
;
468 di
->set_child
[s
] = di
->set_child
[di
->set_child
[s
]];
472 di
->set_size
[di
->set_child
[s
]] = di
->set_size
[s
];
473 s
= di
->set_chain
[s
] = di
->set_child
[s
];
477 di
->path_min
[s
] = di
->path_min
[w
];
478 di
->set_size
[v
] += di
->set_size
[w
];
479 if (di
->set_size
[v
] < 2 * di
->set_size
[w
])
482 s
= di
->set_child
[v
];
483 di
->set_child
[v
] = tmp
;
486 /* Merge all subtrees. */
489 di
->set_chain
[s
] = v
;
490 s
= di
->set_child
[s
];
494 /* This calculates the immediate dominators (or post-dominators if REVERSE is
495 true). DI is our working structure and should hold the DFS forest.
496 On return the immediate dominator to node V is in di->dom[V]. */
499 calc_idoms (struct dom_info
*di
, bool reverse
)
502 basic_block en_block
;
503 edge_iterator ei
, einext
;
506 en_block
= EXIT_BLOCK_PTR
;
508 en_block
= ENTRY_BLOCK_PTR
;
510 /* Go backwards in DFS order, to first look at the leafs. */
514 basic_block bb
= di
->dfs_to_bb
[v
];
517 par
= di
->dfs_parent
[v
];
520 ei
= (reverse
) ? ei_start (bb
->succs
) : ei_start (bb
->preds
);
524 /* If this block has a fake edge to exit, process that first. */
525 if (bitmap_bit_p (di
->fake_exit_edge
, bb
->index
))
529 goto do_fake_exit_edge
;
533 /* Search all direct predecessors for the smallest node with a path
534 to them. That way we have the smallest node with also a path to
535 us only over nodes behind us. In effect we search for our
537 while (!ei_end_p (ei
))
543 b
= (reverse
) ? e
->dest
: e
->src
;
550 k1
= di
->dfs_order
[last_basic_block
];
553 k1
= di
->dfs_order
[b
->index
];
555 /* Call eval() only if really needed. If k1 is above V in DFS tree,
556 then we know, that eval(k1) == k1 and key[k1] == k1. */
558 k1
= di
->key
[eval (di
, k1
)];
566 link_roots (di
, par
, v
);
567 di
->next_bucket
[v
] = di
->bucket
[k
];
570 /* Transform semidominators into dominators. */
571 for (w
= di
->bucket
[par
]; w
; w
= di
->next_bucket
[w
])
574 if (di
->key
[k
] < di
->key
[w
])
579 /* We don't need to cleanup next_bucket[]. */
584 /* Explicitly define the dominators. */
586 for (v
= 2; v
<= di
->nodes
; v
++)
587 if (di
->dom
[v
] != di
->key
[v
])
588 di
->dom
[v
] = di
->dom
[di
->dom
[v
]];
591 /* Assign dfs numbers starting from NUM to NODE and its sons. */
594 assign_dfs_numbers (struct et_node
*node
, int *num
)
598 node
->dfs_num_in
= (*num
)++;
602 assign_dfs_numbers (node
->son
, num
);
603 for (son
= node
->son
->right
; son
!= node
->son
; son
= son
->right
)
604 assign_dfs_numbers (son
, num
);
607 node
->dfs_num_out
= (*num
)++;
610 /* Compute the data necessary for fast resolving of dominator queries in a
611 static dominator tree. */
614 compute_dom_fast_query (enum cdi_direction dir
)
618 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
620 gcc_checking_assert (dom_info_available_p (dir
));
622 if (dom_computed
[dir_index
] == DOM_OK
)
627 if (!bb
->dom
[dir_index
]->father
)
628 assign_dfs_numbers (bb
->dom
[dir_index
], &num
);
631 dom_computed
[dir_index
] = DOM_OK
;
634 /* The main entry point into this module. DIR is set depending on whether
635 we want to compute dominators or postdominators. */
638 calculate_dominance_info (enum cdi_direction dir
)
642 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
643 bool reverse
= (dir
== CDI_POST_DOMINATORS
) ? true : false;
645 if (dom_computed
[dir_index
] == DOM_OK
)
648 timevar_push (TV_DOMINANCE
);
649 if (!dom_info_available_p (dir
))
651 gcc_assert (!n_bbs_in_dom_tree
[dir_index
]);
655 b
->dom
[dir_index
] = et_new_tree (b
);
657 n_bbs_in_dom_tree
[dir_index
] = n_basic_blocks
;
659 init_dom_info (&di
, dir
);
660 calc_dfs_tree (&di
, reverse
);
661 calc_idoms (&di
, reverse
);
665 TBB d
= di
.dom
[di
.dfs_order
[b
->index
]];
668 et_set_father (b
->dom
[dir_index
], di
.dfs_to_bb
[d
]->dom
[dir_index
]);
672 dom_computed
[dir_index
] = DOM_NO_FAST_QUERY
;
675 compute_dom_fast_query (dir
);
677 timevar_pop (TV_DOMINANCE
);
680 /* Free dominance information for direction DIR. */
682 free_dominance_info (enum cdi_direction dir
)
685 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
687 if (!dom_info_available_p (dir
))
692 et_free_tree_force (bb
->dom
[dir_index
]);
693 bb
->dom
[dir_index
] = NULL
;
697 n_bbs_in_dom_tree
[dir_index
] = 0;
699 dom_computed
[dir_index
] = DOM_NONE
;
702 /* Return the immediate dominator of basic block BB. */
704 get_immediate_dominator (enum cdi_direction dir
, basic_block bb
)
706 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
707 struct et_node
*node
= bb
->dom
[dir_index
];
709 gcc_checking_assert (dom_computed
[dir_index
]);
714 return (basic_block
) node
->father
->data
;
717 /* Set the immediate dominator of the block possibly removing
718 existing edge. NULL can be used to remove any edge. */
720 set_immediate_dominator (enum cdi_direction dir
, basic_block bb
,
721 basic_block dominated_by
)
723 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
724 struct et_node
*node
= bb
->dom
[dir_index
];
726 gcc_checking_assert (dom_computed
[dir_index
]);
730 if (node
->father
->data
== dominated_by
)
736 et_set_father (node
, dominated_by
->dom
[dir_index
]);
738 if (dom_computed
[dir_index
] == DOM_OK
)
739 dom_computed
[dir_index
] = DOM_NO_FAST_QUERY
;
742 /* Returns the list of basic blocks immediately dominated by BB, in the
744 VEC (basic_block
, heap
) *
745 get_dominated_by (enum cdi_direction dir
, basic_block bb
)
747 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
748 struct et_node
*node
= bb
->dom
[dir_index
], *son
= node
->son
, *ason
;
749 VEC (basic_block
, heap
) *bbs
= NULL
;
751 gcc_checking_assert (dom_computed
[dir_index
]);
756 VEC_safe_push (basic_block
, heap
, bbs
, (basic_block
) son
->data
);
757 for (ason
= son
->right
; ason
!= son
; ason
= ason
->right
)
758 VEC_safe_push (basic_block
, heap
, bbs
, (basic_block
) ason
->data
);
763 /* Returns the list of basic blocks that are immediately dominated (in
764 direction DIR) by some block between N_REGION ones stored in REGION,
765 except for blocks in the REGION itself. */
767 VEC (basic_block
, heap
) *
768 get_dominated_by_region (enum cdi_direction dir
, basic_block
*region
,
773 VEC (basic_block
, heap
) *doms
= NULL
;
775 for (i
= 0; i
< n_region
; i
++)
776 region
[i
]->flags
|= BB_DUPLICATED
;
777 for (i
= 0; i
< n_region
; i
++)
778 for (dom
= first_dom_son (dir
, region
[i
]);
780 dom
= next_dom_son (dir
, dom
))
781 if (!(dom
->flags
& BB_DUPLICATED
))
782 VEC_safe_push (basic_block
, heap
, doms
, dom
);
783 for (i
= 0; i
< n_region
; i
++)
784 region
[i
]->flags
&= ~BB_DUPLICATED
;
789 /* Returns the list of basic blocks including BB dominated by BB, in the
790 direction DIR up to DEPTH in the dominator tree. The DEPTH of zero will
791 produce a vector containing all dominated blocks. The vector will be sorted
794 VEC (basic_block
, heap
) *
795 get_dominated_to_depth (enum cdi_direction dir
, basic_block bb
, int depth
)
797 VEC(basic_block
, heap
) *bbs
= NULL
;
799 unsigned next_level_start
;
802 VEC_safe_push (basic_block
, heap
, bbs
, bb
);
803 next_level_start
= 1; /* = VEC_length (basic_block, bbs); */
809 bb
= VEC_index (basic_block
, bbs
, i
++);
810 for (son
= first_dom_son (dir
, bb
);
812 son
= next_dom_son (dir
, son
))
813 VEC_safe_push (basic_block
, heap
, bbs
, son
);
815 if (i
== next_level_start
&& --depth
)
816 next_level_start
= VEC_length (basic_block
, bbs
);
818 while (i
< next_level_start
);
823 /* Returns the list of basic blocks including BB dominated by BB, in the
824 direction DIR. The vector will be sorted in preorder. */
826 VEC (basic_block
, heap
) *
827 get_all_dominated_blocks (enum cdi_direction dir
, basic_block bb
)
829 return get_dominated_to_depth (dir
, bb
, 0);
832 /* Redirect all edges pointing to BB to TO. */
834 redirect_immediate_dominators (enum cdi_direction dir
, basic_block bb
,
837 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
838 struct et_node
*bb_node
, *to_node
, *son
;
840 bb_node
= bb
->dom
[dir_index
];
841 to_node
= to
->dom
[dir_index
];
843 gcc_checking_assert (dom_computed
[dir_index
]);
853 et_set_father (son
, to_node
);
856 if (dom_computed
[dir_index
] == DOM_OK
)
857 dom_computed
[dir_index
] = DOM_NO_FAST_QUERY
;
860 /* Find first basic block in the tree dominating both BB1 and BB2. */
862 nearest_common_dominator (enum cdi_direction dir
, basic_block bb1
, basic_block bb2
)
864 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
866 gcc_checking_assert (dom_computed
[dir_index
]);
873 return (basic_block
) et_nca (bb1
->dom
[dir_index
], bb2
->dom
[dir_index
])->data
;
877 /* Find the nearest common dominator for the basic blocks in BLOCKS,
878 using dominance direction DIR. */
881 nearest_common_dominator_for_set (enum cdi_direction dir
, bitmap blocks
)
887 first
= bitmap_first_set_bit (blocks
);
888 dom
= BASIC_BLOCK (first
);
889 EXECUTE_IF_SET_IN_BITMAP (blocks
, 0, i
, bi
)
890 if (dom
!= BASIC_BLOCK (i
))
891 dom
= nearest_common_dominator (dir
, dom
, BASIC_BLOCK (i
));
896 /* Given a dominator tree, we can determine whether one thing
897 dominates another in constant time by using two DFS numbers:
899 1. The number for when we visit a node on the way down the tree
900 2. The number for when we visit a node on the way back up the tree
902 You can view these as bounds for the range of dfs numbers the
903 nodes in the subtree of the dominator tree rooted at that node
906 The dominator tree is always a simple acyclic tree, so there are
907 only three possible relations two nodes in the dominator tree have
910 1. Node A is above Node B (and thus, Node A dominates node B)
919 In the above case, DFS_Number_In of A will be <= DFS_Number_In of
920 B, and DFS_Number_Out of A will be >= DFS_Number_Out of B. This is
921 because we must hit A in the dominator tree *before* B on the walk
922 down, and we will hit A *after* B on the walk back up
924 2. Node A is below node B (and thus, node B dominates node A)
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.
936 This is because we must hit A in the dominator tree *after* B on
937 the walk down, and we will hit A *before* B on the walk back up
939 3. Node A and B are siblings (and thus, neither dominates the other)
947 In the above case, DFS_Number_In of A will *always* be <=
948 DFS_Number_In of B, and DFS_Number_Out of A will *always* be <=
949 DFS_Number_Out of B. This is because we will always finish the dfs
950 walk of one of the subtrees before the other, and thus, the dfs
951 numbers for one subtree can't intersect with the range of dfs
952 numbers for the other subtree. If you swap A and B's position in
953 the dominator tree, the comparison changes direction, but the point
954 is that both comparisons will always go the same way if there is no
955 dominance relationship.
957 Thus, it is sufficient to write
959 A_Dominates_B (node A, node B)
961 return DFS_Number_In(A) <= DFS_Number_In(B)
962 && DFS_Number_Out (A) >= DFS_Number_Out(B);
965 A_Dominated_by_B (node A, node B)
967 return DFS_Number_In(A) >= DFS_Number_In(A)
968 && DFS_Number_Out (A) <= DFS_Number_Out(B);
971 /* Return TRUE in case BB1 is dominated by BB2. */
973 dominated_by_p (enum cdi_direction dir
, const_basic_block bb1
, const_basic_block bb2
)
975 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
976 struct et_node
*n1
= bb1
->dom
[dir_index
], *n2
= bb2
->dom
[dir_index
];
978 gcc_checking_assert (dom_computed
[dir_index
]);
980 if (dom_computed
[dir_index
] == DOM_OK
)
981 return (n1
->dfs_num_in
>= n2
->dfs_num_in
982 && n1
->dfs_num_out
<= n2
->dfs_num_out
);
984 return et_below (n1
, n2
);
987 /* Returns the entry dfs number for basic block BB, in the direction DIR. */
990 bb_dom_dfs_in (enum cdi_direction dir
, basic_block bb
)
992 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
993 struct et_node
*n
= bb
->dom
[dir_index
];
995 gcc_checking_assert (dom_computed
[dir_index
] == DOM_OK
);
996 return n
->dfs_num_in
;
999 /* Returns the exit dfs number for basic block BB, in the direction DIR. */
1002 bb_dom_dfs_out (enum cdi_direction dir
, basic_block bb
)
1004 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
1005 struct et_node
*n
= bb
->dom
[dir_index
];
1007 gcc_checking_assert (dom_computed
[dir_index
] == DOM_OK
);
1008 return n
->dfs_num_out
;
1011 /* Verify invariants of dominator structure. */
1013 verify_dominators (enum cdi_direction dir
)
1016 basic_block bb
, imm_bb
, imm_bb_correct
;
1018 bool reverse
= (dir
== CDI_POST_DOMINATORS
) ? true : false;
1020 gcc_assert (dom_info_available_p (dir
));
1022 init_dom_info (&di
, dir
);
1023 calc_dfs_tree (&di
, reverse
);
1024 calc_idoms (&di
, reverse
);
1028 imm_bb
= get_immediate_dominator (dir
, bb
);
1031 error ("dominator of %d status unknown", bb
->index
);
1035 imm_bb_correct
= di
.dfs_to_bb
[di
.dom
[di
.dfs_order
[bb
->index
]]];
1036 if (imm_bb
!= imm_bb_correct
)
1038 error ("dominator of %d should be %d, not %d",
1039 bb
->index
, imm_bb_correct
->index
, imm_bb
->index
);
1044 free_dom_info (&di
);
1048 /* Determine immediate dominator (or postdominator, according to DIR) of BB,
1049 assuming that dominators of other blocks are correct. We also use it to
1050 recompute the dominators in a restricted area, by iterating it until it
1051 reaches a fixed point. */
1054 recompute_dominator (enum cdi_direction dir
, basic_block bb
)
1056 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
1057 basic_block dom_bb
= NULL
;
1061 gcc_checking_assert (dom_computed
[dir_index
]);
1063 if (dir
== CDI_DOMINATORS
)
1065 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
1067 if (!dominated_by_p (dir
, e
->src
, bb
))
1068 dom_bb
= nearest_common_dominator (dir
, dom_bb
, e
->src
);
1073 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
1075 if (!dominated_by_p (dir
, e
->dest
, bb
))
1076 dom_bb
= nearest_common_dominator (dir
, dom_bb
, e
->dest
);
1083 /* Use simple heuristics (see iterate_fix_dominators) to determine dominators
1084 of BBS. We assume that all the immediate dominators except for those of the
1085 blocks in BBS are correct. If CONSERVATIVE is true, we also assume that the
1086 currently recorded immediate dominators of blocks in BBS really dominate the
1087 blocks. The basic blocks for that we determine the dominator are removed
1091 prune_bbs_to_update_dominators (VEC (basic_block
, heap
) *bbs
,
1096 basic_block bb
, dom
= NULL
;
1100 for (i
= 0; VEC_iterate (basic_block
, bbs
, i
, bb
);)
1102 if (bb
== ENTRY_BLOCK_PTR
)
1105 if (single_pred_p (bb
))
1107 set_immediate_dominator (CDI_DOMINATORS
, bb
, single_pred (bb
));
1116 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
1118 if (dominated_by_p (CDI_DOMINATORS
, e
->src
, bb
))
1126 dom
= nearest_common_dominator (CDI_DOMINATORS
, dom
, e
->src
);
1130 gcc_assert (dom
!= NULL
);
1132 || find_edge (dom
, bb
))
1134 set_immediate_dominator (CDI_DOMINATORS
, bb
, dom
);
1143 VEC_unordered_remove (basic_block
, bbs
, i
);
1147 /* Returns root of the dominance tree in the direction DIR that contains
1151 root_of_dom_tree (enum cdi_direction dir
, basic_block bb
)
1153 return (basic_block
) et_root (bb
->dom
[dom_convert_dir_to_idx (dir
)])->data
;
1156 /* See the comment in iterate_fix_dominators. Finds the immediate dominators
1157 for the sons of Y, found using the SON and BROTHER arrays representing
1158 the dominance tree of graph G. BBS maps the vertices of G to the basic
1162 determine_dominators_for_sons (struct graph
*g
, VEC (basic_block
, heap
) *bbs
,
1163 int y
, int *son
, int *brother
)
1167 VEC (int, heap
) **sccs
;
1168 basic_block bb
, dom
, ybb
;
1175 if (y
== (int) VEC_length (basic_block
, bbs
))
1176 ybb
= ENTRY_BLOCK_PTR
;
1178 ybb
= VEC_index (basic_block
, bbs
, y
);
1180 if (brother
[son
[y
]] == -1)
1182 /* Handle the common case Y has just one son specially. */
1183 bb
= VEC_index (basic_block
, bbs
, son
[y
]);
1184 set_immediate_dominator (CDI_DOMINATORS
, bb
,
1185 recompute_dominator (CDI_DOMINATORS
, bb
));
1186 identify_vertices (g
, y
, son
[y
]);
1190 gprime
= BITMAP_ALLOC (NULL
);
1191 for (a
= son
[y
]; a
!= -1; a
= brother
[a
])
1192 bitmap_set_bit (gprime
, a
);
1194 nc
= graphds_scc (g
, gprime
);
1195 BITMAP_FREE (gprime
);
1197 sccs
= XCNEWVEC (VEC (int, heap
) *, nc
);
1198 for (a
= son
[y
]; a
!= -1; a
= brother
[a
])
1199 VEC_safe_push (int, heap
, sccs
[g
->vertices
[a
].component
], a
);
1201 for (i
= nc
- 1; i
>= 0; i
--)
1204 FOR_EACH_VEC_ELT (int, sccs
[i
], si
, a
)
1206 bb
= VEC_index (basic_block
, bbs
, a
);
1207 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
1209 if (root_of_dom_tree (CDI_DOMINATORS
, e
->src
) != ybb
)
1212 dom
= nearest_common_dominator (CDI_DOMINATORS
, dom
, e
->src
);
1216 gcc_assert (dom
!= NULL
);
1217 FOR_EACH_VEC_ELT (int, sccs
[i
], si
, a
)
1219 bb
= VEC_index (basic_block
, bbs
, a
);
1220 set_immediate_dominator (CDI_DOMINATORS
, bb
, dom
);
1224 for (i
= 0; i
< nc
; i
++)
1225 VEC_free (int, heap
, sccs
[i
]);
1228 for (a
= son
[y
]; a
!= -1; a
= brother
[a
])
1229 identify_vertices (g
, y
, a
);
1232 /* Recompute dominance information for basic blocks in the set BBS. The
1233 function assumes that the immediate dominators of all the other blocks
1234 in CFG are correct, and that there are no unreachable blocks.
1236 If CONSERVATIVE is true, we additionally assume that all the ancestors of
1237 a block of BBS in the current dominance tree dominate it. */
1240 iterate_fix_dominators (enum cdi_direction dir
, VEC (basic_block
, heap
) *bbs
,
1244 basic_block bb
, dom
;
1250 struct pointer_map_t
*map
;
1251 int *parent
, *son
, *brother
;
1252 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
1254 /* We only support updating dominators. There are some problems with
1255 updating postdominators (need to add fake edges from infinite loops
1256 and noreturn functions), and since we do not currently use
1257 iterate_fix_dominators for postdominators, any attempt to handle these
1258 problems would be unused, untested, and almost surely buggy. We keep
1259 the DIR argument for consistency with the rest of the dominator analysis
1261 gcc_checking_assert (dir
== CDI_DOMINATORS
&& dom_computed
[dir_index
]);
1263 /* The algorithm we use takes inspiration from the following papers, although
1264 the details are quite different from any of them:
1266 [1] G. Ramalingam, T. Reps, An Incremental Algorithm for Maintaining the
1267 Dominator Tree of a Reducible Flowgraph
1268 [2] V. C. Sreedhar, G. R. Gao, Y.-F. Lee: Incremental computation of
1270 [3] K. D. Cooper, T. J. Harvey and K. Kennedy: A Simple, Fast Dominance
1273 First, we use the following heuristics to decrease the size of the BBS
1275 a) if BB has a single predecessor, then its immediate dominator is this
1277 additionally, if CONSERVATIVE is true:
1278 b) if all the predecessors of BB except for one (X) are dominated by BB,
1279 then X is the immediate dominator of BB
1280 c) if the nearest common ancestor of the predecessors of BB is X and
1281 X -> BB is an edge in CFG, then X is the immediate dominator of BB
1283 Then, we need to establish the dominance relation among the basic blocks
1284 in BBS. We split the dominance tree by removing the immediate dominator
1285 edges from BBS, creating a forest F. We form a graph G whose vertices
1286 are BBS and ENTRY and X -> Y is an edge of G if there exists an edge
1287 X' -> Y in CFG such that X' belongs to the tree of the dominance forest
1288 whose root is X. We then determine dominance tree of G. Note that
1289 for X, Y in BBS, X dominates Y in CFG if and only if X dominates Y in G.
1290 In this step, we can use arbitrary algorithm to determine dominators.
1291 We decided to prefer the algorithm [3] to the algorithm of
1292 Lengauer and Tarjan, since the set BBS is usually small (rarely exceeding
1293 10 during gcc bootstrap), and [3] should perform better in this case.
1295 Finally, we need to determine the immediate dominators for the basic
1296 blocks of BBS. If the immediate dominator of X in G is Y, then
1297 the immediate dominator of X in CFG belongs to the tree of F rooted in
1298 Y. We process the dominator tree T of G recursively, starting from leaves.
1299 Suppose that X_1, X_2, ..., X_k are the sons of Y in T, and that the
1300 subtrees of the dominance tree of CFG rooted in X_i are already correct.
1301 Let G' be the subgraph of G induced by {X_1, X_2, ..., X_k}. We make
1302 the following observations:
1303 (i) the immediate dominator of all blocks in a strongly connected
1304 component of G' is the same
1305 (ii) if X has no predecessors in G', then the immediate dominator of X
1306 is the nearest common ancestor of the predecessors of X in the
1307 subtree of F rooted in Y
1308 Therefore, it suffices to find the topological ordering of G', and
1309 process the nodes X_i in this order using the rules (i) and (ii).
1310 Then, we contract all the nodes X_i with Y in G, so that the further
1311 steps work correctly. */
1315 /* Split the tree now. If the idoms of blocks in BBS are not
1316 conservatively correct, setting the dominators using the
1317 heuristics in prune_bbs_to_update_dominators could
1318 create cycles in the dominance "tree", and cause ICE. */
1319 FOR_EACH_VEC_ELT (basic_block
, bbs
, i
, bb
)
1320 set_immediate_dominator (CDI_DOMINATORS
, bb
, NULL
);
1323 prune_bbs_to_update_dominators (bbs
, conservative
);
1324 n
= VEC_length (basic_block
, bbs
);
1331 bb
= VEC_index (basic_block
, bbs
, 0);
1332 set_immediate_dominator (CDI_DOMINATORS
, bb
,
1333 recompute_dominator (CDI_DOMINATORS
, bb
));
1337 /* Construct the graph G. */
1338 map
= pointer_map_create ();
1339 FOR_EACH_VEC_ELT (basic_block
, bbs
, i
, bb
)
1341 /* If the dominance tree is conservatively correct, split it now. */
1343 set_immediate_dominator (CDI_DOMINATORS
, bb
, NULL
);
1344 *pointer_map_insert (map
, bb
) = (void *) (size_t) i
;
1346 *pointer_map_insert (map
, ENTRY_BLOCK_PTR
) = (void *) (size_t) n
;
1348 g
= new_graph (n
+ 1);
1349 for (y
= 0; y
< g
->n_vertices
; y
++)
1350 g
->vertices
[y
].data
= BITMAP_ALLOC (NULL
);
1351 FOR_EACH_VEC_ELT (basic_block
, bbs
, i
, bb
)
1353 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
1355 dom
= root_of_dom_tree (CDI_DOMINATORS
, e
->src
);
1359 dom_i
= (size_t) *pointer_map_contains (map
, dom
);
1361 /* Do not include parallel edges to G. */
1362 if (!bitmap_set_bit ((bitmap
) g
->vertices
[dom_i
].data
, i
))
1365 add_edge (g
, dom_i
, i
);
1368 for (y
= 0; y
< g
->n_vertices
; y
++)
1369 BITMAP_FREE (g
->vertices
[y
].data
);
1370 pointer_map_destroy (map
);
1372 /* Find the dominator tree of G. */
1373 son
= XNEWVEC (int, n
+ 1);
1374 brother
= XNEWVEC (int, n
+ 1);
1375 parent
= XNEWVEC (int, n
+ 1);
1376 graphds_domtree (g
, n
, parent
, son
, brother
);
1378 /* Finally, traverse the tree and find the immediate dominators. */
1379 for (y
= n
; son
[y
] != -1; y
= son
[y
])
1383 determine_dominators_for_sons (g
, bbs
, y
, son
, brother
);
1385 if (brother
[y
] != -1)
1388 while (son
[y
] != -1)
1403 add_to_dominance_info (enum cdi_direction dir
, basic_block bb
)
1405 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
1407 gcc_checking_assert (dom_computed
[dir_index
] && !bb
->dom
[dir_index
]);
1409 n_bbs_in_dom_tree
[dir_index
]++;
1411 bb
->dom
[dir_index
] = et_new_tree (bb
);
1413 if (dom_computed
[dir_index
] == DOM_OK
)
1414 dom_computed
[dir_index
] = DOM_NO_FAST_QUERY
;
1418 delete_from_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
]);
1424 et_free_tree (bb
->dom
[dir_index
]);
1425 bb
->dom
[dir_index
] = NULL
;
1426 n_bbs_in_dom_tree
[dir_index
]--;
1428 if (dom_computed
[dir_index
] == DOM_OK
)
1429 dom_computed
[dir_index
] = DOM_NO_FAST_QUERY
;
1432 /* Returns the first son of BB in the dominator or postdominator tree
1433 as determined by DIR. */
1436 first_dom_son (enum cdi_direction dir
, basic_block bb
)
1438 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
1439 struct et_node
*son
= bb
->dom
[dir_index
]->son
;
1441 return (basic_block
) (son
? son
->data
: NULL
);
1444 /* Returns the next dominance son after BB in the dominator or postdominator
1445 tree as determined by DIR, or NULL if it was the last one. */
1448 next_dom_son (enum cdi_direction dir
, basic_block bb
)
1450 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
1451 struct et_node
*next
= bb
->dom
[dir_index
]->right
;
1453 return (basic_block
) (next
->father
->son
== next
? NULL
: next
->data
);
1456 /* Return dominance availability for dominance info DIR. */
1459 dom_info_state (enum cdi_direction dir
)
1461 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
1463 return dom_computed
[dir_index
];
1466 /* Set the dominance availability for dominance info DIR to NEW_STATE. */
1469 set_dom_info_availability (enum cdi_direction dir
, enum dom_state new_state
)
1471 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
1473 dom_computed
[dir_index
] = new_state
;
1476 /* Returns true if dominance information for direction DIR is available. */
1479 dom_info_available_p (enum cdi_direction dir
)
1481 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
1483 return dom_computed
[dir_index
] != DOM_NONE
;
1487 debug_dominance_info (enum cdi_direction dir
)
1489 basic_block bb
, bb2
;
1491 if ((bb2
= get_immediate_dominator (dir
, bb
)))
1492 fprintf (stderr
, "%i %i\n", bb
->index
, bb2
->index
);
1495 /* Prints to stderr representation of the dominance tree (for direction DIR)
1496 rooted in ROOT, indented by INDENT tabulators. If INDENT_FIRST is false,
1497 the first line of the output is not indented. */
1500 debug_dominance_tree_1 (enum cdi_direction dir
, basic_block root
,
1501 unsigned indent
, bool indent_first
)
1508 for (i
= 0; i
< indent
; i
++)
1509 fprintf (stderr
, "\t");
1510 fprintf (stderr
, "%d\t", root
->index
);
1512 for (son
= first_dom_son (dir
, root
);
1514 son
= next_dom_son (dir
, son
))
1516 debug_dominance_tree_1 (dir
, son
, indent
+ 1, !first
);
1521 fprintf (stderr
, "\n");
1524 /* Prints to stderr representation of the dominance tree (for direction DIR)
1528 debug_dominance_tree (enum cdi_direction dir
, basic_block root
)
1530 debug_dominance_tree_1 (dir
, root
, 0, false);