Re: [PATCH] tree-optimization: Simplify ((X CMP1 Y) - (X CMP2 Y)) REL 0

On Mon, Jul 27, 2026 at 2:12 AM Tudor-Stefan Magirescu
<[email protected]> wrote:
>
> Add a new match.pd pattern to fold sign-of-difference expressions into
> a single comparison.  The pattern matches differences of two comparisons
> of the same operands, where the comparison pair is one of {gt,lt} or
> {ge,le}.
>
> The pattern cannot be merged into the generic (X - Y) CMP 0 rule
> above it, which is restricted to eq/ne.  Extending that rule to
> lt/le/gt/ge would defeat ABS_EXPR synthesis in
> fold_cond_expr_with_comparison for expressions of the form
> (X - Y) < 0 ? (Y - X) : (X - Y).  Matching the full comparison
> structure avoids this regression.
>
> Bootstrapped and tested on x86_64-linux-gnu.
>
> gcc/ChangeLog:
>
>         * match.pd (((X CMP1 Y) - (X CMP2 Y)) REL 0): New pattern.
>
> gcc/testsuite/ChangeLog:
>
>         * gcc.c-torture/execute/subcmp-1.c: New test.
>         * gcc.dg/tree-ssa/subcmp-1.c: New test.
>
> Signed-off-by: Tudor-Stefan Magirescu <[email protected]>
> ---
>  gcc/match.pd                                  |  34 +++++
>  .../gcc.c-torture/execute/subcmp-1.c          |  55 ++++++++
>  gcc/testsuite/gcc.dg/tree-ssa/subcmp-1.c      | 131 ++++++++++++++++++
>  3 files changed, 220 insertions(+)
>  create mode 100644 gcc/testsuite/gcc.c-torture/execute/subcmp-1.c
>  create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/subcmp-1.c
>
> diff --git a/gcc/match.pd b/gcc/match.pd
> index cf03333fdc6..a6ae87fb27d 100644
> --- a/gcc/match.pd
> +++ b/gcc/match.pd
> @@ -7314,6 +7314,40 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
>     (if (single_use (@2))
>      (cmp @0 @1)))))
>
> +/* Fold ((X CMP1 Y) - (X CMP2 Y)) REL 0 into a single comparison of X and Y,
> +   e.g., ((X > Y) - (X < Y)) < 0 to X < Y.  This cannot be merged into the
> +   generic X - Y CMP 0 rule above as it would prevent ABS_EXPR synthesis in
> +   fold_cond_expr_with_comparison.  */
> +(for rel (lt le gt ge)
> + (simplify
> +  (rel (minus@2 (convert? (gt @0 @1)) (convert? (lt @0 @1))) integer_zerop)
> +   (if (INTEGRAL_TYPE_P (TREE_TYPE (@0))
> +       && !TYPE_UNSIGNED (TREE_TYPE (@2))
> +       && TYPE_PRECISION (TREE_TYPE (@2)) > 1
> +       && single_use (@2))
> +       (rel @0 @1)))
> + (simplify
> +  (rel (minus@2 (convert? (ge @0 @1)) (convert? (le @0 @1))) integer_zerop)
> +   (if (INTEGRAL_TYPE_P (TREE_TYPE (@0))
> +       && !TYPE_UNSIGNED (TREE_TYPE (@2))
> +       && TYPE_PRECISION (TREE_TYPE (@2)) > 1
> +       && single_use (@2))
> +       (rel @0 @1)))
> + (simplify
> +  (rel (minus@2 (convert? (lt @0 @1)) (convert? (gt @0 @1))) integer_zerop)
> +   (if (INTEGRAL_TYPE_P (TREE_TYPE (@0))
> +       && !TYPE_UNSIGNED (TREE_TYPE (@2))
> +       && TYPE_PRECISION (TREE_TYPE (@2)) > 1
> +       && single_use (@2))
> +       (rel @1 @0)))
> + (simplify
> +  (rel (minus@2 (convert? (le @0 @1)) (convert? (ge @0 @1))) integer_zerop)
> +   (if (INTEGRAL_TYPE_P (TREE_TYPE (@0))
> +       && !TYPE_UNSIGNED (TREE_TYPE (@2))
> +       && TYPE_PRECISION (TREE_TYPE (@2)) > 1
> +       && single_use (@2))
> +       (rel @1 @0))))

