Patchwork [RFA] remove more df_byte_scan corpses

login
register
mail settings
Submitter Paolo Bonzini
Date Aug. 16, 2010, 10:31 p.m.
Message ID <4C69BC3B.9040001@gnu.org>
Download mbox | patch
Permalink /patch/61844/
State New
Headers show

Comments

Paolo Bonzini - Aug. 16, 2010, 10:31 p.m.
The whole DF_REF_EXTRACT machinery can be eliminated, and only the flags 
left in for the benefit of IRA.

Bootstrapped/regtested x86_64-pc-linux-gnu, ok?

Paolo
2010-08-17  Paolo Bonzini  <bonzini@gnu.org>

        * df.h (enum df_ref_class): Remove DF_REF_EXTRACT.
        (struct df_extract_ref): Remove.
        (union df_ref_d): Remove extract_ref member.
        (df_ref_create): Remove last three arguments.
        (DF_REF_LOC): Remove DF_REF_EXTRACT case.
        * df-scan.c (df_ref_record): Remove last three arguments, do not
        pass them to df_ref_create_structure.
        (df_uses_record): Remove first and last three arguments.  Replace
        first argument with DF_REF_REGULAR, adjust calls to remove the
        width, offset and mode.  Always call recursively on the second
        and third argument of ZERO_EXTRACT and SIGN_EXTRACT.
        (df_ref_create_structure): Remove first argument.
        (struct df_scan_problem_data): Remove ref_extract_pool.
        (df_scan_free_internal): Do not free it.
        (df_scan_alloc): Do not allocate it.
        (df_ref_create): Remove last three arguments, do not pass them to
        df_ref_create_structure.
        (df_free_ref): Remove DF_REF_EXTRACT case.
        (df_notes_rescan): Adjust call to df_uses_record.
        (df_ref_equal_p, df_ref_compare, df_ref_create_structure):
        Remove DF_REF_EXTRACT case.
        (df_def_record_1): Do not special case class for a ZERO_EXTRACT lhs.
        Adjust calls to df_ref_record, using DF_REF_REGULAR for all REG
        and SUBREG definitions.
        (df_get_conditional_uses): Remove references to width/offset/mode,
        adjust call to df_ref_create_structure.
        (df_get_call_refs, df_insn_refs_collect, df_bb_refs_collect,
        df_entry_block_defs_collect, df_exit_block_uses_collect): Adjust
        calls to df_uses_record and df_ref_record.
        * fwprop.c (update_df): Remove references to width/offset/mode,
        adjust call to df_ref_create.
Bernd Schmidt - Aug. 17, 2010, 12:03 a.m.
On 08/17/2010 12:31 AM, Paolo Bonzini wrote:
> The whole DF_REF_EXTRACT machinery can be eliminated, and only the flags
> left in for the benefit of IRA.
> 
> Bootstrapped/regtested x86_64-pc-linux-gnu, ok?

Looks ok to me.

I wonder if there's any point to DF_REF_*_EXTRACT, and why there's a
need to have both DF_REF_PARTIAL and DF_REF_READ_WRITE?


Bernd
Paolo Bonzini - Aug. 17, 2010, 12:13 a.m.
On 08/17/2010 02:03 AM, Bernd Schmidt wrote:
> On 08/17/2010 12:31 AM, Paolo Bonzini wrote:
>> The whole DF_REF_EXTRACT machinery can be eliminated, and only the flags
>> left in for the benefit of IRA.
>>
>> Bootstrapped/regtested x86_64-pc-linux-gnu, ok?
>
> Looks ok to me.
>
> I wonder if there's any point to DF_REF_*_EXTRACT

IRA uses it, I don't know it well enough to understand why.  I thought 
about simplifying DF_REF_SIGN_EXTRACT vs. DF_REF_ZERO_EXTRACT, but since 
there is also DF_REF_STRICT_LOW_PART (and IRA uses it too, 
distinguishing DF_REF_ZERO_EXTRACT and DF_REF_STRICT_LOW_PART) it would 
be incoherent and generally it would probably lose readability.

> and why there's a need to have both DF_REF_PARTIAL and DF_REF_READ_WRITE?

DF_REF_READ_WRITE is only set for subregs which appear on the LHS of a set.

Paolo

Patch

Index: df.h
===================================================================
--- df.h	(revision 162940)
+++ df.h	(working copy)
@@ -67,7 +67,7 @@  enum df_flow_dir
   };
 
 /* Descriminator for the various df_ref types.  */
-enum df_ref_class {DF_REF_BASE, DF_REF_ARTIFICIAL, DF_REF_REGULAR, DF_REF_EXTRACT};
+enum df_ref_class {DF_REF_BASE, DF_REF_ARTIFICIAL, DF_REF_REGULAR};
 
 /* The first of these us a set of a registers.  The remaining three
    are all uses of a register (the mem_load and mem_store relate to
@@ -402,26 +402,12 @@  struct df_regular_ref
   rtx *loc;
 };
 
-
-/* A df_ref_extract is just a df_ref with a width and offset field at
-   the end of it.  It is used to hold this information if the ref was
-   wrapped by a SIGN_EXTRACT or a ZERO_EXTRACT and to pass this info
-   to passes that wish to process partial regs precisely.  */
-struct df_extract_ref
-{
-  struct df_regular_ref base;
-  int width;
-  int offset;
-  enum machine_mode mode;
-};
-
 /* Union of the different kinds of defs/uses placeholders.  */
 union df_ref_d
 {
   struct df_base_ref base;
   struct df_regular_ref regular_ref;
   struct df_artificial_ref artificial_ref;
-  struct df_extract_ref extract_ref;
 };
 typedef union df_ref_d *df_ref;
 
