CbC/CbC_gcc: gcc/cselib.c comparison

comparison gcc/cselib.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
 /* Common subexpression elimination library for GNU compiler.
 Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
-1999, 2000, 2001, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
+1999, 2000, 2001, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
 Free Software Foundation, Inc.
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify it under
 #include "flags.h"
 #include "insn-config.h"
 #include "recog.h"
 #include "function.h"
 #include "emit-rtl.h"
-#include "toplev.h"
+#include "diagnostic-core.h"
 #include "output.h"
 #include "ggc.h"
 #include "hashtab.h"
 #include "tree-pass.h"
 #include "cselib.h"
 #include "params.h"
 #include "alloc-pool.h"
 #include "target.h"
 #include "bitmap.h"
+/* A list of cselib_val structures.  */
+struct elt_list {
+struct elt_list *next;
+cselib_val *elt;
+};
 static bool cselib_record_memory;
 static bool cselib_preserve_constants;
 static int entry_and_rtx_equal_p (const void *, const void *);
 static hashval_t get_value_hash (const void *);
 static void unchain_one_elt_list (struct elt_list **);
 static void unchain_one_elt_loc_list (struct elt_loc_list **);
 static int discard_useless_locs (void **, void *);
 static int discard_useless_values (void **, void *);
 static void remove_useless_values (void);
-static unsigned int cselib_hash_rtx (rtx, int);
+static int rtx_equal_for_cselib_1 (rtx, rtx, enum machine_mode);
+static unsigned int cselib_hash_rtx (rtx, int, enum machine_mode);
 static cselib_val *new_cselib_val (unsigned int, enum machine_mode, rtx);
 static void add_mem_for_addr (cselib_val *, cselib_val *, rtx);
 static cselib_val *cselib_lookup_mem (rtx, int);
 static void cselib_invalidate_regno (unsigned int, enum machine_mode);
 static void cselib_invalidate_mem (rtx);
 /* If non-NULL, value of the eliminated arg_pointer_rtx or frame_pointer_rtx
 that is constant through the whole function and should never be
 eliminated.  */
 static cselib_val *cfa_base_preserved_val;
