This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
Reverting part of the alias changes
- To: <gcc-patches at gcc dot gnu dot org>
- Subject: Reverting part of the alias changes
- From: Bernd Schmidt <bernds at redhat dot com>
- Date: Thu, 11 Jan 2001 16:53:38 +0000 (GMT)
I'm backing out the changes that turned REGNO into ORIGINAL_REGNO in alias.c.
This is causing problems with several test cases on e.g. the c4x and sh4
ports. I'll try to work out a solution, but for now, reverting this seems
best.
Bootstrapped on i686-linux and alphaev6-linux. I would have bootstrapped on
ia64-linux, but it's broken right now.
Bernd
* alias.c (throughout): Use REGNO, rather than ORIGINAL_REGNO.
* sched-deps.c (deps_may_trap_p): Likewise.
* basic-block.h: Remove a comment.
* flow.c (PROP_POSTRELOAD): Remove.
(update_life_info): Don't add it to prop_flags.
(mark_set_1): Lose the code that was enabled by it.
Index: alias.c
===================================================================
RCS file: /cvs/gcc/egcs/gcc/alias.c,v
retrieving revision 1.111
diff -u -p -r1.111 alias.c
--- alias.c 2001/01/03 15:00:31 1.111
+++ alias.c 2001/01/11 16:38:31
@@ -148,8 +148,8 @@ static rtx *new_reg_base_value;
static unsigned int reg_base_value_size; /* size of reg_base_value array */
#define REG_BASE_VALUE(X) \
- (ORIGINAL_REGNO (X) < reg_base_value_size \
- ? reg_base_value[ORIGINAL_REGNO (X)] : 0)
+ (REGNO (X) < reg_base_value_size \
+ ? reg_base_value[REGNO (X)] : 0)
/* Vector of known invariant relationships between registers. Set in
loop unrolling. Indexed by register number, if nonzero the value
@@ -668,7 +668,7 @@ find_base_value (src)
return src;
case REG:
- regno = ORIGINAL_REGNO (src);
+ regno = REGNO (src);
/* At the start of a function, argument registers have known base
values which may be lost later. Returning an ADDRESS
expression here allows optimization based on argument values
@@ -792,7 +792,7 @@ record_set (dest, set, data)
if (GET_CODE (dest) != REG)
return;
- regno = ORIGINAL_REGNO (dest);
+ regno = REGNO (dest);
if (regno >= reg_base_value_size)
abort ();
@@ -873,8 +873,8 @@ record_base_value (regno, val, invariant
if (GET_CODE (val) == REG)
{
- if (ORIGINAL_REGNO (val) < reg_base_value_size)
- reg_base_value[regno] = reg_base_value[ORIGINAL_REGNO (val)];
+ if (REGNO (val) < reg_base_value_size)
+ reg_base_value[regno] = reg_base_value[REGNO (val)];
return;
}
@@ -892,10 +892,10 @@ canon_rtx (x)
rtx x;
{
/* Recursively look for equivalences. */
- if (GET_CODE (x) == REG && ORIGINAL_REGNO (x) >= FIRST_PSEUDO_REGISTER
- && ORIGINAL_REGNO (x) < reg_known_value_size)
- return reg_known_value[ORIGINAL_REGNO (x)] == x
- ? x : canon_rtx (reg_known_value[ORIGINAL_REGNO (x)]);
+ if (GET_CODE (x) == REG && REGNO (x) >= FIRST_PSEUDO_REGISTER
+ && REGNO (x) < reg_known_value_size)
+ return reg_known_value[REGNO (x)] == x
+ ? x : canon_rtx (reg_known_value[REGNO (x)]);
else if (GET_CODE (x) == PLUS)
{
rtx x0 = canon_rtx (XEXP (x, 0));
@@ -2114,7 +2114,6 @@ init_alias_analysis ()
reg_base_value_size * sizeof (rtx));
memset ((char *)alias_invariant, 0, reg_base_value_size * sizeof (rtx));
}
-
/* The basic idea is that each pass through this loop will use the
"constant" information from the previous pass to propagate alias
@@ -2211,9 +2210,9 @@ init_alias_analysis ()
if (set != 0
&& GET_CODE (SET_DEST (set)) == REG
- && ORIGINAL_REGNO (SET_DEST (set)) >= FIRST_PSEUDO_REGISTER)
+ && REGNO (SET_DEST (set)) >= FIRST_PSEUDO_REGISTER)
{
- unsigned int regno = ORIGINAL_REGNO (SET_DEST (set));
+ unsigned int regno = REGNO (SET_DEST (set));
rtx src = SET_SRC (set);
if (REG_NOTES (insn) != 0
@@ -2229,13 +2228,13 @@ init_alias_analysis ()
else if (REG_N_SETS (regno) == 1
&& GET_CODE (src) == PLUS
&& GET_CODE (XEXP (src, 0)) == REG
- && ORIGINAL_REGNO (XEXP (src, 0)) >= FIRST_PSEUDO_REGISTER
- && (reg_known_value[ORIGINAL_REGNO (XEXP (src, 0))])
+ && REGNO (XEXP (src, 0)) >= FIRST_PSEUDO_REGISTER
+ && (reg_known_value[REGNO (XEXP (src, 0))])
&& GET_CODE (XEXP (src, 1)) == CONST_INT)
{
rtx op0 = XEXP (src, 0);
- if (reg_known_value[ORIGINAL_REGNO (op0)])
- op0 = reg_known_value[ORIGINAL_REGNO (op0)];
+ if (reg_known_value[REGNO (op0)])
+ op0 = reg_known_value[REGNO (op0)];
reg_known_value[regno]
= plus_constant_for_output (op0,
INTVAL (XEXP (src, 1)));
@@ -2293,7 +2292,7 @@ init_alias_analysis ()
rtx base = reg_base_value[ui];
if (base && GET_CODE (base) == REG)
{
- unsigned int base_regno = ORIGINAL_REGNO (base);
+ unsigned int base_regno = REGNO (base);
if (base_regno == ui) /* register set from itself */
reg_base_value[ui] = 0;
else
Index: basic-block.h
===================================================================
RCS file: /cvs/gcc/egcs/gcc/basic-block.h,v
retrieving revision 1.86
diff -u -p -r1.86 basic-block.h
--- basic-block.h 2001/01/11 09:13:02 1.86
+++ basic-block.h 2001/01/11 16:38:31
@@ -481,7 +481,6 @@ enum update_life_extent
#define PROP_SCAN_DEAD_CODE 16 /* Scan for dead code. */
#define PROP_AUTOINC 32 /* Create autoinc mem references. */
#define PROP_FINAL 63 /* All of the above. */
-/* Flag number 64 is used internally in flow.c. */
/* Flags for loop discovery. */
Index: flow.c
===================================================================
RCS file: /cvs/gcc/egcs/gcc/flow.c,v
retrieving revision 1.367
diff -u -p -r1.367 flow.c
--- flow.c 2001/01/11 09:13:02 1.367
+++ flow.c 2001/01/11 16:38:36
@@ -168,10 +168,6 @@ Boston, MA 02111-1307, USA. */
#define EPILOGUE_USES(REGNO) 0
#endif
-/* Not in basic-block.h, since it is private to this file. When set, it
- causes us to keep REG_N_SETS uptodate for original pseudo registers. */
-#define PROP_POSTRELOAD 64
-
/* The obstack on which the flow graph components are allocated. */
struct obstack flow_obstack;
@@ -3066,9 +3062,6 @@ update_life_info (blocks, extent, prop_f
tmp = INITIALIZE_REG_SET (tmp_head);
- if (reload_completed)
- prop_flags |= PROP_POSTRELOAD;
-
/* For a global update, we go through the relaxation process again. */
if (extent != UPDATE_LIFE_LOCAL)
{
@@ -4643,7 +4636,6 @@ mark_set_1 (pbi, code, reg, cond, insn,
rtx reg, cond, insn;
int flags;
{
- int orig_regno = -1;
int regno_first = -1, regno_last = -1;
int not_dead = 0;
int i;
@@ -4681,7 +4673,6 @@ mark_set_1 (pbi, code, reg, cond, insn,
/* Fall through. */
case REG:
- orig_regno = ORIGINAL_REGNO (reg);
regno_last = regno_first = REGNO (reg);
if (regno_first < FIRST_PSEUDO_REGISTER)
regno_last += HARD_REGNO_NREGS (regno_first, GET_MODE (reg)) - 1;
@@ -4826,7 +4817,7 @@ mark_set_1 (pbi, code, reg, cond, insn,
/* Additional data to record if this is the final pass. */
if (flags & (PROP_LOG_LINKS | PROP_REG_INFO
- | PROP_DEATH_NOTES | PROP_AUTOINC | PROP_POSTRELOAD))
+ | PROP_DEATH_NOTES | PROP_AUTOINC))
{
register rtx y;
register int blocknum = pbi->bb->index;
@@ -4840,11 +4831,6 @@ mark_set_1 (pbi, code, reg, cond, insn,
for (i = regno_first; i <= regno_last; ++i)
pbi->reg_next_use[i] = 0;
}
-
- /* After reload has completed, try to keep REG_N_SETS uptodate for
- the original pseudos. */
- if ((flags & PROP_POSTRELOAD) && orig_regno >= FIRST_PSEUDO_REGISTER)
- REG_N_SETS (orig_regno) += 1;
if (flags & PROP_REG_INFO)
{
Index: sched-deps.c
===================================================================
RCS file: /cvs/gcc/egcs/gcc/sched-deps.c,v
retrieving revision 1.6
diff -u -p -r1.6 sched-deps.c
--- sched-deps.c 2001/01/09 17:45:12 1.6
+++ sched-deps.c 2001/01/11 16:38:37
@@ -96,9 +96,9 @@ deps_may_trap_p (mem)
rtx addr = XEXP (mem, 0);
if (REG_P (addr)
- && ORIGINAL_REGNO (addr) >= FIRST_PSEUDO_REGISTER
- && reg_known_value[ORIGINAL_REGNO (addr)])
- addr = reg_known_value[ORIGINAL_REGNO (addr)];
+ && REGNO (addr) >= FIRST_PSEUDO_REGISTER
+ && reg_known_value[REGNO (addr)])
+ addr = reg_known_value[REGNO (addr)];
return rtx_addr_can_trap_p (addr);
}