[27/77] Use is_a <scalar_int_mode> before LOAD_EXTEND_OP

This patch adds is_a <scalar_int_mode> checks before load_extend_op/
LOAD_EXTEND_OP calls, if that becomes useful for later patches.
(load_extend_op will return UNKNOWN for any other type of mode.)

2017-08-30  Richard Sandiford  <richard.sandiford@linaro.org>
	    Alan Hayward  <alan.hayward@arm.com>
	    David Sherwood  <david.sherwood@arm.com>

gcc/
	* cse.c (cse_insn): Add is_a <scalar_int_mode> checks.
	* reload.c (push_reload): Likewise.
	(find_reloads): Likewise.

Co-Authored-By: Alan Hayward <alan.hayward@arm.com>
Co-Authored-By: David Sherwood <david.sherwood@arm.com>
From-SVN: r251479

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 54a4cf995c42278e803216bf4aa626bab0aaeaba..0500339a0ddc28b58a1db629165fcf99003e7579 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,11 @@
+2017-08-30  Richard Sandiford  <richard.sandiford@linaro.org>
+           Alan Hayward  <alan.hayward@arm.com>
+           David Sherwood  <david.sherwood@arm.com>
+
+       * cse.c (cse_insn): Add is_a <scalar_int_mode> checks.
+       * reload.c (push_reload): Likewise.
+       (find_reloads): Likewise.
+
 2017-08-30  Richard Sandiford  <richard.sandiford@linaro.org>
            Alan Hayward  <alan.hayward@arm.com>
            David Sherwood  <david.sherwood@arm.com>

diff --git a/gcc/cse.c b/gcc/cse.c
index 8ef90639753823a38fe6bc30cb6fbc126aba335f..755ac3b8e8d3322033370a71af2aaeb60e938a5e 100644 (file)
--- a/gcc/cse.c
+++ b/gcc/cse.c
@@ -4923,7 +4923,8 @@ cse_insn (rtx_insn *insn)
       rtx_code extend_op;
       if (flag_expensive_optimizations && src_related == 0
          && MEM_P (src) && ! do_not_record
-         && (extend_op = load_extend_op (mode)) != UNKNOWN)
+         && is_a <scalar_int_mode> (mode, &int_mode)
+         && (extend_op = load_extend_op (int_mode)) != UNKNOWN)
        {
          struct rtx_def memory_extend_buf;
          rtx memory_extend_rtx = &memory_extend_buf;
@@ -4935,7 +4936,7 @@ cse_insn (rtx_insn *insn)
          PUT_CODE (memory_extend_rtx, extend_op);
          XEXP (memory_extend_rtx, 0) = src;
 
-         FOR_EACH_WIDER_MODE (tmode, mode)
+         FOR_EACH_WIDER_MODE (tmode, int_mode)
            {
              struct table_elt *larger_elt;
 
@@ -4952,7 +4953,7 @@ cse_insn (rtx_insn *insn)
                   larger_elt; larger_elt = larger_elt->next_same_value)
                if (REG_P (larger_elt->exp))
                  {
-                   src_related = gen_lowpart (mode, larger_elt->exp);
+                   src_related = gen_lowpart (int_mode, larger_elt->exp);
                    break;
                  }
 

diff --git a/gcc/reload.c b/gcc/reload.c
index d742c32469009eea80b195abb36ebaaa153f9351..2116332b55aa33babd9ab08023026592f2a471c4 100644 (file)
--- a/gcc/reload.c
+++ b/gcc/reload.c
@@ -1050,6 +1050,7 @@ push_reload (rtx in, rtx out, rtx *inloc, rtx *outloc,
      register class.  But if it is inside a STRICT_LOW_PART, we have
      no choice, so we hope we do get the right register class there.  */
 
+  scalar_int_mode inner_mode;
   if (in != 0 && GET_CODE (in) == SUBREG
       && (subreg_lowpart_p (in) || strict_low)
 #ifdef CANNOT_CHANGE_MODE_CLASS
@@ -1064,12 +1065,11 @@ push_reload (rtx in, rtx out, rtx *inloc, rtx *outloc,
               || MEM_P (SUBREG_REG (in)))
              && (paradoxical_subreg_p (inmode, GET_MODE (SUBREG_REG (in)))
                  || (GET_MODE_SIZE (inmode) <= UNITS_PER_WORD
-                     && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (in)))
-                         <= UNITS_PER_WORD)
-                     && paradoxical_subreg_p (inmode,
-                                              GET_MODE (SUBREG_REG (in)))
-                     && INTEGRAL_MODE_P (GET_MODE (SUBREG_REG (in)))
-                     && LOAD_EXTEND_OP (GET_MODE (SUBREG_REG (in))) != UNKNOWN)
+                     && is_a <scalar_int_mode> (GET_MODE (SUBREG_REG (in)),
+                                                &inner_mode)
+                     && GET_MODE_SIZE (inner_mode) <= UNITS_PER_WORD
+                     && paradoxical_subreg_p (inmode, inner_mode)
+                     && LOAD_EXTEND_OP (inner_mode) != UNKNOWN)
                  || (WORD_REGISTER_OPERATIONS
                      && (GET_MODE_PRECISION (inmode)
                          < GET_MODE_PRECISION (GET_MODE (SUBREG_REG (in))))
@@ -3107,6 +3107,7 @@ find_reloads (rtx_insn *insn, int replace, int ind_levels, int live_known,
                  operand = SUBREG_REG (operand);
                  /* Force reload if this is a constant or PLUS or if there may
                     be a problem accessing OPERAND in the outer mode.  */
+                 scalar_int_mode inner_mode;
                  if (CONSTANT_P (operand)
                      || GET_CODE (operand) == PLUS
                      /* We must force a reload of paradoxical SUBREGs
@@ -3144,13 +3145,13 @@ find_reloads (rtx_insn *insn, int replace, int ind_levels, int live_known,
                              || BYTES_BIG_ENDIAN
                              || ((GET_MODE_SIZE (operand_mode[i])
                                   <= UNITS_PER_WORD)
-                                 && (GET_MODE_SIZE (GET_MODE (operand))
+                                 && (is_a <scalar_int_mode>
+                                     (GET_MODE (operand), &inner_mode))
+                                 && (GET_MODE_SIZE (inner_mode)
                                      <= UNITS_PER_WORD)
                                  && paradoxical_subreg_p (operand_mode[i],
-                                                          GET_MODE (operand))
-                                 && INTEGRAL_MODE_P (GET_MODE (operand))
-                                 && LOAD_EXTEND_OP (GET_MODE (operand))
-                                    != UNKNOWN)))
+                                                          inner_mode)
+                                 && LOAD_EXTEND_OP (inner_mode) != UNKNOWN)))
                      )
                    force_reload = 1;
                }