OpenE2K
/
gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

reginfo.c (init_reg_sets_1): Adjust comments. 

* 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.

From-SVN: r161528
This commit is contained in:
Nathan Froyd 2010-06-29 12:18:36 +00:00 committed by Nathan Froyd
parent ea184343e7
commit 079e7538c0
53 changed files with 159 additions and 319 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

65
gcc/ChangeLog
View File

@ -1,3 +1,68 @@
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

25
gcc/calls.c
View File

@ -208,13 +208,15 @@ prepare_call_address (tree fndecl, rtx funexp, rtx static_chain_value,
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
@ -256,7 +258,8 @@ emit_call_1 (rtx funexp, tree fntree ATTRIBUTE_UNUSED, tree fndecl ATTRIBUTE_UNU
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);
@ -2323,10 +2326,10 @@ expand_call (tree exp, rtx target, int ignore)
- 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;

2
gcc/combine-stack-adj.c
View File

@ -555,7 +555,7 @@ rest_of_handle_stack_adjustments (void)
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

9
gcc/config/alpha/alpha.h
View File

@ -703,15 +703,6 @@ extern int alpha_memory_latency;
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;

8
gcc/config/arc/arc.h
View File

@ -530,14 +530,6 @@ extern enum reg_class arc_regno_reg_class[FIRST_PSEUDO_REGISTER];
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

11
gcc/config/arm/arm.h
View File

@ -1498,17 +1498,6 @@ do { \
/* 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) \

2
gcc/config/avr/avr.h
View File

@ -376,8 +376,6 @@ enum reg_class {
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 {

2
gcc/config/bfin/bfin.h
View File

@ -871,8 +871,6 @@ typedef struct {
#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;

2
gcc/config/cris/cris.h
View File

@ -859,8 +859,6 @@ enum reg_class
#define ACCUMULATE_OUTGOING_ARGS 1
#define RETURN_POPS_ARGS(FUNDECL, FUNTYPE, STACKSIZE) 0
/* Node: Register Arguments */

2
gcc/config/crx/crx.h
View File

@ -313,8 +313,6 @@ enum reg_class
#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)))

35
gcc/config/fr30/fr30.h
View File

@ -568,41 +568,6 @@ enum reg_class
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
/*}}}*/
/*{{{ Function Arguments in Registers. */

35
gcc/config/frv/frv.h
View File

@ -1614,41 +1614,6 @@ typedef struct frv_stack {
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
/* The number of register assigned to holding function arguments. */

11
gcc/config/h8300/h8300.h
View File

@ -536,17 +536,6 @@ enum reg_class {
#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

2
gcc/config/i386/i386-protos.h
View File

@ -188,8 +188,6 @@ extern void function_arg_advance (CUMULATIVE_ARGS *, enum machine_mode,
#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);

4
gcc/config/i386/i386.c
View File

@ -4865,7 +4865,7 @@ ix86_eax_live_at_start_p (void)
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;
@ -30888,6 +30888,8 @@ ix86_enum_va_list (int idx, const char **pname, tree *ptree)
#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

20
gcc/config/i386/i386.h
View File

@ -1542,26 +1542,6 @@ enum reg_class
#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. */

6
gcc/config/ia64/ia64.h
View File

@ -1042,12 +1042,6 @@ enum reg_class
#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
/* Function Arguments in Registers */

2
gcc/config/iq2000/iq2000.h
View File

@ -365,8 +365,6 @@ enum reg_class
#define OUTGOING_REG_PARM_STACK_SPACE(FNTYPE) 1
#define RETURN_POPS_ARGS(FUNDECL,FUNTYPE,SIZE) 0
/* Function Arguments in Registers. */

2
gcc/config/lm32/lm32.h
View File

@ -273,8 +273,6 @@ enum reg_class
#define ACCUMULATE_OUTGOING_ARGS 1
#define RETURN_POPS_ARGS(DECL, FUNTYPE, SIZE) 0
/*--------------------------------*/
/* Passing Arguments in Registers */
/*--------------------------------*/

1
gcc/config/m32c/m32c.h
View File

@ -503,7 +503,6 @@ enum reg_class
#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 */

8
gcc/config/m32r/m32r.h
View File

@ -823,14 +823,6 @@ extern enum reg_class m32r_regno_reg_class[FIRST_PSEUDO_REGISTER];
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

9
gcc/config/m68hc11/m68hc11.h
View File

@ -896,15 +896,6 @@ extern enum reg_class m68hc11_tmp_regs_class;
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
/* Passing Arguments in Registers. */

25
gcc/config/m68k/m68k.c
View File

@ -153,6 +153,7 @@ static bool m68k_return_in_memory (const_tree, const_tree);
#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);
@ -271,6 +272,9 @@ const char *m68k_library_id_string = "_current_shared_library_a5_offset_";
#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
@ -6520,4 +6524,25 @@ m68k_trampoline_init (rtx m_tramp, tree fndecl, rtx chain_value)
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"

15
gcc/config/m68k/m68k.h
View File

@ -534,21 +534,6 @@ extern enum reg_class regno_reg_class[];
#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)

10
gcc/config/mcore/mcore.h
View File

@ -540,16 +540,6 @@ extern const enum reg_class reg_class_from_letter[];
/* 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;

2
gcc/config/mep/mep.h
View File

@ -503,8 +503,6 @@ extern unsigned int mep_selected_isa;
#define ACCUMULATE_OUTGOING_ARGS 1
#define RETURN_POPS_ARGS(FUNDECL, FUNTYPE, STACK_SIZE) 0
/* The ABI is thus: Arguments are in $1, $2, $3, $4, stack. Arguments

2
gcc/config/mips/mips.h
View File

@ -2162,8 +2162,6 @@ enum reg_class
#define STACK_BOUNDARY (TARGET_NEWABI ? 128 : 64)
#define RETURN_POPS_ARGS(FUNDECL,FUNTYPE,SIZE) 0
/* Symbolic macros for the registers used to return integer and floating
point values. */

2
gcc/config/mmix/mmix.h
View File

@ -586,8 +586,6 @@ enum reg_class
#define ACCUMULATE_OUTGOING_ARGS 1
#define RETURN_POPS_ARGS(FUNDECL, FUNTYPE, STACKSIZE) 0
/* Node: Register Arguments */
#define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) \

9
gcc/config/mn10300/mn10300.h
View File

@ -492,15 +492,6 @@ enum reg_class {
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

2
gcc/config/moxie/moxie.h
View File

@ -453,8 +453,6 @@ enum reg_class
/* 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

8
gcc/config/pa/pa.h
View File

@ -553,14 +553,6 @@ extern struct rtx_def *hppa_pic_save_rtx (void);
? (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. */

8
gcc/config/pdp11/pdp11.h
View File

@ -435,14 +435,6 @@ extern int current_first_parm_offset;
*/
#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;

3
gcc/config/picochip/picochip.h
View File

@ -406,9 +406,6 @@ extern const enum reg_class picochip_regno_reg_class[FIRST_PSEUDO_REGISTER];
#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. */

9
gcc/config/rs6000/rs6000.h
View File

@ -1578,15 +1578,6 @@ extern enum rs6000_abi rs6000_current_abi; /* available for use by subtarget */
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. */

1
gcc/config/rx/rx.h
View File

@ -154,7 +154,6 @@ extern enum rx_cpu_types rx_cpu_type;
#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)

3
gcc/config/s390/s390.h
View File

@ -673,9 +673,6 @@ extern const enum reg_class regclass_map[FIRST_PSEUDO_REGISTER];
/* 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. */

2
gcc/config/score/score.h
View File

@ -581,8 +581,6 @@ extern enum reg_class score_char_to_class[256];
`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,

11
gcc/config/sh/sh.h
View File

@ -1423,17 +1423,6 @@ extern enum reg_class regno_reg_class[FIRST_PSEUDO_REGISTER];
/* 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.

9
gcc/config/sparc/sparc.h
View File

@ -1387,15 +1387,6 @@ extern char leaf_reg_remap[];
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.

2
gcc/config/spu/spu.h
View File

@ -334,8 +334,6 @@ targetm.resolve_overloaded_builtin = spu_resolve_overloaded_builtin; \
#define OUTGOING_REG_PARM_STACK_SPACE(FNTYPE) 1
#define RETURN_POPS_ARGS(FUNDECL,FUNTYPE,SIZE) (0)
/* Register Arguments */

2
gcc/config/stormy16/stormy16.h
View File

@ -328,8 +328,6 @@ enum reg_class
#define PUSH_ROUNDING(BYTES) (((BYTES) + 1) & ~1)
#define RETURN_POPS_ARGS(FUNDECL, FUNTYPE, STACK_SIZE) 0
/* Function Arguments in Registers. */

9
gcc/config/v850/v850.h
View File

@ -556,15 +556,6 @@ enum reg_class
/* 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)
/* Define a data type for recording info about an argument list

18
gcc/config/vax/vax.c
View File

@ -58,6 +58,7 @@ static rtx vax_struct_value_rtx (tree, int);
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);
/* Initialize the GCC target structure. */
#undef TARGET_ASM_ALIGNED_HI_OP
@ -106,6 +107,8 @@ static void vax_trampoline_init (rtx, tree, rtx);
#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;
@ -2068,3 +2071,18 @@ vax_trampoline_init (rtx m_tramp, tree fndecl, rtx cxt)
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;
}

12
gcc/config/vax/vax.h
View File

@ -305,18 +305,6 @@ enum reg_class { NO_REGS, ALL_REGS, LIM_REG_CLASSES };
/* 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;

3
gcc/config/xtensa/xtensa.h
View File

@ -547,9 +547,6 @@ extern const enum reg_class xtensa_regno_to_class[FIRST_PSEUDO_REGISTER];
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

11
gcc/doc/tm.texi
View File

@ -3928,11 +3928,10 @@ suppresses this behavior and causes the parameter to be passed on the
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
@ -3965,7 +3964,7 @@ arguments pop them but other functions (such as @code{printf}) pop
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

5
gcc/function.c
View File

@ -3369,8 +3369,9 @@ assign_parms (tree fndecl)
/* 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. */

11
gcc/reginfo.c
View File

@ -530,11 +530,12 @@ init_reg_sets_1 (void)
/* 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)
;

3
gcc/system.h
View File

@ -714,7 +714,8 @@ extern void fancy_abort (const char *, int, const char *) ATTRIBUTE_NORETURN;
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

4
gcc/target-def.h
View File

@ -722,6 +722,7 @@
#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, \
@ -748,7 +749,8 @@
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

5
gcc/target.h
View File

@ -1064,6 +1064,11 @@ struct gcc_target
/* 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

8
gcc/targhooks.c
View File

@ -756,6 +756,14 @@ default_trampoline_init (rtx ARG_UNUSED (m_tramp), tree ARG_UNUSED (t_func),
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)
{

1
gcc/targhooks.h
View File

@ -108,6 +108,7 @@ extern bool default_function_value_regno_p (const unsigned int);
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);