Re: [PATCH]: Replace backend dataflow

[Kenneth Zadeck <Kenneth dot Zadeck at NaturalBridge dot com>]

Ian, 

As per the chat last night...

The enclosed patch updates the previous dataflow patch in order to
make it consistent to the changes that zdenek did to the old version
of df and loop-invariant.


> On Thu, 2005-12-22 at 00:03 -0500, Daniel Berlin wrote:
> > This is a port of a recently committed patch from dataflow-branch, to
> > mainline.
> > 
> > 
> 
> I forgot to mention that this patch depends on the bitmap patch in
> http://gcc.gnu.org/ml/gcc-patches/2005-12/msg00633.html

===File ~/patches/dataflow/dataflow17.diff==================
Index: df-core.c
===================================================================
--- df-core.c	(revision 109148)
+++ df-core.c	(working copy)
@@ -1016,31 +992,58 @@ df_find_def (struct df *df, rtx insn, rt
   unsigned int uid;
   struct df_ref *def;
 
+  if (GET_CODE (reg) == SUBREG)
+    reg = SUBREG_REG (reg);
+  gcc_assert (REG_P (reg));
+
   uid = INSN_UID (insn);
   for (def = DF_INSN_UID_GET (df, uid)->defs; def; def = def->next_ref)
-    if (rtx_equal_p (DF_REF_REG (def), reg))
+    if (rtx_equal_p (DF_REF_REAL_REG (def), reg))
       return def;
 
   return NULL;
 }
 
 
-/* Return true if REG is referenced in INSN, zero otherwise.  */ 
+/* Return true if REG is defined in INSN, zero otherwise.  */ 
+
+bool
+df_reg_defined (struct df *df, rtx insn, rtx reg)
+{
+  return df_find_def (df, insn, reg) != NULL;
+}
+  
 
+/* Finds the reference corresponding to the use of REG in INSN.
+   DF is the dataflow object.  */
+  
 struct df_ref *
 df_find_use (struct df *df, rtx insn, rtx reg)
 {
   unsigned int uid;
   struct df_ref *use;
 
+  if (GET_CODE (reg) == SUBREG)
+    reg = SUBREG_REG (reg);
+  gcc_assert (REG_P (reg));
+
   uid = INSN_UID (insn);
   for (use = DF_INSN_UID_GET (df, uid)->uses; use; use = use->next_ref)
-    if (rtx_equal_p (DF_REF_REG (use), reg))
+    if (rtx_equal_p (DF_REF_REAL_REG (use), reg))
       return use; 
 
   return NULL;
 }
 
+
+/* Return true if REG is referenced in INSN, zero otherwise.  */ 
+
+bool
+df_reg_used (struct df *df, rtx insn, rtx reg)
+{
+  return df_find_use (df, insn, reg) != NULL;
+}
+  
 
 /****************************************************************************/
 /* Debugging and printing functions.                                        */
Index: df.h
===================================================================
--- df.h	(revision 109148)
+++ df.h	(working copy)
@@ -310,13 +310,6 @@ struct df
   bitmap exit_block_uses;        /* The set of hardware registers used in exit block.  */
 };
 
-struct df_map
-{
-  rtx old;
-  rtx new;
-};
-
-
 #define DF_SCAN_BB_INFO(DF, BB) (df_scan_get_bb_info((DF)->problems_by_index[DF_SCAN],(BB)->index))
 #define DF_RU_BB_INFO(DF, BB) (df_ru_get_bb_info((DF)->problems_by_index[DF_RU],(BB)->index))
 #define DF_RD_BB_INFO(DF, BB) (df_rd_get_bb_info((DF)->problems_by_index[DF_RD],(BB)->index))
@@ -515,7 +508,9 @@ extern struct df_ref * df_bb_regno_first
 extern struct df_ref * df_bb_regno_last_def_find (struct df *, basic_block, unsigned int);
 extern bool df_insn_regno_def_p (struct df *, rtx, unsigned int);
 extern struct df_ref * df_find_def (struct df *, rtx, rtx);
+extern bool df_reg_defined (struct df *, rtx, rtx);
 extern struct df_ref * df_find_use (struct df *, rtx, rtx);
+extern bool df_reg_used (struct df *, rtx, rtx);
 extern void df_iterative_dataflow (struct dataflow *, bitmap, bitmap, int *, int, bool);
 extern void df_dump (struct df *, FILE *);
 extern void df_chain_dump (struct df *, struct df_link *, FILE *);