+static unsigned int cfa_base_preserved_regno;
 /* Used to list all values that contain memory reference.
 May or may not contain the useless values - the list is compacted
 each time memory is invalidated.  */
 static cselib_val *first_containing_mem = &dummy_val;
 max_value_regs = 0;
 if (cfa_base_preserved_val)
 {
-unsigned int regno = REGNO (cfa_base_preserved_val->locs->loc);
+unsigned int regno = cfa_base_preserved_regno;
 unsigned int new_used_regs = 0;
 for (i = 0; i < n_used_regs; i++)
 	if (used_regs[i] == regno)
 	  {
 	    new_used_regs = 1;
 cselib_get_next_uid (void)
 {
 return next_uid;
 }
+/* See the documentation of cselib_find_slot below.  */
+static enum machine_mode find_slot_memmode;
+/* Search for X, whose hashcode is HASH, in CSELIB_HASH_TABLE,
+INSERTing if requested.  When X is part of the address of a MEM,
+MEMMODE should specify the mode of the MEM.  While searching the
+table, MEMMODE is held in FIND_SLOT_MEMMODE, so that autoinc RTXs
+in X can be resolved.  */
+static void **
+cselib_find_slot (rtx x, hashval_t hash, enum insert_option insert,
+		  enum machine_mode memmode)
+{
+void **slot;
+find_slot_memmode = memmode;
+slot = htab_find_slot_with_hash (cselib_hash_table, x, hash, insert);
+find_slot_memmode = VOIDmode;
+return slot;
+}
 /* The equality test for our hash table.  The first argument ENTRY is a table
 element (i.e. a cselib_val), while the second arg X is an rtx.  We know
 that all callers of htab_find_slot_with_hash will wrap CONST_INTs into a
 CONST of an appropriate mode.  */
 x = XEXP (x, 0);
 /* We don't guarantee that distinct rtx's have different hash values,
 so we need to do a comparison.  */
 for (l = v->locs; l; l = l->next)
-if (rtx_equal_for_cselib_p (l->loc, x))
+if (rtx_equal_for_cselib_1 (l->loc, x, find_slot_memmode))
 {
 	promote_debug_loc (l);
 	return 1;
 }
 /* Arrange for a REG value to be assumed constant through the whole function,
 never invalidated and preserved across cselib_reset_table calls.  */
 void
-cselib_preserve_cfa_base_value (cselib_val *v)
+cselib_preserve_cfa_base_value (cselib_val *v, unsigned int regno)
 {
 if (cselib_preserve_constants
 && v->locs
 && REG_P (v->locs->loc))
-cfa_base_preserved_val = v;
+{
+cfa_base_preserved_val = v;
+cfa_base_preserved_regno = regno;
+}
 }
 /* Clean all non-constant expressions in the hash table, but retain
 their values.  */
 our gathered information into account.  */
 int
 rtx_equal_for_cselib_p (rtx x, rtx y)
 {
+return rtx_equal_for_cselib_1 (x, y, VOIDmode);
+}
+/* If x is a PLUS or an autoinc operation, expand the operation,
+storing the offset, if any, in *OFF.  */
+static rtx
+autoinc_split (rtx x, rtx *off, enum machine_mode memmode)
+{
+switch (GET_CODE (x))
+{
+case PLUS:
+*off = XEXP (x, 1);
+return XEXP (x, 0);
+case PRE_DEC:
+if (memmode == VOIDmode)
+	return x;
+*off = GEN_INT (-GET_MODE_SIZE (memmode));
+return XEXP (x, 0);
+break;
+case PRE_INC:
+if (memmode == VOIDmode)
+	return x;
+*off = GEN_INT (GET_MODE_SIZE (memmode));
+return XEXP (x, 0);
+case PRE_MODIFY:
+return XEXP (x, 1);
+case POST_DEC:
+case POST_INC:
+case POST_MODIFY:
+return XEXP (x, 0);
+default:
+return x;
+}
+}
+/* Return nonzero if we can prove that X and Y contain the same value,
+taking our gathered information into account.  MEMMODE holds the
+mode of the enclosing MEM, if any, as required to deal with autoinc
+addressing modes.  If X and Y are not (known to be) part of
+addresses, MEMMODE should be VOIDmode.  */
+static int
+rtx_equal_for_cselib_1 (rtx x, rtx y, enum machine_mode memmode)
+{
 enum rtx_code code;
 const char *fmt;
 int i;
 if (REG_P (x) || MEM_P (x))
 {
-cselib_val *e = cselib_lookup (x, GET_MODE (x), 0);
+cselib_val *e = cselib_lookup (x, GET_MODE (x), 0, memmode);
 if (e)
 	x = e->val_rtx;
 }
 if (REG_P (y) || MEM_P (y))
 {
-cselib_val *e = cselib_lookup (y, GET_MODE (y), 0);
+cselib_val *e = cselib_lookup (y, GET_MODE (y), 0, memmode);
 if (e)
 	y = e->val_rtx;
 }
 	  rtx t = l->loc;
 	  /* Avoid infinite recursion.  */
 	  if (REG_P (t) || MEM_P (t))
 	    continue;
-	  else if (rtx_equal_for_cselib_p (t, y))
+	  else if (rtx_equal_for_cselib_1 (t, y, memmode))
 	    return 1;
 	}
 return 0;
 }
 	{
 	  rtx t = l->loc;
 	  if (REG_P (t) || MEM_P (t))
 	    continue;
-	  else if (rtx_equal_for_cselib_p (x, t))
+	  else if (rtx_equal_for_cselib_1 (x, t, memmode))
 	    return 1;
 	}
 return 0;
 }
-if (GET_CODE (x) != GET_CODE (y) || GET_MODE (x) != GET_MODE (y))
+if (GET_MODE (x) != GET_MODE (y))
 return 0;
