/* If-conversion support.
- Copyright (C) 2000, 2001, 2002, 2003 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;
/* True if life data ok at present. */
static bool life_data_ok;
-/* The post-dominator relation on the original block numbers. */
-static dominance_info post_dominators;
-
/* Forward references. */
static int count_bb_insns (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 int seq_contains_jump (rtx);
static basic_block block_fallthru (basic_block);
static int cond_exec_process_insns (ce_if_block_t *, rtx, rtx, rtx, rtx, int);
static rtx cond_exec_get_condition (rtx);
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)
+/* Count the number of non-jump active insns in BB. */
+
+static int
+count_bb_insns (basic_block bb)
{
- struct loops loops;
- basic_block bb;
- edge e;
-
- flow_loops_find (&loops, LOOP_TREE);
-
- if (loops.num > 1)
+ int count = 0;
+ rtx insn = BB_HEAD (bb);
+
+ while (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;
- }
- }
+ if (CALL_P (insn) || NONJUMP_INSN_P (insn))
+ count++;
+
+ if (insn == BB_END (bb))
+ break;
+ insn = NEXT_INSN (insn);
}
- flow_loops_free (&loops);
+ return count;
}
-/* Count the number of non-jump active insns in BB. */
+/* 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
-count_bb_insns (basic_block bb)
+static bool
+cheap_bb_rtx_cost_p (basic_block bb, int max_cost)
{
int count = 0;
- rtx insn = bb->head;
+ rtx insn = BB_HEAD (bb);
while (1)
{
- if (GET_CODE (insn) == CALL_INSN || GET_CODE (insn) == INSN)
- count++;
+ if (NONJUMP_INSN_P (insn))
+ {
+ int cost = insn_rtx_cost (PATTERN (insn));
+ if (cost == 0)
+ 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
- if (insn == bb->end)
+ count += cost;
+ if (count >= max_cost)
+ return false;
+ }
+ else if (CALL_P (insn))
+ 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. */
static rtx
first_active_insn (basic_block bb)
{
- rtx insn = bb->head;
+ rtx insn = BB_HEAD (bb);
- if (GET_CODE (insn) == CODE_LABEL)
+ if (LABEL_P (insn))
{
- if (insn == bb->end)
+ if (insn == BB_END (bb))
return NULL_RTX;
insn = NEXT_INSN (insn);
}
- while (GET_CODE (insn) == NOTE)
+ while (NOTE_P (insn))
{
- if (insn == bb->end)
+ if (insn == BB_END (bb))
return NULL_RTX;
insn = NEXT_INSN (insn);
}
- if (GET_CODE (insn) == JUMP_INSN)
+ if (JUMP_P (insn))
return NULL_RTX;
return insn;
static rtx
last_active_insn (basic_block bb, int skip_use_p)
{
- rtx insn = bb->end;
- rtx head = bb->head;
+ rtx insn = BB_END (bb);
+ rtx head = BB_HEAD (bb);
- while (GET_CODE (insn) == NOTE
- || GET_CODE (insn) == JUMP_INSN
+ while (NOTE_P (insn)
+ || JUMP_P (insn)
|| (skip_use_p
- && GET_CODE (insn) == INSN
+ && NONJUMP_INSN_P (insn)
&& GET_CODE (PATTERN (insn)) == USE))
{
if (insn == head)
insn = PREV_INSN (insn);
}
- if (GET_CODE (insn) == CODE_LABEL)
+ if (LABEL_P (insn))
return NULL_RTX;
return insn;
}
-/* It is possible, especially when having dealt with multi-word
- arithmetic, for the expanders to have emitted jumps. Search
- through the sequence and return TRUE if a jump exists so that
- we can abort the conversion. */
-
-static int
-seq_contains_jump (rtx insn)
-{
- while (insn)
- {
- if (GET_CODE (insn) == JUMP_INSN)
- return 1;
- insn = NEXT_INSN (insn);
- }
- return 0;
-}
+/* Return the basic block reached by falling though the basic block BB. */
static 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;
}
for (insn = start; ; insn = NEXT_INSN (insn))
{
- if (GET_CODE (insn) == NOTE)
+ if (NOTE_P (insn))
goto insn_done;
- if (GET_CODE (insn) != INSN && GET_CODE (insn) != CALL_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)
{
/* ??? Ug. Actually unlinking the thing is problematic,
given what we'd have to coordinate with our callers. */
- PUT_CODE (insn, NOTE);
- NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED;
- NOTE_SOURCE_FILE (insn) = 0;
+ SET_INSN_DELETED (insn);
goto insn_done;
}
validate_change (insn, &PATTERN (insn), pattern, 1);
- if (GET_CODE (insn) == CALL_INSN && prob_val)
+ if (CALL_P (insn) && prob_val)
validate_change (insn, ®_NOTES (insn),
alloc_EXPR_LIST (REG_BR_PROB, prob_val,
REG_NOTES (insn)), 1);
/* Find the conditional jump to the ELSE or JOIN part, and isolate
the test. */
- test_expr = cond_exec_get_condition (test_bb->end);
+ test_expr = cond_exec_get_condition (BB_END (test_bb));
if (! test_expr)
return FALSE;
/* If the conditional jump is more than just a conditional jump,
then we can not do conditional execution conversion on this block. */
- if (! onlyjump_p (test_bb->end))
+ if (! onlyjump_p (BB_END (test_bb)))
return FALSE;
/* Collect the bounds of where we're to search, skipping any labels, jumps
true_expr = test_expr;
- false_code = reversed_comparison_code (true_expr, test_bb->end);
+ false_code = reversed_comparison_code (true_expr, BB_END (test_bb));
if (false_code != UNKNOWN)
false_expr = gen_rtx_fmt_ee (false_code, GET_MODE (true_expr),
XEXP (true_expr, 0), XEXP (true_expr, 1));
conditional execution register from a comparison, it can do so here. */
IFCVT_MODIFY_TESTS (ce_info, true_expr, false_expr);
- /* See if the conversion failed */
+ /* See if the conversion failed. */
if (!true_expr || !false_expr)
goto fail;
#endif
- true_prob_val = find_reg_note (test_bb->end, REG_BR_PROB, NULL_RTX);
+ true_prob_val = find_reg_note (BB_END (test_bb), REG_BR_PROB, NULL_RTX);
if (true_prob_val)
{
true_prob_val = XEXP (true_prob_val, 0);
{
rtx start, end;
rtx t, f;
+ enum rtx_code f_code;
bb = block_fallthru (bb);
start = first_active_insn (bb);
/* If the conditional jump is more than just a conditional jump, then
we can not do conditional execution conversion on this block. */
- if (! onlyjump_p (bb->end))
+ if (! onlyjump_p (BB_END (bb)))
goto fail;
/* Find the conditional jump and isolate the test. */
- t = cond_exec_get_condition (bb->end);
+ t = cond_exec_get_condition (BB_END (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);
#ifdef IFCVT_MODIFY_MULTIPLE_TESTS
IFCVT_MODIFY_MULTIPLE_TESTS (ce_info, bb, t, f);
- /* See if the conversion failed */
+ /* See if the conversion failed. */
if (!t || !f)
goto fail;
#endif
}
#ifdef IFCVT_MODIFY_FINAL
- /* Do any machine dependent final modifications */
+ /* Do any machine dependent final modifications. */
IFCVT_MODIFY_FINAL (ce_info);
#endif
/* Conversion succeeded. */
- if (rtl_dump_file)
- fprintf (rtl_dump_file, "%d insn%s converted to conditional execution.\n",
+ if (dump_file)
+ fprintf (dump_file, "%d insn%s converted to conditional execution.\n",
n_insns, (n_insns == 1) ? " was" : "s were");
/* Merge the blocks! */
rtx insn_a, insn_b;
rtx x, a, b;
rtx jump, cond, cond_earliest;
+ /* True if "b" was originally evaluated unconditionally. */
+ bool b_unconditional;
};
static rtx noce_emit_store_flag (struct noce_if_info *, rtx, int, int);
+static int noce_try_move (struct noce_if_info *);
static int noce_try_store_flag (struct noce_if_info *);
static int noce_try_addcc (struct noce_if_info *);
static int noce_try_store_flag_constants (struct noce_if_info *);
static rtx noce_get_alt_condition (struct noce_if_info *, rtx, rtx *);
static int noce_try_minmax (struct noce_if_info *);
static int noce_try_abs (struct noce_if_info *);
+static int noce_try_sign_mask (struct noce_if_info *);
/* Helper function for noce_try_store_flag*. */
|| code == GEU || code == GTU), normalize);
}
-/* Emit instruction to move an rtx into STRICT_LOW_PART. */
+/* Emit instruction to move an rtx, possibly into STRICT_LOW_PART.
+ X is the destination/target and Y is the value to copy. */
+
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,
- GET_MODE_BITSIZE (inmode));
+ store_bit_field (inner, GET_MODE_BITSIZE (outmode), bitpos, outmode, y);
+}
+
+/* Return sequence of instructions generated by if conversion. This
+ function calls end_sequence() to end the current stream, ensures
+ that are instructions are unshared, recognizable non-jump insns.
+ On failure, this function returns a NULL_RTX. */
+
+static rtx
+end_ifcvt_sequence (struct noce_if_info *if_info)
+{
+ rtx insn;
+ rtx seq = get_insns ();
+
+ set_used_flags (if_info->x);
+ set_used_flags (if_info->cond);
+ unshare_all_rtl_in_chain (seq);
+ end_sequence ();
+
+ /* Make sure that all of the instructions emitted are recognizable,
+ and that we haven't introduced a new jump instruction.
+ As an exercise for the reader, build a general mechanism that
+ allows proper placement of required clobbers. */
+ for (insn = seq; insn; insn = NEXT_INSN (insn))
+ if (JUMP_P (insn)
+ || recog_memoized (insn) == -1)
+ return NULL_RTX;
+
+ return seq;
+}
+
+/* Convert "if (a != b) x = a; else x = b" into "x = a" and
+ "if (a == b) x = a; else x = b" into "x = b". */
+
+static int
+noce_try_move (struct noce_if_info *if_info)
+{
+ rtx cond = if_info->cond;
+ enum rtx_code code = GET_CODE (cond);
+ rtx y, seq;
+
+ if (code != NE && code != EQ)
+ return FALSE;
+
+ /* This optimization isn't valid if either A or B could be a NaN
+ or a signed zero. */
+ if (HONOR_NANS (GET_MODE (if_info->x))
+ || HONOR_SIGNED_ZEROS (GET_MODE (if_info->x)))
+ return FALSE;
+
+ /* Check whether the operands of the comparison are A and in
+ either order. */
+ if ((rtx_equal_p (if_info->a, XEXP (cond, 0))
+ && rtx_equal_p (if_info->b, XEXP (cond, 1)))
+ || (rtx_equal_p (if_info->a, XEXP (cond, 1))
+ && rtx_equal_p (if_info->b, XEXP (cond, 0))))
+ {
+ y = (code == EQ) ? if_info->a : if_info->b;
+
+ /* Avoid generating the move if the source is the destination. */
+ if (! rtx_equal_p (if_info->x, y))
+ {
+ start_sequence ();
+ noce_emit_move_insn (if_info->x, y);
+ 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;
+ }
+ return FALSE;
}
/* Convert "if (test) x = 1; else x = 0".
if (target != if_info->x)
noce_emit_move_insn (if_info->x, target);
- seq = get_insns ();
- end_sequence ();
- emit_insn_before_setloc (seq, if_info->jump, INSN_LOCATOR (if_info->insn_a));
+ 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;
}
else
if (target != if_info->x)
noce_emit_move_insn (if_info->x, target);
- seq = get_insns ();
- end_sequence ();
-
- if (seq_contains_jump (seq))
+ seq = end_ifcvt_sequence (if_info);
+ if (!seq)
return FALSE;
- emit_insn_before_setloc (seq, if_info->jump, INSN_LOCATOR (if_info->insn_a));
-
+ emit_insn_before_setloc (seq, if_info->jump,
+ INSN_LOCATOR (if_info->insn_a));
return TRUE;
}
int subtract, normalize;
if (! no_new_pseudos
- /* Should be no `else' case to worry about. */
- && if_info->b == if_info->x
&& GET_CODE (if_info->a) == PLUS
- && rtx_equal_p (XEXP (if_info->a, 0), if_info->x)
+ && rtx_equal_p (XEXP (if_info->a, 0), if_info->b)
&& (reversed_comparison_code (if_info->cond, if_info->jump)
!= UNKNOWN))
{
{
start_sequence ();
target = emit_conditional_add (if_info->x, code,
- XEXP (cond, 0), XEXP (cond, 1),
+ XEXP (cond, 0),
+ XEXP (cond, 1),
VOIDmode,
- if_info->b, XEXP (if_info->a, 1),
+ if_info->b,
+ XEXP (if_info->a, 1),
GET_MODE (if_info->x),
(code == LTU || code == GEU
|| code == LEU || code == GTU));
if (target != if_info->x)
noce_emit_move_insn (if_info->x, target);
- seq = get_insns ();
- end_sequence ();
+ seq = end_ifcvt_sequence (if_info);
+ if (!seq)
+ return FALSE;
+
emit_insn_before_setloc (seq, if_info->jump,
- INSN_LOCATOR (if_info->insn_a));
+ INSN_LOCATOR (if_info->insn_a));
return TRUE;
}
end_sequence ();
if (target)
target = expand_simple_binop (GET_MODE (if_info->x),
subtract ? MINUS : PLUS,
- if_info->x, target, if_info->x,
+ if_info->b, target, if_info->x,
0, OPTAB_WIDEN);
if (target)
{
if (target != if_info->x)
noce_emit_move_insn (if_info->x, target);
- seq = get_insns ();
- end_sequence ();
-
- if (seq_contains_jump (seq))
+ seq = end_ifcvt_sequence (if_info);
+ if (!seq)
return FALSE;
emit_insn_before_setloc (seq, if_info->jump,
- INSN_LOCATOR (if_info->insn_a));
-
+ INSN_LOCATOR (if_info->insn_a));
return TRUE;
}
end_sequence ();
reversep, -1);
if (target)
target = expand_simple_binop (GET_MODE (if_info->x), AND,
- if_info->x, target, if_info->x, 0,
+ if_info->x,
+ target, if_info->x, 0,
OPTAB_WIDEN);
if (target)
if (target != if_info->x)
noce_emit_move_insn (if_info->x, target);
- seq = get_insns ();
- end_sequence ();
-
- if (seq_contains_jump (seq))
+ seq = end_ifcvt_sequence (if_info);
+ if (!seq)
return FALSE;
emit_insn_before_setloc (seq, if_info->jump,
- INSN_LOCATOR (if_info->insn_a));
-
+ INSN_LOCATOR (if_info->insn_a));
return TRUE;
}
if (target != if_info->x)
noce_emit_move_insn (if_info->x, target);
- seq = get_insns ();
- end_sequence ();
+ seq = end_ifcvt_sequence (if_info);
+ if (!seq)
+ return FALSE;
+
emit_insn_before_setloc (seq, if_info->jump,
- INSN_LOCATOR (if_info->insn_a));
+ INSN_LOCATOR (if_info->insn_a));
return TRUE;
}
else
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
early because it'll screw alias analysis. Note that we've
already checked for no side effects. */
if (! no_new_pseudos && cse_not_expected
- && GET_CODE (a) == MEM && GET_CODE (b) == MEM
+ && MEM_P (a) && MEM_P (b)
&& BRANCH_COST >= 5)
{
a = XEXP (a, 0);
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;
}
else if (target != x)
noce_emit_move_insn (x, target);
- tmp = get_insns ();
- end_sequence ();
+ tmp = end_ifcvt_sequence (if_info);
+ if (!tmp)
+ return FALSE;
+
emit_insn_before_setloc (tmp, if_info->jump, INSN_LOCATOR (if_info->insn_a));
return TRUE;
}
cond = canonicalize_condition (if_info->jump, cond, reverse,
- earliest, target, false);
+ earliest, target, false, true);
if (! cond || ! reg_mentioned_p (target, cond))
return NULL;
if (target != if_info->x)
noce_emit_move_insn (if_info->x, target);
- seq = get_insns ();
- end_sequence ();
-
- if (seq_contains_jump (seq))
+ seq = end_ifcvt_sequence (if_info);
+ if (!seq)
return FALSE;
emit_insn_before_setloc (seq, if_info->jump, INSN_LOCATOR (if_info->insn_a));
{
rtx insn, note = NULL;
for (insn = earliest;
- insn != if_info->test_bb->head;
+ insn != BB_HEAD (if_info->test_bb);
insn = PREV_INSN (insn))
if (INSN_P (insn)
&& ((note = find_reg_note (insn, REG_EQUAL, c))
return FALSE;
c = XEXP (note, 0);
}
- if (GET_CODE (c) == MEM
+ if (MEM_P (c)
&& GET_CODE (XEXP (c, 0)) == SYMBOL_REF
&& CONSTANT_POOL_ADDRESS_P (XEXP (c, 0)))
c = get_pool_constant (XEXP (c, 0));
target = expand_abs_nojump (GET_MODE (if_info->x), b, if_info->x, 1);
- /* ??? It's a quandry whether cmove would be better here, especially
+ /* ??? It's a quandary whether cmove would be better here, especially
for integers. Perhaps combine will clean things up. */
if (target && negate)
target = expand_simple_unop (GET_MODE (target), NEG, target, if_info->x, 0);
if (target != if_info->x)
noce_emit_move_insn (if_info->x, target);
- seq = get_insns ();
- end_sequence ();
-
- if (seq_contains_jump (seq))
+ 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;
}
+/* Convert "if (m < 0) x = b; else x = 0;" to "x = (m >> C) & b;". */
+
+static int
+noce_try_sign_mask (struct noce_if_info *if_info)
+{
+ rtx cond, t, m, c, seq;
+ enum machine_mode mode;
+ enum rtx_code code;
+
+ if (no_new_pseudos)
+ return FALSE;
+
+ cond = if_info->cond;
+ code = GET_CODE (cond);
+ m = XEXP (cond, 0);
+ c = XEXP (cond, 1);
+
+ t = NULL_RTX;
+ if (if_info->a == const0_rtx)
+ {
+ if ((code == LT && c == const0_rtx)
+ || (code == LE && c == constm1_rtx))
+ t = if_info->b;
+ }
+ else if (if_info->b == const0_rtx)
+ {
+ if ((code == GE && c == const0_rtx)
+ || (code == GT && c == constm1_rtx))
+ t = if_info->a;
+ }
+
+ if (! t || side_effects_p (t))
+ return FALSE;
+
+ /* We currently don't handle different modes. */
+ mode = GET_MODE (t);
+ if (GET_MODE (m) != mode)
+ return FALSE;
+
+ /* This is only profitable if T is cheap, or T is unconditionally
+ executed/evaluated in the original insn sequence. */
+ if (rtx_cost (t, SET) >= COSTS_N_INSNS (2)
+ && (!if_info->b_unconditional
+ || t != if_info->b))
+ return FALSE;
+
+ start_sequence ();
+ /* Use emit_store_flag to generate "m < 0 ? -1 : 0" instead of expanding
+ "(signed) m >> 31" directly. This benefits targets with specialized
+ insns to obtain the signmask, but still uses ashr_optab otherwise. */
+ m = emit_store_flag (gen_reg_rtx (mode), LT, m, const0_rtx, mode, 0, -1);
+ t = m ? expand_binop (mode, and_optab, m, t, NULL_RTX, 0, OPTAB_DIRECT)
+ : NULL_RTX;
+
+ if (!t)
+ {
+ end_sequence ();
+ return FALSE;
+ }
+
+ noce_emit_move_insn (if_info->x, t);
+
+ 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;
+}
+
+
+/* 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. */
static rtx
noce_get_condition (rtx jump, rtx *earliest)
{
- rtx cond, set, tmp, insn;
+ rtx cond, set, tmp;
bool reverse;
if (! any_condjump_p (jump))
/* Otherwise, fall back on canonicalize_condition to do the dirty
work of manipulating MODE_CC values and COMPARE rtx codes. */
-
- tmp = canonicalize_condition (jump, cond, reverse, earliest, NULL_RTX,
- false);
- if (!tmp)
- return NULL_RTX;
-
- /* We are going to insert code before JUMP, not before EARLIEST.
- We must therefore be certain that the given condition is valid
- at JUMP by virtue of not having been modified since. */
- for (insn = *earliest; insn != jump; insn = NEXT_INSN (insn))
- if (INSN_P (insn) && modified_in_p (tmp, insn))
- break;
- if (insn == jump)
- return tmp;
-
- /* The condition was modified. See if we can get a partial result
- that doesn't follow all the reversals. Perhaps combine can fold
- them together later. */
- tmp = XEXP (tmp, 0);
- if (!REG_P (tmp) || GET_MODE_CLASS (GET_MODE (tmp)) != MODE_INT)
- return NULL_RTX;
- tmp = canonicalize_condition (jump, cond, reverse, earliest, tmp,
- false);
- if (!tmp)
- return NULL_RTX;
-
- /* For sanity's sake, re-validate the new result. */
- for (insn = *earliest; insn != jump; insn = NEXT_INSN (insn))
- if (INSN_P (insn) && modified_in_p (tmp, insn))
- return NULL_RTX;
-
- return tmp;
+ return canonicalize_condition (jump, cond, reverse, earliest,
+ NULL_RTX, false, true);
}
/* Return true if OP is ok for if-then-else processing. */
{
/* We special-case memories, so handle any of them with
no address side effects. */
- if (GET_CODE (op) == MEM)
+ if (MEM_P (op))
return ! side_effects_p (XEXP (op, 0));
if (side_effects_p (op))
}
/* If this is not a standard conditional jump, we can't parse it. */
- jump = test_bb->end;
+ jump = BB_END (test_bb);
cond = noce_get_condition (jump, &if_info.cond_earliest);
if (! cond)
return FALSE;
COND_EARLIEST to JUMP. Make sure the relevant data is still
intact. */
if (! insn_b
- || GET_CODE (insn_b) != INSN
+ || !NONJUMP_INSN_P (insn_b)
|| (set_b = single_set (insn_b)) == NULL_RTX
|| ! rtx_equal_p (x, SET_DEST (set_b))
|| reg_overlap_mentioned_p (x, SET_SRC (set_b))
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
the lifetime of hard registers on small register class machines. */
orig_x = x;
- if (GET_CODE (x) != REG
+ if (!REG_P (x)
|| (SMALL_REGISTER_CLASSES
&& REGNO (x) < FIRST_PSEUDO_REGISTER))
{
if_info.x = x;
if_info.a = a;
if_info.b = b;
+ if_info.b_unconditional = else_bb == 0;
/* Try optimizations in some approximation of a useful order. */
/* ??? Should first look to see if X is live incoming at all. If it
{
rtx note;
- if (else_bb && insn_b == else_bb->end)
- else_bb->end = PREV_INSN (insn_b);
+ if (else_bb && insn_b == BB_END (else_bb))
+ BB_END (else_bb) = PREV_INSN (insn_b);
reorder_insns (insn_b, insn_b, PREV_INSN (jump));
/* If there was a REG_EQUAL note, delete it since it may have been
goto success;
}
+ /* Disallow the "if (...) x = a;" form (with an implicit "else x = x;")
+ for most optimizations if writing to x may trap, i.e. it's a memory
+ other than a static var or a stack slot. */
+ if (! set_b
+ && MEM_P (orig_x)
+ && ! MEM_NOTRAP_P (orig_x)
+ && rtx_addr_can_trap_p (XEXP (orig_x, 0)))
+ {
+ if (HAVE_conditional_move)
+ {
+ if (noce_try_cmove (&if_info))
+ goto success;
+ if (! HAVE_conditional_execution
+ && noce_try_cmove_arith (&if_info))
+ goto success;
+ }
+ return FALSE;
+ }
+
+ if (noce_try_move (&if_info))
+ 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))
if (HAVE_conditional_move
&& noce_try_cmove_arith (&if_info))
goto success;
+ if (noce_try_sign_mask (&if_info))
+ goto success;
}
return FALSE;
if (orig_x != x)
{
start_sequence ();
- noce_emit_move_insn (copy_rtx (orig_x), x);
+ noce_emit_move_insn (orig_x, x);
insn_b = get_insns ();
+ set_used_flags (orig_x);
+ unshare_all_rtl_in_chain (insn_b);
end_sequence ();
- emit_insn_after_setloc (insn_b, test_bb->end, INSN_LOCATOR (insn_a));
+ emit_insn_after_setloc (insn_b, BB_END (test_bb), INSN_LOCATOR (insn_a));
}
/* Merge the blocks! */
{
bb = fallthru;
fallthru = block_fallthru (bb);
- if (post_dominators)
- delete_from_dominance_info (post_dominators, bb);
merge_blocks (combo_bb, bb);
num_true_changes++;
}
if (combo_bb->global_live_at_end)
COPY_REG_SET (combo_bb->global_live_at_end,
then_bb->global_live_at_end);
- if (post_dominators)
- delete_from_dominance_info (post_dominators, then_bb);
merge_blocks (combo_bb, then_bb);
num_true_changes++;
}
get their addresses taken. */
if (else_bb)
{
- if (post_dominators)
- delete_from_dominance_info (post_dominators, else_bb);
merge_blocks (combo_bb, else_bb);
num_true_changes++;
}
if (! join_bb)
{
- rtx last = combo_bb->end;
+ rtx last = BB_END (combo_bb);
/* 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 (GET_CODE (last) == INSN
- && 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 (GET_CODE (last) == JUMP_INSN)
- ;
- else if (combo_bb->succ->dest == EXIT_BLOCK_PTR
- && GET_CODE (last) == CALL_INSN
- && 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. */
COPY_REG_SET (combo_bb->global_live_at_end,
join_bb->global_live_at_end);
- if (post_dominators)
- delete_from_dominance_info (post_dominators, join_bb);
merge_blocks (combo_bb, join_bb);
num_true_changes++;
}
/* 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, combo_bb, join_bb);
+ 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))
&& find_cond_trap (test_bb, then_edge, else_edge))
goto success;
- if (post_dominators
+ if (dom_computed[CDI_POST_DOMINATORS] >= DOM_NO_FAST_QUERY
&& (! HAVE_conditional_execution || reload_completed))
{
if (find_if_case_1 (test_bb, then_edge, else_edge))
return NULL;
success:
- if (rtl_dump_file)
- fprintf (rtl_dump_file, "Conversion succeeded on pass %d.\n", pass);
+ if (dump_file)
+ fprintf (dump_file, "Conversion succeeded on pass %d.\n", pass);
return ce_info.test_bb;
}
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. */
together for conditional execution support. ??? we should support
conditional execution support across calls for IA-64 some day, but
for now it makes the code simpler. */
- end = cur_bb->end;
- insn = cur_bb->head;
+ end = BB_END (cur_bb);
+ insn = BB_HEAD (cur_bb);
while (insn != NULL_RTX)
{
- if (GET_CODE (insn) == CALL_INSN)
+ if (CALL_P (insn))
return -1;
if (INSN_P (insn)
- && GET_CODE (insn) != JUMP_INSN
+ && !JUMP_P (insn)
&& GET_CODE (PATTERN (insn)) != USE
&& GET_CODE (PATTERN (insn)) != CLOBBER)
n_insns++;
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)
- || (flow2_completed && tablejump_p (then_bb->end, NULL, NULL))))
+ 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;
/* If the THEN block has no successors, conditional execution can still
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 = then_bb->end;
+ rtx last_insn = BB_END (then_bb);
while (last_insn
- && GET_CODE (last_insn) == NOTE
- && last_insn != then_bb->head)
+ && NOTE_P (last_insn)
+ && last_insn != BB_HEAD (then_bb))
last_insn = PREV_INSN (last_insn);
if (last_insn
- && GET_CODE (last_insn) == JUMP_INSN
+ && JUMP_P (last_insn)
&& ! simplejump_p (last_insn))
return FALSE;
/* 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)
- && ! (flow2_completed && tablejump_p (else_bb->end, NULL, NULL)))
- join_bb = else_succ->dest;
+ 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 = single_succ (else_bb);
/* Otherwise it is not an IF-THEN or IF-THEN-ELSE combination. */
else
num_possible_if_blocks++;
- if (rtl_dump_file)
+ if (dump_file)
{
- fprintf (rtl_dump_file, "\nIF-THEN%s block found, pass %d, start block %d [insn %d], then %d [%d]",
+ fprintf (dump_file,
+ "\nIF-THEN%s block found, pass %d, start block %d "
+ "[insn %d], then %d [%d]",
(else_bb) ? "-ELSE" : "",
ce_info->pass,
- test_bb->index, (test_bb->head) ? (int)INSN_UID (test_bb->head) : -1,
- then_bb->index, (then_bb->head) ? (int)INSN_UID (then_bb->head) : -1);
+ test_bb->index,
+ BB_HEAD (test_bb) ? (int)INSN_UID (BB_HEAD (test_bb)) : -1,
+ then_bb->index,
+ BB_HEAD (then_bb) ? (int)INSN_UID (BB_HEAD (then_bb)) : -1);
if (else_bb)
- fprintf (rtl_dump_file, ", else %d [%d]",
- else_bb->index, (else_bb->head) ? (int)INSN_UID (else_bb->head) : -1);
+ fprintf (dump_file, ", else %d [%d]",
+ else_bb->index,
+ BB_HEAD (else_bb) ? (int)INSN_UID (BB_HEAD (else_bb)) : -1);
- fprintf (rtl_dump_file, ", join %d [%d]",
- join_bb->index, (join_bb->head) ? (int)INSN_UID (join_bb->head) : -1);
+ fprintf (dump_file, ", join %d [%d]",
+ join_bb->index,
+ BB_HEAD (join_bb) ? (int)INSN_UID (BB_HEAD (join_bb)) : -1);
if (ce_info->num_multiple_test_blocks > 0)
- fprintf (rtl_dump_file, ", %d %s block%s last test %d [%d]",
+ fprintf (dump_file, ", %d %s block%s last test %d [%d]",
ce_info->num_multiple_test_blocks,
(ce_info->and_and_p) ? "&&" : "||",
(ce_info->num_multiple_test_blocks == 1) ? "" : "s",
ce_info->last_test_bb->index,
- ((ce_info->last_test_bb->head)
- ? (int)INSN_UID (ce_info->last_test_bb->head)
+ ((BB_HEAD (ce_info->last_test_bb))
+ ? (int)INSN_UID (BB_HEAD (ce_info->last_test_bb))
: -1));
- fputc ('\n', rtl_dump_file);
+ fputc ('\n', dump_file);
}
/* Make sure IF, THEN, and ELSE, blocks are adjacent. Actually, we get the
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)
else
return FALSE;
- if (rtl_dump_file)
+ if (dump_file)
{
- fprintf (rtl_dump_file, "\nTRAP-IF block found, start %d, trap %d\n",
+ fprintf (dump_file, "\nTRAP-IF block found, start %d, trap %d\n",
test_bb->index, trap_bb->index);
}
/* If this is not a standard conditional jump, we can't parse it. */
- jump = test_bb->end;
+ jump = BB_END (test_bb);
cond = noce_get_condition (jump, &cond_earliest);
if (! cond)
return FALSE;
}
/* Attempt to generate the conditional trap. */
- seq = gen_cond_trap (code, XEXP (cond, 0), XEXP (cond, 1),
+ seq = gen_cond_trap (code, XEXP (cond, 0),
+ XEXP (cond, 1),
TRAP_CODE (PATTERN (trap)));
if (seq == NULL)
return FALSE;
/* Delete the trap block if possible. */
remove_edge (trap_bb == then_bb ? then_edge : else_edge);
- if (trap_bb->pred == NULL)
- {
- if (post_dominators)
- delete_from_dominance_info (post_dominators, trap_bb);
- delete_block (trap_bb);
- }
+ 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.
Otherwise we must insert a direct branch. */
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. */
trap = first_active_insn (bb);
- if (! (trap == bb->end
+ if (! (trap == BB_END (bb)
&& GET_CODE (PATTERN (trap)) == TRAP_IF
&& TRAP_CONDITION (PATTERN (trap)) == const_true_rtx))
return NULL_RTX;
{
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;
+ /* 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
+ bb-reorder.c:partition_hot_cold_basic_blocks for complete details. */
+
+ 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. */
return FALSE;
num_possible_if_blocks++;
- if (rtl_dump_file)
- fprintf (rtl_dump_file,
+ if (dump_file)
+ fprintf (dump_file,
"\nIF-CASE-1 found, start %d, then %d\n",
test_bb->index, then_bb->index);
/* THEN is small. */
- if (count_bb_insns (then_bb) > 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;
- if (post_dominators)
- delete_from_dominance_info (post_dominators, then_bb);
- delete_block (then_bb);
+ delete_basic_block (then_bb);
/* Make rest of code believe that the newly created block is the THEN_BB
block we removed. */
{
new_bb->index = then_bb_index;
BASIC_BLOCK (then_bb_index) = new_bb;
- if (post_dominators)
- add_to_dominance_info (post_dominators, new_bb);
+ /* Since the fallthru edge was redirected from test_bb to new_bb,
+ we need to ensure that new_bb is in the same partition as
+ test bb (you can not fall through across section boundaries). */
+ BB_COPY_PARTITION (new_bb, test_bb);
}
/* We've possibly created jump to next insn, cleanup_cfg will solve that
later. */
{
basic_block then_bb = then_edge->dest;
basic_block else_bb = else_edge->dest;
- edge else_succ = else_bb->succ;
+ edge else_succ;
rtx note;
+ /* 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
+ bb-reorder.c:partition_hot_cold_basic_blocks for complete details. */
+
+ 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. */
return FALSE;
/* ELSE is predicted or SUCC(ELSE) postdominates THEN. */
- note = find_reg_note (test_bb->end, REG_BR_PROB, NULL_RTX);
+ note = find_reg_note (BB_END (test_bb), REG_BR_PROB, NULL_RTX);
if (note && INTVAL (XEXP (note, 0)) >= REG_BR_PROB_BASE / 2)
;
else if (else_succ->dest->index < 0
- || dominated_by_p (post_dominators, then_bb,
+ || dominated_by_p (CDI_POST_DOMINATORS, then_bb,
else_succ->dest))
;
else
return FALSE;
num_possible_if_blocks++;
- if (rtl_dump_file)
- fprintf (rtl_dump_file,
+ if (dump_file)
+ fprintf (dump_file,
"\nIF-CASE-2 found, start %d, else %d\n",
test_bb->index, else_bb->index);
/* ELSE is small. */
- if (count_bb_insns (else_bb) > 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);
- if (post_dominators)
- delete_from_dominance_info (post_dominators, else_bb);
- delete_block (else_bb);
+ delete_basic_block (else_bb);
num_true_changes++;
num_updated_if_blocks++;
static int
find_memory (rtx *px, void *data ATTRIBUTE_UNUSED)
{
- return GET_CODE (*px) == MEM;
+ return MEM_P (*px);
}
/* Used by the code above to perform the actual rtl transformations.
dead_or_predicable (basic_block test_bb, basic_block merge_bb,
basic_block other_bb, basic_block new_dest, int reversep)
{
- rtx head, end, jump, earliest, old_dest, new_label = NULL_RTX;
+ rtx head, end, jump, earliest = NULL_RTX, old_dest, new_label = NULL_RTX;
- jump = test_bb->end;
+ jump = BB_END (test_bb);
/* Find the extent of the real code in the merge block. */
- head = merge_bb->head;
- end = merge_bb->end;
+ head = BB_HEAD (merge_bb);
+ end = BB_END (merge_bb);
- if (GET_CODE (head) == CODE_LABEL)
+ if (LABEL_P (head))
head = NEXT_INSN (head);
- if (GET_CODE (head) == NOTE)
+ if (NOTE_P (head))
{
if (head == end)
{
head = NEXT_INSN (head);
}
- if (GET_CODE (end) == JUMP_INSN)
+ if (JUMP_P (end))
{
if (head == end)
{
if (HAVE_conditional_execution)
{
/* In the conditional execution case, we have things easy. We know
- the condition is reversible. We don't have to check life info,
- becase we're going to conditionally execute the code anyway.
+ the condition is reversible. We don't have to check life info
+ because we're going to conditionally execute the code anyway.
All that's left is making sure the insns involved can actually
be predicated. */
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))
{
- if (GET_CODE (insn) == CALL_INSN)
+ if (CALL_P (insn))
return FALSE;
if (INSN_P (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)
/* Move the insns out of MERGE_BB to before the branch. */
if (head != NULL)
{
- if (end == merge_bb->end)
- merge_bb->end = PREV_INSN (head);
+ if (end == BB_END (merge_bb))
+ BB_END (merge_bb) = PREV_INSN (head);
if (squeeze_notes (&head, &end))
return TRUE;
num_true_changes = 0;
life_data_ok = (x_life_data_ok != 0);
- if (! (* targetm.cannot_modify_jumps_p) ())
- mark_loop_exit_edges ();
+ if ((! targetm.cannot_modify_jumps_p ())
+ && (!flag_reorder_blocks_and_partition || !no_new_pseudos
+ || !targetm.have_named_sections))
+ {
+ struct loops loops;
- /* Free up basic_block_for_insn so that we don't have to keep it
- up to date, either here or in merge_blocks. */
- free_basic_block_vars (1);
+ 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. */
- post_dominators = NULL;
if (HAVE_conditional_execution || life_data_ok)
- {
- post_dominators = calculate_dominance_info (CDI_POST_DOMINATORS);
- }
+ calculate_dominance_info (CDI_POST_DOMINATORS);
+
if (life_data_ok)
clear_bb_flags ();
pass++;
#ifdef IFCVT_MULTIPLE_DUMPS
- if (rtl_dump_file && pass > 1)
- fprintf (rtl_dump_file, "\n\n========== Pass %d ==========\n", pass);
+ if (dump_file && pass > 1)
+ fprintf (dump_file, "\n\n========== Pass %d ==========\n", pass);
#endif
FOR_EACH_BB (bb)
}
#ifdef IFCVT_MULTIPLE_DUMPS
- if (rtl_dump_file && cond_exec_changed_p)
- print_rtl_with_bb (rtl_dump_file, get_insns ());
+ if (dump_file && cond_exec_changed_p)
+ print_rtl_with_bb (dump_file, get_insns ());
#endif
}
while (cond_exec_changed_p);
#ifdef IFCVT_MULTIPLE_DUMPS
- if (rtl_dump_file)
- fprintf (rtl_dump_file, "\n\n========== no more changes\n");
+ if (dump_file)
+ fprintf (dump_file, "\n\n========== no more changes\n");
#endif
- if (post_dominators)
- free_dominance_info (post_dominators);
+ free_dominance_info (CDI_POST_DOMINATORS);
- if (rtl_dump_file)
- fflush (rtl_dump_file);
+ if (dump_file)
+ fflush (dump_file);
clear_aux_for_blocks ();
}
/* Write the final stats. */
- if (rtl_dump_file && num_possible_if_blocks > 0)
+ if (dump_file && num_possible_if_blocks > 0)
{
- fprintf (rtl_dump_file,
+ fprintf (dump_file,
"\n%d possible IF blocks searched.\n",
num_possible_if_blocks);
- fprintf (rtl_dump_file,
+ fprintf (dump_file,
"%d IF blocks converted.\n",
num_updated_if_blocks);
- fprintf (rtl_dump_file,
+ fprintf (dump_file,
"%d true changes made.\n\n\n",
num_true_changes);
}