Index: loop-invariant.c
===================================================================
--- loop-invariant.c	(revision 109149)
+++ loop-invariant.c	(working copy)
@@ -226,10 +226,10 @@ check_maybe_invariant (rtx x)
    invariant.  */
 
 static struct invariant *
-invariant_for_use (struct ref *use)
+invariant_for_use (struct df_ref *use)
 {
   struct df_link *defs;
-  struct ref *def;
+  struct df_ref *def;
   basic_block bb = BLOCK_FOR_INSN (use->insn), def_bb;
 
   defs = DF_REF_CHAIN (use);
@@ -255,7 +255,7 @@ hash_invariant_expr_1 (rtx insn, rtx x)
   const char *fmt;
   hashval_t val = code;
   int do_not_record_p;
-  struct ref *use;
+  struct df_ref *use;
   struct invariant *inv;
 
   switch (code)
@@ -306,7 +306,7 @@ invariant_expr_equal_p (rtx insn1, rtx e
   enum rtx_code code = GET_CODE (e1);
   int i, j;
   const char *fmt;
-  struct ref *use1, *use2;
+  struct df_ref *use1, *use2;
   struct invariant *inv1 = NULL, *inv2 = NULL;
   rtx sub1, sub2;
 
@@ -673,16 +674,14 @@ record_use (struct def *def, rtx *use, r
 static bool
 check_dependencies (rtx insn, bitmap depends_on)
 {
-  struct df_link *uses, *defs;
-  struct ref *use, *def;
+  struct df_link *defs;
+  struct df_ref *use, *def;
   basic_block bb = BLOCK_FOR_INSN (insn), def_bb;
   struct def *def_data;
   struct invariant *inv;
 
-  for (uses = DF_INSN_USES (df, insn); uses; uses = uses->next)
+  for (use = DF_INSN_GET (df, insn)->uses; use; use = use->next_ref)
     {
-      use = uses->ref;
-
       defs = DF_REF_CHAIN (use);
       if (!defs)
 	continue;
@@ -781,13 +780,11 @@ find_invariant_insn (rtx insn, bool alwa
 static void
 record_uses (rtx insn)
 {
-  struct df_link *uses;
-  struct ref *use;
+  struct df_ref *use;
   struct invariant *inv;
 
-  for (uses = DF_INSN_USES (df, insn); uses; uses = uses->next)
+  for (use = DF_INSN_GET (df, insn)->uses; use; use = use->next_ref)
     {
-      use = uses->ref;
       inv = invariant_for_use (use);
       if (inv)
 	record_use (inv->def, DF_REF_LOC (use), DF_REF_INSN (use));
@@ -1098,8 +1096,7 @@ move_invariant_reg (struct loop *loop, u
 	 need to create a temporary register.  */
       set = single_set (inv->insn);
       reg = gen_reg_rtx (GET_MODE (SET_DEST (set)));
-      df_pattern_emit_after (df, gen_move_insn (SET_DEST (set), reg),
-			     BLOCK_FOR_INSN (inv->insn), inv->insn);
+      emit_insn_after (gen_move_insn (SET_DEST (set), reg), inv->insn);
 
       /* If the SET_DEST of the invariant insn is a reg, we can just move
 	 the insn out of the loop.  Otherwise, we have to use gen_move_insn
@@ -1108,13 +1105,11 @@ move_invariant_reg (struct loop *loop, u
 	{
 	  SET_DEST (set) = reg;
 	  reorder_insns (inv->insn, inv->insn, BB_END (preheader));
-	  df_insn_modify (df, preheader, inv->insn);
 	}
       else
 	{
-	  df_pattern_emit_after (df, gen_move_insn (reg, SET_SRC (set)),
-				 preheader, BB_END (preheader));
-	  df_insn_delete (df, BLOCK_FOR_INSN (inv->insn), inv->insn);
+	  emit_insn_after (gen_move_insn (reg, SET_SRC (set)), BB_END (preheader));
+	  delete_insn (inv->insn);
 	}
     }
   else
@@ -1122,9 +1117,8 @@ move_invariant_reg (struct loop *loop, u
       move_invariant_reg (loop, repr->invno);
       reg = repr->reg;
       set = single_set (inv->insn);
-      df_pattern_emit_after (df, gen_move_insn (SET_DEST (set), reg),
-			     BLOCK_FOR_INSN (inv->insn), inv->insn);
-      df_insn_delete (df, BLOCK_FOR_INSN (inv->insn), inv->insn);
+      emit_insn_after (gen_move_insn (SET_DEST (set), reg), inv->insn);
+      delete_insn (inv->insn);
     }
 
   inv->reg = reg;
============================================================