This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
[PATCH] Fix A < 0 ? C : 0 optimization (PR tree-optimization/78720)
- From: Jakub Jelinek <jakub at redhat dot com>
- To: Richard Biener <rguenther at suse dot de>
- Cc: gcc-patches at gcc dot gnu dot org
- Date: Fri, 9 Dec 2016 20:26:04 +0100
- Subject: [PATCH] Fix A < 0 ? C : 0 optimization (PR tree-optimization/78720)
- Authentication-results: sourceware.org; auth=none
- Reply-to: Jakub Jelinek <jakub at redhat dot com>
Hi!
This patch fixes the recently added A < 0 ? C : 0 for power of 2 C
optimization. The if (!TYPE_UNSIGNED (TREE_TYPE (@0))) part is just
for safety, I'd hope that unsigned < 0 is folded into 0 earlier, but just
in case this is handled first.
The issue which breaks the testcase is that the patch actually assumed
that C has type narrower or as wide as A, which generally doesn't have to be
the case. If the type of C is narrower or as wide as A's type, then the
shift count is necessarily non-negative, but if A is narrower than C, we
might need a left shift instead of right shift (and in that case have to
convert A to C's type first, then left shift so that the MSB of A is moved
to the right position and finally and it.
Bootstrapped/regtested on x86_64-linux and i686-linux, ok for trunk?
2016-12-09 Jakub Jelinek <jakub@redhat.com>
PR tree-optimization/78720
* match.pd (A < 0 ? C : 0): Only optimize for signed A. If shift
is negative, first convert to @1's type and then lshift it by -shift.
* gcc.c-torture/execute/pr78720.c: New test.
--- gcc/match.pd.jj 2016-12-07 17:19:11.000000000 +0100
+++ gcc/match.pd 2016-12-09 10:13:58.531705042 +0100
@@ -2768,17 +2768,23 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
(ncmp (convert:stype @0) { build_zero_cst (stype); })))))
/* If we have A < 0 ? C : 0 where C is a power of 2, convert
- this into a right shift followed by ANDing with C. */
+ this into a right or left shift followed by ANDing with C. */
(simplify
(cond
(lt @0 integer_zerop)
integer_pow2p@1 integer_zerop)
- (with {
+ (if (!TYPE_UNSIGNED (TREE_TYPE (@0)))
+ (with {
int shift = element_precision (@0) - wi::exact_log2 (@1) - 1;
- }
- (bit_and
- (convert (rshift @0 { build_int_cst (integer_type_node, shift); }))
- @1)))
+ tree ctype = TREE_TYPE (@1);
+ }
+ (if (shift >= 0)
+ (bit_and
+ (convert (rshift @0 { build_int_cst (integer_type_node, shift); }))
+ @1)
+ (bit_and
+ (lshift (convert:ctype @0) { build_int_cst (integer_type_node, -shift); })
+ @1)))))
/* When the addresses are not directly of decls compare base and offset.
This implements some remaining parts of fold_comparison address
--- gcc/testsuite/gcc.c-torture/execute/pr78720.c.jj 2016-12-09 10:09:09.655375273 +0100
+++ gcc/testsuite/gcc.c-torture/execute/pr78720.c 2016-12-09 10:07:22.000000000 +0100
@@ -0,0 +1,29 @@
+/* PR tree-optimization/78720 */
+
+__attribute__((noinline, noclone)) long int
+foo (signed char x)
+{
+ return x < 0 ? 0x80000L : 0L;
+}
+
+__attribute__((noinline, noclone)) long int
+bar (signed char x)
+{
+ return x < 0 ? 0x80L : 0L;
+}
+
+__attribute__((noinline, noclone)) long int
+baz (signed char x)
+{
+ return x < 0 ? 0x20L : 0L;
+}
+
+int
+main ()
+{
+ if (foo (-1) != 0x80000L || bar (-1) != 0x80L || baz (-1) != 0x20L
+ || foo (0) != 0L || bar (0) != 0L || baz (0) != 0L
+ || foo (31) != 0L || bar (31) != 0L || baz (31) != 0L)
+ __builtin_abort ();
+ return 0;
+}
Jakub