PR rtl-optimization/42575

	* dce.c (word_dce_process_block): Renamed from byte_dce_process_block.
	Argument AU removed.  All callers changed.  Ignore artificial refs.
	Use return value of df_word_lr_simulate_defs to decide whether an insn
	is necessary.
	(fast_dce): Rename arg to WORD_LEVEL.
	(run_word_dce): Renamed from rest_of_handle_fast_byte_dce.  No longer
	static.
	(pass_fast_rtl_byte_dce): Delete.
	* dce.h (run_word_dce): Declare.
	* df-core.c (df_print_word_regset): Renamed from df_print_byteregset.
	All callers changed.  Simplify code to only deal with two-word regs.
	* df.h (DF_WORD_LR): Renamed from DF_BYTE_LR.
	(DF_WORD_LR_BB_INFO): Renamed from DF_BYTE_LR_BB_INFO.
	(DF_WORD_LR_IN): Renamed from DF_BYTE_LR_IN.
	(DF_WORD_LR_OUT): Renamed from DF_BYTE_LR_OUT.
	(struct df_word_lr_bb_info): Renamed from df_byte_lr_bb_info.
	(df_word_lr_mark_ref): Declare.
	(df_word_lr_add_problem, df_word_lr_mark_ref, df_word_lr_simulate_defs,
	df_word_lr_simulate_uses): Declare or rename from byte variants.
	(df_byte_lr_simulate_artificial_refs_at_top,
	df_byte_lr_simulate_artificial_refs_at_end, df_byte_lr_get_regno_start,
	df_byte_lr_get_regno_len, df_compute_accessed_bytes): Delete
	declarations.
	(df_word_lr_get_bb_info): Rename from df_byte_lr_get_bb_info.
	(enum df_mm): Delete.
	* df-byte-scan.c: Delete file.
	* df-problems.c (df_word_lr_problem_data): Renamed from
	df_byte_lr_problem_data, all members deleted except for
	WORD_LR_BITMAPS, which is renamed from BYTE_LR_BITMAPS.  Uses changed.
	(df_word_lr_expand_bitmap, df_byte_lr_simulate_artificial_refs_at_top,
	df_byte_lr_simulate_artificial_refs_at_end, df_byte_lr_get_regno_start,
	df_byte_lr_get_regno_len, df_byte_lr_check_regs,
	df_byte_lr_confluence_0): Delete functions.
	(df_word_lr_free_bb_info): Renamed from df_byte_lr_free_bb_info; all
	callers changed.
	(df_word_lr_alloc): Renamed from df_byte_lr_alloc; all callers changed.
	Don't initialize members that were deleted, don't try to discover data
	about registers.  Ignore hard regs.
	(df_word_lr_reset): Renamed from df_byte_lr_reset; all callers changed.
	(df_word_lr_mark_ref): New function.
	(df_word_lr_bb_local_compute): Renamed from
	df_byte_bb_lr_local_compute; all callers changed.  Use
	df_word_lr_mark_ref.  Assert that artificial refs don't include
	pseudos.  Ignore hard registers.
	(df_word_lr_local_compute): Renamed from df_byte_lr_local_compute.
	Assert that exit block uses don't contain pseudos.
	(df_word_lr_init): Renamed from df_byte_lr_init; all callers changed.
	(df_word_lr_confluence_n): Renamed from df_byte_lr_confluence_n; all
	callers changed.  Ignore hard regs.
	(df_word_lr_transfer_function): Renamed from
	df_byte_lr_transfer_function; all callers changed.
	(df_word_lr_free): Renamed from df_byte_lr_free; all callers changed.
	(df_word_lr_top_dump): Renamed from df_byte_lr_top_dump; all callers
	changed.
	(df_word_lr_bottom_dump): Renamed from df_byte_lr_bottom_dump; all
	callers changed.
	(problem_WORD_LR): Renamed from problem_BYTE_LR; uses changed;
	confluence operator 0 set to NULL.
	(df_word_lr_add_problem): Renamed from df_byte_lr_add_problem; all
	callers changed.
	(df_word_lr_simulate_defs): Renamed from df_byte_lr_simulate_defs.
	Return bool, true if bitmap changed or insn otherwise necessary.
	All callers changed.  Simplify using df_word_lr_mark_ref.
	(df_word_lr_simulate_uses): Renamed from df_byte_lr_simulate_uses;
	all callers changed.  Simplify using df_word_lr_mark_ref.
	* lower-subreg.c: Include "dce.h"
	(decompose_multiword_subregs): Call run_word_dce if df available.
	* Makefile.in (lower-subreg.o): Adjust dependencies.
	(df-byte-scan.o): Delete.
	* timevar.def (TV_DF_WORD_LR): Renamed from TV_DF_BYTE_LR.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@162678 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 26 insertions, 86 deletions

