diff mbox

[simplify-rtx,2/2] Use constants from pool when simplifying binops

Message ID 56266876.4030806@arm.com
State New
Headers show

Commit Message

Kyrylo Tkachov Oct. 20, 2015, 4:14 p.m. UTC 
On 19/10/15 15:37, Kyrill Tkachov wrote:
> Hi Bernd,
>
> On 19/10/15 15:31, Bernd Schmidt wrote:
>> On 10/19/2015 03:57 PM, Kyrill Tkachov wrote:
>>> This second patch teaches simplify_binary_operation to return the
>>> dereferenced
>>> constants from the constant pool in the binary expression if other
>>> simplifications failed.
>>>
>>> This, combined with the 1/2 patch for aarch64
>>> (https://gcc.gnu.org/ml/gcc-patches/2015-10/msg01744.html) allow for:
>>>
>>> int
>>> foo (float a)
>>> {
>>>    return a * 32.0f;
>>> }
>>>
>>> to generate the code:
>>> foo:
>>>          fcvtzs  w0, s0, #5
>>>          ret
>>>
>>> because combine now successfully tries to match:
>>> (set (reg/i:SI 0 x0)
>>>      (fix:SI (mult:SF (reg:SF 32 v0 [ a ])
>>>              (const_double:SF 3.2e+1 [0x0.8p+6]))))
>>>
>>> whereas before it would not try the to use the const_double directly
>>> but rather its constant pool reference.
>>
>> The only way I could see a problem with that if there are circumstances where the memory variant would simplify further. That doesn't seem highly likely, so...
>>
>
> I that were the case, I'd expect the earlier call to simplify_binary_operation_1 have returned a non-NULL rtx,
> and the code in this patch would not come into play.
>
>>>      * simplify-rtx.c (simplify_binary_operation): If either operand was
>>>      a constant pool reference use them if all other simplifications
>>> failed.
>>
>> Ok.
>
> Thanks,
> I'll commit it when the first (aarch64-specific) patch is approved.
>

This patch has already been ok'd, but I'd like to update the aarch64 test to use scan-assembler-times
rather that just scan-assembler in light of Marcus' feedback to another patch.

I committed this version to trunk with r229086.

Thanks,
Kyrill

2015-10-20  Kyrylo Tkachov  <kyrylo.tkachov@arm.com>

     * simplify-rtx.c (simplify_binary_operation): If either operand was
     a constant pool reference use them if all other simplifications failed.

2015-10-20  Kyrylo Tkachov  <kyrylo.tkachov@arm.com>

     * gcc.target/aarch64/fmul_fcvt_1.c: Add multiply-by-32 cases.

> Kyrill
>
>>
>>
>> Bernd
>>
>
diff mbox

Patch

Index: gcc/testsuite/gcc.target/aarch64/fmul_fcvt_1.c
===================================================================
--- gcc/testsuite/gcc.target/aarch64/fmul_fcvt_1.c	(revision 229085)
+++ gcc/testsuite/gcc.target/aarch64/fmul_fcvt_1.c	(working copy)
@@ -83,6 +83,16 @@ 
 /* { dg-final { scan-assembler-times "fcvtzu\tx\[0-9\], d\[0-9\]*.*#4" 1 } } */
 /* { dg-final { scan-assembler-times "fcvtzu\tw\[0-9\], d\[0-9\]*.*#4" 1 } } */
 
+FUNC_DEFS (32)
+FUNC_DEFD (32)
+/* { dg-final { scan-assembler-times "fcvtzs\tw\[0-9\], s\[0-9\]*.*#5" 1 } } */
+/* { dg-final { scan-assembler-times "fcvtzs\tx\[0-9\], s\[0-9\]*.*#5" 1 } } */
+/* { dg-final { scan-assembler-times "fcvtzs\tx\[0-9\], d\[0-9\]*.*#5" 1 } } */
+/* { dg-final { scan-assembler-times "fcvtzs\tw\[0-9\], d\[0-9\]*.*#5" 1 } } */
+/* { dg-final { scan-assembler-times "fcvtzu\tw\[0-9\], s\[0-9\]*.*#5" 1 } } */
+/* { dg-final { scan-assembler-times "fcvtzu\tx\[0-9\], s\[0-9\]*.*#5" 1 } } */
+/* { dg-final { scan-assembler-times "fcvtzu\tx\[0-9\], d\[0-9\]*.*#5" 1 } } */
+/* { dg-final { scan-assembler-times "fcvtzu\tw\[0-9\], d\[0-9\]*.*#5" 1 } } */
 
 #define FUNC_TESTS(__a, __b)					\
 do								\
@@ -120,10 +130,12 @@ 
       FUNC_TESTS (4, i);
       FUNC_TESTS (8, i);
       FUNC_TESTS (16, i);
+      FUNC_TESTS (32, i);
 
       FUNC_TESTD (4, i);
       FUNC_TESTD (8, i);
       FUNC_TESTD (16, i);
+      FUNC_TESTD (32, i);
     }
   return 0;
 }
Index: gcc/simplify-rtx.c
===================================================================
--- gcc/simplify-rtx.c	(revision 229084)
+++ gcc/simplify-rtx.c	(working copy)
@@ -2001,7 +2001,17 @@ 
   tem = simplify_const_binary_operation (code, mode, trueop0, trueop1);
   if (tem)
     return tem;
-  return simplify_binary_operation_1 (code, mode, op0, op1, trueop0, trueop1);
+  tem = simplify_binary_operation_1 (code, mode, op0, op1, trueop0, trueop1);
+
+  if (tem)
+    return tem;
+
+  /* If the above steps did not result in a simplification and op0 or op1
+     were constant pool references, use the referenced constants directly.  */
+  if (trueop0 != op0 || trueop1 != op1)
+    return simplify_gen_binary (code, mode, trueop0, trueop1);
+
+  return NULL_RTX;
 }
 
 /* Subroutine of simplify_binary_operation.  Simplify a binary operation