basic-block.h: Changed basic block numbering so that the entry block is 0 and the exit block is 1.

2005-12-17  Danny Berlin <dberlin@dberlin.org>
	    Kenneth Zadeck <zadeck@naturalbridge.com>

	* basic-block.h: Changed basic block numbering so that the entry
	block is 0 and the exit block is 1.  Changed insn iterators so
	that they are tolerant of blocks with no insns.
	* regrename.c (copyprop_hardreg_forward): Changed basic block
	numbering so that the entry block is 0 and the exit block is 1.
	* sched-ebb.c (sehedule_ebbs): Ditto.
	* tracer.c (branch_ratio_cutoff): Ditto.
	* cfgloopmanip.c (fix_loop_structure): Ditto.
	* cfghooks.c (verify_flow_info): Ditto.
	* cfg.c (compact_blocks): Ditto.
	* reorg.c (dbr_schedule): Ditto.
	* flow.c (calculate_global_regs_live, libcall_dead_p): Ditto.
	* dominance.c (calc_dfs_tree_nonrec, calc_dfs_tree,
	calculate_dominance_info): Ditto.
	* cfganal.c (create_edge_list, print_edge_list,
	flow_depth_first_order_compute, flow_dfs_compute_reverse_init,
	flow_dfs_compute_reverse_add_bb, flow_dfs_compute_reverse_execute,
	dfs_enumerate_from): Ditto.
	* global.c (global_alloc, set_up_bb_rts_numbers): Ditto.
	* ifcvt.c (find_if_case_2): Ditto.
	* cfgbuild.c (control_flow_insn_p, count_basic_blocks,
	find_basic_blocks): Ditto.
	* predict.c (predict_loops, tree_bb_level_predictions,
	predict_paths_leading_to, propagate_freq): Ditto.
	* lcm.c (compute_antinout_edge, compute_laterin,
	compute_available): Ditto.
	* function.c (thread_prologue_and_epilogue_insns): Ditto.
	* gcse.c (gcse_main, bypass_jumps): Ditto.
	* profile.c (compute_branch_probabilities,
	compute_value_histograms, branch_prob): Ditto.
	* tree-flow-inline.h (bsi_start, bsi_after_labels,
	bsi_last): Ditto.
	* tree-ssa-phiopt.c (tree_ssa_phiopt,
	blocks_in_phiopt_order): Ditto.
	* bt-load.c (compute_defs_uses_and_gen, compute_kill,
	compute_out, link_btr_uses, migrate_btr_defs): Ditto.
	* tree-dfa.c (collect_dfa_stats): Ditto.
	* cfgcleanup.c (try_forward_edges, try_optimize_cfg): Ditto.
	* cfglayout.c (fixup_reorder_chain): Ditto.
	* bb-reorder.c (reorder_basic_blocks, duplicate_computed_gotos,
	partition_hot_cold_basic_blocks): Ditto.
	* var-tracking.c (vt_find_locations): Ditto.
	* cfgloop.c (flow_loops_cfg_dump, flow_loops_find, get_loop_body): Ditto.
	* sched-rgn.c (compute_trg_info, init_regions, schedule_insns): Ditto.
	* tree-cfg.c (init_empty_tree_cfg, build_tree_cfg, make_edges
	label_to_block_fn, print_loop_ir, tree_flow_call_edges_add): Ditto.
	* tree-ssa-reassoc.c (init_reassoc): Ditto.
	* cfgrtl.c (entry_of_function, rtl_verify_flow_info,
	rtl_flow_call_edges_add, rtl_flow_call_edges_add): Ditto.
	* df.c (df_analyze_1, hybrid_search, iterative_dataflow): Ditto
	and removed unused reverse orders.
	* df.h (): Ditto.
	* combine.c: Fix document typo.



Co-Authored-By: Kenneth Zadeck <zadeck@naturalbridge.com>

From-SVN: r108713

1 files changed, 23 insertions, 28 deletions

diff --git a/gcc/flow.c b/gcc/flow.c
index 9ef0a90..436bfd7 100644
--- a/gcc/flow.c
+++ b/gcc/flow.c
@@ -1054,17 +1054,14 @@ calculate_global_regs_live (sbitmap blocks_in, sbitmap blocks_out, int flags)
       SET_REGNO_REG_SET (invalidated_by_call, i);
 
   /* Allocate space for the sets of local properties.  */
-  local_sets = xcalloc (last_basic_block - (INVALID_BLOCK + 1),
-			sizeof (regset));
-  cond_local_sets = xcalloc (last_basic_block - (INVALID_BLOCK + 1),
-			     sizeof (regset));
-
-  /* Create a worklist.  Allocate an extra slot for ENTRY_BLOCK, and one
-     because the `head == tail' style test for an empty queue doesn't
-     work with a full queue.  */
-  queue = xmalloc ((n_basic_blocks - (INVALID_BLOCK + 1)) * sizeof (*queue));
+  local_sets = xcalloc (last_basic_block, sizeof (regset));
+  cond_local_sets = xcalloc (last_basic_block, sizeof (regset));
+
+  /* Create a worklist.  Allocate an extra slot for the `head == tail'
+     style test for an empty queue doesn't work with a full queue.  */
+  queue = xmalloc ((n_basic_blocks + 1) * sizeof (*queue));
   qtail = queue;
