+2010-06-29 Nathan Froyd <froydnj@codesourcery.com>
+
+ * reginfo.c (init_reg_sets_1): Adjust comments.
+ * combine-stack-adj.c (rest_of_handle_stack_adjustments): Likewise.
+ * calls.c (prepare_call_address): Likewise.
+ (emit_call_1): Use targetm.calls.return_pops_args.
+ (expand_call): Likewise.
+ * function.c (assign_parms): Likewise.
+ * system.h (RETURN_POPS_ARGS): Add to #pragma poison list.
+ * target.h (struct gcc_target) [struct calls]: Add
+ return_pops_args field.
+ * targhooks.h (default_return_pops_args): Declare.
+ * targhooks.c (default_return_pops_args): Define.
+ * target-def.h (TARGET_RETURN_POPS_ARGS): Define.
+ (TARGET_CALLS): Add TARGET_RETURN_POPS_ARGS.
+ * doc/tm.texi (RETURN_POPS_ARGS): Rename to...
+ (TARGET_RETURN_POPS_ARGS): ...this. Use deftypefn. Adjust
+ documentation.
+ * config/alpha/alpha.h (RETURN_POPS_ARGS): Delete.
+ * config/arc/arc.h (RETURN_POPS_ARGS): Likewise.
+ * config/arm/arm.h (RETURN_POPS_ARGS): Likewise.
+ * config/avr/avr.h (RETURN_POPS_ARGS): Likewise.
+ * config/bfin/bfin.h (RETURN_POPS_ARGS): Likewise.
+ * config/cris/cris.h (RETURN_POPS_ARGS): Likewise.
+ * config/crx/crx.h (RETURN_POPS_ARGS): Likewise.
+ * config/fr30/fr30.h (RETURN_POPS_ARGS): Likewise.
+ * config/frv/frv.h (RETURN_POPS_ARGS): Likewise.
+ * config/h8300/h8300.h (RETURN_POPS_ARGS): Likewise.
+ * config/ia64/ia64.h (RETURN_POPS_ARGS): Likewise.
+ * config/iq2000/iq2000.h (RETURN_POPS_ARGS): Likewise.
+ * config/lm32/lm32.h (RETURN_POPS_ARGS): Likewise.
+ * config/m32c/m32c.h (RETURN_POPS_ARGS): Likewise.
+ * config/m32r/m32r.h (RETURN_POPS_ARGS): Likewise.
+ * config/m68hc11/m68hc11.h (RETURN_POPS_ARGS): Likewise.
+ * config/mcore/mcore.h (RETURN_POPS_ARGS): Likewise.
+ * config/mep/mep.h (RETURN_POPS_ARGS): Likewise.
+ * config/mips/mips.h (RETURN_POPS_ARGS): Likewise.
+ * config/mmix/mmix.h (RETURN_POPS_ARGS): Likewise.
+ * config/mn10300/mn10300.h (RETURN_POPS_ARGS): Likewise.
+ * config/moxie/moxie.h (RETURN_POPS_ARGS): Likewise.
+ * config/pa/pa.h (RETURN_POPS_ARGS): Likewise.
+ * config/pdp11/pdp11.h (RETURN_POPS_ARGS): Likewise.
+ * config/picochip/picochip.h (RETURN_POPS_ARGS): Likewise.
+ * config/rs6000/rs6000.h (RETURN_POPS_ARGS): Likewise.
+ * config/rx/rx.h (RETURN_POPS_ARGS): Likewise.
+ * config/s390/s390.h (RETURN_POPS_ARGS): Likewise.
+ * config/score/score.h (RETURN_POPS_ARGS): Likewise.
+ * config/sh/sh.h (RETURN_POPS_ARGS): Likewise.
+ * config/sparc/sparc.h (RETURN_POPS_ARGS): Likewise.
+ * config/spu/spu.h (RETURN_POPS_ARGS): Likewise.
+ * config/stormy16/stormy16.h (RETURN_POPS_ARGS): Likewise.
+ * config/v850/v850.h (RETURN_POPS_ARGS): Likewise.
+ * config/xtensa/xtensa.h (RETURN_POPS_ARGS): Likewise.
+ * config/i386/i386-protos.h (ix86_return_pops_args): Delete.
+ * config/i386/i386.h (RETURN_POPS_ARGS): Delete.
+ * config/i386/i386.c (ix86_return_pops_args): Make static.
+ Constify arguments.
+ (TARGET_RETURN_POPS_ARGS): Define.
+ * config/m68k/m68k.h (RETURN_POPS_ARGS): Move to...
+ * config/m68k/m68k.c (m68k_return_pops_args): ...here. New function.
+ (TARGET_RETURN_POPS_ARGS): Define.
+ * config/vax/vax.h (RETURN_POPS_ARGS): Move to...
+ * config/vax/vax.c (vax_return_pops_args): ...here. New function.
+ (TARGET_RETURN_POPS_ARGS): Define.
+
2010-06-29 Richard Guenther <rguenther@suse.de>
PR middle-end/44667
The CALL_INSN is the first insn generated.
FNDECL is the declaration node of the function. This is given to the
- macro RETURN_POPS_ARGS to determine whether this function pops its own args.
+ hook TARGET_RETURN_POPS_ARGS to determine whether this function pops
+ its own args.
- FUNTYPE is the data type of the function. This is given to the macro
- RETURN_POPS_ARGS to determine whether this function pops its own args.
- We used to allow an identifier for library functions, but that doesn't
- work when the return type is an aggregate type and the calling convention
- says that the pointer to this aggregate is to be popped by the callee.
+ FUNTYPE is the data type of the function. This is given to the hook
+ TARGET_RETURN_POPS_ARGS to determine whether this function pops its
+ own args. We used to allow an identifier for library functions, but
+ that doesn't work when the return type is an aggregate type and the
+ calling convention says that the pointer to this aggregate is to be
+ popped by the callee.
STACK_SIZE is the number of bytes of arguments on the stack,
ROUNDED_STACK_SIZE is that number rounded up to
rtx rounded_stack_size_rtx = GEN_INT (rounded_stack_size);
rtx call_insn;
int already_popped = 0;
- HOST_WIDE_INT n_popped = RETURN_POPS_ARGS (fndecl, funtype, stack_size);
+ HOST_WIDE_INT n_popped
+ = targetm.calls.return_pops_args (fndecl, funtype, stack_size);
#ifdef CALL_POPS_ARGS
n_popped += CALL_POPS_ARGS (* args_so_far);
- crtl->args.pretend_args_size)
/* If the callee pops its own arguments, then it must pop exactly
the same number of arguments as the current function. */
- || (RETURN_POPS_ARGS (fndecl, funtype, args_size.constant)
- != RETURN_POPS_ARGS (current_function_decl,
- TREE_TYPE (current_function_decl),
- crtl->args.size))
+ || (targetm.calls.return_pops_args (fndecl, funtype, args_size.constant)
+ != targetm.calls.return_pops_args (current_function_decl,
+ TREE_TYPE (current_function_decl),
+ crtl->args.size))
|| !lang_hooks.decls.ok_for_sibcall (fndecl))
try_tail_call = 0;
cleanup_cfg (flag_crossjumping ? CLEANUP_CROSSJUMP : 0);
/* This is kind of a heuristic. We need to run combine_stack_adjustments
- even for machines with possibly nonzero RETURN_POPS_ARGS
+ even for machines with possibly nonzero TARGET_RETURN_POPS_ARGS
and ACCUMULATE_OUTGOING_ARGS. We expect that only ports having
push instructions will have popping returns. */
#ifndef PUSH_ROUNDING
in a register. */
/* #define REG_PARM_STACK_SPACE */
-/* Value is the number of bytes of arguments automatically
- popped when returning from a subroutine call.
- FUNDECL is the declaration node of the function (as a tree),
- FUNTYPE is the data type of the function (as a tree),
- or for a library call it is an identifier node for the subroutine name.
- SIZE is the number of bytes of arguments passed on the stack. */
-
-#define RETURN_POPS_ARGS(FUNDECL,FUNTYPE,SIZE) 0
-
/* Define how to find the value returned by a function.
VALTYPE is the data type of the value (as a tree).
If the precise function being called is known, FUNC is its FUNCTION_DECL;
increase the stack frame size by this amount. */
#define ACCUMULATE_OUTGOING_ARGS 1
-/* Value is the number of bytes of arguments automatically
- popped when returning from a subroutine call.
- FUNDECL is the declaration node of the function (as a tree),
- FUNTYPE is the data type of the function (as a tree),
- or for a library call it is an identifier node for the subroutine name.
- SIZE is the number of bytes of arguments passed on the stack. */
-#define RETURN_POPS_ARGS(DECL, FUNTYPE, SIZE) 0
-
/* Define a data type for recording info about an argument list
during the scan of that argument list. This data type should
hold all necessary information about the function itself
/* Offset of first parameter from the argument pointer register value. */
#define FIRST_PARM_OFFSET(FNDECL) (TARGET_ARM ? 4 : 0)
-/* Value is the number of byte of arguments automatically
- popped when returning from a subroutine call.
- FUNDECL is the declaration node of the function (as a tree),
- FUNTYPE is the data type of the function (as a tree),
- or for a library call it is an identifier node for the subroutine name.
- SIZE is the number of bytes of arguments passed on the stack.
-
- On the ARM, the caller does not pop any of its arguments that were passed
- on the stack. */
-#define RETURN_POPS_ARGS(FUNDECL, FUNTYPE, SIZE) 0
-
/* Define how to find the value returned by a library function
assuming the value has mode MODE. */
#define LIBCALL_VALUE(MODE) \
for POST_DEC targets (PR27386). */
/*#define PUSH_ROUNDING(NPUSHED) (NPUSHED)*/
-#define RETURN_POPS_ARGS(FUNDECL, FUNTYPE, STACK_SIZE) 0
-
#define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) (function_arg (&(CUM), MODE, TYPE, NAMED))
typedef struct avr_args {
#define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED) \
(function_arg_advance (&CUM, MODE, TYPE, NAMED))
-#define RETURN_POPS_ARGS(FDECL, FUNTYPE, STKSIZE) 0
-
/* Define how to find the value returned by a function.
VALTYPE is the data type of the value (as a tree).
If the precise function being called is known, FUNC is its FUNCTION_DECL;
#define ACCUMULATE_OUTGOING_ARGS 1
-#define RETURN_POPS_ARGS(FUNDECL, FUNTYPE, STACKSIZE) 0
-
/* Node: Register Arguments */
#define PUSH_ROUNDING(BYTES) (((BYTES) + 3) & ~3)
-#define RETURN_POPS_ARGS(FNDECL, FUNTYPE, SIZE) 0
-
#define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) \
((rtx) crx_function_arg(&(CUM), (MODE), (TYPE), (NAMED)))
proper. */
#define ACCUMULATE_OUTGOING_ARGS 1
-/* A C expression that should indicate the number of bytes of its own arguments
- that a function pops on returning, or 0 if the function pops no arguments
- and the caller must therefore pop them all after the function returns.
-
- FUNDECL is a C variable whose value is a tree node that describes the
- function in question. Normally it is a node of type `FUNCTION_DECL' that
- describes the declaration of the function. From this it is possible to
- obtain the DECL_ATTRIBUTES of the function.
-
- FUNTYPE is a C variable whose value is a tree node that describes the
- function in question. Normally it is a node of type `FUNCTION_TYPE' that
- describes the data type of the function. From this it is possible to obtain
- the data types of the value and arguments (if known).
-
- When a call to a library function is being considered, FUNTYPE will contain
- an identifier node for the library function. Thus, if you need to
- distinguish among various library functions, you can do so by their names.
- Note that "library function" in this context means a function used to
- perform arithmetic, whose name is known specially in the compiler and was
- not mentioned in the C code being compiled.
-
- STACK-SIZE is the number of bytes of arguments passed on the stack. If a
- variable number of bytes is passed, it is zero, and argument popping will
- always be the responsibility of the calling function.
-
- On the VAX, all functions always pop their arguments, so the definition of
- this macro is STACK-SIZE. On the 68000, using the standard calling
- convention, no functions pop their arguments, so the value of the macro is
- always 0 in this case. But an alternative calling convention is available
- in which functions that take a fixed number of arguments pop them but other
- functions (such as `printf') pop nothing (the caller pops all). When this
- convention is in use, FUNTYPE is examined to determine whether a function
- takes a fixed number of arguments. */
-#define RETURN_POPS_ARGS(FUNDECL, FUNTYPE, STACK_SIZE) 0
-
/*}}}*/ \f
/*{{{ Function Arguments in Registers. */
proper. */
#define ACCUMULATE_OUTGOING_ARGS 1
-/* A C expression that should indicate the number of bytes of its own arguments
- that a function pops on returning, or 0 if the function pops no arguments
- and the caller must therefore pop them all after the function returns.
-
- FUNDECL is a C variable whose value is a tree node that describes the
- function in question. Normally it is a node of type `FUNCTION_DECL' that
- describes the declaration of the function. From this it is possible to
- obtain the DECL_ATTRIBUTES of the function.
-
- FUNTYPE is a C variable whose value is a tree node that describes the
- function in question. Normally it is a node of type `FUNCTION_TYPE' that
- describes the data type of the function. From this it is possible to obtain
- the data types of the value and arguments (if known).
-
- When a call to a library function is being considered, FUNTYPE will contain
- an identifier node for the library function. Thus, if you need to
- distinguish among various library functions, you can do so by their names.
- Note that "library function" in this context means a function used to
- perform arithmetic, whose name is known specially in the compiler and was
- not mentioned in the C code being compiled.
-
- STACK-SIZE is the number of bytes of arguments passed on the stack. If a
- variable number of bytes is passed, it is zero, and argument popping will
- always be the responsibility of the calling function.
-
- On the VAX, all functions always pop their arguments, so the definition of
- this macro is STACK-SIZE. On the 68000, using the standard calling
- convention, no functions pop their arguments, so the value of the macro is
- always 0 in this case. But an alternative calling convention is available
- in which functions that take a fixed number of arguments pop them but other
- functions (such as `printf') pop nothing (the caller pops all). When this
- convention is in use, FUNTYPE is examined to determine whether a function
- takes a fixed number of arguments. */
-#define RETURN_POPS_ARGS(FUNDECL, FUNTYPE, STACK_SIZE) 0
-
\f
/* The number of register assigned to holding function arguments. */
#define FIRST_PARM_OFFSET(FNDECL) 0
-/* Value is the number of bytes of arguments automatically
- popped when returning from a subroutine call.
- FUNDECL is the declaration node of the function (as a tree),
- FUNTYPE is the data type of the function (as a tree),
- or for a library call it is an identifier node for the subroutine name.
- SIZE is the number of bytes of arguments passed on the stack.
-
- On the H8 the return does not pop anything. */
-
-#define RETURN_POPS_ARGS(FUNDECL, FUNTYPE, SIZE) 0
-
/* Definitions for register eliminations.
This is an array of structures. Each structure initializes one pair
#endif /* RTX_CODE */
#ifdef TREE_CODE
-extern int ix86_return_pops_args (tree, tree, int);
-
extern int ix86_data_alignment (tree, int);
extern unsigned int ix86_local_alignment (tree, enum machine_mode,
unsigned int);
The attribute stdcall is equivalent to RTD on a per module basis. */
-int
+static int
ix86_return_pops_args (tree fundecl, tree funtype, int size)
{
int rtd;
#define TARGET_STATIC_CHAIN ix86_static_chain
#undef TARGET_TRAMPOLINE_INIT
#define TARGET_TRAMPOLINE_INIT ix86_trampoline_init
+#undef TARGET_RETURN_POPS_ARGS
+#define TARGET_RETURN_POPS_ARGS ix86_return_pops_args
#undef TARGET_GIMPLIFY_VA_ARG_EXPR
#define TARGET_GIMPLIFY_VA_ARG_EXPR ix86_gimplify_va_arg
#define OUTGOING_REG_PARM_STACK_SPACE(FNTYPE) \
(ix86_function_type_abi (FNTYPE) == MS_ABI)
-/* Value is the number of bytes of arguments automatically
- popped when returning from a subroutine call.
- FUNDECL is the declaration node of the function (as a tree),
- FUNTYPE is the data type of the function (as a tree),
- or for a library call it is an identifier node for the subroutine name.
- SIZE is the number of bytes of arguments passed on the stack.
-
- On the 80386, the RTD insn may be used to pop them if the number
- of args is fixed, but if the number is variable then the caller
- must pop them all. RTD can't be used for library calls now
- because the library is compiled with the Unix compiler.
- Use of RTD is a selectable option, since it is incompatible with
- standard Unix calling sequences. If the option is not selected,
- the caller must always pop the args.
-
- The attribute stdcall is equivalent to RTD on a per module basis. */
-
-#define RETURN_POPS_ARGS(FUNDECL, FUNTYPE, SIZE) \
- ix86_return_pops_args ((FUNDECL), (FUNTYPE), (SIZE))
-
/* Define how to find the value returned by a library function
assuming the value has mode MODE. */
#define ACCUMULATE_OUTGOING_ARGS 1
-/* A C expression that should indicate the number of bytes of its own arguments
- that a function pops on returning, or 0 if the function pops no arguments
- and the caller must therefore pop them all after the function returns. */
-
-#define RETURN_POPS_ARGS(FUNDECL, FUNTYPE, STACK_SIZE) 0
-
\f
/* Function Arguments in Registers */
#define OUTGOING_REG_PARM_STACK_SPACE(FNTYPE) 1
-#define RETURN_POPS_ARGS(FUNDECL,FUNTYPE,SIZE) 0
-
\f
/* Function Arguments in Registers. */
#define ACCUMULATE_OUTGOING_ARGS 1
-#define RETURN_POPS_ARGS(DECL, FUNTYPE, SIZE) 0
-
/*--------------------------------*/
/* Passing Arguments in Registers */
/*--------------------------------*/
#define PUSH_ARGS 1
#define PUSH_ROUNDING(N) m32c_push_rounding (N)
-#define RETURN_POPS_ARGS(D,T,S) 0
#define CALL_POPS_ARGS(C) 0
/* Passing Arguments in Registers */
increase the stack frame size by this amount. */
#define ACCUMULATE_OUTGOING_ARGS 1
-/* Value is the number of bytes of arguments automatically
- popped when returning from a subroutine call.
- FUNDECL is the declaration node of the function (as a tree),
- FUNTYPE is the data type of the function (as a tree),
- or for a library call it is an identifier node for the subroutine name.
- SIZE is the number of bytes of arguments passed on the stack. */
-#define RETURN_POPS_ARGS(DECL, FUNTYPE, SIZE) 0
-
/* Define a data type for recording info about an argument list
during the scan of that argument list. This data type should
hold all necessary information about the function itself
stack pointer really advances by. No rounding or alignment needed
for MC6811. */
#define PUSH_ROUNDING(BYTES) (BYTES)
-
-/* Value is 1 if returning from a function call automatically pops the
- arguments described by the number-of-args field in the call. FUNTYPE is
- the data type of the function (as a tree), or for a library call it is
- an identifier node for the subroutine name.
-
- The standard MC6811 call, with arg count word, includes popping the
- args as part of the call template. */
-#define RETURN_POPS_ARGS(FUNDECL,FUNTYPE,SIZE) 0
\f
/* Passing Arguments in Registers. */
#endif
static void m68k_output_dwarf_dtprel (FILE *, int, rtx) ATTRIBUTE_UNUSED;
static void m68k_trampoline_init (rtx, tree, rtx);
+static int m68k_return_pops_args (tree, tree, int);
static rtx m68k_delegitimize_address (rtx);
\f
#undef TARGET_TRAMPOLINE_INIT
#define TARGET_TRAMPOLINE_INIT m68k_trampoline_init
+#undef TARGET_RETURN_POPS_ARGS
+#define TARGET_RETURN_POPS_ARGS m68k_return_pops_args
+
#undef TARGET_DELEGITIMIZE_ADDRESS
#define TARGET_DELEGITIMIZE_ADDRESS m68k_delegitimize_address
FINALIZE_TRAMPOLINE (XEXP (m_tramp, 0));
}
+/* On the 68000, the RTS insn cannot pop anything.
+ On the 68010, the RTD insn may be used to pop them if the number
+ of args is fixed, but if the number is variable then the caller
+ must pop them all. RTD can't be used for library calls now
+ because the library is compiled with the Unix compiler.
+ Use of RTD is a selectable option, since it is incompatible with
+ standard Unix calling sequences. If the option is not selected,
+ the caller must always pop the args. */
+
+static int
+m68k_return_pops_args (tree fundecl, tree funtype, int size)
+{
+ return ((TARGET_RTD
+ && (!fundecl
+ || TREE_CODE (fundecl) != IDENTIFIER_NODE)
+ && (TYPE_ARG_TYPES (funtype) == 0
+ || (TREE_VALUE (tree_last (TYPE_ARG_TYPES (funtype)))
+ == void_type_node)))
+ ? size : 0);
+}
+
#include "gt-m68k.h"
#define FIRST_PARM_OFFSET(FNDECL) 8
-/* On the 68000, the RTS insn cannot pop anything.
- On the 68010, the RTD insn may be used to pop them if the number
- of args is fixed, but if the number is variable then the caller
- must pop them all. RTD can't be used for library calls now
- because the library is compiled with the Unix compiler.
- Use of RTD is a selectable option, since it is incompatible with
- standard Unix calling sequences. If the option is not selected,
- the caller must always pop the args. */
-#define RETURN_POPS_ARGS(FUNDECL,FUNTYPE,SIZE) \
- ((TARGET_RTD && (!(FUNDECL) || TREE_CODE (FUNDECL) != IDENTIFIER_NODE) \
- && (TYPE_ARG_TYPES (FUNTYPE) == 0 \
- || (TREE_VALUE (tree_last (TYPE_ARG_TYPES (FUNTYPE))) \
- == void_type_node))) \
- ? (SIZE) : 0)
-
/* On the m68k the return value defaults to D0. */
#define FUNCTION_VALUE(VALTYPE, FUNC) \
gen_rtx_REG (TYPE_MODE (VALTYPE), D0_REG)
/* Offset of first parameter from the argument pointer register value. */
#define FIRST_PARM_OFFSET(FNDECL) 0
-/* Value is the number of byte of arguments automatically
- popped when returning from a subroutine call.
- FUNTYPE is the data type of the function (as a tree),
- or for a library call it is an identifier node for the subroutine name.
- SIZE is the number of bytes of arguments passed on the stack.
-
- On the MCore, the callee does not pop any of its arguments that were passed
- on the stack. */
-#define RETURN_POPS_ARGS(FUNDECL,FUNTYPE,SIZE) 0
-
/* Define how to find the value returned by a function.
VALTYPE is the data type of the value (as a tree).
If the precise function being called is known, FUNC is its FUNCTION_DECL;
#define ACCUMULATE_OUTGOING_ARGS 1
-#define RETURN_POPS_ARGS(FUNDECL, FUNTYPE, STACK_SIZE) 0
-
\f
/* The ABI is thus: Arguments are in $1, $2, $3, $4, stack. Arguments
#define STACK_BOUNDARY (TARGET_NEWABI ? 128 : 64)
\f
-#define RETURN_POPS_ARGS(FUNDECL,FUNTYPE,SIZE) 0
-
/* Symbolic macros for the registers used to return integer and floating
point values. */
#define ACCUMULATE_OUTGOING_ARGS 1
-#define RETURN_POPS_ARGS(FUNDECL, FUNTYPE, STACKSIZE) 0
-
/* Node: Register Arguments */
#define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) \
them whenever possible. */
#define CAN_DEBUG_WITHOUT_FP
-/* Value is the number of bytes of arguments automatically
- popped when returning from a subroutine call.
- FUNDECL is the declaration node of the function (as a tree),
- FUNTYPE is the data type of the function (as a tree),
- or for a library call it is an identifier node for the subroutine name.
- SIZE is the number of bytes of arguments passed on the stack. */
-
-#define RETURN_POPS_ARGS(FUNDECL,FUNTYPE,SIZE) 0
-
/* We use d0/d1 for passing parameters, so allocate 8 bytes of space
for a register flushback area. */
#define REG_PARM_STACK_SPACE(DECL) 8
/* All load operations zero extend. */
#define LOAD_EXTEND_OP(MEM) ZERO_EXTEND
-#define RETURN_POPS_ARGS(FUNDECL, FUNTYPE, STACK_SIZE) 0
-
/* A C expression that is nonzero if X is a legitimate constant for
an immediate operand on the target machine. */
#define LEGITIMATE_CONSTANT_P(X) 1
? (STACK_POINTER_OFFSET) \
: ((STACK_POINTER_OFFSET) - crtl->outgoing_args_size))
-/* Value is 1 if returning from a function call automatically
- pops the arguments described by the number-of-args field in the call.
- FUNDECL is the declaration node of the function (as a tree),
- FUNTYPE is the data type of the function (as a tree),
- or for a library call it is an identifier node for the subroutine name. */
-
-#define RETURN_POPS_ARGS(FUNDECL,FUNTYPE,SIZE) 0
-
/* Define how to find the value returned by a library function
assuming the value has mode MODE. */
*/
#define FIRST_PARM_OFFSET(FNDECL) 4
-/* Value is 1 if returning from a function call automatically
- pops the arguments described by the number-of-args field in the call.
- FUNDECL is the declaration node of the function (as a tree),
- FUNTYPE is the data type of the function (as a tree),
- or for a library call it is an identifier node for the subroutine name. */
-
-#define RETURN_POPS_ARGS(FUNDECL,FUNTYPE,SIZE) 0
-
/* Define how to find the value returned by a function.
VALTYPE is the data type of the value (as a tree).
If the precise function being called is known, FUNC is its FUNCTION_DECL;
#define PUSH_ARGS 0
-/* Functions don't pop their args. */
-#define RETURN_POPS_ARGS(FNDECL, FNTYPE, STACK) 0
-
/* Passing Arguments in Registers */
/* Store the offset of the next argument. */
found in the variable crtl->outgoing_args_size. */
#define ACCUMULATE_OUTGOING_ARGS 1
-/* Value is the number of bytes of arguments automatically
- popped when returning from a subroutine call.
- FUNDECL is the declaration node of the function (as a tree),
- FUNTYPE is the data type of the function (as a tree),
- or for a library call it is an identifier node for the subroutine name.
- SIZE is the number of bytes of arguments passed on the stack. */
-
-#define RETURN_POPS_ARGS(FUNDECL,FUNTYPE,SIZE) 0
-
/* Define how to find the value returned by a library function
assuming the value has mode MODE. */
#define MOVE_MAX 4
#define STARTING_FRAME_OFFSET 0
-#define RETURN_POPS_ARGS(FUNDECL, FUNTYPE, SIZE) 0
#define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1
#define LEGITIMATE_CONSTANT_P(X) rx_is_legitimate_constant (X)
/* We need current_function_outgoing_args to be valid. */
#define ACCUMULATE_OUTGOING_ARGS 1
-/* Return doesn't modify the stack. */
-#define RETURN_POPS_ARGS(FUNDECL, FUNTYPE, SIZE) 0
-
/* Register arguments. */
`crtl->outgoing_args_size'. */
#define OUTGOING_REG_PARM_STACK_SPACE(FNTYPE) 1
-#define RETURN_POPS_ARGS(FUNDECL, FUNTYPE, STACK_SIZE) 0
-
/* Passing Arguments in Registers */
/* Determine where to put an argument to a function.
Value is zero to push the argument on the stack,
/* Offset of first parameter from the argument pointer register value. */
#define FIRST_PARM_OFFSET(FNDECL) 0
-/* Value is the number of byte of arguments automatically
- popped when returning from a subroutine call.
- FUNDECL is the declaration node of the function (as a tree),
- FUNTYPE is the data type of the function (as a tree),
- or for a library call it is an identifier node for the subroutine name.
- SIZE is the number of bytes of arguments passed on the stack.
-
- On the SH, the caller does not pop any of its arguments that were passed
- on the stack. */
-#define RETURN_POPS_ARGS(FUNDECL,FUNTYPE,SIZE) 0
-
/* Value is the number of bytes of arguments automatically popped when
calling a subroutine.
CUM is the accumulated argument list.
the function! */
#define ACCUMULATE_OUTGOING_ARGS 1
-/* Value is the number of bytes of arguments automatically
- popped when returning from a subroutine call.
- FUNDECL is the declaration node of the function (as a tree),
- FUNTYPE is the data type of the function (as a tree),
- or for a library call it is an identifier node for the subroutine name.
- SIZE is the number of bytes of arguments passed on the stack. */
-
-#define RETURN_POPS_ARGS(FUNDECL,FUNTYPE,SIZE) 0
-
/* Define this macro if the target machine has "register windows". This
C expression returns the register number as seen by the called function
corresponding to register number OUT as seen by the calling function.
#define OUTGOING_REG_PARM_STACK_SPACE(FNTYPE) 1
-#define RETURN_POPS_ARGS(FUNDECL,FUNTYPE,SIZE) (0)
-
\f
/* Register Arguments */
#define PUSH_ROUNDING(BYTES) (((BYTES) + 1) & ~1)
-#define RETURN_POPS_ARGS(FUNDECL, FUNTYPE, STACK_SIZE) 0
-
\f
/* Function Arguments in Registers. */
/* Keep the stack pointer constant throughout the function. */
#define ACCUMULATE_OUTGOING_ARGS 1
-/* Value is the number of bytes of arguments automatically
- popped when returning from a subroutine call.
- FUNDECL is the declaration node of the function (as a tree),
- FUNTYPE is the data type of the function (as a tree),
- or for a library call it is an identifier node for the subroutine name.
- SIZE is the number of bytes of arguments passed on the stack. */
-
-#define RETURN_POPS_ARGS(FUNDECL,FUNTYPE,SIZE) 0
-
#define RETURN_ADDR_RTX(COUNT, FP) v850_return_addr (COUNT)
\f
/* Define a data type for recording info about an argument list
static rtx vax_builtin_setjmp_frame_value (void);
static void vax_asm_trampoline_template (FILE *);
static void vax_trampoline_init (rtx, tree, rtx);
+static int vax_return_pops_args (tree, tree, int);
\f
/* Initialize the GCC target structure. */
#undef TARGET_ASM_ALIGNED_HI_OP
#define TARGET_ASM_TRAMPOLINE_TEMPLATE vax_asm_trampoline_template
#undef TARGET_TRAMPOLINE_INIT
#define TARGET_TRAMPOLINE_INIT vax_trampoline_init
+#undef TARGET_RETURN_POPS_ARGS
+#define TARGET_RETURN_POPS_ARGS vax_return_pops_args
struct gcc_target targetm = TARGET_INITIALIZER;
\f
emit_insn (gen_sync_istream ());
}
+/* Value is the number of bytes of arguments automatically
+ popped when returning from a subroutine call.
+ FUNDECL is the declaration node of the function (as a tree),
+ FUNTYPE is the data type of the function (as a tree),
+ or for a library call it is an identifier node for the subroutine name.
+ SIZE is the number of bytes of arguments passed on the stack.
+
+ On the VAX, the RET insn pops a maximum of 255 args for any function. */
+
+static int
+vax_return_pops_args (tree fundecl ATTRIBUTE_UNUSED,
+ tree funtype ATTRIBUTE_UNUSED, int size)
+{
+ return size > 255 * 4 ? 0 : size;
+}
/* Offset of first parameter from the argument pointer register value. */
#define FIRST_PARM_OFFSET(FNDECL) 4
-/* Value is the number of bytes of arguments automatically
- popped when returning from a subroutine call.
- FUNDECL is the declaration node of the function (as a tree),
- FUNTYPE is the data type of the function (as a tree),
- or for a library call it is an identifier node for the subroutine name.
- SIZE is the number of bytes of arguments passed on the stack.
-
- On the VAX, the RET insn pops a maximum of 255 args for any function. */
-
-#define RETURN_POPS_ARGS(FUNDECL,FUNTYPE,SIZE) \
- ((SIZE) > 255 * 4 ? 0 : (SIZE))
-
/* Define how to find the value returned by a function.
VALTYPE is the data type of the value (as a tree).
If the precise function being called is known, FUNC is its FUNCTION_DECL;
128-bit datatypes defined in TIE (e.g., for Vectra). */
#define STACK_BOUNDARY 128
-/* Functions do not pop arguments off the stack. */
-#define RETURN_POPS_ARGS(FUNDECL, FUNTYPE, SIZE) 0
-
/* Use a fixed register window size of 8. */
#define WINDOW_SIZE 8
stack in its natural location.
@end defmac
-@defmac RETURN_POPS_ARGS (@var{fundecl}, @var{funtype}, @var{stack-size})
-A C expression that should indicate the number of bytes of its own
-arguments that a function pops on returning, or 0 if the
-function pops no arguments and the caller must therefore pop them all
-after the function returns.
+@deftypefn {Target Hook} TARGET_RETURN_POPS_ARGS (@var{fundecl}, @var{funtype}, @var{stack-size})
+This target hook returns the number of bytes of its own arguments that
+a function pops on returning, or 0 if the function pops no arguments
+and the caller must therefore pop them all after the function returns.
@var{fundecl} is a C variable whose value is a tree node that describes
the function in question. Normally it is a node of type
nothing (the caller pops all). When this convention is in use,
@var{funtype} is examined to determine whether a function takes a fixed
number of arguments.
-@end defmac
+@end deftypefn
@defmac CALL_POPS_ARGS (@var{cum})
A C expression that should indicate the number of bytes a call sequence
/* See how many bytes, if any, of its args a function should try to pop
on return. */
- crtl->args.pops_args = RETURN_POPS_ARGS (fndecl, TREE_TYPE (fndecl),
- crtl->args.size);
+ crtl->args.pops_args = targetm.calls.return_pops_args (fndecl,
+ TREE_TYPE (fndecl),
+ crtl->args.size);
/* For stdarg.h function, save info about
regs and stack space used by the named args. */
/* There are a couple of fixed registers that we know are safe to
exclude from being clobbered by calls:
- The frame pointer is always preserved across calls. The arg pointer
- is if it is fixed. The stack pointer usually is, unless
- RETURN_POPS_ARGS, in which case an explicit CLOBBER will be present.
- If we are generating PIC code, the PIC offset table register is
- preserved across calls, though the target can override that. */
+ The frame pointer is always preserved across calls. The arg
+ pointer is if it is fixed. The stack pointer usually is,
+ unless TARGET_RETURN_POPS_ARGS, in which case an explicit
+ CLOBBER will be present. If we are generating PIC code, the
+ PIC offset table register is preserved across calls, though the
+ target can override that. */
if (i == STACK_POINTER_REGNUM)
;
FUNCTION_ARG_PARTIAL_NREGS ASM_OUTPUT_DWARF_DTPREL \
ALLOCATE_INITIAL_VALUE LEGITIMIZE_ADDRESS FRAME_POINTER_REQUIRED \
CAN_ELIMINATE TRAMPOLINE_TEMPLATE INITIALIZE_TRAMPOLINE \
- TRAMPOLINE_ADJUST_ADDRESS STATIC_CHAIN STATIC_CHAIN_INCOMING
+ TRAMPOLINE_ADJUST_ADDRESS STATIC_CHAIN STATIC_CHAIN_INCOMING \
+ RETURN_POPS_ARGS
/* Other obsolete target macros, or macros that used to be in target
headers and were not used, and may be obsolete or may never have
#define TARGET_STATIC_CHAIN default_static_chain
#define TARGET_TRAMPOLINE_INIT default_trampoline_init
#define TARGET_TRAMPOLINE_ADJUST_ADDRESS NULL
+#define TARGET_RETURN_POPS_ARGS default_return_pops_args
#define TARGET_CALLS { \
TARGET_PROMOTE_FUNCTION_MODE, \
TARGET_ALLOCATE_STACK_SLOTS_FOR_ARGS, \
TARGET_STATIC_CHAIN, \
TARGET_TRAMPOLINE_INIT, \
- TARGET_TRAMPOLINE_ADJUST_ADDRESS \
+ TARGET_TRAMPOLINE_ADJUST_ADDRESS, \
+ TARGET_RETURN_POPS_ARGS \
}
#ifndef TARGET_UNWIND_TABLES_DEFAULT
/* Adjust the address of the trampoline in a target-specific way. */
rtx (*trampoline_adjust_address) (rtx addr);
+
+ /* Return the number of bytes of its own arguments that a function
+ pops on returning, or 0 if the function pops no arguments and the
+ caller must therefore pop them all after the function returns. */
+ int (*return_pops_args) (tree fundecl, tree funtype, int size);
} calls;
/* Return the diagnostic message string if conversion from FROMTYPE
sorry ("nested function trampolines not supported on this target");
}
+int
+default_return_pops_args (tree fundecl ATTRIBUTE_UNUSED,
+ tree funtype ATTRIBUTE_UNUSED,
+ int size ATTRIBUTE_UNUSED)
+{
+ return 0;
+}
+
enum reg_class
default_branch_target_register_class (void)
{
extern rtx default_internal_arg_pointer (void);
extern rtx default_static_chain (const_tree, bool);
extern void default_trampoline_init (rtx, tree, rtx);
+extern int default_return_pops_args (tree, tree, int);
extern enum reg_class default_branch_target_register_class (void);
#ifdef IRA_COVER_CLASSES
extern const enum reg_class *default_ira_cover_classes (void);
projects / platform / upstream / linaro-gcc.git / commitdiff