re PR rtl-optimization/54871 (gfortran.dg/vector_subscript_1.f90 FAILs)

	PR rtl-optimization/54871
	* loop-iv.c (simplify_using_initial_values): When scanning previous
	basic blocks, prune the recorded conditions if the current insn was
	not used to make a replacement.

	* loop-unroll.c (decide_unroll_constant_iterations): Clean up message.
	(unroll_loop_constant_iterations): Clarify head comment.
	(decide_unroll_runtime_iterations): Clean up message.
	(unroll_loop_runtime_iterations): Clarify head comment.
	(decide_peel_simple): Clean up message.
	(peel_loop_simple): Clarify head comment.
	(decide_unroll_stupid): Clean up message.
	(unroll_loop_stupid): Clarify head comment.

From-SVN: r192426

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index f961a99aa5ae53537c42b2a3c602df6efe583fdc..d80612418b96249cc2675ffc2142d33272b7357b 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,19 @@
+2012-10-13  Eric Botcazou  <ebotcazou@adacore.com>
+
+       PR rtl-optimization/54871
+       * loop-iv.c (simplify_using_initial_values): When scanning previous
+       basic blocks, prune the recorded conditions if the current insn was
+       not used to make a replacement.
+
+       * loop-unroll.c (decide_unroll_constant_iterations): Clean up message.
+       (unroll_loop_constant_iterations): Clarify head comment.
+       (decide_unroll_runtime_iterations): Clean up message.
+       (unroll_loop_runtime_iterations): Clarify head comment.
+       (decide_peel_simple): Clean up message.
+       (peel_loop_simple): Clarify head comment.
+       (decide_unroll_stupid): Clean up message.
+       (unroll_loop_stupid): Clarify head comment.
+
 2012-10-13  Andreas Schwab  <schwab@linux-m68k.org>
 
        PR gcov-profile/44728

diff --git a/gcc/loop-iv.c b/gcc/loop-iv.c
index f1e19d82072079acdc96ea2cd44bf843f9a77e8e..4619c626b7b249a91572370414695be4d0db779d 100644 (file)
--- a/gcc/loop-iv.c
+++ b/gcc/loop-iv.c
@@ -2004,11 +2004,30 @@ simplify_using_initial_values (struct loop *loop, enum rtx_code op, rtx *expr)
                }
            }
          else
-           /* If we did not use this insn to make a replacement, any overlap
-              between stores in this insn and our expression will cause the
-              expression to become invalid.  */
-           if (for_each_rtx (expr, altered_reg_used, this_altered))
-             goto out;
+           {
+             rtx *pnote, *pnote_next;
+
+             /* If we did not use this insn to make a replacement, any overlap
+                between stores in this insn and our expression will cause the
+                expression to become invalid.  */
+             if (for_each_rtx (expr, altered_reg_used, this_altered))
+               goto out;
+
+             /* Likewise for the conditions.  */
+             for (pnote = &cond_list; *pnote; pnote = pnote_next)
+               {
+                 rtx note = *pnote;
+                 rtx old_cond = XEXP (note, 0);
+
+                 pnote_next = &XEXP (note, 1);
+                 if (for_each_rtx (&old_cond, altered_reg_used, this_altered))
+                   {
+                     *pnote = *pnote_next;
+                     pnote_next = pnote;
+                     free_EXPR_LIST_node (note);
+                   }
+               }
+           }
 
          if (CONSTANT_P (*expr))
            goto out;

diff --git a/gcc/loop-unroll.c b/gcc/loop-unroll.c
index b6dace030c1e668dfec0e58c90a15746bb583c8f..5350ee0881574288b5b725fdb93cc4b3c68d9a52 100644 (file)
--- a/gcc/loop-unroll.c
+++ b/gcc/loop-unroll.c
@@ -602,26 +602,21 @@ decide_unroll_constant_iterations (struct loop *loop, int flags)
        }
     }
 
-  if (dump_file)
-    fprintf (dump_file, ";; max_unroll %d (%d copies, initial %d).\n",
-            best_unroll + 1, best_copies, nunroll);
-
   loop->lpt_decision.decision = LPT_UNROLL_CONSTANT;
   loop->lpt_decision.times = best_unroll;
 
   if (dump_file)