-  qhead = qend = queue + n_basic_blocks - (INVALID_BLOCK + 1);
+  qhead = qend = queue + n_basic_blocks;
 
   /* Queue the blocks set in the initial mask.  Do this in reverse block
      number order so that we are more likely for the first round to do
@@ -1245,12 +1242,10 @@ calculate_global_regs_live (sbitmap blocks_in, sbitmap blocks_out, int flags)
          basic block.  On subsequent passes, we get to skip out early if
 	 live_at_end wouldn't have changed.  */
 
-      if (local_sets[bb->index - (INVALID_BLOCK + 1)] == NULL)
+      if (local_sets[bb->index] == NULL)
 	{
-	  local_sets[bb->index - (INVALID_BLOCK + 1)]
-	    = ALLOC_REG_SET (&reg_obstack);
-	  cond_local_sets[bb->index - (INVALID_BLOCK + 1)]
-	    = ALLOC_REG_SET (&reg_obstack);
+	  local_sets[bb->index] = ALLOC_REG_SET (&reg_obstack);
+	  cond_local_sets[bb->index] = ALLOC_REG_SET (&reg_obstack);
 	  rescan = 1;
 	}
       else
@@ -1274,7 +1269,7 @@ calculate_global_regs_live (sbitmap blocks_in, sbitmap blocks_out, int flags)
 		  successor block.  We can miss changes in those sets if
 		  we only compare the new live_at_end against the
 		  previous one.  */
-	      cond_local_set = cond_local_sets[bb->index - (INVALID_BLOCK + 1)];
+	      cond_local_set = cond_local_sets[bb->index];
 	      rescan = bitmap_intersect_p (new_live_at_end, cond_local_set);
 	    }
 
@@ -1290,7 +1285,7 @@ calculate_global_regs_live (sbitmap blocks_in, sbitmap blocks_out, int flags)
   
 	      /* If any of the changed bits overlap with local_sets[bb],
  		 we'll have to rescan the block.  */
-	      local_set = local_sets[bb->index - (INVALID_BLOCK + 1)];
+	      local_set = local_sets[bb->index];
 	      rescan = bitmap_intersect_p (tmp, local_set);
 	    }
 	}
@@ -1319,8 +1314,8 @@ calculate_global_regs_live (sbitmap blocks_in, sbitmap blocks_out, int flags)
 	  /* Rescan the block insn by insn to turn (a copy of) live_at_end
 	     into live_at_start.  */
 	  propagate_block (bb, new_live_at_end,
-			   local_sets[bb->index - (INVALID_BLOCK + 1)],
-			   cond_local_sets[bb->index - (INVALID_BLOCK + 1)],
+			   local_sets[bb->index],
+			   cond_local_sets[bb->index],
 			   flags);
 
 	  /* If live_at start didn't change, no need to go farther.  */
@@ -1366,11 +1361,11 @@ calculate_global_regs_live (sbitmap blocks_in, sbitmap blocks_out, int flags)
 			SET_BIT (blocks_out, pbb->index);
 
 		      /* Makes sure to really rescan the block.  */
-		      if (local_sets[pbb->index - (INVALID_BLOCK + 1)])
+		      if (local_sets[pbb->index])
 			{
-			  FREE_REG_SET (local_sets[pbb->index - (INVALID_BLOCK + 1)]);
-			  FREE_REG_SET (cond_local_sets[pbb->index - (INVALID_BLOCK + 1)]);
-			  local_sets[pbb->index - (INVALID_BLOCK + 1)] = 0;
+			  FREE_REG_SET (local_sets[pbb->index]);
+			  FREE_REG_SET (cond_local_sets[pbb->index]);
+			  local_sets[pbb->index] = 0;
 			}
 
 		      /* Add it to the queue.  */
@@ -1416,16 +1411,16 @@ calculate_global_regs_live (sbitmap blocks_in, sbitmap blocks_out, int flags)
       EXECUTE_IF_SET_IN_SBITMAP (blocks_out, 0, i, sbi)
 	{
 	  basic_block bb = BASIC_BLOCK (i);
-	  FREE_REG_SET (local_sets[bb->index - (INVALID_BLOCK + 1)]);
-	  FREE_REG_SET (cond_local_sets[bb->index - (INVALID_BLOCK + 1)]);
+ 	  FREE_REG_SET (local_sets[bb->index]);
+ 	  FREE_REG_SET (cond_local_sets[bb->index]);
 	};
     }
   else
     {
       FOR_EACH_BB (bb)
 	{
-	  FREE_REG_SET (local_sets[bb->index - (INVALID_BLOCK + 1)]);
-	  FREE_REG_SET (cond_local_sets[bb->index - (INVALID_BLOCK + 1)]);
+ 	  FREE_REG_SET (local_sets[bb->index]);
+ 	  FREE_REG_SET (cond_local_sets[bb->index]);
 	}
     }
 
@@ -2472,7 +2467,7 @@ libcall_dead_p (struct propagate_block_info *pbi, rtx note, rtx insn)
 int
 regno_clobbered_at_setjmp (int regno)
 {
-  if (n_basic_blocks == 0)
+  if (n_basic_blocks == NUM_FIXED_BLOCKS)
     return 0;
 
   return ((REG_N_SETS (regno) > 1