CbC/CbC_gcc: gcc/dse.c comparison

comparison gcc/dse.c @ 67:f6334be47118

update gcc from gcc-4.6-20100522 to gcc-4.6-20110318

author	nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
date	Tue, 22 Mar 2011 17:18:12 +0900
parents	b7f97abdc517
children	04ced10e8804

comparison

equal deleted inserted replaced

-:65488c3d617d
+:f6334be47118
 /* True if the base of this group is either the frame_pointer or
 hard_frame_pointer.  */
 bool frame_related;
-/* A mem wrapped around the base pointer for the group in order to
+/* A mem wrapped around the base pointer for the group in order to do
-do read dependency.  */
+read dependency.  It must be given BLKmode in order to encompass all
+the possible offsets from the base.  */
 rtx base_mem;
 /* Canonized version of base_mem's address.  */
 rtx canon_base_addr;
 if (gi == NULL)
 {
 *slot = gi = (group_info_t) pool_alloc (rtx_group_info_pool);
 gi->rtx_base = base;
 gi->id = rtx_group_next_id++;
-gi->base_mem = gen_rtx_MEM (QImode, base);
+gi->base_mem = gen_rtx_MEM (BLKmode, base);
 gi->canon_base_addr = canon_rtx (base);
 gi->store1_n = BITMAP_ALLOC (NULL);
 gi->store1_p = BITMAP_ALLOC (NULL);
 gi->store2_n = BITMAP_ALLOC (NULL);
 gi->store2_p = BITMAP_ALLOC (NULL);
 insn_info->cannot_delete = true;
 insn_info->contains_cselib_groups = false;
 insn_info->store_rec = NULL;
 }
+/* Callback for for_each_inc_dec that emits an INSN that sets DEST to
-struct insn_size {
+SRC + SRCOFF before insn ARG.  */
-int size;
-rtx insn;
-};
-/* Add an insn to do the add inside a x if it is a
-PRE/POST-INC/DEC/MODIFY.  D is an structure containing the insn and
-the size of the mode of the MEM that this is inside of.  */
 static int
-replace_inc_dec (rtx *r, void *d)
+emit_inc_dec_insn_before (rtx mem ATTRIBUTE_UNUSED,
-{
+			  rtx op ATTRIBUTE_UNUSED,
-rtx x = *r;
+			  rtx dest, rtx src, rtx srcoff, void *arg)
-struct insn_size *data = (struct insn_size *)d;
+{
-switch (GET_CODE (x))
+rtx insn = (rtx)arg;
-{
-case PRE_INC:
+if (srcoff)
-case POST_INC:
+src = gen_rtx_PLUS (GET_MODE (src), src, srcoff);
-{
-	rtx r1 = XEXP (x, 0);
+/* We can reuse all operands without copying, because we are about
-	rtx c = gen_int_mode (data->size, GET_MODE (r1));
+to delete the insn that contained it.  */
-	emit_insn_before (gen_rtx_SET (VOIDmode, r1,
-				       gen_rtx_PLUS (GET_MODE (r1), r1, c)),
+emit_insn_before (gen_rtx_SET (VOIDmode, dest, src), insn);
-			  data->insn);
-	return -1;
+return -1;
-}
-case PRE_DEC:
-case POST_DEC:
-{
-	rtx r1 = XEXP (x, 0);
-	rtx c = gen_int_mode (-data->size, GET_MODE (r1));
-	emit_insn_before (gen_rtx_SET (VOIDmode, r1,
-				       gen_rtx_PLUS (GET_MODE (r1), r1, c)),
-			  data->insn);
-	return -1;
-}
-case PRE_MODIFY:
-case POST_MODIFY:
-{
-	/* We can reuse the add because we are about to delete the
-	   insn that contained it.  */
-	rtx add = XEXP (x, 0);
-	rtx r1 = XEXP (add, 0);
-	emit_insn_before (gen_rtx_SET (VOIDmode, r1, add), data->insn);
-	return -1;
-}
-default:
-return 0;
-}
-}
-/* If X is a MEM, check the address to see if it is PRE/POST-INC/DEC/MODIFY
-and generate an add to replace that.  */
-static int
-replace_inc_dec_mem (rtx *r, void *d)
-{
-rtx x = *r;
-if (x != NULL_RTX && MEM_P (x))
-{
-struct insn_size data;
-data.size = GET_MODE_SIZE (GET_MODE (x));
-data.insn = (rtx) d;
-for_each_rtx (&XEXP (x, 0), replace_inc_dec, &data);
-return -1;
-}
-return 0;
 }
 /* Before we delete INSN, make sure that the auto inc/dec, if it is
 there, is split into a separate insn.  */
-static void
+void
 check_for_inc_dec (rtx insn)
 {
 rtx note = find_reg_note (insn, REG_INC, NULL_RTX);
 if (note)
-for_each_rtx (&insn, replace_inc_dec_mem, insn);
+for_each_inc_dec (&insn, emit_inc_dec_insn_before, insn);
 }
 /* Delete the insn and free all of the fields inside INSN_INFO.  */
 	    store1 = group->store1_p;
 	    store2 = group->store2_p;
 	    ai = i;
 	  }
