Make more use of END_REGNO

An upcoming patch will convert 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 patch rewrites uses that are more
easily (and efficiently) written as END_REGNO.

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

gcc/
	* config/frv/frv.c (FOR_EACH_REGNO): Use END_REGNO instead of
	hard_regno_nregs.
	* config/v850/v850.c (v850_reorg): Likewise.
	* reload.c (refers_to_regno_for_reload_p): Likewise.
	(find_equiv_reg): Likewise.
	* reload1.c (reload_reg_reaches_end_p): Likewise.

From-SVN: r252011

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 2683d7759d03a6a5cdaa4747eec42194497cba4b..1b398c8983f335b7df84bbc355e090cd69f2f8fb 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,12 @@
+2017-09-12  Richard Sandiford  <richard.sandiford@linaro.org>
+
+       * config/frv/frv.c (FOR_EACH_REGNO): Use END_REGNO instead of
+       hard_regno_nregs.
+       * config/v850/v850.c (v850_reorg): Likewise.
+       * reload.c (refers_to_regno_for_reload_p): Likewise.
+       (find_equiv_reg): Likewise.
+       * reload1.c (reload_reg_reaches_end_p): Likewise.
+
 2017-09-12  Richard Sandiford  <richard.sandiford@linaro.org>
 
        * caller-save.c (add_used_regs): Use REG_NREGS instead of

