/* Scan backwards to the previous BARRIER. Then see if we can find a
label that starts a basic block. Return the basic block number. */
for (insn = prev_nonnote_insn (insn);
- insn && GET_CODE (insn) != BARRIER && search_limit != 0;
+ insn && !BARRIER_P (insn) && search_limit != 0;
insn = prev_nonnote_insn (insn), --search_limit)
;
/* See if any of the upcoming CODE_LABELs start a basic block. If we reach
anything other than a CODE_LABEL or note, we can't find this code. */
for (insn = next_nonnote_insn (insn);
- insn && GET_CODE (insn) == CODE_LABEL;
+ insn && LABEL_P (insn);
insn = next_nonnote_insn (insn))
{
FOR_EACH_BB (bb)
{
/* If INSN is an annulled branch, skip any insns from the target
of the branch. */
- if ((GET_CODE (insn) == JUMP_INSN
- || GET_CODE (insn) == CALL_INSN
- || GET_CODE (insn) == INSN)
+ if (INSN_P (insn)
&& INSN_ANNULLED_BRANCH_P (insn)
&& NEXT_INSN (PREV_INSN (insn)) != insn)
{
}
insn = NEXT_INSN (insn);
- if (insn && GET_CODE (insn) == INSN
+ if (insn && NONJUMP_INSN_P (insn)
&& GET_CODE (PATTERN (insn)) == SEQUENCE)
insn = XVECEXP (PATTERN (insn), 0, 0);
}
unsigned int last_regno
= regno + hard_regno_nregs[regno][GET_MODE (x)];
- if (last_regno > FIRST_PSEUDO_REGISTER)
- abort ();
+ gcc_assert (last_regno <= FIRST_PSEUDO_REGISTER);
for (r = regno; r < last_regno; r++)
SET_HARD_REG_BIT (res->regs, r);
}
unsigned int last_regno
= regno + hard_regno_nregs[regno][GET_MODE (x)];
- if (last_regno > FIRST_PSEUDO_REGISTER)
- abort ();
+ gcc_assert (last_regno <= FIRST_PSEUDO_REGISTER);
for (r = regno; r < last_regno; r++)
SET_HARD_REG_BIT (res->regs, r);
}
case MEM:
/* If this memory shouldn't change, it really isn't referencing
memory. */
- if (RTX_UNCHANGING_P (x))
+ if (MEM_READONLY_P (x))
res->unch_memory = 1;
else
res->memory = 1;
{
sequence = PATTERN (NEXT_INSN (insn));
seq_size = XVECLEN (sequence, 0);
- if (GET_CODE (sequence) != SEQUENCE)
- abort ();
+ gcc_assert (GET_CODE (sequence) == SEQUENCE);
}
res->memory = 1;
for (i = 0; i < XVECLEN (PATTERN (insn), 0); i++)
{
this_jump_insn = XVECEXP (PATTERN (insn), 0, i);
- if (GET_CODE (this_jump_insn) == JUMP_INSN)
+ if (JUMP_P (this_jump_insn))
break;
}
}
break;
}
- if (GET_CODE (this_jump_insn) == JUMP_INSN)
+ if (JUMP_P (this_jump_insn))
{
if (jump_count++ < 10)
{
if (in_dest)
{
res->memory = 1;
- res->unch_memory |= RTX_UNCHANGING_P (x);
+ res->unch_memory |= MEM_READONLY_P (x);
res->volatil |= MEM_VOLATILE_P (x);
}
unsigned int last_regno
= regno + hard_regno_nregs[regno][GET_MODE (x)];
- if (last_regno > FIRST_PSEUDO_REGISTER)
- abort ();
+ gcc_assert (last_regno <= FIRST_PSEUDO_REGISTER);
for (r = regno; r < last_regno; r++)
SET_HARD_REG_BIT (res->regs, r);
}
unsigned int last_regno
= regno + hard_regno_nregs[regno][GET_MODE (x)];
- if (last_regno > FIRST_PSEUDO_REGISTER)
- abort ();
+ gcc_assert (last_regno <= FIRST_PSEUDO_REGISTER);
for (r = regno; r < last_regno; r++)
SET_HARD_REG_BIT (res->regs, r);
}
}
}
\f
+/* Return TRUE if INSN is a return, possibly with a filled delay slot. */
+
+static bool
+return_insn_p (rtx insn)
+{
+ if (GET_CODE (insn) == JUMP_INSN && GET_CODE (PATTERN (insn)) == RETURN)
+ return true;
+
+ if (GET_CODE (insn) == INSN && GET_CODE (PATTERN (insn)) == SEQUENCE)
+ return return_insn_p (XVECEXP (PATTERN (insn), 0, 0));
+
+ return false;
+}
+
/* Set the resources that are live at TARGET.
If TARGET is zero, we refer to the end of the current function and can
return;
}
+ /* Handle return insn. */
+ else if (return_insn_p (target))
+ {
+ *res = end_of_function_needs;
+ mark_referenced_resources (target, res, 0);
+ return;
+ }
+
/* We have to assume memory is needed, but the CC isn't. */
res->memory = 1;
res->volatil = res->unch_memory = 0;
start_insn = (b == 0 ? insns : BB_HEAD (BASIC_BLOCK (b)));
stop_insn = target;
- if (GET_CODE (start_insn) == INSN
+ if (NONJUMP_INSN_P (start_insn)
&& GET_CODE (PATTERN (start_insn)) == SEQUENCE)
start_insn = XVECEXP (PATTERN (start_insn), 0, 0);
- if (GET_CODE (stop_insn) == INSN
+ if (NONJUMP_INSN_P (stop_insn)
&& GET_CODE (PATTERN (stop_insn)) == SEQUENCE)
stop_insn = next_insn (PREV_INSN (stop_insn));
&& INSN_P (XEXP (PATTERN (insn), 0)))
real_insn = XEXP (PATTERN (insn), 0);
- if (GET_CODE (real_insn) == CALL_INSN)
+ if (CALL_P (real_insn))
{
/* CALL clobbers all call-used regs that aren't fixed except
sp, ap, and fp. Do this before setting the result of the
parameters. But they might be early. A CALL_INSN will usually
clobber registers used for parameters. It isn't worth bothering
with the unlikely case when it won't. */
- if ((GET_CODE (real_insn) == INSN
+ if ((NONJUMP_INSN_P (real_insn)
&& GET_CODE (PATTERN (real_insn)) != USE
&& GET_CODE (PATTERN (real_insn)) != CLOBBER)
- || GET_CODE (real_insn) == JUMP_INSN
- || GET_CODE (real_insn) == CALL_INSN)
+ || JUMP_P (real_insn)
+ || CALL_P (real_insn))
{
for (link = REG_NOTES (real_insn); link; link = XEXP (link, 1))
if (REG_NOTE_KIND (link) == REG_DEAD
}
}
- else if (GET_CODE (real_insn) == CODE_LABEL)
+ else if (LABEL_P (real_insn))
{
/* A label clobbers the pending dead registers since neither
reload nor jump will propagate a value across a label. */
/* The beginning of the epilogue corresponds to the end of the
RTL chain when there are no epilogue insns. Certain resources
are implicitly required at that point. */
- else if (GET_CODE (real_insn) == NOTE
+ else if (NOTE_P (real_insn)
&& NOTE_LINE_NUMBER (real_insn) == NOTE_INSN_EPILOGUE_BEG)
IOR_HARD_REG_SET (current_live_regs, start_of_epilogue_needs.regs);
}
start_of_epilogue_needs = end_of_function_needs;
while ((epilogue_insn = next_nonnote_insn (epilogue_insn)))
- mark_set_resources (epilogue_insn, &end_of_function_needs, 0,
- MARK_SRC_DEST_CALL);
+ {
+ mark_set_resources (epilogue_insn, &end_of_function_needs, 0,
+ MARK_SRC_DEST_CALL);
+ if (return_insn_p (epilogue_insn))
+ break;
+ }
/* Allocate and initialize the tables used by mark_target_live_regs. */
target_hash_table = xcalloc (TARGET_HASH_PRIME, sizeof (struct target_info *));
OSDN Git Service
