#include "expr.h"
#define FORWARDER_BLOCK_P(BB) ((BB)->flags & BB_FORWARDER_BLOCK)
-
+
/* Set to true when we are running first pass of try_optimize_cfg loop. */
static bool first_pass;
static bool try_crossjump_to_edge (int, edge, edge);
/* If we are partitioning hot/cold basic blocks, we don't want to
mess up unconditional or indirect jumps that cross between hot
- and cold sections.
+ and cold sections.
Basic block partitioning may result in some jumps that appear to
- be optimizable (or blocks that appear to be mergeable), but which really
- must be left untouched (they are required to make it safely across
- partition boundaries). See the comments at the top of
+ be optimizable (or blocks that appear to be mergeable), but which really
+ must be left untouched (they are required to make it safely across
+ partition boundaries). See the comments at the top of
bb-reorder.c:partition_hot_cold_basic_blocks for complete details. */
if (BB_PARTITION (jump_block) != BB_PARTITION (jump_dest_block)
switch (GET_CODE (exp))
{
/* In case we do clobber the register, mark it as equal, as we know the
- value is dead so it don't have to match. */
+ value is dead so it don't have to match. */
case CLOBBER:
if (REG_P (XEXP (exp, 0)))
{
/* If we are partitioning hot/cold basic blocks, we don't want to
mess up unconditional or indirect jumps that cross between hot
- and cold sections.
-
+ and cold sections.
+
Basic block partitioning may result in some jumps that appear to
be optimizable (or blocks that appear to be mergeable), but which really m
- ust be left untouched (they are required to make it safely across
- partition boundaries). See the comments at the top of
+ ust be left untouched (they are required to make it safely across
+ partition boundaries). See the comments at the top of
bb-reorder.c:partition_hot_cold_basic_blocks for complete details. */
if (find_reg_note (BB_END (b), REG_CROSSING_JUMP, NULL_RTX))
/* Skip complex edges because we don't know how to update them.
- Still handle fallthru edges, as we can succeed to forward fallthru
- edge to the same place as the branch edge of conditional branch
- and turn conditional branch to an unconditional branch. */
+ Still handle fallthru edges, as we can succeed to forward fallthru
+ edge to the same place as the branch edge of conditional branch
+ and turn conditional branch to an unconditional branch. */
if (e->flags & EDGE_COMPLEX)
{
ei_next (&ei);
up jumps that cross between hot/cold sections.
Basic block partitioning may result in some jumps that appear
- to be optimizable (or blocks that appear to be mergeable), but which
- really must be left untouched (they are required to make it safely
+ to be optimizable (or blocks that appear to be mergeable), but which
+ really must be left untouched (they are required to make it safely
across partition boundaries). See the comments at the top of
bb-reorder.c:partition_hot_cold_basic_blocks for complete
details. */
may_thread |= target->flags & BB_DIRTY;
if (FORWARDER_BLOCK_P (target)
- && !(single_succ_edge (target)->flags & EDGE_CROSSING)
+ && !(single_succ_edge (target)->flags & EDGE_CROSSING)
&& single_succ (target) != EXIT_BLOCK_PTR)
{
/* Bypass trivial infinite loops. */
if (t)
{
if (!threaded_edges)
- threaded_edges = xmalloc (sizeof (*threaded_edges)
- * n_basic_blocks);
+ threaded_edges = XNEWVEC (edge, n_basic_blocks);
else
{
int i;
if (!new_target)
break;
- /* Avoid killing of loop pre-headers, as it is the place loop
- optimizer wants to hoist code to.
-
- For fallthru forwarders, the LOOP_BEG note must appear between
- the header of block and CODE_LABEL of the loop, for non forwarders
- it must appear before the JUMP_INSN. */
- if ((mode & CLEANUP_PRE_LOOP) && optimize && flag_loop_optimize)
- {
- rtx insn = (EDGE_SUCC (target, 0)->flags & EDGE_FALLTHRU
- ? BB_HEAD (target) : prev_nonnote_insn (BB_END (target)));
-
- if (!NOTE_P (insn))
- insn = NEXT_INSN (insn);
-
- for (; insn && !LABEL_P (insn) && !INSN_P (insn);
- insn = NEXT_INSN (insn))
- if (NOTE_P (insn)
- && NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_BEG)
- break;
-
- if (insn && NOTE_P (insn))
- break;
-
- /* Do not clean up branches to just past the end of a loop
- at this time; it can mess up the loop optimizer's
- recognition of some patterns. */
-
- insn = PREV_INSN (BB_HEAD (target));
- if (insn && NOTE_P (insn)
- && NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_END)
- break;
- }
-
counter++;
target = new_target;
threaded |= new_target_threaded;
/* If we are partitioning hot/cold basic blocks, we don't want to
mess up unconditional or indirect jumps that cross between hot
and cold sections.
-
+
Basic block partitioning may result in some jumps that appear to
- be optimizable (or blocks that appear to be mergeable), but which really
- must be left untouched (they are required to make it safely across
- partition boundaries). See the comments at the top of
+ be optimizable (or blocks that appear to be mergeable), but which really
+ must be left untouched (they are required to make it safely across
+ partition boundaries). See the comments at the top of
bb-reorder.c:partition_hot_cold_basic_blocks for complete details. */
if (BB_PARTITION (a) != BB_PARTITION (b))
/* If we are partitioning hot/cold basic blocks, we don't want to
mess up unconditional or indirect jumps that cross between hot
- and cold sections.
-
+ and cold sections.
+
Basic block partitioning may result in some jumps that appear to
- be optimizable (or blocks that appear to be mergeable), but which really
- must be left untouched (they are required to make it safely across
- partition boundaries). See the comments at the top of
+ be optimizable (or blocks that appear to be mergeable), but which really
+ must be left untouched (they are required to make it safely across
+ partition boundaries). See the comments at the top of
bb-reorder.c:partition_hot_cold_basic_blocks for complete details. */
if (BB_PARTITION (a) != BB_PARTITION (b))
necessary. */
only_notes = squeeze_notes (&BB_HEAD (b), &BB_END (b));
gcc_assert (!only_notes);
-
+
/* Scramble the insn chain. */
reorder_insns_nobb (BB_HEAD (b), BB_END (b), BB_END (a));
/* If we are partitioning hot/cold basic blocks, we don't want to
mess up unconditional or indirect jumps that cross between hot
- and cold sections.
-
+ and cold sections.
+
Basic block partitioning may result in some jumps that appear to
- be optimizable (or blocks that appear to be mergeable), but which really
- must be left untouched (they are required to make it safely across
- partition boundaries). See the comments at the top of
+ be optimizable (or blocks that appear to be mergeable), but which really
+ must be left untouched (they are required to make it safely across
+ partition boundaries). See the comments at the top of
bb-reorder.c:partition_hot_cold_basic_blocks for complete details. */
if (BB_PARTITION (b) != BB_PARTITION (c))
return NULL;
-
-
+
+
/* If B has a fallthru edge to C, no need to move anything. */
if (e->flags & EDGE_FALLTHRU)
edge_iterator ei;
/* Avoid overactive code motion, as the forwarder blocks should be
- eliminated by edge redirection instead. One exception might have
+ eliminated by edge redirection instead. One exception might have
been if B is a forwarder block and C has no fallthru edge, but
that should be cleaned up by bb-reorder instead. */
if (FORWARDER_BLOCK_P (b) || FORWARDER_BLOCK_P (c))
if (! c_has_outgoing_fallthru)
{
merge_blocks_move_successor_nojumps (b, c);
- return next == ENTRY_BLOCK_PTR ? next->next_bb : next;
+ return next == ENTRY_BLOCK_PTR ? next->next_bb : next;
}
/* If B does not have an incoming fallthru, then it can be moved
MEM_ATTRS (y) = 0;
else if (! MEM_ATTRS (y))
MEM_ATTRS (x) = 0;
- else
+ else
{
rtx mem_size;
set_mem_alias_set (x, 0);
set_mem_alias_set (y, 0);
}
-
+
if (! mem_expr_equal_p (MEM_EXPR (x), MEM_EXPR (y)))
{
set_mem_expr (x, 0);
set_mem_offset (x, 0);
set_mem_offset (y, 0);
}
-
+
if (!MEM_SIZE (x))
mem_size = NULL_RTX;
else if (!MEM_SIZE (y))
set_mem_align (y, MEM_ALIGN (x));
}
}
-
+
fmt = GET_RTX_FORMAT (code);
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
{
if (CALL_P (i1)
&& (!rtx_equal_p (CALL_INSN_FUNCTION_USAGE (i1),
- CALL_INSN_FUNCTION_USAGE (i2))
+ CALL_INSN_FUNCTION_USAGE (i2))
|| SIBLING_CALL_P (i1) != SIBLING_CALL_P (i2)))
return false;
if ((mode & CLEANUP_POST_REGSTACK) && stack_regs_mentioned (i1))
{
/* If register stack conversion has already been done, then
- death notes must also be compared before it is certain that
- the two instruction streams match. */
+ death notes must also be compared before it is certain that
+ the two instruction streams match. */
rtx note;
HARD_REG_SET i1_regset, i2_regset;
f2 = FALLTHRU_EDGE (bb2);
/* Get around possible forwarders on fallthru edges. Other cases
- should be optimized out already. */
+ should be optimized out already. */
if (FORWARDER_BLOCK_P (f1->dest))
f1 = single_succ_edge (f1->dest);
FOR_EACH_EDGE (e1, ei, bb1->succs)
{
e2 = EDGE_SUCC (bb2, ei.index);
-
+
if (e1->flags & EDGE_EH)
nehedges1++;
return false;
}
- /* We don't need to match the rest of edges as above checks should be enough
- to ensure that they are equivalent. */
+ /* The same checks as in try_crossjump_to_edge. It is required for RTL
+ version of sequence abstraction. */
+ FOR_EACH_EDGE (e1, ei, bb2->succs)
+ {
+ edge e2;
+ edge_iterator ei;
+ basic_block d1 = e1->dest;
+
+ if (FORWARDER_BLOCK_P (d1))
+ d1 = EDGE_SUCC (d1, 0)->dest;
+
+ FOR_EACH_EDGE (e2, ei, bb1->succs)
+ {
+ basic_block d2 = e2->dest;
+ if (FORWARDER_BLOCK_P (d2))
+ d2 = EDGE_SUCC (d2, 0)->dest;
+ if (d1 == d2)
+ break;
+ }
+
+ if (!e2)
+ return false;
+ }
+
return true;
}
+/* Returns true if BB basic block has a preserve label. */
+
+static bool
+block_has_preserve_label (basic_block bb)
+{
+ return (bb
+ && block_label (bb)
+ && LABEL_PRESERVE_P (block_label (bb)));
+}
+
/* E1 and E2 are edges with the same destination block. Search their
predecessors for common code. If found, redirect control flow from
(maybe the middle of) E1->SRC to (maybe the middle of) E2->SRC. */
newpos1 = newpos2 = NULL_RTX;
/* If we have partitioned hot/cold basic blocks, it is a bad idea
- to try this optimization.
+ to try this optimization.
Basic block partitioning may result in some jumps that appear to
- be optimizable (or blocks that appear to be mergeable), but which really
- must be left untouched (they are required to make it safely across
- partition boundaries). See the comments at the top of
+ be optimizable (or blocks that appear to be mergeable), but which really
+ must be left untouched (they are required to make it safely across
+ partition boundaries). See the comments at the top of
bb-reorder.c:partition_hot_cold_basic_blocks for complete details. */
if (flag_reorder_blocks_and_partition && no_new_pseudos)
&& (newpos1 != BB_HEAD (src1)))
return false;
+ /* Avoid deleting preserve label when redirecting ABNORMAL edges. */
+ if (block_has_preserve_label (e1->dest)
+ && (e1->flags & EDGE_ABNORMAL))
+ return false;
+
/* Here we know that the insns in the end of SRC1 which are common with SRC2
will be deleted.
If we have tablejumps in the end of SRC1 and SRC2
redirect_to->count += src1->count;
redirect_to->frequency += src1->frequency;
- /* We may have some registers visible trought the block. */
+ /* We may have some registers visible through the block. */
redirect_to->flags |= BB_DIRTY;
/* Recompute the frequencies and counts of outgoing edges. */
s->count += s2->count;
/* Take care to update possible forwarder blocks. We verified
- that there is no more than one in the chain, so we can't run
- into infinite loop. */
+ that there is no more than one in the chain, so we can't run
+ into infinite loop. */
if (FORWARDER_BLOCK_P (s->dest))
{
single_succ_edge (s->dest)->count += s2->count;
/* If we are partitioning hot/cold basic blocks, we don't want to
mess up unconditional or indirect jumps that cross between hot
- and cold sections.
-
+ and cold sections.
+
Basic block partitioning may result in some jumps that appear to
- be optimizable (or blocks that appear to be mergeable), but which really
- must be left untouched (they are required to make it safely across
- partition boundaries). See the comments at the top of
+ be optimizable (or blocks that appear to be mergeable), but which really
+ must be left untouched (they are required to make it safely across
+ partition boundaries). See the comments at the top of
bb-reorder.c:partition_hot_cold_basic_blocks for complete details. */
- if (BB_PARTITION (EDGE_PRED (bb, 0)->src) !=
- BB_PARTITION (EDGE_PRED (bb, 1)->src)
+ if (BB_PARTITION (EDGE_PRED (bb, 0)->src) !=
+ BB_PARTITION (EDGE_PRED (bb, 1)->src)
|| (EDGE_PRED (bb, 0)->flags & EDGE_CROSSING))
return false;
FOR_EACH_EDGE (e, ei, bb->preds)
{
if (e->flags & EDGE_FALLTHRU)
- fallthru = e;
+ fallthru = e;
}
changed = false;
does not fit merge_blocks interface and is kept here in
hope that it will become useless once more of compiler
is transformed to use cfg_layout mode. */
-
+
if ((mode & CLEANUP_CFGLAYOUT)
&& can_merge_blocks_p (b, c))
{
PROP_DEATH_NOTES
| PROP_SCAN_DEAD_CODE
| PROP_KILL_DEAD_CODE
- | ((mode & CLEANUP_LOG_LINKS)
+ | ((mode & CLEANUP_LOG_LINKS)
? PROP_LOG_LINKS : 0)))
break;
}
return changed;
}
\f
-static void
+static unsigned int
rest_of_handle_jump (void)
{
delete_unreachable_blocks ();
if (cfun->tail_call_emit)
fixup_tail_calls ();
+ return 0;
}
struct tree_opt_pass pass_jump =
{
"sibling", /* name */
- NULL, /* gate */
- rest_of_handle_jump, /* execute */
+ NULL, /* gate */
+ rest_of_handle_jump, /* execute */
NULL, /* sub */
NULL, /* next */
0, /* static_pass_number */
};
-static void
+static unsigned int
rest_of_handle_jump2 (void)
{
/* Turn NOTE_INSN_EXPECTED_VALUE into REG_BR_PROB. Do this
delete_trivially_dead_insns (get_insns (), max_reg_num ());
reg_scan (get_insns (), max_reg_num ());
if (dump_file)
- dump_flow_info (dump_file);
- cleanup_cfg ((optimize ? CLEANUP_EXPENSIVE : 0) | CLEANUP_PRE_LOOP
- | (flag_thread_jumps ? CLEANUP_THREADING : 0));
-
- create_loop_notes ();
+ dump_flow_info (dump_file, dump_flags);
+ cleanup_cfg ((optimize ? CLEANUP_EXPENSIVE : 0)
+ | (flag_thread_jumps ? CLEANUP_THREADING : 0));
purge_line_number_notes ();
if (optimize)
- cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
+ cleanup_cfg (CLEANUP_EXPENSIVE);
/* Jump optimization, and the removal of NULL pointer checks, may
have reduced the number of instructions substantially. CSE, and
future passes, allocate arrays whose dimensions involve the
maximum instruction UID, so if we can reduce the maximum UID
we'll save big on memory. */
- renumber_insns (dump_file);
+ renumber_insns ();
+ return 0;
}
struct tree_opt_pass pass_jump2 =
{
"jump", /* name */
- NULL, /* gate */
- rest_of_handle_jump2, /* execute */
+ NULL, /* gate */
+ rest_of_handle_jump2, /* execute */
NULL, /* sub */
NULL, /* next */
0, /* static_pass_number */
OSDN Git Service
