+Mon Dec 24 10:24:59 2001 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
+
+ * rtl.h (in_expr_list_p): New declaration.
+ * rtlanal.c (in_expr_list_p): New function.
+ * cfgcleanup.c: Reformatting and minor code rearrangement.
+ * cfglayout.c, cfgloop.c, cfgrtl.c: Likewise.
+
2001-12-23 Richard Henderson <rth@redhat.com>
PR c/5163:
#include "obstack.h"
/* cleanup_cfg maintains following flags for each basic block. */
-enum bb_flags {
+
+enum bb_flags
+{
/* Set if life info needs to be recomputed for given BB. */
BB_UPDATE_LIFE = 1,
/* Set if BB is the forwarder block to avoid too many
forwarder_block_p calls. */
BB_FORWARDER_BLOCK = 2
- };
+};
-#define BB_FLAGS(bb) (enum bb_flags)(bb)->aux
-#define BB_SET_FLAG(bb,flag) \
- (bb)->aux = (void *) (long) ((enum bb_flags)(bb)->aux | (flag))
-#define BB_CLEAR_FLAG(bb,flag) \
- (bb)->aux = (void *) (long) ((enum bb_flags)(bb)->aux & ~(flag))
+#define BB_FLAGS(BB) (enum bb_flags) (BB)->aux
+#define BB_SET_FLAG(BB, FLAG) \
+ (BB)->aux = (void *) (long) ((enum bb_flags) (BB)->aux | (FLAG))
+#define BB_CLEAR_FLAG(BB, FLAG) \
+ (BB)->aux = (void *) (long) ((enum bb_flags) (BB)->aux & ~(FLAG))
-#define FORWARDER_BLOCK_P(bb) (BB_FLAGS(bb) & BB_FORWARDER_BLOCK)
+#define FORWARDER_BLOCK_P(BB) (BB_FLAGS (BB) & BB_FORWARDER_BLOCK)
static bool try_crossjump_to_edge PARAMS ((int, edge, edge));
static bool try_crossjump_bb PARAMS ((int, basic_block));
{
if (!bb)
return;
+
BB_SET_FLAG (bb, BB_UPDATE_LIFE);
if (forwarder_block_p (bb))
BB_SET_FLAG (bb, BB_FORWARDER_BLOCK);
\f
/* Attempt to prove that operation is NOOP using CSElib or mark the effect
on register. Used by jump threading. */
+
static bool
mark_effect (exp, nonequal)
rtx exp;
if (REG_P (XEXP (exp, 0)))
CLEAR_REGNO_REG_SET (nonequal, REGNO (XEXP (exp, 0)));
return false;
+
case SET:
if (rtx_equal_for_cselib_p (SET_DEST (exp), SET_SRC (exp)))
return false;
return true;
SET_REGNO_REG_SET (nonequal, REGNO (SET_SRC (exp)));
return false;
+
default:
return false;
}
nonequal = BITMAP_XMALLOC();
CLEAR_REG_SET (nonequal);
+
/* Now assume that we've continued by the edge E to B and continue
processing as if it were same basic block.
-
Our goal is to prove that whole block is an NOOP. */
+
for (insn = NEXT_INSN (b->head); insn != b->end && !failed;
insn = NEXT_INSN (insn))
{
else
failed |= mark_effect (pat, nonequal);
}
+
cselib_process_insn (insn);
}
bool changed = false;
edge e, next, threaded_edge;
- for (e = b->succ; e ; e = next)
+ for (e = b->succ; e; e = next)
{
basic_block target, first;
int counter;
counter = n_basic_blocks;
new_target = target->succ->dest;
}
+
/* Allow to thread only over one edge at time to simplify updating
of probabilities. */
else if ((mode & CLEANUP_THREADING) && !threaded)
new_target_threaded = true;
}
}
+
if (!new_target)
break;
if (GET_CODE (insn) != NOTE)
insn = NEXT_INSN (insn);
- for (;insn && GET_CODE (insn) != CODE_LABEL && !INSN_P (insn);
+ for (; insn && GET_CODE (insn) != CODE_LABEL && !INSN_P (insn);
insn = NEXT_INSN (insn))
if (GET_CODE (insn) == NOTE
&& NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_BEG)
if (GET_CODE (insn) == NOTE)
break;
}
+
counter++;
target = new_target;
threaded |= new_target_threaded;
else if (!redirect_edge_and_branch (e, target))
{
if (rtl_dump_file)
- fprintf (rtl_dump_file, "Forwarding edge %i->%i to %i failed.\n",
+ fprintf (rtl_dump_file,
+ "Forwarding edge %i->%i to %i failed.\n",
b->index, e->dest->index, target->index);
continue;
}
+
/* We successfully forwarded the edge. Now update profile
data: for each edge we traversed in the chain, remove
the original edge's execution count. */
do
{
edge t;
+
first->count -= edge_count;
first->succ->count -= edge_count;
first->frequency -= edge_frequency;
t = threaded_edge;
else
t = first->succ;
+
first = t->dest;
}
while (first != target);
BB_SET_FLAG (a, BB_UPDATE_LIFE);
if (rtl_dump_file)
- {
- fprintf (rtl_dump_file, "Moved block %d before %d and merged.\n",
- a->index, b->index);
- }
+ fprintf (rtl_dump_file, "Moved block %d before %d and merged.\n",
+ a->index, b->index);
/* Swap the records for the two blocks around. Although we are deleting B,
A is now where B was and we want to compact the BB array from where
BB_SET_FLAG (a, BB_UPDATE_LIFE);
if (rtl_dump_file)
- {
- fprintf (rtl_dump_file, "Moved block %d after %d and merged.\n",
- b->index, a->index);
- }
+ fprintf (rtl_dump_file, "Moved block %d after %d and merged.\n",
+ b->index, a->index);
}
/* Attempt to merge basic blocks that are potentially non-adjacent.
update_forwarder_flag (b);
if (rtl_dump_file)
- {
- fprintf (rtl_dump_file, "Merged %d and %d without moving.\n",
- b->index, c->index);
- }
+ fprintf (rtl_dump_file, "Merged %d and %d without moving.\n",
+ b->index, c->index);
return true;
}
+
/* Otherwise we will need to move code around. Do that only if expensive
transformations are allowed. */
else if (mode & CLEANUP_EXPENSIVE)
for (tmp_edge = c->succ; tmp_edge; tmp_edge = tmp_edge->succ_next)
if (tmp_edge->flags & EDGE_FALLTHRU)
break;
+
c_has_outgoing_fallthru = (tmp_edge != NULL);
for (tmp_edge = b->pred; tmp_edge; tmp_edge = tmp_edge->pred_next)
if (tmp_edge->flags & EDGE_FALLTHRU)
break;
+
b_has_incoming_fallthru = (tmp_edge != NULL);
b_fallthru_edge = tmp_edge;
if (b_has_incoming_fallthru)
{
basic_block bb;
+
if (b_fallthru_edge->src == ENTRY_BLOCK_PTR)
return false;
bb = force_nonfallthru (b_fallthru_edge);
else
BB_SET_FLAG (b_fallthru_edge->src, BB_UPDATE_LIFE);
}
+
merge_blocks_move_predecessor_nojumps (b, c);
return true;
}
+
return false;
}
\f
return true;
}
}
+
return false;
}
+
return true;
}
\f
last1 = i1;
i1 = PREV_INSN (i1);
}
+
i2 = bb2->end;
if (onlyjump_p (i2)
|| (returnjump_p (i2) && !side_effects_p (PATTERN (i2))))
/* Ignore notes. */
while (!active_insn_p (i1) && i1 != bb1->head)
i1 = PREV_INSN (i1);
+
while (!active_insn_p (i2) && i2 != bb2->head)
i2 = PREV_INSN (i2);
last1 = i1, last2 = i2;
ninsns++;
}
+
i1 = PREV_INSN (i1);
i2 = PREV_INSN (i2);
}
#ifdef HAVE_cc0
- if (ninsns)
- {
- /* Don't allow the insn after a compare to be shared by
- cross-jumping unless the compare is also shared. */
- if (reg_mentioned_p (cc0_rtx, last1) && ! sets_cc0_p (last1))
- last1 = afterlast1, last2 = afterlast2, ninsns--;
- }
+ /* Don't allow the insn after a compare to be shared by
+ cross-jumping unless the compare is also shared. */
+ if (ninsns && reg_mentioned_p (cc0_rtx, last1) && ! sets_cc0_p (last1))
+ last1 = afterlast1, last2 = afterlast2, ninsns--;
#endif
/* Include preceding notes and labels in the cross-jump. One,
{
while (last1 != bb1->head && !active_insn_p (PREV_INSN (last1)))
last1 = PREV_INSN (last1);
+
if (last1 != bb1->head && GET_CODE (PREV_INSN (last1)) == CODE_LABEL)
last1 = PREV_INSN (last1);
+
while (last2 != bb2->head && !active_insn_p (PREV_INSN (last2)))
last2 = PREV_INSN (last2);
+
if (last2 != bb2->head && GET_CODE (PREV_INSN (last2)) == CODE_LABEL)
last2 = PREV_INSN (last2);
unconditional jump, or a fake edge to exit. */
if (bb1->succ && !bb1->succ->succ_next
&& !(bb1->succ->flags & (EDGE_COMPLEX | EDGE_FAKE)))
- {
- if (! bb2->succ || bb2->succ->succ_next
- || (bb2->succ->flags & (EDGE_COMPLEX | EDGE_FAKE)))
- return false;
- return true;
- }
+ return (bb2->succ && !bb2->succ->succ_next
+ && (bb2->succ->flags & (EDGE_COMPLEX | EDGE_FAKE)) == 0);
/* Match conditional jumps - this may get tricky when fallthru and branch
edges are crossed. */
should be optimized out already. */
if (FORWARDER_BLOCK_P (f1->dest))
f1 = f1->dest->succ;
+
if (FORWARDER_BLOCK_P (f2->dest))
f2 = f2->dest->succ;
code2 = reversed_comparison_code (cond2, bb2->end);
else
code2 = GET_CODE (cond2);
+
if (code2 == UNKNOWN)
return false;
{
rtx note1, note2;
int prob1, prob2;
+
note1 = find_reg_note (bb1->end, REG_BR_PROB, 0);
note2 = find_reg_note (bb2->end, REG_BR_PROB, 0);
if (abs (prob1 - prob2) > REG_BR_PROB_BASE / 20)
return false;
}
+
else if (note1 || note2)
return false;
}
{
if (e1->flags & EDGE_EH)
nehedges1++;
+
if (e2->flags & EDGE_EH)
nehedges2++;
+
if (e1->flags & EDGE_FALLTHRU)
fallthru1 = e1;
if (e2->flags & EDGE_FALLTHRU)
fallthru2 = e2;
}
+
/* If number of edges of various types does not match, fail. */
- if (e1 || e2)
- return false;
- if (nehedges1 != nehedges2)
- return false;
- if ((fallthru1 != 0) != (fallthru2 != 0))
+ if (e1 || e2
+ || nehedges1 != nehedges2
+ || (fallthru1 != 0) != (fallthru2 != 0))
return false;
/* fallthru edges must be forwarded to the same destination. */
? fallthru1->dest->succ->dest: fallthru1->dest);
basic_block d2 = (forwarder_block_p (fallthru2->dest)
? fallthru2->dest->succ->dest: fallthru2->dest);
+
if (d1 != d2)
return false;
}
+
/* In case we do have EH edges, ensure we are in the same region. */
if (nehedges1)
{
rtx n1 = find_reg_note (bb1->end, REG_EH_REGION, 0);
rtx n2 = find_reg_note (bb2->end, REG_EH_REGION, 0);
+
if (XEXP (n1, 0) != XEXP (n2, 0))
return false;
}
+
/* We don't need to match the rest of edges as above checks should be enought
to ensure that they are equivalent. */
return true;
if (src1->pred
&& !src1->pred->pred_next
&& FORWARDER_BLOCK_P (src1))
- {
- e1 = src1->pred;
- src1 = e1->src;
- }
+ e1 = src1->pred, src1 = e1->src;
+
if (src2->pred
&& !src2->pred->pred_next
&& FORWARDER_BLOCK_P (src2))
- {
- e2 = src2->pred;
- src2 = e2->src;
- }
+ e2 = src2->pred, src2 = e2->src;
/* Nothing to do if we reach ENTRY, or a common source block. */
if (src1 == ENTRY_BLOCK_PTR || src2 == ENTRY_BLOCK_PTR)
if (FORWARDER_BLOCK_P (e1->dest)
&& FORWARDER_BLOCK_P (e1->dest->succ->dest))
return false;
+
if (FORWARDER_BLOCK_P (e2->dest)
&& FORWARDER_BLOCK_P (e2->dest->succ->dest))
return false;
if (FORWARDER_BLOCK_P (d))
d = d->succ->dest;
+
for (s2 = src1->succ; ; s2 = s2->succ_next)
{
basic_block d2 = s2->dest;
if (d == d2)
break;
}
+
s->count += s2->count;
/* Take care to update possible forwarder blocks. We verified
s->dest->count += s2->count;
s->dest->frequency += EDGE_FREQUENCY (s);
}
+
if (FORWARDER_BLOCK_P (s2->dest))
{
s2->dest->succ->count -= s2->count;
s2->dest->count -= s2->count;
s2->dest->frequency -= EDGE_FREQUENCY (s);
}
+
if (!redirect_to->frequency && !src1->frequency)
s->probability = (s->probability + s2->probability) / 2;
else
- s->probability =
- ((s->probability * redirect_to->frequency +
- s2->probability * src1->frequency)
- / (redirect_to->frequency + src1->frequency));
+ s->probability
+ = ((s->probability * redirect_to->frequency +
+ s2->probability * src1->frequency)
+ / (redirect_to->frequency + src1->frequency));
}
note = find_reg_note (redirect_to->end, REG_BR_PROB, 0);
/* Skip possible basic block header. */
if (GET_CODE (newpos1) == CODE_LABEL)
newpos1 = NEXT_INSN (newpos1);
+
if (GET_CODE (newpos1) == NOTE)
newpos1 = NEXT_INSN (newpos1);
last = src1->end;
/* Attempt to merge blocks as made possible by edge removal. If a block
has only one successor, and the successor has only one predecessor,
they may be combined. */
-
do
{
changed = false;
c = BASIC_BLOCK (b->index - 1);
if (rtl_dump_file)
fprintf (rtl_dump_file, "Deleting block %i.\n", b->index);
+
flow_delete_block (b);
changed = true;
b = c;
|| ! label_is_jump_target_p (b->head, b->pred->src->end)))
{
rtx label = b->head;
+
b->head = NEXT_INSN (b->head);
delete_insn_chain (label, label);
if (rtl_dump_file)
if (rtl_dump_file)
fprintf (rtl_dump_file, "Deleting fallthru block %i.\n",
b->index);
+
c = BASIC_BLOCK (b->index ? b->index - 1 : 1);
redirect_edge_succ_nodup (b->pred, b->succ->dest);
flow_delete_block (b);
if ((mode & CLEANUP_UPDATE_LIFE) && changed_overall)
{
bool found = 0;
+
blocks = sbitmap_alloc (n_basic_blocks);
sbitmap_zero (blocks);
for (i = 0; i < n_basic_blocks; i++)
found = 1;
SET_BIT (blocks, i);
}
+
if (found)
update_life_info (blocks, UPDATE_LIFE_GLOBAL,
PROP_DEATH_NOTES | PROP_SCAN_DEAD_CODE
| PROP_KILL_DEAD_CODE);
sbitmap_free (blocks);
}
+
for (i = 0; i < n_basic_blocks; i++)
BASIC_BLOCK (i)->aux = NULL;
/* Basic block reordering routines for the GNU compiler.
Copyright (C) 2000, 2001 Free Software Foundation, Inc.
- This file is part of GCC.
+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 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.
+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, 59 Temple Place - Suite 330, Boston, MA
- 02111-1307, USA. */
+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. */
#include "config.h"
#include "system.h"
#include "cfglayout.h"
/* The contents of the current function definition are allocated
- in this obstack, and all are freed at the end of the function.
- For top-level functions, this is temporary_obstack.
- Separate obstacks are made for nested functions. */
+ in this obstack, and all are freed at the end of the function. */
extern struct obstack flow_obstack;
if (bb->index + 1 != n_basic_blocks)
next_head = BASIC_BLOCK (bb->index + 1)->head;
- for (last_insn = insn = bb->end; (insn = NEXT_INSN (insn)); )
+ for (last_insn = insn = bb->end; (insn = NEXT_INSN (insn)) != 0; )
{
if (insn == next_head)
break;
break;
}
- /* It is possible to hit contradicting sequence. For instance:
+
+ /* It is possible to hit contradictory sequence. For instance:
jump_insn
NOTE_INSN_LOOP_BEG
barrier
- Where barrier belongs to jump_insn, but the note does not.
- This can be created by removing the basic block originally
- following NOTE_INSN_LOOP_BEG.
+ Where barrier belongs to jump_insn, but the note does not. This can be
+ created by removing the basic block originally following
+ NOTE_INSN_LOOP_BEG. In such case reorder the notes. */
- In such case reorder the notes. */
for (insn = last_insn; insn != bb->end; insn = prev)
{
- prev = PREV_INSN (insn);
- if (GET_CODE (insn) == NOTE)
- switch (NOTE_LINE_NUMBER (insn))
- {
+ prev = PREV_INSN (insn);
+ if (GET_CODE (insn) == NOTE)
+ switch (NOTE_LINE_NUMBER (insn))
+ {
case NOTE_INSN_LOOP_END:
case NOTE_INSN_BLOCK_END:
case NOTE_INSN_DELETED:
case NOTE_INSN_DELETED_LABEL:
- continue;
+ continue;
default:
- reorder_insns (insn, insn, last_insn);
+ reorder_insns (insn, insn, last_insn);
}
}
if (GET_CODE (label) != CODE_LABEL)
{
if (rtl_dump_file)
- fprintf (rtl_dump_file, "Emitting label for block %d\n",
- bb->index);
+ fprintf (rtl_dump_file, "Emitting label for block %d\n", bb->index);
label = block_label (bb);
if (bb->head == PREV_INSN (RBI (bb)->eff_head))
rtx next_insn = get_insns ();
int i;
- for (i = 0; i < n_basic_blocks; ++i)
+ for (i = 0; i < n_basic_blocks; i++)
{
basic_block bb = BASIC_BLOCK (i);
rtx end;
RBI (bb)->eff_end = end;
next_insn = NEXT_INSN (end);
}
+
function_tail_eff_head = next_insn;
}
\f
+/* Return the next NOTE_INSN_BASIC_BLOCK after X. */
+
static rtx
get_next_bb_note (x)
rtx x;
{
- while (x)
- {
- if (NOTE_INSN_BASIC_BLOCK_P (x))
- return x;
- x = NEXT_INSN (x);
- }
+ for (; x; x = NEXT_INSN (x))
+ if (NOTE_INSN_BASIC_BLOCK_P (x))
+ return x;
+
return NULL;
}
+/* Return the fist NOTE_INSN_BASIC_BLOCK before X. */
+
static rtx
get_prev_bb_note (x)
rtx x;
{
- while (x)
- {
- if (NOTE_INSN_BASIC_BLOCK_P (x))
- return x;
- x = PREV_INSN (x);
- }
+ for (; x; x = PREV_INSN (x))
+ if (NOTE_INSN_BASIC_BLOCK_P (x))
+ return x;
+
return NULL;
}
bbnote = get_next_bb_note (s->note_beg);
if (! bbnote)
abort ();
+
if (NOTE_BASIC_BLOCK (bbnote) == s->bb_end)
{
bbs_spanned = 0;
bbnote = get_prev_bb_note (s->note_end);
if (! bbnote)
abort ();
+
if (NOTE_BASIC_BLOCK (bbnote) == s->bb_beg)
{
bbs_spanned = 0;
bbs_spanned = 0;
else
{
- rtx x1, x2;
/* Both notes are outside of any bbs. This implies that all the
basic blocks spanned by the pair of notes are contained in
this scope.
There is a degenerate case to consider. If the notes do not
span any basic blocks, then it is an empty scope that can
safely be deleted or ignored. Mark these with level = -1. */
+ rtx x1 = get_next_bb_note (s->note_beg);
+ rtx x2 = get_prev_bb_note (s->note_end);
- x1 = get_next_bb_note (s->note_beg);
- x2 = get_prev_bb_note (s->note_end);
if (! (x1 && x2))
{
s->level = -1;
rtx note;
{
scope new_scope = xcalloc (1, sizeof (struct scope_def));
+
new_scope->level = level;
new_scope->note_beg = note;
return new_scope;
root = NULL;
curr_bb = NULL;
bbi = 0;
+
for (x = get_insns (); x; x = NEXT_INSN (x))
{
if (bbi < n_basic_blocks && x == BASIC_BLOCK (bbi)->head)
if (root)
{
scope new_scope;
+
if (! curr_scope)
abort();
+
level++;
new_scope = make_new_scope (level, x);
new_scope->outer = curr_scope;
curr_scope->inner_last = new_scope;
}
curr_scope = curr_scope->inner_last;
+
}
else
{
int ntrees = forest->num_trees;
+
level++;
curr_scope = make_new_scope (level, x);
root = curr_scope;
sizeof (scope) * (ntrees + 1));
forest->trees[forest->num_trees++] = root;
}
+
curr_scope->bb_beg = curr_bb;
}
else if (NOTE_LINE_NUMBER (x) == NOTE_INSN_BLOCK_END)
if (level == -1)
root = NULL;
}
- } /* if note */
+ }
if (curr_bb && curr_bb->end == x)
{
curr_bb = NULL;
bbi++;
}
-
- } /* for */
+ }
for (i = 0; i < forest->num_trees; i++)
relate_bbs_with_scopes (forest->trees[i]);
}
\f
-/* Remove all the NOTE_INSN_BLOCK_BEG and NOTE_INSN_BLOCK_END notes from
- the insn chain. */
+/* Remove all NOTE_INSN_BLOCK_BEG and NOTE_INSN_BLOCK_END notes from the insn
+ chain. */
static void
remove_scope_notes ()
}
}
-
/* Insert NOTE_INSN_BLOCK_END notes and NOTE_INSN_BLOCK_BEG notes for
scopes that are contained within BB. */
}
}
-
/* Given two consecutive basic blocks BB1 and BB2 with different scopes,
insert NOTE_INSN_BLOCK_END notes after BB1 and NOTE_INSN_BLOCK_BEG
notes before BB2 such that the notes are correctly balanced. If BB1 or
{
scope s1 = RBI (bb1)->scope;
scope s2 = RBI (bb2)->scope;
+
if (! s1 && ! s2)
return;
+
if (! s1)
bb1 = NULL;
else if (! s2)
{
scope s1 = RBI (bb1)->scope;
scope s2 = RBI (bb2)->scope;
+
while (s1 != s2)
{
- if (! (s1 && s2))
- abort ();
if (s1->level > s2->level)
s1 = s1->outer;
else if (s2->level > s1->level)
s2 = s2->outer;
}
}
+
com = s1;
}
else
if (bb1)
{
rtx end = bb1->end;
+ scope s;
- scope s = RBI (bb1)->scope;
ip = RBI (bb1)->eff_end;
- while (s != com)
- {
- if (NOTE_BLOCK (s->note_beg))
- {
- ip = emit_note_after (NOTE_INSN_BLOCK_END, ip);
- NOTE_BLOCK (ip) = NOTE_BLOCK (s->note_end);
- }
- s = s->outer;
- }
+ for (s = RBI (bb1)->scope; s != com; s = s->outer)
+ if (NOTE_BLOCK (s->note_beg))
+ {
+ ip = emit_note_after (NOTE_INSN_BLOCK_END, ip);
+ NOTE_BLOCK (ip) = NOTE_BLOCK (s->note_end);
+ }
+
/* Emitting note may move the end of basic block to unwanted place. */
bb1->end = end;
}
/* Open scopes. */
if (bb2)
{
- scope s = RBI (bb2)->scope;
+ scope s;
+
ip = bb2->head;
- while (s != com)
- {
- if (NOTE_BLOCK (s->note_beg))
- {
- ip = emit_note_before (NOTE_INSN_BLOCK_BEG, ip);
- NOTE_BLOCK (ip) = NOTE_BLOCK (s->note_beg);
- }
- s = s->outer;
- }
+ for (s = RBI (bb2)->scope; s != com; s = s->outer)
+ if (NOTE_BLOCK (s->note_beg))
+ {
+ ip = emit_note_before (NOTE_INSN_BLOCK_BEG, ip);
+ NOTE_BLOCK (ip) = NOTE_BLOCK (s->note_beg);
+ }
}
}
{
basic_block bb1 = BASIC_BLOCK (i);
basic_block bb2 = BASIC_BLOCK (i + 1);
+
if (RBI (bb1)->scope != RBI (bb2)->scope)
insert_inter_bb_scope_notes (bb1, bb2);
insert_intra_bb_scope_notes (bb1);
scope_forest_info *forest;
{
int i;
+
for (i = 0; i < forest->num_trees; i++)
free_scope_forest_1 (forest->trees[i]);
}
dump_scope_forest (forest)
scope_forest_info *forest;
{
+ int i;
+
if (forest->num_trees == 0)
fprintf (stderr, "\n< Empty scope forest >\n");
else
- {
- int i;
- fprintf (stderr, "\n< Scope forest >\n");
- for (i = 0; i < forest->num_trees; i++)
- dump_scope_forest_1 (forest->trees[i], 0);
- }
+ fprintf (stderr, "\n< Scope forest >\n");
+
+ for (i = 0; i < forest->num_trees; i++)
+ dump_scope_forest_1 (forest->trees[i], 0);
}
/* Recursive portion of dump_scope_forest. */
/* First do the bulk reordering -- rechain the blocks without regard to
the needed changes to jumps and labels. */
- last_bb = BASIC_BLOCK (0);
- bb = RBI (last_bb)->next;
- index = 1;
- while (bb)
+ for (last_bb = BASIC_BLOCK (0), bb = RBI (last_bb)->next, index = 1;
+ bb != 0;
+ last_bb = bb, bb = RBI (bb)->next, index++)
{
rtx last_e = RBI (last_bb)->eff_end;
rtx curr_h = RBI (bb)->eff_head;
NEXT_INSN (last_e) = curr_h;
PREV_INSN (curr_h) = last_e;
-
- last_bb = bb;
- bb = RBI (bb)->next;
- index++;
}
if (index != n_basic_blocks)
abort ();
insn = RBI (last_bb)->eff_end;
-
NEXT_INSN (insn) = function_tail_eff_head;
if (function_tail_eff_head)
PREV_INSN (function_tail_eff_head) = insn;
while (NEXT_INSN (insn))
insn = NEXT_INSN (insn);
+
set_last_insn (insn);
#ifdef ENABLE_CHECKING
verify_insn_chain ();
if (RBI (bb)->next != e_taken->dest)
{
rtx note = find_reg_note (bb_end_insn, REG_BR_PROB, 0);
+
if (note
&& INTVAL (XEXP (note, 0)) < REG_BR_PROB_BASE / 2
&& invert_jump (bb_end_insn,
99% case, there should not have been a fallthru edge. */
if (! e_fall)
continue;
+
#ifdef CASE_DROPS_THROUGH
/* Except for VAX. Since we didn't have predication for the
tablejump, the fallthru block should not have moved. */
if (RBI (bb)->next == e_fall->dest)
continue;
- /* An fallthru to exit block. */
+ /* A fallthru to exit block. */
if (!RBI (bb)->next && e_fall->dest == EXIT_BLOCK_PTR)
continue;
}
/* We got here if we need to add a new jump insn. */
-
nb = force_nonfallthru (e_fall);
-
if (nb)
{
alloc_aux_for_block (nb, sizeof (struct reorder_block_def));
if (rtl_dump_file)
fprintf (rtl_dump_file, "Reordered sequence:\n");
- while (bb)
+
+ for (; bb; bb = RBI (bb)->next, index++)
{
if (rtl_dump_file)
fprintf (rtl_dump_file, " %i %sbb %i freq %i\n", index,
bb->index >= old_n_basic_blocks ? "compensation " : "",
bb->index,
bb->frequency);
+
bb->index = index;
BASIC_BLOCK (index) = bb;
-
- bb = RBI (bb)->next;
- index++;
}
}
\f
void
verify_insn_chain ()
{
- rtx x,
- prevx,
- nextx;
- int insn_cnt1,
- insn_cnt2;
-
- prevx = NULL;
- insn_cnt1 = 1;
- for (x = get_insns (); x; x = NEXT_INSN (x))
- {
- if (PREV_INSN (x) != prevx)
- {
- fprintf (stderr, "Forward traversal: insn chain corrupt.\n");
- fprintf (stderr, "previous insn:\n");
- debug_rtx (prevx);
- fprintf (stderr, "current insn:\n");
- debug_rtx (x);
- abort ();
- }
- ++insn_cnt1;
- prevx = x;
- }
+ rtx x, prevx, nextx;
+ int insn_cnt1, insn_cnt2;
- if (prevx != get_last_insn ())
- {
- fprintf (stderr, "last_insn corrupt.\n");
+ for (prevx = NULL, insn_cnt1 = 1, x = get_insns ();
+ x != 0;
+ prevx = x, insn_cnt1++, x = NEXT_INSN (x))
+ if (PREV_INSN (x) != prevx)
abort ();
- }
- nextx = NULL;
- insn_cnt2 = 1;
- for (x = get_last_insn (); x; x = PREV_INSN (x))
- {
- if (NEXT_INSN (x) != nextx)
- {
- fprintf (stderr, "Reverse traversal: insn chain corrupt.\n");
- fprintf (stderr, "current insn:\n");
- debug_rtx (x);
- fprintf (stderr, "next insn:\n");
- debug_rtx (nextx);
- abort ();
- }
- ++insn_cnt2;
- nextx = x;
- }
+ if (prevx != get_last_insn ())
+ abort ();
- if (insn_cnt1 != insn_cnt2)
- {
- fprintf (stderr, "insn_cnt1 (%d) not equal to insn_cnt2 (%d).\n",
- insn_cnt1, insn_cnt2);
+ for (nextx = NULL, insn_cnt2 = 1, x = get_last_insn ();
+ x != 0;
+ nextx = x, insn_cnt2++, x = PREV_INSN (x))
+ if (NEXT_INSN (x) != nextx)
abort ();
- }
+
+ if (insn_cnt1 != insn_cnt2)
+ abort ();
}
-/* The block falling through to exit must be the last one in the
- reordered chain. Ensure that this condition is met. */
+/* The block falling through to exit must be the last one in the reordered
+ chain. Ensure it is. */
+
static void
fixup_fallthru_exit_predecessor ()
{
for (e = EXIT_BLOCK_PTR->pred; e; e = e->pred_next)
if (e->flags & EDGE_FALLTHRU)
bb = e->src;
+
if (bb && RBI (bb)->next)
{
basic_block c = BASIC_BLOCK (0);
+
while (RBI (c)->next != bb)
c = RBI (c)->next;
+
RBI (c)->next = RBI (bb)->next;
while (RBI (c)->next)
c = RBI (c)->next;
+
RBI (c)->next = bb;
RBI (bb)->next = NULL;
}
}
\f
-/* Main entry point to this module - initialize the datastructures for
- CFG layout changes. */
+/* Main entry point to this module: initialize the datastructures for CFG
+ layout changes. */
void
cfg_layout_initialize ()
record_effective_endpoints ();
}
-/* Finalize the changes - reorder insn list according to the sequence,
- enter compensation code, rebuild scope forest. */
+/* Finalize the changes: reorder insn list according to the sequence, enter
+ compensation code, rebuild scope forest. */
void
cfg_layout_finalize ()
{
fixup_fallthru_exit_predecessor ();
fixup_reorder_chain ();
+
#ifdef ENABLE_CHECKING
verify_insn_chain ();
#endif
static int flow_loop_entry_edges_find PARAMS ((basic_block, const sbitmap,
edge **));
static int flow_loop_exit_edges_find PARAMS ((const sbitmap, edge **));
-static int flow_loop_nodes_find PARAMS ((basic_block, basic_block, sbitmap));
-static void flow_loop_pre_header_scan PARAMS ((struct loop *));
+static int flow_loop_nodes_find PARAMS ((basic_block, basic_block,
+ sbitmap));
+static void flow_loop_pre_header_scan PARAMS ((struct loop *));
static basic_block flow_loop_pre_header_find PARAMS ((basic_block,
const sbitmap *));
-static void flow_loop_tree_node_add PARAMS ((struct loop *, struct loop *));
+static void flow_loop_tree_node_add PARAMS ((struct loop *,
+ struct loop *));
static void flow_loops_tree_build PARAMS ((struct loops *));
static int flow_loop_level_compute PARAMS ((struct loop *, int));
static int flow_loops_level_compute PARAMS ((struct loops *));
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);
}
}
fprintf (file, ";;\n;; Loop %d (%d to %d):%s%s\n",
loop->num, INSN_UID (loop->first->head),
INSN_UID (loop->last->end),
- loop->shared ? " shared" : "",
- loop->invalid ? " invalid" : "");
+ loop->shared ? " shared" : "", loop->invalid ? " invalid" : "");
else
fprintf (file, ";;\n;; Loop %d:%s%s\n", loop->num,
- loop->shared ? " shared" : "",
- loop->invalid ? " invalid" : "");
+ loop->shared ? " shared" : "", loop->invalid ? " invalid" : "");
fprintf (file, ";; header %d, latch %d, pre-header %d, first %d, last %d\n",
loop->header->index, loop->latch->index,
if (loop->pre_header_edges)
flow_edge_list_print (";; pre-header edges", loop->pre_header_edges,
loop->num_pre_header_edges, file);
+
flow_edge_list_print (";; entry edges", loop->entry_edges,
loop->num_entries, file);
fprintf (file, ";; %d", loop->num_nodes);
flow_nodes_print (" nodes", loop->nodes, file);
flow_edge_list_print (";; exit edges", loop->exit_edges,
loop->num_exits, file);
+
if (loop->exits_doms)
flow_nodes_print (";; exit doms", loop->exits_doms, file);
+
if (loop_dump_aux)
loop_dump_aux (loop, file, verbose);
}
void (*loop_dump_aux) PARAMS((const struct loop *, FILE *, int));
int verbose;
{
- int i;
+ int i, j;
int num_loops;
num_loops = loops->num;
if (! num_loops || ! file)
return;
- fprintf (file, ";; %d loops found, %d levels\n",
- num_loops, loops->levels);
-
+ fprintf (file, ";; %d loops found, %d levels\n", num_loops, loops->levels);
for (i = 0; i < num_loops; i++)
{
struct loop *loop = &loops->array[i];
flow_loop_dump (loop, file, loop_dump_aux, verbose);
-
if (loop->shared)
- {
- int j;
-
- for (j = 0; j < i; j++)
- {
- struct loop *oloop = &loops->array[j];
-
- if (loop->header == oloop->header)
- {
- int disjoint;
- int smaller;
-
- smaller = loop->num_nodes < oloop->num_nodes;
-
- /* If the union of LOOP and OLOOP is different than
- the larger of LOOP and OLOOP then LOOP and OLOOP
- must be disjoint. */
- disjoint = ! flow_loop_nested_p (smaller ? loop : oloop,
- smaller ? oloop : loop);
- fprintf (file,
- ";; loop header %d shared by loops %d, %d %s\n",
- loop->header->index, i, j,
- disjoint ? "disjoint" : "nested");
- }
- }
- }
+ for (j = 0; j < i; j++)
+ {
+ struct loop *oloop = &loops->array[j];
+
+ if (loop->header == oloop->header)
+ {
+ int disjoint;
+ int smaller;
+
+ smaller = loop->num_nodes < oloop->num_nodes;
+
+ /* If the union of LOOP and OLOOP is different than
+ the larger of LOOP and OLOOP then LOOP and OLOOP
+ must be disjoint. */
+ disjoint = ! flow_loop_nested_p (smaller ? loop : oloop,
+ smaller ? oloop : loop);
+ fprintf (file,
+ ";; loop header %d shared by loops %d, %d %s\n",
+ loop->header->index, i, j,
+ disjoint ? "disjoint" : "nested");
+ }
+ }
}
if (verbose)
if (loop->exits_doms)
sbitmap_free (loop->exits_doms);
}
+
free (loops->array);
loops->array = NULL;
if (loops->cfg.dom)
sbitmap_vector_free (loops->cfg.dom);
+
if (loops->cfg.dfs_order)
free (loops->cfg.dfs_order);
flow_loop_pre_header_scan (loop)
struct loop *loop;
{
- int num = 0;
+ int num;
basic_block ebb;
+ edge e;
loop->num_pre_header_edges = 0;
-
if (loop->num_entries != 1)
- return;
+ return;
ebb = loop->entry_edges[0]->src;
+ if (ebb == ENTRY_BLOCK_PTR)
+ return;
- if (ebb != ENTRY_BLOCK_PTR)
- {
- edge e;
-
- /* 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. */
- num++;
- while (ebb->pred->src != ENTRY_BLOCK_PTR && ! ebb->pred->pred_next)
- {
- ebb = ebb->pred->src;
- num++;
- }
-
- loop->pre_header_edges = (edge *) 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 = e->src->pred)
- {
- loop->pre_header_edges[--num] = e;
- }
- }
+ /* 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; ebb->pred->src != ENTRY_BLOCK_PTR && ! ebb->pred->pred_next;
+ num++)
+ ebb = ebb->pred->src;
+
+ loop->pre_header_edges = (edge *) 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 = e->src->pred)
+ loop->pre_header_edges[--num] = e;
}
/* Return the block for the pre-header of the loop with header
}
}
}
+
return pre_header;
}
return;
}
- while (prevloop->outer)
- {
- if (flow_loop_nested_p (prevloop->outer, loop))
- {
- prevloop->next = loop;
- loop->outer = prevloop->outer;
- return;
- }
- prevloop = prevloop->outer;
- }
+ for (; prevloop->outer; prevloop = prevloop->outer)
+ if (flow_loop_nested_p (prevloop->outer, loop))
+ {
+ prevloop->next = loop;
+ loop->outer = prevloop->outer;
+ return;
+ }
prevloop->next = loop;
loop->outer = NULL;
Since we used a depth first search this should be the
outermost loop. */
loops->tree_root = &loops->array[0];
- loops->tree_root->outer = loops->tree_root->inner = loops->tree_root->next = NULL;
+ loops->tree_root->outer = loops->tree_root->inner
+ = loops->tree_root->next = NULL;
/* Add the remaining loops to the tree. */
for (i = 1; i < num_loops; i++)
itself). */
for (inner = loop->inner; inner; inner = inner->next)
{
- int ilevel;
-
- ilevel = flow_loop_level_compute (inner, depth + 1) + 1;
+ int ilevel = flow_loop_level_compute (inner, depth + 1) + 1;
- if (ilevel > level)
- level = ilevel;
+ level = MAX (ilevel, level);
}
+
loop->level = level;
loop->depth = depth;
return level;
flow_loops_level_compute (loops)
struct loops *loops;
{
+ int levels = 0;
struct loop *loop;
int level;
- int levels = 0;
/* Traverse all the outer level loops. */
for (loop = loops->tree_root; loop; loop = loop->next)
{
level = flow_loop_level_compute (loop, 1);
- if (level > levels)
- levels = level;
+ levels = MAX (levels, level);
}
+
return levels;
}
flags |= LOOP_EXIT_EDGES;
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. */
- loop->num_entries
- = flow_loop_entry_edges_find (loop->header,
- loop->nodes,
- &loop->entry_edges);
- }
+ /* Find edges which enter the loop header. Note that the entry edges
+ should only enter the header of a natural loop. */
+ loop->num_entries = flow_loop_entry_edges_find (loop->header, loop->nodes,
+ &loop->entry_edges);
if (flags & LOOP_EXIT_EDGES)
- {
- /* Find edges which exit the loop. */
- loop->num_exits
- = flow_loop_exit_edges_find (loop->nodes,
- &loop->exit_edges);
- }
+ /* Find edges which exit the loop. */
+ loop->num_exits
+ = flow_loop_exit_edges_find (loop->nodes, &loop->exit_edges);
if (flags & LOOP_EXITS_DOMS)
{
the loop pre-header. */
flow_loop_pre_header_scan (loop);
}
+
return 1;
}
-/* 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. */
+/* 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. */
int
flow_loops_find (loops, flags)
if (! (flags & LOOP_TREE))
abort ();
- memset (loops, 0, sizeof (*loops));
+ memset (loops, 0, sizeof *loops);
/* Taking care of this degenerate case makes the rest of
this code simpler. */
/* Count the number of loop edges (back edges). This should be the
same as the number of natural loops. */
-
num_loops = 0;
for (b = 0; b < n_basic_blocks; b++)
{
sbitmap_free (headers);
}
else
- {
- sbitmap_vector_free (dom);
- }
+ sbitmap_vector_free (dom);
loops->num = num_loops;
/* Update the information regarding the loops in the CFG
specified by LOOPS. */
+
int
flow_loops_update (loops, flags)
struct loops *loops;
{
if (e->dest != loop->header)
abort ();
- return (e->src == ENTRY_BLOCK_PTR) || ! TEST_BIT (loop->nodes, e->src->index);
+
+ return (e->src == ENTRY_BLOCK_PTR)
+ || ! TEST_BIT (loop->nodes, e->src->index);
}
Software Foundation, 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA. */
-/* This file contains low level functions to manipulate with CFG and analyze it
- that are aware of RTL intermediate language.
+/* This file contains low level functions to manipulate the CFG and analyze it
+ that are aware of the RTL intermediate language.
Available functionality:
- - CFG aware instruction chain manipulation
+ - CFG-aware instruction chain manipulation
delete_insn, delete_insn_chain
- Basic block manipulation
- create_basic_block, flow_delete_block, split_block, merge_blocks_nomove
- - Infrastructure to determine quickly basic block for instruction.
+ create_basic_block, flow_delete_block, split_block,
+ merge_blocks_nomove
+ - Infrastructure to determine quickly basic block for insn
compute_bb_for_insn, update_bb_for_insn, set_block_for_insn,
- - Edge redirection with updating and optimizing instruction chain
- block_label, redirect_edge_and_branch,
- redirect_edge_and_branch_force, tidy_fallthru_edge, force_nonfallthru
+ - Edge redirection with updating and optimizing of insn chain
+ block_label, redirect_edge_and_branch,
+ redirect_edge_and_branch_force, tidy_fallthru_edge, force_nonfallthru
- Edge splitting and commiting to edges
- split_edge, insert_insn_on_edge, commit_edge_insertions
+ split_edge, insert_insn_on_edge, commit_edge_insertions
- Dumping and debugging
- print_rtl_with_bb, dump_bb, debug_bb, debug_bb_n
+ print_rtl_with_bb, dump_bb, debug_bb, debug_bb_n
- Consistency checking
- verify_flow_info
+ verify_flow_info
- CFG updating after constant propagation
- purge_dead_edges, purge_all_dead_edges
- */
+ purge_dead_edges, purge_all_dead_edges */
\f
#include "config.h"
#include "system.h"
#include "tm_p.h"
#include "obstack.h"
-/* Stubs in case we haven't got a return insn. */
+/* Stubs in case we don't have a return insn. */
#ifndef HAVE_return
#define HAVE_return 0
#define gen_return() NULL_RTX
#endif
/* The basic block structure for every insn, indexed by uid. */
-
varray_type basic_block_for_insn;
/* The labels mentioned in non-jump rtl. Valid during find_basic_blocks. */
/* ??? Should probably be using LABEL_NUSES instead. It would take a
bit of surgery to be able to use or co-opt the routines in jump. */
-
rtx label_value_list;
rtx tail_recursion_label_list;
static basic_block force_nonfallthru_and_redirect PARAMS ((edge, basic_block));
\f
/* Return true if NOTE is not one of the ones that must be kept paired,
- so that we may simply delete them. */
+ so that we may simply delete it. */
static int
can_delete_note_p (note)
can_delete_label_p (label)
rtx label;
{
- rtx x;
-
- if (LABEL_PRESERVE_P (label))
- return 0;
-
- for (x = forced_labels; x; x = XEXP (x, 1))
- if (label == XEXP (x, 0))
- return 0;
- for (x = label_value_list; x; x = XEXP (x, 1))
- if (label == XEXP (x, 0))
- return 0;
- for (x = exception_handler_labels; x; x = XEXP (x, 1))
- if (label == XEXP (x, 0))
- return 0;
-
- /* User declared labels must be preserved. */
- if (LABEL_NAME (label) != 0)
- return 0;
-
- return 1;
+ return (!LABEL_PRESERVE_P (label)
+ /* User declared labels must be preserved. */
+ && LABEL_NAME (label) == 0
+ && !in_expr_list_p (forced_labels, label)
+ && !in_expr_list_p (label_value_list, label)
+ && !in_expr_list_p (exception_handler_labels, label));
}
/* Delete INSN by patching it out. Return the next insn. */
NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED_LABEL;
NOTE_SOURCE_FILE (insn) = name;
}
+
remove_node_from_expr_list (insn, &nonlocal_goto_handler_labels);
}
delete_insn_chain (start, finish)
rtx start, finish;
{
- /* Unchain the insns one by one. It would be quicker to delete all
- of these with a single unchaining, rather than one at a time, but
- we need to keep the NOTE's. */
-
rtx next;
+ /* Unchain the insns one by one. It would be quicker to delete all of these
+ with a single unchaining, rather than one at a time, but we need to keep
+ the NOTE's. */
while (1)
{
next = NEXT_INSN (start);
}
}
\f
-/* Create a new basic block consisting of the instructions between
- HEAD and END inclusive. This function is designed to allow fast
- BB construction - reuses the note and basic block struct
- in BB_NOTE, if any and do not grow BASIC_BLOCK chain and should
- be used directly only by CFG construction code.
- END can be NULL in to create new empty basic block before HEAD.
- Both END and HEAD can be NULL to create basic block at the end of
- INSN chain. */
+/* Create a new basic block consisting of the instructions between HEAD and END
+ inclusive. This function is designed to allow fast BB construction - reuses
+ the note and basic block struct in BB_NOTE, if any and do not grow
+ BASIC_BLOCK chain and should be used directly only by CFG construction code.
+ END can be NULL in to create new empty basic block before HEAD. Both END
+ and HEAD can be NULL to create basic block at the end of INSN chain. */
basic_block
create_basic_block_structure (index, head, end, bb_note)
bb = alloc_block ();
if (!head && !end)
- {
- head = end = bb_note = emit_note_after (NOTE_INSN_BASIC_BLOCK,
- get_last_insn ());
- }
+ head = end = bb_note
+ = emit_note_after (NOTE_INSN_BASIC_BLOCK, get_last_insn ());
else if (GET_CODE (head) == CODE_LABEL && end)
{
bb_note = emit_note_after (NOTE_INSN_BASIC_BLOCK, head);
if (!end)
end = head;
}
+
NOTE_BASIC_BLOCK (bb_note) = bb;
}
return bb;
}
-/* Create new basic block consisting of instructions in between HEAD and
- END and place it to the BB chain at position INDEX.
- END can be NULL in to create new empty basic block before HEAD.
- Both END and HEAD can be NULL to create basic block at the end of
- INSN chain. */
+/* Create new basic block consisting of instructions in between HEAD and END
+ and place it to the BB chain at position INDEX. END can be NULL in to
+ create new empty basic block before HEAD. Both END and HEAD can be NULL to
+ create basic block at the end of INSN chain. */
basic_block
create_basic_block (index, head, end)
for (i = n_basic_blocks - 1; i > index; --i)
{
basic_block tmp = BASIC_BLOCK (i - 1);
+
BASIC_BLOCK (i) = tmp;
tmp->index = i;
}
if (basic_block_for_insn)
VARRAY_FREE (basic_block_for_insn);
+
VARRAY_BB_INIT (basic_block_for_insn, max, "basic_block_for_insn");
for (i = 0; i < n_basic_blocks; ++i)
{
basic_block bb = BASIC_BLOCK (i);
- rtx insn, end;
+ rtx end = bb->end;
+ rtx insn;
- end = bb->end;
- insn = bb->head;
- while (1)
+ for (insn = bb->head; ; insn = NEXT_INSN (insn))
{
- int uid = INSN_UID (insn);
- if (uid < max)
- VARRAY_BB (basic_block_for_insn, uid) = bb;
+ if (INSN_UID (insn) < max)
+ VARRAY_BB (basic_block_for_insn, INSN_UID (insn)) = bb;
+
if (insn == end)
break;
- insn = NEXT_INSN (insn);
}
}
}
{
if (basic_block_for_insn)
VARRAY_FREE (basic_block_for_insn);
+
basic_block_for_insn = 0;
}
for (insn = bb->head; ; insn = NEXT_INSN (insn))
{
set_block_for_insn (insn, bb);
-
if (insn == bb->end)
break;
}
basic_block bb;
{
size_t uid = INSN_UID (insn);
+
if (uid >= basic_block_for_insn->num_elements)
{
- int new_size;
-
/* Add one-eighth the size so we don't keep calling xrealloc. */
- new_size = uid + (uid + 7) / 8;
+ size_t new_size = uid + (uid + 7) / 8;
VARRAY_GROW (basic_block_for_insn, new_size);
}
+
VARRAY_BB (basic_block_for_insn, uid) = bb;
}
\f
merge_blocks_nomove (a, b)
basic_block a, b;
{
- edge e;
- rtx b_head, b_end, a_end;
+ rtx b_head = b->head, b_end = b->end, a_end = a->end;
rtx del_first = NULL_RTX, del_last = NULL_RTX;
int b_empty = 0;
+ edge e;
/* If there was a CODE_LABEL beginning B, delete it. */
- b_head = b->head;
- b_end = b->end;
if (GET_CODE (b_head) == CODE_LABEL)
{
/* Detect basic blocks with nothing but a label. This can happen
in particular at the end of a function. */
if (b_head == b_end)
b_empty = 1;
+
del_first = del_last = b_head;
b_head = NEXT_INSN (b_head);
}
- /* Delete the basic block note. */
+ /* Delete the basic block note and handle blocks containing just that
+ note. */
if (NOTE_INSN_BASIC_BLOCK_P (b_head))
{
if (b_head == b_end)
b_empty = 1;
if (! del_last)
del_first = b_head;
+
del_last = b_head;
b_head = NEXT_INSN (b_head);
}
/* If there was a jump out of A, delete it. */
- a_end = a->end;
if (GET_CODE (a_end) == JUMP_INSN)
{
rtx prev;
if (only_sets_cc0_p (prev))
{
rtx tmp = prev;
+
prev = prev_nonnote_insn (prev);
if (!prev)
prev = a->head;
/* Reassociate the insns of B with A. */
if (!b_empty)
{
- rtx x = a_end;
if (basic_block_for_insn)
{
- BLOCK_FOR_INSN (x) = a;
- while (x != b_end)
- {
- x = NEXT_INSN (x);
- BLOCK_FOR_INSN (x) = a;
- }
+ rtx x;
+
+ for (x = a_end; x != b_end; x = NEXT_INSN (x))
+ BLOCK_FOR_INSN (x) = a;
+
+ BLOCK_FOR_INSN (b_end) = a;
}
+
a_end = b_end;
}
+
a->end = a_end;
}
\f
-/* Return label in the head of basic block. Create one if it doesn't exist. */
+/* Return the label in the head of basic block BLOCK. Create one if it doesn't
+ exist. */
rtx
block_label (block)
{
if (block == EXIT_BLOCK_PTR)
return NULL_RTX;
+
if (GET_CODE (block->head) != CODE_LABEL)
{
block->head = emit_label_before (gen_label_rtx (), block->head);
if (basic_block_for_insn)
set_block_for_insn (block->head, block);
}
+
return block->head;
}
/* Attempt to perform edge redirection by replacing possibly complex jump
- instruction by unconditional jump or removing jump completely.
- This can apply only if all edges now point to the same block.
-
- The parameters and return values are equivalent to redirect_edge_and_branch.
- */
+ instruction by unconditional jump or removing jump completely. This can
+ apply only if all edges now point to the same block. The parameters and
+ return values are equivalent to redirect_edge_and_branch. */
static bool
try_redirect_by_replacing_jump (e, target)
for (tmp = src->succ; tmp; tmp = tmp->succ_next)
if (tmp->dest != target && tmp != e)
break;
+
if (tmp || !onlyjump_p (insn))
return false;
/* Selectively unlink whole insn chain. */
delete_insn_chain (kill_from, PREV_INSN (target->head));
}
+
/* If this already is simplejump, redirect it. */
else if (simplejump_p (insn))
{
INSN_UID (insn), e->dest->index, target->index);
redirect_jump (insn, block_label (target), 0);
}
+
/* Or replace possibly complicated jump insn by simple jump insn. */
else
{
e->flags = EDGE_FALLTHRU;
else
e->flags = 0;
+
e->probability = REG_BR_PROB_BASE;
e->count = src->count;
if (e->dest != target)
redirect_edge_succ (e, target);
+
return true;
}
/* Return last loop_beg note appearing after INSN, before start of next
basic block. Return INSN if there are no such notes.
- When emitting jump to redirect an fallthru edge, it should always
- appear after the LOOP_BEG notes, as loop optimizer expect loop to
- either start by fallthru edge or jump following the LOOP_BEG note
- jumping to the loop exit test. */
+ When emitting jump to redirect an fallthru edge, it should always appear
+ after the LOOP_BEG notes, as loop optimizer expect loop to either start by
+ fallthru edge or jump following the LOOP_BEG note jumping to the loop exit
+ test. */
static rtx
last_loop_beg_note (insn)
rtx insn;
{
rtx last = insn;
- insn = NEXT_INSN (insn);
- while (insn && GET_CODE (insn) == NOTE
- && NOTE_LINE_NUMBER (insn) != NOTE_INSN_BASIC_BLOCK)
- {
- if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_BEG)
- last = insn;
- insn = NEXT_INSN (insn);
- }
+
+ for (insn = NEXT_INSN (insn); insn && GET_CODE (insn) == NOTE
+ && NOTE_LINE_NUMBER (insn) != NOTE_INSN_BASIC_BLOCK;
+ insn = NEXT_INSN (insn))
+ if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_BEG)
+ last = insn;
+
return last;
}
-/* Attempt to change code to redirect edge E to TARGET.
- Don't do that on expense of adding new instructions or reordering
- basic blocks.
+/* Attempt to change code to redirect edge E to TARGET. Don't do that on
+ expense of adding new instructions or reordering basic blocks.
- Function can be also called with edge destination equivalent to the
- TARGET. Then it should try the simplifications and do nothing if
- none is possible.
+ Function can be also called with edge destination equivalent to the TARGET.
+ Then it should try the simplifications and do nothing if none is possible.
- Return true if transformation succeeded. We still return false in case
- E already destinated TARGET and we didn't managed to simplify instruction
+ Return true if transformation succeeded. We still return false in case E
+ already destinated TARGET and we didn't managed to simplify instruction
stream. */
bool
if (try_redirect_by_replacing_jump (e, target))
return true;
+
/* Do this fast path late, as we want above code to simplify for cases
where called on single edge leaving basic block containing nontrivial
jump insn. */
/* We can only redirect non-fallthru edges of jump insn. */
if (e->flags & EDGE_FALLTHRU)
return false;
- if (GET_CODE (insn) != JUMP_INSN)
+ else if (GET_CODE (insn) != JUMP_INSN)
return false;
/* Recognize a tablejump and adjust all matching cases. */
/* ?? We may play the games with moving the named labels from
one basic block to the other in case only one computed_jump is
available. */
- if (computed_jump_p (insn))
- return false;
-
- /* A return instruction can't be redirected. */
- if (returnjump_p (insn))
+ if (computed_jump_p (insn)
+ /* A return instruction can't be redirected. */
+ || returnjump_p (insn))
return false;
/* If the insn doesn't go where we think, we're confused. */
- if (JUMP_LABEL (insn) != old_label)
- abort ();
- /* If the substitution doesn't succeed, die. This can happen
- if the back end emitted unrecognizable instructions. */
- if (! redirect_jump (insn, block_label (target), 0))
+ if (JUMP_LABEL (insn) != old_label
+ /* If the substitution doesn't succeed, die. This can happen
+ if the back end emitted unrecognizable instructions. */
+ || !redirect_jump (insn, block_label (target), 0))
abort ();
}
if (rtl_dump_file)
fprintf (rtl_dump_file, "Edge %i->%i redirected to %i\n",
e->src->index, e->dest->index, target->index);
+
if (e->dest != target)
redirect_edge_succ_nodup (e, target);
+
return true;
}
if (e->flags & EDGE_ABNORMAL)
abort ();
- if (!(e->flags & EDGE_FALLTHRU))
+ else if (!(e->flags & EDGE_FALLTHRU))
abort ();
- if (e->src->succ->succ_next)
+ else if (e->src->succ->succ_next)
{
/* Create the new structures. */
note = last_loop_beg_note (e->src->end);
- jump_block = create_basic_block (e->src->index + 1, NEXT_INSN (note), NULL);
+ jump_block
+ = create_basic_block (e->src->index + 1, NEXT_INSN (note), NULL);
jump_block->count = e->count;
jump_block->frequency = EDGE_FREQUENCY (e);
jump_block->loop_depth = target->loop_depth;
if (target->global_live_at_start)
{
- jump_block->global_live_at_start =
- OBSTACK_ALLOC_REG_SET (&flow_obstack);
- jump_block->global_live_at_end =
- OBSTACK_ALLOC_REG_SET (&flow_obstack);
+ jump_block->global_live_at_start
+ = OBSTACK_ALLOC_REG_SET (&flow_obstack);
+ jump_block->global_live_at_end
+ = OBSTACK_ALLOC_REG_SET (&flow_obstack);
COPY_REG_SET (jump_block->global_live_at_start,
target->global_live_at_start);
COPY_REG_SET (jump_block->global_live_at_end,
}
else
jump_block = e->src;
+
e->flags &= ~EDGE_FALLTHRU;
if (target == EXIT_BLOCK_PTR)
{
JUMP_LABEL (jump_block->end) = label;
LABEL_NUSES (label)++;
}
+
emit_barrier_after (jump_block->end);
redirect_edge_succ_nodup (e, target);
/* Edge E is assumed to be fallthru edge. Emit needed jump instruction
(and possibly create new basic block) to make edge non-fallthru.
Return newly created BB or NULL if none. */
+
basic_block
force_nonfallthru (e)
edge e;
edge e;
basic_block target;
{
- basic_block new_bb;
-
- if (redirect_edge_and_branch (e, target))
- return NULL;
- if (e->dest == target)
+ if (redirect_edge_and_branch (e, target)
+ || e->dest == target)
return NULL;
/* In case the edge redirection failed, try to force it to be non-fallthru
and redirect newly created simplejump. */
- new_bb = force_nonfallthru_and_redirect (e, target);
- return new_bb;
+ return force_nonfallthru_and_redirect (e, target);
}
/* The given edge should potentially be a fallthru edge. If that is in
{
int i;
- for (i = 1; i < n_basic_blocks; ++i)
+ for (i = 1; i < n_basic_blocks; i++)
{
basic_block b = BASIC_BLOCK (i - 1);
basic_block c = BASIC_BLOCK (i);
Furthermore, the edge will be marked as a fallthru because we
merge the flags for the duplicate edges. So we do not want to
check that the edge is not a FALLTHRU edge. */
+
if ((s = b->succ) != NULL
&& ! (s->flags & EDGE_COMPLEX)
&& s->succ_next == NULL
if (bb1->index > bb2->index)
return false;
-
- if (bb1->index == bb2->index)
+ else if (bb1->index == bb2->index)
return true;
for (insn = bb1->end; insn != bb2->head && count >= 0;
{
if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_BEG)
count++;
- if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_END)
+ else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_END)
count--;
}
if ((edge_in->flags & EDGE_FALLTHRU) == 0)
{
edge e;
+
for (e = edge_in->dest->pred; e; e = e->pred_next)
if (e->flags & EDGE_FALLTHRU)
break;
if (edge_in->dest != EXIT_BLOCK_PTR
&& PREV_INSN (edge_in->dest->head)
&& GET_CODE (PREV_INSN (edge_in->dest->head)) == NOTE
- && NOTE_LINE_NUMBER (PREV_INSN (edge_in->dest->head)) == NOTE_INSN_LOOP_BEG
+ && (NOTE_LINE_NUMBER (PREV_INSN (edge_in->dest->head))
+ == NOTE_INSN_LOOP_BEG)
&& !back_edge_of_syntactic_loop_p (edge_in->dest, edge_in->src))
before = PREV_INSN (edge_in->dest->head);
else if (edge_in->dest != EXIT_BLOCK_PTR)
{
bb->global_live_at_start = OBSTACK_ALLOC_REG_SET (&flow_obstack);
bb->global_live_at_end = OBSTACK_ALLOC_REG_SET (&flow_obstack);
- COPY_REG_SET (bb->global_live_at_start, edge_in->dest->global_live_at_start);
- COPY_REG_SET (bb->global_live_at_end, edge_in->dest->global_live_at_start);
+ COPY_REG_SET (bb->global_live_at_start,
+ edge_in->dest->global_live_at_start);
+ COPY_REG_SET (bb->global_live_at_end,
+ edge_in->dest->global_live_at_start);
}
edge_out = make_single_succ_edge (bb, edge_in->dest, EDGE_FALLTHRU);
&& e->src != ENTRY_BLOCK_PTR)
{
bb = e->src;
+
/* It is possible to have a non-simple jump here. Consider a target
where some forms of unconditional jumps clobber a register. This
happens on the fr30 for example.
We know this block has a single successor, so we can just emit
the queued insns before the jump. */
if (GET_CODE (bb->end) == JUMP_INSN)
- {
- before = bb->end;
- while (GET_CODE (PREV_INSN (before)) == NOTE
- && NOTE_LINE_NUMBER (PREV_INSN (before)) == NOTE_INSN_LOOP_BEG)
- before = PREV_INSN (before);
- }
+ for (before = bb->end;
+ GET_CODE (PREV_INSN (before)) == NOTE
+ && NOTE_LINE_NUMBER (PREV_INSN (before)) == NOTE_INSN_LOOP_BEG;
+ before = PREV_INSN (before))
+ ;
else
{
/* We'd better be fallthru, or we've lost track of what's what. */
|| e->succ_next != NULL
|| (e->flags & EDGE_FALLTHRU) == 0)
abort ();
- e->flags &= ~EDGE_FALLTHRU;
+ e->flags &= ~EDGE_FALLTHRU;
emit_barrier_after (last);
if (before)
}
else if (GET_CODE (last) == JUMP_INSN)
abort ();
+
find_sub_basic_blocks (bb);
}
dump_regset (bb->global_live_at_start, outf);
putc ('\n', outf);
- for (insn = bb->head, last = NEXT_INSN (bb->end);
- insn != last;
+ for (insn = bb->head, last = NEXT_INSN (bb->end); insn != last;
insn = NEXT_INSN (insn))
print_rtl_single (outf, insn);
int i;
enum bb_state { NOT_IN_BB, IN_ONE_BB, IN_MULTIPLE_BB };
int max_uid = get_max_uid ();
- basic_block *start = (basic_block *)
- xcalloc (max_uid, sizeof (basic_block));
- basic_block *end = (basic_block *)
- xcalloc (max_uid, sizeof (basic_block));
- enum bb_state *in_bb_p = (enum bb_state *)
- xcalloc (max_uid, sizeof (enum bb_state));
+ basic_block *start
+ = (basic_block *) xcalloc (max_uid, sizeof (basic_block));
+ basic_block *end
+ = (basic_block *) xcalloc (max_uid, sizeof (basic_block));
+ enum bb_state *in_bb_p
+ = (enum bb_state *) xcalloc (max_uid, sizeof (enum bb_state));
for (i = n_basic_blocks - 1; i >= 0; i--)
{
for (x = bb->head; x != NULL_RTX; x = NEXT_INSN (x))
{
enum bb_state state = IN_MULTIPLE_BB;
+
if (in_bb_p[INSN_UID (x)] == NOT_IN_BB)
state = IN_ONE_BB;
in_bb_p[INSN_UID (x)] = state;
- scans body of the basic block for JUMP_INSN, CODE_LABEL
and NOTE_INSN_BASIC_BLOCK
- check that all insns are in the basic blocks
- (except the switch handling code, barriers and notes)
+ (except the switch handling code, barriers and notes)
- check that all returns are followed by barriers
In future it can be extended check a lot of other stuff as well
for (x = last_head; x != NULL_RTX; x = PREV_INSN (x))
if (x == end)
break;
+
if (!x)
{
error ("end insn %d for block %d not found in the insn stream",
INSN_UID (x), bb->index, bb_info[INSN_UID (x)]->index);
err = 1;
}
+
bb_info[INSN_UID (x)] = bb;
if (x == head)
int has_fallthru = 0;
edge e;
- e = bb->succ;
- while (e)
+ for (e = bb->succ; e; e = e->succ_next)
{
if (last_visited [e->dest->index + 2] == bb)
{
e->src->index, e->dest->index);
err = 1;
}
+
last_visited [e->dest->index + 2] = bb;
if (e->flags & EDGE_FALLTHRU)
&& e->dest != EXIT_BLOCK_PTR)
{
rtx insn;
+
if (e->src->index + 1 != e->dest->index)
{
- error ("verify_flow_info: Incorrect blocks for fallthru %i->%i",
- e->src->index, e->dest->index);
- err = 1;
+ error
+ ("verify_flow_info: Incorrect blocks for fallthru %i->%i",
+ e->src->index, e->dest->index);
+ err = 1;
}
else
for (insn = NEXT_INSN (e->src->end); insn != e->dest->head;
insn = NEXT_INSN (insn))
if (GET_CODE (insn) == BARRIER
#ifndef CASE_DROPS_THROUGH
- || INSN_P (insn))
+ || INSN_P (insn)
#else
- || (INSN_P (insn) && ! JUMP_TABLE_DATA_P (insn)))
+ || (INSN_P (insn) && ! JUMP_TABLE_DATA_P (insn))
#endif
+ )
{
error ("verify_flow_info: Incorrect fallthru %i->%i",
e->src->index, e->dest->index);
err = 1;
}
}
+
if (e->src != bb)
{
error ("verify_flow_info: Basic block %d succ edge is corrupted",
fprintf (stderr, "\n");
err = 1;
}
+
edge_checksum[e->dest->index + 2] += (size_t) e;
- e = e->succ_next;
}
+
if (!has_fallthru)
{
rtx insn;
}
}
- e = bb->pred;
- while (e)
+ for (e = bb->pred; e; e = e->pred_next)
{
if (e->dest != bb)
{
err = 1;
}
edge_checksum[e->dest->index + 2] -= (size_t) e;
- e = e->pred_next;
}
- for (x = bb->head; x != NEXT_INSN (bb->end); x = NEXT_INSN (x))
- if (basic_block_for_insn && BLOCK_FOR_INSN (x) != bb)
- {
- debug_rtx (x);
- if (! BLOCK_FOR_INSN (x))
- error ("insn %d is inside basic block %d but block_for_insn is NULL",
- INSN_UID (x), bb->index);
- else
- error ("insn %d is inside basic block %d but block_for_insn is %i",
- INSN_UID (x), bb->index, BLOCK_FOR_INSN (x)->index);
- err = 1;
- }
+
+ for (x = bb->head; x != NEXT_INSN (bb->end); x = NEXT_INSN (x))
+ if (basic_block_for_insn && BLOCK_FOR_INSN (x) != bb)
+ {
+ debug_rtx (x);
+ if (! BLOCK_FOR_INSN (x))
+ error
+ ("insn %d inside basic block %d but block_for_insn is NULL",
+ INSN_UID (x), bb->index);
+ else
+ error
+ ("insn %d inside basic block %d but block_for_insn is %i",
+ INSN_UID (x), bb->index, BLOCK_FOR_INSN (x)->index);
+
+ err = 1;
+ }
/* OK pointers are correct. Now check the header of basic
block. It ought to contain optional CODE_LABEL followed
bb->index);
err = 1;
}
+
x = NEXT_INSN (x);
}
+
if (!NOTE_INSN_BASIC_BLOCK_P (x) || NOTE_BASIC_BLOCK (x) != bb)
{
error ("NOTE_INSN_BASIC_BLOCK is missing for block %d",
}
if (bb->end == x)
- {
- /* Do checks for empty blocks here */
- }
+ /* Do checks for empty blocks her. e */
+ ;
else
- {
- x = NEXT_INSN (x);
- while (x)
- {
- if (NOTE_INSN_BASIC_BLOCK_P (x))
- {
- error ("NOTE_INSN_BASIC_BLOCK %d in the middle of basic block %d",
- INSN_UID (x), bb->index);
- err = 1;
- }
-
- if (x == bb->end)
- break;
-
- if (GET_CODE (x) == JUMP_INSN
- || GET_CODE (x) == CODE_LABEL
- || GET_CODE (x) == BARRIER)
- {
- error ("in basic block %d:", bb->index);
- fatal_insn ("flow control insn inside a basic block", x);
- }
+ for (x = NEXT_INSN (x); x; x = NEXT_INSN (x))
+ {
+ if (NOTE_INSN_BASIC_BLOCK_P (x))
+ {
+ error ("NOTE_INSN_BASIC_BLOCK %d in middle of basic block %d",
+ INSN_UID (x), bb->index);
+ err = 1;
+ }
+
+ if (x == bb->end)
+ break;
- x = NEXT_INSN (x);
- }
- }
+ if (GET_CODE (x) == JUMP_INSN
+ || GET_CODE (x) == CODE_LABEL
+ || GET_CODE (x) == BARRIER)
+ {
+ error ("in basic block %d:", bb->index);
+ fatal_insn ("flow control insn inside a basic block", x);
+ }
+ }
}
/* Complete edge checksumming for ENTRY and EXIT. */
{
edge e;
+
for (e = ENTRY_BLOCK_PTR->succ; e ; e = e->succ_next)
edge_checksum[e->dest->index + 2] += (size_t) e;
+
for (e = EXIT_BLOCK_PTR->pred; e ; e = e->pred_next)
edge_checksum[e->dest->index + 2] -= (size_t) e;
}
last_bb_num_seen = -1;
num_bb_notes = 0;
- x = rtx_first;
- while (x)
+ for (x = rtx_first; x; x = NEXT_INSN (x))
{
if (NOTE_INSN_BASIC_BLOCK_P (x))
{
basic_block bb = NOTE_BASIC_BLOCK (x);
+
num_bb_notes++;
if (bb->index != last_bb_num_seen + 1)
internal_error ("basic blocks not numbered consecutively");
&& GET_CODE (NEXT_INSN (x)) == JUMP_INSN
&& (GET_CODE (PATTERN (NEXT_INSN (x))) == ADDR_DIFF_VEC
|| GET_CODE (PATTERN (NEXT_INSN (x))) == ADDR_VEC))
- {
- x = NEXT_INSN (x);
- }
+ x = NEXT_INSN (x);
/* But in any case, non-deletable labels can appear anywhere. */
break;
&& returnjump_p (x) && ! condjump_p (x)
&& ! (NEXT_INSN (x) && GET_CODE (NEXT_INSN (x)) == BARRIER))
fatal_insn ("return not followed by barrier", x);
-
- x = NEXT_INSN (x);
}
if (num_bb_notes != n_basic_blocks)
rtx insn = bb->end, note;
bool purged = false;
+ /* ??? This makes no sense since the later test includes more cases. */
if (GET_CODE (insn) == JUMP_INSN && !simplejump_p (insn))
return false;
+
if (GET_CODE (insn) == JUMP_INSN)
{
rtx note;
edge b,f;
+
/* We do care only about conditional jumps and simplejumps. */
if (!any_condjump_p (insn)
&& !returnjump_p (insn)
&& !simplejump_p (insn))
return false;
+
for (e = bb->succ; e; e = next)
{
next = e->succ_next;
if ((e->flags & EDGE_FALLTHRU)
&& any_condjump_p (insn))
continue;
- if (e->dest != EXIT_BLOCK_PTR
- && e->dest->head == JUMP_LABEL (insn))
+ else if (e->dest != EXIT_BLOCK_PTR
+ && e->dest->head == JUMP_LABEL (insn))
continue;
- if (e->dest == EXIT_BLOCK_PTR
- && returnjump_p (insn))
+ else if (e->dest == EXIT_BLOCK_PTR
+ && returnjump_p (insn))
continue;
+
purged = true;
remove_edge (e);
}
+
if (!bb->succ || !purged)
return false;
+
if (rtl_dump_file)
fprintf (rtl_dump_file, "Purged edges from bb %i\n", bb->index);
+
if (!optimize)
return purged;
note = find_reg_note (insn, REG_BR_PROB, NULL);
if (!note)
return purged;
+
b = BRANCH_EDGE (bb);
f = FALLTHRU_EDGE (bb);
b->probability = INTVAL (XEXP (note, 0));
b->count = bb->count * b->probability / REG_BR_PROB_BASE;
f->count = bb->count * f->probability / REG_BR_PROB_BASE;
}
+
return purged;
}
&& (note = find_reg_note (insn, REG_EH_REGION, NULL)))
{
rtx eqnote;
+
if (! may_trap_p (PATTERN (insn))
|| ((eqnote = find_reg_equal_equiv_note (insn))
&& ! may_trap_p (XEXP (eqnote, 0))))
edge we know that there used to be a jump here and can then safely
remove all non-fallthru edges. */
for (e = bb->succ; e && (e->flags & (EDGE_COMPLEX | EDGE_FALLTHRU));
- e = e->succ_next);
+ e = e->succ_next)
+ ;
+
if (!e)
return purged;
+
for (e = bb->succ; e; e = next)
{
next = e->succ_next;
if (!(e->flags & EDGE_FALLTHRU))
remove_edge (e), purged = true;
}
+
if (!bb->succ || bb->succ->succ_next)
abort ();
+
bb->succ->probability = REG_BR_PROB_BASE;
bb->succ->count = bb->count;
return purged;
}
-/* Search all basic blocks for potentially dead edges and purge them.
-
- Return true iff some edge has been eliminated.
- */
+/* Search all basic blocks for potentially dead edges and purge them. Return
+ true if some edge has been eliminated. */
bool
purge_all_dead_edges (update_life_p)
blocks = sbitmap_alloc (n_basic_blocks);
sbitmap_zero (blocks);
}
+
for (i = 0; i < n_basic_blocks; i++)
{
- bool purged_here;
- purged_here = purge_dead_edges (BASIC_BLOCK (i));
+ bool purged_here = purge_dead_edges (BASIC_BLOCK (i));
+
purged |= purged_here;
if (purged_here && update_life_p)
SET_BIT (blocks, i);
}
+
if (update_life_p && purged)
update_life_info (blocks, UPDATE_LIFE_GLOBAL,
PROP_DEATH_NOTES | PROP_SCAN_DEAD_CODE
| PROP_KILL_DEAD_CODE);
+
if (update_life_p)
sbitmap_free (blocks);
return purged;
extern int for_each_rtx PARAMS ((rtx *, rtx_function, void *));
extern rtx regno_use_in PARAMS ((unsigned int, rtx));
extern int auto_inc_p PARAMS ((rtx));
+extern int in_expr_list_p PARAMS ((rtx, rtx));
extern void remove_node_from_expr_list PARAMS ((rtx, rtx *));
extern int insns_safe_to_move_p PARAMS ((rtx, rtx, rtx *));
extern int loc_mentioned_in_p PARAMS ((rtx *, rtx));
}
/* Search LISTP (an EXPR_LIST) for an entry whose first operand is NODE and
+ return 1 if it is found. A simple equality test is used to determine if
+ NODE matches. */
+
+int
+in_expr_list_p (listp, node)
+ rtx listp;
+ rtx node;
+{
+ rtx x;
+
+ for (x = listp; x; x = XEXP (x, 1))
+ if (node == XEXP (x, 0))
+ return 1;
+
+ return 0;
+}
+
+/* Search LISTP (an EXPR_LIST) for an entry whose first operand is NODE and
remove that entry from the list if it is found.
A simple equality test is used to determine if NODE matches. */
OSDN Git Service
