-/* 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. On many machines, the following
- definition is safe:
-
- #define PREFERRED_RELOAD_CLASS(X,CLASS) CLASS
-
- 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.
-
- If X is a `const_double', by returning `NO_REGS' you can force X
- into a memory constant. This is useful on certain machines where
- immediate floating values cannot be loaded into certain kinds of
- registers. */
-/* `PREFERRED_OUTPUT_RELOAD_CLASS (X, CLASS)'
- Like `PREFERRED_RELOAD_CLASS', but for output reloads instead of
- input reloads. If you don't define this macro, the default is to
- use CLASS, unchanged. */
-
-/* `LIMIT_RELOAD_CLASS (MODE, CLASS)'
- A C expression that places additional restrictions on the register
- class to use when it is necessary to be able to hold a value of
- mode MODE in a reload register for which class CLASS would
- ordinarily be used.
-
- Unlike `PREFERRED_RELOAD_CLASS', this macro should be used when
- there are certain modes that simply can't go in certain reload
- classes.
-
- The value is a register class; perhaps CLASS, or perhaps another,
- smaller class.
-
- Don't define this macro unless the target machine has limitations
- which require the macro to do something nontrivial. */
-
-/* SECONDARY_INPUT_RELOAD_CLASS(CLASS, MODE, X)
- `SECONDARY_RELOAD_CLASS (CLASS, MODE, X)'
- `SECONDARY_OUTPUT_RELOAD_CLASS (CLASS, MODE, X)'
- Many machines have some registers that cannot be copied directly
- to or from memory or even from other types of registers. An
- example is the `MQ' register, which on most machines, can only be
- copied to or from general registers, but not memory. Some
- machines allow copying all registers to and from memory, but
- require a scratch register for stores to some memory locations
- (e.g., those with symbolic address on the RT, and those with
- certain symbolic address on the Sparc when compiling PIC). In
- some cases, both an intermediate and a scratch register are
- required.
-
- You should define these macros to indicate to the reload phase
- that it may need to allocate at least one register for a reload in
- addition to the register to contain the data. Specifically, if
- copying X to a register CLASS in MODE requires an intermediate
- register, you should define `SECONDARY_INPUT_RELOAD_CLASS' to
- return the largest register class all of whose registers can be
- used as intermediate registers or scratch registers.
-
- If copying a register CLASS in MODE to X requires an intermediate
- or scratch register, `SECONDARY_OUTPUT_RELOAD_CLASS' should be
- defined to return the largest register class required. If the
- requirements for input and output reloads are the same, the macro
- `SECONDARY_RELOAD_CLASS' should be used instead of defining both
- macros identically.
-
- The values returned by these macros are often `GENERAL_REGS'.
- Return `NO_REGS' if no spare register is needed; i.e., if X can be
- directly copied to or from a register of CLASS in MODE without
- requiring a scratch register. Do not define this macro if it
- would always return `NO_REGS'.
-
- If a scratch register is required (either with or without an
- intermediate register), you should define patterns for
- `reload_inM' or `reload_outM', as required (*note Standard
- Names::.. These patterns, which will normally be implemented with
- a `define_expand', should be similar to the `movM' patterns,
- except that operand 2 is the scratch register.
-
- Define constraints for the reload register and scratch register
- that contain a single register class. If the original reload
- register (whose class is CLASS) can meet the constraint given in
- the pattern, the value returned by these macros is used for the
- class of the scratch register. Otherwise, two additional reload
- registers are required. Their classes are obtained from the
- constraints in the insn pattern.
-
- X might be a pseudo-register or a `subreg' of a pseudo-register,
- which could either be in a hard register or in memory. Use
- `true_regnum' to find out; it will return -1 if the pseudo is in
- memory and the hard register number if it is in a register.
-
- These macros should not be used in the case where a particular
- class of registers can only be copied to memory and not to another
- class of registers. In that case, secondary reload registers are
- not needed and would not be helpful. Instead, a stack location
- must be used to perform the copy and the `movM' pattern should use
- memory as an intermediate storage. This case often occurs between
- floating-point and general registers. */
-
-/* `SECONDARY_MEMORY_NEEDED (CLASS1, CLASS2, M)'
- Certain machines have the property that some registers cannot be
- copied to some other registers without using memory. Define this
- macro on those machines to be a C expression that is non-zero if
- objects of mode M in registers of CLASS1 can only be copied to
- registers of class CLASS2 by storing a register of CLASS1 into
- memory and loading that memory location into a register of CLASS2.
-
- Do not define this macro if its value would always be zero.
-
- `SECONDARY_MEMORY_NEEDED_RTX (MODE)'
- Normally when `SECONDARY_MEMORY_NEEDED' is defined, the compiler
- allocates a stack slot for a memory location needed for register
- copies. If this macro is defined, the compiler instead uses the
- memory location defined by this macro.
-
- Do not define this macro if you do not define
- `SECONDARY_MEMORY_NEEDED'. */