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 (active_insn_p (insn
))
72 insn
= NEXT_INSN (insn
);
74 return (!active_insn_p (insn
)
75 || (GET_CODE (insn
) == JUMP_INSN
&& onlyjump_p (insn
)));
78 /* Return nonzero if we can reach target from src by falling trought. */
80 can_fallthru (src
, target
)
81 basic_block src
, target
;
84 rtx insn2
= target
->head
;
86 if (src
->index
+ 1 == target
->index
&& !active_insn_p (insn2
))
87 insn2
= next_active_insn (insn2
);
88 /* ??? Later we may add code to move jump tables offline. */
89 return next_active_insn (insn
) == insn2
;
92 /* Mark the back edges in DFS traversal.
93 Return non-zero if a loop (natural or otherwise) is present.
94 Inspired by Depth_First_Search_PP described in:
96 Advanced Compiler Design and Implementation
100 and heavily borrowed from flow_depth_first_order_compute. */
103 mark_dfs_back_edges ()
114 /* Allocate the preorder and postorder number arrays. */
115 pre
= (int *) xcalloc (n_basic_blocks
, sizeof (int));
116 post
= (int *) xcalloc (n_basic_blocks
, sizeof (int));
118 /* Allocate stack for back-tracking up CFG. */
119 stack
= (edge
*) xmalloc ((n_basic_blocks
+ 1) * sizeof (edge
));
122 /* Allocate bitmap to track nodes that have been visited. */
123 visited
= sbitmap_alloc (n_basic_blocks
);
125 /* None of the nodes in the CFG have been visited yet. */
126 sbitmap_zero (visited
);
128 /* Push the first edge on to the stack. */
129 stack
[sp
++] = ENTRY_BLOCK_PTR
->succ
;
137 /* Look at the edge on the top of the stack. */
141 e
->flags
&= ~EDGE_DFS_BACK
;
143 /* Check if the edge destination has been visited yet. */
144 if (dest
!= EXIT_BLOCK_PTR
&& ! TEST_BIT (visited
, dest
->index
))
146 /* Mark that we have visited the destination. */
147 SET_BIT (visited
, dest
->index
);
149 pre
[dest
->index
] = prenum
++;
153 /* Since the DEST node has been visited for the first
154 time, check its successors. */
155 stack
[sp
++] = dest
->succ
;
158 post
[dest
->index
] = postnum
++;
162 if (dest
!= EXIT_BLOCK_PTR
&& src
!= ENTRY_BLOCK_PTR
163 && pre
[src
->index
] >= pre
[dest
->index
]
164 && post
[dest
->index
] == 0)
165 e
->flags
|= EDGE_DFS_BACK
, found
= true;
167 if (! e
->succ_next
&& src
!= ENTRY_BLOCK_PTR
)
168 post
[src
->index
] = postnum
++;
171 stack
[sp
- 1] = e
->succ_next
;
180 sbitmap_free (visited
);
185 /* Return true if we need to add fake edge to exit.
186 Helper function for the flow_call_edges_add. */
189 need_fake_edge_p (insn
)
195 if ((GET_CODE (insn
) == CALL_INSN
196 && !SIBLING_CALL_P (insn
)
197 && !find_reg_note (insn
, REG_NORETURN
, NULL
)
198 && !find_reg_note (insn
, REG_ALWAYS_RETURN
, NULL
)
199 && !CONST_OR_PURE_CALL_P (insn
)))
202 return ((GET_CODE (PATTERN (insn
)) == ASM_OPERANDS
203 && MEM_VOLATILE_P (PATTERN (insn
)))
204 || (GET_CODE (PATTERN (insn
)) == PARALLEL
205 && asm_noperands (insn
) != -1
206 && MEM_VOLATILE_P (XVECEXP (PATTERN (insn
), 0, 0)))
207 || GET_CODE (PATTERN (insn
)) == ASM_INPUT
);
210 /* Add fake edges to the function exit for any non constant and non noreturn
211 calls, volatile inline assembly in the bitmap of blocks specified by
212 BLOCKS or to the whole CFG if BLOCKS is zero. Return the nuber of blocks
215 The goal is to expose cases in which entering a basic block does not imply
216 that all subsequent instructions must be executed. */
219 flow_call_edges_add (blocks
)
223 int blocks_split
= 0;
226 bool check_last_block
= false;
228 /* Map bb indicies into basic block pointers since split_block
229 will renumber the basic blocks. */
231 bbs
= xmalloc (n_basic_blocks
* sizeof (*bbs
));
235 for (i
= 0; i
< n_basic_blocks
; i
++)
236 bbs
[bb_num
++] = BASIC_BLOCK (i
);
237 check_last_block
= true;
241 EXECUTE_IF_SET_IN_SBITMAP (blocks
, 0, i
,
243 bbs
[bb_num
++] = BASIC_BLOCK (i
);
244 if (i
== n_basic_blocks
- 1)
245 check_last_block
= true;
249 /* In the last basic block, before epilogue generation, there will be
250 a fallthru edge to EXIT. Special care is required if the last insn
251 of the last basic block is a call because make_edge folds duplicate
252 edges, which would result in the fallthru edge also being marked
253 fake, which would result in the fallthru edge being removed by
254 remove_fake_edges, which would result in an invalid CFG.
256 Moreover, we can't elide the outgoing fake edge, since the block
257 profiler needs to take this into account in order to solve the minimal
258 spanning tree in the case that the call doesn't return.
260 Handle this by adding a dummy instruction in a new last basic block. */
262 && need_fake_edge_p (BASIC_BLOCK (n_basic_blocks
- 1)->end
))
265 for (e
= BASIC_BLOCK (n_basic_blocks
- 1)->succ
; e
; e
= e
->succ_next
)
266 if (e
->dest
== EXIT_BLOCK_PTR
)
268 insert_insn_on_edge (gen_rtx_USE (VOIDmode
, const0_rtx
), e
);
269 commit_edge_insertions ();
273 /* Now add fake edges to the function exit for any non constant
274 calls since there is no way that we can determine if they will
277 for (i
= 0; i
< bb_num
; i
++)
279 basic_block bb
= bbs
[i
];
283 for (insn
= bb
->end
; ; insn
= prev_insn
)
285 prev_insn
= PREV_INSN (insn
);
286 if (need_fake_edge_p (insn
))
290 /* The above condition should be enought to verify that there is
291 no edge to the exit block in CFG already. Calling make_edge in
292 such case would make us to mark that edge as fake and remove it
294 #ifdef ENABLE_CHECKING
296 for (e
= bb
->succ
; e
; e
= e
->succ_next
)
297 if (e
->dest
== EXIT_BLOCK_PTR
)
301 /* Note that the following may create a new basic block
302 and renumber the existing basic blocks. */
303 e
= split_block (bb
, insn
);
307 make_edge (bb
, EXIT_BLOCK_PTR
, EDGE_FAKE
);
309 if (insn
== bb
->head
)
320 /* Find unreachable blocks. An unreachable block will have 0 in
321 the reachable bit in block->flags. A non-zero value indicates the
322 block is reachable. */
325 find_unreachable_blocks ()
329 basic_block
*tos
, *worklist
;
332 tos
= worklist
= (basic_block
*) xmalloc (sizeof (basic_block
) * n
);
334 /* Clear all the reachability flags. */
336 for (i
= 0; i
< n
; ++i
)
337 BASIC_BLOCK (i
)->flags
&= ~BB_REACHABLE
;
339 /* Add our starting points to the worklist. Almost always there will
340 be only one. It isn't inconcievable that we might one day directly
341 support Fortran alternate entry points. */
343 for (e
= ENTRY_BLOCK_PTR
->succ
; e
; e
= e
->succ_next
)
347 /* Mark the block reachable. */
348 e
->dest
->flags
|= BB_REACHABLE
;
351 /* Iterate: find everything reachable from what we've already seen. */
353 while (tos
!= worklist
)
355 basic_block b
= *--tos
;
357 for (e
= b
->succ
; e
; e
= e
->succ_next
)
358 if (!(e
->dest
->flags
& BB_REACHABLE
))
361 e
->dest
->flags
|= BB_REACHABLE
;
368 /* Functions to access an edge list with a vector representation.
369 Enough data is kept such that given an index number, the
370 pred and succ that edge represents can be determined, or
371 given a pred and a succ, its index number can be returned.
372 This allows algorithms which consume a lot of memory to
373 represent the normally full matrix of edge (pred,succ) with a
374 single indexed vector, edge (EDGE_INDEX (pred, succ)), with no
375 wasted space in the client code due to sparse flow graphs. */
377 /* This functions initializes the edge list. Basically the entire
378 flowgraph is processed, and all edges are assigned a number,
379 and the data structure is filled in. */
384 struct edge_list
*elist
;
390 block_count
= n_basic_blocks
+ 2; /* Include the entry and exit blocks. */
394 /* Determine the number of edges in the flow graph by counting successor
395 edges on each basic block. */
396 for (x
= 0; x
< n_basic_blocks
; x
++)
398 basic_block bb
= BASIC_BLOCK (x
);
400 for (e
= bb
->succ
; e
; e
= e
->succ_next
)
403 /* Don't forget successors of the entry block. */
404 for (e
= ENTRY_BLOCK_PTR
->succ
; e
; e
= e
->succ_next
)
407 elist
= (struct edge_list
*) xmalloc (sizeof (struct edge_list
));
408 elist
->num_blocks
= block_count
;
409 elist
->num_edges
= num_edges
;
410 elist
->index_to_edge
= (edge
*) xmalloc (sizeof (edge
) * num_edges
);
414 /* Follow successors of the entry block, and register these edges. */
415 for (e
= ENTRY_BLOCK_PTR
->succ
; e
; e
= e
->succ_next
)
417 elist
->index_to_edge
[num_edges
] = e
;
421 for (x
= 0; x
< n_basic_blocks
; x
++)
423 basic_block bb
= BASIC_BLOCK (x
);
425 /* Follow all successors of blocks, and register these edges. */
426 for (e
= bb
->succ
; e
; e
= e
->succ_next
)
428 elist
->index_to_edge
[num_edges
] = e
;
435 /* This function free's memory associated with an edge list. */
438 free_edge_list (elist
)
439 struct edge_list
*elist
;
443 free (elist
->index_to_edge
);
448 /* This function provides debug output showing an edge list. */
451 print_edge_list (f
, elist
)
453 struct edge_list
*elist
;
456 fprintf (f
, "Compressed edge list, %d BBs + entry & exit, and %d edges\n",
457 elist
->num_blocks
- 2, elist
->num_edges
);
459 for (x
= 0; x
< elist
->num_edges
; x
++)
461 fprintf (f
, " %-4d - edge(", x
);
462 if (INDEX_EDGE_PRED_BB (elist
, x
) == ENTRY_BLOCK_PTR
)
463 fprintf (f
, "entry,");
465 fprintf (f
, "%d,", INDEX_EDGE_PRED_BB (elist
, x
)->index
);
467 if (INDEX_EDGE_SUCC_BB (elist
, x
) == EXIT_BLOCK_PTR
)
468 fprintf (f
, "exit)\n");
470 fprintf (f
, "%d)\n", INDEX_EDGE_SUCC_BB (elist
, x
)->index
);
474 /* This function provides an internal consistency check of an edge list,
475 verifying that all edges are present, and that there are no
479 verify_edge_list (f
, elist
)
481 struct edge_list
*elist
;
483 int x
, pred
, succ
, index
;
486 for (x
= 0; x
< n_basic_blocks
; x
++)
488 basic_block bb
= BASIC_BLOCK (x
);
490 for (e
= bb
->succ
; e
; e
= e
->succ_next
)
492 pred
= e
->src
->index
;
493 succ
= e
->dest
->index
;
494 index
= EDGE_INDEX (elist
, e
->src
, e
->dest
);
495 if (index
== EDGE_INDEX_NO_EDGE
)
497 fprintf (f
, "*p* No index for edge from %d to %d\n", pred
, succ
);
500 if (INDEX_EDGE_PRED_BB (elist
, index
)->index
!= pred
)
501 fprintf (f
, "*p* Pred for index %d should be %d not %d\n",
502 index
, pred
, INDEX_EDGE_PRED_BB (elist
, index
)->index
);
503 if (INDEX_EDGE_SUCC_BB (elist
, index
)->index
!= succ
)
504 fprintf (f
, "*p* Succ for index %d should be %d not %d\n",
505 index
, succ
, INDEX_EDGE_SUCC_BB (elist
, index
)->index
);
508 for (e
= ENTRY_BLOCK_PTR
->succ
; e
; e
= e
->succ_next
)
510 pred
= e
->src
->index
;
511 succ
= e
->dest
->index
;
512 index
= EDGE_INDEX (elist
, e
->src
, e
->dest
);
513 if (index
== EDGE_INDEX_NO_EDGE
)
515 fprintf (f
, "*p* No index for edge from %d to %d\n", pred
, succ
);
518 if (INDEX_EDGE_PRED_BB (elist
, index
)->index
!= pred
)
519 fprintf (f
, "*p* Pred for index %d should be %d not %d\n",
520 index
, pred
, INDEX_EDGE_PRED_BB (elist
, index
)->index
);
521 if (INDEX_EDGE_SUCC_BB (elist
, index
)->index
!= succ
)
522 fprintf (f
, "*p* Succ for index %d should be %d not %d\n",
523 index
, succ
, INDEX_EDGE_SUCC_BB (elist
, index
)->index
);
525 /* We've verified that all the edges are in the list, no lets make sure
526 there are no spurious edges in the list. */
528 for (pred
= 0; pred
< n_basic_blocks
; pred
++)
529 for (succ
= 0; succ
< n_basic_blocks
; succ
++)
531 basic_block p
= BASIC_BLOCK (pred
);
532 basic_block s
= BASIC_BLOCK (succ
);
536 for (e
= p
->succ
; e
; e
= e
->succ_next
)
542 for (e
= s
->pred
; e
; e
= e
->pred_next
)
548 if (EDGE_INDEX (elist
, BASIC_BLOCK (pred
), BASIC_BLOCK (succ
))
549 == EDGE_INDEX_NO_EDGE
&& found_edge
!= 0)
550 fprintf (f
, "*** Edge (%d, %d) appears to not have an index\n",
552 if (EDGE_INDEX (elist
, BASIC_BLOCK (pred
), BASIC_BLOCK (succ
))
553 != EDGE_INDEX_NO_EDGE
&& found_edge
== 0)
554 fprintf (f
, "*** Edge (%d, %d) has index %d, but there is no edge\n",
555 pred
, succ
, EDGE_INDEX (elist
, BASIC_BLOCK (pred
),
556 BASIC_BLOCK (succ
)));
558 for (succ
= 0; succ
< n_basic_blocks
; succ
++)
560 basic_block p
= ENTRY_BLOCK_PTR
;
561 basic_block s
= BASIC_BLOCK (succ
);
565 for (e
= p
->succ
; e
; e
= e
->succ_next
)
571 for (e
= s
->pred
; e
; e
= e
->pred_next
)
577 if (EDGE_INDEX (elist
, ENTRY_BLOCK_PTR
, BASIC_BLOCK (succ
))
578 == EDGE_INDEX_NO_EDGE
&& found_edge
!= 0)
579 fprintf (f
, "*** Edge (entry, %d) appears to not have an index\n",
581 if (EDGE_INDEX (elist
, ENTRY_BLOCK_PTR
, BASIC_BLOCK (succ
))
582 != EDGE_INDEX_NO_EDGE
&& found_edge
== 0)
583 fprintf (f
, "*** Edge (entry, %d) has index %d, but no edge exists\n",
584 succ
, EDGE_INDEX (elist
, ENTRY_BLOCK_PTR
,
585 BASIC_BLOCK (succ
)));
587 for (pred
= 0; pred
< n_basic_blocks
; pred
++)
589 basic_block p
= BASIC_BLOCK (pred
);
590 basic_block s
= EXIT_BLOCK_PTR
;
594 for (e
= p
->succ
; e
; e
= e
->succ_next
)
600 for (e
= s
->pred
; e
; e
= e
->pred_next
)
606 if (EDGE_INDEX (elist
, BASIC_BLOCK (pred
), EXIT_BLOCK_PTR
)
607 == EDGE_INDEX_NO_EDGE
&& found_edge
!= 0)
608 fprintf (f
, "*** Edge (%d, exit) appears to not have an index\n",
610 if (EDGE_INDEX (elist
, BASIC_BLOCK (pred
), EXIT_BLOCK_PTR
)
611 != EDGE_INDEX_NO_EDGE
&& found_edge
== 0)
612 fprintf (f
, "*** Edge (%d, exit) has index %d, but no edge exists\n",
613 pred
, EDGE_INDEX (elist
, BASIC_BLOCK (pred
),
618 /* This routine will determine what, if any, edge there is between
619 a specified predecessor and successor. */
622 find_edge_index (edge_list
, pred
, succ
)
623 struct edge_list
*edge_list
;
624 basic_block pred
, succ
;
627 for (x
= 0; x
< NUM_EDGES (edge_list
); x
++)
629 if (INDEX_EDGE_PRED_BB (edge_list
, x
) == pred
630 && INDEX_EDGE_SUCC_BB (edge_list
, x
) == succ
)
633 return (EDGE_INDEX_NO_EDGE
);
636 /* Dump the list of basic blocks in the bitmap NODES. */
639 flow_nodes_print (str
, nodes
, file
)
649 fprintf (file
, "%s { ", str
);
650 EXECUTE_IF_SET_IN_SBITMAP (nodes
, 0, node
, {fprintf (file
, "%d ", node
);});
654 /* Dump the list of edges in the array EDGE_LIST. */
657 flow_edge_list_print (str
, edge_list
, num_edges
, file
)
659 const edge
*edge_list
;
668 fprintf (file
, "%s { ", str
);
669 for (i
= 0; i
< num_edges
; i
++)
670 fprintf (file
, "%d->%d ", edge_list
[i
]->src
->index
,
671 edge_list
[i
]->dest
->index
);
676 /* This routine will remove any fake successor edges for a basic block.
677 When the edge is removed, it is also removed from whatever predecessor
681 remove_fake_successors (bb
)
685 for (e
= bb
->succ
; e
;)
689 if ((tmp
->flags
& EDGE_FAKE
) == EDGE_FAKE
)
694 /* This routine will remove all fake edges from the flow graph. If
695 we remove all fake successors, it will automatically remove all
696 fake predecessors. */
703 for (x
= 0; x
< n_basic_blocks
; x
++)
704 remove_fake_successors (BASIC_BLOCK (x
));
706 /* We've handled all successors except the entry block's. */
707 remove_fake_successors (ENTRY_BLOCK_PTR
);
710 /* This function will add a fake edge between any block which has no
711 successors, and the exit block. Some data flow equations require these
715 add_noreturn_fake_exit_edges ()
719 for (x
= 0; x
< n_basic_blocks
; x
++)
720 if (BASIC_BLOCK (x
)->succ
== NULL
)
721 make_single_succ_edge (BASIC_BLOCK (x
), EXIT_BLOCK_PTR
, EDGE_FAKE
);
724 /* This function adds a fake edge between any infinite loops to the
725 exit block. Some optimizations require a path from each node to
728 See also Morgan, Figure 3.10, pp. 82-83.
730 The current implementation is ugly, not attempting to minimize the
731 number of inserted fake edges. To reduce the number of fake edges
732 to insert, add fake edges from _innermost_ loops containing only
733 nodes not reachable from the exit block. */
736 connect_infinite_loops_to_exit ()
738 basic_block unvisited_block
;
740 /* Perform depth-first search in the reverse graph to find nodes
741 reachable from the exit block. */
742 struct depth_first_search_dsS dfs_ds
;
744 flow_dfs_compute_reverse_init (&dfs_ds
);
745 flow_dfs_compute_reverse_add_bb (&dfs_ds
, EXIT_BLOCK_PTR
);
747 /* Repeatedly add fake edges, updating the unreachable nodes. */
750 unvisited_block
= flow_dfs_compute_reverse_execute (&dfs_ds
);
751 if (!unvisited_block
)
753 make_edge (unvisited_block
, EXIT_BLOCK_PTR
, EDGE_FAKE
);
754 flow_dfs_compute_reverse_add_bb (&dfs_ds
, unvisited_block
);
757 flow_dfs_compute_reverse_finish (&dfs_ds
);
762 /* Compute reverse top sort order */
764 flow_reverse_top_sort_order_compute (rts_order
)
772 /* Allocate stack for back-tracking up CFG. */
773 stack
= (edge
*) xmalloc ((n_basic_blocks
+ 1) * sizeof (edge
));
776 /* Allocate bitmap to track nodes that have been visited. */
777 visited
= sbitmap_alloc (n_basic_blocks
);
779 /* None of the nodes in the CFG have been visited yet. */
780 sbitmap_zero (visited
);
782 /* Push the first edge on to the stack. */
783 stack
[sp
++] = ENTRY_BLOCK_PTR
->succ
;
791 /* Look at the edge on the top of the stack. */
796 /* Check if the edge destination has been visited yet. */
797 if (dest
!= EXIT_BLOCK_PTR
&& ! TEST_BIT (visited
, dest
->index
))
799 /* Mark that we have visited the destination. */
800 SET_BIT (visited
, dest
->index
);
804 /* Since the DEST node has been visited for the first
805 time, check its successors. */
806 stack
[sp
++] = dest
->succ
;
809 rts_order
[postnum
++] = dest
->index
;
813 if (! e
->succ_next
&& src
!= ENTRY_BLOCK_PTR
)
814 rts_order
[postnum
++] = src
->index
;
817 stack
[sp
- 1] = e
->succ_next
;
824 sbitmap_free (visited
);
827 /* Compute the depth first search order and store in the array
828 DFS_ORDER if non-zero, marking the nodes visited in VISITED. If
829 RC_ORDER is non-zero, return the reverse completion number for each
830 node. Returns the number of nodes visited. A depth first search
831 tries to get as far away from the starting point as quickly as
835 flow_depth_first_order_compute (dfs_order
, rc_order
)
842 int rcnum
= n_basic_blocks
- 1;
845 /* Allocate stack for back-tracking up CFG. */
846 stack
= (edge
*) xmalloc ((n_basic_blocks
+ 1) * sizeof (edge
));
849 /* Allocate bitmap to track nodes that have been visited. */
850 visited
= sbitmap_alloc (n_basic_blocks
);
852 /* None of the nodes in the CFG have been visited yet. */
853 sbitmap_zero (visited
);
855 /* Push the first edge on to the stack. */
856 stack
[sp
++] = ENTRY_BLOCK_PTR
->succ
;
864 /* Look at the edge on the top of the stack. */
869 /* Check if the edge destination has been visited yet. */
870 if (dest
!= EXIT_BLOCK_PTR
&& ! TEST_BIT (visited
, dest
->index
))
872 /* Mark that we have visited the destination. */
873 SET_BIT (visited
, dest
->index
);
876 dfs_order
[dfsnum
++] = dest
->index
;
880 /* Since the DEST node has been visited for the first
881 time, check its successors. */
882 stack
[sp
++] = dest
->succ
;
886 /* There are no successors for the DEST node so assign
887 its reverse completion number. */
889 rc_order
[rcnum
--] = dest
->index
;
894 if (! e
->succ_next
&& src
!= ENTRY_BLOCK_PTR
)
896 /* There are no more successors for the SRC node
897 so assign its reverse completion number. */
899 rc_order
[rcnum
--] = src
->index
;
903 stack
[sp
- 1] = e
->succ_next
;
910 sbitmap_free (visited
);
912 /* The number of nodes visited should not be greater than
914 if (dfsnum
> n_basic_blocks
)
917 /* There are some nodes left in the CFG that are unreachable. */
918 if (dfsnum
< n_basic_blocks
)
923 /* Compute the depth first search order on the _reverse_ graph and
924 store in the array DFS_ORDER, marking the nodes visited in VISITED.
925 Returns the number of nodes visited.
927 The computation is split into three pieces:
929 flow_dfs_compute_reverse_init () creates the necessary data
932 flow_dfs_compute_reverse_add_bb () adds a basic block to the data
933 structures. The block will start the search.
935 flow_dfs_compute_reverse_execute () continues (or starts) the
936 search using the block on the top of the stack, stopping when the
939 flow_dfs_compute_reverse_finish () destroys the necessary data
942 Thus, the user will probably call ..._init(), call ..._add_bb() to
943 add a beginning basic block to the stack, call ..._execute(),
944 possibly add another bb to the stack and again call ..._execute(),
945 ..., and finally call _finish(). */
947 /* Initialize the data structures used for depth-first search on the
948 reverse graph. If INITIALIZE_STACK is nonzero, the exit block is
949 added to the basic block stack. DATA is the current depth-first
950 search context. If INITIALIZE_STACK is non-zero, there is an
951 element on the stack. */
954 flow_dfs_compute_reverse_init (data
)
955 depth_first_search_ds data
;
957 /* Allocate stack for back-tracking up CFG. */
959 (basic_block
*) xmalloc ((n_basic_blocks
- (INVALID_BLOCK
+ 1))
960 * sizeof (basic_block
));
963 /* Allocate bitmap to track nodes that have been visited. */
964 data
->visited_blocks
= sbitmap_alloc (n_basic_blocks
- (INVALID_BLOCK
+ 1));
966 /* None of the nodes in the CFG have been visited yet. */
967 sbitmap_zero (data
->visited_blocks
);
972 /* Add the specified basic block to the top of the dfs data
973 structures. When the search continues, it will start at the
977 flow_dfs_compute_reverse_add_bb (data
, bb
)
978 depth_first_search_ds data
;
981 data
->stack
[data
->sp
++] = bb
;
985 /* Continue the depth-first search through the reverse graph starting
986 with the block at the stack's top and ending when the stack is
987 empty. Visited nodes are marked. Returns an unvisited basic
988 block, or NULL if there is none available. */
991 flow_dfs_compute_reverse_execute (data
)
992 depth_first_search_ds data
;
1000 bb
= data
->stack
[--data
->sp
];
1002 /* Mark that we have visited this node. */
1003 if (!TEST_BIT (data
->visited_blocks
, bb
->index
- (INVALID_BLOCK
+ 1)))
1005 SET_BIT (data
->visited_blocks
, bb
->index
- (INVALID_BLOCK
+ 1));
1007 /* Perform depth-first search on adjacent vertices. */
1008 for (e
= bb
->pred
; e
; e
= e
->pred_next
)
1009 flow_dfs_compute_reverse_add_bb (data
, e
->src
);
1013 /* Determine if there are unvisited basic blocks. */
1014 for (i
= n_basic_blocks
- (INVALID_BLOCK
+ 1); --i
>= 0;)
1015 if (!TEST_BIT (data
->visited_blocks
, i
))
1016 return BASIC_BLOCK (i
+ (INVALID_BLOCK
+ 1));
1020 /* Destroy the data structures needed for depth-first search on the
1024 flow_dfs_compute_reverse_finish (data
)
1025 depth_first_search_ds data
;
1028 sbitmap_free (data
->visited_blocks
);