* bb-reorder.c (make_reorder_chain, make_reorder_chain_1):

	Use FOR_EACH_BB macros to iterate over basic block chain.
	* cfg.c (clear_edges, clear_bb_flags, dump_flow_info,
	alloc_aux_for_blocks, clear_aux_for_blocks, alloc_aux_for_edges):
	Likewise.
	* cfganal.c (set_edge_can_fallthru_flag, flow_call_edges_add,
	find_unreachable_blocks, create_edge_list, verify_edge_list,
	remove_fake_edges, add_noreturn_fake_exit_edges,
	flow_preorder_transversal_compute, flow_dfs_compute_reverse_execute):
	Likewise.
	* cfgbuild.c (make_edges, find_basic_blocks, find_many_sub_basic_blocks,
	find_sub_basic_blocks): Likewise.
	* cfgcleanup.c (try_optimize_cfg, delete_unreachable_blocks):
	Likewise.
	* cfglayout.c (record_effective_endpoints, cleanup_unconditional_jumps):
	Likewise.
	* cfgloop.c (flow_loops_cfg_dump, flow_loops_find):
	Likewise.
	* cfgrtl.c (compute_bb_for_insn, tidy_fallthru_edges,
	commit_edge_insertions, commit_edge_insertions_watch_calls,
	print_rtl_with_bb, verify_flow_info, purge_all_dead_edges): Likewise.
	* combine.c (combine_instructions, reg_dead_at_p): Likewise.
	* conflict.c (conflict_graph_compute): Likewise.
	* df.c (df_bitmaps_alloc, df_bitmaps_free, df_alloc, df_analyse_1,
	df_modified_p, df_refs_unlink, df_dump): Likewise.
	* dominance.c (calc_dfs_tree, calculate_dominance_info): Likewise.
	* final.c (compute_alignments): Likewise.
	* flow.c (update_life_info, update_life_info_in_dirty_blocks,
	delete_noop_moves, calculate_global_regs_live, allocate_bb_life_data,
	count_or_remove_death_notes): Likewise.
	* gcse.c (oprs_unchanged_p, record_last_reg_set_info,
	compute_hash_table, compute_kill_rd, compute_rd, compute_ae_kill,
	classic_gcse, compute_transp, cprop, compute_pre_data,
	compute_transpout, invalidate_nonnull_info,
	delete_null_pointer_checks_1, delete_null_pointer_checks,
	compute_code_hoist_vbeinout, hoist_code, compute_ld_motion_mems,
	compute_store_table, build_store_vectors, store_motion): Likewise.
	* global.c (global_conflicts, mark_elimination): Likewise.
	* graph.c (print_rtl_graph_with_bb): Likewise.
	* haifa-sched.c (sched_init): Likewise.
	* ifcvt.c (if_convert): Likewise.
	* lcm.c (compute_antinout_edge, compute_laterin, compute_insert_delete,
	compute_available, compute_nearerout, compute_rev_insert_delete,
	optimize_mode_switching): Likewise.
	* local-alloc.c (local_alloc, update_equiv_regs): Likewise.
	* predict.c (estimate_probability, note_prediction_to_br_prob,
	propagate_freq, counts_to_freqs, expensive_function_p,
	estimate_bb_frequencies): Likewise.
	* profile.c (instrument_edges, get_exec_counts,
	compute_branch_probabilities, compute_checksum, branch_prob,
	find_spanning_tree): Likewise.
	* recog.c (split_all_insns, peephole2_optimize): Likewise.
	* reg-stack.c (reg_to_stack, convert_regs_entry, convert_regs):
	Likewise.
	* regclass.c (scan_one_insn, regclass): Likewise.
	* regmove.c (mark_flags_life_zones, regmove_optimize,
	record_stack_memrefs): Likewise.
	* regrename.c (regrename_optimize, copyprop_hardreg_forward): Likewise.
	* reload1.c (reload, reload_combine, fixup_abnormal_edges): Likewise.
	* resource.c (find_basic_block): Likewise.
	* sched-ebb.c (schedule_ebbs): Likewise.
	* sched-rgn.c (is_cfg_nonregular, build_control_flow,
	find_single_block_region, find_rgns, schedule_insns)
	* sibcall.c (optimize_sibling_and_tail_recursive_call)
	* ssa-ccp.c (optimize_unexecutable_edges,
	ssa_ccp_df_delete_unreachable_insns): Likewise.
	* ssa-dce.c (ssa_eliminate_dead_code): Likewise.
	* ssa.c (find_evaluations, compute_dominance_frontiers_1,
	rename_block, convert_to_ssa, compute_conservative_reg_partition,
	compute_coalesced_reg_partition, rename_equivalent_regs,
	convert_from_ssa): Likewise.
	* config/ia64/ia64.c (emit_predicate_relation_info, process_epilogue,
	process_for_unwind_directive): Likewise.

	* df.c (FOR_ALL_BBS): Removed.
	* gcse.c (struct null_pointer_info): Type of current_block field
	changed.
	(struct reg_avail_info): Type of last_bb field changed.
	* config/ia64/ia64.c (block_num): Removed.
	(need_copy_state): Type changed.
	(last_block): New.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@53804 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 42 insertions, 46 deletions

