gcc/

	* hard-reg-set.h (target_hard_regs): New structure.
	(default_target_hard_regs): Declare.
	(this_target_hard_regs): Declare as a variable or define as a macro.
	(fixed_regs, fixed_reg_set, call_used_regs, call_really_used_regs)
	(call_used_reg_set, call_fixed_reg_set, regs_invalidated_by_call)
	(reg_alloc_order, inv_reg_alloc_order, reg_class_contents)
	(reg_class_size, reg_class_subclasses, reg_class_subunion)
	(reg_class_superunion, reg_names): Redefine as macros.
	* reginfo.c (fixed_regs, fixed_reg_set, call_used_regs)
	(call_used_reg_set, call_really_used_regs, call_fixed_reg_set)
	(regs_invalidated_by_call, reg_alloc_order, inv_reg_alloc_order)
	(reg_class_contents, reg_class_size, reg_class_subclasses)
	(reg_class_subunion, reg_class_superunion, reg_names): Delete.
	(default_target_hard_regs): New variable
	(this_target_hard_regs, initial_call_really_used_regs)
	(initial_reg_alloc_order): New conditional variables.
	(initial_reg_names): New variable.
	(init_reg_sets): Assert that initial_call_really_used_regs,
	initial_reg_alloc_order and initial_reg_names
	are all the same size as their variable counterparts.  Use them to
	initialize those counterparts.
	* target-globals.h (this_target_hard_regs): Declare.
	(target_globals): Add a hard_regs field.
	(restore_target_globals): Copy the hard_regs field to
	this_target_hard_regs.
	* target-globals.c: Include hard-reg-set.h.
	(default_target_globals): Initialize the hard_regs field.
	(save_target_globals): Likewise.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@162089 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 89 insertions, 65 deletions

diff --git a/gcc/hard-reg-set.h b/gcc/hard-reg-set.h
index 1e797285523..c0379b3bea7 100644
--- a/gcc/hard-reg-set.h
+++ b/gcc/hard-reg-set.h
@@ -576,98 +576,122 @@ hard_reg_set_iter_next (hard_reg_set_iterator *iter, unsigned *regno)
 /* Define some standard sets of registers.  */
 
 /* Indexed by hard register number, contains 1 for registers
-   that are fixed use (stack pointer, pc, frame pointer, etc.).
-   These are the registers that cannot be used to allocate
-   a pseudo reg whose life does not cross calls.  */
-
-extern char fixed_regs[FIRST_PSEUDO_REGISTER];
-
-/* The same info as a HARD_REG_SET.  */
-
-extern HARD_REG_SET fixed_reg_set;
-
-/* Indexed by hard register number, contains 1 for registers
-   that are fixed use or are clobbered by function calls.
-   These are the registers that cannot be used to allocate
-   a pseudo reg whose life crosses calls.  */
-
-extern char call_used_regs[FIRST_PSEUDO_REGISTER];
-
-#ifdef CALL_REALLY_USED_REGISTERS
-extern char call_really_used_regs[];
-#endif
-
-/* The same info as a HARD_REG_SET.  */
-
-extern HARD_REG_SET call_used_reg_set;
-
-/* Contains registers that are fixed use -- i.e. in fixed_reg_set -- or
-   a function value return register or TARGET_STRUCT_VALUE_RTX or
-   STATIC_CHAIN_REGNUM.  These are the registers that cannot hold quantities
-   across calls even if we are willing to save and restore them.  */
-
-extern HARD_REG_SET call_fixed_reg_set;
-
-/* Indexed by hard register number, contains 1 for registers
    that are being used for global register decls.
    These must be exempt from ordinary flow analysis
    and are also considered fixed.  */
 
 extern char global_regs[FIRST_PSEUDO_REGISTER];
 