diff --git a/gcc/dce.c b/gcc/dce.c
index ee18b58c4ab..19f8e42030d 100644
--- a/gcc/dce.c
+++ b/gcc/dce.c
@@ -767,12 +767,11 @@ struct rtl_opt_pass pass_ud_rtl_dce =
    artificial uses. */
 
 static bool
-byte_dce_process_block (basic_block bb, bool redo_out, bitmap au)
+word_dce_process_block (basic_block bb, bool redo_out)
 {
   bitmap local_live = BITMAP_ALLOC (&dce_tmp_bitmap_obstack);
   rtx insn;
   bool block_changed;
-  df_ref *def_rec;
 
   if (redo_out)
     {
@@ -781,8 +780,8 @@ byte_dce_process_block (basic_block bb, bool redo_out, bitmap au)
 	 set.  */
       edge e;
       edge_iterator ei;
-      df_confluence_function_n con_fun_n = df_byte_lr->problem->con_fun_n;
-      bitmap_clear (DF_BYTE_LR_OUT (bb));
+      df_confluence_function_n con_fun_n = df_word_lr->problem->con_fun_n;
+      bitmap_clear (DF_WORD_LR_OUT (bb));
       FOR_EACH_EDGE (e, ei, bb->succs)
 	(*con_fun_n) (e);
     }
@@ -790,76 +789,38 @@ byte_dce_process_block (basic_block bb, bool redo_out, bitmap au)
   if (dump_file)
     {
       fprintf (dump_file, "processing block %d live out = ", bb->index);
-      df_print_byte_regset (dump_file, DF_BYTE_LR_OUT (bb));
+      df_print_word_regset (dump_file, DF_WORD_LR_OUT (bb));
     }
 
-  bitmap_copy (local_live, DF_BYTE_LR_OUT (bb));
-
-  df_byte_lr_simulate_artificial_refs_at_end (bb, local_live);
+  bitmap_copy (local_live, DF_WORD_LR_OUT (bb));
 
   FOR_BB_INSNS_REVERSE (bb, insn)
     if (INSN_P (insn))
       {
-	/* The insn is needed if there is someone who uses the output.  */
-	for (def_rec = DF_INSN_DEFS (insn); *def_rec; def_rec++)
-	  {
-	    df_ref def = *def_rec;
-	    unsigned int last;
-	    unsigned int dregno = DF_REF_REGNO (def);
-	    unsigned int start = df_byte_lr_get_regno_start (dregno);
-	    unsigned int len = df_byte_lr_get_regno_len (dregno);
-
-	    unsigned int sb;
-	    unsigned int lb;
-	    /* This is one of the only places where DF_MM_MAY should
-	       be used for defs.  Need to make sure that we are
-	       checking for all of the bits that may be used.  */
-
-	    if (!df_compute_accessed_bytes (def, DF_MM_MAY, &sb, &lb))
-	      {
-		start += sb;
-		len = lb - sb;
-	      }
-
-	    if (bitmap_bit_p (au, dregno))
-	      {
-		mark_insn (insn, true);
-		goto quickexit;
-	      }
-
-	    last = start + len;
-	    while (start < last)
-	      if (bitmap_bit_p (local_live, start++))
-		{
-		  mark_insn (insn, true);
-		  goto quickexit;
-		}
-	  }
-
-      quickexit:
-
+	bool any_changed;
 	/* No matter if the instruction is needed or not, we remove
 	   any regno in the defs from the live set.  */
-	df_byte_lr_simulate_defs (insn, local_live);
+	any_changed = df_word_lr_simulate_defs (insn, local_live);
+	if (any_changed)
+	  mark_insn (insn, true);
 
 	/* On the other hand, we do not allow the dead uses to set
 	   anything in local_live.  */
 	if (marked_insn_p (insn))
-	  df_byte_lr_simulate_uses (insn, local_live);
+	  df_word_lr_simulate_uses (insn, local_live);
 
 	if (dump_file)
 	  {
 	    fprintf (dump_file, "finished processing insn %d live out = ",
 		     INSN_UID (insn));
-	    df_print_byte_regset (dump_file, local_live);
+	    df_print_word_regset (dump_file, local_live);
 	  }
       }
 
-  df_byte_lr_simulate_artificial_refs_at_top (bb, local_live);
-
-  block_changed = !bitmap_equal_p (local_live, DF_BYTE_LR_IN (bb));
+  block_changed = !bitmap_equal_p (local_live, DF_WORD_LR_IN (bb));
   if (block_changed)
-    bitmap_copy (DF_BYTE_LR_IN (bb), local_live);
+    bitmap_copy (DF_WORD_LR_IN (bb), local_live);
+
   BITMAP_FREE (local_live);
   return block_changed;
 }
