tree-vrp.c (execute_vrp): Do not pass loops structure through arguments.

	* tree-vrp.c (execute_vrp): Do not pass loops structure through
	arguments.
	* loop-unswitch.c (unswitch_loops, unswitch_single_loop,
	unswitch_loop): Ditto.
	* tree-loop-linear.c (linear_transform_loops): Ditto.
	* tree-ssa-loop-im.c (determine_lsm, tree_ssa_lim_initialize,
	tree_ssa_lim): Ditto.
	* tree-ssa-loop-niter.c (estimate_numbers_of_iterations,
	free_numbers_of_iterations_estimates): Ditto.
	* tree-ssa-loop-unswitch.c (tree_ssa_unswitch_loops,
	tree_unswitch_single_loop, tree_unswitch_loop): Ditto.
	* cfgloopmanip.c (fix_bb_placement, fix_bb_placements,
	remove_path, add_loop, loopify, unloop, fix_loop_placements,
	place_new_loop, duplicate_loop, duplicate_subloops,
	update_single_exit_for_duplicated_loops, copy_loops_to,
	duplicate_loop_to_header_edge, create_preheaders,
	force_single_succ_latches, loop_version, fix_loop_structure):
	Ditto.
	* tree-ssa-loop-manip.c (tree_duplicate_loop_to_header_edge,
	tree_unroll_loop): Ditto.
	* tree-ssa-loop-ch.c (copy_loop_headers): Ditto.
	* tree-scalar-evolution.c (select_loops_exit_conditions,
	scev_initialize, scev_analysis): Ditto.
	* tree-scalar-evolution.h (scev_initialize): Ditto.
	* cfghooks.c (cfg_hook_duplicate_loop_to_header_edge): Ditto.
	* cfgloopanal.c (mark_irreducible_loops, mark_loop_exit_edges): Ditto.
	* tree-ssa-loop-ivopts.c (tree_ssa_iv_optimize): Ditto.
	* modulo-sched.c (sms_schedule): Ditto.
	* tree-ssa-dom.c (tree_ssa_dominator_optimize): Ditto.
	* loop-init.c (loop_optimizer_init, rtl_move_loop_invariants,
	rtl_unswitch, rtl_unroll_and_peel_loops, rtl_doloop): Ditto.
	* ifcvt.c (if_convert): Ditto.
	* tree-ssa-loop-ivcanon.c (try_unroll_loop_completely,
	canonicalize_loop_induction_variables,
	canonicalize_induction_variables,
	tree_unroll_loops_completely, remove_empty_loops): Ditto.
	* tree-ssa-loop.c (tree_ssa_loop_init, tree_ssa_loop_im,
	tree_ssa_loop_unswitch, tree_vectorize, tree_linear_transform,
	tree_ssa_loop_ivcanon, tree_ssa_empty_loop, tree_ssa_loop_bounds,
	tree_complete_unroll, tree_ssa_loop_prefetch, tree_ssa_loop_ivopts,
	tree_ssa_loop_done): Ditto.
	* predict.c (predict_loops, tree_estimate_probability, estimate_loops,
	estimate_bb_frequencies): Ditto.
	* tree-vectorizer.c (slpeel_tree_duplicate_loop_to_edge_cfg,
	slpeel_tree_peel_loop_to_edge, vectorize_loops): Ditto.
	* loop-unroll.c (unroll_and_peel_loops, peel_loops_completely,
	decide_unrolling_and_peeling, peel_loop_completely,
	unroll_loop_constant_iterations, unroll_loop_runtime_iterations,
	peel_loop_simple, unroll_loop_stupid): Ditto.
	* loop-doloop.c (doloop_optimize_loops): Ditto.
	* tree-cfgcleanup.c (cleanup_tree_cfg_loop): Ditto.
	* loop-invariant.c (move_loop_invariants): Ditto.
	* tree-ssa-dce.c (tree_ssa_dce_loop): Ditto.
	* tree-ssa-loop-prefetch.c (loop_prefetch_arrays,
	tree_ssa_prefetch_arrays): Ditto.
	* lambda-code.c (gcc_loopnest_to_lambda_loopnest, perfect_nestify):
	Ditto.
	* tree-vect-transform.c (vect_do_peeling_for_loop_bound,
	vect_do_peeling_for_alignment, vect_transform_loop): Ditto.
	* cfgloop.c (flow_loops_cfg_dump, flow_loops_dump,
	mark_single_exit_loops, cancel_loop, cancel_loop_tree,
	verify_loop_structure): Ditto.
	* tree-flow.h (vectorize_loops, tree_ssa_lim, tree_ssa_unswitch_loops,
	canonicalize_induction_variables, tree_unroll_loops_completely,
	tree_ssa_prefetch_arrays, remove_empty_loops, tree_ssa_iv_optimize,
	estimate_numbers_of_iterations, free_numbers_of_iterations_estimates,
	tree_duplicate_loop_to_header_edge, tree_ssa_loop_version,
	tree_unroll_loop, linear_transform_loops): Declaration changed.
	* basic-block.h: Remove declaration of struct loops.
	* cfghooks.h (struct cfg_hooks): Change type of
	cfg_hook_duplicate_loop_to_header_edge.
	(cfg_hook_duplicate_loop_to_header_edge): Declaration changed.
	* tree-vectorizer.h (slpeel_tree_peel_loop_to_edge,
	vect_transform_loop): Declaration changed.
	* lambda.h (gcc_loopnest_to_lambda_loopnest): Declaration changed.
	* cfgloop.h (flow_loops_dump, fix_loop_structure,
	mark_irreducible_loops, mark_single_exit_loops, mark_loop_exit_edges,
	cancel_loop_tree, create_preheaders, force_single_succ_latches,
	verify_loop_structure, duplicate_loop, duplicate_loop_to_header_edge,
	loopify, loop_version, remove_path, unswitch_loops,
	unroll_and_peel_loops, doloop_optimize_loops, move_loop_invariants):
	Declaration changed.

