CbC/CbC_gcc: gcc/cfganal.c comparison

comparison gcc/cfganal.c @ 55:77e2b8dfacca gcc-4.4.5

update it from 4.4.3 to 4.5.0

author	ryoma <e075725@ie.u-ryukyu.ac.jp>
date	Fri, 12 Feb 2010 23:39:51 +0900
parents	a06113de4d67
children	b7f97abdc517

comparison

equal deleted inserted replaced

-:c156f1bd5cd9
+:77e2b8dfacca
 numbering of the graph.  If INCLUDE_ENTRY_EXIT is true, then then
 ENTRY_BLOCK and EXIT_BLOCK are included.  If DELETE_UNREACHABLE is
 true, unreachable blocks are deleted.  */
 int
 post_order_compute (int *post_order, bool include_entry_exit,
 		    bool delete_unreachable)
 {
 edge_iterator *stack;
 int sp;
 int post_order_num = 0;
 if (include_entry_exit)
 {
 post_order[post_order_num++] = ENTRY_BLOCK;
 count = post_order_num;
 }
 else
 count = post_order_num + 2;
 /* Delete the unreachable blocks if some were found and we are
 supposed to do it.  */
 if (delete_unreachable && (count != n_basic_blocks))
 {
 basic_block b;
 basic_block next_bb;
 for (b = ENTRY_BLOCK_PTR->next_bb; b != EXIT_BLOCK_PTR; b = next_bb)
 	{
 	  next_bb = b->next_bb;
 	  if (!(TEST_BIT (visited, b->index)))
 	    delete_basic_block (b);
 	}
 tidy_fallthru_edges ();
 }
 free (stack);
 sbitmap_free (visited);
 return post_order_num;
 }
 /* Helper routine for inverted_post_order_compute.
 BB has to belong to a region of CFG
 unreachable by inverted traversal from the exit.
 i.e. there's no control flow path from ENTRY to EXIT
 that contains this BB.
 This can happen in two cases - if there's an infinite loop
 or if there's a block that has no successor
 (call to a function with no return).
 Some RTL passes deal with this condition by
 calling connect_infinite_loops_to_exit () and/or
 add_noreturn_fake_exit_edges ().
 However, those methods involve modifying the CFG itself
 which may not be desirable.
 Hence, we deal with the infinite loop/no return cases
 by identifying a unique basic block that can reach all blocks
 If there's an infinite loop,
 a simple inverted traversal starting from the blocks
 with no successors can't visit all blocks.
 To solve this problem, we first do inverted traversal
 starting from the blocks with no successor.
 And if there's any block left that's not visited by the regular
 inverted traversal from EXIT,
 those blocks are in such problematic region.
 Among those, we find one block that has
 any visited predecessor (which is an entry into such a region),
 and start looking for a "dead end" from that block
 and do another inverted traversal from that block.  */
 int
 inverted_post_order_compute (int *post_order)
 {
 /* Put all blocks that have no successor into the initial work list.  */
 FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
 if (EDGE_COUNT (bb->succs) == 0)
 {
 /* Push the initial edge on to the stack.  */
 if (EDGE_COUNT (bb->preds) > 0)
 {
 stack[sp++] = ei_start (bb->preds);
 SET_BIT (visited, bb->index);
 }
 }
 do
 {
 bool has_unvisited_bb = false;
 /* The inverted traversal loop. */
 while (sp)
 else
 sp--;
 }
 }
 /* Detect any infinite loop and activate the kludge.
 Note that this doesn't check EXIT_BLOCK itself
 since EXIT_BLOCK is always added after the outer do-while loop.  */
 FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR, next_bb)
 if (!TEST_BIT (visited, bb->index))
 {
 }
 }
 if (has_unvisited_bb && sp == 0)
 {
 /* No blocks are reachable from EXIT at all.
 Find a dead-end from the ENTRY, and restart the iteration. */
 basic_block be = dfs_find_deadend (ENTRY_BLOCK_PTR);
 gcc_assert (be != NULL);
 SET_BIT (visited, be->index);
 stack[sp++] = ei_start (be->preds);
 }
 /* The only case the below while fires is
 when there's an infinite loop.  */
 }
 while (sp);
 /* EXIT_BLOCK is always included.  */
 /* Compute the depth first search order and store in the array
 PRE_ORDER if nonzero, marking the nodes visited in VISITED.  If
 REV_POST_ORDER is nonzero, return the reverse completion number for each
 node.  Returns the number of nodes visited.  A depth first search
 tries to get as far away from the starting point as quickly as
 possible.
 pre_order is a really a preorder numbering of the graph.
 rev_post_order is really a reverse postorder numbering of the graph.
 */
 int
 pre_and_rev_post_order_compute (int *pre_order, int *rev_post_order,
 				bool include_entry_exit)
 {
 edge_iterator *stack;
 int sp;
 int pre_order_num = 0;
 	pre_order[pre_order_num] = ENTRY_BLOCK;
 pre_order_num++;
 if (rev_post_order)
 	rev_post_order[rev_post_order_num--] = ENTRY_BLOCK;
 }
 else
 rev_post_order_num -= NUM_FIXED_BLOCKS;
 /* Allocate bitmap to track nodes that have been visited.  */
 visited = sbitmap_alloc (last_basic_block);
 loops), and allocating a large sbitmap would lead to quadratic
 behavior.  */
 static sbitmap visited;
 static unsigned v_size;
 #define MARK_VISITED(BB) (SET_BIT (visited, (BB)->index))
 #define UNMARK_VISITED(BB) (RESET_BIT (visited, (BB)->index))
 #define VISITED_P(BB) (TEST_BIT (visited, (BB)->index))
 /* Resize the VISITED sbitmap if necessary.  */
 size = last_basic_block;
 if (size < 10)
 size = 10;
 if (!visited)
 {

Mercurial > hg > CbC > CbC_gcc

comparison gcc/cfganal.c @ 55:77e2b8dfacca gcc-4.4.5