This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
[PATCH] More REG_EQ* notes cleanups
- From: Steven Bosscher <stevenb dot gcc at gmail dot com>
- To: gcc-patches at gcc dot gnu dot org
- Cc: zadeck at naturalbridge dot com, "Sayle, Roger" <roger at eyesopen dot com>
- Date: Sun, 11 Feb 2007 14:43:33 +0100
- Subject: [PATCH] More REG_EQ* notes cleanups
Hi,
This patch makes us use set_unique_reg_note in more places in gcc/*.
Also makes us use find_reg_equal_equiv_note in alias.c, instead of
going through REG_NOTES to find one ourselves.
The patch is mostly mechanical, but there is one interesting change
to local-alloc.c. We used to turn REG_EQUAL notes into REG_EQUIV
notes if the note datum was invariant. But this is wrong if there
is more than one set to the register that the REG_EQUAL note applies
to. We later on check whether a reg with a REG_EQUIV note has more
than one set, and if it does, we remove the REG_EQUIV note. So what
we end up doing is basically throwing away a REG_EQUAL note. Roger
Sayle pointed this out some time ago on IRC, and I thought I might
as well fix this while I'm working on that code.
Bootstrapped and tested all languages except java (but including ada)
on {i686,x86_64}-unknown-linux-gnu.
OK for the trunk?
Gr.
Steven
* fwprop.c (try_fwprop_subst): Use set_unique_reg_note
to add the REG_EQ* note.
* see.c (see_merge_one_use_extension): Likewise.
* local-alloc.c (update_equiv_regs): Likewise. Also don't
turn REG_EQUAL notes into REG_EQUIV notes if the target
register may have more than one set.
* function.c (assign_parm_setup_reg): Use set_unique_reg_note.
* gcse.c (try_replace_reg): Likewise.
* alias.c (init_alias_analysis): Use find_reg_equal_equiv_note.
* calls.c (fixup_tail_calls): Likewise. Abort if there is
more than one REG_EQUIV note.
* reload1.c (gen_reload): Use set_unique_reg_note.
Index: fwprop.c
===================================================================
--- fwprop.c (revision 121794)
+++ fwprop.c (working copy)
@@ -691,9 +691,10 @@ try_fwprop_subst (struct df_ref *use, rt
if (dump_file)
fprintf (dump_file, " Setting REG_EQUAL note\n");
- REG_NOTES (insn) = gen_rtx_EXPR_LIST (REG_EQUAL, copy_rtx (new),
- REG_NOTES (insn));
+ set_unique_reg_note (insn, REG_EQUAL, copy_rtx (new));
+ /* ??? Is this still necessary if we add the note through
+ set_unique_reg_note? */
if (!CONSTANT_P (new))
update_df (insn, loc, DF_INSN_USES (df, def_insn),
type, DF_REF_IN_NOTE);
Index: see.c
===================================================================
--- see.c (revision 121794)
+++ see.c (working copy)
@@ -2612,7 +2612,8 @@ see_merge_one_use_extension (void **slot
/* Replacement failed. Remove the note. */
remove_note (ref_copy, note);
else
- XEXP (note, 0) = simplified_note;
+ set_unique_reg_note (ref_copy, REG_NOTE_KIND (note),
+ simplified_note);
}
if (!see_want_to_be_merged_with_extension (ref, use_se, USE_EXTENSION))
Index: local-alloc.c
===================================================================
--- local-alloc.c (revision 121794)
+++ local-alloc.c (working copy)
@@ -930,8 +930,13 @@ update_equiv_regs (void)
/* If this register is known to be equal to a constant, record that
it is always equivalent to the constant. */
- if (note && ! rtx_varies_p (XEXP (note, 0), 0))
- PUT_MODE (note, (enum machine_mode) REG_EQUIV);
+ if (REG_N_SETS (regno) == 1
+ && note && ! rtx_varies_p (XEXP (note, 0), 0))
+ {
+ rtx note_value = XEXP (note, 0);
+ remove_note (insn, note);
+ set_unique_reg_note (insn, REG_EQUIV, note_value);
+ }
/* If this insn introduces a "constant" register, decrease the priority
of that register. Record this insn if the register is only used once
@@ -953,9 +958,7 @@ update_equiv_regs (void)
if (note == 0 && REG_BASIC_BLOCK (regno) >= 0
&& MEM_P (SET_SRC (set))
&& validate_equiv_mem (insn, dest, SET_SRC (set)))
- REG_NOTES (insn) = note = gen_rtx_EXPR_LIST (REG_EQUIV,
- copy_rtx (SET_SRC (set)),
- REG_NOTES (insn));
+ note = set_unique_reg_note (insn, REG_EQUIV, copy_rtx (SET_SRC (set)));
if (note)
{
@@ -1061,9 +1064,8 @@ update_equiv_regs (void)
if (validate_equiv_mem (init_insn, src, dest)
&& ! memref_used_between_p (dest, init_insn, insn))
{
- REG_NOTES (init_insn)
- = gen_rtx_EXPR_LIST (REG_EQUIV, copy_rtx (dest),
- REG_NOTES (init_insn));
+ set_unique_reg_note (init_insn, REG_EQUIV, copy_rtx (dest));
+
/* This insn makes the equivalence, not the one initializing
the register. */
reg_equiv_init[regno]
Index: function.c
===================================================================
--- function.c (revision 121794)
+++ function.c (working copy)
@@ -2800,20 +2800,14 @@ assign_parm_setup_reg (struct assign_par
continue;
if (SET_DEST (set) == regno_reg_rtx [regnoi])
- REG_NOTES (sinsn)
- = gen_rtx_EXPR_LIST (REG_EQUIV, stacki,
- REG_NOTES (sinsn));
+ set_unique_reg_note (sinsn, REG_EQUIV, stacki);
else if (SET_DEST (set) == regno_reg_rtx [regnor])
- REG_NOTES (sinsn)
- = gen_rtx_EXPR_LIST (REG_EQUIV, stackr,
- REG_NOTES (sinsn));
+ set_unique_reg_note (sinsn, REG_EQUIV, stackr);
}
}
else if ((set = single_set (linsn)) != 0
&& SET_DEST (set) == parmreg)
- REG_NOTES (linsn)
- = gen_rtx_EXPR_LIST (REG_EQUIV,
- data->stack_parm, REG_NOTES (linsn));
+ set_unique_reg_note (linsn, REG_EQUIV, data->stack_parm);
}
/* For pointer data type, suggest pointer register. */
Index: gcse.c
===================================================================
--- gcse.c (revision 121794)
+++ gcse.c (working copy)
@@ -2668,7 +2668,8 @@ try_replace_reg (rtx from, rtx to, rtx i
/* If there is already a REG_EQUAL note, update the expression in it
with our replacement. */
if (note != 0 && REG_NOTE_KIND (note) == REG_EQUAL)
- XEXP (note, 0) = simplify_replace_rtx (XEXP (note, 0), from, to);
+ set_unique_reg_note (insn, REG_EQUAL,
+ simplify_replace_rtx (XEXP (note, 0), from, to));
if (!success && set && reg_mentioned_p (from, SET_SRC (set)))
{
Index: alias.c
===================================================================
--- alias.c (revision 121794)
+++ alias.c (working copy)
@@ -2546,10 +2546,12 @@ init_alias_analysis (void)
rtx src = SET_SRC (set);
rtx t;
- if (REG_NOTES (insn) != 0
- && (((note = find_reg_note (insn, REG_EQUAL, 0)) != 0
- && REG_N_SETS (regno) == 1)
- || (note = find_reg_note (insn, REG_EQUIV, NULL_RTX)) != 0)
+ note = find_reg_equal_equiv_note (insn);
+ if (note && REG_NOTE_KIND (note) == REG_EQUAL
+ && REG_N_SETS (regno) != 1)
+ note = NULL_RTX;
+
+ if (note != NULL_RTX
&& GET_CODE (XEXP (note, 0)) != EXPR_LIST
&& ! rtx_varies_p (XEXP (note, 0), 1)
&& ! reg_overlap_mentioned_p (SET_DEST (set),
Index: calls.c
===================================================================
--- calls.c (revision 121794)
+++ calls.c (working copy)
@@ -3130,24 +3130,19 @@ fixup_tail_calls (void)
for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
{
+ rtx note;
+
/* There are never REG_EQUIV notes for the incoming arguments
after the NOTE_INSN_FUNCTION_BEG note, so stop if we see it. */
if (NOTE_P (insn)
&& NOTE_LINE_NUMBER (insn) == NOTE_INSN_FUNCTION_BEG)
break;
- while (1)
- {
- rtx note = find_reg_note (insn, REG_EQUIV, 0);
- if (note)
- {
- /* Remove the note and keep looking at the notes for
- this insn. */
- remove_note (insn, note);
- continue;
- }
- break;
- }
+ note = find_reg_note (insn, REG_EQUIV, 0);
+ if (note)
+ remove_note (insn, note);
+ note = find_reg_note (insn, REG_EQUIV, 0);
+ gcc_assert (!note);
}
}
Index: reload1.c
===================================================================
--- reload1.c (revision 121794)
+++ reload1.c (working copy)
@@ -7832,8 +7832,7 @@ gen_reload (rtx out, rtx in, int opnum,
if (insn)
{
/* Add a REG_EQUIV note so that find_equiv_reg can find it. */
- REG_NOTES (insn)
- = gen_rtx_EXPR_LIST (REG_EQUIV, in, REG_NOTES (insn));
+ set_unique_reg_note (insn, REG_EQUIV, in);
return insn;
}
@@ -7842,7 +7841,7 @@ gen_reload (rtx out, rtx in, int opnum,
gen_reload (out, op1, opnum, type);
insn = emit_insn (gen_add2_insn (out, op0));
- REG_NOTES (insn) = gen_rtx_EXPR_LIST (REG_EQUIV, in, REG_NOTES (insn));
+ set_unique_reg_note (insn, REG_EQUIV, in);
}
#ifdef SECONDARY_MEMORY_NEEDED
@@ -7902,8 +7901,7 @@ gen_reload (rtx out, rtx in, int opnum,
insn = emit_insn_if_valid_for_reload (insn);
if (insn)
{
- REG_NOTES (insn)
- = gen_rtx_EXPR_LIST (REG_EQUIV, in, REG_NOTES (insn));
+ set_unique_reg_note (insn, REG_EQUIV, in);
return insn;
}