ytshih/ios2024
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
6ad2fa368f630d8bc6b95f898f1afb1d9c8fe8a3
ios2024/usr/local/nachos/info/gcc.info-24

983 lines
46 KiB
Plaintext
Raw Blame History

This file contains invisible Unicode characters
This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
This is Info file gcc.info, produced by Makeinfo version 1.68 from the
input file ../../gcc-2.95.2/gcc/gcc.texi.
INFO-DIR-SECTION Programming
START-INFO-DIR-ENTRY
* gcc: (gcc). The GNU Compiler Collection.
END-INFO-DIR-ENTRY
This file documents the use and the internals of the GNU compiler.
Published by the Free Software Foundation 59 Temple Place - Suite 330
Boston, MA 02111-1307 USA
Copyright (C) 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
1999 Free Software Foundation, Inc.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of
this manual under the conditions for verbatim copying, provided also
that the sections entitled "GNU General Public License" and "Funding
for Free Software" are included exactly as in the original, and
provided that the entire resulting derived work is distributed under
the terms of a permission notice identical to this one.
Permission is granted to copy and distribute translations of this
manual into another language, under the above conditions for modified
versions, except that the sections entitled "GNU General Public
License" and "Funding for Free Software", and this permission notice,
may be included in translations approved by the Free Software Foundation
instead of in the original English.

