match.pd: Fix parity (X) ^ parity (Y) simplification [PR112719]

When looking around, I've noticed we have a similar simplification
for parity (with ^ rather than +).  Note, unlike the popcount one,
this one doesn't check for INTEGRAL_TYPE_P (type) (which rules out
vector simplification), so I've used the old handling for types_match and
otherwise do it only for scalar argument types and handle different
precision in there.

The testcase ICEs without the previous patch on the first function,
but strangely not on the second which tests parity.  The reason
is that in this case there is no wi::bit_and test like for popcount
and for BITINT_TYPEs build_call_internal actually refuses to create it
and thus the whole simplification fails.  While
.{CLZ,CTZ,CLRSB,FFS,POPCOUNT,PARITY} ifns are direct optab ifns for
normal integer and vector types (and thus it is desirable to punt if
there is no supported optab for them), they have this large/huge _BitInt
extension before bitint lowering, so the patch also adjusts
build_call_internal to allow that case.

2023-11-28  Jakub Jelinek  <jakub@redhat.com>

	PR tree-optimization/112719
	* match.pd (parity(X)^parity(Y) -> parity(X^Y)): Handle case of
	mismatched types.
	* gimple-match-exports.cc (build_call_internal): Add special-case for
	bit query ifns on large/huge BITINT_TYPE before bitint lowering.

	* gcc.dg/bitint-43.c: New test.

diff --git a/gcc/gimple-match-exports.cc b/gcc/gimple-match-exports.cc
index d6dac08cc2b60cc3b3780fa1f195d4b02d5103f8..3a054b6d238f31ea6c3aaebe23ab0c47be88482f 100644 (file)
--- a/gcc/gimple-match-exports.cc
+++ b/gcc/gimple-match-exports.cc
@@ -236,7 +236,30 @@ build_call_internal (internal_fn fn, gimple_match_op *res_op)
       tree_pair types = direct_internal_fn_types (fn, res_op->type,
                                                  res_op->ops);
       if (!direct_internal_fn_supported_p (fn, types, OPTIMIZE_FOR_BOTH))
-       return NULL;
+       {
+         switch (fn)
+           {
+           case IFN_CLZ:
+           case IFN_CTZ:
+           case IFN_CLRSB:
+           case IFN_FFS:
+           case IFN_POPCOUNT:
+           case IFN_PARITY:
+             /* For these 6 builtins large/huge _BitInt operand is ok
+                before bitint lowering pass.  */
+             if (res_op->num_ops >= 1
+                 && TREE_CODE (TREE_TYPE (res_op->ops[0])) == BITINT_TYPE
+                 && (TYPE_PRECISION (TREE_TYPE (res_op->ops[0]))
+                     > MAX_FIXED_MODE_SIZE)
+                 && cfun
+                 && (cfun->curr_properties & PROP_gimple_lbitint) == 0)
+               break;
+             return NULL;
+
+           default:
+             return NULL;
+           }
+       }
     }
   return gimple_build_call_internal (fn, res_op->num_ops,
                                     res_op->op_or_null (0),

diff --git a/gcc/match.pd b/gcc/match.pd
index 0382fd53256a905f26be03fd7ecbfeba8a0f8c61..0170591312c30cb1857bf819abba4f00ded90675 100644 (file)
--- a/gcc/match.pd
+++ b/gcc/match.pd
@@ -8882,7 +8882,14 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
 /* parity(X)^parity(Y) is parity(X^Y).  */
 (simplify
   (bit_xor (PARITY:s @0) (PARITY:s @1))
-  (PARITY (bit_xor @0 @1)))
+  (if (types_match (TREE_TYPE (@0), TREE_TYPE (@1)))
+   (PARITY (bit_xor @0 @1))
+   (if (INTEGRAL_TYPE_P (TREE_TYPE (@0))
+       && INTEGRAL_TYPE_P (TREE_TYPE (@1)))
+    (with { tree utype = TREE_TYPE (@0);
+           if (TYPE_PRECISION (utype) < TYPE_PRECISION (TREE_TYPE (@1)))
+             utype = TREE_TYPE (@1); }
+     (PARITY (bit_xor (convert:utype @0) (convert:utype @1)))))))
 
 #if GIMPLE
 /* parity(zext(X)) == parity(X).  */

diff --git a/gcc/testsuite/gcc.dg/bitint-43.c b/gcc/testsuite/gcc.dg/bitint-43.c
new file mode 100644 (file)
index 0000000..3a506b3
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/bitint-43.c
@@ -0,0 +1,19 @@
+/* PR tree-optimization/112719 */
+/* { dg-do compile { target bitint } } */
+/* { dg-options "-O2" } */
+
+#if __BITINT_MAXWIDTH__ >= 252
+int
+foo (unsigned _BitInt(239) x, unsigned _BitInt(252) y)
+{
+  x &= 0x2aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaauwb;
+  y &= 0x555555555555555555555555555555555555555555555555555555555555555uwb;
+  return __builtin_popcountg (x) + __builtin_popcountg (y);
+}
+
+int
+bar (unsigned _BitInt(239) x, unsigned _BitInt(252) y)
+{
+  return __builtin_parityg (x) ^ __builtin_parityg (y);
+}
+#endif