diff mbox

[Committed] : [PATCH, loop2_invariant, 2/2] Change heuristics for identical invariants

Message ID CACgzC7CSyWvHJKLnhU9DRosYie=0CWqK-8dMyXEa3wOyGTrzCg@mail.gmail.com
State New
Headers show

Commit Message

Zhenqiang Chen July 3, 2014, 5:31 a.m. UTC 
On 2 July 2014 03:54, Jeff Law <law@redhat.com> wrote:
> On 07/01/14 01:16, Zhenqiang Chen wrote:
>
>>
>> ChangeLog:
>> 2014-07-01  Zhenqiang Chen  <zhenqiang.chen@linaro.org>
>>
>>          * loop-invariant.c (struct invariant): Add a new member: eqno;
>>          (find_identical_invariants): Update eqno;
>>          (create_new_invariant): Init eqno;
>>          (get_inv_cost): Compute comp_cost wiht eqno;
>
> s/wiht/with/
>
> Do you have a testcase for this?  If at all possible I'd like to see some
> kind of test to verify that this tracking results in better invariant
> selection.

Since the patch bases on the result of rtx_cost, it is hard to design
a common test case. A testcase for ARM is added.

> With some kind of test and the ChangeLog typo fixed, this is OK.

Thanks. Updated and committed @r212256.

ChangeLog:
2014-07-03  Zhenqiang Chen  <zhenqiang.chen@linaro.org>

    * loop-invariant.c (struct invariant): Add a new member: eqno;
    (find_identical_invariants): Update eqno;
    (create_new_invariant): Init eqno;
    (get_inv_cost): Compute comp_cost with eqno;


testsuite/ChangeLog:
2014-07-03  Zhenqiang Chen  <zhenqiang.chen@linaro.org>

    * gcc.target/arm/identical-invariants.c: New test.

+
diff mbox

Patch

diff --git a/gcc/loop-invariant.c b/gcc/loop-invariant.c
index d47d461..bd67eb9 100644
--- a/gcc/loop-invariant.c
+++ b/gcc/loop-invariant.c
@@ -104,6 +104,9 @@  struct invariant
   /* The number of the invariant with the same value.  */
   unsigned eqto;

+  /* The number of invariants which eqto this.  */
+  unsigned eqno;
+
   /* If we moved the invariant out of the loop, the register that contains its
      value.  */
   rtx reg;
@@ -498,6 +501,7 @@  find_identical_invariants (invariant_htab_type
*eq, struct invariant *inv)
   struct invariant *dep;
   rtx expr, set;
   enum machine_mode mode;
+  struct invariant *tmp;

   if (inv->eqto != ~0u)
     return;
@@ -513,7 +517,12 @@  find_identical_invariants (invariant_htab_type
*eq, struct invariant *inv)
   mode = GET_MODE (expr);
   if (mode == VOIDmode)
     mode = GET_MODE (SET_DEST (set));
-  inv->eqto = find_or_insert_inv (eq, expr, mode, inv)->invno;
+
+  tmp = find_or_insert_inv (eq, expr, mode, inv);
+  inv->eqto = tmp->invno;
+
+  if (tmp->invno != inv->invno && inv->always_executed)
+    tmp->eqno++;

   if (dump_file && inv->eqto != inv->invno)
     fprintf (dump_file,
@@ -1136,7 +1149,7 @@  get_inv_cost (struct invariant *inv, int
*comp_cost, unsigned *regs_needed,

   if (!inv->cheap_address
       || inv->def->n_addr_uses < inv->def->n_uses)
-    (*comp_cost) += inv->cost;
+    (*comp_cost) += inv->cost * inv->eqno;

 #ifdef STACK_REGS
   {
diff --git a/gcc/testsuite/gcc.target/arm/identical-invariants.c
b/gcc/testsuite/gcc.target/arm/identical-invariants.c
new file mode 100644
index 0000000..7762ce6
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/identical-invariants.c
@@ -0,0 +1,29 @@ 
+/* { dg-do compile { target { arm_thumb2_ok } } } */
+/* { dg-options "-O2 -fdump-rtl-loop2_invariant " } */
+
+int t1, t2, t3, t4, t5, t6, t7, t8, t9, t10;
+extern void foo2 (int *, int *, int *, int *, int *, int *);
+extern int foo3 (int, int, int, int, int, int);
+int foo (int a, int b, int c, int d)
+{
+   int i = a;
+
+   for (; i > 0; i += b)
+    {
+      if (a > 0x1234567)
+       foo2 (&t1, &t2, &t3, &t4, &t5, &t6);
+      foo2 (&t1, &t2, &t3, &t4, &t5, &t6);
+      if (b > 0x1234567)
+       foo2 (&t7, &t2, &t8, &t4, &t5, &t6);
+      foo2 (&t1, &t2, &t3, &t4, &t5, &t6);
+      if (c > 0x1234567)
+       foo2 (&t1, &t9, &t10, &t4, &t5, &t6);
+      t2 = t5 - d;
+    }
+
+ return foo3 (t1, t2, t3, t4, t5, t6);
+}
+
+/* { dg-final { scan-rtl-dump "Decided to move invariant 0"
"loop2_invariant" } } */
+/* { dg-final { cleanup-rtl-dump "loop2_invariant" } } */