GNU Info
(gcc-295.info)Addressing Modes
Addressing Modes
================
This is about addressing modes.
`HAVE_POST_INCREMENT'
A C expression that is nonzero 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 which is a
valid address. On most machines, this can be defined as
`CONSTANT_P (X)', but a few machines are more restrictive in which
constant addresses are supported.
`CONSTANT_P' accepts integer-values expressions whose values are
not explicitly known, such as `symbol_ref', `label_ref', and
`high' expressions and `const' arithmetic expressions, in addition
to `const_int' and `const_double' expressions.
`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.
Subroutines to check for acceptable registers for various purposes
(one for base registers, one for index registers, and so on) are
typically among the subroutines used to define
`GO_IF_LEGITIMATE_ADDRESS'. 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
specifically as legitimate addresses. Normally you would simply
recognize any `const' as legitimate.
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'.
On some machines, whether a symbolic address is legitimate depends
on the section that the address refers to. On these machines,
define the macro `ENCODE_SECTION_INFO' to store the information
into the `symbol_ref', and then check for it here. When you see a
`const', you will have to look inside it to find the `symbol_ref'
in order to determine the section. Note: Assembler Format.
The best way to modify the name string is by adding text to the
beginning, with suitable punctuation to prevent any ambiguity.
Allocate the new name in `saveable_obstack'. You will have to
modify `ASM_OUTPUT_LABELREF' to remove and decode the added text
and output the name accordingly, and define `STRIP_NAME_ENCODING'
to access the original name string.
You can check the information stored here into the `symbol_ref' in
the definitions of the macros `GO_IF_LEGITIMATE_ADDRESS' and
`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_MODE_OK_FOR_BASE_P (X, MODE)'
A C expression that is just like `REG_OK_FOR_BASE_P', except that
that expression may examine the mode of the memory reference in
MODE. You should define this macro if the mode of the memory
reference affects whether a register may be used as a base
register. If you define this macro, the compiler will use it
instead of `REG_OK_FOR_BASE_P'.
`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.
`LEGITIMIZE_RELOAD_ADDRESS (X, MODE, OPNUM, TYPE, IND_LEVELS, WIN)'
A C compound statement that attempts to replace X, which is an
address that needs reloading, with a valid memory address for an
operand of mode MODE. WIN will be a C statement label elsewhere
in the code. It is not necessary to define this macro, but it
might be useful for performance reasons.
For example, on the i386, it is sometimes possible to use a single
reload register instead of two by reloading a sum of two pseudo
registers into a register. On the other hand, for number of RISC
processors offsets are limited so that often an intermediate
address needs to be generated in order to address a stack slot.
By defining LEGITIMIZE_RELOAD_ADDRESS appropriately, the
intermediate addresses generated for adjacent some stack slots can
be made identical, and thus be shared.
*Note*: This macro should be used with caution. It is necessary
to know something of how reload works in order to effectively use
this, and it is quite easy to produce macros that build in too
much knowledge of reload internals.
*Note*: This macro must be able to reload an address created by a
previous invocation of this macro. If it fails to handle such
addresses then the compiler may generate incorrect code or abort.
The macro definition should use `push_reload' to indicate parts
that need reloading; OPNUM, TYPE and IND_LEVELS are usually
suitable to be passed unaltered to `push_reload'.
The code generated by this macro must 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. This
also applies to parts that you change indirectly by calling
`push_reload'.
The macro definition may use `strict_memory_address_p' to test if
the address has become legitimate.
If you want to change only a part of X, one standard way of doing
this is to use `copy_rtx'. Note, however, that is unshares only a
single level of rtl. Thus, if the part to be changed is not at the
top level, you'll need to replace first the top leve It is not
necessary for this macro to come up with a legitimate address;
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 or if the address is valid for some modes but not
others.
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 X
satisfies `CONSTANT_P', so you need not check this. In fact, `1'
is a suitable definition for this macro on machines where anything
`CONSTANT_P' is valid.
automatically generated by info2www version 1.2.2.9