X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Fregrename.c;h=b8f1955db910613c39ab3e00f083d707c4f4c9b6;hb=4c079727f2a79a30b0996ee809e16f5e78025c0b;hp=62629f0a4cbe049a7f33918852bee72a8aefde78;hpb=b491e489e9e7b17fd080ced622f1bb06f0df98eb;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/regrename.c b/gcc/regrename.c index 62629f0a4cb..b8f1955db91 100644 --- a/gcc/regrename.c +++ b/gcc/regrename.c @@ -1,5 +1,5 @@ /* Register renaming for the GNU compiler. - Copyright (C) 2000, 2001, 2002 Free Software Foundation, Inc. + Copyright (C) 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc. This file is part of GCC. @@ -18,10 +18,10 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ -#define REG_OK_STRICT - #include "config.h" #include "system.h" +#include "coretypes.h" +#include "tm.h" #include "rtl.h" #include "tm_p.h" #include "insn-config.h" @@ -49,7 +49,7 @@ struct du_chain rtx insn; rtx *loc; - enum reg_class class; + ENUM_BITFIELD(reg_class) cl : 16; unsigned int need_caller_save_reg:1; unsigned int earlyclobber:1; }; @@ -76,36 +76,33 @@ static const char * const scan_actions_name[] = static struct obstack rename_obstack; -static void do_replace PARAMS ((struct du_chain *, int)); -static void scan_rtx_reg PARAMS ((rtx, rtx *, enum reg_class, - enum scan_actions, enum op_type, int)); -static void scan_rtx_address PARAMS ((rtx, rtx *, enum reg_class, - enum scan_actions, enum machine_mode)); -static void scan_rtx PARAMS ((rtx, rtx *, enum reg_class, - enum scan_actions, enum op_type, int)); -static struct du_chain *build_def_use PARAMS ((basic_block)); -static void dump_def_use_chain PARAMS ((struct du_chain *)); -static void note_sets PARAMS ((rtx, rtx, void *)); -static void clear_dead_regs PARAMS ((HARD_REG_SET *, enum machine_mode, rtx)); -static void merge_overlapping_regs PARAMS ((basic_block, HARD_REG_SET *, - struct du_chain *)); +static void do_replace (struct du_chain *, int); +static void scan_rtx_reg (rtx, rtx *, enum reg_class, + enum scan_actions, enum op_type, int); +static void scan_rtx_address (rtx, rtx *, enum reg_class, + enum scan_actions, enum machine_mode); +static void scan_rtx (rtx, rtx *, enum reg_class, enum scan_actions, + enum op_type, int); +static struct du_chain *build_def_use (basic_block); +static void dump_def_use_chain (struct du_chain *); +static void note_sets (rtx, rtx, void *); +static void clear_dead_regs (HARD_REG_SET *, enum machine_mode, rtx); +static void merge_overlapping_regs (basic_block, HARD_REG_SET *, + struct du_chain *); /* Called through note_stores from update_life. Find sets of registers, and record them in *DATA (which is actually a HARD_REG_SET *). */ static void -note_sets (x, set, data) - rtx x; - rtx set ATTRIBUTE_UNUSED; - void *data; +note_sets (rtx x, rtx set ATTRIBUTE_UNUSED, void *data) { HARD_REG_SET *pset = (HARD_REG_SET *) data; unsigned int regno; int nregs; - if (GET_CODE (x) != REG) + if (!REG_P (x)) return; regno = REGNO (x); - nregs = HARD_REGNO_NREGS (regno, GET_MODE (x)); + nregs = hard_regno_nregs[regno][GET_MODE (x)]; /* There must not be pseudos at this point. */ if (regno + nregs > FIRST_PSEUDO_REGISTER) @@ -119,10 +116,7 @@ note_sets (x, set, data) in the list NOTES. */ static void -clear_dead_regs (pset, kind, notes) - HARD_REG_SET *pset; - enum machine_mode kind; - rtx notes; +clear_dead_regs (HARD_REG_SET *pset, enum machine_mode kind, rtx notes) { rtx note; for (note = notes; note; note = XEXP (note, 1)) @@ -130,7 +124,7 @@ clear_dead_regs (pset, kind, notes) { rtx reg = XEXP (note, 0); unsigned int regno = REGNO (reg); - int nregs = HARD_REGNO_NREGS (regno, GET_MODE (reg)); + int nregs = hard_regno_nregs[regno][GET_MODE (reg)]; /* There must not be pseudos at this point. */ if (regno + nregs > FIRST_PSEUDO_REGISTER) @@ -145,17 +139,15 @@ clear_dead_regs (pset, kind, notes) its lifetime and set the corresponding bits in *PSET. */ static void -merge_overlapping_regs (b, pset, chain) - basic_block b; - HARD_REG_SET *pset; - struct du_chain *chain; +merge_overlapping_regs (basic_block b, HARD_REG_SET *pset, + struct du_chain *chain) { struct du_chain *t = chain; rtx insn; HARD_REG_SET live; REG_SET_TO_HARD_REG_SET (live, b->global_live_at_start); - insn = b->head; + insn = BB_HEAD (b); while (t) { /* Search forward until the next reference to the register to be @@ -190,7 +182,7 @@ merge_overlapping_regs (b, pset, chain) /* Perform register renaming on the current function. */ void -regrename_optimize () +regrename_optimize (void) { int tick[FIRST_PSEUDO_REGISTER]; int this_tick = 0; @@ -200,7 +192,7 @@ regrename_optimize () memset (tick, 0, sizeof tick); gcc_obstack_init (&rename_obstack); - first_obj = (char *) obstack_alloc (&rename_obstack, 0); + first_obj = obstack_alloc (&rename_obstack, 0); FOR_EACH_BB (bb) { @@ -210,12 +202,12 @@ regrename_optimize () CLEAR_HARD_REG_SET (unavailable); - if (rtl_dump_file) - fprintf (rtl_dump_file, "\nBasic block %d:\n", bb->index); + if (dump_file) + fprintf (dump_file, "\nBasic block %d:\n", bb->index); all_chains = build_def_use (bb); - if (rtl_dump_file) + if (dump_file) dump_def_use_chain (all_chains); CLEAR_HARD_REG_SET (unavailable); @@ -224,11 +216,11 @@ regrename_optimize () { int i; - for (i = HARD_REGNO_NREGS (FRAME_POINTER_REGNUM, Pmode); i--;) + for (i = hard_regno_nregs[FRAME_POINTER_REGNUM][Pmode]; i--;) SET_HARD_REG_BIT (unavailable, FRAME_POINTER_REGNUM + i); #if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM - for (i = HARD_REGNO_NREGS (HARD_FRAME_POINTER_REGNUM, Pmode); i--;) + for (i = hard_regno_nregs[HARD_FRAME_POINTER_REGNUM][Pmode]; i--;) SET_HARD_REG_BIT (unavailable, HARD_FRAME_POINTER_REGNUM + i); #endif } @@ -236,7 +228,7 @@ regrename_optimize () CLEAR_HARD_REG_SET (regs_seen); while (all_chains) { - int new_reg, best_new_reg = -1; + int new_reg, best_new_reg; int n_uses; struct du_chain *this = all_chains; struct du_chain *tmp, *last; @@ -246,6 +238,8 @@ regrename_optimize () all_chains = this->next_chain; + best_new_reg = reg; + #if 0 /* This just disables optimization opportunities. */ /* Only rename once we've seen the reg more than once. */ if (! TEST_HARD_REG_BIT (regs_seen, reg)) @@ -274,13 +268,13 @@ regrename_optimize () { n_uses++; IOR_COMPL_HARD_REG_SET (this_unavailable, - reg_class_contents[last->class]); + reg_class_contents[last->cl]); } if (n_uses < 1) continue; IOR_COMPL_HARD_REG_SET (this_unavailable, - reg_class_contents[last->class]); + reg_class_contents[last->cl]); if (this->need_caller_save_reg) IOR_HARD_REG_SET (this_unavailable, call_used_reg_set); @@ -291,7 +285,7 @@ regrename_optimize () have a closer look at each register still in there. */ for (new_reg = 0; new_reg < FIRST_PSEUDO_REGISTER; new_reg++) { - int nregs = HARD_REGNO_NREGS (new_reg, GET_MODE (*this->loc)); + int nregs = hard_regno_nregs[new_reg][GET_MODE (*this->loc)]; for (i = nregs - 1; i >= 0; --i) if (TEST_HARD_REG_BIT (this_unavailable, new_reg + i) @@ -326,32 +320,33 @@ regrename_optimize () break; if (! tmp) { - if (best_new_reg == -1 - || tick[best_new_reg] > tick[new_reg]) + if (tick[best_new_reg] > tick[new_reg]) best_new_reg = new_reg; } } - if (rtl_dump_file) + if (dump_file) { - fprintf (rtl_dump_file, "Register %s in insn %d", + fprintf (dump_file, "Register %s in insn %d", reg_names[reg], INSN_UID (last->insn)); if (last->need_caller_save_reg) - fprintf (rtl_dump_file, " crosses a call"); + fprintf (dump_file, " crosses a call"); } - if (best_new_reg == -1) + if (best_new_reg == reg) { - if (rtl_dump_file) - fprintf (rtl_dump_file, "; no available registers\n"); + tick[reg] = ++this_tick; + if (dump_file) + fprintf (dump_file, "; no available better choice\n"); continue; } do_replace (this, best_new_reg); - tick[best_new_reg] = this_tick++; + tick[best_new_reg] = ++this_tick; + regs_ever_live[best_new_reg] = 1; - if (rtl_dump_file) - fprintf (rtl_dump_file, ", renamed as %s\n", reg_names[best_new_reg]); + if (dump_file) + fprintf (dump_file, ", renamed as %s\n", reg_names[best_new_reg]); } obstack_free (&rename_obstack, first_obj); @@ -359,25 +354,26 @@ regrename_optimize () obstack_free (&rename_obstack, NULL); - if (rtl_dump_file) - fputc ('\n', rtl_dump_file); + if (dump_file) + fputc ('\n', dump_file); count_or_remove_death_notes (NULL, 1); update_life_info (NULL, UPDATE_LIFE_LOCAL, - PROP_REG_INFO | PROP_DEATH_NOTES); + PROP_DEATH_NOTES); } static void -do_replace (chain, reg) - struct du_chain *chain; - int reg; +do_replace (struct du_chain *chain, int reg) { while (chain) { unsigned int regno = ORIGINAL_REGNO (*chain->loc); + struct reg_attrs * attr = REG_ATTRS (*chain->loc); + *chain->loc = gen_raw_REG (GET_MODE (*chain->loc), reg); if (regno >= FIRST_PSEUDO_REGISTER) ORIGINAL_REGNO (*chain->loc) = regno; + REG_ATTRS (*chain->loc) = attr; chain = chain->next_use; } } @@ -387,31 +383,26 @@ static struct du_chain *open_chains; static struct du_chain *closed_chains; static void -scan_rtx_reg (insn, loc, class, action, type, earlyclobber) - rtx insn; - rtx *loc; - enum reg_class class; - enum scan_actions action; - enum op_type type; - int earlyclobber; +scan_rtx_reg (rtx insn, rtx *loc, enum reg_class cl, + enum scan_actions action, enum op_type type, int earlyclobber) { struct du_chain **p; rtx x = *loc; enum machine_mode mode = GET_MODE (x); int this_regno = REGNO (x); - int this_nregs = HARD_REGNO_NREGS (this_regno, mode); + int this_nregs = hard_regno_nregs[this_regno][mode]; if (action == mark_write) { if (type == OP_OUT) { - struct du_chain *this = (struct du_chain *) - obstack_alloc (&rename_obstack, sizeof (struct du_chain)); + struct du_chain *this + = obstack_alloc (&rename_obstack, sizeof (struct du_chain)); this->next_use = 0; this->next_chain = open_chains; this->loc = loc; this->insn = insn; - this->class = class; + this->cl = cl; this->need_caller_save_reg = 0; this->earlyclobber = earlyclobber; open_chains = this; @@ -439,7 +430,7 @@ scan_rtx_reg (insn, loc, class, action, type, earlyclobber) else { int regno = REGNO (*this->loc); - int nregs = HARD_REGNO_NREGS (regno, GET_MODE (*this->loc)); + int nregs = hard_regno_nregs[regno][GET_MODE (*this->loc)]; int exact_match = (regno == this_regno && nregs == this_nregs); if (regno + nregs <= this_regno @@ -458,15 +449,14 @@ scan_rtx_reg (insn, loc, class, action, type, earlyclobber) EXTRA_CONSTRAINTS to match registers. Which is arguably wrong, but there we are. Since we know not what this may be replaced with, terminate the chain. */ - if (class != NO_REGS) + if (cl != NO_REGS) { - this = (struct du_chain *) - obstack_alloc (&rename_obstack, sizeof (struct du_chain)); + this = obstack_alloc (&rename_obstack, sizeof (struct du_chain)); this->next_use = 0; this->next_chain = (*p)->next_chain; this->loc = loc; this->insn = insn; - this->class = class; + this->cl = cl; this->need_caller_save_reg = 0; while (*p) p = &(*p)->next_use; @@ -488,16 +478,16 @@ scan_rtx_reg (insn, loc, class, action, type, earlyclobber) { this->next_chain = closed_chains; closed_chains = this; - if (rtl_dump_file) - fprintf (rtl_dump_file, + if (dump_file) + fprintf (dump_file, "Closing chain %s at insn %d (%s)\n", reg_names[REGNO (*this->loc)], INSN_UID (insn), scan_actions_name[(int) action]); } else { - if (rtl_dump_file) - fprintf (rtl_dump_file, + if (dump_file) + fprintf (dump_file, "Discarding chain %s at insn %d (%s)\n", reg_names[REGNO (*this->loc)], INSN_UID (insn), scan_actions_name[(int) action]); @@ -510,16 +500,12 @@ scan_rtx_reg (insn, loc, class, action, type, earlyclobber) } } -/* Adapted from find_reloads_address_1. CLASS is INDEX_REG_CLASS or +/* Adapted from find_reloads_address_1. CL is INDEX_REG_CLASS or BASE_REG_CLASS depending on how the register is being considered. */ static void -scan_rtx_address (insn, loc, class, action, mode) - rtx insn; - rtx *loc; - enum reg_class class; - enum scan_actions action; - enum machine_mode mode; +scan_rtx_address (rtx insn, rtx *loc, enum reg_class cl, + enum scan_actions action, enum machine_mode mode) { rtx x = *loc; RTX_CODE code = GET_CODE (x); @@ -632,7 +618,7 @@ scan_rtx_address (insn, loc, class, action, mode) return; case REG: - scan_rtx_reg (insn, loc, class, action, OP_IN, 0); + scan_rtx_reg (insn, loc, cl, action, OP_IN, 0); return; default: @@ -643,21 +629,16 @@ scan_rtx_address (insn, loc, class, action, mode) for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--) { if (fmt[i] == 'e') - scan_rtx_address (insn, &XEXP (x, i), class, action, mode); + scan_rtx_address (insn, &XEXP (x, i), cl, action, mode); else if (fmt[i] == 'E') for (j = XVECLEN (x, i) - 1; j >= 0; j--) - scan_rtx_address (insn, &XVECEXP (x, i, j), class, action, mode); + scan_rtx_address (insn, &XVECEXP (x, i, j), cl, action, mode); } } static void -scan_rtx (insn, loc, class, action, type, earlyclobber) - rtx insn; - rtx *loc; - enum reg_class class; - enum scan_actions action; - enum op_type type; - int earlyclobber; +scan_rtx (rtx insn, rtx *loc, enum reg_class cl, + enum scan_actions action, enum op_type type, int earlyclobber) { const char *fmt; rtx x = *loc; @@ -678,7 +659,7 @@ scan_rtx (insn, loc, class, action, type, earlyclobber) return; case REG: - scan_rtx_reg (insn, loc, class, action, type, earlyclobber); + scan_rtx_reg (insn, loc, cl, action, type, earlyclobber); return; case MEM: @@ -688,20 +669,20 @@ scan_rtx (insn, loc, class, action, type, earlyclobber) return; case SET: - scan_rtx (insn, &SET_SRC (x), class, action, OP_IN, 0); - scan_rtx (insn, &SET_DEST (x), class, action, OP_OUT, 0); + scan_rtx (insn, &SET_SRC (x), cl, action, OP_IN, 0); + scan_rtx (insn, &SET_DEST (x), cl, action, OP_OUT, 0); return; case STRICT_LOW_PART: - scan_rtx (insn, &XEXP (x, 0), class, action, OP_INOUT, earlyclobber); + scan_rtx (insn, &XEXP (x, 0), cl, action, OP_INOUT, earlyclobber); return; case ZERO_EXTRACT: case SIGN_EXTRACT: - scan_rtx (insn, &XEXP (x, 0), class, action, + scan_rtx (insn, &XEXP (x, 0), cl, action, type == OP_IN ? OP_IN : OP_INOUT, earlyclobber); - scan_rtx (insn, &XEXP (x, 1), class, action, OP_IN, 0); - scan_rtx (insn, &XEXP (x, 2), class, action, OP_IN, 0); + scan_rtx (insn, &XEXP (x, 1), cl, action, OP_IN, 0); + scan_rtx (insn, &XEXP (x, 2), cl, action, OP_IN, 0); return; case POST_INC: @@ -714,13 +695,13 @@ scan_rtx (insn, loc, class, action, type, earlyclobber) abort (); case CLOBBER: - scan_rtx (insn, &SET_DEST (x), class, action, OP_OUT, 1); + scan_rtx (insn, &SET_DEST (x), cl, action, OP_OUT, 1); return; case EXPR_LIST: - scan_rtx (insn, &XEXP (x, 0), class, action, type, 0); + scan_rtx (insn, &XEXP (x, 0), cl, action, type, 0); if (XEXP (x, 1)) - scan_rtx (insn, &XEXP (x, 1), class, action, type, 0); + scan_rtx (insn, &XEXP (x, 1), cl, action, type, 0); return; default: @@ -731,24 +712,23 @@ scan_rtx (insn, loc, class, action, type, earlyclobber) for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--) { if (fmt[i] == 'e') - scan_rtx (insn, &XEXP (x, i), class, action, type, 0); + scan_rtx (insn, &XEXP (x, i), cl, action, type, 0); else if (fmt[i] == 'E') for (j = XVECLEN (x, i) - 1; j >= 0; j--) - scan_rtx (insn, &XVECEXP (x, i, j), class, action, type, 0); + scan_rtx (insn, &XVECEXP (x, i, j), cl, action, type, 0); } } -/* Build def/use chain */ +/* Build def/use chain. */ static struct du_chain * -build_def_use (bb) - basic_block bb; +build_def_use (basic_block bb) { rtx insn; open_chains = closed_chains = NULL; - for (insn = bb->head; ; insn = NEXT_INSN (insn)) + for (insn = BB_HEAD (bb); ; insn = NEXT_INSN (insn)) { if (INSN_P (insn)) { @@ -793,7 +773,7 @@ build_def_use (bb) { int matches = recog_op_alt[i][alt].matches; if (matches >= 0) - recog_op_alt[i][alt].class = recog_op_alt[matches][alt].class; + recog_op_alt[i][alt].cl = recog_op_alt[matches][alt].cl; if (matches >= 0 || recog_op_alt[i][alt].matched >= 0 || (predicated && recog_data.operand_type[i] == OP_OUT)) recog_data.operand_type[i] = OP_INOUT; @@ -842,7 +822,7 @@ build_def_use (bb) *recog_data.operand_loc[i] = old_operands[i]; /* Step 2B: Can't rename function call argument registers. */ - if (GET_CODE (insn) == CALL_INSN && CALL_INSN_FUNCTION_USAGE (insn)) + if (CALL_P (insn) && CALL_INSN_FUNCTION_USAGE (insn)) scan_rtx (insn, &CALL_INSN_FUNCTION_USAGE (insn), NO_REGS, terminate_all_read, OP_IN, 0); @@ -854,7 +834,7 @@ build_def_use (bb) rtx *loc = recog_data.operand_loc[i]; rtx op = *loc; - if (GET_CODE (op) == REG + if (REG_P (op) && REGNO (op) == ORIGINAL_REGNO (op) && (recog_data.operand_type[i] == OP_IN || recog_data.operand_type[i] == OP_INOUT)) @@ -868,7 +848,7 @@ build_def_use (bb) rtx *loc = (i < n_ops ? recog_data.operand_loc[opn] : recog_data.dup_loc[i - n_ops]); - enum reg_class class = recog_op_alt[opn][alt].class; + enum reg_class cl = recog_op_alt[opn][alt].cl; enum op_type type = recog_data.operand_type[opn]; /* Don't scan match_operand here, since we've no reg class @@ -878,9 +858,9 @@ build_def_use (bb) continue; if (recog_op_alt[opn][alt].is_address) - scan_rtx_address (insn, loc, class, mark_read, VOIDmode); + scan_rtx_address (insn, loc, cl, mark_read, VOIDmode); else - scan_rtx (insn, loc, class, mark_read, type, 0); + scan_rtx (insn, loc, cl, mark_read, type, 0); } /* Step 4: Close chains for registers that die here. @@ -897,7 +877,7 @@ build_def_use (bb) /* Step 4B: If this is a call, any chain live at this point requires a caller-saved reg. */ - if (GET_CODE (insn) == CALL_INSN) + if (CALL_P (insn)) { struct du_chain *p; for (p = open_chains; p; p = p->next_chain) @@ -942,27 +922,27 @@ build_def_use (bb) { rtx *loc = recog_data.operand_loc[i]; rtx op = *loc; - enum reg_class class = recog_op_alt[i][alt].class; + enum reg_class cl = recog_op_alt[i][alt].cl; - if (GET_CODE (op) == REG + if (REG_P (op) && REGNO (op) == ORIGINAL_REGNO (op)) continue; - scan_rtx (insn, loc, class, mark_write, OP_OUT, + scan_rtx (insn, loc, cl, mark_write, OP_OUT, recog_op_alt[i][alt].earlyclobber); } } - else if (GET_CODE (insn) != CALL_INSN) + else if (!CALL_P (insn)) for (i = 0; i < n_ops + recog_data.n_dups; i++) { int opn = i < n_ops ? i : recog_data.dup_num[i - n_ops]; rtx *loc = (i < n_ops ? recog_data.operand_loc[opn] : recog_data.dup_loc[i - n_ops]); - enum reg_class class = recog_op_alt[opn][alt].class; + enum reg_class cl = recog_op_alt[opn][alt].cl; if (recog_data.operand_type[opn] == OP_OUT) - scan_rtx (insn, loc, class, mark_write, OP_OUT, + scan_rtx (insn, loc, cl, mark_write, OP_OUT, recog_op_alt[opn][alt].earlyclobber); } @@ -973,7 +953,7 @@ build_def_use (bb) scan_rtx (insn, &XEXP (note, 0), NO_REGS, terminate_dead, OP_IN, 0); } - if (insn == bb->end) + if (insn == BB_END (bb)) break; } @@ -982,26 +962,25 @@ build_def_use (bb) return closed_chains; } -/* Dump all def/use chains in CHAINS to RTL_DUMP_FILE. They are +/* Dump all def/use chains in CHAINS to DUMP_FILE. They are printed in reverse order as that's how we build them. */ static void -dump_def_use_chain (chains) - struct du_chain *chains; +dump_def_use_chain (struct du_chain *chains) { while (chains) { struct du_chain *this = chains; int r = REGNO (*this->loc); - int nregs = HARD_REGNO_NREGS (r, GET_MODE (*this->loc)); - fprintf (rtl_dump_file, "Register %s (%d):", reg_names[r], nregs); + int nregs = hard_regno_nregs[r][GET_MODE (*this->loc)]; + fprintf (dump_file, "Register %s (%d):", reg_names[r], nregs); while (this) { - fprintf (rtl_dump_file, " %d [%s]", INSN_UID (this->insn), - reg_class_names[this->class]); + fprintf (dump_file, " %d [%s]", INSN_UID (this->insn), + reg_class_names[this->cl]); this = this->next_use; } - fprintf (rtl_dump_file, "\n"); + fprintf (dump_file, "\n"); chains = chains->next_chain; } } @@ -1031,42 +1010,39 @@ struct value_data unsigned int max_value_regs; }; -static void kill_value_regno PARAMS ((unsigned, struct value_data *)); -static void kill_value PARAMS ((rtx, struct value_data *)); -static void set_value_regno PARAMS ((unsigned, enum machine_mode, - struct value_data *)); -static void init_value_data PARAMS ((struct value_data *)); -static void kill_clobbered_value PARAMS ((rtx, rtx, void *)); -static void kill_set_value PARAMS ((rtx, rtx, void *)); -static int kill_autoinc_value PARAMS ((rtx *, void *)); -static void copy_value PARAMS ((rtx, rtx, struct value_data *)); -static bool mode_change_ok PARAMS ((enum machine_mode, enum machine_mode, - unsigned int)); -static rtx maybe_mode_change PARAMS ((enum machine_mode, enum machine_mode, - enum machine_mode, unsigned int, - unsigned int)); -static rtx find_oldest_value_reg PARAMS ((enum reg_class, rtx, - struct value_data *)); -static bool replace_oldest_value_reg PARAMS ((rtx *, enum reg_class, rtx, - struct value_data *)); -static bool replace_oldest_value_addr PARAMS ((rtx *, enum reg_class, - enum machine_mode, rtx, - struct value_data *)); -static bool replace_oldest_value_mem PARAMS ((rtx, rtx, struct value_data *)); -static bool copyprop_hardreg_forward_1 PARAMS ((basic_block, - struct value_data *)); -extern void debug_value_data PARAMS ((struct value_data *)); +static void kill_value_one_regno (unsigned, struct value_data *); +static void kill_value_regno (unsigned, unsigned, struct value_data *); +static void kill_value (rtx, struct value_data *); +static void set_value_regno (unsigned, enum machine_mode, struct value_data *); +static void init_value_data (struct value_data *); +static void kill_clobbered_value (rtx, rtx, void *); +static void kill_set_value (rtx, rtx, void *); +static int kill_autoinc_value (rtx *, void *); +static void copy_value (rtx, rtx, struct value_data *); +static bool mode_change_ok (enum machine_mode, enum machine_mode, + unsigned int); +static rtx maybe_mode_change (enum machine_mode, enum machine_mode, + enum machine_mode, unsigned int, unsigned int); +static rtx find_oldest_value_reg (enum reg_class, rtx, struct value_data *); +static bool replace_oldest_value_reg (rtx *, enum reg_class, rtx, + struct value_data *); +static bool replace_oldest_value_addr (rtx *, enum reg_class, + enum machine_mode, rtx, + struct value_data *); +static bool replace_oldest_value_mem (rtx, rtx, struct value_data *); +static bool copyprop_hardreg_forward_1 (basic_block, struct value_data *); +extern void debug_value_data (struct value_data *); #ifdef ENABLE_CHECKING -static void validate_value_data PARAMS ((struct value_data *)); +static void validate_value_data (struct value_data *); #endif -/* Kill register REGNO. This involves removing it from any value lists, - and resetting the value mode to VOIDmode. */ +/* Kill register REGNO. This involves removing it from any value + lists, and resetting the value mode to VOIDmode. This is only a + helper function; it does not handle any hard registers overlapping + with REGNO. */ static void -kill_value_regno (regno, vd) - unsigned int regno; - struct value_data *vd; +kill_value_one_regno (unsigned int regno, struct value_data *vd) { unsigned int i, next; @@ -1093,13 +1069,41 @@ kill_value_regno (regno, vd) #endif } -/* Kill X. This is a convenience function for kill_value_regno +/* Kill the value in register REGNO for NREGS, and any other registers + whose values overlap. */ + +static void +kill_value_regno (unsigned int regno, unsigned int nregs, + struct value_data *vd) +{ + unsigned int j; + + /* Kill the value we're told to kill. */ + for (j = 0; j < nregs; ++j) + kill_value_one_regno (regno + j, vd); + + /* Kill everything that overlapped what we're told to kill. */ + if (regno < vd->max_value_regs) + j = 0; + else + j = regno - vd->max_value_regs; + for (; j < regno; ++j) + { + unsigned int i, n; + if (vd->e[j].mode == VOIDmode) + continue; + n = hard_regno_nregs[j][vd->e[j].mode]; + if (j + n > regno) + for (i = 0; i < n; ++i) + kill_value_one_regno (j + i, vd); + } +} + +/* Kill X. This is a convenience function wrapping kill_value_regno so that we mind the mode the register is in. */ static void -kill_value (x, vd) - rtx x; - struct value_data *vd; +kill_value (rtx x, struct value_data *vd) { /* SUBREGS are supposed to have been eliminated by now. But some ports, e.g. i386 sse, use them to smuggle vector type information @@ -1112,43 +1116,23 @@ kill_value (x, vd) if (REG_P (x)) { unsigned int regno = REGNO (x); - unsigned int n = HARD_REGNO_NREGS (regno, GET_MODE (x)); - unsigned int i, j; + unsigned int n = hard_regno_nregs[regno][GET_MODE (x)]; - /* Kill the value we're told to kill. */ - for (i = 0; i < n; ++i) - kill_value_regno (regno + i, vd); - - /* Kill everything that overlapped what we're told to kill. */ - if (regno < vd->max_value_regs) - j = 0; - else - j = regno - vd->max_value_regs; - for (; j < regno; ++j) - { - if (vd->e[j].mode == VOIDmode) - continue; - n = HARD_REGNO_NREGS (j, vd->e[j].mode); - if (j + n > regno) - for (i = 0; i < n; ++i) - kill_value_regno (j + i, vd); - } + kill_value_regno (regno, n, vd); } } /* Remember that REGNO is valid in MODE. */ static void -set_value_regno (regno, mode, vd) - unsigned int regno; - enum machine_mode mode; - struct value_data *vd; +set_value_regno (unsigned int regno, enum machine_mode mode, + struct value_data *vd) { unsigned int nregs; vd->e[regno].mode = mode; - nregs = HARD_REGNO_NREGS (regno, mode); + nregs = hard_regno_nregs[regno][mode]; if (nregs > vd->max_value_regs) vd->max_value_regs = nregs; } @@ -1156,8 +1140,7 @@ set_value_regno (regno, mode, vd) /* Initialize VD such that there are no known relationships between regs. */ static void -init_value_data (vd) - struct value_data *vd; +init_value_data (struct value_data *vd) { int i; for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i) @@ -1172,10 +1155,7 @@ init_value_data (vd) /* Called through note_stores. If X is clobbered, kill its value. */ static void -kill_clobbered_value (x, set, data) - rtx x; - rtx set; - void *data; +kill_clobbered_value (rtx x, rtx set, void *data) { struct value_data *vd = data; if (GET_CODE (set) == CLOBBER) @@ -1186,10 +1166,7 @@ kill_clobbered_value (x, set, data) current value and install it as the root of its own value list. */ static void -kill_set_value (x, set, data) - rtx x; - rtx set; - void *data; +kill_set_value (rtx x, rtx set, void *data) { struct value_data *vd = data; if (GET_CODE (set) != CLOBBER) @@ -1205,14 +1182,12 @@ kill_set_value (x, set, data) own value list. */ static int -kill_autoinc_value (px, data) - rtx *px; - void *data; +kill_autoinc_value (rtx *px, void *data) { rtx x = *px; struct value_data *vd = data; - if (GET_RTX_CLASS (GET_CODE (x)) == 'a') + if (GET_RTX_CLASS (GET_CODE (x)) == RTX_AUTOINC) { x = XEXP (x, 0); kill_value (x, vd); @@ -1227,10 +1202,7 @@ kill_autoinc_value (px, data) to reflect that SRC contains an older copy of the shared value. */ static void -copy_value (dest, src, vd) - rtx dest; - rtx src; - struct value_data *vd; +copy_value (rtx dest, rtx src, struct value_data *vd) { unsigned int dr = REGNO (dest); unsigned int sr = REGNO (src); @@ -1243,7 +1215,7 @@ copy_value (dest, src, vd) return; /* Do not propagate copies to the stack pointer, as that can leave - memory accesses with no scheduling dependancy on the stack update. */ + memory accesses with no scheduling dependency on the stack update. */ if (dr == STACK_POINTER_REGNUM) return; @@ -1252,8 +1224,8 @@ copy_value (dest, src, vd) return; /* If SRC and DEST overlap, don't record anything. */ - dn = HARD_REGNO_NREGS (dr, GET_MODE (dest)); - sn = HARD_REGNO_NREGS (sr, GET_MODE (dest)); + dn = hard_regno_nregs[dr][GET_MODE (dest)]; + sn = hard_regno_nregs[sr][GET_MODE (dest)]; if ((dr > sr && dr < sr + sn) || (sr > dr && sr < dr + dn)) return; @@ -1264,7 +1236,7 @@ copy_value (dest, src, vd) if (vd->e[sr].mode == VOIDmode) set_value_regno (sr, vd->e[dr].mode, vd); - /* If we are narrowing the the input to a smaller number of hard regs, + /* If we are narrowing the input to a smaller number of hard regs, and it is in big endian, we are really extracting a high part. Since we generally associate a low part of a value with the value itself, we must not do the same for the high part. @@ -1279,7 +1251,7 @@ copy_value (dest, src, vd) We can't properly represent the latter case in our tables, so don't record anything then. */ - else if (sn < (unsigned int) HARD_REGNO_NREGS (sr, vd->e[sr].mode) + else if (sn < (unsigned int) hard_regno_nregs[sr][vd->e[sr].mode] && (GET_MODE_SIZE (vd->e[sr].mode) > UNITS_PER_WORD ? WORDS_BIG_ENDIAN : BYTES_BIG_ENDIAN)) return; @@ -1287,7 +1259,7 @@ copy_value (dest, src, vd) /* If SRC had been assigned a mode narrower than the copy, we can't link DEST into the chain, because not all of the pieces of the copy came from oldest_regno. */ - else if (sn > (unsigned int) HARD_REGNO_NREGS (sr, vd->e[sr].mode)) + else if (sn > (unsigned int) hard_regno_nregs[sr][vd->e[sr].mode]) return; /* Link DR at the end of the value chain used by SR. */ @@ -1306,17 +1278,14 @@ copy_value (dest, src, vd) /* Return true if a mode change from ORIG to NEW is allowed for REGNO. */ static bool -mode_change_ok (orig_mode, new_mode, regno) - enum machine_mode orig_mode, new_mode; - unsigned int regno ATTRIBUTE_UNUSED; +mode_change_ok (enum machine_mode orig_mode, enum machine_mode new_mode, + unsigned int regno ATTRIBUTE_UNUSED) { if (GET_MODE_SIZE (orig_mode) < GET_MODE_SIZE (new_mode)) return false; -#ifdef CLASS_CANNOT_CHANGE_MODE - if (TEST_HARD_REG_BIT (reg_class_contents[CLASS_CANNOT_CHANGE_MODE], regno) - && CLASS_CANNOT_CHANGE_MODE_P (orig_mode, new_mode)) - return false; +#ifdef CANNOT_CHANGE_MODE_CLASS + return !REG_CANNOT_CHANGE_MODE_P (regno, orig_mode, new_mode); #endif return true; @@ -1328,16 +1297,16 @@ mode_change_ok (orig_mode, new_mode, regno) Return a NEW_MODE rtx for REGNO if that's OK, otherwise return NULL_RTX. */ static rtx -maybe_mode_change (orig_mode, copy_mode, new_mode, regno, copy_regno) - enum machine_mode orig_mode, copy_mode, new_mode; - unsigned int regno, copy_regno; +maybe_mode_change (enum machine_mode orig_mode, enum machine_mode copy_mode, + enum machine_mode new_mode, unsigned int regno, + unsigned int copy_regno ATTRIBUTE_UNUSED) { if (orig_mode == new_mode) return gen_rtx_raw_REG (new_mode, regno); else if (mode_change_ok (orig_mode, new_mode, regno)) { - int copy_nregs = HARD_REGNO_NREGS (copy_regno, copy_mode); - int use_nregs = HARD_REGNO_NREGS (copy_regno, new_mode); + int copy_nregs = hard_regno_nregs[copy_regno][copy_mode]; + int use_nregs = hard_regno_nregs[copy_regno][new_mode]; int copy_offset = GET_MODE_SIZE (copy_mode) / copy_nregs * (copy_nregs - use_nregs); int offset @@ -1356,14 +1325,11 @@ maybe_mode_change (orig_mode, copy_mode, new_mode, regno, copy_regno) } /* Find the oldest copy of the value contained in REGNO that is in - register class CLASS and has mode MODE. If found, return an rtx + register class CL and has mode MODE. If found, return an rtx of that oldest register, otherwise return NULL. */ static rtx -find_oldest_value_reg (class, reg, vd) - enum reg_class class; - rtx reg; - struct value_data *vd; +find_oldest_value_reg (enum reg_class cl, rtx reg, struct value_data *vd) { unsigned int regno = REGNO (reg); enum machine_mode mode = GET_MODE (reg); @@ -1378,8 +1344,8 @@ find_oldest_value_reg (class, reg, vd) Replacing r9 with r11 is invalid. */ if (mode != vd->e[regno].mode) { - if (HARD_REGNO_NREGS (regno, mode) - > HARD_REGNO_NREGS (regno, vd->e[regno].mode)) + if (hard_regno_nregs[regno][mode] + > hard_regno_nregs[regno][vd->e[regno].mode]) return NULL_RTX; } @@ -1387,34 +1353,36 @@ find_oldest_value_reg (class, reg, vd) { enum machine_mode oldmode = vd->e[i].mode; rtx new; + unsigned int last; - if (TEST_HARD_REG_BIT (reg_class_contents[class], i) - && (new = maybe_mode_change (oldmode, vd->e[regno].mode, mode, i, - regno))) - { - ORIGINAL_REGNO (new) = ORIGINAL_REGNO (reg); - return new; - } + for (last = i; last < i + hard_regno_nregs[i][mode]; last++) + if (!TEST_HARD_REG_BIT (reg_class_contents[cl], last)) + return NULL_RTX; + + new = maybe_mode_change (oldmode, vd->e[regno].mode, mode, i, regno); + if (new) + { + ORIGINAL_REGNO (new) = ORIGINAL_REGNO (reg); + REG_ATTRS (new) = REG_ATTRS (reg); + return new; + } } return NULL_RTX; } /* If possible, replace the register at *LOC with the oldest register - in register class CLASS. Return true if successfully replaced. */ + in register class CL. Return true if successfully replaced. */ static bool -replace_oldest_value_reg (loc, class, insn, vd) - rtx *loc; - enum reg_class class; - rtx insn; - struct value_data *vd; +replace_oldest_value_reg (rtx *loc, enum reg_class cl, rtx insn, + struct value_data *vd) { - rtx new = find_oldest_value_reg (class, *loc, vd); + rtx new = find_oldest_value_reg (cl, *loc, vd); if (new) { - if (rtl_dump_file) - fprintf (rtl_dump_file, "insn %u: replaced reg %u with %u\n", + if (dump_file) + fprintf (dump_file, "insn %u: replaced reg %u with %u\n", INSN_UID (insn), REGNO (*loc), REGNO (new)); *loc = new; @@ -1424,16 +1392,13 @@ replace_oldest_value_reg (loc, class, insn, vd) } /* Similar to replace_oldest_value_reg, but *LOC contains an address. - Adapted from find_reloads_address_1. CLASS is INDEX_REG_CLASS or + Adapted from find_reloads_address_1. CL is INDEX_REG_CLASS or BASE_REG_CLASS depending on how the register is being considered. */ static bool -replace_oldest_value_addr (loc, class, mode, insn, vd) - rtx *loc; - enum reg_class class; - enum machine_mode mode; - rtx insn; - struct value_data *vd; +replace_oldest_value_addr (rtx *loc, enum reg_class cl, + enum machine_mode mode, rtx insn, + struct value_data *vd) { rtx x = *loc; RTX_CODE code = GET_CODE (x); @@ -1539,7 +1504,7 @@ replace_oldest_value_addr (loc, class, mode, insn, vd) return replace_oldest_value_mem (x, insn, vd); case REG: - return replace_oldest_value_reg (loc, class, insn, vd); + return replace_oldest_value_reg (loc, cl, insn, vd); default: break; @@ -1549,11 +1514,11 @@ replace_oldest_value_addr (loc, class, mode, insn, vd) for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--) { if (fmt[i] == 'e') - changed |= replace_oldest_value_addr (&XEXP (x, i), class, mode, + changed |= replace_oldest_value_addr (&XEXP (x, i), cl, mode, insn, vd); else if (fmt[i] == 'E') for (j = XVECLEN (x, i) - 1; j >= 0; j--) - changed |= replace_oldest_value_addr (&XVECEXP (x, i, j), class, + changed |= replace_oldest_value_addr (&XVECEXP (x, i, j), cl, mode, insn, vd); } @@ -1563,10 +1528,7 @@ replace_oldest_value_addr (loc, class, mode, insn, vd) /* Similar to replace_oldest_value_reg, but X contains a memory. */ static bool -replace_oldest_value_mem (x, insn, vd) - rtx x; - rtx insn; - struct value_data *vd; +replace_oldest_value_mem (rtx x, rtx insn, struct value_data *vd) { return replace_oldest_value_addr (&XEXP (x, 0), MODE_BASE_REG_CLASS (GET_MODE (x)), @@ -1576,14 +1538,12 @@ replace_oldest_value_mem (x, insn, vd) /* Perform the forward copy propagation on basic block BB. */ static bool -copyprop_hardreg_forward_1 (bb, vd) - basic_block bb; - struct value_data *vd; +copyprop_hardreg_forward_1 (basic_block bb, struct value_data *vd) { bool changed = false; rtx insn; - for (insn = bb->head; ; insn = NEXT_INSN (insn)) + for (insn = BB_HEAD (bb); ; insn = NEXT_INSN (insn)) { int n_ops, i, alt, predicated; bool is_asm; @@ -1591,7 +1551,7 @@ copyprop_hardreg_forward_1 (bb, vd) if (! INSN_P (insn)) { - if (insn == bb->end) + if (insn == BB_END (bb)) break; else continue; @@ -1615,7 +1575,7 @@ copyprop_hardreg_forward_1 (bb, vd) { int matches = recog_op_alt[i][alt].matches; if (matches >= 0) - recog_op_alt[i][alt].class = recog_op_alt[matches][alt].class; + recog_op_alt[i][alt].cl = recog_op_alt[matches][alt].cl; if (matches >= 0 || recog_op_alt[i][alt].matched >= 0 || (predicated && recog_data.operand_type[i] == OP_OUT)) recog_data.operand_type[i] = OP_INOUT; @@ -1654,8 +1614,8 @@ copyprop_hardreg_forward_1 (bb, vd) set it in, make sure that the replacement is valid. */ if (mode != vd->e[regno].mode) { - if (HARD_REGNO_NREGS (regno, mode) - > HARD_REGNO_NREGS (regno, vd->e[regno].mode)) + if (hard_regno_nregs[regno][mode] + > hard_regno_nregs[regno][vd->e[regno].mode]) goto no_move_special_case; } @@ -1666,8 +1626,8 @@ copyprop_hardreg_forward_1 (bb, vd) new = find_oldest_value_reg (REGNO_REG_CLASS (regno), src, vd); if (new && validate_change (insn, &SET_SRC (set), new, 0)) { - if (rtl_dump_file) - fprintf (rtl_dump_file, + if (dump_file) + fprintf (dump_file, "insn %u: replaced reg %u with %u\n", INSN_UID (insn), regno, REGNO (new)); changed = true; @@ -1686,8 +1646,9 @@ copyprop_hardreg_forward_1 (bb, vd) if (validate_change (insn, &SET_SRC (set), new, 0)) { ORIGINAL_REGNO (new) = ORIGINAL_REGNO (src); - if (rtl_dump_file) - fprintf (rtl_dump_file, + REG_ATTRS (new) = REG_ATTRS (src); + if (dump_file) + fprintf (dump_file, "insn %u: replaced reg %u with %u\n", INSN_UID (insn), regno, REGNO (new)); changed = true; @@ -1711,7 +1672,7 @@ copyprop_hardreg_forward_1 (bb, vd) continue; /* Don't replace in asms intentionally referencing hard regs. */ - if (is_asm && GET_CODE (recog_data.operand[i]) == REG + if (is_asm && REG_P (recog_data.operand[i]) && (REGNO (recog_data.operand[i]) == ORIGINAL_REGNO (recog_data.operand[i]))) continue; @@ -1721,18 +1682,18 @@ copyprop_hardreg_forward_1 (bb, vd) if (recog_op_alt[i][alt].is_address) replaced = replace_oldest_value_addr (recog_data.operand_loc[i], - recog_op_alt[i][alt].class, + recog_op_alt[i][alt].cl, VOIDmode, insn, vd); else if (REG_P (recog_data.operand[i])) replaced = replace_oldest_value_reg (recog_data.operand_loc[i], - recog_op_alt[i][alt].class, + recog_op_alt[i][alt].cl, insn, vd); - else if (GET_CODE (recog_data.operand[i]) == MEM) + else if (MEM_P (recog_data.operand[i])) replaced = replace_oldest_value_mem (recog_data.operand[i], insn, vd); } - else if (GET_CODE (recog_data.operand[i]) == MEM) + else if (MEM_P (recog_data.operand[i])) replaced = replace_oldest_value_mem (recog_data.operand[i], insn, vd); @@ -1754,10 +1715,10 @@ copyprop_hardreg_forward_1 (bb, vd) did_replacement: /* Clobber call-clobbered registers. */ - if (GET_CODE (insn) == CALL_INSN) + if (CALL_P (insn)) for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) if (TEST_HARD_REG_BIT (regs_invalidated_by_call, i)) - kill_value_regno (i, vd); + kill_value_regno (i, 1, vd); /* Notice stores. */ note_stores (PATTERN (insn), kill_set_value, vd); @@ -1766,7 +1727,7 @@ copyprop_hardreg_forward_1 (bb, vd) if (set && REG_P (SET_DEST (set)) && REG_P (SET_SRC (set))) copy_value (SET_DEST (set), SET_SRC (set), vd); - if (insn == bb->end) + if (insn == BB_END (bb)) break; } @@ -1776,11 +1737,11 @@ copyprop_hardreg_forward_1 (bb, vd) /* Main entry point for the forward copy propagation optimization. */ void -copyprop_hardreg_forward () +copyprop_hardreg_forward (void) { struct value_data *all_vd; bool need_refresh; - basic_block bb, bbp; + basic_block bb, bbp = 0; need_refresh = false; @@ -1791,7 +1752,7 @@ copyprop_hardreg_forward () /* If a block has a single predecessor, that we've already processed, begin with the value data that was live at the end of the predecessor block. */ - /* ??? Ought to use more intelligent queueing of blocks. */ + /* ??? Ought to use more intelligent queuing of blocks. */ if (bb->pred) for (bbp = bb; bbp && bbp != bb->pred->src; bbp = bbp->prev_bb); if (bb->pred @@ -1809,13 +1770,13 @@ copyprop_hardreg_forward () if (need_refresh) { - if (rtl_dump_file) - fputs ("\n\n", rtl_dump_file); + if (dump_file) + fputs ("\n\n", dump_file); /* ??? Irritatingly, delete_noop_moves does not take a set of blocks to scan, so we have to do a life update with no initial set of blocks Just In Case. */ - delete_noop_moves (get_insns ()); + delete_noop_moves (); update_life_info (NULL, UPDATE_LIFE_GLOBAL_RM_NOTES, PROP_DEATH_NOTES | PROP_SCAN_DEAD_CODE @@ -1828,8 +1789,7 @@ copyprop_hardreg_forward () /* Dump the value chain data to stderr. */ void -debug_value_data (vd) - struct value_data *vd; +debug_value_data (struct value_data *vd) { HARD_REG_SET set; unsigned int i, j; @@ -1884,8 +1844,7 @@ debug_value_data (vd) #ifdef ENABLE_CHECKING static void -validate_value_data (vd) - struct value_data *vd; +validate_value_data (struct value_data *vd) { HARD_REG_SET set; unsigned int i, j;