> On 13 Nov 2026, at 05:08, Jeff Law <[email protected]> wrote:
> 
> 
> 
> On 11/11/26 3:20 AM, [email protected] wrote:
>> From: Kyrylo Tkachov <[email protected]>
>> 
>> The folds of x ==/!= (typeof x)(x CMP CST) handle only == and != as
>> CMP.  For
>> 
>>   int f (int a)
>>   {
>>     int t = a > 1;
>>     return t != a;
>>   }
>> 
>> GCC keeps
>> 
>>   _1 = a_3(D) > 1;
>>   t_4 = (int) _1;
>>   _2 = a_3(D) != t_4;
>> 
>> although the result is a != 0.
>> 
>> (typeof x)(x CMP CST) is 0 or 1, so x can only be equal to it if x is 0
>> or 1.  With C0 = (0 CMP CST) and C1 = (1 CMP CST), x == (typeof x)(x
>> CMP CST) is x == 0 if C0 and C1 are false, x == 1 if both are true,
>> (unsigned) x <= 1 if only C1 is true, and false if only C0 is true.
>> x != (typeof x)(x CMP CST) is the inverse.  For == and != these are the
>> results that the folds give now, so compute C0 and C1 and use the folds
>> for all six comparisons.  For a signed one-bit x, (typeof x) true is -1
>> and C1 is (-1 CMP CST).  Compute C0 and C1 with compare_tree_int and a
>> new helper, comparison_result_p, which gives the value of a comparison
>> from the sign of A - B.  f becomes
>> 
>>   _1 = a_2(D) != 0;
>> 
>> Bootstrapped and tested on aarch64-linux-gnu and x86_64-linux-gnu.
>> Ok for trunk?
>> Thanks,
>> Kyrill
>> 
>> Cc: Andrea Pinski <[email protected]>
>> 
>> gcc/ChangeLog:
>> 
>> PR tree-optimization/127292
>> * fold-const.cc (comparison_result_p): New function.
>> * fold-const.h (comparison_result_p): Declare.
>> * match.pd (x ==/!= (typeof x)(x CMP CST)): Handle all
>> comparisons.  Use the results of the comparison for 0 and
>> (typeof x) 1.
>> 
>> gcc/testsuite/ChangeLog:
>> 
>> PR tree-optimization/127292
>> * gcc.dg/tree-ssa/pr127292-1.c: New test.
>> * gcc.dg/torture/pr127292-2.c: New test.
>> * gcc.dg/torture/pr127292-3.c: New test.
>> 
>> Signed-off-by: Kyrylo Tkachov <[email protected]>
>> ---
>> v1 is 6/8 of the series posted on 2026-11-09.
>> Changes from v1 (Andrea Pinski's review):
>> - Compute C0 and C1 with compare_tree_int and the new helper
>>   comparison_result_p, not with const_binop and build_one_cst.
>> - Handle a signed one-bit x, after the change to 5/8.
>> - New test gcc.dg/torture/pr127292-3.c for a signed one-bit bitfield.
> LGTM.  Sashiko didn't pick it up, but Claude seems reasonably happy with it.  
> Claude asked for a run test as well as tests of more types.  Your call on 
> whether or not to beef up the tests.
> 
> I didn't have any other patches from this series marked in my inbox.  So 
> presumably they're acked or hit areas others typically would review.

Thanks again for the reviews.
Patch 8/8 is the most impactful of the series IMO and the one’s needed to get 
the gain in astcenc that motivated the series:
https://gcc.gnu.org/pipermail/gcc-patches/2026-November/738032.html
It hasn’t had any review in the last few iterations of the series so I’d 
appreciate a vibe check on it.
It’s in the backwards threader so I’m not sure whether it falls under yourself 
or Richard. I think a lot of the ranger work dealt with it as well?

Thanks,
Kyrill

> 
> jeff
>> 
>>  gcc/fold-const.cc                          | 26 +++++++++
>>  gcc/fold-const.h                           |  1 +
>>  gcc/match.pd                               | 65 ++++++++-------------
>>  gcc/testsuite/gcc.dg/torture/pr127292-2.c  | 61 ++++++++++++++++++++
>>  gcc/testsuite/gcc.dg/torture/pr127292-3.c  | 60 ++++++++++++++++++++
>>  gcc/testsuite/gcc.dg/tree-ssa/pr127292-1.c | 66 ++++++++++++++++++++++
>>  6 files changed, 238 insertions(+), 41 deletions(-)
>>  create mode 100644 gcc/testsuite/gcc.dg/torture/pr127292-2.c
>>  create mode 100644 gcc/testsuite/gcc.dg/torture/pr127292-3.c
>>  create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/pr127292-1.c
>> 
>> diff --git a/gcc/fold-const.cc b/gcc/fold-const.cc
>> index 4bb80084b8b..8de144275c4 100644
>> --- a/gcc/fold-const.cc
>> +++ b/gcc/fold-const.cc
>> @@ -2989,6 +2989,32 @@ compcode_to_comparison (enum comparison_code code)
>>      }
>>  }
>>  +/* Return the value of A CODE B, where CODE is LT_EXPR, LE_EXPR, EQ_EXPR,
>> +   NE_EXPR, GE_EXPR or GT_EXPR, and CMP is negative, zero or positive if A
>> +   is less than, equal to or greater than B.  */
>> +
>> +bool
>> +comparison_result_p (tree_code code, int cmp)
>> +{
>> +  switch (code)
>> +    {
>> +    case LT_EXPR:
>> +      return cmp < 0;
>> +    case LE_EXPR:
>> +      return cmp <= 0;
>> +    case EQ_EXPR:
>> +      return cmp == 0;
>> +    case NE_EXPR:
>> +      return cmp != 0;
>> +    case GE_EXPR:
>> +      return cmp >= 0;
>> +    case GT_EXPR:
>> +      return cmp > 0;
>> +    default:
>> +      gcc_unreachable ();
>> +    }
>> +}
>> +
>>  /* Return true if COND1 tests the opposite condition of COND2.  */
>>    bool
>> diff --git a/gcc/fold-const.h b/gcc/fold-const.h
>> index 4e640de725f..0ddc9940965 100644
>> --- a/gcc/fold-const.h
>> +++ b/gcc/fold-const.h
>> @@ -152,6 +152,7 @@ extern tree constant_boolean_node (bool, tree);
>>    extern bool tree_swap_operands_p (const_tree, const_tree);
>>  extern enum tree_code swap_tree_comparison (enum tree_code);
>> +extern bool comparison_result_p (tree_code, int);
>>    extern bool ptr_difference_const (tree, tree, poly_int64 *);
>>  extern enum tree_code invert_tree_comparison (enum tree_code, bool);
>> diff --git a/gcc/match.pd b/gcc/match.pd
>> index ee9956ceaba..05be0b59a60 100644
>> --- a/gcc/match.pd
>> +++ b/gcc/match.pd
>> @@ -9529,58 +9529,41 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
>>   (lt:c @0 (convert (ne tree_expr_nonnegative_p@0 integer_zerop)))
>>   { constant_boolean_node (false, type); })
>>  -/* x != (typeof x)(x == CST) -> CST == 0 ? 1 : (CST == 1 ? (x!=0&&x!=1) : 
>> x != 0) */
>> -/* x != (typeof x)(x != CST) -> CST == 1 ? 1 : (CST == 0 ? (x!=0&&x!=1) : x 
>> != 1) */
>> -/* x == (typeof x)(x == CST) -> CST == 0 ? 0 : (CST == 1 ? (x==0||x==1) : x 
>> == 0) */
>> -/* x == (typeof x)(x != CST) -> CST == 1 ? 0 : (CST == 0 ? (x==0||x==1) : x 
>> == 1) */
>> -/* For a signed one-bit x, (typeof x) true is -1, so -1 takes the place
>> -   of 1 above.  If the comparison has a signed one-bit type, true is -1
>> -   and (typeof x) true is not 1 for a wider x, so do not fold.  */
>> +/* (typeof x)(x CMP CST) is 0 or 1, so x can only be equal to it if x is
>> +   0 or 1.  With C0 = (0 CMP CST) and C1 = (1 CMP CST):
>> +   x == (typeof x)(x CMP CST) -> C0 ? (C1 ? x == 1 : 0)
>> +     : (C1 ? (unsigned) x <= 1 : x == 0)
>> +   and x != (typeof x)(x CMP CST) is the inverse.  For a signed one-bit x,
>> +   (typeof x) true is -1, so -1 takes the place of 1.  If the comparison
>> +   has a signed one-bit type, true is -1 and (typeof x) true is not 1 for
>> +   a wider x, so do not fold.  */
>>  (for outer (ne eq)
>> - (for inner (ne eq)
>> + (for inner (simple_comparison)
>>    (simplify
>>     (outer:c @0 (convert (inner@2 @0 INTEGER_CST@1)))
>>     (if (TYPE_UNSIGNED (TREE_TYPE (@2))
>>   || TYPE_PRECISION (TREE_TYPE (@2)) > 1)
>>      (with {
>> -      bool cst1;
>> -      if (TYPE_UNSIGNED (TREE_TYPE (@0))
>> -   || TYPE_PRECISION (TREE_TYPE (@0)) > 1)
>> - cst1 = integer_onep (@1);
>> +      tree itype = TREE_TYPE (@0);
>> +      /* -compare_tree_int (@1, V) compares V with CST.  */
>> +      bool c0 = comparison_result_p (inner, -compare_tree_int (@1, 0));
>> +      bool c1;
>> +      if (TYPE_UNSIGNED (itype) || TYPE_PRECISION (itype) > 1)
>> + c1 = comparison_result_p (inner, -compare_tree_int (@1, 1));
>>        else
>> - cst1 = integer_minus_onep (@1);
>> -      bool cst0 = integer_zerop (@1);
>> -      bool innereq = inner == EQ_EXPR;
>> + /* CST is 0 or -1.  */
>> + c1 = comparison_result_p (inner, integer_zerop (@1) ? -1 : 0);
>>        bool outereq = outer == EQ_EXPR;
>>       }
>>       (switch
>> -      (if (innereq ? cst0 : cst1)
>> +      (if (c0 && !c1)
>>         { constant_boolean_node (!outereq, type); })
>> -      (if (innereq ? cst1 : cst0)
>> -       (with {
>> -  tree utype = unsigned_type_for (TREE_TYPE (@0));
>> -  tree ucst1 = build_one_cst (utype);
>> - }
>> - (if (!outereq)
>> -  (gt (convert:utype @0) { ucst1; })
>> -  (le (convert:utype @0) { ucst1; })
>> - )
>> -       )
>> -      )
>> -      (with {
>> - tree value = build_int_cst (TREE_TYPE (@0), !innereq);
>> -       }
>> -       (if (outereq)
>> - (eq @0 { value; })
>> - (ne @0 { value; })
>> -       )
>> -      )
>> -     )
>> -    )
>> -   )
>> -  )
>> - )
>> -)
>> +      (if (!c0 && c1)
>> +       (with { tree utype = unsigned_type_for (itype); }
>> + (if (outereq)
>> +  (le (convert:utype @0) { build_one_cst (utype); })
>> +  (gt (convert:utype @0) { build_one_cst (utype); }))))
>> +      (outer @0 { build_int_cst (itype, c0); })))))))
>>    (for cmp (unordered ordered unlt unle ungt unge uneq ltgt)
>>   /* If the second operand is NaN, the result is constant.  */
>> diff --git a/gcc/testsuite/gcc.dg/torture/pr127292-2.c 
>> b/gcc/testsuite/gcc.dg/torture/pr127292-2.c
>> new file mode 100644
>> index 00000000000..d83a9bcac76
>> --- /dev/null
>> +++ b/gcc/testsuite/gcc.dg/torture/pr127292-2.c
>> @@ -0,0 +1,61 @@
>> +/* PR tree-optimization/127292 */
>> +/* { dg-do run } */
>> +
>> +/* Compare x OUT (T) (x IN C) with a version where C is not known.  */
>> +
>> +#define F(T, N, OUT, IN, C) \
>> +  __attribute__((noipa)) int N (T x) { return x OUT (T) (x IN (T) (C)); } \
>> +  __attribute__((noipa)) int N##_r (T x) \
>> +  { \
>> +    volatile T c = (T) (C); \
>> +    T b = x IN c; \
>> +    return x OUT b; \
>> +  }
>> +
>> +#define G(T, N, C) \
>> +  F (T, N##_eq_lt, ==, <, C) F (T, N##_eq_le, ==, <=, C) \
>> +  F (T, N##_eq_eq, ==, ==, C) F (T, N##_eq_ne, ==, !=, C) \
>> +  F (T, N##_eq_ge, ==, >=, C) F (T, N##_eq_gt, ==, >, C) \
>> +  F (T, N##_ne_lt, !=, <, C) F (T, N##_ne_le, !=, <=, C) \
>> +  F (T, N##_ne_eq, !=, ==, C) F (T, N##_ne_ne, !=, !=, C) \
>> +  F (T, N##_ne_ge, !=, >=, C) F (T, N##_ne_gt, !=, >, C)
>> +
>> +#define CF(N) if (N (x) != N##_r (x)) __builtin_abort ();
>> +
>> +#define CG(N) \
>> +  CF (N##_eq_lt) CF (N##_eq_le) CF (N##_eq_eq) CF (N##_eq_ne) \
>> +  CF (N##_eq_ge) CF (N##_eq_gt) CF (N##_ne_lt) CF (N##_ne_le) \
>> +  CF (N##_ne_eq) CF (N##_ne_ne) CF (N##_ne_ge) CF (N##_ne_gt)
>> +
>> +#define TYPE(T, N) \
>> +  G (T, N##_m1, -1) G (T, N##_0, 0) G (T, N##_1, 1) G (T, N##_2, 2) \
>> +  __attribute__((noipa)) void \
>> +  check_##N (T x) \
>> +  { \
>> +    CG (N##_m1) CG (N##_0) CG (N##_1) CG (N##_2) \
>> +  }
>> +
>> +TYPE (int, i)
>> +TYPE (unsigned, u)
>> +TYPE (signed char, sc)
>> +TYPE (unsigned char, uc)
>> +TYPE (long long, ll)
>> +
>> +int
>> +main ()
>> +{
>> +  static const long long vals[]
>> +    = { -__LONG_LONG_MAX__ - 1, -__INT_MAX__ - 1, -3, -2, -1, 0, 1, 2, 3,
>> + __INT_MAX__, (long long) __INT_MAX__ * 2 + 1, __LONG_LONG_MAX__ };
>> +  for (int i = 0; i < sizeof (vals) / sizeof (vals[0]); i++)
>> +    {
>> +      check_i (vals[i]);
>> +      check_u (vals[i]);
>> +      check_ll (vals[i]);
>> +    }
>> +  for (int i = -128; i < 256; i++)
>> +    {
>> +      check_sc (i);
>> +      check_uc (i);
>> +    }
>> +}
>> diff --git a/gcc/testsuite/gcc.dg/torture/pr127292-3.c 
>> b/gcc/testsuite/gcc.dg/torture/pr127292-3.c
>> new file mode 100644
>> index 00000000000..452d3e33aa8
>> --- /dev/null
>> +++ b/gcc/testsuite/gcc.dg/torture/pr127292-3.c
>> @@ -0,0 +1,60 @@
>> +/* PR tree-optimization/127292 */
>> +/* { dg-do run } */
>> +
>> +/* Compare x OUT (T) (x IN C) for a signed one-bit bitfield x with a
>> +   version where C is not known.  The extra variables keep the front end
>> +   from folding to BIT_FIELD_REFs.  */
>> +
>> +struct s1
>> +{
>> +  int s : 1;
>> +};
>> +
>> +#define F(N, OUT, IN, C) \
>> +  __attribute__((noipa)) int N (struct s1 a) \
>> +  { \
>> +    struct s1 b; \
>> +    struct s1 c = a; \
>> +    int t = a.s; \
>> +    b.s = (t IN (C)); \
>> +    int t1 = b.s; \
>> +    int t2 = c.s; \
>> +    return t2 OUT t1; \
>> +  } \
>> +  __attribute__((noipa)) int N##_r (struct s1 a) \
>> +  { \
>> +    volatile int vc = (C); \
>> +    struct s1 b; \
>> +    b.s = (a.s IN vc); \
>> +    int t1 = b.s; \
>> +    int t2 = a.s; \
>> +    return t2 OUT t1; \
>> +  }
>> +
>> +#define G(N, C) \
>> +  F (N##_eq_lt, ==, <, C) F (N##_eq_le, ==, <=, C) \
>> +  F (N##_eq_eq, ==, ==, C) F (N##_eq_ne, ==, !=, C) \
>> +  F (N##_eq_ge, ==, >=, C) F (N##_eq_gt, ==, >, C) \
>> +  F (N##_ne_lt, !=, <, C) F (N##_ne_le, !=, <=, C) \
>> +  F (N##_ne_eq, !=, ==, C) F (N##_ne_ne, !=, !=, C) \
>> +  F (N##_ne_ge, !=, >=, C) F (N##_ne_gt, !=, >, C)
>> +
>> +#define CF(N) if (N (x) != N##_r (x)) __builtin_abort ();
>> +
>> +#define CG(N) \
>> +  CF (N##_eq_lt) CF (N##_eq_le) CF (N##_eq_eq) CF (N##_eq_ne) \
>> +  CF (N##_eq_ge) CF (N##_eq_gt) CF (N##_ne_lt) CF (N##_ne_le) \
>> +  CF (N##_ne_eq) CF (N##_ne_ne) CF (N##_ne_ge) CF (N##_ne_gt)
>> +
>> +G (m1, -1)
>> +G (z, 0)
>> +
>> +int
>> +main ()
>> +{
>> +  struct s1 x;
>> +  x.s = -1;
>> +  CG (m1) CG (z)
>> +  x.s = 0;
>> +  CG (m1) CG (z)
>> +}
>> diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr127292-1.c 
>> b/gcc/testsuite/gcc.dg/tree-ssa/pr127292-1.c
>> new file mode 100644
>> index 00000000000..986de82a91b
>> --- /dev/null
>> +++ b/gcc/testsuite/gcc.dg/tree-ssa/pr127292-1.c
>> @@ -0,0 +1,66 @@
>> +/* PR tree-optimization/127292 */
>> +/* { dg-do compile } */
>> +/* { dg-options "-O2 -fdump-tree-optimized" } */
>> +
>> +int
>> +f23 (int a)
>> +{
>> +  int t = a > 1;
>> +  return t != a;
>> +}
>> +
>> +int
>> +f23_1 (int a)
>> +{
>> +  int t;
>> +  if (a > 1)
>> +    t = 1;
>> +  else
>> +    t = 0;
>> +  return t != a;
>> +}
>> +
>> +int
>> +f23_2 (int a)
>> +{
>> +  int t;
>> +  if (a > 1)
>> +    t = 1;
>> +  else
>> +    t = 0;
>> +  if (t != a)
>> +    t = 1;
>> +  else
>> +    t = 0;
>> +  return t;
>> +}
>> +
>> +/* (0 < 1) is true and (1 < 1) is false, so a is never equal.  */
>> +
>> +int
>> +f_never (int a)
>> +{
>> +  return (a < 1) == a;
>> +}
>> +
>> +/* (0 >= 1) is false and (1 >= 1) is true, so a must be 0 or 1.  */
>> +
>> +int
>> +f_zero_one (int a)
>> +{
>> +  return (a >= 1) == a;
>> +}
>> +
>> +/* (0 >= 0) and (1 >= 0) are true, so a must be 1.  */
>> +
>> +int
>> +f_one (int a)
>> +{
>> +  return a != (a >= 0);
>> +}
>> +
>> +/* { dg-final { scan-tree-dump-times "a_\[0-9\]+\\(D\\) != 0" 3 "optimized" 
>> } } */
>> +/* { dg-final { scan-tree-dump-times "return 0;" 1 "optimized" } } */
>> +/* { dg-final { scan-tree-dump-times "\\(unsigned int\\) 
>> a_\[0-9\]+\\(D\\);" 1 "optimized" } } */
>> +/* { dg-final { scan-tree-dump-times "a_\[0-9\]+\\(D\\) != 1" 1 "optimized" 
>> } } */
>> +/* { dg-final { scan-tree-dump-not "a_\[0-9\]+\\(D\\) \[<>\]=? \[01\];" 
>> "optimized" } } */


Reply via email to