procyberian/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

regrename.c (copyprop_hardreg_forward): New optimization.

Browse source 
* regrename.c (copyprop_hardreg_forward): New optimization.
        (kill_value_regno, kill_value, init_value_data, kill_clobbered_value,
        kill_set_value, kill_autoinc_value, copy_value, find_oldest_value_reg,
        replace_oldest_value_reg, replace_oldest_value_addr,
        replace_oldest_value_mem, copyprop_hardreg_forward_1,
        debug_value_data, validate_value_data): New.
        * rtl.h (copyprop_hardreg_forward): Declare.
        * toplev.c (flag_cprop_registers): New.
        (f_options): Add -fcprop-registers
        (rest_of_compilation): Invoke it.
        (parse_options_and_default_flags): Set it at -O1.
        * doc/invoke.texi: Document it.

From-SVN: r47951
This commit is contained in:
Richard Henderson 2001-12-12 14:50:05 -08:00 • committed by Richard Henderson
parent de76a39c6e
commit 8582c27b18
5 changed files with 772 additions and 3 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

15
gcc/ChangeLog
View file

@ -1,3 +1,18 @@
2001-12-12 Richard Henderson <rth@redhat.com>
* regrename.c (copyprop_hardreg_forward): New optimization.
(kill_value_regno, kill_value, init_value_data, kill_clobbered_value,
kill_set_value, kill_autoinc_value, copy_value, find_oldest_value_reg,
replace_oldest_value_reg, replace_oldest_value_addr,
replace_oldest_value_mem, copyprop_hardreg_forward_1,
debug_value_data, validate_value_data): New.
* rtl.h (copyprop_hardreg_forward): Declare.
* toplev.c (flag_cprop_registers): New.
(f_options): Add -fcprop-registers
(rest_of_compilation): Invoke it.
(parse_options_and_default_flags): Set it at -O1.
* doc/invoke.texi: Document it.
2001-12-12 Jakub Jelinek <jakub@redhat.com>
* dwarf2out.c (dw_val_class): Add dw_val_class_range_list.

8
gcc/doc/invoke.texi
View file

