/* Control flow graph manipulation code for GNU compiler.
Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
- 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
+ 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
This file is part of GCC.
rtx insn, end, tmp;
/* If the head of this block is a CODE_LABEL, then it might be the
- label for an exception handler which can't be reached.
-
- We need to remove the label from the exception_handler_label list
- and remove the associated NOTE_INSN_EH_REGION_BEG and
- NOTE_INSN_EH_REGION_END notes. */
-
+ label for an exception handler which can't be reached. We need
+ to remove the label from the exception_handler_label list. */
insn = BB_HEAD (b);
-
if (LABEL_P (insn))
maybe_remove_eh_handler (insn);
if (tablejump_p (end, NULL, &tmp))
end = tmp;
- /* Include any barrier that may follow the basic block. */
+ /* Include any barriers that may follow the basic block. */
tmp = next_nonnote_insn (end);
- if (tmp && BARRIER_P (tmp))
- end = tmp;
+ while (tmp && BARRIER_P (tmp))
+ {
+ end = tmp;
+ tmp = next_nonnote_insn (end);
+ }
/* Selectively delete the entire chain. */
BB_HEAD (b) = NULL;
if (bb->global_live_at_start)
{
- new_bb->global_live_at_start = OBSTACK_ALLOC_REG_SET (®_obstack);
- new_bb->global_live_at_end = OBSTACK_ALLOC_REG_SET (®_obstack);
+ new_bb->global_live_at_start = ALLOC_REG_SET (®_obstack);
+ new_bb->global_live_at_end = ALLOC_REG_SET (®_obstack);
COPY_REG_SET (new_bb->global_live_at_end, bb->global_live_at_end);
/* We now have to calculate which registers are live at the end
{
basic_block src = e->src;
rtx insn = BB_END (src), kill_from;
- edge tmp;
rtx set;
int fallthru = 0;
- edge_iterator ei;
/* If we are partitioning hot/cold basic blocks, we don't want to
mess up unconditional or indirect jumps that cross between hot
|| BB_PARTITION (src) != BB_PARTITION (target)))
return NULL;
- /* Verify that all targets will be TARGET. */
- FOR_EACH_EDGE (tmp, ei, src->succs)
- if (tmp->dest != target && tmp != e)
- break;
+ /* We can replace or remove a complex jump only when we have exactly
+ two edges. Also, if we have exactly one outgoing edge, we can
+ redirect that. */
+ if (EDGE_COUNT (src->succs) >= 3
+ /* Verify that all targets will be TARGET. Specifically, the
+ edge that is not E must also go to TARGET. */
+ || (EDGE_COUNT (src->succs) == 2
+ && EDGE_SUCC (src, EDGE_SUCC (src, 0) == e)->dest != target))
+ return NULL;
- if (tmp || !onlyjump_p (insn))
+ if (!onlyjump_p (insn))
return NULL;
if ((!optimize || reload_completed) && tablejump_p (insn, NULL, NULL))
return NULL;
if (target->global_live_at_start)
{
- jump_block->global_live_at_start
- = OBSTACK_ALLOC_REG_SET (®_obstack);
- jump_block->global_live_at_end
- = OBSTACK_ALLOC_REG_SET (®_obstack);
+ jump_block->global_live_at_start = ALLOC_REG_SET (®_obstack);
+ jump_block->global_live_at_end = ALLOC_REG_SET (®_obstack);
COPY_REG_SET (jump_block->global_live_at_start,
target->global_live_at_start);
COPY_REG_SET (jump_block->global_live_at_end,
{
rtx q;
basic_block b = e->src, c = b->next_bb;
- edge e2;
- edge_iterator ei;
-
- FOR_EACH_EDGE (e2, ei, b->succs)
- if (e == e2)
- break;
/* ??? In a late-running flow pass, other folks may have deleted basic
blocks by nopping out blocks, leaving multiple BARRIERs between here
if (JUMP_P (q)
&& onlyjump_p (q)
&& (any_uncondjump_p (q)
- || (EDGE_SUCC (b, 0) == e && ei.index == EDGE_COUNT (b->succs) - 1)))
+ || EDGE_COUNT (b->succs) == 1))
{
#ifdef HAVE_cc0
/* If this was a conditional jump, we need to also delete
/* ??? This info is likely going to be out of date very soon. */
if (edge_in->dest->global_live_at_start)
{
- bb->global_live_at_start = OBSTACK_ALLOC_REG_SET (®_obstack);
- bb->global_live_at_end = OBSTACK_ALLOC_REG_SET (®_obstack);
+ bb->global_live_at_start = ALLOC_REG_SET (®_obstack);
+ bb->global_live_at_end = ALLOC_REG_SET (®_obstack);
COPY_REG_SET (bb->global_live_at_start,
edge_in->dest->global_live_at_start);
COPY_REG_SET (bb->global_live_at_end,
noccmode = false;
#endif
- killed = OBSTACK_ALLOC_REG_SET (®_obstack);
+ killed = ALLOC_REG_SET (®_obstack);
for (x = insn; x; x = NEXT_INSN (x))
if (INSN_P (x))
note_stores (PATTERN (x), mark_killed_regs, killed);
+
+ /* Mark all hard registers as killed. Register allocator/reload cannot
+ cope with the situation when life range of hard register spans operation
+ for that the appropriate register is needed, i.e. it would be unsafe to
+ extend the life ranges of hard registers. */
+ for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
+ if (!fixed_regs[regno]
+ && !REGNO_PTR_FRAME_P (regno))
+ SET_REGNO_REG_SET (killed, regno);
+
bitmap_and_into (killed, e->dest->global_live_at_start);
EXECUTE_IF_SET_IN_REG_SET (killed, 0, regno, rsi)
insert_insn_on_edge (insn, e);
FREE_REG_SET (killed);
+
return true;
}
rtx note;
edge_iterator ei;
- if (INSN_P (BB_END (bb))
+ if (JUMP_P (BB_END (bb))
&& (note = find_reg_note (BB_END (bb), REG_BR_PROB, NULL_RTX))
&& EDGE_COUNT (bb->succs) >= 2
&& any_condjump_p (BB_END (bb)))
else
for (insn = NEXT_INSN (BB_END (e->src)); insn != BB_HEAD (e->dest);
insn = NEXT_INSN (insn))
- if (BARRIER_P (insn)
-#ifndef CASE_DROPS_THROUGH
- || INSN_P (insn)
-#else
- || (INSN_P (insn) && ! JUMP_TABLE_DATA_P (insn))
-#endif
- )
+ if (BARRIER_P (insn) || INSN_P (insn))
{
error ("verify_flow_info: Incorrect fallthru %i->%i",
e->src->index, e->dest->index);
of conditional jump, remove it. */
if (EDGE_COUNT (src->succs) == 2)
{
- bool found = false;
- unsigned ix = 0;
- edge tmp, s;
- edge_iterator ei;
-
- FOR_EACH_EDGE (tmp, ei, src->succs)
- if (e == tmp)
- {
- found = true;
- ix = ei.index;
- break;
- }
-
- gcc_assert (found);
-
- if (EDGE_COUNT (src->succs) > (ix + 1))
- s = EDGE_SUCC (src, ix + 1);
- else
- s = EDGE_SUCC (src, 0);
+ /* Find the edge that is different from E. */
+ edge s = EDGE_SUCC (src, EDGE_SUCC (src, 0) == e);
if (s->dest == dest
&& any_condjump_p (BB_END (src))
create it to avoid getting an ICE later. */
if (e->dest->global_live_at_start)
{
- new_bb->global_live_at_start = OBSTACK_ALLOC_REG_SET (®_obstack);
- new_bb->global_live_at_end = OBSTACK_ALLOC_REG_SET (®_obstack);
+ new_bb->global_live_at_start = ALLOC_REG_SET (®_obstack);
+ new_bb->global_live_at_end = ALLOC_REG_SET (®_obstack);
COPY_REG_SET (new_bb->global_live_at_start,
e->dest->global_live_at_start);
COPY_REG_SET (new_bb->global_live_at_end,
if ((CALL_P (insn)
&& !SIBLING_CALL_P (insn)
&& !find_reg_note (insn, REG_NORETURN, NULL)
- && !find_reg_note (insn, REG_ALWAYS_RETURN, NULL)
&& !CONST_OR_PURE_CALL_P (insn)))
return true;
OSDN Git Service
