/* If-conversion support.
- Copyright (C) 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
+ Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005
+ Free Software Foundation, Inc.
This file is part of GCC.
#define MAX_CONDITIONAL_EXECUTE (BRANCH_COST + 1)
#endif
-#define NULL_EDGE ((struct edge_def *)NULL)
-#define NULL_BLOCK ((struct basic_block_def *)NULL)
+#define NULL_BLOCK ((basic_block) NULL)
/* # of IF-THEN or IF-THEN-ELSE blocks we looked at */
static int num_possible_if_blocks;
/* Forward references. */
static int count_bb_insns (basic_block);
-static int total_bb_rtx_cost (basic_block);
+static bool cheap_bb_rtx_cost_p (basic_block, int);
static rtx first_active_insn (basic_block);
static rtx last_active_insn (basic_block, int);
static basic_block block_fallthru (basic_block);
basic_block, int);
static void noce_emit_move_insn (rtx, rtx);
static rtx block_has_only_trap (basic_block);
-static void mark_loop_exit_edges (void);
\f
-/* Sets EDGE_LOOP_EXIT flag for all loop exits. */
-static void
-mark_loop_exit_edges (void)
-{
- struct loops loops;
- basic_block bb;
- edge e;
-
- flow_loops_find (&loops, LOOP_TREE);
- free_dominance_info (CDI_DOMINATORS);
-
- if (loops.num > 1)
- {
- FOR_EACH_BB (bb)
- {
- for (e = bb->succ; e; e = e->succ_next)
- {
- if (find_common_loop (bb->loop_father, e->dest->loop_father)
- != bb->loop_father)
- e->flags |= EDGE_LOOP_EXIT;
- else
- e->flags &= ~EDGE_LOOP_EXIT;
- }
- }
- }
-
- flow_loops_free (&loops);
-}
-
/* Count the number of non-jump active insns in BB. */
static int
return count;
}
-/* Count the total insn_rtx_cost of non-jump active insns in BB.
- This function returns -1, if the cost of any instruction could
- not be estimated. */
+/* Determine whether the total insn_rtx_cost on non-jump insns in
+ basic block BB is less than MAX_COST. This function returns
+ false if the cost of any instruction could not be estimated. */
-static int
-total_bb_rtx_cost (basic_block bb)
+static bool
+cheap_bb_rtx_cost_p (basic_block bb, int max_cost)
{
int count = 0;
rtx insn = BB_HEAD (bb);
{
int cost = insn_rtx_cost (PATTERN (insn));
if (cost == 0)
- return -1;
+ return false;
+
+ /* If this instruction is the load or set of a "stack" register,
+ such as a floating point register on x87, then the cost of
+ speculatively executing this instruction needs to include
+ the additional cost of popping this register off of the
+ register stack. */
+#ifdef STACK_REGS
+ {
+ rtx set = single_set (insn);
+ if (set && STACK_REG_P (SET_DEST (set)))
+ cost += COSTS_N_INSNS (1);
+ }
+#endif
+
count += cost;
+ if (count >= max_cost)
+ return false;
}
else if (CALL_P (insn))
- return -1;
+ return false;
if (insn == BB_END (bb))
break;
insn = NEXT_INSN (insn);
}
- return count;
+ return true;
}
/* Return the first non-jump active insn in the basic block. */
block_fallthru (basic_block bb)
{
edge e;
+ edge_iterator ei;
- for (e = bb->succ;
- e != NULL_EDGE && (e->flags & EDGE_FALLTHRU) == 0;
- e = e->succ_next)
- ;
+ FOR_EACH_EDGE (e, ei, bb->succs)
+ if (e->flags & EDGE_FALLTHRU)
+ break;
return (e) ? e->dest : NULL_BLOCK;
}
if (NOTE_P (insn))
goto insn_done;
- if (!NONJUMP_INSN_P (insn) && !CALL_P (insn))
- abort ();
+ gcc_assert(NONJUMP_INSN_P (insn) || CALL_P (insn));
/* Remove USE insns that get in the way. */
if (reload_completed && GET_CODE (PATTERN (insn)) == USE)
{
rtx start, end;
rtx t, f;
+ enum rtx_code f_code;
bb = block_fallthru (bb);
start = first_active_insn (bb);
if (! t)
goto fail;
- f = gen_rtx_fmt_ee (reverse_condition (GET_CODE (t)),
- GET_MODE (t),
- XEXP (t, 0),
- XEXP (t, 1));
+ f_code = reversed_comparison_code (t, BB_END (bb));
+ if (f_code == UNKNOWN)
+ goto fail;
+ f = gen_rtx_fmt_ee (f_code, GET_MODE (t), XEXP (t, 0), XEXP (t, 1));
if (ce_info->and_and_p)
{
t = gen_rtx_AND (GET_MODE (t), true_expr, t);
static void
noce_emit_move_insn (rtx x, rtx y)
{
- enum machine_mode outmode, inmode;
+ enum machine_mode outmode;
rtx outer, inner;
int bitpos;
if (GET_CODE (x) != STRICT_LOW_PART)
{
- emit_move_insn (x, y);
+ rtx seq, insn, target;
+ optab ot;
+
+ start_sequence ();
+ insn = emit_move_insn (x, y);
+ seq = get_insns ();
+ end_sequence();
+
+ if (recog_memoized (insn) <= 0)
+ switch (GET_RTX_CLASS (GET_CODE (y)))
+ {
+ case RTX_UNARY:
+ ot = code_to_optab[GET_CODE (y)];
+ if (ot)
+ {
+ start_sequence ();
+ target = expand_unop (GET_MODE (y), ot, XEXP (y, 0), x, 0);
+ if (target != NULL_RTX)
+ {
+ if (target != x)
+ emit_move_insn (x, target);
+ seq = get_insns ();
+ }
+ end_sequence ();
+ }
+ break;
+
+ case RTX_BIN_ARITH:
+ case RTX_COMM_ARITH:
+ ot = code_to_optab[GET_CODE (y)];
+ if (ot)
+ {
+ start_sequence ();
+ target = expand_binop (GET_MODE (y), ot,
+ XEXP (y, 0), XEXP (y, 1),
+ x, 0, OPTAB_DIRECT);
+ if (target != NULL_RTX)
+ {
+ if (target != x)
+ emit_move_insn (x, target);
+ seq = get_insns ();
+ }
+ end_sequence ();
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ emit_insn (seq);
return;
}
outer = XEXP (x, 0);
inner = XEXP (outer, 0);
outmode = GET_MODE (outer);
- inmode = GET_MODE (inner);
bitpos = SUBREG_BYTE (outer) * BITS_PER_UNIT;
store_bit_field (inner, GET_MODE_BITSIZE (outmode), bitpos, outmode, y);
}
rtx a = if_info->a;
rtx b = if_info->b;
rtx x = if_info->x;
+ rtx orig_a, orig_b;
rtx insn_a, insn_b;
rtx tmp, target;
int is_mem = 0;
+ int insn_cost;
enum rtx_code code;
/* A conditional move from two memory sources is equivalent to a
insn_a = if_info->insn_a;
insn_b = if_info->insn_b;
+ /* Total insn_rtx_cost should be smaller than branch cost. Exit
+ if insn_rtx_cost can't be estimated. */
+ if (insn_a)
+ {
+ insn_cost = insn_rtx_cost (PATTERN (insn_a));
+ if (insn_cost == 0 || insn_cost > COSTS_N_INSNS (BRANCH_COST))
+ return FALSE;
+ }
+ else
+ {
+ insn_cost = 0;
+ }
+
+ if (insn_b) {
+ insn_cost += insn_rtx_cost (PATTERN (insn_b));
+ if (insn_cost == 0 || insn_cost > COSTS_N_INSNS (BRANCH_COST))
+ return FALSE;
+ }
+
/* Possibly rearrange operands to make things come out more natural. */
if (reversed_comparison_code (if_info->cond, if_info->jump) != UNKNOWN)
{
start_sequence ();
+ orig_a = a;
+ orig_b = b;
+
/* If either operand is complex, load it into a register first.
The best way to do this is to copy the original insn. In this
way we preserve any clobbers etc that the insn may have had.
}
if (! general_operand (b, GET_MODE (b)))
{
- rtx set;
+ rtx set, last;
if (no_new_pseudos)
goto end_seq_and_fail;
if (is_mem)
{
tmp = gen_reg_rtx (GET_MODE (b));
- tmp = emit_insn (gen_rtx_SET (VOIDmode,
- tmp,
- b));
+ tmp = gen_rtx_SET (VOIDmode, tmp, b);
}
else if (! insn_b)
goto end_seq_and_fail;
tmp = copy_rtx (insn_b);
set = single_set (tmp);
SET_DEST (set) = b;
- tmp = emit_insn (PATTERN (tmp));
+ tmp = PATTERN (tmp);
}
+
+ /* If insn to set up A clobbers any registers B depends on, try to
+ swap insn that sets up A with the one that sets up B. If even
+ that doesn't help, punt. */
+ last = get_last_insn ();
+ if (last && modified_in_p (orig_b, last))
+ {
+ tmp = emit_insn_before (tmp, get_insns ());
+ if (modified_in_p (orig_a, tmp))
+ goto end_seq_and_fail;
+ }
+ else
+ tmp = emit_insn (tmp);
+
if (recog_memoized (tmp) < 0)
goto end_seq_and_fail;
}
}
+/* Optimize away "if (x & C) x |= C" and similar bit manipulation
+ transformations. */
+
+static int
+noce_try_bitop (struct noce_if_info *if_info)
+{
+ rtx cond, x, a, result, seq;
+ enum machine_mode mode;
+ enum rtx_code code;
+ int bitnum;
+
+ x = if_info->x;
+ cond = if_info->cond;
+ code = GET_CODE (cond);
+
+ /* Check for no else condition. */
+ if (! rtx_equal_p (x, if_info->b))
+ return FALSE;
+
+ /* Check for a suitable condition. */
+ if (code != NE && code != EQ)
+ return FALSE;
+ if (XEXP (cond, 1) != const0_rtx)
+ return FALSE;
+ cond = XEXP (cond, 0);
+
+ /* ??? We could also handle AND here. */
+ if (GET_CODE (cond) == ZERO_EXTRACT)
+ {
+ if (XEXP (cond, 1) != const1_rtx
+ || GET_CODE (XEXP (cond, 2)) != CONST_INT
+ || ! rtx_equal_p (x, XEXP (cond, 0)))
+ return FALSE;
+ bitnum = INTVAL (XEXP (cond, 2));
+ mode = GET_MODE (x);
+ if (bitnum >= HOST_BITS_PER_WIDE_INT)
+ return FALSE;
+ }
+ else
+ return FALSE;
+
+ a = if_info->a;
+ if (GET_CODE (a) == IOR || GET_CODE (a) == XOR)
+ {
+ /* Check for "if (X & C) x = x op C". */
+ if (! rtx_equal_p (x, XEXP (a, 0))
+ || GET_CODE (XEXP (a, 1)) != CONST_INT
+ || (INTVAL (XEXP (a, 1)) & GET_MODE_MASK (mode))
+ != (unsigned HOST_WIDE_INT) 1 << bitnum)
+ return FALSE;
+
+ /* if ((x & C) == 0) x |= C; is transformed to x |= C. */
+ /* if ((x & C) != 0) x |= C; is transformed to nothing. */
+ if (GET_CODE (a) == IOR)
+ result = (code == NE) ? a : NULL_RTX;
+ else if (code == NE)
+ {
+ /* if ((x & C) == 0) x ^= C; is transformed to x |= C. */
+ result = gen_int_mode ((HOST_WIDE_INT) 1 << bitnum, mode);
+ result = simplify_gen_binary (IOR, mode, x, result);
+ }
+ else
+ {
+ /* if ((x & C) != 0) x ^= C; is transformed to x &= ~C. */
+ result = gen_int_mode (~((HOST_WIDE_INT) 1 << bitnum), mode);
+ result = simplify_gen_binary (AND, mode, x, result);
+ }
+ }
+ else if (GET_CODE (a) == AND)
+ {
+ /* Check for "if (X & C) x &= ~C". */
+ if (! rtx_equal_p (x, XEXP (a, 0))
+ || GET_CODE (XEXP (a, 1)) != CONST_INT
+ || (INTVAL (XEXP (a, 1)) & GET_MODE_MASK (mode))
+ != (~((HOST_WIDE_INT) 1 << bitnum) & GET_MODE_MASK (mode)))
+ return FALSE;
+
+ /* if ((x & C) == 0) x &= ~C; is transformed to nothing. */
+ /* if ((x & C) != 0) x &= ~C; is transformed to x &= ~C. */
+ result = (code == EQ) ? a : NULL_RTX;
+ }
+ else
+ return FALSE;
+
+ if (result)
+ {
+ start_sequence ();
+ noce_emit_move_insn (x, result);
+ seq = end_ifcvt_sequence (if_info);
+ if (!seq)
+ return FALSE;
+
+ emit_insn_before_setloc (seq, if_info->jump,
+ INSN_LOCATOR (if_info->insn_a));
+ }
+ return TRUE;
+}
+
+
/* Similar to get_condition, only the resulting condition must be
valid at JUMP, instead of at EARLIEST. */
if (side_effects_p (x))
return FALSE;
+ /* If x is a read-only memory, then the program is valid only if we
+ avoid the store into it. If there are stores on both the THEN and
+ ELSE arms, then we can go ahead with the conversion; either the
+ program is broken, or the condition is always false such that the
+ other memory is selected. */
+ if (!set_b && MEM_P (x) && MEM_READONLY_P (x))
+ return FALSE;
+
b = (set_b ? SET_SRC (set_b) : x);
/* Only operate on register destinations, and even then avoid extending
goto success;
if (noce_try_store_flag (&if_info))
goto success;
+ if (noce_try_bitop (&if_info))
+ goto success;
if (noce_try_minmax (&if_info))
goto success;
if (noce_try_abs (&if_info))
/* The outgoing edge for the current COMBO block should already
be correct. Verify this. */
- if (combo_bb->succ == NULL_EDGE)
- {
- if (find_reg_note (last, REG_NORETURN, NULL))
- ;
- else if (NONJUMP_INSN_P (last)
- && GET_CODE (PATTERN (last)) == TRAP_IF
- && TRAP_CONDITION (PATTERN (last)) == const_true_rtx)
- ;
- else
- abort ();
- }
+ if (EDGE_COUNT (combo_bb->succs) == 0)
+ gcc_assert (find_reg_note (last, REG_NORETURN, NULL)
+ || (NONJUMP_INSN_P (last)
+ && GET_CODE (PATTERN (last)) == TRAP_IF
+ && (TRAP_CONDITION (PATTERN (last))
+ == const_true_rtx)));
+ else
/* There should still be something at the end of the THEN or ELSE
blocks taking us to our final destination. */
- else if (JUMP_P (last))
- ;
- else if (combo_bb->succ->dest == EXIT_BLOCK_PTR
- && CALL_P (last)
- && SIBLING_CALL_P (last))
- ;
- else if ((combo_bb->succ->flags & EDGE_EH)
- && can_throw_internal (last))
- ;
- else
- abort ();
+ gcc_assert (JUMP_P (last)
+ || (EDGE_SUCC (combo_bb, 0)->dest == EXIT_BLOCK_PTR
+ && CALL_P (last)
+ && SIBLING_CALL_P (last))
+ || ((EDGE_SUCC (combo_bb, 0)->flags & EDGE_EH)
+ && can_throw_internal (last)));
}
/* The JOIN block may have had quite a number of other predecessors too.
have only one remaining edge from our if-then-else diamond. If there
is more than one remaining edge, it must come from elsewhere. There
may be zero incoming edges if the THEN block didn't actually join
- back up (as with a call to abort). */
- else if ((join_bb->pred == NULL
- || join_bb->pred->pred_next == NULL)
+ back up (as with a call to a non-return function). */
+ else if (EDGE_COUNT (join_bb->preds) < 2
&& join_bb != EXIT_BLOCK_PTR)
{
/* We can merge the JOIN. */
/* The outgoing edge for the current COMBO block should already
be correct. Verify this. */
- if (combo_bb->succ->succ_next != NULL_EDGE
- || combo_bb->succ->dest != join_bb)
- abort ();
+ gcc_assert (single_succ_p (combo_bb)
+ && single_succ (combo_bb) == join_bb);
/* Remove the jump and cruft from the end of the COMBO block. */
if (join_bb != EXIT_BLOCK_PTR)
- tidy_fallthru_edge (combo_bb->succ);
+ tidy_fallthru_edge (single_succ_edge (combo_bb));
}
num_updated_if_blocks++;
edge else_edge;
/* The kind of block we're looking for has exactly two successors. */
- if ((then_edge = test_bb->succ) == NULL_EDGE
- || (else_edge = then_edge->succ_next) == NULL_EDGE
- || else_edge->succ_next != NULL_EDGE)
+ if (EDGE_COUNT (test_bb->succs) != 2)
return NULL;
+ then_edge = EDGE_SUCC (test_bb, 0);
+ else_edge = EDGE_SUCC (test_bb, 1);
+
/* Neither edge should be abnormal. */
if ((then_edge->flags & EDGE_COMPLEX)
|| (else_edge->flags & EDGE_COMPLEX))
rtx insn;
rtx end;
int n_insns = 0;
+ edge_iterator ei;
if (!cur_bb || !target_bb)
return -1;
/* If no edges, obviously it doesn't jump or fallthru. */
- if (cur_bb->succ == NULL_EDGE)
+ if (EDGE_COUNT (cur_bb->succs) == 0)
return FALSE;
- for (cur_edge = cur_bb->succ;
- cur_edge != NULL_EDGE;
- cur_edge = cur_edge->succ_next)
+ FOR_EACH_EDGE (cur_edge, ei, cur_bb->succs)
{
if (cur_edge->flags & EDGE_COMPLEX)
/* Anything complex isn't what we want. */
basic_block then_bb = ce_info->then_bb;
basic_block else_bb = ce_info->else_bb;
basic_block join_bb = NULL_BLOCK;
- edge then_succ = then_bb->succ;
- edge else_succ = else_bb->succ;
- int then_predecessors;
- int else_predecessors;
edge cur_edge;
basic_block next;
+ edge_iterator ei;
ce_info->last_test_bb = test_bb;
were && tests (which jump to the else block) or || tests (which jump to
the then block). */
if (HAVE_conditional_execution && reload_completed
- && test_bb->pred != NULL_EDGE
- && test_bb->pred->pred_next == NULL_EDGE
- && test_bb->pred->flags == EDGE_FALLTHRU)
+ && single_pred_p (test_bb)
+ && single_pred_edge (test_bb)->flags == EDGE_FALLTHRU)
{
- basic_block bb = test_bb->pred->src;
+ basic_block bb = single_pred (test_bb);
basic_block target_bb;
int max_insns = MAX_CONDITIONAL_EXECUTE;
int n_insns;
total_insns += n_insns;
blocks++;
- if (bb->pred == NULL_EDGE || bb->pred->pred_next != NULL_EDGE)
+ if (!single_pred_p (bb))
break;
- bb = bb->pred->src;
+ bb = single_pred (bb);
n_insns = block_jumps_and_fallthru_p (bb, target_bb);
}
while (n_insns >= 0 && (total_insns + n_insns) <= max_insns);
}
}
- /* Count the number of edges the THEN and ELSE blocks have. */
- then_predecessors = 0;
- for (cur_edge = then_bb->pred;
- cur_edge != NULL_EDGE;
- cur_edge = cur_edge->pred_next)
+ /* The THEN block of an IF-THEN combo must have exactly one predecessor,
+ other than any || blocks which jump to the THEN block. */
+ if ((EDGE_COUNT (then_bb->preds) - ce_info->num_or_or_blocks) != 1)
+ return FALSE;
+
+ /* The edges of the THEN and ELSE blocks cannot have complex edges. */
+ FOR_EACH_EDGE (cur_edge, ei, then_bb->preds)
{
- then_predecessors++;
if (cur_edge->flags & EDGE_COMPLEX)
return FALSE;
}
- else_predecessors = 0;
- for (cur_edge = else_bb->pred;
- cur_edge != NULL_EDGE;
- cur_edge = cur_edge->pred_next)
+ FOR_EACH_EDGE (cur_edge, ei, else_bb->preds)
{
- else_predecessors++;
if (cur_edge->flags & EDGE_COMPLEX)
return FALSE;
}
- /* The THEN block of an IF-THEN combo must have exactly one predecessor,
- other than any || blocks which jump to the THEN block. */
- if ((then_predecessors - ce_info->num_or_or_blocks) != 1)
- return FALSE;
-
/* The THEN block of an IF-THEN combo must have zero or one successors. */
- if (then_succ != NULL_EDGE
- && (then_succ->succ_next != NULL_EDGE
- || (then_succ->flags & EDGE_COMPLEX)
+ if (EDGE_COUNT (then_bb->succs) > 0
+ && (!single_succ_p (then_bb)
+ || (single_succ_edge (then_bb)->flags & EDGE_COMPLEX)
|| (flow2_completed && tablejump_p (BB_END (then_bb), NULL, NULL))))
return FALSE;
Check for the last insn of the THEN block being an indirect jump, which
is listed as not having any successors, but confuses the rest of the CE
code processing. ??? we should fix this in the future. */
- if (then_succ == NULL)
+ if (EDGE_COUNT (then_bb->succs) == 0)
{
- if (else_bb->pred->pred_next == NULL_EDGE)
+ if (single_pred_p (else_bb))
{
rtx last_insn = BB_END (then_bb);
/* If the THEN block's successor is the other edge out of the TEST block,
then we have an IF-THEN combo without an ELSE. */
- else if (then_succ->dest == else_bb)
+ else if (single_succ (then_bb) == else_bb)
{
join_bb = else_bb;
else_bb = NULL_BLOCK;
/* If the THEN and ELSE block meet in a subsequent block, and the ELSE
has exactly one predecessor and one successor, and the outgoing edge
is not complex, then we have an IF-THEN-ELSE combo. */
- else if (else_succ != NULL_EDGE
- && then_succ->dest == else_succ->dest
- && else_bb->pred->pred_next == NULL_EDGE
- && else_succ->succ_next == NULL_EDGE
- && ! (else_succ->flags & EDGE_COMPLEX)
+ else if (single_succ_p (else_bb)
+ && single_succ (then_bb) == single_succ (else_bb)
+ && single_pred_p (else_bb)
+ && ! (single_succ_edge (else_bb)->flags & EDGE_COMPLEX)
&& ! (flow2_completed && tablejump_p (BB_END (else_bb), NULL, NULL)))
- join_bb = else_succ->dest;
+ join_bb = single_succ (else_bb);
/* Otherwise it is not an IF-THEN or IF-THEN-ELSE combination. */
else
we checked the FALLTHRU flag, those are already adjacent to the last IF
block. */
/* ??? As an enhancement, move the ELSE block. Have to deal with
- BLOCK notes, if by no other means than aborting the merge if they
+ BLOCK notes, if by no other means than backing out the merge if they
exist. Sticky enough I don't want to think about it now. */
next = then_bb;
if (else_bb && (next = next->next_bb) != else_bb)
/* Delete the trap block if possible. */
remove_edge (trap_bb == then_bb ? then_edge : else_edge);
- if (trap_bb->pred == NULL)
+ if (EDGE_COUNT (trap_bb->preds) == 0)
delete_basic_block (trap_bb);
/* If the non-trap block and the test are now adjacent, merge them.
return NULL_RTX;
/* The block must have no successors. */
- if (bb->succ)
+ if (EDGE_COUNT (bb->succs) > 0)
return NULL_RTX;
/* The only instruction in the THEN block must be the trap. */
{
basic_block then_bb = then_edge->dest;
basic_block else_bb = else_edge->dest, new_bb;
- edge then_succ = then_bb->succ;
- int then_bb_index, bb_cost;
+ int then_bb_index;
/* If we are partitioning hot/cold basic blocks, we don't want to
mess up unconditional or indirect jumps that cross between hot
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
- && ((BB_END (then_bb)
- && find_reg_note (BB_END (then_bb), REG_CROSSING_JUMP, NULL_RTX))
- || (BB_END (else_bb)
- && find_reg_note (BB_END (else_bb), REG_CROSSING_JUMP,
- NULL_RTX))))
+ if ((BB_END (then_bb)
+ && find_reg_note (BB_END (then_bb), REG_CROSSING_JUMP, NULL_RTX))
+ || (BB_END (test_bb)
+ && find_reg_note (BB_END (test_bb), REG_CROSSING_JUMP, NULL_RTX))
+ || (BB_END (else_bb)
+ && find_reg_note (BB_END (else_bb), REG_CROSSING_JUMP,
+ NULL_RTX)))
return FALSE;
/* THEN has one successor. */
- if (!then_succ || then_succ->succ_next != NULL)
+ if (!single_succ_p (then_bb))
return FALSE;
/* THEN does not fall through, but is not strange either. */
- if (then_succ->flags & (EDGE_COMPLEX | EDGE_FALLTHRU))
+ if (single_succ_edge (then_bb)->flags & (EDGE_COMPLEX | EDGE_FALLTHRU))
return FALSE;
/* THEN has one predecessor. */
- if (then_bb->pred->pred_next != NULL)
+ if (!single_pred_p (then_bb))
return FALSE;
/* THEN must do something. */
test_bb->index, then_bb->index);
/* THEN is small. */
- bb_cost = total_bb_rtx_cost (then_bb);
- if (bb_cost < 0 || bb_cost >= COSTS_N_INSNS (BRANCH_COST))
+ if (! cheap_bb_rtx_cost_p (then_bb, COSTS_N_INSNS (BRANCH_COST)))
return FALSE;
/* Registers set are dead, or are predicable. */
if (! dead_or_predicable (test_bb, then_bb, else_bb,
- then_bb->succ->dest, 1))
+ single_succ (then_bb), 1))
return FALSE;
/* Conversion went ok, including moving the insns and fixing up the
jump. Adjust the CFG to match. */
- bitmap_operation (test_bb->global_live_at_end,
- else_bb->global_live_at_start,
- then_bb->global_live_at_end, BITMAP_IOR);
+ bitmap_ior (test_bb->global_live_at_end,
+ else_bb->global_live_at_start,
+ then_bb->global_live_at_end);
+
+
+ /* We can avoid creating a new basic block if then_bb is immediately
+ followed by else_bb, i.e. deleting then_bb allows test_bb to fall
+ thru to else_bb. */
+
+ if (then_bb->next_bb == else_bb
+ && then_bb->prev_bb == test_bb
+ && else_bb != EXIT_BLOCK_PTR)
+ {
+ redirect_edge_succ (FALLTHRU_EDGE (test_bb), else_bb);
+ new_bb = 0;
+ }
+ else
+ new_bb = redirect_edge_and_branch_force (FALLTHRU_EDGE (test_bb),
+ else_bb);
- new_bb = redirect_edge_and_branch_force (FALLTHRU_EDGE (test_bb), else_bb);
then_bb_index = then_bb->index;
delete_basic_block (then_bb);
{
basic_block then_bb = then_edge->dest;
basic_block else_bb = else_edge->dest;
- edge else_succ = else_bb->succ;
- int bb_cost;
+ edge else_succ;
rtx note;
/* If we are partitioning hot/cold basic blocks, we don't want to
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
- && ((BB_END (then_bb)
- && find_reg_note (BB_END (then_bb), REG_CROSSING_JUMP, NULL_RTX))
- || (BB_END (else_bb)
- && find_reg_note (BB_END (else_bb), REG_CROSSING_JUMP,
- NULL_RTX))))
+ if ((BB_END (then_bb)
+ && find_reg_note (BB_END (then_bb), REG_CROSSING_JUMP, NULL_RTX))
+ || (BB_END (test_bb)
+ && find_reg_note (BB_END (test_bb), REG_CROSSING_JUMP, NULL_RTX))
+ || (BB_END (else_bb)
+ && find_reg_note (BB_END (else_bb), REG_CROSSING_JUMP,
+ NULL_RTX)))
return FALSE;
/* ELSE has one successor. */
- if (!else_succ || else_succ->succ_next != NULL)
+ if (!single_succ_p (else_bb))
return FALSE;
+ else
+ else_succ = single_succ_edge (else_bb);
/* ELSE outgoing edge is not complex. */
if (else_succ->flags & EDGE_COMPLEX)
return FALSE;
/* ELSE has one predecessor. */
- if (else_bb->pred->pred_next != NULL)
+ if (!single_pred_p (else_bb))
return FALSE;
/* THEN is not EXIT. */
test_bb->index, else_bb->index);
/* ELSE is small. */
- bb_cost = total_bb_rtx_cost (else_bb);
- if (bb_cost < 0 || bb_cost >= COSTS_N_INSNS (BRANCH_COST))
+ if (! cheap_bb_rtx_cost_p (else_bb, COSTS_N_INSNS (BRANCH_COST)))
return FALSE;
/* Registers set are dead, or are predicable. */
/* Conversion went ok, including moving the insns and fixing up the
jump. Adjust the CFG to match. */
- bitmap_operation (test_bb->global_live_at_end,
- then_bb->global_live_at_start,
- else_bb->global_live_at_end, BITMAP_IOR);
+ bitmap_ior (test_bb->global_live_at_end,
+ then_bb->global_live_at_start,
+ else_bb->global_live_at_end);
delete_basic_block (else_bb);
that any registers modified are dead at the branch site. */
rtx insn, cond, prev;
- regset_head merge_set_head, tmp_head, test_live_head, test_set_head;
regset merge_set, tmp, test_live, test_set;
struct propagate_block_info *pbi;
- int i, fail = 0;
+ unsigned i, fail = 0;
+ bitmap_iterator bi;
/* Check for no calls or trapping operations. */
for (insn = head; ; insn = NEXT_INSN (insn))
TEST_SET = set of registers set between EARLIEST and the
end of the block. */
- tmp = INITIALIZE_REG_SET (tmp_head);
- merge_set = INITIALIZE_REG_SET (merge_set_head);
- test_live = INITIALIZE_REG_SET (test_live_head);
- test_set = INITIALIZE_REG_SET (test_set_head);
+ tmp = ALLOC_REG_SET (®_obstack);
+ merge_set = ALLOC_REG_SET (®_obstack);
+ test_live = ALLOC_REG_SET (®_obstack);
+ test_set = ALLOC_REG_SET (®_obstack);
/* ??? bb->local_set is only valid during calculate_global_regs_live,
so we must recompute usage for MERGE_BB. Not so bad, I suppose,
hard registers before reload. */
if (SMALL_REGISTER_CLASSES && ! reload_completed)
{
- EXECUTE_IF_SET_IN_BITMAP
- (merge_set, 0, i,
- {
- if (i < FIRST_PSEUDO_REGISTER
- && ! fixed_regs[i]
- && ! global_regs[i])
+ EXECUTE_IF_SET_IN_BITMAP (merge_set, 0, i, bi)
+ {
+ if (i < FIRST_PSEUDO_REGISTER
+ && ! fixed_regs[i]
+ && ! global_regs[i])
fail = 1;
- });
+ }
}
/* For TEST, we're interested in a range of insns, not a whole block.
TEST_SET & merge_bb->global_live_at_start
are empty. */
- bitmap_operation (tmp, test_set, test_live, BITMAP_IOR);
- bitmap_operation (tmp, tmp, merge_set, BITMAP_AND);
- EXECUTE_IF_SET_IN_BITMAP(tmp, 0, i, fail = 1);
-
- bitmap_operation (tmp, test_set, merge_bb->global_live_at_start,
- BITMAP_AND);
- EXECUTE_IF_SET_IN_BITMAP(tmp, 0, i, fail = 1);
+ if (bitmap_intersect_p (test_set, merge_set)
+ || bitmap_intersect_p (test_live, merge_set)
+ || bitmap_intersect_p (test_set, merge_bb->global_live_at_start))
+ fail = 1;
FREE_REG_SET (tmp);
FREE_REG_SET (merge_set);
if (other_bb != new_dest)
{
- if (old_dest)
- LABEL_NUSES (old_dest) -= 1;
- if (new_label)
- LABEL_NUSES (new_label) += 1;
- JUMP_LABEL (jump) = new_label;
- if (reversep)
- invert_br_probabilities (jump);
+ redirect_jump_2 (jump, old_dest, new_label, -1, reversep);
redirect_edge_succ (BRANCH_EDGE (test_bb), new_dest);
if (reversep)
if ((! targetm.cannot_modify_jumps_p ())
&& (!flag_reorder_blocks_and_partition || !no_new_pseudos
|| !targetm.have_named_sections))
- mark_loop_exit_edges ();
+ {
+ struct loops loops;
+
+ flow_loops_find (&loops);
+ mark_loop_exit_edges (&loops);
+ flow_loops_free (&loops);
+ free_dominance_info (CDI_DOMINATORS);
+ }
/* Compute postdominators if we think we'll use them. */
if (HAVE_conditional_execution || life_data_ok)