@ -259,7 +259,7 @@ in the following sections.
@gccoptlist{
-falign-functions=@var{n} -falign-jumps=@var{n} @gol
-falign-labels=@var{n} -falign-loops=@var{n} @gol
-fbranch-probabilities -fcaller-saves @gol
-fbranch-probabilities -fcaller-saves -fcprop-registers @gol
-fcse-follow-jumps -fcse-skip-blocks -fdata-sections @gol
-fdelayed-branch -fdelete-null-pointer-checks @gol
-fexpensive-optimizations -ffast-math -ffloat-store @gol
@ -3774,6 +3774,12 @@ will most benefit processors with lots of registers. It can, however,
make debugging impossible, since variables will no longer stay in
a ``home register''.
@item -fno-cprop-registers
@opindex fno-cprop-registers
After register allocation and post-register allocation instruction splitting,
we perform a copy-propagation pass to try to reduce scheduling dependencies
and occasionally eliminate the copy.
@item --param @var{name}=@var{value}
@opindex param
In some places, GCC uses various constants to control the amount of

740
gcc/regrename.c
View file

@ -33,6 +33,7 @@
#include "function.h"
#include "recog.h"
#include "flags.h"
#include "toplev.h"
#include "obstack.h"
#define obstack_chunk_alloc xmalloc
@ -960,3 +961,742 @@ dump_def_use_chain (chains)
chains = chains->next_chain;
}
}
/* The following code does forward propagation of hard register copies.
The object is to eliminate as many dependencies as possible, so that
we have the most scheduling freedom. As a side effect, we also clean
up some silly register allocation decisions made by reload. This
code may be obsoleted by a new register allocator. */
/* For each register, we have a list of registers that contain the same
value. The OLDEST_REGNO field points to the head of the list, and
the NEXT_REGNO field runs through the list. The MODE field indicates
what mode the data is known to be in; this field is VOIDmode when the
register is not known to contain valid data. */
struct value_data_entry
{
enum machine_mode mode;
unsigned int oldest_regno;
unsigned int next_regno;
};
struct value_data
{
struct value_data_entry e[FIRST_PSEUDO_REGISTER];
};
static void kill_value_regno PARAMS ((unsigned, struct value_data *));
static void kill_value PARAMS ((rtx, struct value_data *));
static void init_value_data PARAMS ((struct value_data *));
static void kill_clobbered_value PARAMS ((rtx, rtx, void *));
static void kill_set_value PARAMS ((rtx, rtx, void *));
static int kill_autoinc_value PARAMS ((rtx *, void *));
static void copy_value PARAMS ((rtx, rtx, struct value_data *));
static rtx find_oldest_value_reg PARAMS ((enum reg_class, unsigned int,
enum machine_mode,
struct value_data *));
static bool replace_oldest_value_reg PARAMS ((rtx *, enum reg_class, rtx,
struct value_data *));
static bool replace_oldest_value_addr PARAMS ((rtx *, enum reg_class,
enum machine_mode, rtx,
struct value_data *));
static bool replace_oldest_value_mem PARAMS ((rtx, rtx, struct value_data *));
static bool copyprop_hardreg_forward_1 PARAMS ((basic_block,
struct value_data *));
extern void debug_value_data PARAMS ((struct value_data *));
#ifdef ENABLE_CHECKING
static void validate_value_data PARAMS ((struct value_data *));
#endif
/* Kill register REGNO. This involves removing it from any value lists,
and resetting the value mode to VOIDmode. */
static void
kill_value_regno (regno, vd)
unsigned int regno;
struct value_data *vd;
{
unsigned int i, next;
if (vd->e[regno].oldest_regno != regno)
{
for (i = vd->e[regno].oldest_regno;
vd->e[i].next_regno != regno;
i = vd->e[i].next_regno)
continue;
next = vd->e[regno].next_regno;
while (1)
{
vd->e[i].next_regno = next;
if (next == INVALID_REGNUM)
break;
i = next;
next = vd->e[next].next_regno;
}
}
else if ((next = vd->e[regno].next_regno) != INVALID_REGNUM)
{
for (i = next; i != INVALID_REGNUM; i = vd->e[i].next_regno)
vd->e[i].oldest_regno = next;
}
vd->e[regno].mode = VOIDmode;
vd->e[regno].oldest_regno = regno;
vd->e[regno].next_regno = INVALID_REGNUM;
#ifdef ENABLE_CHECKING
validate_value_data (vd);
#endif
}
/* Kill X. This is a convenience function for kill_value_regno
so that we don't have to check that X is a register first. */
static void
kill_value (x, vd)
rtx x;
struct value_data *vd;
{
if (REG_P (x))
kill_value_regno (REGNO (x), vd);
}
/* Initialize VD such that there are no known relationships between regs. */
static void
init_value_data (vd)
struct value_data *vd;
{
int i;
for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
{
vd->e[i].mode = VOIDmode;
vd->e[i].oldest_regno = i;
vd->e[i].next_regno = INVALID_REGNUM;
}
}
/* Called through note_stores. If X is clobbered, kill its value. */
static void
kill_clobbered_value (x, set, data)
rtx x;
rtx set;
void *data;
{
struct value_data *vd = data;
if (GET_CODE (set) == CLOBBER)
kill_value (x, vd);
}
/* Called through note_stores. If X is set, not clobbered, kill its
current value and install it as the root of its own value list. */
static void
kill_set_value (x, set, data)
rtx x;
rtx set;
void *data;
{
struct value_data *vd = data;
if (GET_CODE (set) != CLOBBER && REG_P (x))
{
unsigned int regno = REGNO (x);
kill_value_regno (regno, vd);
vd->e[regno].mode = GET_MODE (x);
}
}
/* Called through for_each_rtx. Kill any register used as the base of an
auto-increment expression, and install that register as the root of its
own value list. */
static int
kill_autoinc_value (px, data)
rtx *px;
void *data;
{
rtx x = *px;
struct value_data *vd = data;
if (GET_RTX_CLASS (GET_CODE (x)) == 'a')
{
unsigned int regno = REGNO (XEXP (x, 0));
kill_value_regno (regno, vd);
vd->e[regno].mode = Pmode;
return -1;
}
return 0;
}
/* Assert that SRC has been copied to DEST. Adjust the data structures
to reflect that SRC contains an older copy of the shared value. */
static void
copy_value (dest, src, vd)
rtx dest;
rtx src;
struct value_data *vd;
{
unsigned int dr = REGNO (dest);
unsigned int sr = REGNO (src);
unsigned int i;
/* ??? At present, it's possible to see noop sets. It'd be nice if
this were cleaned up beforehand... */
if (sr == dr)
return;
/* Do not propagate copies to the stack pointer, as that can leave
memory accesses with no scheduling dependancy on the stack update. */
if (dr == STACK_POINTER_REGNUM)
return;
/* Likewise with the frame pointer, if we're using one. */
if (frame_pointer_needed && dr == HARD_FRAME_POINTER_REGNUM)
return;
/* If SRC had no assigned mode (i.e. we didn't know it was live)
assign it now and assume the value came from an input argument
or somesuch. */
if (vd->e[sr].mode == VOIDmode)
vd->e[sr].mode = vd->e[dr].mode;
/* Link DR at the end of the value chain used by SR. */
vd->e[dr].oldest_regno = vd->e[sr].oldest_regno;
for (i = sr; vd->e[i].next_regno != INVALID_REGNUM; i = vd->e[i].next_regno)
continue;
vd->e[i].next_regno = dr;
#ifdef ENABLE_CHECKING
validate_value_data (vd);
#endif
}
/* Find the oldest copy of the value contained in REGNO that is in
register class CLASS and has mode MODE. If found, return an rtx
of that oldest register, otherwise return NULL. */
static rtx
find_oldest_value_reg (class, regno, mode, vd)
enum reg_class class;
unsigned int regno;
enum machine_mode mode;
struct value_data *vd;
{
unsigned int i;
for (i = vd->e[regno].oldest_regno; i != regno; i = vd->e[i].next_regno)
if (vd->e[i].mode == mode
&& TEST_HARD_REG_BIT (reg_class_contents[class], i))
return gen_rtx_REG (mode, i);
return NULL_RTX;
}
/* If possible, replace the register at *LOC with the oldest register
in register class CLASS. Return true if successfully replaced. */
static bool
replace_oldest_value_reg (loc, class, insn, vd)
rtx *loc;
enum reg_class class;
rtx insn;
struct value_data *vd;
{
rtx new = find_oldest_value_reg (class, REGNO (*loc), GET_MODE (*loc), vd);
if (new)
{
if (rtl_dump_file)
fprintf (rtl_dump_file, "insn %u: replaced reg %u with %u\n",
INSN_UID (insn), REGNO (*loc), REGNO (new));
*loc = new;
return true;
}
return false;
}
/* Similar to replace_oldest_value_reg, but *LOC contains an address.
Adapted from find_reloads_address_1. CLASS is INDEX_REG_CLASS or
BASE_REG_CLASS depending on how the register is being considered. */
static bool
replace_oldest_value_addr (loc, class, mode, insn, vd)
rtx *loc;
enum reg_class class;
enum machine_mode mode;
rtx insn;
struct value_data *vd;
{
rtx x = *loc;
RTX_CODE code = GET_CODE (x);
const char *fmt;
int i, j;
bool changed = false;
switch (code)
{
case PLUS:
{
rtx orig_op0 = XEXP (x, 0);
rtx orig_op1 = XEXP (x, 1);
RTX_CODE code0 = GET_CODE (orig_op0);
RTX_CODE code1 = GET_CODE (orig_op1);
rtx op0 = orig_op0;
rtx op1 = orig_op1;
rtx *locI = NULL;
rtx *locB = NULL;
if (GET_CODE (op0) == SUBREG)
{
op0 = SUBREG_REG (op0);
code0 = GET_CODE (op0);
}
if (GET_CODE (op1) == SUBREG)
{
op1 = SUBREG_REG (op1);
code1 = GET_CODE (op1);
}
if (code0 == MULT || code0 == SIGN_EXTEND || code0 == TRUNCATE
|| code0 == ZERO_EXTEND || code1 == MEM)
{
locI = &XEXP (x, 0);
locB = &XEXP (x, 1);
}
else if (code1 == MULT || code1 == SIGN_EXTEND || code1 == TRUNCATE
|| code1 == ZERO_EXTEND || code0 == MEM)
{
locI = &XEXP (x, 1);
locB = &XEXP (x, 0);
}
else if (code0 == CONST_INT || code0 == CONST
|| code0 == SYMBOL_REF || code0 == LABEL_REF)
locB = &XEXP (x, 1);
else if (code1 == CONST_INT || code1 == CONST
|| code1 == SYMBOL_REF || code1 == LABEL_REF)
locB = &XEXP (x, 0);
else if (code0 == REG && code1 == REG)
{
int index_op;
if (REG_OK_FOR_INDEX_P (op0)
&& REG_MODE_OK_FOR_BASE_P (op1, mode))
index_op = 0;
else if (REG_OK_FOR_INDEX_P (op1)
&& REG_MODE_OK_FOR_BASE_P (op0, mode))
index_op = 1;
else if (REG_MODE_OK_FOR_BASE_P (op1, mode))
index_op = 0;
else if (REG_MODE_OK_FOR_BASE_P (op0, mode))
index_op = 1;
else if (REG_OK_FOR_INDEX_P (op1))
index_op = 1;
else
index_op = 0;
locI = &XEXP (x, index_op);
locB = &XEXP (x, !index_op);
}
else if (code0 == REG)
{
locI = &XEXP (x, 0);
locB = &XEXP (x, 1);
}
else if (code1 == REG)
{
locI = &XEXP (x, 1);
locB = &XEXP (x, 0);
}
if (locI)
changed |= replace_oldest_value_addr (locI, INDEX_REG_CLASS, mode,
insn, vd);
if (locB)
changed |= replace_oldest_value_addr (locB, BASE_REG_CLASS, mode,
insn, vd);
return changed;
}
case POST_INC:
case POST_DEC:
case POST_MODIFY:
case PRE_INC:
case PRE_DEC:
case PRE_MODIFY:
return false;
case MEM:
return replace_oldest_value_mem (x, insn, vd);
case REG:
return replace_oldest_value_reg (loc, class, insn, vd);
default:
break;
}
fmt = GET_RTX_FORMAT (code);
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
{
if (fmt[i] == 'e')
changed |= replace_oldest_value_addr (&XEXP (x, i), class, mode,
insn, vd);
else if (fmt[i] == 'E')
for (j = XVECLEN (x, i) - 1; j >= 0; j--)
changed |= replace_oldest_value_addr (&XVECEXP (x, i, j), class,
mode, insn, vd);
}
return changed;
}
/* Similar to replace_oldest_value_reg, but X contains a memory. */
static bool
replace_oldest_value_mem (x, insn, vd)
rtx x;
rtx insn;
struct value_data *vd;
{
return replace_oldest_value_addr (&XEXP (x, 0), BASE_REG_CLASS,
GET_MODE (x), insn, vd);
}
/* Perform the forward copy propagation on basic block BB. */
static bool
copyprop_hardreg_forward_1 (bb, vd)
basic_block bb;
struct value_data *vd;
{
bool changed = false;
rtx insn;
for (insn = bb->head; ; insn = NEXT_INSN (insn))
{
int n_ops, i, alt, predicated;
rtx set;
if (! INSN_P (insn))
{
if (insn == bb->end)
break;
else
continue;
}
set = single_set (insn);
extract_insn (insn);
constrain_operands (1);
preprocess_constraints ();
alt = which_alternative;
n_ops = recog_data.n_operands;
/* Simplify the code below by rewriting things to reflect
matching constraints. Also promote OP_OUT to OP_INOUT
in predicated instructions. */
predicated = GET_CODE (PATTERN (insn)) == COND_EXEC;
for (i = 0; i < n_ops; ++i)
{
int matches = recog_op_alt[i][alt].matches;
if (matches >= 0)
recog_op_alt[i][alt].class = recog_op_alt[matches][alt].class;
if (matches >= 0 || recog_op_alt[i][alt].matched >= 0
|| (predicated && recog_data.operand_type[i] == OP_OUT))
recog_data.operand_type[i] = OP_INOUT;
}
/* For each earlyclobber operand, zap the value data. */
for (i = 0; i < n_ops; i++)
if (recog_op_alt[i][alt].earlyclobber)
kill_value (recog_data.operand[i], vd);
/* Within asms, a clobber cannot overlap inputs or outputs.
I wouldn't think this were true for regular insns, but
scan_rtx treats them like that... */
note_stores (PATTERN (insn), kill_clobbered_value, vd);
/* Kill all auto-incremented values. */
/* ??? REG_INC is useless, since stack pushes aren't done that way. */
for_each_rtx (&PATTERN (insn), kill_autoinc_value, vd);
/* Special-case plain move instructions, since we may well
be able to do the move from a different register class. */
if (set && REG_P (SET_SRC (set)))
{
unsigned int regno = REGNO (SET_SRC (set));
enum machine_mode mode = GET_MODE (SET_SRC (set));
unsigned int i;
rtx new;
/* If the destination is also a register, try to find a source
register in the same class. */
if (REG_P (SET_DEST (set)))
{
new = find_oldest_value_reg (REGNO_REG_CLASS (regno),
regno, mode, vd);
if (new && validate_change (insn, &SET_SRC (set), new, 0))
{
if (rtl_dump_file)
fprintf (rtl_dump_file,
"insn %u: replaced reg %u with %u\n",
INSN_UID (insn), regno, REGNO (new));
changed = true;
goto did_replacement;
}
}
/* Otherwise, try all valid registers and see if its valid. */
for (i = vd->e[regno].oldest_regno; i != regno;
i = vd->e[i].next_regno)
if (mode == vd->e[regno].mode)
{
new = gen_rtx_REG (mode, i);
if (validate_change (insn, &SET_SRC (set), new, 0))
{
if (rtl_dump_file)
fprintf (rtl_dump_file,
"insn %u: replaced reg %u with %u\n",
INSN_UID (insn), regno, REGNO (new));
changed = true;
goto did_replacement;
}
}
}
/* For each input operand, replace a hard register with the
eldest live copy that's in an appropriate register class. */
for (i = 0; i < n_ops; i++)
{
bool replaced = false;
/* Don't scan match_operand here, since we've no reg class
information to pass down. Any operands that we could
substitute in will be represented elsewhere. */
if (recog_data.constraints[i][0] == '\0')
continue;
if (recog_data.operand_type[i] == OP_IN)
{
if (recog_op_alt[i][alt].is_address)
replaced
= replace_oldest_value_addr (recog_data.operand_loc[i],
recog_op_alt[i][alt].class,
VOIDmode, insn, vd);
else if (REG_P (recog_data.operand[i]))
replaced
= replace_oldest_value_reg (recog_data.operand_loc[i],
recog_op_alt[i][alt].class,
insn, vd);
else if (GET_CODE (recog_data.operand[i]) == MEM)
replaced = replace_oldest_value_mem (recog_data.operand[i],
insn, vd);
}
else if (GET_CODE (recog_data.operand[i]) == MEM)
replaced = replace_oldest_value_mem (recog_data.operand[i],
insn, vd);
/* If we performed any replacement, update match_dups. */
if (replaced)
{
int j;
rtx new;
changed = true;
new = *recog_data.operand_loc[i];
recog_data.operand[i] = new;
for (j = 0; j < recog_data.n_dups; j++)
if (recog_data.dup_num[j] == i)
*recog_data.dup_loc[j] = new;
}
}
did_replacement:
/* Clobber call-clobbered registers. */
if (GET_CODE (insn) == CALL_INSN)
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
if (TEST_HARD_REG_BIT (regs_invalidated_by_call, i))
kill_value_regno (i, vd);
/* Notice stores. */
note_stores (PATTERN (insn), kill_set_value, vd);
/* Notice copies. */
if (set && REG_P (SET_DEST (set)) && REG_P (SET_SRC (set)))
copy_value (SET_DEST (set), SET_SRC (set), vd);
if (insn == bb->end)
break;
}
return changed;
}
/* Main entry point for the forward copy propagation optimization. */
void
copyprop_hardreg_forward ()
{
int b, need_refresh;
sbitmap refresh_blocks;
struct value_data *all_vd;
refresh_blocks = sbitmap_alloc (n_basic_blocks);
sbitmap_zero (refresh_blocks);
need_refresh = 0;
all_vd = xmalloc (sizeof (struct value_data) * n_basic_blocks);
for (b = 0; b < n_basic_blocks; b++)
{
basic_block bb = BASIC_BLOCK (b);
/* If a block has a single predecessor, that we've already
processed, begin with the value data that was live at
the end of the predecessor block. */
/* ??? Ought to use more intelligent queueing of blocks. */
if (bb->pred
&& ! bb->pred->pred_next
&& bb->pred->src->index != ENTRY_BLOCK
&& bb->pred->src->index < b)
all_vd[b] = all_vd[bb->pred->src->index];
else
init_value_data (all_vd + b);
if (copyprop_hardreg_forward_1 (bb, all_vd + b))
{
SET_BIT (refresh_blocks, b);
need_refresh = 1;
}
}
if (need_refresh)
{
if (rtl_dump_file)
fputs ("\n\n", rtl_dump_file);
update_life_info (refresh_blocks, UPDATE_LIFE_GLOBAL_RM_NOTES,
PROP_DEATH_NOTES
| PROP_SCAN_DEAD_CODE
| PROP_KILL_DEAD_CODE);
}
sbitmap_free (refresh_blocks);
free (all_vd);
}
/* Dump the value chain data to stderr. */
void
debug_value_data (vd)
struct value_data *vd;
{
HARD_REG_SET set;
unsigned int i, j;
CLEAR_HARD_REG_SET (set);
for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
if (vd->e[i].oldest_regno == i)
{
if (vd->e[i].mode == VOIDmode)
{
if (vd->e[i].next_regno != INVALID_REGNUM)
fprintf (stderr, "[%u] Bad next_regno for empty chain (%u)\n",
i, vd->e[i].next_regno);
continue;
}
SET_HARD_REG_BIT (set, i);
fprintf (stderr, "[%u %s] ", i, GET_MODE_NAME (vd->e[i].mode));
for (j = vd->e[i].next_regno;
j != INVALID_REGNUM;
j = vd->e[j].next_regno)
{
if (TEST_HARD_REG_BIT (set, vd->e[j].next_regno))
{
fprintf (stderr, "[%u] Loop in regno chain\n", j);
return;
}
if (vd->e[j].oldest_regno != i)
{
fprintf (stderr, "[%u] Bad oldest_regno (%u)\n",
j, vd->e[j].oldest_regno);
return;
}
SET_HARD_REG_BIT (set, j);
fprintf (stderr, "[%u %s] ", j, GET_MODE_NAME (vd->e[j].mode));
}
fputc ('\n', stderr);
}
for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
if (! TEST_HARD_REG_BIT (set, i)
&& (vd->e[i].mode != VOIDmode
|| vd->e[i].oldest_regno != i
|| vd->e[i].next_regno != INVALID_REGNUM))
fprintf (stderr, "[%u] Non-empty reg in chain (%s %u %i)\n",
i, GET_MODE_NAME (vd->e[i].mode), vd->e[i].oldest_regno,
vd->e[i].next_regno);
}
#ifdef ENABLE_CHECKING
static void
validate_value_data (vd)
struct value_data *vd;
{
HARD_REG_SET set;
unsigned int i, j;
CLEAR_HARD_REG_SET (set);
for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
if (vd->e[i].oldest_regno == i)
{
if (vd->e[i].mode == VOIDmode)
{
if (vd->e[i].next_regno != INVALID_REGNUM)
internal_error ("validate_value_data: [%u] Bad next_regno for empty chain (%u)",
i, vd->e[i].next_regno);
continue;
}
SET_HARD_REG_BIT (set, i);
for (j = vd->e[i].next_regno;
j != INVALID_REGNUM;
j = vd->e[j].next_regno)
{
if (TEST_HARD_REG_BIT (set, j))
internal_error ("validate_value_data: Loop in regno chain (%u)",
j);
if (vd->e[j].oldest_regno != i)
internal_error ("validate_value_data: [%u] Bad oldest_regno (%u)",
j, vd->e[j].oldest_regno);
SET_HARD_REG_BIT (set, j);
}
}
for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
if (! TEST_HARD_REG_BIT (set, i)
&& (vd->e[i].mode != VOIDmode
|| vd->e[i].oldest_regno != i
|| vd->e[i].next_regno != INVALID_REGNUM))
internal_error ("validate_value_data: [%u] Non-empty reg in chain (%s %u %i)",
i, GET_MODE_NAME (vd->e[i].mode), vd->e[i].oldest_regno,
vd->e[i].next_regno);
}
#endif

