* 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, 43 insertions, 40 deletions

diff --git a/gcc/reload.c b/gcc/reload.c
index e105ac9a715..92c3c47a2b8 100644
--- a/gcc/reload.c
+++ b/gcc/reload.c
@@ -818,7 +818,7 @@ reload_inner_reg_of_subreg (rtx x, enum machine_mode mode, int output)
 	  && output
 	  && GET_MODE_SIZE (GET_MODE (inner)) > UNITS_PER_WORD
 	  && ((GET_MODE_SIZE (GET_MODE (inner)) / UNITS_PER_WORD)
-	      != (int) HARD_REGNO_NREGS (REGNO (inner), GET_MODE (inner))));
+	      != (int) hard_regno_nregs[REGNO (inner)][GET_MODE (inner)]));
 }
 
 /* Return nonzero if IN can be reloaded into REGNO with mode MODE without
@@ -1038,8 +1038,8 @@ push_reload (rtx in, rtx out, rtx *inloc, rtx *outloc,
 		       > UNITS_PER_WORD)
 		   && ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (in)))
 			/ UNITS_PER_WORD)
-		       != (int) HARD_REGNO_NREGS (REGNO (SUBREG_REG (in)),
-						  GET_MODE (SUBREG_REG (in)))))
+		       != (int) hard_regno_nregs[REGNO (SUBREG_REG (in))]
+						[GET_MODE (SUBREG_REG (in))]))
 		  || ! HARD_REGNO_MODE_OK (subreg_regno (in), inmode)))
 #ifdef SECONDARY_INPUT_RELOAD_CLASS
 	  || (SECONDARY_INPUT_RELOAD_CLASS (class, inmode, in) != NO_REGS
@@ -1135,8 +1135,8 @@ push_reload (rtx in, rtx out, rtx *inloc, rtx *outloc,
 		       > UNITS_PER_WORD)
 		   && ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (out)))
 			/ UNITS_PER_WORD)
-		       != (int) HARD_REGNO_NREGS (REGNO (SUBREG_REG (out)),
-						  GET_MODE (SUBREG_REG (out)))))
+		       != (int) hard_regno_nregs[REGNO (SUBREG_REG (out))]
+						[GET_MODE (SUBREG_REG (out))]))
 		  || ! HARD_REGNO_MODE_OK (subreg_regno (out), outmode)))
 #ifdef SECONDARY_OUTPUT_RELOAD_CLASS
 	  || (SECONDARY_OUTPUT_RELOAD_CLASS (class, outmode, out) != NO_REGS
@@ -1262,7 +1262,7 @@ push_reload (rtx in, rtx out, rtx *inloc, rtx *outloc,
 	if (HARD_REGNO_MODE_OK (i, mode)
 	    && TEST_HARD_REG_BIT (reg_class_contents[(int) class], i))
 	  {
-	    int nregs = HARD_REGNO_NREGS (i, mode);
+	    int nregs = hard_regno_nregs[i][mode];
 
 	    int j;
 	    for (j = 1; j < nregs; j++)
@@ -1520,8 +1520,8 @@ push_reload (rtx in, rtx out, rtx *inloc, rtx *outloc,
 	    && reg_mentioned_p (XEXP (note, 0), in)
 	    && ! refers_to_regno_for_reload_p (regno,
 					       (regno
-						+ HARD_REGNO_NREGS (regno,
-								    rel_mode)),
+						+ hard_regno_nregs[regno]
+								  [rel_mode]),
 					       PATTERN (this_insn), inloc)
 	    /* If this is also an output reload, IN cannot be used as
 	       the reload register if it is set in this insn unless IN
@@ -1529,8 +1529,8 @@ push_reload (rtx in, rtx out, rtx *inloc, rtx *outloc,
 	    && (out == 0 || in == out
 		|| ! hard_reg_set_here_p (regno,
 					  (regno
-					   + HARD_REGNO_NREGS (regno,
-							       rel_mode)),
+					   + hard_regno_nregs[regno]
+							     [rel_mode]),
 					  PATTERN (this_insn)))
 	    /* ??? Why is this code so different from the previous?
 	       Is there any simple coherent way to describe the two together?
@@ -1548,8 +1548,8 @@ push_reload (rtx in, rtx out, rtx *inloc, rtx *outloc,
 	    && HARD_REGNO_MODE_OK (regno, outmode))
 	  {
 	    unsigned int offs;
-	    unsigned int nregs = MAX (HARD_REGNO_NREGS (regno, inmode),
-				      HARD_REGNO_NREGS (regno, outmode));
+	    unsigned int nregs = MAX (hard_regno_nregs[regno][inmode],
+				      hard_regno_nregs[regno][outmode]);
 
 	    for (offs = 0; offs < nregs; offs++)
 	      if (fixed_regs[regno + offs]
@@ -1559,7 +1559,7 @@ push_reload (rtx in, rtx out, rtx *inloc, rtx *outloc,
 
 	    if (offs == nregs
 		&& (! (refers_to_regno_for_reload_p
-		       (regno, (regno + HARD_REGNO_NREGS (regno, inmode)),
+		       (regno, (regno + hard_regno_nregs[regno][inmode]),
 				in, (rtx *)0))
 		    || can_reload_into (in, regno, inmode)))
 	      {
@@ -1830,8 +1830,8 @@ combine_reloads (void)
 	&& HARD_REGNO_MODE_OK (REGNO (XEXP (note, 0)), rld[output_reload].outmode)
 	&& TEST_HARD_REG_BIT (reg_class_contents[(int) rld[output_reload].class],
 			      REGNO (XEXP (note, 0)))
-	&& (HARD_REGNO_NREGS (REGNO (XEXP (note, 0)), rld[output_reload].outmode)
-	    <= HARD_REGNO_NREGS (REGNO (XEXP (note, 0)), GET_MODE (XEXP (note, 0))))
+	&& (hard_regno_nregs[REGNO (XEXP (note, 0))][rld[output_reload].outmode]
+	    <= hard_regno_nregs[REGNO (XEXP (note, 0))][GET_MODE (XEXP (note, 0))])
 	/* Ensure that a secondary or tertiary reload for this output
 	   won't want this register.  */
 	&& ((secondary_out = rld[output_reload].secondary_out_reload) == -1
@@ -1923,7 +1923,7 @@ find_dummy_reload (rtx real_in, rtx real_out, rtx *inloc, rtx *outloc,
       && REGNO (out) < FIRST_PSEUDO_REGISTER)
     {
       unsigned int regno = REGNO (out) + out_offset;
-      unsigned int nwords = HARD_REGNO_NREGS (regno, outmode);
+      unsigned int nwords = hard_regno_nregs[regno][outmode];
       rtx saved_rtx;
 
       /* When we consider whether the insn uses OUT,
@@ -1984,7 +1984,7 @@ find_dummy_reload (rtx real_in, rtx real_out, rtx *inloc, rtx *outloc,
 			      ? GET_MODE (out) : outmode)))
     {
       unsigned int regno = REGNO (in) + in_offset;
-      unsigned int nwords = HARD_REGNO_NREGS (regno, inmode);
+      unsigned int nwords = hard_regno_nregs[regno][inmode];
 
       if (! refers_to_regno_for_reload_p (regno, regno + nwords, out, (rtx*) 0)
 	  && ! hard_reg_set_here_p (regno, regno + nwords,
@@ -2056,7 +2056,7 @@ hard_reg_set_here_p (unsigned int beg_regno, unsigned int end_regno, rtx x)
 
 	  /* See if this reg overlaps range under consideration.  */
 	  if (r < end_regno
-	      && r + HARD_REGNO_NREGS (r, GET_MODE (op0)) > beg_regno)
+	      && r + hard_regno_nregs[r][GET_MODE (op0)] > beg_regno)
 	    return 1;
 	}
     }