+if (GET_CODE (x) != GET_CODE (y))
+{
+rtx xorig = x, yorig = y;
+rtx xoff = NULL, yoff = NULL;
+x = autoinc_split (x, &xoff, memmode);
+y = autoinc_split (y, &yoff, memmode);
+if (!xoff != !yoff)
+	return 0;
+if (xoff && !rtx_equal_for_cselib_1 (xoff, yoff, memmode))
+	return 0;
+/* Don't recurse if nothing changed.  */
+if (x != xorig || y != yorig)
+	return rtx_equal_for_cselib_1 (x, y, memmode);
+return 0;
+}
 /* These won't be handled correctly by the code below.  */
 switch (GET_CODE (x))
 {
 case CONST_DOUBLE:
 case CONST_FIXED:
 case DEBUG_EXPR:
 return 0;
+case DEBUG_IMPLICIT_PTR:
+return DEBUG_IMPLICIT_PTR_DECL (x)
+	     == DEBUG_IMPLICIT_PTR_DECL (y);
 case LABEL_REF:
 return XEXP (x, 0) == XEXP (y, 0);
+case MEM:
+/* We have to compare any autoinc operations in the addresses
+	 using this MEM's mode.  */
+return rtx_equal_for_cselib_1 (XEXP (x, 0), XEXP (y, 0), GET_MODE (x));
 default:
 break;
 }
 	  if (XVECLEN (x, i) != XVECLEN (y, i))
 	    return 0;
 	  /* And the corresponding elements must match.  */
 	  for (j = 0; j < XVECLEN (x, i); j++)
-	    if (! rtx_equal_for_cselib_p (XVECEXP (x, i, j),
+	    if (! rtx_equal_for_cselib_1 (XVECEXP (x, i, j),
-					  XVECEXP (y, i, j)))
+					  XVECEXP (y, i, j), memmode))
 	      return 0;
 	  break;
 	case 'e':
 	  if (i == 1
 	      && targetm.commutative_p (x, UNKNOWN)
-	      && rtx_equal_for_cselib_p (XEXP (x, 1), XEXP (y, 0))
+	      && rtx_equal_for_cselib_1 (XEXP (x, 1), XEXP (y, 0), memmode)
-	      && rtx_equal_for_cselib_p (XEXP (x, 0), XEXP (y, 1)))
+	      && rtx_equal_for_cselib_1 (XEXP (x, 0), XEXP (y, 1), memmode))
 	    return 1;
-	  if (! rtx_equal_for_cselib_p (XEXP (x, i), XEXP (y, i)))
+	  if (! rtx_equal_for_cselib_1 (XEXP (x, i), XEXP (y, i), memmode))
 	    return 0;
 	  break;
 	case 'S':
 	case 's':
 N.B. this hash function returns the same hash value for RTXes that
 differ only in the order of operands, thus it is suitable for comparisons
 that take commutativity into account.
 If we wanted to also support associative rules, we'd have to use a different
 strategy to avoid returning spurious 0, e.g. return ~(~0U >> 1) .
+MEMMODE indicates the mode of an enclosing MEM, and it's only
+used to compute autoinc values.
 We used to have a MODE argument for hashing for CONST_INTs, but that
 didn't make sense, since it caused spurious hash differences between
 (set (reg:SI 1) (const_int))
 (plus:SI (reg:SI 2) (reg:SI 1))
 and
 (plus:SI (reg:SI 2) (const_int))
 If the mode is important in any context, it must be checked specifically
 in a comparison anyway, since relying on hash differences is unsafe.  */
 static unsigned int
-cselib_hash_rtx (rtx x, int create)
+cselib_hash_rtx (rtx x, int create, enum machine_mode memmode)
 {
 cselib_val *e;
 int i, j;
 enum rtx_code code;
 const char *fmt;
 switch (code)
 {
 case MEM:
 case REG:
-e = cselib_lookup (x, GET_MODE (x), create);
+e = cselib_lookup (x, GET_MODE (x), create, memmode);
 if (! e)
 	return 0;
 return e->hash;
 case DEBUG_EXPR:
 hash += ((unsigned) DEBUG_EXPR << 7)
 	      + DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (x));
 return hash ? hash : (unsigned int) DEBUG_EXPR;
+case DEBUG_IMPLICIT_PTR:
+hash += ((unsigned) DEBUG_IMPLICIT_PTR << 7)
+	      + DECL_UID (DEBUG_IMPLICIT_PTR_DECL (x));
+return hash ? hash : (unsigned int) DEBUG_IMPLICIT_PTR;
 case CONST_INT:
 hash += ((unsigned) CONST_INT << 7) + INTVAL (x);
 return hash ? hash : (unsigned int) CONST_INT;
 	units = CONST_VECTOR_NUNITS (x);
 	for (i = 0; i < units; ++i)
 	  {
 	    elt = CONST_VECTOR_ELT (x, i);
-	    hash += cselib_hash_rtx (elt, 0);
+	    hash += cselib_hash_rtx (elt, 0, memmode);
 	  }
 	return hash;
 }
 	return hash ? hash : (unsigned int) SYMBOL_REF;
 }
 case PRE_DEC:
 case PRE_INC:
