X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Fregrename.c;h=03aba8073a2fd6eb8ffebfdaad648c9d00bc5924;hb=81540bae22fbff1c51ccdb4952b0c7d1ab144c2c;hp=5a80a90eb83911f3c86050de44e0600be00e96d5;hpb=d90b3d04fca5bcaf406e6e3747b11c8a9295c42b;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/regrename.c b/gcc/regrename.c index 5a80a90eb83..03aba8073a2 100644 --- a/gcc/regrename.c +++ b/gcc/regrename.c @@ -1,11 +1,12 @@ /* Register renaming for the GNU compiler. - Copyright (C) 2000, 2001, 2002 Free Software Foundation, Inc. + Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 + 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 @@ -14,18 +15,18 @@ 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. */ - -#define REG_OK_STRICT + along with GCC; see the file COPYING3. If not see + . */ #include "config.h" #include "system.h" +#include "coretypes.h" +#include "tm.h" #include "rtl.h" #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" @@ -35,12 +36,9 @@ #include "flags.h" #include "toplev.h" #include "obstack.h" - -#ifndef REG_MODE_OK_FOR_BASE_P -#define REG_MODE_OK_FOR_BASE_P(REGNO, MODE) REG_OK_FOR_BASE_P (REGNO) -#endif - -static const char *const reg_class_names[] = REG_CLASS_NAMES; +#include "timevar.h" +#include "tree-pass.h" +#include "df.h" struct du_chain { @@ -49,7 +47,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; }; @@ -61,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[] = @@ -71,73 +73,57 @@ static const char * const scan_actions_name[] = "terminate_write", "terminate_dead", "mark_read", - "mark_write" + "mark_write", + "mark_access" }; 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 *)); - -/* Called through note_stores from update_life. Find sets of registers, and +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, const_rtx, void *); +static void clear_dead_regs (HARD_REG_SET *, enum reg_note, rtx); +static void merge_overlapping_regs (basic_block, HARD_REG_SET *, + struct du_chain *); + +/* Called through note_stores. 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, const_rtx set ATTRIBUTE_UNUSED, void *data) { HARD_REG_SET *pset = (HARD_REG_SET *) data; - unsigned int regno; - int nregs; - if (GET_CODE (x) != REG) - return; - regno = REGNO (x); - nregs = HARD_REGNO_NREGS (regno, GET_MODE (x)); + if (GET_CODE (x) == SUBREG) + x = SUBREG_REG (x); + if (!REG_P (x)) + return; /* There must not be pseudos at this point. */ - if (regno + nregs > FIRST_PSEUDO_REGISTER) - abort (); - - 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 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 reg_note kind, rtx notes) { rtx note; for (note = notes; note; note = XEXP (note, 1)) 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. */ - if (regno + nregs > FIRST_PSEUDO_REGISTER) - abort (); - - 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)); } } @@ -145,17 +131,22 @@ 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; + df_ref *def_rec; - REG_SET_TO_HARD_REG_SET (live, b->global_live_at_start); - insn = b->head; + REG_SET_TO_HARD_REG_SET (live, df_get_live_in (b)); + for (def_rec = df_get_artificial_defs (b->index); *def_rec; def_rec++) + { + df_ref def = *def_rec; + if (DF_REF_FLAGS (def) & DF_REF_AT_TOP) + SET_HARD_REG_BIT (live, DF_REF_REGNO (def)); + } + insn = BB_HEAD (b); while (t) { /* Search forward until the next reference to the register to be @@ -189,18 +180,23 @@ merge_overlapping_regs (b, pset, chain) /* Perform register renaming on the current function. */ -void -regrename_optimize () +static unsigned int +regrename_optimize (void) { int tick[FIRST_PSEUDO_REGISTER]; int this_tick = 0; 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 = (char *) obstack_alloc (&rename_obstack, 0); + first_obj = XOBNEWVAR (&rename_obstack, char, 0); FOR_EACH_BB (bb) { @@ -210,41 +206,38 @@ 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); /* 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 } 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; + struct du_chain *this_du = all_chains; + struct du_chain *tmp; 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; #if 0 /* This just disables optimization opportunities. */ /* Only rename once we've seen the reg more than once. */ @@ -266,39 +259,38 @@ regrename_optimize () COPY_HARD_REG_SET (this_unavailable, unavailable); - /* Find last entry on chain (which has the need_caller_save bit), - count number of uses, and narrow the set of registers we can + /* 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 (tmp = this_du; tmp; tmp = tmp->next_use) { + if (DEBUG_INSN_P (tmp->insn)) + continue; n_uses++; IOR_COMPL_HARD_REG_SET (this_unavailable, - reg_class_contents[last->class]); + reg_class_contents[tmp->cl]); } - if (n_uses < 1) - continue; - IOR_COMPL_HARD_REG_SET (this_unavailable, - reg_class_contents[last->class]); + if (n_uses < 2) + continue; - 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 @@ -316,8 +308,9 @@ regrename_optimize () /* See whether it accepts all modes that occur in definition and uses. */ - for (tmp = this; tmp; tmp = tmp->next_use) - if (! HARD_REGNO_MODE_OK (new_reg, GET_MODE (*tmp->loc)) + for (tmp = this_du; tmp; tmp = tmp->next_use) + if ((! HARD_REGNO_MODE_OK (new_reg, GET_MODE (*tmp->loc)) + && ! DEBUG_INSN_P (tmp->insn)) || (tmp->need_caller_save_reg && ! (HARD_REGNO_CALL_PART_CLOBBERED (reg, GET_MODE (*tmp->loc))) @@ -326,32 +319,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", - reg_names[reg], INSN_UID (last->insn)); - if (last->need_caller_save_reg) - fprintf (rtl_dump_file, " crosses a call"); + fprintf (dump_file, "Register %s in insn %d", + reg_names[reg], INSN_UID (this_du->insn)); + if (this_du->need_caller_save_reg) + 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++; + if (dump_file) + fprintf (dump_file, ", renamed as %s\n", reg_names[best_new_reg]); - if (rtl_dump_file) - fprintf (rtl_dump_file, ", renamed as %s\n", reg_names[best_new_reg]); + do_replace (this_du, best_new_reg); + tick[best_new_reg] = ++this_tick; + df_set_regs_ever_live (best_new_reg, true); } obstack_free (&rename_obstack, first_obj); @@ -359,25 +353,37 @@ 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); + return 0; } static void -do_replace (chain, reg) - struct du_chain *chain; - int reg; +do_replace (struct du_chain *chain, int reg) { + unsigned int base_regno = REGNO (*chain->loc); + + gcc_assert (! DEBUG_INSN_P (chain->insn)); + while (chain) { unsigned int regno = ORIGINAL_REGNO (*chain->loc); - *chain->loc = gen_raw_REG (GET_MODE (*chain->loc), reg); - if (regno >= FIRST_PSEUDO_REGISTER) - ORIGINAL_REGNO (*chain->loc) = regno; + struct reg_attrs * attr = REG_ATTRS (*chain->loc); + int reg_ptr = REG_POINTER (*chain->loc); + + if (DEBUG_INSN_P (chain->insn) && REGNO (*chain->loc) != base_regno) + INSN_VAR_LOCATION_LOC (chain->insn) = gen_rtx_UNKNOWN_VAR_LOC (); + else + { + *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; + REG_POINTER (*chain->loc) = reg_ptr; + } + + df_insn_rescan (chain->insn); chain = chain->next_use; } } @@ -387,45 +393,38 @@ 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)); - this->next_use = 0; - this->next_chain = open_chains; - this->loc = loc; - this->insn = insn; - this->class = class; - 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. @@ -434,50 +433,48 @@ scan_rtx_reg (insn, loc, class, action, type, earlyclobber) 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) { - if (! exact_match) - abort (); + gcc_assert (exact_match || DEBUG_INSN_P (insn)); /* ??? Class NO_REGS can happen if the md file makes use of 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->next_use = 0; - this->next_chain = (*p)->next_chain; - this->loc = loc; - this->insn = insn; - this->class = class; - 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. @@ -486,47 +483,43 @@ scan_rtx_reg (insn, loc, class, action, type, earlyclobber) if ((action == terminate_dead || action == terminate_write) && exact_match) { - this->next_chain = closed_chains; - closed_chains = this; - if (rtl_dump_file) - fprintf (rtl_dump_file, + 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 { - 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), + 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; } } } -/* 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); const char *fmt; int i, j; - if (action == mark_write) + if (action == mark_write || action == mark_access) return; switch (code) @@ -541,6 +534,7 @@ scan_rtx_address (insn, loc, class, action, mode) rtx op1 = orig_op1; rtx *locI = NULL; rtx *locB = NULL; + enum rtx_code index_code = SCRATCH; if (GET_CODE (op0) == SUBREG) { @@ -559,56 +553,69 @@ scan_rtx_address (insn, loc, class, action, mode) { 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_BASE_P (op1, mode)) - index_op = 0; - else if (REG_OK_FOR_INDEX_P (op1) - && REG_MODE_OK_FOR_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_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_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 = &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); + scan_rtx_address (insn, locB, base_reg_class (mode, PLUS, index_code), + action, mode); + return; } @@ -627,12 +634,12 @@ scan_rtx_address (insn, loc, class, action, mode) 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; 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 +650,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; @@ -670,6 +672,7 @@ scan_rtx (insn, loc, class, action, type, earlyclobber) case CONST: case CONST_INT: case CONST_DOUBLE: + case CONST_FIXED: case CONST_VECTOR: case SYMBOL_REF: case LABEL_REF: @@ -678,30 +681,31 @@ 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: 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; 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, + GET_CODE (PATTERN (insn)) == COND_EXEC ? OP_INOUT : 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: @@ -711,16 +715,17 @@ scan_rtx (insn, loc, class, action, type, earlyclobber) case POST_MODIFY: case PRE_MODIFY: /* Should only happen inside MEM. */ - abort (); + gcc_unreachable (); case CLOBBER: - scan_rtx (insn, &SET_DEST (x), class, action, OP_OUT, 1); + scan_rtx (insn, &SET_DEST (x), cl, action, + GET_CODE (PATTERN (insn)) == COND_EXEC ? OP_INOUT : OP_OUT, 0); 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,26 +736,25 @@ 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)) + if (NONDEBUG_INSN_P (insn)) { int n_ops; rtx note; @@ -793,7 +797,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; @@ -821,16 +825,8 @@ build_def_use (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, @@ -840,9 +836,11 @@ build_def_use (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 (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 +852,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 +866,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,26 +876,28 @@ 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. - 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. */ - if (GET_CODE (insn) == CALL_INSN) + if (CALL_P (insn)) { struct du_chain *p; for (p = open_chains; p; p = p->next_chain) @@ -942,30 +942,37 @@ 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); } + /* 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)) @@ -973,7 +980,13 @@ build_def_use (bb) scan_rtx (insn, &XEXP (note, 0), NO_REGS, terminate_dead, OP_IN, 0); } - if (insn == bb->end) + else if (DEBUG_INSN_P (insn) + && !VAR_LOC_UNKNOWN_P (INSN_VAR_LOCATION_LOC (insn))) + { + scan_rtx (insn, &INSN_VAR_LOCATION_LOC (insn), + ALL_REGS, mark_read, OP_IN, 0); + } + if (insn == BB_END (bb)) break; } @@ -982,951 +995,53 @@ 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); - while (this) + 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_du) { - fprintf (rtl_dump_file, " %d [%s]", INSN_UID (this->insn), - reg_class_names[this->class]); - 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 (rtl_dump_file, "\n"); + fprintf (dump_file, "\n"); chains = chains->next_chain; } } - -/* The following code does forward propagation of hard register copies. - The object is to eliminate as many dependencies as possible, so that - we have the most scheduling freedom. As a side effect, we also clean - up some silly register allocation decisions made by reload. This - code may be obsoleted by a new register allocator. */ - -/* For each register, we have a list of registers that contain the same - value. The OLDEST_REGNO field points to the head of the list, and - the NEXT_REGNO field runs through the list. The MODE field indicates - what mode the data is known to be in; this field is VOIDmode when the - register is not known to contain valid data. */ - -struct value_data_entry -{ - enum machine_mode mode; - unsigned int oldest_regno; - unsigned int next_regno; -}; - -struct value_data -{ - struct value_data_entry e[FIRST_PSEUDO_REGISTER]; - 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 *)); -#ifdef ENABLE_CHECKING -static void validate_value_data PARAMS ((struct value_data *)); -#endif - -/* Kill register REGNO. This involves removing it from any value lists, - and resetting the value mode to VOIDmode. */ - -static void -kill_value_regno (regno, vd) - unsigned int regno; - struct value_data *vd; -{ - unsigned int i, next; - - if (vd->e[regno].oldest_regno != regno) - { - for (i = vd->e[regno].oldest_regno; - vd->e[i].next_regno != regno; - i = vd->e[i].next_regno) - continue; - vd->e[i].next_regno = vd->e[regno].next_regno; - } - else if ((next = vd->e[regno].next_regno) != INVALID_REGNUM) - { - for (i = next; i != INVALID_REGNUM; i = vd->e[i].next_regno) - vd->e[i].oldest_regno = next; - } - - vd->e[regno].mode = VOIDmode; - vd->e[regno].oldest_regno = regno; - vd->e[regno].next_regno = INVALID_REGNUM; - -#ifdef ENABLE_CHECKING - validate_value_data (vd); -#endif -} - -/* Kill X. This is a convenience function for 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; -{ - /* SUBREGS are supposed to have been eliminated by now. But some - ports, e.g. i386 sse, use them to smuggle vector type information - through to instruction selection. Each such SUBREG should simplify, - so if we get a NULL we've done something wrong elsewhere. */ - - if (GET_CODE (x) == SUBREG) - x = simplify_subreg (GET_MODE (x), SUBREG_REG (x), - GET_MODE (SUBREG_REG (x)), SUBREG_BYTE (x)); - if (REG_P (x)) - { - unsigned int regno = REGNO (x); - unsigned int n = HARD_REGNO_NREGS (regno, GET_MODE (x)); - unsigned int i, j; - - /* 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); - } - } -} - -/* 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; -{ - unsigned int nregs; - - vd->e[regno].mode = mode; - - nregs = HARD_REGNO_NREGS (regno, mode); - if (nregs > vd->max_value_regs) - vd->max_value_regs = nregs; -} - -/* Initialize VD such that there are no known relationships between regs. */ - -static void -init_value_data (vd) - struct value_data *vd; -{ - int i; - for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i) - { - vd->e[i].mode = VOIDmode; - vd->e[i].oldest_regno = i; - vd->e[i].next_regno = INVALID_REGNUM; - } - vd->max_value_regs = 0; -} - -/* 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; -{ - struct value_data *vd = data; - if (GET_CODE (set) == CLOBBER) - kill_value (x, vd); -} - -/* Called through note_stores. If X is set, not clobbered, kill its - 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; -{ - struct value_data *vd = data; - if (GET_CODE (set) != CLOBBER) - { - kill_value (x, vd); - if (REG_P (x)) - set_value_regno (REGNO (x), GET_MODE (x), vd); - } -} - -/* Called through for_each_rtx. Kill any register used as the base of an - auto-increment expression, and install that register as the root of its - own value list. */ - -static int -kill_autoinc_value (px, data) - rtx *px; - void *data; -{ - rtx x = *px; - struct value_data *vd = data; - - if (GET_RTX_CLASS (GET_CODE (x)) == 'a') - { - x = XEXP (x, 0); - kill_value (x, vd); - set_value_regno (REGNO (x), Pmode, vd); - return -1; - } - - return 0; -} - -/* Assert that SRC has been copied to DEST. Adjust the data structures - 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; -{ - unsigned int dr = REGNO (dest); - unsigned int sr = REGNO (src); - unsigned int dn, sn; - unsigned int i; - - /* ??? At present, it's possible to see noop sets. It'd be nice if - this were cleaned up beforehand... */ - if (sr == dr) - return; - - /* Do not propagate copies to the stack pointer, as that can leave - memory accesses with no scheduling dependancy on the stack update. */ - if (dr == STACK_POINTER_REGNUM) - return; - - /* Likewise with the frame pointer, if we're using one. */ - if (frame_pointer_needed && dr == HARD_FRAME_POINTER_REGNUM) - 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)); - if ((dr > sr && dr < sr + sn) - || (sr > dr && sr < dr + dn)) - return; - - /* If SRC had no assigned mode (i.e. we didn't know it was live) - assign it now and assume the value came from an input argument - or somesuch. */ - 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, - 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. - Note we can still get low parts for the same mode combination through - a two-step copy involving differently sized hard regs. - Assume hard regs fr* are 32 bits bits each, while r* are 64 bits each: - (set (reg:DI r0) (reg:DI fr0)) - (set (reg:SI fr2) (reg:SI r0)) - loads the low part of (reg:DI fr0) - i.e. fr1 - into fr2, while: - (set (reg:SI fr2) (reg:SI fr0)) - loads the high part of (reg:DI fr0) into fr2. - - 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) - && (GET_MODE_SIZE (vd->e[sr].mode) > UNITS_PER_WORD - ? WORDS_BIG_ENDIAN : BYTES_BIG_ENDIAN)) - return; - - /* 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)) - return; - - /* Link DR at the end of the value chain used by SR. */ - - vd->e[dr].oldest_regno = vd->e[sr].oldest_regno; - - for (i = sr; vd->e[i].next_regno != INVALID_REGNUM; i = vd->e[i].next_regno) - continue; - vd->e[i].next_regno = dr; - -#ifdef ENABLE_CHECKING - validate_value_data (vd); -#endif -} - -/* 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; -{ - 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; -#endif - - return true; -} - -/* Register REGNO was originally set in ORIG_MODE. It - or a copy of it - - was copied in COPY_MODE to COPY_REGNO, and then COPY_REGNO was accessed - in NEW_MODE. - 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; -{ - 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_offset - = GET_MODE_SIZE (copy_mode) / copy_nregs * (copy_nregs - use_nregs); - int offset - = GET_MODE_SIZE (orig_mode) - GET_MODE_SIZE (new_mode) - copy_offset; - int byteoffset = offset % UNITS_PER_WORD; - int wordoffset = offset - byteoffset; - - offset = ((WORDS_BIG_ENDIAN ? wordoffset : 0) - + (BYTES_BIG_ENDIAN ? byteoffset : 0)); - return gen_rtx_raw_REG (new_mode, - regno + subreg_regno_offset (regno, orig_mode, - offset, - new_mode)); - } - return NULL_RTX; -} - -/* 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 - 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; -{ - unsigned int regno = REGNO (reg); - enum machine_mode mode = GET_MODE (reg); - unsigned int i; - - /* If we are accessing REG in some mode other that what we set it in, - make sure that the replacement is valid. In particular, consider - (set (reg:DI r11) (...)) - (set (reg:SI r9) (reg:SI r11)) - (set (reg:SI r10) (...)) - (set (...) (reg:DI r9)) - 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)) - return NULL_RTX; - } - - 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; - - 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; - } - } - - return NULL_RTX; -} - -/* If possible, replace the register at *LOC with the oldest register - in register class CLASS. 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; -{ - rtx new = find_oldest_value_reg (class, *loc, vd); - if (new) - { - if (rtl_dump_file) - fprintf (rtl_dump_file, "insn %u: replaced reg %u with %u\n", - INSN_UID (insn), REGNO (*loc), REGNO (new)); - - *loc = new; - return true; - } - return false; -} - -/* Similar to replace_oldest_value_reg, but *LOC contains an address. - Adapted from find_reloads_address_1. CLASS 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; -{ - rtx x = *loc; - RTX_CODE code = GET_CODE (x); - const char *fmt; - int i, j; - bool changed = false; - - switch (code) - { - case PLUS: - { - rtx orig_op0 = XEXP (x, 0); - rtx orig_op1 = XEXP (x, 1); - RTX_CODE code0 = GET_CODE (orig_op0); - RTX_CODE code1 = GET_CODE (orig_op1); - rtx op0 = orig_op0; - rtx op1 = orig_op1; - rtx *locI = NULL; - rtx *locB = NULL; - - if (GET_CODE (op0) == SUBREG) - { - op0 = SUBREG_REG (op0); - code0 = GET_CODE (op0); - } - - if (GET_CODE (op1) == SUBREG) - { - op1 = SUBREG_REG (op1); - code1 = GET_CODE (op1); - } - - if (code0 == MULT || code0 == SIGN_EXTEND || code0 == TRUNCATE - || code0 == ZERO_EXTEND || code1 == MEM) - { - locI = &XEXP (x, 0); - locB = &XEXP (x, 1); - } - else if (code1 == MULT || code1 == SIGN_EXTEND || code1 == TRUNCATE - || code1 == ZERO_EXTEND || code0 == MEM) - { - locI = &XEXP (x, 1); - locB = &XEXP (x, 0); - } - else if (code0 == CONST_INT || code0 == CONST - || code0 == SYMBOL_REF || code0 == LABEL_REF) - locB = &XEXP (x, 1); - else if (code1 == CONST_INT || code1 == CONST - || code1 == SYMBOL_REF || code1 == LABEL_REF) - locB = &XEXP (x, 0); - else if (code0 == REG && code1 == REG) - { - int index_op; - - if (REG_OK_FOR_INDEX_P (op0) - && REG_MODE_OK_FOR_BASE_P (op1, mode)) - index_op = 0; - else if (REG_OK_FOR_INDEX_P (op1) - && REG_MODE_OK_FOR_BASE_P (op0, mode)) - index_op = 1; - else if (REG_MODE_OK_FOR_BASE_P (op1, mode)) - index_op = 0; - else if (REG_MODE_OK_FOR_BASE_P (op0, mode)) - index_op = 1; - else if (REG_OK_FOR_INDEX_P (op1)) - index_op = 1; - else - index_op = 0; - - locI = &XEXP (x, index_op); - locB = &XEXP (x, !index_op); - } - else if (code0 == REG) - { - locI = &XEXP (x, 0); - locB = &XEXP (x, 1); - } - else if (code1 == REG) - { - locI = &XEXP (x, 1); - locB = &XEXP (x, 0); - } - - if (locI) - changed |= replace_oldest_value_addr (locI, INDEX_REG_CLASS, mode, - insn, vd); - if (locB) - changed |= replace_oldest_value_addr (locB, - MODE_BASE_REG_CLASS (mode), - mode, insn, vd); - return changed; - } - - case POST_INC: - case POST_DEC: - case POST_MODIFY: - case PRE_INC: - case PRE_DEC: - case PRE_MODIFY: - return false; - - case MEM: - return replace_oldest_value_mem (x, insn, vd); - - case REG: - return replace_oldest_value_reg (loc, class, insn, vd); - - default: - break; - } - - fmt = GET_RTX_FORMAT (code); - for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--) - { - if (fmt[i] == 'e') - changed |= replace_oldest_value_addr (&XEXP (x, i), class, 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, - mode, insn, vd); - } - - return changed; -} - -/* 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; -{ - return replace_oldest_value_addr (&XEXP (x, 0), - MODE_BASE_REG_CLASS (GET_MODE (x)), - GET_MODE (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; -{ - bool changed = false; - rtx insn; - - for (insn = bb->head; ; insn = NEXT_INSN (insn)) - { - int n_ops, i, alt, predicated; - bool is_asm; - rtx set; - - if (! INSN_P (insn)) - { - if (insn == bb->end) - break; - else - continue; - } - - set = single_set (insn); - extract_insn (insn); - if (! constrain_operands (1)) - fatal_insn_not_found (insn); - preprocess_constraints (); - alt = which_alternative; - n_ops = recog_data.n_operands; - is_asm = asm_noperands (PATTERN (insn)) >= 0; - - /* Simplify the code below by rewriting things to reflect - matching constraints. Also promote OP_OUT to OP_INOUT - in predicated instructions. */ - - predicated = GET_CODE (PATTERN (insn)) == COND_EXEC; - for (i = 0; i < n_ops; ++i) - { - int matches = recog_op_alt[i][alt].matches; - if (matches >= 0) - recog_op_alt[i][alt].class = recog_op_alt[matches][alt].class; - 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; - } - - /* For each earlyclobber operand, zap the value data. */ - for (i = 0; i < n_ops; i++) - if (recog_op_alt[i][alt].earlyclobber) - kill_value (recog_data.operand[i], vd); - - /* Within asms, a clobber cannot overlap inputs or outputs. - I wouldn't think this were true for regular insns, but - scan_rtx treats them like that... */ - note_stores (PATTERN (insn), kill_clobbered_value, vd); - - /* Kill all auto-incremented values. */ - /* ??? REG_INC is useless, since stack pushes aren't done that way. */ - for_each_rtx (&PATTERN (insn), kill_autoinc_value, vd); - - /* Kill all early-clobbered operands. */ - for (i = 0; i < n_ops; i++) - if (recog_op_alt[i][alt].earlyclobber) - kill_value (recog_data.operand[i], vd); - - /* Special-case plain move instructions, since we may well - be able to do the move from a different register class. */ - if (set && REG_P (SET_SRC (set))) - { - rtx src = SET_SRC (set); - unsigned int regno = REGNO (src); - enum machine_mode mode = GET_MODE (src); - unsigned int i; - rtx new; - - /* If we are accessing SRC in some mode other that what we - 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)) - goto no_move_special_case; - } - - /* If the destination is also a register, try to find a source - 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)) - { - if (rtl_dump_file) - fprintf (rtl_dump_file, - "insn %u: replaced reg %u with %u\n", - INSN_UID (insn), regno, REGNO (new)); - changed = true; - goto did_replacement; - } - } - - /* Otherwise, try all valid registers and see if its valid. */ - 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, - mode, i, regno); - if (new != NULL_RTX) - { - if (validate_change (insn, &SET_SRC (set), new, 0)) - { - ORIGINAL_REGNO (new) = ORIGINAL_REGNO (src); - if (rtl_dump_file) - fprintf (rtl_dump_file, - "insn %u: replaced reg %u with %u\n", - INSN_UID (insn), regno, REGNO (new)); - changed = true; - goto did_replacement; - } - } - } - } - no_move_special_case: - - /* 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; - - /* Don't scan match_operand here, since we've no reg class - information to pass down. Any operands that we could - substitute in will be represented elsewhere. */ - if (recog_data.constraints[i][0] == '\0') - continue; - - /* Don't replace in asms intentionally referencing hard regs. */ - if (is_asm && GET_CODE (recog_data.operand[i]) == REG - && (REGNO (recog_data.operand[i]) - == ORIGINAL_REGNO (recog_data.operand[i]))) - continue; - - if (recog_data.operand_type[i] == OP_IN) - { - if (recog_op_alt[i][alt].is_address) - replaced - = replace_oldest_value_addr (recog_data.operand_loc[i], - recog_op_alt[i][alt].class, - 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, - insn, vd); - else if (GET_CODE (recog_data.operand[i]) == MEM) - replaced = replace_oldest_value_mem (recog_data.operand[i], - insn, vd); - } - else if (GET_CODE (recog_data.operand[i]) == MEM) - replaced = replace_oldest_value_mem (recog_data.operand[i], - insn, vd); - - /* If we performed any replacement, update match_dups. */ - if (replaced) - { - int j; - rtx new; - - changed = true; - - new = *recog_data.operand_loc[i]; - recog_data.operand[i] = new; - for (j = 0; j < recog_data.n_dups; j++) - if (recog_data.dup_num[j] == i) - *recog_data.dup_loc[j] = new; - } - } - - did_replacement: - /* Clobber call-clobbered registers. */ - if (GET_CODE (insn) == CALL_INSN) - for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) - if (TEST_HARD_REG_BIT (regs_invalidated_by_call, i)) - kill_value_regno (i, vd); - - /* Notice stores. */ - note_stores (PATTERN (insn), kill_set_value, vd); - - /* Notice copies. */ - 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) - break; - } - - return changed; -} - -/* Main entry point for the forward copy propagation optimization. */ - -void -copyprop_hardreg_forward () +gate_handle_regrename (void) { - struct value_data *all_vd; - bool need_refresh; - basic_block bb, bbp = 0; - - need_refresh = false; - - all_vd = xmalloc (sizeof (struct value_data) * last_basic_block); - - FOR_EACH_BB (bb) - { - /* 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. */ - if (bb->pred) - for (bbp = bb; bbp && bbp != bb->pred->src; bbp = bbp->prev_bb); - if (bb->pred - && ! bb->pred->pred_next - && ! (bb->pred->flags & (EDGE_ABNORMAL_CALL | EDGE_EH)) - && bb->pred->src != ENTRY_BLOCK_PTR - && bbp) - all_vd[bb->index] = all_vd[bb->pred->src->index]; - else - init_value_data (all_vd + bb->index); - - if (copyprop_hardreg_forward_1 (bb, all_vd + bb->index)) - need_refresh = true; - } - - if (need_refresh) - { - if (rtl_dump_file) - fputs ("\n\n", rtl_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 ()); - update_life_info (NULL, UPDATE_LIFE_GLOBAL_RM_NOTES, - PROP_DEATH_NOTES - | PROP_SCAN_DEAD_CODE - | PROP_KILL_DEAD_CODE); - } - - free (all_vd); + return (optimize > 0 && (flag_rename_registers)); } -/* Dump the value chain data to stderr. */ - -void -debug_value_data (vd) - struct value_data *vd; +struct rtl_opt_pass pass_regrename = { - HARD_REG_SET set; - unsigned int i, j; - - CLEAR_HARD_REG_SET (set); - - for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i) - if (vd->e[i].oldest_regno == i) - { - if (vd->e[i].mode == VOIDmode) - { - if (vd->e[i].next_regno != INVALID_REGNUM) - fprintf (stderr, "[%u] Bad next_regno for empty chain (%u)\n", - i, vd->e[i].next_regno); - continue; - } - - SET_HARD_REG_BIT (set, i); - fprintf (stderr, "[%u %s] ", i, GET_MODE_NAME (vd->e[i].mode)); - - for (j = vd->e[i].next_regno; - j != INVALID_REGNUM; - j = vd->e[j].next_regno) - { - if (TEST_HARD_REG_BIT (set, j)) - { - fprintf (stderr, "[%u] Loop in regno chain\n", j); - return; - } - - if (vd->e[j].oldest_regno != i) - { - fprintf (stderr, "[%u] Bad oldest_regno (%u)\n", - j, vd->e[j].oldest_regno); - return; - } - SET_HARD_REG_BIT (set, j); - fprintf (stderr, "[%u %s] ", j, GET_MODE_NAME (vd->e[j].mode)); - } - fputc ('\n', stderr); - } - - for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i) - if (! TEST_HARD_REG_BIT (set, i) - && (vd->e[i].mode != VOIDmode - || vd->e[i].oldest_regno != i - || vd->e[i].next_regno != INVALID_REGNUM)) - fprintf (stderr, "[%u] Non-empty reg in chain (%s %u %i)\n", - i, GET_MODE_NAME (vd->e[i].mode), vd->e[i].oldest_regno, - vd->e[i].next_regno); -} - -#ifdef ENABLE_CHECKING -static void -validate_value_data (vd) - struct value_data *vd; -{ - HARD_REG_SET set; - unsigned int i, j; - - CLEAR_HARD_REG_SET (set); - - for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i) - if (vd->e[i].oldest_regno == i) - { - if (vd->e[i].mode == VOIDmode) - { - if (vd->e[i].next_regno != INVALID_REGNUM) - internal_error ("validate_value_data: [%u] Bad next_regno for empty chain (%u)", - i, vd->e[i].next_regno); - continue; - } - - SET_HARD_REG_BIT (set, i); - - for (j = vd->e[i].next_regno; - j != INVALID_REGNUM; - j = vd->e[j].next_regno) - { - if (TEST_HARD_REG_BIT (set, j)) - internal_error ("validate_value_data: Loop in regno chain (%u)", - j); - if (vd->e[j].oldest_regno != i) - internal_error ("validate_value_data: [%u] Bad oldest_regno (%u)", - j, vd->e[j].oldest_regno); - - SET_HARD_REG_BIT (set, j); - } - } + { + RTL_PASS, + "rnreg", /* name */ + gate_handle_regrename, /* gate */ + regrename_optimize, /* 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 */ + } +}; - for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i) - if (! TEST_HARD_REG_BIT (set, i) - && (vd->e[i].mode != VOIDmode - || vd->e[i].oldest_regno != i - || vd->e[i].next_regno != INVALID_REGNUM)) - internal_error ("validate_value_data: [%u] Non-empty reg in chain (%s %u %i)", - i, GET_MODE_NAME (vd->e[i].mode), vd->e[i].oldest_regno, - vd->e[i].next_regno); -} -#endif