OSDN Git Service

* df.h (struct df_ref): Replace 'insn' field with 'insn_info' field.
authorsteven <steven@138bc75d-0d04-0410-961f-82ee72b054a4>
Wed, 18 Jun 2008 05:42:23 +0000 (05:42 +0000)
committersteven <steven@138bc75d-0d04-0410-961f-82ee72b054a4>
Wed, 18 Jun 2008 05:42:23 +0000 (05:42 +0000)
(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

gcc/ChangeLog
gcc/dce.c
gcc/ddg.c
gcc/df-core.c
gcc/df-problems.c
gcc/df-scan.c
gcc/df.h
gcc/doc/rtl.texi
gcc/fwprop.c
gcc/loop-invariant.c
gcc/web.c

index 51d1b34..c65ec1e 100644 (file)
@@ -1,3 +1,48 @@
+2008-06-18  Steven Bosscher  <steven@gcc.gnu.org>
+
+       * 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  <Ralf.Wildenhues@gmx.de>
 
        * configure: Regenerate.
index b75a8b1..31a5f51 100644 (file)
--- 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);
     }
 }
 
index 14b1874..1f8c140 100644 (file)
--- 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);
index 9593290..9e23c75 100644 (file)
@@ -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))
index 043cf38..b9f5eec 100644 (file)
@@ -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);
index 6a34bf7..966fd4b 100644 (file)
@@ -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))
     {
index bd4d7ff..30e9850 100644 (file)
--- 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))
index 10e4999..a901a17 100644 (file)
@@ -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
index 35bc230..6456b0e 100644 (file)
@@ -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);
            }
        }
index 6677307..dd75b3a 100644 (file)
@@ -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);
index 84987df..d04e8a2 100644 (file)
--- 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;