From e7056ca417326a70eca05defb6a8b20b737d3417 Mon Sep 17 00:00:00 2001 From: Richard Sandiford Date: Tue, 20 Aug 2019 08:52:48 +0000 Subject: Use function_arg_info for TARGET_SETUP_INCOMING_ARGS The hook is passed the promoted mode instead of the original type mode. 2019-08-20 Richard Sandiford gcc/ * target.def (setup_incoming_varargs): Take a function_arg_info instead of a mode and tree. * doc/tm.texi: Regenerate. * targhooks.h (default_setup_incoming_varargs): Take a function_arg_info instead of a mode and tree. * targhooks.c (default_setup_incoming_varargs): Likewise. * config/aarch64/aarch64.c (aarch64_setup_incoming_varargs): Likewise. * config/alpha/alpha.c (alpha_setup_incoming_varargs): Likewise. * config/arc/arc.c (arc_setup_incoming_varargs): Likewise. * config/arm/arm.c (arm_setup_incoming_varargs): Likewise. * config/bfin/bfin.c (setup_incoming_varargs): Likewise. * config/cris/cris.c (cris_setup_incoming_varargs): Likewise. * config/csky/csky.c (csky_setup_incoming_varargs): Likewise. * config/epiphany/epiphany.c (epiphany_setup_incoming_varargs): Likewise. * config/fr30/fr30.c (fr30_setup_incoming_varargs): Likewise. * config/frv/frv.c (frv_setup_incoming_varargs): Likewise. * config/ft32/ft32.c (ft32_setup_incoming_varargs): Likewise. * config/i386/i386.c (ix86_setup_incoming_varargs): Likewise. * config/ia64/ia64.c (ia64_setup_incoming_varargs): Likewise. * config/iq2000/iq2000.c (iq2000_setup_incoming_varargs): Likewise. * config/lm32/lm32.c (lm32_setup_incoming_varargs): Likewise. * config/m32r/m32r.c (m32r_setup_incoming_varargs): Likewise. * config/mcore/mcore.c (mcore_setup_incoming_varargs): Likewise. * config/mips/mips.c (mips_setup_incoming_varargs): Likewise. * config/mmix/mmix.c (mmix_setup_incoming_varargs): Likewise. * config/moxie/moxie.c (moxie_setup_incoming_varargs): Likewise. * config/nds32/nds32.c (nds32_setup_incoming_varargs): Likewise. * config/nios2/nios2.c (nios2_setup_incoming_varargs): Likewise. * config/riscv/riscv.c (riscv_setup_incoming_varargs): Likewise. * config/rs6000/rs6000-internal.h (setup_incoming_varargs): Likewise. * config/rs6000/rs6000-call.c (setup_incoming_varargs): Likewise. * config/sh/sh.c (sh_setup_incoming_varargs): Likewise. * config/spu/spu.c (spu_setup_incoming_varargs): Likewise. * config/tilegx/tilegx.c (tilegx_setup_incoming_varargs): Likewise. * config/tilepro/tilepro.c (tilepro_setup_incoming_varargs): Likewise. * config/visium/visium.c (visium_setup_incoming_varargs): Likewise. * function.c (assign_parms_setup_varargs): Update call to targetm.calls.setup_incoming_varargs. From-SVN: r274699 --- gcc/config/aarch64/aarch64.c | 9 +++++---- gcc/config/alpha/alpha.c | 9 +++++---- gcc/config/arc/arc.c | 8 ++++---- gcc/config/arm/arm.c | 13 ++++++------- gcc/config/bfin/bfin.c | 5 ++--- gcc/config/cris/cris.c | 8 ++++---- gcc/config/csky/csky.c | 5 ++--- gcc/config/epiphany/epiphany.c | 15 ++++++++------- gcc/config/fr30/fr30.c | 16 ++++++++-------- gcc/config/frv/frv.c | 13 ++++++------- gcc/config/ft32/ft32.c | 5 ++--- gcc/config/i386/i386.c | 9 +++++---- gcc/config/ia64/ia64.c | 15 +++++++++------ gcc/config/iq2000/iq2000.c | 9 ++++----- gcc/config/lm32/lm32.c | 14 +++++--------- gcc/config/m32r/m32r.c | 21 ++++++++++++--------- gcc/config/mcore/mcore.c | 9 ++++++--- gcc/config/mips/mips.c | 10 +++++----- gcc/config/mmix/mmix.c | 7 +++---- gcc/config/moxie/moxie.c | 3 +-- gcc/config/nds32/nds32.c | 9 ++++----- gcc/config/nios2/nios2.c | 6 +++--- gcc/config/riscv/riscv.c | 9 +++++---- gcc/config/rs6000/rs6000-call.c | 14 +++++++------- gcc/config/rs6000/rs6000-internal.h | 5 ++--- gcc/config/sh/sh.c | 14 ++++++-------- gcc/config/spu/spu.c | 8 +++++--- gcc/config/tilegx/tilegx.c | 6 +++--- gcc/config/tilepro/tilepro.c | 6 +++--- gcc/config/visium/visium.c | 10 +++++----- 30 files changed, 145 insertions(+), 145 deletions(-) (limited to 'gcc/config') diff --git a/gcc/config/aarch64/aarch64.c b/gcc/config/aarch64/aarch64.c index 5694dd7..4c5871c 100644 --- a/gcc/config/aarch64/aarch64.c +++ b/gcc/config/aarch64/aarch64.c @@ -14511,9 +14511,9 @@ aarch64_gimplify_va_arg_expr (tree valist, tree type, gimple_seq *pre_p, /* Implement TARGET_SETUP_INCOMING_VARARGS. */ static void -aarch64_setup_incoming_varargs (cumulative_args_t cum_v, machine_mode mode, - tree type, int *pretend_size ATTRIBUTE_UNUSED, - int no_rtl) +aarch64_setup_incoming_varargs (cumulative_args_t cum_v, + const function_arg_info &arg, + int *pretend_size ATTRIBUTE_UNUSED, int no_rtl) { CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v); CUMULATIVE_ARGS local_cum; @@ -14524,7 +14524,8 @@ aarch64_setup_incoming_varargs (cumulative_args_t cum_v, machine_mode mode, argument. Advance a local copy of CUM past the last "real" named argument, to find out how many registers are left over. */ local_cum = *cum; - aarch64_function_arg_advance (pack_cumulative_args(&local_cum), mode, type, true); + aarch64_function_arg_advance (pack_cumulative_args(&local_cum), + arg.mode, arg.type, arg.named); /* Found out how many registers we need to save. Honor tree-stdvar analysis results. */ diff --git a/gcc/config/alpha/alpha.c b/gcc/config/alpha/alpha.c index e431367..2aace88 100644 --- a/gcc/config/alpha/alpha.c +++ b/gcc/config/alpha/alpha.c @@ -6090,14 +6090,15 @@ escapes: variable number of arguments. */ static void -alpha_setup_incoming_varargs (cumulative_args_t pcum, machine_mode mode, - tree type, int *pretend_size, int no_rtl) +alpha_setup_incoming_varargs (cumulative_args_t pcum, + const function_arg_info &arg, + int *pretend_size, int no_rtl) { CUMULATIVE_ARGS cum = *get_cumulative_args (pcum); /* Skip the current argument. */ - targetm.calls.function_arg_advance (pack_cumulative_args (&cum), mode, type, - true); + targetm.calls.function_arg_advance (pack_cumulative_args (&cum), + arg.mode, arg.type, arg.named); #if TARGET_ABI_OPEN_VMS /* For VMS, we allocate space for all 6 arg registers plus a count. diff --git a/gcc/config/arc/arc.c b/gcc/config/arc/arc.c index 5b0d8b9..bfa38ab 100644 --- a/gcc/config/arc/arc.c +++ b/gcc/config/arc/arc.c @@ -2415,12 +2415,12 @@ arc_double_limm_p (rtx value) create a register parameter block, and then copy any anonymous arguments in registers to memory. - CUM has not been updated for the last named argument which has type TYPE - and mode MODE, and we rely on this fact. */ + CUM has not been updated for the last named argument (which is given + by ARG), and we rely on this fact. */ static void arc_setup_incoming_varargs (cumulative_args_t args_so_far, - machine_mode mode, tree type, + const function_arg_info &arg, int *pretend_size, int no_rtl) { int first_anon_arg; @@ -2430,7 +2430,7 @@ arc_setup_incoming_varargs (cumulative_args_t args_so_far, next_cum = *get_cumulative_args (args_so_far); arc_function_arg_advance (pack_cumulative_args (&next_cum), - mode, type, true); + arg.mode, arg.type, arg.named); first_anon_arg = next_cum; if (FUNCTION_ARG_REGNO_P (first_anon_arg)) diff --git a/gcc/config/arm/arm.c b/gcc/config/arm/arm.c index cceb3c7..f713945 100644 --- a/gcc/config/arm/arm.c +++ b/gcc/config/arm/arm.c @@ -212,8 +212,8 @@ static void arm_file_end (void); static void arm_file_start (void); static void arm_insert_attributes (tree, tree *); -static void arm_setup_incoming_varargs (cumulative_args_t, machine_mode, - tree, int *, int); +static void arm_setup_incoming_varargs (cumulative_args_t, + const function_arg_info &, int *, int); static bool arm_pass_by_reference (cumulative_args_t, const function_arg_info &); static bool arm_promote_prototypes (const_tree); @@ -27054,8 +27054,7 @@ arm_output_load_gr (rtx *operands) static void arm_setup_incoming_varargs (cumulative_args_t pcum_v, - machine_mode mode, - tree type, + const function_arg_info &arg, int *pretend_size, int second_time ATTRIBUTE_UNUSED) { @@ -27068,17 +27067,17 @@ arm_setup_incoming_varargs (cumulative_args_t pcum_v, nregs = pcum->aapcs_ncrn; if (nregs & 1) { - int res = arm_needs_doubleword_align (mode, type); + int res = arm_needs_doubleword_align (arg.mode, arg.type); if (res < 0 && warn_psabi) inform (input_location, "parameter passing for argument of " - "type %qT changed in GCC 7.1", type); + "type %qT changed in GCC 7.1", arg.type); else if (res > 0) { nregs++; if (res > 1 && warn_psabi) inform (input_location, "parameter passing for argument of type " - "%qT changed in GCC 9.1", type); + "%qT changed in GCC 9.1", arg.type); } } } diff --git a/gcc/config/bfin/bfin.c b/gcc/config/bfin/bfin.c index 783beff..7dd0a24 100644 --- a/gcc/config/bfin/bfin.c +++ b/gcc/config/bfin/bfin.c @@ -540,7 +540,7 @@ expand_epilogue_reg_restore (rtx spreg, bool saveall, bool is_inthandler) CUM is as above. - MODE and TYPE are the mode and type of the current parameter. + ARG is the last named argument. PRETEND_SIZE is a variable that should be set to the amount of stack that must be pushed by the prolog to pretend that our caller pushed @@ -559,8 +559,7 @@ expand_epilogue_reg_restore (rtx spreg, bool saveall, bool is_inthandler) static void setup_incoming_varargs (cumulative_args_t cum, - machine_mode mode ATTRIBUTE_UNUSED, - tree type ATTRIBUTE_UNUSED, int *pretend_size, + const function_arg_info &, int *pretend_size, int no_rtl) { rtx mem; diff --git a/gcc/config/cris/cris.c b/gcc/config/cris/cris.c index e2a78de..0b2947e 100644 --- a/gcc/config/cris/cris.c +++ b/gcc/config/cris/cris.c @@ -108,8 +108,9 @@ static struct machine_function * cris_init_machine_status (void); static rtx cris_struct_value_rtx (tree, int); -static void cris_setup_incoming_varargs (cumulative_args_t, machine_mode, - tree type, int *, int); +static void cris_setup_incoming_varargs (cumulative_args_t, + const function_arg_info &, + int *, int); static int cris_initial_frame_pointer_offset (void); @@ -4021,8 +4022,7 @@ cris_struct_value_rtx (tree fntype ATTRIBUTE_UNUSED, static void cris_setup_incoming_varargs (cumulative_args_t ca_v, - machine_mode mode ATTRIBUTE_UNUSED, - tree type ATTRIBUTE_UNUSED, + const function_arg_info &, int *pretend_arg_size, int second_time) { diff --git a/gcc/config/csky/csky.c b/gcc/config/csky/csky.c index 98789bc..c851354 100644 --- a/gcc/config/csky/csky.c +++ b/gcc/config/csky/csky.c @@ -1937,8 +1937,7 @@ csky_arg_partial_bytes (cumulative_args_t pcum_v, const function_arg_info &arg) static void csky_setup_incoming_varargs (cumulative_args_t pcum_v, - machine_mode mode, - tree type, + const function_arg_info &arg, int *pretend_size, int second_time ATTRIBUTE_UNUSED) { @@ -1949,7 +1948,7 @@ csky_setup_incoming_varargs (cumulative_args_t pcum_v, cfun->machine->uses_anonymous_args = 1; local_cum = *pcum; - csky_function_arg_advance (local_cum_v, mode, type, true); + csky_function_arg_advance (local_cum_v, arg.mode, arg.type, arg.named); regs_to_push = CSKY_NPARM_REGS - local_cum; if (regs_to_push) *pretend_size = regs_to_push * UNITS_PER_WORD; diff --git a/gcc/config/epiphany/epiphany.c b/gcc/config/epiphany/epiphany.c index c98fc52..9dd1643 100644 --- a/gcc/config/epiphany/epiphany.c +++ b/gcc/config/epiphany/epiphany.c @@ -711,24 +711,25 @@ epiphany_function_arg_boundary (machine_mode mode, const_tree type) /* Do any needed setup for a variadic function. For the EPIPHANY, we actually emit the code in epiphany_expand_prologue. - CUM has not been updated for the last named argument which has type TYPE - and mode MODE, and we rely on this fact. */ + CUM has not been updated for the last named argument (which is given + by ARG), and we rely on this fact. */ static void -epiphany_setup_incoming_varargs (cumulative_args_t cum, machine_mode mode, - tree type, int *pretend_size, int no_rtl) +epiphany_setup_incoming_varargs (cumulative_args_t cum, + const function_arg_info &arg, + int *pretend_size, int no_rtl) { int first_anon_arg; CUMULATIVE_ARGS next_cum; machine_function_t *mf = MACHINE_FUNCTION (cfun); /* All BLKmode values are passed by reference. */ - gcc_assert (mode != BLKmode); + gcc_assert (arg.mode != BLKmode); next_cum = *get_cumulative_args (cum); - next_cum - = ROUND_ADVANCE_CUM (next_cum, mode, type) + ROUND_ADVANCE_ARG (mode, type); + next_cum = (ROUND_ADVANCE_CUM (next_cum, arg.mode, arg.type) + + ROUND_ADVANCE_ARG (arg.mode, arg.type)); first_anon_arg = next_cum; if (first_anon_arg < MAX_EPIPHANY_PARM_REGS && !no_rtl) diff --git a/gcc/config/fr30/fr30.c b/gcc/config/fr30/fr30.c index 5972801..d6c8351 100644 --- a/gcc/config/fr30/fr30.c +++ b/gcc/config/fr30/fr30.c @@ -113,8 +113,9 @@ static struct fr30_frame_info current_frame_info; /* Zero structure to initialize current_frame_info. */ static struct fr30_frame_info zero_frame_info; -static void fr30_setup_incoming_varargs (cumulative_args_t, machine_mode, - tree, int *, int); +static void fr30_setup_incoming_varargs (cumulative_args_t, + const function_arg_info &, + int *, int); static bool fr30_must_pass_in_stack (machine_mode, const_tree); static int fr30_arg_partial_bytes (cumulative_args_t, const function_arg_info &); @@ -459,12 +460,11 @@ fr30_expand_epilogue (void) 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. */ + CUM 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, + const function_arg_info &arg, int *pretend_size, int second_time ATTRIBUTE_UNUSED) { @@ -473,7 +473,7 @@ fr30_setup_incoming_varargs (cumulative_args_t arg_regs_used_so_far_v, int size; /* All BLKmode values are passed by reference. */ - gcc_assert (mode != BLKmode); + gcc_assert (arg.mode != BLKmode); /* ??? This run-time test as well as the code inside the if statement is probably unnecessary. */ @@ -481,7 +481,7 @@ fr30_setup_incoming_varargs (cumulative_args_t 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); + arg_regs_used_so_far += fr30_num_arg_regs (arg.mode, arg.type); size = FR30_NUM_ARG_REGS - (* arg_regs_used_so_far); diff --git a/gcc/config/frv/frv.c b/gcc/config/frv/frv.c index 4560fc6..5e06cf6 100644 --- a/gcc/config/frv/frv.c +++ b/gcc/config/frv/frv.c @@ -359,8 +359,8 @@ static bool frv_in_small_data_p (const_tree); static void frv_asm_output_mi_thunk (FILE *, tree, HOST_WIDE_INT, HOST_WIDE_INT, tree); static void frv_setup_incoming_varargs (cumulative_args_t, - machine_mode, - tree, int *, int); + const function_arg_info &, + int *, int); static rtx frv_expand_builtin_saveregs (void); static void frv_expand_builtin_va_start (tree, rtx); static bool frv_rtx_costs (rtx, machine_mode, int, int, @@ -2109,17 +2109,16 @@ frv_initial_elimination_offset (int from, int to) static void frv_setup_incoming_varargs (cumulative_args_t cum_v, - machine_mode mode, - tree type ATTRIBUTE_UNUSED, - int *pretend_size, - int second_time) + const function_arg_info &arg, + int *pretend_size, + int second_time) { CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v); if (TARGET_DEBUG_ARG) fprintf (stderr, "setup_vararg: words = %2d, mode = %4s, pretend_size = %d, second_time = %d\n", - *cum, GET_MODE_NAME (mode), *pretend_size, second_time); + *cum, GET_MODE_NAME (arg.mode), *pretend_size, second_time); } diff --git a/gcc/config/ft32/ft32.c b/gcc/config/ft32/ft32.c index d5b66df..ee073c8 100644 --- a/gcc/config/ft32/ft32.c +++ b/gcc/config/ft32/ft32.c @@ -630,13 +630,12 @@ ft32_initial_elimination_offset (int from, int to) static void ft32_setup_incoming_varargs (cumulative_args_t cum_v, - machine_mode mode, - tree type ATTRIBUTE_UNUSED, + const function_arg_info &arg, int *pretend_size, int no_rtl ATTRIBUTE_UNUSED) { CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v); int named_size = - GET_MODE_SIZE (SImode) * (*cum - FT32_R0) + GET_MODE_SIZE (mode); + GET_MODE_SIZE (SImode) * (*cum - FT32_R0) + GET_MODE_SIZE (arg.mode); if (named_size < 24) *pretend_size = 24 - named_size; diff --git a/gcc/config/i386/i386.c b/gcc/config/i386/i386.c index 02a551c..67959c1 100644 --- a/gcc/config/i386/i386.c +++ b/gcc/config/i386/i386.c @@ -4096,8 +4096,9 @@ setup_incoming_varargs_ms_64 (CUMULATIVE_ARGS *cum) } static void -ix86_setup_incoming_varargs (cumulative_args_t cum_v, machine_mode mode, - tree type, int *, int no_rtl) +ix86_setup_incoming_varargs (cumulative_args_t cum_v, + const function_arg_info &arg, + int *, int no_rtl) { CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v); CUMULATIVE_ARGS next_cum; @@ -4116,8 +4117,8 @@ ix86_setup_incoming_varargs (cumulative_args_t cum_v, machine_mode mode, For stdargs, we do want to skip the last named argument. */ next_cum = *cum; if (stdarg_p (fntype)) - ix86_function_arg_advance (pack_cumulative_args (&next_cum), mode, type, - true); + ix86_function_arg_advance (pack_cumulative_args (&next_cum), + arg.mode, arg.type, arg.named); if (cum->call_abi == MS_ABI) setup_incoming_varargs_ms_64 (&next_cum); diff --git a/gcc/config/ia64/ia64.c b/gcc/config/ia64/ia64.c index 13dd715..3bd2068 100644 --- a/gcc/config/ia64/ia64.c +++ b/gcc/config/ia64/ia64.c @@ -199,8 +199,9 @@ static rtx gen_fr_restore_x (rtx, rtx, rtx); static void ia64_option_override (void); static bool ia64_can_eliminate (const int, const int); static machine_mode hfa_element_mode (const_tree, bool); -static void ia64_setup_incoming_varargs (cumulative_args_t, machine_mode, - tree, int *, int); +static void ia64_setup_incoming_varargs (cumulative_args_t, + const function_arg_info &, + int *, int); static int ia64_arg_partial_bytes (cumulative_args_t, const function_arg_info &); static rtx ia64_function_arg_1 (cumulative_args_t, machine_mode, @@ -4585,19 +4586,21 @@ ia64_trampoline_init (rtx m_tramp, tree fndecl, rtx static_chain) } /* Do any needed setup for a variadic function. CUM has not been updated - for the last named argument which has type TYPE and mode MODE. + for the last named argument, which is given by ARG. We generate the actual spill instructions during prologue generation. */ static void -ia64_setup_incoming_varargs (cumulative_args_t cum, machine_mode mode, - tree type, int * pretend_size, +ia64_setup_incoming_varargs (cumulative_args_t cum, + const function_arg_info &arg, + int *pretend_size, int second_time ATTRIBUTE_UNUSED) { CUMULATIVE_ARGS next_cum = *get_cumulative_args (cum); /* Skip the current argument. */ - ia64_function_arg_advance (pack_cumulative_args (&next_cum), mode, type, 1); + ia64_function_arg_advance (pack_cumulative_args (&next_cum), + arg.mode, arg.type, arg.named); if (next_cum.words < MAX_ARGUMENT_SLOTS) { diff --git a/gcc/config/iq2000/iq2000.c b/gcc/config/iq2000/iq2000.c index db54423..ec615df 100644 --- a/gcc/config/iq2000/iq2000.c +++ b/gcc/config/iq2000/iq2000.c @@ -152,8 +152,8 @@ static void iq2000_init_builtins (void); static rtx iq2000_expand_builtin (tree, rtx, rtx, machine_mode, int); static bool iq2000_return_in_memory (const_tree, const_tree); static void iq2000_setup_incoming_varargs (cumulative_args_t, - machine_mode, tree, int *, - int); + const function_arg_info &, + int *, int); static bool iq2000_rtx_costs (rtx, machine_mode, int, int, int *, bool); static int iq2000_address_cost (rtx, machine_mode, addr_space_t, bool); @@ -2894,9 +2894,8 @@ iq2000_return_in_memory (const_tree type, const_tree fntype ATTRIBUTE_UNUSED) static void iq2000_setup_incoming_varargs (cumulative_args_t cum_v, - machine_mode mode ATTRIBUTE_UNUSED, - tree type ATTRIBUTE_UNUSED, int * pretend_size, - int no_rtl) + const function_arg_info &, + int *pretend_size, int no_rtl) { CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v); unsigned int iq2000_off = ! cum->last_arg_fp; diff --git a/gcc/config/lm32/lm32.c b/gcc/config/lm32/lm32.c index 7ed9ac0..c9d863d 100644 --- a/gcc/config/lm32/lm32.c +++ b/gcc/config/lm32/lm32.c @@ -64,7 +64,7 @@ static void expand_save_restore (struct lm32_frame_info *info, int op); static void stack_adjust (HOST_WIDE_INT amount); static bool lm32_in_small_data_p (const_tree); static void lm32_setup_incoming_varargs (cumulative_args_t cum, - machine_mode mode, tree type, + const function_arg_info &, int *pretend_size, int no_rtl); static bool lm32_rtx_costs (rtx x, machine_mode mode, int outer_code, int opno, int *total, bool speed); @@ -684,8 +684,9 @@ lm32_compute_initial_elimination_offset (int from, int to) } static void -lm32_setup_incoming_varargs (cumulative_args_t cum_v, machine_mode mode, - tree type, int *pretend_size, int no_rtl) +lm32_setup_incoming_varargs (cumulative_args_t cum_v, + const function_arg_info &arg, + int *pretend_size, int no_rtl) { CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v); int first_anon_arg; @@ -702,12 +703,7 @@ lm32_setup_incoming_varargs (cumulative_args_t cum_v, machine_mode mode, 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); + int size = arg.promoted_size_in_bytes (); first_anon_arg = *cum + LM32_FIRST_ARG_REG + diff --git a/gcc/config/m32r/m32r.c b/gcc/config/m32r/m32r.c index 7ee4fed..01bbec9 100644 --- a/gcc/config/m32r/m32r.c +++ b/gcc/config/m32r/m32r.c @@ -86,8 +86,9 @@ static bool m32r_return_in_memory (const_tree, const_tree); static rtx m32r_function_value (const_tree, const_tree, bool); static rtx m32r_libcall_value (machine_mode, const_rtx); static bool m32r_function_value_regno_p (const unsigned int); -static void m32r_setup_incoming_varargs (cumulative_args_t, machine_mode, - tree, int *, int); +static void m32r_setup_incoming_varargs (cumulative_args_t, + const function_arg_info &, + int *, int); static void init_idents (void); static bool m32r_rtx_costs (rtx, machine_mode, int, int, int *, bool speed); static int m32r_memory_move_cost (machine_mode, reg_class_t, bool); @@ -1280,12 +1281,13 @@ m32r_function_value_regno_p (const unsigned int regno) create a register parameter block, and then copy any anonymous arguments in registers to memory. - CUM has not been updated for the last named argument which has type TYPE - and mode MODE, and we rely on this fact. */ + CUM has not been updated for the last named argument (which is given + by ARG), and we rely on this fact. */ static void -m32r_setup_incoming_varargs (cumulative_args_t cum, machine_mode mode, - tree type, int *pretend_size, int no_rtl) +m32r_setup_incoming_varargs (cumulative_args_t cum, + const function_arg_info &arg, + int *pretend_size, int no_rtl) { int first_anon_arg; @@ -1293,10 +1295,11 @@ m32r_setup_incoming_varargs (cumulative_args_t cum, machine_mode mode, return; /* All BLKmode values are passed by reference. */ - gcc_assert (mode != BLKmode); + gcc_assert (arg.mode != BLKmode); - first_anon_arg = (ROUND_ADVANCE_CUM (*get_cumulative_args (cum), mode, type) - + ROUND_ADVANCE_ARG (mode, type)); + first_anon_arg = (ROUND_ADVANCE_CUM (*get_cumulative_args (cum), + arg.mode, arg.type) + + ROUND_ADVANCE_ARG (arg.mode, arg.type)); if (first_anon_arg < M32R_MAX_PARM_REGS) { diff --git a/gcc/config/mcore/mcore.c b/gcc/config/mcore/mcore.c index d93c818..98f0111 100644 --- a/gcc/config/mcore/mcore.c +++ b/gcc/config/mcore/mcore.c @@ -99,7 +99,9 @@ static int calc_live_regs (int *); static int try_constant_tricks (HOST_WIDE_INT, HOST_WIDE_INT *, HOST_WIDE_INT *); static const char * output_inline_const (machine_mode, rtx *); static void layout_mcore_frame (struct mcore_frame *); -static void mcore_setup_incoming_varargs (cumulative_args_t, machine_mode, tree, int *, int); +static void mcore_setup_incoming_varargs (cumulative_args_t, + const function_arg_info &, + int *, int); static cond_type is_cond_candidate (rtx); static rtx_insn *emit_new_cond_insn (rtx_insn *, int); static rtx_insn *conditionalize_block (rtx_insn *); @@ -1942,7 +1944,7 @@ mcore_initial_elimination_offset (int from, int to) static void mcore_setup_incoming_varargs (cumulative_args_t args_so_far_v, - machine_mode mode, tree type, + const function_arg_info &arg, int * ptr_pretend_size ATTRIBUTE_UNUSED, int second_time ATTRIBUTE_UNUSED) { @@ -1953,7 +1955,8 @@ mcore_setup_incoming_varargs (cumulative_args_t args_so_far_v, /* We need to know how many argument registers are used before the varargs start, so that we can push the remaining argument registers during the prologue. */ - number_of_regs_before_varargs = *args_so_far + mcore_num_arg_regs (mode, type); + number_of_regs_before_varargs + = *args_so_far + mcore_num_arg_regs (arg.mode, arg.type); /* There is a bug somewhere in the arg handling code. Until I can find it this workaround always pushes the diff --git a/gcc/config/mips/mips.c b/gcc/config/mips/mips.c index 8a8adb9..1427e99 100644 --- a/gcc/config/mips/mips.c +++ b/gcc/config/mips/mips.c @@ -6544,9 +6544,9 @@ mips_return_in_memory (const_tree type, const_tree fndecl ATTRIBUTE_UNUSED) /* Implement TARGET_SETUP_INCOMING_VARARGS. */ static void -mips_setup_incoming_varargs (cumulative_args_t cum, machine_mode mode, - tree type, int *pretend_size ATTRIBUTE_UNUSED, - int no_rtl) +mips_setup_incoming_varargs (cumulative_args_t cum, + const function_arg_info &arg, + int *pretend_size ATTRIBUTE_UNUSED, int no_rtl) { CUMULATIVE_ARGS local_cum; int gp_saved, fp_saved; @@ -6555,8 +6555,8 @@ mips_setup_incoming_varargs (cumulative_args_t cum, machine_mode mode, argument. Advance a local copy of CUM past the last "real" named argument, to find out how many registers are left over. */ local_cum = *get_cumulative_args (cum); - mips_function_arg_advance (pack_cumulative_args (&local_cum), mode, type, - true); + mips_function_arg_advance (pack_cumulative_args (&local_cum), + arg.mode, arg.type, arg.named); /* Found out how many registers we need to save. */ gp_saved = MAX_ARGS_IN_REGISTERS - local_cum.num_gprs; diff --git a/gcc/config/mmix/mmix.c b/gcc/config/mmix/mmix.c index 1b3a609..cb70a2d 100644 --- a/gcc/config/mmix/mmix.c +++ b/gcc/config/mmix/mmix.c @@ -138,7 +138,7 @@ static void mmix_reorg (void); static void mmix_asm_output_mi_thunk (FILE *, tree, HOST_WIDE_INT, HOST_WIDE_INT, tree); static void mmix_setup_incoming_varargs - (cumulative_args_t, machine_mode, tree, int *, int); + (cumulative_args_t, const function_arg_info &, int *, int); static void mmix_file_start (void); static void mmix_file_end (void); static void mmix_init_libfuncs (void); @@ -960,8 +960,7 @@ mmix_function_profiler (FILE *stream ATTRIBUTE_UNUSED, static void mmix_setup_incoming_varargs (cumulative_args_t args_so_farp_v, - machine_mode mode, - tree vartype, + const function_arg_info &arg, int *pretend_sizep, int second_time ATTRIBUTE_UNUSED) { @@ -974,7 +973,7 @@ mmix_setup_incoming_varargs (cumulative_args_t args_so_farp_v, /* We assume that one argument takes up one register here. That should be true until we start messing with multi-reg parameters. */ - if ((7 + (MMIX_FUNCTION_ARG_SIZE (mode, vartype))) / 8 != 1) + if ((7 + (MMIX_FUNCTION_ARG_SIZE (arg.mode, arg.type))) / 8 != 1) internal_error ("MMIX Internal: Last named vararg would not fit in a register"); } diff --git a/gcc/config/moxie/moxie.c b/gcc/config/moxie/moxie.c index e8eaedf..a8e1bf2 100644 --- a/gcc/config/moxie/moxie.c +++ b/gcc/config/moxie/moxie.c @@ -385,8 +385,7 @@ moxie_initial_elimination_offset (int from, int to) static void moxie_setup_incoming_varargs (cumulative_args_t cum_v, - machine_mode mode ATTRIBUTE_UNUSED, - tree type ATTRIBUTE_UNUSED, + const function_arg_info &, int *pretend_size, int no_rtl) { CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v); diff --git a/gcc/config/nds32/nds32.c b/gcc/config/nds32/nds32.c index c92a598..b076aa4 100644 --- a/gcc/config/nds32/nds32.c +++ b/gcc/config/nds32/nds32.c @@ -2345,8 +2345,7 @@ nds32_warn_func_return (tree decl) static void nds32_setup_incoming_varargs (cumulative_args_t ca, - machine_mode mode, - tree type, + const function_arg_info &arg, int *pretend_args_size, int second_time ATTRIBUTE_UNUSED) { @@ -2370,14 +2369,14 @@ nds32_setup_incoming_varargs (cumulative_args_t ca, cum = get_cumulative_args (ca); - /* The MODE and TYPE describe the last argument. + /* ARG describes the last argument. We need those information to determine the remaining registers for varargs. */ total_args_regs = NDS32_MAX_GPR_REGS_FOR_ARGS + NDS32_GPR_ARG_FIRST_REGNUM; num_of_used_regs - = NDS32_AVAILABLE_REGNUM_FOR_GPR_ARG (cum->gpr_offset, mode, type) - + NDS32_NEED_N_REGS_FOR_ARG (mode, type); + = NDS32_AVAILABLE_REGNUM_FOR_GPR_ARG (cum->gpr_offset, arg.mode, arg.type) + + NDS32_NEED_N_REGS_FOR_ARG (arg.mode, arg.type); remaining_reg_count = total_args_regs - num_of_used_regs; *pretend_args_size = remaining_reg_count * UNITS_PER_WORD; diff --git a/gcc/config/nios2/nios2.c b/gcc/config/nios2/nios2.c index 1e04cf9..b93274a 100644 --- a/gcc/config/nios2/nios2.c +++ b/gcc/config/nios2/nios2.c @@ -3516,8 +3516,8 @@ nios2_return_in_memory (const_tree type, const_tree fntype ATTRIBUTE_UNUSED) own va_arg type. */ static void nios2_setup_incoming_varargs (cumulative_args_t cum_v, - machine_mode mode, tree type, - int *pretend_size, int second_time) + const function_arg_info &arg, + int *pretend_size, int second_time) { CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v); CUMULATIVE_ARGS local_cum; @@ -3527,7 +3527,7 @@ nios2_setup_incoming_varargs (cumulative_args_t cum_v, cfun->machine->uses_anonymous_args = 1; local_cum = *cum; - nios2_function_arg_advance (local_cum_v, mode, type, true); + nios2_function_arg_advance (local_cum_v, arg.mode, arg.type, arg.named); regs_to_push = NUM_ARG_REGS - local_cum.regs_used; diff --git a/gcc/config/riscv/riscv.c b/gcc/config/riscv/riscv.c index 659e3ed..47d9001 100644 --- a/gcc/config/riscv/riscv.c +++ b/gcc/config/riscv/riscv.c @@ -2854,9 +2854,9 @@ riscv_return_in_memory (const_tree type, const_tree fndecl ATTRIBUTE_UNUSED) /* Implement TARGET_SETUP_INCOMING_VARARGS. */ static void -riscv_setup_incoming_varargs (cumulative_args_t cum, machine_mode mode, - tree type, int *pretend_size ATTRIBUTE_UNUSED, - int no_rtl) +riscv_setup_incoming_varargs (cumulative_args_t cum, + const function_arg_info &arg, + int *pretend_size ATTRIBUTE_UNUSED, int no_rtl) { CUMULATIVE_ARGS local_cum; int gp_saved; @@ -2865,7 +2865,8 @@ riscv_setup_incoming_varargs (cumulative_args_t cum, machine_mode mode, argument. Advance a local copy of CUM past the last "real" named argument, to find out how many registers are left over. */ local_cum = *get_cumulative_args (cum); - riscv_function_arg_advance (pack_cumulative_args (&local_cum), mode, type, 1); + riscv_function_arg_advance (pack_cumulative_args (&local_cum), + arg.mode, arg.type, arg.named); /* Found out how many registers we need to save. */ gp_saved = MAX_ARGS_IN_REGISTERS - local_cum.num_gprs; diff --git a/gcc/config/rs6000/rs6000-call.c b/gcc/config/rs6000/rs6000-call.c index 4f006aa..874d525 100644 --- a/gcc/config/rs6000/rs6000-call.c +++ b/gcc/config/rs6000/rs6000-call.c @@ -2365,7 +2365,7 @@ rs6000_move_block_from_reg (int regno, rtx x, int nregs) CUM is as above. - MODE and TYPE are the mode and type of the current parameter. + ARG is the last named argument. PRETEND_SIZE is a variable that should be set to the amount of stack that must be pushed by the prolog to pretend that our caller pushed @@ -2375,9 +2375,9 @@ rs6000_move_block_from_reg (int regno, rtx x, int nregs) stack and set PRETEND_SIZE to the length of the registers pushed. */ void -setup_incoming_varargs (cumulative_args_t cum, machine_mode mode, - tree type, int *pretend_size ATTRIBUTE_UNUSED, - int no_rtl) +setup_incoming_varargs (cumulative_args_t cum, + const function_arg_info &arg, + int *pretend_size ATTRIBUTE_UNUSED, int no_rtl) { CUMULATIVE_ARGS next_cum; int reg_size = TARGET_32BIT ? 4 : 8; @@ -2387,7 +2387,7 @@ setup_incoming_varargs (cumulative_args_t cum, machine_mode mode, /* Skip the last named argument. */ next_cum = *get_cumulative_args (cum); - rs6000_function_arg_advance_1 (&next_cum, mode, type, true, 0); + rs6000_function_arg_advance_1 (&next_cum, arg.mode, arg.type, arg.named, 0); if (DEFAULT_ABI == ABI_V4) { @@ -2461,8 +2461,8 @@ setup_incoming_varargs (cumulative_args_t cum, machine_mode mode, first_reg_offset = next_cum.words; save_area = crtl->args.internal_arg_pointer; - if (targetm.calls.must_pass_in_stack (mode, type)) - first_reg_offset += rs6000_arg_size (TYPE_MODE (type), type); + if (targetm.calls.must_pass_in_stack (arg.mode, arg.type)) + first_reg_offset += rs6000_arg_size (TYPE_MODE (arg.type), arg.type); } set = get_varargs_alias_set (); diff --git a/gcc/config/rs6000/rs6000-internal.h b/gcc/config/rs6000/rs6000-internal.h index 9601782..45a6a7a 100644 --- a/gcc/config/rs6000/rs6000-internal.h +++ b/gcc/config/rs6000/rs6000-internal.h @@ -152,9 +152,8 @@ extern bool rs6000_return_in_memory (const_tree type, extern bool rs6000_return_in_msb (const_tree valtype); extern bool rs6000_pass_by_reference (cumulative_args_t, const function_arg_info &); -extern void setup_incoming_varargs (cumulative_args_t cum, machine_mode mode, - tree type, int *pretend_size ATTRIBUTE_UNUSED, - int no_rtl); +extern void setup_incoming_varargs (cumulative_args_t, + const function_arg_info &, int *, int); extern unsigned int rs6000_function_arg_boundary (machine_mode mode, const_tree type); extern bool rs6000_must_pass_in_stack (machine_mode mode, const_tree type); diff --git a/gcc/config/sh/sh.c b/gcc/config/sh/sh.c index e84a3dd..bcd82cb 100644 --- a/gcc/config/sh/sh.c +++ b/gcc/config/sh/sh.c @@ -280,8 +280,8 @@ static bool sh_function_value_regno_p (const unsigned int); static rtx sh_libcall_value (machine_mode, const_rtx); static bool sh_return_in_memory (const_tree, const_tree); static rtx sh_builtin_saveregs (void); -static void sh_setup_incoming_varargs (cumulative_args_t, machine_mode, - tree, int *, int); +static void sh_setup_incoming_varargs (cumulative_args_t, + const function_arg_info &, int *, int); static bool sh_strict_argument_naming (cumulative_args_t); static bool sh_pretend_outgoing_varargs_named (cumulative_args_t); static void sh_atomic_assign_expand_fenv (tree *, tree *, tree *); @@ -8184,8 +8184,7 @@ sh_return_in_memory (const_tree type, const_tree fndecl) function that tell if a function uses varargs or stdarg. */ static void sh_setup_incoming_varargs (cumulative_args_t ca, - machine_mode mode, - tree type, + const function_arg_info &arg, int *pretend_arg_size, int second_time ATTRIBUTE_UNUSED) { @@ -8194,10 +8193,9 @@ sh_setup_incoming_varargs (cumulative_args_t ca, { int named_parm_regs, anon_parm_regs; - named_parm_regs = (sh_round_reg (*get_cumulative_args (ca), mode) - + (mode == BLKmode - ? CEIL (int_size_in_bytes (type), UNITS_PER_WORD) - : CEIL (GET_MODE_SIZE (mode), UNITS_PER_WORD))); + named_parm_regs = (sh_round_reg (*get_cumulative_args (ca), arg.mode) + + CEIL (arg.promoted_size_in_bytes (), + UNITS_PER_WORD)); anon_parm_regs = NPARM_REGS (SImode) - named_parm_regs; if (anon_parm_regs > 0) *pretend_arg_size = anon_parm_regs * 4; diff --git a/gcc/config/spu/spu.c b/gcc/config/spu/spu.c index 43a25c4..92dd556 100644 --- a/gcc/config/spu/spu.c +++ b/gcc/config/spu/spu.c @@ -4089,8 +4089,9 @@ spu_gimplify_va_arg_expr (tree valist, tree type, gimple_seq * pre_p, in the stack then save no registers. Set pretend_args_size to the amount of space needed to save the registers. */ static void -spu_setup_incoming_varargs (cumulative_args_t cum, machine_mode mode, - tree type, int *pretend_size, int no_rtl) +spu_setup_incoming_varargs (cumulative_args_t cum, + const function_arg_info &arg, + int *pretend_size, int no_rtl) { if (!no_rtl) { @@ -4101,7 +4102,8 @@ spu_setup_incoming_varargs (cumulative_args_t cum, machine_mode mode, /* cum currently points to the last named argument, we want to start at the next argument. */ - spu_function_arg_advance (pack_cumulative_args (&ncum), mode, type, true); + spu_function_arg_advance (pack_cumulative_args (&ncum), + arg.mode, arg.type, arg.named); offset = -STACK_POINTER_OFFSET; for (regno = ncum; regno < MAX_REGISTER_ARGS; regno++) diff --git a/gcc/config/tilegx/tilegx.c b/gcc/config/tilegx/tilegx.c index f800e9e..6f334825 100644 --- a/gcc/config/tilegx/tilegx.c +++ b/gcc/config/tilegx/tilegx.c @@ -390,8 +390,8 @@ tilegx_va_start (tree valist, rtx nextarg ATTRIBUTE_UNUSED) /* Implement TARGET_SETUP_INCOMING_VARARGS. */ static void tilegx_setup_incoming_varargs (cumulative_args_t cum, - machine_mode mode, - tree type, int *pretend_args, int no_rtl) + const function_arg_info &arg, + int *pretend_args, int no_rtl) { CUMULATIVE_ARGS local_cum = *get_cumulative_args (cum); int first_reg; @@ -400,7 +400,7 @@ tilegx_setup_incoming_varargs (cumulative_args_t cum, argument. Advance a local copy of CUM past the last "real" named argument, to find out how many registers are left over. */ targetm.calls.function_arg_advance (pack_cumulative_args (&local_cum), - mode, type, true); + arg.mode, arg.type, arg.named); first_reg = local_cum; if (local_cum < TILEGX_NUM_ARG_REGS) diff --git a/gcc/config/tilepro/tilepro.c b/gcc/config/tilepro/tilepro.c index 483a897..dd53771 100644 --- a/gcc/config/tilepro/tilepro.c +++ b/gcc/config/tilepro/tilepro.c @@ -342,8 +342,8 @@ tilepro_va_start (tree valist, rtx nextarg ATTRIBUTE_UNUSED) /* Implement TARGET_SETUP_INCOMING_VARARGS. */ static void tilepro_setup_incoming_varargs (cumulative_args_t cum, - machine_mode mode, - tree type, int *pretend_args, int no_rtl) + const function_arg_info &arg, + int *pretend_args, int no_rtl) { CUMULATIVE_ARGS local_cum = *get_cumulative_args (cum); int first_reg; @@ -352,7 +352,7 @@ tilepro_setup_incoming_varargs (cumulative_args_t cum, argument. Advance a local copy of CUM past the last "real" named argument, to find out how many registers are left over. */ targetm.calls.function_arg_advance (pack_cumulative_args (&local_cum), - mode, type, true); + arg.mode, arg.type, arg.named); first_reg = local_cum; if (local_cum < TILEPRO_NUM_ARG_REGS) diff --git a/gcc/config/visium/visium.c b/gcc/config/visium/visium.c index 456bba2..2dd261a 100644 --- a/gcc/config/visium/visium.c +++ b/gcc/config/visium/visium.c @@ -175,8 +175,8 @@ static rtx visium_function_value (const_tree, const_tree fn_decl_or_type, static rtx visium_libcall_value (machine_mode, const_rtx); static void visium_setup_incoming_varargs (cumulative_args_t, - machine_mode, - tree, int *, int); + const function_arg_info &, + int *, int); static void visium_va_start (tree valist, rtx nextarg); @@ -1460,8 +1460,7 @@ visium_libcall_value (machine_mode mode, const_rtx fun ATTRIBUTE_UNUSED) static void visium_setup_incoming_varargs (cumulative_args_t pcum_v, - machine_mode mode, - tree type, + const function_arg_info &arg, int *pretend_size ATTRIBUTE_UNUSED, int no_rtl) { @@ -1487,7 +1486,8 @@ visium_setup_incoming_varargs (cumulative_args_t pcum_v, /* The caller has advanced ARGS_SO_FAR up to, but not beyond, the last named argument. Advance a local copy of ARGS_SO_FAR past the last "real" named argument, to find out how many registers are left over. */ - TARGET_FUNCTION_ARG_ADVANCE (local_args_so_far, mode, type, 1); + TARGET_FUNCTION_ARG_ADVANCE (local_args_so_far, arg.mode, + arg.type, arg.named); /* Find how many registers we need to save. */ locargs = get_cumulative_args (local_args_so_far); -- cgit v1.1