* alias.c (record_set): Use hard_regno_nregs.

	* bt-load.c (find_btr_reference, note_btr_set): Likewise.
	* builtins.c (apply_args_size): Likewise.
	* caller-save.c (setup_save_areas, save_call_clobbered_regs,
	mark_set_regs, add_stored_regs, mark_referenced_regs,
	insert_restore, insert_save, insert_one_insn): Likewise.
	* cfgcleanup.c: Include regs.h
	(mark_effect, mentions_nonequal_regs): Likewise.
	* cfgrtl.c (mark_killed_regs): Likewise
	* combine.c (update_table_tick, record_value_for_reg,
	record_dead_and_set_regs, get_last_value_validate, use_crosses_set_p,
	reg_dead_at_p_1, reg_dead_at_p, mark_used_regs_combine, move_deaths,
	reg_bitfield_target_p, distribute_notes): Likewise.
	* cse.c (mention_regs, insert, invalidate, invalidate_for_call,
	exp_equiv_p, cse_insn): Likewise.
	* cselib.c (cselib_lookup): Likewise.
	(cselib_invalidate_regno, cselib_record_set): Likewise.
	* df.c (df_ref_record): Likewise.
	* dwarf2out.c (reg_loc_descriptor, multiple_reg_loc_descriptor):
	Likewise.
	* flow.c (mark_reg, insn_dead_p, mark_set_1, mark_used_reg,
	count_or_remove_death_notes_bb): Likewise.
	* function.c (aggregate_value_p, keep_stack_depressed): Likewise.
	* gloval.c (global_alloc, find_reg, mark_reg_store, mark_reg_conflicts,
	mark_reg_death, set_preference, reg_becomes_live, reg_dies): Likewise.
	* integrate.c (mark_stores): Likewise.
	* jump.c (delete_prior_computation): Likewise.
	* lcm.c (reg_dies, reg_becomes_live): Likewise.
	* local-alloc.c (combine_regs, find_free_reg, post_mark_life): Likewise.
	* loop.c (LOOP_REGNO_NREGS): Likewise.
	* postreload.c (reload_combine, reload_combine_note_store,
	reload_combine_note_use, reload_cse_move2add, move2add_note_store): Likewise.
	* ra-colorize.c (combine, color_usable_p, get_free_reg,
	calculate_dont_begin, calculate_dont_begin, colorize_one_web,
	try_recolor_web, insert_coalesced_conflicts, check_colors,
	break_precolored_alias): Likewise.
	* ra-debug.c: Include regs.h
	(ra_print_rtx_object): Likewise.
	* ra-rewrite (choose_spill_colors): Likewise.
	(spill_same_color_p, update_spill_colors, spill_is_free): Likewise.
	* ra.c (init_ra): Likewise.
	* recog.c (reg_fits_class_p, peep2_reg_dead_p,
	peep2_find_free_register): Likewise.
	* reg-stack.c (subst_stack_regs_pat, convert_regs_exit): Likewise.
	* regclass.c (hard_regno_nregs): New array.
	(init_reg_modes_once): Initialize it.
	(choose_hard_reg_mode): Use it.
	(record_reg_classes): Likewise.
	* regmove.c (mark_flags_life_zones): Likewise.
	* regrename.c (note_sets, clear_dead_regs, regrename_optimize,
	scan_rtx_reg, dump_def_use_chain, kill_value, set_value_regno,
	copy_value, maybe_mode_change, find_oldest_value_reg,
	copyprop_hardreg_forward_1):
	* regs.h (hard_regno_nregs): Declare.
	* realod.c (reload_inner_reg_of_subreg): Use it.
	(push_reload, combine_reloads, find_dummy_reload,
	hard_reg_set_here_p, operands_match_p, decompose, find_reloads,
	refers_to_regno_for_reload_p, find_equiv_reg, regno_clobbered_p,
	reload_adjust_reg_for_mode): Likewise.
	* reload1.c (compute_use_by_pseudos, count_pseudo,
	count_spilled_pseudo, find_reg, find_reload_regs, mark_home_live,
	spill_hard_reg, forget_old_reloads_1, mark_reload_reg_in_use,
	clear_reload_reg_in_use, reload_reg_free_for_value_p, free_for_value_p
	allocate_reload_reg, choose_reload_regs, emit_reload_insns,
	delete_output_reload): Likewise.
	* resource.c (update_live_status, mark_referenced_resources,
	mark_set_resources, mark_target_live_regs): Likewise.
	* rtlanal.c:  Include regs.h
	(refers_to_regno_p, reg_overlap_mentioned_p, dead_or_set_p,
	dead_or_set_regno_p, find_regno_note, find_reg_fusage,
	subreg_regno_offset, subreg_offset_representable_p,
	hoist_test_store): Likewise.
	* sched-deps.c (sched_analyze_1, sched_analyze_2): Likewise.
	* sched-rgn.c (check_live_1, update_live_1): Likewise.
	* stmt.c: Include regs.h
	(decl_conflicts_with_clobbers_p): Likewise.
	* varasm.c (make_decl_rtl): Likewise.
	* Makefile.in (cfgcleanup.o, rtlanal.o, ra-debug.o): Add regs.h dependnecy.


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