+/* We can't compute these without knowing the MEM mode.  */
+gcc_assert (memmode != VOIDmode);
+i = GET_MODE_SIZE (memmode);
+if (code == PRE_DEC)
+	i = -i;
+/* Adjust the hash so that (mem:MEMMODE (pre_* (reg))) hashes
+	 like (mem:MEMMODE (plus (reg) (const_int I))).  */
+hash += (unsigned) PLUS - (unsigned)code
+	+ cselib_hash_rtx (XEXP (x, 0), create, memmode)
+	+ cselib_hash_rtx (GEN_INT (i), create, memmode);
+return hash ? hash : 1 + (unsigned) PLUS;
+case PRE_MODIFY:
+gcc_assert (memmode != VOIDmode);
+return cselib_hash_rtx (XEXP (x, 1), create, memmode);
 case POST_DEC:
 case POST_INC:
 case POST_MODIFY:
-case PRE_MODIFY:
+gcc_assert (memmode != VOIDmode);
+return cselib_hash_rtx (XEXP (x, 0), create, memmode);
 case PC:
 case CC0:
 case CALL:
 case UNSPEC_VOLATILE:
 return 0;
 switch (fmt[i])
 	{
 	case 'e':
 	  {
 	    rtx tem = XEXP (x, i);
-	    unsigned int tem_hash = cselib_hash_rtx (tem, create);
+	    unsigned int tem_hash = cselib_hash_rtx (tem, create, memmode);
 	    if (tem_hash == 0)
 	      return 0;
 	    hash += tem_hash;
 	  break;
 	case 'E':
 	  for (j = 0; j < XVECLEN (x, i); j++)
 	    {
 	      unsigned int tem_hash
-		= cselib_hash_rtx (XVECEXP (x, i, j), create);
+		= cselib_hash_rtx (XVECEXP (x, i, j), create, memmode);
 	      if (tem_hash == 0)
 		return 0;
 	      hash += tem_hash;
 CSELIB_VAL_PTR (e->val_rtx) = e;
 e->addr_list = 0;
 e->locs = 0;
 e->next_containing_mem = 0;
-if (dump_file && (dump_flags & TDF_DETAILS))
+if (dump_file && (dump_flags & TDF_CSELIB))
 {
 fprintf (dump_file, "cselib value %u:%u ", e->uid, hash);
 if (flag_dump_noaddr || flag_dump_unnumbered)
 	fputs ("# ", dump_file);
 else
 static cselib_val *
 cselib_lookup_mem (rtx x, int create)
 {
 enum machine_mode mode = GET_MODE (x);
+enum machine_mode addr_mode;
 void **slot;
 cselib_val *addr;
 cselib_val *mem_elt;
 struct elt_list *l;
 if (MEM_VOLATILE_P (x) || mode == BLKmode
 || !cselib_record_memory
 || (FLOAT_MODE_P (mode) && flag_float_store))
 return 0;
+addr_mode = GET_MODE (XEXP (x, 0));
+if (addr_mode == VOIDmode)
+addr_mode = Pmode;
 /* Look up the value for the address.  */
-addr = cselib_lookup (XEXP (x, 0), mode, create);
+addr = cselib_lookup (XEXP (x, 0), addr_mode, create, mode);
 if (! addr)
 return 0;
 /* Find a value that describes a value of our mode at that address.  */
 for (l = addr->addr_list; l; l = l->next)
 if (! create)
 return 0;
 mem_elt = new_cselib_val (next_uid, mode, x);
 add_mem_for_addr (addr, mem_elt, x);
-slot = htab_find_slot_with_hash (cselib_hash_table, wrap_constant (mode, x),
+slot = cselib_find_slot (wrap_constant (mode, x), mem_elt->hash,
-				   mem_elt->hash, INSERT);
+			   INSERT, mode);
 *slot = mem_elt;
 return mem_elt;
 }
 /* Search thru the possible substitutions in P.  We prefer a non reg
 	       && CSELIB_VAL_PTR (p->loc)->locs == p_in)
 	continue;
 else if (!REG_P (p->loc))
 	{
 	  rtx result, note;
-	  if (dump_file && (dump_flags & TDF_DETAILS))
+	  if (dump_file && (dump_flags & TDF_CSELIB))
 	    {
 	      print_inline_rtx (dump_file, p->loc, 0);
 	      fprintf (dump_file, "\n");
 	    }
 	  if (GET_CODE (p->loc) == LO_SUM
 }
 if (regno != UINT_MAX)
 {
 rtx result;
-if (dump_file && (dump_flags & TDF_DETAILS))
+if (dump_file && (dump_flags & TDF_CSELIB))
 	fprintf (dump_file, "r%d\n", regno);
 result = cselib_expand_value_rtx_1 (reg_result, evd, max_depth - 1);
 if (result)
 	return result;
 }
-if (dump_file && (dump_flags & TDF_DETAILS))
+if (dump_file && (dump_flags & TDF_CSELIB))
 {
 if (reg_result)
 	{
 	  print_inline_rtx (dump_file, reg_result, 0);
 	  fprintf (dump_file, "\n");
 		  || regno == HARD_FRAME_POINTER_REGNUM)
 		return orig;
 	      bitmap_set_bit (evd->regs_active, regno);
-	      if (dump_file && (dump_flags & TDF_DETAILS))
+	      if (dump_file && (dump_flags & TDF_CSELIB))
 		fprintf (dump_file, "expanding: r%d into: ", regno);
 	      result = expand_loc (l->elt->locs, evd, max_depth);
 	      bitmap_clear_bit (evd->regs_active, regno);
 case VALUE:
 {
 	rtx result;
-	if (dump_file && (dump_flags & TDF_DETAILS))
+	if (dump_file && (dump_flags & TDF_CSELIB))
 	  {
 	    fputs ("\nexpanding ", dump_file);
 	    print_rtl_single (dump_file, orig);
 	    fputs (" into...", dump_file);
 	  }
 /* Walk rtx X and replace all occurrences of REG and MEM subexpressions
 with VALUE expressions.  This way, it becomes independent of changes
 to registers and memory.
 X isn't actually modified; if modifications are needed, new rtl is
-allocated.  However, the return value can share rtl with X.  */
+allocated.  However, the return value can share rtl with X.
+If X is within a MEM, MEMMODE must be the mode of the MEM.  */
 rtx
-cselib_subst_to_values (rtx x)
+cselib_subst_to_values (rtx x, enum machine_mode memmode)
 {
 enum rtx_code code = GET_CODE (x);
 const char *fmt = GET_RTX_FORMAT (code);
 cselib_val *e;
 struct elt_list *l;
 gcc_unreachable ();
 case MEM:
 e = cselib_lookup_mem (x, 0);
+/* This used to happen for autoincrements, but we deal with them
+	 properly now.  Remove the if stmt for the next release.  */
 if (! e)
 	{
-	  /* This happens for autoincrements.  Assign a value that doesn't
+	  /* Assign a value that doesn't match any other.  */
-	     match any other.  */
 	  e = new_cselib_val (next_uid, GET_MODE (x), x);
 	}
 return e->val_rtx;
 case CONST_DOUBLE:
 case CONST_VECTOR:
 case CONST_INT:
 case CONST_FIXED:
 return x;
+case PRE_DEC:
+case PRE_INC:
+gcc_assert (memmode != VOIDmode);
+i = GET_MODE_SIZE (memmode);
+if (code == PRE_DEC)
+	i = -i;
+return cselib_subst_to_values (plus_constant (XEXP (x, 0), i),
+				     memmode);
+case PRE_MODIFY:
+gcc_assert (memmode != VOIDmode);
+return cselib_subst_to_values (XEXP (x, 1), memmode);
+case POST_DEC:
 case POST_INC:
-case PRE_INC:
-case POST_DEC:
-case PRE_DEC:
 case POST_MODIFY:
-case PRE_MODIFY:
+gcc_assert (memmode != VOIDmode);
-e = new_cselib_val (next_uid, GET_MODE (x), x);
+return cselib_subst_to_values (XEXP (x, 0), memmode);
-return e->val_rtx;
 default:
 break;
 }
 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
 {
 if (fmt[i] == 'e')
 	{
-	  rtx t = cselib_subst_to_values (XEXP (x, i));
+	  rtx t = cselib_subst_to_values (XEXP (x, i), memmode);
 	  if (t != XEXP (x, i))
 	    {
 	      if (x == copy)
 		copy = shallow_copy_rtx (x);
 	{
 	  int j;
 	  for (j = 0; j < XVECLEN (x, i); j++)
 	    {
-	      rtx t = cselib_subst_to_values (XVECEXP (x, i, j));
+	      rtx t = cselib_subst_to_values (XVECEXP (x, i, j), memmode);
 	      if (t != XVECEXP (x, i, j))
 		{
 		  if (XVEC (x, i) == XVEC (copy, i))
 		    {
 }
 return copy;
 }
-/* Look up the rtl expression X in our tables and return the value it has.
+/* Look up the rtl expression X in our tables and return the value it
-If CREATE is zero, we return NULL if we don't know the value.  Otherwise,
+has.  If CREATE is zero, we return NULL if we don't know the value.
-we create a new one if possible, using mode MODE if X doesn't have a mode
+Otherwise, we create a new one if possible, using mode MODE if X
-(i.e. because it's a constant).  */
+doesn't have a mode (i.e. because it's a constant).  When X is part
+of an address, MEMMODE should be the mode of the enclosing MEM if
+we're tracking autoinc expressions.  */
 static cselib_val *
-cselib_lookup_1 (rtx x, enum machine_mode mode, int create)
+cselib_lookup_1 (rtx x, enum machine_mode mode,
+		 int create, enum machine_mode memmode)
 {
 void **slot;
 cselib_val *e;
 unsigned int hashval;
 	     register, or NULL.  */
 	  used_regs[n_used_regs++] = i;
 	  REG_VALUES (i) = new_elt_list (REG_VALUES (i), NULL);
 	}
 REG_VALUES (i)->next = new_elt_list (REG_VALUES (i)->next, e);
-slot = htab_find_slot_with_hash (cselib_hash_table, x, e->hash, INSERT);
+slot = cselib_find_slot (x, e->hash, INSERT, memmode);
 *slot = e;
 return e;
 }
 if (MEM_P (x))
 return cselib_lookup_mem (x, create);
-hashval = cselib_hash_rtx (x, create);
+hashval = cselib_hash_rtx (x, create, memmode);
 /* Can't even create if hashing is not possible.  */
 if (! hashval)
 return 0;
-slot = htab_find_slot_with_hash (cselib_hash_table, wrap_constant (mode, x),
+slot = cselib_find_slot (wrap_constant (mode, x), hashval,
-				   hashval, create ? INSERT : NO_INSERT);
+			   create ? INSERT : NO_INSERT, memmode);
 if (slot == 0)
 return 0;
 e = (cselib_val *) *slot;
 if (e)
 /* We have to fill the slot before calling cselib_subst_to_values:
 the hash table is inconsistent until we do so, and
 cselib_subst_to_values will need to do lookups.  */
 *slot = (void *) e;
-e->locs = new_elt_loc_list (e->locs, cselib_subst_to_values (x));
+e->locs = new_elt_loc_list (e->locs,
+			      cselib_subst_to_values (x, memmode));
 return e;
 }
 /* Wrapper for cselib_lookup, that indicates X is in INSN.  */
 cselib_val *
 cselib_lookup_from_insn (rtx x, enum machine_mode mode,
-			 int create, rtx insn)
+			 int create, enum machine_mode memmode, rtx insn)
 {
 cselib_val *ret;
 gcc_assert (!cselib_current_insn);
 cselib_current_insn = insn;
-ret = cselib_lookup (x, mode, create);
+ret = cselib_lookup (x, mode, create, memmode);
 cselib_current_insn = NULL;
 return ret;
 }
 /* Wrapper for cselib_lookup_1, that logs the lookup result and
 maintains invariants related with debug insns.  */
 cselib_val *
-cselib_lookup (rtx x, enum machine_mode mode, int create)
+cselib_lookup (rtx x, enum machine_mode mode,
-{
+	       int create, enum machine_mode memmode)
-cselib_val *ret = cselib_lookup_1 (x, mode, create);
+{
+cselib_val *ret = cselib_lookup_1 (x, mode, create, memmode);
 /* ??? Should we return NULL if we're not to create an entry, the
 found loc is a debug loc and cselib_current_insn is not DEBUG?
 If so, we should also avoid converting val to non-DEBUG; probably
 easiest setting cselib_current_insn to NULL before the call
 above.  */
-if (dump_file && (dump_flags & TDF_DETAILS))
+if (dump_file && (dump_flags & TDF_CSELIB))
 {
 fputs ("cselib lookup ", dump_file);
 print_inline_rtx (dump_file, x, 2);
 fprintf (dump_file, " => %u:%u\n",
 	       ret ? ret->uid : 0,
 	  unsigned int this_last = i;
 	  if (i < FIRST_PSEUDO_REGISTER && v != NULL)
 	    this_last = end_hard_regno (GET_MODE (v->val_rtx), i) - 1;
-	  if (this_last < regno || v == NULL || v == cfa_base_preserved_val)
+	  if (this_last < regno || v == NULL
+	      || (v == cfa_base_preserved_val
+		  && i == cfa_base_preserved_regno))
 	    {
 	      l = &(*l)->next;
 	      continue;
 	    }
 	    }
 	  /* This one overlaps.  */
 	  /* We must have a mapping from this MEM's address to the
 	     value (E).  Remove that, too.  */
-	  addr = cselib_lookup (XEXP (x, 0), VOIDmode, 0);
+	  addr = cselib_lookup (XEXP (x, 0), VOIDmode, 0, GET_MODE (x));
 	  mem_chain = &addr->addr_list;
 	  for (;;)
 	    {
 	      if ((*mem_chain)->elt == v)
 		{
 if (REG_P (dest))
 cselib_invalidate_regno (REGNO (dest), GET_MODE (dest));
 else if (MEM_P (dest))
 cselib_invalidate_mem (dest);
-/* Some machines don't define AUTO_INC_DEC, but they still use push
-instructions.  We need to catch that case here in order to
-invalidate the stack pointer correctly.  Note that invalidating
-the stack pointer is different from invalidating DEST.  */
-if (push_operand (dest, GET_MODE (dest)))
-cselib_invalidate_rtx (stack_pointer_rtx);
 }
 /* A wrapper for cselib_invalidate_rtx to be called via note_stores.  */
 static void
 /* There is no good way to determine how many elements there can be
 in a PARALLEL.  Since it's fairly cheap, use a really large number.  */
 #define MAX_SETS (FIRST_PSEUDO_REGISTER * 2)
-/* Record the effects of any sets in INSN.  */
+struct cselib_record_autoinc_data
+{
+struct cselib_set *sets;
+int n_sets;
+};
+/* Callback for for_each_inc_dec.  Records in ARG the SETs implied by
+autoinc RTXs: SRC plus SRCOFF if non-NULL is stored in DEST.  */
+static int
+cselib_record_autoinc_cb (rtx mem ATTRIBUTE_UNUSED, rtx op ATTRIBUTE_UNUSED,
+			  rtx dest, rtx src, rtx srcoff, void *arg)
+{
+struct cselib_record_autoinc_data *data;
+data = (struct cselib_record_autoinc_data *)arg;
+data->sets[data->n_sets].dest = dest;
+if (srcoff)
+data->sets[data->n_sets].src = gen_rtx_PLUS (GET_MODE (src), src, srcoff);
+else
+data->sets[data->n_sets].src = src;
+data->n_sets++;
+return -1;
+}
+/* Record the effects of any sets and autoincs in INSN.  */
 static void
 cselib_record_sets (rtx insn)
 {
 int n_sets = 0;
 int i;
 struct cselib_set sets[MAX_SETS];
 rtx body = PATTERN (insn);
 rtx cond = 0;
+int n_sets_before_autoinc;
+struct cselib_record_autoinc_data data;
 body = PATTERN (insn);
 if (GET_CODE (body) == COND_EXEC)
 {
 cond = COND_EXEC_TEST (body);
 rtx note = find_reg_equal_equiv_note (insn);
 if (note && CONSTANT_P (XEXP (note, 0)))
 	sets[0].src = XEXP (note, 0);
 }
+data.sets = sets;
+data.n_sets = n_sets_before_autoinc = n_sets;
+for_each_inc_dec (&insn, cselib_record_autoinc_cb, &data);
+n_sets = data.n_sets;
 /* Look up the values that are read.  Do this before invalidating the
 locations that are written.  */
 for (i = 0; i < n_sets; i++)
 {
 	  || (MEM_P (dest) && cselib_record_memory))
 {
 	  rtx src = sets[i].src;
 	  if (cond)
 	    src = gen_rtx_IF_THEN_ELSE (GET_MODE (dest), cond, src, dest);
-	  sets[i].src_elt = cselib_lookup (src, GET_MODE (dest), 1);
+	  sets[i].src_elt = cselib_lookup (src, GET_MODE (dest), 1, VOIDmode);
 	  if (MEM_P (dest))
 	    {
 	      enum machine_mode address_mode
 		= targetm.addr_space.address_mode (MEM_ADDR_SPACE (dest));
 	      sets[i].dest_addr_elt = cselib_lookup (XEXP (dest, 0),
-						     address_mode, 1);
+						     address_mode, 1,
+						     GET_MODE (dest));
 	    }
 	  else
 	    sets[i].dest_addr_elt = 0;
 	}
 }
 /* Invalidate all locations written by this insn.  Note that the elts we
 looked up in the previous loop aren't affected, just some of their
 locations may go away.  */
 note_stores (body, cselib_invalidate_rtx_note_stores, NULL);
+for (i = n_sets_before_autoinc; i < n_sets; i++)
+cselib_invalidate_rtx (sets[i].dest);
 /* If this is an asm, look for duplicate sets.  This can happen when the
 user uses the same value as an output multiple times.  This is valid
 if the outputs are not actually used thereafter.  Treat this case as
 if the value isn't actually set.  We do this by smashing the destination
 	cselib_invalidate_mem (callmem);
 }
 cselib_record_sets (insn);
-#ifdef AUTO_INC_DEC
-/* Clobber any registers which appear in REG_INC notes.  We
-could keep track of the changes to their values, but it is
-unlikely to help.  */
-for (x = REG_NOTES (insn); x; x = XEXP (x, 1))
-if (REG_NOTE_KIND (x) == REG_INC)
-cselib_invalidate_rtx (XEXP (x, 0));
-#endif
 /* Look for any CLOBBERs in CALL_INSN_FUNCTION_USAGE, but only
 after we have processed the insn.  */
 if (CALL_P (insn))
 for (x = CALL_INSN_FUNCTION_USAGE (insn); x; x = XEXP (x, 1))
 if (GET_CODE (XEXP (x, 0)) == CLOBBER)
 cselib_finish (void)
 {
 cselib_discard_hook = NULL;
 cselib_preserve_constants = false;
 cfa_base_preserved_val = NULL;
+cfa_base_preserved_regno = INVALID_REGNUM;
 free_alloc_pool (elt_list_pool);
 free_alloc_pool (elt_loc_list_pool);
 free_alloc_pool (cselib_val_pool);
 free_alloc_pool (value_pool);
 cselib_clear_table ();

Mercurial > hg > CbC > CbC_gcc

comparison gcc/cselib.c @ 67:f6334be47118