diff --git a/gcc/config/frv/frv.c b/gcc/config/frv/frv.c
index b6119e9c3952deaf9af48c27937e077bcefbfc14..add19e5cb14e5fd750e9d864b4bcff73329ed351 100644 (file)
--- a/gcc/config/frv/frv.c
+++ b/gcc/config/frv/frv.c
@@ -135,9 +135,7 @@ struct frv_io {
 
 /* Loop with REG set to each hard register in rtx X.  */
 #define FOR_EACH_REGNO(REG, X)                                         \
-  for (REG = REGNO (X);                                                        \
-       REG < REGNO (X) + HARD_REGNO_NREGS (REGNO (X), GET_MODE (X));   \
-       REG++)
+  for (REG = REGNO (X); REG < END_REGNO (X); REG++)
 
 /* This structure contains machine specific function data.  */
 struct GTY(()) machine_function

diff --git a/gcc/config/v850/v850.c b/gcc/config/v850/v850.c
index 0b674d14e786bfc459b19a74c0ee7500111d466f..32c6a036eb37f410cafb2ebe68d60daa14b99692 100644 (file)
--- a/gcc/config/v850/v850.c
+++ b/gcc/config/v850/v850.c
@@ -1376,12 +1376,11 @@ v850_reorg (void)
                 for the register */
              if (GET_CODE (dest) == REG)
                {
-                 machine_mode mode = GET_MODE (dest);
                  int regno;
                  int endregno;
 
                  regno = REGNO (dest);
-                 endregno = regno + HARD_REGNO_NREGS (regno, mode);
+                 endregno = END_REGNO (dest);
 
                  if (!use_ep)
                    {

diff --git a/gcc/reload.c b/gcc/reload.c
index eb67db6c951b5b911f6d50c20e91271a79a11f95..21efdcbcaaf429471b2060173c0687296a1e7657 100644 (file)
--- a/gcc/reload.c
+++ b/gcc/reload.c
@@ -6439,10 +6439,7 @@ refers_to_regno_for_reload_p (unsigned int regno, unsigned int endregno,
          return 0;
        }
 
-      return (endregno > r
-             && regno < r + (r < FIRST_PSEUDO_REGISTER
-                             ? hard_regno_nregs[r][GET_MODE (x)]
-                             : 1));
+      return endregno > r && regno < END_REGNO (x);
 
     case SUBREG:
       /* If this is a SUBREG of a hard reg, we can see exactly which
@@ -6889,15 +6886,11 @@ find_equiv_reg (rtx goal, rtx_insn *insn, enum reg_class rclass, int other,
     {
       int i;
       for (i = 0; i < n_reloads; i++)
-       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)];
-           if (regno1 < valueno + valuenregs
-               && regno1 + nregs1 > valueno)
-             return 0;
-         }
+       if (rld[i].reg_rtx != 0
+           && rld[i].in
+           && (int) REGNO (rld[i].reg_rtx) < valueno + valuenregs
+           && (int) END_REGNO (rld[i].reg_rtx) > valueno)
+         return 0;
     }
 
   if (goal_mem)
@@ -6963,15 +6956,11 @@ find_equiv_reg (rtx goal, rtx_insn *insn, enum reg_class rclass, int other,
              if (REG_P (dest))
                {
                  int xregno = REGNO (dest);
-                 int xnregs;
-                 if (REGNO (dest) < FIRST_PSEUDO_REGISTER)
-                   xnregs = hard_regno_nregs[xregno][GET_MODE (dest)];
-                 else
-                   xnregs = 1;
-                 if (xregno < regno + nregs && xregno + xnregs > regno)
+                 int end_xregno = END_REGNO (dest);
+                 if (xregno < regno + nregs && end_xregno > regno)
                    return 0;
                  if (xregno < valueno + valuenregs
-                     && xregno + xnregs > valueno)
+                     && end_xregno > valueno)
                    return 0;
                  if (goal_mem_addr_varies
                      && reg_overlap_mentioned_for_reload_p (dest, goal))
@@ -7006,16 +6995,12 @@ find_equiv_reg (rtx goal, rtx_insn *insn, enum reg_class rclass, int other,
                      if (REG_P (dest))
                        {
                          int xregno = REGNO (dest);
-                         int xnregs;
-                         if (REGNO (dest) < FIRST_PSEUDO_REGISTER)
-                           xnregs = hard_regno_nregs[xregno][GET_MODE (dest)];
-                         else
-                           xnregs = 1;
+                         int end_xregno = END_REGNO (dest);
                          if (xregno < regno + nregs
-                             && xregno + xnregs > regno)
+                             && end_xregno > regno)
                            return 0;
                          if (xregno < valueno + valuenregs
-                             && xregno + xnregs > valueno)
+                             && end_xregno > valueno)
                            return 0;
                          if (goal_mem_addr_varies
                              && reg_overlap_mentioned_for_reload_p (dest,
@@ -7052,14 +7037,13 @@ find_equiv_reg (rtx goal, rtx_insn *insn, enum reg_class rclass, int other,
                      if (REG_P (dest))
                        {
                          int xregno = REGNO (dest);
-                         int xnregs
-                           = hard_regno_nregs[xregno][GET_MODE (dest)];
+                         int end_xregno = END_REGNO (dest);
 
                          if (xregno < regno + nregs
-                             && xregno + xnregs > regno)
+                             && end_xregno > regno)
                            return 0;
                          else if (xregno < valueno + valuenregs
-                                  && xregno + xnregs > valueno)
+                                  && end_xregno > valueno)
                            return 0;
                          else if (goal_mem_addr_varies
                                   && reg_overlap_mentioned_for_reload_p (dest,

diff --git a/gcc/reload1.c b/gcc/reload1.c
index 092995138a6d4ae5bd62961c9ddefaf16e2638fd..4f39e0e91b00fcddfd872f770955e9d52e817e54 100644 (file)
--- a/gcc/reload1.c
+++ b/gcc/reload1.c
@@ -5349,15 +5349,13 @@ reload_reg_reaches_end_p (unsigned int regno, int reloadnum)
   for (i = reloadnum + 1; i < n_reloads; i++)
     {
       rtx reg;
-      int nregs;
 
       if (rld[i].opnum != opnum || rld[i].when_needed != type)
        continue;
       reg = rld[i].reg_rtx;
       if (reg == NULL_RTX)
        continue;
-      nregs = hard_regno_nregs[REGNO (reg)][GET_MODE (reg)];
-      if (regno >= REGNO (reg) && regno < REGNO (reg) + nregs)
+      if (regno >= REGNO (reg) && regno < END_REGNO (reg))
        return 0;
     }