@@ -2148,10 +2148,10 @@ operands_match_p (rtx x, rtx y)
 	 (reg:SI 1) will be considered the same register.  */
       if (WORDS_BIG_ENDIAN && GET_MODE_SIZE (GET_MODE (x)) > UNITS_PER_WORD
 	  && i < FIRST_PSEUDO_REGISTER)
-	i += HARD_REGNO_NREGS (i, GET_MODE (x)) - 1;
+	i += hard_regno_nregs[i][GET_MODE (x)] - 1;
       if (WORDS_BIG_ENDIAN && GET_MODE_SIZE (GET_MODE (y)) > UNITS_PER_WORD
 	  && j < FIRST_PSEUDO_REGISTER)
-	j += HARD_REGNO_NREGS (j, GET_MODE (y)) - 1;
+	j += hard_regno_nregs[j][GET_MODE (y)] - 1;
 
       return i == j;
     }
@@ -2363,7 +2363,7 @@ decompose (rtx x)
 	}
       else
 	/* A hard reg.  */
-	val.end = val.start + HARD_REGNO_NREGS (val.start, GET_MODE (x));
+	val.end = val.start + hard_regno_nregs[val.start][GET_MODE (x)];
     }
   else if (GET_CODE (x) == SUBREG)
     {
@@ -2376,7 +2376,7 @@ decompose (rtx x)
 	return decompose (SUBREG_REG (x));
       else
 	/* A hard reg.  */
-	val.end = val.start + HARD_REGNO_NREGS (val.start, GET_MODE (x));
+	val.end = val.start + hard_regno_nregs[val.start][GET_MODE (x)];
     }
   else if (CONSTANT_P (x)
 	   /* This hasn't been assigned yet, so it can't conflict yet.  */
@@ -4366,7 +4366,7 @@ find_reloads (rtx insn, int replace, int ind_levels, int live_known,
 	    && TEST_HARD_REG_BIT (reg_class_contents[rld[i].class], regno)
 	    && HARD_REGNO_MODE_OK (regno, rld[i].mode))
 	  {
-	    int nr = HARD_REGNO_NREGS (regno, rld[i].mode);
+	    int nr = hard_regno_nregs[regno][rld[i].mode];
 	    int ok = 1, nri;
 
 	    for (nri = 1; nri < nr; nri ++)
@@ -6177,7 +6177,7 @@ refers_to_regno_for_reload_p (unsigned int regno, unsigned int endregno,
 
       return (endregno > r
 	      && regno < r + (r < FIRST_PSEUDO_REGISTER
-			      ? HARD_REGNO_NREGS (r, GET_MODE (x))
+			      ? hard_regno_nregs[r][GET_MODE (x)]
 			      : 1));
 
     case SUBREG:
@@ -6189,7 +6189,7 @@ refers_to_regno_for_reload_p (unsigned int regno, unsigned int endregno,
 	  unsigned int inner_regno = subreg_regno (x);
 	  unsigned int inner_endregno
 	    = inner_regno + (inner_regno < FIRST_PSEUDO_REGISTER
-			     ? HARD_REGNO_NREGS (regno, GET_MODE (x)) : 1);
+			     ? hard_regno_nregs[regno][GET_MODE (x)] : 1);
 
 	  return endregno > inner_regno && regno < inner_endregno;
 	}
@@ -6328,7 +6328,7 @@ reg_overlap_mentioned_for_reload_p (rtx x, rtx in)
     abort ();
 
   endregno = regno + (regno < FIRST_PSEUDO_REGISTER
-		      ? HARD_REGNO_NREGS (regno, GET_MODE (x)) : 1);
+		      ? hard_regno_nregs[regno][GET_MODE (x)] : 1);
 
   return refers_to_regno_for_reload_p (regno, endregno, in, (rtx*) 0);
 }
