[49/77] Simplify nonzero/num_sign_bits hooks

The two implementations of the reg_nonzero_bits and reg_num_sign_bits
hooks ignored the "known_x", "known_mode" and "known_ret" arguments,
so this patch removes them.  It adds a new scalar_int_mode parameter
that specifies the mode of "x".  (This mode might be different from
"mode", which is the mode in which "x" is used.)

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

gcc/
	* rtl.h (rtl_hooks::reg_nonzero_bits): Add a scalar_int_mode
	parameter for the mode of "x".  Remove the "known_x", "known_mode"
	and "known_ret" arguments.  Change the type of the mode argument
	to scalar_int_mode.
	(rtl_hooks:reg_num_sign_bit_copies): Likewise.
	* combine.c (reg_nonzero_bits_for_combine): Update accordingly.
	(reg_num_sign_bit_copies_for_combine): Likewise.
	* rtlanal.c (nonzero_bits1): Likewise.
	(num_sign_bit_copies1): Likewise.
	* rtlhooks-def.h (reg_nonzero_bits_general): Likewise.
	(reg_num_sign_bit_copies_general): Likewise.
	* rtlhooks.c (reg_num_sign_bit_copies_general): Likewise.
	(reg_nonzero_bits_general): Likewise.

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

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index ca176fc5e393c1c4afe44d8f29a9b8663d09158a..23648780ce4a9d554cbe8c519f2c93faed5971cd 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,21 @@
+2017-08-30  Richard Sandiford  <richard.sandiford@linaro.org>
+           Alan Hayward  <alan.hayward@arm.com>
+           David Sherwood  <david.sherwood@arm.com>
+
+       * rtl.h (rtl_hooks::reg_nonzero_bits): Add a scalar_int_mode
+       parameter for the mode of "x".  Remove the "known_x", "known_mode"
+       and "known_ret" arguments.  Change the type of the mode argument
+       to scalar_int_mode.
+       (rtl_hooks:reg_num_sign_bit_copies): Likewise.
+       * combine.c (reg_nonzero_bits_for_combine): Update accordingly.
+       (reg_num_sign_bit_copies_for_combine): Likewise.
+       * rtlanal.c (nonzero_bits1): Likewise.
+       (num_sign_bit_copies1): Likewise.
+       * rtlhooks-def.h (reg_nonzero_bits_general): Likewise.
+       (reg_num_sign_bit_copies_general): Likewise.
+       * rtlhooks.c (reg_num_sign_bit_copies_general): Likewise.
+       (reg_nonzero_bits_general): 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/combine.c b/gcc/combine.c
index 5eeeeda55b607b18b2de7f2d95e9a3abc52f7f30..85a2f50bca6254938ad33741737d9e406acfd05a 100644 (file)
--- a/gcc/combine.c
+++ b/gcc/combine.c
@@ -414,13 +414,12 @@ static struct undobuf undobuf;
 
 static int n_occurrences;
 
