On Wed, Nov 11, 2026 at 2:21 AM <[email protected]> wrote:
>
> From: Kyrylo Tkachov <[email protected]>
>
> The folds of x ==/!= (typeof x)(x ==/!= CST) assume that the converted
> comparison is 0 or 1.  For a signed one-bit x, (typeof x) true is -1.
> For
>
>   struct s1 { int s : 1; };
>   int f (struct s1 a)
>   {
>     struct s1 b;
>     struct s1 c = a;
>     int t = a.s;
>     b.s = (t == -1);
>     int t1 = b.s;
>     int t2 = c.s;
>     return t2 != t1;
>   }
>
> forwprop1 sees
>
>   _2 = _1 == -1;
>   _3 = (<unnamed-signed:1>) _2;
>   b.s = _3;
>   _4 = b.s;
>   _5 = c.s;
>   _6 = _4 != _5;
>
> and the fold gives a.s != 0, so f ((struct s1){-1}) is 1 instead of 0
> at -O1 and above.  This is a regression since GCC 14.  C2Y signed
> _BitInt(1) gives the same wrong code.
>
> For a signed one-bit x, compare CST with -1 in place of 1.  The other
> parts of the folds are then correct, because x can only be 0 or -1.
> The result above becomes 0.
>
> A comparison can also have a signed one-bit result type in GIMPLE.
> Then (typeof x) true is -1 or all ones for a wider x, so do not fold.
>
> 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/128585
>         * match.pd (x ==/!= (typeof x)(x ==/!= CST)): Compare CST with -1
>         for a signed one-bit x.  Do not fold if the comparison has a signed
>         one-bit type.
>
> gcc/testsuite/ChangeLog:
>
>         PR tree-optimization/128585
>         * gcc.dg/torture/pr110293-bitint.c: New test.
>         * gcc.dg/torture/pr128585.c: New test.
>         * gcc.dg/tree-ssa/pr128585.c: New test.
>
> Signed-off-by: Kyrylo Tkachov <[email protected]>
> ---
> v1 is 5/8 of the series posted on 2026-11-09.
> Changes from v1 (Andrea's review):
> - Fold for a signed one-bit x and compare CST with -1 for it, with the
>   code that Andrea gave.
> - Keep the check that the comparison does not have a signed one-bit type.
>   GIMPLE allows such a comparison (f3 in pr110293-bitint.c).

That is not valid gimple.  The check in verify_gimple_comparison is too relaxed:
```
  /* The resulting type of a comparison may be an effective boolean type.  */
  if (INTEGRAL_TYPE_P (type)
      && (TREE_CODE (type) == BOOLEAN_TYPE
          || TYPE_PRECISION (type) == 1))
```

> - New tests from Andrea's C99 bitfield testcase, PR128585.
>
>  gcc/match.pd                                  | 59 +++++++++++--------
>  .../gcc.dg/torture/pr110293-bitint.c          | 48 +++++++++++++++
>  gcc/testsuite/gcc.dg/torture/pr128585.c       | 44 ++++++++++++++
>  gcc/testsuite/gcc.dg/tree-ssa/pr128585.c      | 38 ++++++++++++
>  4 files changed, 165 insertions(+), 24 deletions(-)
>  create mode 100644 gcc/testsuite/gcc.dg/torture/pr110293-bitint.c
>  create mode 100644 gcc/testsuite/gcc.dg/torture/pr128585.c
>  create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/pr128585.c
>
> diff --git a/gcc/match.pd b/gcc/match.pd
> index 3912f9f7d54..ee9956ceaba 100644
> --- a/gcc/match.pd
> +++ b/gcc/match.pd
> @@ -9533,38 +9533,49 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
>  /* 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.  */
>  (for outer (ne eq)
>   (for inner (ne eq)
>    (simplify
> -   (outer:c @0 (convert (inner @0 INTEGER_CST@1)))
> -   (with {
> -     bool cst1 = integer_onep (@1);
> -     bool cst0 = integer_zerop (@1);
> -     bool innereq = inner == EQ_EXPR;
> -     bool outereq = outer == EQ_EXPR;
> -    }
> -    (switch
> -     (if (innereq ? cst0 : cst1)
> -      { constant_boolean_node (!outereq, type); })
> -     (if (innereq ? cst1 : cst0)
> +   (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);
> +      else
> +       cst1 = integer_minus_onep (@1);
> +      bool cst0 = integer_zerop (@1);
> +      bool innereq = inner == EQ_EXPR;
> +      bool outereq = outer == EQ_EXPR;
> +     }
> +     (switch
> +      (if (innereq ? cst0 : cst1)
> +       { 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 utype = unsigned_type_for (TREE_TYPE (@0));
> -        tree ucst1 = build_one_cst (utype);
> +       tree value = build_int_cst (TREE_TYPE (@0), !innereq);
>         }
> -       (if (!outereq)
> -        (gt (convert:utype @0) { ucst1; })
> -        (le (convert:utype @0) { ucst1; })
> +       (if (outereq)
> +       (eq @0 { value; })
> +       (ne @0 { value; })
>         )
>        )
>       )
> -     (with {
> -       tree value = build_int_cst (TREE_TYPE (@0), !innereq);
> -      }
> -      (if (outereq)
> -       (eq @0 { value; })
> -       (ne @0 { value; })
> -      )
> -     )
>      )
>     )
>    )
> diff --git a/gcc/testsuite/gcc.dg/torture/pr110293-bitint.c 
> b/gcc/testsuite/gcc.dg/torture/pr110293-bitint.c
> new file mode 100644
> index 00000000000..dcdc03e29d5
> --- /dev/null
> +++ b/gcc/testsuite/gcc.dg/torture/pr110293-bitint.c
> @@ -0,0 +1,48 @@
> +/* { dg-do run { target bitint } } */
> +/* { dg-additional-options "-std=c2y -fgimple" } */
> +
> +/* The PR110293 folds of x ==/!= (T)(x ==/!= C) for signed one-bit types.
> +   The conversion of true to such a type gives -1.  */
> +
> +typedef signed _BitInt(1) S;
> +
> +__attribute__((noipa)) int
> +f1 (S a)
> +{
> +  return a != (S) (a == -1);
> +}
> +
> +__attribute__((noipa)) int
> +f2 (S a)
> +{
> +  return a == (S) (a == -1);
> +}
> +
> +/* Here the comparison has the signed one-bit type.  */
> +
> +int __GIMPLE (ssa) __attribute__((noipa))
> +f3 (int x)
> +{
> +  S _1;
> +  int _2;
> +  _Bool _3;
> +  int _4;
> +
> +  __BB(2):
> +  _1 = x_5(D) != 0;
> +  _2 = (int) _1;
> +  _3 = x_5(D) != _2;
> +  _4 = (int) _3;
> +  return _4;
> +}
> +
> +int
> +main ()
> +{
> +  if (f1 (-1) != 0 || f1 (0) != 0)
> +    __builtin_abort ();
> +  if (f2 (-1) != 1 || f2 (0) != 1)
> +    __builtin_abort ();
> +  if (f3 (-1) != 0 || f3 (0) != 0 || f3 (1) != 1 || f3 (2) != 1)
> +    __builtin_abort ();
> +}
> diff --git a/gcc/testsuite/gcc.dg/torture/pr128585.c 
> b/gcc/testsuite/gcc.dg/torture/pr128585.c
> new file mode 100644
> index 00000000000..3d77f59b010
> --- /dev/null
> +++ b/gcc/testsuite/gcc.dg/torture/pr128585.c
> @@ -0,0 +1,44 @@
> +/* PR tree-optimization/128585 */
> +/* { dg-do run } */
> +
> +/* The PR110293 folds of x ==/!= (T)(x ==/!= C) for a signed one-bit
> +   bitfield x.  The conversion of true to that type gives -1.  The extra
> +   variables keep the front end from folding to BIT_FIELD_REFs.  */
> +
> +struct s1
> +{
> +  int s : 1;
> +};
> +
> +__attribute__((noipa)) int
> +f1 (struct s1 a)
> +{
> +  struct s1 b;
> +  struct s1 c = a;
> +  int t = a.s;
> +  b.s = (t == -1);
> +  int t1 = b.s;
> +  int t2 = c.s;
> +  return t2 != t1;
> +}
> +
> +__attribute__((noipa)) int
> +f2 (struct s1 a)
> +{
> +  struct s1 b;
> +  struct s1 c = a;
> +  int t = a.s;
> +  b.s = (t == -1);
> +  int t1 = b.s;
> +  int t2 = c.s;
> +  return t2 == t1;
> +}
> +
> +int
> +main ()
> +{
> +  if (f1 ((struct s1){-1}) != 0 || f1 ((struct s1){0}) != 0)
> +    __builtin_abort ();
> +  if (f2 ((struct s1){-1}) != 1 || f2 ((struct s1){0}) != 1)
> +    __builtin_abort ();
> +}
> diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr128585.c 
> b/gcc/testsuite/gcc.dg/tree-ssa/pr128585.c
> new file mode 100644
> index 00000000000..518b43b72f6
> --- /dev/null
> +++ b/gcc/testsuite/gcc.dg/tree-ssa/pr128585.c
> @@ -0,0 +1,38 @@
> +/* PR tree-optimization/128585 */
> +/* { dg-do compile } */
> +/* { dg-options "-O1 -fdump-tree-optimized" } */
> +
> +/* For a signed one-bit x, x ==/!= (typeof x)(x == -1) folds to a
> +   constant.  */
> +
> +struct s1
> +{
> +  int s : 1;
> +};
> +
> +int
> +f1 (struct s1 a)
> +{
> +  struct s1 b;
> +  struct s1 c = a;
> +  int t = a.s;
> +  b.s = (t == -1);
> +  int t1 = b.s;
> +  int t2 = c.s;
> +  return t2 != t1;
> +}
> +
> +int
> +f2 (struct s1 a)
> +{
> +  struct s1 b;
> +  struct s1 c = a;
> +  int t = a.s;
> +  b.s = (t == -1);
> +  int t1 = b.s;
> +  int t2 = c.s;
> +  return t2 == t1;
> +}
> +
> +/* { dg-final { scan-tree-dump-times "return 0;" 1 "optimized" } } */
> +/* { dg-final { scan-tree-dump-times "return 1;" 1 "optimized" } } */
> --
> 2.54.0 (Apple Git-157)
>

Reply via email to