Constant Expression Types
=========================
The simplest RTL expressions are those that represent constant
values.
`(const_int I)'
This type of expression represents the integer value I. I is
customarily accessed with the macro `INTVAL' as in `INTVAL (EXP)',
which is equivalent to `XWINT (EXP, 0)'.
There is only one expression object for the integer value zero; it
is the value of the variable `const0_rtx'. Likewise, the only
expression for integer value one is found in `const1_rtx', the only
expression for integer value two is found in `const2_rtx', and the
only expression for integer value negative one is found in
`constm1_rtx'. Any attempt to create an expression of code
`const_int' and value zero, one, two or negative one will return
`const0_rtx', `const1_rtx', `const2_rtx' or `constm1_rtx' as
appropriate.
Similarly, there is only one object for the integer whose value is
`STORE_FLAG_VALUE'. It is found in `const_true_rtx'. If
`STORE_FLAG_VALUE' is one, `const_true_rtx' and `const1_rtx' will
point to the same object. If `STORE_FLAG_VALUE' is -1,
`const_true_rtx' and `constm1_rtx' will point to the same object.
`(const_double:M ADDR I0 I1 ...)'
Represents either a floating-point constant of mode M or an
integer constant too large to fit into `HOST_BITS_PER_WIDE_INT'
bits but small enough to fit within twice that number of bits (GCC
does not provide a mechanism to represent even larger constants).
In the latter case, M will be `VOIDmode'.
ADDR is used to contain the `mem' expression that corresponds to
the location in memory that at which the constant can be found. If
it has not been allocated a memory location, but is on the chain
of all `const_double' expressions in this compilation (maintained
using an undisplayed field), ADDR contains `const0_rtx'. If it is
not on the chain, ADDR contains `cc0_rtx'. ADDR is customarily
accessed with the macro `CONST_DOUBLE_MEM' and the chain field via
`CONST_DOUBLE_CHAIN'.
If M is `VOIDmode', the bits of the value are stored in I0 and I1.
I0 is customarily accessed with the macro `CONST_DOUBLE_LOW' and
I1 with `CONST_DOUBLE_HIGH'.
If the constant is floating point (regardless of its precision),
then the number of integers used to store the value depends on the
size of `REAL_VALUE_TYPE' (Note:Cross-compilation). The
integers represent a floating point number, but not precisely in
the target machine's or host machine's floating point format. To
convert them to the precise bit pattern used by the target
machine, use the macro `REAL_VALUE_TO_TARGET_DOUBLE' and friends
(Note:Data Output).
The macro `CONST0_RTX (MODE)' refers to an expression with value 0
in mode MODE. If mode MODE is of mode class `MODE_INT', it
returns `const0_rtx'. Otherwise, it returns a `CONST_DOUBLE'
expression in mode MODE. Similarly, the macro `CONST1_RTX (MODE)'
refers to an expression with value 1 in mode MODE and similarly
for `CONST2_RTX'.
`(const_string STR)'
Represents a constant string with value STR. Currently this is
used only for insn attributes (Note:Insn Attributes) since
constant strings in C are placed in memory.
`(symbol_ref:MODE SYMBOL)'
Represents the value of an assembler label for data. SYMBOL is a
string that describes the name of the assembler label. If it
starts with a `*', the label is the rest of SYMBOL not including
the `*'. Otherwise, the label is SYMBOL, usually prefixed with
`_'.
The `symbol_ref' contains a mode, which is usually `Pmode'.
Usually that is the only mode for which a symbol is directly valid.
`(label_ref LABEL)'
Represents the value of an assembler label for code. It contains
one operand, an expression, which must be a `code_label' that
appears in the instruction sequence to identify the place where
the label should go.
The reason for using a distinct expression type for code label
references is so that jump optimization can distinguish them.
`(const:M EXP)'
Represents a constant that is the result of an assembly-time
arithmetic computation. The operand, EXP, is an expression that
contains only constants (`const_int', `symbol_ref' and `label_ref'
expressions) combined with `plus' and `minus'. However, not all
combinations are valid, since the assembler cannot do arbitrary
arithmetic on relocatable symbols.
M should be `Pmode'.
`(high:M EXP)'
Represents the high-order bits of EXP, usually a `symbol_ref'.
The number of bits is machine-dependent and is normally the number
of bits specified in an instruction that initializes the high
order bits of a register. It is used with `lo_sum' to represent
the typical two-instruction sequence used in RISC machines to
reference a global memory location.
M should be `Pmode'.