From: Marc Glisse <marc.glisse@inria.fr>
To: gcc-patches@gcc.gnu.org
Subject: match.pd: Relax some tree_nop_conversion_p
Date: Sun, 22 May 2016 17:42:00 -0000 [thread overview]
Message-ID: <alpine.DEB.2.02.1605221922250.4797@laptop-mg.saclay.inria.fr> (raw)
[-- Attachment #1: Type: TEXT/PLAIN, Size: 1328 bytes --]
Hello,
this patch replaces some tree_nop_conversion_p tests with less restrictive
conditions. In some cases I checked the transformation automatically (of
course I could have messed up the checker, or the translation). I didn't
always put the laxest possible check. For instance the transformation for
(~x & ~y) is valid with sign extension, but the gain is less obvious in
that case. ~(~X >> Y) also seems valid in some odd cases involving boolean
types, not worth the complication. The bad case for a * (1 << b) is when
1<<b turns into INT_MIN (and then we sign-extend), which I think is valid
even with the strictest overflow rules :-(
I only did a few transforms because it isn't clear to me that this is
worth it. It makes the validity of the transformation less obvious to the
reader and probably seldom fires in regular code. True conversions also
have a cost that can change if the transformation actually gains anything
(may require extra :s). It could also interfere with a narrowing/promotion
pass.
Bootstrap+regtest on powerpc64le-unknown-linux-gnu.
2016-05-23 Marc Glisse <marc.glisse@inria.fr>
gcc/
* match.pd (a * (1 << b), ~x & ~y, ~X ^ ~Y, (X ^ Y) ^ Y, ~ (-A),
~ (A - 1), ~(~X >> Y), ~(~X >>r Y)): Relax constraints.
gcc/testsuite/
* gcc.dg/fold-notshift-2.c: Adjust.
--
Marc Glisse
[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #2: Type: TEXT/x-diff; name=nop.diff, Size: 7816 bytes --]
Index: gcc/match.pd
===================================================================
--- gcc/match.pd (revision 236488)
+++ gcc/match.pd (working copy)
@@ -447,21 +447,22 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
(for ops (conj negate)
(for cabss (CABS)
(simplify
(cabss (ops @0))
(cabss @0))))
/* Fold (a * (1 << b)) into (a << b) */
(simplify
(mult:c @0 (convert? (lshift integer_onep@1 @2)))
(if (! FLOAT_TYPE_P (type)
- && tree_nop_conversion_p (type, TREE_TYPE (@1)))
+ && (element_precision (type) <= element_precision (TREE_TYPE (@1))
+ || TYPE_UNSIGNED (TREE_TYPE (@1))))
(lshift @0 @2)))
/* Fold (C1/X)*C2 into (C1*C2)/X. */
(simplify
(mult (rdiv@3 REAL_CST@0 @1) REAL_CST@2)
(if (flag_associative_math
&& single_use (@3))
(with
{ tree tem = const_binop (MULT_EXPR, type, @0, @2); }
(if (tem)
@@ -648,22 +649,22 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
(simplify
(bit_and:c (bit_ior:c @0 @1) (bit_xor:c @1 (bit_not @0)))
(bit_and @0 @1))
/* ~x & ~y -> ~(x | y)
~x | ~y -> ~(x & y) */
(for op (bit_and bit_ior)
rop (bit_ior bit_and)
(simplify
(op (convert1? (bit_not @0)) (convert2? (bit_not @1)))
- (if (tree_nop_conversion_p (type, TREE_TYPE (@0))
- && tree_nop_conversion_p (type, TREE_TYPE (@1)))
+ (if (element_precision (type) <= element_precision (TREE_TYPE (@0))
+ && element_precision (type) <= element_precision (TREE_TYPE (@1)))
(bit_not (rop (convert @0) (convert @1))))))
/* If we are XORing or adding two BIT_AND_EXPR's, both of which are and'ing
with a constant, and the two constants have no bits in common,
we should treat this as a BIT_IOR_EXPR since this may produce more
simplifications. */
(for op (bit_xor plus)
(simplify
(op (convert1? (bit_and@4 @0 INTEGER_CST@1))
(convert2? (bit_and@5 @2 INTEGER_CST@3)))
@@ -674,22 +675,22 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
/* (X | Y) ^ X -> Y & ~ X*/
(simplify
(bit_xor:c (convert? (bit_ior:c @0 @1)) (convert? @0))
(if (tree_nop_conversion_p (type, TREE_TYPE (@0)))
(convert (bit_and @1 (bit_not @0)))))
/* Convert ~X ^ ~Y to X ^ Y. */
(simplify
(bit_xor (convert1? (bit_not @0)) (convert2? (bit_not @1)))
- (if (tree_nop_conversion_p (type, TREE_TYPE (@0))
- && tree_nop_conversion_p (type, TREE_TYPE (@1)))
+ (if (element_precision (type) <= element_precision (TREE_TYPE (@0))
+ && element_precision (type) <= element_precision (TREE_TYPE (@1)))
(bit_xor (convert @0) (convert @1))))
/* Convert ~X ^ C to X ^ ~C. */
(simplify
(bit_xor (convert? (bit_not @0)) INTEGER_CST@1)
(if (tree_nop_conversion_p (type, TREE_TYPE (@0)))
(bit_xor (convert @0) (bit_not @1))))
/* Fold (X & Y) ^ Y and (X ^ Y) & Y as ~X & Y. */
(for opo (bit_and bit_xor)
@@ -715,22 +716,21 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
/* Some simple reassociation for bit operations, also handled in reassoc. */
/* (X & Y) & Y -> X & Y
(X | Y) | Y -> X | Y */
(for op (bit_and bit_ior)
(simplify
(op:c (convert?@2 (op:c @0 @1)) (convert? @1))
@2))
/* (X ^ Y) ^ Y -> X */
(simplify
(bit_xor:c (convert? (bit_xor:c @0 @1)) (convert? @1))
- (if (tree_nop_conversion_p (type, TREE_TYPE (@0)))
- (convert @0)))
+ (convert @0))
/* (X & Y) & (X & Z) -> (X & Y) & Z
(X | Y) | (X | Z) -> (X | Y) | Z */
(for op (bit_and bit_ior)
(simplify
(op:c (convert1?@3 (op:c@4 @0 @1)) (convert2?@5 (op:c@6 @0 @2)))
(if (tree_nop_conversion_p (type, TREE_TYPE (@1))
&& tree_nop_conversion_p (type, TREE_TYPE (@2)))
(if (single_use (@5) && single_use (@6))
(op @3 (convert @2))
(if (single_use (@3) && single_use (@4))
@@ -908,31 +908,34 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
(le @0 @1)))
/* ~~x -> x */
(simplify
(bit_not (bit_not @0))
@0)
/* Convert ~ (-A) to A - 1. */
(simplify
(bit_not (convert? (negate @0)))
- (if (tree_nop_conversion_p (type, TREE_TYPE (@0)))
+ (if (element_precision (type) <= element_precision (TREE_TYPE (@0))
+ || !TYPE_UNSIGNED (TREE_TYPE (@0)))
(convert (minus @0 { build_each_one_cst (TREE_TYPE (@0)); }))))
/* Convert ~ (A - 1) or ~ (A + -1) to -A. */
(simplify
(bit_not (convert? (minus @0 integer_each_onep)))
- (if (tree_nop_conversion_p (type, TREE_TYPE (@0)))
+ (if (element_precision (type) <= element_precision (TREE_TYPE (@0))
+ || !TYPE_UNSIGNED (TREE_TYPE (@0)))
(convert (negate @0))))
(simplify
(bit_not (convert? (plus @0 integer_all_onesp)))
- (if (tree_nop_conversion_p (type, TREE_TYPE (@0)))
+ (if (element_precision (type) <= element_precision (TREE_TYPE (@0))
+ || !TYPE_UNSIGNED (TREE_TYPE (@0)))
(convert (negate @0))))
/* Part of convert ~(X ^ Y) to ~X ^ Y or X ^ ~Y if ~X or ~Y simplify. */
(simplify
(bit_not (convert? (bit_xor @0 INTEGER_CST@1)))
(if (tree_nop_conversion_p (type, TREE_TYPE (@0)))
(convert (bit_xor @0 (bit_not @1)))))
(simplify
(bit_not (convert? (bit_xor:c (bit_not @0) @1)))
(if (tree_nop_conversion_p (type, TREE_TYPE (@0)))
@@ -1498,34 +1501,37 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
(simplify
(shift (convert?:s (bit_op:s @0 INTEGER_CST@2)) INTEGER_CST@1)
(if (tree_nop_conversion_p (type, TREE_TYPE (@0)))
(with { tree mask = int_const_binop (shift, fold_convert (type, @2), @1); }
(bit_op (shift (convert @0) @1) { mask; }))))))
/* ~(~X >> Y) -> X >> Y (for arithmetic shift). */
(simplify
(bit_not (convert1?:s (rshift:s (convert2?@0 (bit_not @1)) @2)))
(if (!TYPE_UNSIGNED (TREE_TYPE (@0))
- && element_precision (TREE_TYPE (@0))
- <= element_precision (TREE_TYPE (@1))
- && element_precision (type) <= element_precision (TREE_TYPE (@0)))
+ && (element_precision (TREE_TYPE (@0))
+ <= element_precision (TREE_TYPE (@1))
+ || !TYPE_UNSIGNED (TREE_TYPE (@1))))
(with
{ tree shift_type = TREE_TYPE (@0); }
(convert (rshift (convert:shift_type @1) @2)))))
/* ~(~X >>r Y) -> X >>r Y
~(~X <<r Y) -> X <<r Y */
(for rotate (lrotate rrotate)
(simplify
(bit_not (convert1?:s (rotate:s (convert2?@0 (bit_not @1)) @2)))
- (if (element_precision (TREE_TYPE (@0)) <= element_precision (TREE_TYPE (@1))
- && element_precision (type) <= element_precision (TREE_TYPE (@0)))
+ (if ((element_precision (TREE_TYPE (@0))
+ <= element_precision (TREE_TYPE (@1))
+ || !TYPE_UNSIGNED (TREE_TYPE (@1)))
+ && (element_precision (type) <= element_precision (TREE_TYPE (@0))
+ || !TYPE_UNSIGNED (TREE_TYPE (@0))))
(with
{ tree rotate_type = TREE_TYPE (@0); }
(convert (rotate (convert:rotate_type @1) @2))))))
/* Simplifications of conversions. */
/* Basic strip-useless-type-conversions / strip_nops. */
(for cvt (convert view_convert float fix_trunc)
(simplify
(cvt @0)
Index: gcc/testsuite/gcc.dg/fold-notshift-2.c
===================================================================
--- gcc/testsuite/gcc.dg/fold-notshift-2.c (revision 236488)
+++ gcc/testsuite/gcc.dg/fold-notshift-2.c (working copy)
@@ -8,26 +8,26 @@ lsr (unsigned int a, unsigned int b)
{
return ~((~a) >> b);
}
int
sl (int a, int b)
{
return ~((~a) << b);
}
-typedef __INT32_TYPE__ int32_t;
+typedef unsigned __INT32_TYPE__ uint32_t;
typedef __INT64_TYPE__ int64_t;
int64_t
-asr_widen1 (int32_t a, int b)
+asr_widen1 (uint32_t a, int b)
{
return ~((int64_t)(~a) >> b);
}
int64_t
-asr_widen2 (int32_t a, int b)
+asr_widen2 (uint32_t a, int b)
{
return ~(int64_t)(~a >> b);
}
/* { dg-final { scan-tree-dump-times "~" 8 "cddce1" } } */
next reply other threads:[~2016-05-22 17:42 UTC|newest]
Thread overview: 2+ messages / expand[flat|nested] mbox.gz Atom feed top
2016-05-22 17:42 Marc Glisse [this message]
2016-05-23 11:38 ` Richard Biener
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=alpine.DEB.2.02.1605221922250.4797@laptop-mg.saclay.inria.fr \
--to=marc.glisse@inria.fr \
--cc=gcc-patches@gcc.gnu.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).