diff --git a/gcc/cfgbuild.c b/gcc/cfgbuild.c
index 0451a3475fd..305c09fc94f 100644
--- a/gcc/cfgbuild.c
+++ b/gcc/cfgbuild.c
@@ -284,7 +284,7 @@ make_edges (label_value_list, min, max, update_p)
      basic_block min, max;
      int update_p;
 {
-  int i;
+  basic_block bb;
   sbitmap *edge_cache = NULL;
 
   /* Assume no computed jump; revise as we create edges.  */
@@ -299,24 +299,24 @@ make_edges (label_value_list, min, max, update_p)
       sbitmap_vector_zero (edge_cache, n_basic_blocks);
 
       if (update_p)
-	for (i = min->index; i <= max->index; ++i)
+        FOR_BB_BETWEEN (bb, min, max->next_bb, next_bb)
 	  {
 	    edge e;
 
-	    for (e = BASIC_BLOCK (i)->succ; e ; e = e->succ_next)
+	    for (e = bb->succ; e ; e = e->succ_next)
 	      if (e->dest != EXIT_BLOCK_PTR)
-		SET_BIT (edge_cache[i], e->dest->index);
+		SET_BIT (edge_cache[bb->index], e->dest->index);
 	  }
     }
 
-  /* By nature of the way these get numbered, block 0 is always the entry.  */
+  /* By nature of the way these get numbered, ENTRY_BLOCK_PTR->next_bb block
+     is always the entry.  */
   if (min == ENTRY_BLOCK_PTR->next_bb)
     cached_make_edge (edge_cache, ENTRY_BLOCK_PTR, min,
 		      EDGE_FALLTHRU);
 
