On Wed, 21 Aug 2024, Artemiy Volkov wrote:
> Hi,
>
> sending a v2 of
> https://gcc.gnu.org/pipermail/gcc-patches/2024-August/659851.html after
> changing variable types in all new testcases from standard to fixed-width.
>
> Could anyone please assist with reviewing and/or pushing to trunk/14 since I
> don't have commit access?
>
> Many thanks,
> Artemiy
>
> ---------- 8< ------------
>
> This patch implements match.pd patterns for the following transformations:
>
> (1) (UB-on-overflow types) C1 - X cmp C2 -> X cmp C1 - C2
>
> (2) (unsigned types) C1 - X cmp C2 ->
> (a) X cmp C1 - C2, when cmp is !=, ==
> (b) X - (C1 - C2) cmp C2, when cmp is <=, >
> (c) X - (C1 - C2 + 1) cmp C2, when cmp is <, >=,
>
> (3) (signed wrapping types) C1 - X cmp C2
> (a) X cmp C1 - C2, when cmp is !=, ==
> (b) X - (C1 + 1) rcmp -(C2 + 1), otherwise
>
> (4) (all wrapping types) X + C1 cmp C2 ->
> (a) X cmp C2 - C1, when cmp is !=, ==
> (b) X cmp -C1, when cmp is <=, > and C2 - C1 == max
> (c) X cmp -C1, when cmp is <, >= and C2 - C1 == min
It would be easier to review if separating those, it wasn't all
clear what of (1) .. (4) corresponds to which hunk below.
> Included along are testcases for all the aforementioned changes. This
> patch has been bootstrapped and regtested on aarch64, x86_64, and i386,
> and additionally regtested on riscv32. Existing tests were adjusted
> where necessary.
>
> gcc/ChangeLog:
>
> PR tree-optimization/116024
> * match.pd: New transformations around integer comparison.
>
> gcc/testsuite/ChangeLog:
>
> * gcc.dg/tree-ssa/pr116024.c: New test.
> * gcc.dg/tree-ssa/pr116024-1.c: Ditto.
> * gcc.dg/tree-ssa/pr116024-1-fwrapv.c: Ditto.
> * gcc.dg/tree-ssa/pr116024-2.c: Ditto.
> * gcc.dg/tree-ssa/pr116024-2-fwrapv.c: Ditto.
> * gcc.dg/pr67089-6.c: Adjust.
> * gcc.target/aarch64/gtu_to_ltu_cmp_1.c: Ditto.
>
> Signed-off-by: Artemiy Volkov <arte...@synopsys.com>
> ---
> gcc/match.pd | 75 ++++++++++++++++++-
> gcc/testsuite/gcc.dg/pr67089-6.c | 4 +-
> .../gcc.dg/tree-ssa/pr116024-1-fwrapv.c | 74 ++++++++++++++++++
> gcc/testsuite/gcc.dg/tree-ssa/pr116024-1.c | 74 ++++++++++++++++++
> .../gcc.dg/tree-ssa/pr116024-2-fwrapv.c | 38 ++++++++++
> gcc/testsuite/gcc.dg/tree-ssa/pr116024-2.c | 39 ++++++++++
> gcc/testsuite/gcc.dg/tree-ssa/pr116024.c | 74 ++++++++++++++++++
> .../gcc.target/aarch64/gtu_to_ltu_cmp_1.c | 2 +-
> 8 files changed, 376 insertions(+), 4 deletions(-)
> create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/pr116024-1-fwrapv.c
> create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/pr116024-1.c
> create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/pr116024-2-fwrapv.c
> create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/pr116024-2.c
> create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/pr116024.c
>
> diff --git a/gcc/match.pd b/gcc/match.pd
> index 65a3aae2243..bf3ccef7437 100644
> --- a/gcc/match.pd
> +++ b/gcc/match.pd
> @@ -8800,6 +8800,7 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
> (cmp @0 { TREE_OVERFLOW (res)
> ? drop_tree_overflow (res) : res; }))))))))
> (for cmp (lt le gt ge)
> + rcmp (gt ge lt le)
> (for op (plus minus)
> rop (minus plus)
> (simplify
> @@ -8827,7 +8828,79 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
> "X cmp C2 -+ C1"),
> WARN_STRICT_OVERFLOW_COMPARISON);
> }
> - (cmp @0 { res; })))))))))
> + (cmp @0 { res; })))))
> +/* For wrapping types, simplify X + C1 CMP C2 to X CMP -C1 when possible. */
it's more like X +- C1 CMP C2 to X CMP' C2 -+ C1 when C2 -+ C1 == +-INF?
I have to think hard whether this requires an unsigned type
(naturally TYPE_OVERFLOW_WRAPS) or if it also works for signed
types (with -fwrapv).
Can you explain?
> + (if (TYPE_OVERFLOW_WRAPS (TREE_TYPE (@0)))
> + (with
> + {
> + wide_int max = wi::max_value (TREE_TYPE (@0));
> + wide_int min = wi::min_value (TREE_TYPE (@0));
> +
> + wide_int c2 = rop == PLUS_EXPR
> + ? wi::add (wi::to_wide (@2), wi::to_wide (@1))
> + : wi::sub (wi::to_wide (@2), wi::to_wide (@1));
> + }
> + (if (((cmp == LE_EXPR || cmp == GT_EXPR) && wi::eq_p (c2, max))
> + || ((cmp == LT_EXPR || cmp == GE_EXPR) && wi::eq_p (c2, min)))
> + (with
> + {
> + wide_int c1 = rop == PLUS_EXPR
> + ? wi::add (min, wi::to_wide (@1))
> + : wi::sub (min, wi::to_wide (@1));
> + tree c1_cst = build_uniform_cst (TREE_TYPE (@0),
> + wide_int_to_tree (TREE_TYPE (@0), c1));
> + }
> + (rcmp @0 { c1_cst; })))))))))
> +
> +/* Invert sign of X in comparisons of the form C1 - X CMP C2. */
> +
> +(for cmp (lt le gt ge eq ne)
> + rcmp (gt ge lt le eq ne)
> + (simplify
> + (cmp (minus INTEGER_CST@0 @1) INTEGER_CST@2)
> + (if (!TREE_OVERFLOW (@0) && !TREE_OVERFLOW (@2)
> + && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (@1)))
> + (with { tree res = int_const_binop (MINUS_EXPR, @0, @2); }
> + (if (TREE_OVERFLOW (res))
> + (with
> + {
> + fold_overflow_warning (("assuming signed overflow does not occur "
> + "when simplifying conditional to constant"),
> + WARN_STRICT_OVERFLOW_CONDITIONAL);
> + }
> + (switch
> + (if (cmp == NE_EXPR)
> + { constant_boolean_node (true, type); })
> + (if (cmp == EQ_EXPR)
> + { constant_boolean_node (false, type); })
> + {
> + bool less = cmp == LE_EXPR || cmp == LT_EXPR;
> + bool ovf_high = wi::lt_p (wi::to_wide (@0), 0,
> + TYPE_SIGN (TREE_TYPE (@0)));
> + constant_boolean_node (less == ovf_high, type);
> + }))
> + (with
> + {
> + fold_overflow_warning (("assuming signed overflow does not occur "
> + "when changing C1 - X cmp C2 to "
> + "X cmp C1 - C2"),
> + WARN_STRICT_OVERFLOW_COMPARISON);
please don't add more fold_overflow_warning
> + }
> + (rcmp @1 { res; }))))
> + (if (TYPE_UNSIGNED (TREE_TYPE (@1)))
> + (switch
> + (if (cmp == EQ_EXPR || cmp == NE_EXPR)
> + (cmp @1 (minus @0 @2)))
> + (if (cmp == LE_EXPR || cmp == GT_EXPR)
> + (cmp (plus @1 (minus @2 @0)) @2))
Why's that an improvement?
> + (if (cmp == LT_EXPR || cmp == GE_EXPR)
> + (cmp (plus @1 (minus @2
> + (plus @0 { build_int_cst (TREE_TYPE (@1), 1); }))) @2)))
Likewise? Can you add comments describing the transform before the
respective transforms?
> + (if (TYPE_OVERFLOW_WRAPS (TREE_TYPE (@1)))
> + (if (cmp == EQ_EXPR || cmp == NE_EXPR)
> + (cmp @1 (minus @0 @2))
> + (rcmp (minus @1 (plus @0 { build_int_cst (TREE_TYPE (@1), 1); }))
> + (negate @2))))))))
why is the latter valid for all compares but the TYPE_UNSIGNED case is
not? I suppose this is for signed compares but without undefined
overflow?
More comments would clearly help so that people later understand what
the different cases are.
>
> /* Canonicalizations of BIT_FIELD_REFs. */
>
> diff --git a/gcc/testsuite/gcc.dg/pr67089-6.c
> b/gcc/testsuite/gcc.dg/pr67089-6.c
> index b59d75b2318..80a33c3f3e2 100644
> --- a/gcc/testsuite/gcc.dg/pr67089-6.c
> +++ b/gcc/testsuite/gcc.dg/pr67089-6.c
> @@ -57,5 +57,5 @@ T (25, unsigned short, 2U - x, if (r > 2U) foo (0))
> T (26, unsigned char, 2U - x, if (r <= 2U) foo (0))
>
> /* { dg-final { scan-tree-dump-times "ADD_OVERFLOW" 16 "widening_mul" {
> target { i?86-*-* x86_64-*-* } } } } */
> -/* { dg-final { scan-tree-dump-times "SUB_OVERFLOW" 11 "widening_mul" {
> target { { i?86-*-* x86_64-*-* } && { ! ia32 } } } } } */
> -/* { dg-final { scan-tree-dump-times "SUB_OVERFLOW" 9 "widening_mul" {
> target { { i?86-*-* x86_64-*-* } && ia32 } } } } */
> +/* { dg-final { scan-tree-dump-times "SUB_OVERFLOW" 9 "widening_mul" {
> target { { i?86-*-* x86_64-*-* } && { ! ia32 } } } } } */
> +/* { dg-final { scan-tree-dump-times "SUB_OVERFLOW" 7 "widening_mul" {
> target { { i?86-*-* x86_64-*-* } && ia32 } } } } */
> diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr116024-1-fwrapv.c
> b/gcc/testsuite/gcc.dg/tree-ssa/pr116024-1-fwrapv.c
> new file mode 100644
> index 00000000000..1fe8c821bec
> --- /dev/null
> +++ b/gcc/testsuite/gcc.dg/tree-ssa/pr116024-1-fwrapv.c
> @@ -0,0 +1,74 @@
> +/* PR tree-optimization/116024 */
> +/* { dg-do compile } */
> +/* { dg-options "-O1 -fdump-tree-forwprop1-details -fwrapv" } */
> +
> +#include <stdint.h>
> +#include <limits.h>
> +
> +uint32_t f(void);
> +
> +int32_t i2(void)
> +{
> + int32_t l = 2;
> + l = 10 - (int32_t)f();
> + return l <= 20; // f() + 10 + INT_MIN <= 20
> +}
> +
> +int32_t i2a(void)
> +{
> + int32_t l = 2;
> + l = 10 - (int32_t)f();
> + return l < 30; // f() + 19 + INT_MIN <= 29
> +}
> +
> +int32_t i2b(void)
> +{
> + int32_t l = 2;
> + l = 200 - (int32_t)f();
> + return l <= 100; // f() - 100 + INT_MIN <= 100
> +}
> +
> +int32_t i2c(void)
> +{
> + int32_t l = 2;
> + l = 300 - (int32_t)f();
> + return l < 100; // f() - 201 + INT_MIN <= 99
> +}
> +
> +int32_t i2d(void)
> +{
> + int32_t l = 2;
> + l = 1000 - (int32_t)f();
> + return l >= 2000; // f() + 999 + INT_MIN > 1999
> +}
> +
> +int32_t i2e(void)
> +{
> + int32_t l = 2;
> + l = 1000 - (int32_t)f();
> + return l > 3000; // f() + 2000 + INT_MIN > 3000
> +}
> +
> +int32_t i2f(void)
> +{
> + int32_t l = 2;
> + l = 20000 - (int32_t)f();
> + return l >= 10000; // f() - 10001 + INT_MIN > 9999
> +}
> +
> +int32_t i2g(void)
> +{
> + int32_t l = 2;
> + l = 30000 - (int32_t)f();
> + return l > 10000; // f() - 20000 + INT_MIN > 10000
> +}
> +
> +/* { dg-final { scan-tree-dump-times "Removing dead stmt:.*?- _" 8
> "forwprop1" } } */
> +/* { dg-final { scan-tree-dump-times "gimple_simplified to.* \\+ -11.*\n.*>=
> -20" 1 "forwprop1" } } */
> +/* { dg-final { scan-tree-dump-times "gimple_simplified to.* \\+ -11.*\n.*>=
> -29" 1 "forwprop1" } } */
> +/* { dg-final { scan-tree-dump-times "gimple_simplified to.* \\+
> -201.*\n.*>= -100" 1 "forwprop1" } } */
> +/* { dg-final { scan-tree-dump-times "gimple_simplified to.* \\+
> -301.*\n.*>= -99" 1 "forwprop1" } } */
> +/* { dg-final { scan-tree-dump-times "gimple_simplified to.* \\+
> -1001.*\n.*< -1999" 1 "forwprop1" } } */
> +/* { dg-final { scan-tree-dump-times "gimple_simplified to.* \\+
> -1001.*\n.*< -3000" 1 "forwprop1" } } */
> +/* { dg-final { scan-tree-dump-times "gimple_simplified to.* \\+
> -20001.*\n.*< -9999" 1 "forwprop1" } } */
> +/* { dg-final { scan-tree-dump-times "gimple_simplified to.* \\+
> -30001.*\n.*< -10000" 1 "forwprop1" } } */
> diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr116024-1.c
> b/gcc/testsuite/gcc.dg/tree-ssa/pr116024-1.c
> new file mode 100644
> index 00000000000..ecafb41fa09
> --- /dev/null
> +++ b/gcc/testsuite/gcc.dg/tree-ssa/pr116024-1.c
> @@ -0,0 +1,74 @@
> +/* PR tree-optimization/116024 */
> +/* { dg-do compile } */
> +/* { dg-options "-O1 -fdump-tree-forwprop1-details" } */
> +
> +#include <stdint.h>
> +#include <limits.h>
> +
> +uint32_t f(void);
> +
> +int32_t i2(void)
> +{
> + uint32_t l = 2;
> + l = 10 - (uint32_t)f();
> + return l <= 20; // f() + 10 <= 20
> +}
> +
> +int32_t i2a(void)
> +{
> + uint32_t l = 2;
> + l = 10 - (uint32_t)f();
> + return l < 30; // f() + 19 <= 29
> +}
> +
> +int32_t i2b(void)
> +{
> + uint32_t l = 2;
> + l = 200 - (uint32_t)f();
> + return l <= 100; // f() - 100 <= 100
> +}
> +
> +int32_t i2c(void)
> +{
> + uint32_t l = 2;
> + l = 300 - (uint32_t)f();
> + return l < 100; // f() - 201 <= 99
> +}
> +
> +int32_t i2d(void)
> +{
> + uint32_t l = 2;
> + l = 1000 - (uint32_t)f();
> + return l >= 2000; // f() + 999 > 1999
> +}
> +
> +int32_t i2e(void)
> +{
> + uint32_t l = 2;
> + l = 1000 - (uint32_t)f();
> + return l > 3000; // f() + 2000 > 3000
> +}
> +
> +int32_t i2f(void)
> +{
> + uint32_t l = 2;
> + l = 20000 - (uint32_t)f();
> + return l >= 10000; // f() - 10001 > 9999
> +}
> +
> +int32_t i2g(void)
> +{
> + uint32_t l = 2;
> + l = 30000 - (uint32_t)f();
> + return l > 10000; // f() - 20000 > 10000
> +}
> +
> +/* { dg-final { scan-tree-dump-times "Removing dead stmt:.*?- _" 8
> "forwprop1" } } */
> +/* { dg-final { scan-tree-dump-times "gimple_simplified to.* \\+ 10.*\n.*<=
> 20" 1 "forwprop1" } } */
> +/* { dg-final { scan-tree-dump-times "gimple_simplified to.* \\+ 19.*\n.*<=
> 29" 1 "forwprop1" } } */
> +/* { dg-final { scan-tree-dump-times "gimple_simplified to.* \\+
> 4294967196.*\n.*<= 100" 1 "forwprop1" } } */
> +/* { dg-final { scan-tree-dump-times "gimple_simplified to.* \\+
> 4294967095.*\n.*<= 99" 1 "forwprop1" } } */
> +/* { dg-final { scan-tree-dump-times "gimple_simplified to.* \\+ 999.*\n.*>
> 1999" 1 "forwprop1" } } */
> +/* { dg-final { scan-tree-dump-times "gimple_simplified to.* \\+ 2000.*\n.*>
> 3000" 1 "forwprop1" } } */
> +/* { dg-final { scan-tree-dump-times "gimple_simplified to.* \\+
> 4294957295.*\n.*> 9999" 1 "forwprop1" } } */
> +/* { dg-final { scan-tree-dump-times "gimple_simplified to.* \\+
> 4294947296.*\n.*> 10000" 1 "forwprop1" } } */
> diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr116024-2-fwrapv.c
> b/gcc/testsuite/gcc.dg/tree-ssa/pr116024-2-fwrapv.c
> new file mode 100644
> index 00000000000..ff8f097e647
> --- /dev/null
> +++ b/gcc/testsuite/gcc.dg/tree-ssa/pr116024-2-fwrapv.c
> @@ -0,0 +1,38 @@
> +/* PR tree-optimization/116024 */
> +/* { dg-do compile } */
> +/* { dg-options "-O1 -fdump-tree-forwprop1-details -fwrapv" } */
> +
> +#include <stdint.h>
> +#include <limits.h>
> +
> +uint32_t f(void);
> +
> +int32_t i3(void)
> +{
> + int32_t l = -10 + (int32_t)f();
> + return l <= INT_MAX - 10; // f() > INT_MIN + 9
> +}
> +
> +int32_t i3a(void)
> +{
> + int32_t l = -21 + (int32_t)f();
> + return l < INT_MAX - 20; // f() > INT_MIN + 20
> +}
> +
> +int32_t i3b(void)
> +{
> + int32_t l = 30 + (int32_t)f();
> + return l >= INT_MIN + 30; // f() <= INT_MAX - 30
> +}
> +
> +int32_t i3c(void)
> +{
> + int32_t l = 40 + (int32_t)f();
> + return l > INT_MIN + 39; // f() <= INT_MAX - 39
> +}
> +
> +/* { dg-final { scan-tree-dump-times "Removing dead stmt:.*? \\+" 4
> "forwprop1" } } */
> +/* { dg-final { scan-tree-dump-times "gimple_simplified to.* >= -2147483638"
> 1 "forwprop1" } } */
> +/* { dg-final { scan-tree-dump-times "gimple_simplified to.* >= -2147483627"
> 1 "forwprop1" } } */
> +/* { dg-final { scan-tree-dump-times "gimple_simplified to.* <= 2147483618"
> 1 "forwprop1" } } */
> +/* { dg-final { scan-tree-dump-times "gimple_simplified to.* <= 2147483608"
> 1 "forwprop1" } } */
> diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr116024-2.c
> b/gcc/testsuite/gcc.dg/tree-ssa/pr116024-2.c
> new file mode 100644
> index 00000000000..f7269765fcb
> --- /dev/null
> +++ b/gcc/testsuite/gcc.dg/tree-ssa/pr116024-2.c
> @@ -0,0 +1,39 @@
> +/* PR tree-optimization/116024 */
> +/* { dg-do compile } */
> +/* { dg-options "-O1 -fdump-tree-forwprop1-details" } */
> +
> +#include <stdint.h>
> +#include <limits.h>
> +
> +uint32_t f(void);
> +
> +int32_t i3(void)
> +{
> + uint32_t l = 2;
> + l = UINT_MAX - 9 + (uint32_t)f();
> + return l <= UINT_MAX - 10; // f() > 9
> +}
> +
> +int32_t i3a(void)
> +{
> + uint32_t l = UINT_MAX - 20 + (uint32_t)f();
> + return l < UINT_MAX - 20; // f() > 20
> +}
> +
> +int32_t i3b(void)
> +{
> + uint32_t l = 30 + (uint32_t)f();
> + return l >= 30; // f() < -30u
> +}
> +
> +int32_t i3c(void)
> +{
> + uint32_t l = 40 + (uint32_t)f();
> + return l > 39; // f() < -39u
> +}
> +
> +/* { dg-final { scan-tree-dump-times "Removing dead stmt:.*? \\+" 4
> "forwprop1" } } */
> +/* { dg-final { scan-tree-dump-times "gimple_simplified to.* > 9" 1
> "forwprop1" } } */
> +/* { dg-final { scan-tree-dump-times "gimple_simplified to.* > 20" 1
> "forwprop1" } } */
> +/* { dg-final { scan-tree-dump-times "gimple_simplified to.* <= 4294967265"
> 1 "forwprop1" } } */
> +/* { dg-final { scan-tree-dump-times "gimple_simplified to.* <= 4294967255"
> 1 "forwprop1" } } */
> diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr116024.c
> b/gcc/testsuite/gcc.dg/tree-ssa/pr116024.c
> new file mode 100644
> index 00000000000..22b08057b2b
> --- /dev/null
> +++ b/gcc/testsuite/gcc.dg/tree-ssa/pr116024.c
> @@ -0,0 +1,74 @@
> +/* PR tree-optimization/116024 */
> +/* { dg-do compile } */
> +/* { dg-options "-O1 -fdump-tree-forwprop1-details" } */
> +
> +#include <stdint.h>
> +#include <limits.h>
> +
> +uint32_t f(void);
> +
> +int32_t i1(void)
> +{
> + int32_t l = 2;
> + l = 10 - (int32_t)f();
> + return l <= 9; // f() > 0
> +}
> +
> +int32_t i1a(void)
> +{
> + int32_t l = 2;
> + l = 20 - (int32_t)f();
> + return l <= INT_MIN; // return 0
> +}
> +
> +int32_t i1b(void)
> +{
> + int32_t l = 2;
> + l = 30 - (int32_t)f();
> + return l <= INT_MIN + 31; // f() == INT_MAX
> +}
> +
> +int32_t i1c(void)
> +{
> + int32_t l = 2;
> + l = INT_MAX - 40 - (int32_t)f();
> + return l <= -38; // f() > INT_MAX - 3
> +}
> +
> +int32_t i1d(void)
> +{
> + int32_t l = 2;
> + l = INT_MAX - 50 - (int32_t)f();
> + return l <= INT_MAX - 1; // f() != -50
> +}
> +
> +int32_t i1e(void)
> +{
> + int32_t l = 2;
> + l = INT_MAX - 60 - (int32_t)f();
> + return l != INT_MAX - 90; // f() != 30
> +}
> +
> +int32_t i1f(void)
> +{
> + int32_t l = 2;
> + l = INT_MIN + 70 - (int32_t)f();
> + return l <= INT_MAX - 2; // return 0
> +}
> +
> +int32_t i1g(void)
> +{
> + int32_t l = 2;
> + l = INT_MAX/2 + 30 - (int32_t)f();
> + return l <= INT_MIN/2 - 30; // return 1
> +}
> +
> +
> +/* { dg-final { scan-tree-dump-times "Removing dead stmt:.*?- _" 5
> "forwprop1" } } */
> +/* { dg-final { scan-tree-dump-times "return 0" 2 "forwprop1" } } */
> +/* { dg-final { scan-tree-dump-times "return 1" 1 "forwprop1" } } */
> +/* { dg-final { scan-tree-dump-times "gimple_simplified to.* > 0" 1
> "forwprop1" } } */
> +/* { dg-final { scan-tree-dump-times "gimple_simplified to.* == 2147483647"
> 1 "forwprop1" } } */
> +/* { dg-final { scan-tree-dump-times "gimple_simplified to.* > 2147483644" 1
> "forwprop1" } } */
> +/* { dg-final { scan-tree-dump-times "gimple_simplified to.* != 4294967246"
> 1 "forwprop1" } } */
> +/* { dg-final { scan-tree-dump-times "gimple_simplified to.* != 30" 1
> "forwprop1" } } */
> diff --git a/gcc/testsuite/gcc.target/aarch64/gtu_to_ltu_cmp_1.c
> b/gcc/testsuite/gcc.target/aarch64/gtu_to_ltu_cmp_1.c
> index 81c536c90af..bfcec6719de 100644
> --- a/gcc/testsuite/gcc.target/aarch64/gtu_to_ltu_cmp_1.c
> +++ b/gcc/testsuite/gcc.target/aarch64/gtu_to_ltu_cmp_1.c
> @@ -10,4 +10,4 @@ f1 (int x, int t)
> return t;
> }
>
> -/* { dg-final { scan-assembler-times "cmn\\tw\[0-9\]+, #2" 1 } } */
> +/* { dg-final { scan-assembler-times "cmn\\tw\[0-9\]+, #3" 1 } } */
>
--
Richard Biener <rguent...@suse.de>
SUSE Software Solutions Germany GmbH,
Frankenstrasse 146, 90461 Nuernberg, Germany;
GF: Ivo Totev, Andrew McDonald, Werner Knoblich; (HRB 36809, AG Nuernberg)
