CbC/CbC_gcc: gcc/dce.c comparison

comparison gcc/dce.c @ 55:77e2b8dfacca gcc-4.4.5

update it from 4.4.3 to 4.5.0

author	ryoma <e075725@ie.u-ryukyu.ac.jp>
date	Fri, 12 Feb 2010 23:39:51 +0900
parents	a06113de4d67
children	f6334be47118

comparison

equal deleted inserted replaced

-:c156f1bd5cd9
+:77e2b8dfacca
 #include "rtl.h"
 #include "tree.h"
 #include "regs.h"
 #include "hard-reg-set.h"
 #include "flags.h"
+#include "except.h"
 #include "df.h"
 #include "cselib.h"
 #include "dce.h"
 #include "timevar.h"
 #include "tree-pass.h"
 #include "dbgcnt.h"
 #include "tm_p.h"
-DEF_VEC_I(int);
-DEF_VEC_ALLOC_I(int,heap);
 /* -------------------------------------------------------------------------
 Core mark/delete routines
 ------------------------------------------------------------------------- */
 	 changed, and the UNSPEC case can be removed.  */
 case UNSPEC:
 return false;
 default:
-if (volatile_refs_p (body))
+return !volatile_refs_p (body);
-	return false;
-if (flag_non_call_exceptions && may_trap_p (body))
-	return false;
-return true;
 }
 }
 /* Return true if INSN is a normal instruction that can be deleted by
 static bool
 deletable_insn_p (rtx insn, bool fast, bitmap arg_stores)
 {
 rtx body, x;
 int i;
+/* Don't delete jumps, notes and the like.  */
+if (!NONJUMP_INSN_P (insn))
+return false;
+/* Don't delete insns that can throw.  */
+if (!insn_nothrow_p (insn))
+return false;
 if (CALL_P (insn)
 /* We cannot delete calls inside of the recursive dce because
 	 this may cause basic blocks to be deleted and this messes up
 	 the rest of the stack of optimization passes.  */
 infinite loop.  */
 && (RTL_CONST_OR_PURE_CALL_P (insn)
 	  && !RTL_LOOPING_CONST_OR_PURE_CALL_P (insn)))
 return find_call_stack_args (insn, false, fast, arg_stores);
