OpenE2K
/
gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

PR tree-optimization/105835: Two narrowing patterns for match.pd. 

This patch resolves PR tree-optimization/105835, which is a code quality
(dead code elimination) regression at -O1 triggered/exposed by a recent
change to canonicalize X&-Y as X*Y.  The new (shorter) form exposes some
missed optimization opportunities that can be handled by adding some
extra simplifications to match.pd.

One transformation is to simplify "(short)(x ? 65535 : 0)" into the
equivalent "x ? -1 : 0", or more accurately x ? (short)-1 : (short)0",
as INTEGER_CSTs record their type, and integer conversions can be
pushed inside COND_EXPRs reducing the number of gimple statements.

The other transformation is that (short)(X * 65535), where X is [0,1],
into the equivalent (short)X * -1, (or again (short)-1 where tree's
INTEGER_CSTs encode their type).  This is valid because multiplications
where one operand is [0,1] are guaranteed not to overflow, and hence
integer conversions can also be pushed inside these multiplications.

These narrowing conversion optimizations can be identified by range
analyses, such as EVRP, but these are only performed at -O2 and above,
which is why this regression is only visible with -O1.

2022-06-18  Roger Sayle  <roger@nextmovesoftware.com>

gcc/ChangeLog
	PR tree-optimization/105835
	* match.pd (convert (mult zero_one_valued_p@1 INTEGER_CST@2)):
	Narrow integer multiplication by a zero_one_valued_p operand.
	(convert (cond @1 INTEGER_CST@2 INTEGER_CST@3)): Push integer
	conversions inside COND_EXPR where both data operands are
	integer constants.

gcc/testsuite/ChangeLog
	PR tree-optimization/105835
	* gcc.dg/pr105835.c: New test case.
This commit is contained in:
Roger Sayle 2022-06-18 09:06:20 +01:00
parent 479b6f449e
commit 9991d84d2a
2 changed files with 33 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
gcc/match.pd
View File

@ -1881,6 +1881,15 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
&& !TYPE_UNSIGNED (TREE_TYPE (@0)))
(mult (convert @0) @1)))
/* Narrow integer multiplication by a zero_one_valued_p operand.
Multiplication by [0,1] is guaranteed not to overflow. */
(simplify
(convert (mult@0 zero_one_valued_p@1 INTEGER_CST@2))
(if (INTEGRAL_TYPE_P (type)
&& INTEGRAL_TYPE_P (TREE_TYPE (@0))
&& TYPE_PRECISION (type) <= TYPE_PRECISION (TREE_TYPE (@0)))
(mult (convert @1) (convert @2))))
/* Convert ~ (-A) to A - 1. */
(simplify
(bit_not (convert? (negate @0)))
@ -4356,6 +4365,12 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
)
#endif
(simplify
(convert (cond@0 @1 INTEGER_CST@2 INTEGER_CST@3))
(if (INTEGRAL_TYPE_P (type)
&& INTEGRAL_TYPE_P (TREE_TYPE (@0)))
(cond @1 (convert @2) (convert @3))))
/* Simplification moved from fold_cond_expr_with_comparison. It may also
be extended. */
/* This pattern implements two kinds simplification:

18
gcc/testsuite/gcc.dg/pr105835.c Normal file
View File

@ -0,0 +1,18 @@
/* { dg-do compile } */
/* { dg-options "-O1 -fdump-tree-optimized" } */
void foo();
static int b;
static short a(short c, unsigned short d) { return c - d; }
int main() {
int e = -(0 < b);
if (a(1, e))
b = 0;
else
foo();
}
/* { dg-final { scan-tree-dump-not "goto" "optimized" } } */