1 files changed, 28 insertions, 28 deletions

diff --git a/gcc/reload1.c b/gcc/reload1.c
index 1ea21ee3890..5cce770ca12 100644
--- a/gcc/reload1.c
+++ b/gcc/reload1.c
@@ -534,7 +534,7 @@ compute_use_by_pseudos (HARD_REG_SET *to, regset from)
 	 }
        else
 	 {
-	   nregs = HARD_REGNO_NREGS (r, PSEUDO_REGNO_MODE (regno));
+	   nregs = hard_regno_nregs[r][PSEUDO_REGNO_MODE (regno)];
 	   while (nregs-- > 0)
 	     SET_HARD_REG_BIT (*to, r + nregs);
 	 }
@@ -1572,7 +1572,7 @@ count_pseudo (int reg)
 
   spill_add_cost[r] += freq;
 
-  nregs = HARD_REGNO_NREGS (r, PSEUDO_REGNO_MODE (reg));
+  nregs = hard_regno_nregs[r][PSEUDO_REGNO_MODE (reg)];
   while (nregs-- > 0)
     spill_cost[r + nregs] += freq;
 }
@@ -1634,7 +1634,7 @@ static void
 count_spilled_pseudo (int spilled, int spilled_nregs, int reg)
 {
   int r = reg_renumber[reg];
-  int nregs = HARD_REGNO_NREGS (r, PSEUDO_REGNO_MODE (reg));
+  int nregs = hard_regno_nregs[r][PSEUDO_REGNO_MODE (reg)];
 
   if (REGNO_REG_SET_P (&spilled_pseudos, reg)
       || spilled + spilled_nregs <= r || r + nregs <= spilled)
@@ -1685,7 +1685,7 @@ find_reg (struct insn_chain *chain, int order)
 	{
 	  int this_cost = spill_cost[regno];
 	  int ok = 1;
-	  unsigned int this_nregs = HARD_REGNO_NREGS (regno, rl->mode);
+	  unsigned int this_nregs = hard_regno_nregs[regno][rl->mode];
 
 	  for (j = 1; j < this_nregs; j++)
 	    {
@@ -1724,7 +1724,7 @@ find_reg (struct insn_chain *chain, int order)
   if (rtl_dump_file)
     fprintf (rtl_dump_file, "Using reg %d for reload %d\n", best_reg, rnum);
 
-  rl->nregs = HARD_REGNO_NREGS (best_reg, rl->mode);
+  rl->nregs = hard_regno_nregs[best_reg][rl->mode];
   rl->regno = best_reg;
 
   EXECUTE_IF_SET_IN_REG_SET
@@ -1772,7 +1772,7 @@ find_reload_regs (struct insn_chain *chain)
 	  int regno = REGNO (chain->rld[i].reg_rtx);
 	  chain->rld[i].regno = regno;
 	  chain->rld[i].nregs
-	    = HARD_REGNO_NREGS (regno, GET_MODE (chain->rld[i].reg_rtx));
+	    = hard_regno_nregs[regno][GET_MODE (chain->rld[i].reg_rtx)];
 	}
       else
 	chain->rld[i].regno = -1;
@@ -2062,7 +2062,7 @@ mark_home_live (int regno)
   i = reg_renumber[regno];
   if (i < 0)
     return;
-  lim = i + HARD_REGNO_NREGS (i, PSEUDO_REGNO_MODE (regno));
+  lim = i + hard_regno_nregs[i][PSEUDO_REGNO_MODE (regno)];
   while (i < lim)
     regs_ever_live[i++] = 1;
 }
@@ -3516,8 +3516,8 @@ spill_hard_reg (unsigned int regno, int cant_eliminate)
     if (reg_renumber[i] >= 0
 	&& (unsigned int) reg_renumber[i] <= regno
 	&& ((unsigned int) reg_renumber[i]
-	    + HARD_REGNO_NREGS ((unsigned int) reg_renumber[i],
-				PSEUDO_REGNO_MODE (i))
+	    + hard_regno_nregs[(unsigned int) reg_renumber[i]]
+			      [PSEUDO_REGNO_MODE (i)]
 	    > regno))
       SET_REGNO_REG_SET (&spilled_pseudos, i);
 }