@@ -6539,7 +6539,7 @@ find_equiv_reg (rtx goal, rtx insn, enum reg_class class, int other,
 		{
 		  int i;
 
-		  for (i = HARD_REGNO_NREGS (valueno, mode) - 1; i >= 0; i--)
+		  for (i = hard_regno_nregs[valueno][mode] - 1; i >= 0; i--)
 		    if (! TEST_HARD_REG_BIT (reg_class_contents[(int) class],
 					     valueno + i))
 		      break;
@@ -6581,19 +6581,22 @@ find_equiv_reg (rtx goal, rtx insn, enum reg_class class, int other,
   if (goal_mem && value == SET_DEST (single_set (where))
       && refers_to_regno_for_reload_p (valueno,
 				       (valueno
-					+ HARD_REGNO_NREGS (valueno, mode)),
+					+ hard_regno_nregs[valueno][mode]),
 				       goal, (rtx*) 0))
     return 0;
 
   /* Reject registers that overlap GOAL.  */
 
   if (!goal_mem && !goal_const
-      && regno + (int) HARD_REGNO_NREGS (regno, mode) > valueno
-      && regno < valueno + (int) HARD_REGNO_NREGS (valueno, mode))
+      && regno + (int) hard_regno_nregs[regno][mode] > valueno
+      && regno < valueno + (int) hard_regno_nregs[valueno][mode])
     return 0;
 
-  nregs = HARD_REGNO_NREGS (regno, mode);
-  valuenregs = HARD_REGNO_NREGS (valueno, mode);
+  if (regno >= 0 && regno < FIRST_PSEUDO_REGISTER)
+    nregs = hard_regno_nregs[regno][mode];
+  else
+    nregs = 1;
+  valuenregs = hard_regno_nregs[valueno][mode];
 
   /* Reject VALUE if it is one of the regs reserved for reloads.
      Reload1 knows how to reuse them anyway, and it would get
@@ -6619,8 +6622,8 @@ find_equiv_reg (rtx goal, rtx insn, enum reg_class class, int other,
 	if (rld[i].reg_rtx != 0 && rld[i].in)
 	  {
 	    int regno1 = REGNO (rld[i].reg_rtx);
-	    int nregs1 = HARD_REGNO_NREGS (regno1,
-					   GET_MODE (rld[i].reg_rtx));
+	    int nregs1 = hard_regno_nregs[regno1]
+					 [GET_MODE (rld[i].reg_rtx)];
 	    if (regno1 < valueno + valuenregs
 		&& regno1 + nregs1 > valueno)
 	      return 0;
@@ -6694,7 +6697,7 @@ find_equiv_reg (rtx goal, rtx insn, enum reg_class class, int other,
 		  int xregno = REGNO (dest);
 		  int xnregs;
 		  if (REGNO (dest) < FIRST_PSEUDO_REGISTER)
-		    xnregs = HARD_REGNO_NREGS (xregno, GET_MODE (dest));
+		    xnregs = hard_regno_nregs[xregno][GET_MODE (dest)];
 		  else
 		    xnregs = 1;
 		  if (xregno < regno + nregs && xregno + xnregs > regno)
@@ -6738,7 +6741,7 @@ find_equiv_reg (rtx goal, rtx insn, enum reg_class class, int other,
 			  int xregno = REGNO (dest);
 			  int xnregs;
 			  if (REGNO (dest) < FIRST_PSEUDO_REGISTER)
-			    xnregs = HARD_REGNO_NREGS (xregno, GET_MODE (dest));
+			    xnregs = hard_regno_nregs[xregno][GET_MODE (dest)];
 			  else
 			    xnregs = 1;
 			  if (xregno < regno + nregs
@@ -6783,7 +6786,7 @@ find_equiv_reg (rtx goal, rtx insn, enum reg_class class, int other,
 			{
 			  int xregno = REGNO (dest);
 			  int xnregs
-			    = HARD_REGNO_NREGS (xregno, GET_MODE (dest));
+			    = hard_regno_nregs[xregno][GET_MODE (dest)];
 
 			  if (xregno < regno + nregs
 			      && xregno + xnregs > regno)
@@ -6898,7 +6901,7 @@ int
 regno_clobbered_p (unsigned int regno, rtx insn, enum machine_mode mode,
 		   int sets)
 {
-  unsigned int nregs = HARD_REGNO_NREGS (regno, mode);
+  unsigned int nregs = hard_regno_nregs[regno][mode];
   unsigned int endregno = regno + nregs;
 
   if ((GET_CODE (PATTERN (insn)) == CLOBBER
@@ -6944,8 +6947,8 @@ reload_adjust_reg_for_mode (rtx reloadreg, enum machine_mode mode)
   regno = REGNO (reloadreg);
 
   if (WORDS_BIG_ENDIAN)
-    regno += HARD_REGNO_NREGS (regno, GET_MODE (reloadreg))
-      - HARD_REGNO_NREGS (regno, mode);
+    regno += (int) hard_regno_nregs[regno][GET_MODE (reloadreg)]
+      - (int) hard_regno_nregs[regno][mode];
 
   return gen_rtx_REG (mode, regno);
 }