I think it would be a good idea to combine this into one pattern using
the for loop feature better.
Something like:
(for rel (lt le gt ge)
 (for cmp1 (gt ge)
        cmp2 (lt le)
  (rel (minus@2 (convert? (cmp1:c @0 @1)) (convert? (cmp2:c @0 @1)))
integer_zerop)

I am not sure we need/want the single use here. Yes in theory it could
extend @0/@1 lifetime, but the expression is much simpler and will be
folded into a conditional.
Note the `:c` here for gt/ge will match lt/le with swapped operands.
that is (lt @1 @0) will match for (gt @0 @1) (likewise for ge).

Thanks,
Andrea

> +
>  /* Simplify (x < 0) ^ (y < 0) to (x ^ y) < 0 and
>     (x >= 0) ^ (y >= 0) to (x ^ y) < 0.  */
>  (for cmp (lt ge)
> diff --git a/gcc/testsuite/gcc.c-torture/execute/subcmp-1.c b/gcc/testsuite/gcc.c-torture/execute/subcmp-1.c
> new file mode 100644
> index 00000000000..4682246c355
> --- /dev/null
> +++ b/gcc/testsuite/gcc.c-torture/execute/subcmp-1.c
> @@ -0,0 +1,55 @@
> +#define func(vol, op1, op2, op3)       \
> +_Bool op1##_##op2##_##op3##_##vol (int a, int b)       \
> +{                                      \
> + vol _Bool x = op_##op1(a, b);         \
> + vol _Bool y = op_##op2(a, b);         \
> + return op_##op3(x - y, 0);            \
> +}
> +
> +#define op_lt(a, b) ((a) < (b))
> +#define op_le(a, b) ((a) <= (b))
> +#define op_gt(a, b) ((a) > (b))
> +#define op_ge(a, b) ((a) >= (b))
> +
> +#define funcs(a) \
> + a(gt,lt,lt) \
> + a(gt,lt,le) \
> + a(gt,lt,gt) \
> + a(gt,lt,ge) \
> +  \
> + a(ge,le,lt) \
> + a(ge,le,le) \
> + a(ge,le,gt) \
> + a(ge,le,ge) \
> +  \
> + a(lt,gt,lt) \
> + a(lt,gt,le) \
> + a(lt,gt,gt) \
> + a(lt,gt,ge) \
> +  \
> + a(le,ge,lt) \
> + a(le,ge,le) \
> + a(le,ge,gt) \
> + a(le,ge,ge) \
> +
> +#define funcs1(a,b,c) \
> +func(,a,b,c) \
> +func(volatile,a,b,c)
> +
> +funcs(funcs1)
> +
> +#define test(op1,op2,op3)                      \
> +do {                                           \
> +  if (op1##_##op2##_##op3##_(x,y)              \
> +      != op1##_##op2##_##op3##_volatile(x,y))  \
> +    __builtin_abort();                         \
> +} while(0);
> +
> +int main()
> +{
> +  for(int x = -10; x < 10; x++)
> +    for(int y = -10; y < 10; y++)
> +    {
> +        funcs(test)
> +    }
> +}
> diff --git a/gcc/testsuite/gcc.dg/tree-ssa/subcmp-1.c b/gcc/testsuite/gcc.dg/tree-ssa/subcmp-1.c
> new file mode 100644
> index 00000000000..489cf4c1f40
> --- /dev/null
> +++ b/gcc/testsuite/gcc.dg/tree-ssa/subcmp-1.c
> @@ -0,0 +1,131 @@
> +/* { dg-do compile } */
> +/* { dg-options "-O2 -fdump-tree-optimized" } */
> +
> +_Bool subgtlt_lt(int a00, int b00)
> +{
> +  _Bool x00 = a00 > b00;
> +  _Bool y00 = a00 < b00;
> +  return x00 - y00 < 0;
> +}
> +/* { dg-final { scan-tree-dump "a00_\[0-9\]+.D. < b00_\[0-9\]+.D.|b00_\[0-9\]+.D. > a00_\[0-9\]+.D." "optimized" } } */
> +
> +_Bool subgtlt_le(int a01, int b01)
> +{
> +  _Bool x01 = a01 > b01;
> +  _Bool y01 = a01 < b01;
> +  return x01 - y01 <= 0;
> +}
> +/* { dg-final { scan-tree-dump "a01_\[0-9\]+.D. <= b01_\[0-9\]+.D.|b01_\[0-9\]+.D. >= a01_\[0-9\]+.D." "optimized" } } */
> +
> +_Bool subgtlt_gt(int a02, int b02)
> +{
> +  _Bool x02 = a02 > b02;
> +  _Bool y02 = a02 < b02;
> +  return x02 - y02 > 0;
> +}
> +/* { dg-final { scan-tree-dump "a02_\[0-9\]+.D. > b02_\[0-9\]+.D.|b02_\[0-9\]+.D. < a02_\[0-9\]+.D." "optimized" } } */
> +
> +_Bool subgtlt_ge(int a03, int b03)
> +{
> +  _Bool x03 = a03 > b03;
> +  _Bool y03 = a03 < b03;
> +  return x03 - y03 >= 0;
> +}
> +/* { dg-final { scan-tree-dump "a03_\[0-9\]+.D. >= b03_\[0-9\]+.D.|b03_\[0-9\]+.D. <= a03_\[0-9\]+.D." "optimized" } } */
> +
> +_Bool subgele_lt(int a04, int b04)
> +{
> +  _Bool x04 = a04 >= b04;
> +  _Bool y04 = a04 <= b04;
> +  return x04 - y04 < 0;
> +}
> +/* { dg-final { scan-tree-dump "a04_\[0-9\]+.D. < b04_\[0-9\]+.D.|b04_\[0-9\]+.D. > a04_\[0-9\]+.D." "optimized" } } */
> +
> +_Bool subgele_le(int a05, int b05)
> +{
> +  _Bool x05 = a05 >= b05;
> +  _Bool y05 = a05 <= b05;
> +  return x05 - y05 <= 0;
> +}
> +/* { dg-final { scan-tree-dump "a05_\[0-9\]+.D. <= b05_\[0-9\]+.D.|b05_\[0-9\]+.D. >= a05_\[0-9\]+.D." "optimized" } } */
> +
> +_Bool subgele_gt(int a06, int b06)
> +{
> +  _Bool x06 = a06 >= b06;
> +  _Bool y06 = a06 <= b06;
> +  return x06 - y06 > 0;
> +}
> +/* { dg-final { scan-tree-dump "a06_\[0-9\]+.D. > b06_\[0-9\]+.D.|b06_\[0-9\]+.D. < a06_\[0-9\]+.D." "optimized" } } */
> +
> +_Bool subgele_ge(int a07, int b07)
> +{
> +  _Bool x07 = a07 >= b07;
> +  _Bool y07 = a07 <= b07;
> +  return x07 - y07 >= 0;
> +}
> +/* { dg-final { scan-tree-dump "a07_\[0-9\]+.D. >= b07_\[0-9\]+.D.|b07_\[0-9\]+.D. <= a07_\[0-9\]+.D." "optimized" } } */
> +
> +_Bool subltgt_lt(int a08, int b08)
> +{
> +  _Bool x08 = a08 < b08;
> +  _Bool y08 = a08 > b08;
> +  return x08 - y08 < 0;
> +}
> +/* { dg-final { scan-tree-dump "a08_\[0-9\]+.D. > b08_\[0-9\]+.D.|b08_\[0-9\]+.D. < a08_\[0-9\]+.D." "optimized" } } */
> +
> +_Bool subltgt_le(int a09, int b09)
> +{
> +  _Bool x09 = a09 < b09;
> +  _Bool y09 = a09 > b09;
> +  return x09 - y09 <= 0;
> +}
> +/* { dg-final { scan-tree-dump "a09_\[0-9\]+.D. >= b09_\[0-9\]+.D.|b09_\[0-9\]+.D. <= a09_\[0-9\]+.D." "optimized" } } */
> +
> +_Bool subltgt_gt(int a10, int b10)
> +{
> +  _Bool x10 = a10 < b10;
> +  _Bool y10 = a10 > b10;
> +  return x10 - y10 > 0;
> +}
> +/* { dg-final { scan-tree-dump "a10_\[0-9\]+.D. < b10_\[0-9\]+.D.|b10_\[0-9\]+.D. > a10_\[0-9\]+.D." "optimized" } } */
> +
> +_Bool subltgt_ge(int a11, int b11)
> +{
> +  _Bool x11 = a11 < b11;
> +  _Bool y11 = a11 > b11;
> +  return x11 - y11 >= 0;
> +}
> +/* { dg-final { scan-tree-dump "a11_\[0-9\]+.D. <= b11_\[0-9\]+.D.|b11_\[0-9\]+.D. >= a11_\[0-9\]+.D." "optimized" } } */
> +
> +_Bool sublege_lt(int a12, int b12)
> +{
> +  _Bool x12 = a12 <= b12;
> +  _Bool y12 = a12 >= b12;
> +  return x12 - y12 < 0;
> +}
> +/* { dg-final { scan-tree-dump "a12_\[0-9\]+.D. > b12_\[0-9\]+.D.|b12_\[0-9\]+.D. < a12_\[0-9\]+.D." "optimized" } } */
> +
> +_Bool sublege_le(int a13, int b13)
> +{
> +  _Bool x13 = a13 <= b13;
> +  _Bool y13 = a13 >= b13;
> +  return x13 - y13 <= 0;
> +}
> +/* { dg-final { scan-tree-dump "a13_\[0-9\]+.D. >= b13_\[0-9\]+.D.|b13_\[0-9\]+.D. <= a13_\[0-9\]+.D." "optimized" } } */
> +
> +_Bool sublege_gt(int a14, int b14)
> +{
> +  _Bool x14 = a14 <= b14;
> +  _Bool y14 = a14 >= b14;
> +  return x14 - y14 > 0;
> +}
> +/* { dg-final { scan-tree-dump "a14_\[0-9\]+.D. < b14_\[0-9\]+.D.|b14_\[0-9\]+.D. > a14_\[0-9\]+.D." "optimized" } } */
> +
> +_Bool sublege_ge(int a15, int b15)
> +{
> +  _Bool x15 = a15 <= b15;
> +  _Bool y15 = a15 >= b15;
> +  return x15 - y15 >= 0;
> +}
> +/* { dg-final { scan-tree-dump "a15_\[0-9\]+.D. <= b15_\[0-9\]+.D.|b15_\[0-9\]+.D. >= a15_\[0-9\]+.D." "optimized" } } */
> +/* { dg-final { scan-tree-dump-not "_\[0-9\]+ - _\[0-9\]+" "optimized" } } */
> --
> 2.43.0
>