-if (!NONJUMP_INSN_P (insn))
-return false;
 body = PATTERN (insn);
 switch (GET_CODE (body))
 {
 case USE:
+case VAR_LOCATION:
 return false;
 case CLOBBER:
 if (fast)
 	{
 	    set = single_set (DF_REF_INSN (defs->ref));
 	    off += INTVAL (XEXP (SET_SRC (set), 1));
 	  }
 	for (byte = off; byte < off + INTVAL (MEM_SIZE (mem)); byte++)
 	  {
-	    gcc_assert (!bitmap_bit_p (sp_bytes, byte - min_sp_off));
+	    if (!bitmap_set_bit (sp_bytes, byte - min_sp_off))
-	    bitmap_set_bit (sp_bytes, byte - min_sp_off);
+	      gcc_unreachable ();
 	  }
 }
 /* Walk backwards, looking for argument stores.  The search stops
 when seeing another call, sp adjustment or memory store other than
 for (byte = off; byte < off + GET_MODE_SIZE (GET_MODE (mem)); byte++)
 	{
 	  if (byte < min_sp_off
 	      || byte >= max_sp_off
-	      || !bitmap_bit_p (sp_bytes, byte - min_sp_off))
+	      || !bitmap_clear_bit (sp_bytes, byte - min_sp_off))
 	    break;
-	  bitmap_clear_bit (sp_bytes, byte - min_sp_off);
 	}
 if (!deletable_insn_p (insn, fast, NULL))
 	break;
 struct df_link *defs;
 df_ref *use_rec;
 FOR_ALL_BB (bb)
 {
 for (use_rec = df_get_artificial_uses (bb->index);
 	   *use_rec; use_rec++)
 	for (defs = DF_REF_CHAIN (*use_rec); defs; defs = defs->next)
 	  if (! DF_REF_IS_ARTIFICIAL (defs->ref))
 	    mark_insn (DF_REF_INSN (defs->ref), false);
 }
 static void
 mark_reg_dependencies (rtx insn)
 {
 struct df_link *defs;
 df_ref *use_rec;
+if (DEBUG_INSN_P (insn))
+return;
 for (use_rec = DF_INSN_USES (insn); *use_rec; use_rec++)
 {
 df_ref use = *use_rec;
 if (dump_file)
 struct rtl_opt_pass pass_ud_rtl_dce =
 {
 {
 RTL_PASS,
-"dce",                                /* name */
+"ud dce",                             /* name */
-gate_ud_dce,                        /* gate */
+gate_ud_dce,                          /* gate */
-rest_of_handle_ud_dce,              /* execute */
+rest_of_handle_ud_dce,                /* execute */
 NULL,                                 /* sub */
 NULL,                                 /* next */
 0,                                    /* static_pass_number */
 TV_DCE,                               /* tv_id */
 0,                                    /* properties_required */
 	    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:
 	/* 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);
 	/* On the other hand, we do not allow the dead uses to set
 	if (marked_insn_p (insn))
 	  df_byte_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_byte_lr_simulate_artificial_refs_at_top (bb, local_live);
 block_changed = !bitmap_equal_p (local_live, DF_BYTE_LR_IN (bb));
 if (block_changed)
 bitmap_copy (DF_BYTE_LR_IN (bb), local_live);
 	      || bitmap_bit_p (au, DF_REF_REGNO (*def_rec)))
 	    {
 	      needed = true;
 	      break;
 	    }
 	if (needed)
 	  mark_insn (insn, true);
 	/* No matter if the instruction is needed or not, we remove
 	   any regno in the defs from the live set.  */
 	df_simulate_defs (insn, local_live);
 	/* On the other hand, we do not allow the dead uses to set
 	   anything in local_live.  */
 	if (marked_insn_p (insn))
 	  df_simulate_uses (insn, local_live);
 }
 df_simulate_finalize_backwards (bb, local_live);
 block_changed = !bitmap_equal_p (local_live, DF_LR_IN (bb));
 if (block_changed)
 bitmap_copy (DF_LR_IN (bb), local_live);
 	      bitmap_set_bit (processed, index);
 	      continue;
 	    }
 	  if (byte_level)
 	    local_changed
 	      = byte_dce_process_block (bb, bitmap_bit_p (redo_out, index),
 					  bb_has_eh_pred (bb) ? au_eh : au);
 	  else
 	    local_changed
 	      = dce_process_block (bb, bitmap_bit_p (redo_out, index),
 				   bb_has_eh_pred (bb) ? au_eh : au);
 	  bitmap_set_bit (processed, index);
 	  if (local_changed)
 	    {
 	      edge e;
 	      edge_iterator ei;
 	      FOR_EACH_EDGE (e, ei, bb->preds)
 		  global_changed = true;
 		else
 		  bitmap_set_bit (redo_out, e->src->index);
 	    }
 	}
 if (global_changed)
 	{
 	  /* Turn off the RUN_DCE flag to prevent recursive calls to
 	     dce.  */
 	  int old_flag = df_clear_flags (DF_LR_RUN_DCE);
 	     the cheap.  */
 	  delete_unmarked_insns ();
 	  sbitmap_zero (marked);
 	  bitmap_clear (processed);
 	  bitmap_clear (redo_out);
 	  /* We do not need to rescan any instructions.  We only need
 	     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);
 	  else
 	    df_analyze_problem (df_lr, all_blocks, postorder, n_blocks);
 if (flag_dce)
 {
 /* If dce is able to delete something, it has to happen
 	 immediately.  Otherwise there will be problems handling the
 	 eq_notes.  */
-enum df_changeable_flags old_flags
+int old_flags =
-	= df_clear_flags (DF_DEFER_INSN_RESCAN + DF_NO_INSN_RESCAN);
+	df_clear_flags (DF_DEFER_INSN_RESCAN + DF_NO_INSN_RESCAN);
 df_in_progress = true;
 rest_of_handle_fast_dce ();
 df_in_progress = false;
 df_set_flags (old_flags);
 struct rtl_opt_pass pass_fast_rtl_dce =
 {
 {
 RTL_PASS,
-"dce",                                /* name */
+"rtl dce",                            /* name */
 gate_fast_dce,                        /* gate */
 rest_of_handle_fast_dce,              /* execute */
 NULL,                                 /* sub */
 NULL,                                 /* next */
 0,                                    /* static_pass_number */

Mercurial > hg > CbC > CbC_gcc

comparison gcc/dce.c @ 55:77e2b8dfacca gcc-4.4.5