static int moxie_arg_partial_bytes (cumulative_args_t cum_v, machine_mode mode, tree type, bool named) { CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v); int bytes_left, size; if (*cum >= 8) return 0; if (moxie_pass_by_reference (cum_v, mode, type, named)) size = 4; else if (type) { if (AGGREGATE_TYPE_P (type)) return 0; size = int_size_in_bytes (type); } else size = GET_MODE_SIZE (mode); bytes_left = (4 * 6) - ((*cum - 2) * 4); if (size > bytes_left) return bytes_left; else return 0; }
static void moxie_setup_incoming_varargs (cumulative_args_t cum_v, machine_mode mode ATTRIBUTE_UNUSED, tree type ATTRIBUTE_UNUSED, int *pretend_size, int no_rtl) { CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v); int regno; int regs = 8 - *cum; *pretend_size = regs < 0 ? 0 : GET_MODE_SIZE (SImode) * regs; if (no_rtl) return; for (regno = *cum; regno < 8; regno++) { rtx reg = gen_rtx_REG (SImode, regno); rtx slot = gen_rtx_PLUS (Pmode, gen_rtx_REG (SImode, ARG_POINTER_REGNUM), GEN_INT (UNITS_PER_WORD * (3 + (regno-2)))); emit_move_insn (gen_rtx_MEM (SImode, slot), reg); } }
/* 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_t arg_regs_used_so_far_v, machine_mode mode, tree type ATTRIBUTE_UNUSED, int *pretend_size, int second_time ATTRIBUTE_UNUSED) { CUMULATIVE_ARGS *arg_regs_used_so_far = get_cumulative_args (arg_regs_used_so_far_v); 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_v)) /* If TARGET_STRICT_ARGUMENT_NAMING returns true, then the last named arg must not be treated as an anonymous arg. */ /* ??? This is a pointer increment, which makes no sense. */ 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 void moxie_function_arg_advance (cumulative_args_t cum_v, machine_mode mode, const_tree type, bool named ATTRIBUTE_UNUSED) { CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v); *cum = (*cum < MOXIE_R6 ? *cum + ((3 + MOXIE_FUNCTION_ARG_SIZE (mode, type)) / 4) : *cum); }
static rtx moxie_function_arg (cumulative_args_t cum_v, machine_mode mode, const_tree type ATTRIBUTE_UNUSED, bool named ATTRIBUTE_UNUSED) { CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v); if (*cum < 8) return gen_rtx_REG (mode, *cum); else return NULL_RTX; }
static rtx fr30_function_arg (cumulative_args_t cum_v, machine_mode mode, const_tree type, bool named) { CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v); if (!named || fr30_must_pass_in_stack (mode, type) || *cum >= FR30_NUM_ARG_REGS) return NULL_RTX; else return gen_rtx_REG (mode, *cum + FIRST_ARG_REGNUM); }
static void lm32_setup_incoming_varargs (cumulative_args_t cum_v, machine_mode mode, tree type, int *pretend_size, int no_rtl) { CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v); int first_anon_arg; tree fntype; fntype = TREE_TYPE (current_function_decl); if (stdarg_p (fntype)) first_anon_arg = *cum + LM32_FIRST_ARG_REG; else { /* this is the common case, we have been passed details setup for the last named argument, we want to skip over the registers, if any used in passing this named paramter in order to determine which is the first registers used to pass anonymous arguments. */ int size; if (mode == BLKmode) size = int_size_in_bytes (type); else size = GET_MODE_SIZE (mode); first_anon_arg = *cum + LM32_FIRST_ARG_REG + ((size + UNITS_PER_WORD - 1) / UNITS_PER_WORD); } if ((first_anon_arg < (LM32_FIRST_ARG_REG + LM32_NUM_ARG_REGS)) && !no_rtl) { int first_reg_offset = first_anon_arg; int size = LM32_FIRST_ARG_REG + LM32_NUM_ARG_REGS - first_anon_arg; rtx regblock; regblock = gen_rtx_MEM (BLKmode, plus_constant (Pmode, arg_pointer_rtx, FIRST_PARM_OFFSET (0))); move_block_from_reg (first_reg_offset, regblock, size); *pretend_size = size * UNITS_PER_WORD; } }
static rtx lm32_function_arg (cumulative_args_t cum_v, machine_mode mode, const_tree type, bool named) { CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v); if (mode == VOIDmode) /* Compute operand 2 of the call insn. */ return GEN_INT (0); if (targetm.calls.must_pass_in_stack (mode, type)) return NULL_RTX; if (!named || (*cum + LM32_NUM_REGS2 (mode, type) > LM32_NUM_ARG_REGS)) return NULL_RTX; return gen_rtx_REG (mode, *cum + LM32_FIRST_ARG_REG); }
static int fr30_arg_partial_bytes (cumulative_args_t cum_v, machine_mode mode, tree type, bool named) { CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v); /* 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; }
static void lm32_function_arg_advance (cumulative_args_t cum, machine_mode mode, const_tree type, bool named ATTRIBUTE_UNUSED) { *get_cumulative_args (cum) += LM32_NUM_REGS2 (mode, type); }
/* 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); }