mirror/gcc
2
0
Fork 0
mirror of git://gcc.gnu.org/git/gcc.git synced 2025-03-19 03:20:28 +08:00
Code Issues Packages Projects Releases Wiki Activity

alias.c (reg_base_value, [...]): Change the type to VEC(rtx,gc) *.

Browse Source 
* alias.c (reg_base_value, old_reg_base_value): Change the
	type to VEC(rtx,gc) *.
	(REG_BASE_VALUE, find_base_value, record_set,
	init_alias_analysis): Use VEC instead of VARRAY.

From-SVN: r113004
This commit is contained in:
Kazu Hirata 2006-04-17 12:40:57 +00:00 committed by Kazu Hirata
parent 726ac11ebd
commit 08c796829c
2 changed files with 32 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
gcc/ChangeLog
View File

@ -1,3 +1,10 @@
2006-04-16 Kazu Hirata <kazu@codesourcery.com>
* alias.c (reg_base_value, old_reg_base_value): Change the
type to VEC(rtx,gc) *.
(REG_BASE_VALUE, find_base_value, record_set,
init_alias_analysis): Use VEC instead of VARRAY.
2006-04-16 Roger Sayle <roger@eyesopen.com>
PR target/26961

58
gcc/alias.c
View File

@ -206,21 +206,21 @@ static void record_alias_subset (HOST_WIDE_INT, HOST_WIDE_INT);
current function performs nonlocal memory memory references for the
purposes of marking the function as a constant function. */
static GTY(()) varray_type reg_base_value;
static GTY(()) VEC(rtx,gc) *reg_base_value;
static rtx *new_reg_base_value;
/* We preserve the copy of old array around to avoid amount of garbage
produced. About 8% of garbage produced were attributed to this
array. */
static GTY((deletable)) varray_type old_reg_base_value;
static GTY((deletable)) VEC(rtx,gc) *old_reg_base_value;
/* Static hunks of RTL used by the aliasing code; these are initialized
once per function to avoid unnecessary RTL allocations. */
static GTY (()) rtx static_reg_base_value[FIRST_PSEUDO_REGISTER];
#define REG_BASE_VALUE(X) \
(reg_base_value && REGNO (X) < VARRAY_SIZE (reg_base_value) \
? VARRAY_RTX (reg_base_value, REGNO (X)) : 0)
#define REG_BASE_VALUE(X) \
(REGNO (X) < VEC_length (rtx, reg_base_value) \
? VEC_index (rtx, reg_base_value, REGNO (X)) : 0)
/* Vector indexed by N giving the initial (unchanging) value known for
pseudo-register N. This array is initialized in init_alias_analysis,
@ -815,7 +815,7 @@ find_base_value (rtx src)
The test above is not sufficient because the scheduler may move
a copy out of an arg reg past the NOTE_INSN_FUNCTION_BEGIN. */
if ((regno >= FIRST_PSEUDO_REGISTER || fixed_regs[regno])
&& regno < VARRAY_SIZE (reg_base_value))
&& regno < VEC_length (rtx, reg_base_value))
{
/* If we're inside init_alias_analysis, use new_reg_base_value
to reduce the number of relaxation iterations. */
@ -823,8 +823,8 @@ find_base_value (rtx src)
&& REG_N_SETS (regno) == 1)
return new_reg_base_value[regno];
if (VARRAY_RTX (reg_base_value, regno))
return VARRAY_RTX (reg_base_value, regno);
if (VEC_index (rtx, reg_base_value, regno))
return VEC_index (rtx, reg_base_value, regno);
}
return 0;
@ -968,7 +968,7 @@ record_set (rtx dest, rtx set, void *data ATTRIBUTE_UNUSED)
regno = REGNO (dest);
gcc_assert (regno < VARRAY_SIZE (reg_base_value));
gcc_assert (regno < VEC_length (rtx, reg_base_value));
/* If this spans multiple hard registers, then we must indicate that every
register has an unusable value. */
@ -2424,24 +2424,16 @@ init_alias_analysis (void)
reg_known_value = ggc_calloc (reg_known_value_size, sizeof (rtx));
reg_known_equiv_p = xcalloc (reg_known_value_size, sizeof (bool));
/* Overallocate reg_base_value to allow some growth during loop
optimization. Loop unrolling can create a large number of
registers. */
/* If we have memory allocated from the previous run, use it. */
if (old_reg_base_value)
{
reg_base_value = old_reg_base_value;
/* If varray gets large zeroing cost may get important. */
if (VARRAY_SIZE (reg_base_value) > 256
&& VARRAY_SIZE (reg_base_value) > 4 * maxreg)
VARRAY_GROW (reg_base_value, maxreg);
VARRAY_CLEAR (reg_base_value);
if (VARRAY_SIZE (reg_base_value) < maxreg)
VARRAY_GROW (reg_base_value, maxreg);
}
else
{
VARRAY_RTX_INIT (reg_base_value, maxreg, "reg_base_value");
}
reg_base_value = old_reg_base_value;
if (reg_base_value)
VEC_truncate (rtx, reg_base_value, 0);
VEC_safe_grow (rtx, gc, reg_base_value, maxreg);
memset (VEC_address (rtx, reg_base_value), 0,
sizeof (rtx) * VEC_length (rtx, reg_base_value));
new_reg_base_value = XNEWVEC (rtx, maxreg);
reg_seen = XNEWVEC (char, maxreg);
@ -2576,11 +2568,11 @@ init_alias_analysis (void)
for (ui = 0; ui < maxreg; ui++)
{
if (new_reg_base_value[ui]
&& new_reg_base_value[ui] != VARRAY_RTX (reg_base_value, ui)
&& new_reg_base_value[ui] != VEC_index (rtx, reg_base_value, ui)
&& ! rtx_equal_p (new_reg_base_value[ui],
VARRAY_RTX (reg_base_value, ui)))
VEC_index (rtx, reg_base_value, ui)))
{
VARRAY_RTX (reg_base_value, ui) = new_reg_base_value[ui];
VEC_replace (rtx, reg_base_value, ui, new_reg_base_value[ui]);
changed = 1;
}
}
@ -2609,15 +2601,15 @@ init_alias_analysis (void)
pass++;
for (ui = 0; ui < maxreg; ui++)
{
rtx base = VARRAY_RTX (reg_base_value, ui);
rtx base = VEC_index (rtx, reg_base_value, ui);
if (base && REG_P (base))
{
unsigned int base_regno = REGNO (base);
if (base_regno == ui) /* register set from itself */
VARRAY_RTX (reg_base_value, ui) = 0;
VEC_replace (rtx, reg_base_value, ui, 0);
else
VARRAY_RTX (reg_base_value, ui)
= VARRAY_RTX (reg_base_value, base_regno);
VEC_replace (rtx, reg_base_value, ui,
VEC_index (rtx, reg_base_value, base_regno));
changed = 1;
}
}