-	if (bitmap_bit_p (store1, ai))
+	if (!bitmap_set_bit (store1, ai))
 	  bitmap_set_bit (store2, ai);
 	else
 	  {
-	    bitmap_set_bit (store1, ai);
 	    if (i < 0)
 	      {
 		if (group->offset_map_size_n < ai)
 		  group->offset_map_size_n = ai;
 	      }
 	}
 }
 *alias_set_out = 0;
-cselib_lookup (mem_address, address_mode, 1);
+cselib_lookup (mem_address, address_mode, 1, GET_MODE (mem));
 if (dump_file)
 {
 fprintf (dump_file, "  mem: ");
 print_inline_rtx (dump_file, mem_address, 0);
 	  *group_id = group->id;
 	  return true;
 	}
 }
-*base = cselib_lookup (address, address_mode, true);
+*base = cselib_lookup (address, address_mode, true, GET_MODE (mem));
 *group_id = -1;
 if (*base == NULL)
 {
 if (dump_file)
 static inline void
 set_position_unneeded (store_info_t s_info, int pos)
 {
 if (__builtin_expect (s_info->is_large, false))
 {
-if (!bitmap_bit_p (s_info->positions_needed.large.bmap, pos))
+if (bitmap_set_bit (s_info->positions_needed.large.bmap, pos))
-	{
+	s_info->positions_needed.large.count++;
-	  s_info->positions_needed.large.count++;
-	  bitmap_set_bit (s_info->positions_needed.large.bmap, pos);
-	}
 }
 else
 s_info->positions_needed.small_bitmask
 &= ~(((unsigned HOST_WIDE_INT) 1) << pos);
 }
 bitmap store1 = clear_alias_group->store1_p;
 bitmap store2 = clear_alias_group->store2_p;
 gcc_assert (GET_MODE (mem) != BLKmode);
-if (bitmap_bit_p (store1, spill_alias_set))
+if (!bitmap_set_bit (store1, spill_alias_set))
 	bitmap_set_bit (store2, spill_alias_set);
-else
-	bitmap_set_bit (store1, spill_alias_set);
 if (clear_alias_group->offset_map_size_p < spill_alias_set)
 	clear_alias_group->offset_map_size_p = spill_alias_set;
 store_info = (store_info_t) pool_alloc (rtx_store_info_pool);
 for (idx = 0;
 arg != void_list_node && idx < nargs;
 arg = TREE_CHAIN (arg), idx++)
 {
 enum machine_mode mode = TYPE_MODE (TREE_VALUE (arg));
-rtx reg = FUNCTION_ARG (args_so_far, mode, NULL_TREE, 1), link, tmp;
+rtx reg, link, tmp;
+reg = targetm.calls.function_arg (&args_so_far, mode, NULL_TREE, true);
 if (!reg || !REG_P (reg) || GET_MODE (reg) != mode
 	  || GET_MODE_CLASS (mode) != MODE_INT)
 	return false;
 for (link = CALL_INSN_FUNCTION_USAGE (call_insn);
 	  tmp = GEN_INT (trunc_int_for_mode (INTVAL (tmp), mode));
 	}
 if (tmp)
 	args[idx] = tmp;
-FUNCTION_ARG_ADVANCE (args_so_far, mode, NULL_TREE, 1);
+targetm.calls.function_arg_advance (&args_so_far, mode, NULL_TREE, true);
 }
 if (arg != void_list_node || idx != nargs)
 return false;
 return true;
 }
 dse_step2_init (void)
 {
 unsigned int i;
 group_info_t group;
-for (i = 0; VEC_iterate (group_info_t, rtx_group_vec, i, group); i++)
+FOR_EACH_VEC_ELT (group_info_t, rtx_group_vec, i, group)
 {
 /* For all non stack related bases, we only consider a store to
 	 be deletable if there are two or more stores for that
 	 position.  This is because it takes one store to make the
 	 other store redundant.  However, for the stores that are
 group_info_t group;
 /* Position 0 is unused because 0 is used in the maps to mean
 unused.  */
 current_position = 1;
-for (i = 0; VEC_iterate (group_info_t, rtx_group_vec, i, group); i++)
+FOR_EACH_VEC_ELT (group_info_t, rtx_group_vec, i, group)
 {
 bitmap_iterator bi;
 unsigned int j;
 if (group == clear_alias_group)
 group_info_t group;
 /* If this insn reads the frame, kill all the frame related stores.  */
 if (insn_info->frame_read)
 {
-for (i = 0; VEC_iterate (group_info_t, rtx_group_vec, i, group); i++)
+FOR_EACH_VEC_ELT (group_info_t, rtx_group_vec, i, group)
 	if (group->process_globally && group->frame_related)
 	  {
 	    if (kill)
 	      bitmap_ior_into (kill, group->group_kill);
 	    bitmap_and_compl_into (gen, group->group_kill);
 	  }
 }
 while (read_info)
 {
-for (i = 0; VEC_iterate (group_info_t, rtx_group_vec, i, group); i++)
+FOR_EACH_VEC_ELT (group_info_t, rtx_group_vec, i, group)
 	{
 	  if (group->process_globally)
 	    {
 	      if (i == read_info->group_id)
 		{
 		     read.  Anything with a constant base cannot alias
 		     something else with a different constant
 		     base.  */
 		  if ((read_info->group_id < 0)
 		      && canon_true_dependence (group->base_mem,
-						QImode,
+						GET_MODE (group->base_mem),
 						group->canon_base_addr,
 						read_info->mem, NULL_RTX,
 						rtx_varies_p))
 		    {
 		      if (kill)
 if (stores_off_frame_dead_at_return)
 {
 unsigned int i;
 group_info_t group;
-for (i = 0; VEC_iterate (group_info_t, rtx_group_vec, i, group); i++)
+FOR_EACH_VEC_ELT (group_info_t, rtx_group_vec, i, group)
 	{
 	  if (group->process_globally && group->frame_related)
 	    bitmap_ior_into (bb_info->gen, group->group_kill);
 	}
 }
 	    {
 	      unsigned int j;
 	      group_info_t group;
 	      all_ones = BITMAP_ALLOC (NULL);
-	      for (j = 0; VEC_iterate (group_info_t, rtx_group_vec, j, group); j++)
+	      FOR_EACH_VEC_ELT (group_info_t, rtx_group_vec, j, group)
 		bitmap_ior_into (all_ones, group->group_kill);
 	    }
 	  if (!bb_info->out)
 	    {
 	      bb_info->out = BITMAP_ALLOC (NULL);
 /* Propagate the information from the in set of the dest of E to the
 out set of the src of E.  If the various in or out sets are not
 there, that means they are all ones.  */
-static void
+static bool
 dse_confluence_n (edge e)
 {
 bb_info_t src_info = bb_table[e->src->index];
 bb_info_t dest_info = bb_table[e->dest->index];
 	{
 	  src_info->out = BITMAP_ALLOC (NULL);
 	  bitmap_copy (src_info->out, dest_info->in);
 	}
 }
+return true;
 }
 /* Propagate the info from the out to the in set of BB_INDEX's basic
 block.  There are three cases:
 {
 unsigned int i;
 group_info_t group;
 basic_block bb;
-for (i = 0; VEC_iterate (group_info_t, rtx_group_vec, i, group); i++)
+FOR_EACH_VEC_ELT (group_info_t, rtx_group_vec, i, group)
 {
 free (group->offset_map_n);
 free (group->offset_map_p);
 BITMAP_FREE (group->store1_n);
 BITMAP_FREE (group->store1_p);

Mercurial > hg > CbC > CbC_gcc

comparison gcc/dse.c @ 67:f6334be47118