match.pd: Handle BUILT_IN_BITREVERSE8 like other BUILT_IN_BITREVERSE* [PR125399]

I've mistakenly omitted BUILT_IN_BITREVERSE8 in the BITREVERSE
operator list.

The following patch fixes that, plus extends the __builtin_bitreverse32
test with one further check and duplicates the test for the other
builtins, i.e. __builtin_bitreverse{8,16,64,128}.

2026-05-22  Jakub Jelinek  <jakub@redhat.com>

	PR tree-optimization/125399
	* match.pd (BITREVERSE): Add BUILT_IN_BITREVERSE8.

	* gcc.dg/builtin-bitreverse-4.c (foo9): New function.
	* gcc.dg/builtin-bitreverse-5.c: New test.
	* gcc.dg/builtin-bitreverse-6.c: New test.
	* gcc.dg/builtin-bitreverse-7.c: New test.
	* gcc.dg/builtin-bitreverse-8.c: New test.

Reviewed-by: Richard Biener <rguenth@suse.de>

diff --git a/gcc/match.pd b/gcc/match.pd
index c6272c1e24ea152f3870fadfc11f8a706696b43c..b3ddd51582875977e5f0a2d41755e4ddf59a3663 100644 (file)
--- a/gcc/match.pd
+++ b/gcc/match.pd
@@ -55,8 +55,8 @@ along with GCC; see the file COPYING3.  If not see
 (define_operator_list swapped_simple_comparison gt   ge   eq ne le   lt)
 (define_operator_list BSWAP BUILT_IN_BSWAP16 BUILT_IN_BSWAP32
            BUILT_IN_BSWAP64 BUILT_IN_BSWAP128)
-(define_operator_list BITREVERSE BUILT_IN_BITREVERSE16 BUILT_IN_BITREVERSE32
-           BUILT_IN_BITREVERSE64 BUILT_IN_BITREVERSE128)
+(define_operator_list BITREVERSE BUILT_IN_BITREVERSE8 BUILT_IN_BITREVERSE16
+           BUILT_IN_BITREVERSE32 BUILT_IN_BITREVERSE64 BUILT_IN_BITREVERSE128)
 
 #include "cfn-operators.pd"
 

diff --git a/gcc/testsuite/gcc.dg/builtin-bitreverse-4.c b/gcc/testsuite/gcc.dg/builtin-bitreverse-4.c
index 2344de17acdbd1a062b493672d60e60623119b32..a2e7330594f7f41cbe538cb5f48164af0a89c151 100644 (file)
--- a/gcc/testsuite/gcc.dg/builtin-bitreverse-4.c
+++ b/gcc/testsuite/gcc.dg/builtin-bitreverse-4.c
@@ -51,4 +51,10 @@ foo8 (unsigned a)
   return BS (BS (BS (BS (a))));
 }
 
+bool
+foo9 (unsigned a)
+{
+  return BS (a) == 0;
+}
+
 /* { dg-final { scan-tree-dump-not "__builtin_bitreverse" "optimized" } } */

diff --git a/gcc/testsuite/gcc.dg/builtin-bitreverse-5.c b/gcc/testsuite/gcc.dg/builtin-bitreverse-5.c
new file mode 100644 (file)
index 0000000..3f1fb32
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/builtin-bitreverse-5.c
@@ -0,0 +1,60 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+#define BS(X) __builtin_bitreverse64 (X)
+
+unsigned long long
+foo1 (unsigned long long a)
+{
+  return BS (~ BS (a));
+}
+
+unsigned long long
+foo2 (unsigned long long a)
+{
+  return BS (BS (a) & 0xA0000);
+}
+
+unsigned long long
+foo3 (unsigned long long a)
+{
+  return BS (BS (a) | 0xA0000);
+}
+
+unsigned long long
+foo4 (unsigned long long a)
+{
+  return BS (BS (a) ^ 0xA0000);
+}
+
+unsigned long long
+foo5 (unsigned long long a, unsigned long long b)
+{
+  return BS (BS (a) & BS (b));
+}
+
+unsigned long long
+foo6 (unsigned long long a, unsigned long long b)
+{
+  return BS (BS (a) | BS (b));
+}
+
+unsigned long long
+foo7 (unsigned long long a, unsigned long long b)
+{
+  return BS (BS (a) ^ BS (b));
+}
+
+unsigned long long
+foo8 (unsigned long long a)
+{
+  return BS (BS (BS (BS (a))));
+}
+
+bool
+foo9 (unsigned long long a)
+{
+  return BS (a) == 0;
+}
+
+/* { dg-final { scan-tree-dump-not "__builtin_bitreverse" "optimized" } } */

