From: Richard Biener <richard.guenther@gmail.com>
To: Marc Glisse <marc.glisse@inria.fr>
Cc: GCC Patches <gcc-patches@gcc.gnu.org>
Subject: Re: match.pd: Relax some tree_nop_conversion_p
Date: Mon, 23 May 2016 11:38:00 -0000 [thread overview]
Message-ID: <CAFiYyc2zkA+Vd92jao64qXtZ4LsSaBhDbB4xFNtk_yfhkdiG7g@mail.gmail.com> (raw)
In-Reply-To: <alpine.DEB.2.02.1605221922250.4797@laptop-mg.saclay.inria.fr>
On Sun, May 22, 2016 at 7:42 PM, Marc Glisse <marc.glisse@inria.fr> wrote:
> 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.
Ok.
Thanks,
Richard.
> 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
> 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" } } */
>
prev parent reply other threads:[~2016-05-23 11:38 UTC|newest]
Thread overview: 2+ messages / expand[flat|nested] mbox.gz Atom feed top
2016-05-22 17:42 Marc Glisse
2016-05-23 11:38 ` Richard Biener [this message]
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=CAFiYyc2zkA+Vd92jao64qXtZ4LsSaBhDbB4xFNtk_yfhkdiG7g@mail.gmail.com \
--to=richard.guenther@gmail.com \
--cc=gcc-patches@gcc.gnu.org \
--cc=marc.glisse@inria.fr \
/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).