Net2/usr/src/usr.bin/gcc/doc/gcc.info-9
Info file gcc.info, produced by Makeinfo, -*- Text -*- from input
file gcc.texinfo.
This file documents the use and the internals of the GNU compiler.
Copyright (C) 1988, 1989, 1990 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 "Protect
Your Freedom--Fight `Look And Feel'" 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 "Protect Your Freedom--Fight `Look And Feel'" 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 Classes, Next: Stack Layout, Prev: Registers, Up: Machine Macros
Register Classes
================
On many machines, the numbered registers are not all equivalent. For
example, certain registers may not be allowed for indexed addressing;
certain registers may not be allowed in some instructions. These
machine restrictions are described to the compiler using "register
classes".
You define a number of register classes, giving each one a name and
saying which of the registers belong to it. Then you can specify
register classes that are allowed as operands to particular
instruction patterns.
In general, each register will belong to several classes. In fact,
one class must be named `ALL_REGS' and contain all the registers.
Another class must be named `NO_REGS' and contain no registers.
Often the union of two classes will be another class; however, this
is not required.
One of the classes must be named `GENERAL_REGS'. There is nothing
terribly special about the name, but the operand constraint letters
`r' and `g' specify this class. If `GENERAL_REGS' is the same as
`ALL_REGS', just define it as a macro which expands to `ALL_REGS'.
The way classes other than `GENERAL_REGS' are specified in operand
constraints is through machine-dependent operand constraint letters.
You can define such letters to correspond to various classes, then
use them in operand constraints.
You should define a class for the union of two classes whenever some
instruction allows both classes. For example, if an instruction
allows either a floating-point (coprocessor) register or a general
register for a certain operand, you should define a class
`FLOAT_OR_GENERAL_REGS' which includes both of them. Otherwise you
will get suboptimal code.
You must also specify certain redundant information about the
register classes: for each class, which classes contain it and which
ones are contained in it; for each pair of classes, the largest class
contained in their union.
When a value occupying several consecutive registers is expected in a
certain class, all the registers used must belong to that class.
Therefore, register classes cannot be used to enforce a requirement
for a register pair to start with an even-numbered register. The way
to specify this requirement is with `HARD_REGNO_MODE_OK'.
Register classes used for input-operands of bitwise-and or shift
instructions have a special requirement: each such class must have,
for each fixed-point machine mode, a subclass whose registers can
transfer that mode to or from memory. For example, on some machines,
the operations for single-byte values (`QImode') are limited to
certain registers. When this is so, each register class that is used
in a bitwise-and or shift instruction must have a subclass consisting
of registers from which single-byte values can be loaded or stored.
This is so that `PREFERRED_RELOAD_CLASS' can always have a possible
value to return.
`enum reg_class'
An enumeral type that must be defined with all the register
class names as enumeral values. `NO_REGS' must be first.
`ALL_REGS' must be the last register class, followed by one more
enumeral value, `LIM_REG_CLASSES', which is not a register class
but rather tells how many classes there are.
Each register class has a number, which is the value of casting
the class name to type `int'. The number serves as an index in
many of the tables described below.
`N_REG_CLASSES'
The number of distinct register classes, defined as follows:
#define N_REG_CLASSES (int) LIM_REG_CLASSES
`REG_CLASS_NAMES'
An initializer containing the names of the register classes as C
string constants. These names are used in writing some of the
debugging dumps.
`REG_CLASS_CONTENTS'
An initializer containing the contents of the register classes,
as integers which are bit masks. The Nth integer specifies the
contents of class N. The way the integer MASK is interpreted is
that register R is in the class if `MASK & (1 << R)' is 1.
When the machine has more than 32 registers, an integer does not
suffice. Then the integers are replaced by sub-initializers,
braced groupings containing several integers. Each
sub-initializer must be suitable as an initializer for the type
`HARD_REG_SET' which is defined in `hard-reg-set.h'.
`REGNO_REG_CLASS (REGNO)'
A C expression whose value is a register class containing hard
register REGNO. In general there is more that one such class;
choose a class which is "minimal", meaning that no smaller class
also contains the register.
`BASE_REG_CLASS'
A macro whose definition is the name of the class to which a
valid base register must belong. A base register is one used in
an address which is the register value plus a displacement.
`INDEX_REG_CLASS'
A macro whose definition is the name of the class to which a
valid index register must belong. An index register is one used
in an address where its value is either multiplied by a scale
factor or added to another register (as well as added to a
displacement).
`REG_CLASS_FROM_LETTER (CHAR)'
A C expression which defines the machine-dependent operand
constraint letters for register classes. If CHAR is such a
letter, the value should be the register class corresponding to
it. Otherwise, the value should be `NO_REGS'.
`REGNO_OK_FOR_BASE_P (NUM)'
A C expression which is nonzero if register number NUM is
suitable for use as a base register in operand addresses. It
may be either a suitable hard register or a pseudo register that
has been allocated such a hard register.
`REGNO_OK_FOR_INDEX_P (NUM)'
A C expression which is nonzero if register number NUM is
suitable for use as an index register in operand addresses. It
may be either a suitable hard register or a pseudo register that
has been allocated such a hard register.
The difference between an index register and a base register is
that the index register may be scaled. If an address involves
the sum of two registers, neither one of them scaled, then
either one may be labeled the "base" and the other the "index";
but whichever labeling is used must fit the machine's
constraints of which registers may serve in each capacity. The
compiler will try both labelings, looking for one that is valid,
and will reload one or both registers only if neither labeling
works.
`PREFERRED_RELOAD_CLASS (X, CLASS)'
A C expression that places additional restrictions on the
register class to use when it is necessary to copy value X into
a register in class CLASS. The value is a register class;
perhaps CLASS, or perhaps another, smaller class. On many
machines, the definition
#define PREFERRED_RELOAD_CLASS(X,CLASS) CLASS
is safe.
Sometimes returning a more restrictive class makes better code.
For example, on the 68000, when X is an integer constant that is
in range for a `moveq' instruction, the value of this macro is
always `DATA_REGS' as long as CLASS includes the data registers.
Requiring a data register guarantees that a `moveq' will be used.
If X is a `const_double', by returning `NO_REGS' you can force X
into a memory constant. This is useful on certain machines
where immediate floating values cannot be loaded into certain
kinds of registers.
In a shift instruction or a bitwise-and instruction, the mode of
X, the value being reloaded, may not be the same as the mode of
the instruction's operand. (They will both be fixed-point
modes, however.) In such a case, CLASS may not be a safe value
to return. CLASS is certainly valid for the instruction, but it
may not be valid for reloading X. This problem can occur on
machines such as the 68000 and 80386 where some registers can
handle full-word values but cannot handle single-byte values.
On such machines, this macro must examine the mode of X and
return a subclass of CLASS which can handle loads and stores of
that mode. On the 68000, where address registers cannot handle
`QImode', if X has `QImode' then you must return `DATA_REGS'.
If CLASS is `ADDR_REGS', then there is no correct value to
return; but the shift and bitwise-and instructions don't use
`ADDR_REGS', so this fatal case never arises.
`CLASS_MAX_NREGS (CLASS, MODE)'
A C expression for the maximum number of consecutive registers
of class CLASS needed to hold a value of mode MODE.
This is closely related to the macro `HARD_REGNO_NREGS'. In
fact, the value of the macro `CLASS_MAX_NREGS (CLASS, MODE)'
should be the maximum value of `HARD_REGNO_NREGS (REGNO, MODE)'
for all REGNO values in the class CLASS.
This macro helps control the handling of multiple-word values in
the reload pass.
Two other special macros describe which constants fit which
constraint letters.
`CONST_OK_FOR_LETTER_P (VALUE, C)'
A C expression that defines the machine-dependent operand
constraint letters that specify particular ranges of integer
values. If C is one of those letters, the expression should
check that VALUE, an integer, is in the appropriate range and
return 1 if so, 0 otherwise. If C is not one of those letters,
the value should be 0 regardless of VALUE.
`CONST_DOUBLE_OK_FOR_LETTER_P (VALUE, C)'
A C expression that defines the machine-dependent operand
constraint letters that specify particular ranges of floating
values. If C is one of those letters, the expression should
check that VALUE, an RTX of code `const_double', is in the
appropriate range and return 1 if so, 0 otherwise. If C is not
one of those letters, the value should be 0 regardless of VALUE.
File: gcc.info, Node: Stack Layout, Next: Library Names, Prev: Register Classes, Up: Machine Macros
Describing Stack Layout
=======================
`STACK_GROWS_DOWNWARD'
Define this macro if pushing a word onto the stack moves the
stack pointer to a smaller address.
When we say, "define this macro if ...," it means that the
compiler checks this macro only with `#ifdef' so the precise
definition used does not matter.
`FRAME_GROWS_DOWNWARD'
Define this macro if the addresses of local variable slots are
at negative offsets from the frame pointer.
`STARTING_FRAME_OFFSET'
Offset from the frame pointer to the first local variable slot
to be allocated.
If `FRAME_GROWS_DOWNWARD', the next slot's offset is found by
subtracting the length of the first slot from
`STARTING_FRAME_OFFSET'. Otherwise, it is found by adding the
length of the first slot to the value `STARTING_FRAME_OFFSET'.
`PUSH_ROUNDING (NPUSHED)'
A C expression that is the number of bytes actually pushed onto
the stack when an instruction attempts to push NPUSHED bytes.
If the target machine does not have a push instruction, do not
define this macro. That directs GNU CC to use an alternate
strategy: to allocate the entire argument block and then store
the arguments into it.
On some machines, the definition
#define PUSH_ROUNDING(BYTES) (BYTES)
will suffice. But on other machines, instructions that appear
to push one byte actually push two bytes in an attempt to
maintain alignment. Then the definition should be
#define PUSH_ROUNDING(BYTES) (((BYTES) + 1) & ~1)
`FIRST_PARM_OFFSET (FUNDECL)'
Offset from the argument pointer register to the first
argument's address. On some machines it may depend on the data
type of the function. (In the next version of GNU CC, the
argument will be changed to the function data type rather than
its declaration.)
`FIRST_PARM_CALLER_OFFSET (FUNDECL)'
Define this macro on machines where register parameters have
shadow locations on the stack, at addresses below the nominal
parameter. This matters because certain arguments cannot be
passed on the stack. On these machines, such arguments must be
stored into the shadow locations.
This macro should expand into a C expression whose value is the
offset of the first parameter's shadow location from the nominal
stack pointer value. (That value is itself computed by adding
the value of `STACK_POINTER_OFFSET' to the stack pointer
register.)
`REG_PARM_STACK_SPACE'
Define this macro if functions should assume that stack space
has been allocated for arguments even when their values are
passed in registers.
The actual allocation of such space would be done either by the
call instruction or by the function prologue, or by defining
`FIRST_PARM_CALLER_OFFSET'.
`STACK_ARGS_ADJUST (SIZE)'
Define this macro if the machine requires padding on the stack
for certain function calls. This is padding on a
per-function-call basis, not padding for individual arguments.
The argument SIZE will be a C variable of type `struct arg_data'
which contains two fields, an integer named `constant' and an
RTX named `var'. These together represent a size measured in
bytes which is the sum of the integer and the RTX. Most of the
time `var' is 0, which means that the size is simply the integer.
The definition should be a C statement or compound statement
which alters the variable supplied in whatever way you wish.
Note that the value you leave in the variable `size' will
ultimately be rounded up to a multiple of `STACK_BOUNDARY' bits.
This macro is not fully implemented for machines which have push
instructions (i.e., on which `PUSH_ROUNDING' is defined).
`RETURN_POPS_ARGS (FUNTYPE)'
A C expression that should be 1 if a function pops its own
arguments on returning, or 0 if the function pops no arguments
and the caller must therefore pop them all after the function
returns.
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.
On the Vax, all functions always pop their arguments, so the
definition of this macro is 1. 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.
When this macro returns nonzero, the macro
`FRAME_POINTER_REQUIRED' must also return nonzero for proper
operation.
`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).
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_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, and
`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.
`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' are returned in memory
regardless of 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 0.
`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.
`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.
`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 should either be a `reg' RTX for the
hard register in which to pass the argument, or zero to pass the
argument on the stack.
For the Vax and 68000, where normally all arguments are pushed,
zero suffices as a definition.
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.
`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.
`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.
`INIT_CUMULATIVE_ARGS (CUM, FNTYPE)'
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.
`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.
`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.
`FUNCTION_ARG_PADDING (MODE, SIZE)'
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 argument SIZE is an RTX which describes the size of the
argument, in bytes. It should be used only if MODE is
`BLKmode'. Otherwise, SIZE is 0.
This macro does not control the *amount* of padding; that is
always just enough to reach the next multiple of `PARM_BOUNDARY'.
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_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, but not if it is one of the
call-used registers.
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.
On machines where an argument may be passed partly in registers
and partly in memory, this macro must examine the variable
`current_function_pretend_args_size', and allocate that many
bytes of uninitialized space on the stack just underneath the
first argument arriving on the stack. (This may not be at the
very end of the stack, 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.)
`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.
`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. This code should 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_PROFILER (FILE, BLOCKNO)'
A C statement or compound statement to increment the count
associated with the basic block number BLOCKNO. 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.
`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'.
`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 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.
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
`current_function_pops_args' is nonzero if the function should
pop its own arguments. If so, use the variable
`current_function_args_size' as the number of bytes to pop.
`FIX_FRAME_POINTER_ADDRESS (ADDR, DEPTH)'
A C compound statement to alter a memory address that uses the
frame pointer register so that it uses the stack pointer
register instead. This must be done in the instructions that
load parameter values into registers, when the reload pass
determines that a frame pointer is not necessary for the
function. ADDR will be a C variable name, and the updated
address should be stored in that variable. DEPTH will be the
current depth of stack temporaries (number of bytes of arguments
currently pushed). The change in offset between a
frame-pointer-relative address and a stack-pointer-relative
address must include DEPTH.
Even if your machine description specifies there will always be
a frame pointer in the frame pointer register, you must still
define `FIX_FRAME_POINTER_ADDRESS', but the definition will
never be executed at run time, so it may be empty.
`LONGJMP_RESTORE_FROM_STACK'
Define this macro if the `longjmp' function restores registers
from the stack frames, rather than from those saved specifically
by `setjmp'. Certain quantities must not be kept in registers
across a call to `setjmp' on such machines.
File: gcc.info, Node: Library Names, Next: Addressing Modes, Prev: Stack Layout, Up: Machine Macros
Library Subroutine Names
========================
`MULSI3_LIBCALL'
A C string constant giving the name of the function to call for
multiplication of one signed full-word by another. If you do
not define this macro, the default name is used, which is
`__mulsi3', a function defined in `gnulib'.
`UMULSI3_LIBCALL'
A C string constant giving the name of the function to call for
multiplication of one unsigned full-word by another. If you do
not define this macro, the default name is used, which is
`__umulsi3', a function defined in `gnulib'.
`DIVSI3_LIBCALL'
A C string constant giving the name of the function to call for
division of one signed full-word by another. If you do not
define this macro, the default name is used, which is
`__divsi3', a function defined in `gnulib'.
`UDIVSI3_LIBCALL'
A C string constant giving the name of the function to call for
division of one unsigned full-word by another. If you do not
define this macro, the default name is used, which is
`__udivsi3', a function defined in `gnulib'.
`MODSI3_LIBCALL'
A C string constant giving the name of the function to call for
the remainder in division of one signed full-word by another.
If you do not define this macro, the default name is used, which
is `__modsi3', a function defined in `gnulib'.
`UMODSI3_LIBCALL'
A C string constant giving the name of the function to call for
the remainder in division of one unsigned full-word by another.
If you do not define this macro, the default name is used, which
is `__umodsi3', a function defined in `gnulib'.
`TARGET_MEM_FUNCTIONS'
Define this macro if GNU CC should generate calls to the System
V (and ANSI C) library functions `memcpy' and `memset' rather
than the BSD functions `bcopy' and `bzero'.
File: gcc.info, Node: Addressing Modes, Next: Delayed Branch, Prev: Library Names, Up: Machine Macros
Addressing Modes
================
`HAVE_POST_INCREMENT'
Define this macro if the machine supports post-increment
addressing.
`HAVE_PRE_INCREMENT'
`HAVE_POST_DECREMENT'
`HAVE_PRE_DECREMENT'
Similar for other kinds of addressing.
`CONSTANT_ADDRESS_P (X)'
A C expression that is 1 if the RTX X is a constant whose value
is an integer. This includes integers whose values are not
explicitly known, such as `symbol_ref' and `label_ref'
expressions and `const' arithmetic expressions.
On most machines, this can be defined as `CONSTANT_P (X)', but a
few machines are more restrictive in which constant addresses
are supported.
`MAX_REGS_PER_ADDRESS'
A number, the maximum number of registers that can appear in a
valid memory address. Note that it is up to you to specify a
value equal to the maximum number that
`go_if_legitimate_address' would ever accept.
`GO_IF_LEGITIMATE_ADDRESS (MODE, X, LABEL)'
A C compound statement with a conditional `goto LABEL;' executed
if X (an RTX) is a legitimate memory address on the target
machine for a memory operand of mode MODE.
It usually pays to define several simpler macros to serve as
subroutines for this one. Otherwise it may be too complicated
to understand.
This macro must exist in two variants: a strict variant and a
non-strict one. The strict variant is used in the reload pass.
It must be defined so that any pseudo-register that has not been
allocated a hard register is considered a memory reference. In
contexts where some kind of register is required, a
pseudo-register with no hard register must be rejected.
The non-strict variant is used in other passes. It must be
defined to accept all pseudo-registers in every context where
some kind of register is required.
Compiler source files that want to use the strict variant of
this macro define the macro `REG_OK_STRICT'. You should use an
`#ifdef REG_OK_STRICT' conditional to define the strict variant
in that case and the non-strict variant otherwise.
Typically among the subroutines used to define
`GO_IF_LEGITIMATE_ADDRESS' are subroutines to check for
acceptable registers for various purposes (one for base
registers, one for index registers, and so on). Then only these
subroutine macros need have two variants; the higher levels of
macros may be the same whether strict or not.
Normally, constant addresses which are the sum of a `symbol_ref'
and an integer are stored inside a `const' RTX to mark them as
constant. Therefore, there is no need to recognize such sums as
legitimate addresses.
Usually `PRINT_OPERAND_ADDRESS' is not prepared to handle
constant sums that are not marked with `const'. It assumes
that a naked `plus' indicates indexing. If so, then you *must*
reject such naked constant sums as illegitimate addresses, so
that none of them will be given to `PRINT_OPERAND_ADDRESS'.
`REG_OK_FOR_BASE_P (X)'
A C expression that is nonzero if X (assumed to be a `reg' RTX)
is valid for use as a base register. For hard registers, it
should always accept those which the hardware permits and reject
the others. Whether the macro accepts or rejects pseudo
registers must be controlled by `REG_OK_STRICT' as described
above. This usually requires two variant definitions, of which
`REG_OK_STRICT' controls the one actually used.
`REG_OK_FOR_INDEX_P (X)'
A C expression that is nonzero if X (assumed to be a `reg' RTX)
is valid for use as an index register.
The difference between an index register and a base register is
that the index register may be scaled. If an address involves
the sum of two registers, neither one of them scaled, then
either one may be labeled the "base" and the other the "index";
but whichever labeling is used must fit the machine's
constraints of which registers may serve in each capacity. The
compiler will try both labelings, looking for one that is valid,
and will reload one or both registers only if neither labeling
works.
`LEGITIMIZE_ADDRESS (X, OLDX, MODE, WIN)'
A C compound statement that attempts to replace X with a valid
memory address for an operand of mode MODE. WIN will be a C
statement label elsewhere in the code; the macro definition may
use
GO_IF_LEGITIMATE_ADDRESS (MODE, X, WIN);
to avoid further processing if the address has become legitimate.
X will always be the result of a call to
`break_out_memory_refs', and OLDX will be the operand that was
given to that function to produce X.
The code generated by this macro should not alter the
substructure of X. If it transforms X into a more legitimate
form, it should assign X (which will always be a C variable) a
new value.
It is not necessary for this macro to come up with a legitimate
address. The compiler has standard ways of doing so in all
cases. In fact, it is safe for this macro to do nothing. But
often a machine-dependent strategy can generate better code.
`GO_IF_MODE_DEPENDENT_ADDRESS (ADDR, LABEL)'
A C statement or compound statement with a conditional `goto
LABEL;' executed if memory address X (an RTX) can have different
meanings depending on the machine mode of the memory reference
it is used for.
Autoincrement and autodecrement addresses typically have
mode-dependent effects because the amount of the increment or
decrement is the size of the operand being addressed. Some
machines have other mode-dependent addresses. Many RISC
machines have no mode-dependent addresses.
You may assume that ADDR is a valid address for the machine.
`LEGITIMATE_CONSTANT_P (X)'
A C expression that is nonzero if X is a legitimate constant for
an immediate operand on the target machine. You can assume that
either X is a `const_double' or it satisfies `CONSTANT_P', so
you need not check these things. In fact, `1' is a suitable
definition for this macro on machines where any `const_double'
is valid and anything `CONSTANT_P' is valid.
File: gcc.info, Node: Delayed Branch, Next: Condition Code, Prev: Addressing Modes, Up: Machine Macros
Parameters for Delayed Branch Optimization
==========================================
`HAVE_DELAYED_BRANCH'
Define this macro if the target machine has delayed branches,
that is, a branch does not take effect immediately, and the
actual branch instruction may be followed by one or more
instructions that will be issued before the PC is actually
changed.
If defined, this allows a special scheduling pass to be run
after the second jump optimization to attempt to reorder
instructions to exploit this. Defining this macro also requires
the definition of certain other macros described below.
`DBR_SLOTS_AFTER (INSN)'
This macro must be defined if `HAVE_DELAYED_BRANCH' is defined.
Its definition should be a C expression returning the number of
available delay slots following the instruction(s) output by the
pattern for INSN. The definition of "slot" is
machine-dependent, and may denote instructions, bytes, or
whatever.
`DBR_INSN_SLOTS (INSN)'
This macro must be defined if `HAVE_DELAYED_BRANCH' is defined.
It should be a C expression returning the number of slots
(typically the number of machine instructions) consumed by INSN.
You may assume that INSN is truly an insn, not a note, label,
barrier, dispatch table, `use', or `clobber'.
`DBR_INSN_ELIGIBLE_P (INSN, DINSN)'
A C expression whose value is non-zero if it is legitimate to
put INSN in the delay slot following DINSN.
You do not need to take account of data flow considerations in
the definition of this macro, because the delayed branch
optimizer always does that. This macro is needed only when
certain insns may not be placed in certain delay slots for
reasons not evident from the RTL expressions themselves. If
there are no such problems, you don't need to define this macro.
You may assume that INSN is truly an insn, not a note, label,
barrier, dispatch table, `use', or `clobber'. You may assume
that DINSN is a jump insn with a delay slot.
`DBR_OUTPUT_SEQEND(FILE)'
A C statement, to be executed after all slot-filler instructions
have been output. If necessary, call `dbr_sequence_length' to
determine the number of slots filled in a sequence (zero if not
currently outputting a sequence), to decide how many no-ops to
output, or whatever.
Don't define this macro if it has nothing to do, but it is
helpful in reading assembly output if the extent of the delay
sequence is made explicit (e.g. with white space).
Note that output routines for instructions with delay slots must
be prepared to deal with not being output as part of a sequence
(i.e. when the scheduling pass is not run, or when no slot
fillers could be found.) The variable `final_sequence' is null
when not processing a sequence, otherwise it contains the
`sequence' rtx being output.
File: gcc.info, Node: Condition Code, Next: Cross-compilation, Prev: Delayed Branch, Up: Machine Macros
Condition Code Information
==========================
The file `conditions.h' defines a variable `cc_status' to describe
how the condition code was computed (in case the interpretation of
the condition code depends on the instruction that it was set by).
This variable contains the RTL expressions on which the condition
code is currently based, and several standard flags.
Sometimes additional machine-specific flags must be defined in the
machine description header file. It can also add additional
machine-specific information by defining `CC_STATUS_MDEP'.
`CC_STATUS_MDEP'
C code for a data type which is used for declaring the `mdep'
component of `cc_status'. It defaults to `int'.
`CC_STATUS_MDEP_INIT'
A C expression to initialize the `mdep' field to "empty". The
default definition does nothing, since most machines don't use
the field anyway. If you want to use the field, you should
probably define this macro to initialize it.
`NOTICE_UPDATE_CC (EXP, INSN)'
A C compound statement to set the components of `cc_status'
appropriately for an insn INSN whose body is EXP. It is this
macro's responsibility to recognize insns that set the condition
code as a byproduct of other activity as well as those that
explicitly set `(cc0)'.
If there are insn that do not set the condition code but do
alter other machine registers, this macro must check to see
whether they invalidate the expressions that the condition code
is recorded as reflecting. For example, on the 68000, insns
that store in address registers do not set the condition code,
which means that usually `NOTICE_UPDATE_CC' can leave
`cc_status' unaltered for such insns. But suppose that the
previous insn set the condition code based on location
`a4@(102)' and the current insn stores a new value in `a4'.
Although the condition code is not changed by this, it will no
longer be true that it reflects the contents of `a4@(102)'.
Therefore, `NOTICE_UPDATE_CC' must alter `cc_status' in this
case to say that nothing is known about the condition code value.
The definition of `NOTICE_UPDATE_CC' must be prepared to deal
with the results of peephole optimization: insns whose patterns
are `parallel' RTXs containing various `reg', `mem' or constants
which are just the operands. The RTL structure of these insns
is not sufficient to indicate what the insns actually do. What
`NOTICE_UPDATE_CC' should do when it sees one is just to run
`CC_STATUS_INIT'.