Convert hard_regno_nregs to a function

This patch converts hard_regno_nregs into an inline function, which
in turn allows hard_regno_nregs to be used as the name of a targetm
field.  This is just a mechanical change.

2017-09-12  Richard Sandiford  <richard.sandiford@linaro.org>

gcc/
	* regs.h (hard_regno_nregs): Turn into a function.
	(end_hard_regno): Update accordingly.
	* caller-save.c (setup_save_areas): Likewise.
	(save_call_clobbered_regs): Likewise.
	(replace_reg_with_saved_mem): Likewise.
	(insert_restore): Likewise.
	(insert_save): Likewise.
	* combine.c (can_change_dest_mode): Likewise.
	(move_deaths): Likewise.
	(distribute_notes): Likewise.
	* config/mips/mips.c (mips_hard_regno_call_part_clobbered): Likewise.
	* config/powerpcspe/powerpcspe.c (rs6000_cannot_change_mode_class)
	(rs6000_split_multireg_move): Likewise.
	(rs6000_register_move_cost): Likewise.
	(rs6000_memory_move_cost): Likewise.
	* config/rs6000/rs6000.c (rs6000_cannot_change_mode_class): Likewise.
	(rs6000_split_multireg_move): Likewise.
	(rs6000_register_move_cost): Likewise.
	(rs6000_memory_move_cost): Likewise.
	* cselib.c (cselib_reset_table): Likewise.
	(cselib_lookup_1): Likewise.
	* emit-rtl.c (set_mode_and_regno): Likewise.
	* function.c (aggregate_value_p): Likewise.
	* ira-color.c (setup_profitable_hard_regs): Likewise.
	(check_hard_reg_p): Likewise.
	(calculate_saved_nregs): Likewise.
	(assign_hard_reg): Likewise.
	(improve_allocation): Likewise.
	(calculate_spill_cost): Likewise.
	* ira-emit.c (modify_move_list): Likewise.
	* ira-int.h (ira_hard_reg_set_intersection_p): Likewise.
	(ira_hard_reg_in_set_p): Likewise.
	* ira.c (setup_reg_mode_hard_regset): Likewise.
	(clarify_prohibited_class_mode_regs): Likewise.
	(check_allocation): Likewise.
	* lra-assigns.c (find_hard_regno_for_1): Likewise.
	(lra_setup_reg_renumber): Likewise.
	(setup_try_hard_regno_pseudos): Likewise.
	(spill_for): Likewise.
	(assign_hard_regno): Likewise.
	(setup_live_pseudos_and_spill_after_risky_transforms): Likewise.
	* lra-constraints.c (in_class_p): Likewise.
	(lra_constraint_offset): Likewise.
	(simplify_operand_subreg): Likewise.
	(lra_constraints): Likewise.
	(split_reg): Likewise.
	(split_if_necessary): Likewise.
	(invariant_p): Likewise.
	(inherit_in_ebb): Likewise.
	* lra-lives.c (process_bb_lives): Likewise.
	* lra-remat.c (reg_overlap_for_remat_p): Likewise.
	(get_hard_regs): Likewise.
	(do_remat): Likewise.
	* lra-spills.c (assign_spill_hard_regs): Likewise.
	* mode-switching.c (create_pre_exit): Likewise.
	* postreload.c (reload_combine_recognize_pattern): Likewise.
	* recog.c (peep2_find_free_register): Likewise.
	* regcprop.c (kill_value_regno): Likewise.
	(set_value_regno): Likewise.
	(copy_value): Likewise.
	(maybe_mode_change): Likewise.
	(find_oldest_value_reg): Likewise.
	(copyprop_hardreg_forward_1): Likewise.
	* regrename.c (check_new_reg_p): Likewise.
	(regrename_do_replace): Likewise.
	* reload.c (push_reload): Likewise.
	(combine_reloads): Likewise.
	(find_dummy_reload): Likewise.
	(operands_match_p): Likewise.
	(find_reloads): Likewise.
	(find_equiv_reg): Likewise.
	(reload_adjust_reg_for_mode): Likewise.
	* reload1.c (count_pseudo): Likewise.
	(count_spilled_pseudo): Likewise.
	(find_reg): Likewise.
	(clear_reload_reg_in_use): Likewise.
	(free_for_value_p): Likewise.
	(allocate_reload_reg): Likewise.
	(choose_reload_regs): Likewise.
	(reload_adjust_reg_for_temp): Likewise.
	(emit_reload_insns): Likewise.
	(delete_output_reload): Likewise.
	* rtlanal.c (subreg_get_info): Likewise.
	* sched-deps.c (sched_analyze_reg): Likewise.
	* sel-sched.c (init_regs_for_mode): Likewise.
	(mark_unavailable_hard_regs): Likewise.
	(choose_best_reg_1): Likewise.
	(verify_target_availability): Likewise.
	* valtrack.c (dead_debug_insert_temp): Likewise.
	* var-tracking.c (track_loc_p): Likewise.
	(emit_note_insn_var_location): Likewise.
	* varasm.c (make_decl_rtl): Likewise.
	* reginfo.c (choose_hard_reg_mode): Likewise.
	(init_reg_modes_target): Refer directly to
	this_target_regs->x_hard_regno_nregs.

