#include "config.h"
#include "system.h"
+#include "coretypes.h"
+#include "tm.h"
#include "rtl.h"
#include "hard-reg-set.h"
#include "basic-block.h"
#include "recog.h"
#include "toplev.h"
#include "cselib.h"
+#include "params.h"
#include "tm_p.h"
#include "target.h"
basic_block));
static void merge_blocks_move_successor_nojumps PARAMS ((basic_block,
basic_block));
-static bool merge_blocks PARAMS ((edge,basic_block,basic_block,
+static basic_block merge_blocks PARAMS ((edge,basic_block,basic_block,
int));
static bool try_optimize_cfg PARAMS ((int));
static bool try_simplify_condjump PARAMS ((basic_block));
update_br_prob_note (cbranch_block);
/* Delete the block with the unconditional jump, and clean up the mess. */
- flow_delete_block (jump_block);
+ delete_block (jump_block);
tidy_fallthru_edge (cbranch_jump_edge, cbranch_block, cbranch_dest_block);
return true;
return 0;
}
/* Attempt to prove that the basic block B will have no side effects and
- allways continues in the same edge if reached via E. Return the edge
+ always continues in the same edge if reached via E. Return the edge
if exist, NULL otherwise. */
static edge
return NULL;
/* Ensure that the comparison operators are equivalent.
- ??? This is far too pesimistic. We should allow swapped operands,
+ ??? This is far too pessimistic. We should allow swapped operands,
different CCmodes, or for example comparisons for interval, that
dominate even when operands are not equivalent. */
if (!rtx_equal_p (XEXP (cond1, 0), XEXP (cond2, 0))
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)
+ if ((mode & CLEANUP_PRE_LOOP) && optimize)
{
rtx insn = (target->succ->flags & EDGE_FALLTHRU
? target->head : prev_nonnote_insn (target->end));
/* 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. */
+ recognition of some patterns. */
insn = PREV_INSN (target->head);
if (insn && GET_CODE (insn) == NOTE
if (label == tmp)
return true;
- if (tmp != NULL_RTX
- && (tmp = NEXT_INSN (tmp)) != NULL_RTX
- && GET_CODE (tmp) == JUMP_INSN
- && (tmp = PATTERN (tmp),
- GET_CODE (tmp) == ADDR_VEC
- || GET_CODE (tmp) == ADDR_DIFF_VEC))
+ if (tablejump_p (jump_insn, NULL, &tmp))
{
rtvec vec = XVEC (tmp, GET_CODE (tmp) == ADDR_DIFF_VEC);
int i, veclen = GET_NUM_ELEM (vec);
}
/* Attempt to merge basic blocks that are potentially non-adjacent.
- Return true iff the attempt succeeded. */
-
-static bool
+ Return NULL iff the attempt failed, otherwise return basic block
+ where cleanup_cfg should continue. Because the merging commonly
+ moves basic block away or introduces another optimization
+ possiblity, return basic block just before B so cleanup_cfg don't
+ need to iterate.
+
+ It may be good idea to return basic block before C in the case
+ C has been moved after B and originally appeared earlier in the
+ insn seqeunce, but we have no infromation available about the
+ relative ordering of these two. Hopefully it is not too common. */
+
+static basic_block
merge_blocks (e, b, c, mode)
edge e;
basic_block b, c;
int mode;
{
+ basic_block next;
/* If C has a tail recursion label, do not merge. There is no
edge recorded from the call_placeholder back to this label, as
that would make optimize_sibling_and_tail_recursive_calls more
if ((mode & CLEANUP_PRE_SIBCALL)
&& GET_CODE (c->head) == CODE_LABEL
&& tail_recursion_label_p (c->head))
- return false;
+ return NULL;
/* If B has a fallthru edge to C, no need to move anything. */
if (e->flags & EDGE_FALLTHRU)
fprintf (rtl_dump_file, "Merged %d and %d without moving.\n",
b_index, c_index);
- return true;
+ return b->prev_bb == ENTRY_BLOCK_PTR ? b : b->prev_bb;
}
/* Otherwise we will need to move code around. Do that only if expensive
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))
- return false;
+ return NULL;
/* We must make sure to not munge nesting of lexical blocks,
and loop notes. This is done by squeezing out all the notes
b_has_incoming_fallthru = (tmp_edge != NULL);
b_fallthru_edge = tmp_edge;
+ next = b->prev_bb;
+ if (next == c)
+ next = next->prev_bb;
/* Otherwise, we're going to try to move C after B. If C does
not have an outgoing fallthru, then it can be moved
if (! c_has_outgoing_fallthru)
{
merge_blocks_move_successor_nojumps (b, c);
- return true;
+ return next == ENTRY_BLOCK_PTR ? next->next_bb : next;
}
/* If B does not have an incoming fallthru, then it can be moved
basic_block bb;
if (b_fallthru_edge->src == ENTRY_BLOCK_PTR)
- return false;
+ return NULL;
bb = force_nonfallthru (b_fallthru_edge);
if (bb)
notice_new_block (bb);
}
merge_blocks_move_predecessor_nojumps (b, c);
- return true;
+ return next == ENTRY_BLOCK_PTR ? next->next_bb : next;
}
- return false;
+ return NULL;
}
\f
equal, they were constructed identically. */
if (GET_CODE (i1) == CALL_INSN
- && !rtx_equal_p (CALL_INSN_FUNCTION_USAGE (i1),
- CALL_INSN_FUNCTION_USAGE (i2)))
+ && (!rtx_equal_p (CALL_INSN_FUNCTION_USAGE (i1),
+ CALL_INSN_FUNCTION_USAGE (i2))
+ || SIBLING_CALL_P (i1) != SIBLING_CALL_P (i2)))
return false;
#ifdef STACK_REGS
#endif
if (reload_completed
- ? ! rtx_renumbered_equal_p (p1, p2) : ! rtx_equal_p (p1, p2))
+ ? rtx_renumbered_equal_p (p1, p2) : rtx_equal_p (p1, p2))
+ return true;
+
+ /* Do not do EQUIV substitution after reload. First, we're undoing the
+ work of reload_cse. Second, we may be undoing the work of the post-
+ reload splitting pass. */
+ /* ??? Possibly add a new phase switch variable that can be used by
+ targets to disallow the troublesome insns after splitting. */
+ if (!reload_completed)
{
/* The following code helps take care of G++ cleanups. */
rtx equiv1 = find_reg_equal_equiv_note (i1);
return true;
}
}
-
- return false;
}
- return true;
+ return false;
}
\f
/* Look through the insns at the end of BB1 and BB2 and find the longest
while (true)
{
/* Ignore notes. */
- while (!active_insn_p (i1) && i1 != bb1->head)
+ while (!INSN_P (i1) && i1 != bb1->head)
i1 = PREV_INSN (i1);
- while (!active_insn_p (i2) && i2 != bb2->head)
+ while (!INSN_P (i2) && i2 != bb2->head)
i2 = PREV_INSN (i2);
if (i1 == bb1->head || i2 == bb2->head)
if (!insns_match_p (mode, i1, i2))
break;
- /* Don't begin a cross-jump with a USE or CLOBBER insn. */
- if (active_insn_p (i1))
+ /* Don't begin a cross-jump with a NOTE insn. */
+ if (INSN_P (i1))
{
/* If the merged insns have different REG_EQUAL notes, then
remove them. */
Two, it keeps line number notes as matched as may be. */
if (ninsns)
{
- while (last1 != bb1->head && !active_insn_p (PREV_INSN (last1)))
+ while (last1 != bb1->head && !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)))
+ while (last2 != bb2->head && !INSN_P (PREV_INSN (last2)))
last2 = PREV_INSN (last2);
if (last2 != bb2->head && GET_CODE (PREV_INSN (last2)) == CODE_LABEL)
/* If BB1 has only one successor, we may be looking at either an
unconditional jump, or a fake edge to exit. */
if (bb1->succ && !bb1->succ->succ_next
- && !(bb1->succ->flags & (EDGE_COMPLEX | EDGE_FAKE)))
+ && (bb1->succ->flags & (EDGE_COMPLEX | EDGE_FAKE)) == 0
+ && (GET_CODE (bb1->end) != JUMP_INSN || simplejump_p (bb1->end)))
return (bb2->succ && !bb2->succ->succ_next
- && (bb2->succ->flags & (EDGE_COMPLEX | EDGE_FAKE)) == 0);
+ && (bb2->succ->flags & (EDGE_COMPLEX | EDGE_FAKE)) == 0
+ && (GET_CODE (bb2->end) != JUMP_INSN || simplejump_p (bb2->end)));
/* Match conditional jumps - this may get tricky when fallthru and branch
edges are crossed. */
|| !onlyjump_p (bb2->end))
return false;
- /* Do not crossjump across loop boundaries. This is a temporary
- workaround for the common scenario in which crossjumping results
- in killing the duplicated loop condition, making bb-reorder rotate
- the loop incorectly, leaving an extra unconditional jump inside
- the loop.
-
- This check should go away once bb-reorder knows how to duplicate
- code in this case or rotate the loops to avoid this scenario. */
- if (bb1->loop_depth != bb2->loop_depth)
- return false;
-
b1 = BRANCH_EDGE (bb1);
b2 = BRANCH_EDGE (bb2);
f1 = FALLTHRU_EDGE (bb1);
return match;
}
- /* Generic case - we are seeing an computed jump, table jump or trapping
+ /* Generic case - we are seeing a computed jump, table jump or trapping
instruction. */
+#ifndef CASE_DROPS_THROUGH
+ /* Check whether there are tablejumps in the end of BB1 and BB2.
+ Return true if they are identical. */
+ {
+ rtx label1, label2;
+ rtx table1, table2;
+
+ if (tablejump_p (bb1->end, &label1, &table1)
+ && tablejump_p (bb2->end, &label2, &table2)
+ && GET_CODE (PATTERN (table1)) == GET_CODE (PATTERN (table2)))
+ {
+ /* The labels should never be the same rtx. If they really are same
+ the jump tables are same too. So disable crossjumping of blocks BB1
+ and BB2 because when deleting the common insns in the end of BB1
+ by delete_block () the jump table would be deleted too. */
+ /* If LABEL2 is referenced in BB1->END do not do anything
+ because we would loose information when replacing
+ LABEL1 by LABEL2 and then LABEL2 by LABEL1 in BB1->END. */
+ if (label1 != label2 && !rtx_referenced_p (label2, bb1->end))
+ {
+ /* Set IDENTICAL to true when the tables are identical. */
+ bool identical = false;
+ rtx p1, p2;
+
+ p1 = PATTERN (table1);
+ p2 = PATTERN (table2);
+ if (GET_CODE (p1) == ADDR_VEC && rtx_equal_p (p1, p2))
+ {
+ identical = true;
+ }
+ else if (GET_CODE (p1) == ADDR_DIFF_VEC
+ && (XVECLEN (p1, 1) == XVECLEN (p2, 1))
+ && rtx_equal_p (XEXP (p1, 2), XEXP (p2, 2))
+ && rtx_equal_p (XEXP (p1, 3), XEXP (p2, 3)))
+ {
+ int i;
+
+ identical = true;
+ for (i = XVECLEN (p1, 1) - 1; i >= 0 && identical; i--)
+ if (!rtx_equal_p (XVECEXP (p1, 1, i), XVECEXP (p2, 1, i)))
+ identical = false;
+ }
+
+ if (identical)
+ {
+ replace_label_data rr;
+ bool match;
+
+ /* Temporarily replace references to LABEL1 with LABEL2
+ in BB1->END so that we could compare the instructions. */
+ rr.r1 = label1;
+ rr.r2 = label2;
+ rr.update_label_nuses = false;
+ for_each_rtx (&bb1->end, replace_label, &rr);
+
+ match = insns_match_p (mode, bb1->end, bb2->end);
+ if (rtl_dump_file && match)
+ fprintf (rtl_dump_file,
+ "Tablejumps in bb %i and %i match.\n",
+ bb1->index, bb2->index);
+
+ /* Set the original label in BB1->END because when deleting
+ a block whose end is a tablejump, the tablejump referenced
+ from the instruction is deleted too. */
+ rr.r1 = label2;
+ rr.r2 = label1;
+ for_each_rtx (&bb1->end, replace_label, &rr);
+
+ return match;
+ }
+ }
+ return false;
+ }
+ }
+#endif
+
/* First ensure that the instructions match. There may be many outgoing
- edges so this test is generally cheaper.
- ??? Currently the tablejumps will never match, as they do have
- different tables. */
+ edges so this test is generally cheaper. */
if (!insns_match_p (mode, bb1->end, bb2->end))
return false;
if (!nmatch)
return false;
+#ifndef CASE_DROPS_THROUGH
+ /* 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
+ they have been already compared for equivalence in outgoing_edges_match ()
+ so replace the references to TABLE1 by references to TABLE2. */
+ {
+ rtx label1, label2;
+ rtx table1, table2;
+
+ if (tablejump_p (src1->end, &label1, &table1)
+ && tablejump_p (src2->end, &label2, &table2)
+ && label1 != label2)
+ {
+ replace_label_data rr;
+ rtx insn;
+
+ /* Replace references to LABEL1 with LABEL2. */
+ rr.r1 = label1;
+ rr.r2 = label2;
+ rr.update_label_nuses = true;
+ for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
+ {
+ /* Do not replace the label in SRC1->END because when deleting
+ a block whose end is a tablejump, the tablejump referenced
+ from the instruction is deleted too. */
+ if (insn != src1->end)
+ for_each_rtx (&insn, replace_label, &rr);
+ }
+ }
+ }
+#endif
+
/* Avoid splitting if possible. */
if (newpos2 == src2->head)
redirect_to = src2;
to_remove = redirect_from->succ->dest;
redirect_edge_and_branch_force (redirect_from->succ, redirect_to);
- flow_delete_block (to_remove);
+ delete_block (to_remove);
update_forwarder_flag (redirect_from);
{
edge e, e2, nexte2, nexte, fallthru;
bool changed;
- int n = 0;
+ int n = 0, max;
/* Nothing to do if there is not at least two incoming edges. */
if (!bb->pred || !bb->pred->pred_next)
/* It is always cheapest to redirect a block that ends in a branch to
a block that falls through into BB, as that adds no branches to the
program. We'll try that combination first. */
- for (fallthru = bb->pred; fallthru; fallthru = fallthru->pred_next, n++)
+ fallthru = NULL;
+ max = PARAM_VALUE (PARAM_MAX_CROSSJUMP_EDGES);
+ for (e = bb->pred; e ; e = e->pred_next, n++)
{
- if (fallthru->flags & EDGE_FALLTHRU)
- break;
- if (n > 100)
+ if (e->flags & EDGE_FALLTHRU)
+ fallthru = e;
+ if (n > max)
return false;
}
bool changed_overall = false;
bool changed;
int iterations = 0;
- basic_block bb, b;
+ basic_block bb, b, next;
if (mode & CLEANUP_CROSSJUMP)
add_noreturn_fake_exit_edges ();
fprintf (rtl_dump_file, "Deleting block %i.\n",
b->index);
- flow_delete_block (b);
+ delete_block (b);
changed = true;
b = c;
}
c = b->prev_bb == ENTRY_BLOCK_PTR ? b->next_bb : b->prev_bb;
redirect_edge_succ_nodup (b->pred, b->succ->dest);
- flow_delete_block (b);
+ delete_block (b);
changed = true;
b = c;
}
- /* Merge blocks. Loop because chains of blocks might be
- combineable. */
- while ((s = b->succ) != NULL
- && s->succ_next == NULL
- && !(s->flags & EDGE_COMPLEX)
- && (c = s->dest) != EXIT_BLOCK_PTR
- && c->pred->pred_next == NULL
- && b != c
- /* If the jump insn has side effects,
- we can't kill the edge. */
- && (GET_CODE (b->end) != JUMP_INSN
- || simplejump_p (b->end))
- && merge_blocks (s, b, c, mode))
- changed_here = true;
+ if ((s = b->succ) != NULL
+ && s->succ_next == NULL
+ && !(s->flags & EDGE_COMPLEX)
+ && (c = s->dest) != EXIT_BLOCK_PTR
+ && c->pred->pred_next == NULL
+ && b != c
+ /* If the jump insn has side effects,
+ we can't kill the edge. */
+ && (GET_CODE (b->end) != JUMP_INSN
+ || (flow2_completed
+ ? simplejump_p (b->end)
+ : onlyjump_p (b->end)))
+ && (next = merge_blocks (s, b, c, mode)))
+ {
+ b = next;
+ changed_here = true;
+ }
/* Simplify branch over branch. */
if ((mode & CLEANUP_EXPENSIVE) && try_simplify_condjump (b))
if (!(b->flags & BB_REACHABLE))
{
- flow_delete_block (b);
+ delete_block (b);
changed = true;
}
}
{
changed = true;
/* We've possibly created trivially dead code. Cleanup it right
- now to introduce more oppurtunities for try_optimize_cfg. */
+ now to introduce more opportunities for try_optimize_cfg. */
if (!(mode & (CLEANUP_NO_INSN_DEL
| CLEANUP_UPDATE_LIFE | CLEANUP_PRE_SIBCALL))
&& !reload_completed)
delete_unreachable_blocks (), changed = true;
if (mode & CLEANUP_UPDATE_LIFE)
{
- /* Cleaning up CFG introduces more oppurtunities for dead code
- removal that in turn may introduce more oppurtunities for
+ /* Cleaning up CFG introduces more opportunities for dead code
+ removal that in turn may introduce more opportunities for
cleaning up the CFG. */
if (!update_life_info_in_dirty_blocks (UPDATE_LIFE_GLOBAL_RM_NOTES,
PROP_DEATH_NOTES
break;
}
else if (!(mode & (CLEANUP_NO_INSN_DEL | CLEANUP_PRE_SIBCALL))
+ && (mode & CLEANUP_EXPENSIVE)
&& !reload_completed)
{
if (!delete_trivially_dead_insns (get_insns(), max_reg_num ()))
OSDN Git Service
