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)
>