-static rtx reg_nonzero_bits_for_combine (const_rtx, machine_mode, const_rtx,
-                                        machine_mode,
-                                        unsigned HOST_WIDE_INT,
+static rtx reg_nonzero_bits_for_combine (const_rtx, scalar_int_mode,
+                                        scalar_int_mode,
                                         unsigned HOST_WIDE_INT *);
-static rtx reg_num_sign_bit_copies_for_combine (const_rtx, machine_mode, const_rtx,
-                                               machine_mode,
-                                               unsigned int, unsigned int *);
+static rtx reg_num_sign_bit_copies_for_combine (const_rtx, scalar_int_mode,
+                                               scalar_int_mode,
+                                               unsigned int *);
 static void do_SUBST (rtx *, rtx);
 static void do_SUBST_INT (int *, int);
 static void init_reg_last (void);
@@ -10035,17 +10034,15 @@ simplify_and_const_int (rtx x, scalar_int_mode mode, rtx varop,
   return x;
 }
 \f
-/* Given a REG, X, compute which bits in X can be nonzero.
+/* Given a REG X of mode XMODE, compute which bits in X can be nonzero.
    We don't care about bits outside of those defined in MODE.
 
    For most X this is simply GET_MODE_MASK (GET_MODE (MODE)), but if X is
    a shift, AND, or zero_extract, we can do better.  */
 
 static rtx
-reg_nonzero_bits_for_combine (const_rtx x, machine_mode mode,
-                             const_rtx known_x ATTRIBUTE_UNUSED,
-                             machine_mode known_mode ATTRIBUTE_UNUSED,
-                             unsigned HOST_WIDE_INT known_ret ATTRIBUTE_UNUSED,
+reg_nonzero_bits_for_combine (const_rtx x, scalar_int_mode xmode,
+                             scalar_int_mode mode,
                              unsigned HOST_WIDE_INT *nonzero)
 {
   rtx tem;
@@ -10086,8 +10083,7 @@ reg_nonzero_bits_for_combine (const_rtx x, machine_mode mode,
   if (tem)
     {
       if (SHORT_IMMEDIATES_SIGN_EXTEND)
-       tem = sign_extend_short_imm (tem, GET_MODE (x),
-                                    GET_MODE_PRECISION (mode));
+       tem = sign_extend_short_imm (tem, xmode, GET_MODE_PRECISION (mode));
 
       return tem;
     }
@@ -10096,9 +10092,9 @@ reg_nonzero_bits_for_combine (const_rtx x, machine_mode mode,
     {
       unsigned HOST_WIDE_INT mask = rsp->nonzero_bits;
 
-      if (GET_MODE_PRECISION (GET_MODE (x)) < GET_MODE_PRECISION (mode))
+      if (GET_MODE_PRECISION (xmode) < GET_MODE_PRECISION (mode))
        /* We don't know anything about the upper bits.  */
-       mask |= GET_MODE_MASK (mode) ^ GET_MODE_MASK (GET_MODE (x));
+       mask |= GET_MODE_MASK (mode) ^ GET_MODE_MASK (xmode);
 
       *nonzero &= mask;
     }
@@ -10106,17 +10102,14 @@ reg_nonzero_bits_for_combine (const_rtx x, machine_mode mode,
   return NULL;
 }
 
-/* Return the number of bits at the high-order end of X that are known to
-   be equal to the sign bit.  X will be used in mode MODE; if MODE is
-   VOIDmode, X will be used in its own mode.  The returned value  will always
-   be between 1 and the number of bits in MODE.  */
+/* Given a reg X of mode XMODE, return the number of bits at the high-order
+   end of X that are known to be equal to the sign bit.  X will be used
+   in mode MODE; the returned value will always be between 1 and the
+   number of bits in MODE.  */
 
 static rtx
-reg_num_sign_bit_copies_for_combine (const_rtx x, machine_mode mode,
-                                    const_rtx known_x ATTRIBUTE_UNUSED,
-                                    machine_mode known_mode
-                                    ATTRIBUTE_UNUSED,
-                                    unsigned int known_ret ATTRIBUTE_UNUSED,
+reg_num_sign_bit_copies_for_combine (const_rtx x, scalar_int_mode xmode,
+                                    scalar_int_mode mode,
                                     unsigned int *result)
 {
   rtx tem;
@@ -10145,7 +10138,7 @@ reg_num_sign_bit_copies_for_combine (const_rtx x, machine_mode mode,
     return tem;
 
   if (nonzero_sign_valid && rsp->sign_bit_copies != 0
-      && GET_MODE_PRECISION (GET_MODE (x)) == GET_MODE_PRECISION (mode))
+      && GET_MODE_PRECISION (xmode) == GET_MODE_PRECISION (mode))
     *result = rsp->sign_bit_copies;
 
   return NULL;

diff --git a/gcc/rtl.h b/gcc/rtl.h
index 39425778536c3219868968272821d22bdcff8918..9e16b9b179fca39a9db459b55475948e7fc9d09a 100644 (file)
--- a/gcc/rtl.h
+++ b/gcc/rtl.h
@@ -3779,10 +3779,10 @@ struct rtl_hooks
 {
   rtx (*gen_lowpart) (machine_mode, rtx);
   rtx (*gen_lowpart_no_emit) (machine_mode, rtx);
-  rtx (*reg_nonzero_bits) (const_rtx, machine_mode, const_rtx, machine_mode,
-                          unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT *);
-  rtx (*reg_num_sign_bit_copies) (const_rtx, machine_mode, const_rtx, machine_mode,
-                                 unsigned int, unsigned int *);
+  rtx (*reg_nonzero_bits) (const_rtx, scalar_int_mode, scalar_int_mode,
+                          unsigned HOST_WIDE_INT *);
+  rtx (*reg_num_sign_bit_copies) (const_rtx, scalar_int_mode, scalar_int_mode,
+                                 unsigned int *);
   bool (*reg_truncated_to_mode) (machine_mode, const_rtx);
 
   /* Whenever you add entries here, make sure you adjust rtlhooks-def.h.  */

diff --git a/gcc/rtlanal.c b/gcc/rtlanal.c
index 605fd973d0b129d9b991eddb9fc2996fdcd34590..3066ae20c4d4da3a6e640eadfd3339446156d798 100644 (file)
--- a/gcc/rtlanal.c
+++ b/gcc/rtlanal.c
@@ -4449,9 +4449,8 @@ nonzero_bits1 (const_rtx x, scalar_int_mode mode, const_rtx known_x,
 
       {
        unsigned HOST_WIDE_INT nonzero_for_hook = nonzero;
-       rtx new_rtx = rtl_hooks.reg_nonzero_bits (x, mode, known_x,
-                                             known_mode, known_ret,
-                                             &nonzero_for_hook);
+       rtx new_rtx = rtl_hooks.reg_nonzero_bits (x, xmode, mode,
+                                                 &nonzero_for_hook);
 
        if (new_rtx)
          nonzero_for_hook &= cached_nonzero_bits (new_rtx, mode, known_x,
@@ -4943,9 +4942,8 @@ num_sign_bit_copies1 (const_rtx x, scalar_int_mode mode, const_rtx known_x,
 
       {
        unsigned int copies_for_hook = 1, copies = 1;
-       rtx new_rtx = rtl_hooks.reg_num_sign_bit_copies (x, mode, known_x,
-                                                    known_mode, known_ret,
-                                                    &copies_for_hook);
+       rtx new_rtx = rtl_hooks.reg_num_sign_bit_copies (x, xmode, mode,
+                                                        &copies_for_hook);
 
        if (new_rtx)
          copies = cached_num_sign_bit_copies (new_rtx, mode, known_x,

diff --git a/gcc/rtlhooks-def.h b/gcc/rtlhooks-def.h
index 936189244eab6361e724887b7536556b299b2964..afc5c02f0e16becef4d4e2691f9cd114f36c2146 100644 (file)
--- a/gcc/rtlhooks-def.h
+++ b/gcc/rtlhooks-def.h
@@ -38,13 +38,11 @@ along with GCC; see the file COPYING3.  If not see
 }
 
 extern rtx gen_lowpart_general (machine_mode, rtx);
-extern rtx reg_nonzero_bits_general (const_rtx, machine_mode, const_rtx,
-                                    machine_mode,
-                                    unsigned HOST_WIDE_INT,
+extern rtx reg_nonzero_bits_general (const_rtx, scalar_int_mode,
+                                    scalar_int_mode,
                                     unsigned HOST_WIDE_INT *);
-extern rtx reg_num_sign_bit_copies_general (const_rtx, machine_mode, const_rtx,
-                                           machine_mode,
-                                           unsigned int, unsigned int *);
+extern rtx reg_num_sign_bit_copies_general (const_rtx, scalar_int_mode,
+                                           scalar_int_mode, unsigned int *);
 extern bool reg_truncated_to_mode_general (machine_mode, const_rtx);
 
 #endif /* GCC_RTL_HOOKS_DEF_H */

diff --git a/gcc/rtlhooks.c b/gcc/rtlhooks.c
index 9704e2a774223e6e5ebbafa410d988a57ca602a6..b008b15e78ec4a13d6d8979b4743538c80e482e3 100644 (file)
--- a/gcc/rtlhooks.c
+++ b/gcc/rtlhooks.c
@@ -86,23 +86,15 @@ gen_lowpart_general (machine_mode mode, rtx x)
 }
 
 rtx
-reg_num_sign_bit_copies_general (const_rtx x ATTRIBUTE_UNUSED,
-                                machine_mode mode ATTRIBUTE_UNUSED,
-                                 const_rtx known_x ATTRIBUTE_UNUSED,
-                                machine_mode known_mode ATTRIBUTE_UNUSED,
-                                 unsigned int known_ret ATTRIBUTE_UNUSED,
-                                 unsigned int *result ATTRIBUTE_UNUSED)
+reg_num_sign_bit_copies_general (const_rtx, scalar_int_mode, scalar_int_mode,
+                                unsigned int *)
 {
   return NULL;
 }
 
 rtx
-reg_nonzero_bits_general (const_rtx x ATTRIBUTE_UNUSED,
-                         machine_mode mode ATTRIBUTE_UNUSED,
-                         const_rtx known_x ATTRIBUTE_UNUSED,
-                          machine_mode known_mode ATTRIBUTE_UNUSED,
-                          unsigned HOST_WIDE_INT known_ret ATTRIBUTE_UNUSED,
-                          unsigned HOST_WIDE_INT *nonzero ATTRIBUTE_UNUSED)
+reg_nonzero_bits_general (const_rtx, scalar_int_mode, scalar_int_mode,
+                         unsigned HOST_WIDE_INT *)
 {
   return NULL;
 }