File: gcc.info, Node: Register Arguments, Next: Scalar Return, Prev: Stack Arguments, Up: Stack and Calling
Passing Arguments in Registers
------------------------------
This section describes the macros which let you control how various
types of arguments are passed in registers or how they are arranged in
the stack.
`FUNCTION_ARG (CUM, MODE, TYPE, NAMED)'
A C expression that controls whether a function argument is passed
in a register, and which register.
The arguments are CUM, which summarizes all the previous
arguments; MODE, the machine mode of the argument; TYPE, the data
type of the argument as a tree node or 0 if that is not known
(which happens for C support library functions); and NAMED, which
is 1 for an ordinary argument and 0 for nameless arguments that
correspond to `...' in the called function's prototype.
The value of the expression is usually either a `reg' RTX for the
hard register in which to pass the argument, or zero to pass the
argument on the stack.
For machines like the Vax and 68000, where normally all arguments
are pushed, zero suffices as a definition.
The value of the expression can also be a `parallel' RTX. This is
used when an argument is passed in multiple locations. The mode
of the of the `parallel' should be the mode of the entire
argument. The `parallel' holds any number of `expr_list' pairs;
each one describes where part of the argument is passed. In each
`expr_list' the first operand must be a `reg' RTX for the hard
register in which to pass this part of the argument, and the mode
of the register RTX indicates how large this part of the argument
is. The second operand of the `expr_list' is a `const_int' which
gives the offset in bytes into the entire argument of where this
part starts. As a special exception the first `expr_list' in the
`parallel' RTX may have a first operand of zero. This indicates
that the bytes starting from the second operand of that
`expr_list' are stored on the stack and not held in a register.
The usual way to make the ANSI library `stdarg.h' work on a machine
where some arguments are usually passed in registers, is to cause
nameless arguments to be passed on the stack instead. This is done
by making `FUNCTION_ARG' return 0 whenever NAMED is 0.
You may use the macro `MUST_PASS_IN_STACK (MODE, TYPE)' in the
definition of this macro to determine if this argument is of a
type that must be passed in the stack. If `REG_PARM_STACK_SPACE'
is not defined and `FUNCTION_ARG' returns non-zero for such an
argument, the compiler will abort. If `REG_PARM_STACK_SPACE' is
defined, the argument will be computed in the stack and then
loaded into a register.
`MUST_PASS_IN_STACK (MODE, TYPE)'
Define as a C expression that evaluates to nonzero if we do not
know how to pass TYPE solely in registers. The file `expr.h'
defines a definition that is usually appropriate, refer to
`expr.h' for additional documentation.
`FUNCTION_INCOMING_ARG (CUM, MODE, TYPE, NAMED)'
Define this macro if the target machine has "register windows", so
that the register in which a function sees an arguments is not
necessarily the same as the one in which the caller passed the
argument.
For such machines, `FUNCTION_ARG' computes the register in which
the caller passes the value, and `FUNCTION_INCOMING_ARG' should be
defined in a similar fashion to tell the function being called
where the arguments will arrive.
If `FUNCTION_INCOMING_ARG' is not defined, `FUNCTION_ARG' serves
both purposes.
`FUNCTION_ARG_PARTIAL_NREGS (CUM, MODE, TYPE, NAMED)'
A C expression for the number of words, at the beginning of an
argument, must be put in registers. The value must be zero for
arguments that are passed entirely in registers or that are
entirely pushed on the stack.
On some machines, certain arguments must be passed partially in
registers and partially in memory. On these machines, typically
the first N words of arguments are passed in registers, and the
rest on the stack. If a multi-word argument (a `double' or a
structure) crosses that boundary, its first few words must be
passed in registers and the rest must be pushed. This macro tells
the compiler when this occurs, and how many of the words should go
in registers.
`FUNCTION_ARG' for these arguments should return the first
register to be used by the caller for this argument; likewise
`FUNCTION_INCOMING_ARG', for the called function.
`FUNCTION_ARG_PASS_BY_REFERENCE (CUM, MODE, TYPE, NAMED)'
A C expression that indicates when an argument must be passed by
reference. If nonzero for an argument, a copy of that argument is
made in memory and a pointer to the argument is passed instead of
the argument itself. The pointer is passed in whatever way is
appropriate for passing a pointer to that type.
On machines where `REG_PARM_STACK_SPACE' is not defined, a suitable
definition of this macro might be
#define FUNCTION_ARG_PASS_BY_REFERENCE\
(CUM, MODE, TYPE, NAMED) \
MUST_PASS_IN_STACK (MODE, TYPE)
`FUNCTION_ARG_CALLEE_COPIES (CUM, MODE, TYPE, NAMED)'
If defined, a C expression that indicates when it is the called
function's responsibility to make a copy of arguments passed by
invisible reference. Normally, the caller makes a copy and passes
the address of the copy to the routine being called. When
FUNCTION_ARG_CALLEE_COPIES is defined and is nonzero, the caller
does not make a copy. Instead, it passes a pointer to the "live"
value. The called function must not modify this value. If it can
be determined that the value won't be modified, it need not make a
copy; otherwise a copy must be made.
`CUMULATIVE_ARGS'
A C type for declaring a variable that is used as the first
argument of `FUNCTION_ARG' and other related values. For some
target machines, the type `int' suffices and can hold the number
of bytes of argument so far.
There is no need to record in `CUMULATIVE_ARGS' anything about the
arguments that have been passed on the stack. The compiler has
other variables to keep track of that. For target machines on
which all arguments are passed on the stack, there is no need to
store anything in `CUMULATIVE_ARGS'; however, the data structure
must exist and should not be empty, so use `int'.
`INIT_CUMULATIVE_ARGS (CUM, FNTYPE, LIBNAME, INDIRECT)'
A C statement (sans semicolon) for initializing the variable CUM
for the state at the beginning of the argument list. The variable
has type `CUMULATIVE_ARGS'. The value of FNTYPE is the tree node
for the data type of the function which will receive the args, or 0
if the args are to a compiler support library function. The value
of INDIRECT is nonzero when processing an indirect call, for
example a call through a function pointer. The value of INDIRECT
is zero for a call to an explicitly named function, a library
function call, or when `INIT_CUMULATIVE_ARGS' is used to find
arguments for the function being compiled.
When processing a call to a compiler support library function,
LIBNAME identifies which one. It is a `symbol_ref' rtx which
contains the name of the function, as a string. LIBNAME is 0 when
an ordinary C function call is being processed. Thus, each time
this macro is called, either LIBNAME or FNTYPE is nonzero, but
never both of them at once.
`INIT_CUMULATIVE_INCOMING_ARGS (CUM, FNTYPE, LIBNAME)'
Like `INIT_CUMULATIVE_ARGS' but overrides it for the purposes of
finding the arguments for the function being compiled. If this
macro is undefined, `INIT_CUMULATIVE_ARGS' is used instead.
The value passed for LIBNAME is always 0, since library routines
with special calling conventions are never compiled with GNU CC.
The argument LIBNAME exists for symmetry with
`INIT_CUMULATIVE_ARGS'.
`FUNCTION_ARG_ADVANCE (CUM, MODE, TYPE, NAMED)'
A C statement (sans semicolon) to update the summarizer variable
CUM to advance past an argument in the argument list. The values
MODE, TYPE and NAMED describe that argument. Once this is done,
the variable CUM is suitable for analyzing the *following*
argument with `FUNCTION_ARG', etc.
This macro need not do anything if the argument in question was
passed on the stack. The compiler knows how to track the amount
of stack space used for arguments without any special help.
`FUNCTION_ARG_PADDING (MODE, TYPE)'
If defined, a C expression which determines whether, and in which
direction, to pad out an argument with extra space. The value
should be of type `enum direction': either `upward' to pad above
the argument, `downward' to pad below, or `none' to inhibit
padding.
The *amount* of padding is always just enough to reach the next
multiple of `FUNCTION_ARG_BOUNDARY'; this macro does not control
it.
This macro has a default definition which is right for most
systems. For little-endian machines, the default is to pad
upward. For big-endian machines, the default is to pad downward
for an argument of constant size shorter than an `int', and upward
otherwise.
`FUNCTION_ARG_BOUNDARY (MODE, TYPE)'
If defined, a C expression that gives the alignment boundary, in
bits, of an argument with the specified mode and type. If it is
not defined, `PARM_BOUNDARY' is used for all arguments.
`FUNCTION_ARG_REGNO_P (REGNO)'
A C expression that is nonzero if REGNO is the number of a hard
register in which function arguments are sometimes passed. This
does *not* include implicit arguments such as the static chain and
the structure-value address. On many machines, no registers can be
used for this purpose since all function arguments are pushed on
the stack.
`LOAD_ARGS_REVERSED'
If defined, the order in which arguments are loaded into their
respective argument registers is reversed so that the last
argument is loaded first. This macro only effects arguments
passed in registers.

