+extern int num_not_at_initial_offset;
+
+#if defined SET_HARD_REG_BIT && defined CLEAR_REG_SET
+/* This structure describes instructions which are relevant for reload.
+ Apart from all regular insns, this also includes CODE_LABELs, since they
+ must be examined for register elimination. */
+struct insn_chain
+{
+ /* Links to the neighbor instructions. */
+ struct insn_chain *next, *prev;
+
+ /* Link through a chains set up by calculate_needs_all_insns, containing
+ all insns that need reloading. */
+ struct insn_chain *next_need_reload;
+
+ /* The rtx of the insn. */
+ rtx insn;
+
+ /* The basic block this insn is in. */
+ int block;
+
+ /* Nonzero if find_reloads said the insn requires reloading. */
+ unsigned int need_reload:1;
+ /* Nonzero if find_reloads needs to be run during reload_as_needed to
+ perform modifications on any operands. */
+ unsigned int need_operand_change:1;
+ /* Nonzero if eliminate_regs_in_insn said it requires eliminations. */
+ unsigned int need_elim:1;
+ /* Nonzero if this insn was inserted by perform_caller_saves. */
+ unsigned int is_caller_save_insn:1;
+
+ /* Register life information: record all live hard registers, and
+ all live pseudos that have a hard register. This set also
+ contains pseudos spilled by IRA. */
+ bitmap_head live_throughout;
+ bitmap_head dead_or_set;
+
+ /* Copies of the global variables computed by find_reloads. */
+ struct reload *rld;
+ int n_reloads;
+
+ /* Indicates which registers have already been used for spills. */
+ HARD_REG_SET used_spill_regs;
+};
+
+/* A chain of insn_chain structures to describe all non-note insns in
+ a function. */
+extern struct insn_chain *reload_insn_chain;
+
+/* Allocate a new insn_chain structure. */
+extern struct insn_chain *new_insn_chain (void);
+#endif
+
+#if defined SET_HARD_REG_BIT
+extern void compute_use_by_pseudos (HARD_REG_SET *, bitmap);
+#endif
+
+/* Functions from reload.c: */
+
+extern reg_class_t secondary_reload_class (bool, reg_class_t,
+ enum machine_mode, rtx);
+
+#ifdef GCC_INSN_CODES_H
+extern enum reg_class scratch_reload_class (enum insn_code);
+#endif
+
+/* Return a memory location that will be used to copy X in mode MODE.
+ If we haven't already made a location for this mode in this insn,
+ call find_reloads_address on the location being returned. */
+extern rtx get_secondary_mem (rtx, enum machine_mode, int, enum reload_type);
+
+/* Clear any secondary memory locations we've made. */
+extern void clear_secondary_mem (void);
+
+/* Transfer all replacements that used to be in reload FROM to be in
+ reload TO. */
+extern void transfer_replacements (int, int);
+
+/* IN_RTX is the value loaded by a reload that we now decided to inherit,
+ or a subpart of it. If we have any replacements registered for IN_RTX,
+ cancel the reloads that were supposed to load them.
+ Return nonzero if we canceled any reloads. */
+extern int remove_address_replacements (rtx in_rtx);
+
+/* Like rtx_equal_p except that it allows a REG and a SUBREG to match
+ if they are the same hard reg, and has special hacks for
+ autoincrement and autodecrement. */
+extern int operands_match_p (rtx, rtx);
+
+/* Return 1 if altering OP will not modify the value of CLOBBER. */
+extern int safe_from_earlyclobber (rtx, rtx);
+
+/* Search the body of INSN for values that need reloading and record them
+ with push_reload. REPLACE nonzero means record also where the values occur
+ so that subst_reloads can be used. */
+extern int find_reloads (rtx, int, int, int, short *);
+
+/* Compute the sum of X and Y, making canonicalizations assumed in an
+ address, namely: sum constant integers, surround the sum of two
+ constants with a CONST, put the constant as the second operand, and
+ group the constant on the outermost sum. */
+extern rtx form_sum (enum machine_mode, rtx, rtx);
+
+/* Substitute into the current INSN the registers into which we have reloaded
+ the things that need reloading. */
+extern void subst_reloads (rtx);
+
+/* Make a copy of any replacements being done into X and move those copies
+ to locations in Y, a copy of X. We only look at the highest level of
+ the RTL. */
+extern void copy_replacements (rtx, rtx);
+
+/* Change any replacements being done to *X to be done to *Y */
+extern void move_replacements (rtx *x, rtx *y);
+
+/* If LOC was scheduled to be replaced by something, return the replacement.
+ Otherwise, return *LOC. */
+extern rtx find_replacement (rtx *);
+
+/* Nonzero if modifying X will affect IN. */
+extern int reg_overlap_mentioned_for_reload_p (rtx, rtx);
+
+/* Check the insns before INSN to see if there is a suitable register
+ containing the same value as GOAL. */
+extern rtx find_equiv_reg (rtx, rtx, enum reg_class, int, short *,
+ int, enum machine_mode);
+
+/* Return 1 if register REGNO is the subject of a clobber in insn INSN. */
+extern int regno_clobbered_p (unsigned int, rtx, enum machine_mode, int);
+
+/* Return 1 if X is an operand of an insn that is being earlyclobbered. */
+extern int earlyclobber_operand_p (rtx);
+
+/* Record one reload that needs to be performed. */
+extern int push_reload (rtx, rtx, rtx *, rtx *, enum reg_class,
+ enum machine_mode, enum machine_mode,
+ int, int, int, enum reload_type);
+
+/* Functions in reload1.c: */
+
+/* Initialize the reload pass once per compilation. */
+extern void init_reload (void);
+
+/* The reload pass itself. */
+extern bool reload (rtx, int);
+
+/* Mark the slots in regs_ever_live for the hard regs
+ used by pseudo-reg number REGNO. */
+extern void mark_home_live (int);
+
+/* Scan X and replace any eliminable registers (such as fp) with a
+ replacement (such as sp), plus an offset. */
+extern rtx eliminate_regs (rtx, enum machine_mode, rtx);
+extern bool elimination_target_reg_p (rtx);
+
+/* Called from the register allocator to estimate costs of eliminating
+ invariant registers. */
+extern void calculate_elim_costs_all_insns (void);
+
+/* Deallocate the reload register used by reload number R. */
+extern void deallocate_reload_reg (int r);
+
+/* Functions in caller-save.c: */
+
+/* Initialize for caller-save. */
+extern void init_caller_save (void);
+
+/* Initialize save areas by showing that we haven't allocated any yet. */
+extern void init_save_areas (void);
+
+/* Allocate save areas for any hard registers that might need saving. */
+extern void setup_save_areas (void);
+
+/* Find the places where hard regs are live across calls and save them. */
+extern void save_call_clobbered_regs (void);
+
+/* Replace (subreg (reg)) with the appropriate (reg) for any operands. */
+extern void cleanup_subreg_operands (rtx);