On Mon, May 24, 2021 at 3:27 AM apinski--- via Gcc-patches
<[email protected]> wrote:
>
> From: Andrew Pinski <[email protected]>
>
> This copies the optimization that is done in phiopt for
> "x < 0 ? ~y : y to (x >> 31) ^ y" into match.pd. The code
> for phiopt is kept around until phiopt uses match.pd (which
> I am working towards).
>
> Note the original testcase is now optimized early on and I added a
> new testcase to optimize during phiopt.
>
> OK? Bootstrapped and tested on x86_64-linux-gnu with no regressions.
>
> Thanks,
> Andrew Pinski
>
> Differences from v1:
> V2: Add check for integeral type to make sure vector types are not done.
>
> gcc:
> * match.pd (x < 0 ? ~y : y): New patterns.
>
> gcc/testsuite:
> * gcc.dg/tree-ssa/pr96928.c: Update test for slightly different IR.
> * gcc.dg/tree-ssa/pr96928-1.c: New testcase.
> ---
> gcc/match.pd | 32 +++++++++++++++
> gcc/testsuite/gcc.dg/tree-ssa/pr96928-1.c | 48 +++++++++++++++++++++++
> gcc/testsuite/gcc.dg/tree-ssa/pr96928.c | 7 +++-
> 3 files changed, 85 insertions(+), 2 deletions(-)
> create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/pr96928-1.c
>
> diff --git a/gcc/match.pd b/gcc/match.pd
> index ad6b057c56d..dd730814942 100644
> --- a/gcc/match.pd
> +++ b/gcc/match.pd
> @@ -4875,6 +4875,38 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
> (cmp (bit_and@2 @0 integer_pow2p@1) @1)
> (icmp @2 { build_zero_cst (TREE_TYPE (@0)); })))
>
> +(for cmp (ge lt)
> +/* x < 0 ? ~y : y into (x >> (prec-1)) ^ y. */
> +/* x >= 0 ? ~y : y into ~((x >> (prec-1)) ^ y). */
> + (simplify
> + (cond (cmp @0 integer_zerop) (bit_not @1) @1)
> + (if (INTEGRAL_TYPE_P (type)
> + && INTEGRAL_TYPE_P (TREE_TYPE (@0))
> + && !TYPE_UNSIGNED (TREE_TYPE (@0))
> + && TYPE_PRECISION (TREE_TYPE (@0)) == TYPE_PRECISION (type))
> + (with
> + {
> + tree shifter = build_int_cst (integer_type_node, TYPE_PRECISION
> (type) - 1);
> + }
> + (if (cmp == LT_EXPR)
> + (bit_xor (convert (rshift @0 {shifter;})) @1)
> + (bit_not (bit_xor (convert (rshift @0 {shifter;})) @1))))))
> +/* x < 0 ? y : ~y into ~((x >> (prec-1)) ^ y). */
> +/* x >= 0 ? y : ~y into (x >> (prec-1)) ^ y. */
> + (simplify
> + (cond (cmp @0 integer_zerop) @1 (bit_not @1))
> + (if (INTEGRAL_TYPE_P (type)
> + && INTEGRAL_TYPE_P (TREE_TYPE (@0))
> + && !TYPE_UNSIGNED (TREE_TYPE (@0))
> + && TYPE_PRECISION (TREE_TYPE (@0)) == TYPE_PRECISION (type))
> + (with
> + {
> + tree shifter = build_int_cst (integer_type_node, TYPE_PRECISION
> (type) - 1);
> + }
> + (if (cmp == GE_EXPR)
> + (bit_xor (convert (rshift @0 {shifter;})) @1)
> + (bit_not (bit_xor (convert (rshift @0 {shifter;})) @1)))))))
I wonder if it makes sense to support
(for cmp (ge lt)
(cond:c (cmp @0 integer_zerop) (bit_not @1) @1)
...
similar to how we support (cmp:c ...), so (cond:c (cmp ...) @0 @1) would
lower to
(cond (cmp ..) @0 @1)
and
(cond (invert_tree_comparison (cmp) ..) @1 @0)
with the caveat that invert_tree_comparison doesn't work for all compares
with HONOR_NANS (and thus compares ever matching FP codes). Thus the
implementation might be a bit tricky.
Anyway, the patch looks OK to me, we can ponder over match.pd extensions
as followup.
Thanks,
Richard.
> /* If we have (A & C) != 0 ? D : 0 where C and D are powers of 2,
> convert this into a shift followed by ANDing with D. */
> (simplify
> diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr96928-1.c
> b/gcc/testsuite/gcc.dg/tree-ssa/pr96928-1.c
> new file mode 100644
> index 00000000000..a2770e5e896
> --- /dev/null
> +++ b/gcc/testsuite/gcc.dg/tree-ssa/pr96928-1.c
> @@ -0,0 +1,48 @@
> +/* PR tree-optimization/96928 */
> +/* { dg-do compile } */
> +/* { dg-options "-O2 -fdump-tree-phiopt2" } */
> +/* { dg-final { scan-tree-dump-times " = a_\[0-9]*\\\(D\\\) >> " 5 "phiopt2"
> } } */
> +/* { dg-final { scan-tree-dump-times " = ~c_\[0-9]*\\\(D\\\);" 1 "phiopt2" }
> } */
> +/* { dg-final { scan-tree-dump-times " = ~" 1 "phiopt2" } } */
> +/* { dg-final { scan-tree-dump-times " = \[abc_0-9\\\(\\\)D]* \\\^ " 5
> "phiopt2" } } */
> +/* { dg-final { scan-tree-dump-not "a < 0" "phiopt2" } } */
> +
> +int
> +foo (int a)
> +{
> + if (a < 0)
> + return ~a;
> + return a;
> +}
> +
> +int
> +bar (int a, int b)
> +{
> + if (a < 0)
> + return ~b;
> + return b;
> +}
> +
> +unsigned
> +baz (int a, unsigned int b)
> +{
> + if (a < 0)
> + return ~b;
> + return b;
> +}
> +
> +unsigned
> +qux (int a, unsigned int c)
> +{
> + if (a >= 0)
> + return ~c;
> + return c;
> +}
> +
> +int
> +corge (int a, int b)
> +{
> + if (a >= 0)
> + return b;
> + return ~b;
> +}
> diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr96928.c
> b/gcc/testsuite/gcc.dg/tree-ssa/pr96928.c
> index 20913572691..e8fd82fc26e 100644
> --- a/gcc/testsuite/gcc.dg/tree-ssa/pr96928.c
> +++ b/gcc/testsuite/gcc.dg/tree-ssa/pr96928.c
> @@ -1,8 +1,11 @@
> /* PR tree-optimization/96928 */
> /* { dg-do compile } */
> -/* { dg-options "-O2 -fdump-tree-phiopt2" } */
> +/* { dg-options "-O2 -fdump-tree-phiopt2 -fdump-tree-optimized" } */
> /* { dg-final { scan-tree-dump-times " = a_\[0-9]*\\\(D\\\) >> " 5 "phiopt2"
> } } */
> -/* { dg-final { scan-tree-dump-times " = ~c_\[0-9]*\\\(D\\\);" 1 "phiopt2" }
> } */
> +/* The following check is done at optimized because a ^ (~b) is rewritten as
> ~(a^b)
> + and in the case of match.pd optimizing these ?:, the ~ is moved out
> already
> + by the time we get to phiopt2. */
> +/* { dg-final { scan-tree-dump-times "\\\^ c_\[0-9]*\\\(D\\\);" 1
> "optimized" } } */
> /* { dg-final { scan-tree-dump-times " = ~" 1 "phiopt2" } } */
> /* { dg-final { scan-tree-dump-times " = \[abc_0-9\\\(\\\)D]* \\\^ " 5
> "phiopt2" } } */
> /* { dg-final { scan-tree-dump-not "a < 0" "phiopt2" } } */
> --
> 2.17.1
>