-    fprintf (dump_file,
-            ";; Decided to unroll the constant times rolling loop, %d times.\n",
-            loop->lpt_decision.times);
+    fprintf (dump_file, ";; Decided to unroll the loop %d times (%d copies).\n",
+            loop->lpt_decision.times, best_copies);
 }
 
-/* Unroll LOOP with constant number of iterations LOOP->LPT_DECISION.TIMES + 1
-   times.  The transformation does this:
+/* Unroll LOOP with constant number of iterations LOOP->LPT_DECISION.TIMES times.
+   The transformation does this:
 
    for (i = 0; i < 102; i++)
      body;
 
-   ==>
+   ==>  (LOOP->LPT_DECISION.TIMES == 3)
 
    i = 0;
    body; i++;
@@ -671,7 +666,7 @@ unroll_loop_constant_iterations (struct loop *loop)
         of exit condition have continuous body after unrolling.  */
 
       if (dump_file)
-       fprintf (dump_file, ";; Condition on beginning of loop.\n");
+       fprintf (dump_file, ";; Condition at beginning of loop.\n");
 
       /* Peel exit_mod iterations.  */
       RESET_BIT (wont_exit, 0);
@@ -713,7 +708,7 @@ unroll_loop_constant_iterations (struct loop *loop)
         the loop tests the condition at the end of loop body.  */
 
       if (dump_file)
-       fprintf (dump_file, ";; Condition on end of loop.\n");
+       fprintf (dump_file, ";; Condition at end of loop.\n");
 
       /* We know that niter >= max_unroll + 2; so we do not need to care of
         case when we would exit before reaching the loop.  So just peel
@@ -896,9 +891,7 @@ decide_unroll_runtime_iterations (struct loop *loop, int flags)
   loop->lpt_decision.times = i - 1;
 
   if (dump_file)
-    fprintf (dump_file,
-            ";; Decided to unroll the runtime computable "
-            "times rolling loop, %d times.\n",
+    fprintf (dump_file, ";; Decided to unroll the loop %d times.\n",
             loop->lpt_decision.times);
 }
 
@@ -949,14 +942,14 @@ split_edge_and_insert (edge e, rtx insns)
   return bb;
 }
 
-/* Unroll LOOP for that we are able to count number of iterations in runtime
-   LOOP->LPT_DECISION.TIMES + 1 times.  The transformation does this (with some
+/* Unroll LOOP for which we are able to count number of iterations in runtime
+   LOOP->LPT_DECISION.TIMES times.  The transformation does this (with some
    extra care for case n < 0):
 
    for (i = 0; i < n; i++)
      body;
 
-   ==>
+   ==>  (LOOP->LPT_DECISION.TIMES == 3)
 
    i = 0;
    mod = n % 4;
@@ -1314,20 +1307,23 @@ decide_peel_simple (struct loop *loop, int flags)
   loop->lpt_decision.times = npeel;
 
   if (dump_file)
-    fprintf (dump_file, ";; Decided to simply peel the loop, %d times.\n",
+    fprintf (dump_file, ";; Decided to simply peel the loop %d times.\n",
             loop->lpt_decision.times);
 }
 
-/* Peel a LOOP LOOP->LPT_DECISION.TIMES times.  The transformation:
+/* Peel a LOOP LOOP->LPT_DECISION.TIMES times.  The transformation does this:
+
    while (cond)
      body;
 
-   ==>
+   ==>  (LOOP->LPT_DECISION.TIMES == 3)
 
    if (!cond) goto end;
    body;
    if (!cond) goto end;
    body;
+   if (!cond) goto end;
+   body;
    while (cond)
      body;
    end: ;
@@ -1464,16 +1460,16 @@ decide_unroll_stupid (struct loop *loop, int flags)
   loop->lpt_decision.times = i - 1;
 
   if (dump_file)
-    fprintf (dump_file,
-            ";; Decided to unroll the loop stupidly, %d times.\n",
+    fprintf (dump_file, ";; Decided to unroll the loop stupidly %d times.\n",
             loop->lpt_decision.times);
 }
 
-/* Unroll a LOOP LOOP->LPT_DECISION.TIMES times.  The transformation:
+/* Unroll a LOOP LOOP->LPT_DECISION.TIMES times.  The transformation does this:
+
    while (cond)
      body;
 
-   ==>
+   ==>  (LOOP->LPT_DECISION.TIMES == 3)
 
    while (cond)
      {