-/* Contains 1 for registers that are set or clobbered by calls.  */
-/* ??? Ideally, this would be just call_used_regs plus global_regs, but
-   for someone's bright idea to have call_used_regs strictly include
-   fixed_regs.  Which leaves us guessing as to the set of fixed_regs
-   that are actually preserved.  We know for sure that those associated
-   with the local stack frame are safe, but scant others.  */
-
-extern HARD_REG_SET regs_invalidated_by_call;
-
 /* 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;
 
-#ifdef REG_ALLOC_ORDER
-/* Table of register numbers in the order in which to try to use them.  */
+struct target_hard_regs {
+  /* Indexed by hard register number, contains 1 for registers
+     that are fixed use (stack pointer, pc, frame pointer, etc.;.
+     These are the registers that cannot be used to allocate
+     a pseudo reg whose life does not cross calls.  */
+  char x_fixed_regs[FIRST_PSEUDO_REGISTER];
 
-extern int reg_alloc_order[FIRST_PSEUDO_REGISTER];
+  /* The same info as a HARD_REG_SET.  */
+  HARD_REG_SET x_fixed_reg_set;
 
-/* The inverse of reg_alloc_order.  */
+  /* Indexed by hard register number, contains 1 for registers
+     that are fixed use or are clobbered by function calls.
+     These are the registers that cannot be used to allocate
+     a pseudo reg whose life crosses calls.  */
+  char x_call_used_regs[FIRST_PSEUDO_REGISTER];
 
-extern int inv_reg_alloc_order[FIRST_PSEUDO_REGISTER];
-#endif
+  char x_call_really_used_regs[FIRST_PSEUDO_REGISTER];
+
+  /* The same info as a HARD_REG_SET.  */
+  HARD_REG_SET x_call_used_reg_set;
 
-/* For each reg class, a HARD_REG_SET saying which registers are in it.  */
+  /* Contains registers that are fixed use -- i.e. in fixed_reg_set -- or
+     a function value return register or TARGET_STRUCT_VALUE_RTX or
+     STATIC_CHAIN_REGNUM.  These are the registers that cannot hold quantities
+     across calls even if we are willing to save and restore them.  */
+  HARD_REG_SET x_call_fixed_reg_set;
 
-extern HARD_REG_SET reg_class_contents[N_REG_CLASSES];
+  /* Contains 1 for registers that are set or clobbered by calls.  */
+  /* ??? Ideally, this would be just call_used_regs plus global_regs, but
+     for someone's bright idea to have call_used_regs strictly include
+     fixed_regs.  Which leaves us guessing as to the set of fixed_regs
+     that are actually preserved.  We know for sure that those associated
+     with the local stack frame are safe, but scant others.  */
+  HARD_REG_SET x_regs_invalidated_by_call;
 
-/* For each reg class, a boolean saying whether the class contains only
-   fixed registers.  */
-extern bool class_only_fixed_regs[N_REG_CLASSES];
+  /* Table of register numbers in the order in which to try to use them.  */
+  int x_reg_alloc_order[FIRST_PSEUDO_REGISTER];
 
-/* For each reg class, number of regs it contains.  */
+  /* The inverse of reg_alloc_order.  */
+  int x_inv_reg_alloc_order[FIRST_PSEUDO_REGISTER];
 
-extern unsigned int reg_class_size[N_REG_CLASSES];
+  /* For each reg class, a HARD_REG_SET saying which registers are in it.  */
+  HARD_REG_SET x_reg_class_contents[N_REG_CLASSES];
 
-/* For each reg class, table listing all the classes contained in it.  */
+  /* For each reg class, a boolean saying whether the class contains only
+     fixed registers.  */
+  bool x_class_only_fixed_regs[N_REG_CLASSES];
 
-extern enum reg_class reg_class_subclasses[N_REG_CLASSES][N_REG_CLASSES];
+  /* For each reg class, number of regs it contains.  */
+  unsigned int x_reg_class_size[N_REG_CLASSES];
 
-/* For each pair of reg classes,
-   a largest reg class contained in their union.  */
+  /* For each reg class, table listing all the classes contained in it.  */
+  enum reg_class x_reg_class_subclasses[N_REG_CLASSES][N_REG_CLASSES];
 
-extern enum reg_class reg_class_subunion[N_REG_CLASSES][N_REG_CLASSES];
+  /* For each pair of reg classes,
+     a largest reg class contained in their union.  */
+  enum reg_class x_reg_class_subunion[N_REG_CLASSES][N_REG_CLASSES];
 
-/* For each pair of reg classes,
-   the smallest reg class that contains their union.  */
+  /* For each pair of reg classes,
+     the smallest reg class that contains their union.  */
+  enum reg_class x_reg_class_superunion[N_REG_CLASSES][N_REG_CLASSES];
 
-extern enum reg_class reg_class_superunion[N_REG_CLASSES][N_REG_CLASSES];
+  /* Vector indexed by hardware reg giving its name.  */
+  const char *x_reg_names[FIRST_PSEUDO_REGISTER];
+};
 
-/* Vector indexed by hardware reg giving its name.  */
+extern struct target_hard_regs default_target_hard_regs;
+#if SWITCHABLE_TARGET
+extern struct target_hard_regs *this_target_hard_regs;
+#else
+#define this_target_hard_regs (&default_target_hard_regs)
+#endif
 
-extern const char * reg_names[FIRST_PSEUDO_REGISTER];
+#define fixed_regs \
+  (this_target_hard_regs->x_fixed_regs)
+#define fixed_reg_set \
+  (this_target_hard_regs->x_fixed_reg_set)
+#define call_used_regs \
+  (this_target_hard_regs->x_call_used_regs)
+#define call_really_used_regs \
+  (this_target_hard_regs->x_call_really_used_regs)
+#define call_used_reg_set \
+  (this_target_hard_regs->x_call_used_reg_set)
+#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 reg_alloc_order \
+  (this_target_hard_regs->x_reg_alloc_order)
+#define inv_reg_alloc_order \
+  (this_target_hard_regs->x_inv_reg_alloc_order)
+#define reg_class_contents \
+  (this_target_hard_regs->x_reg_class_contents)
+#define class_only_fixed_regs \
+  (this_target_hard_regs->x_class_only_fixed_regs)
+#define reg_class_size \
+  (this_target_hard_regs->x_reg_class_size)
+#define reg_class_subclasses \
+  (this_target_hard_regs->x_reg_class_subclasses)
+#define reg_class_subunion \
+  (this_target_hard_regs->x_reg_class_subunion)
+#define reg_class_superunion \
+  (this_target_hard_regs->x_reg_class_superunion)
+#define reg_names \
+  (this_target_hard_regs->x_reg_names)
 
 /* Vector indexed by reg class giving its name.  */