/* Do any needed setup for a variadic function. We must create a register
parameter block, and then copy any anonymous arguments, plus the last
named argument, from registers into memory. * copying actually done in
fr30_expand_prologue().
ARG_REGS_USED_SO_FAR has *not* been updated for the last named argument
which has type TYPE and mode MODE, and we rely on this fact. */
void
fr30_setup_incoming_varargs (CUMULATIVE_ARGS *arg_regs_used_so_far,
enum machine_mode mode,
tree type ATTRIBUTE_UNUSED,
int *pretend_size,
int second_time ATTRIBUTE_UNUSED)
{
int size;
/* All BLKmode values are passed by reference. */
gcc_assert (mode != BLKmode);
/* ??? This run-time test as well as the code inside the if
statement is probably unnecessary. */
if (targetm.calls.strict_argument_naming (arg_regs_used_so_far))
/* If TARGET_STRICT_ARGUMENT_NAMING returns true, then the last named
arg must not be treated as an anonymous arg. */
arg_regs_used_so_far += fr30_num_arg_regs (mode, type);
size = FR30_NUM_ARG_REGS - (* arg_regs_used_so_far);
if (size <= 0)
return;
* pretend_size = (size * UNITS_PER_WORD);
}
static int
fr30_arg_partial_bytes (CUMULATIVE_ARGS *cum, enum machine_mode mode,
tree type, bool named)
{
/* Unnamed arguments, i.e. those that are prototyped as ...
are always passed on the stack.
Also check here to see if all the argument registers are full. */
if (named == 0 || *cum >= FR30_NUM_ARG_REGS)
return 0;
/* Work out how many argument registers would be needed if this
parameter were to be passed entirely in registers. If there
are sufficient argument registers available (or if no registers
are needed because the parameter must be passed on the stack)
then return zero, as this parameter does not require partial
register, partial stack stack space. */
if (*cum + fr30_num_arg_regs (mode, type) <= FR30_NUM_ARG_REGS)
return 0;
return (FR30_NUM_ARG_REGS - *cum) * UNITS_PER_WORD;
}
/* A C statement (sans semicolon) to update the summarizer variable CUM to
advance past an argument in the argument list. The values MODE, TYPE and
NAMED describe that argument. Once this is done, the variable CUM is
suitable for analyzing the *following* argument with `FUNCTION_ARG', etc.
This macro need not do anything if the argument in question was passed on
the stack. The compiler knows how to track the amount of stack space used
for arguments without any special help. */
static void
fr30_function_arg_advance (cumulative_args_t cum, machine_mode mode,
const_tree type, bool named)
{
*get_cumulative_args (cum) += named * fr30_num_arg_regs (mode, type);
}