diff --git a/gcc/testsuite/gcc.dg/builtin-bitreverse-6.c b/gcc/testsuite/gcc.dg/builtin-bitreverse-6.c
new file mode 100644 (file)
index 0000000..730427d
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/builtin-bitreverse-6.c
@@ -0,0 +1,60 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+#define BS(X) __builtin_bitreverse16 (X)
+
+unsigned short
+foo1 (unsigned short a)
+{
+  return BS (~ BS (a));
+}
+
+unsigned short
+foo2 (unsigned short a)
+{
+  return BS (BS (a) & 0xA00);
+}
+
+unsigned short
+foo3 (unsigned short a)
+{
+  return BS (BS (a) | 0xA00);
+}
+
+unsigned short
+foo4 (unsigned short a)
+{
+  return BS (BS (a) ^ 0xA00);
+}
+
+unsigned short
+foo5 (unsigned short a, unsigned short b)
+{
+  return BS (BS (a) & BS (b));
+}
+
+unsigned short
+foo6 (unsigned short a, unsigned short b)
+{
+  return BS (BS (a) | BS (b));
+}
+
+unsigned short
+foo7 (unsigned short a, unsigned short b)
+{
+  return BS (BS (a) ^ BS (b));
+}
+
+unsigned short
+foo8 (unsigned short a)
+{
+  return BS (BS (BS (BS (a))));
+}
+
+bool
+foo9 (unsigned short a)
+{
+  return BS (a) == 0;
+}
+
+/* { dg-final { scan-tree-dump-not "__builtin_bitreverse" "optimized" } } */

diff --git a/gcc/testsuite/gcc.dg/builtin-bitreverse-7.c b/gcc/testsuite/gcc.dg/builtin-bitreverse-7.c
new file mode 100644 (file)
index 0000000..1cb7044
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/builtin-bitreverse-7.c
@@ -0,0 +1,60 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+#define BS(X) __builtin_bitreverse8 (X)
+
+unsigned char
+foo1 (unsigned char a)
+{
+  return BS (~ BS (a));
+}
+
+unsigned char
+foo2 (unsigned char a)
+{
+  return BS (BS (a) & 0x0A);
+}
+
+unsigned char
+foo3 (unsigned char a)
+{
+  return BS (BS (a) | 0x0A);
+}
+
+unsigned char
+foo4 (unsigned char a)
+{
+  return BS (BS (a) ^ 0x0A);
+}
+
+unsigned char
+foo5 (unsigned char a, unsigned char b)
+{
+  return BS (BS (a) & BS (b));
+}
+
+unsigned char
+foo6 (unsigned char a, unsigned char b)
+{
+  return BS (BS (a) | BS (b));
+}
+
+unsigned char
+foo7 (unsigned char a, unsigned char b)
+{
+  return BS (BS (a) ^ BS (b));
+}
+
+unsigned char
+foo8 (unsigned char a)
+{
+  return BS (BS (BS (BS (a))));
+}
+
+bool
+foo9 (unsigned char a)
+{
+  return BS (a) == 0;
+}
+
+/* { dg-final { scan-tree-dump-not "__builtin_bitreverse" "optimized" } } */

diff --git a/gcc/testsuite/gcc.dg/builtin-bitreverse-8.c b/gcc/testsuite/gcc.dg/builtin-bitreverse-8.c
new file mode 100644 (file)
index 0000000..383ffe6
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/builtin-bitreverse-8.c
@@ -0,0 +1,60 @@
+/* { dg-do compile { target int128 } } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+#define BS(X) __builtin_bitreverse128 (X)
+
+unsigned __int128
+foo1 (unsigned __int128 a)
+{
+  return BS (~ BS (a));
+}
+
+unsigned __int128
+foo2 (unsigned __int128 a)
+{
+  return BS (BS (a) & 0xA0000A0000ULL);
+}
+
+unsigned __int128
+foo3 (unsigned __int128 a)
+{
+  return BS (BS (a) | 0xA0000A0000ULL);
+}
+
+unsigned __int128
+foo4 (unsigned __int128 a)
+{
+  return BS (BS (a) ^ 0xA0000A0000ULL);
+}
+
+unsigned __int128
+foo5 (unsigned __int128 a, unsigned __int128 b)
+{
+  return BS (BS (a) & BS (b));
+}
+
+unsigned __int128
+foo6 (unsigned __int128 a, unsigned __int128 b)
+{
+  return BS (BS (a) | BS (b));
+}
+
+unsigned __int128
+foo7 (unsigned __int128 a, unsigned __int128 b)
+{
+  return BS (BS (a) ^ BS (b));
+}
+
+unsigned __int128
+foo8 (unsigned __int128 a)
+{
+  return BS (BS (BS (BS (a))));
+}
+
+bool
+foo9 (unsigned __int128 a)
+{
+  return BS (a) == 0;
+}
+
+/* { dg-final { scan-tree-dump-not "__builtin_bitreverse" "optimized" } } */