re PR middle-end/37448 (cannot compile big function)

2008-10-11  Kenneth Zadeck <zadeck@naturalbridge.com>

	PR rtl-optimization/37448
	* df.h: (df_ref_class): New enum.
	(DF_REF_TYPE_NAMES, df_ref_extract): Removed.
	(struct df_ref): Replaced with union df_ref_d.
	(df_base_ref, df_artificial_ref, df_regular_ref, df_extract_ref):
	New members of df_ref_d union.
	(DF_REF_REAL_REG, DF_REF_REGNO, DF_REF_REAL_LOC, DF_REF_REG,
	DF_REF_LOC, DF_REF_BB, DF_REF_INSN_INFO, DF_REF_INSN,
	DF_REF_CLASS, DF_REF_TYPE, DF_REF_CHAIN, DF_REF_ID, DF_REF_FLAGS,
	DF_REF_ORDER, DF_REF_IS_ARTIFICIAL, DF_REF_NEXT_REG,
	DF_REF_PREV_REG, DF_REF_EXTRACT_WIDTH, DF_REF_EXTRACT_OFFSET,
	DF_REF_EXTRACT_MODE): Replaced definition to access union
	df_ref_d.
       	(DF_MWS_REG_DEF_P, DF_MWS_REG_USE_P, DF_MWS_TYPE): New macros.
	(df_scan_bb_info, df_bb_regno_first_def_find,
	df_bb_regno_last_def_find, df_find_def, df_find_use,
	df_refs_chain_dump, df_regs_chain_dump, df_ref_debug,
	debug_df_ref, df_chain_create, df_chain_unlink, df_chain_copy,
	df_ref_create, df_ref_remove, df_compute_accessed_bytes,
	df_get_artificial_defs, df_get_artificial_uses, union_defs)
	Replaced struct df_ref * with df_ref.
	* df-scan.c (df_collection_rec, df_null_ref_rec,
	df_ref_chain_delete_du_chain, df_ref_chain_delete, df_install_ref,
	df_grow_ref_info, df_ref_create, df_reg_chain_unlink,
	df_ref_compress_rec, df_ref_remove, df_ref_chain_delete_du_chain,
	df_ref_chain_delete, df_free_collection_rec, df_insn_rescan,
	df_reorganize_refs_by_reg_by_reg,
	df_reorganize_refs_by_reg_by_insn, df_reorganize_refs_by_reg,
	df_ref_change_reg_with_loc_1, df_notes_rescan, df_swap_refs,
	df_sort_and_compress_refs, df_install_ref, df_install_refs,
	df_ref_record, df_get_conditional_uses, df_get_call_refs,
	df_bb_refs_record, df_exit_block_uses_collect,
	df_record_exit_block_uses, df_reg_chain_mark,
	df_reg_chain_verify_unmarked, df_refs_verify): Replaced struct
	df_ref * with df_ref.
	(df_ref_record, df_uses_record, df_ref_create_structure): Added
	df_ref_class parameter.
	(df_scan_problem_data): Added new pools for different types of
	refs.
	(df_scan_free_internal, df_scan_alloc, df_free_ref,
	df_ref_create_structure): Processed new ref pools.
	(df_scan_start_dump): Added counts of refs and insns.
	(df_ref_create, df_notes_rescan, df_def_record_1, df_uses_record,
	df_get_call_refs, df_insn_refs_collect, df_bb_refs_collect,
	df_entry_block_defs_collect, df_exit_block_uses_collect): Added
	code to pass df_ref_class down to ref creation functions.
	(df_reg_chain_unlink, df_ref_remove, df_ref_change_reg_with_loc_1,
	df_reg_chain_mark): Use macros to hide references to df_refs.
	(df_ref_chain_change_bb): Removed.
	(df_insn_change_bb): Remove calls to df_ref_insn_change_bb.
	(df_ref_equal_p, df_ref_compare, df_ref_create_structure):
	Enhanced to understand df_ref union structure.
	* fwprop.c (local_ref_killed_between_p, use_killed_between,
	all_uses_available_at, update_df, try_fwprop_subst,
	forward_propagate_subreg, forward_propagate_and_simplify,
	forward_propagate_into, fwprop, fwprop_addr): Replaced struct
	df_ref * with df_ref.
	(use_killed_between, all_uses_available_at): Use macros to hide
	references to df_refs.
	* regstat.c (regstat_bb_compute_ri,
	regstat_bb_compute_calls_crossed): Replaced struct df_ref * with
	df_ref.
	* see.c (see_handle_relevant_defs, see_handle_relevant_uses,
	see_handle_relevant_refs, see_analyze_one_def,
	see_update_relevancy, see_propagate_extensions_to_uses): Replaced
	struct df_ref * with df_ref.
	* ra-conflict.c (record_one_conflict, clear_reg_in_live,
	global_conflicts): Replaced struct df_ref * with df_ref.
	* ddg.c (create_ddg_dep_from_intra_loop_link,
	add_cross_iteration_register_deps, build_inter_loop_deps):
	Replaced struct df_ref * with df_ref.
	(create_ddg_dep_from_intra_loop_link,
	add_cross_iteration_register_deps): Use macros to hide references
	to df_refs.
	* auto-inc-dec.c (find_inc, merge_in_block): Replaced struct
	df_ref * with df_ref.
	* df-core.c (df_bb_regno_first_def_find,
	df_bb_regno_last_def_find, df_find_def, df_find_use,
	df_refs_chain_dump, df_regs_chain_dump, df_ref_debug,
	debug_df_ref): Replaced struct df_ref * with df_ref.
	(df_mws_dump, df_ref_debug): Use macros to hide references to
	df_refs.
	* cse.c (cse_extended_basic_block): Replaced struct df_ref * with
	df_ref.
	* web.c (union_defs, entry_register, replace_ref, web_main):
	Replaced struct df_ref * with df_ref.
	(union_defs, replace_ref): Use macros to hide references to
	df_refs.
	* global.c (compute_regs_asm_clobbered, build_insn_chain):
	Replaced struct df_ref * with df_ref.
	* ifcvt.c (dead_or_predicable): Replaced struct df_ref * with
	df_ref.
	* sel-sched-ir.c (maybe_downgrade_id_to_use, setup_id_reg_sets, ):
	Replaced struct df_ref * with df_ref.
	* ira-lives.c (mark_ref_live, def_conflicts_with_inputs_p,
	mark_ref_dead, process_bb_node_lives): Replaced struct df_ref *
	with df_ref.
	* local-alloc.c (block_alloc): Replaced struct df_ref * with
	df_ref.
	* df-byte-scan.c (df_compute_accessed_bytes_extract,
	df_compute_accessed_bytes_strict_low_part,
	df_compute_accessed_bytes_subreg, df_compute_accessed_bytes):
	Replaced struct df_ref * with df_ref.
	(df_compute_accessed_bytes): Use macros to hide references to
	df_refs.
	* init-regs.c (initialize_uninitialized_regs): Replaced struct
	df_ref * with df_ref.
	* loop-invariant.c (invariant_for_use, hash_invariant_expr_1,
	check_dependency, check_dependencies, record_uses): Replaced
	struct df_ref * with df_ref.
	(invariant_for_use, check_dependency): Use macros to hide
	references to df_refs.
	* loop-iv.c (iv_analysis_loop_init, iv_get_reaching_def,
	get_biv_step_1, get_biv_step, record_iv, iv_analyze_def,
	iv_analyze, biv_p): Replaced struct df_ref * with df_ref.
	(iv_analysis_loop_init, iv_get_reaching_def): Use macros to hide
	references to df_refs.
	* ira.c (compute_regs_asm_clobbered): Replaced struct df_ref * with df_ref.
	* combine.c (create_log_links): Replaced struct df_ref * with df_ref.
	* df-problems.c (df_rd_bb_local_compute_process_def,
	df_lr_bb_local_compute, df_live_bb_local_compute, df_chain_create,
	df_chain_unlink_1, df_chain_unlink, df_chain_copy,
	df_chain_remove_problem, df_chain_create_bb_process_use,
	df_chain_create_bb, df_chain_top_dump, df_chain_bottom_dump,
	df_byte_lr_check_regs, df_byte_lr_bb_local_compute,
	df_byte_lr_simulate_defs, df_byte_lr_simulate_uses,
	df_byte_lr_simulate_artificial_refs_at_top,
	df_byte_lr_simulate_artificial_refs_at_end, df_create_unused_note,
	df_note_bb_compute, df_note_add_problem, df_simulate_defs,
	df_simulate_uses, df_simulate_artificial_refs_at_end,
	df_simulate_artificial_refs_at_top): Replaced struct df_ref * with df_ref.
	(df_chain_dump): Use macros to hide
	references to df_refs.
	* config/mips/mips.c (r10k_simplify_address): Replaced struct
	df_ref * with df_ref.
	* dce.c (mark_nonreg_stores, delete_corresponding_reg_eq_notes,
	mark_artificial_uses, mark_reg_dependencies,
	byte_dce_process_block): Replaced struct df_ref * with df_ref.

From-SVN: r141067

1 files changed, 351 insertions, 253 deletions