@@ -4059,7 +4059,7 @@ forget_old_reloads_1 (rtx x, rtx ignored ATTRIBUTE_UNUSED,
     {
       unsigned int i;
 
-      nr = HARD_REGNO_NREGS (regno, GET_MODE (x));
+      nr = hard_regno_nregs[regno][GET_MODE (x)];
       /* Storing into a spilled-reg invalidates its contents.
 	 This can happen if a block-local pseudo is allocated to that reg
 	 and it wasn't spilled because this block's total need is 0.
@@ -4133,7 +4133,7 @@ static void
 mark_reload_reg_in_use (unsigned int regno, int opnum, enum reload_type type,
 			enum machine_mode mode)
 {
-  unsigned int nregs = HARD_REGNO_NREGS (regno, mode);
+  unsigned int nregs = hard_regno_nregs[regno][mode];
   unsigned int i;
 
   for (i = regno; i < nregs + regno; i++)
@@ -4195,7 +4195,7 @@ static void
 clear_reload_reg_in_use (unsigned int regno, int opnum,
 			 enum reload_type type, enum machine_mode mode)
 {
-  unsigned int nregs = HARD_REGNO_NREGS (regno, mode);
+  unsigned int nregs = hard_regno_nregs[regno][mode];
   unsigned int start_regno, end_regno, r;
   int i;
   /* A complication is that for some reload types, inheritance might
@@ -4279,7 +4279,7 @@ clear_reload_reg_in_use (unsigned int regno, int opnum,
 	      unsigned int conflict_start = true_regnum (rld[i].reg_rtx);
 	      unsigned int conflict_end
 		= (conflict_start
-		   + HARD_REGNO_NREGS (conflict_start, rld[i].mode));
+		   + hard_regno_nregs[conflict_start][rld[i].mode]);
 
 	      /* If there is an overlap with the first to-be-freed register,
 		 adjust the interval start.  */
@@ -4774,7 +4774,7 @@ reload_reg_free_for_value_p (int start_regno, int regno, int opnum,
       rtx reg = rld[i].reg_rtx;
       if (reg && GET_CODE (reg) == REG
 	  && ((unsigned) regno - true_regnum (reg)
-	      <= HARD_REGNO_NREGS (REGNO (reg), GET_MODE (reg)) - (unsigned) 1)
+	      <= hard_regno_nregs[REGNO (reg)][GET_MODE (reg)] - (unsigned) 1)
 	  && i != reloadnum)
 	{
 	  rtx other_input = rld[i].in;
@@ -4930,7 +4930,7 @@ free_for_value_p (int regno, enum machine_mode mode, int opnum,
 		  enum reload_type type, rtx value, rtx out, int reloadnum,
 		  int ignore_address_reloads)
 {
-  int nregs = HARD_REGNO_NREGS (regno, mode);
+  int nregs = hard_regno_nregs[regno][mode];
   while (nregs-- > 0)
     if (! reload_reg_free_for_value_p (regno, regno + nregs, opnum, type,
 				       value, out, reloadnum,
@@ -5103,7 +5103,7 @@ allocate_reload_reg (struct insn_chain *chain ATTRIBUTE_UNUSED, int r,
 		      && ! TEST_HARD_REG_BIT (reload_reg_used_for_inherit,
 					      regnum))))
 	    {
-	      int nr = HARD_REGNO_NREGS (regnum, rld[r].mode);
+	      int nr = hard_regno_nregs[regnum][rld[r].mode];
 	      /* Avoid the problem where spilling a GENERAL_OR_FP_REG
 		 (on 68000) got us two FP regs.  If NR is 1,
 		 we would reject both of them.  */
@@ -5436,7 +5436,7 @@ choose_reload_regs (struct insn_chain *chain)
 		    {
 		      /* If a group is needed, verify that all the subsequent
 			 registers still have their values intact.  */
-		      int nr = HARD_REGNO_NREGS (i, rld[r].mode);
+		      int nr = hard_regno_nregs[i][rld[r].mode];
 		      int k;
 
 		      for (k = 1; k < nr; k++)
@@ -5669,7 +5669,7 @@ choose_reload_regs (struct insn_chain *chain)
 		  && (regno != HARD_FRAME_POINTER_REGNUM
 		      || !frame_pointer_needed))
 		{
-		  int nr = HARD_REGNO_NREGS (regno, rld[r].mode);
+		  int nr = hard_regno_nregs[regno][rld[r].mode];
 		  int k;
 		  rld[r].reg_rtx = equiv;
 		  reload_inherited[r] = 1;
@@ -5884,14 +5884,14 @@ choose_reload_regs (struct insn_chain *chain)
 	  int nr = 1;
 
 	  if (nregno < FIRST_PSEUDO_REGISTER)
-	    nr = HARD_REGNO_NREGS (nregno, rld[r].mode);
+	    nr = hard_regno_nregs[nregno][rld[r].mode];
 
 	  while (--nr >= 0)
 	    reg_has_output_reload[nregno + nr] = 1;
 
 	  if (i >= 0)
 	    {
-	      nr = HARD_REGNO_NREGS (i, rld[r].mode);
+	      nr = hard_regno_nregs[i][rld[r].mode];
 	      while (--nr >= 0)
 		SET_HARD_REG_BIT (reg_is_output_reload, i + nr);
 	    }
@@ -7032,7 +7032,7 @@ emit_reload_insns (struct insn_chain *chain)
 
       if (i >= 0 && rld[r].reg_rtx != 0)
 	{
-	  int nr = HARD_REGNO_NREGS (i, GET_MODE (rld[r].reg_rtx));
+	  int nr = hard_regno_nregs[i][GET_MODE (rld[r].reg_rtx)];
 	  int k;
 	  int part_reaches_end = 0;
 	  int all_reaches_end = 1;
@@ -7076,8 +7076,8 @@ emit_reload_insns (struct insn_chain *chain)
 /* AUTO_INC */		     : XEXP (rld[r].in_reg, 0));
 		  int nregno = REGNO (out);
 		  int nnr = (nregno >= FIRST_PSEUDO_REGISTER ? 1
-			     : HARD_REGNO_NREGS (nregno,
-						 GET_MODE (rld[r].reg_rtx)));
+			     : hard_regno_nregs[nregno]
+					       [GET_MODE (rld[r].reg_rtx)]);
 
 		  spill_reg_store[i] = new_spill_reg_store[i];
 		  spill_reg_stored_to[i] = out;
@@ -7137,8 +7137,8 @@ emit_reload_insns (struct insn_chain *chain)
 		  nregno = REGNO (in);
 
 		  nnr = (nregno >= FIRST_PSEUDO_REGISTER ? 1
-			 : HARD_REGNO_NREGS (nregno,
-					     GET_MODE (rld[r].reg_rtx)));
+			 : hard_regno_nregs[nregno]
+					   [GET_MODE (rld[r].reg_rtx)]);
 
 		  reg_last_reload_reg[nregno] = rld[r].reg_rtx;
 
@@ -7238,7 +7238,7 @@ emit_reload_insns (struct insn_chain *chain)
 		  && REGNO (src_reg) < FIRST_PSEUDO_REGISTER)
 		{
 		  int src_regno = REGNO (src_reg);
-		  int nr = HARD_REGNO_NREGS (src_regno, rld[r].mode);
+		  int nr = hard_regno_nregs[src_regno][rld[r].mode];
 		  /* The place where to find a death note varies with
 		     PRESERVE_DEATH_INFO_REGNO_P .  The condition is not
 		     necessarily checked exactly in the code that moves
@@ -7269,7 +7269,7 @@ emit_reload_insns (struct insn_chain *chain)
 	    }
 	  else
 	    {
-	      int num_regs = HARD_REGNO_NREGS (nregno, GET_MODE (rld[r].out));
+	      int num_regs = hard_regno_nregs[nregno][GET_MODE (rld[r].out)];
 
 	      while (num_regs-- > 0)
 		reg_last_reload_reg[nregno + num_regs] = 0;
@@ -7594,7 +7594,7 @@ delete_output_reload (rtx insn, int j, int last_reload_reg)
     }
 
   /* We will be deleting the insn.  Remove the spill reg information.  */
-  for (k = HARD_REGNO_NREGS (last_reload_reg, GET_MODE (reg)); k-- > 0; )
+  for (k = hard_regno_nregs[last_reload_reg][GET_MODE (reg)]; k-- > 0; )
     {
       spill_reg_store[last_reload_reg + k] = 0;
       spill_reg_stored_to[last_reload_reg + k] = 0;