File: gcc.info, Node: Scalar Return, Next: Aggregate Return, Prev: Register Arguments, Up: Stack and Calling
How Scalar Function Values Are Returned
---------------------------------------
This section discusses the macros that control returning scalars as
values--values that can fit in registers.
`TRADITIONAL_RETURN_FLOAT'
Define this macro if `-traditional' should not cause functions
declared to return `float' to convert the value to `double'.
`FUNCTION_VALUE (VALTYPE, FUNC)'
A C expression to create an RTX representing the place where a
function returns a value of data type VALTYPE. VALTYPE is a tree
node representing a data type. Write `TYPE_MODE (VALTYPE)' to get
the machine mode used to represent that type. On many machines,
only the mode is relevant. (Actually, on most machines, scalar
values are returned in the same place regardless of mode).
The value of the expression is usually a `reg' RTX for the hard
register where the return value is stored. The value can also be a
`parallel' RTX, if the return value is in multiple places. See
`FUNCTION_ARG' for an explanation of the `parallel' form.
If `PROMOTE_FUNCTION_RETURN' is defined, you must apply the same
promotion rules specified in `PROMOTE_MODE' if VALTYPE is a scalar
type.
If the precise function being called is known, FUNC is a tree node
(`FUNCTION_DECL') for it; otherwise, FUNC is a null pointer. This
makes it possible to use a different value-returning convention
for specific functions when all their calls are known.
`FUNCTION_VALUE' is not used for return vales with aggregate data
types, because these are returned in another way. See
`STRUCT_VALUE_REGNUM' and related macros, below.
`FUNCTION_OUTGOING_VALUE (VALTYPE, FUNC)'
Define this macro if the target machine has "register windows" so
that the register in which a function returns its value is not the
same as the one in which the caller sees the value.
For such machines, `FUNCTION_VALUE' computes the register in which
the caller will see the value. `FUNCTION_OUTGOING_VALUE' should be
defined in a similar fashion to tell the function where to put the
value.
If `FUNCTION_OUTGOING_VALUE' is not defined, `FUNCTION_VALUE'
serves both purposes.
`FUNCTION_OUTGOING_VALUE' is not used for return vales with
aggregate data types, because these are returned in another way.
See `STRUCT_VALUE_REGNUM' and related macros, below.
`LIBCALL_VALUE (MODE)'
A C expression to create an RTX representing the place where a
library function returns a value of mode MODE. If the precise
function being called is known, FUNC is a tree node
(`FUNCTION_DECL') for it; otherwise, FUNC is a null pointer. This
makes it possible to use a different value-returning convention
for specific functions when all their calls are known.
Note that "library function" in this context means a compiler
support routine, used to perform arithmetic, whose name is known
specially by the compiler and was not mentioned in the C code being
compiled.
The definition of `LIBRARY_VALUE' need not be concerned aggregate
data types, because none of the library functions returns such
types.
`FUNCTION_VALUE_REGNO_P (REGNO)'
A C expression that is nonzero if REGNO is the number of a hard
register in which the values of called function may come back.
A register whose use for returning values is limited to serving as
the second of a pair (for a value of type `double', say) need not
be recognized by this macro. So for most machines, this definition
suffices:
#define FUNCTION_VALUE_REGNO_P(N) ((N) == 0)
If the machine has register windows, so that the caller and the
called function use different registers for the return value, this
macro should recognize only the caller's register numbers.
`APPLY_RESULT_SIZE'
Define this macro if `untyped_call' and `untyped_return' need more
space than is implied by `FUNCTION_VALUE_REGNO_P' for saving and
restoring an arbitrary return value.

File: gcc.info, Node: Aggregate Return, Next: Caller Saves, Prev: Scalar Return, Up: Stack and Calling
How Large Values Are Returned
-----------------------------
When a function value's mode is `BLKmode' (and in some other cases),
the value is not returned according to `FUNCTION_VALUE' (*note Scalar
Return::.). Instead, the caller passes the address of a block of
memory in which the value should be stored. This address is called the
"structure value address".
This section describes how to control returning structure values in
memory.
`RETURN_IN_MEMORY (TYPE)'
A C expression which can inhibit the returning of certain function
values in registers, based on the type of value. A nonzero value
says to return the function value in memory, just as large
structures are always returned. Here TYPE will be a C expression
of type `tree', representing the data type of the value.
Note that values of mode `BLKmode' must be explicitly handled by
this macro. Also, the option `-fpcc-struct-return' takes effect
regardless of this macro. On most systems, it is possible to
leave the macro undefined; this causes a default definition to be
used, whose value is the constant 1 for `BLKmode' values, and 0
otherwise.
Do not use this macro to indicate that structures and unions
should always be returned in memory. You should instead use
`DEFAULT_PCC_STRUCT_RETURN' to indicate this.
`DEFAULT_PCC_STRUCT_RETURN'
Define this macro to be 1 if all structure and union return values
must be in memory. Since this results in slower code, this should
be defined only if needed for compatibility with other compilers
or with an ABI. If you define this macro to be 0, then the
conventions used for structure and union return values are decided
by the `RETURN_IN_MEMORY' macro.
If not defined, this defaults to the value 1.
`STRUCT_VALUE_REGNUM'
If the structure value address is passed in a register, then
`STRUCT_VALUE_REGNUM' should be the number of that register.
`STRUCT_VALUE'
If the structure value address is not passed in a register, define
`STRUCT_VALUE' as an expression returning an RTX for the place
where the address is passed. If it returns 0, the address is
passed as an "invisible" first argument.
`STRUCT_VALUE_INCOMING_REGNUM'
On some architectures the place where the structure value address
is found by the called function is not the same place that the
caller put it. This can be due to register windows, or it could
be because the function prologue moves it to a different place.
If the incoming location of the structure value address is in a
register, define this macro as the register number.
`STRUCT_VALUE_INCOMING'
If the incoming location is not a register, then you should define
`STRUCT_VALUE_INCOMING' as an expression for an RTX for where the
called function should find the value. If it should find the
value on the stack, define this to create a `mem' which refers to
the frame pointer. A definition of 0 means that the address is
passed as an "invisible" first argument.
`PCC_STATIC_STRUCT_RETURN'
Define this macro if the usual system convention on the target
machine for returning structures and unions is for the called
function to return the address of a static variable containing the
value.
Do not define this if the usual system convention is for the
caller to pass an address to the subroutine.
This macro has effect in `-fpcc-struct-return' mode, but it does
nothing when you use `-freg-struct-return' mode.

File: gcc.info, Node: Caller Saves, Next: Function Entry, Prev: Aggregate Return, Up: Stack and Calling
Caller-Saves Register Allocation
--------------------------------
If you enable it, GNU CC can save registers around function calls.
This makes it possible to use call-clobbered registers to hold
variables that must live across calls.
`DEFAULT_CALLER_SAVES'
Define this macro if function calls on the target machine do not
preserve any registers; in other words, if `CALL_USED_REGISTERS'
has 1 for all registers. When defined, this macro enables
`-fcaller-saves' by default for all optimization levels. It has
no effect for optimization levels 2 and higher, where
`-fcaller-saves' is the default.
`CALLER_SAVE_PROFITABLE (REFS, CALLS)'
A C expression to determine whether it is worthwhile to consider
placing a pseudo-register in a call-clobbered hard register and
saving and restoring it around each function call. The expression
should be 1 when this is worth doing, and 0 otherwise.
If you don't define this macro, a default is used which is good on
most machines: `4 * CALLS < REFS'.
`HARD_REGNO_CALLER_SAVE_MODE (REGNO, NREGS)'
A C expression specifying which mode is required for saving NREGS
of a pseudo-register in call-clobbered hard register REGNO. If
REGNO is unsuitable for caller save, `VOIDmode' should be
returned. For most machines this macro need not be defined since
GCC will select the smallest suitable mode.

File: gcc.info, Node: Function Entry, Next: Profiling, Prev: Caller Saves, Up: Stack and Calling
Function Entry and Exit
-----------------------
This section describes the macros that output function entry
("prologue") and exit ("epilogue") code.
`FUNCTION_PROLOGUE (FILE, SIZE)'
A C compound statement that outputs the assembler code for entry
to a function. The prologue is responsible for setting up the
stack frame, initializing the frame pointer register, saving
registers that must be saved, and allocating SIZE additional bytes
of storage for the local variables. SIZE is an integer. FILE is
a stdio stream to which the assembler code should be output.
The label for the beginning of the function need not be output by
this macro. That has already been done when the macro is run.
To determine which registers to save, the macro can refer to the
array `regs_ever_live': element R is nonzero if hard register R is
used anywhere within the function. This implies the function
prologue should save register R, provided it is not one of the
call-used registers. (`FUNCTION_EPILOGUE' must likewise use
`regs_ever_live'.)
On machines that have "register windows", the function entry code
does not save on the stack the registers that are in the windows,
even if they are supposed to be preserved by function calls;
instead it takes appropriate steps to "push" the register stack,
if any non-call-used registers are used in the function.
On machines where functions may or may not have frame-pointers, the
function entry code must vary accordingly; it must set up the frame
pointer if one is wanted, and not otherwise. To determine whether
a frame pointer is in wanted, the macro can refer to the variable
`frame_pointer_needed'. The variable's value will be 1 at run
time in a function that needs a frame pointer. *Note
Elimination::.
The function entry code is responsible for allocating any stack
space required for the function. This stack space consists of the
regions listed below. In most cases, these regions are allocated
in the order listed, with the last listed region closest to the
top of the stack (the lowest address if `STACK_GROWS_DOWNWARD' is
defined, and the highest address if it is not defined). You can
use a different order for a machine if doing so is more convenient
or required for compatibility reasons. Except in cases where
required by standard or by a debugger, there is no reason why the
stack layout used by GCC need agree with that used by other
compilers for a machine.
* A region of `current_function_pretend_args_size' bytes of
uninitialized space just underneath the first argument
arriving on the stack. (This may not be at the very start of
the allocated stack region if the calling sequence has pushed
anything else since pushing the stack arguments. But
usually, on such machines, nothing else has been pushed yet,
because the function prologue itself does all the pushing.)
This region is used on machines where an argument may be
passed partly in registers and partly in memory, and, in some
cases to support the features in `varargs.h' and `stdargs.h'.
* An area of memory used to save certain registers used by the
function. The size of this area, which may also include
space for such things as the return address and pointers to
previous stack frames, is machine-specific and usually
depends on which registers have been used in the function.
Machines with register windows often do not require a save
area.
* A region of at least SIZE bytes, possibly rounded up to an
allocation boundary, to contain the local variables of the
function. On some machines, this region and the save area
may occur in the opposite order, with the save area closer to
the top of the stack.
* Optionally, when `ACCUMULATE_OUTGOING_ARGS' is defined, a
region of `current_function_outgoing_args_size' bytes to be
used for outgoing argument lists of the function. *Note
Stack Arguments::.
Normally, it is necessary for the macros `FUNCTION_PROLOGUE' and
`FUNCTION_EPILOGUE' to treat leaf functions specially. The C
variable `current_function_is_leaf' is nonzero for such a function.
`EXIT_IGNORE_STACK'
Define this macro as a C expression that is nonzero if the return
instruction or the function epilogue ignores the value of the stack
pointer; in other words, if it is safe to delete an instruction to
adjust the stack pointer before a return from the function.
Note that this macro's value is relevant only for functions for
which frame pointers are maintained. It is never safe to delete a
final stack adjustment in a function that has no frame pointer,
and the compiler knows this regardless of `EXIT_IGNORE_STACK'.
`EPILOGUE_USES (REGNO)'
Define this macro as a C expression that is nonzero for registers
are used by the epilogue or the `return' pattern. The stack and
frame pointer registers are already be assumed to be used as
needed.
`FUNCTION_EPILOGUE (FILE, SIZE)'
A C compound statement that outputs the assembler code for exit
from a function. The epilogue is responsible for restoring the
saved registers and stack pointer to their values when the
function was called, and returning control to the caller. This
macro takes the same arguments as the macro `FUNCTION_PROLOGUE',
and the registers to restore are determined from `regs_ever_live'
and `CALL_USED_REGISTERS' in the same way.
On some machines, there is a single instruction that does all the
work of returning from the function. On these machines, give that
instruction the name `return' and do not define the macro
`FUNCTION_EPILOGUE' at all.
Do not define a pattern named `return' if you want the
`FUNCTION_EPILOGUE' to be used. If you want the target switches
to control whether return instructions or epilogues are used,
define a `return' pattern with a validity condition that tests the
target switches appropriately. If the `return' pattern's validity
condition is false, epilogues will be used.
On machines where functions may or may not have frame-pointers, the
function exit code must vary accordingly. Sometimes the code for
these two cases is completely different. To determine whether a
frame pointer is wanted, the macro can refer to the variable
`frame_pointer_needed'. The variable's value will be 1 when
compiling a function that needs a frame pointer.
Normally, `FUNCTION_PROLOGUE' and `FUNCTION_EPILOGUE' must treat
leaf functions specially. The C variable
`current_function_is_leaf' is nonzero for such a function. *Note
Leaf Functions::.
On some machines, some functions pop their arguments on exit while
others leave that for the caller to do. For example, the 68020
when given `-mrtd' pops arguments in functions that take a fixed
number of arguments.
Your definition of the macro `RETURN_POPS_ARGS' decides which
functions pop their own arguments. `FUNCTION_EPILOGUE' needs to
know what was decided. The variable that is called
`current_function_pops_args' is the number of bytes of its
arguments that a function should pop. *Note Scalar Return::.
`DELAY_SLOTS_FOR_EPILOGUE'
Define this macro if the function epilogue contains delay slots to
which instructions from the rest of the function can be "moved".
The definition should be a C expression whose value is an integer
representing the number of delay slots there.
`ELIGIBLE_FOR_EPILOGUE_DELAY (INSN, N)'
A C expression that returns 1 if INSN can be placed in delay slot
number N of the epilogue.
The argument N is an integer which identifies the delay slot now
being considered (since different slots may have different rules of
eligibility). It is never negative and is always less than the
number of epilogue delay slots (what `DELAY_SLOTS_FOR_EPILOGUE'
returns). If you reject a particular insn for a given delay slot,
in principle, it may be reconsidered for a subsequent delay slot.
Also, other insns may (at least in principle) be considered for
the so far unfilled delay slot.
The insns accepted to fill the epilogue delay slots are put in an
RTL list made with `insn_list' objects, stored in the variable
`current_function_epilogue_delay_list'. The insn for the first
delay slot comes first in the list. Your definition of the macro
`FUNCTION_EPILOGUE' should fill the delay slots by outputting the
insns in this list, usually by calling `final_scan_insn'.
You need not define this macro if you did not define
`DELAY_SLOTS_FOR_EPILOGUE'.
`ASM_OUTPUT_MI_THUNK (FILE, THUNK_FNDECL, DELTA, FUNCTION)'
A C compound statement that outputs the assembler code for a thunk
function, used to implement C++ virtual function calls with
multiple inheritance. The thunk acts as a wrapper around a
virtual function, adjusting the implicit object parameter before
handing control off to the real function.
First, emit code to add the integer DELTA to the location that
contains the incoming first argument. Assume that this argument
contains a pointer, and is the one used to pass the `this' pointer
in C++. This is the incoming argument *before* the function
prologue, e.g. `%o0' on a sparc. The addition must preserve the
values of all other incoming arguments.
After the addition, emit code to jump to FUNCTION, which is a
`FUNCTION_DECL'. This is a direct pure jump, not a call, and does
not touch the return address. Hence returning from FUNCTION will
return to whoever called the current `thunk'.
The effect must be as if FUNCTION had been called directly with
the adjusted first argument. This macro is responsible for
emitting all of the code for a thunk function; `FUNCTION_PROLOGUE'
and `FUNCTION_EPILOGUE' are not invoked.
The THUNK_FNDECL is redundant. (DELTA and FUNCTION have already
been extracted from it.) It might possibly be useful on some
targets, but probably not.
If you do not define this macro, the target-independent code in
the C++ frontend will generate a less efficient heavyweight thunk
that calls FUNCTION instead of jumping to it. The generic
approach does not support varargs.

File: gcc.info, Node: Profiling, Prev: Function Entry, Up: Stack and Calling
Generating Code for Profiling
-----------------------------
These macros will help you generate code for profiling.
`FUNCTION_PROFILER (FILE, LABELNO)'
A C statement or compound statement to output to FILE some
assembler code to call the profiling subroutine `mcount'. Before
calling, the assembler code must load the address of a counter
variable into a register where `mcount' expects to find the
address. The name of this variable is `LP' followed by the number
LABELNO, so you would generate the name using `LP%d' in a
`fprintf'.
The details of how the address should be passed to `mcount' are
determined by your operating system environment, not by GNU CC. To
figure them out, compile a small program for profiling using the
system's installed C compiler and look at the assembler code that
results.
`PROFILE_BEFORE_PROLOGUE'
Define this macro if the code for function profiling should come
before the function prologue. Normally, the profiling code comes
after.
`FUNCTION_BLOCK_PROFILER (FILE, LABELNO)'
A C statement or compound statement to output to FILE some
assembler code to initialize basic-block profiling for the current
object module. The global compile flag `profile_block_flag'
distinguishes two profile modes.
`profile_block_flag != 2'
Output code to call the subroutine `__bb_init_func' once per
object module, passing it as its sole argument the address of
a block allocated in the object module.
The name of the block is a local symbol made with this
statement:
ASM_GENERATE_INTERNAL_LABEL (BUFFER, "LPBX", 0);
Of course, since you are writing the definition of
`ASM_GENERATE_INTERNAL_LABEL' as well as that of this macro,
you can take a short cut in the definition of this macro and
use the name that you know will result.
The first word of this block is a flag which will be nonzero
if the object module has already been initialized. So test
this word first, and do not call `__bb_init_func' if the flag
is nonzero. BLOCK_OR_LABEL contains a unique number which
may be used to generate a label as a branch destination when
`__bb_init_func' will not be called.
Described in assembler language, the code to be output looks
like:
cmp (LPBX0),0
bne local_label
parameter1 <- LPBX0
call __bb_init_func
local_label:
`profile_block_flag == 2'
Output code to call the subroutine `__bb_init_trace_func' and
pass two parameters to it. The first parameter is the same as
for `__bb_init_func'. The second parameter is the number of
the first basic block of the function as given by
BLOCK_OR_LABEL. Note that `__bb_init_trace_func' has to be
called, even if the object module has been initialized
already.
Described in assembler language, the code to be output looks
like:
parameter1 <- LPBX0
parameter2 <- BLOCK_OR_LABEL
call __bb_init_trace_func
`BLOCK_PROFILER (FILE, BLOCKNO)'
A C statement or compound statement to output to FILE some
assembler code to increment the count associated with the basic
block number BLOCKNO. The global compile flag
`profile_block_flag' distinguishes two profile modes.
`profile_block_flag != 2'
Output code to increment the counter directly. Basic blocks
are numbered separately from zero within each compilation.
The count associated with block number BLOCKNO is at index
BLOCKNO in a vector of words; the name of this array is a
local symbol made with this statement:
ASM_GENERATE_INTERNAL_LABEL (BUFFER, "LPBX", 2);
Of course, since you are writing the definition of
`ASM_GENERATE_INTERNAL_LABEL' as well as that of this macro,
you can take a short cut in the definition of this macro and
use the name that you know will result.
Described in assembler language, the code to be output looks
like:
inc (LPBX2+4*BLOCKNO)
`profile_block_flag == 2'
Output code to initialize the global structure `__bb' and
call the function `__bb_trace_func', which will increment the
counter.
`__bb' consists of two words. In the first word, the current
basic block number, as given by BLOCKNO, has to be stored. In
the second word, the address of a block allocated in the
object module has to be stored. The address is given by the
label created with this statement:
ASM_GENERATE_INTERNAL_LABEL (BUFFER, "LPBX", 0);
Described in assembler language, the code to be output looks
like:
move BLOCKNO -> (__bb)
move LPBX0 -> (__bb+4)
call __bb_trace_func
`FUNCTION_BLOCK_PROFILER_EXIT (FILE)'
A C statement or compound statement to output to FILE assembler
code to call function `__bb_trace_ret'. The assembler code should
only be output if the global compile flag `profile_block_flag' ==
2. This macro has to be used at every place where code for
returning from a function is generated (e.g. `FUNCTION_EPILOGUE').
Although you have to write the definition of `FUNCTION_EPILOGUE'
as well, you have to define this macro to tell the compiler, that
the proper call to `__bb_trace_ret' is produced.
`MACHINE_STATE_SAVE (ID)'
A C statement or compound statement to save all registers, which
may be clobbered by a function call, including condition codes.
The `asm' statement will be mostly likely needed to handle this
task. Local labels in the assembler code can be concatenated with
the string ID, to obtain a unique lable name.
Registers or condition codes clobbered by `FUNCTION_PROLOGUE' or
`FUNCTION_EPILOGUE' must be saved in the macros
`FUNCTION_BLOCK_PROFILER', `FUNCTION_BLOCK_PROFILER_EXIT' and
`BLOCK_PROFILER' prior calling `__bb_init_trace_func',
`__bb_trace_ret' and `__bb_trace_func' respectively.
`MACHINE_STATE_RESTORE (ID)'
A C statement or compound statement to restore all registers,
including condition codes, saved by `MACHINE_STATE_SAVE'.
Registers or condition codes clobbered by `FUNCTION_PROLOGUE' or
`FUNCTION_EPILOGUE' must be restored in the macros
`FUNCTION_BLOCK_PROFILER', `FUNCTION_BLOCK_PROFILER_EXIT' and
`BLOCK_PROFILER' after calling `__bb_init_trace_func',
`__bb_trace_ret' and `__bb_trace_func' respectively.
`BLOCK_PROFILER_CODE'
A C function or functions which are needed in the library to
support block profiling.

File: gcc.info, Node: Varargs, Next: Trampolines, Prev: Stack and Calling, Up: Target Macros
Implementing the Varargs Macros
===============================
GNU CC comes with an implementation of `varargs.h' and `stdarg.h'
that work without change on machines that pass arguments on the stack.
Other machines require their own implementations of varargs, and the
two machine independent header files must have conditionals to include
it.
ANSI `stdarg.h' differs from traditional `varargs.h' mainly in the
calling convention for `va_start'. The traditional implementation
takes just one argument, which is the variable in which to store the
argument pointer. The ANSI implementation of `va_start' takes an
additional second argument. The user is supposed to write the last
named argument of the function here.
However, `va_start' should not use this argument. The way to find
the end of the named arguments is with the built-in functions described
below.
`__builtin_saveregs ()'
Use this built-in function to save the argument registers in
memory so that the varargs mechanism can access them. Both ANSI
and traditional versions of `va_start' must use
`__builtin_saveregs', unless you use `SETUP_INCOMING_VARARGS' (see
below) instead.
On some machines, `__builtin_saveregs' is open-coded under the
control of the macro `EXPAND_BUILTIN_SAVEREGS'. On other machines,
it calls a routine written in assembler language, found in
`libgcc2.c'.
Code generated for the call to `__builtin_saveregs' appears at the
beginning of the function, as opposed to where the call to
`__builtin_saveregs' is written, regardless of what the code is.
This is because the registers must be saved before the function
starts to use them for its own purposes.
`__builtin_args_info (CATEGORY)'
Use this built-in function to find the first anonymous arguments in
registers.
In general, a machine may have several categories of registers
used for arguments, each for a particular category of data types.
(For example, on some machines, floating-point registers are used
for floating-point arguments while other arguments are passed in
the general registers.) To make non-varargs functions use the
proper calling convention, you have defined the `CUMULATIVE_ARGS'
data type to record how many registers in each category have been
used so far
`__builtin_args_info' accesses the same data structure of type
`CUMULATIVE_ARGS' after the ordinary argument layout is finished
with it, with CATEGORY specifying which word to access. Thus, the
value indicates the first unused register in a given category.
Normally, you would use `__builtin_args_info' in the implementation
of `va_start', accessing each category just once and storing the
value in the `va_list' object. This is because `va_list' will
have to update the values, and there is no way to alter the values
accessed by `__builtin_args_info'.
`__builtin_next_arg (LASTARG)'
This is the equivalent of `__builtin_args_info', for stack
arguments. It returns the address of the first anonymous stack
argument, as type `void *'. If `ARGS_GROW_DOWNWARD', it returns
the address of the location above the first anonymous stack
argument. Use it in `va_start' to initialize the pointer for
fetching arguments from the stack. Also use it in `va_start' to
verify that the second parameter LASTARG is the last named argument
of the current function.
`__builtin_classify_type (OBJECT)'
Since each machine has its own conventions for which data types are
passed in which kind of register, your implementation of `va_arg'
has to embody these conventions. The easiest way to categorize the
specified data type is to use `__builtin_classify_type' together
with `sizeof' and `__alignof__'.
`__builtin_classify_type' ignores the value of OBJECT, considering
only its data type. It returns an integer describing what kind of
type that is--integer, floating, pointer, structure, and so on.
The file `typeclass.h' defines an enumeration that you can use to
interpret the values of `__builtin_classify_type'.
These machine description macros help implement varargs:
`EXPAND_BUILTIN_SAVEREGS (ARGS)'
If defined, is a C expression that produces the machine-specific
code for a call to `__builtin_saveregs'. This code will be moved
to the very beginning of the function, before any parameter access
are made. The return value of this function should be an RTX that
contains the value to use as the return of `__builtin_saveregs'.
The argument ARGS is a `tree_list' containing the arguments that
were passed to `__builtin_saveregs'.
If this macro is not defined, the compiler will output an ordinary
call to the library function `__builtin_saveregs'.
`SETUP_INCOMING_VARARGS (ARGS_SO_FAR, MODE, TYPE, PRETEND_ARGS_SIZE, SECOND_TIME)'
This macro offers an alternative to using `__builtin_saveregs' and
defining the macro `EXPAND_BUILTIN_SAVEREGS'. Use it to store the
anonymous register arguments into the stack so that all the
arguments appear to have been passed consecutively on the stack.
Once this is done, you can use the standard implementation of
varargs that works for machines that pass all their arguments on
the stack.
The argument ARGS_SO_FAR is the `CUMULATIVE_ARGS' data structure,
containing the values that obtain after processing of the named
arguments. The arguments MODE and TYPE describe the last named
argument--its machine mode and its data type as a tree node.
The macro implementation should do two things: first, push onto the
stack all the argument registers *not* used for the named
arguments, and second, store the size of the data thus pushed into
the `int'-valued variable whose name is supplied as the argument
PRETEND_ARGS_SIZE. The value that you store here will serve as
additional offset for setting up the stack frame.
Because you must generate code to push the anonymous arguments at
compile time without knowing their data types,
`SETUP_INCOMING_VARARGS' is only useful on machines that have just
a single category of argument register and use it uniformly for
all data types.
If the argument SECOND_TIME is nonzero, it means that the
arguments of the function are being analyzed for the second time.
This happens for an inline function, which is not actually
compiled until the end of the source file. The macro
`SETUP_INCOMING_VARARGS' should not generate any instructions in
this case.
`STRICT_ARGUMENT_NAMING'
Define this macro to be a nonzero value if the location where a
function argument is passed depends on whether or not it is a
named argument.
This macro controls how the NAMED argument to `FUNCTION_ARG' is
set for varargs and stdarg functions. If this macro returns a
nonzero value, the NAMED argument is always true for named
arguments, and false for unnamed arguments. If it returns a value
of zero, but `SETUP_INCOMING_VARARGS' is defined, then all
arguments are treated as named. Otherwise, all named arguments
except the last are treated as named.
You need not define this macro if it always returns zero.
`PRETEND_OUTGOING_VARARGS_NAMED'
If you need to conditionally change ABIs so that one works with
`SETUP_INCOMING_VARARGS', but the other works like neither
`SETUP_INCOMING_VARARGS' nor `STRICT_ARGUMENT_NAMING' was defined,
then define this macro to return nonzero if
`SETUP_INCOMING_VARARGS' is used, zero otherwise. Otherwise, you
should not define this macro.
Reference in New Issue View Git Blame Copy Permalink