From-SVN: r119189

1 files changed, 45 insertions, 48 deletions

diff --git a/gcc/cfgloop.c b/gcc/cfgloop.c
index b168b97..5a58fb2 100644
--- a/gcc/cfgloop.c
+++ b/gcc/cfgloop.c
@@ -40,7 +40,7 @@ Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
 #define HEADER_BLOCK(B) (* (int *) (B)->aux)
 #define LATCH_EDGE(E) (*(int *) (E)->aux)
 
-static void flow_loops_cfg_dump (const struct loops *, FILE *);
+static void flow_loops_cfg_dump (FILE *);
 static void establish_preds (struct loop *);
 static void canonicalize_loop_headers (void);
 static bool glb_enum_p (basic_block, void *);
@@ -48,11 +48,11 @@ static bool glb_enum_p (basic_block, void *);
 /* Dump loop related CFG information.  */
 
 static void
-flow_loops_cfg_dump (const struct loops *loops, FILE *file)
+flow_loops_cfg_dump (FILE *file)
 {
   basic_block bb;
 
-  if (! loops->num || ! file)
+  if (!file)
     return;
 
   FOR_EACH_BB (bb)
@@ -122,24 +122,22 @@ flow_loop_dump (const struct loop *loop, FILE *file,
     loop_dump_aux (loop, file, verbose);
 }
 
-/* Dump the loop information specified by LOOPS to the stream FILE,
+/* Dump the loop information about loops to the stream FILE,
    using auxiliary dump callback function LOOP_DUMP_AUX if non null.  */
 
 void
-flow_loops_dump (const struct loops *loops, FILE *file, void (*loop_dump_aux) (const struct loop *, FILE *, int), int verbose)
+flow_loops_dump (FILE *file, void (*loop_dump_aux) (const struct loop *, FILE *, int), int verbose)
 {
-  int i;
-  int num_loops;
+  unsigned i;
 
-  num_loops = loops->num;
-  if (! num_loops || ! file)
+  if (!current_loops || ! file)
     return;
 
-  fprintf (file, ";; %d loops found\n", num_loops);
+  fprintf (file, ";; %d loops found\n", current_loops->num);
 
-  for (i = 0; i < num_loops; i++)
+  for (i = 0; i < current_loops->num; i++)
     {
-      struct loop *loop = loops->parray[i];
+      struct loop *loop = current_loops->parray[i];
 
       if (!loop)
 	continue;
@@ -148,7 +146,7 @@ flow_loops_dump (const struct loops *loops, FILE *file, void (*loop_dump_aux) (c
     }
 
   if (verbose)
-    flow_loops_cfg_dump (loops, file);
+    flow_loops_cfg_dump (file);
 }
 
 /* Free data allocated for LOOP.  */
@@ -236,20 +234,19 @@ flow_loop_nodes_find (basic_block header, struct loop *loop)
   return num_nodes;
 }
 
-/* For each loop in the lOOPS tree that has just a single exit
-   record the exit edge.  */
+/* For each loop that has just a single exit, record the exit edge.  */
 
 void
-mark_single_exit_loops (struct loops *loops)
+mark_single_exit_loops (void)
 {
   basic_block bb;
   edge e;
   struct loop *loop;
   unsigned i;
 
-  for (i = 1; i < loops->num; i++)
+  for (i = 1; i < current_loops->num; i++)
     {
-      loop = loops->parray[i];
+      loop = current_loops->parray[i];
       if (loop)
 	set_single_exit (loop, NULL);
     }
@@ -257,7 +254,7 @@ mark_single_exit_loops (struct loops *loops)
   FOR_EACH_BB (bb)
     {
       edge_iterator ei;
-      if (bb->loop_father == loops->tree_root)
+      if (bb->loop_father == current_loops->tree_root)
 	continue;
       FOR_EACH_EDGE (e, ei, bb->succs)
 	{
@@ -281,9 +278,9 @@ mark_single_exit_loops (struct loops *loops)
 	}
     }
 
-  for (i = 1; i < loops->num; i++)
+  for (i = 1; i < current_loops->num; i++)
     {
-      loop = loops->parray[i];
+      loop = current_loops->parray[i];
       if (!loop)
 	continue;
 
@@ -291,7 +288,7 @@ mark_single_exit_loops (struct loops *loops)
 	set_single_exit (loop, NULL);
     }
 
-  loops->state |= LOOPS_HAVE_MARKED_SINGLE_EXITS;
+  current_loops->state |= LOOPS_HAVE_MARKED_SINGLE_EXITS;
 }
 
 static void
@@ -930,7 +927,7 @@ find_common_loop (struct loop *loop_s, struct loop *loop_d)
 /* Cancels the LOOP; it must be innermost one.  */
 
 static void
-cancel_loop (struct loops *loops, struct loop *loop)
+cancel_loop (struct loop *loop)
 {
   basic_block *bbs;
   unsigned i;
@@ -946,7 +943,7 @@ cancel_loop (struct loops *loops, struct loop *loop)
   flow_loop_tree_node_remove (loop);
 
   /* Remove loop from loops array.  */
-  loops->parray[loop->num] = NULL;
+  current_loops->parray[loop->num] = NULL;
 
   /* Free loop data.  */
   flow_loop_free (loop);
@@ -954,14 +951,14 @@ cancel_loop (struct loops *loops, struct loop *loop)
 
 /* Cancels LOOP and all its subloops.  */
 void
-cancel_loop_tree (struct loops *loops, struct loop *loop)
+cancel_loop_tree (struct loop *loop)
 {
   while (loop->inner)
-    cancel_loop_tree (loops, loop->inner);
-  cancel_loop (loops, loop);
+    cancel_loop_tree (loop->inner);
+  cancel_loop (loop);
 }
 
-/* Checks that LOOPS are all right:
+/* Checks that information about loops is correct
      -- sizes of loops are all right
      -- results of get_loop_body really belong to the loop
      -- loop header have just single entry edge and single latch edge
@@ -969,7 +966,7 @@ cancel_loop_tree (struct loops *loops, struct loop *loop)
      -- irreducible loops are correctly marked
   */
 void
-verify_loop_structure (struct loops *loops)
+verify_loop_structure (void)
 {
   unsigned *sizes, i, j;
   sbitmap irreds;
@@ -979,30 +976,30 @@ verify_loop_structure (struct loops *loops)
   edge e;
 
   /* Check sizes.  */
-  sizes = XCNEWVEC (unsigned, loops->num);
+  sizes = XCNEWVEC (unsigned, current_loops->num);
   sizes[0] = 2;
 
   FOR_EACH_BB (bb)
     for (loop = bb->loop_father; loop; loop = loop->outer)
       sizes[loop->num]++;
 
-  for (i = 0; i < loops->num; i++)
+  for (i = 0; i < current_loops->num; i++)
     {
-      if (!loops->parray[i])
+      if (!current_loops->parray[i])
 	continue;
 
-      if (loops->parray[i]->num_nodes != sizes[i])
+      if (current_loops->parray[i]->num_nodes != sizes[i])
 	{
 	  error ("size of loop %d should be %d, not %d",
-		   i, sizes[i], loops->parray[i]->num_nodes);
+		   i, sizes[i], current_loops->parray[i]->num_nodes);
 	  err = 1;
 	}
     }
 
   /* Check get_loop_body.  */
-  for (i = 1; i < loops->num; i++)
+  for (i = 1; i < current_loops->num; i++)
     {
-      loop = loops->parray[i];
+      loop = current_loops->parray[i];
       if (!loop)
 	continue;
       bbs = get_loop_body (loop);
@@ -1018,19 +1015,19 @@ verify_loop_structure (struct loops *loops)
     }
 
   /* Check headers and latches.  */
-  for (i = 1; i < loops->num; i++)
+  for (i = 1; i < current_loops->num; i++)
     {
-      loop = loops->parray[i];
+      loop = current_loops->parray[i];
       if (!loop)
 	continue;
 
-      if ((loops->state & LOOPS_HAVE_PREHEADERS)
+      if ((current_loops->state & LOOPS_HAVE_PREHEADERS)
 	  && EDGE_COUNT (loop->header->preds) != 2)
 	{
 	  error ("loop %d's header does not have exactly 2 entries", i);
 	  err = 1;
 	}
-      if (loops->state & LOOPS_HAVE_SIMPLE_LATCHES)
+      if (current_loops->state & LOOPS_HAVE_SIMPLE_LATCHES)
 	{
 	  if (!single_succ_p (loop->latch))
 	    {
@@ -1053,7 +1050,7 @@ verify_loop_structure (struct loops *loops)
 	  error ("loop %d's header does not belong directly to it", i);
 	  err = 1;
 	}
-      if ((loops->state & LOOPS_HAVE_MARKED_IRREDUCIBLE_REGIONS)
+      if ((current_loops->state & LOOPS_HAVE_MARKED_IRREDUCIBLE_REGIONS)
 	  && (loop_latch_edge (loop)->flags & EDGE_IRREDUCIBLE_LOOP))
 	{
 	  error ("loop %d's latch is marked as part of irreducible region", i);
@@ -1062,7 +1059,7 @@ verify_loop_structure (struct loops *loops)
     }
 
   /* Check irreducible loops.  */
-  if (loops->state & LOOPS_HAVE_MARKED_IRREDUCIBLE_REGIONS)
+  if (current_loops->state & LOOPS_HAVE_MARKED_IRREDUCIBLE_REGIONS)
     {
       /* Record old info.  */
       irreds = sbitmap_alloc (last_basic_block);
@@ -1079,7 +1076,7 @@ verify_loop_structure (struct loops *loops)
 	}
 
       /* Recount it.  */
-      mark_irreducible_loops (loops);
+      mark_irreducible_loops ();
 
       /* Compare.  */
       FOR_EACH_BB (bb)
@@ -1121,13 +1118,13 @@ verify_loop_structure (struct loops *loops)
     }
 
   /* Check the single_exit.  */
-  if (loops->state & LOOPS_HAVE_MARKED_SINGLE_EXITS)
+  if (current_loops->state & LOOPS_HAVE_MARKED_SINGLE_EXITS)
     {
-      memset (sizes, 0, sizeof (unsigned) * loops->num);
+      memset (sizes, 0, sizeof (unsigned) * current_loops->num);
       FOR_EACH_BB (bb)
 	{
 	  edge_iterator ei;
-	  if (bb->loop_father == loops->tree_root)
+	  if (bb->loop_father == current_loops->tree_root)
 	    continue;
 	  FOR_EACH_EDGE (e, ei, bb->succs)
 	    {
@@ -1157,9 +1154,9 @@ verify_loop_structure (struct loops *loops)
 	    }
 	}
 
-      for (i = 1; i < loops->num; i++)
+      for (i = 1; i < current_loops->num; i++)
 	{
-	  loop = loops->parray[i];
+	  loop = current_loops->parray[i];
 	  if (!loop)
 	    continue;