@@ -645,7 +631,7 @@  struct df_d
 #define DF_REF_REAL_LOC(REF) (GET_CODE (*((REF)->regular_ref.loc)) == SUBREG \
                                ? &SUBREG_REG (*((REF)->regular_ref.loc)) : ((REF)->regular_ref.loc))
 #define DF_REF_REG(REF) ((REF)->base.reg)
-#define DF_REF_LOC(REF) ((DF_REF_CLASS(REF) == DF_REF_REGULAR || DF_REF_CLASS(REF) == DF_REF_EXTRACT) ? \
+#define DF_REF_LOC(REF) (DF_REF_CLASS(REF) == DF_REF_REGULAR ? \
 			 (REF)->regular_ref.loc : NULL)
 #define DF_REF_BB(REF) (DF_REF_IS_ARTIFICIAL(REF) ? \
                         (REF)->artificial_ref.bb : BLOCK_FOR_INSN (DF_REF_INSN(REF)))
@@ -994,8 +980,7 @@  extern void df_grow_reg_info (void);
 extern void df_grow_insn_info (void);
 extern void df_scan_blocks (void);
 extern df_ref df_ref_create (rtx, rtx *, rtx,basic_block,
-				     enum df_ref_type, int ref_flags,
-				     int, int, enum machine_mode);
+			     enum df_ref_type, int ref_flags);
 extern void df_ref_remove (df_ref);
 extern struct df_insn_info * df_insn_create_insn_record (rtx);
 extern void df_insn_delete (basic_block, unsigned int);
Index: df-scan.c
===================================================================
--- df-scan.c	(revision 162940)
+++ df-scan.c	(working copy)
@@ -110,26 +110,22 @@  static struct df_mw_hardreg * df_null_mw
 static void df_ref_record (enum df_ref_class, struct df_collection_rec *,
 			   rtx, rtx *,
 			   basic_block, struct df_insn_info *,
-			   enum df_ref_type, int ref_flags,
-			   int, int, enum machine_mode);
+			   enum df_ref_type, int ref_flags);
 static void df_def_record_1 (struct df_collection_rec *, rtx,
 			     basic_block, struct df_insn_info *,
 			     int ref_flags);
 static void df_defs_record (struct df_collection_rec *, rtx,
 			    basic_block, struct df_insn_info *,
 			    int ref_flags);
-static void df_uses_record (enum df_ref_class, struct df_collection_rec *,
+static void df_uses_record (struct df_collection_rec *,
 			    rtx *, enum df_ref_type,
 			    basic_block, struct df_insn_info *,
-			    int ref_flags,
-			    int, int, enum machine_mode);
+			    int ref_flags);
 
 static df_ref df_ref_create_structure (enum df_ref_class,
 				       struct df_collection_rec *, rtx, rtx *,
 				       basic_block, struct df_insn_info *,
-				       enum df_ref_type, int ref_flags,
-				       int, int, enum machine_mode);
-
+				       enum df_ref_type, int ref_flags);
 static void df_insn_refs_collect (struct df_collection_rec*,
 				  basic_block, struct df_insn_info *);
 static void df_canonize_collection_rec (struct df_collection_rec *);
@@ -182,7 +178,6 @@  struct df_scan_problem_data
   alloc_pool ref_base_pool;
   alloc_pool ref_artificial_pool;
   alloc_pool ref_regular_pool;
-  alloc_pool ref_extract_pool;
   alloc_pool insn_pool;
   alloc_pool reg_pool;
   alloc_pool mw_reg_pool;
@@ -269,7 +264,6 @@  df_scan_free_internal (void)
   free_alloc_pool (problem_data->ref_base_pool);
   free_alloc_pool (problem_data->ref_artificial_pool);
   free_alloc_pool (problem_data->ref_regular_pool);
-  free_alloc_pool (problem_data->ref_extract_pool);
   free_alloc_pool (problem_data->insn_pool);
   free_alloc_pool (problem_data->reg_pool);
   free_alloc_pool (problem_data->mw_reg_pool);
@@ -344,9 +338,6 @@  df_scan_alloc (bitmap all_blocks ATTRIBU
   problem_data->ref_regular_pool
     = create_alloc_pool ("df_scan ref regular",
 			 sizeof (struct df_regular_ref), block_size);
-  problem_data->ref_extract_pool
-    = create_alloc_pool ("df_scan ref extract",
-			 sizeof (struct df_extract_ref), block_size);
   problem_data->insn_pool
     = create_alloc_pool ("df_scan insn",
 			 sizeof (struct df_insn_info), block_size);
@@ -689,19 +680,13 @@  df_scan_blocks (void)
 
 
 /* Create a new ref of type DF_REF_TYPE for register REG at address
-   LOC within INSN of BB.  This function is only used externally.
-
-   If the REF_FLAGS field contain DF_REF_SIGN_EXTRACT or
-   DF_REF_ZERO_EXTRACT.  WIDTH, OFFSET and MODE are used to access the
-   fields if they were constants.  Otherwise they should be -1 if
-   those flags were set.  */
+   LOC within INSN of BB.  This function is only used externally.  */
 
 df_ref
 df_ref_create (rtx reg, rtx *loc, rtx insn,
 	       basic_block bb,
 	       enum df_ref_type ref_type,
-	       int ref_flags,
-	       int width, int offset, enum machine_mode mode)
+	       int ref_flags)
 {
   df_ref ref;
   struct df_reg_info **reg_info;
@@ -717,15 +702,12 @@  df_ref_create (rtx reg, rtx *loc, rtx in
   /* You cannot hack artificial refs.  */
   gcc_assert (insn);
 
-  if (width != -1 || offset != -1)
-    cl = DF_REF_EXTRACT;
-  else if (loc)
+  if (loc)
     cl = DF_REF_REGULAR;
   else
     cl = DF_REF_BASE;
   ref = df_ref_create_structure (cl, NULL, reg, loc, bb, DF_INSN_INFO_GET (insn),
-                                 ref_type, ref_flags,
-				 width, offset, mode);
+                                 ref_type, ref_flags);
 
   if (DF_REF_REG_DEF_P (ref))
     {
@@ -843,10 +825,6 @@  df_free_ref (df_ref ref)
     case DF_REF_REGULAR:
       pool_free (problem_data->ref_regular_pool, ref);
       break;
-
-    case DF_REF_EXTRACT:
-      pool_free (problem_data->ref_extract_pool, ref);
-      break;
     }
 }
 
