> On 11 Nov 2026, at 17:25, Andrea Pinski <[email protected]> > wrote: > > 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)) > ```
I’m happy to tighten the check if there is consensus, but I think there has been some disagreement on this in the past? https://inbox.sourceware.org/gcc/CAFiYyc1tHPLJd4tEWMaVp39r_E3e4SUpJH_aL1M=q4dchgc...@mail.gmail.com/ Thanks, Kyrill > >> - 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)