From-SVN: r252014

1 files changed, 17 insertions, 17 deletions

diff --git a/gcc/reload1.c b/gcc/reload1.c
index 4f39e0e..e59f6d9 100644
--- a/gcc/reload1.c
+++ b/gcc/reload1.c
@@ -1711,7 +1711,7 @@ count_pseudo (int reg)
   gcc_assert (r >= 0);
 
   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)
     {
       hard_regno_to_pseudo_regno[r + nregs] = reg;
@@ -1788,7 +1788,7 @@ count_spilled_pseudo (int spilled, int spilled_nregs, int reg)
 
   gcc_assert (r >= 0);
 
-  nregs = hard_regno_nregs[r][PSEUDO_REGNO_MODE (reg)];
+  nregs = hard_regno_nregs (r, PSEUDO_REGNO_MODE (reg));
 
   if (REGNO_REG_SET_P (&spilled_pseudos, reg)
       || spilled + spilled_nregs <= r || r + nregs <= spilled)
@@ -1849,7 +1849,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++)
 	    {
@@ -1920,7 +1920,7 @@ find_reg (struct insn_chain *chain, int order)
   if (dump_file)
     fprintf (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
@@ -5068,7 +5068,7 @@ static void
 clear_reload_reg_in_use (unsigned int regno, int opnum,
 			 enum reload_type type, 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
@@ -6026,7 +6026,7 @@ free_for_value_p (int regno, 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,
@@ -6222,7 +6222,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);
 
 	      /* During the second pass we want to avoid reload registers
 		 which are "bad" for this reload.  */
@@ -6608,7 +6608,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++)
@@ -6838,7 +6838,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_spill_index[r] = regno;
@@ -7075,7 +7075,7 @@ 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)
 	    SET_REGNO_REG_SET (&reg_has_output_reload,
@@ -7150,7 +7150,7 @@ reload_adjust_reg_for_temp (rtx *reload_reg, rtx alt_reload_reg,
 	{
 	  if (!targetm.hard_regno_mode_ok (regno, new_mode))
 	    continue;
-	  if (hard_regno_nregs[regno][new_mode] > REG_NREGS (reg))
+	  if (hard_regno_nregs (regno, new_mode) > REG_NREGS (reg))
 	    continue;
 	  reg = reload_adjust_reg_for_mode (reg, new_mode);
 	}
@@ -8194,7 +8194,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;
 
 	  /* For a multi register reload, we need to check if all or part
@@ -8238,7 +8238,7 @@ emit_reload_insns (struct insn_chain *chain)
 /* AUTO_INC */		     : XEXP (rld[r].in_reg, 0));
 		  int out_regno = REGNO (out);
 		  int out_nregs = (!HARD_REGISTER_NUM_P (out_regno) ? 1
-				   : hard_regno_nregs[out_regno][mode]);
+				   : hard_regno_nregs (out_regno, mode));
 		  bool piecemeal;
 
 		  spill_reg_store[regno] = new_spill_reg_store[regno];
@@ -8320,7 +8320,7 @@ emit_reload_insns (struct insn_chain *chain)
 		  in_regno = REGNO (in);
 
 		  in_nregs = (!HARD_REGISTER_NUM_P (in_regno) ? 1
-			      : hard_regno_nregs[in_regno][mode]);
+			      : hard_regno_nregs (in_regno, mode));
 
 		  reg_last_reload_reg[in_regno] = reg;
 
@@ -8449,7 +8449,7 @@ emit_reload_insns (struct insn_chain *chain)
 
 		  gcc_assert (GET_MODE (src_reg) == mode);
 		  src_regno = REGNO (src_reg);
-		  src_nregs = hard_regno_nregs[src_regno][mode];
+		  src_nregs = hard_regno_nregs (src_regno, 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
@@ -8488,7 +8488,7 @@ emit_reload_insns (struct insn_chain *chain)
 	    }
 	  else
 	    {
-	      int k, out_nregs = hard_regno_nregs[out_regno][mode];
+	      int k, out_nregs = hard_regno_nregs (out_regno, mode);
 
 	      for (k = 0; k < out_nregs; k++)
 		reg_last_reload_reg[out_regno + k] = 0;
@@ -8860,7 +8860,7 @@ delete_output_reload (rtx_insn *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;