X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Fhard-reg-set.h;h=486a88a2ed84b9377cd97d372b345602c641e9a3;hb=5c47e7ffea359b45dfe4958813240a9a9457970b;hp=7e17caba9df939f5eb5d9fbebf58997dcbe094bd;hpb=e1ab78748da58d43da7f08cc64b9de80577f470e;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/hard-reg-set.h b/gcc/hard-reg-set.h index 7e17caba9df..486a88a2ed8 100644 --- a/gcc/hard-reg-set.h +++ b/gcc/hard-reg-set.h @@ -1,5 +1,5 @@ /* Sets (bit vectors) of hard registers, and operations on them. - Copyright (C) 1987, 1992, 1994, 2000, 2003, 2004, 2005, 2007 + Copyright (C) 1987, 1992, 1994, 2000, 2003, 2004, 2005, 2007, 2008, 2009 Free Software Foundation, Inc. This file is part of GCC @@ -19,7 +19,7 @@ along with GCC; see the file COPYING3. If not see . */ #ifndef GCC_HARD_REG_SET_H -#define GCC_HARD_REG_SET_H +#define GCC_HARD_REG_SET_H /* Define the type of a set of hard registers. */ @@ -500,10 +500,10 @@ typedef struct #define HARD_REG_ELT_BITS UHOST_BITS_PER_WIDE_INT -/* The implementation of the iterator functions is fully analogous to +/* The implementation of the iterator functions is fully analogous to the bitmap iterators. */ static inline void -hard_reg_set_iter_init (hard_reg_set_iterator *iter, HARD_REG_SET set, +hard_reg_set_iter_init (hard_reg_set_iterator *iter, HARD_REG_SET set, unsigned min, unsigned *regno) { #ifdef HARD_REG_SET_LONGS @@ -525,7 +525,7 @@ hard_reg_set_iter_init (hard_reg_set_iterator *iter, HARD_REG_SET set, *regno = min; } -static inline bool +static inline bool hard_reg_set_iter_set (hard_reg_set_iterator *iter, unsigned *regno) { while (1) @@ -544,7 +544,7 @@ hard_reg_set_iter_set (hard_reg_set_iterator *iter, unsigned *regno) } return (*regno < FIRST_PSEUDO_REGISTER); } - + /* Round to the beginning of the next word. */ *regno = (*regno + HARD_REG_ELT_BITS - 1); *regno -= *regno % HARD_REG_ELT_BITS; @@ -576,102 +576,123 @@ 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; - -/* Registers that we don't want to caller save. */ -extern HARD_REG_SET losing_caller_save_reg_set; - -/* Indexed by hard register number, contains 1 for registers that are - fixed use -- i.e. in fixed_regs -- 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 char call_fixed_regs[FIRST_PSEUDO_REGISTER]; - -/* The same info as a HARD_REG_SET. */ - -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; +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]; -/* Call used hard registers which can not be saved because there is no - insn for this. */ + /* The same info as a HARD_REG_SET. */ + HARD_REG_SET x_fixed_reg_set; -extern HARD_REG_SET no_caller_save_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. */ + char x_call_used_regs[FIRST_PSEUDO_REGISTER]; -#ifdef REG_ALLOC_ORDER -/* Table of register numbers in the order in which to try to use them. */ + char x_call_really_used_regs[FIRST_PSEUDO_REGISTER]; -extern int reg_alloc_order[FIRST_PSEUDO_REGISTER]; + /* The same info as a HARD_REG_SET. */ + HARD_REG_SET x_call_used_reg_set; -/* The inverse of reg_alloc_order. */ + /* 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 int inv_reg_alloc_order[FIRST_PSEUDO_REGISTER]; -#endif + /* 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 HARD_REG_SET saying which registers are in it. */ + /* 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; -extern HARD_REG_SET reg_class_contents[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 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 \ + (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. */