This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
[patch] Make df_ref point to a df_insn_info instead of an insn rtx
- From: "Steven Bosscher" <stevenb dot gcc at gmail dot com>
- To: "Kenneth Zadeck" <zadeck at naturalbridge dot com>
- Cc: gcc-patches <gcc-patches at gcc dot gnu dot org>
- Date: Wed, 18 Jun 2008 01:20:45 +0200
- Subject: [patch] Make df_ref point to a df_insn_info instead of an insn rtx
Hi,
This is the patch to change how df_refs point to their insns. Without
this patch, a df_ref points directly to the insn's rtx. And from the
insn, we get the df_insn_info via DF_INSN_GET, which points to the
insn def and use refs.
But if we are going to have fake insns that have defs and uses, but no
real insns (e.g. PHI nodes), we need a different way to find the
sibling defs/uses for a given reference. The easiest way is to just
point directly at the df_insn_info for the insn that contains the
reference. This way, we can then still point at a df_insn_info for
fake insns.
Attached patch was bootstrapped&tested on ia64-unknown-linux-gnu (and
an earlier equivalent version on powerpc). Kenny, what do you think
about this? OK for trunk?
Gr.
Steven
* df.h (struct df_ref): Replace 'insn' field with 'insn_info' field.
(DF_REF_INSN_INFO): New.
(DF_REF_INSN, DF_REF_INSN_UID): Rewrite macros using DF_REF_INSN_INFO.
(DF_REF_IS_ARTIFICIAL): Artificial refs are now identified as refs
with a NULL DF_REF_INSN_INFO.
(DF_INSN_INFO_GET, DF_INSN_INFO_SET): Renamed from DF_INSN_GET and
DF_INSN_SET.
(DF_INSN_INFO_LUID, DF_INSN_INFO_DEFS, DF_INSN_INFO_USES,
DF_INSN_INFO_EQ_USES): New.
(DF_INSN_LUID, DF_INSN_DEFS, DF_INSN_USES, DF_INSN_EQ_USES,
DF_INSN_UID_LUID, DF_INSN_UID_DEFS, DF_INSN_UID_USES,
DF_INSN_UID_EQ_USES): Rewrite using DF_INSN_INFO_* macros.
* df-code.c: Update comment for above changes.
(df_insn_debug_regno): Use DF_INSN_INFO_GET instead of INSN_UID and
DF_INSN_UID_* macros.
(df_ref_debug): Check for NULL DF_REF_INSN_INFO.
* df-scan.c (df_ref_record): Take a df_insn_info instead of an
insn rtx. Update all callers.
(df_def_record_1, df_defs_record, df_uses_record, df_get_call_refs,
df_ref_create_structure, df_insn_refs_collect): Likewise.
(df_ref_equal_p): Compare DF_REF_INSN_INFO pointers for the refs.
* df-problems.c (df_chain_dump): Test for non-NULL DF_REF_INSN_INFO.
(df_live_bb_local_compute): Retrieve DF_INSN_INFO, use DF_INSN_INFO_*
macros to access the insn refs.
(df_chain_top_dump, df_chain_bottom_dump, df_byte_lr_alloc): Likewise.
* fwprop.c (use_killed_between): Use DF_REF_INSN accessor macro.
(all_uses_available): Retrieve DF_INSN_INFO for def_insn, and use it
for accessing the refs.
(try_fwprop_subst): Likewise.
* ddg.c (add_cross_iteration_register_deps): Use DF_REF_INSN macro.
* web.c (union_defs): Retrieve DF_INSN_INFO for def_insn, and use it
for accessing the refs.
* loop-invariant.c (invariant_for_use): Use DF_REF_BB macro.
(check_dependencies): Use DF_INSN_INFO_GET, use DF_INSN_INFO_* macros
to look at the insn refs.
(record_uses): Likewise.
* dce.c (deletable_insn_p): Don't tolerate artificial DEFs in this
function anymore.
(mark_artificial_uses): Don't mark_insn for artificial refs.
(mark_reg_rependencies): Likewise.
Index: df.h
===================================================================
--- df.h (revision 136868)
+++ df.h (working copy)
@@ -370,9 +370,10 @@ struct df_ref
rtx reg; /* The register referenced. */
basic_block bb; /* Basic block containing the instruction. */
- /* Insn containing ref. This will be null if this is an artificial
- reference. */
- rtx insn;
+ /* Insn info for the insn containing ref. This will be null if this is
+ an artificial reference. */
+ struct df_insn_info *insn_info;
+
rtx *loc; /* The location of the reg. */
struct df_link *chain; /* Head of def-use, use-def. */
/* Location in the ref table. This is only valid after a call to
@@ -612,8 +613,9 @@ struct df
#define DF_REF_LOC(REF) ((REF)->loc)
#define DF_REF_BB(REF) ((REF)->bb)
#define DF_REF_BBNO(REF) (DF_REF_BB (REF)->index)
-#define DF_REF_INSN(REF) ((REF)->insn)
-#define DF_REF_INSN_UID(REF) (INSN_UID ((REF)->insn))
+#define DF_REF_INSN_INFO(REF) ((REF)->insn_info)
+#define DF_REF_INSN(REF) ((REF)->insn_info->insn)
+#define DF_REF_INSN_UID(REF) (INSN_UID (DF_REF_INSN(REF)))
#define DF_REF_TYPE(REF) ((REF)->type)
#define DF_REF_CHAIN(REF) ((REF)->chain)
#define DF_REF_ID(REF) ((REF)->id)
@@ -626,7 +628,7 @@ struct df
but an artificial one created to model
always live registers, eh uses, etc.
ARTIFICIAL refs has NULL insn. */
-#define DF_REF_IS_ARTIFICIAL(REF) ((REF)->insn == NULL)
+#define DF_REF_IS_ARTIFICIAL(REF) ((REF)->insn_info == NULL)
#define DF_REF_REG_MARK(REF) (DF_REF_FLAGS_SET ((REF),DF_REF_REG_MARKER))
#define DF_REF_REG_UNMARK(REF) (DF_REF_FLAGS_CLEAR ((REF),DF_REF_REG_MARKER))
#define DF_REF_IS_REG_MARKED(REF) (DF_REF_FLAGS_IS_SET ((REF),DF_REF_REG_MARKER))
@@ -691,12 +693,17 @@ struct df
/* Macros to access the elements within the insn_info structure table. */
#define DF_INSN_SIZE() ((df)->insns_size)
-#define DF_INSN_GET(INSN) (df->insns[(INSN_UID(INSN))])
-#define DF_INSN_SET(INSN,VAL) (df->insns[(INSN_UID (INSN))]=(VAL))
-#define DF_INSN_LUID(INSN) (DF_INSN_GET(INSN)->luid)
-#define DF_INSN_DEFS(INSN) (DF_INSN_GET(INSN)->defs)
-#define DF_INSN_USES(INSN) (DF_INSN_GET(INSN)->uses)
-#define DF_INSN_EQ_USES(INSN) (DF_INSN_GET(INSN)->eq_uses)
+#define DF_INSN_INFO_GET(INSN) (df->insns[(INSN_UID(INSN))])
+#define DF_INSN_INFO_SET(INSN,VAL) (df->insns[(INSN_UID (INSN))]=(VAL))
+#define DF_INSN_INFO_LUID(II) ((II)->luid)
+#define DF_INSN_INFO_DEFS(II) ((II)->defs)
+#define DF_INSN_INFO_USES(II) ((II)->uses)
+#define DF_INSN_INFO_EQ_USES(II) ((II)->eq_uses)
+
+#define DF_INSN_LUID(INSN) (DF_INSN_INFO_LUID (DF_INSN_INFO_GET(INSN)))
+#define DF_INSN_DEFS(INSN) (DF_INSN_INFO_DEFS (DF_INSN_INFO_GET(INSN)))
+#define DF_INSN_USES(INSN) (DF_INSN_INFO_USES (DF_INSN_INFO_GET(INSN)))
+#define DF_INSN_EQ_USES(INSN) (DF_INSN_INFO_EQ_USES (DF_INSN_INFO_GET(INSN)))
#define DF_INSN_UID_GET(UID) (df->insns[(UID)])
#define DF_INSN_UID_SET(UID,VAL) (df->insns[(UID)]=(VAL))
Index: df-core.c
===================================================================
--- df-core.c (revision 136868)
+++ df-core.c (working copy)
@@ -268,25 +268,29 @@ pseudos and long for the hard registers.
ACCESSING INSNS:
-1) The df insn information is kept in the insns array. This array is
- indexed by insn uid.
-
-2) Each insn has three sets of refs: They are linked into one of three
- lists: the insn's defs list (accessed by the DF_INSN_DEFS or
- DF_INSN_UID_DEFS macros), the insn's uses list (accessed by the
- DF_INSN_USES or DF_INSN_UID_USES macros) or the insn's eq_uses list
- (accessed by the DF_INSN_EQ_USES or DF_INSN_UID_EQ_USES macros).
- The latter list are the list of references in REG_EQUAL or
- REG_EQUIV notes. These macros produce a ref (or NULL), the rest of
- the list can be obtained by traversal of the NEXT_REF field
- (accessed by the DF_REF_NEXT_REF macro.) There is no significance
- to the ordering of the uses or refs in an instruction.
-
-3) Each insn has a logical uid field (LUID). When properly set, this
- is an integer that numbers each insn in the basic block, in order from
- the start of the block. The numbers are only correct after a call to
- df_analyse. They will rot after insns are added deleted or moved
- around.
+1) The df insn information is kept in an array of DF_INSN_INFO objects.
+ The array is indexed by insn uid, and every DF_REF points to the
+ DF_INSN_INFO object of the insn that contains the reference.
+
+2) Each insn has three sets of refs, which are linked into one of three
+ lists: The insn's defs list (accessed by the DF_INSN_INFO_DEFS,
+ DF_INSN_DEFS, or DF_INSN_UID_DEFS macros), the insn's uses list
+ (accessed by the DF_INSN_INFO_USES, DF_INSN_USES, or
+ DF_INSN_UID_USES macros) or the insn's eq_uses list (accessed by the
+ DF_INSN_INFO_EQ_USES, DF_INSN_EQ_USES or DF_INSN_UID_EQ_USES macros).
+ The latter list are the list of references in REG_EQUAL or REG_EQUIV
+ notes. These macros produce a ref (or NULL), the rest of the list
+ can be obtained by traversal of the NEXT_REF field (accessed by the
+ DF_REF_NEXT_REF macro.) There is no significance to the ordering of
+ the uses or refs in an instruction.
+
+3) Each insn has a logical uid field (LUID) which is stored in the
+ DF_INSN_INFO object for the insn. The LUID field is accessed by
+ the DF_INSN_INFO_LUID, DF_INSN_LUID, and DF_INSN_UID_LUID macros.
+ When properly set, the LUID is an integer that numbers each insn in
+ the basic block, in order from the start of the block.
+ The numbers are only correct after a call to df_analyze. They will
+ rot after insns are added deleted or moved round.
ACCESSING REFS:
@@ -2152,17 +2156,18 @@ df_insn_debug (rtx insn, bool follow_cha
void
df_insn_debug_regno (rtx insn, FILE *file)
{
- unsigned int uid = INSN_UID(insn);
+ struct df_insn_info *insn_info = DF_INSN_INFO_GET (insn);
fprintf (file, "insn %d bb %d luid %d defs ",
- uid, BLOCK_FOR_INSN (insn)->index, DF_INSN_LUID (insn));
- df_refs_chain_dump (DF_INSN_UID_DEFS (uid), false, file);
+ INSN_UID (insn), BLOCK_FOR_INSN (insn)->index,
+ DF_INSN_INFO_LUID (insn_info));
+ df_refs_chain_dump (DF_INSN_INFO_DEFS (insn_info), false, file);
fprintf (file, " uses ");
- df_refs_chain_dump (DF_INSN_UID_USES (uid), false, file);
+ df_refs_chain_dump (DF_INSN_INFO_USES (insn_info), false, file);
fprintf (file, " eq_uses ");
- df_refs_chain_dump (DF_INSN_UID_EQ_USES (uid), false, file);
+ df_refs_chain_dump (DF_INSN_INFO_EQ_USES (insn_info), false, file);
fprintf (file, "\n");
}
@@ -2188,7 +2193,7 @@ df_ref_debug (struct df_ref *ref, FILE *
fprintf (file, "reg %d bb %d insn %d flag 0x%x type 0x%x ",
DF_REF_REGNO (ref),
DF_REF_BBNO (ref),
- DF_REF_INSN (ref) ? INSN_UID (DF_REF_INSN (ref)) : -1,
+ DF_REF_INSN_INFO (ref) ? INSN_UID (DF_REF_INSN (ref)) : -1,
DF_REF_FLAGS (ref),
DF_REF_TYPE (ref));
if (DF_REF_LOC (ref))
Index: df-scan.c
===================================================================
--- df-scan.c (revision 136868)
+++ df-scan.c (working copy)
@@ -94,26 +94,28 @@ static struct df_mw_hardreg * df_null_mw
static void df_ref_record (struct df_collection_rec *,
rtx, rtx *,
- basic_block, rtx, enum df_ref_type,
- enum df_ref_flags, int, int, enum machine_mode);
-static void df_def_record_1 (struct df_collection_rec *,
- rtx, basic_block, rtx,
+ basic_block, struct df_insn_info *,
+ enum df_ref_type, enum df_ref_flags,
+ int, int, enum machine_mode);
+static void df_def_record_1 (struct df_collection_rec *, rtx,
+ basic_block, struct df_insn_info *,
enum df_ref_flags);
-static void df_defs_record (struct df_collection_rec *,
- rtx, basic_block, rtx,
+static void df_defs_record (struct df_collection_rec *, rtx,
+ basic_block, struct df_insn_info *,
enum df_ref_flags);
static void df_uses_record (struct df_collection_rec *,
rtx *, enum df_ref_type,
- basic_block, rtx, enum df_ref_flags,
+ basic_block, struct df_insn_info *,
+ enum df_ref_flags,
int, int, enum machine_mode);
static struct df_ref *df_ref_create_structure (struct df_collection_rec *, rtx, rtx *,
- basic_block, rtx, enum df_ref_type,
- enum df_ref_flags,
+ basic_block, struct df_insn_info *,
+ enum df_ref_type, enum df_ref_flags,
int, int, enum machine_mode);
static void df_insn_refs_collect (struct df_collection_rec*,
- basic_block, rtx);
+ basic_block, struct df_insn_info *);
static void df_canonize_collection_rec (struct df_collection_rec *);
static void df_get_regular_block_artificial_uses (bitmap);
@@ -636,7 +638,7 @@ df_ref_create (rtx reg, rtx *loc, rtx in
/* You cannot hack artificial refs. */
gcc_assert (insn);
- ref = df_ref_create_structure (NULL, reg, loc, bb, insn,
+ ref = df_ref_create_structure (NULL, reg, loc, bb, DF_INSN_INFO_GET (insn),
ref_type, ref_flags,
width, offset, mode);
@@ -924,11 +926,11 @@ df_insn_create_insn_record (rtx insn)
struct df_insn_info *insn_rec;
df_grow_insn_info ();
- insn_rec = DF_INSN_GET (insn);
+ insn_rec = DF_INSN_INFO_GET (insn);
if (!insn_rec)
{
insn_rec = pool_alloc (problem_data->insn_pool);
- DF_INSN_SET (insn, insn_rec);
+ DF_INSN_INFO_SET (insn, insn_rec);
}
memset (insn_rec, 0, sizeof (struct df_insn_info));
insn_rec->insn = insn;
@@ -1166,8 +1168,8 @@ df_insn_rescan (rtx insn)
}
else
{
- df_insn_create_insn_record (insn);
- df_insn_refs_collect (&collection_rec, bb, insn);
+ struct df_insn_info *insn_info = df_insn_create_insn_record (insn);
+ df_insn_refs_collect (&collection_rec, bb, insn_info);
if (dump_file)
fprintf (dump_file, "scanning new insn with uid = %d.\n", uid);
}
@@ -1893,8 +1895,7 @@ df_ref_change_reg_with_loc_1 (struct df_
}
else
{
- struct df_insn_info *insn_info
- = DF_INSN_GET (DF_REF_INSN (the_ref));
+ struct df_insn_info *insn_info = DF_REF_INSN_INFO (the_ref);
if (DF_REF_FLAGS (the_ref) & DF_REF_IN_NOTE)
ref_vec = insn_info->eq_uses;
else
@@ -2064,7 +2065,7 @@ df_notes_rescan (rtx insn)
case REG_EQUAL:
df_uses_record (&collection_rec,
&XEXP (note, 0), DF_REF_REG_USE,
- bb, insn, DF_REF_IN_NOTE, -1, -1, 0);
+ bb, insn_info, DF_REF_IN_NOTE, -1, -1, 0);
default:
break;
}
@@ -2149,7 +2150,7 @@ df_ref_equal_p (struct df_ref *ref1, str
(DF_REF_REG (ref1) == DF_REF_REG (ref2)
&& DF_REF_REGNO (ref1) == DF_REF_REGNO (ref2)
&& DF_REF_LOC (ref1) == DF_REF_LOC (ref2)
- && DF_REF_INSN (ref1) == DF_REF_INSN (ref2)
+ && DF_REF_INSN_INFO (ref1) == DF_REF_INSN_INFO (ref2)
&& DF_REF_TYPE (ref1) == DF_REF_TYPE (ref2)
&& ((DF_REF_FLAGS (ref1) & ~(DF_REF_REG_MARKER + DF_REF_MW_HARDREG))
== (DF_REF_FLAGS (ref2) & ~(DF_REF_REG_MARKER + DF_REF_MW_HARDREG)))
@@ -2516,7 +2517,7 @@ df_refs_add_to_chains (struct df_collect
{
if (insn)
{
- struct df_insn_info *insn_rec = DF_INSN_GET (insn);
+ struct df_insn_info *insn_rec = DF_INSN_INFO_GET (insn);
/* If there is a vector in the collection rec, add it to the
insn. A null rec is a signal that the caller will handle the
chain specially. */
@@ -2591,7 +2592,7 @@ df_refs_add_to_chains (struct df_collect
static struct df_ref *
df_ref_create_structure (struct df_collection_rec *collection_rec,
rtx reg, rtx *loc,
- basic_block bb, rtx insn,
+ basic_block bb, struct df_insn_info *info,
enum df_ref_type ref_type,
enum df_ref_flags ref_flags,
int width, int offset, enum machine_mode mode)
@@ -2614,7 +2615,7 @@ df_ref_create_structure (struct df_colle
DF_REF_REG (this_ref) = reg;
DF_REF_REGNO (this_ref) = regno;
DF_REF_LOC (this_ref) = loc;
- DF_REF_INSN (this_ref) = insn;
+ DF_REF_INSN_INFO (this_ref) = info;
DF_REF_CHAIN (this_ref) = NULL;
DF_REF_TYPE (this_ref) = ref_type;
DF_REF_FLAGS (this_ref) = ref_flags;
@@ -2669,7 +2670,7 @@ df_ref_create_structure (struct df_colle
static void
df_ref_record (struct df_collection_rec *collection_rec,
rtx reg, rtx *loc,
- basic_block bb, rtx insn,
+ basic_block bb, struct df_insn_info *insn_info,
enum df_ref_type ref_type,
enum df_ref_flags ref_flags,
int width, int offset, enum machine_mode mode)
@@ -2700,7 +2701,7 @@ df_ref_record (struct df_collection_rec
/* If this is a multiword hardreg, we create some extra
datastructures that will enable us to easily build REG_DEAD
and REG_UNUSED notes. */
- if ((endregno != regno + 1) && insn)
+ if ((endregno != regno + 1) && insn_info)
{
/* Sets to a subreg of a multiword register are partial.
Sets to a non-subreg of a multiword register are not. */
@@ -2721,7 +2722,7 @@ df_ref_record (struct df_collection_rec
for (i = regno; i < endregno; i++)
{
ref = df_ref_create_structure (collection_rec, regno_reg_rtx[i], loc,
- bb, insn, ref_type, ref_flags,
+ bb, insn_info, ref_type, ref_flags,
width, offset, mode);
gcc_assert (ORIGINAL_REGNO (DF_REF_REG (ref)) == i);
@@ -2730,7 +2731,7 @@ df_ref_record (struct df_collection_rec
else
{
struct df_ref *ref;
- ref = df_ref_create_structure (collection_rec, reg, loc, bb, insn,
+ ref = df_ref_create_structure (collection_rec, reg, loc, bb, insn_info,
ref_type, ref_flags, width, offset, mode);
}
}
@@ -2760,7 +2761,7 @@ df_read_modify_subreg_p (rtx x)
static void
df_def_record_1 (struct df_collection_rec *collection_rec,
- rtx x, basic_block bb, rtx insn,
+ rtx x, basic_block bb, struct df_insn_info *insn_info,
enum df_ref_flags flags)
{
rtx *loc;
@@ -2788,7 +2789,7 @@ df_def_record_1 (struct df_collection_re
if (GET_CODE (temp) == EXPR_LIST || GET_CODE (temp) == CLOBBER
|| GET_CODE (temp) == SET)
df_def_record_1 (collection_rec,
- temp, bb, insn,
+ temp, bb, insn_info,
GET_CODE (temp) == CLOBBER
? flags | DF_REF_MUST_CLOBBER : flags);
}
@@ -2823,14 +2824,14 @@ df_def_record_1 (struct df_collection_re
if (REG_P (dst))
{
df_ref_record (collection_rec,
- dst, loc, bb, insn, DF_REF_REG_DEF, flags,
+ dst, loc, bb, insn_info, DF_REF_REG_DEF, flags,
width, offset, mode);
/* We want to keep sp alive everywhere - by making all
writes to sp also use of sp. */
if (REGNO (dst) == STACK_POINTER_REGNUM)
df_ref_record (collection_rec,
- dst, NULL, bb, insn, DF_REF_REG_USE, flags,
+ dst, NULL, bb, insn_info, DF_REF_REG_USE, flags,
width, offset, mode);
}
else if (GET_CODE (dst) == SUBREG && REG_P (SUBREG_REG (dst)))
@@ -2841,7 +2842,7 @@ df_def_record_1 (struct df_collection_re
flags |= DF_REF_SUBREG;
df_ref_record (collection_rec,
- dst, loc, bb, insn, DF_REF_REG_DEF, flags,
+ dst, loc, bb, insn_info, DF_REF_REG_DEF, flags,
width, offset, mode);
}
}
@@ -2851,7 +2852,8 @@ df_def_record_1 (struct df_collection_re
static void
df_defs_record (struct df_collection_rec *collection_rec,
- rtx x, basic_block bb, rtx insn, enum df_ref_flags flags)
+ rtx x, basic_block bb, struct df_insn_info *insn_info,
+ enum df_ref_flags flags)
{
RTX_CODE code = GET_CODE (x);
@@ -2860,12 +2862,12 @@ df_defs_record (struct df_collection_rec
/* Mark the single def within the pattern. */
enum df_ref_flags clobber_flags = flags;
clobber_flags |= (code == CLOBBER) ? DF_REF_MUST_CLOBBER : 0;
- df_def_record_1 (collection_rec, x, bb, insn, clobber_flags);
+ df_def_record_1 (collection_rec, x, bb, insn_info, clobber_flags);
}
else if (code == COND_EXEC)
{
df_defs_record (collection_rec, COND_EXEC_CODE (x),
- bb, insn, DF_REF_CONDITIONAL);
+ bb, insn_info, DF_REF_CONDITIONAL);
}
else if (code == PARALLEL)
{
@@ -2873,7 +2875,7 @@ df_defs_record (struct df_collection_rec
/* Mark the multiple defs within the pattern. */
for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
- df_defs_record (collection_rec, XVECEXP (x, 0, i), bb, insn, flags);
+ df_defs_record (collection_rec, XVECEXP (x, 0, i), bb, insn_info, flags);
}
}
@@ -2888,7 +2890,8 @@ df_defs_record (struct df_collection_rec
static void
df_uses_record (struct df_collection_rec *collection_rec,
rtx *loc, enum df_ref_type ref_type,
- basic_block bb, rtx insn, enum df_ref_flags flags,
+ basic_block bb, struct df_insn_info *insn_info,
+ enum df_ref_flags flags,
int width, int offset, enum machine_mode mode)
{
RTX_CODE code;
@@ -2920,8 +2923,9 @@ df_uses_record (struct df_collection_rec
if (MEM_P (XEXP (x, 0)))
df_uses_record (collection_rec,
&XEXP (XEXP (x, 0), 0),
- DF_REF_REG_MEM_STORE, bb, insn, flags,
- width, offset, mode);
+ DF_REF_REG_MEM_STORE,
+ bb, insn_info,
+ flags, width, offset, mode);
/* If we're clobbering a REG then we have a def so ignore. */
return;
@@ -2929,7 +2933,7 @@ df_uses_record (struct df_collection_rec
case MEM:
df_uses_record (collection_rec,
&XEXP (x, 0), DF_REF_REG_MEM_LOAD,
- bb, insn, flags & DF_REF_IN_NOTE,
+ bb, insn_info, flags & DF_REF_IN_NOTE,
width, offset, mode);
return;
@@ -2940,7 +2944,7 @@ df_uses_record (struct df_collection_rec
if (!REG_P (SUBREG_REG (x)))
{
loc = &SUBREG_REG (x);
- df_uses_record (collection_rec, loc, ref_type, bb, insn, flags,
+ df_uses_record (collection_rec, loc, ref_type, bb, insn_info, flags,
width, offset, mode);
return;
}
@@ -2948,7 +2952,8 @@ df_uses_record (struct df_collection_rec
case REG:
df_ref_record (collection_rec,
- x, loc, bb, insn, ref_type, flags,
+ x, loc, bb, insn_info,
+ ref_type, flags,
width, offset, mode);
return;
@@ -2971,7 +2976,7 @@ df_uses_record (struct df_collection_rec
flags |= DF_REF_SIGN_EXTRACT;
df_uses_record (collection_rec,
- &XEXP (x, 0), ref_type, bb, insn, flags,
+ &XEXP (x, 0), ref_type, bb, insn_info, flags,
width, offset, mode);
return;
}
@@ -2983,7 +2988,7 @@ df_uses_record (struct df_collection_rec
rtx dst = SET_DEST (x);
gcc_assert (!(flags & DF_REF_IN_NOTE));
df_uses_record (collection_rec,
- &SET_SRC (x), DF_REF_REG_USE, bb, insn, flags,
+ &SET_SRC (x), DF_REF_REG_USE, bb, insn_info, flags,
width, offset, mode);
switch (GET_CODE (dst))
@@ -2992,7 +2997,7 @@ df_uses_record (struct df_collection_rec
if (df_read_modify_subreg_p (dst))
{
df_uses_record (collection_rec, &SUBREG_REG (dst),
- DF_REF_REG_USE, bb, insn,
+ DF_REF_REG_USE, bb, insn_info,
flags | DF_REF_READ_WRITE | DF_REF_SUBREG,
width, offset, mode);
break;
@@ -3006,7 +3011,7 @@ df_uses_record (struct df_collection_rec
break;
case MEM:
df_uses_record (collection_rec, &XEXP (dst, 0),
- DF_REF_REG_MEM_STORE, bb, insn, flags,
+ DF_REF_REG_MEM_STORE, bb, insn_info, flags,
width, offset, mode);
break;
case STRICT_LOW_PART:
@@ -3017,7 +3022,7 @@ df_uses_record (struct df_collection_rec
dst = XEXP (dst, 0);
df_uses_record (collection_rec,
(GET_CODE (dst) == SUBREG) ? &SUBREG_REG (dst) : temp,
- DF_REF_REG_USE, bb, insn,
+ DF_REF_REG_USE, bb, insn_info,
DF_REF_READ_WRITE | DF_REF_STRICT_LOW_PART,
width, offset, mode);
}
@@ -3034,15 +3039,15 @@ df_uses_record (struct df_collection_rec
else
{
df_uses_record (collection_rec, &XEXP (dst, 1),
- DF_REF_REG_USE, bb, insn, flags,
+ DF_REF_REG_USE, bb, insn_info, flags,
width, offset, mode);
df_uses_record (collection_rec, &XEXP (dst, 2),
- DF_REF_REG_USE, bb, insn, flags,
+ DF_REF_REG_USE, bb, insn_info, flags,
width, offset, mode);
}
df_uses_record (collection_rec, &XEXP (dst, 0),
- DF_REF_REG_USE, bb, insn,
+ DF_REF_REG_USE, bb, insn_info,
DF_REF_READ_WRITE | DF_REF_ZERO_EXTRACT,
width, offset, mode);
}
@@ -3094,7 +3099,7 @@ df_uses_record (struct df_collection_rec
for (j = 0; j < ASM_OPERANDS_INPUT_LENGTH (x); j++)
df_uses_record (collection_rec, &ASM_OPERANDS_INPUT (x, j),
- DF_REF_REG_USE, bb, insn, flags,
+ DF_REF_REG_USE, bb, insn_info, flags,
width, offset, mode);
return;
}
@@ -3108,7 +3113,8 @@ df_uses_record (struct df_collection_rec
case PRE_MODIFY:
case POST_MODIFY:
/* Catch the def of the register being modified. */
- df_ref_record (collection_rec, XEXP (x, 0), &XEXP (x, 0), bb, insn,
+ df_ref_record (collection_rec, XEXP (x, 0), &XEXP (x, 0),
+ bb, insn_info,
DF_REF_REG_DEF,
flags | DF_REF_READ_WRITE | DF_REF_PRE_POST_MODIFY,
width, offset, mode);
@@ -3135,7 +3141,7 @@ df_uses_record (struct df_collection_rec
goto retry;
}
df_uses_record (collection_rec, &XEXP (x, i), ref_type,
- bb, insn, flags,
+ bb, insn_info, flags,
width, offset, mode);
}
else if (fmt[i] == 'E')
@@ -3144,7 +3150,7 @@ df_uses_record (struct df_collection_rec
for (j = 0; j < XVECLEN (x, i); j++)
df_uses_record (collection_rec,
&XVECEXP (x, i, j), ref_type,
- bb, insn, flags,
+ bb, insn_info, flags,
width, offset, mode);
}
}
@@ -3179,7 +3185,7 @@ df_get_conditional_uses (struct df_colle
use = df_ref_create_structure (collection_rec, DF_REF_REG (ref),
DF_REF_LOC (ref), DF_REF_BB (ref),
- DF_REF_INSN (ref), DF_REF_REG_USE,
+ DF_REF_INSN_INFO (ref), DF_REF_REG_USE,
DF_REF_FLAGS (ref) & ~DF_REF_CONDITIONAL,
width, offset, mode);
DF_REF_REGNO (use) = DF_REF_REGNO (ref);
@@ -3193,7 +3199,7 @@ df_get_conditional_uses (struct df_colle
static void
df_get_call_refs (struct df_collection_rec * collection_rec,
basic_block bb,
- rtx insn,
+ struct df_insn_info *insn_info,
enum df_ref_flags flags)
{
rtx note;
@@ -3214,12 +3220,12 @@ df_get_call_refs (struct df_collection_r
/* Record the registers used to pass arguments, and explicitly
noted as clobbered. */
- for (note = CALL_INSN_FUNCTION_USAGE (insn); note;
+ for (note = CALL_INSN_FUNCTION_USAGE (insn_info->insn); note;
note = XEXP (note, 1))
{
if (GET_CODE (XEXP (note, 0)) == USE)
df_uses_record (collection_rec, &XEXP (XEXP (note, 0), 0),
- DF_REF_REG_USE, bb, insn, flags, -1, -1, 0);
+ DF_REF_REG_USE, bb, insn_info, flags, -1, -1, 0);
else if (GET_CODE (XEXP (note, 0)) == CLOBBER)
{
if (REG_P (XEXP (XEXP (note, 0), 0)))
@@ -3227,17 +3233,18 @@ df_get_call_refs (struct df_collection_r
unsigned int regno = REGNO (XEXP (XEXP (note, 0), 0));
if (!bitmap_bit_p (defs_generated, regno))
df_defs_record (collection_rec, XEXP (note, 0), bb,
- insn, flags);
+ insn_info, flags);
}
else
df_uses_record (collection_rec, &XEXP (note, 0),
- DF_REF_REG_USE, bb, insn, flags, -1, -1, 0);
+ DF_REF_REG_USE, bb, insn_info, flags, -1, -1, 0);
}
}
/* The stack ptr is used (honorarily) by a CALL insn. */
df_ref_record (collection_rec, regno_reg_rtx[STACK_POINTER_REGNUM],
- NULL, bb, insn, DF_REF_REG_USE, DF_REF_CALL_STACK_USAGE | flags,
+ NULL, bb, insn_info, DF_REF_REG_USE,
+ DF_REF_CALL_STACK_USAGE | flags,
-1, -1, 0);
/* Calls may also reference any of the global registers,
@@ -3246,12 +3253,12 @@ df_get_call_refs (struct df_collection_r
if (global_regs[i])
{
df_ref_record (collection_rec, regno_reg_rtx[i],
- NULL, bb, insn, DF_REF_REG_USE, flags, -1, -1, 0);
+ NULL, bb, insn_info, DF_REF_REG_USE, flags, -1, -1, 0);
df_ref_record (collection_rec, regno_reg_rtx[i],
- NULL, bb, insn, DF_REF_REG_DEF, flags, -1, -1, 0);
+ NULL, bb, insn_info, DF_REF_REG_DEF, flags, -1, -1, 0);
}
- is_sibling_call = SIBLING_CALL_P (insn);
+ is_sibling_call = SIBLING_CALL_P (insn_info->insn);
EXECUTE_IF_SET_IN_BITMAP (df_invalidated_by_call, 0, ui, bi)
{
if (!global_regs[ui]
@@ -3261,7 +3268,8 @@ df_get_call_refs (struct df_collection_r
|| refers_to_regno_p (ui, ui+1,
crtl->return_rtx, NULL)))
df_ref_record (collection_rec, regno_reg_rtx[ui],
- NULL, bb, insn, DF_REF_REG_DEF, DF_REF_MAY_CLOBBER | flags,
+ NULL, bb, insn_info, DF_REF_REG_DEF,
+ DF_REF_MAY_CLOBBER | flags,
-1, -1, 0);
}
@@ -3276,10 +3284,10 @@ df_get_call_refs (struct df_collection_r
static void
df_insn_refs_collect (struct df_collection_rec* collection_rec,
- basic_block bb, rtx insn)
+ basic_block bb, struct df_insn_info *insn_info)
{
rtx note;
- bool is_cond_exec = (GET_CODE (PATTERN (insn)) == COND_EXEC);
+ bool is_cond_exec = (GET_CODE (PATTERN (insn_info->insn)) == COND_EXEC);
/* Clear out the collection record. */
collection_rec->next_def = 0;
@@ -3288,10 +3296,10 @@ df_insn_refs_collect (struct df_collecti
collection_rec->next_mw = 0;
/* Record register defs. */
- df_defs_record (collection_rec, PATTERN (insn), bb, insn, 0);
+ df_defs_record (collection_rec, PATTERN (insn_info->insn), bb, insn_info, 0);
- /* Process REG_EQUIV/REG_EQUAL notes */
- for (note = REG_NOTES (insn); note;
+ /* Process REG_EQUIV/REG_EQUAL notes. */
+ for (note = REG_NOTES (insn_info->insn); note;
note = XEXP (note, 1))
{
switch (REG_NOTE_KIND (note))
@@ -3300,20 +3308,18 @@ df_insn_refs_collect (struct df_collecti
case REG_EQUAL:
df_uses_record (collection_rec,
&XEXP (note, 0), DF_REF_REG_USE,
- bb, insn, DF_REF_IN_NOTE, -1, -1, 0);
+ bb, insn_info, DF_REF_IN_NOTE, -1, -1, 0);
break;
case REG_NON_LOCAL_GOTO:
/* The frame ptr is used by a non-local goto. */
df_ref_record (collection_rec,
regno_reg_rtx[FRAME_POINTER_REGNUM],
- NULL,
- bb, insn,
+ NULL, bb, insn_info,
DF_REF_REG_USE, 0, -1, -1, 0);
#if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
df_ref_record (collection_rec,
regno_reg_rtx[HARD_FRAME_POINTER_REGNUM],
- NULL,
- bb, insn,
+ NULL, bb, insn_info,
DF_REF_REG_USE, 0, -1, -1, 0);
#endif
break;
@@ -3322,13 +3328,13 @@ df_insn_refs_collect (struct df_collecti
}
}
- if (CALL_P (insn))
- df_get_call_refs (collection_rec, bb, insn,
+ if (CALL_P (insn_info->insn))
+ df_get_call_refs (collection_rec, bb, insn_info,
(is_cond_exec) ? DF_REF_CONDITIONAL : 0);
/* Record the register uses. */
df_uses_record (collection_rec,
- &PATTERN (insn), DF_REF_REG_USE, bb, insn, 0,
+ &PATTERN (insn_info->insn), DF_REF_REG_USE, bb, insn_info, 0,
-1, -1, 0);
/* DF_REF_CONDITIONAL needs corresponding USES. */
@@ -3351,16 +3357,16 @@ df_recompute_luids (basic_block bb)
/* Scan the block an insn at a time from beginning to end. */
FOR_BB_INSNS (bb, insn)
{
- struct df_insn_info *insn_info = DF_INSN_GET (insn);
+ struct df_insn_info *insn_info = DF_INSN_INFO_GET (insn);
/* Inserting labels does not always trigger the incremental
rescanning. */
if (!insn_info)
{
gcc_assert (!INSN_P (insn));
- df_insn_create_insn_record (insn);
+ insn_info = df_insn_create_insn_record (insn);
}
- DF_INSN_LUID (insn) = luid;
+ DF_INSN_INFO_LUID (insn_info) = luid;
if (INSN_P (insn))
luid++;
}
@@ -3499,18 +3505,18 @@ df_bb_refs_record (int bb_index, bool sc
/* Scan the block an insn at a time from beginning to end. */
FOR_BB_INSNS (bb, insn)
{
- struct df_insn_info *insn_info = DF_INSN_GET (insn);
+ struct df_insn_info *insn_info = DF_INSN_INFO_GET (insn);
gcc_assert (!insn_info);
- df_insn_create_insn_record (insn);
+ insn_info = df_insn_create_insn_record (insn);
if (INSN_P (insn))
{
/* Record refs within INSN. */
- DF_INSN_LUID (insn) = luid++;
- df_insn_refs_collect (&collection_rec, bb, insn);
+ DF_INSN_INFO_LUID (insn_info) = luid++;
+ df_insn_refs_collect (&collection_rec, bb, DF_INSN_INFO_GET (insn));
df_refs_add_to_chains (&collection_rec, bb, insn);
}
- DF_INSN_LUID (insn) = luid;
+ DF_INSN_INFO_LUID (insn_info) = luid;
}
/* Other block level artificial refs */
@@ -4272,8 +4278,9 @@ df_insn_refs_verify (struct df_collectio
{
bool ret1, ret2, ret3, ret4;
unsigned int uid = INSN_UID (insn);
+ struct df_insn_info *insn_info = DF_INSN_INFO_GET (insn);
- df_insn_refs_collect (collection_rec, bb, insn);
+ df_insn_refs_collect (collection_rec, bb, insn_info);
if (!DF_INSN_UID_DEFS (uid))
{
Index: df-problems.c
===================================================================
--- df-problems.c (revision 136868)
+++ df-problems.c (working copy)
@@ -129,7 +129,7 @@ df_chain_dump (struct df_link *link, FIL
DF_REF_REG_DEF_P (link->ref) ? 'd' : 'u',
DF_REF_ID (link->ref),
DF_REF_BBNO (link->ref),
- DF_REF_INSN (link->ref) ? DF_REF_INSN_UID (link->ref) : -1);
+ DF_REF_INSN_INFO (link->ref) ? DF_REF_INSN_UID (link->ref) : -1);
}
fprintf (file, "}");
}
@@ -1429,15 +1429,15 @@ df_live_bb_local_compute (unsigned int b
if (!insn_info)
{
gcc_assert (!INSN_P (insn));
- df_insn_create_insn_record (insn);
+ insn_info = df_insn_create_insn_record (insn);
}
- DF_INSN_LUID (insn) = luid;
+ DF_INSN_INFO_LUID (insn_info) = luid;
if (!INSN_P (insn))
continue;
luid++;
- for (def_rec = DF_INSN_UID_DEFS (uid); *def_rec; def_rec++)
+ for (def_rec = DF_INSN_INFO_DEFS (insn_info); *def_rec; def_rec++)
{
struct df_ref *def = *def_rec;
unsigned int regno = DF_REF_REGNO (def);
@@ -2201,14 +2201,14 @@ df_chain_top_dump (basic_block bb, FILE
FOR_BB_INSNS (bb, insn)
{
- unsigned int uid = INSN_UID (insn);
if (INSN_P (insn))
{
- def_rec = DF_INSN_UID_DEFS (uid);
+ struct df_insn_info *insn_info = DF_INSN_INFO_GET (insn);
+ def_rec = DF_INSN_INFO_DEFS (insn_info);
if (*def_rec)
{
fprintf (file, ";; DU chains for insn luid %d uid %d\n",
- DF_INSN_LUID (insn), uid);
+ DF_INSN_INFO_LUID (insn_info), INSN_UID (insn));
while (*def_rec)
{
@@ -2250,15 +2250,15 @@ df_chain_bottom_dump (basic_block bb, FI
FOR_BB_INSNS (bb, insn)
{
- unsigned int uid = INSN_UID (insn);
if (INSN_P (insn))
{
- struct df_ref **eq_use_rec = DF_INSN_UID_EQ_USES (uid);
- use_rec = DF_INSN_UID_USES (uid);
+ struct df_insn_info *insn_info = DF_INSN_INFO_GET (insn);
+ struct df_ref **eq_use_rec = DF_INSN_INFO_EQ_USES (insn_info);
+ use_rec = DF_INSN_INFO_USES (insn_info);
if (*use_rec || *eq_use_rec)
{
fprintf (file, ";; UD chains for insn luid %d uid %d\n",
- DF_INSN_LUID (insn), uid);
+ DF_INSN_INFO_LUID (insn_info), INSN_UID (insn));
while (*use_rec)
{
@@ -2515,8 +2515,9 @@ df_byte_lr_alloc (bitmap all_blocks ATTR
{
if (INSN_P (insn))
{
- df_byte_lr_check_regs (DF_INSN_DEFS (insn));
- df_byte_lr_check_regs (DF_INSN_USES (insn));
+ struct df_insn_info *insn_info = DF_INSN_INFO_GET (insn);
+ df_byte_lr_check_regs (DF_INSN_INFO_DEFS (insn_info));
+ df_byte_lr_check_regs (DF_INSN_INFO_USES (insn_info));
}
}
bitmap_set_bit (df_byte_lr->out_of_date_transfer_functions, bb->index);
Index: fwprop.c
===================================================================
--- fwprop.c (revision 136868)
+++ fwprop.c (working copy)
@@ -546,13 +546,13 @@ use_killed_between (struct df_ref *use,
/* See if USE is killed between DEF_INSN and the last insn in the
basic block containing DEF_INSN. */
x = df_bb_regno_last_def_find (def_bb, regno);
- if (x && DF_INSN_LUID (x->insn) >= DF_INSN_LUID (def_insn))
+ if (x && DF_INSN_LUID (DF_REF_INSN (x)) >= DF_INSN_LUID (def_insn))
return true;
/* See if USE is killed between TARGET_INSN and the first insn in the
basic block containing TARGET_INSN. */
x = df_bb_regno_first_def_find (target_bb, regno);
- if (x && DF_INSN_LUID (x->insn) < DF_INSN_LUID (target_insn))
+ if (x && DF_INSN_LUID (DF_REF_INSN (x)) < DF_INSN_LUID (target_insn))
return true;
return false;
@@ -570,6 +570,7 @@ static bool
all_uses_available_at (rtx def_insn, rtx target_insn)
{
struct df_ref **use_rec;
+ struct df_insn_info *insn_info = DF_INSN_INFO_GET (def_insn);
rtx def_set = single_set (def_insn);
gcc_assert (def_set);
@@ -583,13 +584,13 @@ all_uses_available_at (rtx def_insn, rtx
/* If the insn uses the reg that it defines, the substitution is
invalid. */
- for (use_rec = DF_INSN_USES (def_insn); *use_rec; use_rec++)
+ for (use_rec = DF_INSN_INFO_USES (insn_info); *use_rec; use_rec++)
{
struct df_ref *use = *use_rec;
if (rtx_equal_p (DF_REF_REG (use), def_reg))
return false;
}
- for (use_rec = DF_INSN_EQ_USES (def_insn); *use_rec; use_rec++)
+ for (use_rec = DF_INSN_INFO_EQ_USES (insn_info); *use_rec; use_rec++)
{
struct df_ref *use = *use_rec;
if (rtx_equal_p (use->reg, def_reg))
@@ -600,13 +601,13 @@ all_uses_available_at (rtx def_insn, rtx
{
/* Look at all the uses of DEF_INSN, and see if they are not
killed between DEF_INSN and TARGET_INSN. */
- for (use_rec = DF_INSN_USES (def_insn); *use_rec; use_rec++)
+ for (use_rec = DF_INSN_INFO_USES (insn_info); *use_rec; use_rec++)
{
struct df_ref *use = *use_rec;
if (use_killed_between (use, def_insn, target_insn))
return false;
}
- for (use_rec = DF_INSN_EQ_USES (def_insn); *use_rec; use_rec++)
+ for (use_rec = DF_INSN_INFO_EQ_USES (insn_info); *use_rec; use_rec++)
{
struct df_ref *use = *use_rec;
if (use_killed_between (use, def_insn, target_insn))
@@ -767,8 +768,9 @@ try_fwprop_subst (struct df_ref *use, rt
df_ref_remove (use);
if (!CONSTANT_P (new))
{
- update_df (insn, loc, DF_INSN_USES (def_insn), type, flags);
- update_df (insn, loc, DF_INSN_EQ_USES (def_insn), type, flags);
+ struct df_insn_info *insn_info = DF_INSN_INFO_GET (def_insn);
+ update_df (insn, loc, DF_INSN_INFO_USES (insn_info), type, flags);
+ update_df (insn, loc, DF_INSN_INFO_EQ_USES (insn_info), type, flags);
}
}
else
@@ -788,9 +790,10 @@ try_fwprop_subst (struct df_ref *use, rt
set_unique_reg_note? */
if (!CONSTANT_P (new))
{
- update_df (insn, loc, DF_INSN_USES (def_insn),
+ struct df_insn_info *insn_info = DF_INSN_INFO_GET (def_insn);
+ update_df (insn, loc, DF_INSN_INFO_USES (insn_info),
type, DF_REF_IN_NOTE);
- update_df (insn, loc, DF_INSN_EQ_USES (def_insn),
+ update_df (insn, loc, DF_INSN_INFO_EQ_USES (insn_info),
type, DF_REF_IN_NOTE);
}
}
Index: ddg.c
===================================================================
--- ddg.c (revision 136868)
+++ ddg.c (working copy)
@@ -289,7 +289,7 @@ add_cross_iteration_register_deps (ddg_p
deps when broken. If the first_def reaches the USE then
there is such a dep. */
ddg_node_ptr first_def_node = get_node_of_insn (g,
- first_def->insn);
+ DF_REF_INSN (first_def));
gcc_assert (first_def_node);
@@ -314,7 +314,7 @@ add_cross_iteration_register_deps (ddg_p
if (last_def->id == first_def->id)
return;
- dest_node = get_node_of_insn (g, first_def->insn);
+ dest_node = get_node_of_insn (g, DF_REF_INSN (first_def));
gcc_assert (dest_node);
create_ddg_dep_no_link (g, last_def_node, dest_node,
OUTPUT_DEP, REG_DEP, 1);
Index: web.c
===================================================================
--- web.c (revision 136868)
+++ web.c (working copy)
@@ -105,22 +105,24 @@ union_defs (struct df_ref *use, struct w
struct web_entry *use_entry,
bool (*fun) (struct web_entry *, struct web_entry *))
{
- rtx insn = DF_REF_INSN (use);
+ struct df_insn_info *insn_info = DF_REF_INSN_INFO (use);
struct df_link *link = DF_REF_CHAIN (use);
struct df_ref **use_link;
struct df_ref **eq_use_link;
struct df_ref **def_link;
rtx set;
- if (insn)
+ if (insn_info)
{
- use_link = DF_INSN_USES (insn);
- eq_use_link = DF_INSN_EQ_USES (insn);
- def_link = DF_INSN_DEFS (insn);
+ rtx insn = insn_info->insn;
+ use_link = DF_INSN_INFO_USES (insn_info);
+ eq_use_link = DF_INSN_INFO_EQ_USES (insn_info);
+ def_link = DF_INSN_INFO_DEFS (insn_info);
set = single_set (insn);
}
else
{
+ /* An artificial use. It links up with nothing. */
use_link = NULL;
eq_use_link = NULL;
def_link = NULL;
@@ -180,8 +182,8 @@ union_defs (struct df_ref *use, struct w
{
struct df_ref **link;
- if (DF_REF_INSN (use))
- link = DF_INSN_DEFS (DF_REF_INSN (use));
+ if (insn_info)
+ link = DF_INSN_INFO_DEFS (insn_info);
else
link = NULL;
Index: loop-invariant.c
===================================================================
--- loop-invariant.c (revision 136868)
+++ loop-invariant.c (working copy)
@@ -248,7 +248,7 @@ invariant_for_use (struct df_ref *use)
{
struct df_link *defs;
struct df_ref *def;
- basic_block bb = BLOCK_FOR_INSN (use->insn), def_bb;
+ basic_block bb = DF_REF_BB (use), def_bb;
if (use->flags & DF_REF_READ_WRITE)
return NULL;
@@ -768,13 +768,14 @@ check_dependency (basic_block bb, struct
static bool
check_dependencies (rtx insn, bitmap depends_on)
{
+ struct df_insn_info *insn_info = DF_INSN_INFO_GET (insn);
struct df_ref **use_rec;
basic_block bb = BLOCK_FOR_INSN (insn);
- for (use_rec = DF_INSN_USES (insn); *use_rec; use_rec++)
+ for (use_rec = DF_INSN_INFO_USES (insn_info); *use_rec; use_rec++)
if (!check_dependency (bb, *use_rec, depends_on))
return false;
- for (use_rec = DF_INSN_EQ_USES (insn); *use_rec; use_rec++)
+ for (use_rec = DF_INSN_INFO_EQ_USES (insn_info); *use_rec; use_rec++)
if (!check_dependency (bb, *use_rec, depends_on))
return false;
@@ -850,17 +851,18 @@ find_invariant_insn (rtx insn, bool alwa
static void
record_uses (rtx insn)
{
+ struct df_insn_info *insn_info = DF_INSN_INFO_GET (insn);
struct df_ref **use_rec;
struct invariant *inv;
- for (use_rec = DF_INSN_USES (insn); *use_rec; use_rec++)
+ for (use_rec = DF_INSN_INFO_USES (insn_info); *use_rec; use_rec++)
{
struct df_ref *use = *use_rec;
inv = invariant_for_use (use);
if (inv)
record_use (inv->def, DF_REF_REAL_LOC (use), DF_REF_INSN (use));
}
- for (use_rec = DF_INSN_EQ_USES (insn); *use_rec; use_rec++)
+ for (use_rec = DF_INSN_INFO_EQ_USES (insn_info); *use_rec; use_rec++)
{
struct df_ref *use = *use_rec;
inv = invariant_for_use (use);
Index: dce.c
===================================================================
--- dce.c (revision 136868)
+++ dce.c (working copy)
@@ -154,12 +154,10 @@ deletable_insn_p (rtx insn, bool fast)
static inline int
marked_insn_p (rtx insn)
{
- if (insn)
- return TEST_BIT (marked, INSN_UID (insn));
- else
- /* Artificial defs are always needed and they do not have an
- insn. */
- return true;
+ /* Artificial defs are always needed and they do not have an insn.
+ We should never see them here. */
+ gcc_assert (insn);
+ return TEST_BIT (marked, INSN_UID (insn));
}
@@ -339,7 +337,8 @@ mark_artificial_uses (void)
for (use_rec = df_get_artificial_uses (bb->index);
*use_rec; use_rec++)
for (defs = DF_REF_CHAIN (*use_rec); defs; defs = defs->next)
- mark_insn (DF_REF_INSN (defs->ref), false);
+ if (! DF_REF_IS_ARTIFICIAL (defs->ref))
+ mark_insn (DF_REF_INSN (defs->ref), false);
}
}
@@ -362,7 +361,8 @@ mark_reg_dependencies (rtx insn)
fprintf (dump_file, " in insn %d:\n", INSN_UID (insn));
}
for (defs = DF_REF_CHAIN (use); defs; defs = defs->next)
- mark_insn (DF_REF_INSN (defs->ref), false);
+ if (! DF_REF_IS_ARTIFICIAL (defs->ref))
+ mark_insn (DF_REF_INSN (defs->ref), false);
}
}