Reorganize the gcc vendor import work area. This flattens out a bunch

of unnecessary path components that are relics of cvs2svn.

(These are directory moves)

1 files changed, 1301 insertions, 0 deletions

diff --git a/gcc/cfgloop.c b/gcc/cfgloop.c
new file mode 100644
index 0000000..9afd48b
--- /dev/null
+++ b/gcc/cfgloop.c
@@ -0,0 +1,1301 @@
+/* Natural loop discovery code for GNU compiler.
+   Copyright (C) 2000, 2001, 2003, 2004, 2005 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 later
+version.
+
+GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or
+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.  */
+
+#include "config.h"
+#include "system.h"
+#include "coretypes.h"
+#include "tm.h"
+#include "rtl.h"
+#include "hard-reg-set.h"
+#include "obstack.h"
+#include "function.h"
+#include "basic-block.h"
+#include "toplev.h"
+#include "cfgloop.h"
+#include "flags.h"
+#include "tree.h"
+#include "tree-flow.h"
+
+/* Ratio of frequencies of edges so that one of more latch edges is
+   considered to belong to inner loop with same header.  */
+#define HEAVY_EDGE_RATIO 8
+
+#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 int flow_loop_level_compute (struct loop *);
+static void flow_loops_level_compute (struct loops *);
+static void establish_preds (struct loop *);
+static void canonicalize_loop_headers (void);
+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)
+{
+  int i;
+  basic_block bb;
+
+  if (! loops->num || ! file)
+    return;
+
+  FOR_EACH_BB (bb)
+    {
+      edge succ;
+      edge_iterator ei;
+
+      fprintf (file, ";; %d succs { ", bb->index);
+      FOR_EACH_EDGE (succ, ei, bb->succs)
+	fprintf (file, "%d ", succ->dest->index);
+      fprintf (file, "}\n");
+    }
+
+  /* Dump the DFS node order.  */
+  if (loops->cfg.dfs_order)
+    {
+      fputs (";; DFS order: ", file);
+      for (i = NUM_FIXED_BLOCKS; i < n_basic_blocks; i++)
+	fprintf (file, "%d ", loops->cfg.dfs_order[i]);
+
+      fputs ("\n", file);
+    }
+
+  /* Dump the reverse completion node order.  */
+  if (loops->cfg.rc_order)
+    {
+      fputs (";; RC order: ", file);
+      for (i = NUM_FIXED_BLOCKS; i < n_basic_blocks; i++)
+	fprintf (file, "%d ", loops->cfg.rc_order[i]);
+
+      fputs ("\n", file);
+    }
+}
+
+/* Return nonzero if the nodes of LOOP are a subset of OUTER.  */
+
+bool
+flow_loop_nested_p (const struct loop *outer, const struct loop *loop)
+{
+  return (loop->depth > outer->depth
+	 && loop->pred[outer->depth] == outer);
+}
+
+/* Returns the loop such that LOOP is nested DEPTH (indexed from zero)
+   loops within LOOP.  */
+
+struct loop *
+superloop_at_depth (struct loop *loop, unsigned depth)
+{
+  gcc_assert (depth <= (unsigned) loop->depth);
+
+  if (depth == (unsigned) loop->depth)
+    return loop;
+
+  return loop->pred[depth];
+}
+
+/* Dump the loop information specified by LOOP to the stream FILE
+   using auxiliary dump callback function LOOP_DUMP_AUX if non null.  */
+
+void
+flow_loop_dump (const struct loop *loop, FILE *file,
+		void (*loop_dump_aux) (const struct loop *, FILE *, int),
+		int verbose)
+{
+  basic_block *bbs;
+  unsigned i;
+
+  if (! loop || ! loop->header)
+    return;
+
+  fprintf (file, ";;\n;; Loop %d\n", loop->num);
+
+  fprintf (file, ";;  header %d, latch %d\n",
+	   loop->header->index, loop->latch->index);
+  fprintf (file, ";;  depth %d, level %d, outer %ld\n",
+	   loop->depth, loop->level,
+	   (long) (loop->outer ? loop->outer->num : -1));
+
+  fprintf (file, ";;  nodes:");
+  bbs = get_loop_body (loop);
+  for (i = 0; i < loop->num_nodes; i++)
+    fprintf (file, " %d", bbs[i]->index);
+  free (bbs);
+  fprintf (file, "\n");
+
+  if (loop_dump_aux)
+    loop_dump_aux (loop, file, verbose);
+}
+
+/* Dump the loop information specified by 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)
+{
+  int i;
+  int num_loops;
+
+  num_loops = loops->num;
+  if (! num_loops || ! file)
+    return;
+
+  fprintf (file, ";; %d loops found\n", num_loops);
+
+  for (i = 0; i < num_loops; i++)
+    {
+      struct loop *loop = loops->parray[i];
+
+      if (!loop)
+	continue;
+
+      flow_loop_dump (loop, file, loop_dump_aux, verbose);
+    }
+
+  if (verbose)
+    flow_loops_cfg_dump (loops, file);
+}
+
+/* Free data allocated for LOOP.  */
+void
+flow_loop_free (struct loop *loop)
+{
+  if (loop->pred)
+    free (loop->pred);
+  free (loop);
+}
+
+/* Free all the memory allocated for LOOPS.  */
+
+void
+flow_loops_free (struct loops *loops)
+{
+  if (loops->parray)
+    {
+      unsigned i;
+
+      gcc_assert (loops->num);
+
+      /* Free the loop descriptors.  */
+      for (i = 0; i < loops->num; i++)
+	{
+	  struct loop *loop = loops->parray[i];
+
+	  if (!loop)
+	    continue;
+
+	  flow_loop_free (loop);
+	}
+
+      free (loops->parray);
+      loops->parray = NULL;
+
+      if (loops->cfg.dfs_order)
+	free (loops->cfg.dfs_order);
+      if (loops->cfg.rc_order)
+	free (loops->cfg.rc_order);
+
+    }
+}
+
+/* Find the nodes contained within the LOOP with header HEADER.
+   Return the number of nodes within the loop.  */
+
+int
+flow_loop_nodes_find (basic_block header, struct loop *loop)
+{
+  basic_block *stack;
+  int sp;
+  int num_nodes = 1;
+
+  header->loop_father = loop;
+  header->loop_depth = loop->depth;
+
+  if (loop->latch->loop_father != loop)
+    {
+      stack = XNEWVEC (basic_block, n_basic_blocks);
+      sp = 0;
+      num_nodes++;
+      stack[sp++] = loop->latch;
+      loop->latch->loop_father = loop;
+      loop->latch->loop_depth = loop->depth;
+
+      while (sp)
+	{
+	  basic_block node;
+	  edge e;
+	  edge_iterator ei;
+
+	  node = stack[--sp];
+
+	  FOR_EACH_EDGE (e, ei, node->preds)
+	    {
+	      basic_block ancestor = e->src;
+
+	      if (ancestor != ENTRY_BLOCK_PTR
+		  && ancestor->loop_father != loop)
+		{
+		  ancestor->loop_father = loop;
+		  ancestor->loop_depth = loop->depth;
+		  num_nodes++;
+		  stack[sp++] = ancestor;
+		}
+	    }
+	}
+      free (stack);
+    }
+  return num_nodes;
+}
+
+/* For each loop in the lOOPS tree that has just a single exit
+   record the exit edge.  */
+
+void
+mark_single_exit_loops (struct loops *loops)
+{
+  basic_block bb;
+  edge e;
+  struct loop *loop;
+  unsigned i;
+
+  for (i = 1; i < loops->num; i++)
+    {
+      loop = loops->parray[i];
+      if (loop)
+	loop->single_exit = NULL;
+    }
+
+  FOR_EACH_BB (bb)
+    {
+      edge_iterator ei;
+      if (bb->loop_father == loops->tree_root)
+	continue;
+      FOR_EACH_EDGE (e, ei, bb->succs)
+	{
+	  if (e->dest == EXIT_BLOCK_PTR)
+	    continue;
+
+	  if (flow_bb_inside_loop_p (bb->loop_father, e->dest))
+	    continue;
+
+	  for (loop = bb->loop_father;
+	       loop != e->dest->loop_father;
+	       loop = loop->outer)
+	    {
+	      /* If we have already seen an exit, mark this by the edge that
+		 surely does not occur as any exit.  */
+	      if (loop->single_exit)
+		loop->single_exit = single_succ_edge (ENTRY_BLOCK_PTR);
+	      else
+		loop->single_exit = e;
+	    }
+	}
+    }
+
+  for (i = 1; i < loops->num; i++)
+    {
+      loop = loops->parray[i];
+      if (!loop)
+	continue;
+
+      if (loop->single_exit == single_succ_edge (ENTRY_BLOCK_PTR))
+	loop->single_exit = NULL;
+    }
+
+  loops->state |= LOOPS_HAVE_MARKED_SINGLE_EXITS;
+}
+
+static void
+establish_preds (struct loop *loop)
+{
+  struct loop *ploop, *father = loop->outer;
+
+  loop->depth = father->depth + 1;
+
+  /* Remember the current loop depth if it is the largest seen so far.  */
+  cfun->max_loop_depth = MAX (cfun->max_loop_depth, loop->depth);
+
+  if (loop->pred)
+    free (loop->pred);
+  loop->pred = XNEWVEC (struct loop *, loop->depth);
+  memcpy (loop->pred, father->pred, sizeof (struct loop *) * father->depth);
+  loop->pred[father->depth] = father;
+
+  for (ploop = loop->inner; ploop; ploop = ploop->next)
+    establish_preds (ploop);
+}
+
+/* Add LOOP to the loop hierarchy tree where FATHER is father of the
+   added loop.  If LOOP has some children, take care of that their
+   pred field will be initialized correctly.  */
+
+void
+flow_loop_tree_node_add (struct loop *father, struct loop *loop)
+{
+  loop->next = father->inner;
+  father->inner = loop;
+  loop->outer = father;
+
+  establish_preds (loop);
+}
+
+/* Remove LOOP from the loop hierarchy tree.  */
+
+void
+flow_loop_tree_node_remove (struct loop *loop)
+{
+  struct loop *prev, *father;
+
+  father = loop->outer;
+  loop->outer = NULL;
+
+  /* Remove loop from the list of sons.  */
+  if (father->inner == loop)
+    father->inner = loop->next;
+  else
+    {
+      for (prev = father->inner; prev->next != loop; prev = prev->next);
+      prev->next = loop->next;
+    }
+
+  loop->depth = -1;
+  free (loop->pred);
+  loop->pred = NULL;
+}
+
+/* Helper function to compute loop nesting depth and enclosed loop level
+   for the natural loop specified by LOOP.  Returns the loop level.  */
+
+static int
+flow_loop_level_compute (struct loop *loop)
+{
+  struct loop *inner;
+  int level = 1;
+
+  if (! loop)
+    return 0;
+
+  /* Traverse loop tree assigning depth and computing level as the
+     maximum level of all the inner loops of this loop.  The loop
+     level is equivalent to the height of the loop in the loop tree
+     and corresponds to the number of enclosed loop levels (including
+     itself).  */
+  for (inner = loop->inner; inner; inner = inner->next)
+    {
+      int ilevel = flow_loop_level_compute (inner) + 1;
+
+      if (ilevel > level)
+	level = ilevel;
+    }
+
+  loop->level = level;
+  return level;
+}
+
+/* Compute the loop nesting depth and enclosed loop level for the loop
+   hierarchy tree specified by LOOPS.  Return the maximum enclosed loop
+   level.  */
+
+static void
+flow_loops_level_compute (struct loops *loops)
+{
+  flow_loop_level_compute (loops->tree_root);
+}
+
+/* A callback to update latch and header info for basic block JUMP created
+   by redirecting an edge.  */
+
+static void
+update_latch_info (basic_block jump)
+{
+  alloc_aux_for_block (jump, sizeof (int));
+  HEADER_BLOCK (jump) = 0;
+  alloc_aux_for_edge (single_pred_edge (jump), sizeof (int));
+  LATCH_EDGE (single_pred_edge (jump)) = 0;
+  set_immediate_dominator (CDI_DOMINATORS, jump, single_pred (jump));
+}
+
+/* A callback for make_forwarder block, to redirect all edges except for
+   MFB_KJ_EDGE to the entry part.  E is the edge for that we should decide
+   whether to redirect it.  */
+
+static edge mfb_kj_edge;
+static bool
+mfb_keep_just (edge e)
+{
+  return e != mfb_kj_edge;
+}
+
+/* A callback for make_forwarder block, to redirect the latch edges into an
+   entry part.  E is the edge for that we should decide whether to redirect
+   it.  */
+
+static bool
+mfb_keep_nonlatch (edge e)
+{
+  return LATCH_EDGE (e);
+}
+
+/* Takes care of merging natural loops with shared headers.  */
+
+static void
+canonicalize_loop_headers (void)
+{
+  basic_block header;
+  edge e;
+
+  alloc_aux_for_blocks (sizeof (int));
+  alloc_aux_for_edges (sizeof (int));
+
+  /* Split blocks so that each loop has only single latch.  */
+  FOR_EACH_BB (header)
+    {
+      edge_iterator ei;
+      int num_latches = 0;
+      int have_abnormal_edge = 0;
+
+      FOR_EACH_EDGE (e, ei, header->preds)
+	{
+	  basic_block latch = e->src;
+
+	  if (e->flags & EDGE_ABNORMAL)
+	    have_abnormal_edge = 1;
+
+	  if (latch != ENTRY_BLOCK_PTR
+	      && dominated_by_p (CDI_DOMINATORS, latch, header))
+	    {
+	      num_latches++;
+	      LATCH_EDGE (e) = 1;
+	    }
+	}
+      if (have_abnormal_edge)
+	HEADER_BLOCK (header) = 0;
+      else
+	HEADER_BLOCK (header) = num_latches;
+    }
+
+  if (HEADER_BLOCK (single_succ (ENTRY_BLOCK_PTR)))
+    {
+      basic_block bb;
+
+      /* We could not redirect edges freely here. On the other hand,
+	 we can simply split the edge from entry block.  */
+      bb = split_edge (single_succ_edge (ENTRY_BLOCK_PTR));
+
+      alloc_aux_for_edge (single_succ_edge (bb), sizeof (int));
+      LATCH_EDGE (single_succ_edge (bb)) = 0;
+      alloc_aux_for_block (bb, sizeof (int));
+      HEADER_BLOCK (bb) = 0;
+    }
+
+  FOR_EACH_BB (header)
+    {
+      int max_freq, is_heavy;
+      edge heavy, tmp_edge;
+      edge_iterator ei;
+
+      if (HEADER_BLOCK (header) <= 1)
+	continue;
+
+      /* Find a heavy edge.  */
+      is_heavy = 1;
+      heavy = NULL;
+      max_freq = 0;
+      FOR_EACH_EDGE (e, ei, header->preds)
+	if (LATCH_EDGE (e) &&
+	    EDGE_FREQUENCY (e) > max_freq)
+	  max_freq = EDGE_FREQUENCY (e);
+      FOR_EACH_EDGE (e, ei, header->preds)
+	if (LATCH_EDGE (e) &&
+	    EDGE_FREQUENCY (e) >= max_freq / HEAVY_EDGE_RATIO)
+	  {
+	    if (heavy)
+	      {
+		is_heavy = 0;
+		break;
+	      }
+	    else
+	      heavy = e;
+	  }
+
+      if (is_heavy)
+	{
+	  /* Split out the heavy edge, and create inner loop for it.  */
+	  mfb_kj_edge = heavy;
+	  tmp_edge = make_forwarder_block (header, mfb_keep_just,
+					   update_latch_info);
+	  alloc_aux_for_block (tmp_edge->dest, sizeof (int));
+	  HEADER_BLOCK (tmp_edge->dest) = 1;
+	  alloc_aux_for_edge (tmp_edge, sizeof (int));
+	  LATCH_EDGE (tmp_edge) = 0;
+	  HEADER_BLOCK (header)--;
+	}
+
+      if (HEADER_BLOCK (header) > 1)
+	{
+	  /* Create a new latch block.  */
+	  tmp_edge = make_forwarder_block (header, mfb_keep_nonlatch,
+					   update_latch_info);
+	  alloc_aux_for_block (tmp_edge->dest, sizeof (int));
+	  HEADER_BLOCK (tmp_edge->src) = 0;
+	  HEADER_BLOCK (tmp_edge->dest) = 1;
+	  alloc_aux_for_edge (tmp_edge, sizeof (int));
+	  LATCH_EDGE (tmp_edge) = 1;
+	}
+    }
+
+  free_aux_for_blocks ();
+  free_aux_for_edges ();
+
+#ifdef ENABLE_CHECKING
+  verify_dominators (CDI_DOMINATORS);
+#endif
+}
+
+/* Initialize all the parallel_p fields of the loops structure to true.  */
+
+static void
+initialize_loops_parallel_p (struct loops *loops)
+{
+  unsigned int i;
+
+  for (i = 0; i < loops->num; i++)
+    {
+      struct loop *loop = loops->parray[i];
+      loop->parallel_p = true;
+    }
+}
+
+/* Find all the natural loops in the function and save in LOOPS structure and
+   recalculate loop_depth information in basic block structures.
+   Return the number of natural loops found.  */
+
+int
+flow_loops_find (struct loops *loops)
+{
+  int b;
+  int num_loops;
+  edge e;
+  sbitmap headers;
+  int *dfs_order;
+  int *rc_order;
+  basic_block header;
+  basic_block bb;
+
+  memset (loops, 0, sizeof *loops);
+
+  /* We are going to recount the maximum loop depth,
+     so throw away the last count.  */
+  cfun->max_loop_depth = 0;
+
+  /* Taking care of this degenerate case makes the rest of
+     this code simpler.  */
+  if (n_basic_blocks == NUM_FIXED_BLOCKS)
+    return 0;
+
+  dfs_order = NULL;
+  rc_order = NULL;
+
+  /* Ensure that the dominators are computed.  */
+  calculate_dominance_info (CDI_DOMINATORS);
+
+  /* Join loops with shared headers.  */
+  canonicalize_loop_headers ();
+
+  /* Count the number of loop headers.  This should be the
+     same as the number of natural loops.  */
+  headers = sbitmap_alloc (last_basic_block);
+  sbitmap_zero (headers);
+
+  num_loops = 0;
+  FOR_EACH_BB (header)
+    {
+      edge_iterator ei;
+      int more_latches = 0;
+
+      header->loop_depth = 0;
+
+      /* If we have an abnormal predecessor, do not consider the
+	 loop (not worth the problems).  */
+      FOR_EACH_EDGE (e, ei, header->preds)
+	if (e->flags & EDGE_ABNORMAL)
+	  break;
+      if (e)
+	continue;
+
+      FOR_EACH_EDGE (e, ei, header->preds)
+	{
+	  basic_block latch = e->src;
+
+	  gcc_assert (!(e->flags & EDGE_ABNORMAL));
+
+	  /* Look for back edges where a predecessor is dominated
+	     by this block.  A natural loop has a single entry
+	     node (header) that dominates all the nodes in the
+	     loop.  It also has single back edge to the header
+	     from a latch node.  */
+	  if (latch != ENTRY_BLOCK_PTR
+	      && dominated_by_p (CDI_DOMINATORS, latch, header))
+	    {
+	      /* Shared headers should be eliminated by now.  */
+	      gcc_assert (!more_latches);
+	      more_latches = 1;
+	      SET_BIT (headers, header->index);
+	      num_loops++;
+	    }
+	}
+    }
+
+  /* Allocate loop structures.  */
+  loops->parray = XCNEWVEC (struct loop *, num_loops + 1);
+
+  /* Dummy loop containing whole function.  */
+  loops->parray[0] = XCNEW (struct loop);
+  loops->parray[0]->next = NULL;
+  loops->parray[0]->inner = NULL;
+  loops->parray[0]->outer = NULL;
+  loops->parray[0]->depth = 0;
+  loops->parray[0]->pred = NULL;
+  loops->parray[0]->num_nodes = n_basic_blocks;
+  loops->parray[0]->latch = EXIT_BLOCK_PTR;
+  loops->parray[0]->header = ENTRY_BLOCK_PTR;
+  ENTRY_BLOCK_PTR->loop_father = loops->parray[0];
+  EXIT_BLOCK_PTR->loop_father = loops->parray[0];
+
+  loops->tree_root = loops->parray[0];
+
+  /* Find and record information about all the natural loops
+     in the CFG.  */
+  loops->num = 1;
+  FOR_EACH_BB (bb)
+    bb->loop_father = loops->tree_root;
+
+  if (num_loops)
+    {
+      /* Compute depth first search order of the CFG so that outer
+	 natural loops will be found before inner natural loops.  */
+      dfs_order = XNEWVEC (int, n_basic_blocks);
+      rc_order = XNEWVEC (int, n_basic_blocks);
+      pre_and_rev_post_order_compute (dfs_order, rc_order, false);
+
+      /* Save CFG derived information to avoid recomputing it.  */
+      loops->cfg.dfs_order = dfs_order;
+      loops->cfg.rc_order = rc_order;
+
+      num_loops = 1;
+
+      for (b = 0; b < n_basic_blocks - NUM_FIXED_BLOCKS; b++)
+	{
+	  struct loop *loop;
+	  edge_iterator ei;
+
+	  /* Search the nodes of the CFG in reverse completion order
+	     so that we can find outer loops first.  */
+	  if (!TEST_BIT (headers, rc_order[b]))
+	    continue;
+
+	  header = BASIC_BLOCK (rc_order[b]);
+
+	  loop = loops->parray[num_loops] = XCNEW (struct loop);
+
+	  loop->header = header;
+	  loop->num = num_loops;
+	  num_loops++;
+
+	  /* Look for the latch for this header block.  */
+	  FOR_EACH_EDGE (e, ei, header->preds)
+	    {
+	      basic_block latch = e->src;
+
+	      if (latch != ENTRY_BLOCK_PTR
+		  && dominated_by_p (CDI_DOMINATORS, latch, header))
+		{
+		  loop->latch = latch;
+		  break;
+		}
+	    }
+
+	  flow_loop_tree_node_add (header->loop_father, loop);
+	  loop->num_nodes = flow_loop_nodes_find (loop->header, loop);
+	}
+
+      /* Assign the loop nesting depth and enclosed loop level for each
+	 loop.  */
+      flow_loops_level_compute (loops);
+
+      loops->num = num_loops;
+      initialize_loops_parallel_p (loops);
+    }
+
+  sbitmap_free (headers);
+
+  loops->state = 0;
+#ifdef ENABLE_CHECKING
+  verify_flow_info ();
+  verify_loop_structure (loops);
+#endif
+
+  return loops->num;
+}
+
+/* Return nonzero if basic block BB belongs to LOOP.  */
+bool
+flow_bb_inside_loop_p (const struct loop *loop, const basic_block bb)
+{
+  struct loop *source_loop;
+
+  if (bb == ENTRY_BLOCK_PTR || bb == EXIT_BLOCK_PTR)
+    return 0;
+
+  source_loop = bb->loop_father;
+  return loop == source_loop || flow_loop_nested_p (loop, source_loop);
+}
+
+/* Enumeration predicate for get_loop_body.  */
+static bool
+glb_enum_p (basic_block bb, void *glb_header)
+{
+  return bb != (basic_block) glb_header;
+}
+
+/* Gets basic blocks of a LOOP.  Header is the 0-th block, rest is in dfs
+   order against direction of edges from latch.  Specially, if
+   header != latch, latch is the 1-st block.  */
+basic_block *
+get_loop_body (const struct loop *loop)
+{
+  basic_block *tovisit, bb;
+  unsigned tv = 0;
+
+  gcc_assert (loop->num_nodes);
+
+  tovisit = XCNEWVEC (basic_block, loop->num_nodes);
+  tovisit[tv++] = loop->header;
+
+  if (loop->latch == EXIT_BLOCK_PTR)
+    {
+      /* There may be blocks unreachable from EXIT_BLOCK.  */
+      gcc_assert (loop->num_nodes == (unsigned) n_basic_blocks);
+      FOR_EACH_BB (bb)
+	tovisit[tv++] = bb;
+      tovisit[tv++] = EXIT_BLOCK_PTR;
+    }
+  else if (loop->latch != loop->header)
+    {
+      tv = dfs_enumerate_from (loop->latch, 1, glb_enum_p,
+			       tovisit + 1, loop->num_nodes - 1,
+			       loop->header) + 1;
+    }
+
+  gcc_assert (tv == loop->num_nodes);
+  return tovisit;
+}
+
+/* Fills dominance descendants inside LOOP of the basic block BB into
+   array TOVISIT from index *TV.  */
+
+static void
+fill_sons_in_loop (const struct loop *loop, basic_block bb,
+		   basic_block *tovisit, int *tv)
+{
+  basic_block son, postpone = NULL;
+
+  tovisit[(*tv)++] = bb;
+  for (son = first_dom_son (CDI_DOMINATORS, bb);
+       son;
+       son = next_dom_son (CDI_DOMINATORS, son))
+    {
+      if (!flow_bb_inside_loop_p (loop, son))
+	continue;
+
+      if (dominated_by_p (CDI_DOMINATORS, loop->latch, son))
+	{
+	  postpone = son;
+	  continue;
+	}
+      fill_sons_in_loop (loop, son, tovisit, tv);
+    }
+
+  if (postpone)
+    fill_sons_in_loop (loop, postpone, tovisit, tv);
+}
+
+/* Gets body of a LOOP (that must be different from the outermost loop)
+   sorted by dominance relation.  Additionally, if a basic block s dominates
+   the latch, then only blocks dominated by s are be after it.  */
+
+basic_block *
+get_loop_body_in_dom_order (const struct loop *loop)
+{
+  basic_block *tovisit;
+  int tv;
+
+  gcc_assert (loop->num_nodes);
+
+  tovisit = XCNEWVEC (basic_block, loop->num_nodes);
+
+  gcc_assert (loop->latch != EXIT_BLOCK_PTR);
+
+  tv = 0;
+  fill_sons_in_loop (loop, loop->header, tovisit, &tv);
+
+  gcc_assert (tv == (int) loop->num_nodes);
+
+  return tovisit;
+}
+
+/* Get body of a LOOP in breadth first sort order.  */
+
+basic_block *
+get_loop_body_in_bfs_order (const struct loop *loop)
+{
+  basic_block *blocks;
+  basic_block bb;
+  bitmap visited;
+  unsigned int i = 0;
+  unsigned int vc = 1;
+
+  gcc_assert (loop->num_nodes);
+  gcc_assert (loop->latch != EXIT_BLOCK_PTR);
+
+  blocks = XCNEWVEC (basic_block, loop->num_nodes);
+  visited = BITMAP_ALLOC (NULL);
+
+  bb = loop->header;
+  while (i < loop->num_nodes)
+    {
+      edge e;
+      edge_iterator ei;
+
+      if (!bitmap_bit_p (visited, bb->index))
+	{
+	  /* This basic block is now visited */
+	  bitmap_set_bit (visited, bb->index);
+	  blocks[i++] = bb;
+	}
+
+      FOR_EACH_EDGE (e, ei, bb->succs)
+	{
+	  if (flow_bb_inside_loop_p (loop, e->dest))
+	    {
+	      if (!bitmap_bit_p (visited, e->dest->index))
+		{
+		  bitmap_set_bit (visited, e->dest->index);
+		  blocks[i++] = e->dest;
+		}
+	    }
+	}
+
+      gcc_assert (i >= vc);
+
+      bb = blocks[vc++];
+    }
+
+  BITMAP_FREE (visited);
+  return blocks;
+}
+
+/* Gets exit edges of a LOOP, returning their number in N_EDGES.  */
+edge *
+get_loop_exit_edges (const struct loop *loop, unsigned int *num_edges)
+{
+  edge *edges, e;
+  unsigned i, n;
+  basic_block * body;
+  edge_iterator ei;
+
+  gcc_assert (loop->latch != EXIT_BLOCK_PTR);
+
+  body = get_loop_body (loop);
+  n = 0;
+  for (i = 0; i < loop->num_nodes; i++)
+    FOR_EACH_EDGE (e, ei, body[i]->succs)
+      if (!flow_bb_inside_loop_p (loop, e->dest))
+	n++;
+  edges = XNEWVEC (edge, n);
+  *num_edges = n;
+  n = 0;
+  for (i = 0; i < loop->num_nodes; i++)
+    FOR_EACH_EDGE (e, ei, body[i]->succs)
+      if (!flow_bb_inside_loop_p (loop, e->dest))
+	edges[n++] = e;
+  free (body);
+
+  return edges;
+}
+
+/* Counts the number of conditional branches inside LOOP.  */
+
+unsigned
+num_loop_branches (const struct loop *loop)
+{
+  unsigned i, n;
+  basic_block * body;
+
+  gcc_assert (loop->latch != EXIT_BLOCK_PTR);
+
+  body = get_loop_body (loop);
+  n = 0;
+  for (i = 0; i < loop->num_nodes; i++)
+    if (EDGE_COUNT (body[i]->succs) >= 2)
+      n++;
+  free (body);
+
+  return n;
+}
+
+/* Adds basic block BB to LOOP.  */
+void
+add_bb_to_loop (basic_block bb, struct loop *loop)
+{
+   int i;
+
+   bb->loop_father = loop;
+   bb->loop_depth = loop->depth;
+   loop->num_nodes++;
+   for (i = 0; i < loop->depth; i++)
+     loop->pred[i]->num_nodes++;
+ }
+
+/* Remove basic block BB from loops.  */
+void
+remove_bb_from_loops (basic_block bb)
+{
+   int i;
+   struct loop *loop = bb->loop_father;
+
+   loop->num_nodes--;
+   for (i = 0; i < loop->depth; i++)
+     loop->pred[i]->num_nodes--;
+   bb->loop_father = NULL;
+   bb->loop_depth = 0;
+}
+
+/* Finds nearest common ancestor in loop tree for given loops.  */
+struct loop *
+find_common_loop (struct loop *loop_s, struct loop *loop_d)
+{
+  if (!loop_s) return loop_d;
+  if (!loop_d) return loop_s;
+
+  if (loop_s->depth < loop_d->depth)
+    loop_d = loop_d->pred[loop_s->depth];
+  else if (loop_s->depth > loop_d->depth)
+    loop_s = loop_s->pred[loop_d->depth];
+
+  while (loop_s != loop_d)
+    {
+      loop_s = loop_s->outer;
+      loop_d = loop_d->outer;
+    }
+  return loop_s;
+}
+
+/* Cancels the LOOP; it must be innermost one.  */
+
+static void
+cancel_loop (struct loops *loops, struct loop *loop)
+{
+  basic_block *bbs;
+  unsigned i;
+
+  gcc_assert (!loop->inner);
+
+  /* Move blocks up one level (they should be removed as soon as possible).  */
+  bbs = get_loop_body (loop);
+  for (i = 0; i < loop->num_nodes; i++)
+    bbs[i]->loop_father = loop->outer;
+
+  /* Remove the loop from structure.  */
+  flow_loop_tree_node_remove (loop);
+
+  /* Remove loop from loops array.  */
+  loops->parray[loop->num] = NULL;
+
+  /* Free loop data.  */
+  flow_loop_free (loop);
+}
+
+/* Cancels LOOP and all its subloops.  */
+void
+cancel_loop_tree (struct loops *loops, struct loop *loop)
+{
+  while (loop->inner)
+    cancel_loop_tree (loops, loop->inner);
+  cancel_loop (loops, loop);
+}
+
+/* Checks that LOOPS are all right:
+     -- 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
+     -- loop latches have only single successor that is header of their loop
+     -- irreducible loops are correctly marked
+  */
+void
+verify_loop_structure (struct loops *loops)
+{
+  unsigned *sizes, i, j;
+  sbitmap irreds;
+  basic_block *bbs, bb;
+  struct loop *loop;
+  int err = 0;
+  edge e;
+
+  /* Check sizes.  */
+  sizes = XCNEWVEC (unsigned, 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++)
+    {
+      if (!loops->parray[i])
+	continue;
+
+      if (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);
+	  err = 1;
+	}
+    }
+
+  /* Check get_loop_body.  */
+  for (i = 1; i < loops->num; i++)
+    {
+      loop = loops->parray[i];
+      if (!loop)
+	continue;
+      bbs = get_loop_body (loop);
+
+      for (j = 0; j < loop->num_nodes; j++)
+	if (!flow_bb_inside_loop_p (loop, bbs[j]))
+	  {
+	    error ("bb %d do not belong to loop %d",
+		    bbs[j]->index, i);
+	    err = 1;
+	  }
+      free (bbs);
+    }
+
+  /* Check headers and latches.  */
+  for (i = 1; i < loops->num; i++)
+    {
+      loop = loops->parray[i];
+      if (!loop)
+	continue;
+
+      if ((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 (!single_succ_p (loop->latch))
+	    {
+	      error ("loop %d's latch does not have exactly 1 successor", i);
+	      err = 1;
+	    }
+	  if (single_succ (loop->latch) != loop->header)
+	    {
+	      error ("loop %d's latch does not have header as successor", i);
+	      err = 1;
+	    }
+	  if (loop->latch->loop_father != loop)
+	    {
+	      error ("loop %d's latch does not belong directly to it", i);
+	      err = 1;
+	    }
+	}
+      if (loop->header->loop_father != loop)
+	{
+	  error ("loop %d's header does not belong directly to it", i);
+	  err = 1;
+	}
+      if ((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);
+	  err = 1;
+	}
+    }
+
+  /* Check irreducible loops.  */
+  if (loops->state & LOOPS_HAVE_MARKED_IRREDUCIBLE_REGIONS)
+    {
+      /* Record old info.  */
+      irreds = sbitmap_alloc (last_basic_block);
+      FOR_EACH_BB (bb)
+	{
+	  edge_iterator ei;
+	  if (bb->flags & BB_IRREDUCIBLE_LOOP)
+	    SET_BIT (irreds, bb->index);
+	  else
+	    RESET_BIT (irreds, bb->index);
+	  FOR_EACH_EDGE (e, ei, bb->succs)
+	    if (e->flags & EDGE_IRREDUCIBLE_LOOP)
+	      e->flags |= EDGE_ALL_FLAGS + 1;
+	}
+
+      /* Recount it.  */
+      mark_irreducible_loops (loops);
+
+      /* Compare.  */
+      FOR_EACH_BB (bb)
+	{
+	  edge_iterator ei;
+
+	  if ((bb->flags & BB_IRREDUCIBLE_LOOP)
+	      && !TEST_BIT (irreds, bb->index))
+	    {
+	      error ("basic block %d should be marked irreducible", bb->index);
+	      err = 1;
+	    }
+	  else if (!(bb->flags & BB_IRREDUCIBLE_LOOP)
+	      && TEST_BIT (irreds, bb->index))
+	    {
+	      error ("basic block %d should not be marked irreducible", bb->index);
+	      err = 1;
+	    }
+	  FOR_EACH_EDGE (e, ei, bb->succs)
+	    {
+	      if ((e->flags & EDGE_IRREDUCIBLE_LOOP)
+		  && !(e->flags & (EDGE_ALL_FLAGS + 1)))
+		{
+		  error ("edge from %d to %d should be marked irreducible",
+			 e->src->index, e->dest->index);
+		  err = 1;
+		}
+	      else if (!(e->flags & EDGE_IRREDUCIBLE_LOOP)
+		       && (e->flags & (EDGE_ALL_FLAGS + 1)))
+		{
+		  error ("edge from %d to %d should not be marked irreducible",
+			 e->src->index, e->dest->index);
+		  err = 1;
+		}
+	      e->flags &= ~(EDGE_ALL_FLAGS + 1);
+	    }
+	}
+      free (irreds);
+    }
+
+  /* Check the single_exit.  */
+  if (loops->state & LOOPS_HAVE_MARKED_SINGLE_EXITS)
+    {
+      memset (sizes, 0, sizeof (unsigned) * loops->num);
+      FOR_EACH_BB (bb)
+	{
+	  edge_iterator ei;
+	  if (bb->loop_father == loops->tree_root)
+	    continue;
+	  FOR_EACH_EDGE (e, ei, bb->succs)
+	    {
+	      if (e->dest == EXIT_BLOCK_PTR)
+		continue;
+
+	      if (flow_bb_inside_loop_p (bb->loop_father, e->dest))
+		continue;
+
+	      for (loop = bb->loop_father;
+		   loop != e->dest->loop_father;
+		   loop = loop->outer)
+		{
+		  sizes[loop->num]++;
+		  if (loop->single_exit
+		      && loop->single_exit != e)
+		    {
+		      error ("wrong single exit %d->%d recorded for loop %d",
+			     loop->single_exit->src->index,
+			     loop->single_exit->dest->index,
+			     loop->num);
+		      error ("right exit is %d->%d",
+			     e->src->index, e->dest->index);
+		      err = 1;
+		    }
+		}
+	    }
+	}
+
+      for (i = 1; i < loops->num; i++)
+	{
+	  loop = loops->parray[i];
+	  if (!loop)
+	    continue;
+
+	  if (sizes[i] == 1
+	      && !loop->single_exit)
+	    {
+	      error ("single exit not recorded for loop %d", loop->num);
+	      err = 1;
+	    }
+
+	  if (sizes[i] != 1
+	      && loop->single_exit)
+	    {
+	      error ("loop %d should not have single exit (%d -> %d)",
+		     loop->num,
+		     loop->single_exit->src->index,
+		     loop->single_exit->dest->index);
+	      err = 1;
+	    }
+	}
+    }
+
+  gcc_assert (!err);
+
+  free (sizes);
+}
+
+/* Returns latch edge of LOOP.  */
+edge
+loop_latch_edge (const struct loop *loop)
+{
+  return find_edge (loop->latch, loop->header);
+}
+
+/* Returns preheader edge of LOOP.  */
+edge
+loop_preheader_edge (const struct loop *loop)
+{
+  edge e;
+  edge_iterator ei;
+
+  FOR_EACH_EDGE (e, ei, loop->header->preds)
+    if (e->src != loop->latch)
+      break;
+
+  return e;
+}
+
+/* Returns true if E is an exit of LOOP.  */
+
+bool
+loop_exit_edge_p (const struct loop *loop, edge e)
+{
+  return (flow_bb_inside_loop_p (loop, e->src)
+	  && !flow_bb_inside_loop_p (loop, e->dest));
+}