Index: gcc/defaults.h
===================================================================
--- gcc/defaults.h	2010-07-04 10:13:13.000000000 +0100
+++ gcc/defaults.h	2010-07-04 10:13:17.000000000 +0100
@@ -1017,6 +1017,14 @@ #define STORE_FLAG_VALUE  1
 #define MOVE_MAX_PIECES   MOVE_MAX
 #endif
 
+#ifndef MAX_MOVE_MAX
+#define MAX_MOVE_MAX MOVE_MAX
+#endif
+
+#ifndef MIN_UNITS_PER_WORD
+#define MIN_UNITS_PER_WORD UNITS_PER_WORD
+#endif
+
 #ifndef STACK_POINTER_OFFSET
 #define STACK_POINTER_OFFSET    0
 #endif
Index: gcc/libgcc2.c
===================================================================
--- gcc/libgcc2.c	2010-07-04 10:12:55.000000000 +0100
+++ gcc/libgcc2.c	2010-07-04 10:12:57.000000000 +0100
@@ -36,10 +36,6 @@ #define ATTRIBUTE_HIDDEN  __attribute__
 #define ATTRIBUTE_HIDDEN
 #endif
 
-#ifndef MIN_UNITS_PER_WORD
-#define MIN_UNITS_PER_WORD UNITS_PER_WORD
-#endif
-
 /* Work out the largest "word" size that we can deal with on this target.  */
 #if MIN_UNITS_PER_WORD > 4
 # define LIBGCC2_MAX_UNITS_PER_WORD 8
Index: gcc/hard-reg-set.h
===================================================================
--- gcc/hard-reg-set.h	2010-07-04 10:07:43.000000000 +0100
+++ gcc/hard-reg-set.h	2010-07-04 10:14:30.000000000 +0100
@@ -582,11 +582,6 @@ #define EXECUTE_IF_SET_IN_HARD_REG_SET(S
 
 extern char global_regs[FIRST_PSEUDO_REGISTER];
 
-/* Call used hard registers which can not be saved because there is no
-   insn for this.  */
-
-extern HARD_REG_SET no_caller_save_reg_set;
-
 struct target_hard_regs {
   /* Indexed by hard register number, contains 1 for registers
      that are fixed use (stack pointer, pc, frame pointer, etc.;.
@@ -622,6 +617,10 @@ struct target_hard_regs {
      with the local stack frame are safe, but scant others.  */
   HARD_REG_SET x_regs_invalidated_by_call;
 
+  /* Call used hard registers which can not be saved because there is no
+     insn for this.  */
+  HARD_REG_SET x_no_caller_save_reg_set;
+
   /* Table of register numbers in the order in which to try to use them.  */
   int x_reg_alloc_order[FIRST_PSEUDO_REGISTER];
 
@@ -670,6 +669,8 @@ #define call_fixed_reg_set \
   (this_target_hard_regs->x_call_fixed_reg_set)
 #define regs_invalidated_by_call \
   (this_target_hard_regs->x_regs_invalidated_by_call)
+#define no_caller_save_reg_set \
+  (this_target_hard_regs->x_no_caller_save_reg_set)
 #define reg_alloc_order \
   (this_target_hard_regs->x_reg_alloc_order)
 #define inv_reg_alloc_order \
Index: gcc/reload.h
===================================================================
--- gcc/reload.h	2010-07-04 10:05:00.000000000 +0100
+++ gcc/reload.h	2010-07-04 10:06:56.000000000 +0100
@@ -171,6 +171,17 @@ struct target_reload {
      means that (MEM (MEM (REG n))) is also valid if (REG n) does not get
      a hard register.  */
   bool x_spill_indirect_levels;
+
+  /* True if caller-save has been reinitialized.  */
+  bool x_caller_save_initialized_p;
+
+  /* Modes for each hard register that we can save.  The smallest mode is wide
+     enough to save the entire contents of the register.  When saving the
+     register because it is live we first try to save in multi-register modes.
+     If that is not possible the save is done one register at a time.  */
+  enum machine_mode (x_regno_save_mode
+		     [FIRST_PSEUDO_REGISTER]
+		     [MAX_MOVE_MAX / MIN_UNITS_PER_WORD + 1]);
 };
 
 extern struct target_reload default_target_reload;
@@ -184,6 +195,8 @@ #define indirect_symref_ok \
   (this_target_reload->x_indirect_symref_ok)
 #define double_reg_address_ok \
   (this_target_reload->x_double_reg_address_ok)
+#define caller_save_initialized_p \
+  (this_target_reload->x_caller_save_initialized_p)
 
 extern GTY (()) VEC(rtx,gc) *reg_equiv_memory_loc_vec;
 extern rtx *reg_equiv_constant;
@@ -377,9 +390,6 @@ extern void calculate_elim_costs_all_ins
 /* Deallocate the reload register used by reload number R.  */
 extern void deallocate_reload_reg (int r);
 
-/* True if caller-save has been reinitialized.  */
-extern bool caller_save_initialized_p;
-
 /* Functions in caller-save.c:  */
 
 /* Initialize for caller-save.  */
Index: gcc/caller-save.c
===================================================================
--- gcc/caller-save.c	2010-07-04 10:10:33.000000000 +0100
+++ gcc/caller-save.c	2010-07-04 10:12:41.000000000 +0100
@@ -40,30 +40,10 @@ Software Foundation; either version 3, o
 #include "output.h"
 #include "ggc.h"
 
-/* True if caller-save has been initialized.  */
-bool caller_save_initialized_p;
-
-/* Call used hard registers which can not be saved because there is no
-   insn for this.  */
-HARD_REG_SET no_caller_save_reg_set;
-
-#ifndef MAX_MOVE_MAX
-#define MAX_MOVE_MAX MOVE_MAX
-#endif
-
-#ifndef MIN_UNITS_PER_WORD
-#define MIN_UNITS_PER_WORD UNITS_PER_WORD
-#endif
-
 #define MOVE_MAX_WORDS (MOVE_MAX / UNITS_PER_WORD)
 
-/* Modes for each hard register that we can save.  The smallest mode is wide
-   enough to save the entire contents of the register.  When saving the
-   register because it is live we first try to save in multi-register modes.
-   If that is not possible the save is done one register at a time.  */
-
-static enum machine_mode
-  regno_save_mode[FIRST_PSEUDO_REGISTER][MAX_MOVE_MAX / MIN_UNITS_PER_WORD + 1];
+#define regno_save_mode \
+  (this_target_reload->x_regno_save_mode)
 
 /* For each hard register, a place on the stack where it can be saved,
    if needed.  */