1 /* Calculate (post)dominators in slightly super-linear time.
2 Copyright (C) 2000, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
3 Contributed by Michael Matz (matz@ifh.de).
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, 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 COPYING. If not, write to the Free
19 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
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"
45 #include "et-forest.h"
48 #include "pointer-set.h"
51 /* Whether the dominators and the postdominators are available. */
52 static enum dom_state dom_computed
[2];
54 /* We name our nodes with integers, beginning with 1. Zero is reserved for
55 'undefined' or 'end of list'. The name of each node is given by the dfs
56 number of the corresponding basic block. Please note, that we include the
57 artificial ENTRY_BLOCK (or EXIT_BLOCK in the post-dom case) in our lists to
58 support multiple entry points. Its dfs number is of course 1. */
60 /* Type of Basic Block aka. TBB */
61 typedef unsigned int TBB
;
63 /* We work in a poor-mans object oriented fashion, and carry an instance of
64 this structure through all our 'methods'. It holds various arrays
65 reflecting the (sub)structure of the flowgraph. Most of them are of type
66 TBB and are also indexed by TBB. */
70 /* The parent of a node in the DFS tree. */
72 /* For a node x key[x] is roughly the node nearest to the root from which
73 exists a way to x only over nodes behind x. Such a node is also called
76 /* The value in path_min[x] is the node y on the path from x to the root of
77 the tree x is in with the smallest key[y]. */
79 /* bucket[x] points to the first node of the set of nodes having x as key. */
81 /* And next_bucket[x] points to the next node. */
83 /* After the algorithm is done, dom[x] contains the immediate dominator
87 /* The following few fields implement the structures needed for disjoint
89 /* set_chain[x] is the next node on the path from x to the representant
90 of the set containing x. If set_chain[x]==0 then x is a root. */
92 /* set_size[x] is the number of elements in the set named by x. */
93 unsigned int *set_size
;
94 /* set_child[x] is used for balancing the tree representing a set. It can
95 be understood as the next sibling of x. */
98 /* If b is the number of a basic block (BB->index), dfs_order[b] is the
99 number of that node in DFS order counted from 1. This is an index
100 into most of the other arrays in this structure. */
102 /* If x is the DFS-index of a node which corresponds with a basic block,
103 dfs_to_bb[x] is that basic block. Note, that in our structure there are
104 more nodes that basic blocks, so only dfs_to_bb[dfs_order[bb->index]]==bb
105 is true for every basic block bb, but not the opposite. */
106 basic_block
*dfs_to_bb
;
108 /* This is the next free DFS number when creating the DFS tree. */
110 /* The number of nodes in the DFS tree (==dfsnum-1). */
113 /* Blocks with bits set here have a fake edge to EXIT. These are used
114 to turn a DFS forest into a proper tree. */
115 bitmap fake_exit_edge
;
118 static void init_dom_info (struct dom_info
*, enum cdi_direction
);
119 static void free_dom_info (struct dom_info
*);
120 static void calc_dfs_tree_nonrec (struct dom_info
*, basic_block
, bool);
121 static void calc_dfs_tree (struct dom_info
*, bool);
122 static void compress (struct dom_info
*, TBB
);
123 static TBB
eval (struct dom_info
*, TBB
);
124 static void link_roots (struct dom_info
*, TBB
, TBB
);
125 static void calc_idoms (struct dom_info
*, bool);
126 void debug_dominance_info (enum cdi_direction
);
127 void debug_dominance_tree (enum cdi_direction
, basic_block
);
129 /* Keeps track of the*/
130 static unsigned n_bbs_in_dom_tree
[2];
132 /* Helper macro for allocating and initializing an array,
133 for aesthetic reasons. */
134 #define init_ar(var, type, num, content) \
137 unsigned int i = 1; /* Catch content == i. */ \
139 (var) = XCNEWVEC (type, num); \
142 (var) = XNEWVEC (type, (num)); \
143 for (i = 0; i < num; i++) \
144 (var)[i] = (content); \
149 /* Allocate all needed memory in a pessimistic fashion (so we round up).
150 This initializes the contents of DI, which already must be allocated. */
153 init_dom_info (struct dom_info
*di
, enum cdi_direction dir
)
155 /* We need memory for n_basic_blocks nodes. */
156 unsigned int num
= n_basic_blocks
;
157 init_ar (di
->dfs_parent
, TBB
, num
, 0);
158 init_ar (di
->path_min
, TBB
, num
, i
);
159 init_ar (di
->key
, TBB
, num
, i
);
160 init_ar (di
->dom
, TBB
, num
, 0);
162 init_ar (di
->bucket
, TBB
, num
, 0);
163 init_ar (di
->next_bucket
, TBB
, num
, 0);
165 init_ar (di
->set_chain
, TBB
, num
, 0);
166 init_ar (di
->set_size
, unsigned int, num
, 1);
167 init_ar (di
->set_child
, TBB
, num
, 0);
169 init_ar (di
->dfs_order
, TBB
, (unsigned int) last_basic_block
+ 1, 0);
170 init_ar (di
->dfs_to_bb
, basic_block
, num
, 0);
178 di
->fake_exit_edge
= NULL
;
180 case CDI_POST_DOMINATORS
:
181 di
->fake_exit_edge
= BITMAP_ALLOC (NULL
);
191 /* Map dominance calculation type to array index used for various
192 dominance information arrays. This version is simple -- it will need
193 to be modified, obviously, if additional values are added to
197 dom_convert_dir_to_idx (enum cdi_direction dir
)
199 gcc_assert (dir
== CDI_DOMINATORS
|| dir
== CDI_POST_DOMINATORS
);
203 /* Free all allocated memory in DI, but not DI itself. */
206 free_dom_info (struct dom_info
*di
)
208 free (di
->dfs_parent
);
213 free (di
->next_bucket
);
214 free (di
->set_chain
);
216 free (di
->set_child
);
217 free (di
->dfs_order
);
218 free (di
->dfs_to_bb
);
219 BITMAP_FREE (di
->fake_exit_edge
);
222 /* The nonrecursive variant of creating a DFS tree. DI is our working
223 structure, BB the starting basic block for this tree and REVERSE
224 is true, if predecessors should be visited instead of successors of a
225 node. After this is done all nodes reachable from BB were visited, have
226 assigned their dfs number and are linked together to form a tree. */
229 calc_dfs_tree_nonrec (struct dom_info
*di
, basic_block bb
, bool reverse
)
231 /* We call this _only_ if bb is not already visited. */
233 TBB child_i
, my_i
= 0;
234 edge_iterator
*stack
;
235 edge_iterator ei
, einext
;
237 /* Start block (ENTRY_BLOCK_PTR for forward problem, EXIT_BLOCK for backward
239 basic_block en_block
;
241 basic_block ex_block
;
243 stack
= XNEWVEC (edge_iterator
, n_basic_blocks
+ 1);
246 /* Initialize our border blocks, and the first edge. */
249 ei
= ei_start (bb
->preds
);
250 en_block
= EXIT_BLOCK_PTR
;
251 ex_block
= ENTRY_BLOCK_PTR
;
255 ei
= ei_start (bb
->succs
);
256 en_block
= ENTRY_BLOCK_PTR
;
257 ex_block
= EXIT_BLOCK_PTR
;
260 /* When the stack is empty we break out of this loop. */
265 /* This loop traverses edges e in depth first manner, and fills the
267 while (!ei_end_p (ei
))
271 /* Deduce from E the current and the next block (BB and BN), and the
277 /* If the next node BN is either already visited or a border
278 block the current edge is useless, and simply overwritten
279 with the next edge out of the current node. */
280 if (bn
== ex_block
|| di
->dfs_order
[bn
->index
])
286 einext
= ei_start (bn
->preds
);
291 if (bn
== ex_block
|| di
->dfs_order
[bn
->index
])
297 einext
= ei_start (bn
->succs
);
300 gcc_assert (bn
!= en_block
);
302 /* Fill the DFS tree info calculatable _before_ recursing. */
304 my_i
= di
->dfs_order
[bb
->index
];
306 my_i
= di
->dfs_order
[last_basic_block
];
307 child_i
= di
->dfs_order
[bn
->index
] = di
->dfsnum
++;
308 di
->dfs_to_bb
[child_i
] = bn
;
309 di
->dfs_parent
[child_i
] = my_i
;
311 /* Save the current point in the CFG on the stack, and recurse. */
320 /* OK. The edge-list was exhausted, meaning normally we would
321 end the recursion. After returning from the recursive call,
322 there were (may be) other statements which were run after a
323 child node was completely considered by DFS. Here is the
324 point to do it in the non-recursive variant.
325 E.g. The block just completed is in e->dest for forward DFS,
326 the block not yet completed (the parent of the one above)
327 in e->src. This could be used e.g. for computing the number of
328 descendants or the tree depth. */
334 /* The main entry for calculating the DFS tree or forest. DI is our working
335 structure and REVERSE is true, if we are interested in the reverse flow
336 graph. In that case the result is not necessarily a tree but a forest,
337 because there may be nodes from which the EXIT_BLOCK is unreachable. */
340 calc_dfs_tree (struct dom_info
*di
, bool reverse
)
342 /* The first block is the ENTRY_BLOCK (or EXIT_BLOCK if REVERSE). */
343 basic_block begin
= reverse
? EXIT_BLOCK_PTR
: ENTRY_BLOCK_PTR
;
344 di
->dfs_order
[last_basic_block
] = 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 (b
)
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
] = di
->dfs_order
[last_basic_block
];
378 calc_dfs_tree_nonrec (di
, b
, reverse
);
383 FOR_EACH_BB_REVERSE (b
)
385 if (di
->dfs_order
[b
->index
])
387 bitmap_set_bit (di
->fake_exit_edge
, b
->index
);
388 di
->dfs_order
[b
->index
] = di
->dfsnum
;
389 di
->dfs_to_bb
[di
->dfsnum
] = b
;
390 di
->dfs_parent
[di
->dfsnum
] = di
->dfs_order
[last_basic_block
];
392 calc_dfs_tree_nonrec (di
, b
, reverse
);
397 di
->nodes
= di
->dfsnum
- 1;
399 /* This aborts e.g. when there is _no_ path from ENTRY to EXIT at all. */
400 gcc_assert (di
->nodes
== (unsigned int) n_basic_blocks
- 1);
403 /* Compress the path from V to the root of its set and update path_min at the
404 same time. After compress(di, V) set_chain[V] is the root of the set V is
405 in and path_min[V] is the node with the smallest key[] value on the path
406 from V to that root. */
409 compress (struct dom_info
*di
, TBB v
)
411 /* Btw. It's not worth to unrecurse compress() as the depth is usually not
412 greater than 5 even for huge graphs (I've not seen call depth > 4).
413 Also performance wise compress() ranges _far_ behind eval(). */
414 TBB parent
= di
->set_chain
[v
];
415 if (di
->set_chain
[parent
])
417 compress (di
, parent
);
418 if (di
->key
[di
->path_min
[parent
]] < di
->key
[di
->path_min
[v
]])
419 di
->path_min
[v
] = di
->path_min
[parent
];
420 di
->set_chain
[v
] = di
->set_chain
[parent
];
424 /* Compress the path from V to the set root of V if needed (when the root has
425 changed since the last call). Returns the node with the smallest key[]
426 value on the path from V to the root. */
429 eval (struct dom_info
*di
, TBB v
)
431 /* The representant of the set V is in, also called root (as the set
432 representation is a tree). */
433 TBB rep
= di
->set_chain
[v
];
435 /* V itself is the root. */
437 return di
->path_min
[v
];
439 /* Compress only if necessary. */
440 if (di
->set_chain
[rep
])
443 rep
= di
->set_chain
[v
];
446 if (di
->key
[di
->path_min
[rep
]] >= di
->key
[di
->path_min
[v
]])
447 return di
->path_min
[v
];
449 return di
->path_min
[rep
];
452 /* This essentially merges the two sets of V and W, giving a single set with
453 the new root V. The internal representation of these disjoint sets is a
454 balanced tree. Currently link(V,W) is only used with V being the parent
458 link_roots (struct dom_info
*di
, TBB v
, TBB w
)
462 /* Rebalance the tree. */
463 while (di
->key
[di
->path_min
[w
]] < di
->key
[di
->path_min
[di
->set_child
[s
]]])
465 if (di
->set_size
[s
] + di
->set_size
[di
->set_child
[di
->set_child
[s
]]]
466 >= 2 * di
->set_size
[di
->set_child
[s
]])
468 di
->set_chain
[di
->set_child
[s
]] = s
;
469 di
->set_child
[s
] = di
->set_child
[di
->set_child
[s
]];
473 di
->set_size
[di
->set_child
[s
]] = di
->set_size
[s
];
474 s
= di
->set_chain
[s
] = di
->set_child
[s
];
478 di
->path_min
[s
] = di
->path_min
[w
];
479 di
->set_size
[v
] += di
->set_size
[w
];
480 if (di
->set_size
[v
] < 2 * di
->set_size
[w
])
483 s
= di
->set_child
[v
];
484 di
->set_child
[v
] = tmp
;
487 /* Merge all subtrees. */
490 di
->set_chain
[s
] = v
;
491 s
= di
->set_child
[s
];
495 /* This calculates the immediate dominators (or post-dominators if REVERSE is
496 true). DI is our working structure and should hold the DFS forest.
497 On return the immediate dominator to node V is in di->dom[V]. */
500 calc_idoms (struct dom_info
*di
, bool reverse
)
503 basic_block en_block
;
504 edge_iterator ei
, einext
;
507 en_block
= EXIT_BLOCK_PTR
;
509 en_block
= ENTRY_BLOCK_PTR
;
511 /* Go backwards in DFS order, to first look at the leafs. */
515 basic_block bb
= di
->dfs_to_bb
[v
];
518 par
= di
->dfs_parent
[v
];
521 ei
= (reverse
) ? ei_start (bb
->succs
) : ei_start (bb
->preds
);
525 /* If this block has a fake edge to exit, process that first. */
526 if (bitmap_bit_p (di
->fake_exit_edge
, bb
->index
))
530 goto do_fake_exit_edge
;
534 /* Search all direct predecessors for the smallest node with a path
535 to them. That way we have the smallest node with also a path to
536 us only over nodes behind us. In effect we search for our
538 while (!ei_end_p (ei
))
544 b
= (reverse
) ? e
->dest
: e
->src
;
551 k1
= di
->dfs_order
[last_basic_block
];
554 k1
= di
->dfs_order
[b
->index
];
556 /* Call eval() only if really needed. If k1 is above V in DFS tree,
557 then we know, that eval(k1) == k1 and key[k1] == k1. */
559 k1
= di
->key
[eval (di
, k1
)];
567 link_roots (di
, par
, v
);
568 di
->next_bucket
[v
] = di
->bucket
[k
];
571 /* Transform semidominators into dominators. */
572 for (w
= di
->bucket
[par
]; w
; w
= di
->next_bucket
[w
])
575 if (di
->key
[k
] < di
->key
[w
])
580 /* We don't need to cleanup next_bucket[]. */
585 /* Explicitly define the dominators. */
587 for (v
= 2; v
<= di
->nodes
; v
++)
588 if (di
->dom
[v
] != di
->key
[v
])
589 di
->dom
[v
] = di
->dom
[di
->dom
[v
]];
592 /* Assign dfs numbers starting from NUM to NODE and its sons. */
595 assign_dfs_numbers (struct et_node
*node
, int *num
)
599 node
->dfs_num_in
= (*num
)++;
603 assign_dfs_numbers (node
->son
, num
);
604 for (son
= node
->son
->right
; son
!= node
->son
; son
= son
->right
)
605 assign_dfs_numbers (son
, num
);
608 node
->dfs_num_out
= (*num
)++;
611 /* Compute the data necessary for fast resolving of dominator queries in a
612 static dominator tree. */
615 compute_dom_fast_query (enum cdi_direction dir
)
619 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
621 gcc_assert (dom_info_available_p (dir
));
623 if (dom_computed
[dir_index
] == DOM_OK
)
628 if (!bb
->dom
[dir_index
]->father
)
629 assign_dfs_numbers (bb
->dom
[dir_index
], &num
);
632 dom_computed
[dir_index
] = DOM_OK
;
635 /* The main entry point into this module. DIR is set depending on whether
636 we want to compute dominators or postdominators. */
639 calculate_dominance_info (enum cdi_direction dir
)
643 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
644 bool reverse
= (dir
== CDI_POST_DOMINATORS
) ? true : false;
646 if (dom_computed
[dir_index
] == DOM_OK
)
649 timevar_push (TV_DOMINANCE
);
650 if (!dom_info_available_p (dir
))
652 gcc_assert (!n_bbs_in_dom_tree
[dir_index
]);
656 b
->dom
[dir_index
] = et_new_tree (b
);
658 n_bbs_in_dom_tree
[dir_index
] = n_basic_blocks
;
660 init_dom_info (&di
, dir
);
661 calc_dfs_tree (&di
, reverse
);
662 calc_idoms (&di
, reverse
);
666 TBB d
= di
.dom
[di
.dfs_order
[b
->index
]];
669 et_set_father (b
->dom
[dir_index
], di
.dfs_to_bb
[d
]->dom
[dir_index
]);
673 dom_computed
[dir_index
] = DOM_NO_FAST_QUERY
;
676 compute_dom_fast_query (dir
);
678 timevar_pop (TV_DOMINANCE
);
681 /* Free dominance information for direction DIR. */
683 free_dominance_info (enum cdi_direction dir
)
686 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
688 if (!dom_info_available_p (dir
))
693 et_free_tree_force (bb
->dom
[dir_index
]);
694 bb
->dom
[dir_index
] = NULL
;
698 n_bbs_in_dom_tree
[dir_index
] = 0;
700 dom_computed
[dir_index
] = DOM_NONE
;
703 /* Return the immediate dominator of basic block BB. */
705 get_immediate_dominator (enum cdi_direction dir
, basic_block bb
)
707 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
708 struct et_node
*node
= bb
->dom
[dir_index
];
710 gcc_assert (dom_computed
[dir_index
]);
715 return node
->father
->data
;
718 /* Set the immediate dominator of the block possibly removing
719 existing edge. NULL can be used to remove any edge. */
721 set_immediate_dominator (enum cdi_direction dir
, basic_block bb
,
722 basic_block dominated_by
)
724 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
725 struct et_node
*node
= bb
->dom
[dir_index
];
727 gcc_assert (dom_computed
[dir_index
]);
731 if (node
->father
->data
== dominated_by
)
737 et_set_father (node
, dominated_by
->dom
[dir_index
]);
739 if (dom_computed
[dir_index
] == DOM_OK
)
740 dom_computed
[dir_index
] = DOM_NO_FAST_QUERY
;
743 /* Returns the list of basic blocks immediately dominated by BB, in the
745 VEC (basic_block
, heap
) *
746 get_dominated_by (enum cdi_direction dir
, basic_block bb
)
749 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
750 struct et_node
*node
= bb
->dom
[dir_index
], *son
= node
->son
, *ason
;
751 VEC (basic_block
, heap
) *bbs
= NULL
;
753 gcc_assert (dom_computed
[dir_index
]);
758 VEC_safe_push (basic_block
, heap
, bbs
, son
->data
);
759 for (ason
= son
->right
, n
= 1; ason
!= son
; ason
= ason
->right
)
760 VEC_safe_push (basic_block
, heap
, bbs
, ason
->data
);
765 /* Returns the list of basic blocks that are immediately dominated (in
766 direction DIR) by some block between N_REGION ones stored in REGION,
767 except for blocks in the REGION itself. */
769 VEC (basic_block
, heap
) *
770 get_dominated_by_region (enum cdi_direction dir
, basic_block
*region
,
775 VEC (basic_block
, heap
) *doms
= NULL
;
777 for (i
= 0; i
< n_region
; i
++)
778 region
[i
]->flags
|= BB_DUPLICATED
;
779 for (i
= 0; i
< n_region
; i
++)
780 for (dom
= first_dom_son (dir
, region
[i
]);
782 dom
= next_dom_son (dir
, dom
))
783 if (!(dom
->flags
& BB_DUPLICATED
))
784 VEC_safe_push (basic_block
, heap
, doms
, dom
);
785 for (i
= 0; i
< n_region
; i
++)
786 region
[i
]->flags
&= ~BB_DUPLICATED
;
791 /* Redirect all edges pointing to BB to TO. */
793 redirect_immediate_dominators (enum cdi_direction dir
, basic_block bb
,
796 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
797 struct et_node
*bb_node
, *to_node
, *son
;
799 bb_node
= bb
->dom
[dir_index
];
800 to_node
= to
->dom
[dir_index
];
802 gcc_assert (dom_computed
[dir_index
]);
812 et_set_father (son
, to_node
);
815 if (dom_computed
[dir_index
] == DOM_OK
)
816 dom_computed
[dir_index
] = DOM_NO_FAST_QUERY
;
819 /* Find first basic block in the tree dominating both BB1 and BB2. */
821 nearest_common_dominator (enum cdi_direction dir
, basic_block bb1
, basic_block bb2
)
823 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
825 gcc_assert (dom_computed
[dir_index
]);
832 return et_nca (bb1
->dom
[dir_index
], bb2
->dom
[dir_index
])->data
;
836 /* Find the nearest common dominator for the basic blocks in BLOCKS,
837 using dominance direction DIR. */
840 nearest_common_dominator_for_set (enum cdi_direction dir
, bitmap blocks
)
846 first
= bitmap_first_set_bit (blocks
);
847 dom
= BASIC_BLOCK (first
);
848 EXECUTE_IF_SET_IN_BITMAP (blocks
, 0, i
, bi
)
849 if (dom
!= BASIC_BLOCK (i
))
850 dom
= nearest_common_dominator (dir
, dom
, BASIC_BLOCK (i
));
855 /* Given a dominator tree, we can determine whether one thing
856 dominates another in constant time by using two DFS numbers:
858 1. The number for when we visit a node on the way down the tree
859 2. The number for when we visit a node on the way back up the tree
861 You can view these as bounds for the range of dfs numbers the
862 nodes in the subtree of the dominator tree rooted at that node
865 The dominator tree is always a simple acyclic tree, so there are
866 only three possible relations two nodes in the dominator tree have
869 1. Node A is above Node B (and thus, Node A dominates node B)
878 In the above case, DFS_Number_In of A will be <= DFS_Number_In of
879 B, and DFS_Number_Out of A will be >= DFS_Number_Out of B. This is
880 because we must hit A in the dominator tree *before* B on the walk
881 down, and we will hit A *after* B on the walk back up
883 2. Node A is below node B (and thus, node B dominates node A)
892 In the above case, DFS_Number_In of A will be >= DFS_Number_In of
893 B, and DFS_Number_Out of A will be <= DFS_Number_Out of B.
895 This is because we must hit A in the dominator tree *after* B on
896 the walk down, and we will hit A *before* B on the walk back up
898 3. Node A and B are siblings (and thus, neither dominates the other)
906 In the above case, DFS_Number_In of A will *always* be <=
907 DFS_Number_In of B, and DFS_Number_Out of A will *always* be <=
908 DFS_Number_Out of B. This is because we will always finish the dfs
909 walk of one of the subtrees before the other, and thus, the dfs
910 numbers for one subtree can't intersect with the range of dfs
911 numbers for the other subtree. If you swap A and B's position in
912 the dominator tree, the comparison changes direction, but the point
913 is that both comparisons will always go the same way if there is no
914 dominance relationship.
916 Thus, it is sufficient to write
918 A_Dominates_B (node A, node B)
920 return DFS_Number_In(A) <= DFS_Number_In(B)
921 && DFS_Number_Out (A) >= DFS_Number_Out(B);
924 A_Dominated_by_B (node A, node B)
926 return DFS_Number_In(A) >= DFS_Number_In(A)
927 && DFS_Number_Out (A) <= DFS_Number_Out(B);
930 /* Return TRUE in case BB1 is dominated by BB2. */
932 dominated_by_p (enum cdi_direction dir
, basic_block bb1
, basic_block bb2
)
934 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
935 struct et_node
*n1
= bb1
->dom
[dir_index
], *n2
= bb2
->dom
[dir_index
];
937 gcc_assert (dom_computed
[dir_index
]);
939 if (dom_computed
[dir_index
] == DOM_OK
)
940 return (n1
->dfs_num_in
>= n2
->dfs_num_in
941 && n1
->dfs_num_out
<= n2
->dfs_num_out
);
943 return et_below (n1
, n2
);
946 /* Returns the entry dfs number for basic block BB, in the direction DIR. */
949 bb_dom_dfs_in (enum cdi_direction dir
, basic_block bb
)
951 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
952 struct et_node
*n
= bb
->dom
[dir_index
];
954 gcc_assert (dom_computed
[dir_index
] == DOM_OK
);
955 return n
->dfs_num_in
;
958 /* Returns the exit dfs number for basic block BB, in the direction DIR. */
961 bb_dom_dfs_out (enum cdi_direction dir
, basic_block bb
)
963 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
964 struct et_node
*n
= bb
->dom
[dir_index
];
966 gcc_assert (dom_computed
[dir_index
] == DOM_OK
);
967 return n
->dfs_num_out
;
970 /* Verify invariants of dominator structure. */
972 verify_dominators (enum cdi_direction dir
)
975 basic_block bb
, imm_bb
, imm_bb_correct
;
977 bool reverse
= (dir
== CDI_POST_DOMINATORS
) ? true : false;
979 gcc_assert (dom_info_available_p (dir
));
981 init_dom_info (&di
, dir
);
982 calc_dfs_tree (&di
, reverse
);
983 calc_idoms (&di
, reverse
);
987 imm_bb
= get_immediate_dominator (dir
, bb
);
990 error ("dominator of %d status unknown", bb
->index
);
994 imm_bb_correct
= di
.dfs_to_bb
[di
.dom
[di
.dfs_order
[bb
->index
]]];
995 if (imm_bb
!= imm_bb_correct
)
997 error ("dominator of %d should be %d, not %d",
998 bb
->index
, imm_bb_correct
->index
, imm_bb
->index
);
1003 free_dom_info (&di
);
1007 /* Determine immediate dominator (or postdominator, according to DIR) of BB,
1008 assuming that dominators of other blocks are correct. We also use it to
1009 recompute the dominators in a restricted area, by iterating it until it
1010 reaches a fixed point. */
1013 recompute_dominator (enum cdi_direction dir
, basic_block bb
)
1015 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
1016 basic_block dom_bb
= NULL
;
1020 gcc_assert (dom_computed
[dir_index
]);
1022 if (dir
== CDI_DOMINATORS
)
1024 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
1026 if (!dominated_by_p (dir
, e
->src
, bb
))
1027 dom_bb
= nearest_common_dominator (dir
, dom_bb
, e
->src
);
1032 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
1034 if (!dominated_by_p (dir
, e
->dest
, bb
))
1035 dom_bb
= nearest_common_dominator (dir
, dom_bb
, e
->dest
);
1042 /* Use simple heuristics (see iterate_fix_dominators) to determine dominators
1043 of BBS. We assume that all the immediate dominators except for those of the
1044 blocks in BBS are correct. If CONSERVATIVE is true, we also assume that the
1045 currently recorded immediate dominators of blocks in BBS really dominate the
1046 blocks. The basic blocks for that we determine the dominator are removed
1050 prune_bbs_to_update_dominators (VEC (basic_block
, heap
) *bbs
,
1055 basic_block bb
, dom
= NULL
;
1059 for (i
= 0; VEC_iterate (basic_block
, bbs
, i
, bb
);)
1061 if (bb
== ENTRY_BLOCK_PTR
)
1064 if (single_pred_p (bb
))
1066 set_immediate_dominator (CDI_DOMINATORS
, bb
, single_pred (bb
));
1075 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
1077 if (dominated_by_p (CDI_DOMINATORS
, e
->src
, bb
))
1085 dom
= nearest_common_dominator (CDI_DOMINATORS
, dom
, e
->src
);
1089 gcc_assert (dom
!= NULL
);
1091 || find_edge (dom
, bb
))
1093 set_immediate_dominator (CDI_DOMINATORS
, bb
, dom
);
1102 VEC_unordered_remove (basic_block
, bbs
, i
);
1106 /* Returns root of the dominance tree in the direction DIR that contains
1110 root_of_dom_tree (enum cdi_direction dir
, basic_block bb
)
1112 return et_root (bb
->dom
[dom_convert_dir_to_idx (dir
)])->data
;
1115 /* See the comment in iterate_fix_dominators. Finds the immediate dominators
1116 for the sons of Y, found using the SON and BROTHER arrays representing
1117 the dominance tree of graph G. BBS maps the vertices of G to the basic
1121 determine_dominators_for_sons (struct graph
*g
, VEC (basic_block
, heap
) *bbs
,
1122 int y
, int *son
, int *brother
)
1126 VEC (int, heap
) **sccs
;
1127 basic_block bb
, dom
, ybb
;
1134 if (y
== (int) VEC_length (basic_block
, bbs
))
1135 ybb
= ENTRY_BLOCK_PTR
;
1137 ybb
= VEC_index (basic_block
, bbs
, y
);
1139 if (brother
[son
[y
]] == -1)
1141 /* Handle the common case Y has just one son specially. */
1142 bb
= VEC_index (basic_block
, bbs
, son
[y
]);
1143 set_immediate_dominator (CDI_DOMINATORS
, bb
,
1144 recompute_dominator (CDI_DOMINATORS
, bb
));
1145 identify_vertices (g
, y
, son
[y
]);
1149 gprime
= BITMAP_ALLOC (NULL
);
1150 for (a
= son
[y
]; a
!= -1; a
= brother
[a
])
1151 bitmap_set_bit (gprime
, a
);
1153 nc
= graphds_scc (g
, gprime
);
1154 BITMAP_FREE (gprime
);
1156 sccs
= XCNEWVEC (VEC (int, heap
) *, nc
);
1157 for (a
= son
[y
]; a
!= -1; a
= brother
[a
])
1158 VEC_safe_push (int, heap
, sccs
[g
->vertices
[a
].component
], a
);
1160 for (i
= nc
- 1; i
>= 0; i
--)
1163 for (si
= 0; VEC_iterate (int, sccs
[i
], si
, a
); si
++)
1165 bb
= VEC_index (basic_block
, bbs
, a
);
1166 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
1168 if (root_of_dom_tree (CDI_DOMINATORS
, e
->src
) != ybb
)
1171 dom
= nearest_common_dominator (CDI_DOMINATORS
, dom
, e
->src
);
1175 gcc_assert (dom
!= NULL
);
1176 for (si
= 0; VEC_iterate (int, sccs
[i
], si
, a
); si
++)
1178 bb
= VEC_index (basic_block
, bbs
, a
);
1179 set_immediate_dominator (CDI_DOMINATORS
, bb
, dom
);
1183 for (i
= 0; i
< nc
; i
++)
1184 VEC_free (int, heap
, sccs
[i
]);
1187 for (a
= son
[y
]; a
!= -1; a
= brother
[a
])
1188 identify_vertices (g
, y
, a
);
1191 /* Recompute dominance information for basic blocks in the set BBS. The
1192 function assumes that the immediate dominators of all the other blocks
1193 in CFG are correct, and that there are no unreachable blocks.
1195 If CONSERVATIVE is true, we additionally assume that all the ancestors of
1196 a block of BBS in the current dominance tree dominate it. */
1199 iterate_fix_dominators (enum cdi_direction dir
, VEC (basic_block
, heap
) *bbs
,
1203 basic_block bb
, dom
;
1209 struct pointer_map_t
*map
;
1210 int *parent
, *son
, *brother
;
1211 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
1213 /* We only support updating dominators. There are some problems with
1214 updating postdominators (need to add fake edges from infinite loops
1215 and noreturn functions), and since we do not currently use
1216 iterate_fix_dominators for postdominators, any attempt to handle these
1217 problems would be unused, untested, and almost surely buggy. We keep
1218 the DIR argument for consistency with the rest of the dominator analysis
1220 gcc_assert (dir
== CDI_DOMINATORS
);
1221 gcc_assert (dom_computed
[dir_index
]);
1223 /* The algorithm we use takes inspiration from the following papers, although
1224 the details are quite different from any of them:
1226 [1] G. Ramalingam, T. Reps, An Incremental Algorithm for Maintaining the
1227 Dominator Tree of a Reducible Flowgraph
1228 [2] V. C. Sreedhar, G. R. Gao, Y.-F. Lee: Incremental computation of
1230 [3] K. D. Cooper, T. J. Harvey and K. Kennedy: A Simple, Fast Dominance
1233 First, we use the following heuristics to decrease the size of the BBS
1235 a) if BB has a single predecessor, then its immediate dominator is this
1237 additionally, if CONSERVATIVE is true:
1238 b) if all the predecessors of BB except for one (X) are dominated by BB,
1239 then X is the immediate dominator of BB
1240 c) if the nearest common ancestor of the predecessors of BB is X and
1241 X -> BB is an edge in CFG, then X is the immediate dominator of BB
1243 Then, we need to establish the dominance relation among the basic blocks
1244 in BBS. We split the dominance tree by removing the immediate dominator
1245 edges from BBS, creating a forest F. We form a graph G whose vertices
1246 are BBS and ENTRY and X -> Y is an edge of G if there exists an edge
1247 X' -> Y in CFG such that X' belongs to the tree of the dominance forest
1248 whose root is X. We then determine dominance tree of G. Note that
1249 for X, Y in BBS, X dominates Y in CFG if and only if X dominates Y in G.
1250 In this step, we can use arbitrary algorithm to determine dominators.
1251 We decided to prefer the algorithm [3] to the algorithm of
1252 Lengauer and Tarjan, since the set BBS is usually small (rarely exceeding
1253 10 during gcc bootstrap), and [3] should perform better in this case.
1255 Finally, we need to determine the immediate dominators for the basic
1256 blocks of BBS. If the immediate dominator of X in G is Y, then
1257 the immediate dominator of X in CFG belongs to the tree of F rooted in
1258 Y. We process the dominator tree T of G recursively, starting from leaves.
1259 Suppose that X_1, X_2, ..., X_k are the sons of Y in T, and that the
1260 subtrees of the dominance tree of CFG rooted in X_i are already correct.
1261 Let G' be the subgraph of G induced by {X_1, X_2, ..., X_k}. We make
1262 the following observations:
1263 (i) the immediate dominator of all blocks in a strongly connected
1264 component of G' is the same
1265 (ii) if X has no predecessors in G', then the immediate dominator of X
1266 is the nearest common ancestor of the predecessors of X in the
1267 subtree of F rooted in Y
1268 Therefore, it suffices to find the topological ordering of G', and
1269 process the nodes X_i in this order using the rules (i) and (ii).
1270 Then, we contract all the nodes X_i with Y in G, so that the further
1271 steps work correctly. */
1275 /* Split the tree now. If the idoms of blocks in BBS are not
1276 conservatively correct, setting the dominators using the
1277 heuristics in prune_bbs_to_update_dominators could
1278 create cycles in the dominance "tree", and cause ICE. */
1279 for (i
= 0; VEC_iterate (basic_block
, bbs
, i
, bb
); i
++)
1280 set_immediate_dominator (CDI_DOMINATORS
, bb
, NULL
);
1283 prune_bbs_to_update_dominators (bbs
, conservative
);
1284 n
= VEC_length (basic_block
, bbs
);
1291 bb
= VEC_index (basic_block
, bbs
, 0);
1292 set_immediate_dominator (CDI_DOMINATORS
, bb
,
1293 recompute_dominator (CDI_DOMINATORS
, bb
));
1297 /* Construct the graph G. */
1298 map
= pointer_map_create ();
1299 for (i
= 0; VEC_iterate (basic_block
, bbs
, i
, bb
); i
++)
1301 /* If the dominance tree is conservatively correct, split it now. */
1303 set_immediate_dominator (CDI_DOMINATORS
, bb
, NULL
);
1304 *pointer_map_insert (map
, bb
) = (void *) (size_t) i
;
1306 *pointer_map_insert (map
, ENTRY_BLOCK_PTR
) = (void *) (size_t) n
;
1308 g
= new_graph (n
+ 1);
1309 for (y
= 0; y
< g
->n_vertices
; y
++)
1310 g
->vertices
[y
].data
= BITMAP_ALLOC (NULL
);
1311 for (i
= 0; VEC_iterate (basic_block
, bbs
, i
, bb
); i
++)
1313 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
1315 dom
= root_of_dom_tree (CDI_DOMINATORS
, e
->src
);
1319 dom_i
= (size_t) *pointer_map_contains (map
, dom
);
1321 /* Do not include parallel edges to G. */
1322 if (bitmap_bit_p (g
->vertices
[dom_i
].data
, i
))
1325 bitmap_set_bit (g
->vertices
[dom_i
].data
, i
);
1326 add_edge (g
, dom_i
, i
);
1329 for (y
= 0; y
< g
->n_vertices
; y
++)
1330 BITMAP_FREE (g
->vertices
[y
].data
);
1331 pointer_map_destroy (map
);
1333 /* Find the dominator tree of G. */
1334 son
= XNEWVEC (int, n
+ 1);
1335 brother
= XNEWVEC (int, n
+ 1);
1336 parent
= XNEWVEC (int, n
+ 1);
1337 graphds_domtree (g
, n
, parent
, son
, brother
);
1339 /* Finally, traverse the tree and find the immediate dominators. */
1340 for (y
= n
; son
[y
] != -1; y
= son
[y
])
1344 determine_dominators_for_sons (g
, bbs
, y
, son
, brother
);
1346 if (brother
[y
] != -1)
1349 while (son
[y
] != -1)
1364 add_to_dominance_info (enum cdi_direction dir
, basic_block bb
)
1366 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
1368 gcc_assert (dom_computed
[dir_index
]);
1369 gcc_assert (!bb
->dom
[dir_index
]);
1371 n_bbs_in_dom_tree
[dir_index
]++;
1373 bb
->dom
[dir_index
] = et_new_tree (bb
);
1375 if (dom_computed
[dir_index
] == DOM_OK
)
1376 dom_computed
[dir_index
] = DOM_NO_FAST_QUERY
;
1380 delete_from_dominance_info (enum cdi_direction dir
, basic_block bb
)
1382 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
1384 gcc_assert (dom_computed
[dir_index
]);
1386 et_free_tree (bb
->dom
[dir_index
]);
1387 bb
->dom
[dir_index
] = NULL
;
1388 n_bbs_in_dom_tree
[dir_index
]--;
1390 if (dom_computed
[dir_index
] == DOM_OK
)
1391 dom_computed
[dir_index
] = DOM_NO_FAST_QUERY
;
1394 /* Returns the first son of BB in the dominator or postdominator tree
1395 as determined by DIR. */
1398 first_dom_son (enum cdi_direction dir
, basic_block bb
)
1400 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
1401 struct et_node
*son
= bb
->dom
[dir_index
]->son
;
1403 return son
? son
->data
: NULL
;
1406 /* Returns the next dominance son after BB in the dominator or postdominator
1407 tree as determined by DIR, or NULL if it was the last one. */
1410 next_dom_son (enum cdi_direction dir
, basic_block bb
)
1412 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
1413 struct et_node
*next
= bb
->dom
[dir_index
]->right
;
1415 return next
->father
->son
== next
? NULL
: next
->data
;
1418 /* Return dominance availability for dominance info DIR. */
1421 dom_info_state (enum cdi_direction dir
)
1423 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
1425 return dom_computed
[dir_index
];
1428 /* Set the dominance availability for dominance info DIR to NEW_STATE. */
1431 set_dom_info_availability (enum cdi_direction dir
, enum dom_state new_state
)
1433 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
1435 dom_computed
[dir_index
] = new_state
;
1438 /* Returns true if dominance information for direction DIR is available. */
1441 dom_info_available_p (enum cdi_direction dir
)
1443 unsigned int dir_index
= dom_convert_dir_to_idx (dir
);
1445 return dom_computed
[dir_index
] != DOM_NONE
;
1449 debug_dominance_info (enum cdi_direction dir
)
1451 basic_block bb
, bb2
;
1453 if ((bb2
= get_immediate_dominator (dir
, bb
)))
1454 fprintf (stderr
, "%i %i\n", bb
->index
, bb2
->index
);
1457 /* Prints to stderr representation of the dominance tree (for direction DIR)
1458 rooted in ROOT, indented by INDENT tabelators. If INDENT_FIRST is false,
1459 the first line of the output is not indented. */
1462 debug_dominance_tree_1 (enum cdi_direction dir
, basic_block root
,
1463 unsigned indent
, bool indent_first
)
1470 for (i
= 0; i
< indent
; i
++)
1471 fprintf (stderr
, "\t");
1472 fprintf (stderr
, "%d\t", root
->index
);
1474 for (son
= first_dom_son (dir
, root
);
1476 son
= next_dom_son (dir
, son
))
1478 debug_dominance_tree_1 (dir
, son
, indent
+ 1, !first
);
1483 fprintf (stderr
, "\n");
1486 /* Prints to stderr representation of the dominance tree (for direction DIR)
1490 debug_dominance_tree (enum cdi_direction dir
, basic_block root
)
1492 debug_dominance_tree_1 (dir
, root
, 0, false);