@@ -938,12 +899,12 @@ dce_process_block (basic_block bb, bool redo_out, bitmap au)
 }
 
 
-/* Perform fast DCE once initialization is done.  If BYTE_LEVEL is
-   true, use the byte level dce, otherwise do it at the pseudo
+/* Perform fast DCE once initialization is done.  If WORD_LEVEL is
+   true, use the word level dce, otherwise do it at the pseudo
    level.  */
 
 static void
-fast_dce (bool byte_level)
+fast_dce (bool word_level)
 {
   int *postorder = df_get_postorder (DF_BACKWARD);
   int n_blocks = df_get_n_blocks (DF_BACKWARD);
@@ -985,10 +946,9 @@ fast_dce (bool byte_level)
 	      continue;
 	    }
 
-	  if (byte_level)
+	  if (word_level)
 	    local_changed
-	      = byte_dce_process_block (bb, bitmap_bit_p (redo_out, index),
-					  bb_has_eh_pred (bb) ? au_eh : au);
+	      = word_dce_process_block (bb, bitmap_bit_p (redo_out, index));
 	  else
 	    local_changed
 	      = dce_process_block (bb, bitmap_bit_p (redo_out, index),
@@ -1028,8 +988,8 @@ fast_dce (bool byte_level)
 	     to redo the dataflow equations for the blocks that had a
 	     change at the top of the block.  Then we need to redo the
 	     iteration.  */
-	  if (byte_level)
-	    df_analyze_problem (df_byte_lr, all_blocks, postorder, n_blocks);
+	  if (word_level)
+	    df_analyze_problem (df_word_lr, all_blocks, postorder, n_blocks);
 	  else
 	    df_analyze_problem (df_lr, all_blocks, postorder, n_blocks);
 
@@ -1062,14 +1022,15 @@ rest_of_handle_fast_dce (void)
 
 /* Fast byte level DCE.  */
 
-static unsigned int
-rest_of_handle_fast_byte_dce (void)
+void
+run_word_dce (void)
 {
-  df_byte_lr_add_problem ();
+  timevar_push (TV_DCE);
+  df_word_lr_add_problem ();
   init_dce (true);
   fast_dce (true);
   fini_dce (true);
-  return 0;
+  timevar_pop (TV_DCE);
 }
 
 
@@ -1139,24 +1100,3 @@ struct rtl_opt_pass pass_fast_rtl_dce =
   TODO_ggc_collect                      /* todo_flags_finish */
  }
 };
-
-struct rtl_opt_pass pass_fast_rtl_byte_dce =
-{
- {
-  RTL_PASS,
-  "byte-dce",                           /* name */
-  gate_fast_dce,                        /* gate */
-  rest_of_handle_fast_byte_dce,         /* execute */
-  NULL,                                 /* sub */
-  NULL,                                 /* next */
-  0,                                    /* static_pass_number */
-  TV_DCE,                               /* tv_id */
-  0,                                    /* properties_required */
-  0,                                    /* properties_provided */
-  0,                                    /* properties_destroyed */
-  0,                                    /* todo_flags_start */
-  TODO_dump_func |
-  TODO_df_finish | TODO_verify_rtl_sharing |
-  TODO_ggc_collect                      /* todo_flags_finish */
- }
-};