1
gcc/rtl.h
View file

@ -2097,6 +2097,7 @@ extern rtx stack_limit_rtx;
/* In regrename.c */
extern void regrename_optimize PARAMS ((void));
extern void copyprop_hardreg_forward PARAMS ((void));
/* In ifcvt.c */
extern void if_convert PARAMS ((int));

11
gcc/toplev.c
View file

@ -427,6 +427,7 @@ int flag_reorder_blocks = 0;
/* Nonzero if registers should be renamed. */
int flag_rename_registers = 0;
int flag_cprop_registers = 0;
/* Nonzero for -pedantic switch: warn about anything
that standard spec forbids. */
@ -1083,6 +1084,8 @@ lang_independent_options f_options[] =
N_("Reorder basic blocks to improve code placement") },
{"rename-registers", &flag_rename_registers, 1,
N_("Do the register renaming optimization pass") },
{"cprop-registers", &flag_cprop_registers, 1,
N_("Do the register copy-propagation optimization pass") },
{"common", &flag_no_common, 0,
N_("Do not put uninitialized globals in the common section") },
{"inhibit-size-directive", &flag_inhibit_size_directive, 1,
@ -3280,12 +3283,15 @@ rest_of_compilation (decl)
}
#endif
if (optimize > 0 && flag_rename_registers)
if (flag_rename_registers || flag_cprop_registers)
{
timevar_push (TV_RENAME_REGISTERS);
open_dump_file (DFI_rnreg, decl);
regrename_optimize ();
if (flag_rename_registers)
regrename_optimize ();
if (flag_cprop_registers)
copyprop_hardreg_forward ();
close_dump_file (DFI_rnreg, print_rtl_with_bb, insns);
timevar_pop (TV_RENAME_REGISTERS);
@ -4620,6 +4626,7 @@ parse_options_and_default_flags (argc, argv)
flag_omit_frame_pointer = 1;
#endif
flag_guess_branch_prob = 1;
flag_cprop_registers = 1;
}
if (optimize >= 2)