#### 18.7.1 Basic Characteristics of Registers

Registers have various characteristics.

Macro: FIRST_PSEUDO_REGISTER

  Number of hardware registers known to the compiler. They receive numbers 0 through `FIRST_PSEUDO_REGISTER-1`; thus, the first pseudo register’s number really is assigned the number `FIRST_PSEUDO_REGISTER`.

Macro: FIXED_REGISTERS

  An initializer that says which registers are used for fixed purposes all throughout the compiled code and are therefore not available for general allocation. These would include the stack pointer, the frame pointer (except on machines where that can be used as a general register when no frame pointer is needed), the program counter on machines where that is considered one of the addressable registers, and any other numbered register with a standard use.

  This information is expressed as a sequence of numbers, separated by commas and surrounded by braces. The nth number is 1 if register n is fixed, 0 otherwise.

  The table initialized from this macro, and the table initialized by the following one, may be overridden at run time either automatically, by the actions of the macro `CONDITIONAL_REGISTER_USAGE`, or by the user with the command options `-ffixed-reg`, `-fcall-used-reg` and `-fcall-saved-reg`.

Macro: CALL_USED_REGISTERS

  Like `FIXED_REGISTERS` but has 1 for each register that is clobbered (in general) by function calls as well as for fixed registers. This macro therefore identifies the registers that are not available for general allocation of values that must live across function calls.

  If a register has 0 in `CALL_USED_REGISTERS`, the compiler automatically saves it on function entry and restores it on function exit, if the register is used within the function.

Macro: CALL_REALLY_USED_REGISTERS

  Like `CALL_USED_REGISTERS` except this macro doesn’t require that the entire set of `FIXED_REGISTERS` be included. (`CALL_USED_REGISTERS` must be a superset of `FIXED_REGISTERS`). This macro is optional. If not specified, it defaults to the value of `CALL_USED_REGISTERS`.

Target Hook: bool TARGET_HARD_REGNO_CALL_PART_CLOBBERED (rtx_insn *insn, unsigned int regno, machine_mode mode)

  This hook should return true if regno is partly call-saved and partly call-clobbered, and if a value of mode mode would be partly clobbered by call instruction insn. If insn is NULL then it should return true if any call could partly clobber the register. For example, if the low 32 bits of regno are preserved across a call but higher bits are clobbered, this hook should return true for a 64-bit mode but false for a 32-bit mode.

  The default implementation returns false, which is correct for targets that don’t have partly call-clobbered registers.

Target Hook: void TARGET_REMOVE_EXTRA_CALL_PRESERVED_REGS (rtx_insn *insn, HARD_REG_SET *used_regs)

  This hook removes registers from the set of call-clobbered registers in used_regs if, contrary to the default rules, something guarantees that ‘`insn`’ preserves those registers. For example, some targets support variant ABIs in which functions preserve more registers than normal functions would. Removing those extra registers from used_regs can lead to better register allocation.

  The default implementation does nothing, which is always safe. Defining the hook is purely an optimization.

Target Hook: rtx_insn * TARGET_RETURN_CALL_WITH_MAX_CLOBBERS (rtx_insn *call_1, rtx_insn *call_2)

  This hook returns a pointer to the call that partially clobbers the most registers. If a platform supports multiple ABIs where the registers that are partially clobbered may vary, this function compares two calls and returns a pointer to the one that clobbers the most registers. If both calls clobber the same registers, call_1 must be returned.

  The registers clobbered in different ABIs must be a proper subset or superset of all other ABIs. call_1 must always be a call insn, call_2 may be NULL or a call insn.

Target Hook: const char * TARGET_GET_MULTILIB_ABI_NAME (void)

  This hook returns name of multilib ABI name.

Target Hook: void TARGET_CONDITIONAL_REGISTER_USAGE (void)

  This hook may conditionally modify five variables `fixed_regs`, `call_used_regs`, `global_regs`, `reg_names`, and `reg_class_contents`, to take into account any dependence of these register sets on target flags. The first three of these are of type `char []` (interpreted as boolean vectors). `global_regs` is a `const char *[]`, and `reg_class_contents` is a `HARD_REG_SET`. Before the macro is called, `fixed_regs`, `call_used_regs`, `reg_class_contents`, and `reg_names` have been initialized from `FIXED_REGISTERS`, `CALL_USED_REGISTERS`, `REG_CLASS_CONTENTS`, and `REGISTER_NAMES`, respectively. `global_regs` has been cleared, and any `-ffixed-reg`, `-fcall-used-reg` and `-fcall-saved-reg` command options have been applied.

  If the usage of an entire class of registers depends on the target flags, you may indicate this to GCC by using this macro to modify `fixed_regs` and `call_used_regs` to 1 for each of the registers in the classes which should not be used by GCC. Also make `define_register_constraint`s return `NO_REGS` for constraints that shouldn’t be used.

  (However, if this class is not included in `GENERAL_REGS` and all of the insn patterns whose constraints permit this class are controlled by target switches, then GCC will automatically avoid using these registers when the target switches are opposed to them.)

Macro: INCOMING_REGNO (out)

  Define this macro if the target machine has register windows. This C expression returns the register number as seen by the called function corresponding to the register number out as seen by the calling function. Return out if register number out is not an outbound register.

Macro: OUTGOING_REGNO (in)

  Define this macro if the target machine has register windows. This C expression returns the register number as seen by the calling function corresponding to the register number in as seen by the called function. Return in if register number in is not an inbound register.

Macro: LOCAL_REGNO (regno)

  Define this macro if the target machine has register windows. This C expression returns true if the register is call-saved but is in the register window. Unlike most call-saved registers, such registers need not be explicitly restored on function exit or during non-local gotos.

Macro: PC_REGNUM

  If the program counter has a register number, define this as that register number. Otherwise, do not define it.