CbC/CbC_gcc: gcc/config/mcore/mcore.c comparison

comparison gcc/config/mcore/mcore.c @ 145:1830386684a0

gcc-9.2.0

author	anatofuz
date	Thu, 13 Feb 2020 11:34:05 +0900
parents	84e7813d76e9
children

comparison

equal deleted inserted replaced

-:84e7813d76e9
+:1830386684a0
 /* Output routines for Motorola MCore processor
-Copyright (C) 1993-2018 Free Software Foundation, Inc.
+Copyright (C) 1993-2020 Free Software Foundation, Inc.
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify it
 under the terms of the GNU General Public License as published
 static void       output_stack_adjust           (int, int);
 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 *);
 static void       conditionalize_optimization   (void);
 static void       mcore_reorg                   (void);
 static bool       mcore_rtx_costs		(rtx, machine_mode, int, int,
 						 int *, bool);
 static void       mcore_external_libcall	(rtx);
 static bool       mcore_return_in_memory	(const_tree, const_tree);
 static int        mcore_arg_partial_bytes       (cumulative_args_t,
-						 machine_mode,
+						 const function_arg_info &);
-						 tree, bool);
 static rtx        mcore_function_arg            (cumulative_args_t,
-						 machine_mode,
+						 const function_arg_info &);
-						 const_tree, bool);
 static void       mcore_function_arg_advance    (cumulative_args_t,
-						 machine_mode,
+						 const function_arg_info &);
-						 const_tree, bool);
 static unsigned int mcore_function_arg_boundary (machine_mode,
 						 const_tree);
 static void       mcore_asm_trampoline_template (FILE *);
 static void       mcore_trampoline_init		(rtx, tree, rtx);
 static bool       mcore_warn_func_return        (tree);
 * count = 0;
 for (reg = 0; reg < FIRST_PSEUDO_REGISTER; reg++)
 {
-if (df_regs_ever_live_p (reg) && !call_used_regs[reg])
+if (df_regs_ever_live_p (reg) && !call_used_or_fixed_reg_p (reg))
 	{
 	  (*count)++;
 	  live_regs_mask |= (1 << reg);
 	}
 }
 /* Keep track of some information about varargs for the prolog.  */
 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)
 {
 CUMULATIVE_ARGS *args_so_far = get_cumulative_args (args_so_far_v);
 current_function_anonymous_args = 1;
 /* 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
 last named argument onto the stack.  */
 number_of_regs_before_varargs = *args_so_far;
 int
 mcore_num_arg_regs (machine_mode mode, const_tree type)
 {
 int size;
-if (targetm.calls.must_pass_in_stack (mode, type))
+function_arg_info arg (const_cast<tree> (type), mode, /*named=*/true);
+if (targetm.calls.must_pass_in_stack (arg))
 return 0;
 if (type && mode == BLKmode)
 size = int_size_in_bytes (type);
 else
 /* Define where to put the arguments to a function.
 Value is zero to push the argument on the stack,
 or a hard register in which to store the argument.
-MODE is the argument's machine mode.
-TYPE is the data type of the argument (as a tree).
-This is null for libcalls where that information may
-not be available.
 CUM is a variable of type CUMULATIVE_ARGS which gives info about
 the preceding args and about the function being called.
-NAMED is nonzero if this argument is a named parameter
+ARG is a description of the argument.
-(otherwise it is an extra parameter matching an ellipsis).
 On MCore the first args are normally in registers
 and the rest are pushed.  Any arg that starts within the first
 NPARM_REGS words is at least partially passed in a register unless
 its data type forbids.  */
 static rtx
-mcore_function_arg (cumulative_args_t cum, machine_mode mode,
+mcore_function_arg (cumulative_args_t cum, const function_arg_info &arg)
-		    const_tree type, bool named)
 {
 int arg_reg;
-if (! named || mode == VOIDmode)
+if (!arg.named || arg.end_marker_p ())
 return 0;
-if (targetm.calls.must_pass_in_stack (mode, type))
+if (targetm.calls.must_pass_in_stack (arg))
 return 0;
-arg_reg = ROUND_REG (*get_cumulative_args (cum), mode);
+arg_reg = ROUND_REG (*get_cumulative_args (cum), arg.mode);
 if (arg_reg < NPARM_REGS)
-return handle_structs_in_regs (mode, type, FIRST_PARM_REG + arg_reg);
+return handle_structs_in_regs (arg.mode, arg.type,
+				   FIRST_PARM_REG + arg_reg);
 return 0;
 }
 static void
-mcore_function_arg_advance (cumulative_args_t cum_v, machine_mode mode,
+mcore_function_arg_advance (cumulative_args_t cum_v,
-			    const_tree type, bool named ATTRIBUTE_UNUSED)
+			    const function_arg_info &arg)
 {
 CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
-*cum = (ROUND_REG (*cum, mode)
+*cum = (ROUND_REG (*cum, arg.mode)
-	  + (int)named * mcore_num_arg_regs (mode, type));
+	  + (int) arg.named * mcore_num_arg_regs (arg.mode, arg.type));
 }
 static unsigned int
 mcore_function_arg_boundary (machine_mode mode,
 			     const_tree type ATTRIBUTE_UNUSED)
 	  ? BIGGEST_ALIGNMENT
 	  : PARM_BOUNDARY);
 }
 /* Returns the number of bytes of argument registers required to hold *part*
-of a parameter of machine mode MODE and type TYPE (which may be NULL if
+of argument ARG.  If the argument fits entirely in the argument registers,
-the type is not known).  If the argument fits entirely in the argument
+or entirely on the stack, then 0 is returned.  CUM is the number of
-registers, or entirely on the stack, then 0 is returned.  CUM is the
+argument registers already used by earlier parameters to the function.  */
-number of argument registers already used by earlier parameters to
-the function.  */
 static int
-mcore_arg_partial_bytes (cumulative_args_t cum, machine_mode mode,
+mcore_arg_partial_bytes (cumulative_args_t cum, const function_arg_info &arg)
-			 tree type, bool named)
+{
-{
+int reg = ROUND_REG (*get_cumulative_args (cum), arg.mode);
-int reg = ROUND_REG (*get_cumulative_args (cum), mode);
+if (!arg.named)
-if (named == 0)
 return 0;
-if (targetm.calls.must_pass_in_stack (mode, type))
+if (targetm.calls.must_pass_in_stack (arg))
 return 0;
 /* REG is not the *hardware* register number of the register that holds
 the argument, it is the *argument* register number.  So for example,
 the first argument to a function goes in argument register 0, which
 the target.  */
 if (reg >= NPARM_REGS)
 return 0;
 /* If the argument fits entirely in registers, return 0.  */
-if (reg + mcore_num_arg_regs (mode, type) <= NPARM_REGS)
+if (reg + mcore_num_arg_regs (arg.mode, arg.type) <= NPARM_REGS)
 return 0;
 /* The argument overflows the number of available argument registers.
 Compute how many argument registers have not yet been assigned to
 hold an argument.  */

Mercurial > hg > CbC > CbC_gcc

comparison gcc/config/mcore/mcore.c @ 145:1830386684a0