On 8/22/2024 3:15 PM, Richard Biener wrote:
> 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.
OK, I will split this patch into 4 in v3.
>
>> 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 CMP is <= and C2 -+ C1 == +INF, we can add -+C1 to both sides of the
comparison (and use the fact that -INF <= X+-C1) to obtain (-INF-+C1 <=)
X <= C2-+C1. The right part always holds, so we are left with -INF-+C1
<= X. (> is the negation of this, so -INF-+C1 > X).
Similarly, for >= (and <), using the fact that X+-C1 <= +INF, we can
eliminate C2 and simplify to X <= +INF-+C1.
>
>> + (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));
BTW, in accordance with the above, this should clearly be wi::{add,sub}
(c2, wi::to_wide (@1)). This error did not cause any of the newly added
tests to fail only because something had replaced < to <= and >= to >
prior to the forwprop1 pass. I will correct this in v3.
>> + 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
OK, I will remove both warnings.
>
>> + }
>> + (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?
The rest of the cases (including these two above) are an improvement
because the variable (@1) now appears with a plus instead of a minus
sign, potentially saving sub instructions in generated code. E.g.,
currently on 32-bit RISC-V the expression "10 - (unsigned int) f() < 30"
is computed using 3 instructions:
li a5,10
sub a0,a5,a0
sltiu a0,a0,30
With my patch applied, it becomes 2:
addi a0,a0,19
sltiu a0,a0,30
This was the motivating example in PR116024.
>
>> + (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.
Yes, this is for !TYPE_UNSIGNED () && TYPE_OVERFLOW_WRAPS (), thus for
signed integers under -fwrapv. The primary reason the approaches for
unsigned and wrapping signed integers are different is that for the
latter I can just negate C2 and invert the comparison, and for unsigned
types it's easier to replace C1 - X CMP C2 with X + (C2 - C1) CMP C2
(with additional adjustments in both cases).
I will make sure to add more comments describing all of this to match.pd
in v3.
Thanks for taking a look,
Artemiy
>
>>
>> /* 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 } } */
>>
>
