Mercurial > hg > CbC > CbC_gcc
diff gcc/regs.h @ 67:f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
author | nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp> |
---|---|
date | Tue, 22 Mar 2011 17:18:12 +0900 |
parents | b7f97abdc517 |
children | 04ced10e8804 |
line wrap: on
line diff
--- a/gcc/regs.h Tue May 25 18:58:51 2010 +0900 +++ b/gcc/regs.h Tue Mar 22 17:18:12 2011 +0900 @@ -1,6 +1,6 @@ /* Define per-register tables for data flow info and register allocation. Copyright (C) 1987, 1993, 1994, 1995, 1996, 1997, 1998, - 1999, 2000, 2003, 2004, 2005, 2006, 2007, 2008 Free Software + 1999, 2000, 2003, 2004, 2005, 2006, 2007, 2008, 2010 Free Software Foundation, Inc. This file is part of GCC. @@ -22,9 +22,8 @@ #ifndef GCC_REGS_H #define GCC_REGS_H -#include "obstack.h" +#include "machmode.h" #include "hard-reg-set.h" -#include "basic-block.h" #define REG_BYTES(R) mode_size[(int) GET_MODE (R)] @@ -215,17 +214,6 @@ extern short *reg_renumber; -/* Vector indexed by machine mode saying whether there are regs of that mode. */ - -extern bool have_regs_of_mode [MAX_MACHINE_MODE]; - -/* For each hard register, the widest mode object that it can contain. - This will be a MODE_INT mode if the register can hold integers. Otherwise - it will be a MODE_FLOAT or a MODE_CC mode, whichever is valid for the - register. */ - -extern enum machine_mode reg_raw_mode[FIRST_PSEUDO_REGISTER]; - /* Flag set by local-alloc or global-alloc if they decide to allocate something in a call-clobbered register. */ @@ -239,12 +227,6 @@ #define CALLER_SAVE_PROFITABLE(REFS, CALLS) (4 * (CALLS) < (REFS)) #endif -/* On most machines a register class is likely to be spilled if it - only has one register. */ -#ifndef CLASS_LIKELY_SPILLED_P -#define CLASS_LIKELY_SPILLED_P(CLASS) (reg_class_size[(int) (CLASS)] == 1) -#endif - /* Select a register mode required for caller save of hard regno REGNO. */ #ifndef HARD_REGNO_CALLER_SAVE_MODE #define HARD_REGNO_CALLER_SAVE_MODE(REGNO, NREGS, MODE) \ @@ -257,26 +239,79 @@ #define HARD_REGNO_CALL_PART_CLOBBERED(REGNO, MODE) 0 #endif -/* 1 if the corresponding class does contain register of given - mode. */ -extern char contains_reg_of_mode [N_REG_CLASSES] [MAX_MACHINE_MODE]; - typedef unsigned short move_table[N_REG_CLASSES]; -/* Maximum cost of moving from a register in one class to a register - in another class. */ -extern move_table *move_cost[MAX_MACHINE_MODE]; +/* Target-dependent globals. */ +struct target_regs { + /* For each starting hard register, the number of consecutive hard + registers that a given machine mode occupies. */ + unsigned char x_hard_regno_nregs[FIRST_PSEUDO_REGISTER][MAX_MACHINE_MODE]; + + /* For each hard register, the widest mode object that it can contain. + This will be a MODE_INT mode if the register can hold integers. Otherwise + it will be a MODE_FLOAT or a MODE_CC mode, whichever is valid for the + register. */ + enum machine_mode x_reg_raw_mode[FIRST_PSEUDO_REGISTER]; + + /* Vector indexed by machine mode saying whether there are regs of + that mode. */ + bool x_have_regs_of_mode[MAX_MACHINE_MODE]; -/* Specify number of hard registers given machine mode occupy. */ -extern unsigned char hard_regno_nregs[FIRST_PSEUDO_REGISTER][MAX_MACHINE_MODE]; + /* 1 if the corresponding class contains a register of the given mode. */ + char x_contains_reg_of_mode[N_REG_CLASSES][MAX_MACHINE_MODE]; + + /* Maximum cost of moving from a register in one class to a register + in another class. Based on TARGET_REGISTER_MOVE_COST. */ + move_table *x_move_cost[MAX_MACHINE_MODE]; + + /* Similar, but here we don't have to move if the first index is a + subset of the second so in that case the cost is zero. */ + move_table *x_may_move_in_cost[MAX_MACHINE_MODE]; + + /* Similar, but here we don't have to move if the first index is a + superset of the second so in that case the cost is zero. */ + move_table *x_may_move_out_cost[MAX_MACHINE_MODE]; + + /* Keep track of the last mode we initialized move costs for. */ + int x_last_mode_for_init_move_cost; -/* Similar, but here we don't have to move if the first index is a - subset of the second so in that case the cost is zero. */ -extern move_table *may_move_in_cost[MAX_MACHINE_MODE]; + /* Record for each mode whether we can move a register directly to or + from an object of that mode in memory. If we can't, we won't try + to use that mode directly when accessing a field of that mode. */ + char x_direct_load[NUM_MACHINE_MODES]; + char x_direct_store[NUM_MACHINE_MODES]; + + /* Record for each mode whether we can float-extend from memory. */ + bool x_float_extend_from_mem[NUM_MACHINE_MODES][NUM_MACHINE_MODES]; +}; + +extern struct target_regs default_target_regs; +#if SWITCHABLE_TARGET +extern struct target_regs *this_target_regs; +#else +#define this_target_regs (&default_target_regs) +#endif -/* Similar, but here we don't have to move if the first index is a - superset of the second so in that case the cost is zero. */ -extern move_table *may_move_out_cost[MAX_MACHINE_MODE]; +#define hard_regno_nregs \ + (this_target_regs->x_hard_regno_nregs) +#define reg_raw_mode \ + (this_target_regs->x_reg_raw_mode) +#define have_regs_of_mode \ + (this_target_regs->x_have_regs_of_mode) +#define contains_reg_of_mode \ + (this_target_regs->x_contains_reg_of_mode) +#define move_cost \ + (this_target_regs->x_move_cost) +#define may_move_in_cost \ + (this_target_regs->x_may_move_in_cost) +#define may_move_out_cost \ + (this_target_regs->x_may_move_out_cost) +#define direct_load \ + (this_target_regs->x_direct_load) +#define direct_store \ + (this_target_regs->x_direct_store) +#define float_extend_from_mem \ + (this_target_regs->x_float_extend_from_mem) /* Return an exclusive upper bound on the registers occupied by hard register (reg:MODE REGNO). */