/* Register renaming for the GNU compiler.
- Copyright (C) 2000 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 GNU CC.
+ This file is part of GCC.
- GNU CC 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)
+ 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 3, or (at your option)
any later version.
- GNU CC is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
+ GCC is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
+ License for more details.
You should have received a copy of the GNU General Public License
- along with GNU CC; 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
+ <http://www.gnu.org/licenses/>. */
#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"
#include "function.h"
#include "recog.h"
#include "flags.h"
+#include "toplev.h"
#include "obstack.h"
-
-#define obstack_chunk_alloc xmalloc
-#define obstack_chunk_free free
-
-#ifndef REGNO_MODE_OK_FOR_BASE_P
-#define REGNO_MODE_OK_FOR_BASE_P(REGNO, MODE) REGNO_OK_FOR_BASE_P (REGNO)
-#endif
-
-#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
{
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;
};
enum scan_actions
{
- note_reference,
terminate_all_read,
terminate_overlapping_read,
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[] =
{
- "note_reference",
"terminate_all_read",
"terminate_overlapping_read",
"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));
-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));
-static struct du_chain *build_def_use PARAMS ((basic_block, HARD_REG_SET *));
-static void dump_def_use_chain PARAMS ((struct du_chain *));
-
-void
-regrename_optimize ()
+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 (rtx x, const_rtx set ATTRIBUTE_UNUSED, void *data)
+{
+ HARD_REG_SET *pset = (HARD_REG_SET *) data;
+
+ if (GET_CODE (x) == SUBREG)
+ x = SUBREG_REG (x);
+ if (!REG_P (x))
+ return;
+ /* There must not be pseudos at this point. */
+ 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 (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);
+ /* There must not be pseudos at this point. */
+ gcc_assert (HARD_REGISTER_P (reg));
+ remove_from_hard_reg_set (pset, GET_MODE (reg), REGNO (reg));
+ }
+}
+
+/* For a def-use chain CHAIN in basic block B, find which registers overlap
+ its lifetime and set the corresponding bits in *PSET. */
+
+static void
+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, 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
+ renamed. */
+ while (insn != t->insn)
+ {
+ if (INSN_P (insn))
+ {
+ clear_dead_regs (&live, REG_DEAD, REG_NOTES (insn));
+ note_stores (PATTERN (insn), note_sets, (void *) &live);
+ /* Only record currently live regs if we are inside the
+ reg's live range. */
+ if (t != chain)
+ IOR_HARD_REG_SET (*pset, live);
+ clear_dead_regs (&live, REG_UNUSED, REG_NOTES (insn));
+ }
+ insn = NEXT_INSN (insn);
+ }
+
+ IOR_HARD_REG_SET (*pset, live);
+
+ /* For the last reference, also merge in all registers set in the
+ same insn.
+ @@@ We only have take earlyclobbered sets into account. */
+ if (! t->next_use)
+ note_stores (PATTERN (insn), note_sets, (void *) pset);
+
+ t = t->next_use;
+ }
+}
+
+/* Perform register renaming on the current function. */
+
+static unsigned int
+regrename_optimize (void)
{
- int b;
+ 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 (b = 0; b < n_basic_blocks; b++)
+ FOR_EACH_BB (bb)
{
- basic_block bb = BASIC_BLOCK (b);
struct du_chain *all_chains = 0;
- HARD_REG_SET regs_used;
HARD_REG_SET unavailable;
HARD_REG_SET regs_seen;
- CLEAR_HARD_REG_SET (regs_used);
CLEAR_HARD_REG_SET (unavailable);
- if (rtl_dump_file)
- fprintf (rtl_dump_file, "\nBasic block %d:\n", b);
+ if (dump_file)
+ fprintf (dump_file, "\nBasic block %d:\n", bb->index);
- all_chains = build_def_use (bb, ®s_used);
+ all_chains = build_def_use (bb);
- if (rtl_dump_file)
+ if (dump_file)
dump_def_use_chain (all_chains);
- /* Available registers are not: used in the block, live at the start
- live at the end, a register we've renamed to. */
- REG_SET_TO_HARD_REG_SET (unavailable, bb->global_live_at_start);
- REG_SET_TO_HARD_REG_SET (regs_seen, bb->global_live_at_end);
- IOR_HARD_REG_SET (unavailable, regs_seen);
- IOR_HARD_REG_SET (unavailable, regs_used);
-
+ CLEAR_HARD_REG_SET (unavailable);
/* Don't clobber traceback for noreturn functions. */
if (frame_pointer_needed)
{
- SET_HARD_REG_BIT (unavailable, FRAME_POINTER_REGNUM);
+ add_to_hard_reg_set (&unavailable, Pmode, FRAME_POINTER_REGNUM);
#if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
- SET_HARD_REG_BIT (unavailable, HARD_FRAME_POINTER_REGNUM);
+ 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;
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), treg;
- int nregs = HARD_REGNO_NREGS (reg, GET_MODE (*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. */
if (! TEST_HARD_REG_BIT (regs_seen, reg))
{
SET_HARD_REG_BIT (regs_seen, reg);
continue;
}
+#endif
- if (fixed_regs[reg] || global_regs[reg])
+ if (fixed_regs[reg] || global_regs[reg]
+#if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
+ || (frame_pointer_needed && reg == HARD_FRAME_POINTER_REGNUM)
+#else
+ || (frame_pointer_needed && reg == FRAME_POINTER_REGNUM)
+#endif
+ )
continue;
COPY_HARD_REG_SET (this_unavailable, unavailable);
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,
- 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 (last->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_du);
+
/* Now potential_regs is a reasonable approximation, let's
have a closer look at each register still in there. */
- for (treg = 0; treg < FIRST_PSEUDO_REGISTER; treg++)
+ for (new_reg = 0; new_reg < FIRST_PSEUDO_REGISTER; new_reg++)
{
+ 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, treg+i)
- || fixed_regs[treg+i]
- || global_regs[treg+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[treg+i] && ! call_used_regs[treg+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
+ leaf function. */
+ || (current_function_is_leaf
+ && !LEAF_REGISTERS[new_reg + i])
+#endif
#ifdef HARD_REGNO_RENAME_OK
- || ! HARD_REGNO_RENAME_OK (reg+i, treg+i)
+ || ! HARD_REGNO_RENAME_OK (reg + i, new_reg + i)
#endif
)
break;
/* 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 (treg, GET_MODE (*tmp->loc)))
+ 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
+ (reg, GET_MODE (*tmp->loc)))
+ && (HARD_REGNO_CALL_PART_CLOBBERED
+ (new_reg, GET_MODE (*tmp->loc)))))
break;
if (! tmp)
- break;
+ {
+ 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 (treg == FIRST_PSEUDO_REGISTER)
+ 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;
}
-
- for (i = nregs - 1; i >= 0; --i)
- SET_HARD_REG_BIT (unavailable, treg+i);
- do_replace (this, treg);
+ 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[treg]);
+ 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);
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)
{
while (chain)
{
- *chain->loc = gen_rtx_REG (GET_MODE (*chain->loc), reg);
+ unsigned int regno = ORIGINAL_REGNO (*chain->loc);
+ struct reg_attrs * attr = REG_ATTRS (*chain->loc);
+ int reg_ptr = REG_POINTER (*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;
+ REG_POINTER (*chain->loc) = reg_ptr;
+ df_insn_rescan (chain->insn);
chain = chain->next_use;
}
}
-static HARD_REG_SET *referenced_regs;
static struct du_chain *open_chains;
static struct du_chain *closed_chains;
static void
-scan_rtx_reg (insn, loc, class, action, type)
- rtx insn;
- rtx *loc;
- enum reg_class class;
- enum scan_actions action;
- enum op_type type;
+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);
-
- if (action == note_reference)
- {
- while (this_nregs-- > 0)
- SET_HARD_REG_BIT (*referenced_regs, this_regno + this_nregs);
- return;
- }
+ 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;
- 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.
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;
- else if (action == mark_read)
{
- if (! exact_match)
- abort ();
- if (class == NO_REGS)
- abort ();
-
- this = (struct du_chain *)
- obstack_alloc (&rename_obstack, sizeof (struct du_chain));
- this->next_use = *p;
- this->next_chain = (*p)->next_chain;
- this->loc = loc;
- this->insn = insn;
- this->class = class;
- this->need_caller_save_reg = 0;
- *p = this;
- return;
+ p = &this_du->next_chain;
+ continue;
+ }
+
+ if (action == mark_read || action == mark_access)
+ {
+ gcc_assert (exact_match);
+
+ /* ??? 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 (cl != NO_REGS)
+ {
+ 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_du;
+ return;
+ }
}
- else if (action != terminate_overlapping_read || ! exact_match)
+
+ 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.
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)
rtx op1 = orig_op1;
rtx *locI = NULL;
rtx *locB = NULL;
+ enum rtx_code index_code = SCRATCH;
if (GET_CODE (op0) == SUBREG)
{
{
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, BASE_REG_CLASS, action, mode);
+ scan_rtx_address (insn, locB, base_reg_class (mode, PLUS, index_code),
+ action, mode);
+
return;
}
break;
case MEM:
- scan_rtx_address (insn, &XEXP (x, 0), BASE_REG_CLASS, action,
+ scan_rtx_address (insn, &XEXP (x, 0),
+ base_reg_class (GET_MODE (x), MEM, SCRATCH), action,
GET_MODE (x));
return;
case REG:
- scan_rtx_reg (insn, loc, class, action, OP_IN);
+ scan_rtx_reg (insn, loc, cl, action, OP_IN, 0);
return;
default:
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)
- rtx insn;
- rtx *loc;
- enum reg_class class;
- enum scan_actions action;
- enum op_type type;
+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;
case CONST:
case CONST_INT:
case CONST_DOUBLE:
+ case CONST_FIXED:
+ case CONST_VECTOR:
case SYMBOL_REF:
case LABEL_REF:
case CC0:
return;
case REG:
- scan_rtx_reg (insn, loc, class, action, type);
+ scan_rtx_reg (insn, loc, cl, action, type, earlyclobber);
return;
case MEM:
- scan_rtx_address (insn, &XEXP (x, 0), BASE_REG_CLASS, action,
+ scan_rtx_address (insn, &XEXP (x, 0),
+ 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);
- scan_rtx (insn, &SET_DEST (x), class, action, OP_OUT);
+ 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);
+ 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,
- type == OP_IN ? OP_IN : OP_INOUT);
- scan_rtx (insn, &XEXP (x, 1), class, action, OP_IN);
- scan_rtx (insn, &XEXP (x, 2), class, action, OP_IN);
+ case SIGN_EXTRACT:
+ scan_rtx (insn, &XEXP (x, 0), cl, action,
+ type == OP_IN ? OP_IN : OP_INOUT, earlyclobber);
+ 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:
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);
+ 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);
+ scan_rtx (insn, &XEXP (x, 0), cl, action, type, 0);
if (XEXP (x, 1))
- scan_rtx (insn, &XEXP (x, 1), class, action, type);
+ scan_rtx (insn, &XEXP (x, 1), cl, action, type, 0);
return;
default:
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
{
if (fmt[i] == 'e')
- scan_rtx (insn, &XEXP (x, i), class, action, type);
+ 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);
+ 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, regs_used)
- basic_block bb;
- HARD_REG_SET *regs_used;
+build_def_use (basic_block bb)
{
rtx insn;
open_chains = closed_chains = NULL;
- referenced_regs = regs_used;
- for (insn = bb->head; ; insn = NEXT_INSN (insn))
+ for (insn = BB_HEAD (bb); ; insn = NEXT_INSN (insn))
{
if (INSN_P (insn))
{
rtx note;
rtx old_operands[MAX_RECOG_OPERANDS];
rtx old_dups[MAX_DUP_OPERANDS];
- int i;
+ int i, icode;
int alt;
int predicated;
- /* Record all mentioned registers in regs_used. */
- scan_rtx (insn, &PATTERN (insn), NO_REGS, note_reference, OP_IN);
-
/* Process the insn, determining its effect on the def-use
chains. We perform the following steps with the register
references in the insn:
(6) For any write we find in an operand, make a new chain.
(7) For any REG_UNUSED, close any chains we just opened. */
+ icode = recog_memoized (insn);
extract_insn (insn);
- constrain_operands (1);
+ if (! constrain_operands (1))
+ fatal_insn_not_found (insn);
preprocess_constraints ();
alt = which_alternative;
n_ops = recog_data.n_operands;
{
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;
for (i = 0; i < n_ops; i++)
scan_rtx (insn, recog_data.operand_loc[i],
NO_REGS, terminate_overlapping_read,
- recog_data.operand_type[i]);
+ recog_data.operand_type[i], 0);
/* Step 2: Close chains for which we have reads outside operands.
- We do this by munging all operands into CC0, and closing
+ We do this by munging all operands into CC0, and closing
everything remaining. */
for (i = 0; i < n_ops; i++)
{
old_operands[i] = recog_data.operand[i];
/* Don't squash match_operator or match_parallel here, since
- we don't know that all of the contained registers are
+ we don't know that all of the contained registers are
reachable by proper operands. */
if (recog_data.constraints[i][0] == '\0')
continue;
*recog_data.dup_loc[i] = cc0_rtx;
}
- scan_rtx (insn, &PATTERN (insn), NO_REGS, terminate_all_read, OP_IN);
+ scan_rtx (insn, &PATTERN (insn), NO_REGS, terminate_all_read,
+ OP_IN, 0);
for (i = 0; i < recog_data.n_dups; i++)
*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);
+ NO_REGS, terminate_all_read, OP_IN, 0);
+
+ /* Step 2C: Can't rename asm operands that were originally
+ hard registers. */
+ if (asm_noperands (PATTERN (insn)) > 0)
+ for (i = 0; i < n_ops; i++)
+ {
+ rtx *loc = recog_data.operand_loc[i];
+ rtx op = *loc;
+
+ if (REG_P (op)
+ && REGNO (op) == ORIGINAL_REGNO (op)
+ && (recog_data.operand_type[i] == OP_IN
+ || recog_data.operand_type[i] == OP_INOUT))
+ scan_rtx (insn, loc, NO_REGS, terminate_all_read, OP_IN, 0);
+ }
/* Step 3: Append to chains for reads inside operands. */
for (i = 0; i < n_ops + recog_data.n_dups; i++)
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
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);
+ 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);
- else if (REG_NOTE_KIND (note) == REG_INC)
- scan_rtx (insn, &XEXP (note, 0), ALL_REGS, mark_read, OP_INOUT);
- }
+ 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)
- {
- struct du_chain *p2;
- for (p2 = p; p2->next_use; p2 = p2->next_use)
- /* nothing */;
- p2->need_caller_save_reg = 1;
- }
+ p->need_caller_save_reg = 1;
}
/* Step 5: Close open chains that overlap writes. Similar to
*recog_data.dup_loc[i] = cc0_rtx;
}
- scan_rtx (insn, &PATTERN (insn), NO_REGS, terminate_write, OP_IN);
+ scan_rtx (insn, &PATTERN (insn), NO_REGS, terminate_write, OP_IN, 0);
for (i = 0; i < recog_data.n_dups; i++)
*recog_data.dup_loc[i] = old_dups[i];
/* Step 6: Begin new chains for writes inside operands. */
/* ??? Many targets have output constraints on the SET_DEST
of a call insn, which is stupid, since these are certainly
- ABI defined hard registers. Don't change calls at all. */
- if (GET_CODE (insn) != CALL_INSN)
+ ABI defined hard registers. Don't change calls at all.
+ Similarly take special care for asm statement that originally
+ referenced hard registers. */
+ if (asm_noperands (PATTERN (insn)) > 0)
+ {
+ for (i = 0; i < n_ops; i++)
+ if (recog_data.operand_type[i] == OP_OUT)
+ {
+ rtx *loc = recog_data.operand_loc[i];
+ rtx op = *loc;
+ enum reg_class cl = recog_op_alt[i][alt].cl;
+
+ if (REG_P (op)
+ && REGNO (op) == ORIGINAL_REGNO (op))
+ continue;
+
+ scan_rtx (insn, loc, cl, mark_write, OP_OUT,
+ recog_op_alt[i][alt].earlyclobber);
+ }
+ }
+ 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))
if (REG_NOTE_KIND (note) == REG_UNUSED)
- scan_rtx (insn, &XEXP (note, 0), NO_REGS, terminate_dead, OP_IN);
+ scan_rtx (insn, &XEXP (note, 0), NO_REGS, terminate_dead,
+ OP_IN, 0);
}
- if (insn == bb->end)
+ if (insn == BB_END (bb))
break;
}
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;
}
}
+
+\f
+static bool
+gate_handle_regrename (void)
+{
+ return (optimize > 0 && (flag_rename_registers));
+}
+
+struct rtl_opt_pass pass_regrename =
+{
+ {
+ 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 */
+ }
+};
+
OSDN Git Service
