target that would only be safe to execute knowing that the branch
is taken.
+ The HP-PA always has a branch delay slot. For unconditional branches
+ its effects can be annulled when the branch is taken. The effects
+ of the delay slot in a conditional branch can be nullified for forward
+ taken branches, or for untaken backward branches. This means
+ we can hoist insns from the fall-through path for forward branches or
+ steal insns from the target of backward branches.
+
Three techniques for filling delay slots have been implemented so far:
(1) `fill_simple_delay_slots' is the simplest, most efficient way
#define obstack_chunk_free free
#ifndef ANNUL_IFTRUE_SLOTS
-#define eligible_for_annul_true(INSN, SLOTS, TRIAL) 0
+#define eligible_for_annul_true(INSN, SLOTS, TRIAL, FLAGS) 0
#endif
#ifndef ANNUL_IFFALSE_SLOTS
-#define eligible_for_annul_false(INSN, SLOTS, TRIAL) 0
+#define eligible_for_annul_false(INSN, SLOTS, TRIAL, FLAGS) 0
#endif
/* Insns which have delay slots that have not yet been filled. */
static void delete_scheduled_jump PROTO((rtx));
static void note_delay_statistics PROTO((int, int));
static rtx optimize_skip PROTO((rtx));
+static int get_jump_flags PROTO((rtx, rtx));
static int mostly_true_jump PROTO((rtx, rtx));
static rtx get_branch_condition PROTO((rtx, rtx));
static int condition_dominates_p PROTO((rtx, rtx));
rtx next_trial = next_active_insn (trial);
rtx delay_list = 0;
rtx target_label;
+ int flags;
+
+ flags = get_jump_flags (insn, JUMP_LABEL (insn));
if (trial == 0
|| GET_CODE (trial) != INSN
|| GET_CODE (PATTERN (trial)) == SEQUENCE
|| recog_memoized (trial) < 0
- || (! eligible_for_annul_false (insn, 0, trial)
- && ! eligible_for_annul_true (insn, 0, trial)))
+ || (! eligible_for_annul_false (insn, 0, trial, flags)
+ && ! eligible_for_annul_true (insn, 0, trial, flags)))
return 0;
/* There are two cases where we are just executing one insn (we assume
&& (simplejump_p (next_trial)
|| GET_CODE (PATTERN (next_trial)) == RETURN)))
{
- if (eligible_for_annul_false (insn, 0, trial))
+ if (eligible_for_annul_false (insn, 0, trial, flags))
{
if (invert_jump (insn, JUMP_LABEL (insn)))
INSN_FROM_TARGET_P (trial) = 1;
- else if (! eligible_for_annul_true (insn, 0, trial))
+ else if (! eligible_for_annul_true (insn, 0, trial, flags))
return 0;
}
}
#endif
\f
+
+/* Encode and return branch direction and prediction information for
+ INSN assuming it will jump to LABEL.
+
+ Non conditional branches return no direction information and
+ are predicted as very likely taken. */
+static int
+get_jump_flags (insn, label)
+ rtx insn, label;
+{
+ int flags;
+
+ /* get_jump_flags can be passed any insn with delay slots, these may
+ be INSNs, CALL_INSNs, or JUMP_INSNs. Only JUMP_INSNs have branch
+ direction information, and only if they are conditional jumps.
+
+ If LABEL is zero, then there is no way to determine the branch
+ direction. */
+ if (GET_CODE (insn) == JUMP_INSN
+ && condjump_p (insn)
+ && INSN_UID (insn) <= max_uid
+ && INSN_UID (label) <= max_uid
+ && label != 0)
+ flags
+ = (uid_to_ruid[INSN_UID (label)] > uid_to_ruid[INSN_UID (insn)])
+ ? ATTR_FLAG_forward : ATTR_FLAG_backward;
+ /* No valid direction information. */
+ else
+ flags = 0;
+
+ /* If insn is a conditional branch call mostly_true_jump to get
+ determine the branch prediction.
+
+ Non conditional branches are predicted as very likely taken. */
+ if (GET_CODE (insn) == JUMP_INSN
+ && condjump_p (insn))
+ {
+ int prediction;
+
+ prediction = mostly_true_jump (insn, get_branch_condition (insn, label));
+ switch (prediction)
+ {
+ case 2:
+ flags |= (ATTR_FLAG_very_likely | ATTR_FLAG_likely);
+ break;
+ case 1:
+ flags |= ATTR_FLAG_likely;
+ break;
+
+ case 0:
+ flags |= ATTR_FLAG_unlikely;
+ break;
+ /* mostly_true_jump does not return -1 for very unlikely jumps
+ yet, but it should in the future. */
+ case -1:
+ flags |= (ATTR_FLAG_very_unlikely | ATTR_FLAG_unlikely);
+ break;
+
+ default:
+ abort();
+ }
+ }
+ else
+ flags |= (ATTR_FLAG_very_likely | ATTR_FLAG_likely);
+
+ return flags;
+}
+
/* Return truth value of the statement that this branch
is mostly taken. If we think that the branch is extremely likely
to be taken, we return 2. If the branch is slightly more likely to be
for (i = 1; i < XVECLEN (seq, 0); i++)
{
rtx trial = XVECEXP (seq, 0, i);
+ int flags;
if (insn_references_resource_p (trial, sets, 0)
|| insn_sets_resource_p (trial, needed, 0)
if (redundant_insn_p (trial, insn, new_delay_list))
continue;
+ /* We will end up re-vectoring this branch, so compute flags
+ based on jumping to the new label. */
+ flags = get_jump_flags (insn, JUMP_LABEL (XVECEXP (seq, 0, 0)));
+
if (! must_annul
&& ((condition == const_true_rtx
|| (! insn_sets_resource_p (trial, other_needed, 0)
&& ! may_trap_p (PATTERN (trial)))))
- ? eligible_for_delay (insn, total_slots_filled, trial)
+ ? eligible_for_delay (insn, total_slots_filled, trial, flags)
: (must_annul = 1,
- eligible_for_annul_false (insn, total_slots_filled, trial)))
+ eligible_for_annul_false (insn, total_slots_filled, trial, flags)))
{
temp = copy_rtx (trial);
INSN_FROM_TARGET_P (temp) = 1;
int *pannul_p;
{
int i;
+ int flags;
+
+ flags = get_jump_flags (insn, JUMP_LABEL (insn));
/* We can't do anything if SEQ's delay insn isn't an
unconditional branch. */
&& ((condition == const_true_rtx
|| (! insn_sets_resource_p (trial, other_needed, 0)
&& ! may_trap_p (PATTERN (trial)))))
- ? eligible_for_delay (insn, *pslots_filled, trial)
+ ? eligible_for_delay (insn, *pslots_filled, trial, flags)
: (*pannul_p = 1,
- eligible_for_annul_true (insn, *pslots_filled, trial)))
+ eligible_for_annul_true (insn, *pslots_filled, trial, flags)))
{
delete_from_delay_slot (trial);
delay_list = add_to_delay_list (trial, delay_list);
struct resources set, needed;
rtx merged_insns = 0;
int i;
+ int flags;
+
+ flags = get_jump_flags (insn, JUMP_LABEL (insn));
CLEAR_RESOURCE (&needed);
CLEAR_RESOURCE (&set);
&& rtx_equal_p (PATTERN (next_to_match), PATTERN (trial))
/* Have to test this condition if annul condition is different
from (and less restrictive than) non-annulling one. */
- && eligible_for_delay (delay_insn, slot_number - 1, trial))
+ && eligible_for_delay (delay_insn, slot_number - 1, trial, flags))
{
next_trial = next_nonnote_insn (trial);
&& ! sets_cc0_p (PATTERN (dtrial))
#endif
&& rtx_equal_p (PATTERN (next_to_match), PATTERN (dtrial))
- && eligible_for_delay (delay_insn, slot_number - 1, dtrial))
+ && eligible_for_delay (delay_insn, slot_number - 1, dtrial, flags))
{
if (! annul_p)
{
for (i = 0; i < num_unfilled_slots; i++)
{
+ int flags;
/* Get the next insn to fill. If it has already had any slots assigned,
we can't do anything with it. Maybe we'll improve this later. */
|| (GET_CODE (insn) == JUMP_INSN && non_jumps_p)
|| (GET_CODE (insn) != JUMP_INSN && ! non_jumps_p))
continue;
-
+
+ flags = get_jump_flags (insn, JUMP_LABEL (insn));
slots_to_fill = num_delay_slots (insn);
if (slots_to_fill == 0)
abort ();
&& (trial = next_active_insn (insn))
&& GET_CODE (trial) == JUMP_INSN
&& simplejump_p (trial)
- && eligible_for_delay (insn, slots_filled, trial)
+ && eligible_for_delay (insn, slots_filled, trial, flags)
&& no_labels_between_p (insn, trial))
{
slots_filled++;
{
trial = try_split (pat, trial, 1);
next_trial = prev_nonnote_insn (trial);
- if (eligible_for_delay (insn, slots_filled, trial))
+ if (eligible_for_delay (insn, slots_filled, trial, flags))
{
/* In this case, we are searching backward, so if we
find insns to put on the delay list, we want
#endif
&& ! (maybe_never && may_trap_p (pat))
&& (trial = try_split (pat, trial, 0))
- && eligible_for_delay (insn, slots_filled, trial))
+ && eligible_for_delay (insn, slots_filled, trial, flags))
{
next_trial = next_nonnote_insn (trial);
delay_list = add_to_delay_list (trial, delay_list);
#endif
&& ! (maybe_never && may_trap_p (PATTERN (next_trial)))
&& (next_trial = try_split (PATTERN (next_trial), next_trial, 0))
- && eligible_for_delay (insn, slots_filled, next_trial))
+ && eligible_for_delay (insn, slots_filled, next_trial, flags))
{
rtx new_label = next_active_insn (next_trial);
rtx trial;
int lose = 0;
int must_annul = 0;
+ int flags;
/* Validate our arguments. */
if ((condition == const_true_rtx && ! thread_if_true)
|| (! own_thread && ! thread_if_true))
abort ();
+ flags = get_jump_flags (insn, JUMP_LABEL (insn));
+
/* If our thread is the end of subroutine, we can't get any delay
insns from that. */
if (thread == 0)
{
trial = try_split (pat, trial, 0);
pat = PATTERN (trial);
- if (eligible_for_delay (insn, *pslots_filled, trial))
+ if (eligible_for_delay (insn, *pslots_filled, trial, flags))
goto winner;
}
else if (0
trial = try_split (pat, trial, 0);
pat = PATTERN (trial);
if ((thread_if_true
- ? eligible_for_annul_false (insn, *pslots_filled, trial)
- : eligible_for_annul_true (insn, *pslots_filled, trial)))
+ ? eligible_for_annul_false (insn, *pslots_filled, trial, flags)
+ : eligible_for_annul_true (insn, *pslots_filled, trial, flags)))
{
rtx temp;
pat = PATTERN (trial);
if (GET_CODE (trial) != INSN || GET_CODE (pat) != SET
- || ! eligible_for_delay (insn, 0, trial))
+ || ! eligible_for_delay (insn, 0, trial, flags))
return 0;
dest = SET_DEST (pat), src = SET_SRC (pat);
for (insn = first; insn; insn = NEXT_INSN (insn))
{
+ int flags;
+
/* Only look at filled JUMP_INSNs that go to the end of function
label. */
if (GET_CODE (insn) != INSN
It can if it has more or an equal number of slots and the contents
of each is valid. */
+ flags = get_jump_flags (jump_insn, JUMP_LABEL (jump_insn));
slots = num_delay_slots (jump_insn);
if (slots >= XVECLEN (pat, 0) - 1)
{
(INSN_ANNULLED_BRANCH_P (jump_insn)
&& INSN_FROM_TARGET_P (XVECEXP (pat, 0, i)))
? eligible_for_annul_false (jump_insn, i - 1,
- XVECEXP (pat, 0, i)) :
+ XVECEXP (pat, 0, i), flags) :
#endif
#ifdef ANNUL_IFTRUE_SLOTS
(INSN_ANNULLED_BRANCH_P (jump_insn)
&& ! INSN_FROM_TARGET_P (XVECEXP (pat, 0, i)))
? eligible_for_annul_true (jump_insn, i - 1,
- XVECEXP (pat, 0, i)) :
+ XVECEXP (pat, 0, i), flags) :
#endif
- eligible_for_delay (jump_insn, i -1, XVECEXP (pat, 0, i))))
+ eligible_for_delay (jump_insn, i -1, XVECEXP (pat, 0, i), flags)))
break;
}
else
projects / gcc.git / commitdiff