/* Register renaming for the GNU compiler.
- Copyright (C) 2000, 2001, 2002 Free Software Foundation, Inc.
+ Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005
+ Free Software Foundation, Inc.
This file is part of GCC.
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
+ Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
+ 02110-1301, USA. */
#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 "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"
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;
};
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[] =
"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 *));
+static void do_replace (struct du_chain *, int);
+static void scan_rtx_reg (rtx, rtx *, enum reg_class,
+ enum scan_actions, enum op_type, int);
+static void scan_rtx_address (rtx, rtx *, enum reg_class,
+ enum scan_actions, enum machine_mode);
+static void scan_rtx (rtx, rtx *, enum reg_class, enum scan_actions,
+ enum op_type, int);
+static struct du_chain *build_def_use (basic_block);
+static void dump_def_use_chain (struct du_chain *);
+static void note_sets (rtx, rtx, void *);
+static void clear_dead_regs (HARD_REG_SET *, enum machine_mode, rtx);
+static void merge_overlapping_regs (basic_block, HARD_REG_SET *,
+ struct du_chain *);
/* Called through note_stores from update_life. Find sets of registers, and
record them in *DATA (which is actually a HARD_REG_SET *). */
static void
-note_sets (x, set, data)
- rtx x;
- rtx set ATTRIBUTE_UNUSED;
- void *data;
+note_sets (rtx x, rtx set ATTRIBUTE_UNUSED, void *data)
{
HARD_REG_SET *pset = (HARD_REG_SET *) data;
unsigned int regno;
int nregs;
- if (GET_CODE (x) != REG)
+
+ if (GET_CODE (x) == SUBREG)
+ x = SUBREG_REG (x);
+ if (!REG_P (x))
return;
regno = REGNO (x);
- nregs = HARD_REGNO_NREGS (regno, GET_MODE (x));
+ nregs = hard_regno_nregs[regno][GET_MODE (x)];
/* There must not be pseudos at this point. */
- if (regno + nregs > FIRST_PSEUDO_REGISTER)
- abort ();
+ gcc_assert (regno + nregs <= FIRST_PSEUDO_REGISTER);
while (nregs-- > 0)
SET_HARD_REG_BIT (*pset, regno + nregs);
in the list NOTES. */
static void
-clear_dead_regs (pset, kind, notes)
- HARD_REG_SET *pset;
- enum machine_mode kind;
- rtx notes;
+clear_dead_regs (HARD_REG_SET *pset, enum machine_mode kind, rtx notes)
{
rtx note;
for (note = notes; note; note = XEXP (note, 1))
{
rtx reg = XEXP (note, 0);
unsigned int regno = REGNO (reg);
- int nregs = HARD_REGNO_NREGS (regno, GET_MODE (reg));
+ int nregs = hard_regno_nregs[regno][GET_MODE (reg)];
/* There must not be pseudos at this point. */
- if (regno + nregs > FIRST_PSEUDO_REGISTER)
- abort ();
+ gcc_assert (regno + nregs <= FIRST_PSEUDO_REGISTER);
while (nregs-- > 0)
CLEAR_HARD_REG_BIT (*pset, regno + nregs);
its lifetime and set the corresponding bits in *PSET. */
static void
-merge_overlapping_regs (b, pset, chain)
- basic_block b;
- HARD_REG_SET *pset;
- struct du_chain *chain;
+merge_overlapping_regs (basic_block b, HARD_REG_SET *pset,
+ struct du_chain *chain)
{
struct du_chain *t = chain;
rtx insn;
HARD_REG_SET live;
- REG_SET_TO_HARD_REG_SET (live, b->global_live_at_start);
- insn = b->head;
+ REG_SET_TO_HARD_REG_SET (live, b->il.rtl->global_live_at_start);
+ insn = BB_HEAD (b);
while (t)
{
/* Search forward until the next reference to the register to be
reg's live range. */
if (t != chain)
IOR_HARD_REG_SET (*pset, live);
- clear_dead_regs (&live, REG_UNUSED, REG_NOTES (insn));
+ clear_dead_regs (&live, REG_UNUSED, REG_NOTES (insn));
}
insn = NEXT_INSN (insn);
}
/* Perform register renaming on the current function. */
-void
-regrename_optimize ()
+static void
+regrename_optimize (void)
{
int tick[FIRST_PSEUDO_REGISTER];
int this_tick = 0;
- int b;
+ basic_block bb;
char *first_obj;
memset (tick, 0, sizeof tick);
gcc_obstack_init (&rename_obstack);
- first_obj = (char *) obstack_alloc (&rename_obstack, 0);
+ first_obj = obstack_alloc (&rename_obstack, 0);
- for (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 unavailable;
HARD_REG_SET regs_seen;
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);
- if (rtl_dump_file)
+ if (dump_file)
dump_def_use_chain (all_chains);
CLEAR_HARD_REG_SET (unavailable);
if (frame_pointer_needed)
{
int i;
-
- for (i = HARD_REGNO_NREGS (FRAME_POINTER_REGNUM, Pmode); i--;)
+
+ for (i = hard_regno_nregs[FRAME_POINTER_REGNUM][Pmode]; i--;)
SET_HARD_REG_BIT (unavailable, FRAME_POINTER_REGNUM + i);
-
+
#if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
- for (i = HARD_REGNO_NREGS (HARD_FRAME_POINTER_REGNUM, Pmode); i--;)
+ for (i = hard_regno_nregs[HARD_FRAME_POINTER_REGNUM][Pmode]; i--;)
SET_HARD_REG_BIT (unavailable, HARD_FRAME_POINTER_REGNUM + i);
#endif
}
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;
int i;
all_chains = this->next_chain;
-
+
+ best_new_reg = reg;
+
#if 0 /* This just disables optimization opportunities. */
/* Only rename once we've seen the reg more than once. */
if (! TEST_HARD_REG_BIT (regs_seen, reg))
{
n_uses++;
IOR_COMPL_HARD_REG_SET (this_unavailable,
- reg_class_contents[last->class]);
+ reg_class_contents[last->cl]);
}
if (n_uses < 1)
continue;
IOR_COMPL_HARD_REG_SET (this_unavailable,
- reg_class_contents[last->class]);
+ reg_class_contents[last->cl]);
if (this->need_caller_save_reg)
IOR_HARD_REG_SET (this_unavailable, call_used_reg_set);
have a closer look at each register still in there. */
for (new_reg = 0; new_reg < FIRST_PSEUDO_REGISTER; new_reg++)
{
- int nregs = HARD_REGNO_NREGS (new_reg, GET_MODE (*this->loc));
+ int nregs = hard_regno_nregs[new_reg][GET_MODE (*this->loc)];
for (i = nregs - 1; i >= 0; --i)
if (TEST_HARD_REG_BIT (this_unavailable, new_reg + i)
|| (! regs_ever_live[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
+ /* We can't use a non-leaf register if we're in a
leaf function. */
- || (current_function_is_leaf
+ || (current_function_is_leaf
&& !LEAF_REGISTERS[new_reg + i])
#endif
#ifdef HARD_REGNO_RENAME_OK
break;
if (! tmp)
{
- if (best_new_reg == -1
- || tick[best_new_reg] > tick[new_reg])
+ if (tick[best_new_reg] > tick[new_reg])
best_new_reg = new_reg;
}
}
- if (rtl_dump_file)
+ if (dump_file)
{
- fprintf (rtl_dump_file, "Register %s in insn %d",
+ fprintf (dump_file, "Register %s in insn %d",
reg_names[reg], INSN_UID (last->insn));
if (last->need_caller_save_reg)
- fprintf (rtl_dump_file, " crosses a call");
- }
+ fprintf (dump_file, " crosses a call");
+ }
- if (best_new_reg == -1)
+ if (best_new_reg == reg)
{
- if (rtl_dump_file)
- fprintf (rtl_dump_file, "; no available registers\n");
+ tick[reg] = ++this_tick;
+ if (dump_file)
+ fprintf (dump_file, "; no available better choice\n");
continue;
}
do_replace (this, best_new_reg);
- tick[best_new_reg] = this_tick++;
+ tick[best_new_reg] = ++this_tick;
+ regs_ever_live[best_new_reg] = 1;
- if (rtl_dump_file)
- fprintf (rtl_dump_file, ", renamed as %s\n", reg_names[best_new_reg]);
+ if (dump_file)
+ fprintf (dump_file, ", renamed as %s\n", reg_names[best_new_reg]);
}
obstack_free (&rename_obstack, first_obj);
obstack_free (&rename_obstack, NULL);
- if (rtl_dump_file)
- fputc ('\n', rtl_dump_file);
+ if (dump_file)
+ fputc ('\n', dump_file);
count_or_remove_death_notes (NULL, 1);
update_life_info (NULL, UPDATE_LIFE_LOCAL,
- PROP_REG_INFO | PROP_DEATH_NOTES);
+ PROP_DEATH_NOTES);
}
static void
-do_replace (chain, reg)
- struct du_chain *chain;
- int reg;
+do_replace (struct du_chain *chain, int reg)
{
while (chain)
{
unsigned int regno = ORIGINAL_REGNO (*chain->loc);
+ struct reg_attrs * attr = REG_ATTRS (*chain->loc);
+
*chain->loc = gen_raw_REG (GET_MODE (*chain->loc), reg);
if (regno >= FIRST_PSEUDO_REGISTER)
ORIGINAL_REGNO (*chain->loc) = regno;
+ REG_ATTRS (*chain->loc) = attr;
chain = chain->next_use;
}
}
static struct du_chain *closed_chains;
static void
-scan_rtx_reg (insn, loc, class, action, type, earlyclobber)
- rtx insn;
- rtx *loc;
- enum reg_class class;
- enum scan_actions action;
- enum op_type type;
- int earlyclobber;
+scan_rtx_reg (rtx insn, rtx *loc, enum reg_class cl,
+ enum scan_actions action, enum op_type type, int earlyclobber)
{
struct du_chain **p;
rtx x = *loc;
enum machine_mode mode = GET_MODE (x);
int this_regno = REGNO (x);
- int this_nregs = HARD_REGNO_NREGS (this_regno, mode);
+ int this_nregs = hard_regno_nregs[this_regno][mode];
if (action == mark_write)
{
if (type == OP_OUT)
{
- struct du_chain *this = (struct du_chain *)
- obstack_alloc (&rename_obstack, sizeof (struct du_chain));
+ struct du_chain *this
+ = obstack_alloc (&rename_obstack, sizeof (struct du_chain));
this->next_use = 0;
this->next_chain = open_chains;
this->loc = loc;
this->insn = insn;
- this->class = class;
+ this->cl = cl;
this->need_caller_save_reg = 0;
this->earlyclobber = earlyclobber;
open_chains = this;
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;)
if (*this->loc == cc0_rtx)
p = &this->next_chain;
else
- {
+ {
int regno = REGNO (*this->loc);
- int nregs = HARD_REGNO_NREGS (regno, GET_MODE (*this->loc));
+ int nregs = hard_regno_nregs[regno][GET_MODE (*this->loc)];
int exact_match = (regno == this_regno && nregs == this_nregs);
if (regno + nregs <= this_regno
continue;
}
- if (action == mark_read)
+ if (action == mark_read || action == mark_access)
{
- if (! exact_match)
- abort ();
+ gcc_assert (exact_match);
- /* ??? Class NO_REGS can happen if the md file makes use of
+ /* ??? 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 = obstack_alloc (&rename_obstack, sizeof (struct du_chain));
this->next_use = 0;
this->next_chain = (*p)->next_chain;
this->loc = loc;
this->insn = insn;
- this->class = class;
+ this->cl = cl;
this->need_caller_save_reg = 0;
while (*p)
p = &(*p)->next_use;
{
this->next_chain = closed_chains;
closed_chains = this;
- if (rtl_dump_file)
- fprintf (rtl_dump_file,
+ if (dump_file)
+ fprintf (dump_file,
"Closing chain %s at insn %d (%s)\n",
reg_names[REGNO (*this->loc)], INSN_UID (insn),
scan_actions_name[(int) action]);
}
else
{
- if (rtl_dump_file)
- fprintf (rtl_dump_file,
+ if (dump_file)
+ fprintf (dump_file,
"Discarding chain %s at insn %d (%s)\n",
reg_names[REGNO (*this->loc)], INSN_UID (insn),
scan_actions_name[(int) action]);
}
}
-/* 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))
+ if (REGNO_OK_FOR_INDEX_P (regno0)
+ && regno_ok_for_base_p (regno1, mode, PLUS, REG))
index_op = 0;
- else if (REG_OK_FOR_INDEX_P (op1)
- && REG_MODE_OK_FOR_BASE_P (op0, mode))
+ else 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_base_p (regno1, mode, PLUS, REG))
index_op = 0;
- else if (REG_MODE_OK_FOR_BASE_P (op0, mode))
+ else if (regno_ok_for_base_p (regno0, mode, PLUS, REG))
index_op = 1;
- else if (REG_OK_FOR_INDEX_P (op1))
+ else if (REGNO_OK_FOR_INDEX_P (regno1))
index_op = 1;
else
index_op = 0;
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;
}
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:
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;
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,
+ 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), 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:
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:
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))
{
(6) For any write we find in an operand, make a new chain.
(7) For any REG_UNUSED, close any chains we just opened. */
- extract_insn (insn);
- constrain_operands (1);
icode = recog_memoized (insn);
+ extract_insn (insn);
+ 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;
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.operand_loc[i] = old_operands[i];
/* Step 2B: Can't rename function call argument registers. */
- if (GET_CODE (insn) == CALL_INSN && CALL_INSN_FUNCTION_USAGE (insn))
+ if (CALL_P (insn) && CALL_INSN_FUNCTION_USAGE (insn))
scan_rtx (insn, &CALL_INSN_FUNCTION_USAGE (insn),
NO_REGS, terminate_all_read, OP_IN, 0);
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))
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, 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)
{
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
- && REGNO (op) == ORIGINAL_REGNO (op))
+ 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))
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);
+ int nregs = hard_regno_nregs[r][GET_MODE (*this->loc)];
+ fprintf (dump_file, "Register %s (%d):", reg_names[r], nregs);
while (this)
{
- fprintf (rtl_dump_file, " %d [%s]", INSN_UID (this->insn),
- reg_class_names[this->class]);
+ fprintf (dump_file, " %d [%s]", INSN_UID (this->insn),
+ reg_class_names[this->cl]);
this = this->next_use;
}
- fprintf (rtl_dump_file, "\n");
+ fprintf (dump_file, "\n");
chains = chains->next_chain;
}
}
/* 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
+ 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
+ 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. */
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 find_oldest_value_reg PARAMS ((enum reg_class, rtx,
- struct value_data *));
-static bool replace_oldest_value_reg PARAMS ((rtx *, enum reg_class, rtx,
- struct value_data *));
-static bool replace_oldest_value_addr PARAMS ((rtx *, enum reg_class,
- enum machine_mode, rtx,
- struct value_data *));
-static bool replace_oldest_value_mem PARAMS ((rtx, rtx, struct value_data *));
-static bool copyprop_hardreg_forward_1 PARAMS ((basic_block,
- struct value_data *));
-extern void debug_value_data PARAMS ((struct value_data *));
+static void kill_value_one_regno (unsigned, struct value_data *);
+static void kill_value_regno (unsigned, unsigned, struct value_data *);
+static void kill_value (rtx, struct value_data *);
+static void set_value_regno (unsigned, enum machine_mode, struct value_data *);
+static void init_value_data (struct value_data *);
+static void kill_clobbered_value (rtx, rtx, void *);
+static void kill_set_value (rtx, rtx, void *);
+static int kill_autoinc_value (rtx *, void *);
+static void copy_value (rtx, rtx, struct value_data *);
+static bool mode_change_ok (enum machine_mode, enum machine_mode,
+ unsigned int);
+static rtx maybe_mode_change (enum machine_mode, enum machine_mode,
+ enum machine_mode, unsigned int, unsigned int);
+static rtx find_oldest_value_reg (enum reg_class, rtx, struct value_data *);
+static bool replace_oldest_value_reg (rtx *, enum reg_class, rtx,
+ struct value_data *);
+static bool replace_oldest_value_addr (rtx *, enum reg_class,
+ enum machine_mode, rtx,
+ struct value_data *);
+static bool replace_oldest_value_mem (rtx, rtx, struct value_data *);
+static bool copyprop_hardreg_forward_1 (basic_block, struct value_data *);
+extern void debug_value_data (struct value_data *);
#ifdef ENABLE_CHECKING
-static void validate_value_data PARAMS ((struct value_data *));
+static void validate_value_data (struct value_data *);
#endif
-/* Kill register REGNO. This involves removing it from any value lists,
- and resetting the value mode to VOIDmode. */
+/* Kill register REGNO. This involves removing it from any value
+ lists, and resetting the value mode to VOIDmode. This is only a
+ helper function; it does not handle any hard registers overlapping
+ with REGNO. */
static void
-kill_value_regno (regno, vd)
- unsigned int regno;
- struct value_data *vd;
+kill_value_one_regno (unsigned int regno, struct value_data *vd)
{
unsigned int i, next;
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[i].oldest_regno = next;
}
vd->e[regno].mode = VOIDmode;
#endif
}
-/* Kill X. This is a convenience function for kill_value_regno
+/* Kill the value in register REGNO for NREGS, and any other registers
+ whose values overlap. */
+
+static void
+kill_value_regno (unsigned int regno, unsigned int nregs,
+ struct value_data *vd)
+{
+ unsigned int j;
+
+ /* Kill the value we're told to kill. */
+ for (j = 0; j < nregs; ++j)
+ kill_value_one_regno (regno + j, vd);
+
+ /* Kill everything that overlapped what we're told to kill. */
+ if (regno < vd->max_value_regs)
+ j = 0;
+ else
+ j = regno - vd->max_value_regs;
+ for (; j < regno; ++j)
+ {
+ unsigned int i, n;
+ if (vd->e[j].mode == VOIDmode)
+ continue;
+ n = hard_regno_nregs[j][vd->e[j].mode];
+ if (j + n > regno)
+ for (i = 0; i < n; ++i)
+ kill_value_one_regno (j + i, vd);
+ }
+}
+
+/* Kill X. This is a convenience function wrapping kill_value_regno
so that we mind the mode the register is in. */
static void
-kill_value (x, vd)
- rtx x;
- struct value_data *vd;
+kill_value (rtx x, struct value_data *vd)
{
- /* SUBREGS are supposed to have been eliminated by now. But some
- ports, e.g. i386 sse, use them to smuggle vector type information
- through to instruction selection. Each such SUBREG should simplify,
- so if we get a NULL we've done something wrong elsewhere. */
+ rtx orig_rtx = x;
if (GET_CODE (x) == SUBREG)
- x = simplify_subreg (GET_MODE (x), SUBREG_REG (x),
- GET_MODE (SUBREG_REG (x)), SUBREG_BYTE (x));
+ {
+ x = simplify_subreg (GET_MODE (x), SUBREG_REG (x),
+ GET_MODE (SUBREG_REG (x)), SUBREG_BYTE (x));
+ if (x == NULL_RTX)
+ x = SUBREG_REG (orig_rtx);
+ }
if (REG_P (x))
{
unsigned int regno = REGNO (x);
- unsigned int n = HARD_REGNO_NREGS (regno, GET_MODE (x));
- unsigned int i, j;
+ unsigned int n = hard_regno_nregs[regno][GET_MODE (x)];
- /* Kill the value we're told to kill. */
- for (i = 0; i < n; ++i)
- kill_value_regno (regno + i, vd);
-
- /* Kill everything that overlapped what we're told to kill. */
- if (regno < vd->max_value_regs)
- j = 0;
- else
- j = regno - vd->max_value_regs;
- for (; j < regno; ++j)
- {
- if (vd->e[j].mode == VOIDmode)
- continue;
- n = HARD_REGNO_NREGS (j, vd->e[j].mode);
- if (j + n > regno)
- for (i = 0; i < n; ++i)
- kill_value_regno (j + i, vd);
- }
+ kill_value_regno (regno, n, vd);
}
}
/* Remember that REGNO is valid in MODE. */
static void
-set_value_regno (regno, mode, vd)
- unsigned int regno;
- enum machine_mode mode;
- struct value_data *vd;
+set_value_regno (unsigned int regno, enum machine_mode mode,
+ struct value_data *vd)
{
unsigned int nregs;
vd->e[regno].mode = mode;
- nregs = HARD_REGNO_NREGS (regno, mode);
+ nregs = hard_regno_nregs[regno][mode];
if (nregs > vd->max_value_regs)
vd->max_value_regs = nregs;
}
/* Initialize VD such that there are no known relationships between regs. */
static void
-init_value_data (vd)
- struct value_data *vd;
+init_value_data (struct value_data *vd)
{
int i;
for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
/* Called through note_stores. If X is clobbered, kill its value. */
static void
-kill_clobbered_value (x, set, data)
- rtx x;
- rtx set;
- void *data;
+kill_clobbered_value (rtx x, rtx set, void *data)
{
struct value_data *vd = data;
if (GET_CODE (set) == CLOBBER)
kill_value (x, vd);
}
-/* Called through note_stores. If X is set, not clobbered, kill its
+/* 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;
+kill_set_value (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);
+ set_value_regno (REGNO (x), GET_MODE (x), vd);
}
}
own value list. */
static int
-kill_autoinc_value (px, data)
- rtx *px;
- void *data;
+kill_autoinc_value (rtx *px, void *data)
{
rtx x = *px;
struct value_data *vd = data;
- if (GET_RTX_CLASS (GET_CODE (x)) == 'a')
+ if (GET_RTX_CLASS (GET_CODE (x)) == RTX_AUTOINC)
{
x = XEXP (x, 0);
kill_value (x, vd);
to reflect that SRC contains an older copy of the shared value. */
static void
-copy_value (dest, src, vd)
- rtx dest;
- rtx src;
- struct value_data *vd;
+copy_value (rtx dest, rtx src, struct value_data *vd)
{
unsigned int dr = REGNO (dest);
unsigned int sr = REGNO (src);
return;
/* Do not propagate copies to the stack pointer, as that can leave
- memory accesses with no scheduling dependancy on the stack update. */
+ memory accesses with no scheduling dependency on the stack update. */
if (dr == STACK_POINTER_REGNUM)
return;
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));
+ 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 (vd->e[sr].mode == VOIDmode)
set_value_regno (sr, vd->e[dr].mode, vd);
+ /* If we are narrowing the input to a smaller number of hard regs,
+ and it is in big endian, we are really extracting a high part.
+ Since we generally associate a low part of a value with the value itself,
+ we must not do the same for the high part.
+ 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))
+ 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. */
/* Return true if a mode change from ORIG to NEW is allowed for REGNO. */
static bool
-mode_change_ok (orig_mode, new_mode, regno)
- enum machine_mode orig_mode, new_mode;
- unsigned int regno ATTRIBUTE_UNUSED;
+mode_change_ok (enum machine_mode orig_mode, enum machine_mode new_mode,
+ unsigned int regno ATTRIBUTE_UNUSED)
{
if (GET_MODE_SIZE (orig_mode) < GET_MODE_SIZE (new_mode))
return false;
-#ifdef CLASS_CANNOT_CHANGE_MODE
- if (TEST_HARD_REG_BIT (reg_class_contents[CLASS_CANNOT_CHANGE_MODE], regno)
- && CLASS_CANNOT_CHANGE_MODE_P (orig_mode, new_mode))
- return false;
+#ifdef CANNOT_CHANGE_MODE_CLASS
+ return !REG_CANNOT_CHANGE_MODE_P (regno, orig_mode, new_mode);
#endif
return true;
}
+/* 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 (enum machine_mode orig_mode, enum machine_mode copy_mode,
+ enum machine_mode new_mode, unsigned int regno,
+ unsigned int copy_regno ATTRIBUTE_UNUSED)
+{
+ if (orig_mode == new_mode)
+ return gen_rtx_raw_REG (new_mode, regno);
+ else if (mode_change_ok (orig_mode, new_mode, regno))
+ {
+ int copy_nregs = hard_regno_nregs[copy_regno][copy_mode];
+ int use_nregs = hard_regno_nregs[copy_regno][new_mode];
+ int copy_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
+ register class CL and has mode MODE. If found, return an rtx
of that oldest register, otherwise return NULL. */
static rtx
-find_oldest_value_reg (class, reg, vd)
- enum reg_class class;
- rtx reg;
- struct value_data *vd;
+find_oldest_value_reg (enum reg_class cl, rtx reg, struct value_data *vd)
{
unsigned int regno = REGNO (reg);
enum machine_mode mode = GET_MODE (reg);
Replacing r9 with r11 is invalid. */
if (mode != vd->e[regno].mode)
{
- if (HARD_REGNO_NREGS (regno, mode)
- > HARD_REGNO_NREGS (regno, vd->e[regno].mode))
+ if (hard_regno_nregs[regno][mode]
+ > hard_regno_nregs[regno][vd->e[regno].mode])
return NULL_RTX;
}
for (i = vd->e[regno].oldest_regno; i != regno; i = vd->e[i].next_regno)
- if (TEST_HARD_REG_BIT (reg_class_contents[class], i)
- && (vd->e[i].mode == mode
- || mode_change_ok (vd->e[i].mode, mode, i)))
- {
- rtx new = gen_rtx_raw_REG (mode, i);
- ORIGINAL_REGNO (new) = ORIGINAL_REGNO (reg);
- return new;
- }
+ {
+ enum machine_mode oldmode = vd->e[i].mode;
+ rtx new;
+ unsigned int last;
+
+ for (last = i; last < i + hard_regno_nregs[i][mode]; last++)
+ if (!TEST_HARD_REG_BIT (reg_class_contents[cl], last))
+ return NULL_RTX;
+
+ new = maybe_mode_change (oldmode, vd->e[regno].mode, mode, i, regno);
+ if (new)
+ {
+ ORIGINAL_REGNO (new) = ORIGINAL_REGNO (reg);
+ REG_ATTRS (new) = REG_ATTRS (reg);
+ return new;
+ }
+ }
return NULL_RTX;
}
/* If possible, replace the register at *LOC with the oldest register
- in register class CLASS. Return true if successfully replaced. */
+ in register class CL. Return true if successfully replaced. */
static bool
-replace_oldest_value_reg (loc, class, insn, vd)
- rtx *loc;
- enum reg_class class;
- rtx insn;
- struct value_data *vd;
+replace_oldest_value_reg (rtx *loc, enum reg_class cl, rtx insn,
+ struct value_data *vd)
{
- rtx new = find_oldest_value_reg (class, *loc, vd);
+ rtx new = find_oldest_value_reg (cl, *loc, vd);
if (new)
{
- if (rtl_dump_file)
- fprintf (rtl_dump_file, "insn %u: replaced reg %u with %u\n",
+ if (dump_file)
+ fprintf (dump_file, "insn %u: replaced reg %u with %u\n",
INSN_UID (insn), REGNO (*loc), REGNO (new));
- *loc = new;
+ validate_change (insn, loc, new, 1);
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
+ Adapted from find_reloads_address_1. CL is INDEX_REG_CLASS or
BASE_REG_CLASS depending on how the register is being considered. */
static bool
-replace_oldest_value_addr (loc, class, mode, insn, vd)
- rtx *loc;
- enum reg_class class;
- enum machine_mode mode;
- rtx insn;
- struct value_data *vd;
+replace_oldest_value_addr (rtx *loc, enum reg_class cl,
+ enum machine_mode mode, rtx insn,
+ struct value_data *vd)
{
rtx x = *loc;
RTX_CODE code = GET_CODE (x);
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))
+ if (REGNO_OK_FOR_INDEX_P (regno0)
+ && regno_ok_for_base_p (regno1, mode, PLUS, REG))
index_op = 0;
- else if (REG_OK_FOR_INDEX_P (op1)
- && REG_MODE_OK_FOR_BASE_P (op0, mode))
+ else 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_base_p (regno1, mode, PLUS, REG))
index_op = 0;
- else if (REG_MODE_OK_FOR_BASE_P (op0, mode))
+ else if (regno_ok_for_base_p (regno0, mode, PLUS, REG))
index_op = 1;
- else if (REG_OK_FOR_INDEX_P (op1))
+ else if (REGNO_OK_FOR_INDEX_P (regno1))
index_op = 1;
else
index_op = 0;
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)
changed |= replace_oldest_value_addr (locI, INDEX_REG_CLASS, mode,
- insn, vd);
+ insn, vd);
if (locB)
changed |= replace_oldest_value_addr (locB,
- MODE_BASE_REG_CLASS (mode),
+ base_reg_class (mode, PLUS,
+ index_code),
mode, insn, vd);
return changed;
}
return replace_oldest_value_mem (x, insn, vd);
case REG:
- return replace_oldest_value_reg (loc, class, insn, vd);
+ return replace_oldest_value_reg (loc, cl, insn, vd);
default:
break;
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
{
if (fmt[i] == 'e')
- changed |= replace_oldest_value_addr (&XEXP (x, i), class, mode,
+ changed |= replace_oldest_value_addr (&XEXP (x, i), cl, mode,
insn, vd);
else if (fmt[i] == 'E')
for (j = XVECLEN (x, i) - 1; j >= 0; j--)
- changed |= replace_oldest_value_addr (&XVECEXP (x, i, j), class,
- mode, insn, vd);
+ changed |= replace_oldest_value_addr (&XVECEXP (x, i, j), cl,
+ 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;
+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);
}
/* Perform the forward copy propagation on basic block BB. */
static bool
-copyprop_hardreg_forward_1 (bb, vd)
- basic_block bb;
- struct value_data *vd;
+copyprop_hardreg_forward_1 (basic_block bb, struct value_data *vd)
{
bool changed = false;
rtx insn;
- for (insn = bb->head; ; insn = NEXT_INSN (insn))
+ for (insn = BB_HEAD (bb); ; insn = NEXT_INSN (insn))
{
int n_ops, i, alt, predicated;
- bool is_asm;
+ bool is_asm, any_replacements;
rtx set;
+ bool replaced[MAX_RECOG_OPERANDS];
if (! INSN_P (insn))
{
- if (insn == bb->end)
+ if (insn == BB_END (bb))
break;
else
continue;
set = single_set (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;
set it in, make sure that the replacement is valid. */
if (mode != vd->e[regno].mode)
{
- if (HARD_REGNO_NREGS (regno, mode)
- > HARD_REGNO_NREGS (regno, vd->e[regno].mode))
+ if (hard_regno_nregs[regno][mode]
+ > hard_regno_nregs[regno][vd->e[regno].mode])
goto no_move_special_case;
}
new = find_oldest_value_reg (REGNO_REG_CLASS (regno), src, vd);
if (new && validate_change (insn, &SET_SRC (set), new, 0))
{
- if (rtl_dump_file)
- fprintf (rtl_dump_file,
+ if (dump_file)
+ fprintf (dump_file,
"insn %u: replaced reg %u with %u\n",
INSN_UID (insn), regno, REGNO (new));
- changed = true;
+ 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)
- if (vd->e[i].mode == mode
- || mode_change_ok (vd->e[i].mode, mode, i))
- {
- new = gen_rtx_raw_REG (mode, i);
- 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;
- }
- }
+ {
+ 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);
+ REG_ATTRS (new) = REG_ATTRS (src);
+ if (dump_file)
+ fprintf (dump_file,
+ "insn %u: replaced reg %u with %u\n",
+ INSN_UID (insn), regno, REGNO (new));
+ changed = true;
+ goto did_replacement;
+ }
+ }
+ }
}
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
continue;
/* Don't replace in asms intentionally referencing hard regs. */
- if (is_asm && GET_CODE (recog_data.operand[i]) == REG
+ if (is_asm && REG_P (recog_data.operand[i])
&& (REGNO (recog_data.operand[i])
== ORIGINAL_REGNO (recog_data.operand[i])))
continue;
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].class,
+ 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].class,
+ recog_op_alt[i][alt].cl,
insn, vd);
- else if (GET_CODE (recog_data.operand[i]) == MEM)
- replaced = replace_oldest_value_mem (recog_data.operand[i],
- insn, vd);
+ else if (MEM_P (recog_data.operand[i]))
+ replaced[i] = 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);
+ else if (MEM_P (recog_data.operand[i]))
+ 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;
-
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;
+ validate_change (insn, recog_data.dup_loc[j], new, 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 (GET_CODE (insn) == CALL_INSN)
+ if (CALL_P (insn))
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
if (TEST_HARD_REG_BIT (regs_invalidated_by_call, i))
- kill_value_regno (i, vd);
+ kill_value_regno (i, 1, vd);
/* Notice stores. */
note_stores (PATTERN (insn), kill_set_value, vd);
if (set && REG_P (SET_DEST (set)) && REG_P (SET_SRC (set)))
copy_value (SET_DEST (set), SET_SRC (set), vd);
- if (insn == bb->end)
+ if (insn == BB_END (bb))
break;
}
/* Main entry point for the forward copy propagation optimization. */
-void
-copyprop_hardreg_forward ()
+static void
+copyprop_hardreg_forward (void)
{
struct value_data *all_vd;
bool need_refresh;
- int b;
+ basic_block bb;
+ sbitmap visited;
need_refresh = false;
- all_vd = xmalloc (sizeof (struct value_data) * n_basic_blocks);
+ all_vd = XNEWVEC (struct value_data, last_basic_block);
+
+ visited = sbitmap_alloc (last_basic_block);
+ sbitmap_zero (visited);
- for (b = 0; b < n_basic_blocks; b++)
+ FOR_EACH_BB (bb)
{
- basic_block bb = BASIC_BLOCK (b);
+ 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 queueing of blocks. */
- if (bb->pred
- && ! bb->pred->pred_next
- && ! (bb->pred->flags & (EDGE_ABNORMAL_CALL | EDGE_EH))
- && bb->pred->src->index != ENTRY_BLOCK
- && bb->pred->src->index < b)
- all_vd[b] = all_vd[bb->pred->src->index];
+ /* ??? Ought to use more intelligent queuing of blocks. */
+ 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 + b);
+ init_value_data (all_vd + bb->index);
- if (copyprop_hardreg_forward_1 (bb, all_vd + b))
+ if (copyprop_hardreg_forward_1 (bb, all_vd + bb->index))
need_refresh = true;
}
+ sbitmap_free (visited);
+
if (need_refresh)
{
- if (rtl_dump_file)
- fputs ("\n\n", rtl_dump_file);
+ if (dump_file)
+ fputs ("\n\n", dump_file);
/* ??? Irritatingly, delete_noop_moves does not take a set of blocks
to scan, so we have to do a life update with no initial set of
blocks Just In Case. */
- delete_noop_moves (get_insns ());
+ delete_noop_moves ();
update_life_info (NULL, UPDATE_LIFE_GLOBAL_RM_NOTES,
PROP_DEATH_NOTES
| PROP_SCAN_DEAD_CODE
/* Dump the value chain data to stderr. */
void
-debug_value_data (vd)
- struct value_data *vd;
+debug_value_data (struct value_data *vd)
{
HARD_REG_SET set;
unsigned int i, j;
#ifdef ENABLE_CHECKING
static void
-validate_value_data (vd)
- struct value_data *vd;
+validate_value_data (struct value_data *vd)
{
HARD_REG_SET set;
unsigned int i, j;
vd->e[i].next_regno);
}
#endif
+\f
+static bool
+gate_handle_regrename (void)
+{
+ return (optimize > 0 && (flag_rename_registers || flag_cprop_registers));
+}
+
+
+/* Run the regrename and cprop passes. */
+static unsigned int
+rest_of_handle_regrename (void)
+{
+ if (flag_rename_registers)
+ regrename_optimize ();
+ if (flag_cprop_registers)
+ copyprop_hardreg_forward ();
+ return 0;
+}
+
+struct tree_opt_pass pass_regrename =
+{
+ "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_dump_func, /* todo_flags_finish */
+ 'n' /* letter */
+};
+