/* Register renaming for the GNU compiler.
|
/* Register renaming for the GNU compiler.
|
Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007
|
Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007
|
Free Software Foundation, Inc.
|
Free Software Foundation, Inc.
|
|
|
This file is part of GCC.
|
This file is part of GCC.
|
|
|
GCC is free software; you can redistribute it and/or modify it
|
GCC is free software; you can redistribute it and/or modify it
|
under the terms of the GNU General Public License as published by
|
under the terms of the GNU General Public License as published by
|
the Free Software Foundation; either version 3, or (at your option)
|
the Free Software Foundation; either version 3, or (at your option)
|
any later version.
|
any later version.
|
|
|
GCC is distributed in the hope that it will be useful, but WITHOUT
|
GCC is distributed in the hope that it will be useful, but WITHOUT
|
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
|
or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
|
License for more details.
|
License for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with GCC; see the file COPYING3. If not see
|
along with GCC; see the file COPYING3. If not see
|
<http://www.gnu.org/licenses/>. */
|
<http://www.gnu.org/licenses/>. */
|
|
|
#include "config.h"
|
#include "config.h"
|
#include "system.h"
|
#include "system.h"
|
#include "coretypes.h"
|
#include "coretypes.h"
|
#include "tm.h"
|
#include "tm.h"
|
#include "rtl.h"
|
#include "rtl.h"
|
#include "tm_p.h"
|
#include "tm_p.h"
|
#include "insn-config.h"
|
#include "insn-config.h"
|
#include "regs.h"
|
#include "regs.h"
|
#include "addresses.h"
|
#include "addresses.h"
|
#include "hard-reg-set.h"
|
#include "hard-reg-set.h"
|
#include "basic-block.h"
|
#include "basic-block.h"
|
#include "reload.h"
|
#include "reload.h"
|
#include "output.h"
|
#include "output.h"
|
#include "function.h"
|
#include "function.h"
|
#include "recog.h"
|
#include "recog.h"
|
#include "flags.h"
|
#include "flags.h"
|
#include "toplev.h"
|
#include "toplev.h"
|
#include "obstack.h"
|
#include "obstack.h"
|
#include "timevar.h"
|
#include "timevar.h"
|
#include "tree-pass.h"
|
#include "tree-pass.h"
|
|
|
struct du_chain
|
struct du_chain
|
{
|
{
|
struct du_chain *next_chain;
|
struct du_chain *next_chain;
|
struct du_chain *next_use;
|
struct du_chain *next_use;
|
|
|
rtx insn;
|
rtx insn;
|
rtx *loc;
|
rtx *loc;
|
ENUM_BITFIELD(reg_class) cl : 16;
|
ENUM_BITFIELD(reg_class) cl : 16;
|
unsigned int need_caller_save_reg:1;
|
unsigned int need_caller_save_reg:1;
|
unsigned int earlyclobber:1;
|
unsigned int earlyclobber:1;
|
};
|
};
|
|
|
enum scan_actions
|
enum scan_actions
|
{
|
{
|
terminate_all_read,
|
terminate_all_read,
|
terminate_overlapping_read,
|
terminate_overlapping_read,
|
terminate_write,
|
terminate_write,
|
terminate_dead,
|
terminate_dead,
|
mark_read,
|
mark_read,
|
mark_write,
|
mark_write,
|
/* mark_access is for marking the destination regs in
|
/* mark_access is for marking the destination regs in
|
REG_FRAME_RELATED_EXPR notes (as if they were read) so that the
|
REG_FRAME_RELATED_EXPR notes (as if they were read) so that the
|
note is updated properly. */
|
note is updated properly. */
|
mark_access
|
mark_access
|
};
|
};
|
|
|
static const char * const scan_actions_name[] =
|
static const char * const scan_actions_name[] =
|
{
|
{
|
"terminate_all_read",
|
"terminate_all_read",
|
"terminate_overlapping_read",
|
"terminate_overlapping_read",
|
"terminate_write",
|
"terminate_write",
|
"terminate_dead",
|
"terminate_dead",
|
"mark_read",
|
"mark_read",
|
"mark_write",
|
"mark_write",
|
"mark_access"
|
"mark_access"
|
};
|
};
|
|
|
static struct obstack rename_obstack;
|
static struct obstack rename_obstack;
|
|
|
static void do_replace (struct du_chain *, int);
|
static void do_replace (struct du_chain *, int);
|
static void scan_rtx_reg (rtx, rtx *, enum reg_class,
|
static void scan_rtx_reg (rtx, rtx *, enum reg_class,
|
enum scan_actions, enum op_type, int);
|
enum scan_actions, enum op_type, int);
|
static void scan_rtx_address (rtx, rtx *, enum reg_class,
|
static void scan_rtx_address (rtx, rtx *, enum reg_class,
|
enum scan_actions, enum machine_mode);
|
enum scan_actions, enum machine_mode);
|
static void scan_rtx (rtx, rtx *, enum reg_class, enum scan_actions,
|
static void scan_rtx (rtx, rtx *, enum reg_class, enum scan_actions,
|
enum op_type, int);
|
enum op_type, int);
|
static struct du_chain *build_def_use (basic_block);
|
static struct du_chain *build_def_use (basic_block);
|
static void dump_def_use_chain (struct du_chain *);
|
static void dump_def_use_chain (struct du_chain *);
|
static void note_sets (rtx, rtx, void *);
|
static void note_sets (rtx, rtx, void *);
|
static void clear_dead_regs (HARD_REG_SET *, enum machine_mode, rtx);
|
static void clear_dead_regs (HARD_REG_SET *, enum machine_mode, rtx);
|
static void merge_overlapping_regs (basic_block, HARD_REG_SET *,
|
static void merge_overlapping_regs (basic_block, HARD_REG_SET *,
|
struct du_chain *);
|
struct du_chain *);
|
|
|
/* Called through note_stores from update_life. Find sets of registers, and
|
/* Called through note_stores from update_life. Find sets of registers, and
|
record them in *DATA (which is actually a HARD_REG_SET *). */
|
record them in *DATA (which is actually a HARD_REG_SET *). */
|
|
|
static void
|
static void
|
note_sets (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;
|
HARD_REG_SET *pset = (HARD_REG_SET *) data;
|
unsigned int regno;
|
unsigned int regno;
|
int nregs;
|
int nregs;
|
|
|
if (GET_CODE (x) == SUBREG)
|
if (GET_CODE (x) == SUBREG)
|
x = SUBREG_REG (x);
|
x = SUBREG_REG (x);
|
if (!REG_P (x))
|
if (!REG_P (x))
|
return;
|
return;
|
regno = REGNO (x);
|
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. */
|
/* There must not be pseudos at this point. */
|
gcc_assert (regno + nregs <= FIRST_PSEUDO_REGISTER);
|
gcc_assert (regno + nregs <= FIRST_PSEUDO_REGISTER);
|
|
|
while (nregs-- > 0)
|
while (nregs-- > 0)
|
SET_HARD_REG_BIT (*pset, regno + nregs);
|
SET_HARD_REG_BIT (*pset, regno + nregs);
|
}
|
}
|
|
|
/* Clear all registers from *PSET for which a note of kind KIND can be found
|
/* Clear all registers from *PSET for which a note of kind KIND can be found
|
in the list NOTES. */
|
in the list NOTES. */
|
|
|
static void
|
static void
|
clear_dead_regs (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;
|
rtx note;
|
for (note = notes; note; note = XEXP (note, 1))
|
for (note = notes; note; note = XEXP (note, 1))
|
if (REG_NOTE_KIND (note) == kind && REG_P (XEXP (note, 0)))
|
if (REG_NOTE_KIND (note) == kind && REG_P (XEXP (note, 0)))
|
{
|
{
|
rtx reg = XEXP (note, 0);
|
rtx reg = XEXP (note, 0);
|
unsigned int regno = REGNO (reg);
|
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. */
|
/* There must not be pseudos at this point. */
|
gcc_assert (regno + nregs <= FIRST_PSEUDO_REGISTER);
|
gcc_assert (regno + nregs <= FIRST_PSEUDO_REGISTER);
|
|
|
while (nregs-- > 0)
|
while (nregs-- > 0)
|
CLEAR_HARD_REG_BIT (*pset, regno + nregs);
|
CLEAR_HARD_REG_BIT (*pset, regno + nregs);
|
}
|
}
|
}
|
}
|
|
|
/* For a def-use chain CHAIN in basic block B, find which registers overlap
|
/* For a def-use chain CHAIN in basic block B, find which registers overlap
|
its lifetime and set the corresponding bits in *PSET. */
|
its lifetime and set the corresponding bits in *PSET. */
|
|
|
static void
|
static void
|
merge_overlapping_regs (basic_block b, HARD_REG_SET *pset,
|
merge_overlapping_regs (basic_block b, HARD_REG_SET *pset,
|
struct du_chain *chain)
|
struct du_chain *chain)
|
{
|
{
|
struct du_chain *t = chain;
|
struct du_chain *t = chain;
|
rtx insn;
|
rtx insn;
|
HARD_REG_SET live;
|
HARD_REG_SET live;
|
|
|
REG_SET_TO_HARD_REG_SET (live, b->il.rtl->global_live_at_start);
|
REG_SET_TO_HARD_REG_SET (live, b->il.rtl->global_live_at_start);
|
insn = BB_HEAD (b);
|
insn = BB_HEAD (b);
|
while (t)
|
while (t)
|
{
|
{
|
/* Search forward until the next reference to the register to be
|
/* Search forward until the next reference to the register to be
|
renamed. */
|
renamed. */
|
while (insn != t->insn)
|
while (insn != t->insn)
|
{
|
{
|
if (INSN_P (insn))
|
if (INSN_P (insn))
|
{
|
{
|
clear_dead_regs (&live, REG_DEAD, REG_NOTES (insn));
|
clear_dead_regs (&live, REG_DEAD, REG_NOTES (insn));
|
note_stores (PATTERN (insn), note_sets, (void *) &live);
|
note_stores (PATTERN (insn), note_sets, (void *) &live);
|
/* Only record currently live regs if we are inside the
|
/* Only record currently live regs if we are inside the
|
reg's live range. */
|
reg's live range. */
|
if (t != chain)
|
if (t != chain)
|
IOR_HARD_REG_SET (*pset, live);
|
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);
|
insn = NEXT_INSN (insn);
|
}
|
}
|
|
|
IOR_HARD_REG_SET (*pset, live);
|
IOR_HARD_REG_SET (*pset, live);
|
|
|
/* For the last reference, also merge in all registers set in the
|
/* For the last reference, also merge in all registers set in the
|
same insn.
|
same insn.
|
@@@ We only have take earlyclobbered sets into account. */
|
@@@ We only have take earlyclobbered sets into account. */
|
if (! t->next_use)
|
if (! t->next_use)
|
note_stores (PATTERN (insn), note_sets, (void *) pset);
|
note_stores (PATTERN (insn), note_sets, (void *) pset);
|
|
|
t = t->next_use;
|
t = t->next_use;
|
}
|
}
|
}
|
}
|
|
|
/* Perform register renaming on the current function. */
|
/* Perform register renaming on the current function. */
|
|
|
static void
|
static void
|
regrename_optimize (void)
|
regrename_optimize (void)
|
{
|
{
|
int tick[FIRST_PSEUDO_REGISTER];
|
int tick[FIRST_PSEUDO_REGISTER];
|
int this_tick = 0;
|
int this_tick = 0;
|
basic_block bb;
|
basic_block bb;
|
char *first_obj;
|
char *first_obj;
|
|
|
memset (tick, 0, sizeof tick);
|
memset (tick, 0, sizeof tick);
|
|
|
gcc_obstack_init (&rename_obstack);
|
gcc_obstack_init (&rename_obstack);
|
first_obj = obstack_alloc (&rename_obstack, 0);
|
first_obj = obstack_alloc (&rename_obstack, 0);
|
|
|
FOR_EACH_BB (bb)
|
FOR_EACH_BB (bb)
|
{
|
{
|
struct du_chain *all_chains = 0;
|
struct du_chain *all_chains = 0;
|
HARD_REG_SET unavailable;
|
HARD_REG_SET unavailable;
|
HARD_REG_SET regs_seen;
|
HARD_REG_SET regs_seen;
|
|
|
CLEAR_HARD_REG_SET (unavailable);
|
CLEAR_HARD_REG_SET (unavailable);
|
|
|
if (dump_file)
|
if (dump_file)
|
fprintf (dump_file, "\nBasic block %d:\n", bb->index);
|
fprintf (dump_file, "\nBasic block %d:\n", bb->index);
|
|
|
all_chains = build_def_use (bb);
|
all_chains = build_def_use (bb);
|
|
|
if (dump_file)
|
if (dump_file)
|
dump_def_use_chain (all_chains);
|
dump_def_use_chain (all_chains);
|
|
|
CLEAR_HARD_REG_SET (unavailable);
|
CLEAR_HARD_REG_SET (unavailable);
|
/* Don't clobber traceback for noreturn functions. */
|
/* Don't clobber traceback for noreturn functions. */
|
if (frame_pointer_needed)
|
if (frame_pointer_needed)
|
{
|
{
|
int i;
|
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);
|
SET_HARD_REG_BIT (unavailable, FRAME_POINTER_REGNUM + i);
|
|
|
#if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
|
#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);
|
SET_HARD_REG_BIT (unavailable, HARD_FRAME_POINTER_REGNUM + i);
|
#endif
|
#endif
|
}
|
}
|
|
|
CLEAR_HARD_REG_SET (regs_seen);
|
CLEAR_HARD_REG_SET (regs_seen);
|
while (all_chains)
|
while (all_chains)
|
{
|
{
|
int new_reg, best_new_reg;
|
int new_reg, best_new_reg;
|
int n_uses;
|
int n_uses;
|
struct du_chain *this = all_chains;
|
struct du_chain *this = all_chains;
|
struct du_chain *tmp, *last;
|
struct du_chain *tmp, *last;
|
HARD_REG_SET this_unavailable;
|
HARD_REG_SET this_unavailable;
|
int reg = REGNO (*this->loc);
|
int reg = REGNO (*this->loc);
|
int i;
|
int i;
|
|
|
all_chains = this->next_chain;
|
all_chains = this->next_chain;
|
|
|
best_new_reg = reg;
|
best_new_reg = reg;
|
|
|
#if 0 /* This just disables optimization opportunities. */
|
#if 0 /* This just disables optimization opportunities. */
|
/* Only rename once we've seen the reg more than once. */
|
/* Only rename once we've seen the reg more than once. */
|
if (! TEST_HARD_REG_BIT (regs_seen, reg))
|
if (! TEST_HARD_REG_BIT (regs_seen, reg))
|
{
|
{
|
SET_HARD_REG_BIT (regs_seen, reg);
|
SET_HARD_REG_BIT (regs_seen, reg);
|
continue;
|
continue;
|
}
|
}
|
#endif
|
#endif
|
|
|
if (fixed_regs[reg] || global_regs[reg]
|
if (fixed_regs[reg] || global_regs[reg]
|
#if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
|
#if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
|
|| (frame_pointer_needed && reg == HARD_FRAME_POINTER_REGNUM)
|
|| (frame_pointer_needed && reg == HARD_FRAME_POINTER_REGNUM)
|
#else
|
#else
|
|| (frame_pointer_needed && reg == FRAME_POINTER_REGNUM)
|
|| (frame_pointer_needed && reg == FRAME_POINTER_REGNUM)
|
#endif
|
#endif
|
)
|
)
|
continue;
|
continue;
|
|
|
COPY_HARD_REG_SET (this_unavailable, unavailable);
|
COPY_HARD_REG_SET (this_unavailable, unavailable);
|
|
|
/* Find last entry on chain (which has the need_caller_save bit),
|
/* 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. */
|
use for renaming. */
|
n_uses = 0;
|
n_uses = 0;
|
for (last = this; last->next_use; last = last->next_use)
|
for (last = this; last->next_use; last = last->next_use)
|
{
|
{
|
n_uses++;
|
n_uses++;
|
IOR_COMPL_HARD_REG_SET (this_unavailable,
|
IOR_COMPL_HARD_REG_SET (this_unavailable,
|
reg_class_contents[last->cl]);
|
reg_class_contents[last->cl]);
|
}
|
}
|
if (n_uses < 1)
|
if (n_uses < 1)
|
continue;
|
continue;
|
|
|
IOR_COMPL_HARD_REG_SET (this_unavailable,
|
IOR_COMPL_HARD_REG_SET (this_unavailable,
|
reg_class_contents[last->cl]);
|
reg_class_contents[last->cl]);
|
|
|
if (this->need_caller_save_reg)
|
if (this->need_caller_save_reg)
|
IOR_HARD_REG_SET (this_unavailable, call_used_reg_set);
|
IOR_HARD_REG_SET (this_unavailable, call_used_reg_set);
|
|
|
merge_overlapping_regs (bb, &this_unavailable, this);
|
merge_overlapping_regs (bb, &this_unavailable, this);
|
|
|
/* Now potential_regs is a reasonable approximation, let's
|
/* Now potential_regs is a reasonable approximation, let's
|
have a closer look at each register still in there. */
|
have a closer look at each register still in there. */
|
for (new_reg = 0; new_reg < FIRST_PSEUDO_REGISTER; new_reg++)
|
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)
|
for (i = nregs - 1; i >= 0; --i)
|
if (TEST_HARD_REG_BIT (this_unavailable, new_reg + i)
|
if (TEST_HARD_REG_BIT (this_unavailable, new_reg + i)
|
|| fixed_regs[new_reg + i]
|
|| fixed_regs[new_reg + i]
|
|| global_regs[new_reg + i]
|
|| global_regs[new_reg + i]
|
/* Can't use regs which aren't saved by the prologue. */
|
/* Can't use regs which aren't saved by the prologue. */
|
|| (! regs_ever_live[new_reg + i]
|
|| (! regs_ever_live[new_reg + i]
|
&& ! call_used_regs[new_reg + i])
|
&& ! call_used_regs[new_reg + i])
|
#ifdef LEAF_REGISTERS
|
#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. */
|
leaf function. */
|
|| (current_function_is_leaf
|
|| (current_function_is_leaf
|
&& !LEAF_REGISTERS[new_reg + i])
|
&& !LEAF_REGISTERS[new_reg + i])
|
#endif
|
#endif
|
#ifdef HARD_REGNO_RENAME_OK
|
#ifdef HARD_REGNO_RENAME_OK
|
|| ! HARD_REGNO_RENAME_OK (reg + i, new_reg + i)
|
|| ! HARD_REGNO_RENAME_OK (reg + i, new_reg + i)
|
#endif
|
#endif
|
)
|
)
|
break;
|
break;
|
if (i >= 0)
|
if (i >= 0)
|
continue;
|
continue;
|
|
|
/* See whether it accepts all modes that occur in
|
/* See whether it accepts all modes that occur in
|
definition and uses. */
|
definition and uses. */
|
for (tmp = this; tmp; tmp = tmp->next_use)
|
for (tmp = this; tmp; tmp = tmp->next_use)
|
if (! HARD_REGNO_MODE_OK (new_reg, GET_MODE (*tmp->loc))
|
if (! HARD_REGNO_MODE_OK (new_reg, GET_MODE (*tmp->loc))
|
|| (tmp->need_caller_save_reg
|
|| (tmp->need_caller_save_reg
|
&& ! (HARD_REGNO_CALL_PART_CLOBBERED
|
&& ! (HARD_REGNO_CALL_PART_CLOBBERED
|
(reg, GET_MODE (*tmp->loc)))
|
(reg, GET_MODE (*tmp->loc)))
|
&& (HARD_REGNO_CALL_PART_CLOBBERED
|
&& (HARD_REGNO_CALL_PART_CLOBBERED
|
(new_reg, GET_MODE (*tmp->loc)))))
|
(new_reg, GET_MODE (*tmp->loc)))))
|
break;
|
break;
|
if (! tmp)
|
if (! tmp)
|
{
|
{
|
if (tick[best_new_reg] > tick[new_reg])
|
if (tick[best_new_reg] > tick[new_reg])
|
best_new_reg = new_reg;
|
best_new_reg = new_reg;
|
}
|
}
|
}
|
}
|
|
|
if (dump_file)
|
if (dump_file)
|
{
|
{
|
fprintf (dump_file, "Register %s in insn %d",
|
fprintf (dump_file, "Register %s in insn %d",
|
reg_names[reg], INSN_UID (last->insn));
|
reg_names[reg], INSN_UID (last->insn));
|
if (last->need_caller_save_reg)
|
if (last->need_caller_save_reg)
|
fprintf (dump_file, " crosses a call");
|
fprintf (dump_file, " crosses a call");
|
}
|
}
|
|
|
if (best_new_reg == reg)
|
if (best_new_reg == reg)
|
{
|
{
|
tick[reg] = ++this_tick;
|
tick[reg] = ++this_tick;
|
if (dump_file)
|
if (dump_file)
|
fprintf (dump_file, "; no available better choice\n");
|
fprintf (dump_file, "; no available better choice\n");
|
continue;
|
continue;
|
}
|
}
|
|
|
do_replace (this, best_new_reg);
|
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;
|
regs_ever_live[best_new_reg] = 1;
|
|
|
if (dump_file)
|
if (dump_file)
|
fprintf (dump_file, ", renamed as %s\n", reg_names[best_new_reg]);
|
fprintf (dump_file, ", renamed as %s\n", reg_names[best_new_reg]);
|
}
|
}
|
|
|
obstack_free (&rename_obstack, first_obj);
|
obstack_free (&rename_obstack, first_obj);
|
}
|
}
|
|
|
obstack_free (&rename_obstack, NULL);
|
obstack_free (&rename_obstack, NULL);
|
|
|
if (dump_file)
|
if (dump_file)
|
fputc ('\n', dump_file);
|
fputc ('\n', dump_file);
|
|
|
count_or_remove_death_notes (NULL, 1);
|
count_or_remove_death_notes (NULL, 1);
|
update_life_info (NULL, UPDATE_LIFE_LOCAL,
|
update_life_info (NULL, UPDATE_LIFE_LOCAL,
|
PROP_DEATH_NOTES);
|
PROP_DEATH_NOTES);
|
}
|
}
|
|
|
static void
|
static void
|
do_replace (struct du_chain *chain, int reg)
|
do_replace (struct du_chain *chain, int reg)
|
{
|
{
|
while (chain)
|
while (chain)
|
{
|
{
|
unsigned int regno = ORIGINAL_REGNO (*chain->loc);
|
unsigned int regno = ORIGINAL_REGNO (*chain->loc);
|
struct reg_attrs * attr = REG_ATTRS (*chain->loc);
|
struct reg_attrs * attr = REG_ATTRS (*chain->loc);
|
|
|
*chain->loc = gen_raw_REG (GET_MODE (*chain->loc), reg);
|
*chain->loc = gen_raw_REG (GET_MODE (*chain->loc), reg);
|
if (regno >= FIRST_PSEUDO_REGISTER)
|
if (regno >= FIRST_PSEUDO_REGISTER)
|
ORIGINAL_REGNO (*chain->loc) = regno;
|
ORIGINAL_REGNO (*chain->loc) = regno;
|
REG_ATTRS (*chain->loc) = attr;
|
REG_ATTRS (*chain->loc) = attr;
|
chain = chain->next_use;
|
chain = chain->next_use;
|
}
|
}
|
}
|
}
|
|
|
|
|
static struct du_chain *open_chains;
|
static struct du_chain *open_chains;
|
static struct du_chain *closed_chains;
|
static struct du_chain *closed_chains;
|
|
|
static void
|
static void
|
scan_rtx_reg (rtx insn, rtx *loc, enum reg_class cl,
|
scan_rtx_reg (rtx insn, rtx *loc, enum reg_class cl,
|
enum scan_actions action, enum op_type type, int earlyclobber)
|
enum scan_actions action, enum op_type type, int earlyclobber)
|
{
|
{
|
struct du_chain **p;
|
struct du_chain **p;
|
rtx x = *loc;
|
rtx x = *loc;
|
enum machine_mode mode = GET_MODE (x);
|
enum machine_mode mode = GET_MODE (x);
|
int this_regno = REGNO (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 (action == mark_write)
|
{
|
{
|
if (type == OP_OUT)
|
if (type == OP_OUT)
|
{
|
{
|
struct du_chain *this
|
struct du_chain *this
|
= obstack_alloc (&rename_obstack, sizeof (struct du_chain));
|
= obstack_alloc (&rename_obstack, sizeof (struct du_chain));
|
this->next_use = 0;
|
this->next_use = 0;
|
this->next_chain = open_chains;
|
this->next_chain = open_chains;
|
this->loc = loc;
|
this->loc = loc;
|
this->insn = insn;
|
this->insn = insn;
|
this->cl = cl;
|
this->cl = cl;
|
this->need_caller_save_reg = 0;
|
this->need_caller_save_reg = 0;
|
this->earlyclobber = earlyclobber;
|
this->earlyclobber = earlyclobber;
|
open_chains = this;
|
open_chains = this;
|
}
|
}
|
return;
|
return;
|
}
|
}
|
|
|
if ((type == OP_OUT) != (action == terminate_write || action == mark_access))
|
if ((type == OP_OUT) != (action == terminate_write || action == mark_access))
|
return;
|
return;
|
|
|
for (p = &open_chains; *p;)
|
for (p = &open_chains; *p;)
|
{
|
{
|
struct du_chain *this = *p;
|
struct du_chain *this = *p;
|
|
|
/* Check if the chain has been terminated if it has then skip to
|
/* Check if the chain has been terminated if it has then skip to
|
the next chain.
|
the next chain.
|
|
|
This can happen when we've already appended the location to
|
This can happen when we've already appended the location to
|
the chain in Step 3, but are trying to hide in-out operands
|
the chain in Step 3, but are trying to hide in-out operands
|
from terminate_write in Step 5. */
|
from terminate_write in Step 5. */
|
|
|
if (*this->loc == cc0_rtx)
|
if (*this->loc == cc0_rtx)
|
p = &this->next_chain;
|
p = &this->next_chain;
|
else
|
else
|
{
|
{
|
int regno = REGNO (*this->loc);
|
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);
|
int exact_match = (regno == this_regno && nregs == this_nregs);
|
|
|
if (regno + nregs <= this_regno
|
if (regno + nregs <= this_regno
|
|| this_regno + this_nregs <= regno)
|
|| this_regno + this_nregs <= regno)
|
{
|
{
|
p = &this->next_chain;
|
p = &this->next_chain;
|
continue;
|
continue;
|
}
|
}
|
|
|
if (action == mark_read || action == mark_access)
|
if (action == mark_read || action == mark_access)
|
{
|
{
|
gcc_assert (exact_match);
|
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
|
EXTRA_CONSTRAINTS to match registers. Which is arguably
|
wrong, but there we are. Since we know not what this may
|
wrong, but there we are. Since we know not what this may
|
be replaced with, terminate the chain. */
|
be replaced with, terminate the chain. */
|
if (cl != NO_REGS)
|
if (cl != NO_REGS)
|
{
|
{
|
this = obstack_alloc (&rename_obstack, sizeof (struct du_chain));
|
this = obstack_alloc (&rename_obstack, sizeof (struct du_chain));
|
this->next_use = 0;
|
this->next_use = 0;
|
this->next_chain = (*p)->next_chain;
|
this->next_chain = (*p)->next_chain;
|
this->loc = loc;
|
this->loc = loc;
|
this->insn = insn;
|
this->insn = insn;
|
this->cl = cl;
|
this->cl = cl;
|
this->need_caller_save_reg = 0;
|
this->need_caller_save_reg = 0;
|
while (*p)
|
while (*p)
|
p = &(*p)->next_use;
|
p = &(*p)->next_use;
|
*p = this;
|
*p = this;
|
return;
|
return;
|
}
|
}
|
}
|
}
|
|
|
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->next_chain;
|
|
|
/* Whether the terminated chain can be used for renaming
|
/* Whether the terminated chain can be used for renaming
|
depends on the action and this being an exact match.
|
depends on the action and this being an exact match.
|
In either case, we remove this element from open_chains. */
|
In either case, we remove this element from open_chains. */
|
|
|
if ((action == terminate_dead || action == terminate_write)
|
if ((action == terminate_dead || action == terminate_write)
|
&& exact_match)
|
&& exact_match)
|
{
|
{
|
this->next_chain = closed_chains;
|
this->next_chain = closed_chains;
|
closed_chains = this;
|
closed_chains = this;
|
if (dump_file)
|
if (dump_file)
|
fprintf (dump_file,
|
fprintf (dump_file,
|
"Closing chain %s at insn %d (%s)\n",
|
"Closing chain %s at insn %d (%s)\n",
|
reg_names[REGNO (*this->loc)], INSN_UID (insn),
|
reg_names[REGNO (*this->loc)], INSN_UID (insn),
|
scan_actions_name[(int) action]);
|
scan_actions_name[(int) action]);
|
}
|
}
|
else
|
else
|
{
|
{
|
if (dump_file)
|
if (dump_file)
|
fprintf (dump_file,
|
fprintf (dump_file,
|
"Discarding chain %s at insn %d (%s)\n",
|
"Discarding chain %s at insn %d (%s)\n",
|
reg_names[REGNO (*this->loc)], INSN_UID (insn),
|
reg_names[REGNO (*this->loc)], INSN_UID (insn),
|
scan_actions_name[(int) action]);
|
scan_actions_name[(int) action]);
|
}
|
}
|
*p = next;
|
*p = next;
|
}
|
}
|
else
|
else
|
p = &this->next_chain;
|
p = &this->next_chain;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Adapted from find_reloads_address_1. CL 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. */
|
BASE_REG_CLASS depending on how the register is being considered. */
|
|
|
static void
|
static void
|
scan_rtx_address (rtx insn, rtx *loc, enum reg_class cl,
|
scan_rtx_address (rtx insn, rtx *loc, enum reg_class cl,
|
enum scan_actions action, enum machine_mode mode)
|
enum scan_actions action, enum machine_mode mode)
|
{
|
{
|
rtx x = *loc;
|
rtx x = *loc;
|
RTX_CODE code = GET_CODE (x);
|
RTX_CODE code = GET_CODE (x);
|
const char *fmt;
|
const char *fmt;
|
int i, j;
|
int i, j;
|
|
|
if (action == mark_write || action == mark_access)
|
if (action == mark_write || action == mark_access)
|
return;
|
return;
|
|
|
switch (code)
|
switch (code)
|
{
|
{
|
case PLUS:
|
case PLUS:
|
{
|
{
|
rtx orig_op0 = XEXP (x, 0);
|
rtx orig_op0 = XEXP (x, 0);
|
rtx orig_op1 = XEXP (x, 1);
|
rtx orig_op1 = XEXP (x, 1);
|
RTX_CODE code0 = GET_CODE (orig_op0);
|
RTX_CODE code0 = GET_CODE (orig_op0);
|
RTX_CODE code1 = GET_CODE (orig_op1);
|
RTX_CODE code1 = GET_CODE (orig_op1);
|
rtx op0 = orig_op0;
|
rtx op0 = orig_op0;
|
rtx op1 = orig_op1;
|
rtx op1 = orig_op1;
|
rtx *locI = NULL;
|
rtx *locI = NULL;
|
rtx *locB = NULL;
|
rtx *locB = NULL;
|
enum rtx_code index_code = SCRATCH;
|
enum rtx_code index_code = SCRATCH;
|
|
|
if (GET_CODE (op0) == SUBREG)
|
if (GET_CODE (op0) == SUBREG)
|
{
|
{
|
op0 = SUBREG_REG (op0);
|
op0 = SUBREG_REG (op0);
|
code0 = GET_CODE (op0);
|
code0 = GET_CODE (op0);
|
}
|
}
|
|
|
if (GET_CODE (op1) == SUBREG)
|
if (GET_CODE (op1) == SUBREG)
|
{
|
{
|
op1 = SUBREG_REG (op1);
|
op1 = SUBREG_REG (op1);
|
code1 = GET_CODE (op1);
|
code1 = GET_CODE (op1);
|
}
|
}
|
|
|
if (code0 == MULT || code0 == SIGN_EXTEND || code0 == TRUNCATE
|
if (code0 == MULT || code0 == SIGN_EXTEND || code0 == TRUNCATE
|
|| code0 == ZERO_EXTEND || code1 == MEM)
|
|| code0 == ZERO_EXTEND || code1 == MEM)
|
{
|
{
|
locI = &XEXP (x, 0);
|
locI = &XEXP (x, 0);
|
locB = &XEXP (x, 1);
|
locB = &XEXP (x, 1);
|
index_code = GET_CODE (*locI);
|
index_code = GET_CODE (*locI);
|
}
|
}
|
else if (code1 == MULT || code1 == SIGN_EXTEND || code1 == TRUNCATE
|
else if (code1 == MULT || code1 == SIGN_EXTEND || code1 == TRUNCATE
|
|| code1 == ZERO_EXTEND || code0 == MEM)
|
|| code1 == ZERO_EXTEND || code0 == MEM)
|
{
|
{
|
locI = &XEXP (x, 1);
|
locI = &XEXP (x, 1);
|
locB = &XEXP (x, 0);
|
locB = &XEXP (x, 0);
|
index_code = GET_CODE (*locI);
|
index_code = GET_CODE (*locI);
|
}
|
}
|
else if (code0 == CONST_INT || code0 == CONST
|
else if (code0 == CONST_INT || code0 == CONST
|
|| code0 == SYMBOL_REF || code0 == LABEL_REF)
|
|| code0 == SYMBOL_REF || code0 == LABEL_REF)
|
{
|
{
|
locB = &XEXP (x, 1);
|
locB = &XEXP (x, 1);
|
index_code = GET_CODE (XEXP (x, 0));
|
index_code = GET_CODE (XEXP (x, 0));
|
}
|
}
|
else if (code1 == CONST_INT || code1 == CONST
|
else if (code1 == CONST_INT || code1 == CONST
|
|| code1 == SYMBOL_REF || code1 == LABEL_REF)
|
|| code1 == SYMBOL_REF || code1 == LABEL_REF)
|
{
|
{
|
locB = &XEXP (x, 0);
|
locB = &XEXP (x, 0);
|
index_code = GET_CODE (XEXP (x, 1));
|
index_code = GET_CODE (XEXP (x, 1));
|
}
|
}
|
else if (code0 == REG && code1 == REG)
|
else if (code0 == REG && code1 == REG)
|
{
|
{
|
int index_op;
|
int index_op;
|
unsigned regno0 = REGNO (op0), regno1 = REGNO (op1);
|
unsigned regno0 = REGNO (op0), regno1 = REGNO (op1);
|
|
|
if (REGNO_OK_FOR_INDEX_P (regno0)
|
if (REGNO_OK_FOR_INDEX_P (regno0)
|
&& regno_ok_for_base_p (regno1, mode, PLUS, REG))
|
&& regno_ok_for_base_p (regno1, mode, PLUS, REG))
|
index_op = 0;
|
index_op = 0;
|
else if (REGNO_OK_FOR_INDEX_P (regno1)
|
else if (REGNO_OK_FOR_INDEX_P (regno1)
|
&& regno_ok_for_base_p (regno0, mode, PLUS, REG))
|
&& regno_ok_for_base_p (regno0, mode, PLUS, REG))
|
index_op = 1;
|
index_op = 1;
|
else if (regno_ok_for_base_p (regno1, mode, PLUS, REG))
|
else if (regno_ok_for_base_p (regno1, mode, PLUS, REG))
|
index_op = 0;
|
index_op = 0;
|
else if (regno_ok_for_base_p (regno0, mode, PLUS, REG))
|
else if (regno_ok_for_base_p (regno0, mode, PLUS, REG))
|
index_op = 1;
|
index_op = 1;
|
else if (REGNO_OK_FOR_INDEX_P (regno1))
|
else if (REGNO_OK_FOR_INDEX_P (regno1))
|
index_op = 1;
|
index_op = 1;
|
else
|
else
|
index_op = 0;
|
index_op = 0;
|
|
|
locI = &XEXP (x, index_op);
|
locI = &XEXP (x, index_op);
|
locB = &XEXP (x, !index_op);
|
locB = &XEXP (x, !index_op);
|
index_code = GET_CODE (*locI);
|
index_code = GET_CODE (*locI);
|
}
|
}
|
else if (code0 == REG)
|
else if (code0 == REG)
|
{
|
{
|
locI = &XEXP (x, 0);
|
locI = &XEXP (x, 0);
|
locB = &XEXP (x, 1);
|
locB = &XEXP (x, 1);
|
index_code = GET_CODE (*locI);
|
index_code = GET_CODE (*locI);
|
}
|
}
|
else if (code1 == REG)
|
else if (code1 == REG)
|
{
|
{
|
locI = &XEXP (x, 1);
|
locI = &XEXP (x, 1);
|
locB = &XEXP (x, 0);
|
locB = &XEXP (x, 0);
|
index_code = GET_CODE (*locI);
|
index_code = GET_CODE (*locI);
|
}
|
}
|
|
|
if (locI)
|
if (locI)
|
scan_rtx_address (insn, locI, INDEX_REG_CLASS, action, mode);
|
scan_rtx_address (insn, locI, INDEX_REG_CLASS, action, mode);
|
if (locB)
|
if (locB)
|
scan_rtx_address (insn, locB, base_reg_class (mode, PLUS, index_code),
|
scan_rtx_address (insn, locB, base_reg_class (mode, PLUS, index_code),
|
action, mode);
|
action, mode);
|
|
|
return;
|
return;
|
}
|
}
|
|
|
case POST_INC:
|
case POST_INC:
|
case POST_DEC:
|
case POST_DEC:
|
case POST_MODIFY:
|
case POST_MODIFY:
|
case PRE_INC:
|
case PRE_INC:
|
case PRE_DEC:
|
case PRE_DEC:
|
case PRE_MODIFY:
|
case PRE_MODIFY:
|
#ifndef AUTO_INC_DEC
|
#ifndef AUTO_INC_DEC
|
/* If the target doesn't claim to handle autoinc, this must be
|
/* If the target doesn't claim to handle autoinc, this must be
|
something special, like a stack push. Kill this chain. */
|
something special, like a stack push. Kill this chain. */
|
action = terminate_all_read;
|
action = terminate_all_read;
|
#endif
|
#endif
|
break;
|
break;
|
|
|
case MEM:
|
case MEM:
|
scan_rtx_address (insn, &XEXP (x, 0),
|
scan_rtx_address (insn, &XEXP (x, 0),
|
base_reg_class (GET_MODE (x), MEM, SCRATCH), action,
|
base_reg_class (GET_MODE (x), MEM, SCRATCH), action,
|
GET_MODE (x));
|
GET_MODE (x));
|
return;
|
return;
|
|
|
case REG:
|
case REG:
|
scan_rtx_reg (insn, loc, cl, action, OP_IN, 0);
|
scan_rtx_reg (insn, loc, cl, action, OP_IN, 0);
|
return;
|
return;
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
fmt = GET_RTX_FORMAT (code);
|
fmt = GET_RTX_FORMAT (code);
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
{
|
{
|
if (fmt[i] == 'e')
|
if (fmt[i] == 'e')
|
scan_rtx_address (insn, &XEXP (x, i), cl, action, mode);
|
scan_rtx_address (insn, &XEXP (x, i), cl, action, mode);
|
else if (fmt[i] == 'E')
|
else if (fmt[i] == 'E')
|
for (j = XVECLEN (x, i) - 1; j >= 0; j--)
|
for (j = XVECLEN (x, i) - 1; j >= 0; j--)
|
scan_rtx_address (insn, &XVECEXP (x, i, j), cl, action, mode);
|
scan_rtx_address (insn, &XVECEXP (x, i, j), cl, action, mode);
|
}
|
}
|
}
|
}
|
|
|
static void
|
static void
|
scan_rtx (rtx insn, rtx *loc, enum reg_class cl,
|
scan_rtx (rtx insn, rtx *loc, enum reg_class cl,
|
enum scan_actions action, enum op_type type, int earlyclobber)
|
enum scan_actions action, enum op_type type, int earlyclobber)
|
{
|
{
|
const char *fmt;
|
const char *fmt;
|
rtx x = *loc;
|
rtx x = *loc;
|
enum rtx_code code = GET_CODE (x);
|
enum rtx_code code = GET_CODE (x);
|
int i, j;
|
int i, j;
|
|
|
code = GET_CODE (x);
|
code = GET_CODE (x);
|
switch (code)
|
switch (code)
|
{
|
{
|
case CONST:
|
case CONST:
|
case CONST_INT:
|
case CONST_INT:
|
case CONST_DOUBLE:
|
case CONST_DOUBLE:
|
case CONST_VECTOR:
|
case CONST_VECTOR:
|
case SYMBOL_REF:
|
case SYMBOL_REF:
|
case LABEL_REF:
|
case LABEL_REF:
|
case CC0:
|
case CC0:
|
case PC:
|
case PC:
|
return;
|
return;
|
|
|
case REG:
|
case REG:
|
scan_rtx_reg (insn, loc, cl, action, type, earlyclobber);
|
scan_rtx_reg (insn, loc, cl, action, type, earlyclobber);
|
return;
|
return;
|
|
|
case MEM:
|
case MEM:
|
scan_rtx_address (insn, &XEXP (x, 0),
|
scan_rtx_address (insn, &XEXP (x, 0),
|
base_reg_class (GET_MODE (x), MEM, SCRATCH), action,
|
base_reg_class (GET_MODE (x), MEM, SCRATCH), action,
|
GET_MODE (x));
|
GET_MODE (x));
|
return;
|
return;
|
|
|
case SET:
|
case SET:
|
scan_rtx (insn, &SET_SRC (x), cl, action, OP_IN, 0);
|
scan_rtx (insn, &SET_SRC (x), cl, action, OP_IN, 0);
|
scan_rtx (insn, &SET_DEST (x), cl, action,
|
scan_rtx (insn, &SET_DEST (x), cl, action,
|
GET_CODE (PATTERN (insn)) == COND_EXEC ? OP_INOUT : OP_OUT, 0);
|
GET_CODE (PATTERN (insn)) == COND_EXEC ? OP_INOUT : OP_OUT, 0);
|
return;
|
return;
|
|
|
case STRICT_LOW_PART:
|
case STRICT_LOW_PART:
|
scan_rtx (insn, &XEXP (x, 0), cl, action, OP_INOUT, earlyclobber);
|
scan_rtx (insn, &XEXP (x, 0), cl, action, OP_INOUT, earlyclobber);
|
return;
|
return;
|
|
|
case ZERO_EXTRACT:
|
case ZERO_EXTRACT:
|
case SIGN_EXTRACT:
|
case SIGN_EXTRACT:
|
scan_rtx (insn, &XEXP (x, 0), cl, action,
|
scan_rtx (insn, &XEXP (x, 0), cl, action,
|
type == OP_IN ? OP_IN : OP_INOUT, earlyclobber);
|
type == OP_IN ? OP_IN : OP_INOUT, earlyclobber);
|
scan_rtx (insn, &XEXP (x, 1), cl, 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);
|
scan_rtx (insn, &XEXP (x, 2), cl, action, OP_IN, 0);
|
return;
|
return;
|
|
|
case POST_INC:
|
case POST_INC:
|
case PRE_INC:
|
case PRE_INC:
|
case POST_DEC:
|
case POST_DEC:
|
case PRE_DEC:
|
case PRE_DEC:
|
case POST_MODIFY:
|
case POST_MODIFY:
|
case PRE_MODIFY:
|
case PRE_MODIFY:
|
/* Should only happen inside MEM. */
|
/* Should only happen inside MEM. */
|
gcc_unreachable ();
|
gcc_unreachable ();
|
|
|
case CLOBBER:
|
case CLOBBER:
|
scan_rtx (insn, &SET_DEST (x), cl, action,
|
scan_rtx (insn, &SET_DEST (x), cl, action,
|
GET_CODE (PATTERN (insn)) == COND_EXEC ? OP_INOUT : OP_OUT, 0);
|
GET_CODE (PATTERN (insn)) == COND_EXEC ? OP_INOUT : OP_OUT, 0);
|
return;
|
return;
|
|
|
case EXPR_LIST:
|
case EXPR_LIST:
|
scan_rtx (insn, &XEXP (x, 0), cl, action, type, 0);
|
scan_rtx (insn, &XEXP (x, 0), cl, action, type, 0);
|
if (XEXP (x, 1))
|
if (XEXP (x, 1))
|
scan_rtx (insn, &XEXP (x, 1), cl, action, type, 0);
|
scan_rtx (insn, &XEXP (x, 1), cl, action, type, 0);
|
return;
|
return;
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
fmt = GET_RTX_FORMAT (code);
|
fmt = GET_RTX_FORMAT (code);
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
{
|
{
|
if (fmt[i] == 'e')
|
if (fmt[i] == 'e')
|
scan_rtx (insn, &XEXP (x, i), cl, action, type, 0);
|
scan_rtx (insn, &XEXP (x, i), cl, action, type, 0);
|
else if (fmt[i] == 'E')
|
else if (fmt[i] == 'E')
|
for (j = XVECLEN (x, i) - 1; j >= 0; j--)
|
for (j = XVECLEN (x, i) - 1; j >= 0; j--)
|
scan_rtx (insn, &XVECEXP (x, i, j), cl, 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 *
|
static struct du_chain *
|
build_def_use (basic_block bb)
|
build_def_use (basic_block bb)
|
{
|
{
|
rtx insn;
|
rtx insn;
|
|
|
open_chains = closed_chains = NULL;
|
open_chains = closed_chains = NULL;
|
|
|
for (insn = BB_HEAD (bb); ; insn = NEXT_INSN (insn))
|
for (insn = BB_HEAD (bb); ; insn = NEXT_INSN (insn))
|
{
|
{
|
if (INSN_P (insn))
|
if (INSN_P (insn))
|
{
|
{
|
int n_ops;
|
int n_ops;
|
rtx note;
|
rtx note;
|
rtx old_operands[MAX_RECOG_OPERANDS];
|
rtx old_operands[MAX_RECOG_OPERANDS];
|
rtx old_dups[MAX_DUP_OPERANDS];
|
rtx old_dups[MAX_DUP_OPERANDS];
|
int i, icode;
|
int i, icode;
|
int alt;
|
int alt;
|
int predicated;
|
int predicated;
|
|
|
/* Process the insn, determining its effect on the def-use
|
/* Process the insn, determining its effect on the def-use
|
chains. We perform the following steps with the register
|
chains. We perform the following steps with the register
|
references in the insn:
|
references in the insn:
|
(1) Any read that overlaps an open chain, but doesn't exactly
|
(1) Any read that overlaps an open chain, but doesn't exactly
|
match, causes that chain to be closed. We can't deal
|
match, causes that chain to be closed. We can't deal
|
with overlaps yet.
|
with overlaps yet.
|
(2) Any read outside an operand causes any chain it overlaps
|
(2) Any read outside an operand causes any chain it overlaps
|
with to be closed, since we can't replace it.
|
with to be closed, since we can't replace it.
|
(3) Any read inside an operand is added if there's already
|
(3) Any read inside an operand is added if there's already
|
an open chain for it.
|
an open chain for it.
|
(4) For any REG_DEAD note we find, close open chains that
|
(4) For any REG_DEAD note we find, close open chains that
|
overlap it.
|
overlap it.
|
(5) For any write we find, close open chains that overlap it.
|
(5) For any write we find, close open chains that overlap it.
|
(6) For any write we find in an operand, make a new chain.
|
(6) For any write we find in an operand, make a new chain.
|
(7) For any REG_UNUSED, close any chains we just opened. */
|
(7) For any REG_UNUSED, close any chains we just opened. */
|
|
|
icode = recog_memoized (insn);
|
icode = recog_memoized (insn);
|
extract_insn (insn);
|
extract_insn (insn);
|
if (! constrain_operands (1))
|
if (! constrain_operands (1))
|
fatal_insn_not_found (insn);
|
fatal_insn_not_found (insn);
|
preprocess_constraints ();
|
preprocess_constraints ();
|
alt = which_alternative;
|
alt = which_alternative;
|
n_ops = recog_data.n_operands;
|
n_ops = recog_data.n_operands;
|
|
|
/* Simplify the code below by rewriting things to reflect
|
/* Simplify the code below by rewriting things to reflect
|
matching constraints. Also promote OP_OUT to OP_INOUT
|
matching constraints. Also promote OP_OUT to OP_INOUT
|
in predicated instructions. */
|
in predicated instructions. */
|
|
|
predicated = GET_CODE (PATTERN (insn)) == COND_EXEC;
|
predicated = GET_CODE (PATTERN (insn)) == COND_EXEC;
|
for (i = 0; i < n_ops; ++i)
|
for (i = 0; i < n_ops; ++i)
|
{
|
{
|
int matches = recog_op_alt[i][alt].matches;
|
int matches = recog_op_alt[i][alt].matches;
|
if (matches >= 0)
|
if (matches >= 0)
|
recog_op_alt[i][alt].cl = recog_op_alt[matches][alt].cl;
|
recog_op_alt[i][alt].cl = recog_op_alt[matches][alt].cl;
|
if (matches >= 0 || recog_op_alt[i][alt].matched >= 0
|
if (matches >= 0 || recog_op_alt[i][alt].matched >= 0
|
|| (predicated && recog_data.operand_type[i] == OP_OUT))
|
|| (predicated && recog_data.operand_type[i] == OP_OUT))
|
recog_data.operand_type[i] = OP_INOUT;
|
recog_data.operand_type[i] = OP_INOUT;
|
}
|
}
|
|
|
/* Step 1: Close chains for which we have overlapping reads. */
|
/* Step 1: Close chains for which we have overlapping reads. */
|
for (i = 0; i < n_ops; i++)
|
for (i = 0; i < n_ops; i++)
|
scan_rtx (insn, recog_data.operand_loc[i],
|
scan_rtx (insn, recog_data.operand_loc[i],
|
NO_REGS, terminate_overlapping_read,
|
NO_REGS, terminate_overlapping_read,
|
recog_data.operand_type[i], 0);
|
recog_data.operand_type[i], 0);
|
|
|
/* Step 2: Close chains for which we have reads outside operands.
|
/* 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. */
|
everything remaining. */
|
|
|
for (i = 0; i < n_ops; i++)
|
for (i = 0; i < n_ops; i++)
|
{
|
{
|
old_operands[i] = recog_data.operand[i];
|
old_operands[i] = recog_data.operand[i];
|
/* Don't squash match_operator or match_parallel here, since
|
/* 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. */
|
reachable by proper operands. */
|
if (recog_data.constraints[i][0] == '\0')
|
if (recog_data.constraints[i][0] == '\0')
|
continue;
|
continue;
|
*recog_data.operand_loc[i] = cc0_rtx;
|
*recog_data.operand_loc[i] = cc0_rtx;
|
}
|
}
|
for (i = 0; i < recog_data.n_dups; i++)
|
for (i = 0; i < recog_data.n_dups; i++)
|
{
|
{
|
int dup_num = recog_data.dup_num[i];
|
int dup_num = recog_data.dup_num[i];
|
|
|
old_dups[i] = *recog_data.dup_loc[i];
|
old_dups[i] = *recog_data.dup_loc[i];
|
*recog_data.dup_loc[i] = cc0_rtx;
|
*recog_data.dup_loc[i] = cc0_rtx;
|
|
|
/* For match_dup of match_operator or match_parallel, share
|
/* For match_dup of match_operator or match_parallel, share
|
them, so that we don't miss changes in the dup. */
|
them, so that we don't miss changes in the dup. */
|
if (icode >= 0
|
if (icode >= 0
|
&& insn_data[icode].operand[dup_num].eliminable == 0)
|
&& insn_data[icode].operand[dup_num].eliminable == 0)
|
old_dups[i] = recog_data.operand[dup_num];
|
old_dups[i] = recog_data.operand[dup_num];
|
}
|
}
|
|
|
scan_rtx (insn, &PATTERN (insn), NO_REGS, terminate_all_read,
|
scan_rtx (insn, &PATTERN (insn), NO_REGS, terminate_all_read,
|
OP_IN, 0);
|
OP_IN, 0);
|
|
|
for (i = 0; i < recog_data.n_dups; i++)
|
for (i = 0; i < recog_data.n_dups; i++)
|
*recog_data.dup_loc[i] = old_dups[i];
|
*recog_data.dup_loc[i] = old_dups[i];
|
for (i = 0; i < n_ops; i++)
|
for (i = 0; i < n_ops; i++)
|
*recog_data.operand_loc[i] = old_operands[i];
|
*recog_data.operand_loc[i] = old_operands[i];
|
|
|
/* Step 2B: Can't rename function call argument registers. */
|
/* Step 2B: Can't rename function call argument registers. */
|
if (CALL_P (insn) && CALL_INSN_FUNCTION_USAGE (insn))
|
if (CALL_P (insn) && CALL_INSN_FUNCTION_USAGE (insn))
|
scan_rtx (insn, &CALL_INSN_FUNCTION_USAGE (insn),
|
scan_rtx (insn, &CALL_INSN_FUNCTION_USAGE (insn),
|
NO_REGS, terminate_all_read, OP_IN, 0);
|
NO_REGS, terminate_all_read, OP_IN, 0);
|
|
|
/* Step 2C: Can't rename asm operands that were originally
|
/* Step 2C: Can't rename asm operands that were originally
|
hard registers. */
|
hard registers. */
|
if (asm_noperands (PATTERN (insn)) > 0)
|
if (asm_noperands (PATTERN (insn)) > 0)
|
for (i = 0; i < n_ops; i++)
|
for (i = 0; i < n_ops; i++)
|
{
|
{
|
rtx *loc = recog_data.operand_loc[i];
|
rtx *loc = recog_data.operand_loc[i];
|
rtx op = *loc;
|
rtx op = *loc;
|
|
|
if (REG_P (op)
|
if (REG_P (op)
|
&& REGNO (op) == ORIGINAL_REGNO (op)
|
&& REGNO (op) == ORIGINAL_REGNO (op)
|
&& (recog_data.operand_type[i] == OP_IN
|
&& (recog_data.operand_type[i] == OP_IN
|
|| recog_data.operand_type[i] == OP_INOUT))
|
|| recog_data.operand_type[i] == OP_INOUT))
|
scan_rtx (insn, loc, NO_REGS, terminate_all_read, OP_IN, 0);
|
scan_rtx (insn, loc, NO_REGS, terminate_all_read, OP_IN, 0);
|
}
|
}
|
|
|
/* Step 3: Append to chains for reads inside operands. */
|
/* Step 3: Append to chains for reads inside operands. */
|
for (i = 0; i < n_ops + recog_data.n_dups; i++)
|
for (i = 0; i < n_ops + recog_data.n_dups; i++)
|
{
|
{
|
int opn = i < n_ops ? i : recog_data.dup_num[i - n_ops];
|
int opn = i < n_ops ? i : recog_data.dup_num[i - n_ops];
|
rtx *loc = (i < n_ops
|
rtx *loc = (i < n_ops
|
? recog_data.operand_loc[opn]
|
? recog_data.operand_loc[opn]
|
: recog_data.dup_loc[i - n_ops]);
|
: recog_data.dup_loc[i - n_ops]);
|
enum reg_class cl = recog_op_alt[opn][alt].cl;
|
enum reg_class cl = recog_op_alt[opn][alt].cl;
|
enum op_type type = recog_data.operand_type[opn];
|
enum op_type type = recog_data.operand_type[opn];
|
|
|
/* Don't scan match_operand here, since we've no reg class
|
/* Don't scan match_operand here, since we've no reg class
|
information to pass down. Any operands that we could
|
information to pass down. Any operands that we could
|
substitute in will be represented elsewhere. */
|
substitute in will be represented elsewhere. */
|
if (recog_data.constraints[opn][0] == '\0')
|
if (recog_data.constraints[opn][0] == '\0')
|
continue;
|
continue;
|
|
|
if (recog_op_alt[opn][alt].is_address)
|
if (recog_op_alt[opn][alt].is_address)
|
scan_rtx_address (insn, loc, cl, mark_read, VOIDmode);
|
scan_rtx_address (insn, loc, cl, mark_read, VOIDmode);
|
else
|
else
|
scan_rtx (insn, loc, cl, mark_read, type, 0);
|
scan_rtx (insn, loc, cl, mark_read, type, 0);
|
}
|
}
|
|
|
/* Step 3B: Record updates for regs in REG_INC notes, and
|
/* Step 3B: Record updates for regs in REG_INC notes, and
|
source regs in REG_FRAME_RELATED_EXPR notes. */
|
source regs in REG_FRAME_RELATED_EXPR notes. */
|
for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
|
for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
|
if (REG_NOTE_KIND (note) == REG_INC
|
if (REG_NOTE_KIND (note) == REG_INC
|
|| REG_NOTE_KIND (note) == REG_FRAME_RELATED_EXPR)
|
|| REG_NOTE_KIND (note) == REG_FRAME_RELATED_EXPR)
|
scan_rtx (insn, &XEXP (note, 0), ALL_REGS, mark_read,
|
scan_rtx (insn, &XEXP (note, 0), ALL_REGS, mark_read,
|
OP_INOUT, 0);
|
OP_INOUT, 0);
|
|
|
/* Step 4: Close chains for registers that die here. */
|
/* Step 4: Close chains for registers that die here. */
|
for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
|
for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
|
if (REG_NOTE_KIND (note) == REG_DEAD)
|
if (REG_NOTE_KIND (note) == REG_DEAD)
|
scan_rtx (insn, &XEXP (note, 0), NO_REGS, terminate_dead,
|
scan_rtx (insn, &XEXP (note, 0), NO_REGS, terminate_dead,
|
OP_IN, 0);
|
OP_IN, 0);
|
|
|
/* Step 4B: If this is a call, any chain live at this point
|
/* Step 4B: If this is a call, any chain live at this point
|
requires a caller-saved reg. */
|
requires a caller-saved reg. */
|
if (CALL_P (insn))
|
if (CALL_P (insn))
|
{
|
{
|
struct du_chain *p;
|
struct du_chain *p;
|
for (p = open_chains; p; p = p->next_chain)
|
for (p = open_chains; p; p = p->next_chain)
|
p->need_caller_save_reg = 1;
|
p->need_caller_save_reg = 1;
|
}
|
}
|
|
|
/* Step 5: Close open chains that overlap writes. Similar to
|
/* Step 5: Close open chains that overlap writes. Similar to
|
step 2, we hide in-out operands, since we do not want to
|
step 2, we hide in-out operands, since we do not want to
|
close these chains. */
|
close these chains. */
|
|
|
for (i = 0; i < n_ops; i++)
|
for (i = 0; i < n_ops; i++)
|
{
|
{
|
old_operands[i] = recog_data.operand[i];
|
old_operands[i] = recog_data.operand[i];
|
if (recog_data.operand_type[i] == OP_INOUT)
|
if (recog_data.operand_type[i] == OP_INOUT)
|
*recog_data.operand_loc[i] = cc0_rtx;
|
*recog_data.operand_loc[i] = cc0_rtx;
|
}
|
}
|
for (i = 0; i < recog_data.n_dups; i++)
|
for (i = 0; i < recog_data.n_dups; i++)
|
{
|
{
|
int opn = recog_data.dup_num[i];
|
int opn = recog_data.dup_num[i];
|
old_dups[i] = *recog_data.dup_loc[i];
|
old_dups[i] = *recog_data.dup_loc[i];
|
if (recog_data.operand_type[opn] == OP_INOUT)
|
if (recog_data.operand_type[opn] == OP_INOUT)
|
*recog_data.dup_loc[i] = cc0_rtx;
|
*recog_data.dup_loc[i] = cc0_rtx;
|
}
|
}
|
|
|
scan_rtx (insn, &PATTERN (insn), NO_REGS, terminate_write, OP_IN, 0);
|
scan_rtx (insn, &PATTERN (insn), NO_REGS, terminate_write, OP_IN, 0);
|
|
|
for (i = 0; i < recog_data.n_dups; i++)
|
for (i = 0; i < recog_data.n_dups; i++)
|
*recog_data.dup_loc[i] = old_dups[i];
|
*recog_data.dup_loc[i] = old_dups[i];
|
for (i = 0; i < n_ops; i++)
|
for (i = 0; i < n_ops; i++)
|
*recog_data.operand_loc[i] = old_operands[i];
|
*recog_data.operand_loc[i] = old_operands[i];
|
|
|
/* Step 6: Begin new chains for writes inside operands. */
|
/* Step 6: Begin new chains for writes inside operands. */
|
/* ??? Many targets have output constraints on the SET_DEST
|
/* ??? Many targets have output constraints on the SET_DEST
|
of a call insn, which is stupid, since these are certainly
|
of a call insn, which is stupid, since these are certainly
|
ABI defined hard registers. Don't change calls at all.
|
ABI defined hard registers. Don't change calls at all.
|
Similarly take special care for asm statement that originally
|
Similarly take special care for asm statement that originally
|
referenced hard registers. */
|
referenced hard registers. */
|
if (asm_noperands (PATTERN (insn)) > 0)
|
if (asm_noperands (PATTERN (insn)) > 0)
|
{
|
{
|
for (i = 0; i < n_ops; i++)
|
for (i = 0; i < n_ops; i++)
|
if (recog_data.operand_type[i] == OP_OUT)
|
if (recog_data.operand_type[i] == OP_OUT)
|
{
|
{
|
rtx *loc = recog_data.operand_loc[i];
|
rtx *loc = recog_data.operand_loc[i];
|
rtx op = *loc;
|
rtx op = *loc;
|
enum reg_class cl = recog_op_alt[i][alt].cl;
|
enum reg_class cl = recog_op_alt[i][alt].cl;
|
|
|
if (REG_P (op)
|
if (REG_P (op)
|
&& REGNO (op) == ORIGINAL_REGNO (op))
|
&& REGNO (op) == ORIGINAL_REGNO (op))
|
continue;
|
continue;
|
|
|
scan_rtx (insn, loc, cl, mark_write, OP_OUT,
|
scan_rtx (insn, loc, cl, mark_write, OP_OUT,
|
recog_op_alt[i][alt].earlyclobber);
|
recog_op_alt[i][alt].earlyclobber);
|
}
|
}
|
}
|
}
|
else if (!CALL_P (insn))
|
else if (!CALL_P (insn))
|
for (i = 0; i < n_ops + recog_data.n_dups; i++)
|
for (i = 0; i < n_ops + recog_data.n_dups; i++)
|
{
|
{
|
int opn = i < n_ops ? i : recog_data.dup_num[i - n_ops];
|
int opn = i < n_ops ? i : recog_data.dup_num[i - n_ops];
|
rtx *loc = (i < n_ops
|
rtx *loc = (i < n_ops
|
? recog_data.operand_loc[opn]
|
? recog_data.operand_loc[opn]
|
: recog_data.dup_loc[i - n_ops]);
|
: recog_data.dup_loc[i - n_ops]);
|
enum reg_class cl = recog_op_alt[opn][alt].cl;
|
enum reg_class cl = recog_op_alt[opn][alt].cl;
|
|
|
if (recog_data.operand_type[opn] == OP_OUT)
|
if (recog_data.operand_type[opn] == OP_OUT)
|
scan_rtx (insn, loc, cl, mark_write, OP_OUT,
|
scan_rtx (insn, loc, cl, mark_write, OP_OUT,
|
recog_op_alt[opn][alt].earlyclobber);
|
recog_op_alt[opn][alt].earlyclobber);
|
}
|
}
|
|
|
/* Step 6B: Record destination regs in REG_FRAME_RELATED_EXPR
|
/* Step 6B: Record destination regs in REG_FRAME_RELATED_EXPR
|
notes for update. */
|
notes for update. */
|
for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
|
for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
|
if (REG_NOTE_KIND (note) == REG_FRAME_RELATED_EXPR)
|
if (REG_NOTE_KIND (note) == REG_FRAME_RELATED_EXPR)
|
scan_rtx (insn, &XEXP (note, 0), ALL_REGS, mark_access,
|
scan_rtx (insn, &XEXP (note, 0), ALL_REGS, mark_access,
|
OP_INOUT, 0);
|
OP_INOUT, 0);
|
|
|
/* Step 7: Close chains for registers that were never
|
/* Step 7: Close chains for registers that were never
|
really used here. */
|
really used here. */
|
for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
|
for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
|
if (REG_NOTE_KIND (note) == REG_UNUSED)
|
if (REG_NOTE_KIND (note) == REG_UNUSED)
|
scan_rtx (insn, &XEXP (note, 0), NO_REGS, terminate_dead,
|
scan_rtx (insn, &XEXP (note, 0), NO_REGS, terminate_dead,
|
OP_IN, 0);
|
OP_IN, 0);
|
}
|
}
|
if (insn == BB_END (bb))
|
if (insn == BB_END (bb))
|
break;
|
break;
|
}
|
}
|
|
|
/* Since we close every chain when we find a REG_DEAD note, anything that
|
/* Since we close every chain when we find a REG_DEAD note, anything that
|
is still open lives past the basic block, so it can't be renamed. */
|
is still open lives past the basic block, so it can't be renamed. */
|
return closed_chains;
|
return closed_chains;
|
}
|
}
|
|
|
/* Dump all def/use chains in CHAINS to 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. */
|
printed in reverse order as that's how we build them. */
|
|
|
static void
|
static void
|
dump_def_use_chain (struct du_chain *chains)
|
dump_def_use_chain (struct du_chain *chains)
|
{
|
{
|
while (chains)
|
while (chains)
|
{
|
{
|
struct du_chain *this = chains;
|
struct du_chain *this = chains;
|
int r = REGNO (*this->loc);
|
int r = REGNO (*this->loc);
|
int nregs = hard_regno_nregs[r][GET_MODE (*this->loc)];
|
int nregs = hard_regno_nregs[r][GET_MODE (*this->loc)];
|
fprintf (dump_file, "Register %s (%d):", reg_names[r], nregs);
|
fprintf (dump_file, "Register %s (%d):", reg_names[r], nregs);
|
while (this)
|
while (this)
|
{
|
{
|
fprintf (dump_file, " %d [%s]", INSN_UID (this->insn),
|
fprintf (dump_file, " %d [%s]", INSN_UID (this->insn),
|
reg_class_names[this->cl]);
|
reg_class_names[this->cl]);
|
this = this->next_use;
|
this = this->next_use;
|
}
|
}
|
fprintf (dump_file, "\n");
|
fprintf (dump_file, "\n");
|
chains = chains->next_chain;
|
chains = chains->next_chain;
|
}
|
}
|
}
|
}
|
|
|
/* The following code does forward propagation of hard register copies.
|
/* The following code does forward propagation of hard register copies.
|
The object is to eliminate as many dependencies as possible, so that
|
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
|
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. */
|
code may be obsoleted by a new register allocator. */
|
|
|
/* For each register, we have a list of registers that contain the same
|
/* 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
|
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
|
what mode the data is known to be in; this field is VOIDmode when the
|
register is not known to contain valid data. */
|
register is not known to contain valid data. */
|
|
|
struct value_data_entry
|
struct value_data_entry
|
{
|
{
|
enum machine_mode mode;
|
enum machine_mode mode;
|
unsigned int oldest_regno;
|
unsigned int oldest_regno;
|
unsigned int next_regno;
|
unsigned int next_regno;
|
};
|
};
|
|
|
struct value_data
|
struct value_data
|
{
|
{
|
struct value_data_entry e[FIRST_PSEUDO_REGISTER];
|
struct value_data_entry e[FIRST_PSEUDO_REGISTER];
|
unsigned int max_value_regs;
|
unsigned int max_value_regs;
|
};
|
};
|
|
|
static void kill_value_one_regno (unsigned, 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_regno (unsigned, unsigned, struct value_data *);
|
static void kill_value (rtx, 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 set_value_regno (unsigned, enum machine_mode, struct value_data *);
|
static void init_value_data (struct value_data *);
|
static void init_value_data (struct value_data *);
|
static void kill_clobbered_value (rtx, rtx, void *);
|
static void kill_clobbered_value (rtx, rtx, void *);
|
static void kill_set_value (rtx, rtx, void *);
|
static void kill_set_value (rtx, rtx, void *);
|
static int kill_autoinc_value (rtx *, void *);
|
static int kill_autoinc_value (rtx *, void *);
|
static void copy_value (rtx, rtx, struct value_data *);
|
static void copy_value (rtx, rtx, struct value_data *);
|
static bool mode_change_ok (enum machine_mode, enum machine_mode,
|
static bool mode_change_ok (enum machine_mode, enum machine_mode,
|
unsigned int);
|
unsigned int);
|
static rtx maybe_mode_change (enum machine_mode, enum machine_mode,
|
static rtx maybe_mode_change (enum machine_mode, enum machine_mode,
|
enum machine_mode, unsigned int, unsigned int);
|
enum machine_mode, unsigned int, unsigned int);
|
static rtx find_oldest_value_reg (enum reg_class, rtx, struct value_data *);
|
static rtx find_oldest_value_reg (enum reg_class, rtx, struct value_data *);
|
static bool replace_oldest_value_reg (rtx *, enum reg_class, rtx,
|
static bool replace_oldest_value_reg (rtx *, enum reg_class, rtx,
|
struct value_data *);
|
struct value_data *);
|
static bool replace_oldest_value_addr (rtx *, enum reg_class,
|
static bool replace_oldest_value_addr (rtx *, enum reg_class,
|
enum machine_mode, rtx,
|
enum machine_mode, rtx,
|
struct value_data *);
|
struct value_data *);
|
static bool replace_oldest_value_mem (rtx, 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 *);
|
static bool copyprop_hardreg_forward_1 (basic_block, struct value_data *);
|
extern void debug_value_data (struct value_data *);
|
extern void debug_value_data (struct value_data *);
|
#ifdef ENABLE_CHECKING
|
#ifdef ENABLE_CHECKING
|
static void validate_value_data (struct value_data *);
|
static void validate_value_data (struct value_data *);
|
#endif
|
#endif
|
|
|
/* Kill register REGNO. This involves removing it from any value
|
/* Kill register REGNO. This involves removing it from any value
|
lists, and resetting the value mode to VOIDmode. This is only a
|
lists, and resetting the value mode to VOIDmode. This is only a
|
helper function; it does not handle any hard registers overlapping
|
helper function; it does not handle any hard registers overlapping
|
with REGNO. */
|
with REGNO. */
|
|
|
static void
|
static void
|
kill_value_one_regno (unsigned int regno, struct value_data *vd)
|
kill_value_one_regno (unsigned int regno, struct value_data *vd)
|
{
|
{
|
unsigned int i, next;
|
unsigned int i, next;
|
|
|
if (vd->e[regno].oldest_regno != regno)
|
if (vd->e[regno].oldest_regno != regno)
|
{
|
{
|
for (i = vd->e[regno].oldest_regno;
|
for (i = vd->e[regno].oldest_regno;
|
vd->e[i].next_regno != regno;
|
vd->e[i].next_regno != regno;
|
i = vd->e[i].next_regno)
|
i = vd->e[i].next_regno)
|
continue;
|
continue;
|
vd->e[i].next_regno = vd->e[regno].next_regno;
|
vd->e[i].next_regno = vd->e[regno].next_regno;
|
}
|
}
|
else if ((next = vd->e[regno].next_regno) != INVALID_REGNUM)
|
else if ((next = vd->e[regno].next_regno) != INVALID_REGNUM)
|
{
|
{
|
for (i = next; i != INVALID_REGNUM; i = vd->e[i].next_regno)
|
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;
|
vd->e[regno].mode = VOIDmode;
|
vd->e[regno].oldest_regno = regno;
|
vd->e[regno].oldest_regno = regno;
|
vd->e[regno].next_regno = INVALID_REGNUM;
|
vd->e[regno].next_regno = INVALID_REGNUM;
|
|
|
#ifdef ENABLE_CHECKING
|
#ifdef ENABLE_CHECKING
|
validate_value_data (vd);
|
validate_value_data (vd);
|
#endif
|
#endif
|
}
|
}
|
|
|
/* Kill the value in register REGNO for NREGS, and any other registers
|
/* Kill the value in register REGNO for NREGS, and any other registers
|
whose values overlap. */
|
whose values overlap. */
|
|
|
static void
|
static void
|
kill_value_regno (unsigned int regno, unsigned int nregs,
|
kill_value_regno (unsigned int regno, unsigned int nregs,
|
struct value_data *vd)
|
struct value_data *vd)
|
{
|
{
|
unsigned int j;
|
unsigned int j;
|
|
|
/* Kill the value we're told to kill. */
|
/* Kill the value we're told to kill. */
|
for (j = 0; j < nregs; ++j)
|
for (j = 0; j < nregs; ++j)
|
kill_value_one_regno (regno + j, vd);
|
kill_value_one_regno (regno + j, vd);
|
|
|
/* Kill everything that overlapped what we're told to kill. */
|
/* Kill everything that overlapped what we're told to kill. */
|
if (regno < vd->max_value_regs)
|
if (regno < vd->max_value_regs)
|
j = 0;
|
j = 0;
|
else
|
else
|
j = regno - vd->max_value_regs;
|
j = regno - vd->max_value_regs;
|
for (; j < regno; ++j)
|
for (; j < regno; ++j)
|
{
|
{
|
unsigned int i, n;
|
unsigned int i, n;
|
if (vd->e[j].mode == VOIDmode)
|
if (vd->e[j].mode == VOIDmode)
|
continue;
|
continue;
|
n = hard_regno_nregs[j][vd->e[j].mode];
|
n = hard_regno_nregs[j][vd->e[j].mode];
|
if (j + n > regno)
|
if (j + n > regno)
|
for (i = 0; i < n; ++i)
|
for (i = 0; i < n; ++i)
|
kill_value_one_regno (j + i, vd);
|
kill_value_one_regno (j + i, vd);
|
}
|
}
|
}
|
}
|
|
|
/* Kill X. This is a convenience function wrapping kill_value_regno
|
/* Kill X. This is a convenience function wrapping kill_value_regno
|
so that we mind the mode the register is in. */
|
so that we mind the mode the register is in. */
|
|
|
static void
|
static void
|
kill_value (rtx x, struct value_data *vd)
|
kill_value (rtx x, struct value_data *vd)
|
{
|
{
|
rtx orig_rtx = x;
|
rtx orig_rtx = x;
|
|
|
if (GET_CODE (x) == SUBREG)
|
if (GET_CODE (x) == SUBREG)
|
{
|
{
|
x = simplify_subreg (GET_MODE (x), SUBREG_REG (x),
|
x = simplify_subreg (GET_MODE (x), SUBREG_REG (x),
|
GET_MODE (SUBREG_REG (x)), SUBREG_BYTE (x));
|
GET_MODE (SUBREG_REG (x)), SUBREG_BYTE (x));
|
if (x == NULL_RTX)
|
if (x == NULL_RTX)
|
x = SUBREG_REG (orig_rtx);
|
x = SUBREG_REG (orig_rtx);
|
}
|
}
|
if (REG_P (x))
|
if (REG_P (x))
|
{
|
{
|
unsigned int regno = REGNO (x);
|
unsigned int regno = REGNO (x);
|
unsigned int n = hard_regno_nregs[regno][GET_MODE (x)];
|
unsigned int n = hard_regno_nregs[regno][GET_MODE (x)];
|
|
|
kill_value_regno (regno, n, vd);
|
kill_value_regno (regno, n, vd);
|
}
|
}
|
}
|
}
|
|
|
/* Remember that REGNO is valid in MODE. */
|
/* Remember that REGNO is valid in MODE. */
|
|
|
static void
|
static void
|
set_value_regno (unsigned int regno, enum machine_mode mode,
|
set_value_regno (unsigned int regno, enum machine_mode mode,
|
struct value_data *vd)
|
struct value_data *vd)
|
{
|
{
|
unsigned int nregs;
|
unsigned int nregs;
|
|
|
vd->e[regno].mode = mode;
|
vd->e[regno].mode = mode;
|
|
|
nregs = hard_regno_nregs[regno][mode];
|
nregs = hard_regno_nregs[regno][mode];
|
if (nregs > vd->max_value_regs)
|
if (nregs > vd->max_value_regs)
|
vd->max_value_regs = nregs;
|
vd->max_value_regs = nregs;
|
}
|
}
|
|
|
/* Initialize VD such that there are no known relationships between regs. */
|
/* Initialize VD such that there are no known relationships between regs. */
|
|
|
static void
|
static void
|
init_value_data (struct value_data *vd)
|
init_value_data (struct value_data *vd)
|
{
|
{
|
int i;
|
int i;
|
for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
|
for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
|
{
|
{
|
vd->e[i].mode = VOIDmode;
|
vd->e[i].mode = VOIDmode;
|
vd->e[i].oldest_regno = i;
|
vd->e[i].oldest_regno = i;
|
vd->e[i].next_regno = INVALID_REGNUM;
|
vd->e[i].next_regno = INVALID_REGNUM;
|
}
|
}
|
vd->max_value_regs = 0;
|
vd->max_value_regs = 0;
|
}
|
}
|
|
|
/* Called through note_stores. If X is clobbered, kill its value. */
|
/* Called through note_stores. If X is clobbered, kill its value. */
|
|
|
static void
|
static void
|
kill_clobbered_value (rtx x, rtx set, void *data)
|
kill_clobbered_value (rtx x, rtx set, void *data)
|
{
|
{
|
struct value_data *vd = data;
|
struct value_data *vd = data;
|
if (GET_CODE (set) == CLOBBER)
|
if (GET_CODE (set) == CLOBBER)
|
kill_value (x, vd);
|
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. */
|
current value and install it as the root of its own value list. */
|
|
|
static void
|
static void
|
kill_set_value (rtx x, rtx set, void *data)
|
kill_set_value (rtx x, rtx set, void *data)
|
{
|
{
|
struct value_data *vd = data;
|
struct value_data *vd = data;
|
if (GET_CODE (set) != CLOBBER)
|
if (GET_CODE (set) != CLOBBER)
|
{
|
{
|
kill_value (x, vd);
|
kill_value (x, vd);
|
if (REG_P (x))
|
if (REG_P (x))
|
set_value_regno (REGNO (x), GET_MODE (x), vd);
|
set_value_regno (REGNO (x), GET_MODE (x), vd);
|
}
|
}
|
}
|
}
|
|
|
/* Called through for_each_rtx. Kill any register used as the base of an
|
/* 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
|
auto-increment expression, and install that register as the root of its
|
own value list. */
|
own value list. */
|
|
|
static int
|
static int
|
kill_autoinc_value (rtx *px, void *data)
|
kill_autoinc_value (rtx *px, void *data)
|
{
|
{
|
rtx x = *px;
|
rtx x = *px;
|
struct value_data *vd = data;
|
struct value_data *vd = data;
|
|
|
if (GET_RTX_CLASS (GET_CODE (x)) == RTX_AUTOINC)
|
if (GET_RTX_CLASS (GET_CODE (x)) == RTX_AUTOINC)
|
{
|
{
|
x = XEXP (x, 0);
|
x = XEXP (x, 0);
|
kill_value (x, vd);
|
kill_value (x, vd);
|
set_value_regno (REGNO (x), Pmode, vd);
|
set_value_regno (REGNO (x), Pmode, vd);
|
return -1;
|
return -1;
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Assert that SRC has been copied to DEST. Adjust the data structures
|
/* Assert that SRC has been copied to DEST. Adjust the data structures
|
to reflect that SRC contains an older copy of the shared value. */
|
to reflect that SRC contains an older copy of the shared value. */
|
|
|
static void
|
static void
|
copy_value (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 dr = REGNO (dest);
|
unsigned int sr = REGNO (src);
|
unsigned int sr = REGNO (src);
|
unsigned int dn, sn;
|
unsigned int dn, sn;
|
unsigned int i;
|
unsigned int i;
|
|
|
/* ??? At present, it's possible to see noop sets. It'd be nice if
|
/* ??? At present, it's possible to see noop sets. It'd be nice if
|
this were cleaned up beforehand... */
|
this were cleaned up beforehand... */
|
if (sr == dr)
|
if (sr == dr)
|
return;
|
return;
|
|
|
/* Do not propagate copies to the stack pointer, as that can leave
|
/* Do not propagate copies to the stack pointer, as that can leave
|
memory accesses with no scheduling dependency on the stack update. */
|
memory accesses with no scheduling dependency on the stack update. */
|
if (dr == STACK_POINTER_REGNUM)
|
if (dr == STACK_POINTER_REGNUM)
|
return;
|
return;
|
|
|
/* Likewise with the frame pointer, if we're using one. */
|
/* Likewise with the frame pointer, if we're using one. */
|
if (frame_pointer_needed && dr == HARD_FRAME_POINTER_REGNUM)
|
if (frame_pointer_needed && dr == HARD_FRAME_POINTER_REGNUM)
|
return;
|
return;
|
|
|
/* Do not propagate copies to fixed or global registers, patterns
|
/* Do not propagate copies to fixed or global registers, patterns
|
can be relying to see particular fixed register or users can
|
can be relying to see particular fixed register or users can
|
expect the chosen global register in asm. */
|
expect the chosen global register in asm. */
|
if (fixed_regs[dr] || global_regs[dr])
|
if (fixed_regs[dr] || global_regs[dr])
|
return;
|
return;
|
|
|
/* If SRC and DEST overlap, don't record anything. */
|
/* If SRC and DEST overlap, don't record anything. */
|
dn = hard_regno_nregs[dr][GET_MODE (dest)];
|
dn = hard_regno_nregs[dr][GET_MODE (dest)];
|
sn = hard_regno_nregs[sr][GET_MODE (dest)];
|
sn = hard_regno_nregs[sr][GET_MODE (dest)];
|
if ((dr > sr && dr < sr + sn)
|
if ((dr > sr && dr < sr + sn)
|
|| (sr > dr && sr < dr + dn))
|
|| (sr > dr && sr < dr + dn))
|
return;
|
return;
|
|
|
/* If SRC had no assigned mode (i.e. we didn't know it was live)
|
/* 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
|
assign it now and assume the value came from an input argument
|
or somesuch. */
|
or somesuch. */
|
if (vd->e[sr].mode == VOIDmode)
|
if (vd->e[sr].mode == VOIDmode)
|
set_value_regno (sr, vd->e[dr].mode, vd);
|
set_value_regno (sr, vd->e[dr].mode, vd);
|
|
|
/* If we are narrowing the input to a smaller number of hard regs,
|
/* If we are narrowing the input to a smaller number of hard regs,
|
and it is in big endian, we are really extracting a high part.
|
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,
|
Since we generally associate a low part of a value with the value itself,
|
we must not do the same for the high part.
|
we must not do the same for the high part.
|
Note we can still get low parts for the same mode combination through
|
Note we can still get low parts for the same mode combination through
|
a two-step copy involving differently sized hard regs.
|
a two-step copy involving differently sized hard regs.
|
Assume hard regs fr* are 32 bits bits each, while r* are 64 bits each:
|
Assume hard regs fr* are 32 bits bits each, while r* are 64 bits each:
|
(set (reg:DI r0) (reg:DI fr0))
|
(set (reg:DI r0) (reg:DI fr0))
|
(set (reg:SI fr2) (reg:SI r0))
|
(set (reg:SI fr2) (reg:SI r0))
|
loads the low part of (reg:DI fr0) - i.e. fr1 - into fr2, while:
|
loads the low part of (reg:DI fr0) - i.e. fr1 - into fr2, while:
|
(set (reg:SI fr2) (reg:SI fr0))
|
(set (reg:SI fr2) (reg:SI fr0))
|
loads the high part of (reg:DI fr0) into fr2.
|
loads the high part of (reg:DI fr0) into fr2.
|
|
|
We can't properly represent the latter case in our tables, so don't
|
We can't properly represent the latter case in our tables, so don't
|
record anything then. */
|
record anything then. */
|
else if (sn < (unsigned int) hard_regno_nregs[sr][vd->e[sr].mode]
|
else if (sn < (unsigned int) hard_regno_nregs[sr][vd->e[sr].mode]
|
&& (GET_MODE_SIZE (vd->e[sr].mode) > UNITS_PER_WORD
|
&& (GET_MODE_SIZE (vd->e[sr].mode) > UNITS_PER_WORD
|
? WORDS_BIG_ENDIAN : BYTES_BIG_ENDIAN))
|
? WORDS_BIG_ENDIAN : BYTES_BIG_ENDIAN))
|
return;
|
return;
|
|
|
/* If SRC had been assigned a mode narrower than the copy, we can't
|
/* 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
|
link DEST into the chain, because not all of the pieces of the
|
copy came from oldest_regno. */
|
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;
|
return;
|
|
|
/* Link DR at the end of the value chain used by SR. */
|
/* Link DR at the end of the value chain used by SR. */
|
|
|
vd->e[dr].oldest_regno = vd->e[sr].oldest_regno;
|
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)
|
for (i = sr; vd->e[i].next_regno != INVALID_REGNUM; i = vd->e[i].next_regno)
|
continue;
|
continue;
|
vd->e[i].next_regno = dr;
|
vd->e[i].next_regno = dr;
|
|
|
#ifdef ENABLE_CHECKING
|
#ifdef ENABLE_CHECKING
|
validate_value_data (vd);
|
validate_value_data (vd);
|
#endif
|
#endif
|
}
|
}
|
|
|
/* Return true if a mode change from ORIG to NEW is allowed for REGNO. */
|
/* Return true if a mode change from ORIG to NEW is allowed for REGNO. */
|
|
|
static bool
|
static bool
|
mode_change_ok (enum machine_mode orig_mode, enum machine_mode new_mode,
|
mode_change_ok (enum machine_mode orig_mode, enum machine_mode new_mode,
|
unsigned int regno ATTRIBUTE_UNUSED)
|
unsigned int regno ATTRIBUTE_UNUSED)
|
{
|
{
|
if (GET_MODE_SIZE (orig_mode) < GET_MODE_SIZE (new_mode))
|
if (GET_MODE_SIZE (orig_mode) < GET_MODE_SIZE (new_mode))
|
return false;
|
return false;
|
|
|
#ifdef CANNOT_CHANGE_MODE_CLASS
|
#ifdef CANNOT_CHANGE_MODE_CLASS
|
return !REG_CANNOT_CHANGE_MODE_P (regno, orig_mode, new_mode);
|
return !REG_CANNOT_CHANGE_MODE_P (regno, orig_mode, new_mode);
|
#endif
|
#endif
|
|
|
return true;
|
return true;
|
}
|
}
|
|
|
/* Register REGNO was originally set in ORIG_MODE. It - or a copy of it -
|
/* 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
|
was copied in COPY_MODE to COPY_REGNO, and then COPY_REGNO was accessed
|
in NEW_MODE.
|
in NEW_MODE.
|
Return a NEW_MODE rtx for REGNO if that's OK, otherwise return NULL_RTX. */
|
Return a NEW_MODE rtx for REGNO if that's OK, otherwise return NULL_RTX. */
|
|
|
static rtx
|
static rtx
|
maybe_mode_change (enum machine_mode orig_mode, enum machine_mode copy_mode,
|
maybe_mode_change (enum machine_mode orig_mode, enum machine_mode copy_mode,
|
enum machine_mode new_mode, unsigned int regno,
|
enum machine_mode new_mode, unsigned int regno,
|
unsigned int copy_regno ATTRIBUTE_UNUSED)
|
unsigned int copy_regno ATTRIBUTE_UNUSED)
|
{
|
{
|
if (orig_mode == new_mode)
|
if (orig_mode == new_mode)
|
return gen_rtx_raw_REG (new_mode, regno);
|
return gen_rtx_raw_REG (new_mode, regno);
|
else if (mode_change_ok (orig_mode, new_mode, regno))
|
else if (mode_change_ok (orig_mode, new_mode, regno))
|
{
|
{
|
int copy_nregs = hard_regno_nregs[copy_regno][copy_mode];
|
int copy_nregs = hard_regno_nregs[copy_regno][copy_mode];
|
int use_nregs = hard_regno_nregs[copy_regno][new_mode];
|
int use_nregs = hard_regno_nregs[copy_regno][new_mode];
|
int copy_offset
|
int copy_offset
|
= GET_MODE_SIZE (copy_mode) / copy_nregs * (copy_nregs - use_nregs);
|
= GET_MODE_SIZE (copy_mode) / copy_nregs * (copy_nregs - use_nregs);
|
int offset
|
int offset
|
= GET_MODE_SIZE (orig_mode) - GET_MODE_SIZE (new_mode) - copy_offset;
|
= GET_MODE_SIZE (orig_mode) - GET_MODE_SIZE (new_mode) - copy_offset;
|
int byteoffset = offset % UNITS_PER_WORD;
|
int byteoffset = offset % UNITS_PER_WORD;
|
int wordoffset = offset - byteoffset;
|
int wordoffset = offset - byteoffset;
|
|
|
offset = ((WORDS_BIG_ENDIAN ? wordoffset : 0)
|
offset = ((WORDS_BIG_ENDIAN ? wordoffset : 0)
|
+ (BYTES_BIG_ENDIAN ? byteoffset : 0));
|
+ (BYTES_BIG_ENDIAN ? byteoffset : 0));
|
return gen_rtx_raw_REG (new_mode,
|
return gen_rtx_raw_REG (new_mode,
|
regno + subreg_regno_offset (regno, orig_mode,
|
regno + subreg_regno_offset (regno, orig_mode,
|
offset,
|
offset,
|
new_mode));
|
new_mode));
|
}
|
}
|
return NULL_RTX;
|
return NULL_RTX;
|
}
|
}
|
|
|
/* Find the oldest copy of the value contained in REGNO that is in
|
/* Find the oldest copy of the value contained in REGNO that is in
|
register class CL 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. */
|
of that oldest register, otherwise return NULL. */
|
|
|
static rtx
|
static rtx
|
find_oldest_value_reg (enum reg_class cl, 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);
|
unsigned int regno = REGNO (reg);
|
enum machine_mode mode = GET_MODE (reg);
|
enum machine_mode mode = GET_MODE (reg);
|
unsigned int i;
|
unsigned int i;
|
|
|
/* If we are accessing REG in some mode other that what we set it in,
|
/* 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
|
make sure that the replacement is valid. In particular, consider
|
(set (reg:DI r11) (...))
|
(set (reg:DI r11) (...))
|
(set (reg:SI r9) (reg:SI r11))
|
(set (reg:SI r9) (reg:SI r11))
|
(set (reg:SI r10) (...))
|
(set (reg:SI r10) (...))
|
(set (...) (reg:DI r9))
|
(set (...) (reg:DI r9))
|
Replacing r9 with r11 is invalid. */
|
Replacing r9 with r11 is invalid. */
|
if (mode != vd->e[regno].mode)
|
if (mode != vd->e[regno].mode)
|
{
|
{
|
if (hard_regno_nregs[regno][mode]
|
if (hard_regno_nregs[regno][mode]
|
> hard_regno_nregs[regno][vd->e[regno].mode])
|
> hard_regno_nregs[regno][vd->e[regno].mode])
|
return NULL_RTX;
|
return NULL_RTX;
|
}
|
}
|
|
|
for (i = vd->e[regno].oldest_regno; i != regno; i = vd->e[i].next_regno)
|
for (i = vd->e[regno].oldest_regno; i != regno; i = vd->e[i].next_regno)
|
{
|
{
|
enum machine_mode oldmode = vd->e[i].mode;
|
enum machine_mode oldmode = vd->e[i].mode;
|
rtx new;
|
rtx new;
|
unsigned int last;
|
unsigned int last;
|
|
|
for (last = i; last < i + hard_regno_nregs[i][mode]; last++)
|
for (last = i; last < i + hard_regno_nregs[i][mode]; last++)
|
if (!TEST_HARD_REG_BIT (reg_class_contents[cl], last))
|
if (!TEST_HARD_REG_BIT (reg_class_contents[cl], last))
|
return NULL_RTX;
|
return NULL_RTX;
|
|
|
new = maybe_mode_change (oldmode, vd->e[regno].mode, mode, i, regno);
|
new = maybe_mode_change (oldmode, vd->e[regno].mode, mode, i, regno);
|
if (new)
|
if (new)
|
{
|
{
|
ORIGINAL_REGNO (new) = ORIGINAL_REGNO (reg);
|
ORIGINAL_REGNO (new) = ORIGINAL_REGNO (reg);
|
REG_ATTRS (new) = REG_ATTRS (reg);
|
REG_ATTRS (new) = REG_ATTRS (reg);
|
return new;
|
return new;
|
}
|
}
|
}
|
}
|
|
|
return NULL_RTX;
|
return NULL_RTX;
|
}
|
}
|
|
|
/* If possible, replace the register at *LOC with the oldest register
|
/* If possible, replace the register at *LOC with the oldest register
|
in register class CL. Return true if successfully replaced. */
|
in register class CL. Return true if successfully replaced. */
|
|
|
static bool
|
static bool
|
replace_oldest_value_reg (rtx *loc, enum reg_class cl, rtx insn,
|
replace_oldest_value_reg (rtx *loc, enum reg_class cl, rtx insn,
|
struct value_data *vd)
|
struct value_data *vd)
|
{
|
{
|
rtx new = find_oldest_value_reg (cl, *loc, vd);
|
rtx new = find_oldest_value_reg (cl, *loc, vd);
|
if (new)
|
if (new)
|
{
|
{
|
if (dump_file)
|
if (dump_file)
|
fprintf (dump_file, "insn %u: replaced reg %u with %u\n",
|
fprintf (dump_file, "insn %u: replaced reg %u with %u\n",
|
INSN_UID (insn), REGNO (*loc), REGNO (new));
|
INSN_UID (insn), REGNO (*loc), REGNO (new));
|
|
|
validate_change (insn, loc, new, 1);
|
validate_change (insn, loc, new, 1);
|
return true;
|
return true;
|
}
|
}
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Similar to replace_oldest_value_reg, but *LOC contains an address.
|
/* Similar to replace_oldest_value_reg, but *LOC contains an address.
|
Adapted from find_reloads_address_1. CL 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. */
|
BASE_REG_CLASS depending on how the register is being considered. */
|
|
|
static bool
|
static bool
|
replace_oldest_value_addr (rtx *loc, enum reg_class cl,
|
replace_oldest_value_addr (rtx *loc, enum reg_class cl,
|
enum machine_mode mode, rtx insn,
|
enum machine_mode mode, rtx insn,
|
struct value_data *vd)
|
struct value_data *vd)
|
{
|
{
|
rtx x = *loc;
|
rtx x = *loc;
|
RTX_CODE code = GET_CODE (x);
|
RTX_CODE code = GET_CODE (x);
|
const char *fmt;
|
const char *fmt;
|
int i, j;
|
int i, j;
|
bool changed = false;
|
bool changed = false;
|
|
|
switch (code)
|
switch (code)
|
{
|
{
|
case PLUS:
|
case PLUS:
|
{
|
{
|
rtx orig_op0 = XEXP (x, 0);
|
rtx orig_op0 = XEXP (x, 0);
|
rtx orig_op1 = XEXP (x, 1);
|
rtx orig_op1 = XEXP (x, 1);
|
RTX_CODE code0 = GET_CODE (orig_op0);
|
RTX_CODE code0 = GET_CODE (orig_op0);
|
RTX_CODE code1 = GET_CODE (orig_op1);
|
RTX_CODE code1 = GET_CODE (orig_op1);
|
rtx op0 = orig_op0;
|
rtx op0 = orig_op0;
|
rtx op1 = orig_op1;
|
rtx op1 = orig_op1;
|
rtx *locI = NULL;
|
rtx *locI = NULL;
|
rtx *locB = NULL;
|
rtx *locB = NULL;
|
enum rtx_code index_code = SCRATCH;
|
enum rtx_code index_code = SCRATCH;
|
|
|
if (GET_CODE (op0) == SUBREG)
|
if (GET_CODE (op0) == SUBREG)
|
{
|
{
|
op0 = SUBREG_REG (op0);
|
op0 = SUBREG_REG (op0);
|
code0 = GET_CODE (op0);
|
code0 = GET_CODE (op0);
|
}
|
}
|
|
|
if (GET_CODE (op1) == SUBREG)
|
if (GET_CODE (op1) == SUBREG)
|
{
|
{
|
op1 = SUBREG_REG (op1);
|
op1 = SUBREG_REG (op1);
|
code1 = GET_CODE (op1);
|
code1 = GET_CODE (op1);
|
}
|
}
|
|
|
if (code0 == MULT || code0 == SIGN_EXTEND || code0 == TRUNCATE
|
if (code0 == MULT || code0 == SIGN_EXTEND || code0 == TRUNCATE
|
|| code0 == ZERO_EXTEND || code1 == MEM)
|
|| code0 == ZERO_EXTEND || code1 == MEM)
|
{
|
{
|
locI = &XEXP (x, 0);
|
locI = &XEXP (x, 0);
|
locB = &XEXP (x, 1);
|
locB = &XEXP (x, 1);
|
index_code = GET_CODE (*locI);
|
index_code = GET_CODE (*locI);
|
}
|
}
|
else if (code1 == MULT || code1 == SIGN_EXTEND || code1 == TRUNCATE
|
else if (code1 == MULT || code1 == SIGN_EXTEND || code1 == TRUNCATE
|
|| code1 == ZERO_EXTEND || code0 == MEM)
|
|| code1 == ZERO_EXTEND || code0 == MEM)
|
{
|
{
|
locI = &XEXP (x, 1);
|
locI = &XEXP (x, 1);
|
locB = &XEXP (x, 0);
|
locB = &XEXP (x, 0);
|
index_code = GET_CODE (*locI);
|
index_code = GET_CODE (*locI);
|
}
|
}
|
else if (code0 == CONST_INT || code0 == CONST
|
else if (code0 == CONST_INT || code0 == CONST
|
|| code0 == SYMBOL_REF || code0 == LABEL_REF)
|
|| code0 == SYMBOL_REF || code0 == LABEL_REF)
|
{
|
{
|
locB = &XEXP (x, 1);
|
locB = &XEXP (x, 1);
|
index_code = GET_CODE (XEXP (x, 0));
|
index_code = GET_CODE (XEXP (x, 0));
|
}
|
}
|
else if (code1 == CONST_INT || code1 == CONST
|
else if (code1 == CONST_INT || code1 == CONST
|
|| code1 == SYMBOL_REF || code1 == LABEL_REF)
|
|| code1 == SYMBOL_REF || code1 == LABEL_REF)
|
{
|
{
|
locB = &XEXP (x, 0);
|
locB = &XEXP (x, 0);
|
index_code = GET_CODE (XEXP (x, 1));
|
index_code = GET_CODE (XEXP (x, 1));
|
}
|
}
|
else if (code0 == REG && code1 == REG)
|
else if (code0 == REG && code1 == REG)
|
{
|
{
|
int index_op;
|
int index_op;
|
unsigned regno0 = REGNO (op0), regno1 = REGNO (op1);
|
unsigned regno0 = REGNO (op0), regno1 = REGNO (op1);
|
|
|
if (REGNO_OK_FOR_INDEX_P (regno0)
|
if (REGNO_OK_FOR_INDEX_P (regno0)
|
&& regno_ok_for_base_p (regno1, mode, PLUS, REG))
|
&& regno_ok_for_base_p (regno1, mode, PLUS, REG))
|
index_op = 0;
|
index_op = 0;
|
else if (REGNO_OK_FOR_INDEX_P (regno1)
|
else if (REGNO_OK_FOR_INDEX_P (regno1)
|
&& regno_ok_for_base_p (regno0, mode, PLUS, REG))
|
&& regno_ok_for_base_p (regno0, mode, PLUS, REG))
|
index_op = 1;
|
index_op = 1;
|
else if (regno_ok_for_base_p (regno1, mode, PLUS, REG))
|
else if (regno_ok_for_base_p (regno1, mode, PLUS, REG))
|
index_op = 0;
|
index_op = 0;
|
else if (regno_ok_for_base_p (regno0, mode, PLUS, REG))
|
else if (regno_ok_for_base_p (regno0, mode, PLUS, REG))
|
index_op = 1;
|
index_op = 1;
|
else if (REGNO_OK_FOR_INDEX_P (regno1))
|
else if (REGNO_OK_FOR_INDEX_P (regno1))
|
index_op = 1;
|
index_op = 1;
|
else
|
else
|
index_op = 0;
|
index_op = 0;
|
|
|
locI = &XEXP (x, index_op);
|
locI = &XEXP (x, index_op);
|
locB = &XEXP (x, !index_op);
|
locB = &XEXP (x, !index_op);
|
index_code = GET_CODE (*locI);
|
index_code = GET_CODE (*locI);
|
}
|
}
|
else if (code0 == REG)
|
else if (code0 == REG)
|
{
|
{
|
locI = &XEXP (x, 0);
|
locI = &XEXP (x, 0);
|
locB = &XEXP (x, 1);
|
locB = &XEXP (x, 1);
|
index_code = GET_CODE (*locI);
|
index_code = GET_CODE (*locI);
|
}
|
}
|
else if (code1 == REG)
|
else if (code1 == REG)
|
{
|
{
|
locI = &XEXP (x, 1);
|
locI = &XEXP (x, 1);
|
locB = &XEXP (x, 0);
|
locB = &XEXP (x, 0);
|
index_code = GET_CODE (*locI);
|
index_code = GET_CODE (*locI);
|
}
|
}
|
|
|
if (locI)
|
if (locI)
|
changed |= replace_oldest_value_addr (locI, INDEX_REG_CLASS, mode,
|
changed |= replace_oldest_value_addr (locI, INDEX_REG_CLASS, mode,
|
insn, vd);
|
insn, vd);
|
if (locB)
|
if (locB)
|
changed |= replace_oldest_value_addr (locB,
|
changed |= replace_oldest_value_addr (locB,
|
base_reg_class (mode, PLUS,
|
base_reg_class (mode, PLUS,
|
index_code),
|
index_code),
|
mode, insn, vd);
|
mode, insn, vd);
|
return changed;
|
return changed;
|
}
|
}
|
|
|
case POST_INC:
|
case POST_INC:
|
case POST_DEC:
|
case POST_DEC:
|
case POST_MODIFY:
|
case POST_MODIFY:
|
case PRE_INC:
|
case PRE_INC:
|
case PRE_DEC:
|
case PRE_DEC:
|
case PRE_MODIFY:
|
case PRE_MODIFY:
|
return false;
|
return false;
|
|
|
case MEM:
|
case MEM:
|
return replace_oldest_value_mem (x, insn, vd);
|
return replace_oldest_value_mem (x, insn, vd);
|
|
|
case REG:
|
case REG:
|
return replace_oldest_value_reg (loc, cl, insn, vd);
|
return replace_oldest_value_reg (loc, cl, insn, vd);
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
fmt = GET_RTX_FORMAT (code);
|
fmt = GET_RTX_FORMAT (code);
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
{
|
{
|
if (fmt[i] == 'e')
|
if (fmt[i] == 'e')
|
changed |= replace_oldest_value_addr (&XEXP (x, i), cl, mode,
|
changed |= replace_oldest_value_addr (&XEXP (x, i), cl, mode,
|
insn, vd);
|
insn, vd);
|
else if (fmt[i] == 'E')
|
else if (fmt[i] == 'E')
|
for (j = XVECLEN (x, i) - 1; j >= 0; j--)
|
for (j = XVECLEN (x, i) - 1; j >= 0; j--)
|
changed |= replace_oldest_value_addr (&XVECEXP (x, i, j), cl,
|
changed |= replace_oldest_value_addr (&XVECEXP (x, i, j), cl,
|
mode, insn, vd);
|
mode, insn, vd);
|
}
|
}
|
|
|
return changed;
|
return changed;
|
}
|
}
|
|
|
/* Similar to replace_oldest_value_reg, but X contains a memory. */
|
/* Similar to replace_oldest_value_reg, but X contains a memory. */
|
|
|
static bool
|
static bool
|
replace_oldest_value_mem (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),
|
return replace_oldest_value_addr (&XEXP (x, 0),
|
base_reg_class (GET_MODE (x), MEM,
|
base_reg_class (GET_MODE (x), MEM,
|
SCRATCH),
|
SCRATCH),
|
GET_MODE (x), insn, vd);
|
GET_MODE (x), insn, vd);
|
}
|
}
|
|
|
/* Perform the forward copy propagation on basic block BB. */
|
/* Perform the forward copy propagation on basic block BB. */
|
|
|
static bool
|
static bool
|
copyprop_hardreg_forward_1 (basic_block bb, struct value_data *vd)
|
copyprop_hardreg_forward_1 (basic_block bb, struct value_data *vd)
|
{
|
{
|
bool changed = false;
|
bool changed = false;
|
rtx insn;
|
rtx insn;
|
|
|
for (insn = BB_HEAD (bb); ; insn = NEXT_INSN (insn))
|
for (insn = BB_HEAD (bb); ; insn = NEXT_INSN (insn))
|
{
|
{
|
int n_ops, i, alt, predicated;
|
int n_ops, i, alt, predicated;
|
bool is_asm, any_replacements;
|
bool is_asm, any_replacements;
|
rtx set;
|
rtx set;
|
bool replaced[MAX_RECOG_OPERANDS];
|
bool replaced[MAX_RECOG_OPERANDS];
|
|
|
if (! INSN_P (insn))
|
if (! INSN_P (insn))
|
{
|
{
|
if (insn == BB_END (bb))
|
if (insn == BB_END (bb))
|
break;
|
break;
|
else
|
else
|
continue;
|
continue;
|
}
|
}
|
|
|
set = single_set (insn);
|
set = single_set (insn);
|
extract_insn (insn);
|
extract_insn (insn);
|
if (! constrain_operands (1))
|
if (! constrain_operands (1))
|
fatal_insn_not_found (insn);
|
fatal_insn_not_found (insn);
|
preprocess_constraints ();
|
preprocess_constraints ();
|
alt = which_alternative;
|
alt = which_alternative;
|
n_ops = recog_data.n_operands;
|
n_ops = recog_data.n_operands;
|
is_asm = asm_noperands (PATTERN (insn)) >= 0;
|
is_asm = asm_noperands (PATTERN (insn)) >= 0;
|
|
|
/* Simplify the code below by rewriting things to reflect
|
/* Simplify the code below by rewriting things to reflect
|
matching constraints. Also promote OP_OUT to OP_INOUT
|
matching constraints. Also promote OP_OUT to OP_INOUT
|
in predicated instructions. */
|
in predicated instructions. */
|
|
|
predicated = GET_CODE (PATTERN (insn)) == COND_EXEC;
|
predicated = GET_CODE (PATTERN (insn)) == COND_EXEC;
|
for (i = 0; i < n_ops; ++i)
|
for (i = 0; i < n_ops; ++i)
|
{
|
{
|
int matches = recog_op_alt[i][alt].matches;
|
int matches = recog_op_alt[i][alt].matches;
|
if (matches >= 0)
|
if (matches >= 0)
|
recog_op_alt[i][alt].cl = recog_op_alt[matches][alt].cl;
|
recog_op_alt[i][alt].cl = recog_op_alt[matches][alt].cl;
|
if (matches >= 0 || recog_op_alt[i][alt].matched >= 0
|
if (matches >= 0 || recog_op_alt[i][alt].matched >= 0
|
|| (predicated && recog_data.operand_type[i] == OP_OUT))
|
|| (predicated && recog_data.operand_type[i] == OP_OUT))
|
recog_data.operand_type[i] = OP_INOUT;
|
recog_data.operand_type[i] = OP_INOUT;
|
}
|
}
|
|
|
/* For each earlyclobber operand, zap the value data. */
|
/* For each earlyclobber operand, zap the value data. */
|
for (i = 0; i < n_ops; i++)
|
for (i = 0; i < n_ops; i++)
|
if (recog_op_alt[i][alt].earlyclobber)
|
if (recog_op_alt[i][alt].earlyclobber)
|
kill_value (recog_data.operand[i], vd);
|
kill_value (recog_data.operand[i], vd);
|
|
|
/* Within asms, a clobber cannot overlap inputs or outputs.
|
/* Within asms, a clobber cannot overlap inputs or outputs.
|
I wouldn't think this were true for regular insns, but
|
I wouldn't think this were true for regular insns, but
|
scan_rtx treats them like that... */
|
scan_rtx treats them like that... */
|
note_stores (PATTERN (insn), kill_clobbered_value, vd);
|
note_stores (PATTERN (insn), kill_clobbered_value, vd);
|
|
|
/* Kill all auto-incremented values. */
|
/* Kill all auto-incremented values. */
|
/* ??? REG_INC is useless, since stack pushes aren't done that way. */
|
/* ??? REG_INC is useless, since stack pushes aren't done that way. */
|
for_each_rtx (&PATTERN (insn), kill_autoinc_value, vd);
|
for_each_rtx (&PATTERN (insn), kill_autoinc_value, vd);
|
|
|
/* Kill all early-clobbered operands. */
|
/* Kill all early-clobbered operands. */
|
for (i = 0; i < n_ops; i++)
|
for (i = 0; i < n_ops; i++)
|
if (recog_op_alt[i][alt].earlyclobber)
|
if (recog_op_alt[i][alt].earlyclobber)
|
kill_value (recog_data.operand[i], vd);
|
kill_value (recog_data.operand[i], vd);
|
|
|
/* Special-case plain move instructions, since we may well
|
/* Special-case plain move instructions, since we may well
|
be able to do the move from a different register class. */
|
be able to do the move from a different register class. */
|
if (set && REG_P (SET_SRC (set)))
|
if (set && REG_P (SET_SRC (set)))
|
{
|
{
|
rtx src = SET_SRC (set);
|
rtx src = SET_SRC (set);
|
unsigned int regno = REGNO (src);
|
unsigned int regno = REGNO (src);
|
enum machine_mode mode = GET_MODE (src);
|
enum machine_mode mode = GET_MODE (src);
|
unsigned int i;
|
unsigned int i;
|
rtx new;
|
rtx new;
|
|
|
/* If we are accessing SRC in some mode other that what we
|
/* If we are accessing SRC in some mode other that what we
|
set it in, make sure that the replacement is valid. */
|
set it in, make sure that the replacement is valid. */
|
if (mode != vd->e[regno].mode)
|
if (mode != vd->e[regno].mode)
|
{
|
{
|
if (hard_regno_nregs[regno][mode]
|
if (hard_regno_nregs[regno][mode]
|
> hard_regno_nregs[regno][vd->e[regno].mode])
|
> hard_regno_nregs[regno][vd->e[regno].mode])
|
goto no_move_special_case;
|
goto no_move_special_case;
|
}
|
}
|
|
|
/* If the destination is also a register, try to find a source
|
/* If the destination is also a register, try to find a source
|
register in the same class. */
|
register in the same class. */
|
if (REG_P (SET_DEST (set)))
|
if (REG_P (SET_DEST (set)))
|
{
|
{
|
new = find_oldest_value_reg (REGNO_REG_CLASS (regno), src, vd);
|
new = find_oldest_value_reg (REGNO_REG_CLASS (regno), src, vd);
|
if (new && validate_change (insn, &SET_SRC (set), new, 0))
|
if (new && validate_change (insn, &SET_SRC (set), new, 0))
|
{
|
{
|
if (dump_file)
|
if (dump_file)
|
fprintf (dump_file,
|
fprintf (dump_file,
|
"insn %u: replaced reg %u with %u\n",
|
"insn %u: replaced reg %u with %u\n",
|
INSN_UID (insn), regno, REGNO (new));
|
INSN_UID (insn), regno, REGNO (new));
|
changed = true;
|
changed = true;
|
goto did_replacement;
|
goto did_replacement;
|
}
|
}
|
}
|
}
|
|
|
/* Otherwise, try all valid registers and see if its valid. */
|
/* Otherwise, try all valid registers and see if its valid. */
|
for (i = vd->e[regno].oldest_regno; i != regno;
|
for (i = vd->e[regno].oldest_regno; i != regno;
|
i = vd->e[i].next_regno)
|
i = vd->e[i].next_regno)
|
{
|
{
|
new = maybe_mode_change (vd->e[i].mode, vd->e[regno].mode,
|
new = maybe_mode_change (vd->e[i].mode, vd->e[regno].mode,
|
mode, i, regno);
|
mode, i, regno);
|
if (new != NULL_RTX)
|
if (new != NULL_RTX)
|
{
|
{
|
if (validate_change (insn, &SET_SRC (set), new, 0))
|
if (validate_change (insn, &SET_SRC (set), new, 0))
|
{
|
{
|
ORIGINAL_REGNO (new) = ORIGINAL_REGNO (src);
|
ORIGINAL_REGNO (new) = ORIGINAL_REGNO (src);
|
REG_ATTRS (new) = REG_ATTRS (src);
|
REG_ATTRS (new) = REG_ATTRS (src);
|
if (dump_file)
|
if (dump_file)
|
fprintf (dump_file,
|
fprintf (dump_file,
|
"insn %u: replaced reg %u with %u\n",
|
"insn %u: replaced reg %u with %u\n",
|
INSN_UID (insn), regno, REGNO (new));
|
INSN_UID (insn), regno, REGNO (new));
|
changed = true;
|
changed = true;
|
goto did_replacement;
|
goto did_replacement;
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
no_move_special_case:
|
no_move_special_case:
|
|
|
any_replacements = false;
|
any_replacements = false;
|
|
|
/* For each input operand, replace a hard register with the
|
/* For each input operand, replace a hard register with the
|
eldest live copy that's in an appropriate register class. */
|
eldest live copy that's in an appropriate register class. */
|
for (i = 0; i < n_ops; i++)
|
for (i = 0; i < n_ops; i++)
|
{
|
{
|
replaced[i] = false;
|
replaced[i] = false;
|
|
|
/* Don't scan match_operand here, since we've no reg class
|
/* Don't scan match_operand here, since we've no reg class
|
information to pass down. Any operands that we could
|
information to pass down. Any operands that we could
|
substitute in will be represented elsewhere. */
|
substitute in will be represented elsewhere. */
|
if (recog_data.constraints[i][0] == '\0')
|
if (recog_data.constraints[i][0] == '\0')
|
continue;
|
continue;
|
|
|
/* Don't replace in asms intentionally referencing hard regs. */
|
/* Don't replace in asms intentionally referencing hard regs. */
|
if (is_asm && REG_P (recog_data.operand[i])
|
if (is_asm && REG_P (recog_data.operand[i])
|
&& (REGNO (recog_data.operand[i])
|
&& (REGNO (recog_data.operand[i])
|
== ORIGINAL_REGNO (recog_data.operand[i])))
|
== ORIGINAL_REGNO (recog_data.operand[i])))
|
continue;
|
continue;
|
|
|
if (recog_data.operand_type[i] == OP_IN)
|
if (recog_data.operand_type[i] == OP_IN)
|
{
|
{
|
if (recog_op_alt[i][alt].is_address)
|
if (recog_op_alt[i][alt].is_address)
|
replaced[i]
|
replaced[i]
|
= replace_oldest_value_addr (recog_data.operand_loc[i],
|
= replace_oldest_value_addr (recog_data.operand_loc[i],
|
recog_op_alt[i][alt].cl,
|
recog_op_alt[i][alt].cl,
|
VOIDmode, insn, vd);
|
VOIDmode, insn, vd);
|
else if (REG_P (recog_data.operand[i]))
|
else if (REG_P (recog_data.operand[i]))
|
replaced[i]
|
replaced[i]
|
= replace_oldest_value_reg (recog_data.operand_loc[i],
|
= replace_oldest_value_reg (recog_data.operand_loc[i],
|
recog_op_alt[i][alt].cl,
|
recog_op_alt[i][alt].cl,
|
insn, vd);
|
insn, vd);
|
else if (MEM_P (recog_data.operand[i]))
|
else if (MEM_P (recog_data.operand[i]))
|
replaced[i] = replace_oldest_value_mem (recog_data.operand[i],
|
replaced[i] = replace_oldest_value_mem (recog_data.operand[i],
|
insn, vd);
|
insn, vd);
|
}
|
}
|
else if (MEM_P (recog_data.operand[i]))
|
else if (MEM_P (recog_data.operand[i]))
|
replaced[i] = replace_oldest_value_mem (recog_data.operand[i],
|
replaced[i] = replace_oldest_value_mem (recog_data.operand[i],
|
insn, vd);
|
insn, vd);
|
|
|
/* If we performed any replacement, update match_dups. */
|
/* If we performed any replacement, update match_dups. */
|
if (replaced[i])
|
if (replaced[i])
|
{
|
{
|
int j;
|
int j;
|
rtx new;
|
rtx new;
|
|
|
new = *recog_data.operand_loc[i];
|
new = *recog_data.operand_loc[i];
|
recog_data.operand[i] = new;
|
recog_data.operand[i] = new;
|
for (j = 0; j < recog_data.n_dups; j++)
|
for (j = 0; j < recog_data.n_dups; j++)
|
if (recog_data.dup_num[j] == i)
|
if (recog_data.dup_num[j] == i)
|
validate_change (insn, recog_data.dup_loc[j], new, 1);
|
validate_change (insn, recog_data.dup_loc[j], new, 1);
|
|
|
any_replacements = true;
|
any_replacements = true;
|
}
|
}
|
}
|
}
|
|
|
if (any_replacements)
|
if (any_replacements)
|
{
|
{
|
if (! apply_change_group ())
|
if (! apply_change_group ())
|
{
|
{
|
for (i = 0; i < n_ops; i++)
|
for (i = 0; i < n_ops; i++)
|
if (replaced[i])
|
if (replaced[i])
|
{
|
{
|
rtx old = *recog_data.operand_loc[i];
|
rtx old = *recog_data.operand_loc[i];
|
recog_data.operand[i] = old;
|
recog_data.operand[i] = old;
|
}
|
}
|
|
|
if (dump_file)
|
if (dump_file)
|
fprintf (dump_file,
|
fprintf (dump_file,
|
"insn %u: reg replacements not verified\n",
|
"insn %u: reg replacements not verified\n",
|
INSN_UID (insn));
|
INSN_UID (insn));
|
}
|
}
|
else
|
else
|
changed = true;
|
changed = true;
|
}
|
}
|
|
|
did_replacement:
|
did_replacement:
|
/* Clobber call-clobbered registers. */
|
/* Clobber call-clobbered registers. */
|
if (CALL_P (insn))
|
if (CALL_P (insn))
|
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
|
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
|
if (TEST_HARD_REG_BIT (regs_invalidated_by_call, i))
|
if (TEST_HARD_REG_BIT (regs_invalidated_by_call, i))
|
kill_value_regno (i, 1, vd);
|
kill_value_regno (i, 1, vd);
|
|
|
/* Notice stores. */
|
/* Notice stores. */
|
note_stores (PATTERN (insn), kill_set_value, vd);
|
note_stores (PATTERN (insn), kill_set_value, vd);
|
|
|
/* Notice copies. */
|
/* Notice copies. */
|
if (set && REG_P (SET_DEST (set)) && REG_P (SET_SRC (set)))
|
if (set && REG_P (SET_DEST (set)) && REG_P (SET_SRC (set)))
|
copy_value (SET_DEST (set), SET_SRC (set), vd);
|
copy_value (SET_DEST (set), SET_SRC (set), vd);
|
|
|
if (insn == BB_END (bb))
|
if (insn == BB_END (bb))
|
break;
|
break;
|
}
|
}
|
|
|
return changed;
|
return changed;
|
}
|
}
|
|
|
/* Main entry point for the forward copy propagation optimization. */
|
/* Main entry point for the forward copy propagation optimization. */
|
|
|
static void
|
static void
|
copyprop_hardreg_forward (void)
|
copyprop_hardreg_forward (void)
|
{
|
{
|
struct value_data *all_vd;
|
struct value_data *all_vd;
|
bool need_refresh;
|
bool need_refresh;
|
basic_block bb;
|
basic_block bb;
|
sbitmap visited;
|
sbitmap visited;
|
|
|
need_refresh = false;
|
need_refresh = false;
|
|
|
all_vd = XNEWVEC (struct value_data, last_basic_block);
|
all_vd = XNEWVEC (struct value_data, last_basic_block);
|
|
|
visited = sbitmap_alloc (last_basic_block);
|
visited = sbitmap_alloc (last_basic_block);
|
sbitmap_zero (visited);
|
sbitmap_zero (visited);
|
|
|
FOR_EACH_BB (bb)
|
FOR_EACH_BB (bb)
|
{
|
{
|
SET_BIT (visited, bb->index);
|
SET_BIT (visited, bb->index);
|
|
|
/* If a block has a single predecessor, that we've already
|
/* If a block has a single predecessor, that we've already
|
processed, begin with the value data that was live at
|
processed, begin with the value data that was live at
|
the end of the predecessor block. */
|
the end of the predecessor block. */
|
/* ??? Ought to use more intelligent queuing of blocks. */
|
/* ??? Ought to use more intelligent queuing of blocks. */
|
if (single_pred_p (bb)
|
if (single_pred_p (bb)
|
&& TEST_BIT (visited, single_pred (bb)->index)
|
&& TEST_BIT (visited, single_pred (bb)->index)
|
&& ! (single_pred_edge (bb)->flags & (EDGE_ABNORMAL_CALL | EDGE_EH)))
|
&& ! (single_pred_edge (bb)->flags & (EDGE_ABNORMAL_CALL | EDGE_EH)))
|
all_vd[bb->index] = all_vd[single_pred (bb)->index];
|
all_vd[bb->index] = all_vd[single_pred (bb)->index];
|
else
|
else
|
init_value_data (all_vd + bb->index);
|
init_value_data (all_vd + bb->index);
|
|
|
if (copyprop_hardreg_forward_1 (bb, all_vd + bb->index))
|
if (copyprop_hardreg_forward_1 (bb, all_vd + bb->index))
|
need_refresh = true;
|
need_refresh = true;
|
}
|
}
|
|
|
sbitmap_free (visited);
|
sbitmap_free (visited);
|
|
|
if (need_refresh)
|
if (need_refresh)
|
{
|
{
|
if (dump_file)
|
if (dump_file)
|
fputs ("\n\n", dump_file);
|
fputs ("\n\n", dump_file);
|
|
|
/* ??? Irritatingly, delete_noop_moves does not take a set of blocks
|
/* ??? 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
|
to scan, so we have to do a life update with no initial set of
|
blocks Just In Case. */
|
blocks Just In Case. */
|
delete_noop_moves ();
|
delete_noop_moves ();
|
update_life_info (NULL, UPDATE_LIFE_GLOBAL_RM_NOTES,
|
update_life_info (NULL, UPDATE_LIFE_GLOBAL_RM_NOTES,
|
PROP_DEATH_NOTES
|
PROP_DEATH_NOTES
|
| PROP_SCAN_DEAD_CODE
|
| PROP_SCAN_DEAD_CODE
|
| PROP_KILL_DEAD_CODE);
|
| PROP_KILL_DEAD_CODE);
|
}
|
}
|
|
|
free (all_vd);
|
free (all_vd);
|
}
|
}
|
|
|
/* Dump the value chain data to stderr. */
|
/* Dump the value chain data to stderr. */
|
|
|
void
|
void
|
debug_value_data (struct value_data *vd)
|
debug_value_data (struct value_data *vd)
|
{
|
{
|
HARD_REG_SET set;
|
HARD_REG_SET set;
|
unsigned int i, j;
|
unsigned int i, j;
|
|
|
CLEAR_HARD_REG_SET (set);
|
CLEAR_HARD_REG_SET (set);
|
|
|
for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
|
for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
|
if (vd->e[i].oldest_regno == i)
|
if (vd->e[i].oldest_regno == i)
|
{
|
{
|
if (vd->e[i].mode == VOIDmode)
|
if (vd->e[i].mode == VOIDmode)
|
{
|
{
|
if (vd->e[i].next_regno != INVALID_REGNUM)
|
if (vd->e[i].next_regno != INVALID_REGNUM)
|
fprintf (stderr, "[%u] Bad next_regno for empty chain (%u)\n",
|
fprintf (stderr, "[%u] Bad next_regno for empty chain (%u)\n",
|
i, vd->e[i].next_regno);
|
i, vd->e[i].next_regno);
|
continue;
|
continue;
|
}
|
}
|
|
|
SET_HARD_REG_BIT (set, i);
|
SET_HARD_REG_BIT (set, i);
|
fprintf (stderr, "[%u %s] ", i, GET_MODE_NAME (vd->e[i].mode));
|
fprintf (stderr, "[%u %s] ", i, GET_MODE_NAME (vd->e[i].mode));
|
|
|
for (j = vd->e[i].next_regno;
|
for (j = vd->e[i].next_regno;
|
j != INVALID_REGNUM;
|
j != INVALID_REGNUM;
|
j = vd->e[j].next_regno)
|
j = vd->e[j].next_regno)
|
{
|
{
|
if (TEST_HARD_REG_BIT (set, j))
|
if (TEST_HARD_REG_BIT (set, j))
|
{
|
{
|
fprintf (stderr, "[%u] Loop in regno chain\n", j);
|
fprintf (stderr, "[%u] Loop in regno chain\n", j);
|
return;
|
return;
|
}
|
}
|
|
|
if (vd->e[j].oldest_regno != i)
|
if (vd->e[j].oldest_regno != i)
|
{
|
{
|
fprintf (stderr, "[%u] Bad oldest_regno (%u)\n",
|
fprintf (stderr, "[%u] Bad oldest_regno (%u)\n",
|
j, vd->e[j].oldest_regno);
|
j, vd->e[j].oldest_regno);
|
return;
|
return;
|
}
|
}
|
SET_HARD_REG_BIT (set, j);
|
SET_HARD_REG_BIT (set, j);
|
fprintf (stderr, "[%u %s] ", j, GET_MODE_NAME (vd->e[j].mode));
|
fprintf (stderr, "[%u %s] ", j, GET_MODE_NAME (vd->e[j].mode));
|
}
|
}
|
fputc ('\n', stderr);
|
fputc ('\n', stderr);
|
}
|
}
|
|
|
for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
|
for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
|
if (! TEST_HARD_REG_BIT (set, i)
|
if (! TEST_HARD_REG_BIT (set, i)
|
&& (vd->e[i].mode != VOIDmode
|
&& (vd->e[i].mode != VOIDmode
|
|| vd->e[i].oldest_regno != i
|
|| vd->e[i].oldest_regno != i
|
|| vd->e[i].next_regno != INVALID_REGNUM))
|
|| vd->e[i].next_regno != INVALID_REGNUM))
|
fprintf (stderr, "[%u] Non-empty reg in chain (%s %u %i)\n",
|
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,
|
i, GET_MODE_NAME (vd->e[i].mode), vd->e[i].oldest_regno,
|
vd->e[i].next_regno);
|
vd->e[i].next_regno);
|
}
|
}
|
|
|
#ifdef ENABLE_CHECKING
|
#ifdef ENABLE_CHECKING
|
static void
|
static void
|
validate_value_data (struct value_data *vd)
|
validate_value_data (struct value_data *vd)
|
{
|
{
|
HARD_REG_SET set;
|
HARD_REG_SET set;
|
unsigned int i, j;
|
unsigned int i, j;
|
|
|
CLEAR_HARD_REG_SET (set);
|
CLEAR_HARD_REG_SET (set);
|
|
|
for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
|
for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
|
if (vd->e[i].oldest_regno == i)
|
if (vd->e[i].oldest_regno == i)
|
{
|
{
|
if (vd->e[i].mode == VOIDmode)
|
if (vd->e[i].mode == VOIDmode)
|
{
|
{
|
if (vd->e[i].next_regno != INVALID_REGNUM)
|
if (vd->e[i].next_regno != INVALID_REGNUM)
|
internal_error ("validate_value_data: [%u] Bad next_regno for empty chain (%u)",
|
internal_error ("validate_value_data: [%u] Bad next_regno for empty chain (%u)",
|
i, vd->e[i].next_regno);
|
i, vd->e[i].next_regno);
|
continue;
|
continue;
|
}
|
}
|
|
|
SET_HARD_REG_BIT (set, i);
|
SET_HARD_REG_BIT (set, i);
|
|
|
for (j = vd->e[i].next_regno;
|
for (j = vd->e[i].next_regno;
|
j != INVALID_REGNUM;
|
j != INVALID_REGNUM;
|
j = vd->e[j].next_regno)
|
j = vd->e[j].next_regno)
|
{
|
{
|
if (TEST_HARD_REG_BIT (set, j))
|
if (TEST_HARD_REG_BIT (set, j))
|
internal_error ("validate_value_data: Loop in regno chain (%u)",
|
internal_error ("validate_value_data: Loop in regno chain (%u)",
|
j);
|
j);
|
if (vd->e[j].oldest_regno != i)
|
if (vd->e[j].oldest_regno != i)
|
internal_error ("validate_value_data: [%u] Bad oldest_regno (%u)",
|
internal_error ("validate_value_data: [%u] Bad oldest_regno (%u)",
|
j, vd->e[j].oldest_regno);
|
j, vd->e[j].oldest_regno);
|
|
|
SET_HARD_REG_BIT (set, j);
|
SET_HARD_REG_BIT (set, j);
|
}
|
}
|
}
|
}
|
|
|
for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
|
for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
|
if (! TEST_HARD_REG_BIT (set, i)
|
if (! TEST_HARD_REG_BIT (set, i)
|
&& (vd->e[i].mode != VOIDmode
|
&& (vd->e[i].mode != VOIDmode
|
|| vd->e[i].oldest_regno != i
|
|| vd->e[i].oldest_regno != i
|
|| vd->e[i].next_regno != INVALID_REGNUM))
|
|| vd->e[i].next_regno != INVALID_REGNUM))
|
internal_error ("validate_value_data: [%u] Non-empty reg in chain (%s %u %i)",
|
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,
|
i, GET_MODE_NAME (vd->e[i].mode), vd->e[i].oldest_regno,
|
vd->e[i].next_regno);
|
vd->e[i].next_regno);
|
}
|
}
|
#endif
|
#endif
|
|
|
static bool
|
static bool
|
gate_handle_regrename (void)
|
gate_handle_regrename (void)
|
{
|
{
|
return (optimize > 0 && (flag_rename_registers || flag_cprop_registers));
|
return (optimize > 0 && (flag_rename_registers || flag_cprop_registers));
|
}
|
}
|
|
|
|
|
/* Run the regrename and cprop passes. */
|
/* Run the regrename and cprop passes. */
|
static unsigned int
|
static unsigned int
|
rest_of_handle_regrename (void)
|
rest_of_handle_regrename (void)
|
{
|
{
|
if (flag_rename_registers)
|
if (flag_rename_registers)
|
regrename_optimize ();
|
regrename_optimize ();
|
if (flag_cprop_registers)
|
if (flag_cprop_registers)
|
copyprop_hardreg_forward ();
|
copyprop_hardreg_forward ();
|
return 0;
|
return 0;
|
}
|
}
|
|
|
struct tree_opt_pass pass_regrename =
|
struct tree_opt_pass pass_regrename =
|
{
|
{
|
"rnreg", /* name */
|
"rnreg", /* name */
|
gate_handle_regrename, /* gate */
|
gate_handle_regrename, /* gate */
|
rest_of_handle_regrename, /* execute */
|
rest_of_handle_regrename, /* execute */
|
NULL, /* sub */
|
NULL, /* sub */
|
NULL, /* next */
|
NULL, /* next */
|
0, /* static_pass_number */
|
0, /* static_pass_number */
|
TV_RENAME_REGISTERS, /* tv_id */
|
TV_RENAME_REGISTERS, /* tv_id */
|
0, /* properties_required */
|
0, /* properties_required */
|
0, /* properties_provided */
|
0, /* properties_provided */
|
0, /* properties_destroyed */
|
0, /* properties_destroyed */
|
0, /* todo_flags_start */
|
0, /* todo_flags_start */
|
TODO_dump_func, /* todo_flags_finish */
|
TODO_dump_func, /* todo_flags_finish */
|
'n' /* letter */
|
'n' /* letter */
|
};
|
};
|
|
|
|
|
