/* Called after register allocation to add any instructions needed for the
epilogue. Using an epilogue insn is favored compared to putting all of the
instructions in output_function_epilogue(), since it allows the scheduler
to intermix instructions with the restores of the caller saved registers.
In some cases, it might be necessary to emit a barrier instruction as the
first insn to prevent such scheduling. */
void
fr30_expand_epilogue (void)
{
int regno;
/* Perform the inversion operations of the prologue. */
gcc_assert (current_frame_info.initialised);
/* Pop local variables and arguments off the stack.
If frame_pointer_needed is TRUE then the frame pointer register
has actually been used as a frame pointer, and we can recover
the stack pointer from it, otherwise we must unwind the stack
manually. */
if (current_frame_info.frame_size > 0)
{
if (current_frame_info.save_fp && frame_pointer_needed)
{
emit_insn (gen_leave_func ());
current_frame_info.save_fp = 0;
}
else if (current_frame_info.frame_size <= 508)
emit_insn (gen_add_to_stack
(GEN_INT (current_frame_info.frame_size)));
else
{
rtx tmp = gen_rtx_REG (Pmode, PROLOGUE_TMP_REGNUM);
emit_insn (gen_movsi (tmp, GEN_INT (current_frame_info.frame_size)));
emit_insn (gen_addsi3 (stack_pointer_rtx, stack_pointer_rtx, tmp));
}
}
if (current_frame_info.save_fp)
emit_insn (gen_movsi_pop (frame_pointer_rtx));
/* Pop all the registers that were pushed. */
if (current_frame_info.save_rp)
emit_insn (gen_movsi_pop (gen_rtx_REG (Pmode, RETURN_POINTER_REGNUM)));
for (regno = 0; regno < STACK_POINTER_REGNUM; regno ++)
if (current_frame_info.gmask & (1 << regno))
emit_insn (gen_movsi_pop (gen_rtx_REG (Pmode, regno)));
if (current_frame_info.pretend_size)
emit_insn (gen_add_to_stack (GEN_INT (current_frame_info.pretend_size)));
/* Reset state info for each function. */
current_frame_info = zero_frame_info;
emit_jump_insn (gen_return_from_func ());
}
void
moxie_expand_prologue (void)
{
int regno;
rtx insn;
moxie_compute_frame ();
/* Save callee-saved registers. */
for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
{
if (!fixed_regs[regno] && df_regs_ever_live_p (regno) && !call_used_regs[regno])
{
insn = emit_insn (gen_movsi_push (gen_rtx_REG (Pmode, regno)));
RTX_FRAME_RELATED_P (insn) = 1;
}
}
if (cfun->machine->size_for_adjusting_sp > 0)
{
if (cfun->machine->size_for_adjusting_sp <= 255)
{
insn = emit_insn (gen_subsi3 (stack_pointer_rtx,
stack_pointer_rtx,
GEN_INT (cfun->machine->size_for_adjusting_sp)));
RTX_FRAME_RELATED_P (insn) = 1;
}
else
{
insn =
emit_insn (gen_movsi
(gen_rtx_REG (Pmode, MOXIE_R5),
GEN_INT (-cfun->machine->size_for_adjusting_sp)));
RTX_FRAME_RELATED_P (insn) = 1;
insn = emit_insn (gen_addsi3 (stack_pointer_rtx,
stack_pointer_rtx,
gen_rtx_REG (Pmode, MOXIE_R5)));
RTX_FRAME_RELATED_P (insn) = 1;
}
}
}
void
fr30_expand_prologue (void)
{
int regno;
rtx insn;
if (! current_frame_info.initialised)
fr30_compute_frame_size (0, 0);
/* This cases shouldn't happen. Catch it now. */
gcc_assert (current_frame_info.total_size || !current_frame_info.gmask);
/* Allocate space for register arguments if this is a variadic function. */
if (current_frame_info.pretend_size)
{
int regs_to_save = current_frame_info.pretend_size / UNITS_PER_WORD;
/* Push argument registers into the pretend arg area. */
for (regno = FIRST_ARG_REGNUM + FR30_NUM_ARG_REGS; regno --, regs_to_save --;)
{
insn = emit_insn (gen_movsi_push (gen_rtx_REG (Pmode, regno)));
RTX_FRAME_RELATED_P (insn) = 1;
}
}
if (current_frame_info.gmask)
{
/* Save any needed call-saved regs. */
for (regno = STACK_POINTER_REGNUM; regno--;)
{
if ((current_frame_info.gmask & (1 << regno)) != 0)
{
insn = emit_insn (gen_movsi_push (gen_rtx_REG (Pmode, regno)));
RTX_FRAME_RELATED_P (insn) = 1;
}
}
}
/* Save return address if necessary. */
if (current_frame_info.save_rp)
{
insn = emit_insn (gen_movsi_push (gen_rtx_REG (Pmode,
RETURN_POINTER_REGNUM)));
RTX_FRAME_RELATED_P (insn) = 1;
}
/* Save old frame pointer and create new one, if necessary. */
if (current_frame_info.save_fp)
{
if (current_frame_info.frame_size < ((1 << 10) - UNITS_PER_WORD))
{
int enter_size = current_frame_info.frame_size + UNITS_PER_WORD;
rtx pattern;
insn = emit_insn (gen_enter_func (GEN_INT (enter_size)));
RTX_FRAME_RELATED_P (insn) = 1;
pattern = PATTERN (insn);
/* Also mark all 3 subexpressions as RTX_FRAME_RELATED_P. */
if (GET_CODE (pattern) == PARALLEL)
{
int x;
for (x = XVECLEN (pattern, 0); x--;)
{
rtx part = XVECEXP (pattern, 0, x);
/* One of the insns in the ENTER pattern updates the
frame pointer. If we do not actually need the frame
pointer in this function then this is a side effect
rather than a desired effect, so we do not mark that
insn as being related to the frame set up. Doing this
allows us to compile the crash66.C test file in the
G++ testsuite. */
if (! frame_pointer_needed
&& GET_CODE (part) == SET
&& REGNO (SET_DEST (part)) == HARD_FRAME_POINTER_REGNUM)
RTX_FRAME_RELATED_P (part) = 0;
else
RTX_FRAME_RELATED_P (part) = 1;
}
}
}
else
{
insn = emit_insn (gen_movsi_push (frame_pointer_rtx));
RTX_FRAME_RELATED_P (insn) = 1;
if (frame_pointer_needed)
{
insn = emit_insn (gen_movsi (frame_pointer_rtx, stack_pointer_rtx));
RTX_FRAME_RELATED_P (insn) = 1;
}
}
}
/* Allocate the stack frame. */
if (current_frame_info.frame_size == 0)
; /* Nothing to do. */
else if (current_frame_info.save_fp
&& current_frame_info.frame_size < ((1 << 10) - UNITS_PER_WORD))
; /* Nothing to do. */
else if (current_frame_info.frame_size <= 512)
{
insn = emit_insn (gen_add_to_stack (GEN_INT (- current_frame_info.frame_size)));
RTX_FRAME_RELATED_P (insn) = 1;
}
else
{
rtx tmp = gen_rtx_REG (Pmode, PROLOGUE_TMP_REGNUM);
insn = emit_insn (gen_movsi (tmp, GEN_INT (current_frame_info.frame_size)));
RTX_FRAME_RELATED_P (insn) = 1;
insn = emit_insn (gen_subsi3 (stack_pointer_rtx, stack_pointer_rtx, tmp));
RTX_FRAME_RELATED_P (insn) = 1;
}
if (current_function_profile)
emit_insn (gen_blockage ());
}
