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. */
61 forwarder_block_p (bb)
66 if (bb == EXIT_BLOCK_PTR || bb == ENTRY_BLOCK_PTR
67 || !bb->succ || bb->succ->succ_next)
70 for (insn = bb->head; insn != bb->end; insn = NEXT_INSN (insn))
71 if (INSN_P (insn) && active_insn_p (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. */
82 can_fallthru (src, target)
83 basic_block src, target;
86 rtx insn2 = target->head;
88 if (src->index + 1 == target->index && !active_insn_p (insn2))
89 insn2 = next_active_insn (insn2);
91 /* ??? Later we may add code to move jump tables offline. */
92 return next_active_insn (insn) == insn2;
95 /* Mark the back edges in DFS traversal.
96 Return non-zero if a loop (natural or otherwise) is present.
97 Inspired by Depth_First_Search_PP described in:
99 Advanced Compiler Design and Implementation
101 Morgan Kaufmann, 1997
103 and heavily borrowed from flow_depth_first_order_compute. */
106 mark_dfs_back_edges ()
117 /* Allocate the preorder and postorder number arrays. */
118 pre = (int *) xcalloc (n_basic_blocks, sizeof (int));
119 post = (int *) xcalloc (n_basic_blocks, sizeof (int));
121 /* Allocate stack for back-tracking up CFG. */
122 stack = (edge *) xmalloc ((n_basic_blocks + 1) * sizeof (edge));
125 /* Allocate bitmap to track nodes that have been visited. */
126 visited = sbitmap_alloc (n_basic_blocks);
128 /* None of the nodes in the CFG have been visited yet. */
129 sbitmap_zero (visited);
131 /* Push the first edge on to the stack. */
132 stack[sp++] = ENTRY_BLOCK_PTR->succ;
140 /* Look at the edge on the top of the stack. */
144 e->flags &= ~EDGE_DFS_BACK;
146 /* Check if the edge destination has been visited yet. */
147 if (dest != EXIT_BLOCK_PTR && ! TEST_BIT (visited, dest->index))
149 /* Mark that we have visited the destination. */
150 SET_BIT (visited, dest->index);
152 pre[dest->index] = prenum++;
155 /* Since the DEST node has been visited for the first
156 time, check its successors. */
157 stack[sp++] = dest->succ;
160 post[dest->index] = postnum++;
164 if (dest != EXIT_BLOCK_PTR && src != ENTRY_BLOCK_PTR
165 && pre[src->index] >= pre[dest->index]
166 && post[dest->index] == 0)
167 e->flags |= EDGE_DFS_BACK, found = true;
169 if (! e->succ_next && src != ENTRY_BLOCK_PTR)
170 post[src->index] = postnum++;
173 stack[sp - 1] = e->succ_next;
182 sbitmap_free (visited);
187 /* Return true if we need to add fake edge to exit.
188 Helper function for the flow_call_edges_add. */
191 need_fake_edge_p (insn)
197 if ((GET_CODE (insn) == CALL_INSN
198 && !SIBLING_CALL_P (insn)
199 && !find_reg_note (insn, REG_NORETURN, NULL)
200 && !find_reg_note (insn, REG_ALWAYS_RETURN, NULL)
201 && !CONST_OR_PURE_CALL_P (insn)))
204 return ((GET_CODE (PATTERN (insn)) == ASM_OPERANDS
205 && MEM_VOLATILE_P (PATTERN (insn)))
206 || (GET_CODE (PATTERN (insn)) == PARALLEL
207 && asm_noperands (insn) != -1
208 && MEM_VOLATILE_P (XVECEXP (PATTERN (insn), 0, 0)))
209 || GET_CODE (PATTERN (insn)) == ASM_INPUT);
212 /* Add fake edges to the function exit for any non constant and non noreturn
213 calls, volatile inline assembly in the bitmap of blocks specified by
214 BLOCKS or to the whole CFG if BLOCKS is zero. Return the number of blocks
217 The goal is to expose cases in which entering a basic block does not imply
218 that all subsequent instructions must be executed. */
221 flow_call_edges_add (blocks)
225 int blocks_split = 0;
228 bool check_last_block = false;
230 /* Map bb indices into basic block pointers since split_block
231 will renumber the basic blocks. */
233 bbs = xmalloc (n_basic_blocks * sizeof (*bbs));
237 for (i = 0; i < n_basic_blocks; i++)
238 bbs[bb_num++] = BASIC_BLOCK (i);
240 check_last_block = true;
243 EXECUTE_IF_SET_IN_SBITMAP (blocks, 0, i,
245 bbs[bb_num++] = BASIC_BLOCK (i);
246 if (i == n_basic_blocks - 1)
247 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))
267 for (e = BASIC_BLOCK (n_basic_blocks - 1)->succ; e; e = e->succ_next)
268 if (e->dest == EXIT_BLOCK_PTR)
271 insert_insn_on_edge (gen_rtx_USE (VOIDmode, const0_rtx), e);
272 commit_edge_insertions ();
275 /* Now add fake edges to the function exit for any non constant
276 calls since there is no way that we can determine if they will
279 for (i = 0; i < bb_num; i++)
281 basic_block bb = bbs[i];
285 for (insn = bb->end; ; insn = prev_insn)
287 prev_insn = PREV_INSN (insn);
288 if (need_fake_edge_p (insn))
292 /* The above condition should be enough to verify that there is
293 no edge to the exit block in CFG already. Calling make_edge
294 in such case would make us to mark that edge as fake and
297 #ifdef ENABLE_CHECKING
299 for (e = bb->succ; e; e = e->succ_next)
300 if (e->dest == EXIT_BLOCK_PTR)
304 /* Note that the following may create a new basic block
305 and renumber the existing basic blocks. */
306 e = split_block (bb, insn);
310 make_edge (bb, EXIT_BLOCK_PTR, EDGE_FAKE);
313 if (insn == bb->head)
325 /* Find unreachable blocks. An unreachable block will have 0 in
326 the reachable bit in block->flags. A non-zero value indicates the
327 block is reachable. */
330 find_unreachable_blocks ()
334 basic_block *tos, *worklist;
337 tos = worklist = (basic_block *) xmalloc (sizeof (basic_block) * n);
339 /* Clear all the reachability flags. */
341 for (i = 0; i < n; ++i)
342 BASIC_BLOCK (i)->flags &= ~BB_REACHABLE;
344 /* Add our starting points to the worklist. Almost always there will
345 be only one. It isn't inconceivable that we might one day directly
346 support Fortran alternate entry points. */
348 for (e = ENTRY_BLOCK_PTR->succ; e; e = e->succ_next)
352 /* Mark the block reachable. */
353 e->dest->flags |= BB_REACHABLE;
356 /* Iterate: find everything reachable from what we've already seen. */
358 while (tos != worklist)
360 basic_block b = *--tos;
362 for (e = b->succ; e; e = e->succ_next)
363 if (!(e->dest->flags & BB_REACHABLE))
366 e->dest->flags |= BB_REACHABLE;
373 /* Functions to access an edge list with a vector representation.
374 Enough data is kept such that given an index number, the
375 pred and succ that edge represents can be determined, or
376 given a pred and a succ, its index number can be returned.
377 This allows algorithms which consume a lot of memory to
378 represent the normally full matrix of edge (pred,succ) with a
379 single indexed vector, edge (EDGE_INDEX (pred, succ)), with no
380 wasted space in the client code due to sparse flow graphs. */
382 /* This functions initializes the edge list. Basically the entire
383 flowgraph is processed, and all edges are assigned a number,
384 and the data structure is filled in. */
389 struct edge_list *elist;
395 block_count = n_basic_blocks + 2; /* Include the entry and exit blocks. */
399 /* Determine the number of edges in the flow graph by counting successor
400 edges on each basic block. */
401 for (x = 0; x < n_basic_blocks; x++)
403 basic_block bb = BASIC_BLOCK (x);
405 for (e = bb->succ; e; e = e->succ_next)
409 /* Don't forget successors of the entry block. */
410 for (e = ENTRY_BLOCK_PTR->succ; e; e = e->succ_next)
413 elist = (struct edge_list *) xmalloc (sizeof (struct edge_list));
414 elist->num_blocks = block_count;
415 elist->num_edges = num_edges;
416 elist->index_to_edge = (edge *) xmalloc (sizeof (edge) * num_edges);
420 /* Follow successors of the entry block, and register these edges. */
421 for (e = ENTRY_BLOCK_PTR->succ; e; e = e->succ_next)
422 elist->index_to_edge[num_edges++] = e;
424 for (x = 0; x < n_basic_blocks; x++)
426 basic_block bb = BASIC_BLOCK (x);
428 /* Follow all successors of blocks, and register these edges. */
429 for (e = bb->succ; e; e = e->succ_next)
430 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;
458 fprintf (f, "Compressed edge list, %d BBs + entry & exit, and %d edges\n",
459 elist->num_blocks - 2, elist->num_edges);
461 for (x = 0; x < elist->num_edges; x++)
463 fprintf (f, " %-4d - edge(", x);
464 if (INDEX_EDGE_PRED_BB (elist, x) == ENTRY_BLOCK_PTR)
465 fprintf (f, "entry,");
467 fprintf (f, "%d,", INDEX_EDGE_PRED_BB (elist, x)->index);
469 if (INDEX_EDGE_SUCC_BB (elist, x) == EXIT_BLOCK_PTR)
470 fprintf (f, "exit)\n");
472 fprintf (f, "%d)\n", INDEX_EDGE_SUCC_BB (elist, x)->index);
476 /* This function provides an internal consistency check of an edge list,
477 verifying that all edges are present, and that there are no
481 verify_edge_list (f, elist)
483 struct edge_list *elist;
485 int x, pred, succ, index;
488 for (x = 0; x < n_basic_blocks; x++)
490 basic_block bb = BASIC_BLOCK (x);
492 for (e = bb->succ; e; e = e->succ_next)
494 pred = e->src->index;
495 succ = e->dest->index;
496 index = EDGE_INDEX (elist, e->src, e->dest);
497 if (index == EDGE_INDEX_NO_EDGE)
499 fprintf (f, "*p* No index for edge from %d to %d\n", pred, succ);
503 if (INDEX_EDGE_PRED_BB (elist, index)->index != pred)
504 fprintf (f, "*p* Pred for index %d should be %d not %d\n",
505 index, pred, INDEX_EDGE_PRED_BB (elist, index)->index);
506 if (INDEX_EDGE_SUCC_BB (elist, index)->index != succ)
507 fprintf (f, "*p* Succ for index %d should be %d not %d\n",
508 index, succ, INDEX_EDGE_SUCC_BB (elist, index)->index);
512 for (e = ENTRY_BLOCK_PTR->succ; e; e = e->succ_next)
514 pred = e->src->index;
515 succ = e->dest->index;
516 index = EDGE_INDEX (elist, e->src, e->dest);
517 if (index == EDGE_INDEX_NO_EDGE)
519 fprintf (f, "*p* No index for edge from %d to %d\n", pred, succ);
523 if (INDEX_EDGE_PRED_BB (elist, index)->index != pred)
524 fprintf (f, "*p* Pred for index %d should be %d not %d\n",
525 index, pred, INDEX_EDGE_PRED_BB (elist, index)->index);
526 if (INDEX_EDGE_SUCC_BB (elist, index)->index != succ)
527 fprintf (f, "*p* Succ for index %d should be %d not %d\n",
528 index, succ, INDEX_EDGE_SUCC_BB (elist, index)->index);
531 /* We've verified that all the edges are in the list, no lets make sure
532 there are no spurious edges in the list. */
534 for (pred = 0; pred < n_basic_blocks; pred++)
535 for (succ = 0; succ < n_basic_blocks; succ++)
537 basic_block p = BASIC_BLOCK (pred);
538 basic_block s = BASIC_BLOCK (succ);
541 for (e = p->succ; e; e = e->succ_next)
548 for (e = s->pred; e; e = e->pred_next)
555 if (EDGE_INDEX (elist, BASIC_BLOCK (pred), BASIC_BLOCK (succ))
556 == EDGE_INDEX_NO_EDGE && found_edge != 0)
557 fprintf (f, "*** Edge (%d, %d) appears to not have an index\n",
559 if (EDGE_INDEX (elist, BASIC_BLOCK (pred), BASIC_BLOCK (succ))
560 != EDGE_INDEX_NO_EDGE && found_edge == 0)
561 fprintf (f, "*** Edge (%d, %d) has index %d, but there is no edge\n",
562 pred, succ, EDGE_INDEX (elist, BASIC_BLOCK (pred),
563 BASIC_BLOCK (succ)));
566 for (succ = 0; succ < n_basic_blocks; succ++)
568 basic_block p = ENTRY_BLOCK_PTR;
569 basic_block s = BASIC_BLOCK (succ);
572 for (e = p->succ; e; e = e->succ_next)
579 for (e = s->pred; e; e = e->pred_next)
586 if (EDGE_INDEX (elist, ENTRY_BLOCK_PTR, BASIC_BLOCK (succ))
587 == EDGE_INDEX_NO_EDGE && found_edge != 0)
588 fprintf (f, "*** Edge (entry, %d) appears to not have an index\n",
590 if (EDGE_INDEX (elist, ENTRY_BLOCK_PTR, BASIC_BLOCK (succ))
591 != EDGE_INDEX_NO_EDGE && found_edge == 0)
592 fprintf (f, "*** Edge (entry, %d) has index %d, but no edge exists\n",
593 succ, EDGE_INDEX (elist, ENTRY_BLOCK_PTR,
594 BASIC_BLOCK (succ)));
597 for (pred = 0; pred < n_basic_blocks; pred++)
599 basic_block p = BASIC_BLOCK (pred);
600 basic_block s = EXIT_BLOCK_PTR;
603 for (e = p->succ; e; e = e->succ_next)
610 for (e = s->pred; e; e = e->pred_next)
617 if (EDGE_INDEX (elist, BASIC_BLOCK (pred), EXIT_BLOCK_PTR)
618 == EDGE_INDEX_NO_EDGE && found_edge != 0)
619 fprintf (f, "*** Edge (%d, exit) appears to not have an index\n",
621 if (EDGE_INDEX (elist, BASIC_BLOCK (pred), EXIT_BLOCK_PTR)
622 != EDGE_INDEX_NO_EDGE && found_edge == 0)
623 fprintf (f, "*** Edge (%d, exit) has index %d, but no edge exists\n",
624 pred, EDGE_INDEX (elist, BASIC_BLOCK (pred),
629 /* This routine will determine what, if any, edge there is between
630 a specified predecessor and successor. */
633 find_edge_index (edge_list, pred, succ)
634 struct edge_list *edge_list;
635 basic_block pred, succ;
639 for (x = 0; x < NUM_EDGES (edge_list); x++)
640 if (INDEX_EDGE_PRED_BB (edge_list, x) == pred
641 && INDEX_EDGE_SUCC_BB (edge_list, x) == succ)
644 return (EDGE_INDEX_NO_EDGE);
647 /* Dump the list of basic blocks in the bitmap NODES. */
650 flow_nodes_print (str, nodes, file)
660 fprintf (file, "%s { ", str);
661 EXECUTE_IF_SET_IN_SBITMAP (nodes, 0, node, {fprintf (file, "%d ", node);});
665 /* Dump the list of edges in the array EDGE_LIST. */
668 flow_edge_list_print (str, edge_list, num_edges, file)
670 const edge *edge_list;
679 fprintf (file, "%s { ", str);
680 for (i = 0; i < num_edges; i++)
681 fprintf (file, "%d->%d ", edge_list[i]->src->index,
682 edge_list[i]->dest->index);
688 /* This routine will remove any fake successor edges for a basic block.
689 When the edge is removed, it is also removed from whatever predecessor
693 remove_fake_successors (bb)
698 for (e = bb->succ; e;)
703 if ((tmp->flags & EDGE_FAKE) == EDGE_FAKE)
708 /* This routine will remove all fake edges from the flow graph. If
709 we remove all fake successors, it will automatically remove all
710 fake predecessors. */
717 for (x = 0; x < n_basic_blocks; x++)
718 remove_fake_successors (BASIC_BLOCK (x));
720 /* We've handled all successors except the entry block's. */
721 remove_fake_successors (ENTRY_BLOCK_PTR);
724 /* This function will add a fake edge between any block which has no
725 successors, and the exit block. Some data flow equations require these
729 add_noreturn_fake_exit_edges ()
733 for (x = 0; x < n_basic_blocks; x++)
734 if (BASIC_BLOCK (x)->succ == NULL)
735 make_single_succ_edge (BASIC_BLOCK (x), EXIT_BLOCK_PTR, EDGE_FAKE);
738 /* This function adds a fake edge between any infinite loops to the
739 exit block. Some optimizations require a path from each node to
742 See also Morgan, Figure 3.10, pp. 82-83.
744 The current implementation is ugly, not attempting to minimize the
745 number of inserted fake edges. To reduce the number of fake edges
746 to insert, add fake edges from _innermost_ loops containing only
747 nodes not reachable from the exit block. */
750 connect_infinite_loops_to_exit ()
752 basic_block unvisited_block;
753 struct depth_first_search_dsS dfs_ds;
755 /* Perform depth-first search in the reverse graph to find nodes
756 reachable from the exit block. */
757 flow_dfs_compute_reverse_init (&dfs_ds);
758 flow_dfs_compute_reverse_add_bb (&dfs_ds, EXIT_BLOCK_PTR);
760 /* Repeatedly add fake edges, updating the unreachable nodes. */
763 unvisited_block = flow_dfs_compute_reverse_execute (&dfs_ds);
764 if (!unvisited_block)
767 make_edge (unvisited_block, EXIT_BLOCK_PTR, EDGE_FAKE);
768 flow_dfs_compute_reverse_add_bb (&dfs_ds, unvisited_block);
771 flow_dfs_compute_reverse_finish (&dfs_ds);
775 /* Compute reverse top sort order */
778 flow_reverse_top_sort_order_compute (rts_order)
786 /* Allocate stack for back-tracking up CFG. */
787 stack = (edge *) xmalloc ((n_basic_blocks + 1) * sizeof (edge));
790 /* Allocate bitmap to track nodes that have been visited. */
791 visited = sbitmap_alloc (n_basic_blocks);
793 /* None of the nodes in the CFG have been visited yet. */
794 sbitmap_zero (visited);
796 /* Push the first edge on to the stack. */
797 stack[sp++] = ENTRY_BLOCK_PTR->succ;
805 /* Look at the edge on the top of the stack. */
810 /* Check if the edge destination has been visited yet. */
811 if (dest != EXIT_BLOCK_PTR && ! TEST_BIT (visited, dest->index))
813 /* Mark that we have visited the destination. */
814 SET_BIT (visited, dest->index);
817 /* Since the DEST node has been visited for the first
818 time, check its successors. */
819 stack[sp++] = dest->succ;
821 rts_order[postnum++] = dest->index;
825 if (! e->succ_next && src != ENTRY_BLOCK_PTR)
826 rts_order[postnum++] = src->index;
829 stack[sp - 1] = e->succ_next;
836 sbitmap_free (visited);
839 /* Compute the depth first search order and store in the array
840 DFS_ORDER if non-zero, marking the nodes visited in VISITED. If
841 RC_ORDER is non-zero, return the reverse completion number for each
842 node. Returns the number of nodes visited. A depth first search
843 tries to get as far away from the starting point as quickly as
847 flow_depth_first_order_compute (dfs_order, rc_order)
854 int rcnum = n_basic_blocks - 1;
857 /* Allocate stack for back-tracking up CFG. */
858 stack = (edge *) xmalloc ((n_basic_blocks + 1) * sizeof (edge));
861 /* Allocate bitmap to track nodes that have been visited. */
862 visited = sbitmap_alloc (n_basic_blocks);
864 /* None of the nodes in the CFG have been visited yet. */
865 sbitmap_zero (visited);
867 /* Push the first edge on to the stack. */
868 stack[sp++] = ENTRY_BLOCK_PTR->succ;
876 /* Look at the edge on the top of the stack. */
881 /* Check if the edge destination has been visited yet. */
882 if (dest != EXIT_BLOCK_PTR && ! TEST_BIT (visited, dest->index))
884 /* Mark that we have visited the destination. */
885 SET_BIT (visited, dest->index);
888 dfs_order[dfsnum] = dest->index;
893 /* Since the DEST node has been visited for the first
894 time, check its successors. */
895 stack[sp++] = dest->succ;
897 /* There are no successors for the DEST node so assign
898 its reverse completion number. */
899 rc_order[rcnum--] = dest->index;
903 if (! e->succ_next && src != ENTRY_BLOCK_PTR
905 /* There are no more successors for the SRC node
906 so assign its reverse completion number. */
907 rc_order[rcnum--] = src->index;
910 stack[sp - 1] = e->succ_next;
917 sbitmap_free (visited);
919 /* The number of nodes visited should not be greater than
921 if (dfsnum > n_basic_blocks)
924 /* There are some nodes left in the CFG that are unreachable. */
925 if (dfsnum < n_basic_blocks)
934 struct dfst_node **node;
935 struct dfst_node *up;
938 /* Compute a preorder transversal ordering such that a sub-tree which
939 is the source of a cross edge appears before the sub-tree which is
940 the destination of the cross edge. This allows for easy detection
941 of all the entry blocks for a loop.
943 The ordering is compute by:
945 1) Generating a depth first spanning tree.
947 2) Walking the resulting tree from right to left. */
950 flow_preorder_transversal_compute (pot_order)
959 struct dfst_node *node;
960 struct dfst_node *dfst;
962 /* Allocate stack for back-tracking up CFG. */
963 stack = (edge *) xmalloc ((n_basic_blocks + 1) * sizeof (edge));
966 /* Allocate the tree. */
967 dfst = (struct dfst_node *) xcalloc (n_basic_blocks,
968 sizeof (struct dfst_node));
970 for (i = 0; i < n_basic_blocks; i++)
973 for (e = BASIC_BLOCK (i)->succ; e; e = e->succ_next)
978 ? (struct dfst_node **) xcalloc (max_successors,
979 sizeof (struct dfst_node *))
983 /* Allocate bitmap to track nodes that have been visited. */
984 visited = sbitmap_alloc (n_basic_blocks);
986 /* None of the nodes in the CFG have been visited yet. */
987 sbitmap_zero (visited);
989 /* Push the first edge on to the stack. */
990 stack[sp++] = ENTRY_BLOCK_PTR->succ;
997 /* Look at the edge on the top of the stack. */
1002 /* Check if the edge destination has been visited yet. */
1003 if (dest != EXIT_BLOCK_PTR && ! TEST_BIT (visited, dest->index))
1005 /* Mark that we have visited the destination. */
1006 SET_BIT (visited, dest->index);
1008 /* Add the destination to the preorder tree. */
1009 if (src != ENTRY_BLOCK_PTR)
1011 dfst[src->index].node[dfst[src->index].nnodes++]
1012 = &dfst[dest->index];
1013 dfst[dest->index].up = &dfst[src->index];
1017 /* Since the DEST node has been visited for the first
1018 time, check its successors. */
1019 stack[sp++] = dest->succ;
1022 else if (e->succ_next)
1023 stack[sp - 1] = e->succ_next;
1029 sbitmap_free (visited);
1031 /* Record the preorder transversal order by
1032 walking the tree from right to left. */
1042 node = node->node[--node->nnodes];
1043 pot_order[i++] = node - dfst;
1049 /* Free the tree. */
1051 for (i = 0; i < n_basic_blocks; i++)
1053 free (dfst[i].node);
1058 /* Compute the depth first search order on the _reverse_ graph and
1059 store in the array DFS_ORDER, marking the nodes visited in VISITED.
1060 Returns the number of nodes visited.
1062 The computation is split into three pieces:
1064 flow_dfs_compute_reverse_init () creates the necessary data
1067 flow_dfs_compute_reverse_add_bb () adds a basic block to the data
1068 structures. The block will start the search.
1070 flow_dfs_compute_reverse_execute () continues (or starts) the
1071 search using the block on the top of the stack, stopping when the
1074 flow_dfs_compute_reverse_finish () destroys the necessary data
1077 Thus, the user will probably call ..._init(), call ..._add_bb() to
1078 add a beginning basic block to the stack, call ..._execute(),
1079 possibly add another bb to the stack and again call ..._execute(),
1080 ..., and finally call _finish(). */
1082 /* Initialize the data structures used for depth-first search on the
1083 reverse graph. If INITIALIZE_STACK is nonzero, the exit block is
1084 added to the basic block stack. DATA is the current depth-first
1085 search context. If INITIALIZE_STACK is non-zero, there is an
1086 element on the stack. */
1089 flow_dfs_compute_reverse_init (data)
1090 depth_first_search_ds data;
1092 /* Allocate stack for back-tracking up CFG. */
1093 data->stack = (basic_block *) xmalloc ((n_basic_blocks - (INVALID_BLOCK + 1))
1094 * sizeof (basic_block));
1097 /* Allocate bitmap to track nodes that have been visited. */
1098 data->visited_blocks = sbitmap_alloc (n_basic_blocks - (INVALID_BLOCK + 1));
1100 /* None of the nodes in the CFG have been visited yet. */
1101 sbitmap_zero (data->visited_blocks);
1106 /* Add the specified basic block to the top of the dfs data
1107 structures. When the search continues, it will start at the
1111 flow_dfs_compute_reverse_add_bb (data, bb)
1112 depth_first_search_ds data;
1115 data->stack[data->sp++] = bb;
1116 SET_BIT (data->visited_blocks, bb->index - (INVALID_BLOCK + 1));
1119 /* Continue the depth-first search through the reverse graph starting with the
1120 block at the stack's top and ending when the stack is empty. Visited nodes
1121 are marked. Returns an unvisited basic block, or NULL if there is none
1125 flow_dfs_compute_reverse_execute (data)
1126 depth_first_search_ds data;
1132 while (data->sp > 0)
1134 bb = data->stack[--data->sp];
1136 /* Perform depth-first search on adjacent vertices. */
1137 for (e = bb->pred; e; e = e->pred_next)
1138 if (!TEST_BIT (data->visited_blocks,
1139 e->src->index - (INVALID_BLOCK + 1)))
1140 flow_dfs_compute_reverse_add_bb (data, e->src);
1143 /* Determine if there are unvisited basic blocks. */
1144 for (i = n_basic_blocks - (INVALID_BLOCK + 1); --i >= 0; )
1145 if (!TEST_BIT (data->visited_blocks, i))
1146 return BASIC_BLOCK (i + (INVALID_BLOCK + 1));
1151 /* Destroy the data structures needed for depth-first search on the
1155 flow_dfs_compute_reverse_finish (data)
1156 depth_first_search_ds data;
1159 sbitmap_free (data->visited_blocks);