tree.h (enum tree_code_class): Add tcc_vl_exp.

[gcc.git] / gcc / cfgloopanal.c

diff --git a/gcc/cfgloopanal.c b/gcc/cfgloopanal.c
index da545838436856559e48139f8471dd2976b655f3..5a9189787eae1727a0eac86b7e49dc5a23cdeda0 100644 (file)
--- a/gcc/cfgloopanal.c
+++ b/gcc/cfgloopanal.c
@@ -266,17 +266,19 @@ free_graph (struct graph *g)
 #define BB_REPR(BB) ((BB)->index + 1)
 
 void
-mark_irreducible_loops (struct loops *loops)
+mark_irreducible_loops (void)
 {
   basic_block act;
   edge e;
   edge_iterator ei;
   int i, src, dest;
   struct graph *g;
-  int *queue1 = XNEWVEC (int, last_basic_block + loops->num);
-  int *queue2 = XNEWVEC (int, last_basic_block + loops->num);
+  int num = current_loops ? number_of_loops () : 1;
+  int *queue1 = XNEWVEC (int, last_basic_block + num);
+  int *queue2 = XNEWVEC (int, last_basic_block + num);
   int nq, depth;
-  struct loop *cloop;
+  struct loop *cloop, *loop;
+  loop_iterator li;
 
   /* Reset the flags.  */
   FOR_BB_BETWEEN (act, ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR, next_bb)
@@ -287,7 +289,7 @@ mark_irreducible_loops (struct loops *loops)
     }
 
   /* Create the edge lists.  */
-  g = new_graph (last_basic_block + loops->num);
+  g = new_graph (last_basic_block + num);
 
   FOR_BB_BETWEEN (act, ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR, next_bb)
     FOR_EACH_EDGE (e, ei, act->succs)
@@ -296,35 +298,38 @@ mark_irreducible_loops (struct loops *loops)
        if (e->dest == EXIT_BLOCK_PTR)
          continue;
 
-       /* And latch edges.  */
-       if (e->dest->loop_father->header == e->dest
-           && e->dest->loop_father->latch == act)
-         continue;
+       src = BB_REPR (act);
+       dest = BB_REPR (e->dest);
 
-       /* Edges inside a single loop should be left where they are.  Edges
-          to subloop headers should lead to representative of the subloop,
-          but from the same place.
+       if (current_loops)
+         {
+           /* Ignore latch edges.  */
+           if (e->dest->loop_father->header == e->dest
+               && e->dest->loop_father->latch == act)
+             continue;
 
-          Edges exiting loops should lead from representative
-          of the son of nearest common ancestor of the loops in that
-          act lays.  */
+           /* Edges inside a single loop should be left where they are.  Edges
+              to subloop headers should lead to representative of the subloop,
+              but from the same place.
 
-       src = BB_REPR (act);
-       dest = BB_REPR (e->dest);
+              Edges exiting loops should lead from representative
+              of the son of nearest common ancestor of the loops in that
+              act lays.  */
 
-       if (e->dest->loop_father->header == e->dest)
-         dest = LOOP_REPR (e->dest->loop_father);
+           if (e->dest->loop_father->header == e->dest)
+             dest = LOOP_REPR (e->dest->loop_father);
 
-       if (!flow_bb_inside_loop_p (act->loop_father, e->dest))
-         {
-           depth = find_common_loop (act->loop_father,
-                                     e->dest->loop_father)->depth + 1;
-           if (depth == act->loop_father->depth)
-             cloop = act->loop_father;
-           else
-             cloop = act->loop_father->pred[depth];
-
-           src = LOOP_REPR (cloop);
+           if (!flow_bb_inside_loop_p (act->loop_father, e->dest))
+             {
+               depth = find_common_loop (act->loop_father,
+                                         e->dest->loop_father)->depth + 1;
+               if (depth == act->loop_father->depth)
+                 cloop = act->loop_father;
+               else
+                 cloop = act->loop_father->pred[depth];
+
+               src = LOOP_REPR (cloop);
+             }
          }
 
        add_edge (g, src, dest, e);
@@ -339,9 +344,14 @@ mark_irreducible_loops (struct loops *loops)
     {
       queue1[nq++] = BB_REPR (act);
     }
-  for (i = 1; i < (int) loops->num; i++)
-    if (loops->parray[i])
-      queue1[nq++] = LOOP_REPR (loops->parray[i]);
+
+  if (current_loops)
+    {
+      FOR_EACH_LOOP (li, loop, 0)
+       {
+         queue1[nq++] = LOOP_REPR (loop);
+       }
+    }
   dfs (g, queue1, nq, queue2, false);
   for (i = 0; i < nq; i++)
     queue1[i] = queue2[nq - i - 1];
@@ -354,7 +364,8 @@ mark_irreducible_loops (struct loops *loops)
   free (queue1);
   free (queue2);
 
-  loops->state |= LOOPS_HAVE_MARKED_IRREDUCIBLE_REGIONS;
+  if (current_loops)
+    current_loops->state |= LOOPS_HAVE_MARKED_IRREDUCIBLE_REGIONS;
 }
 
 /* Counts number of insns inside LOOP.  */
@@ -567,15 +578,15 @@ global_cost_for_size (unsigned size, unsigned regs_used, unsigned n_uses)
   return cost;
 }
 
-/* Sets EDGE_LOOP_EXIT flag for all exits of LOOPS.  */
+/* Sets EDGE_LOOP_EXIT flag for all loop exits.  */
 
 void
-mark_loop_exit_edges (struct loops *loops)
+mark_loop_exit_edges (void)
 {
   basic_block bb;
   edge e;
 
-  if (loops->num <= 1)
+  if (!current_loops)
     return;
 
   FOR_EACH_BB (bb)