V10/cmd/gcc/internals-6
File: internals, Node: Registers, Next: Register Classes, Prev: Storage Layout, Up: Machine Macros
Register Usage
==============
`FIRST_PSEUDO_REGISTER'
Number of hardware registers known to the compiler. They receive
numbers 0 through `FIRST_PSEUDO_REGISTER-1'; thus, the first pseudo
register's number really is assigned the number `FIRST_PSEUDO_REGISTER'.
`FIXED_REGISTERS'
An initializer that says which registers are used for fixed purposes
all throughout the compiled code and are therefore not available for
general allocation. These would include the stack pointer, the frame
pointer, the program counter on machines where that is considered one
of the addressable registers, and any other numbered register with a
standard use.
This information is expressed as a sequence of numbers, separated by
commas and surrounded by braces. The Nth number is 1 if register N is
fixed, 0 otherwise.
The table initialized from this macro, and the table initialized by
the following one, may be overridden at run time either automatically,
by the actions of the macro `CONDITIONAL_REGISTER_USAGE', or by the
user with the command options `-ffixed-REG', `-fcall-used-REG' and
`-fcall-saved-REG'.
`CALL_USED_REGISTERS'
Like `FIXED_REGISTERS' but has 1 for each register that is clobbered
(in general) by function calls as well as for fixed registers. This
macro therefore identifies the registers that are not available for
general allocation of values that must live across function calls.
If a register has 0 in `CALL_USED_REGISTERS', the compiler
automatically saves it on function entry and restores it on function
exit, if the register is used within the function.
`CONDITIONAL_REGISTER_USAGE'
Zero or more C statements that may conditionally modify two variables
`fixed_regs' and `call_used_regs' (both of type `char []') after they
have been initialized from the two preceding macros.
This is necessary in case the fixed or call-clobbered registers depend
on target flags.
You need not define this macro if it has no work to do.
`HARD_REGNO_REGS (REGNO, MODE)'
A C expression for the number of consecutive hard registers, starting
at register number REGNO, required to hold a value of mode MODE.
On a machine where all registers are exactly one word, a suitable
definition of this macro is
#define HARD_REGNO_NREGS(REGNO, MODE) \
((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) \
/ UNITS_PER_WORD))
`HARD_REGNO_MODE_OK (REGNO, MODE)'
A C expression that is nonzero if it is permissible to store a value
of mode MODE in hard register number REGNO (or in several registers
starting with that one). For a machine where all registers are
equivalent, a suitable definition is
#define HARD_REGNO_MODE_OK(REGNO, MODE) 1
It is not necessary for this macro to check for fixed register numbers
because the allocation mechanism considers them to be always occupied.
Many machines have special registers for floating point arithmetic.
Often people assume that floating point machine modes are allowed only
in floating point registers. This is not true. Any registers that
can hold integers can safely *hold* a floating point machine mode,
whether or not floating arithmetic can be done on it in those registers.
The true significance of special floating registers is rather than
non-floating-point machine modes *may not* go in those registers.
This is true if the floating registers normalize any value stored in
them, because storing a non-floating value there would garble it. If
the floating registers do not automatically normalize, if you can
store any bit pattern in one and retrieve it unchanged without a trap,
then any machine mode may go in a floating register and this macro
should say so.
Sometimes there are floating registers that are especially slow to
access, so that it is better to store a value in a stack frame than in
such a register if floating point arithmetic is not being done. As
long as the floating registers are not in class `GENERAL_REGS', they
will not be used unless some insn's constraint asks for one.
It is obligatory to support floating point `move' instructions into
and out of general registers, because unions and structures (which
have modes `SImode' or `DImode') can be in those registers and they
may have floating point members.
`MODES_TIEABLE_P (MODE1, MODE2)'
A C expression that is nonzero if it is desirable to choose register
allocation so as to avoid move instructions between a value of mode
MODE1 and a value of mode MODE2.
If `HARD_REGNO_MODE_OK (R, MODE1)' and `HARD_REGNO_MODE_OK (R, MODE2)'
are ever different for any R, then `MODES_TIEABLE_P (MODE1, MODE2)'
must be zero.
`PC_REGNUM'
If the program counter has a register number, define this as that
register number. Otherwise, do not define it.
`STACK_POINTER_REGNUM'
The register number of the stack pointer register, which must also be
a fixed register according to `FIXED_REGISTERS'. On many machines,
the hardware determines which register this is.
`FRAME_POINTER_REGNUM'
The register number of the frame pointer register, which is used to
access automatic variables in the stack frame. On some machines, the
hardware determines which register this is. On other machines, you
can choose any register you wish for this purpose.
`FRAME_POINTER_REQUIRED'
A C expression which is nonzero if a function must have and use a
frame pointer. This expression is evaluated in the reload pass, in
the function `reload', and it can in principle examine the current
function and decide according to the facts, but on most machines the
constant 0 or the constant 1 suffices. Use 0 when the machine allows
code to be generated with no frame pointer, and doing so saves some
time or space. Use 1 when there is no possible advantage to avoiding
a frame pointer.
In certain cases, the compiler does not know how to do without a frame
pointer. The compiler recognizes those cases and automatically gives
the function a frame pointer regardless of what
`FRAME_POINTER_REQUIRED' says. You don't need to worry about them.
In a function that does not require a frame pointer, the frame pointer
register can be allocated for ordinary usage, provided it is not
marked as a fixed register. See `FIXED_REGISTERS' for more information.
`ARG_POINTER_REGNUM'
The register number of the arg pointer register, which is used to
access the function's argument list. On some machines, this is the
same as the frame pointer register. On some machines, the hardware
determines which register this is. On other machines, you can choose
any register you wish for this purpose. It must in any case be a
fixed register according to `FIXED_REGISTERS'.
`STATIC_CHAIN_REGNUM'
The register number used for passing a function's static chain
pointer. This is needed for languages such as Pascal and Algol where
functions defined within other functions can access the local
variables of the outer functions; it is not currently used because C
does not provide this feature.
The static chain register need not be a fixed register.
`STRUCT_VALUE_REGNUM'
When a function's value's mode is `BLKmode', the value is not returned
according to `FUNCTION_VALUE'. Instead, the caller passes the address
of a block of memory in which the value should be stored.
`STRUCT_VALUE_REGNUM' is the register in which this address is passed.
File: internals, 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.
`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.
`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.
`INDEX_REG_CLASS'
A macro whose definition is the name of the class to which a valid
index register must belong.
`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 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. CLASS is always safe as a value. In fact,
the definition
#define PREFERRED_RELOAD_CLASS(X,CLASS) CLASS
is always safe. However, 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.
`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: internals, 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'
Offset from the argument pointer register to the first argument's
address.
`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.
`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.
`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 function values are sometimes returned.
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)
`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.
`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)'
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'.
`FUNCTION_ARG_ADVANCE (CUM, MODE, TYPE, NAMED)'
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_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.
`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.
`EXIT_IGNORES_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 for which frame
pointers are maintained. It is never possible to delete a final stack
adjustment in a function that has no frame pointer, and the compiler
knows this regardless of `EXIT_IGNORES_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.
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.
File: internals, Node: Library Names, Next: Addressing Modes, Prev: Stack Layout, Up: Machine Macros
Library Subroutine Names
========================
`UDIVSI3_LIBCALL'
A C string constant giving the name of the function to call for
division of a full-word by a full-word. If you do not define this
macro, the default name is used, which is `_udivsi3', 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 a full-word by a full-word. 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: internals, Node: Addressing Modes, Next: Misc, 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.
`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.
`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: internals, Node: Misc, Next: Condition Code, Prev: Addressing Modes, Up: Machine Macros
Miscellaneous Parameters
========================
`CASE_VECTOR_MODE'
An alias for a machine mode name. This is the machine mode that
elements of a jump-table should have.
`CASE_VECTOR_PC_RELATIVE'
Define this macro if jump-tables should contain relative addresses.
`CASE_DROPS_THROUGH'
Define this if control falls through a `case' insn when the index
value is out of range. This means the specified default-label is
actually ignored by the `case' insn proper.
`IMPLICIT_FIX_EXPR'
An alias for a tree code that should be used by default for conversion
of floating point values to fixed point. Normally, `FIX_ROUND_EXPR'
is used.
`FIXUNS_TRUNC_LIKE_FIX_TRUNC'
Define this macro if the same instructions that convert a floating
point number to a signed fixed point number also convert validly to an
unsigned one.
`EASY_DIV_EXPR'
An alias for a tree code that is the easiest kind of division to
compile code for in the general case. It may be `TRUNC_DIV_EXPR',
`FLOOR_DIV_EXPR', `CEIL_DIV_EXPR' or `ROUND_DIV_EXPR'. These four
division operators differ in how they round the result to an integer.
`EASY_DIV_EXPR' is used when it is permissible to use any of those
kinds of division and the choice should be made on the basis of
efficiency.
`DEFAULT_SIGNED_CHAR'
An expression whose value is 1 or 0, according to whether the type
`char' should be signed or unsigned by default. The user can always
override this default with the options `-fsigned-char' and
`-funsigned-char'.
`SCCS_DIRECTIVE'
Define this if the preprocessor should ignore `#sccs' directives with
no error message.
`MOVE_MAX'
The maximum number of bytes that a single instruction can move quickly
from memory to memory.
`INT_TYPE_SIZE'
A C expression for the size in bits of the type `int' on the target
machine.
`SLOW_BYTE_ACCESS'
Define this macro as a C expression which is nonzero if accessing less
than a word of memory (i.e. a `char' or a `short') is slow (requires
more than one instruction).
`SLOW_ZERO_EXTEND'
Define this macro if zero-extension (of a `char' or `short' to an
`int') can be done faster if the destination is a register that is
known to be zero.
If you define this macro, you must have instruction patterns that
recognize RTL structures like this:
(set (strict-low-part (subreg:QI (reg:SI ...) 0)) ...)
and likewise for `HImode'.
`SHIFT_COUNT_TRUNCATED'
Define this macro if shift instructions ignore all but the lowest few
bits of the shift count. It implies that a sign-extend or zero-extend
instruction for the shift count can be omitted.
`TRULY_NOOP_TRUNCATION (OUTPREC, INPREC)'
A C expression which is nonzero if on this machine it is safe to
``convert'' an integer of INPREC bits to one of OUTPREC bits (where
OUTPREC is smaller than INPREC) by merely operating on it as if it had
only OUTPREC bits.
On many machines, this expression can be 1.
`NO_FUNCTION_CSE'
Define this macro if it is as good or better to call a constant
function address than to call an address kept in a register.
`STORE_FLAG_VALUE'
A C expression for the value stored by a store-flag instruction
(`sCOND') when the condition is true. This is usually 1 or -1; it is
required to be an odd number.
Do not define `STORE_FLAG_VALUE' if the machine has no store-flag
instructions.
`Pmode'
An alias for the machine mode for pointers. Normally the definition
can be
#define Pmode SImode
`FUNCTION_MODE'
An alias for the machine mode used for memory references to functions
being called, in `call' RTL expressions. On most machines this should
be `QImode'.
`CONST_COST (X, CODE)'
A part of a C `switch' statement that describes the relative costs of
constant RTL expressions. It must contain `case' labels for
expression codes `const_int', `const', `symbol_ref', `label_ref' and
`const_double'. Each case must ultimately reach a `return' statement
to return the relative cost of the use of that kind of constant value
in an expression. The cost may depend on the precise value of the
constant, which is available for examination in X.
CODE is the expression code---redundant, since it can be obtained with
`GET_CODE (X)'.
`DOLLARS_IN_IDENTIFIERS'
Define this if the character `$' should be allowed in identifier names.
File: internals, Node: Condition Code, Next: Assembler Format, Prev: Misc, 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 for the initial value of the `mdep' field. It defaults
to 0.
`NOTICE_UPDATE_CC (EXP)'
A C compound statement to set the components of `cc_status'
appropriately for an 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.