Machine Modes
=============
A machine mode describes a size of data object and the
representation used for it. In the C code, machine modes are
represented by an enumeration type, `enum machine_mode', defined in
`machmode.def'. Each RTL expression has room for a machine mode and so
do certain kinds of tree expressions (declarations and types, to be
precise).
In debugging dumps and machine descriptions, the machine mode of an
RTL expression is written after the expression code with a colon to
separate them. The letters `mode' which appear at the end of each
machine mode name are omitted. For example, `(reg:SI 38)' is a `reg'
expression with machine mode `SImode'. If the mode is `VOIDmode', it
is not written at all.
Here is a table of machine modes. The term "byte" below refers to an
object of `BITS_PER_UNIT' bits (Note:Storage Layout).
`BImode'
"Bit" mode represents a single bit, for predicate registers.
`QImode'
"Quarter-Integer" mode represents a single byte treated as an
integer.
`HImode'
"Half-Integer" mode represents a two-byte integer.
`PSImode'
"Partial Single Integer" mode represents an integer which occupies
four bytes but which doesn't really use all four. On some
machines, this is the right mode to use for pointers.
`SImode'
"Single Integer" mode represents a four-byte integer.
`PDImode'
"Partial Double Integer" mode represents an integer which occupies
eight bytes but which doesn't really use all eight. On some
machines, this is the right mode to use for certain pointers.
`DImode'
"Double Integer" mode represents an eight-byte integer.
`TImode'
"Tetra Integer" (?) mode represents a sixteen-byte integer.
`OImode'
"Octa Integer" (?) mode represents a thirty-two-byte integer.
`SFmode'
"Single Floating" mode represents a single-precision (four byte)
floating point number.
`DFmode'
"Double Floating" mode represents a double-precision (eight byte)
floating point number.
`XFmode'
"Extended Floating" mode represents a triple-precision (twelve
byte) floating point number. This mode is used for IEEE extended
floating point. On some systems not all bits within these bytes
will actually be used.
`TFmode'
"Tetra Floating" mode represents a quadruple-precision (sixteen
byte) floating point number.
`CCmode'
"Condition Code" mode represents the value of a condition code,
which is a machine-specific set of bits used to represent the
result of a comparison operation. Other machine-specific modes
may also be used for the condition code. These modes are not used
on machines that use `cc0' (see Note:Condition Code).
`BLKmode'
"Block" mode represents values that are aggregates to which none of
the other modes apply. In RTL, only memory references can have
this mode, and only if they appear in string-move or vector
instructions. On machines which have no such instructions,
`BLKmode' will not appear in RTL.
`VOIDmode'
Void mode means the absence of a mode or an unspecified mode. For
example, RTL expressions of code `const_int' have mode `VOIDmode'
because they can be taken to have whatever mode the context
requires. In debugging dumps of RTL, `VOIDmode' is expressed by
the absence of any mode.
`SCmode, DCmode, XCmode, TCmode'
These modes stand for a complex number represented as a pair of
floating point values. The floating point values are in `SFmode',
`DFmode', `XFmode', and `TFmode', respectively.
`CQImode, CHImode, CSImode, CDImode, CTImode, COImode'
These modes stand for a complex number represented as a pair of
integer values. The integer values are in `QImode', `HImode',
`SImode', `DImode', `TImode', and `OImode', respectively.
The machine description defines `Pmode' as a C macro which expands
into the machine mode used for addresses. Normally this is the mode
whose size is `BITS_PER_WORD', `SImode' on 32-bit machines.
The only modes which a machine description must support are
`QImode', and the modes corresponding to `BITS_PER_WORD',
`FLOAT_TYPE_SIZE' and `DOUBLE_TYPE_SIZE'. The compiler will attempt to
use `DImode' for 8-byte structures and unions, but this can be
prevented by overriding the definition of `MAX_FIXED_MODE_SIZE'.
Alternatively, you can have the compiler use `TImode' for 16-byte
structures and unions. Likewise, you can arrange for the C type `short
int' to avoid using `HImode'.
Very few explicit references to machine modes remain in the compiler
and these few references will soon be removed. Instead, the machine
modes are divided into mode classes. These are represented by the
enumeration type `enum mode_class' defined in `machmode.h'. The
possible mode classes are:
`MODE_INT'
Integer modes. By default these are `QImode', `HImode', `SImode',
`DImode', and `TImode'.
`MODE_PARTIAL_INT'
The "partial integer" modes, `PSImode' and `PDImode'.
`MODE_FLOAT'
floating point modes. By default these are `SFmode', `DFmode',
`XFmode' and `TFmode'.
`MODE_COMPLEX_INT'
Complex integer modes. (These are not currently implemented).
`MODE_COMPLEX_FLOAT'
Complex floating point modes. By default these are `SCmode',
`DCmode', `XCmode', and `TCmode'.
`MODE_FUNCTION'
Algol or Pascal function variables including a static chain.
(These are not currently implemented).
`MODE_CC'
Modes representing condition code values. These are `CCmode' plus
any modes listed in the `EXTRA_CC_MODES' macro. Note:Jump
Patterns, also see Note:Condition Code.
`MODE_RANDOM'
This is a catchall mode class for modes which don't fit into the
above classes. Currently `VOIDmode' and `BLKmode' are in
`MODE_RANDOM'.
Here are some C macros that relate to machine modes:
`GET_MODE (X)'
Returns the machine mode of the RTX X.
`PUT_MODE (X, NEWMODE)'
Alters the machine mode of the RTX X to be NEWMODE.
`NUM_MACHINE_MODES'
Stands for the number of machine modes available on the target
machine. This is one greater than the largest numeric value of any
machine mode.
`GET_MODE_NAME (M)'
Returns the name of mode M as a string.
`GET_MODE_CLASS (M)'
Returns the mode class of mode M.
`GET_MODE_WIDER_MODE (M)'
Returns the next wider natural mode. For example, the expression
`GET_MODE_WIDER_MODE (QImode)' returns `HImode'.
`GET_MODE_SIZE (M)'
Returns the size in bytes of a datum of mode M.
`GET_MODE_BITSIZE (M)'
Returns the size in bits of a datum of mode M.
`GET_MODE_MASK (M)'
Returns a bitmask containing 1 for all bits in a word that fit
within mode M. This macro can only be used for modes whose
bitsize is less than or equal to `HOST_BITS_PER_INT'.
`GET_MODE_ALIGNMENT (M)'
Return the required alignment, in bits, for an object of mode M.
`GET_MODE_UNIT_SIZE (M)'
Returns the size in bytes of the subunits of a datum of mode M.
This is the same as `GET_MODE_SIZE' except in the case of complex
modes. For them, the unit size is the size of the real or
imaginary part.
`GET_MODE_NUNITS (M)'
Returns the number of units contained in a mode, i.e.,
`GET_MODE_SIZE' divided by `GET_MODE_UNIT_SIZE'.
`GET_CLASS_NARROWEST_MODE (C)'
Returns the narrowest mode in mode class C.
The global variables `byte_mode' and `word_mode' contain modes whose
classes are `MODE_INT' and whose bitsizes are either `BITS_PER_UNIT' or
`BITS_PER_WORD', respectively. On 32-bit machines, these are `QImode'
and `SImode', respectively.