-  for (i = min->index; i <= max->index; ++i)
+  FOR_BB_BETWEEN (bb, min, max->next_bb, next_bb)
     {
-      basic_block bb = BASIC_BLOCK (i);
       rtx insn, x;
       enum rtx_code code;
       int force_fallthru = 0;
@@ -614,6 +614,8 @@ find_basic_blocks (f, nregs, file)
      FILE *file ATTRIBUTE_UNUSED;
 {
   int max_uid;
+  basic_block bb;
+
   timevar_push (TV_CFG);
 
   basic_block_for_insn = 0;
@@ -621,15 +623,13 @@ find_basic_blocks (f, nregs, file)
   /* Flush out existing data.  */
   if (basic_block_info != NULL)
     {
-      int i;
-
       clear_edges ();
 
       /* Clear bb->aux on all extant basic blocks.  We'll use this as a
 	 tag for reuse during create_basic_block, just in case some pass
 	 copies around basic block notes improperly.  */
-      for (i = 0; i < n_basic_blocks; ++i)
-	BASIC_BLOCK (i)->aux = NULL;
+      FOR_EACH_BB (bb)
+ 	bb->aux = NULL;
 
       VARRAY_FREE (basic_block_info);
     }
@@ -794,55 +794,53 @@ void
 find_many_sub_basic_blocks (blocks)
      sbitmap blocks;
 {
-  int i;
-  int min, max;
+  basic_block bb, min, max;
 
-  for (i = 0; i < n_basic_blocks; i++)
-    SET_STATE (BASIC_BLOCK (i),
-	       TEST_BIT (blocks, i) ? BLOCK_TO_SPLIT : BLOCK_ORIGINAL);
+  FOR_EACH_BB (bb)
+    SET_STATE (bb,
+	       TEST_BIT (blocks, bb->index) ? BLOCK_TO_SPLIT : BLOCK_ORIGINAL);
 
-  for (i = 0; i < n_basic_blocks; i++)
-    if (STATE (BASIC_BLOCK (i)) == BLOCK_TO_SPLIT)
-      find_bb_boundaries (BASIC_BLOCK (i));
+  FOR_EACH_BB (bb)
+    if (STATE (bb) == BLOCK_TO_SPLIT)
+      find_bb_boundaries (bb);
 
-  for (i = 0; i < n_basic_blocks; i++)
-    if (STATE (BASIC_BLOCK (i)) != BLOCK_ORIGINAL)
+  FOR_EACH_BB (bb)
+    if (STATE (bb) != BLOCK_ORIGINAL)
       break;
 
-  min = max = i;
-  for (; i < n_basic_blocks; i++)
-    if (STATE (BASIC_BLOCK (i)) != BLOCK_ORIGINAL)
-      max = i;
+  min = max = bb;
+  for (; bb != EXIT_BLOCK_PTR; bb = bb->next_bb)
+    if (STATE (bb) != BLOCK_ORIGINAL)
+      max = bb;
 
   /* Now re-scan and wire in all edges.  This expect simple (conditional)
      jumps at the end of each new basic blocks.  */
-  make_edges (NULL, BASIC_BLOCK (min), BASIC_BLOCK (max), 1);
+  make_edges (NULL, min, max, 1);
 
   /* Update branch probabilities.  Expect only (un)conditional jumps
      to be created with only the forward edges.  */
-  for (i = min; i <= max; i++)
+  FOR_BB_BETWEEN (bb, min, max->next_bb, next_bb)
     {
       edge e;
-      basic_block b = BASIC_BLOCK (i);
 
-      if (STATE (b) == BLOCK_ORIGINAL)
+      if (STATE (bb) == BLOCK_ORIGINAL)
 	continue;
-      if (STATE (b) == BLOCK_NEW)
+      if (STATE (bb) == BLOCK_NEW)
 	{
-	  b->count = 0;
-	  b->frequency = 0;
-	  for (e = b->pred; e; e=e->pred_next)
+	  bb->count = 0;
+	  bb->frequency = 0;
+	  for (e = bb->pred; e; e=e->pred_next)
 	    {
-	      b->count += e->count;
-	      b->frequency += EDGE_FREQUENCY (e);
+	      bb->count += e->count;
+	      bb->frequency += EDGE_FREQUENCY (e);
 	    }
 	}
 
-      compute_outgoing_frequencies (b);
+      compute_outgoing_frequencies (bb);
     }
 
-  for (i = 0; i < n_basic_blocks; i++)
-    SET_STATE (BASIC_BLOCK (i), 0);
+  FOR_EACH_BB (bb)
+    SET_STATE (bb, 0);
 }
 
 /* Like above but for single basic block only.  */
@@ -851,26 +849,24 @@ void
 find_sub_basic_blocks (bb)
      basic_block bb;
 {
-  int i;
-  int min, max;
+  basic_block min, max, b;
   basic_block next = bb->next_bb;
 
-  min = bb->index;
+  min = bb;
   find_bb_boundaries (bb);
-  max = next->prev_bb->index;
+  max = next->prev_bb;
 
   /* Now re-scan and wire in all edges.  This expect simple (conditional)
      jumps at the end of each new basic blocks.  */
-  make_edges (NULL, BASIC_BLOCK (min), BASIC_BLOCK (max), 1);
+  make_edges (NULL, min, max, 1);
 
   /* Update branch probabilities.  Expect only (un)conditional jumps
      to be created with only the forward edges.  */
-  for (i = min; i <= max; i++)
+  FOR_BB_BETWEEN (b, min, max->next_bb, next_bb)
     {
       edge e;
-      basic_block b = BASIC_BLOCK (i);
 
-      if (i != min)
+      if (b != min)
 	{
 	  b->count = 0;
 	  b->frequency = 0;