@@ -2013,7 +1991,7 @@  df_ref_change_reg_with_loc_1 (struct df_
   while (the_ref)
     {
       if ((!DF_REF_IS_ARTIFICIAL (the_ref))
-	  && (DF_REF_LOC (the_ref))
+	  && DF_REF_LOC (the_ref)
 	  && (*DF_REF_LOC (the_ref) == loc))
 	{
 	  df_ref next_ref = DF_REF_NEXT_REG (the_ref);
@@ -2216,9 +2194,9 @@  df_notes_rescan (rtx insn)
 	    {
 	    case REG_EQUIV:
 	    case REG_EQUAL:
-	      df_uses_record (DF_REF_REGULAR, &collection_rec,
+	      df_uses_record (&collection_rec,
 			      &XEXP (note, 0), DF_REF_REG_USE,
-			      bb, insn_info, DF_REF_IN_NOTE, -1, -1, VOIDmode);
+			      bb, insn_info, DF_REF_IN_NOTE);
 	    default:
 	      break;
 	    }
@@ -2312,13 +2290,6 @@  df_ref_equal_p (df_ref ref1, df_ref ref2
     case DF_REF_BASE:
       return true;
 
-    case DF_REF_EXTRACT:
-      if ((DF_REF_EXTRACT_OFFSET (ref1) != DF_REF_EXTRACT_OFFSET (ref2))
-	  || (DF_REF_EXTRACT_WIDTH (ref1) != DF_REF_EXTRACT_WIDTH (ref2))
-	  || (DF_REF_EXTRACT_MODE (ref1) != DF_REF_EXTRACT_MODE (ref2)))
-	return false;
-      /* fallthru.  */
-
     case DF_REF_REGULAR:
       return DF_REF_LOC (ref1) == DF_REF_LOC (ref2);
 
@@ -2373,17 +2344,6 @@  df_ref_compare (const void *r1, const vo
 	return 1;
     }
 
-  /* The classes are the same at this point so it is safe to only look
-     at ref1.  */
-  if (DF_REF_CLASS (ref1) == DF_REF_EXTRACT)
-    {
-      if (DF_REF_EXTRACT_OFFSET (ref1) != DF_REF_EXTRACT_OFFSET (ref2))
-	return DF_REF_EXTRACT_OFFSET (ref1) - DF_REF_EXTRACT_OFFSET (ref2);
-      if (DF_REF_EXTRACT_WIDTH (ref1) != DF_REF_EXTRACT_WIDTH (ref2))
-	return DF_REF_EXTRACT_WIDTH (ref1) - DF_REF_EXTRACT_WIDTH (ref2);
-      if (DF_REF_EXTRACT_MODE (ref1) != DF_REF_EXTRACT_MODE (ref2))
-	return DF_REF_EXTRACT_MODE (ref1) - DF_REF_EXTRACT_MODE (ref2);
-    }
   return (int)DF_REF_ORDER (ref1) - (int)DF_REF_ORDER (ref2);
 }
 
@@ -2764,12 +2724,7 @@  df_refs_add_to_chains (struct df_collect
 }
 
 
-/* Allocate a ref and initialize its fields.
-
-   If the REF_FLAGS field contain DF_REF_SIGN_EXTRACT or
-   DF_REF_ZERO_EXTRACT.  WIDTH, OFFSET and MODE are used to access the fields
-   if they were constants.  Otherwise they should be -1 if those flags
-   were set.  */
+/* Allocate a ref and initialize its fields.  */
 
 static df_ref
 df_ref_create_structure (enum df_ref_class cl,
@@ -2777,8 +2732,7 @@  df_ref_create_structure (enum df_ref_cla
 			 rtx reg, rtx *loc,
 			 basic_block bb, struct df_insn_info *info,
 			 enum df_ref_type ref_type,
-			 int ref_flags,
-			 int width, int offset, enum machine_mode mode)
+			 int ref_flags)
 {
   df_ref this_ref = NULL;
   int regno = REGNO (GET_CODE (reg) == SUBREG ? SUBREG_REG (reg) : reg);
@@ -2803,15 +2757,6 @@  df_ref_create_structure (enum df_ref_cla
       this_ref->regular_ref.loc = loc;
       gcc_checking_assert (loc);
       break;
-
-    case DF_REF_EXTRACT:
-      this_ref = (df_ref) pool_alloc (problem_data->ref_extract_pool);
-      DF_REF_EXTRACT_WIDTH (this_ref) = width;
-      DF_REF_EXTRACT_OFFSET (this_ref) = offset;
-      DF_REF_EXTRACT_MODE (this_ref) = mode;
-      this_ref->regular_ref.loc = loc;
-      gcc_checking_assert (loc);
-      break;
     }
 
   DF_REF_CLASS (this_ref) = cl;
@@ -2861,12 +2806,7 @@  df_ref_create_structure (enum df_ref_cla
 
 
 /* Create new references of type DF_REF_TYPE for each part of register REG
-   at address LOC within INSN of BB.
-
-   If the REF_FLAGS field contain DF_REF_SIGN_EXTRACT or
-   DF_REF_ZERO_EXTRACT.  WIDTH, OFFSET and MODE are used to access the
-   fields if they were constants.  Otherwise they should be -1 if
-   those flags were set.  */
+   at address LOC within INSN of BB.  */
 
 
 static void
@@ -2875,8 +2815,7 @@  df_ref_record (enum df_ref_class cl,
                rtx reg, rtx *loc,
 	       basic_block bb, struct df_insn_info *insn_info,
 	       enum df_ref_type ref_type,
-	       int ref_flags,
-	       int width, int offset, enum machine_mode mode)
+	       int ref_flags)
 {
   unsigned int regno;
 
@@ -2926,8 +2865,7 @@  df_ref_record (enum df_ref_class cl,
       for (i = regno; i < endregno; i++)
 	{
 	  ref = df_ref_create_structure (cl, collection_rec, regno_reg_rtx[i], loc,
-					 bb, insn_info, ref_type, ref_flags,
-					 width, offset, mode);
+					 bb, insn_info, ref_type, ref_flags);
 
           gcc_assert (ORIGINAL_REGNO (DF_REF_REG (ref)) == i);
 	}
@@ -2935,7 +2873,7 @@  df_ref_record (enum df_ref_class cl,
   else
     {
       df_ref_create_structure (cl, collection_rec, reg, loc, bb, insn_info,
-			       ref_type, ref_flags, width, offset, mode);
+			       ref_type, ref_flags);
     }
 }
 
@@ -2969,10 +2907,6 @@  df_def_record_1 (struct df_collection_re
 {
   rtx *loc;
   rtx dst;
-  int offset = -1;
-  int width = -1;
-  enum machine_mode mode = VOIDmode;
-  enum df_ref_class cl = DF_REF_REGULAR;
 
  /* We may recursively call ourselves on EXPR_LIST when dealing with PARALLEL
      construct.  */
@@ -3012,15 +2946,6 @@  df_def_record_1 (struct df_collection_re
     {
       flags |= DF_REF_READ_WRITE | DF_REF_PARTIAL | DF_REF_ZERO_EXTRACT;
 
-      if (CONST_INT_P (XEXP (dst, 1))
-	  && CONST_INT_P (XEXP (dst, 2)))
-	{
-	  width = INTVAL (XEXP (dst, 1));
-	  offset = INTVAL (XEXP (dst, 2));
-	  mode = GET_MODE (dst);
-	  cl = DF_REF_EXTRACT;
-	}
-
       loc = &XEXP (dst, 0);
       dst = *loc;
     }
@@ -3028,16 +2953,14 @@  df_def_record_1 (struct df_collection_re
   /* At this point if we do not have a reg or a subreg, just return.  */
   if (REG_P (dst))
     {
-      df_ref_record (cl, collection_rec,
-		     dst, loc, bb, insn_info, DF_REF_REG_DEF, flags,
-		     width, offset, mode);
+      df_ref_record (DF_REF_REGULAR, collection_rec,
+		     dst, loc, bb, insn_info, DF_REF_REG_DEF, flags);
 
       /* 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 (DF_REF_BASE, collection_rec,
-		       dst, NULL, bb, insn_info, DF_REF_REG_USE, flags,
-		       width, offset, mode);
+		       dst, NULL, bb, insn_info, DF_REF_REG_USE, flags);
     }
   else if (GET_CODE (dst) == SUBREG && REG_P (SUBREG_REG (dst)))
     {
@@ -3046,9 +2969,8 @@  df_def_record_1 (struct df_collection_re
 
       flags |= DF_REF_SUBREG;
 
-      df_ref_record (cl, collection_rec,
-		     dst, loc, bb, insn_info, DF_REF_REG_DEF, flags,
-		     width, offset, mode);
+      df_ref_record (DF_REF_REGULAR, collection_rec,
+		     dst, loc, bb, insn_info, DF_REF_REG_DEF, flags);
     }
 }
 
@@ -3085,19 +3007,13 @@  df_defs_record (struct df_collection_rec
 }
 
 
-/* Process all the registers used in the rtx at address LOC.
-
-   If the REF_FLAGS field contain DF_REF_SIGN_EXTRACT or
-   DF_REF_ZERO_EXTRACT.  WIDTH, OFFSET and MODE are used to access the
-   fields if they were constants.  Otherwise they should be -1 if
-   those flags were set.  */
+/* Process all the registers used in the rtx at address LOC.  */
 
 static void
-df_uses_record (enum df_ref_class cl, struct df_collection_rec *collection_rec,
+df_uses_record (struct df_collection_rec *collection_rec,
                 rtx *loc, enum df_ref_type ref_type,
 		basic_block bb, struct df_insn_info *insn_info,
-		int flags,
-		int width, int offset, enum machine_mode mode)
+		int flags)
 {
   RTX_CODE code;
   rtx x;
@@ -3126,20 +3042,19 @@  df_uses_record (enum df_ref_class cl, st
       /* If we are clobbering a MEM, mark any registers inside the address
 	 as being used.  */
       if (MEM_P (XEXP (x, 0)))
-	df_uses_record (cl, collection_rec,
+	df_uses_record (collection_rec,
 			&XEXP (XEXP (x, 0), 0),
 			DF_REF_REG_MEM_STORE,
 		        bb, insn_info,
-			flags, width, offset, mode);
+			flags);
 
       /* If we're clobbering a REG then we have a def so ignore.  */
       return;
 
     case MEM:
-      df_uses_record (cl, collection_rec,
+      df_uses_record (collection_rec,
 		      &XEXP (x, 0), DF_REF_REG_MEM_LOAD,
-		      bb, insn_info, flags & DF_REF_IN_NOTE,
-		      width, offset, mode);
+		      bb, insn_info, flags & DF_REF_IN_NOTE);
       return;
 
     case SUBREG:
@@ -3149,42 +3064,32 @@  df_uses_record (enum df_ref_class cl, st
       if (!REG_P (SUBREG_REG (x)))
 	{
 	  loc = &SUBREG_REG (x);
-	  df_uses_record (cl, collection_rec, loc, ref_type, bb, insn_info, flags,
-			  width, offset, mode);
+	  df_uses_record (collection_rec, loc, ref_type, bb, insn_info, flags);
 	  return;
 	}
       /* ... Fall through ...  */
 
     case REG:
-      df_ref_record (cl, collection_rec,
+      df_ref_record (DF_REF_REGULAR, collection_rec,
 		     x, loc, bb, insn_info,
-		     ref_type, flags,
-		     width, offset, mode);
+		     ref_type, flags);
       return;
 
     case SIGN_EXTRACT:
     case ZERO_EXTRACT:
       {
-	/* If the parameters to the zero or sign extract are
-	   constants, strip them off and recurse, otherwise there is
-	   no information that we can gain from this operation.  */
-	if (CONST_INT_P (XEXP (x, 1))
-	    && CONST_INT_P (XEXP (x, 2)))
-	  {
-	    width = INTVAL (XEXP (x, 1));
-	    offset = INTVAL (XEXP (x, 2));
-	    mode = GET_MODE (x);
-
-	    if (code == ZERO_EXTRACT)
-	      flags |= DF_REF_ZERO_EXTRACT;
-	    else
-	      flags |= DF_REF_SIGN_EXTRACT;
-
-	    df_uses_record (DF_REF_EXTRACT, collection_rec,
-			    &XEXP (x, 0), ref_type, bb, insn_info, flags,
-			    width, offset, mode);
-	    return;
-	  }
+        df_uses_record (collection_rec,
+                        &XEXP (x, 1), ref_type, bb, insn_info, flags);
+        df_uses_record (collection_rec,
+                        &XEXP (x, 2), ref_type, bb, insn_info, flags);
+
+        if (code == ZERO_EXTRACT)
+          flags |= DF_REF_ZERO_EXTRACT;
+        else
+          flags |= DF_REF_SIGN_EXTRACT;
+        df_uses_record (collection_rec,
+                        &XEXP (x, 0), ref_type, bb, insn_info, flags);
+        return;
       }
       break;
 
@@ -3192,19 +3101,17 @@  df_uses_record (enum df_ref_class cl, st
       {
 	rtx dst = SET_DEST (x);
 	gcc_assert (!(flags & DF_REF_IN_NOTE));
-	df_uses_record (cl, collection_rec,
-			&SET_SRC (x), DF_REF_REG_USE, bb, insn_info, flags,
-			width, offset, mode);
+	df_uses_record (collection_rec,
+			&SET_SRC (x), DF_REF_REG_USE, bb, insn_info, flags);
 
 	switch (GET_CODE (dst))
 	  {
 	    case SUBREG:
 	      if (df_read_modify_subreg_p (dst))
 		{
-		  df_uses_record (cl, collection_rec, &SUBREG_REG (dst),
+		  df_uses_record (collection_rec, &SUBREG_REG (dst),
 				  DF_REF_REG_USE, bb, insn_info,
-				  flags | DF_REF_READ_WRITE | DF_REF_SUBREG,
-				  width, offset, mode);
+				  flags | DF_REF_READ_WRITE | DF_REF_SUBREG);
 		  break;
 		}
 	      /* Fall through.  */
@@ -3215,9 +3122,8 @@  df_uses_record (enum df_ref_class cl, st
 	    case CC0:
 		break;
 	    case MEM:
-	      df_uses_record (cl, collection_rec, &XEXP (dst, 0),
-			      DF_REF_REG_MEM_STORE, bb, insn_info, flags,
-			      width, offset, mode);
+	      df_uses_record (collection_rec, &XEXP (dst, 0),
+			      DF_REF_REG_MEM_STORE, bb, insn_info, flags);
 	      break;
 	    case STRICT_LOW_PART:
 	      {
@@ -3225,53 +3131,26 @@  df_uses_record (enum df_ref_class cl, st
 		/* A strict_low_part uses the whole REG and not just the
 		 SUBREG.  */
 		dst = XEXP (dst, 0);
-		df_uses_record (cl, collection_rec,
+		df_uses_record (collection_rec,
 				(GET_CODE (dst) == SUBREG) ? &SUBREG_REG (dst) : temp,
 				DF_REF_REG_USE, bb, insn_info,
-				DF_REF_READ_WRITE | DF_REF_STRICT_LOW_PART,
-				width, offset, mode);
+				DF_REF_READ_WRITE | DF_REF_STRICT_LOW_PART);
 	      }
 	      break;
 	    case ZERO_EXTRACT:
 	      {
-		if (CONST_INT_P (XEXP (dst, 1))
-		    && CONST_INT_P (XEXP (dst, 2)))
-		  {
-		    width = INTVAL (XEXP (dst, 1));
-		    offset = INTVAL (XEXP (dst, 2));
-		    mode = GET_MODE (dst);
-		    if (GET_CODE (XEXP (dst,0)) == MEM)
-		      {
-			/* Handle the case of zero_extract(mem(...)) in the set dest.
-			   This special case is allowed only if the mem is a single byte and
-			   is useful to set a bitfield in memory.  */
-			df_uses_record (DF_REF_EXTRACT, collection_rec, &XEXP (XEXP (dst,0), 0),
-					DF_REF_REG_MEM_STORE, bb, insn_info,
-					DF_REF_ZERO_EXTRACT,
-					width, offset, mode);
-		      }
-		    else
-		      {
-			df_uses_record (DF_REF_EXTRACT, collection_rec, &XEXP (dst, 0),
-					DF_REF_REG_USE, bb, insn_info,
-					DF_REF_READ_WRITE | DF_REF_ZERO_EXTRACT,
-					width, offset, mode);
-		      }
-		  }
-		else
-		  {
-		    df_uses_record (cl, collection_rec, &XEXP (dst, 1),
-				    DF_REF_REG_USE, bb, insn_info, flags,
-				    width, offset, mode);
-		    df_uses_record (cl, collection_rec, &XEXP (dst, 2),
-				    DF_REF_REG_USE, bb, insn_info, flags,
-				    width, offset, mode);
-		    df_uses_record (cl, collection_rec, &XEXP (dst, 0),
-				    DF_REF_REG_USE, bb, insn_info,
-				    DF_REF_READ_WRITE | DF_REF_ZERO_EXTRACT,
-				    width, offset, mode);
-		  }
-
+		df_uses_record (collection_rec, &XEXP (dst, 1),
+				DF_REF_REG_USE, bb, insn_info, flags);
+		df_uses_record (collection_rec, &XEXP (dst, 2),
+				DF_REF_REG_USE, bb, insn_info, flags);
+                if (GET_CODE (XEXP (dst,0)) == MEM)
+                  df_uses_record (collection_rec, &XEXP (dst, 0),
+                                  DF_REF_REG_USE, bb, insn_info,
+                                  DF_REF_ZERO_EXTRACT);
+                else
+                  df_uses_record (collection_rec, &XEXP (dst, 0),
+                                  DF_REF_REG_USE, bb, insn_info,
+                                  DF_REF_READ_WRITE | DF_REF_ZERO_EXTRACT);
 	      }
 	      break;
 
@@ -3320,19 +3199,17 @@  df_uses_record (enum df_ref_class cl, st
 	    int j;
 
 	    for (j = 0; j < ASM_OPERANDS_INPUT_LENGTH (x); j++)
-	      df_uses_record (cl, collection_rec, &ASM_OPERANDS_INPUT (x, j),
-			      DF_REF_REG_USE, bb, insn_info, flags,
-			      width, offset, mode);
+	      df_uses_record (collection_rec, &ASM_OPERANDS_INPUT (x, j),
+			      DF_REF_REG_USE, bb, insn_info, flags);
 	    return;
 	  }
 	break;
       }
 
     case VAR_LOCATION:
-      df_uses_record (cl, collection_rec,
+      df_uses_record (collection_rec,
 		      &PAT_VAR_LOCATION_LOC (x),
-		      DF_REF_REG_USE, bb, insn_info,
-		      flags, width, offset, mode);
+		      DF_REF_REG_USE, bb, insn_info, flags);
       return;
 
     case PRE_DEC:
@@ -3343,11 +3220,10 @@  df_uses_record (enum df_ref_class cl, st
     case POST_MODIFY:
       gcc_assert (!DEBUG_INSN_P (insn_info->insn));
       /* Catch the def of the register being modified.  */
-      df_ref_record (cl, collection_rec, XEXP (x, 0), &XEXP (x, 0),
+      df_ref_record (DF_REF_REGULAR, 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);
+                     flags | DF_REF_READ_WRITE | DF_REF_PRE_POST_MODIFY);
 
       /* ... Fall through to handle uses ...  */
 
@@ -3370,18 +3246,16 @@  df_uses_record (enum df_ref_class cl, st
 		loc = &XEXP (x, 0);
 		goto retry;
 	      }
-	    df_uses_record (cl, collection_rec, &XEXP (x, i), ref_type,
-			    bb, insn_info, flags,
-			    width, offset, mode);
+	    df_uses_record (collection_rec, &XEXP (x, i), ref_type,
+			    bb, insn_info, flags);
 	  }
 	else if (fmt[i] == 'E')
 	  {
 	    int j;
 	    for (j = 0; j < XVECLEN (x, i); j++)
-	      df_uses_record (cl, collection_rec,
+	      df_uses_record (collection_rec,
 			      &XVECEXP (x, i, j), ref_type,
-			      bb, insn_info, flags,
-			      width, offset, mode);
+			      bb, insn_info, flags);
 	  }
       }
   }
@@ -3402,23 +3276,12 @@  df_get_conditional_uses (struct df_colle
     {
       if (DF_REF_FLAGS_IS_SET (ref, DF_REF_CONDITIONAL))
         {
-	  int width = -1;
-	  int offset = -1;
-	  enum machine_mode mode = VOIDmode;
           df_ref use;
 
-	  if (DF_REF_FLAGS_IS_SET (ref, DF_REF_SIGN_EXTRACT | DF_REF_ZERO_EXTRACT))
-	    {
-	      width = DF_REF_EXTRACT_WIDTH (ref);
-	      offset = DF_REF_EXTRACT_OFFSET (ref);
-	      mode = DF_REF_EXTRACT_MODE (ref);
-	    }
-
           use = df_ref_create_structure (DF_REF_CLASS (ref), collection_rec, DF_REF_REG (ref),
 					 DF_REF_LOC (ref), DF_REF_BB (ref),
 					 DF_REF_INSN_INFO (ref), DF_REF_REG_USE,
-					 DF_REF_FLAGS (ref) & ~DF_REF_CONDITIONAL,
-					 width, offset, mode);
+					 DF_REF_FLAGS (ref) & ~DF_REF_CONDITIONAL);
           DF_REF_REGNO (use) = DF_REF_REGNO (ref);
         }
     }
@@ -3455,9 +3318,8 @@  df_get_call_refs (struct df_collection_r
        note = XEXP (note, 1))
     {
       if (GET_CODE (XEXP (note, 0)) == USE)
-        df_uses_record (DF_REF_REGULAR, collection_rec, &XEXP (XEXP (note, 0), 0),
-			DF_REF_REG_USE, bb, insn_info, flags, -1, -1,
-			VOIDmode);
+        df_uses_record (collection_rec, &XEXP (XEXP (note, 0), 0),
+			DF_REF_REG_USE, bb, insn_info, flags);
       else if (GET_CODE (XEXP (note, 0)) == CLOBBER)
 	{
 	  if (REG_P (XEXP (XEXP (note, 0), 0)))
@@ -3468,17 +3330,15 @@  df_get_call_refs (struct df_collection_r
 				insn_info, flags);
 	    }
 	  else
-	    df_uses_record (DF_REF_REGULAR, collection_rec, &XEXP (note, 0),
-		            DF_REF_REG_USE, bb, insn_info, flags, -1, -1,
-			    VOIDmode);
+	    df_uses_record (collection_rec, &XEXP (note, 0),
+		            DF_REF_REG_USE, bb, insn_info, flags);
 	}
     }
 
   /* The stack ptr is used (honorarily) by a CALL insn.  */
   df_ref_record (DF_REF_BASE, collection_rec, regno_reg_rtx[STACK_POINTER_REGNUM],
 		 NULL, bb, insn_info, DF_REF_REG_USE,
-		 DF_REF_CALL_STACK_USAGE | flags,
-		 -1, -1, VOIDmode);
+		 DF_REF_CALL_STACK_USAGE | flags);
 
   /* Calls may also reference any of the global registers,
      so they are recorded as used.  */
@@ -3486,11 +3346,9 @@  df_get_call_refs (struct df_collection_r
     if (global_regs[i])
       {
 	df_ref_record (DF_REF_BASE, collection_rec, regno_reg_rtx[i],
-		       NULL, bb, insn_info, DF_REF_REG_USE, flags, -1, -1,
-		       VOIDmode);
+		       NULL, bb, insn_info, DF_REF_REG_USE, flags);
 	df_ref_record (DF_REF_BASE, collection_rec, regno_reg_rtx[i],
-		       NULL, bb, insn_info, DF_REF_REG_DEF, flags, -1, -1,
-		       VOIDmode);
+		       NULL, bb, insn_info, DF_REF_REG_DEF, flags);
       }
 
   is_sibling_call = SIBLING_CALL_P (insn_info->insn);
@@ -3504,8 +3362,7 @@  df_get_call_refs (struct df_collection_r
 				    crtl->return_rtx, NULL)))
         df_ref_record (DF_REF_BASE, collection_rec, regno_reg_rtx[ui],
 		       NULL, bb, insn_info, DF_REF_REG_DEF,
-		       DF_REF_MAY_CLOBBER | flags,
-		       -1, -1, VOIDmode);
+		       DF_REF_MAY_CLOBBER | flags);
     }
 
   bitmap_clear (&defs_generated);
@@ -3541,21 +3398,21 @@  df_insn_refs_collect (struct df_collecti
         {
         case REG_EQUIV:
         case REG_EQUAL:
-          df_uses_record (DF_REF_REGULAR, collection_rec,
+          df_uses_record (collection_rec,
                           &XEXP (note, 0), DF_REF_REG_USE,
-                          bb, insn_info, DF_REF_IN_NOTE, -1, -1, VOIDmode);
+                          bb, insn_info, DF_REF_IN_NOTE);
           break;
         case REG_NON_LOCAL_GOTO:
           /* The frame ptr is used by a non-local goto.  */
           df_ref_record (DF_REF_BASE, collection_rec,
                          regno_reg_rtx[FRAME_POINTER_REGNUM],
                          NULL, bb, insn_info,
-                         DF_REF_REG_USE, 0, -1, -1, VOIDmode);
+                         DF_REF_REG_USE, 0);
 #if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
           df_ref_record (DF_REF_BASE, collection_rec,
                          regno_reg_rtx[HARD_FRAME_POINTER_REGNUM],
                          NULL, bb, insn_info,
-                         DF_REF_REG_USE, 0, -1, -1, VOIDmode);
+                         DF_REF_REG_USE, 0);
 #endif
           break;
         default:
@@ -3568,9 +3425,8 @@  df_insn_refs_collect (struct df_collecti
 		      (is_cond_exec) ? DF_REF_CONDITIONAL : 0);
 
   /* Record the register uses.  */
-  df_uses_record (DF_REF_REGULAR, collection_rec,
-		  &PATTERN (insn_info->insn), DF_REF_REG_USE, bb, insn_info, 0,
-		  -1, -1, VOIDmode);
+  df_uses_record (collection_rec,
+		  &PATTERN (insn_info->insn), DF_REF_REG_USE, bb, insn_info, 0);
 
   /* DF_REF_CONDITIONAL needs corresponding USES. */
   if (is_cond_exec)
@@ -3641,8 +3497,7 @@  df_bb_refs_collect (struct df_collection
 	  if (regno == INVALID_REGNUM)
 	    break;
 	  df_ref_record (DF_REF_ARTIFICIAL, collection_rec, regno_reg_rtx[regno], NULL,
-			 bb, NULL, DF_REF_REG_DEF, DF_REF_AT_TOP, -1, -1,
-			 VOIDmode);
+			 bb, NULL, DF_REF_REG_DEF, DF_REF_AT_TOP);
 	}
     }
 #endif
@@ -3651,7 +3506,7 @@  df_bb_refs_collect (struct df_collection
      non-local goto.  */
   if (bb->flags & BB_NON_LOCAL_GOTO_TARGET)
     df_ref_record (DF_REF_ARTIFICIAL, collection_rec, hard_frame_pointer_rtx, NULL,
-		   bb, NULL, DF_REF_REG_DEF, DF_REF_AT_TOP, -1, -1, VOIDmode);
+		   bb, NULL, DF_REF_REG_DEF, DF_REF_AT_TOP);
 
   /* Add the artificial uses.  */
   if (bb->index >= NUM_FIXED_BLOCKS)
@@ -3665,7 +3520,7 @@  df_bb_refs_collect (struct df_collection
       EXECUTE_IF_SET_IN_BITMAP (au, 0, regno, bi)
 	{
 	  df_ref_record (DF_REF_ARTIFICIAL, collection_rec, regno_reg_rtx[regno], NULL,
-			 bb, NULL, DF_REF_REG_USE, 0, -1, -1, VOIDmode);
+			 bb, NULL, DF_REF_REG_USE, 0);
 	}
     }
 
@@ -3941,8 +3796,7 @@  df_entry_block_defs_collect (struct df_c
   EXECUTE_IF_SET_IN_BITMAP (entry_block_defs, 0, i, bi)
     {
       df_ref_record (DF_REF_ARTIFICIAL, collection_rec, regno_reg_rtx[i], NULL,
-		     ENTRY_BLOCK_PTR, NULL, DF_REF_REG_DEF, 0, -1, -1,
-		     VOIDmode);
+		     ENTRY_BLOCK_PTR, NULL, DF_REF_REG_DEF, 0);
     }
 
   df_canonize_collection_rec (collection_rec);
@@ -4105,7 +3959,7 @@  df_exit_block_uses_collect (struct df_co
 
   EXECUTE_IF_SET_IN_BITMAP (exit_block_uses, 0, i, bi)
     df_ref_record (DF_REF_ARTIFICIAL, collection_rec, regno_reg_rtx[i], NULL,
-		   EXIT_BLOCK_PTR, NULL, DF_REF_REG_USE, 0, -1, -1, VOIDmode);
+		   EXIT_BLOCK_PTR, NULL, DF_REF_REG_USE, 0);
 
 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
   /* It is deliberate that this is not put in the exit block uses but
@@ -4115,7 +3969,7 @@  df_exit_block_uses_collect (struct df_co
       && bb_has_eh_pred (EXIT_BLOCK_PTR)
       && fixed_regs[ARG_POINTER_REGNUM])
     df_ref_record (DF_REF_ARTIFICIAL, collection_rec, regno_reg_rtx[ARG_POINTER_REGNUM], NULL,
-		   EXIT_BLOCK_PTR, NULL, DF_REF_REG_USE, 0, -1, -1, VOIDmode);
+		   EXIT_BLOCK_PTR, NULL, DF_REF_REG_USE, 0);
 #endif
 
   df_canonize_collection_rec (collection_rec);
Index: fwprop.c
===================================================================
--- fwprop.c	(revision 162940)
+++ fwprop.c	(working copy)
@@ -908,28 +908,17 @@  update_df (rtx insn, rtx *loc, df_ref *u
     {
       df_ref use = *use_rec;
       df_ref orig_use = use, new_use;
-      int width = -1;
-      int offset = -1;
-      enum machine_mode mode = VOIDmode;
       rtx *new_loc = find_occurrence (loc, DF_REF_REG (orig_use));
       use_rec++;
 
       if (!new_loc)
 	continue;
 
-      if (DF_REF_FLAGS_IS_SET (orig_use, DF_REF_SIGN_EXTRACT | DF_REF_ZERO_EXTRACT))
-	{
-	  width = DF_REF_EXTRACT_WIDTH (orig_use);
-	  offset = DF_REF_EXTRACT_OFFSET (orig_use);
-	  mode = DF_REF_EXTRACT_MODE (orig_use);
-	}
-
       /* Add a new insn use.  Use the original type, because it says if the
          use was within a MEM.  */
       new_use = df_ref_create (DF_REF_REG (orig_use), new_loc,
 			       insn, BLOCK_FOR_INSN (insn),
-			       type, DF_REF_FLAGS (orig_use) | new_flags,
-			       width, offset, mode);
+			       type, DF_REF_FLAGS (orig_use) | new_flags);
 
       /* Set up the use-def chain.  */
       gcc_assert (DF_REF_ID (new_use) == (int) VEC_length (df_ref, use_def_ref));