diff --git a/gcc/df-scan.c b/gcc/df-scan.c
index 7e6796b40e7..ec0d12edc54 100644
--- a/gcc/df-scan.c
+++ b/gcc/df-scan.c
@@ -94,20 +94,20 @@ bitmap df_invalidated_by_call = NULL;
 
 struct df_collection_rec
 {
-  struct df_ref ** def_vec;
+  df_ref * def_vec;
   unsigned int next_def;
-  struct df_ref ** use_vec;
+  df_ref * use_vec;
   unsigned int next_use;
-  struct df_ref ** eq_use_vec;
+  df_ref * eq_use_vec;
   unsigned int next_eq_use;
   struct df_mw_hardreg **mw_vec;
   unsigned int next_mw;
 };
 
-static struct df_ref * df_null_ref_rec[1];
+static df_ref df_null_ref_rec[1];
 static struct df_mw_hardreg * df_null_mw_rec[1];
 
-static void df_ref_record (struct df_collection_rec *,
+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, enum df_ref_flags,
@@ -118,16 +118,17 @@ static void df_def_record_1 (struct df_collection_rec *, 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 *,
+static void df_uses_record (enum df_ref_class, struct df_collection_rec *,
 			    rtx *, enum df_ref_type,
 			    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, struct df_insn_info *,
-					       enum df_ref_type, enum df_ref_flags,
-					       int, int, enum machine_mode);
+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, enum df_ref_flags,
+				       int, int, enum machine_mode);
 
 static void df_insn_refs_collect (struct df_collection_rec*, 
 				  basic_block, struct df_insn_info *); 
@@ -141,8 +142,8 @@ static void df_record_exit_block_uses (bitmap);
 static void df_get_exit_block_use_set (bitmap);
 static void df_get_entry_block_def_set (bitmap);
 static void df_grow_ref_info (struct df_ref_info *, unsigned int);
-static void df_ref_chain_delete_du_chain (struct df_ref **);
-static void df_ref_chain_delete (struct df_ref **);
+static void df_ref_chain_delete_du_chain (df_ref *);
+static void df_ref_chain_delete (df_ref *);
 
 static void df_refs_add_to_chains (struct df_collection_rec *, 
 				   basic_block, rtx);
@@ -150,7 +151,7 @@ static void df_refs_add_to_chains (struct df_collection_rec *,
 static bool df_insn_refs_verify (struct df_collection_rec *, basic_block, rtx, bool);
 static void df_entry_block_defs_collect (struct df_collection_rec *, bitmap);
 static void df_exit_block_uses_collect (struct df_collection_rec *, bitmap);
-static void df_install_ref (struct df_ref *, struct df_reg_info *, 
+static void df_install_ref (df_ref, struct df_reg_info *, 
 			    struct df_ref_info *, bool);
 
 static int df_ref_compare (const void *, const void *);
@@ -178,7 +179,9 @@ static bool regs_ever_live[FIRST_PSEUDO_REGISTER];
 /* Problem data for the scanning dataflow function.  */
 struct df_scan_problem_data
 {
-  alloc_pool ref_pool;
+  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;
@@ -264,7 +267,9 @@ df_scan_free_internal (void)
   BITMAP_FREE (df->insns_to_notes_rescan);
 
   free_alloc_pool (df_scan->block_pool);
-  free_alloc_pool (problem_data->ref_pool);
+  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);
@@ -344,20 +349,26 @@ df_scan_alloc (bitmap all_blocks ATTRIBUTE_UNUSED)
   df_scan->problem_data = problem_data;
   df_scan->computed = true;
 
-  problem_data->ref_pool 
-    = create_alloc_pool ("df_scan_ref pool", 
-			 sizeof (struct df_ref), block_size);
+  problem_data->ref_base_pool 
+    = create_alloc_pool ("df_scan ref base", 
+			 sizeof (struct df_base_ref), block_size);
+  problem_data->ref_artificial_pool 
+    = create_alloc_pool ("df_scan ref artificial", 
+			 sizeof (struct df_artificial_ref), block_size);
+  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 pool", 
-			 sizeof (struct df_ref_extract), block_size);
+    = create_alloc_pool ("df_scan ref extract", 
+			 sizeof (struct df_extract_ref), block_size);
   problem_data->insn_pool 
-    = create_alloc_pool ("df_scan_insn pool", 
+    = create_alloc_pool ("df_scan insn", 
 			 sizeof (struct df_insn_info), block_size);
   problem_data->reg_pool 
-    = create_alloc_pool ("df_scan_reg pool", 
+    = create_alloc_pool ("df_scan reg", 
 			 sizeof (struct df_reg_info), block_size);
   problem_data->mw_reg_pool 
-    = create_alloc_pool ("df_scan_mw_reg pool", 
+    = create_alloc_pool ("df_scan mw_reg", 
 			 sizeof (struct df_mw_hardreg), block_size);
 
   bitmap_obstack_initialize (&problem_data->reg_bitmaps);
@@ -416,6 +427,13 @@ static void
 df_scan_start_dump (FILE *file ATTRIBUTE_UNUSED)
 {
   int i;
+  int dcount = 0;
+  int ucount = 0;
+  int ecount = 0;
+  int icount = 0;
+  int ccount = 0;
+  basic_block bb;
+  rtx insn;
 
   fprintf (file, ";;  invalidated by call \t");
   df_print_regset (file, df_invalidated_by_call);
@@ -433,8 +451,46 @@ df_scan_start_dump (FILE *file ATTRIBUTE_UNUSED)
   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
     if (df_regs_ever_live_p (i))
       fprintf (file, " %d[%s]", i, reg_names[i]);
+  fprintf (file, "\n;;  ref usage \t");
+  
+  for (i = 0; i < (int)df->regs_inited; i++)
+    if (DF_REG_DEF_COUNT (i) || DF_REG_USE_COUNT (i) || DF_REG_EQ_USE_COUNT (i))
+      {
+	const char * sep = "";
+
+	fprintf (file, "r%d={", i);
+	if (DF_REG_DEF_COUNT (i))
+	  {
+	    fprintf (file, "%dd", DF_REG_DEF_COUNT (i));
+	    sep = ",";
+	    dcount += DF_REG_DEF_COUNT (i);
+	  }
+	if (DF_REG_USE_COUNT (i))
+	  {
+	    fprintf (file, "%s%du", sep, DF_REG_USE_COUNT (i));
+	    sep = ",";
+	    ucount += DF_REG_USE_COUNT (i);
+	  }
+	if (DF_REG_EQ_USE_COUNT (i))
+	  {
+	    fprintf (file, "%s%dd", sep, DF_REG_EQ_USE_COUNT (i));
+	    ecount += DF_REG_EQ_USE_COUNT (i);
+	  }
+	fprintf (file, "} ");
+      }
 
-  fprintf (file, "\n");
+  FOR_EACH_BB (bb)
+    FOR_BB_INSNS (bb, insn)
+      if (INSN_P (insn))
+	{
+	  if (CALL_P (insn))
+	    ccount++;
+	  else
+	    icount++;
+	}
+
+  fprintf (file, "\n;;    total ref usage %d{%dd,%du,%de} in %d{%d regular + %d call} insns.\n", 
+	   dcount + ucount + ecount, dcount, ucount, ecount, icount + ccount, icount, ccount);
 }
 
 /* Dump the bb_info for a given basic block. */
@@ -565,9 +621,9 @@ df_grow_ref_info (struct df_ref_info *ref_info, unsigned int new_size)
 {
   if (ref_info->refs_size < new_size)
     {
-      ref_info->refs = XRESIZEVEC (struct df_ref *, ref_info->refs, new_size);
+      ref_info->refs = XRESIZEVEC (df_ref, ref_info->refs, new_size);
       memset (ref_info->refs + ref_info->refs_size, 0,
-	      (new_size - ref_info->refs_size) *sizeof (struct df_ref *));
+	      (new_size - ref_info->refs_size) *sizeof (df_ref));
       ref_info->refs_size = new_size;
     }
 }
@@ -658,30 +714,38 @@ df_scan_blocks (void)
    fields if they were constants.  Otherwise they should be -1 if
    those flags were set.  */
 
-struct df_ref *
+df_ref 
 df_ref_create (rtx reg, rtx *loc, rtx insn, 
 	       basic_block bb,
 	       enum df_ref_type ref_type, 
 	       enum df_ref_flags ref_flags,
 	       int width, int offset, enum machine_mode mode)
 {
-  struct df_ref *ref;
+  df_ref ref;
   struct df_reg_info **reg_info;
   struct df_ref_info *ref_info;
-  struct df_ref **ref_rec;
-  struct df_ref ***ref_rec_ptr;
+  df_ref *ref_rec;
+  df_ref **ref_rec_ptr;
   unsigned int count = 0;
   bool add_to_table;
+  enum df_ref_class cl;
 
   df_grow_reg_info ();
 
   /* You cannot hack artificial refs.  */
   gcc_assert (insn);
-  ref = df_ref_create_structure (NULL, reg, loc, bb, DF_INSN_INFO_GET (insn),
+
+  if (width != -1 || offset != -1)
+    cl = DF_REF_EXTRACT;
+  else 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);
 
-  if (DF_REF_TYPE (ref) == DF_REF_REG_DEF)
+  if (DF_REF_REG_DEF_P (ref))
     {
       reg_info = df->def_regs;
       ref_info = &df->def_info;
@@ -742,15 +806,15 @@ df_ref_create (rtx reg, rtx *loc, rtx insn,
   ref_rec = *ref_rec_ptr;
   if (count)
     {
-      ref_rec = XRESIZEVEC (struct df_ref *, ref_rec, count+2);
+      ref_rec = XRESIZEVEC (df_ref, ref_rec, count+2);
       *ref_rec_ptr = ref_rec;
       ref_rec[count] = ref;
       ref_rec[count+1] = NULL;
-      qsort (ref_rec, count + 1, sizeof (struct df_ref *), df_ref_compare);
+      qsort (ref_rec, count + 1, sizeof (df_ref), df_ref_compare);
     }
   else
     {
-      struct df_ref **ref_rec = XNEWVEC (struct df_ref*, 2);
+      df_ref *ref_rec = XNEWVEC (df_ref, 2);
       ref_rec[0] = ref;
       ref_rec[1] = NULL;
       *ref_rec_ptr = ref_rec;
@@ -778,15 +842,29 @@ df_ref_create (rtx reg, rtx *loc, rtx insn,
 ----------------------------------------------------------------------------*/
 
 static void
-df_free_ref (struct df_ref *ref)
+df_free_ref (df_ref ref)
 {
   struct df_scan_problem_data *problem_data
     = (struct df_scan_problem_data *) df_scan->problem_data;
 
-  if (DF_REF_FLAGS_IS_SET (ref, DF_REF_SIGN_EXTRACT | DF_REF_ZERO_EXTRACT))
-    pool_free (problem_data->ref_extract_pool, (struct df_ref_extract *)ref);
-  else
-    pool_free (problem_data->ref_pool, ref);
+  switch (DF_REF_CLASS (ref))
+    {
+    case DF_REF_BASE:
+      pool_free (problem_data->ref_base_pool, ref);
+      break;
+
+    case DF_REF_ARTIFICIAL:
+      pool_free (problem_data->ref_artificial_pool, ref);
+      break;
+
+    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;
+    }
 }
 
 
@@ -794,17 +872,18 @@ df_free_ref (struct df_ref *ref)
    Also delete the def-use or use-def chain if it exists.  */
 
 static void
-df_reg_chain_unlink (struct df_ref *ref) 
+df_reg_chain_unlink (df_ref ref) 
 {
-  struct df_ref *next = DF_REF_NEXT_REG (ref);  
-  struct df_ref *prev = DF_REF_PREV_REG (ref);
+  df_ref next = DF_REF_NEXT_REG (ref);  
+  df_ref prev = DF_REF_PREV_REG (ref);
   int id = DF_REF_ID (ref);
   struct df_reg_info *reg_info;
-  struct df_ref **refs = NULL;
+  df_ref *refs = NULL;
 
-  if (DF_REF_TYPE (ref) == DF_REF_REG_DEF)
+  if (DF_REF_REG_DEF_P (ref))
     {
-      reg_info = DF_REG_DEF_GET (DF_REF_REGNO (ref));
+      int regno = DF_REF_REGNO (ref);
+      reg_info = DF_REG_DEF_GET (regno);
       refs = df->def_info.refs;
     }
   else 
@@ -834,7 +913,7 @@ df_reg_chain_unlink (struct df_ref *ref)
     {
       if (df->analyze_subset)
 	{
-	  if (bitmap_bit_p (df->blocks_to_analyze, DF_REF_BB (ref)->index))
+	  if (bitmap_bit_p (df->blocks_to_analyze, DF_REF_BBNO (ref)))
 	    refs[id] = NULL;
 	}
       else
@@ -875,9 +954,9 @@ df_reg_chain_unlink (struct df_ref *ref)
 /* Remove REF from VEC.  */
 
 static void
-df_ref_compress_rec (struct df_ref ***vec_ptr, struct df_ref *ref)
+df_ref_compress_rec (df_ref **vec_ptr, df_ref ref)
 {
-  struct df_ref **vec = *vec_ptr;
+  df_ref *vec = *vec_ptr;
 
   if (vec[1])
     {
@@ -901,7 +980,7 @@ df_ref_compress_rec (struct df_ref ***vec_ptr, struct df_ref *ref)
 /* Unlink REF from all def-use/use-def chains, etc.  */
 
 void
-df_ref_remove (struct df_ref *ref)
+df_ref_remove (df_ref ref)
 {
 #if 0
   if (dump_file)
@@ -916,7 +995,7 @@ df_ref_remove (struct df_ref *ref)
       if (DF_REF_IS_ARTIFICIAL (ref))
 	{
 	  struct df_scan_bb_info *bb_info 
-	    = df_scan_get_bb_info (DF_REF_BB (ref)->index);
+	    = df_scan_get_bb_info (DF_REF_BBNO (ref));
 	  df_ref_compress_rec (&bb_info->artificial_defs, ref);
 	}
       else
@@ -931,7 +1010,7 @@ df_ref_remove (struct df_ref *ref)
       if (DF_REF_IS_ARTIFICIAL (ref))
 	{
 	  struct df_scan_bb_info *bb_info 
-	    = df_scan_get_bb_info (DF_REF_BB (ref)->index);
+	    = df_scan_get_bb_info (DF_REF_BBNO (ref));
 	  df_ref_compress_rec (&bb_info->artificial_uses, ref);
 	}
       else 
@@ -980,11 +1059,11 @@ df_insn_create_insn_record (rtx insn)
 /* Delete all du chain (DF_REF_CHAIN()) of all refs in the ref chain.  */
 
 static void
-df_ref_chain_delete_du_chain (struct df_ref **ref_rec)
+df_ref_chain_delete_du_chain (df_ref *ref_rec)
 {
   while (*ref_rec)
     {
-      struct df_ref *ref = *ref_rec;
+      df_ref ref = *ref_rec;
       /* CHAIN is allocated by DF_CHAIN. So make sure to 
          pass df_scan instance for the problem.  */
       if (DF_REF_CHAIN (ref))
@@ -997,9 +1076,9 @@ df_ref_chain_delete_du_chain (struct df_ref **ref_rec)
 /* Delete all refs in the ref chain.  */
 
 static void
-df_ref_chain_delete (struct df_ref **ref_rec)
+df_ref_chain_delete (df_ref *ref_rec)
 {
-  struct df_ref **start = ref_rec;
+  df_ref *start = ref_rec;
   while (*ref_rec)
     {
       df_reg_chain_unlink (*ref_rec);
@@ -1113,7 +1192,7 @@ df_free_collection_rec (struct df_collection_rec *collection_rec)
 {
   struct df_scan_problem_data *problem_data 
     = (struct df_scan_problem_data *) df_scan->problem_data;
-  struct df_ref **ref;
+  df_ref *ref;
   struct df_mw_hardreg **mw;
 
   if (collection_rec->def_vec)
@@ -1140,9 +1219,9 @@ df_insn_rescan (rtx insn)
   struct df_insn_info *insn_info = NULL;
   basic_block bb = BLOCK_FOR_INSN (insn);
   struct df_collection_rec collection_rec;
-  collection_rec.def_vec = XALLOCAVEC (struct df_ref *, 1000);
-  collection_rec.use_vec = XALLOCAVEC (struct df_ref *, 1000);
-  collection_rec.eq_use_vec = XALLOCAVEC (struct df_ref *, 1000);
+  collection_rec.def_vec = XALLOCAVEC (df_ref, 1000);
+  collection_rec.use_vec = XALLOCAVEC (df_ref, 1000);
+  collection_rec.eq_use_vec = XALLOCAVEC (df_ref, 1000);
   collection_rec.mw_vec = XALLOCAVEC (struct df_mw_hardreg *, 100);
 
   if ((!df) || (!INSN_P (insn)))
@@ -1407,7 +1486,7 @@ df_reorganize_refs_by_reg_by_reg (struct df_ref_info *ref_info,
       ref_info->begin[regno] = offset;
       if (include_defs)
 	{
-	  struct df_ref *ref = DF_REG_DEF_CHAIN (regno);
+	  df_ref ref = DF_REG_DEF_CHAIN (regno);
 	  while (ref) 
 	    {
 	      ref_info->refs[offset] = ref;
@@ -1419,7 +1498,7 @@ df_reorganize_refs_by_reg_by_reg (struct df_ref_info *ref_info,
 	}
       if (include_uses)
 	{
-	  struct df_ref *ref = DF_REG_USE_CHAIN (regno);
+	  df_ref ref = DF_REG_USE_CHAIN (regno);
 	  while (ref) 
 	    {
 	      ref_info->refs[offset] = ref;
@@ -1431,7 +1510,7 @@ df_reorganize_refs_by_reg_by_reg (struct df_ref_info *ref_info,
 	}
       if (include_eq_uses)
 	{
-	  struct df_ref *ref = DF_REG_EQ_USE_CHAIN (regno);
+	  df_ref ref = DF_REG_EQ_USE_CHAIN (regno);
 	  while (ref) 
 	    {
 	      ref_info->refs[offset] = ref;
@@ -1480,7 +1559,7 @@ df_reorganize_refs_by_reg_by_insn (struct df_ref_info *ref_info,
     {
       basic_block bb = BASIC_BLOCK (bb_index);
       rtx insn;
-      struct df_ref **ref_rec;
+      df_ref *ref_rec;
 
       if (include_defs)
 	for (ref_rec = df_get_artificial_defs (bb_index); *ref_rec; ref_rec++)
@@ -1534,12 +1613,12 @@ df_reorganize_refs_by_reg_by_insn (struct df_ref_info *ref_info,
     {
       basic_block bb = BASIC_BLOCK (bb_index);
       rtx insn;
-      struct df_ref **ref_rec;
+      df_ref *ref_rec;
 
       if (include_defs)
 	for (ref_rec = df_get_artificial_defs (bb_index); *ref_rec; ref_rec++)
 	  {
-	    struct df_ref *ref = *ref_rec;
+	    df_ref ref = *ref_rec;
 	    unsigned int regno = DF_REF_REGNO (ref);
 	    if (regno >= start)
 	      {
@@ -1552,7 +1631,7 @@ df_reorganize_refs_by_reg_by_insn (struct df_ref_info *ref_info,
       if (include_uses)
 	for (ref_rec = df_get_artificial_uses (bb_index); *ref_rec; ref_rec++)
 	  {
-	    struct df_ref *ref = *ref_rec;
+	    df_ref ref = *ref_rec;
 	    unsigned int regno = DF_REF_REGNO (ref);
 	    if (regno >= start)
 	      {
@@ -1572,7 +1651,7 @@ df_reorganize_refs_by_reg_by_insn (struct df_ref_info *ref_info,
 	      if (include_defs)
 		for (ref_rec = DF_INSN_UID_DEFS (uid); *ref_rec; ref_rec++)
 		  {
-		    struct df_ref *ref = *ref_rec;
+		    df_ref ref = *ref_rec;
 		    unsigned int regno = DF_REF_REGNO (ref);
 		    if (regno >= start)
 		      {
@@ -1585,7 +1664,7 @@ df_reorganize_refs_by_reg_by_insn (struct df_ref_info *ref_info,
 	      if (include_uses)
 		for (ref_rec = DF_INSN_UID_USES (uid); *ref_rec; ref_rec++)
 		  {
-		    struct df_ref *ref = *ref_rec;
+		    df_ref ref = *ref_rec;
 		    unsigned int regno = DF_REF_REGNO (ref);
 		    if (regno >= start)
 		      {
@@ -1598,7 +1677,7 @@ df_reorganize_refs_by_reg_by_insn (struct df_ref_info *ref_info,
 	      if (include_eq_uses)
 		for (ref_rec = DF_INSN_UID_EQ_USES (uid); *ref_rec; ref_rec++)
 		  {
-		    struct df_ref *ref = *ref_rec;
+		    df_ref ref = *ref_rec;
 		    unsigned int regno = DF_REF_REGNO (ref);
 		    if (regno >= start)
 		      {
@@ -1641,11 +1720,11 @@ df_reorganize_refs_by_reg (struct df_ref_info *ref_info,
 static unsigned int 
 df_add_refs_to_table (unsigned int offset, 
 		      struct df_ref_info *ref_info, 
-		      struct df_ref **ref_vec)
+		      df_ref *ref_vec)
 {
   while (*ref_vec)
     {
-      struct df_ref *ref = *ref_vec;
+      df_ref ref = *ref_vec;
       if ((!(df->changeable_flags & DF_NO_HARD_REGS))
 	  || (DF_REF_REGNO (ref) >= FIRST_PSEUDO_REGISTER))
 	{
@@ -1813,25 +1892,6 @@ df_maybe_reorganize_def_refs (enum df_ref_order order)
 }
 
 
-/* Change the BB of all refs in the ref chain from OLD_BB to NEW_BB.
-   Assumes that all refs in the chain have the same BB.  */
-
-static void
-df_ref_chain_change_bb (struct df_ref **ref_rec, 
-                        basic_block old_bb,
-                        basic_block new_bb)
-{
-  while (*ref_rec)
-    {
-      struct df_ref *ref = *ref_rec;
-
-      gcc_assert (DF_REF_BB (ref) == old_bb);
-      DF_REF_BB (ref) = new_bb;
-      ref_rec++;
-    }
-}
-
-
 /* Change all of the basic block references in INSN to use the insn's
    current basic block.  This function is called from routines that move 
    instructions from one block to another.  */  
@@ -1866,10 +1926,6 @@ df_insn_change_bb (rtx insn, basic_block new_bb)
   if (!INSN_P (insn))
     return;
 
-  df_ref_chain_change_bb (insn_info->defs, old_bb, new_bb);
-  df_ref_chain_change_bb (insn_info->uses, old_bb, new_bb);
-  df_ref_chain_change_bb (insn_info->eq_uses, old_bb, new_bb);
-
   df_set_bb_dirty (new_bb);
   if (old_bb)
     {
@@ -1887,18 +1943,22 @@ df_insn_change_bb (rtx insn, basic_block new_bb)
 /* Helper function for df_ref_change_reg_with_loc.  */
 
 static void
-df_ref_change_reg_with_loc_1 (struct df_reg_info *old_df, struct df_reg_info *new_df,
+df_ref_change_reg_with_loc_1 (struct df_reg_info *old_df, 
+			      struct df_reg_info *new_df,
 			      int new_regno, rtx loc)
 {
-  struct df_ref *the_ref = old_df->reg_chain;
+  df_ref the_ref = old_df->reg_chain;
 
   while (the_ref)
     {
-      if (DF_REF_LOC(the_ref) && (*DF_REF_LOC(the_ref) == loc))
+      if ((!DF_REF_IS_ARTIFICIAL (the_ref))
+	  && (DF_REF_LOC (the_ref))
+	  && (*DF_REF_LOC (the_ref) == loc))
 	{
-	  struct df_ref *next_ref = the_ref->next_reg;
-	  struct df_ref *prev_ref = the_ref->prev_reg;
-	  struct df_ref **ref_vec, **ref_vec_t;
+	  df_ref next_ref = DF_REF_NEXT_REG (the_ref);
+	  df_ref prev_ref = DF_REF_PREV_REG (the_ref);
+	  df_ref *ref_vec, *ref_vec_t;
+	  struct df_insn_info *insn_info = DF_REF_INSN_INFO (the_ref);
 	  unsigned int count = 0;
 
 	  DF_REF_REGNO (the_ref) = new_regno;
@@ -1906,64 +1966,55 @@ df_ref_change_reg_with_loc_1 (struct df_reg_info *old_df, struct df_reg_info *ne
 
 	  /* Pull the_ref out of the old regno chain.  */
 	  if (prev_ref)
-	    prev_ref->next_reg = next_ref;
+	    DF_REF_NEXT_REG (prev_ref) = next_ref;
 	  else
 	    old_df->reg_chain = next_ref;
 	  if (next_ref)
-	    next_ref->prev_reg = prev_ref;
+	    DF_REF_PREV_REG (next_ref) = prev_ref;
 	  old_df->n_refs--;
 
 	  /* Put the ref into the new regno chain.  */
-	  the_ref->prev_reg = NULL;
-	  the_ref->next_reg = new_df->reg_chain;
+	  DF_REF_PREV_REG (the_ref) = NULL;
+	  DF_REF_NEXT_REG (the_ref) = new_df->reg_chain;
 	  if (new_df->reg_chain)
-	    new_df->reg_chain->prev_reg = the_ref;
+	    DF_REF_PREV_REG (new_df->reg_chain) = the_ref;
 	  new_df->reg_chain = the_ref;
 	  new_df->n_refs++;
 	  df_set_bb_dirty (DF_REF_BB (the_ref));
 
-	  /* Need to resort the record that the ref was in because the
-	     regno is a sorting key.  First, find the right record.  */
-	  if (DF_REF_IS_ARTIFICIAL (the_ref))
-	    {
-	      unsigned int bb_index = DF_REF_BB (the_ref)->index;
-	      if (DF_REF_REG_DEF_P (the_ref))
-		ref_vec = df_get_artificial_defs (bb_index);
-	      else
-		ref_vec = df_get_artificial_uses (bb_index);
-	    }
+	  /* Need to sort the record again that the ref was in because
+	     the regno is a sorting key.  First, find the right
+	     record.  */
+	  if (DF_REF_FLAGS (the_ref) & DF_REF_IN_NOTE)
+	    ref_vec = insn_info->eq_uses;
 	  else
-	    {
-	      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
-		ref_vec = insn_info->uses;
-	      if (dump_file)
-		fprintf (dump_file, "changing reg in insn %d\n", 
-			 INSN_UID (DF_REF_INSN (the_ref))); 
-	    }
+	    ref_vec = insn_info->uses;
+	  if (dump_file)
+	    fprintf (dump_file, "changing reg in insn %d\n", 
+		     DF_REF_INSN_UID (the_ref)); 
+      
 	  ref_vec_t = ref_vec;
-
+	  
 	  /* Find the length.  */
 	  while (*ref_vec_t)
 	    {
 	      count++;
 	      ref_vec_t++;
 	    }
-	  qsort (ref_vec, count, sizeof (struct df_ref *), df_ref_compare);
+	  qsort (ref_vec, count, sizeof (df_ref ), df_ref_compare);
 
 	  the_ref = next_ref;
 	}
       else
-	the_ref = the_ref->next_reg;
+	the_ref = DF_REF_NEXT_REG (the_ref);
     }
 }
 
 
 /* Change the regno of all refs that contained LOC from OLD_REGNO to
-   NEW_REGNO.  Refs that do not match LOC are not changed.  This call
-   is to support the SET_REGNO macro. */
+   NEW_REGNO.  Refs that do not match LOC are not changed which means
+   that artificial refs are not changed since they have no loc.  This
+   call is to support the SET_REGNO macro. */
 
 void
 df_ref_change_reg_with_loc (int old_regno, int new_regno, rtx loc)
@@ -2087,7 +2138,7 @@ df_notes_rescan (rtx insn)
       unsigned int num_deleted;
 
       memset (&collection_rec, 0, sizeof (struct df_collection_rec));
-      collection_rec.eq_use_vec = XALLOCAVEC (struct df_ref *, 1000);
+      collection_rec.eq_use_vec = XALLOCAVEC (df_ref, 1000);
       collection_rec.mw_vec = XALLOCAVEC (struct df_mw_hardreg *, 1000);
 
       num_deleted = df_mw_hardreg_chain_delete_eq_uses (insn_info);
@@ -2102,7 +2153,7 @@ df_notes_rescan (rtx insn)
 	    {
 	    case REG_EQUIV:
 	    case REG_EQUAL:
-	      df_uses_record (&collection_rec,
+	      df_uses_record (DF_REF_REGULAR, &collection_rec,
 			      &XEXP (note, 0), DF_REF_REG_USE,
 			      bb, insn_info, DF_REF_IN_NOTE, -1, -1, 0);
 	    default:
@@ -2170,30 +2221,44 @@ df_notes_rescan (rtx insn)
    It ignores DF_REF_MARKER.  */
 
 static bool
-df_ref_equal_p (struct df_ref *ref1, struct df_ref *ref2)
+df_ref_equal_p (df_ref ref1, df_ref ref2)
 {
   if (!ref2)
     return false;
+  
+  if (ref1 == ref2)
+    return true;
+
+  if (DF_REF_CLASS (ref1) != DF_REF_CLASS (ref2)
+      || DF_REF_REGNO (ref1) != DF_REF_REGNO (ref2)
+      || DF_REF_REG (ref1) != DF_REF_REG (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)))
+      || DF_REF_BB (ref1) != DF_REF_BB (ref2)
+      || DF_REF_INSN_INFO (ref1) != DF_REF_INSN_INFO (ref2))
+    return false;
+  
+  switch (DF_REF_CLASS (ref1))
+    {
+    case DF_REF_ARTIFICIAL:
+    case DF_REF_BASE:
+      return true;
 
-  /* The two flag tests here are only to make sure we do not look at
-     the offset and width if they are not there.  The flags are
-     compared in the next set of tests.  */
-  if ((DF_REF_FLAGS_IS_SET (ref1, DF_REF_SIGN_EXTRACT | DF_REF_ZERO_EXTRACT))
-      && (DF_REF_FLAGS_IS_SET (ref2, DF_REF_SIGN_EXTRACT | DF_REF_ZERO_EXTRACT))
-      && ((DF_REF_EXTRACT_OFFSET (ref1) != DF_REF_EXTRACT_OFFSET (ref2))
+    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;
+	  || (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);
 
-  return (ref1 == 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_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)))
-     && DF_REF_BB (ref1) == DF_REF_BB (ref2));
+    default:
+      gcc_unreachable ();
+    }
+  return false;
 }
 
 
@@ -2204,20 +2269,27 @@ df_ref_equal_p (struct df_ref *ref1, struct df_ref *ref2)
 static int
 df_ref_compare (const void *r1, const void *r2)
 {
-  const struct df_ref *const ref1 = *(const struct df_ref *const*)r1;
-  const struct df_ref *const ref2 = *(const struct df_ref *const*)r2;
+  const df_ref ref1 = *(const df_ref *)r1;
+  const df_ref ref2 = *(const df_ref *)r2;
 
   if (ref1 == ref2)
     return 0;
 
+  if (DF_REF_CLASS (ref1) != DF_REF_CLASS (ref2))
+    return (int)DF_REF_CLASS (ref1) - (int)DF_REF_CLASS (ref2);
+
   if (DF_REF_REGNO (ref1) != DF_REF_REGNO (ref2))
     return (int)DF_REF_REGNO (ref1) - (int)DF_REF_REGNO (ref2);
   
   if (DF_REF_TYPE (ref1) != DF_REF_TYPE (ref2))
     return (int)DF_REF_TYPE (ref1) - (int)DF_REF_TYPE (ref2);
 
-  if ((DF_REF_REG (ref1) != DF_REF_REG (ref2))
-      || (DF_REF_LOC (ref1) != DF_REF_LOC (ref2)))
+  if (DF_REF_REG (ref1) != DF_REF_REG (ref2))
+    return (int)DF_REF_ORDER (ref1) - (int)DF_REF_ORDER (ref2);
+
+  /* Cannot look at the LOC field on artificial refs.  */
+  if (DF_REF_CLASS (ref1) != DF_REF_ARTIFICIAL
+      && DF_REF_LOC (ref1) != DF_REF_LOC (ref2))
     return (int)DF_REF_ORDER (ref1) - (int)DF_REF_ORDER (ref2);
 
   if (DF_REF_FLAGS (ref1) != DF_REF_FLAGS (ref2))
@@ -2234,24 +2306,24 @@ df_ref_compare (const void *r1, const void *r2)
 	return 1;
     }
 
-  /* The flags are the same at this point so it is safe to only look
+  /* The classes are the same at this point so it is safe to only look
      at ref1.  */
-  if (DF_REF_FLAGS_IS_SET (ref1, DF_REF_SIGN_EXTRACT | DF_REF_ZERO_EXTRACT))
+  if (DF_REF_CLASS (ref1) == DF_REF_EXTRACT)
     {
-      if (DF_REF_EXTRACT_OFFSET_CONST (ref1) != DF_REF_EXTRACT_OFFSET_CONST (ref2))
-	return DF_REF_EXTRACT_OFFSET_CONST (ref1) - DF_REF_EXTRACT_OFFSET_CONST (ref2);
-      if (DF_REF_EXTRACT_WIDTH_CONST (ref1) != DF_REF_EXTRACT_WIDTH_CONST (ref2))
-	return DF_REF_EXTRACT_WIDTH_CONST (ref1) - DF_REF_EXTRACT_WIDTH_CONST (ref2);
-      if (DF_REF_EXTRACT_MODE_CONST (ref1) != DF_REF_EXTRACT_MODE_CONST (ref2))
-	return DF_REF_EXTRACT_MODE_CONST (ref1) - DF_REF_EXTRACT_MODE_CONST (ref2);
+      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 0;
 }
 
 static void
-df_swap_refs (struct df_ref **ref_vec, int i, int j)
+df_swap_refs (df_ref *ref_vec, int i, int j)
 {
-  struct df_ref *tmp = ref_vec[i];
+  df_ref tmp = ref_vec[i];
   ref_vec[i] = ref_vec[j];
   ref_vec[j] = tmp;
 }
@@ -2259,7 +2331,7 @@ df_swap_refs (struct df_ref **ref_vec, int i, int j)
 /* Sort and compress a set of refs.  */
 
 static unsigned int
-df_sort_and_compress_refs (struct df_ref **ref_vec, unsigned int count)
+df_sort_and_compress_refs (df_ref *ref_vec, unsigned int count)
 {
   unsigned int i;
   unsigned int dist = 0;
@@ -2287,7 +2359,7 @@ df_sort_and_compress_refs (struct df_ref **ref_vec, unsigned int count)
          of DF_REF_COMPARE.  */
       if (i == count - 1)
         return count;
-      qsort (ref_vec, count, sizeof (struct df_ref *), df_ref_compare);
+      qsort (ref_vec, count, sizeof (df_ref), df_ref_compare);
     }
 
   for (i=0; i<count-dist; i++)
@@ -2427,14 +2499,14 @@ df_canonize_collection_rec (struct df_collection_rec *collection_rec)
 /* Add the new df_ref to appropriate reg_info/ref_info chains.  */
 
 static void
-df_install_ref (struct df_ref *this_ref, 
+df_install_ref (df_ref this_ref, 
 		struct df_reg_info *reg_info, 
 		struct df_ref_info *ref_info,
 		bool add_to_table)
 {
   unsigned int regno = DF_REF_REGNO (this_ref);
   /* Add the ref to the reg_{def,use,eq_use} chain.  */
-  struct df_ref *head = reg_info->reg_chain;
+  df_ref head = reg_info->reg_chain;
 
   reg_info->reg_chain = this_ref;
   reg_info->n_refs++;
@@ -2476,9 +2548,9 @@ df_install_ref (struct df_ref *this_ref,
    eq_uses) and installs the entire group into the insn.  It also adds
    each of these refs into the appropriate chains.  */
 
-static struct df_ref **
+static df_ref *
 df_install_refs (basic_block bb,
-		 struct df_ref **old_vec, unsigned int count, 
+		 df_ref *old_vec, unsigned int count, 
 		 struct df_reg_info **reg_info, 
 		 struct df_ref_info *ref_info,
 		 bool is_notes)
@@ -2486,7 +2558,7 @@ df_install_refs (basic_block bb,
   if (count)
     {
       unsigned int i;
-      struct df_ref **new_vec = XNEWVEC (struct df_ref*, count + 1);
+      df_ref *new_vec = XNEWVEC (df_ref, count + 1);
       bool add_to_table;
 
       switch (ref_info->ref_order)
@@ -2514,7 +2586,7 @@ df_install_refs (basic_block bb,
 
       for (i = 0; i < count; i++)
 	{
-	  struct df_ref *this_ref = old_vec[i];
+	  df_ref this_ref = old_vec[i];
 	  new_vec[i] = this_ref;
 	  df_install_ref (this_ref, reg_info[DF_REF_REGNO (this_ref)], 
 			  ref_info, add_to_table);
@@ -2622,37 +2694,57 @@ df_refs_add_to_chains (struct df_collection_rec *collection_rec,
    if they were constants.  Otherwise they should be -1 if those flags
    were set.  */
 
-static struct df_ref *
-df_ref_create_structure (struct df_collection_rec *collection_rec,
+static df_ref 
+df_ref_create_structure (enum df_ref_class cl, 
+			 struct df_collection_rec *collection_rec,
 			 rtx reg, rtx *loc, 
 			 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)
 {
-  struct df_ref *this_ref;
+  df_ref this_ref = NULL;
   int regno = REGNO (GET_CODE (reg) == SUBREG ? SUBREG_REG (reg) : reg);
   struct df_scan_problem_data *problem_data
     = (struct df_scan_problem_data *) df_scan->problem_data;
 
-  if (ref_flags & (DF_REF_SIGN_EXTRACT | DF_REF_ZERO_EXTRACT))
+  switch (cl)
     {
-      this_ref = (struct df_ref *) pool_alloc (problem_data->ref_extract_pool);
+    case DF_REF_BASE:
+      this_ref = (df_ref) pool_alloc (problem_data->ref_base_pool);
+      gcc_assert (loc == NULL);
+      break;
+
+    case DF_REF_ARTIFICIAL:
+      this_ref = (df_ref) pool_alloc (problem_data->ref_artificial_pool);
+      this_ref->artificial_ref.bb = bb;
+      gcc_assert (loc == NULL);
+      break;
+
+    case DF_REF_REGULAR:
+      this_ref = (df_ref) pool_alloc (problem_data->ref_regular_pool);
+      this_ref->regular_ref.loc = loc;
+      gcc_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_assert (loc);
+      break;
     }
-  else
-    this_ref = (struct df_ref *) pool_alloc (problem_data->ref_pool);
+
+  DF_REF_CLASS (this_ref) = cl;
   DF_REF_ID (this_ref) = -1;
   DF_REF_REG (this_ref) = reg;
   DF_REF_REGNO (this_ref) =  regno;
-  DF_REF_LOC (this_ref) = loc;
+  DF_REF_TYPE (this_ref) = ref_type;
   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;
-  DF_REF_BB (this_ref) = bb;
   DF_REF_NEXT_REG (this_ref) = NULL;
   DF_REF_PREV_REG (this_ref) = NULL;
   DF_REF_ORDER (this_ref) = df->ref_order++;
@@ -2666,7 +2758,7 @@ df_ref_create_structure (struct df_collection_rec *collection_rec,
   if ((regno < FIRST_PSEUDO_REGISTER) 
       && (!DF_REF_IS_ARTIFICIAL (this_ref)))
     {
-      if (DF_REF_TYPE (this_ref) == DF_REF_REG_DEF)
+      if (DF_REF_REG_DEF_P (this_ref))
 	{
 	  if (!DF_REF_FLAGS_IS_SET (this_ref, DF_REF_MAY_CLOBBER))
 	    DF_REF_FLAGS_SET (this_ref, DF_HARD_REG_LIVE);
@@ -2679,7 +2771,7 @@ df_ref_create_structure (struct df_collection_rec *collection_rec,
 
   if (collection_rec)
     {
-      if (DF_REF_TYPE (this_ref) == DF_REF_REG_DEF)
+      if (DF_REF_REG_DEF_P (this_ref))
 	collection_rec->def_vec[collection_rec->next_def++] = this_ref;
       else if (DF_REF_FLAGS (this_ref) & DF_REF_IN_NOTE)
 	collection_rec->eq_use_vec[collection_rec->next_eq_use++] = this_ref;
@@ -2701,7 +2793,8 @@ df_ref_create_structure (struct df_collection_rec *collection_rec,
 
 
 static void
-df_ref_record (struct df_collection_rec *collection_rec,
+df_ref_record (enum df_ref_class cl, 
+	       struct df_collection_rec *collection_rec,
                rtx reg, rtx *loc, 
 	       basic_block bb, struct df_insn_info *insn_info,
 	       enum df_ref_type ref_type, 
@@ -2720,7 +2813,7 @@ df_ref_record (struct df_collection_rec *collection_rec,
         = (struct df_scan_problem_data *) df_scan->problem_data;
       unsigned int i;
       unsigned int endregno;
-      struct df_ref *ref;
+      df_ref ref;
 
       if (GET_CODE (reg) == SUBREG)
 	{
@@ -2754,7 +2847,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, 
+	  ref = df_ref_create_structure (cl, collection_rec, regno_reg_rtx[i], loc, 
 					 bb, insn_info, ref_type, ref_flags, 
 					 width, offset, mode);
 
@@ -2763,9 +2856,8 @@ 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_info, 
-                                     ref_type, ref_flags, width, offset, mode);
+      df_ref_create_structure (cl, collection_rec, reg, loc, bb, insn_info, 
+			       ref_type, ref_flags, width, offset, mode);
     }
 }
 
@@ -2802,6 +2894,7 @@ df_def_record_1 (struct df_collection_rec *collection_rec,
   int offset = -1;
   int width = -1;
   enum machine_mode mode = 0;
+  enum df_ref_class cl = DF_REF_REGULAR;
 
  /* We may recursively call ourselves on EXPR_LIST when dealing with PARALLEL
      construct.  */
@@ -2847,6 +2940,7 @@ df_def_record_1 (struct df_collection_rec *collection_rec,
 	  width = INTVAL (XEXP (dst, 1));
 	  offset = INTVAL (XEXP (dst, 2));
 	  mode = GET_MODE (dst);
+	  cl = DF_REF_EXTRACT;
 	}
 
       loc = &XEXP (dst, 0);
@@ -2856,14 +2950,14 @@ df_def_record_1 (struct df_collection_rec *collection_rec,
   /* At this point if we do not have a reg or a subreg, just return.  */
   if (REG_P (dst))
     {
-      df_ref_record (collection_rec, 
+      df_ref_record (cl, collection_rec, 
 		     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,
+	df_ref_record (DF_REF_BASE, collection_rec,
 		       dst, NULL, bb, insn_info, DF_REF_REG_USE, flags, 
 		       width, offset, mode);
     }
@@ -2874,7 +2968,7 @@ df_def_record_1 (struct df_collection_rec *collection_rec,
 
       flags |= DF_REF_SUBREG;
 
-      df_ref_record (collection_rec, 
+      df_ref_record (cl, collection_rec, 
 		     dst, loc, bb, insn_info, DF_REF_REG_DEF, flags, 
 		     width, offset, mode);
     }
@@ -2921,7 +3015,7 @@ df_defs_record (struct df_collection_rec *collection_rec,
    those flags were set.  */
 
 static void
-df_uses_record (struct df_collection_rec *collection_rec,
+df_uses_record (enum df_ref_class cl, struct df_collection_rec *collection_rec,
                 rtx *loc, enum df_ref_type ref_type,
 		basic_block bb, struct df_insn_info *insn_info,
 		enum df_ref_flags flags,
@@ -2954,7 +3048,7 @@ df_uses_record (struct df_collection_rec *collection_rec,
       /* If we are clobbering a MEM, mark any registers inside the address
 	 as being used.  */
       if (MEM_P (XEXP (x, 0)))
-	df_uses_record (collection_rec,
+	df_uses_record (cl, collection_rec,
 			&XEXP (XEXP (x, 0), 0),
 			DF_REF_REG_MEM_STORE,
 		        bb, insn_info,
@@ -2964,7 +3058,7 @@ df_uses_record (struct df_collection_rec *collection_rec,
       return;
 
     case MEM:
-      df_uses_record (collection_rec,
+      df_uses_record (cl, collection_rec,
 		      &XEXP (x, 0), DF_REF_REG_MEM_LOAD, 
 		      bb, insn_info, flags & DF_REF_IN_NOTE, 
 		      width, offset, mode);
@@ -2977,14 +3071,14 @@ 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_info, flags, 
+	  df_uses_record (cl, collection_rec, loc, ref_type, bb, insn_info, flags, 
 			  width, offset, mode);
 	  return;
 	}
       /* ... Fall through ...  */
 
     case REG:
-      df_ref_record (collection_rec, 
+      df_ref_record (cl, collection_rec, 
 		     x, loc, bb, insn_info,
 		     ref_type, flags, 
 		     width, offset, mode);
@@ -3008,7 +3102,7 @@ df_uses_record (struct df_collection_rec *collection_rec,
 	    else
 	      flags |= DF_REF_SIGN_EXTRACT;
 
-	    df_uses_record (collection_rec,
+	    df_uses_record (DF_REF_EXTRACT, collection_rec,
 			    &XEXP (x, 0), ref_type, bb, insn_info, flags, 
 			    width, offset, mode);
 	    return;
@@ -3020,7 +3114,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,
+	df_uses_record (cl, collection_rec,
 			&SET_SRC (x), DF_REF_REG_USE, bb, insn_info, flags, 
 			width, offset, mode);
 
@@ -3029,7 +3123,7 @@ df_uses_record (struct df_collection_rec *collection_rec,
 	    case SUBREG:
 	      if (df_read_modify_subreg_p (dst))
 		{
-		  df_uses_record (collection_rec, &SUBREG_REG (dst), 
+		  df_uses_record (cl, collection_rec, &SUBREG_REG (dst), 
 				  DF_REF_REG_USE, bb, insn_info, 
 				  flags | DF_REF_READ_WRITE | DF_REF_SUBREG, 
 				  width, offset, mode);
@@ -3043,7 +3137,7 @@ df_uses_record (struct df_collection_rec *collection_rec,
 	    case CC0:
 		break;
 	    case MEM:
-	      df_uses_record (collection_rec, &XEXP (dst, 0),
+	      df_uses_record (cl, collection_rec, &XEXP (dst, 0),
 			      DF_REF_REG_MEM_STORE, bb, insn_info, flags, 
 			      width, offset, mode);
 	      break;
@@ -3053,7 +3147,7 @@ df_uses_record (struct df_collection_rec *collection_rec,
 		/* A strict_low_part uses the whole REG and not just the
 		 SUBREG.  */
 		dst = XEXP (dst, 0);
-		df_uses_record (collection_rec, 
+		df_uses_record (cl, 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, 
@@ -3068,21 +3162,25 @@ df_uses_record (struct df_collection_rec *collection_rec,
 		    width = INTVAL (XEXP (dst, 1));
 		    offset = INTVAL (XEXP (dst, 2));
 		    mode = GET_MODE (dst);
+		    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 (collection_rec, &XEXP (dst, 1), 
+		    df_uses_record (cl, collection_rec, &XEXP (dst, 1), 
 				    DF_REF_REG_USE, bb, insn_info, flags, 
 				    width, offset, mode);
-		    df_uses_record (collection_rec, &XEXP (dst, 2), 
+		    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, 0), 
-				DF_REF_REG_USE, bb, insn_info, 
-				DF_REF_READ_WRITE | DF_REF_ZERO_EXTRACT, 
-				width, offset, mode);
 	      }
 	      break;
 
@@ -3131,7 +3229,7 @@ df_uses_record (struct df_collection_rec *collection_rec,
 	    int j;
 
 	    for (j = 0; j < ASM_OPERANDS_INPUT_LENGTH (x); j++)
-	      df_uses_record (collection_rec, &ASM_OPERANDS_INPUT (x, j),
+	      df_uses_record (cl, collection_rec, &ASM_OPERANDS_INPUT (x, j),
 			      DF_REF_REG_USE, bb, insn_info, flags, 
 			      width, offset, mode);
 	    return;
@@ -3146,7 +3244,7 @@ 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),
+      df_ref_record (cl, 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, 
@@ -3173,7 +3271,7 @@ df_uses_record (struct df_collection_rec *collection_rec,
 		loc = &XEXP (x, 0);
 		goto retry;
 	      }
-	    df_uses_record (collection_rec, &XEXP (x, i), ref_type, 
+	    df_uses_record (cl, collection_rec, &XEXP (x, i), ref_type, 
 			    bb, insn_info, flags, 
 			    width, offset, mode);
 	  }
@@ -3181,7 +3279,7 @@ df_uses_record (struct df_collection_rec *collection_rec,
 	  {
 	    int j;
 	    for (j = 0; j < XVECLEN (x, i); j++)
-	      df_uses_record (collection_rec,
+	      df_uses_record (cl, collection_rec,
 			      &XVECEXP (x, i, j), ref_type, 
 			      bb, insn_info, flags, 
 			      width, offset, mode);
@@ -3201,13 +3299,13 @@ df_get_conditional_uses (struct df_collection_rec *collection_rec)
   unsigned int i;
   for (i = 0; i < collection_rec->next_def; i++)
     {
-      struct df_ref *ref = collection_rec->def_vec[i];
+      df_ref ref = collection_rec->def_vec[i];
       if (DF_REF_FLAGS_IS_SET (ref, DF_REF_CONDITIONAL))
         {
 	  int width = -1;
 	  int offset = -1;
 	  enum machine_mode mode = 0;
-          struct df_ref *use;
+          df_ref use;
 
 	  if (DF_REF_FLAGS_IS_SET (ref, DF_REF_SIGN_EXTRACT | DF_REF_ZERO_EXTRACT))
 	    {
@@ -3216,7 +3314,7 @@ df_get_conditional_uses (struct df_collection_rec *collection_rec)
 	      mode = DF_REF_EXTRACT_MODE (ref);
 	    }
 
-          use = df_ref_create_structure (collection_rec, DF_REF_REG (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,
@@ -3247,7 +3345,7 @@ df_get_call_refs (struct df_collection_rec * collection_rec,
      depending on which def is seen first.  */
   for (i=0; i<collection_rec->next_def; i++)
     {
-      struct df_ref *def = collection_rec->def_vec[i];
+      df_ref def = collection_rec->def_vec[i];
       bitmap_set_bit (defs_generated, DF_REF_REGNO (def));
     }
 
@@ -3257,7 +3355,7 @@ df_get_call_refs (struct df_collection_rec * collection_rec,
        note = XEXP (note, 1))
     {
       if (GET_CODE (XEXP (note, 0)) == USE)
-        df_uses_record (collection_rec, &XEXP (XEXP (note, 0), 0),
+        df_uses_record (DF_REF_REGULAR, collection_rec, &XEXP (XEXP (note, 0), 0),
 			DF_REF_REG_USE, bb, insn_info, flags, -1, -1, 0);
       else if (GET_CODE (XEXP (note, 0)) == CLOBBER)
 	{
@@ -3269,13 +3367,13 @@ df_get_call_refs (struct df_collection_rec * collection_rec,
 				insn_info, flags);
 	    }
 	  else
-	    df_uses_record (collection_rec, &XEXP (note, 0),
+	    df_uses_record (DF_REF_REGULAR, collection_rec, &XEXP (note, 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],
+  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, 0);
@@ -3285,9 +3383,9 @@ df_get_call_refs (struct df_collection_rec * collection_rec,
   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
     if (global_regs[i])
       {
-	df_ref_record (collection_rec, regno_reg_rtx[i],
+	df_ref_record (DF_REF_BASE, collection_rec, regno_reg_rtx[i],
 		       NULL, bb, insn_info, DF_REF_REG_USE, flags, -1, -1, 0);
-	df_ref_record (collection_rec, regno_reg_rtx[i],
+	df_ref_record (DF_REF_BASE, collection_rec, regno_reg_rtx[i],
 		       NULL, bb, insn_info, DF_REF_REG_DEF, flags, -1, -1, 0);
       }
 
@@ -3300,7 +3398,7 @@ df_get_call_refs (struct df_collection_rec * collection_rec,
 	      || !bitmap_bit_p (df->exit_block_uses, ui)
 	      || refers_to_regno_p (ui, ui+1, 
 				    crtl->return_rtx, NULL)))
-        df_ref_record (collection_rec, regno_reg_rtx[ui], 
+        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, 0);
@@ -3339,18 +3437,18 @@ df_insn_refs_collect (struct df_collection_rec* collection_rec,
         {
         case REG_EQUIV:
         case REG_EQUAL:
-          df_uses_record (collection_rec,
+          df_uses_record (DF_REF_REGULAR, collection_rec,
                           &XEXP (note, 0), DF_REF_REG_USE,
                           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,
+          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, 0);
 #if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
-          df_ref_record (collection_rec,
+          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, 0);
@@ -3366,7 +3464,7 @@ df_insn_refs_collect (struct df_collection_rec* collection_rec,
 		      (is_cond_exec) ? DF_REF_CONDITIONAL : 0);
 
   /* Record the register uses.  */
-  df_uses_record (collection_rec,
+  df_uses_record (DF_REF_REGULAR, collection_rec,
 		  &PATTERN (insn_info->insn), DF_REF_REG_USE, bb, insn_info, 0, 
 		  -1, -1, 0);
 
@@ -3450,7 +3548,7 @@ df_bb_refs_collect (struct df_collection_rec *collection_rec, basic_block bb)
 	  unsigned regno = EH_RETURN_DATA_REGNO (i);
 	  if (regno == INVALID_REGNUM)
 	    break;
-	  df_ref_record (collection_rec, regno_reg_rtx[regno], NULL,
+	  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, 0);
 	}
     }
@@ -3474,7 +3572,7 @@ df_bb_refs_collect (struct df_collection_rec *collection_rec, basic_block bb)
          eh-receiver for all of the edges at once. */
       for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
 	if (EH_USES (i))
-	  df_ref_record (collection_rec, regno_reg_rtx[i], NULL,
+	  df_ref_record (DF_REF_ARTIFICIAL, collection_rec, regno_reg_rtx[i], NULL,
 			 bb, NULL, DF_REF_REG_USE, DF_REF_AT_TOP, -1, -1, 0);
     }
 #endif
@@ -3482,7 +3580,7 @@ df_bb_refs_collect (struct df_collection_rec *collection_rec, basic_block bb)
   /* Add the hard_frame_pointer if this block is the target of a
      non-local goto.  */
   if (bb->flags & BB_NON_LOCAL_GOTO_TARGET)
-    df_ref_record (collection_rec, hard_frame_pointer_rtx, NULL,
+    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, 0);
  
   /* Add the artificial uses.  */
@@ -3496,7 +3594,7 @@ df_bb_refs_collect (struct df_collection_rec *collection_rec, basic_block bb)
 
       EXECUTE_IF_SET_IN_BITMAP (au, 0, regno, bi)
 	{
-	  df_ref_record (collection_rec, regno_reg_rtx[regno], NULL,
+	  df_ref_record (DF_REF_ARTIFICIAL, collection_rec, regno_reg_rtx[regno], NULL,
 			 bb, NULL, DF_REF_REG_USE, 0, -1, -1, 0);
 	}
     }
@@ -3515,9 +3613,9 @@ df_bb_refs_record (int bb_index, bool scan_insns)
   int luid = 0;
   struct df_scan_bb_info *bb_info;
   struct df_collection_rec collection_rec;
-  collection_rec.def_vec = XALLOCAVEC (struct df_ref *, 1000);
-  collection_rec.use_vec = XALLOCAVEC (struct df_ref *, 1000);
-  collection_rec.eq_use_vec = XALLOCAVEC (struct df_ref *, 1000);
+  collection_rec.def_vec = XALLOCAVEC (df_ref, 1000);
+  collection_rec.use_vec = XALLOCAVEC (df_ref, 1000);
+  collection_rec.eq_use_vec = XALLOCAVEC (df_ref, 1000);
   collection_rec.mw_vec = XALLOCAVEC (struct df_mw_hardreg *, 100);
 
   if (!df)
@@ -3789,7 +3887,7 @@ df_entry_block_defs_collect (struct df_collection_rec *collection_rec,
 
   EXECUTE_IF_SET_IN_BITMAP (entry_block_defs, 0, i, bi)
     {
-      df_ref_record (collection_rec, regno_reg_rtx[i], NULL, 
+      df_ref_record (DF_REF_ARTIFICIAL, collection_rec, regno_reg_rtx[i], NULL, 
 		     ENTRY_BLOCK_PTR, NULL, DF_REF_REG_DEF, 0, -1, -1, 0);
     }
 
@@ -3805,7 +3903,7 @@ df_record_entry_block_defs (bitmap entry_block_defs)
 {
   struct df_collection_rec collection_rec;
   memset (&collection_rec, 0, sizeof (struct df_collection_rec));
-  collection_rec.def_vec = XALLOCAVEC (struct df_ref *, FIRST_PSEUDO_REGISTER);
+  collection_rec.def_vec = XALLOCAVEC (df_ref, FIRST_PSEUDO_REGISTER);
 
   df_entry_block_defs_collect (&collection_rec, entry_block_defs);
 
@@ -3950,7 +4048,7 @@ df_exit_block_uses_collect (struct df_collection_rec *collection_rec, bitmap exi
   bitmap_iterator bi;
 
   EXECUTE_IF_SET_IN_BITMAP (exit_block_uses, 0, i, bi)
-    df_ref_record (collection_rec, regno_reg_rtx[i], NULL,
+    df_ref_record (DF_REF_ARTIFICIAL, collection_rec, regno_reg_rtx[i], NULL,
 		   EXIT_BLOCK_PTR, NULL, DF_REF_REG_USE, 0, -1, -1, 0);
 
 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
@@ -3960,7 +4058,7 @@ df_exit_block_uses_collect (struct df_collection_rec *collection_rec, bitmap exi
       && !bitmap_bit_p (exit_block_uses, ARG_POINTER_REGNUM)
       && bb_has_eh_pred (EXIT_BLOCK_PTR)
       && fixed_regs[ARG_POINTER_REGNUM])
-    df_ref_record (collection_rec, regno_reg_rtx[ARG_POINTER_REGNUM], NULL,
+    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, 0);
 #endif
 
@@ -3976,7 +4074,7 @@ df_record_exit_block_uses (bitmap exit_block_uses)
 {
   struct df_collection_rec collection_rec;
   memset (&collection_rec, 0, sizeof (struct df_collection_rec));
-  collection_rec.use_vec = XALLOCAVEC (struct df_ref *, FIRST_PSEUDO_REGISTER);
+  collection_rec.use_vec = XALLOCAVEC (df_ref, FIRST_PSEUDO_REGISTER);
 
   df_exit_block_uses_collect (&collection_rec, exit_block_uses);
 
@@ -4183,11 +4281,11 @@ df_compute_regs_ever_live (bool reset)
 are in the correct chain.  */ 
 
 static unsigned int
-df_reg_chain_mark (struct df_ref *refs, unsigned int regno, 
+df_reg_chain_mark (df_ref refs, unsigned int regno, 
 		   bool is_def, bool is_eq_use)
 {
   unsigned int count = 0;
-  struct df_ref *ref;
+  df_ref ref;
   for (ref = refs; ref; ref = DF_REF_NEXT_REG (ref))
     {
       gcc_assert (!DF_REF_IS_REG_MARKED (ref));
@@ -4200,17 +4298,17 @@ df_reg_chain_mark (struct df_ref *refs, unsigned int regno,
       /* Check to make sure the ref is in the correct chain.  */
       gcc_assert (DF_REF_REGNO (ref) == regno);
       if (is_def)
-	gcc_assert (DF_REF_TYPE(ref) == DF_REF_REG_DEF);
+	gcc_assert (DF_REF_REG_DEF_P (ref));
       else
-	gcc_assert (DF_REF_TYPE(ref) != DF_REF_REG_DEF);
+	gcc_assert (!DF_REF_REG_DEF_P (ref));
 
       if (is_eq_use)
 	gcc_assert ((DF_REF_FLAGS (ref) & DF_REF_IN_NOTE));
       else
 	gcc_assert ((DF_REF_FLAGS (ref) & DF_REF_IN_NOTE) == 0);
 
-      if (ref->next_reg)
-	gcc_assert (ref->next_reg->prev_reg == ref);
+      if (DF_REF_NEXT_REG (ref))
+	gcc_assert (DF_REF_PREV_REG (DF_REF_NEXT_REG (ref)) == ref);
       count++;
       DF_REF_REG_MARK (ref);
     }
@@ -4221,9 +4319,9 @@ df_reg_chain_mark (struct df_ref *refs, unsigned int regno,
 /* Verify that all of the registers in the chain are unmarked.  */ 
 
 static void
-df_reg_chain_verify_unmarked (struct df_ref *refs)
+df_reg_chain_verify_unmarked (df_ref refs)
 {
-  struct df_ref *ref;
+  df_ref ref;
   for (ref = refs; ref; ref = DF_REF_NEXT_REG (ref))
     gcc_assert (!DF_REF_IS_REG_MARKED (ref));
 }
@@ -4232,7 +4330,7 @@ df_reg_chain_verify_unmarked (struct df_ref *refs)
 /* Verify that NEW_REC and OLD_REC have exactly the same members. */
 
 static bool
-df_refs_verify (struct df_ref **new_rec, struct df_ref **old_rec,
+df_refs_verify (df_ref *new_rec, df_ref *old_rec,
 		bool abort_if_fail)
 {
   while ((*new_rec) && (*old_rec))
@@ -4350,14 +4448,14 @@ df_bb_verify (basic_block bb)
   struct df_collection_rec collection_rec;
   
   memset (&collection_rec, 0, sizeof (struct df_collection_rec));
-  collection_rec.def_vec = XALLOCAVEC (struct df_ref *, 1000);
-  collection_rec.use_vec = XALLOCAVEC (struct df_ref *, 1000);
-  collection_rec.eq_use_vec = XALLOCAVEC (struct df_ref *, 1000);
+  collection_rec.def_vec = XALLOCAVEC (df_ref, 1000);
+  collection_rec.use_vec = XALLOCAVEC (df_ref, 1000);
+  collection_rec.eq_use_vec = XALLOCAVEC (df_ref, 1000);
   collection_rec.mw_vec = XALLOCAVEC (struct df_mw_hardreg *, 100);
 
   gcc_assert (bb_info);
 
-  /* Scan the block an insn at a time from beginning to end.  */
+  /* Scan the block, one insn at a time, from beginning to end.  */
   FOR_BB_INSNS_REVERSE (bb, insn)
     {
       if (!INSN_P (insn))