+/* Functions from reload.c: */
+
+extern enum reg_class secondary_reload_class (bool, enum reg_class,
+ 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 (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 postreload.c: */
+extern void reload_cse_regs (rtx);
+
+/* Functions in reload1.c: */
+
+/* Initialize the reload pass once per compilation. */
+extern void init_reload (void);
+
+/* The reload pass itself. */
+extern int 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);
+
+/* 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);
+
+/* Debugging support. */
+extern void debug_reload_to_stream (FILE *);
+extern void debug_reload (void);
+
+/* Compute the actual register we should reload to, in case we're
+ reloading to/from a register that is wider than a word. */
+extern rtx reload_adjust_reg_for_mode (rtx, enum machine_mode);