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, 2003 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. */
25 #include "coretypes.h"
28 #include "hard-reg-set.h"
29 #include "basic-block.h"
30 #include "insn-config.h"
35 /* Store the data structures necessary for depth-first search. */
36 struct depth_first_search_dsS
{
37 /* stack for backtracking during the algorithm */
40 /* number of edges in the stack. That is, positions 0, ..., sp-1
44 /* record of basic blocks already seen by depth-first search */
45 sbitmap visited_blocks
;
47 typedef struct depth_first_search_dsS
*depth_first_search_ds
;
49 static void flow_dfs_compute_reverse_init (depth_first_search_ds
);
50 static void flow_dfs_compute_reverse_add_bb (depth_first_search_ds
,
52 static basic_block
flow_dfs_compute_reverse_execute (depth_first_search_ds
);
53 static void flow_dfs_compute_reverse_finish (depth_first_search_ds
);
54 static void remove_fake_successors (basic_block
);
55 static bool need_fake_edge_p (rtx
);
56 static bool flow_active_insn_p (rtx
);
58 /* Like active_insn_p, except keep the return value clobber around
62 flow_active_insn_p (rtx insn
)
64 if (active_insn_p (insn
))
67 /* A clobber of the function return value exists for buggy
68 programs that fail to return a value. Its effect is to
69 keep the return value from being live across the entire
70 function. If we allow it to be skipped, we introduce the
71 possibility for register livetime aborts. */
72 if (GET_CODE (PATTERN (insn
)) == CLOBBER
73 && GET_CODE (XEXP (PATTERN (insn
), 0)) == REG
74 && REG_FUNCTION_VALUE_P (XEXP (PATTERN (insn
), 0)))
80 /* Return true if the block has no effect and only forwards control flow to
81 its single destination. */
84 forwarder_block_p (basic_block bb
)
88 if (bb
== EXIT_BLOCK_PTR
|| bb
== ENTRY_BLOCK_PTR
89 || !bb
->succ
|| bb
->succ
->succ_next
)
92 for (insn
= bb
->head
; insn
!= bb
->end
; insn
= NEXT_INSN (insn
))
93 if (INSN_P (insn
) && flow_active_insn_p (insn
))
96 return (!INSN_P (insn
)
97 || (GET_CODE (insn
) == JUMP_INSN
&& simplejump_p (insn
))
98 || !flow_active_insn_p (insn
));
101 /* Return nonzero if we can reach target from src by falling through. */
104 can_fallthru (basic_block src
, basic_block target
)
107 rtx insn2
= target
== EXIT_BLOCK_PTR
? NULL
: target
->head
;
109 if (src
->next_bb
!= target
)
112 if (insn2
&& !active_insn_p (insn2
))
113 insn2
= next_active_insn (insn2
);
115 /* ??? Later we may add code to move jump tables offline. */
116 return next_active_insn (insn
) == insn2
;
119 /* Mark the back edges in DFS traversal.
120 Return nonzero if a loop (natural or otherwise) is present.
121 Inspired by Depth_First_Search_PP described in:
123 Advanced Compiler Design and Implementation
125 Morgan Kaufmann, 1997
127 and heavily borrowed from flow_depth_first_order_compute. */
130 mark_dfs_back_edges (void)
141 /* Allocate the preorder and postorder number arrays. */
142 pre
= (int *) xcalloc (last_basic_block
, sizeof (int));
143 post
= (int *) xcalloc (last_basic_block
, sizeof (int));
145 /* Allocate stack for back-tracking up CFG. */
146 stack
= (edge
*) xmalloc ((n_basic_blocks
+ 1) * sizeof (edge
));
149 /* Allocate bitmap to track nodes that have been visited. */
150 visited
= sbitmap_alloc (last_basic_block
);
152 /* None of the nodes in the CFG have been visited yet. */
153 sbitmap_zero (visited
);
155 /* Push the first edge on to the stack. */
156 stack
[sp
++] = ENTRY_BLOCK_PTR
->succ
;
164 /* Look at the edge on the top of the stack. */
168 e
->flags
&= ~EDGE_DFS_BACK
;
170 /* Check if the edge destination has been visited yet. */
171 if (dest
!= EXIT_BLOCK_PTR
&& ! TEST_BIT (visited
, dest
->index
))
173 /* Mark that we have visited the destination. */
174 SET_BIT (visited
, dest
->index
);
176 pre
[dest
->index
] = prenum
++;
179 /* Since the DEST node has been visited for the first
180 time, check its successors. */
181 stack
[sp
++] = dest
->succ
;
184 post
[dest
->index
] = postnum
++;
188 if (dest
!= EXIT_BLOCK_PTR
&& src
!= ENTRY_BLOCK_PTR
189 && pre
[src
->index
] >= pre
[dest
->index
]
190 && post
[dest
->index
] == 0)
191 e
->flags
|= EDGE_DFS_BACK
, found
= true;
193 if (! e
->succ_next
&& src
!= ENTRY_BLOCK_PTR
)
194 post
[src
->index
] = postnum
++;
197 stack
[sp
- 1] = e
->succ_next
;
206 sbitmap_free (visited
);
211 /* Set the flag EDGE_CAN_FALLTHRU for edges that can be fallthru. */
214 set_edge_can_fallthru_flag (void)
222 for (e
= bb
->succ
; e
; e
= e
->succ_next
)
224 e
->flags
&= ~EDGE_CAN_FALLTHRU
;
226 /* The FALLTHRU edge is also CAN_FALLTHRU edge. */
227 if (e
->flags
& EDGE_FALLTHRU
)
228 e
->flags
|= EDGE_CAN_FALLTHRU
;
231 /* If the BB ends with an invertible condjump all (2) edges are
232 CAN_FALLTHRU edges. */
233 if (!bb
->succ
|| !bb
->succ
->succ_next
|| bb
->succ
->succ_next
->succ_next
)
235 if (!any_condjump_p (bb
->end
))
237 if (!invert_jump (bb
->end
, JUMP_LABEL (bb
->end
), 0))
239 invert_jump (bb
->end
, JUMP_LABEL (bb
->end
), 0);
240 bb
->succ
->flags
|= EDGE_CAN_FALLTHRU
;
241 bb
->succ
->succ_next
->flags
|= EDGE_CAN_FALLTHRU
;
245 /* Return true if we need to add fake edge to exit.
246 Helper function for the flow_call_edges_add. */
249 need_fake_edge_p (rtx insn
)
254 if ((GET_CODE (insn
) == CALL_INSN
255 && !SIBLING_CALL_P (insn
)
256 && !find_reg_note (insn
, REG_NORETURN
, NULL
)
257 && !find_reg_note (insn
, REG_ALWAYS_RETURN
, NULL
)
258 && !CONST_OR_PURE_CALL_P (insn
)))
261 return ((GET_CODE (PATTERN (insn
)) == ASM_OPERANDS
262 && MEM_VOLATILE_P (PATTERN (insn
)))
263 || (GET_CODE (PATTERN (insn
)) == PARALLEL
264 && asm_noperands (insn
) != -1
265 && MEM_VOLATILE_P (XVECEXP (PATTERN (insn
), 0, 0)))
266 || GET_CODE (PATTERN (insn
)) == ASM_INPUT
);
269 /* Add fake edges to the function exit for any non constant and non noreturn
270 calls, volatile inline assembly in the bitmap of blocks specified by
271 BLOCKS or to the whole CFG if BLOCKS is zero. Return the number of blocks
274 The goal is to expose cases in which entering a basic block does not imply
275 that all subsequent instructions must be executed. */
278 flow_call_edges_add (sbitmap blocks
)
281 int blocks_split
= 0;
282 int last_bb
= last_basic_block
;
283 bool check_last_block
= false;
285 if (n_basic_blocks
== 0)
289 check_last_block
= true;
291 check_last_block
= TEST_BIT (blocks
, EXIT_BLOCK_PTR
->prev_bb
->index
);
293 /* In the last basic block, before epilogue generation, there will be
294 a fallthru edge to EXIT. Special care is required if the last insn
295 of the last basic block is a call because make_edge folds duplicate
296 edges, which would result in the fallthru edge also being marked
297 fake, which would result in the fallthru edge being removed by
298 remove_fake_edges, which would result in an invalid CFG.
300 Moreover, we can't elide the outgoing fake edge, since the block
301 profiler needs to take this into account in order to solve the minimal
302 spanning tree in the case that the call doesn't return.
304 Handle this by adding a dummy instruction in a new last basic block. */
305 if (check_last_block
)
307 basic_block bb
= EXIT_BLOCK_PTR
->prev_bb
;
310 /* Back up past insns that must be kept in the same block as a call. */
311 while (insn
!= bb
->head
312 && keep_with_call_p (insn
))
313 insn
= PREV_INSN (insn
);
315 if (need_fake_edge_p (insn
))
319 for (e
= bb
->succ
; e
; e
= e
->succ_next
)
320 if (e
->dest
== EXIT_BLOCK_PTR
)
322 insert_insn_on_edge (gen_rtx_USE (VOIDmode
, const0_rtx
), e
);
323 commit_edge_insertions ();
329 /* Now add fake edges to the function exit for any non constant
330 calls since there is no way that we can determine if they will
333 for (i
= 0; i
< last_bb
; i
++)
335 basic_block bb
= BASIC_BLOCK (i
);
342 if (blocks
&& !TEST_BIT (blocks
, i
))
345 for (insn
= bb
->end
; ; insn
= prev_insn
)
347 prev_insn
= PREV_INSN (insn
);
348 if (need_fake_edge_p (insn
))
351 rtx split_at_insn
= insn
;
353 /* Don't split the block between a call and an insn that should
354 remain in the same block as the call. */
355 if (GET_CODE (insn
) == CALL_INSN
)
356 while (split_at_insn
!= bb
->end
357 && keep_with_call_p (NEXT_INSN (split_at_insn
)))
358 split_at_insn
= NEXT_INSN (split_at_insn
);
360 /* The handling above of the final block before the epilogue
361 should be enough to verify that there is no edge to the exit
362 block in CFG already. Calling make_edge in such case would
363 cause us to mark that edge as fake and remove it later. */
365 #ifdef ENABLE_CHECKING
366 if (split_at_insn
== bb
->end
)
367 for (e
= bb
->succ
; e
; e
= e
->succ_next
)
368 if (e
->dest
== EXIT_BLOCK_PTR
)
372 /* Note that the following may create a new basic block
373 and renumber the existing basic blocks. */
374 if (split_at_insn
!= bb
->end
)
376 e
= split_block (bb
, split_at_insn
);
381 make_edge (bb
, EXIT_BLOCK_PTR
, EDGE_FAKE
);
384 if (insn
== bb
->head
)
395 /* Find unreachable blocks. An unreachable block will have 0 in
396 the reachable bit in block->flags. A nonzero value indicates the
397 block is reachable. */
400 find_unreachable_blocks (void)
403 basic_block
*tos
, *worklist
, bb
;
406 (basic_block
*) xmalloc (sizeof (basic_block
) * n_basic_blocks
);
408 /* Clear all the reachability flags. */
411 bb
->flags
&= ~BB_REACHABLE
;
413 /* Add our starting points to the worklist. Almost always there will
414 be only one. It isn't inconceivable that we might one day directly
415 support Fortran alternate entry points. */
417 for (e
= ENTRY_BLOCK_PTR
->succ
; e
; e
= e
->succ_next
)
421 /* Mark the block reachable. */
422 e
->dest
->flags
|= BB_REACHABLE
;
425 /* Iterate: find everything reachable from what we've already seen. */
427 while (tos
!= worklist
)
429 basic_block b
= *--tos
;
431 for (e
= b
->succ
; e
; e
= e
->succ_next
)
432 if (!(e
->dest
->flags
& BB_REACHABLE
))
435 e
->dest
->flags
|= BB_REACHABLE
;
442 /* Functions to access an edge list with a vector representation.
443 Enough data is kept such that given an index number, the
444 pred and succ that edge represents can be determined, or
445 given a pred and a succ, its index number can be returned.
446 This allows algorithms which consume a lot of memory to
447 represent the normally full matrix of edge (pred,succ) with a
448 single indexed vector, edge (EDGE_INDEX (pred, succ)), with no
449 wasted space in the client code due to sparse flow graphs. */
451 /* This functions initializes the edge list. Basically the entire
452 flowgraph is processed, and all edges are assigned a number,
453 and the data structure is filled in. */
456 create_edge_list (void)
458 struct edge_list
*elist
;
464 block_count
= n_basic_blocks
+ 2; /* Include the entry and exit blocks. */
468 /* Determine the number of edges in the flow graph by counting successor
469 edges on each basic block. */
470 FOR_BB_BETWEEN (bb
, ENTRY_BLOCK_PTR
, EXIT_BLOCK_PTR
, next_bb
)
472 for (e
= bb
->succ
; e
; e
= e
->succ_next
)
476 elist
= (struct edge_list
*) xmalloc (sizeof (struct edge_list
));
477 elist
->num_blocks
= block_count
;
478 elist
->num_edges
= num_edges
;
479 elist
->index_to_edge
= (edge
*) xmalloc (sizeof (edge
) * num_edges
);
483 /* Follow successors of blocks, and register these edges. */
484 FOR_BB_BETWEEN (bb
, ENTRY_BLOCK_PTR
, EXIT_BLOCK_PTR
, next_bb
)
485 for (e
= bb
->succ
; e
; e
= e
->succ_next
)
486 elist
->index_to_edge
[num_edges
++] = e
;
491 /* This function free's memory associated with an edge list. */
494 free_edge_list (struct edge_list
*elist
)
498 free (elist
->index_to_edge
);
503 /* This function provides debug output showing an edge list. */
506 print_edge_list (FILE *f
, struct edge_list
*elist
)
510 fprintf (f
, "Compressed edge list, %d BBs + entry & exit, and %d edges\n",
511 elist
->num_blocks
- 2, elist
->num_edges
);
513 for (x
= 0; x
< elist
->num_edges
; x
++)
515 fprintf (f
, " %-4d - edge(", x
);
516 if (INDEX_EDGE_PRED_BB (elist
, x
) == ENTRY_BLOCK_PTR
)
517 fprintf (f
, "entry,");
519 fprintf (f
, "%d,", INDEX_EDGE_PRED_BB (elist
, x
)->index
);
521 if (INDEX_EDGE_SUCC_BB (elist
, x
) == EXIT_BLOCK_PTR
)
522 fprintf (f
, "exit)\n");
524 fprintf (f
, "%d)\n", INDEX_EDGE_SUCC_BB (elist
, x
)->index
);
528 /* This function provides an internal consistency check of an edge list,
529 verifying that all edges are present, and that there are no
533 verify_edge_list (FILE *f
, struct edge_list
*elist
)
535 int pred
, succ
, index
;
537 basic_block bb
, p
, s
;
539 FOR_BB_BETWEEN (bb
, ENTRY_BLOCK_PTR
, EXIT_BLOCK_PTR
, next_bb
)
541 for (e
= bb
->succ
; e
; e
= e
->succ_next
)
543 pred
= e
->src
->index
;
544 succ
= e
->dest
->index
;
545 index
= EDGE_INDEX (elist
, e
->src
, e
->dest
);
546 if (index
== EDGE_INDEX_NO_EDGE
)
548 fprintf (f
, "*p* No index for edge from %d to %d\n", pred
, succ
);
552 if (INDEX_EDGE_PRED_BB (elist
, index
)->index
!= pred
)
553 fprintf (f
, "*p* Pred for index %d should be %d not %d\n",
554 index
, pred
, INDEX_EDGE_PRED_BB (elist
, index
)->index
);
555 if (INDEX_EDGE_SUCC_BB (elist
, index
)->index
!= succ
)
556 fprintf (f
, "*p* Succ for index %d should be %d not %d\n",
557 index
, succ
, INDEX_EDGE_SUCC_BB (elist
, index
)->index
);
561 /* We've verified that all the edges are in the list, now lets make sure
562 there are no spurious edges in the list. */
564 FOR_BB_BETWEEN (p
, ENTRY_BLOCK_PTR
, EXIT_BLOCK_PTR
, next_bb
)
565 FOR_BB_BETWEEN (s
, ENTRY_BLOCK_PTR
->next_bb
, NULL
, next_bb
)
569 for (e
= p
->succ
; e
; e
= e
->succ_next
)
576 for (e
= s
->pred
; e
; e
= e
->pred_next
)
583 if (EDGE_INDEX (elist
, p
, s
)
584 == EDGE_INDEX_NO_EDGE
&& found_edge
!= 0)
585 fprintf (f
, "*** Edge (%d, %d) appears to not have an index\n",
587 if (EDGE_INDEX (elist
, p
, s
)
588 != EDGE_INDEX_NO_EDGE
&& found_edge
== 0)
589 fprintf (f
, "*** Edge (%d, %d) has index %d, but there is no edge\n",
590 p
->index
, s
->index
, EDGE_INDEX (elist
, p
, s
));
594 /* This routine will determine what, if any, edge there is between
595 a specified predecessor and successor. */
598 find_edge_index (struct edge_list
*edge_list
, basic_block pred
, basic_block succ
)
602 for (x
= 0; x
< NUM_EDGES (edge_list
); x
++)
603 if (INDEX_EDGE_PRED_BB (edge_list
, x
) == pred
604 && INDEX_EDGE_SUCC_BB (edge_list
, x
) == succ
)
607 return (EDGE_INDEX_NO_EDGE
);
610 /* Dump the list of basic blocks in the bitmap NODES. */
613 flow_nodes_print (const char *str
, const sbitmap nodes
, FILE *file
)
620 fprintf (file
, "%s { ", str
);
621 EXECUTE_IF_SET_IN_SBITMAP (nodes
, 0, node
, {fprintf (file
, "%d ", node
);});
625 /* Dump the list of edges in the array EDGE_LIST. */
628 flow_edge_list_print (const char *str
, const edge
*edge_list
, int num_edges
, FILE *file
)
635 fprintf (file
, "%s { ", str
);
636 for (i
= 0; i
< num_edges
; i
++)
637 fprintf (file
, "%d->%d ", edge_list
[i
]->src
->index
,
638 edge_list
[i
]->dest
->index
);
644 /* This routine will remove any fake successor edges for a basic block.
645 When the edge is removed, it is also removed from whatever predecessor
649 remove_fake_successors (basic_block bb
)
653 for (e
= bb
->succ
; e
;)
658 if ((tmp
->flags
& EDGE_FAKE
) == EDGE_FAKE
)
663 /* This routine will remove all fake edges from the flow graph. If
664 we remove all fake successors, it will automatically remove all
665 fake predecessors. */
668 remove_fake_edges (void)
672 FOR_BB_BETWEEN (bb
, ENTRY_BLOCK_PTR
, EXIT_BLOCK_PTR
, next_bb
)
673 remove_fake_successors (bb
);
676 /* This function will add a fake edge between any block which has no
677 successors, and the exit block. Some data flow equations require these
681 add_noreturn_fake_exit_edges (void)
686 if (bb
->succ
== NULL
)
687 make_single_succ_edge (bb
, EXIT_BLOCK_PTR
, EDGE_FAKE
);
690 /* This function adds a fake edge between any infinite loops to the
691 exit block. Some optimizations require a path from each node to
694 See also Morgan, Figure 3.10, pp. 82-83.
696 The current implementation is ugly, not attempting to minimize the
697 number of inserted fake edges. To reduce the number of fake edges
698 to insert, add fake edges from _innermost_ loops containing only
699 nodes not reachable from the exit block. */
702 connect_infinite_loops_to_exit (void)
704 basic_block unvisited_block
;
705 struct depth_first_search_dsS dfs_ds
;
707 /* Perform depth-first search in the reverse graph to find nodes
708 reachable from the exit block. */
709 flow_dfs_compute_reverse_init (&dfs_ds
);
710 flow_dfs_compute_reverse_add_bb (&dfs_ds
, EXIT_BLOCK_PTR
);
712 /* Repeatedly add fake edges, updating the unreachable nodes. */
715 unvisited_block
= flow_dfs_compute_reverse_execute (&dfs_ds
);
716 if (!unvisited_block
)
719 make_edge (unvisited_block
, EXIT_BLOCK_PTR
, EDGE_FAKE
);
720 flow_dfs_compute_reverse_add_bb (&dfs_ds
, unvisited_block
);
723 flow_dfs_compute_reverse_finish (&dfs_ds
);
727 /* Compute reverse top sort order. */
730 flow_reverse_top_sort_order_compute (int *rts_order
)
737 /* Allocate stack for back-tracking up CFG. */
738 stack
= (edge
*) xmalloc ((n_basic_blocks
+ 1) * sizeof (edge
));
741 /* Allocate bitmap to track nodes that have been visited. */
742 visited
= sbitmap_alloc (last_basic_block
);
744 /* None of the nodes in the CFG have been visited yet. */
745 sbitmap_zero (visited
);
747 /* Push the first edge on to the stack. */
748 stack
[sp
++] = ENTRY_BLOCK_PTR
->succ
;
756 /* Look at the edge on the top of the stack. */
761 /* Check if the edge destination has been visited yet. */
762 if (dest
!= EXIT_BLOCK_PTR
&& ! TEST_BIT (visited
, dest
->index
))
764 /* Mark that we have visited the destination. */
765 SET_BIT (visited
, dest
->index
);
768 /* Since the DEST node has been visited for the first
769 time, check its successors. */
770 stack
[sp
++] = dest
->succ
;
772 rts_order
[postnum
++] = dest
->index
;
776 if (! e
->succ_next
&& src
!= ENTRY_BLOCK_PTR
)
777 rts_order
[postnum
++] = src
->index
;
780 stack
[sp
- 1] = e
->succ_next
;
787 sbitmap_free (visited
);
790 /* Compute the depth first search order and store in the array
791 DFS_ORDER if nonzero, marking the nodes visited in VISITED. If
792 RC_ORDER is nonzero, return the reverse completion number for each
793 node. Returns the number of nodes visited. A depth first search
794 tries to get as far away from the starting point as quickly as
798 flow_depth_first_order_compute (int *dfs_order
, int *rc_order
)
803 int rcnum
= n_basic_blocks
- 1;
806 /* Allocate stack for back-tracking up CFG. */
807 stack
= (edge
*) xmalloc ((n_basic_blocks
+ 1) * sizeof (edge
));
810 /* Allocate bitmap to track nodes that have been visited. */
811 visited
= sbitmap_alloc (last_basic_block
);
813 /* None of the nodes in the CFG have been visited yet. */
814 sbitmap_zero (visited
);
816 /* Push the first edge on to the stack. */
817 stack
[sp
++] = ENTRY_BLOCK_PTR
->succ
;
825 /* Look at the edge on the top of the stack. */
830 /* Check if the edge destination has been visited yet. */
831 if (dest
!= EXIT_BLOCK_PTR
&& ! TEST_BIT (visited
, dest
->index
))
833 /* Mark that we have visited the destination. */
834 SET_BIT (visited
, dest
->index
);
837 dfs_order
[dfsnum
] = dest
->index
;
842 /* Since the DEST node has been visited for the first
843 time, check its successors. */
844 stack
[sp
++] = dest
->succ
;
846 /* There are no successors for the DEST node so assign
847 its reverse completion number. */
848 rc_order
[rcnum
--] = dest
->index
;
852 if (! e
->succ_next
&& src
!= ENTRY_BLOCK_PTR
854 /* There are no more successors for the SRC node
855 so assign its reverse completion number. */
856 rc_order
[rcnum
--] = src
->index
;
859 stack
[sp
- 1] = e
->succ_next
;
866 sbitmap_free (visited
);
868 /* The number of nodes visited should not be greater than
870 if (dfsnum
> n_basic_blocks
)
873 /* There are some nodes left in the CFG that are unreachable. */
874 if (dfsnum
< n_basic_blocks
)
883 struct dfst_node
**node
;
884 struct dfst_node
*up
;
887 /* Compute a preorder transversal ordering such that a sub-tree which
888 is the source of a cross edge appears before the sub-tree which is
889 the destination of the cross edge. This allows for easy detection
890 of all the entry blocks for a loop.
892 The ordering is compute by:
894 1) Generating a depth first spanning tree.
896 2) Walking the resulting tree from right to left. */
899 flow_preorder_transversal_compute (int *pot_order
)
907 struct dfst_node
*node
;
908 struct dfst_node
*dfst
;
911 /* Allocate stack for back-tracking up CFG. */
912 stack
= (edge
*) xmalloc ((n_basic_blocks
+ 1) * sizeof (edge
));
915 /* Allocate the tree. */
916 dfst
= (struct dfst_node
*) xcalloc (last_basic_block
,
917 sizeof (struct dfst_node
));
922 for (e
= bb
->succ
; e
; e
= e
->succ_next
)
927 ? (struct dfst_node
**) xcalloc (max_successors
,
928 sizeof (struct dfst_node
*))
932 /* Allocate bitmap to track nodes that have been visited. */
933 visited
= sbitmap_alloc (last_basic_block
);
935 /* None of the nodes in the CFG have been visited yet. */
936 sbitmap_zero (visited
);
938 /* Push the first edge on to the stack. */
939 stack
[sp
++] = ENTRY_BLOCK_PTR
->succ
;
946 /* Look at the edge on the top of the stack. */
951 /* Check if the edge destination has been visited yet. */
952 if (dest
!= EXIT_BLOCK_PTR
&& ! TEST_BIT (visited
, dest
->index
))
954 /* Mark that we have visited the destination. */
955 SET_BIT (visited
, dest
->index
);
957 /* Add the destination to the preorder tree. */
958 if (src
!= ENTRY_BLOCK_PTR
)
960 dfst
[src
->index
].node
[dfst
[src
->index
].nnodes
++]
961 = &dfst
[dest
->index
];
962 dfst
[dest
->index
].up
= &dfst
[src
->index
];
966 /* Since the DEST node has been visited for the first
967 time, check its successors. */
968 stack
[sp
++] = dest
->succ
;
971 else if (e
->succ_next
)
972 stack
[sp
- 1] = e
->succ_next
;
978 sbitmap_free (visited
);
980 /* Record the preorder transversal order by
981 walking the tree from right to left. */
984 node
= &dfst
[ENTRY_BLOCK_PTR
->next_bb
->index
];
991 node
= node
->node
[--node
->nnodes
];
992 pot_order
[i
++] = node
- dfst
;
1000 for (i
= 0; i
< last_basic_block
; i
++)
1002 free (dfst
[i
].node
);
1007 /* Compute the depth first search order on the _reverse_ graph and
1008 store in the array DFS_ORDER, marking the nodes visited in VISITED.
1009 Returns the number of nodes visited.
1011 The computation is split into three pieces:
1013 flow_dfs_compute_reverse_init () creates the necessary data
1016 flow_dfs_compute_reverse_add_bb () adds a basic block to the data
1017 structures. The block will start the search.
1019 flow_dfs_compute_reverse_execute () continues (or starts) the
1020 search using the block on the top of the stack, stopping when the
1023 flow_dfs_compute_reverse_finish () destroys the necessary data
1026 Thus, the user will probably call ..._init(), call ..._add_bb() to
1027 add a beginning basic block to the stack, call ..._execute(),
1028 possibly add another bb to the stack and again call ..._execute(),
1029 ..., and finally call _finish(). */
1031 /* Initialize the data structures used for depth-first search on the
1032 reverse graph. If INITIALIZE_STACK is nonzero, the exit block is
1033 added to the basic block stack. DATA is the current depth-first
1034 search context. If INITIALIZE_STACK is nonzero, there is an
1035 element on the stack. */
1038 flow_dfs_compute_reverse_init (depth_first_search_ds data
)
1040 /* Allocate stack for back-tracking up CFG. */
1041 data
->stack
= (basic_block
*) xmalloc ((n_basic_blocks
- (INVALID_BLOCK
+ 1))
1042 * sizeof (basic_block
));
1045 /* Allocate bitmap to track nodes that have been visited. */
1046 data
->visited_blocks
= sbitmap_alloc (last_basic_block
- (INVALID_BLOCK
+ 1));
1048 /* None of the nodes in the CFG have been visited yet. */
1049 sbitmap_zero (data
->visited_blocks
);
1054 /* Add the specified basic block to the top of the dfs data
1055 structures. When the search continues, it will start at the
1059 flow_dfs_compute_reverse_add_bb (depth_first_search_ds data
, basic_block bb
)
1061 data
->stack
[data
->sp
++] = bb
;
1062 SET_BIT (data
->visited_blocks
, bb
->index
- (INVALID_BLOCK
+ 1));
1065 /* Continue the depth-first search through the reverse graph starting with the
1066 block at the stack's top and ending when the stack is empty. Visited nodes
1067 are marked. Returns an unvisited basic block, or NULL if there is none
1071 flow_dfs_compute_reverse_execute (depth_first_search_ds data
)
1076 while (data
->sp
> 0)
1078 bb
= data
->stack
[--data
->sp
];
1080 /* Perform depth-first search on adjacent vertices. */
1081 for (e
= bb
->pred
; e
; e
= e
->pred_next
)
1082 if (!TEST_BIT (data
->visited_blocks
,
1083 e
->src
->index
- (INVALID_BLOCK
+ 1)))
1084 flow_dfs_compute_reverse_add_bb (data
, e
->src
);
1087 /* Determine if there are unvisited basic blocks. */
1088 FOR_BB_BETWEEN (bb
, EXIT_BLOCK_PTR
, NULL
, prev_bb
)
1089 if (!TEST_BIT (data
->visited_blocks
, bb
->index
- (INVALID_BLOCK
+ 1)))
1095 /* Destroy the data structures needed for depth-first search on the
1099 flow_dfs_compute_reverse_finish (depth_first_search_ds data
)
1102 sbitmap_free (data
->visited_blocks
);
1105 /* Performs dfs search from BB over vertices satisfying PREDICATE;
1106 if REVERSE, go against direction of edges. Returns number of blocks
1107 found and their list in RSLT. RSLT can contain at most RSLT_MAX items. */
1109 dfs_enumerate_from (basic_block bb
, int reverse
,
1110 bool (*predicate
) (basic_block
, void *),
1111 basic_block
*rslt
, int rslt_max
, void *data
)
1113 basic_block
*st
, lbb
;
1116 st
= xcalloc (rslt_max
, sizeof (basic_block
));
1117 rslt
[tv
++] = st
[sp
++] = bb
;
1118 bb
->flags
|= BB_VISITED
;
1125 for (e
= lbb
->pred
; e
; e
= e
->pred_next
)
1126 if (!(e
->src
->flags
& BB_VISITED
) && predicate (e
->src
, data
))
1130 rslt
[tv
++] = st
[sp
++] = e
->src
;
1131 e
->src
->flags
|= BB_VISITED
;
1136 for (e
= lbb
->succ
; e
; e
= e
->succ_next
)
1137 if (!(e
->dest
->flags
& BB_VISITED
) && predicate (e
->dest
, data
))
1141 rslt
[tv
++] = st
[sp
++] = e
->dest
;
1142 e
->dest
->flags
|= BB_VISITED
;
1147 for (sp
= 0; sp
< tv
; sp
++)
1148 rslt
[sp
]->flags
&= ~BB_VISITED
;