/* Natural loop discovery code for GNU compiler.
- Copyright (C) 2000, 2001, 2003, 2004 Free Software Foundation, Inc.
+ Copyright (C) 2000, 2001, 2003, 2004, 2005 Free Software Foundation, Inc.
This file is part of GCC.
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, 59 Temple Place - Suite 330, Boston, MA
-02111-1307, USA. */
+Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301, USA. */
#include "config.h"
#include "system.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"
#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_loop_entry_edges_find (struct loop *);
-static void flow_loop_exit_edges_find (struct loop *);
-static int flow_loop_nodes_find (basic_block, struct loop *);
-static void flow_loop_pre_header_scan (struct loop *);
-static basic_block flow_loop_pre_header_find (basic_block);
-static int flow_loop_level_compute (struct loop *);
-static void flow_loops_level_compute (struct loops *);
+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 *);
/* Dump loop related CFG information. */
static void
-flow_loops_cfg_dump (const struct loops *loops, FILE *file)
+flow_loops_cfg_dump (FILE *file)
{
- int i;
basic_block bb;
- if (! loops->num || ! file)
+ if (!file)
return;
FOR_EACH_BB (bb)
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 = 0; 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 = 0; 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. */
if (! loop || ! loop->header)
return;
- fprintf (file, ";;\n;; Loop %d:%s\n", loop->num,
- loop->invalid ? " invalid" : "");
-
- fprintf (file, ";; header %d, latch %d, pre-header %d\n",
- loop->header->index, loop->latch->index,
- loop->pre_header ? loop->pre_header->index : -1);
- fprintf (file, ";; depth %d, level %d, outer %ld\n",
- loop->depth, loop->level,
- (long) (loop->outer ? loop->outer->num : -1));
+ fprintf (file, ";;\n;; Loop %d\n", loop->num);
- if (loop->pre_header_edges)
- flow_edge_list_print (";; pre-header edges", loop->pre_header_edges,
- loop->num_pre_header_edges, file);
+ fprintf (file, ";; header %d, latch %d\n",
+ loop->header->index, loop->latch->index);
+ fprintf (file, ";; depth %d, outer %ld\n",
+ loop->depth, (long) (loop->outer ? loop->outer->num : -1));
- flow_edge_list_print (";; entry edges", loop->entry_edges,
- loop->num_entries, file);
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");
- flow_edge_list_print (";; exit edges", loop->exit_edges,
- loop->num_exits, file);
if (loop_dump_aux)
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;
}
if (verbose)
- flow_loops_cfg_dump (loops, file);
+ flow_loops_cfg_dump (file);
}
/* Free data allocated for LOOP. */
void
flow_loop_free (struct loop *loop)
{
- if (loop->pre_header_edges)
- free (loop->pre_header_edges);
- if (loop->entry_edges)
- free (loop->entry_edges);
- if (loop->exit_edges)
- free (loop->exit_edges);
if (loop->pred)
free (loop->pred);
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 entry edges into the LOOP. */
-
-static void
-flow_loop_entry_edges_find (struct loop *loop)
-{
- edge e;
- edge_iterator ei;
- int num_entries;
-
- num_entries = 0;
- FOR_EACH_EDGE (e, ei, loop->header->preds)
- {
- if (flow_loop_outside_edge_p (loop, e))
- num_entries++;
- }
-
- gcc_assert (num_entries);
-
- loop->entry_edges = xmalloc (num_entries * sizeof (edge *));
-
- num_entries = 0;
- FOR_EACH_EDGE (e, ei, loop->header->preds)
- {
- if (flow_loop_outside_edge_p (loop, e))
- loop->entry_edges[num_entries++] = e;
- }
-
- loop->num_entries = num_entries;
-}
-
-/* Find the exit edges from the LOOP. */
-
-static void
-flow_loop_exit_edges_find (struct loop *loop)
-{
- edge e;
- basic_block node, *bbs;
- unsigned num_exits, i;
-
- loop->exit_edges = NULL;
- loop->num_exits = 0;
-
- /* Check all nodes within the loop to see if there are any
- successors not in the loop. Note that a node may have multiple
- exiting edges. */
- num_exits = 0;
- bbs = get_loop_body (loop);
- for (i = 0; i < loop->num_nodes; i++)
- {
- edge_iterator ei;
- node = bbs[i];
- FOR_EACH_EDGE (e, ei, node->succs)
- {
- basic_block dest = e->dest;
-
- if (!flow_bb_inside_loop_p (loop, dest))
- num_exits++;
- }
- }
-
- if (! num_exits)
- {
- free (bbs);
- return;
}
-
- loop->exit_edges = xmalloc (num_exits * sizeof (edge *));
-
- /* Store all exiting edges into an array. */
- num_exits = 0;
- for (i = 0; i < loop->num_nodes; i++)
- {
- edge_iterator ei;
- node = bbs[i];
- FOR_EACH_EDGE (e, ei, node->succs)
- {
- basic_block dest = e->dest;
-
- if (!flow_bb_inside_loop_p (loop, dest))
- {
- e->flags |= EDGE_LOOP_EXIT;
- loop->exit_edges[num_exits++] = e;
- }
- }
- }
- free (bbs);
- loop->num_exits = num_exits;
}
/* Find the nodes contained within the LOOP with header HEADER.
Return the number of nodes within the loop. */
-static int
+int
flow_loop_nodes_find (basic_block header, struct loop *loop)
{
basic_block *stack;
if (loop->latch->loop_father != loop)
{
- stack = xmalloc (n_basic_blocks * sizeof (basic_block));
+ stack = XNEWVEC (basic_block, n_basic_blocks);
sp = 0;
num_nodes++;
stack[sp++] = loop->latch;
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)
- loop->single_exit = NULL;
+ set_single_exit (loop, NULL);
}
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)
{
{
/* 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 = EDGE_SUCC (ENTRY_BLOCK_PTR, 0);
+ if (single_exit (loop))
+ set_single_exit (loop, single_succ_edge (ENTRY_BLOCK_PTR));
else
- loop->single_exit = e;
+ set_single_exit (loop, e);
}
}
}
- 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 (loop->single_exit == EDGE_SUCC (ENTRY_BLOCK_PTR, 0))
- loop->single_exit = NULL;
- }
-
- loops->state |= LOOPS_HAVE_MARKED_SINGLE_EXITS;
-}
-
-/* Find the root node of the loop pre-header extended basic block and
- the edges along the trace from the root node to the loop header. */
-
-static void
-flow_loop_pre_header_scan (struct loop *loop)
-{
- int num;
- basic_block ebb;
- edge e;
-
- loop->num_pre_header_edges = 0;
- if (loop->num_entries != 1)
- return;
-
- ebb = loop->entry_edges[0]->src;
- if (ebb == ENTRY_BLOCK_PTR)
- return;
-
- /* Count number of edges along trace from loop header to
- root of pre-header extended basic block. Usually this is
- only one or two edges. */
- for (num = 1;
- EDGE_PRED (ebb, 0)->src != ENTRY_BLOCK_PTR && EDGE_COUNT (ebb->preds) == 1;
- num++)
- ebb = EDGE_PRED (ebb, 0)->src;
-
- loop->pre_header_edges = xmalloc (num * sizeof (edge));
- loop->num_pre_header_edges = num;
-
- /* Store edges in order that they are followed. The source of the first edge
- is the root node of the pre-header extended basic block and the
- destination of the last last edge is the loop header. */
- for (e = loop->entry_edges[0]; num; e = EDGE_PRED (e->src, 0))
- loop->pre_header_edges[--num] = e;
-}
-
-/* Return the block for the pre-header of the loop with header
- HEADER. Return NULL if there is no pre-header. */
-
-static basic_block
-flow_loop_pre_header_find (basic_block header)
-{
- basic_block pre_header;
- edge e;
- edge_iterator ei;
-
- /* If block p is a predecessor of the header and is the only block
- that the header does not dominate, then it is the pre-header. */
- pre_header = NULL;
- FOR_EACH_EDGE (e, ei, header->preds)
- {
- basic_block node = e->src;
-
- if (node != ENTRY_BLOCK_PTR
- && ! dominated_by_p (CDI_DOMINATORS, node, header))
- {
- if (pre_header == NULL)
- pre_header = node;
- else
- {
- /* There are multiple edges into the header from outside
- the loop so there is no pre-header block. */
- pre_header = NULL;
- break;
- }
- }
+ if (single_exit (loop) == single_succ_edge (ENTRY_BLOCK_PTR))
+ set_single_exit (loop, NULL);
}
- return pre_header;
+ current_loops->state |= LOOPS_HAVE_MARKED_SINGLE_EXITS;
}
static void
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 = xmalloc (sizeof (struct loop *) * loop->depth);
+ loop->pred = XNEWVEC (struct loop *, loop->depth);
memcpy (loop->pred, father->pred, sizeof (struct loop *) * father->depth);
loop->pred[father->depth] = father;
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);
-}
-
-/* Scan a single natural loop specified by LOOP collecting information
- about it specified by FLAGS. */
-
-int
-flow_loop_scan (struct loop *loop, int flags)
-{
- if (flags & LOOP_ENTRY_EDGES)
- {
- /* Find edges which enter the loop header.
- Note that the entry edges should only
- enter the header of a natural loop. */
- flow_loop_entry_edges_find (loop);
- }
-
- if (flags & LOOP_EXIT_EDGES)
- {
- /* Find edges which exit the loop. */
- flow_loop_exit_edges_find (loop);
- }
-
- if (flags & LOOP_PRE_HEADER)
- {
- /* Look to see if the loop has a pre-header node. */
- loop->pre_header = flow_loop_pre_header_find (loop->header);
-
- /* Find the blocks within the extended basic block of
- the loop pre-header. */
- flow_loop_pre_header_scan (loop);
- }
-
- return 1;
-}
-
/* A callback to update latch and header info for basic block JUMP created
by redirecting an edge. */
{
alloc_aux_for_block (jump, sizeof (int));
HEADER_BLOCK (jump) = 0;
- alloc_aux_for_edge (EDGE_PRED (jump, 0), sizeof (int));
- LATCH_EDGE (EDGE_PRED (jump, 0)) = 0;
- set_immediate_dominator (CDI_DOMINATORS, jump, EDGE_PRED (jump, 0)->src);
+ 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
HEADER_BLOCK (header) = num_latches;
}
- if (HEADER_BLOCK (EDGE_SUCC (ENTRY_BLOCK_PTR, 0)->dest))
+ 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 (EDGE_SUCC (ENTRY_BLOCK_PTR, 0));
+ bb = split_edge (single_succ_edge (ENTRY_BLOCK_PTR));
- alloc_aux_for_edge (EDGE_SUCC (bb, 0), sizeof (int));
- LATCH_EDGE (EDGE_SUCC (bb, 0)) = 0;
+ 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;
}
}
/* Find all the natural loops in the function and save in LOOPS structure and
- recalculate loop_depth information in basic block structures. FLAGS
- controls which loop information is collected. Return the number of natural
- loops found. */
+ recalculate loop_depth information in basic block structures.
+ Return the number of natural loops found. */
int
-flow_loops_find (struct loops *loops, int flags)
+flow_loops_find (struct loops *loops)
{
- int i;
int b;
int num_loops;
edge e;
basic_block header;
basic_block bb;
- /* This function cannot be repeatedly called with different
- flags to build up the loop information. The loop tree
- must always be built if this function is called. */
- gcc_assert (flags & LOOP_TREE);
-
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 == 0)
+ if (n_basic_blocks == NUM_FIXED_BLOCKS)
return 0;
dfs_order = NULL;
}
/* Allocate loop structures. */
- loops->parray = xcalloc (num_loops + 1, sizeof (struct loop *));
+ loops->parray = XCNEWVEC (struct loop *, num_loops + 1);
/* Dummy loop containing whole function. */
- loops->parray[0] = xcalloc (1, sizeof (struct loop));
+ 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 + 2;
+ 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];
{
/* Compute depth first search order of the CFG so that outer
natural loops will be found before inner natural loops. */
- dfs_order = xmalloc (n_basic_blocks * sizeof (int));
- rc_order = xmalloc (n_basic_blocks * sizeof (int));
- flow_depth_first_order_compute (dfs_order, rc_order);
-
- /* Save CFG derived information to avoid recomputing it. */
- loops->cfg.dfs_order = dfs_order;
- loops->cfg.rc_order = rc_order;
+ 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);
num_loops = 1;
- for (b = 0; b < n_basic_blocks; b++)
+ for (b = 0; b < n_basic_blocks - NUM_FIXED_BLOCKS; b++)
{
struct loop *loop;
edge_iterator ei;
header = BASIC_BLOCK (rc_order[b]);
- loop = loops->parray[num_loops] = xcalloc (1, sizeof (struct loop));
+ loop = loops->parray[num_loops] = XCNEW (struct loop);
loop->header = header;
loop->num = num_loops;
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);
-
- /* Scan the loops. */
- for (i = 1; i < num_loops; i++)
- flow_loop_scan (loops->parray[i], flags);
-
loops->num = num_loops;
initialize_loops_parallel_p (loops);
+
+ free (dfs_order);
+ free (rc_order);
}
sbitmap_free (headers);
loops->state = 0;
-#ifdef ENABLE_CHECKING
- verify_flow_info ();
- verify_loop_structure (loops);
-#endif
-
return loops->num;
}
return loop == source_loop || flow_loop_nested_p (loop, source_loop);
}
-/* Return nonzero if edge E enters header of LOOP from outside of LOOP. */
-
-bool
-flow_loop_outside_edge_p (const struct loop *loop, edge e)
-{
- gcc_assert (e->dest == loop->header);
- return !flow_bb_inside_loop_p (loop, e->src);
-}
-
/* Enumeration predicate for get_loop_body. */
static bool
glb_enum_p (basic_block bb, void *glb_header)
gcc_assert (loop->num_nodes);
- tovisit = xcalloc (loop->num_nodes, sizeof (basic_block));
+ 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 + 2);
+ gcc_assert (loop->num_nodes == (unsigned) n_basic_blocks);
FOR_EACH_BB (bb)
tovisit[tv++] = bb;
tovisit[tv++] = EXIT_BLOCK_PTR;
gcc_assert (loop->num_nodes);
- tovisit = xcalloc (loop->num_nodes, sizeof (basic_block));
+ tovisit = XCNEWVEC (basic_block, loop->num_nodes);
gcc_assert (loop->latch != EXIT_BLOCK_PTR);
gcc_assert (loop->num_nodes);
gcc_assert (loop->latch != EXIT_BLOCK_PTR);
- blocks = xcalloc (loop->num_nodes, sizeof (basic_block));
- visited = BITMAP_XMALLOC ();
+ 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;
- }
-
+ {
+ /* 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;
- }
- }
- }
-
+ {
+ 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_XFREE (visited);
+
+ 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 *n_edges)
+/* Returns the list of the exit edges of a LOOP. */
+
+VEC (edge, heap) *
+get_loop_exit_edges (const struct loop *loop)
{
- edge *edges, e;
- unsigned i, n;
- basic_block * body;
+ VEC (edge, heap) *edges = NULL;
+ edge e;
+ unsigned i;
+ 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 = xmalloc (n * sizeof (edge));
- *n_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;
+ VEC_safe_push (edge, heap, edges, e);
free (body);
return edges;
{
int i;
+ gcc_assert (bb->loop_father == NULL);
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
int i;
struct loop *loop = bb->loop_father;
+ gcc_assert (loop != NULL);
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 *
}
/* Cancels the LOOP; it must be innermost one. */
-void
-cancel_loop (struct loops *loops, struct loop *loop)
+
+static void
+cancel_loop (struct loop *loop)
{
basic_block *bbs;
unsigned i;
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);
/* 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
-- irreducible loops are correctly marked
*/
void
-verify_loop_structure (struct loops *loops)
+verify_loop_structure (void)
{
unsigned *sizes, i, j;
sbitmap irreds;
edge e;
/* Check sizes. */
- sizes = xcalloc (loops->num, sizeof (int));
+ 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])
- continue;
+ 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);
+ error ("size of loop %d should be %d, not %d",
+ 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);
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.",
+ error ("bb %d do not belong to loop %d",
bbs[j]->index, i);
err = 1;
}
}
/* 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);
+ 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 (EDGE_COUNT (loop->latch->succs) != 1)
+ if (!single_succ_p (loop->latch))
{
- error ("Loop %d's latch does not have exactly 1 successor.", i);
+ error ("loop %d's latch does not have exactly 1 successor", i);
err = 1;
}
- if (EDGE_SUCC (loop->latch, 0)->dest != loop->header)
+ if (single_succ (loop->latch) != loop->header)
{
- error ("Loop %d's latch does not have header as successor.", i);
+ 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);
+ 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);
+ 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);
+ 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)
+ if (current_loops->state & LOOPS_HAVE_MARKED_IRREDUCIBLE_REGIONS)
{
/* Record old info. */
irreds = sbitmap_alloc (last_basic_block);
}
/* Recount it. */
- mark_irreducible_loops (loops);
+ mark_irreducible_loops ();
/* Compare. */
FOR_EACH_BB (bb)
if ((bb->flags & BB_IRREDUCIBLE_LOOP)
&& !TEST_BIT (irreds, bb->index))
{
- error ("Basic block %d should be marked irreducible.", 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);
+ 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.",
+ 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.",
+ error ("edge from %d to %d should not be marked irreducible",
e->src->index, e->dest->index);
err = 1;
}
}
/* 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)
{
loop = loop->outer)
{
sizes[loop->num]++;
- if (loop->single_exit
- && loop->single_exit != e)
+ if (single_exit (loop)
+ && single_exit (loop) != e)
{
- error ("Wrong single exit %d->%d recorded for loop %d.",
- loop->single_exit->src->index,
- loop->single_exit->dest->index,
+ error ("wrong single exit %d->%d recorded for loop %d",
+ single_exit (loop)->src->index,
+ single_exit (loop)->dest->index,
loop->num);
- error ("Right exit is %d->%d.",
+ error ("right exit is %d->%d",
e->src->index, e->dest->index);
err = 1;
}
}
}
- 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 (sizes[i] == 1
- && !loop->single_exit)
+ && !single_exit (loop))
{
- error ("Single exit not recorded for loop %d.", loop->num);
+ error ("single exit not recorded for loop %d", loop->num);
err = 1;
}
if (sizes[i] != 1
- && loop->single_exit)
+ && single_exit (loop))
{
- error ("Loop %d should not have single exit (%d -> %d).",
+ error ("loop %d should not have single exit (%d -> %d)",
loop->num,
- loop->single_exit->src->index,
- loop->single_exit->dest->index);
+ single_exit (loop)->src->index,
+ single_exit (loop)->dest->index);
err = 1;
}
}
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));
+}
+
+/* Returns the single exit edge of LOOP, or NULL if LOOP has either no exit
+ or more than one exit. */
+
+edge
+single_exit (const struct loop *loop)
+{
+ return loop->single_exit_;
+}
+
+/* Records E as a single exit edge of LOOP. */
+
+void
+set_single_exit (struct loop *loop, edge e)
+{
+ loop->single_exit_ = e;
+}