From: steven Date: Wed, 18 Jun 2008 05:42:23 +0000 (+0000) Subject: * df.h (struct df_ref): Replace 'insn' field with 'insn_info' field. X-Git-Url: http://git.sourceforge.jp/view?p=pf3gnuchains%2Fgcc-fork.git;a=commitdiff_plain;h=158b6cc9bfed6b3b97b121d8ce7f4e62c2382651;hp=594fa6a7f0bfd36eb2f23d88f7832856d517d1e4 * 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-core.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. * doc/rtl.texi: Remove documentation of ADDRESSOF. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@136885 138bc75d-0d04-0410-961f-82ee72b054a4 --- diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 51d1b34e7dc..c65ec1ed14e 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,48 @@ +2008-06-18 Steven Bosscher + + * 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-core.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. + + * doc/rtl.texi: Remove documentation of ADDRESSOF. + 2008-06-17 Ralf Wildenhues * configure: Regenerate. diff --git a/gcc/dce.c b/gcc/dce.c index b75a8b1b113..31a5f51ac1c 100644 --- a/gcc/dce.c +++ b/gcc/dce.c @@ -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); } } diff --git a/gcc/ddg.c b/gcc/ddg.c index 14b18745823..1f8c1406fc4 100644 --- a/gcc/ddg.c +++ b/gcc/ddg.c @@ -289,7 +289,7 @@ add_cross_iteration_register_deps (ddg_ptr g, struct df_ref *last_def) 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_ptr g, struct df_ref *last_def) 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); diff --git a/gcc/df-core.c b/gcc/df-core.c index 95932909ebb..9e23c759469 100644 --- a/gcc/df-core.c +++ b/gcc/df-core.c @@ -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_chain, FILE *file) 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 *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)) diff --git a/gcc/df-problems.c b/gcc/df-problems.c index 043cf38398f..b9f5eecec08 100644 --- a/gcc/df-problems.c +++ b/gcc/df-problems.c @@ -129,7 +129,7 @@ df_chain_dump (struct df_link *link, FILE *file) 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 bb_index) 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 *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, FILE *file) 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 ATTRIBUTE_UNUSED) { 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); diff --git a/gcc/df-scan.c b/gcc/df-scan.c index 6a34bf77300..966fd4b255f 100644 --- a/gcc/df-scan.c +++ b/gcc/df-scan.c @@ -94,26 +94,28 @@ static struct df_mw_hardreg * df_null_mw_rec[1]; 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 insn, /* 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_reg_info *old, struct df_reg_info *new, } 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, struct df_ref *ref2) (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_collection_rec *collection_rec, { 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_collection_rec *collection_rec, 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_collection_rec *collection_rec, 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_collection_rec *collection_rec, 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 *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 *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 *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_rec *collection_rec, 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_rec *collection_rec, 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_rec *collection_rec, 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_rec *collection_rec, 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 *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 *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 *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 *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 *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 *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 *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 *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 *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 *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 *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 *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 *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 *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 *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 *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 *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_collection_rec *collection_rec) 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_collection_rec *collection_rec) 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_rec * collection_rec, /* 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_rec * collection_rec, 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_rec * collection_rec, 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_rec * collection_rec, || 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_rec * collection_rec, 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_collection_rec* collection_rec, 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_collection_rec* collection_rec, 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_collection_rec* collection_rec, } } - 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 scan_insns) /* 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_collection_rec *collection_rec, { 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)) { diff --git a/gcc/df.h b/gcc/df.h index bd4d7ff7aca..30e98507d41 100644 --- a/gcc/df.h +++ b/gcc/df.h @@ -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)) diff --git a/gcc/doc/rtl.texi b/gcc/doc/rtl.texi index 10e4999ca9f..a901a17b2a3 100644 --- a/gcc/doc/rtl.texi +++ b/gcc/doc/rtl.texi @@ -2018,14 +2018,6 @@ The construct @code{(mem:BLK (scratch))} is considered to alias all other memories. Thus it may be used as a memory barrier in epilogue stack deallocation patterns. -@findex addressof -@item (addressof:@var{m} @var{reg}) -This RTX represents a request for the address of register @var{reg}. Its mode -is always @code{Pmode}. If there are any @code{addressof} -expressions left in the function after CSE, @var{reg} is forced into the -stack and the @code{addressof} expression is replaced with a @code{plus} -expression for the address of its stack slot. - @findex concat @item (concat@var{m} @var{rtx} @var{rtx}) This RTX represents the concatenation of two other RTXs. This is used diff --git a/gcc/fwprop.c b/gcc/fwprop.c index 35bc230fa34..6456b0eae02 100644 --- a/gcc/fwprop.c +++ b/gcc/fwprop.c @@ -546,13 +546,13 @@ use_killed_between (struct df_ref *use, rtx def_insn, rtx target_insn) /* 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 target_insn) /* 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 target_insn) { /* 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, rtx *loc, rtx new, rtx def_insn, bool set_ 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, rtx *loc, rtx new, rtx def_insn, bool set_ 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); } } diff --git a/gcc/loop-invariant.c b/gcc/loop-invariant.c index 66773075dd6..dd75b3a3a8f 100644 --- a/gcc/loop-invariant.c +++ b/gcc/loop-invariant.c @@ -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 df_ref *use, bitmap depends_on) 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 always_reached, bool always_executed) 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); diff --git a/gcc/web.c b/gcc/web.c index 84987df5e1f..d04e8a22890 100644 --- a/gcc/web.c +++ b/gcc/web.c @@ -105,22 +105,24 @@ union_defs (struct df_ref *use, struct web_entry *def_entry, 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 web_entry *def_entry, { 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;