How Values Fit in Registers
---------------------------
This section discusses the macros that describe which kinds of values
(specifically, which machine modes) each register can hold, and how many
consecutive registers are needed for a given mode.
`HARD_REGNO_NREGS (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))
`ALTER_HARD_SUBREG (TGT_MODE, WORD, SRC_MODE, REGNO)'
A C expression that returns an adjusted hard register number for
(subreg:TGT_MODE (reg:SRC_MODE REGNO) WORD)
This may be needed if the target machine has mixed sized big-endian
registers, like Sparc v9.
`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
You need not include code to check for the numbers of fixed
registers, because the allocation mechanism considers them to be
always occupied.
On some machines, double-precision values must be kept in even/odd
register pairs. You can implement that by defining this macro to
reject odd register numbers for such modes.
The minimum requirement for a mode to be OK in a register is that
the `movMODE' instruction pattern support moves between the
register and other hard register in the same class and that moving
a value into the register and back out not alter it.
Since the same instruction used to move `word_mode' will work for
all narrower integer modes, it is not necessary on any machine for
`HARD_REGNO_MODE_OK' to distinguish between these modes, provided
you define patterns `movhi', etc., to take advantage of this. This
is useful because of the interaction between `HARD_REGNO_MODE_OK'
and `MODES_TIEABLE_P'; it is very desirable for all integer modes
to be tieable.
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. Integer move instructions can be used
to move the values.
On some machines, though, the converse is true: fixed-point machine
modes may not go in floating registers. This is true if the
floating registers normalize any value stored in them, because
storing a non-floating value there would garble it. In this case,
`HARD_REGNO_MODE_OK' should reject fixed-point machine modes in
floating registers. But 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, so you can define this macro to say
so.
The primary significance of special floating registers is rather
that they are the registers acceptable in floating point arithmetic
instructions. However, this is of no concern to
`HARD_REGNO_MODE_OK'. You handle it by writing the proper
constraints for those instructions.
On some machines, the floating registers 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 pattern's
constraint asks for one.
`MODES_TIEABLE_P (MODE1, MODE2)'
A C expression that is nonzero if a value of mode MODE1 is
accessible in mode MODE2 without copying.
If `HARD_REGNO_MODE_OK (R, MODE1)' and `HARD_REGNO_MODE_OK (R,
MODE2)' are always the same for any R, then `MODES_TIEABLE_P
(MODE1, MODE2)' should be nonzero. If they differ for any R, you
should define this macro to return zero unless some other
mechanism ensures the accessibility of the value in a narrower
mode.
You should define this macro to return nonzero in as many cases as
possible since doing so will allow GNU CC to perform better
register allocation.
`AVOID_CCMODE_COPIES'
Define this macro if the compiler should avoid copies to/from
`CCmode' registers. You should only define this macro if support
fo copying to/from `CCmode' is incomplete.