/* Loop unswitching for GNU compiler.
- Copyright (C) 2002 Free Software Foundation, Inc.
+ Copyright (C) 2002, 2003 Free Software Foundation, Inc.
This file is part of GCC.
#include "expr.h"
/* This pass moves constant conditions out of loops, duplicating the loop
- in progres, i.e. this code:
+ in progress, i.e. this code:
while (loop_cond)
{
containing subloops would not be very large compared to complications
with handling this case. */
-static struct loop *unswitch_loop PARAMS ((struct loops *,
- struct loop *, basic_block));
-static void unswitch_single_loop PARAMS ((struct loops *, struct loop *,
- rtx, int));
-static bool may_unswitch_on_p PARAMS ((struct loops *, basic_block,
- struct loop *, basic_block *));
-static rtx reversed_condition PARAMS ((rtx));
+static struct loop *unswitch_loop (struct loops *, struct loop *,
+ basic_block);
+static void unswitch_single_loop (struct loops *, struct loop *, rtx, int);
+static bool may_unswitch_on_p (struct loops *, basic_block, struct loop *,
+ basic_block *);
+static rtx reversed_condition (rtx);
/* Main entry point. Perform loop unswitching on all suitable LOOPS. */
void
-unswitch_loops (loops)
- struct loops *loops;
+unswitch_loops (struct loops *loops)
{
int i, num;
struct loop *loop;
/* Go through inner loops (only original ones). */
num = loops->num;
-
+
for (i = 1; i < num; i++)
{
/* Removed loop? */
basic blocks (for what it means see comments below). List of basic blocks
inside LOOP is provided in BODY to save time. */
static bool
-may_unswitch_on_p (loops, bb, loop, body)
- struct loops *loops;
- basic_block bb;
- struct loop *loop;
- basic_block *body;
+may_unswitch_on_p (struct loops *loops, basic_block bb, struct loop *loop,
+ basic_block *body)
{
rtx test;
unsigned i;
/* Reverses CONDition; returns NULL if we cannot. */
static rtx
-reversed_condition (cond)
- rtx cond;
+reversed_condition (rtx cond)
{
enum rtx_code reversed;
reversed = reversed_comparison_code (cond, NULL);
number of unswitchings done; do not allow it to grow too much, it is too
easy to create example on that the code would grow exponentially. */
static void
-unswitch_single_loop (loops, loop, cond_checked, num)
- struct loops *loops;
- struct loop *loop;
- rtx cond_checked;
- int num;
+unswitch_single_loop (struct loops *loops, struct loop *loop,
+ rtx cond_checked, int num)
{
basic_block *bbs, bb;
struct loop *nloop;
fprintf (rtl_dump_file, ";; Not unswitching, not innermost loop\n");
return;
}
-
+
/* We must be able to duplicate loop body. */
if (!can_duplicate_loop_p (loop))
{
fprintf (rtl_dump_file, ";; Not unswitching, loop too big\n");
return;
}
-
+
/* Do not unswitch in cold areas. */
if (!maybe_hot_bb_p (loop->header))
{
fprintf (rtl_dump_file, ";; Not unswitching, not hot area\n");
return;
}
-
+
/* Nor if the loop usually does not roll. */
if (expected_loop_iterations (loop) < 1)
{
do
{
repeat = 0;
-
+
/* Find a bb to unswitch on. */
bbs = get_loop_body (loop);
for (i = 0; i < loop->num_nodes; i++)
if (!(cond = get_condition (bbs[i]->end, &split_before)))
abort ();
rcond = reversed_condition (cond);
-
+
/* Check whether the result can be predicted. */
always_true = 0;
always_false = 0;
if (always_true)
{
/* Remove false path. */
- for (e = bbs[i]->succ; !(e->flags & EDGE_FALLTHRU); e = e->succ_next);
+ for (e = bbs[i]->succ; !(e->flags & EDGE_FALLTHRU); e = e->succ_next);
remove_path (loops, e);
free (bbs);
repeat = 1;
repeat = 1;
}
} while (repeat);
-
+
/* We found the condition we can unswitch on. */
conds = alloc_EXPR_LIST (0, cond, cond_checked);
if (rcond)
for the condition we unswitch on. Returns NULL if impossible, new
loop otherwise. */
static struct loop *
-unswitch_loop (loops, loop, unswitch_on)
- struct loops *loops;
- struct loop *loop;
- basic_block unswitch_on;
+unswitch_loop (struct loops *loops, struct loop *loop, basic_block unswitch_on)
{
- edge entry, e, latch_edge;
+ edge entry, latch_edge;
basic_block switch_bb, unswitch_on_alt, src;
struct loop *nloop;
sbitmap zero_bitmap;
abort ();
if (!flow_bb_inside_loop_p (loop, unswitch_on->succ->succ_next->dest))
abort ();
-
+
/* Will we be able to perform redirection? */
if (!any_condjump_p (unswitch_on->end))
return NULL;
return NULL;
entry = loop_preheader_edge (loop);
-
+
/* Make a copy. */
src = entry->src;
- irred_flag = src->flags & BB_IRREDUCIBLE_LOOP;
- src->flags &= ~BB_IRREDUCIBLE_LOOP;
+ irred_flag = entry->flags & EDGE_IRREDUCIBLE_LOOP;
+ entry->flags &= ~EDGE_IRREDUCIBLE_LOOP;
zero_bitmap = sbitmap_alloc (2);
sbitmap_zero (zero_bitmap);
if (!duplicate_loop_to_header_edge (loop, entry, loops, 1,
zero_bitmap, NULL, NULL, NULL, 0))
return NULL;
free (zero_bitmap);
- src->flags |= irred_flag;
+ entry->flags |= irred_flag;
/* Record the block with condition we unswitch on. */
- unswitch_on_alt = RBI (unswitch_on)->copy;
+ unswitch_on_alt = unswitch_on->rbi->copy;
/* Make a copy of the block containing the condition; we will use
it as switch to decide which loop we want to use. */
switch_bb = cfg_layout_duplicate_bb (unswitch_on, NULL);
- switch_bb->flags &= ~BB_IRREDUCIBLE_LOOP;
- switch_bb->flags |= irred_flag;
+ if (irred_flag)
+ {
+ switch_bb->flags |= BB_IRREDUCIBLE_LOOP;
+ switch_bb->succ->flags |= EDGE_IRREDUCIBLE_LOOP;
+ switch_bb->succ->succ_next->flags |= EDGE_IRREDUCIBLE_LOOP;
+ }
+ else
+ {
+ switch_bb->flags &= ~BB_IRREDUCIBLE_LOOP;
+ switch_bb->succ->flags &= ~EDGE_IRREDUCIBLE_LOOP;
+ switch_bb->succ->succ_next->flags &= ~EDGE_IRREDUCIBLE_LOOP;
+ }
add_to_dominance_info (loops->cfg.dom, switch_bb);
- RBI (unswitch_on)->copy = unswitch_on_alt;
+ unswitch_on->rbi->copy = unswitch_on_alt;
/* Loopify from the copy of LOOP body, constructing the new loop. */
- for (latch_edge = RBI (loop->latch)->copy->succ;
+ for (latch_edge = loop->latch->rbi->copy->succ;
latch_edge->dest != loop->header;
latch_edge = latch_edge->succ_next);
nloop = loopify (loops, latch_edge,
- RBI (loop->header)->copy->pred, switch_bb);
+ loop->header->rbi->copy->pred, switch_bb);
/* Remove branches that are now unreachable in new loops. We rely on the
fact that cfg_layout_duplicate_bb reverses list of edges. */
- for (e = unswitch_on->succ->succ_next->dest->pred; e; e = e->pred_next)
- if (e->src != unswitch_on &&
- !dominated_by_p (loops->cfg.dom, e->src, e->dest))
- break;
remove_path (loops, unswitch_on->succ);
remove_path (loops, unswitch_on_alt->succ);
/* One of created loops do not have to be subloop of the outer loop now,
- so fix its placement in loop datastructure. */
+ so fix its placement in loop data structure. */
fix_loop_placement (loop);
fix_loop_placement (nloop);
OSDN Git Service
