1 /* Calculate (post)dominators in slightly super-linear time.
2 Copyright (C) 2000, 2003, 2004 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, 59 Temple Place - Suite 330, 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 its 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"
42 #include "basic-block.h"
44 #include "et-forest.h"
46 /* Whether the dominators and the postdominators are available. */
47 enum dom_state dom_computed
[2];
49 /* We name our nodes with integers, beginning with 1. Zero is reserved for
50 'undefined' or 'end of list'. The name of each node is given by the dfs
51 number of the corresponding basic block. Please note, that we include the
52 artificial ENTRY_BLOCK (or EXIT_BLOCK in the post-dom case) in our lists to
53 support multiple entry points. As it has no real basic block index we use
54 'last_basic_block' for that. Its dfs number is of course 1. */
56 /* Type of Basic Block aka. TBB */
57 typedef unsigned int TBB
;
59 /* We work in a poor-mans object oriented fashion, and carry an instance of
60 this structure through all our 'methods'. It holds various arrays
61 reflecting the (sub)structure of the flowgraph. Most of them are of type
62 TBB and are also indexed by TBB. */
66 /* The parent of a node in the DFS tree. */
68 /* For a node x key[x] is roughly the node nearest to the root from which
69 exists a way to x only over nodes behind x. Such a node is also called
72 /* The value in path_min[x] is the node y on the path from x to the root of
73 the tree x is in with the smallest key[y]. */
75 /* bucket[x] points to the first node of the set of nodes having x as key. */
77 /* And next_bucket[x] points to the next node. */
79 /* After the algorithm is done, dom[x] contains the immediate dominator
83 /* The following few fields implement the structures needed for disjoint
85 /* set_chain[x] is the next node on the path from x to the representant
86 of the set containing x. If set_chain[x]==0 then x is a root. */
88 /* set_size[x] is the number of elements in the set named by x. */
89 unsigned int *set_size
;
90 /* set_child[x] is used for balancing the tree representing a set. It can
91 be understood as the next sibling of x. */
94 /* If b is the number of a basic block (BB->index), dfs_order[b] is the
95 number of that node in DFS order counted from 1. This is an index
96 into most of the other arrays in this structure. */
98 /* If x is the DFS-index of a node which corresponds with a basic block,
99 dfs_to_bb[x] is that basic block. Note, that in our structure there are
100 more nodes that basic blocks, so only dfs_to_bb[dfs_order[bb->index]]==bb
101 is true for every basic block bb, but not the opposite. */
102 basic_block
*dfs_to_bb
;
104 /* This is the next free DFS number when creating the DFS tree. */
106 /* The number of nodes in the DFS tree (==dfsnum-1). */
109 /* Blocks with bits set here have a fake edge to EXIT. These are used
110 to turn a DFS forest into a proper tree. */
111 bitmap fake_exit_edge
;
114 static void init_dom_info (struct dom_info
*, enum cdi_direction
);
115 static void free_dom_info (struct dom_info
*);
116 static void calc_dfs_tree_nonrec (struct dom_info
*, basic_block
,
118 static void calc_dfs_tree (struct dom_info
*, enum cdi_direction
);
119 static void compress (struct dom_info
*, TBB
);
120 static TBB
eval (struct dom_info
*, TBB
);
121 static void link_roots (struct dom_info
*, TBB
, TBB
);
122 static void calc_idoms (struct dom_info
*, enum cdi_direction
);
123 void debug_dominance_info (enum cdi_direction
);
125 /* Keeps track of the*/
126 static unsigned n_bbs_in_dom_tree
[2];
128 /* Helper macro for allocating and initializing an array,
129 for aesthetic reasons. */
130 #define init_ar(var, type, num, content) \
133 unsigned int i = 1; /* Catch content == i. */ \
135 (var) = xcalloc ((num), sizeof (type)); \
138 (var) = xmalloc ((num) * sizeof (type)); \
139 for (i = 0; i < num; i++) \
140 (var)[i] = (content); \
145 /* Allocate all needed memory in a pessimistic fashion (so we round up).
146 This initializes the contents of DI, which already must be allocated. */
149 init_dom_info (struct dom_info
*di
, enum cdi_direction dir
)
151 /* We need memory for n_basic_blocks nodes and the ENTRY_BLOCK or
153 unsigned int num
= n_basic_blocks
+ 1 + 1;
154 init_ar (di
->dfs_parent
, TBB
, num
, 0);
155 init_ar (di
->path_min
, TBB
, num
, i
);
156 init_ar (di
->key
, TBB
, num
, i
);
157 init_ar (di
->dom
, TBB
, num
, 0);
159 init_ar (di
->bucket
, TBB
, num
, 0);
160 init_ar (di
->next_bucket
, TBB
, num
, 0);
162 init_ar (di
->set_chain
, TBB
, num
, 0);
163 init_ar (di
->set_size
, unsigned int, num
, 1);
164 init_ar (di
->set_child
, TBB
, num
, 0);
166 init_ar (di
->dfs_order
, TBB
, (unsigned int) last_basic_block
+ 1, 0);
167 init_ar (di
->dfs_to_bb
, basic_block
, num
, 0);
172 di
->fake_exit_edge
= dir
? BITMAP_XMALLOC () : NULL
;
177 /* Free all allocated memory in DI, but not DI itself. */
180 free_dom_info (struct dom_info
*di
)
182 free (di
->dfs_parent
);
187 free (di
->next_bucket
);
188 free (di
->set_chain
);
190 free (di
->set_child
);
191 free (di
->dfs_order
);
192 free (di
->dfs_to_bb
);
193 BITMAP_XFREE (di
->fake_exit_edge
);
196 /* The nonrecursive variant of creating a DFS tree. DI is our working
197 structure, BB the starting basic block for this tree and REVERSE
198 is true, if predecessors should be visited instead of successors of a
199 node. After this is done all nodes reachable from BB were visited, have
200 assigned their dfs number and are linked together to form a tree. */
203 calc_dfs_tree_nonrec (struct dom_info
*di
, basic_block bb
,
204 enum cdi_direction reverse
)
206 /* We call this _only_ if bb is not already visited. */
210 TBB child_i
, my_i
= 0;
211 struct edge_stack
*stack
;
213 /* Start block (ENTRY_BLOCK_PTR for forward problem, EXIT_BLOCK for backward
215 basic_block en_block
;
217 basic_block ex_block
;
218 unsigned ix
, ix_next
;
220 stack
= xmalloc ((n_basic_blocks
+ 3) * sizeof (struct edge_stack
));
223 /* Initialize our border blocks, and the first edge. */
227 en_block
= EXIT_BLOCK_PTR
;
228 ex_block
= ENTRY_BLOCK_PTR
;
233 en_block
= ENTRY_BLOCK_PTR
;
234 ex_block
= EXIT_BLOCK_PTR
;
238 /* When the stack is empty we break out of this loop. */
243 /* This loop traverses edges e in depth first manner, and fills the
245 while (ix
< EDGE_COUNT (ev
))
249 /* Deduce from E the current and the next block (BB and BN), and the
255 /* If the next node BN is either already visited or a border
256 block the current edge is useless, and simply overwritten
257 with the next edge out of the current node. */
258 if (bn
== ex_block
|| di
->dfs_order
[bn
->index
])
270 if (bn
== ex_block
|| di
->dfs_order
[bn
->index
])
283 /* Fill the DFS tree info calculatable _before_ recursing. */
285 my_i
= di
->dfs_order
[bb
->index
];
287 my_i
= di
->dfs_order
[last_basic_block
];
288 child_i
= di
->dfs_order
[bn
->index
] = di
->dfsnum
++;
289 di
->dfs_to_bb
[child_i
] = bn
;
290 di
->dfs_parent
[child_i
] = my_i
;
292 /* Save the current point in the CFG on the stack, and recurse. */
305 /* OK. The edge-list was exhausted, meaning normally we would
306 end the recursion. After returning from the recursive call,
307 there were (may be) other statements which were run after a
308 child node was completely considered by DFS. Here is the
309 point to do it in the non-recursive variant.
310 E.g. The block just completed is in e->dest for forward DFS,
311 the block not yet completed (the parent of the one above)
312 in e->src. This could be used e.g. for computing the number of
313 descendants or the tree depth. */
319 /* The main entry for calculating the DFS tree or forest. DI is our working
320 structure and REVERSE is true, if we are interested in the reverse flow
321 graph. In that case the result is not necessarily a tree but a forest,
322 because there may be nodes from which the EXIT_BLOCK is unreachable. */
325 calc_dfs_tree (struct dom_info
*di
, enum cdi_direction reverse
)
327 /* The first block is the ENTRY_BLOCK (or EXIT_BLOCK if REVERSE). */
328 basic_block begin
= reverse
? EXIT_BLOCK_PTR
: ENTRY_BLOCK_PTR
;
329 di
->dfs_order
[last_basic_block
] = di
->dfsnum
;
330 di
->dfs_to_bb
[di
->dfsnum
] = begin
;
333 calc_dfs_tree_nonrec (di
, begin
, reverse
);
337 /* In the post-dom case we may have nodes without a path to EXIT_BLOCK.
338 They are reverse-unreachable. In the dom-case we disallow such
339 nodes, but in post-dom we have to deal with them.
341 There are two situations in which this occurs. First, noreturn
342 functions. Second, infinite loops. In the first case we need to
343 pretend that there is an edge to the exit block. In the second
344 case, we wind up with a forest. We need to process all noreturn
345 blocks before we know if we've got any infinite loops. */
348 bool saw_unconnected
= false;
350 FOR_EACH_BB_REVERSE (b
)
354 if (di
->dfs_order
[b
->index
] == 0)
355 saw_unconnected
= true;
358 bitmap_set_bit (di
->fake_exit_edge
, b
->index
);
359 di
->dfs_order
[b
->index
] = di
->dfsnum
;
360 di
->dfs_to_bb
[di
->dfsnum
] = b
;
361 di
->dfs_parent
[di
->dfsnum
] = di
->dfs_order
[last_basic_block
];
363 calc_dfs_tree_nonrec (di
, b
, reverse
);
368 FOR_EACH_BB_REVERSE (b
)
370 if (di
->dfs_order
[b
->index
])
372 bitmap_set_bit (di
->fake_exit_edge
, b
->index
);
373 di
->dfs_order
[b
->index
] = di
->dfsnum
;
374 di
->dfs_to_bb
[di
->dfsnum
] = b
;
375 di
->dfs_parent
[di
->dfsnum
] = di
->dfs_order
[last_basic_block
];
377 calc_dfs_tree_nonrec (di
, b
, reverse
);
382 di
->nodes
= di
->dfsnum
- 1;
384 /* This aborts e.g. when there is _no_ path from ENTRY to EXIT at all. */
385 if (di
->nodes
!= (unsigned int) n_basic_blocks
+ 1)
389 /* Compress the path from V to the root of its set and update path_min at the
390 same time. After compress(di, V) set_chain[V] is the root of the set V is
391 in and path_min[V] is the node with the smallest key[] value on the path
392 from V to that root. */
395 compress (struct dom_info
*di
, TBB v
)
397 /* Btw. It's not worth to unrecurse compress() as the depth is usually not
398 greater than 5 even for huge graphs (I've not seen call depth > 4).
399 Also performance wise compress() ranges _far_ behind eval(). */
400 TBB parent
= di
->set_chain
[v
];
401 if (di
->set_chain
[parent
])
403 compress (di
, parent
);
404 if (di
->key
[di
->path_min
[parent
]] < di
->key
[di
->path_min
[v
]])
405 di
->path_min
[v
] = di
->path_min
[parent
];
406 di
->set_chain
[v
] = di
->set_chain
[parent
];
410 /* Compress the path from V to the set root of V if needed (when the root has
411 changed since the last call). Returns the node with the smallest key[]
412 value on the path from V to the root. */
415 eval (struct dom_info
*di
, TBB v
)
417 /* The representant of the set V is in, also called root (as the set
418 representation is a tree). */
419 TBB rep
= di
->set_chain
[v
];
421 /* V itself is the root. */
423 return di
->path_min
[v
];
425 /* Compress only if necessary. */
426 if (di
->set_chain
[rep
])
429 rep
= di
->set_chain
[v
];
432 if (di
->key
[di
->path_min
[rep
]] >= di
->key
[di
->path_min
[v
]])
433 return di
->path_min
[v
];
435 return di
->path_min
[rep
];
438 /* This essentially merges the two sets of V and W, giving a single set with
439 the new root V. The internal representation of these disjoint sets is a
440 balanced tree. Currently link(V,W) is only used with V being the parent
444 link_roots (struct dom_info
*di
, TBB v
, TBB w
)
448 /* Rebalance the tree. */
449 while (di
->key
[di
->path_min
[w
]] < di
->key
[di
->path_min
[di
->set_child
[s
]]])
451 if (di
->set_size
[s
] + di
->set_size
[di
->set_child
[di
->set_child
[s
]]]
452 >= 2 * di
->set_size
[di
->set_child
[s
]])
454 di
->set_chain
[di
->set_child
[s
]] = s
;
455 di
->set_child
[s
] = di
->set_child
[di
->set_child
[s
]];
459 di
->set_size
[di
->set_child
[s
]] = di
->set_size
[s
];
460 s
= di
->set_chain
[s
] = di
->set_child
[s
];
464 di
->path_min
[s
] = di
->path_min
[w
];
465 di
->set_size
[v
] += di
->set_size
[w
];
466 if (di
->set_size
[v
] < 2 * di
->set_size
[w
])
469 s
= di
->set_child
[v
];
470 di
->set_child
[v
] = tmp
;
473 /* Merge all subtrees. */
476 di
->set_chain
[s
] = v
;
477 s
= di
->set_child
[s
];
481 /* This calculates the immediate dominators (or post-dominators if REVERSE is
482 true). DI is our working structure and should hold the DFS forest.
483 On return the immediate dominator to node V is in di->dom[V]. */
486 calc_idoms (struct dom_info
*di
, enum cdi_direction reverse
)
489 basic_block en_block
;
493 en_block
= EXIT_BLOCK_PTR
;
495 en_block
= ENTRY_BLOCK_PTR
;
497 /* Go backwards in DFS order, to first look at the leafs. */
501 basic_block bb
= di
->dfs_to_bb
[v
];
505 par
= di
->dfs_parent
[v
];
507 ev
= (reverse
) ? bb
->succ
: bb
->pred
;
510 /* If this block has a fake edge to exit, process that first. */
511 if (bitmap_bit_p (di
->fake_exit_edge
, bb
->index
))
512 goto do_fake_exit_edge
;
515 /* Search all direct predecessors for the smallest node with a path
516 to them. That way we have the smallest node with also a path to
517 us only over nodes behind us. In effect we search for our
519 FOR_EACH_EDGE (e
, ev
, ix
)
522 basic_block b
= (reverse
) ? e
->dest
: e
->src
;
527 k1
= di
->dfs_order
[last_basic_block
];
530 k1
= di
->dfs_order
[b
->index
];
532 /* Call eval() only if really needed. If k1 is above V in DFS tree,
533 then we know, that eval(k1) == k1 and key[k1] == k1. */
535 k1
= di
->key
[eval (di
, k1
)];
541 link_roots (di
, par
, v
);
542 di
->next_bucket
[v
] = di
->bucket
[k
];
545 /* Transform semidominators into dominators. */
546 for (w
= di
->bucket
[par
]; w
; w
= di
->next_bucket
[w
])
549 if (di
->key
[k
] < di
->key
[w
])
554 /* We don't need to cleanup next_bucket[]. */
559 /* Explicitly define the dominators. */
561 for (v
= 2; v
<= di
->nodes
; v
++)
562 if (di
->dom
[v
] != di
->key
[v
])
563 di
->dom
[v
] = di
->dom
[di
->dom
[v
]];
566 /* Assign dfs numbers starting from NUM to NODE and its sons. */
569 assign_dfs_numbers (struct et_node
*node
, int *num
)
573 node
->dfs_num_in
= (*num
)++;
577 assign_dfs_numbers (node
->son
, num
);
578 for (son
= node
->son
->right
; son
!= node
->son
; son
= son
->right
)
579 assign_dfs_numbers (son
, num
);
582 node
->dfs_num_out
= (*num
)++;
585 /* Compute the data necessary for fast resolving of dominator queries in a
586 static dominator tree. */
589 compute_dom_fast_query (enum cdi_direction dir
)
594 if (dom_computed
[dir
] < DOM_NO_FAST_QUERY
)
597 if (dom_computed
[dir
] == DOM_OK
)
602 if (!bb
->dom
[dir
]->father
)
603 assign_dfs_numbers (bb
->dom
[dir
], &num
);
606 dom_computed
[dir
] = DOM_OK
;
609 /* The main entry point into this module. DIR is set depending on whether
610 we want to compute dominators or postdominators. */
613 calculate_dominance_info (enum cdi_direction dir
)
618 if (dom_computed
[dir
] == DOM_OK
)
621 if (dom_computed
[dir
] != DOM_NO_FAST_QUERY
)
623 if (dom_computed
[dir
] != DOM_NONE
)
624 free_dominance_info (dir
);
626 if (n_bbs_in_dom_tree
[dir
])
631 b
->dom
[dir
] = et_new_tree (b
);
633 n_bbs_in_dom_tree
[dir
] = n_basic_blocks
+ 2;
635 init_dom_info (&di
, dir
);
636 calc_dfs_tree (&di
, dir
);
637 calc_idoms (&di
, dir
);
641 TBB d
= di
.dom
[di
.dfs_order
[b
->index
]];
644 et_set_father (b
->dom
[dir
], di
.dfs_to_bb
[d
]->dom
[dir
]);
648 dom_computed
[dir
] = DOM_NO_FAST_QUERY
;
651 compute_dom_fast_query (dir
);
654 /* Free dominance information for direction DIR. */
656 free_dominance_info (enum cdi_direction dir
)
660 if (!dom_computed
[dir
])
665 delete_from_dominance_info (dir
, bb
);
668 /* If there are any nodes left, something is wrong. */
669 if (n_bbs_in_dom_tree
[dir
])
672 dom_computed
[dir
] = DOM_NONE
;
675 /* Return the immediate dominator of basic block BB. */
677 get_immediate_dominator (enum cdi_direction dir
, basic_block bb
)
679 struct et_node
*node
= bb
->dom
[dir
];
681 if (!dom_computed
[dir
])
687 return node
->father
->data
;
690 /* Set the immediate dominator of the block possibly removing
691 existing edge. NULL can be used to remove any edge. */
693 set_immediate_dominator (enum cdi_direction dir
, basic_block bb
,
694 basic_block dominated_by
)
696 struct et_node
*node
= bb
->dom
[dir
];
698 if (!dom_computed
[dir
])
703 if (node
->father
->data
== dominated_by
)
709 et_set_father (node
, dominated_by
->dom
[dir
]);
711 if (dom_computed
[dir
] == DOM_OK
)
712 dom_computed
[dir
] = DOM_NO_FAST_QUERY
;
715 /* Store all basic blocks immediately dominated by BB into BBS and return
718 get_dominated_by (enum cdi_direction dir
, basic_block bb
, basic_block
**bbs
)
721 struct et_node
*node
= bb
->dom
[dir
], *son
= node
->son
, *ason
;
723 if (!dom_computed
[dir
])
732 for (ason
= son
->right
, n
= 1; ason
!= son
; ason
= ason
->right
)
735 *bbs
= xmalloc (n
* sizeof (basic_block
));
736 (*bbs
)[0] = son
->data
;
737 for (ason
= son
->right
, n
= 1; ason
!= son
; ason
= ason
->right
)
738 (*bbs
)[n
++] = ason
->data
;
743 /* Redirect all edges pointing to BB to TO. */
745 redirect_immediate_dominators (enum cdi_direction dir
, basic_block bb
,
748 struct et_node
*bb_node
= bb
->dom
[dir
], *to_node
= to
->dom
[dir
], *son
;
750 if (!dom_computed
[dir
])
761 et_set_father (son
, to_node
);
764 if (dom_computed
[dir
] == DOM_OK
)
765 dom_computed
[dir
] = DOM_NO_FAST_QUERY
;
768 /* Find first basic block in the tree dominating both BB1 and BB2. */
770 nearest_common_dominator (enum cdi_direction dir
, basic_block bb1
, basic_block bb2
)
772 if (!dom_computed
[dir
])
780 return et_nca (bb1
->dom
[dir
], bb2
->dom
[dir
])->data
;
783 /* Return TRUE in case BB1 is dominated by BB2. */
785 dominated_by_p (enum cdi_direction dir
, basic_block bb1
, basic_block bb2
)
787 struct et_node
*n1
= bb1
->dom
[dir
], *n2
= bb2
->dom
[dir
];
789 if (!dom_computed
[dir
])
792 if (dom_computed
[dir
] == DOM_OK
)
793 return (n1
->dfs_num_in
>= n2
->dfs_num_in
794 && n1
->dfs_num_out
<= n2
->dfs_num_out
);
796 return et_below (n1
, n2
);
799 /* Verify invariants of dominator structure. */
801 verify_dominators (enum cdi_direction dir
)
806 if (!dom_computed
[dir
])
813 dom_bb
= recount_dominator (dir
, bb
);
814 if (dom_bb
!= get_immediate_dominator (dir
, bb
))
816 error ("dominator of %d should be %d, not %d",
817 bb
->index
, dom_bb
->index
, get_immediate_dominator(dir
, bb
)->index
);
825 /* Determine immediate dominator (or postdominator, according to DIR) of BB,
826 assuming that dominators of other blocks are correct. We also use it to
827 recompute the dominators in a restricted area, by iterating it until it
828 reaches a fixed point. */
831 recount_dominator (enum cdi_direction dir
, basic_block bb
)
833 basic_block dom_bb
= NULL
;
837 if (!dom_computed
[dir
])
840 if (dir
== CDI_DOMINATORS
)
842 FOR_EACH_EDGE (e
, bb
->pred
, ix
)
844 if (!dominated_by_p (dir
, e
->src
, bb
))
845 dom_bb
= nearest_common_dominator (dir
, dom_bb
, e
->src
);
850 FOR_EACH_EDGE (e
, bb
->succ
, ix
)
852 if (!dominated_by_p (dir
, e
->dest
, bb
))
853 dom_bb
= nearest_common_dominator (dir
, dom_bb
, e
->dest
);
860 /* Iteratively recount dominators of BBS. The change is supposed to be local
861 and not to grow further. */
863 iterate_fix_dominators (enum cdi_direction dir
, basic_block
*bbs
, int n
)
866 basic_block old_dom
, new_dom
;
868 if (!dom_computed
[dir
])
874 for (i
= 0; i
< n
; i
++)
876 old_dom
= get_immediate_dominator (dir
, bbs
[i
]);
877 new_dom
= recount_dominator (dir
, bbs
[i
]);
878 if (old_dom
!= new_dom
)
881 set_immediate_dominator (dir
, bbs
[i
], new_dom
);
888 add_to_dominance_info (enum cdi_direction dir
, basic_block bb
)
890 if (!dom_computed
[dir
])
896 n_bbs_in_dom_tree
[dir
]++;
898 bb
->dom
[dir
] = et_new_tree (bb
);
900 if (dom_computed
[dir
] == DOM_OK
)
901 dom_computed
[dir
] = DOM_NO_FAST_QUERY
;
905 delete_from_dominance_info (enum cdi_direction dir
, basic_block bb
)
907 if (!dom_computed
[dir
])
910 et_free_tree (bb
->dom
[dir
]);
912 n_bbs_in_dom_tree
[dir
]--;
914 if (dom_computed
[dir
] == DOM_OK
)
915 dom_computed
[dir
] = DOM_NO_FAST_QUERY
;
918 /* Returns the first son of BB in the dominator or postdominator tree
919 as determined by DIR. */
922 first_dom_son (enum cdi_direction dir
, basic_block bb
)
924 struct et_node
*son
= bb
->dom
[dir
]->son
;
926 return son
? son
->data
: NULL
;
929 /* Returns the next dominance son after BB in the dominator or postdominator
930 tree as determined by DIR, or NULL if it was the last one. */
933 next_dom_son (enum cdi_direction dir
, basic_block bb
)
935 struct et_node
*next
= bb
->dom
[dir
]->right
;
937 return next
->father
->son
== next
? NULL
: next
->data
;
941 debug_dominance_info (enum cdi_direction dir
)
945 if ((bb2
= get_immediate_dominator (dir
, bb
)))
946 fprintf (stderr
, "%i %i\n", bb
->index
, bb2
->index
);