1 /* Control flow graph analysis code for GNU compiler.
2 Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
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 contains various simple utilities to analyze the CFG. */
26 #include "hard-reg-set.h"
27 #include "basic-block.h"
32 /* Store the data structures necessary for depth-first search. */
33 struct depth_first_search_dsS
{
34 /* stack for backtracking during the algorithm */
37 /* number of edges in the stack. That is, positions 0, ..., sp-1
41 /* record of basic blocks already seen by depth-first search */
42 sbitmap visited_blocks
;
44 typedef struct depth_first_search_dsS
*depth_first_search_ds
;
46 static void flow_dfs_compute_reverse_init
47 PARAMS ((depth_first_search_ds
));
48 static void flow_dfs_compute_reverse_add_bb
49 PARAMS ((depth_first_search_ds
, basic_block
));
50 static basic_block flow_dfs_compute_reverse_execute
51 PARAMS ((depth_first_search_ds
));
52 static void flow_dfs_compute_reverse_finish
53 PARAMS ((depth_first_search_ds
));
54 static void remove_fake_successors
PARAMS ((basic_block
));
55 static bool need_fake_edge_p
PARAMS ((rtx
));
57 /* Return true if the block has no effect and only forwards control flow to
58 its single destination. */
60 forwarder_block_p (bb
)
64 if (bb
== EXIT_BLOCK_PTR
|| bb
== ENTRY_BLOCK_PTR
65 || !bb
->succ
|| bb
->succ
->succ_next
)
68 while (insn
!= bb
->end
)
70 if (INSN_P (insn
) && active_insn_p (insn
))
72 insn
= NEXT_INSN (insn
);
74 return (!INSN_P (insn
)
75 || (GET_CODE (insn
) == JUMP_INSN
&& simplejump_p (insn
))
76 || !active_insn_p (insn
));
79 /* Return nonzero if we can reach target from src by falling through. */
81 can_fallthru (src
, target
)
82 basic_block src
, target
;
85 rtx insn2
= target
->head
;
87 if (src
->index
+ 1 == target
->index
&& !active_insn_p (insn2
))
88 insn2
= next_active_insn (insn2
);
89 /* ??? Later we may add code to move jump tables offline. */
90 return next_active_insn (insn
) == insn2
;
93 /* Mark the back edges in DFS traversal.
94 Return non-zero if a loop (natural or otherwise) is present.
95 Inspired by Depth_First_Search_PP described in:
97 Advanced Compiler Design and Implementation
101 and heavily borrowed from flow_depth_first_order_compute. */
104 mark_dfs_back_edges ()
115 /* Allocate the preorder and postorder number arrays. */
116 pre
= (int *) xcalloc (n_basic_blocks
, sizeof (int));
117 post
= (int *) xcalloc (n_basic_blocks
, sizeof (int));
119 /* Allocate stack for back-tracking up CFG. */
120 stack
= (edge
*) xmalloc ((n_basic_blocks
+ 1) * sizeof (edge
));
123 /* Allocate bitmap to track nodes that have been visited. */
124 visited
= sbitmap_alloc (n_basic_blocks
);
126 /* None of the nodes in the CFG have been visited yet. */
127 sbitmap_zero (visited
);
129 /* Push the first edge on to the stack. */
130 stack
[sp
++] = ENTRY_BLOCK_PTR
->succ
;
138 /* Look at the edge on the top of the stack. */
142 e
->flags
&= ~EDGE_DFS_BACK
;
144 /* Check if the edge destination has been visited yet. */
145 if (dest
!= EXIT_BLOCK_PTR
&& ! TEST_BIT (visited
, dest
->index
))
147 /* Mark that we have visited the destination. */
148 SET_BIT (visited
, dest
->index
);
150 pre
[dest
->index
] = prenum
++;
154 /* Since the DEST node has been visited for the first
155 time, check its successors. */
156 stack
[sp
++] = dest
->succ
;
159 post
[dest
->index
] = postnum
++;
163 if (dest
!= EXIT_BLOCK_PTR
&& src
!= ENTRY_BLOCK_PTR
164 && pre
[src
->index
] >= pre
[dest
->index
]
165 && post
[dest
->index
] == 0)
166 e
->flags
|= EDGE_DFS_BACK
, found
= true;
168 if (! e
->succ_next
&& src
!= ENTRY_BLOCK_PTR
)
169 post
[src
->index
] = postnum
++;
172 stack
[sp
- 1] = e
->succ_next
;
181 sbitmap_free (visited
);
186 /* Return true if we need to add fake edge to exit.
187 Helper function for the flow_call_edges_add. */
190 need_fake_edge_p (insn
)
196 if ((GET_CODE (insn
) == CALL_INSN
197 && !SIBLING_CALL_P (insn
)
198 && !find_reg_note (insn
, REG_NORETURN
, NULL
)
199 && !find_reg_note (insn
, REG_ALWAYS_RETURN
, NULL
)
200 && !CONST_OR_PURE_CALL_P (insn
)))
203 return ((GET_CODE (PATTERN (insn
)) == ASM_OPERANDS
204 && MEM_VOLATILE_P (PATTERN (insn
)))
205 || (GET_CODE (PATTERN (insn
)) == PARALLEL
206 && asm_noperands (insn
) != -1
207 && MEM_VOLATILE_P (XVECEXP (PATTERN (insn
), 0, 0)))
208 || GET_CODE (PATTERN (insn
)) == ASM_INPUT
);
211 /* Add fake edges to the function exit for any non constant and non noreturn
212 calls, volatile inline assembly in the bitmap of blocks specified by
213 BLOCKS or to the whole CFG if BLOCKS is zero. Return the number of blocks
216 The goal is to expose cases in which entering a basic block does not imply
217 that all subsequent instructions must be executed. */
220 flow_call_edges_add (blocks
)
224 int blocks_split
= 0;
227 bool check_last_block
= false;
229 /* Map bb indices into basic block pointers since split_block
230 will renumber the basic blocks. */
232 bbs
= xmalloc (n_basic_blocks
* sizeof (*bbs
));
236 for (i
= 0; i
< n_basic_blocks
; i
++)
237 bbs
[bb_num
++] = BASIC_BLOCK (i
);
238 check_last_block
= true;
242 EXECUTE_IF_SET_IN_SBITMAP (blocks
, 0, i
,
244 bbs
[bb_num
++] = BASIC_BLOCK (i
);
245 if (i
== n_basic_blocks
- 1)
246 check_last_block
= true;
250 /* In the last basic block, before epilogue generation, there will be
251 a fallthru edge to EXIT. Special care is required if the last insn
252 of the last basic block is a call because make_edge folds duplicate
253 edges, which would result in the fallthru edge also being marked
254 fake, which would result in the fallthru edge being removed by
255 remove_fake_edges, which would result in an invalid CFG.
257 Moreover, we can't elide the outgoing fake edge, since the block
258 profiler needs to take this into account in order to solve the minimal
259 spanning tree in the case that the call doesn't return.
261 Handle this by adding a dummy instruction in a new last basic block. */
263 && need_fake_edge_p (BASIC_BLOCK (n_basic_blocks
- 1)->end
))
266 for (e
= BASIC_BLOCK (n_basic_blocks
- 1)->succ
; e
; e
= e
->succ_next
)
267 if (e
->dest
== EXIT_BLOCK_PTR
)
269 insert_insn_on_edge (gen_rtx_USE (VOIDmode
, const0_rtx
), e
);
270 commit_edge_insertions ();
274 /* Now add fake edges to the function exit for any non constant
275 calls since there is no way that we can determine if they will
278 for (i
= 0; i
< bb_num
; i
++)
280 basic_block bb
= bbs
[i
];
284 for (insn
= bb
->end
; ; insn
= prev_insn
)
286 prev_insn
= PREV_INSN (insn
);
287 if (need_fake_edge_p (insn
))
291 /* The above condition should be enough to verify that there is
292 no edge to the exit block in CFG already. Calling make_edge in
293 such case would make us to mark that edge as fake and remove it
295 #ifdef ENABLE_CHECKING
297 for (e
= bb
->succ
; e
; e
= e
->succ_next
)
298 if (e
->dest
== EXIT_BLOCK_PTR
)
302 /* Note that the following may create a new basic block
303 and renumber the existing basic blocks. */
304 e
= split_block (bb
, insn
);
308 make_edge (bb
, EXIT_BLOCK_PTR
, EDGE_FAKE
);
310 if (insn
== bb
->head
)
321 /* Find unreachable blocks. An unreachable block will have 0 in
322 the reachable bit in block->flags. A non-zero value indicates the
323 block is reachable. */
326 find_unreachable_blocks ()
330 basic_block
*tos
, *worklist
;
333 tos
= worklist
= (basic_block
*) xmalloc (sizeof (basic_block
) * n
);
335 /* Clear all the reachability flags. */
337 for (i
= 0; i
< n
; ++i
)
338 BASIC_BLOCK (i
)->flags
&= ~BB_REACHABLE
;
340 /* Add our starting points to the worklist. Almost always there will
341 be only one. It isn't inconceivable that we might one day directly
342 support Fortran alternate entry points. */
344 for (e
= ENTRY_BLOCK_PTR
->succ
; e
; e
= e
->succ_next
)
348 /* Mark the block reachable. */
349 e
->dest
->flags
|= BB_REACHABLE
;
352 /* Iterate: find everything reachable from what we've already seen. */
354 while (tos
!= worklist
)
356 basic_block b
= *--tos
;
358 for (e
= b
->succ
; e
; e
= e
->succ_next
)
359 if (!(e
->dest
->flags
& BB_REACHABLE
))
362 e
->dest
->flags
|= BB_REACHABLE
;
369 /* Functions to access an edge list with a vector representation.
370 Enough data is kept such that given an index number, the
371 pred and succ that edge represents can be determined, or
372 given a pred and a succ, its index number can be returned.
373 This allows algorithms which consume a lot of memory to
374 represent the normally full matrix of edge (pred,succ) with a
375 single indexed vector, edge (EDGE_INDEX (pred, succ)), with no
376 wasted space in the client code due to sparse flow graphs. */
378 /* This functions initializes the edge list. Basically the entire
379 flowgraph is processed, and all edges are assigned a number,
380 and the data structure is filled in. */
385 struct edge_list
*elist
;
391 block_count
= n_basic_blocks
+ 2; /* Include the entry and exit blocks. */
395 /* Determine the number of edges in the flow graph by counting successor
396 edges on each basic block. */
397 for (x
= 0; x
< n_basic_blocks
; x
++)
399 basic_block bb
= BASIC_BLOCK (x
);
401 for (e
= bb
->succ
; e
; e
= e
->succ_next
)
404 /* Don't forget successors of the entry block. */
405 for (e
= ENTRY_BLOCK_PTR
->succ
; e
; e
= e
->succ_next
)
408 elist
= (struct edge_list
*) xmalloc (sizeof (struct edge_list
));
409 elist
->num_blocks
= block_count
;
410 elist
->num_edges
= num_edges
;
411 elist
->index_to_edge
= (edge
*) xmalloc (sizeof (edge
) * num_edges
);
415 /* Follow successors of the entry block, and register these edges. */
416 for (e
= ENTRY_BLOCK_PTR
->succ
; e
; e
= e
->succ_next
)
418 elist
->index_to_edge
[num_edges
] = e
;
422 for (x
= 0; x
< n_basic_blocks
; x
++)
424 basic_block bb
= BASIC_BLOCK (x
);
426 /* Follow all successors of blocks, and register these edges. */
427 for (e
= bb
->succ
; e
; e
= e
->succ_next
)
429 elist
->index_to_edge
[num_edges
] = e
;
436 /* This function free's memory associated with an edge list. */
439 free_edge_list (elist
)
440 struct edge_list
*elist
;
444 free (elist
->index_to_edge
);
449 /* This function provides debug output showing an edge list. */
452 print_edge_list (f
, elist
)
454 struct edge_list
*elist
;
457 fprintf (f
, "Compressed edge list, %d BBs + entry & exit, and %d edges\n",
458 elist
->num_blocks
- 2, elist
->num_edges
);
460 for (x
= 0; x
< elist
->num_edges
; x
++)
462 fprintf (f
, " %-4d - edge(", x
);
463 if (INDEX_EDGE_PRED_BB (elist
, x
) == ENTRY_BLOCK_PTR
)
464 fprintf (f
, "entry,");
466 fprintf (f
, "%d,", INDEX_EDGE_PRED_BB (elist
, x
)->index
);
468 if (INDEX_EDGE_SUCC_BB (elist
, x
) == EXIT_BLOCK_PTR
)
469 fprintf (f
, "exit)\n");
471 fprintf (f
, "%d)\n", INDEX_EDGE_SUCC_BB (elist
, x
)->index
);
475 /* This function provides an internal consistency check of an edge list,
476 verifying that all edges are present, and that there are no
480 verify_edge_list (f
, elist
)
482 struct edge_list
*elist
;
484 int x
, pred
, succ
, index
;
487 for (x
= 0; x
< n_basic_blocks
; x
++)
489 basic_block bb
= BASIC_BLOCK (x
);
491 for (e
= bb
->succ
; e
; e
= e
->succ_next
)
493 pred
= e
->src
->index
;
494 succ
= e
->dest
->index
;
495 index
= EDGE_INDEX (elist
, e
->src
, e
->dest
);
496 if (index
== EDGE_INDEX_NO_EDGE
)
498 fprintf (f
, "*p* No index for edge from %d to %d\n", pred
, succ
);
501 if (INDEX_EDGE_PRED_BB (elist
, index
)->index
!= pred
)
502 fprintf (f
, "*p* Pred for index %d should be %d not %d\n",
503 index
, pred
, INDEX_EDGE_PRED_BB (elist
, index
)->index
);
504 if (INDEX_EDGE_SUCC_BB (elist
, index
)->index
!= succ
)
505 fprintf (f
, "*p* Succ for index %d should be %d not %d\n",
506 index
, succ
, INDEX_EDGE_SUCC_BB (elist
, index
)->index
);
509 for (e
= ENTRY_BLOCK_PTR
->succ
; e
; e
= e
->succ_next
)
511 pred
= e
->src
->index
;
512 succ
= e
->dest
->index
;
513 index
= EDGE_INDEX (elist
, e
->src
, e
->dest
);
514 if (index
== EDGE_INDEX_NO_EDGE
)
516 fprintf (f
, "*p* No index for edge from %d to %d\n", pred
, succ
);
519 if (INDEX_EDGE_PRED_BB (elist
, index
)->index
!= pred
)
520 fprintf (f
, "*p* Pred for index %d should be %d not %d\n",
521 index
, pred
, INDEX_EDGE_PRED_BB (elist
, index
)->index
);
522 if (INDEX_EDGE_SUCC_BB (elist
, index
)->index
!= succ
)
523 fprintf (f
, "*p* Succ for index %d should be %d not %d\n",
524 index
, succ
, INDEX_EDGE_SUCC_BB (elist
, index
)->index
);
526 /* We've verified that all the edges are in the list, no lets make sure
527 there are no spurious edges in the list. */
529 for (pred
= 0; pred
< n_basic_blocks
; pred
++)
530 for (succ
= 0; succ
< n_basic_blocks
; succ
++)
532 basic_block p
= BASIC_BLOCK (pred
);
533 basic_block s
= BASIC_BLOCK (succ
);
537 for (e
= p
->succ
; e
; e
= e
->succ_next
)
543 for (e
= s
->pred
; e
; e
= e
->pred_next
)
549 if (EDGE_INDEX (elist
, BASIC_BLOCK (pred
), BASIC_BLOCK (succ
))
550 == EDGE_INDEX_NO_EDGE
&& found_edge
!= 0)
551 fprintf (f
, "*** Edge (%d, %d) appears to not have an index\n",
553 if (EDGE_INDEX (elist
, BASIC_BLOCK (pred
), BASIC_BLOCK (succ
))
554 != EDGE_INDEX_NO_EDGE
&& found_edge
== 0)
555 fprintf (f
, "*** Edge (%d, %d) has index %d, but there is no edge\n",
556 pred
, succ
, EDGE_INDEX (elist
, BASIC_BLOCK (pred
),
557 BASIC_BLOCK (succ
)));
559 for (succ
= 0; succ
< n_basic_blocks
; succ
++)
561 basic_block p
= ENTRY_BLOCK_PTR
;
562 basic_block s
= BASIC_BLOCK (succ
);
566 for (e
= p
->succ
; e
; e
= e
->succ_next
)
572 for (e
= s
->pred
; e
; e
= e
->pred_next
)
578 if (EDGE_INDEX (elist
, ENTRY_BLOCK_PTR
, BASIC_BLOCK (succ
))
579 == EDGE_INDEX_NO_EDGE
&& found_edge
!= 0)
580 fprintf (f
, "*** Edge (entry, %d) appears to not have an index\n",
582 if (EDGE_INDEX (elist
, ENTRY_BLOCK_PTR
, BASIC_BLOCK (succ
))
583 != EDGE_INDEX_NO_EDGE
&& found_edge
== 0)
584 fprintf (f
, "*** Edge (entry, %d) has index %d, but no edge exists\n",
585 succ
, EDGE_INDEX (elist
, ENTRY_BLOCK_PTR
,
586 BASIC_BLOCK (succ
)));
588 for (pred
= 0; pred
< n_basic_blocks
; pred
++)
590 basic_block p
= BASIC_BLOCK (pred
);
591 basic_block s
= EXIT_BLOCK_PTR
;
595 for (e
= p
->succ
; e
; e
= e
->succ_next
)
601 for (e
= s
->pred
; e
; e
= e
->pred_next
)
607 if (EDGE_INDEX (elist
, BASIC_BLOCK (pred
), EXIT_BLOCK_PTR
)
608 == EDGE_INDEX_NO_EDGE
&& found_edge
!= 0)
609 fprintf (f
, "*** Edge (%d, exit) appears to not have an index\n",
611 if (EDGE_INDEX (elist
, BASIC_BLOCK (pred
), EXIT_BLOCK_PTR
)
612 != EDGE_INDEX_NO_EDGE
&& found_edge
== 0)
613 fprintf (f
, "*** Edge (%d, exit) has index %d, but no edge exists\n",
614 pred
, EDGE_INDEX (elist
, BASIC_BLOCK (pred
),
619 /* This routine will determine what, if any, edge there is between
620 a specified predecessor and successor. */
623 find_edge_index (edge_list
, pred
, succ
)
624 struct edge_list
*edge_list
;
625 basic_block pred
, succ
;
628 for (x
= 0; x
< NUM_EDGES (edge_list
); x
++)
630 if (INDEX_EDGE_PRED_BB (edge_list
, x
) == pred
631 && INDEX_EDGE_SUCC_BB (edge_list
, x
) == succ
)
634 return (EDGE_INDEX_NO_EDGE
);
637 /* Dump the list of basic blocks in the bitmap NODES. */
640 flow_nodes_print (str
, nodes
, file
)
650 fprintf (file
, "%s { ", str
);
651 EXECUTE_IF_SET_IN_SBITMAP (nodes
, 0, node
, {fprintf (file
, "%d ", node
);});
655 /* Dump the list of edges in the array EDGE_LIST. */
658 flow_edge_list_print (str
, edge_list
, num_edges
, file
)
660 const edge
*edge_list
;
669 fprintf (file
, "%s { ", str
);
670 for (i
= 0; i
< num_edges
; i
++)
671 fprintf (file
, "%d->%d ", edge_list
[i
]->src
->index
,
672 edge_list
[i
]->dest
->index
);
677 /* This routine will remove any fake successor edges for a basic block.
678 When the edge is removed, it is also removed from whatever predecessor
682 remove_fake_successors (bb
)
686 for (e
= bb
->succ
; e
;)
690 if ((tmp
->flags
& EDGE_FAKE
) == EDGE_FAKE
)
695 /* This routine will remove all fake edges from the flow graph. If
696 we remove all fake successors, it will automatically remove all
697 fake predecessors. */
704 for (x
= 0; x
< n_basic_blocks
; x
++)
705 remove_fake_successors (BASIC_BLOCK (x
));
707 /* We've handled all successors except the entry block's. */
708 remove_fake_successors (ENTRY_BLOCK_PTR
);
711 /* This function will add a fake edge between any block which has no
712 successors, and the exit block. Some data flow equations require these
716 add_noreturn_fake_exit_edges ()
720 for (x
= 0; x
< n_basic_blocks
; x
++)
721 if (BASIC_BLOCK (x
)->succ
== NULL
)
722 make_single_succ_edge (BASIC_BLOCK (x
), EXIT_BLOCK_PTR
, EDGE_FAKE
);
725 /* This function adds a fake edge between any infinite loops to the
726 exit block. Some optimizations require a path from each node to
729 See also Morgan, Figure 3.10, pp. 82-83.
731 The current implementation is ugly, not attempting to minimize the
732 number of inserted fake edges. To reduce the number of fake edges
733 to insert, add fake edges from _innermost_ loops containing only
734 nodes not reachable from the exit block. */
737 connect_infinite_loops_to_exit ()
739 basic_block unvisited_block
;
741 /* Perform depth-first search in the reverse graph to find nodes
742 reachable from the exit block. */
743 struct depth_first_search_dsS dfs_ds
;
745 flow_dfs_compute_reverse_init (&dfs_ds
);
746 flow_dfs_compute_reverse_add_bb (&dfs_ds
, EXIT_BLOCK_PTR
);
748 /* Repeatedly add fake edges, updating the unreachable nodes. */
751 unvisited_block
= flow_dfs_compute_reverse_execute (&dfs_ds
);
752 if (!unvisited_block
)
754 make_edge (unvisited_block
, EXIT_BLOCK_PTR
, EDGE_FAKE
);
755 flow_dfs_compute_reverse_add_bb (&dfs_ds
, unvisited_block
);
758 flow_dfs_compute_reverse_finish (&dfs_ds
);
763 /* Compute reverse top sort order */
765 flow_reverse_top_sort_order_compute (rts_order
)
773 /* Allocate stack for back-tracking up CFG. */
774 stack
= (edge
*) xmalloc ((n_basic_blocks
+ 1) * sizeof (edge
));
777 /* Allocate bitmap to track nodes that have been visited. */
778 visited
= sbitmap_alloc (n_basic_blocks
);
780 /* None of the nodes in the CFG have been visited yet. */
781 sbitmap_zero (visited
);
783 /* Push the first edge on to the stack. */
784 stack
[sp
++] = ENTRY_BLOCK_PTR
->succ
;
792 /* Look at the edge on the top of the stack. */
797 /* Check if the edge destination has been visited yet. */
798 if (dest
!= EXIT_BLOCK_PTR
&& ! TEST_BIT (visited
, dest
->index
))
800 /* Mark that we have visited the destination. */
801 SET_BIT (visited
, dest
->index
);
805 /* Since the DEST node has been visited for the first
806 time, check its successors. */
807 stack
[sp
++] = dest
->succ
;
810 rts_order
[postnum
++] = dest
->index
;
814 if (! e
->succ_next
&& src
!= ENTRY_BLOCK_PTR
)
815 rts_order
[postnum
++] = src
->index
;
818 stack
[sp
- 1] = e
->succ_next
;
825 sbitmap_free (visited
);
828 /* Compute the depth first search order and store in the array
829 DFS_ORDER if non-zero, marking the nodes visited in VISITED. If
830 RC_ORDER is non-zero, return the reverse completion number for each
831 node. Returns the number of nodes visited. A depth first search
832 tries to get as far away from the starting point as quickly as
836 flow_depth_first_order_compute (dfs_order
, rc_order
)
843 int rcnum
= n_basic_blocks
- 1;
846 /* Allocate stack for back-tracking up CFG. */
847 stack
= (edge
*) xmalloc ((n_basic_blocks
+ 1) * sizeof (edge
));
850 /* Allocate bitmap to track nodes that have been visited. */
851 visited
= sbitmap_alloc (n_basic_blocks
);
853 /* None of the nodes in the CFG have been visited yet. */
854 sbitmap_zero (visited
);
856 /* Push the first edge on to the stack. */
857 stack
[sp
++] = ENTRY_BLOCK_PTR
->succ
;
865 /* Look at the edge on the top of the stack. */
870 /* Check if the edge destination has been visited yet. */
871 if (dest
!= EXIT_BLOCK_PTR
&& ! TEST_BIT (visited
, dest
->index
))
873 /* Mark that we have visited the destination. */
874 SET_BIT (visited
, dest
->index
);
877 dfs_order
[dfsnum
++] = dest
->index
;
881 /* Since the DEST node has been visited for the first
882 time, check its successors. */
883 stack
[sp
++] = dest
->succ
;
887 /* There are no successors for the DEST node so assign
888 its reverse completion number. */
890 rc_order
[rcnum
--] = dest
->index
;
895 if (! e
->succ_next
&& src
!= ENTRY_BLOCK_PTR
)
897 /* There are no more successors for the SRC node
898 so assign its reverse completion number. */
900 rc_order
[rcnum
--] = src
->index
;
904 stack
[sp
- 1] = e
->succ_next
;
911 sbitmap_free (visited
);
913 /* The number of nodes visited should not be greater than
915 if (dfsnum
> n_basic_blocks
)
918 /* There are some nodes left in the CFG that are unreachable. */
919 if (dfsnum
< n_basic_blocks
)
924 /* Compute the depth first search order on the _reverse_ graph and
925 store in the array DFS_ORDER, marking the nodes visited in VISITED.
926 Returns the number of nodes visited.
928 The computation is split into three pieces:
930 flow_dfs_compute_reverse_init () creates the necessary data
933 flow_dfs_compute_reverse_add_bb () adds a basic block to the data
934 structures. The block will start the search.
936 flow_dfs_compute_reverse_execute () continues (or starts) the
937 search using the block on the top of the stack, stopping when the
940 flow_dfs_compute_reverse_finish () destroys the necessary data
943 Thus, the user will probably call ..._init(), call ..._add_bb() to
944 add a beginning basic block to the stack, call ..._execute(),
945 possibly add another bb to the stack and again call ..._execute(),
946 ..., and finally call _finish(). */
948 /* Initialize the data structures used for depth-first search on the
949 reverse graph. If INITIALIZE_STACK is nonzero, the exit block is
950 added to the basic block stack. DATA is the current depth-first
951 search context. If INITIALIZE_STACK is non-zero, there is an
952 element on the stack. */
955 flow_dfs_compute_reverse_init (data
)
956 depth_first_search_ds data
;
958 /* Allocate stack for back-tracking up CFG. */
960 (basic_block
*) xmalloc ((n_basic_blocks
- (INVALID_BLOCK
+ 1))
961 * sizeof (basic_block
));
964 /* Allocate bitmap to track nodes that have been visited. */
965 data
->visited_blocks
= sbitmap_alloc (n_basic_blocks
- (INVALID_BLOCK
+ 1));
967 /* None of the nodes in the CFG have been visited yet. */
968 sbitmap_zero (data
->visited_blocks
);
973 /* Add the specified basic block to the top of the dfs data
974 structures. When the search continues, it will start at the
978 flow_dfs_compute_reverse_add_bb (data
, bb
)
979 depth_first_search_ds data
;
982 data
->stack
[data
->sp
++] = bb
;
986 /* Continue the depth-first search through the reverse graph starting
987 with the block at the stack's top and ending when the stack is
988 empty. Visited nodes are marked. Returns an unvisited basic
989 block, or NULL if there is none available. */
992 flow_dfs_compute_reverse_execute (data
)
993 depth_first_search_ds data
;
1001 bb
= data
->stack
[--data
->sp
];
1003 /* Mark that we have visited this node. */
1004 if (!TEST_BIT (data
->visited_blocks
, bb
->index
- (INVALID_BLOCK
+ 1)))
1006 SET_BIT (data
->visited_blocks
, bb
->index
- (INVALID_BLOCK
+ 1));
1008 /* Perform depth-first search on adjacent vertices. */
1009 for (e
= bb
->pred
; e
; e
= e
->pred_next
)
1010 flow_dfs_compute_reverse_add_bb (data
, e
->src
);
1014 /* Determine if there are unvisited basic blocks. */
1015 for (i
= n_basic_blocks
- (INVALID_BLOCK
+ 1); --i
>= 0;)
1016 if (!TEST_BIT (data
->visited_blocks
, i
))
1017 return BASIC_BLOCK (i
+ (INVALID_BLOCK
+ 1));
1021 /* Destroy the data structures needed for depth-first search on the
1025 flow_dfs_compute_reverse_finish (data
)
1026 depth_first_search_ds data
;
1029 sbitmap_free (data
->visited_blocks
);