mirror/gcc
1
0
Fork 0
mirror of https://github.com/gcc-mirror/gcc.git synced 2024-11-21 13:40:47 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

MATCH: Simplify a rrotate (32-b) -> a lrotate b [PR109906]

Browse Source 
The pattern `a rrotate (32-b)` should be optimized to `a lrotate b`.
The same is also true for `a lrotate (32-b)`. It can be optimized to
`a rrotate b`.

This patch adds following patterns:
a rrotate (32-b) -> a lrotate b
a lrotate (32-b) -> a rrotate b

Bootstrapped and tested on x86_64-linux-gnu with no regressions.

	PR tree-optimization/109906

gcc/ChangeLog:

	* match.pd (a rrotate (32-b) -> a lrotate b): New pattern
	(a lrotate (32-b) -> a rrotate b): New pattern

gcc/testsuite/ChangeLog:

	* gcc.dg/tree-ssa/pr109906.c: New test.

Signed-off-by: Eikansh Gupta <quic_eikagupt@quicinc.com>
This commit is contained in:
Eikansh Gupta 2024-11-11 17:06:04 +05:30 committed by Andrew Pinski
parent 6d85a0bc2e
commit 879c1619ab
2 changed files with 50 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
gcc/match.pd
View File

@ -5020,6 +5020,15 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
build_int_cst (TREE_TYPE (@1),
element_precision (type)), @1); }))
/* a rrotate (32-b) -> a lrotate b */
/* a lrotate (32-b) -> a rrotate b */
(for rotate (lrotate rrotate)
orotate (rrotate lrotate)
(simplify
(rotate @0 (minus INTEGER_CST@1 @2))
(if (element_precision (TREE_TYPE (@0)) == wi::to_wide (@1))
(orotate @0 @2))))
/* Turn (a OP c1) OP c2 into a OP (c1+c2). */
(for op (lrotate rrotate rshift lshift)
(simplify

41
gcc/testsuite/gcc.dg/tree-ssa/pr109906.c Normal file
View File

@ -0,0 +1,41 @@
/* PR tree-optimization/109906 */
/* { dg-do compile } */
/* { dg-options "-O1 -fdump-tree-optimized-raw" } */
/* { dg-require-effective-target int32 } */
/* Implementation of rotate right operation */
static inline
unsigned rrotate(unsigned x, int t)
{
if (t >= 32) __builtin_unreachable();
unsigned tl = x >> (t);
unsigned th = x << (32 - t);
return tl | th;
}
/* Here rotate left is achieved by doing rotate right by (32 - x) */
unsigned rotateleft(unsigned t, int x)
{
return rrotate (t, 32 - x);
}
/* Implementation of rotate left operation */
static inline
unsigned lrotate(unsigned x, int t)
{
if (t >= 32) __builtin_unreachable();
unsigned tl = x << (t);
unsigned th = x >> (32 - t);
return tl | th;
}
/* Here rotate right is achieved by doing rotate left by (32 - x) */
unsigned rotateright(unsigned t, int x)
{
return lrotate (t, 32 - x);
}
/* Shouldn't have instruction for (32 - x). */
/* { dg-final { scan-tree-dump-not "minus_expr" "optimized" } } */
/* { dg-final { scan-tree-dump "rrotate_expr" "optimized" } } */
/* { dg-final { scan-tree-dump "lrotate_expr" "optimized" } } */