* trans.c (convert_with_check): Update call to real_2expN.

[pf3gnuchains/gcc-fork.git] / gcc / tree-ssa-loop-ivcanon.c

diff --git a/gcc/tree-ssa-loop-ivcanon.c b/gcc/tree-ssa-loop-ivcanon.c
index 7dcb0da..60fc2ce 100644 (file)
--- a/gcc/tree-ssa-loop-ivcanon.c
+++ b/gcc/tree-ssa-loop-ivcanon.c
@@ -1,11 +1,11 @@
 /* Induction variable canonicalization.
-   Copyright (C) 2004, 2005 Free Software Foundation, Inc.
+   Copyright (C) 2004, 2005, 2007 Free Software Foundation, Inc.
    
 This file is part of GCC.
    
 GCC is free software; you can redistribute it and/or modify it
 under the terms of the GNU General Public License as published by the
-Free Software Foundation; either version 2, or (at your option) any
+Free Software Foundation; either version 3, or (at your option) any
 later version.
    
 GCC is distributed in the hope that it will be useful, but WITHOUT
@@ -14,9 +14,8 @@ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 for more details.
    
 You should have received a copy of the GNU General Public License
-along with GCC; see the file COPYING.  If not, write to the Free
-Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
-02110-1301, USA.  */
+along with GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */
 
 /* This pass detects the loops that iterate a constant number of times,
    adds a canonical induction variable (step -1, tested against 0) 
@@ -111,10 +110,10 @@ create_canonical_iv (struct loop *loop, edge exit, tree niter)
   update_stmt (cond);
 }
 
-/* Computes an estimated number of insns in LOOP.  */
+/* Computes an estimated number of insns in LOOP, weighted by WEIGHTS.  */
 
 unsigned
-tree_num_loop_insns (struct loop *loop)
+tree_num_loop_insns (struct loop *loop, eni_weights *weights)
 {
   basic_block *body = get_loop_body (loop);
   block_stmt_iterator bsi;
@@ -122,7 +121,7 @@ tree_num_loop_insns (struct loop *loop)
 
   for (i = 0; i < loop->num_nodes; i++)
     for (bsi = bsi_start (body[i]); !bsi_end_p (bsi); bsi_next (&bsi))
-      size += estimate_num_insns (bsi_stmt (bsi));
+      size += estimate_num_insns (bsi_stmt (bsi), weights);
   free (body);
 
   return size;
@@ -182,7 +181,7 @@ try_unroll_loop_completely (struct loop *loop,
       if (ul == UL_SINGLE_ITER)
        return false;
 
-      ninsns = tree_num_loop_insns (loop);
+      ninsns = tree_num_loop_insns (loop, &eni_size_weights);
 
       if (n_unroll * ninsns
          > (unsigned) PARAM_VALUE (PARAM_MAX_COMPLETELY_PEELED_INSNS))
@@ -223,8 +222,6 @@ try_unroll_loop_completely (struct loop *loop,
   if (n_unroll)
     {
       sbitmap wont_exit;
-      edge *edges_to_remove = XNEWVEC (edge, n_unroll);
-      unsigned int n_to_remove = 0;
 
       old_cond = COND_EXPR_COND (cond);
       COND_EXPR_COND (cond) = dont_exit;
@@ -237,8 +234,7 @@ try_unroll_loop_completely (struct loop *loop,
 
       if (!tree_duplicate_loop_to_header_edge (loop, loop_preheader_edge (loop),
                                               n_unroll, wont_exit,
-                                              exit, edges_to_remove,
-                                              &n_to_remove,
+                                              exit, NULL,
                                               DLTHE_FLAG_UPDATE_FREQ
                                               | DLTHE_FLAG_COMPLETTE_PEEL))
        {
@@ -246,11 +242,9 @@ try_unroll_loop_completely (struct loop *loop,
          update_stmt (cond);
           free_original_copy_tables ();
          free (wont_exit);
-         free (edges_to_remove);
          return false;
        }
       free (wont_exit);
-      free (edges_to_remove);
       free_original_copy_tables ();
     }
   
@@ -279,18 +273,12 @@ canonicalize_loop_induction_variables (struct loop *loop,
   edge exit = NULL;
   tree niter;
 
-  niter = number_of_iterations_in_loop (loop);
+  niter = number_of_latch_executions (loop);
   if (TREE_CODE (niter) == INTEGER_CST)
     {
       exit = single_exit (loop);
       if (!just_once_each_iteration_p (loop, exit->src))
        return false;
-
-      /* The result of number_of_iterations_in_loop is by one higher than
-        we expect (i.e. it returns number of executions of the exit
-        condition, not of the loop latch edge).  */
-      niter = fold_build2 (MINUS_EXPR, TREE_TYPE (niter), niter,
-                          build_int_cst (TREE_TYPE (niter), 1));
     }
   else
     {
@@ -332,18 +320,15 @@ canonicalize_loop_induction_variables (struct loop *loop,
 unsigned int
 canonicalize_induction_variables (void)
 {
-  unsigned i;
+  loop_iterator li;
   struct loop *loop;
   bool changed = false;
   
-  for (i = 1; i < current_loops->num; i++)
+  FOR_EACH_LOOP (li, loop, 0)
     {
-      loop = current_loops->parray[i];
-
-      if (loop)
-       changed |= canonicalize_loop_induction_variables (loop,
-                                                         true, UL_SINGLE_ITER,
-                                                         true);
+      changed |= canonicalize_loop_induction_variables (loop,
+                                                       true, UL_SINGLE_ITER,
+                                                       true);
     }
 
   /* Clean up the information about numbers of iterations, since brute force
@@ -362,18 +347,13 @@ canonicalize_induction_variables (void)
 unsigned int
 tree_unroll_loops_completely (bool may_increase_size)
 {
-  unsigned i;
+  loop_iterator li;
   struct loop *loop;
   bool changed = false;
   enum unroll_level ul;
 
-  for (i = 1; i < current_loops->num; i++)
+  FOR_EACH_LOOP (li, loop, 0)
     {
-      loop = current_loops->parray[i];
-
-      if (!loop)
-       continue;
-
       if (may_increase_size && maybe_hot_bb_p (loop->header))
        ul = UL_ALL;
       else
@@ -499,6 +479,9 @@ remove_empty_loop (struct loop *loop)
   unsigned n_before, freq_in, freq_h;
   gcov_type exit_count = exit->count;
 
+  if (dump_file)
+    fprintf (dump_file, "Removing empty loop %d\n", loop->num);
+
   non_exit = EDGE_SUCC (exit->src, 0);
   if (non_exit == exit)
     non_exit = EDGE_SUCC (exit->src, 1);