X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Fregrename.c;h=0ed810e639387df125308a75adc2a484568fa195;hb=559b071287596bbceeeffddd76a12ccfdb96a340;hp=f2ab1f10338307dcb3495d2966e0fe48e19a974e;hpb=d3129ae76f1d23b055609ef4791b08414db97491;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/regrename.c b/gcc/regrename.c index f2ab1f10338..0ed810e6393 100644 --- a/gcc/regrename.c +++ b/gcc/regrename.c @@ -1,12 +1,12 @@ /* Register renaming for the GNU compiler. - Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005 + Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc. This file is part of GCC. GCC is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2, or (at your option) + the Free Software Foundation; either version 3, or (at your option) any later version. GCC is distributed in the hope that it will be useful, but WITHOUT @@ -15,9 +15,8 @@ License for more details. You should have received a copy of the GNU General Public License - along with GCC; see the file COPYING. If not, write to the Free - Software Foundation, 59 Temple Place - Suite 330, Boston, MA - 02111-1307, USA. */ + along with GCC; see the file COPYING3. If not see + . */ #include "config.h" #include "system.h" @@ -27,6 +26,7 @@ #include "tm_p.h" #include "insn-config.h" #include "regs.h" +#include "addresses.h" #include "hard-reg-set.h" #include "basic-block.h" #include "reload.h" @@ -36,6 +36,9 @@ #include "flags.h" #include "toplev.h" #include "obstack.h" +#include "timevar.h" +#include "tree-pass.h" +#include "df.h" struct du_chain { @@ -56,7 +59,11 @@ enum scan_actions terminate_write, terminate_dead, mark_read, - mark_write + mark_write, + /* mark_access is for marking the destination regs in + REG_FRAME_RELATED_EXPR notes (as if they were read) so that the + note is updated properly. */ + mark_access }; static const char * const scan_actions_name[] = @@ -66,7 +73,8 @@ static const char * const scan_actions_name[] = "terminate_write", "terminate_dead", "mark_read", - "mark_write" + "mark_write", + "mark_access" }; static struct obstack rename_obstack; @@ -80,30 +88,26 @@ 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 note_sets (rtx, const_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 +/* Called through note_stores. Find sets of registers, and record them in *DATA (which is actually a HARD_REG_SET *). */ static void -note_sets (rtx x, rtx set ATTRIBUTE_UNUSED, void *data) +note_sets (rtx x, const_rtx set ATTRIBUTE_UNUSED, void *data) { HARD_REG_SET *pset = (HARD_REG_SET *) data; - unsigned int regno; - int nregs; + + if (GET_CODE (x) == SUBREG) + x = SUBREG_REG (x); if (!REG_P (x)) return; - regno = REGNO (x); - nregs = hard_regno_nregs[regno][GET_MODE (x)]; - /* There must not be pseudos at this point. */ - gcc_assert (regno + nregs <= FIRST_PSEUDO_REGISTER); - - while (nregs-- > 0) - SET_HARD_REG_BIT (*pset, regno + nregs); + gcc_assert (HARD_REGISTER_P (x)); + add_to_hard_reg_set (pset, GET_MODE (x), REGNO (x)); } /* Clear all registers from *PSET for which a note of kind KIND can be found @@ -117,14 +121,9 @@ clear_dead_regs (HARD_REG_SET *pset, enum machine_mode kind, rtx notes) if (REG_NOTE_KIND (note) == kind && REG_P (XEXP (note, 0))) { rtx reg = XEXP (note, 0); - unsigned int regno = REGNO (reg); - int nregs = hard_regno_nregs[regno][GET_MODE (reg)]; - /* There must not be pseudos at this point. */ - gcc_assert (regno + nregs <= FIRST_PSEUDO_REGISTER); - - while (nregs-- > 0) - CLEAR_HARD_REG_BIT (*pset, regno + nregs); + gcc_assert (HARD_REGISTER_P (reg)); + remove_from_hard_reg_set (pset, GET_MODE (reg), REGNO (reg)); } } @@ -139,7 +138,7 @@ merge_overlapping_regs (basic_block b, HARD_REG_SET *pset, rtx insn; HARD_REG_SET live; - REG_SET_TO_HARD_REG_SET (live, b->global_live_at_start); + REG_SET_TO_HARD_REG_SET (live, df_get_live_in (b)); insn = BB_HEAD (b); while (t) { @@ -174,7 +173,7 @@ merge_overlapping_regs (basic_block b, HARD_REG_SET *pset, /* Perform register renaming on the current function. */ -void +static void regrename_optimize (void) { int tick[FIRST_PSEUDO_REGISTER]; @@ -182,10 +181,15 @@ regrename_optimize (void) basic_block bb; char *first_obj; + df_set_flags (DF_LR_RUN_DCE); + df_note_add_problem (); + df_analyze (); + df_set_flags (DF_DEFER_INSN_RESCAN); + memset (tick, 0, sizeof tick); gcc_obstack_init (&rename_obstack); - first_obj = obstack_alloc (&rename_obstack, 0); + first_obj = XOBNEWVAR (&rename_obstack, char, 0); FOR_EACH_BB (bb) { @@ -207,14 +211,9 @@ regrename_optimize (void) /* Don't clobber traceback for noreturn functions. */ if (frame_pointer_needed) { - int i; - - for (i = hard_regno_nregs[FRAME_POINTER_REGNUM][Pmode]; i--;) - SET_HARD_REG_BIT (unavailable, FRAME_POINTER_REGNUM + i); - + add_to_hard_reg_set (&unavailable, Pmode, FRAME_POINTER_REGNUM); #if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM - for (i = hard_regno_nregs[HARD_FRAME_POINTER_REGNUM][Pmode]; i--;) - SET_HARD_REG_BIT (unavailable, HARD_FRAME_POINTER_REGNUM + i); + add_to_hard_reg_set (&unavailable, Pmode, HARD_FRAME_POINTER_REGNUM); #endif } @@ -223,13 +222,13 @@ regrename_optimize (void) { int new_reg, best_new_reg; int n_uses; - struct du_chain *this = all_chains; + struct du_chain *this_du = all_chains; struct du_chain *tmp, *last; HARD_REG_SET this_unavailable; - int reg = REGNO (*this->loc); + int reg = REGNO (*this_du->loc); int i; - all_chains = this->next_chain; + all_chains = this_du->next_chain; best_new_reg = reg; @@ -257,7 +256,7 @@ regrename_optimize (void) count number of uses, and narrow the set of registers we can use for renaming. */ n_uses = 0; - for (last = this; last->next_use; last = last->next_use) + for (last = this_du; last->next_use; last = last->next_use) { n_uses++; IOR_COMPL_HARD_REG_SET (this_unavailable, @@ -269,23 +268,23 @@ regrename_optimize (void) IOR_COMPL_HARD_REG_SET (this_unavailable, reg_class_contents[last->cl]); - if (this->need_caller_save_reg) + if (this_du->need_caller_save_reg) IOR_HARD_REG_SET (this_unavailable, call_used_reg_set); - merge_overlapping_regs (bb, &this_unavailable, this); + merge_overlapping_regs (bb, &this_unavailable, this_du); /* Now potential_regs is a reasonable approximation, let's 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_du->loc)]; for (i = nregs - 1; i >= 0; --i) if (TEST_HARD_REG_BIT (this_unavailable, new_reg + i) || fixed_regs[new_reg + i] || global_regs[new_reg + i] /* Can't use regs which aren't saved by the prologue. */ - || (! regs_ever_live[new_reg + i] + || (! df_regs_ever_live_p (new_reg + i) && ! call_used_regs[new_reg + i]) #ifdef LEAF_REGISTERS /* We can't use a non-leaf register if we're in a @@ -303,7 +302,7 @@ regrename_optimize (void) /* See whether it accepts all modes that occur in definition and uses. */ - for (tmp = this; tmp; tmp = tmp->next_use) + for (tmp = this_du; tmp; tmp = tmp->next_use) if (! HARD_REGNO_MODE_OK (new_reg, GET_MODE (*tmp->loc)) || (tmp->need_caller_save_reg && ! (HARD_REGNO_CALL_PART_CLOBBERED @@ -334,9 +333,9 @@ regrename_optimize (void) continue; } - do_replace (this, best_new_reg); + do_replace (this_du, best_new_reg); tick[best_new_reg] = ++this_tick; - regs_ever_live[best_new_reg] = 1; + df_set_regs_ever_live (best_new_reg, true); if (dump_file) fprintf (dump_file, ", renamed as %s\n", reg_names[best_new_reg]); @@ -349,10 +348,6 @@ regrename_optimize (void) if (dump_file) fputc ('\n', dump_file); - - count_or_remove_death_notes (NULL, 1); - update_life_info (NULL, UPDATE_LIFE_LOCAL, - PROP_DEATH_NOTES); } static void @@ -367,6 +362,7 @@ do_replace (struct du_chain *chain, int reg) if (regno >= FIRST_PSEUDO_REGISTER) ORIGINAL_REGNO (*chain->loc) = regno; REG_ATTRS (*chain->loc) = attr; + df_insn_rescan (chain->insn); chain = chain->next_use; } } @@ -389,27 +385,25 @@ scan_rtx_reg (rtx insn, rtx *loc, enum reg_class cl, { if (type == OP_OUT) { - 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->cl = cl; - this->need_caller_save_reg = 0; - this->earlyclobber = earlyclobber; - open_chains = this; + struct du_chain *this_du = XOBNEW (&rename_obstack, struct du_chain); + this_du->next_use = 0; + this_du->next_chain = open_chains; + this_du->loc = loc; + this_du->insn = insn; + this_du->cl = cl; + this_du->need_caller_save_reg = 0; + this_du->earlyclobber = earlyclobber; + open_chains = this_du; } return; } - if ((type == OP_OUT && action != terminate_write) - || (type != OP_OUT && action == terminate_write)) + if ((type == OP_OUT) != (action == terminate_write || action == mark_access)) return; for (p = &open_chains; *p;) { - struct du_chain *this = *p; + struct du_chain *this_du = *p; /* Check if the chain has been terminated if it has then skip to the next chain. @@ -418,22 +412,22 @@ scan_rtx_reg (rtx insn, rtx *loc, enum reg_class cl, the chain in Step 3, but are trying to hide in-out operands from terminate_write in Step 5. */ - if (*this->loc == cc0_rtx) - p = &this->next_chain; + if (*this_du->loc == cc0_rtx) + p = &this_du->next_chain; else { - int regno = REGNO (*this->loc); - int nregs = hard_regno_nregs[regno][GET_MODE (*this->loc)]; + int regno = REGNO (*this_du->loc); + int nregs = hard_regno_nregs[regno][GET_MODE (*this_du->loc)]; int exact_match = (regno == this_regno && nregs == this_nregs); if (regno + nregs <= this_regno || this_regno + this_nregs <= regno) { - p = &this->next_chain; + p = &this_du->next_chain; continue; } - if (action == mark_read) + if (action == mark_read || action == mark_access) { gcc_assert (exact_match); @@ -443,23 +437,23 @@ scan_rtx_reg (rtx insn, rtx *loc, enum reg_class cl, be replaced with, terminate the chain. */ if (cl != NO_REGS) { - 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->cl = cl; - this->need_caller_save_reg = 0; + this_du = XOBNEW (&rename_obstack, struct du_chain); + this_du->next_use = 0; + this_du->next_chain = (*p)->next_chain; + this_du->loc = loc; + this_du->insn = insn; + this_du->cl = cl; + this_du->need_caller_save_reg = 0; while (*p) p = &(*p)->next_use; - *p = this; + *p = this_du; return; } } if (action != terminate_overlapping_read || ! exact_match) { - struct du_chain *next = this->next_chain; + struct du_chain *next = this_du->next_chain; /* Whether the terminated chain can be used for renaming depends on the action and this being an exact match. @@ -468,12 +462,12 @@ scan_rtx_reg (rtx insn, rtx *loc, enum reg_class cl, if ((action == terminate_dead || action == terminate_write) && exact_match) { - this->next_chain = closed_chains; - closed_chains = this; + this_du->next_chain = closed_chains; + closed_chains = this_du; if (dump_file) fprintf (dump_file, "Closing chain %s at insn %d (%s)\n", - reg_names[REGNO (*this->loc)], INSN_UID (insn), + reg_names[REGNO (*this_du->loc)], INSN_UID (insn), scan_actions_name[(int) action]); } else @@ -481,13 +475,13 @@ scan_rtx_reg (rtx insn, rtx *loc, enum reg_class cl, if (dump_file) fprintf (dump_file, "Discarding chain %s at insn %d (%s)\n", - reg_names[REGNO (*this->loc)], INSN_UID (insn), + reg_names[REGNO (*this_du->loc)], INSN_UID (insn), scan_actions_name[(int) action]); } *p = next; } else - p = &this->next_chain; + p = &this_du->next_chain; } } } @@ -504,7 +498,7 @@ scan_rtx_address (rtx insn, rtx *loc, enum reg_class cl, const char *fmt; int i, j; - if (action == mark_write) + if (action == mark_write || action == mark_access) return; switch (code) @@ -519,7 +513,7 @@ scan_rtx_address (rtx insn, rtx *loc, enum reg_class cl, rtx op1 = orig_op1; rtx *locI = NULL; rtx *locB = NULL; - rtx *locB_reg = NULL; + enum rtx_code index_code = SCRATCH; if (GET_CODE (op0) == SUBREG) { @@ -538,59 +532,69 @@ scan_rtx_address (rtx insn, rtx *loc, enum reg_class cl, { locI = &XEXP (x, 0); locB = &XEXP (x, 1); + index_code = GET_CODE (*locI); } else if (code1 == MULT || code1 == SIGN_EXTEND || code1 == TRUNCATE || code1 == ZERO_EXTEND || code0 == MEM) { locI = &XEXP (x, 1); locB = &XEXP (x, 0); + index_code = GET_CODE (*locI); } else if (code0 == CONST_INT || code0 == CONST || code0 == SYMBOL_REF || code0 == LABEL_REF) - locB = &XEXP (x, 1); + { + locB = &XEXP (x, 1); + index_code = GET_CODE (XEXP (x, 0)); + } else if (code1 == CONST_INT || code1 == CONST || code1 == SYMBOL_REF || code1 == LABEL_REF) - locB = &XEXP (x, 0); + { + locB = &XEXP (x, 0); + index_code = GET_CODE (XEXP (x, 1)); + } else if (code0 == REG && code1 == REG) { int index_op; + unsigned regno0 = REGNO (op0), regno1 = REGNO (op1); - if (REG_OK_FOR_INDEX_P (op0) - && REG_MODE_OK_FOR_REG_BASE_P (op1, mode)) - index_op = 0; - else if (REG_OK_FOR_INDEX_P (op1) - && REG_MODE_OK_FOR_REG_BASE_P (op0, mode)) + if (REGNO_OK_FOR_INDEX_P (regno1) + && regno_ok_for_base_p (regno0, mode, PLUS, REG)) index_op = 1; - else if (REG_MODE_OK_FOR_REG_BASE_P (op1, mode)) + else if (REGNO_OK_FOR_INDEX_P (regno0) + && regno_ok_for_base_p (regno1, mode, PLUS, REG)) index_op = 0; - else if (REG_MODE_OK_FOR_REG_BASE_P (op0, mode)) - index_op = 1; - else if (REG_OK_FOR_INDEX_P (op1)) + else if (regno_ok_for_base_p (regno0, mode, PLUS, REG) + || REGNO_OK_FOR_INDEX_P (regno1)) index_op = 1; - else + else if (regno_ok_for_base_p (regno1, mode, PLUS, REG)) index_op = 0; + else + index_op = 1; locI = &XEXP (x, index_op); - locB_reg = &XEXP (x, !index_op); + locB = &XEXP (x, !index_op); + index_code = GET_CODE (*locI); } else if (code0 == REG) { locI = &XEXP (x, 0); locB = &XEXP (x, 1); + index_code = GET_CODE (*locI); } else if (code1 == REG) { locI = &XEXP (x, 1); locB = &XEXP (x, 0); + index_code = GET_CODE (*locI); } if (locI) scan_rtx_address (insn, locI, INDEX_REG_CLASS, action, mode); if (locB) - scan_rtx_address (insn, locB, MODE_BASE_REG_CLASS (mode), action, mode); - if (locB_reg) - scan_rtx_address (insn, locB_reg, MODE_BASE_REG_REG_CLASS (mode), + scan_rtx_address (insn, locB, base_reg_class (mode, PLUS, index_code), action, mode); + return; } @@ -609,7 +613,7 @@ scan_rtx_address (rtx insn, rtx *loc, enum reg_class cl, case MEM: scan_rtx_address (insn, &XEXP (x, 0), - MODE_BASE_REG_CLASS (GET_MODE (x)), action, + base_reg_class (GET_MODE (x), MEM, SCRATCH), action, GET_MODE (x)); return; @@ -647,6 +651,7 @@ scan_rtx (rtx insn, rtx *loc, enum reg_class cl, case CONST: case CONST_INT: case CONST_DOUBLE: + case CONST_FIXED: case CONST_VECTOR: case SYMBOL_REF: case LABEL_REF: @@ -660,7 +665,7 @@ scan_rtx (rtx insn, rtx *loc, enum reg_class cl, case MEM: scan_rtx_address (insn, &XEXP (x, 0), - MODE_BASE_REG_CLASS (GET_MODE (x)), action, + base_reg_class (GET_MODE (x), MEM, SCRATCH), action, GET_MODE (x)); return; @@ -799,16 +804,8 @@ build_def_use (basic_block bb) } for (i = 0; i < recog_data.n_dups; i++) { - int dup_num = recog_data.dup_num[i]; - old_dups[i] = *recog_data.dup_loc[i]; *recog_data.dup_loc[i] = cc0_rtx; - - /* For match_dup of match_operator or match_parallel, share - them, so that we don't miss changes in the dup. */ - if (icode >= 0 - && insn_data[icode].operand[dup_num].eliminable == 0) - old_dups[i] = recog_data.operand[dup_num]; } scan_rtx (insn, &PATTERN (insn), NO_REGS, terminate_all_read, @@ -818,6 +815,8 @@ build_def_use (basic_block bb) *recog_data.dup_loc[i] = old_dups[i]; for (i = 0; i < n_ops; i++) *recog_data.operand_loc[i] = old_operands[i]; + if (recog_data.n_dups) + df_insn_rescan (insn); /* Step 2B: Can't rename function call argument registers. */ if (CALL_P (insn) && CALL_INSN_FUNCTION_USAGE (insn)) @@ -861,17 +860,19 @@ build_def_use (basic_block bb) scan_rtx (insn, loc, cl, mark_read, type, 0); } - /* Step 4: Close chains for registers that die here. - Also record updates for REG_INC notes. */ + /* Step 3B: Record updates for regs in REG_INC notes, and + source regs in REG_FRAME_RELATED_EXPR notes. */ for (note = REG_NOTES (insn); note; note = XEXP (note, 1)) - { - if (REG_NOTE_KIND (note) == REG_DEAD) - scan_rtx (insn, &XEXP (note, 0), NO_REGS, terminate_dead, - OP_IN, 0); - else if (REG_NOTE_KIND (note) == REG_INC) - scan_rtx (insn, &XEXP (note, 0), ALL_REGS, mark_read, - OP_INOUT, 0); - } + if (REG_NOTE_KIND (note) == REG_INC + || REG_NOTE_KIND (note) == REG_FRAME_RELATED_EXPR) + scan_rtx (insn, &XEXP (note, 0), ALL_REGS, mark_read, + OP_INOUT, 0); + + /* Step 4: Close chains for registers that die here. */ + for (note = REG_NOTES (insn); note; note = XEXP (note, 1)) + if (REG_NOTE_KIND (note) == REG_DEAD) + scan_rtx (insn, &XEXP (note, 0), NO_REGS, terminate_dead, + OP_IN, 0); /* Step 4B: If this is a call, any chain live at this point requires a caller-saved reg. */ @@ -944,6 +945,13 @@ build_def_use (basic_block bb) recog_op_alt[opn][alt].earlyclobber); } + /* Step 6B: Record destination regs in REG_FRAME_RELATED_EXPR + notes for update. */ + for (note = REG_NOTES (insn); note; note = XEXP (note, 1)) + if (REG_NOTE_KIND (note) == REG_FRAME_RELATED_EXPR) + scan_rtx (insn, &XEXP (note, 0), ALL_REGS, mark_access, + OP_INOUT, 0); + /* Step 7: Close chains for registers that were never really used here. */ for (note = REG_NOTES (insn); note; note = XEXP (note, 1)) @@ -968,15 +976,15 @@ 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)]; + struct du_chain *this_du = chains; + int r = REGNO (*this_du->loc); + int nregs = hard_regno_nregs[r][GET_MODE (*this_du->loc)]; fprintf (dump_file, "Register %s (%d):", reg_names[r], nregs); - while (this) + while (this_du) { - fprintf (dump_file, " %d [%s]", INSN_UID (this->insn), - reg_class_names[this->cl]); - this = this->next_use; + fprintf (dump_file, " %d [%s]", INSN_UID (this_du->insn), + reg_class_names[this_du->cl]); + this_du = this_du->next_use; } fprintf (dump_file, "\n"); chains = chains->next_chain; @@ -1013,8 +1021,8 @@ 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 void kill_clobbered_value (rtx, const_rtx, void *); +static void kill_set_value (rtx, const_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, @@ -1154,9 +1162,9 @@ init_value_data (struct value_data *vd) /* Called through note_stores. If X is clobbered, kill its value. */ static void -kill_clobbered_value (rtx x, rtx set, void *data) +kill_clobbered_value (rtx x, const_rtx set, void *data) { - struct value_data *vd = data; + struct value_data *const vd = (struct value_data *) data; if (GET_CODE (set) == CLOBBER) kill_value (x, vd); } @@ -1165,9 +1173,9 @@ kill_clobbered_value (rtx x, rtx set, void *data) current value and install it as the root of its own value list. */ static void -kill_set_value (rtx x, rtx set, void *data) +kill_set_value (rtx x, const_rtx set, void *data) { - struct value_data *vd = data; + struct value_data *const vd = (struct value_data *) data; if (GET_CODE (set) != CLOBBER) { kill_value (x, vd); @@ -1184,7 +1192,7 @@ static int kill_autoinc_value (rtx *px, void *data) { rtx x = *px; - struct value_data *vd = data; + struct value_data *const vd = (struct value_data *) data; if (GET_RTX_CLASS (GET_CODE (x)) == RTX_AUTOINC) { @@ -1222,6 +1230,12 @@ copy_value (rtx dest, rtx src, struct value_data *vd) if (frame_pointer_needed && dr == HARD_FRAME_POINTER_REGNUM) return; + /* Do not propagate copies to fixed or global registers, patterns + can be relying to see particular fixed register or users can + expect the chosen global register in asm. */ + if (fixed_regs[dr] || global_regs[dr]) + 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)]; @@ -1351,19 +1365,17 @@ find_oldest_value_reg (enum reg_class cl, rtx reg, struct value_data *vd) for (i = vd->e[regno].oldest_regno; i != regno; i = vd->e[i].next_regno) { enum machine_mode oldmode = vd->e[i].mode; - rtx new; - unsigned int last; + rtx new_rtx; - for (last = i; last < i + hard_regno_nregs[i][mode]; last++) - if (!TEST_HARD_REG_BIT (reg_class_contents[cl], last)) - return NULL_RTX; + if (!in_hard_reg_set_p (reg_class_contents[cl], mode, i)) + return NULL_RTX; - new = maybe_mode_change (oldmode, vd->e[regno].mode, mode, i, regno); - if (new) + new_rtx = maybe_mode_change (oldmode, vd->e[regno].mode, mode, i, regno); + if (new_rtx) { - ORIGINAL_REGNO (new) = ORIGINAL_REGNO (reg); - REG_ATTRS (new) = REG_ATTRS (reg); - return new; + ORIGINAL_REGNO (new_rtx) = ORIGINAL_REGNO (reg); + REG_ATTRS (new_rtx) = REG_ATTRS (reg); + return new_rtx; } } @@ -1377,14 +1389,14 @@ static bool replace_oldest_value_reg (rtx *loc, enum reg_class cl, rtx insn, struct value_data *vd) { - rtx new = find_oldest_value_reg (cl, *loc, vd); - if (new) + rtx new_rtx = find_oldest_value_reg (cl, *loc, vd); + if (new_rtx) { if (dump_file) fprintf (dump_file, "insn %u: replaced reg %u with %u\n", - INSN_UID (insn), REGNO (*loc), REGNO (new)); + INSN_UID (insn), REGNO (*loc), REGNO (new_rtx)); - *loc = new; + validate_change (insn, loc, new_rtx, 1); return true; } return false; @@ -1417,7 +1429,7 @@ replace_oldest_value_addr (rtx *loc, enum reg_class cl, rtx op1 = orig_op1; rtx *locI = NULL; rtx *locB = NULL; - rtx *locB_reg = NULL; + enum rtx_code index_code = SCRATCH; if (GET_CODE (op0) == SUBREG) { @@ -1436,50 +1448,61 @@ replace_oldest_value_addr (rtx *loc, enum reg_class cl, { locI = &XEXP (x, 0); locB = &XEXP (x, 1); + index_code = GET_CODE (*locI); } else if (code1 == MULT || code1 == SIGN_EXTEND || code1 == TRUNCATE || code1 == ZERO_EXTEND || code0 == MEM) { locI = &XEXP (x, 1); locB = &XEXP (x, 0); + index_code = GET_CODE (*locI); } else if (code0 == CONST_INT || code0 == CONST || code0 == SYMBOL_REF || code0 == LABEL_REF) - locB = &XEXP (x, 1); + { + locB = &XEXP (x, 1); + index_code = GET_CODE (XEXP (x, 0)); + } else if (code1 == CONST_INT || code1 == CONST || code1 == SYMBOL_REF || code1 == LABEL_REF) - locB = &XEXP (x, 0); + { + locB = &XEXP (x, 0); + index_code = GET_CODE (XEXP (x, 1)); + } else if (code0 == REG && code1 == REG) { int index_op; + unsigned regno0 = REGNO (op0), regno1 = REGNO (op1); - if (REG_OK_FOR_INDEX_P (op0) - && REG_MODE_OK_FOR_REG_BASE_P (op1, mode)) - index_op = 0; - else if (REG_OK_FOR_INDEX_P (op1) - && REG_MODE_OK_FOR_REG_BASE_P (op0, mode)) + if (REGNO_OK_FOR_INDEX_P (regno1) + && regno_ok_for_base_p (regno0, mode, PLUS, REG)) index_op = 1; - else if (REG_MODE_OK_FOR_REG_BASE_P (op1, mode)) + else if (REGNO_OK_FOR_INDEX_P (regno0) + && regno_ok_for_base_p (regno1, mode, PLUS, REG)) index_op = 0; - else if (REG_MODE_OK_FOR_REG_BASE_P (op0, mode)) + else if (regno_ok_for_base_p (regno0, mode, PLUS, REG) + || REGNO_OK_FOR_INDEX_P (regno1)) index_op = 1; - else if (REG_OK_FOR_INDEX_P (op1)) - index_op = 1; - else + else if (regno_ok_for_base_p (regno1, mode, PLUS, REG)) index_op = 0; + else + index_op = 1; locI = &XEXP (x, index_op); - locB_reg = &XEXP (x, !index_op); + locB = &XEXP (x, !index_op); + index_code = GET_CODE (*locI); } else if (code0 == REG) { locI = &XEXP (x, 0); locB = &XEXP (x, 1); + index_code = GET_CODE (*locI); } else if (code1 == REG) { locI = &XEXP (x, 1); locB = &XEXP (x, 0); + index_code = GET_CODE (*locI); } if (locI) @@ -1487,11 +1510,8 @@ replace_oldest_value_addr (rtx *loc, enum reg_class cl, insn, vd); if (locB) changed |= replace_oldest_value_addr (locB, - MODE_BASE_REG_CLASS (mode), - mode, insn, vd); - if (locB_reg) - changed |= replace_oldest_value_addr (locB_reg, - MODE_BASE_REG_REG_CLASS (mode), + base_reg_class (mode, PLUS, + index_code), mode, insn, vd); return changed; } @@ -1535,7 +1555,8 @@ static bool 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)), + base_reg_class (GET_MODE (x), MEM, + SCRATCH), GET_MODE (x), insn, vd); } @@ -1550,8 +1571,9 @@ copyprop_hardreg_forward_1 (basic_block bb, struct value_data *vd) for (insn = BB_HEAD (bb); ; insn = NEXT_INSN (insn)) { int n_ops, i, alt, predicated; - bool is_asm; + bool is_asm, any_replacements; rtx set; + bool replaced[MAX_RECOG_OPERANDS]; if (! INSN_P (insn)) { @@ -1612,7 +1634,7 @@ copyprop_hardreg_forward_1 (basic_block bb, struct value_data *vd) unsigned int regno = REGNO (src); enum machine_mode mode = GET_MODE (src); unsigned int i; - rtx new; + rtx new_rtx; /* If we are accessing SRC in some mode other that what we set it in, make sure that the replacement is valid. */ @@ -1627,13 +1649,13 @@ copyprop_hardreg_forward_1 (basic_block bb, struct value_data *vd) register in the same class. */ if (REG_P (SET_DEST (set))) { - new = find_oldest_value_reg (REGNO_REG_CLASS (regno), src, vd); - if (new && validate_change (insn, &SET_SRC (set), new, 0)) + new_rtx = find_oldest_value_reg (REGNO_REG_CLASS (regno), src, vd); + if (new_rtx && validate_change (insn, &SET_SRC (set), new_rtx, 0)) { if (dump_file) fprintf (dump_file, "insn %u: replaced reg %u with %u\n", - INSN_UID (insn), regno, REGNO (new)); + INSN_UID (insn), regno, REGNO (new_rtx)); changed = true; goto did_replacement; } @@ -1643,18 +1665,18 @@ copyprop_hardreg_forward_1 (basic_block bb, struct value_data *vd) for (i = vd->e[regno].oldest_regno; i != regno; i = vd->e[i].next_regno) { - new = maybe_mode_change (vd->e[i].mode, vd->e[regno].mode, + new_rtx = maybe_mode_change (vd->e[i].mode, vd->e[regno].mode, mode, i, regno); - if (new != NULL_RTX) + if (new_rtx != NULL_RTX) { - if (validate_change (insn, &SET_SRC (set), new, 0)) + if (validate_change (insn, &SET_SRC (set), new_rtx, 0)) { - ORIGINAL_REGNO (new) = ORIGINAL_REGNO (src); - REG_ATTRS (new) = REG_ATTRS (src); + ORIGINAL_REGNO (new_rtx) = ORIGINAL_REGNO (src); + REG_ATTRS (new_rtx) = REG_ATTRS (src); if (dump_file) fprintf (dump_file, "insn %u: replaced reg %u with %u\n", - INSN_UID (insn), regno, REGNO (new)); + INSN_UID (insn), regno, REGNO (new_rtx)); changed = true; goto did_replacement; } @@ -1663,11 +1685,13 @@ copyprop_hardreg_forward_1 (basic_block bb, struct value_data *vd) } no_move_special_case: + any_replacements = false; + /* For each input operand, replace a hard register with the eldest live copy that's in an appropriate register class. */ for (i = 0; i < n_ops; i++) { - bool replaced = false; + replaced[i] = false; /* Don't scan match_operand here, since we've no reg class information to pass down. Any operands that we could @@ -1684,39 +1708,59 @@ copyprop_hardreg_forward_1 (basic_block bb, struct value_data *vd) if (recog_data.operand_type[i] == OP_IN) { if (recog_op_alt[i][alt].is_address) - replaced + replaced[i] = replace_oldest_value_addr (recog_data.operand_loc[i], recog_op_alt[i][alt].cl, VOIDmode, insn, vd); else if (REG_P (recog_data.operand[i])) - replaced + replaced[i] = replace_oldest_value_reg (recog_data.operand_loc[i], recog_op_alt[i][alt].cl, insn, vd); else if (MEM_P (recog_data.operand[i])) - replaced = replace_oldest_value_mem (recog_data.operand[i], - insn, vd); + replaced[i] = replace_oldest_value_mem (recog_data.operand[i], + insn, vd); } else if (MEM_P (recog_data.operand[i])) - replaced = replace_oldest_value_mem (recog_data.operand[i], - insn, vd); + replaced[i] = replace_oldest_value_mem (recog_data.operand[i], + insn, vd); /* If we performed any replacement, update match_dups. */ - if (replaced) + if (replaced[i]) { int j; - rtx new; - - changed = true; + rtx new_rtx; - new = *recog_data.operand_loc[i]; - recog_data.operand[i] = new; + new_rtx = *recog_data.operand_loc[i]; + recog_data.operand[i] = new_rtx; for (j = 0; j < recog_data.n_dups; j++) if (recog_data.dup_num[j] == i) - *recog_data.dup_loc[j] = new; + validate_unshare_change (insn, recog_data.dup_loc[j], new_rtx, 1); + + any_replacements = true; } } + if (any_replacements) + { + if (! apply_change_group ()) + { + for (i = 0; i < n_ops; i++) + if (replaced[i]) + { + rtx old = *recog_data.operand_loc[i]; + recog_data.operand[i] = old; + } + + if (dump_file) + fprintf (dump_file, + "insn %u: reg replacements not verified\n", + INSN_UID (insn)); + } + else + changed = true; + } + did_replacement: /* Clobber call-clobbered registers. */ if (CALL_P (insn)) @@ -1740,58 +1784,37 @@ copyprop_hardreg_forward_1 (basic_block bb, struct value_data *vd) /* Main entry point for the forward copy propagation optimization. */ -void +static void copyprop_hardreg_forward (void) { struct value_data *all_vd; - bool need_refresh; basic_block bb; sbitmap visited; - need_refresh = false; - - all_vd = xmalloc (sizeof (struct value_data) * last_basic_block); + all_vd = XNEWVEC (struct value_data, last_basic_block); - visited = sbitmap_alloc (last_basic_block - (INVALID_BLOCK + 1)); + visited = sbitmap_alloc (last_basic_block); sbitmap_zero (visited); FOR_EACH_BB (bb) { - SET_BIT (visited, bb->index - (INVALID_BLOCK + 1)); + SET_BIT (visited, bb->index); /* 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 queuing of blocks. */ - if (EDGE_COUNT (bb->preds) == 1 - && TEST_BIT (visited, - EDGE_PRED (bb, 0)->src->index - (INVALID_BLOCK + 1)) - && ! (EDGE_PRED (bb, 0)->flags & (EDGE_ABNORMAL_CALL | EDGE_EH))) - all_vd[bb->index] = all_vd[EDGE_PRED (bb, 0)->src->index]; + if (single_pred_p (bb) + && TEST_BIT (visited, single_pred (bb)->index) + && ! (single_pred_edge (bb)->flags & (EDGE_ABNORMAL_CALL | EDGE_EH))) + all_vd[bb->index] = all_vd[single_pred (bb)->index]; else init_value_data (all_vd + bb->index); - if (copyprop_hardreg_forward_1 (bb, all_vd + bb->index)) - need_refresh = true; + copyprop_hardreg_forward_1 (bb, all_vd + bb->index); } sbitmap_free (visited); - - if (need_refresh) - { - 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 (); - update_life_info (NULL, UPDATE_LIFE_GLOBAL_RM_NOTES, - PROP_DEATH_NOTES - | PROP_SCAN_DEAD_CODE - | PROP_KILL_DEAD_CODE); - } - free (all_vd); } @@ -1898,3 +1921,73 @@ validate_value_data (struct value_data *vd) vd->e[i].next_regno); } #endif + +static bool +gate_handle_regrename (void) +{ + return (optimize > 0 && (flag_rename_registers)); +} + + +/* Run the regrename and cprop passes. */ +static unsigned int +rest_of_handle_regrename (void) +{ + regrename_optimize (); + return 0; +} + +struct rtl_opt_pass pass_regrename = +{ + { + RTL_PASS, + "rnreg", /* name */ + gate_handle_regrename, /* gate */ + rest_of_handle_regrename, /* execute */ + NULL, /* sub */ + NULL, /* next */ + 0, /* static_pass_number */ + TV_RENAME_REGISTERS, /* tv_id */ + 0, /* properties_required */ + 0, /* properties_provided */ + 0, /* properties_destroyed */ + 0, /* todo_flags_start */ + TODO_df_finish | TODO_verify_rtl_sharing | + TODO_dump_func /* todo_flags_finish */ + } +}; + +static bool +gate_handle_cprop (void) +{ + return (optimize > 0 && (flag_cprop_registers)); +} + + +/* Run the regrename and cprop passes. */ +static unsigned int +rest_of_handle_cprop (void) +{ + copyprop_hardreg_forward (); + return 0; +} + +struct rtl_opt_pass pass_cprop_hardreg = +{ + { + RTL_PASS, + "cprop_hardreg", /* name */ + gate_handle_cprop, /* gate */ + rest_of_handle_cprop, /* execute */ + NULL, /* sub */ + NULL, /* next */ + 0, /* static_pass_number */ + TV_RENAME_REGISTERS, /* tv_id */ + 0, /* properties_required */ + 0, /* properties_provided */ + 0, /* properties_destroyed */ + 0, /* todo_flags_start */ + TODO_dump_func | TODO_verify_rtl_sharing /* todo_flags_finish */ + } +}; +