CbC/CbC_gcc: gcc/alias.c comparison

comparison gcc/alias.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	855418dad1a3
children	b7f97abdc517

comparison

equal deleted inserted replaced

-:c156f1bd5cd9
+:77e2b8dfacca
 #include "cgraph.h"
 #include "varray.h"
 #include "tree-pass.h"
 #include "ipa-type-escape.h"
 #include "df.h"
+#include "tree-ssa-alias.h"
+#include "pointer-set.h"
+#include "tree-flow.h"
 /* The aliasing API provided here solves related but different problems:
 Say there exists (in c)
 Alias set zero is implicitly a superset of all other alias sets.
 However, this is no actual entry for alias set zero.  It is an
 error to attempt to explicitly construct a subset of zero.  */
-struct alias_set_entry GTY(())
+struct GTY(()) alias_set_entry_d {
-{
 /* The alias set number, as stored in MEM_ALIAS_SET.  */
 alias_set_type alias_set;
 /* Nonzero if would have a child of zero: this effectively makes this
 alias set the same as alias set zero.  */
 continuing our example above, the children here will be all of
 `int', `double', `float', and `struct S'.  */
 splay_tree GTY((param1_is (int), param2_is (int))) children;
 };
-typedef struct alias_set_entry *alias_set_entry;
+typedef struct alias_set_entry_d *alias_set_entry;
 static int rtx_equal_for_memref_p (const_rtx, const_rtx);
 static int memrefs_conflict_p (int, rtx, int, rtx, HOST_WIDE_INT);
 static void record_set (rtx, const_rtx, void *);
 static int base_alias_check (rtx, rtx, enum machine_mode,
 			     enum machine_mode);
 static rtx find_base_value (rtx);
 static int mems_in_disjoint_alias_sets_p (const_rtx, const_rtx);
 static int insert_subset_children (splay_tree_node, void*);
-static tree find_base_decl (tree);
 static alias_set_entry get_alias_set_entry (alias_set_type);
 static const_rtx fixed_scalar_and_varying_struct_p (const_rtx, const_rtx, rtx, rtx,
 						    bool (*) (const_rtx, bool));
 static int aliases_everything_p (const_rtx);
 static bool nonoverlapping_component_refs_p (const_tree, const_tree);
 DEF_VEC_ALLOC_P(alias_set_entry,gc);
 /* The splay-tree used to store the various alias set entries.  */
 static GTY (()) VEC(alias_set_entry,gc) *alias_sets;
+/* Build a decomposed reference object for querying the alias-oracle
+from the MEM rtx and store it in *REF.
+Returns false if MEM is not suitable for the alias-oracle.  */
+static bool
+ao_ref_from_mem (ao_ref *ref, const_rtx mem)
+{
+tree expr = MEM_EXPR (mem);
+tree base;
+if (!expr)
+return false;
+/* If MEM_OFFSET or MEM_SIZE are NULL punt.  */
+if (!MEM_OFFSET (mem)
+|| !MEM_SIZE (mem))
+return false;
+ao_ref_init (ref, expr);
+/* Get the base of the reference and see if we have to reject or
+adjust it.  */
+base = ao_ref_base (ref);
+if (base == NULL_TREE)
+return false;
+/* If this is a pointer dereference of a non-SSA_NAME punt.
+???  We could replace it with a pointer to anything.  */
+if (INDIRECT_REF_P (base)
+&& TREE_CODE (TREE_OPERAND (base, 0)) != SSA_NAME)
+return false;
+/* The tree oracle doesn't like to have these.  */
+if (TREE_CODE (base) == FUNCTION_DECL
+|| TREE_CODE (base) == LABEL_DECL)
+return false;
+/* If this is a reference based on a partitioned decl replace the
+base with an INDIRECT_REF of the pointer representative we
+created during stack slot partitioning.  */
+if (TREE_CODE (base) == VAR_DECL
+&& ! TREE_STATIC (base)
+&& cfun->gimple_df->decls_to_pointers != NULL)
+{
+void *namep;
+namep = pointer_map_contains (cfun->gimple_df->decls_to_pointers, base);
+if (namep)
+	{
+	  ref->base_alias_set = get_alias_set (base);
+	  ref->base = build1 (INDIRECT_REF, TREE_TYPE (base), *(tree *)namep);
+	}
+}
+ref->ref_alias_set = MEM_ALIAS_SET (mem);
+/* If the base decl is a parameter we can have negative MEM_OFFSET in
+case of promoted subregs on bigendian targets.  Trust the MEM_EXPR
+here.  */
+if (INTVAL (MEM_OFFSET (mem)) < 0
+&& ((INTVAL (MEM_SIZE (mem)) + INTVAL (MEM_OFFSET (mem)))
+	  * BITS_PER_UNIT) == ref->size)
+return true;
+ref->offset += INTVAL (MEM_OFFSET (mem)) * BITS_PER_UNIT;
+ref->size = INTVAL (MEM_SIZE (mem)) * BITS_PER_UNIT;
+/* The MEM may extend into adjacent fields, so adjust max_size if
+necessary.  */
+if (ref->max_size != -1
+&& ref->size > ref->max_size)
+ref->max_size = ref->size;
+/* If MEM_OFFSET and MEM_SIZE get us outside of the base object of
+the MEM_EXPR punt.  This happens for STRICT_ALIGNMENT targets a lot.  */
+if (MEM_EXPR (mem) != get_spill_slot_decl (false)
+&& (ref->offset < 0
+	  || (DECL_P (ref->base)
+	      && (!host_integerp (DECL_SIZE (ref->base), 1)
+		  || (TREE_INT_CST_LOW (DECL_SIZE ((ref->base)))
+		      < (unsigned HOST_WIDE_INT)(ref->offset + ref->size))))))
+return false;
+return true;
+}
+/* Query the alias-oracle on whether the two memory rtx X and MEM may
+alias.  If TBAA_P is set also apply TBAA.  Returns true if the
+two rtxen may alias, false otherwise.  */
+static bool
+rtx_refs_may_alias_p (const_rtx x, const_rtx mem, bool tbaa_p)
+{
+ao_ref ref1, ref2;
+if (!ao_ref_from_mem (&ref1, x)
+|| !ao_ref_from_mem (&ref2, mem))
+return true;
+return refs_may_alias_p_1 (&ref1, &ref2, tbaa_p);
+}
 /* Returns a pointer to the alias set entry for ALIAS_SET, if there is
 such an entry, or NULL otherwise.  */
 static inline alias_set_entry
 get_alias_set_entry (alias_set_type alias_set)
 {
 if (MEM_P (*x))
 {
 if (alias_sets_conflict_p (MEM_ALIAS_SET(*x), MEM_ALIAS_SET(mem)))
 return 1;
 return -1;
 }
 return 0;
 }
 static int
 {
 /* Visit all MEMs in *PAT and check indepedence.  */
 if (for_each_rtx (pat, (rtx_function) walk_mems_2, *x))
 /* Indicate that dependence was determined and stop traversal.  */
 return 1;
 return -1;
 }
 return 0;
 }
 t2 for which a pair of subobjects of these respective subtypes
 overlaps on the stack.  */
 return alias_sets_must_conflict_p (set1, set2);
 }
-/* T is an expression with pointer type.  Find the DECL on which this
-expression is based.  (For example, in `a[i]' this would be `a'.)
-If there is no such DECL, or a unique decl cannot be determined,
-NULL_TREE is returned.  */
-static tree
-find_base_decl (tree t)
-{
-tree d0, d1;
-if (t == 0 || t == error_mark_node || ! POINTER_TYPE_P (TREE_TYPE (t)))
-return 0;
-/* If this is a declaration, return it.  If T is based on a restrict
-qualified decl, return that decl.  */
-if (DECL_P (t))
-{
-if (TREE_CODE (t) == VAR_DECL && DECL_BASED_ON_RESTRICT_P (t))
-	t = DECL_GET_RESTRICT_BASE (t);
-return t;
-}
-/* Handle general expressions.  It would be nice to deal with
-COMPONENT_REFs here.  If we could tell that `a' and `b' were the
-same, then `a->f' and `b->f' are also the same.  */
-switch (TREE_CODE_CLASS (TREE_CODE (t)))
-{
-case tcc_unary:
-return find_base_decl (TREE_OPERAND (t, 0));
-case tcc_binary:
-/* Return 0 if found in neither or both are the same.  */
-d0 = find_base_decl (TREE_OPERAND (t, 0));
-d1 = find_base_decl (TREE_OPERAND (t, 1));
-if (d0 == d1)
-	return d0;
-else if (d0 == 0)
-	return d1;
-else if (d1 == 0)
-	return d0;
-else
-	return 0;
-default:
-return 0;
-}
-}
 /* Return true if all nested component references handled by
 get_inner_reference in T are such that we should use the alias set
 provided by the object at the heart of T.
 This is true for non-addressable components (which don't have their
 if (get_alias_set (TREE_TYPE (t)) == 0)
 	return true;
 }
 }
+/* Return the alias set for the memory pointed to by T, which may be
+either a type or an expression.  Return -1 if there is nothing
+special about dereferencing T.  */
+static alias_set_type
+get_deref_alias_set_1 (tree t)
+{
+/* If we're not doing any alias analysis, just assume everything
+aliases everything else.  */
+if (!flag_strict_aliasing)
+return 0;
+/* All we care about is the type.  */
+if (! TYPE_P (t))
+t = TREE_TYPE (t);
+/* If we have an INDIRECT_REF via a void pointer, we don't
+know anything about what that might alias.  Likewise if the
+pointer is marked that way.  */
+if (TREE_CODE (TREE_TYPE (t)) == VOID_TYPE
+|| TYPE_REF_CAN_ALIAS_ALL (t))
+return 0;
+return -1;
+}
+/* Return the alias set for the memory pointed to by T, which may be
+either a type or an expression.  */
+alias_set_type
+get_deref_alias_set (tree t)
+{
+alias_set_type set = get_deref_alias_set_1 (t);
+/* Fall back to the alias-set of the pointed-to type.  */
+if (set == -1)
+{
+if (! TYPE_P (t))
+	t = TREE_TYPE (t);
+set = get_alias_set (TREE_TYPE (t));
+}
+return set;
+}
 /* Return the alias set for T, which may be either a type or an
 expression.  Call language-specific routine for help, if needed.  */
 alias_set_type
 get_alias_set (tree t)
 to figure out what to do.  At each juncture, we see if this is a tree
 that the language may need to handle specially.  First handle things that
 aren't types.  */
 if (! TYPE_P (t))
 {
-tree inner = t;
+tree inner;
 /* Remove any nops, then give the language a chance to do
 	 something with this tree before we look at it.  */
 STRIP_NOPS (t);
 set = lang_hooks.get_alias_set (t);
 if (set != -1)
 	return set;
+/* Retrieve the original memory reference if needed.  */
+if (TREE_CODE (t) == TARGET_MEM_REF)
+	t = TMR_ORIGINAL (t);
 /* First see if the actual object referenced is an INDIRECT_REF from a
 	 restrict-qualified pointer or a "void *".  */
+inner = t;
 while (handled_component_p (inner))
 	{
 	  inner = TREE_OPERAND (inner, 0);
 	  STRIP_NOPS (inner);
 	}
-/* Check for accesses through restrict-qualified pointers.  */
 if (INDIRECT_REF_P (inner))
 	{
-	  tree decl;
+	  set = get_deref_alias_set_1 (TREE_OPERAND (inner, 0));
+	  if (set != -1)
-	  if (TREE_CODE (TREE_OPERAND (inner, 0)) == SSA_NAME)
+	    return set;
-	    decl = SSA_NAME_VAR (TREE_OPERAND (inner, 0));
-	  else
-	    decl = find_base_decl (TREE_OPERAND (inner, 0));
-	  if (decl && DECL_POINTER_ALIAS_SET_KNOWN_P (decl))
-	    {
-	      /* If we haven't computed the actual alias set, do it now.  */
-	      if (DECL_POINTER_ALIAS_SET (decl) == -2)
-		{
-		  tree pointed_to_type = TREE_TYPE (TREE_TYPE (decl));
-		  /* No two restricted pointers can point at the same thing.
-		     However, a restricted pointer can point at the same thing
-		     as an unrestricted pointer, if that unrestricted pointer
-		     is based on the restricted pointer.  So, we make the
-		     alias set for the restricted pointer a subset of the
-		     alias set for the type pointed to by the type of the
-		     decl.  */
-		  alias_set_type pointed_to_alias_set
-		    = get_alias_set (pointed_to_type);
-		  if (pointed_to_alias_set == 0)
-		    /* It's not legal to make a subset of alias set zero.  */
-		    DECL_POINTER_ALIAS_SET (decl) = 0;
-		  else if (AGGREGATE_TYPE_P (pointed_to_type))
-		    /* For an aggregate, we must treat the restricted
-		       pointer the same as an ordinary pointer.  If we
-		       were to make the type pointed to by the
-		       restricted pointer a subset of the pointed-to
-		       type, then we would believe that other subsets
-		       of the pointed-to type (such as fields of that
-		       type) do not conflict with the type pointed to
-		       by the restricted pointer.  */
-		    DECL_POINTER_ALIAS_SET (decl)
-		      = pointed_to_alias_set;
-		  else
-		    {
-		      DECL_POINTER_ALIAS_SET (decl) = new_alias_set ();
-		      record_alias_subset (pointed_to_alias_set,
-					   DECL_POINTER_ALIAS_SET (decl));
-		    }
-		}
-	      /* We use the alias set indicated in the declaration.  */
-	      return DECL_POINTER_ALIAS_SET (decl);
-	    }
-	  /* If we have an INDIRECT_REF via a void pointer, we don't
-	     know anything about what that might alias.  Likewise if the
-	     pointer is marked that way.  */
-	  else if (TREE_CODE (TREE_TYPE (inner)) == VOID_TYPE
-		   || (TYPE_REF_CAN_ALIAS_ALL
-		       (TREE_TYPE (TREE_OPERAND (inner, 0)))))
-	    return 0;
 	}
 /* Otherwise, pick up the outermost object that we could have a pointer
 	 to, processing conversions as above.  */
 while (component_uses_parent_alias_set (t))
 /* Now all we care about is the type.  */
 t = TREE_TYPE (t);
 }
 /* Variant qualifiers don't affect the alias set, so get the main
-variant.  Always use the canonical type as well.
+variant.  */
-If this is a type with a known alias set, return it.  */
 t = TYPE_MAIN_VARIANT (t);
-if (TYPE_CANONICAL (t))
-t = TYPE_CANONICAL (t);
+/* Always use the canonical type as well.  If this is a type that
+requires structural comparisons to identify compatible types
+use alias set zero.  */
+if (TYPE_STRUCTURAL_EQUALITY_P (t))
+{
+/* Allow the language to specify another alias set for this
+	 type.  */
+set = lang_hooks.get_alias_set (t);
+if (set != -1)
+	return set;
+return 0;
+}
+t = TYPE_CANONICAL (t);
+/* Canonical types shouldn't form a tree nor should the canonical
+type require structural equality checks.  */
+gcc_assert (!TYPE_STRUCTURAL_EQUALITY_P (t) && TYPE_CANONICAL (t) == t);
+/* If this is a type with a known alias set, return it.  */
 if (TYPE_ALIAS_SET_KNOWN_P (t))
 return TYPE_ALIAS_SET (t);
 /* We don't want to set TYPE_ALIAS_SET for incomplete types.  */
 if (!COMPLETE_TYPE_P (t))
 superset_entry = get_alias_set_entry (superset);
 if (superset_entry == 0)
 {
 /* Create an entry for the SUPERSET, so that we have a place to
 	 attach the SUBSET.  */
-superset_entry = GGC_NEW (struct alias_set_entry);
+superset_entry = GGC_NEW (struct alias_set_entry_d);
 superset_entry->alias_set = superset;
 superset_entry->children
 	= splay_tree_new_ggc (splay_tree_compare_ints);
 superset_entry->has_zero_child = 0;
 VEC_replace (alias_set_entry, alias_sets, superset, superset_entry);
 	  return src_1;
 	/* Guess which operand is the base address:
 	   If either operand is a symbol, then it is the base.  If
 	   either operand is a CONST_INT, then the other is the base.  */
-	if (GET_CODE (src_1) == CONST_INT || CONSTANT_P (src_0))
+	if (CONST_INT_P (src_1) || CONSTANT_P (src_0))
 	  return find_base_value (src_0);
-	else if (GET_CODE (src_0) == CONST_INT || CONSTANT_P (src_1))
+	else if (CONST_INT_P (src_0) || CONSTANT_P (src_1))
 	  return find_base_value (src_1);
 	return 0;
 }
 return find_base_value (XEXP (src, 1));
 case AND:
 /* If the second operand is constant set the base
 	 address to the first operand.  */
-if (GET_CODE (XEXP (src, 1)) == CONST_INT && INTVAL (XEXP (src, 1)) != 0)
+if (CONST_INT_P (XEXP (src, 1)) && INTVAL (XEXP (src, 1)) != 0)
 	return find_base_value (XEXP (src, 0));
 return 0;
 case TRUNCATE:
+/* As we do not know which address space the pointer is refering to, we can
+	 handle this only if the target does not support different pointer or
+	 address modes depending on the address space.  */
+if (!target_default_pointer_address_modes_p ())
+	break;
 if (GET_MODE_SIZE (GET_MODE (src)) < GET_MODE_SIZE (Pmode))
 	break;
 /* Fall through.  */
 case HIGH:
 case PRE_INC:
 case POST_MODIFY:
 return find_base_value (XEXP (src, 0));
 case ZERO_EXTEND:
 case SIGN_EXTEND:	/* used for NT/Alpha pointers */
+/* As we do not know which address space the pointer is refering to, we can
+	 handle this only if the target does not support different pointer or
+	 address modes depending on the address space.  */
+if (!target_default_pointer_address_modes_p ())
+	break;
 {
 	rtx temp = find_base_value (XEXP (src, 0));
 	if (temp != 0 && CONSTANT_P (temp))
 	  temp = convert_memory_address (Pmode, temp);
 	  if (! other || find_base_value (other))
 	    new_reg_base_value[regno] = 0;
 	  break;
 	}
 case AND:
-	if (XEXP (src, 0) != dest || GET_CODE (XEXP (src, 1)) != CONST_INT)
+	if (XEXP (src, 0) != dest || !CONST_INT_P (XEXP (src, 1)))
 	  new_reg_base_value[regno] = 0;
 	break;
 default:
 	new_reg_base_value[regno] = 0;
 	break;
 rtx x0 = canon_rtx (XEXP (x, 0));
 rtx x1 = canon_rtx (XEXP (x, 1));
 if (x0 != XEXP (x, 0) || x1 != XEXP (x, 1))
 	{
-	  if (GET_CODE (x0) == CONST_INT)
+	  if (CONST_INT_P (x0))
 	    return plus_constant (x1, INTVAL (x0));
-	  else if (GET_CODE (x1) == CONST_INT)
+	  else if (CONST_INT_P (x1))
 	    return plus_constant (x0, INTVAL (x1));
 	  return gen_rtx_PLUS (GET_MODE (x), x0, x1);
 	}
 }
 {
 case REG:
 return REG_BASE_VALUE (x);
 case TRUNCATE:
+/* As we do not know which address space the pointer is refering to, we can
+	 handle this only if the target does not support different pointer or
+	 address modes depending on the address space.  */
+if (!target_default_pointer_address_modes_p ())
+	return 0;
 if (GET_MODE_SIZE (GET_MODE (x)) < GET_MODE_SIZE (Pmode))
 	return 0;
 /* Fall through.  */
 case HIGH:
 case PRE_INC:
 case POST_MODIFY:
 return find_base_term (XEXP (x, 0));
 case ZERO_EXTEND:
 case SIGN_EXTEND:	/* Used for Alpha/NT pointers */
+/* As we do not know which address space the pointer is refering to, we can
+	 handle this only if the target does not support different pointer or
+	 address modes depending on the address space.  */
+if (!target_default_pointer_address_modes_p ())
+	return 0;
 {
 	rtx temp = find_base_term (XEXP (x, 0));
 	if (temp != 0 && CONSTANT_P (temp))
 	  temp = convert_memory_address (Pmode, temp);
 	  return find_base_term (tmp2);
 	/* If either operand is known to be a pointer, then use it
 	   to determine the base term.  */
 	if (REG_P (tmp1) && REG_POINTER (tmp1))
-	  return find_base_term (tmp1);
+	  {
+	    rtx base = find_base_term (tmp1);
+	    if (base)
+	      return base;
+	  }
 	if (REG_P (tmp2) && REG_POINTER (tmp2))
-	  return find_base_term (tmp2);
+	  {
+	    rtx base = find_base_term (tmp2);
+	    if (base)
+	      return base;
+	  }
 	/* Neither operand was known to be a pointer.  Go ahead and find the
 	   base term for both operands.  */
 	tmp1 = find_base_term (tmp1);
 	tmp2 = find_base_term (tmp2);
 	   nothing from the base alias check.  */
 	return 0;
 }
 case AND:
-if (GET_CODE (XEXP (x, 1)) == CONST_INT && INTVAL (XEXP (x, 1)) != 0)
+if (CONST_INT_P (XEXP (x, 1)) && INTVAL (XEXP (x, 1)) != 0)
 	return find_base_term (XEXP (x, 0));
 return 0;
 case SYMBOL_REF:
 case LABEL_REF:
 via AND address can alias all surrounding object types except those
 with aligment 8 or higher.  */
 if (GET_CODE (x) == AND && GET_CODE (y) == AND)
 return 1;
 if (GET_CODE (x) == AND
-&& (GET_CODE (XEXP (x, 1)) != CONST_INT
+&& (!CONST_INT_P (XEXP (x, 1))
 	  || (int) GET_MODE_UNIT_SIZE (y_mode) < -INTVAL (XEXP (x, 1))))
 return 1;
 if (GET_CODE (y) == AND
-&& (GET_CODE (XEXP (y, 1)) != CONST_INT
+&& (!CONST_INT_P (XEXP (y, 1))
 	  || (int) GET_MODE_UNIT_SIZE (x_mode) < -INTVAL (XEXP (y, 1))))
 return 1;
 /* Differing symbols not accessed via AND never alias.  */
 if (GET_CODE (x_base) != ADDRESS && GET_CODE (y_base) != ADDRESS)
 	  if (rtx_equal_for_memref_p (x1, y1))
 	    return memrefs_conflict_p (xsize, x0, ysize, y0, c);
 	  if (rtx_equal_for_memref_p (x0, y0))
 	    return memrefs_conflict_p (xsize, x1, ysize, y1, c);
-	  if (GET_CODE (x1) == CONST_INT)
+	  if (CONST_INT_P (x1))
 	    {
-	      if (GET_CODE (y1) == CONST_INT)
+	      if (CONST_INT_P (y1))
 		return memrefs_conflict_p (xsize, x0, ysize, y0,
 					   c - INTVAL (x1) + INTVAL (y1));
 	      else
 		return memrefs_conflict_p (xsize, x0, ysize, y,
 					   c - INTVAL (x1));
 	    }
-	  else if (GET_CODE (y1) == CONST_INT)
+	  else if (CONST_INT_P (y1))
 	    return memrefs_conflict_p (xsize, x, ysize, y0, c + INTVAL (y1));
 	  return 1;
 	}
-else if (GET_CODE (x1) == CONST_INT)
+else if (CONST_INT_P (x1))
 	return memrefs_conflict_p (xsize, x0, ysize, y, c - INTVAL (x1));
 }
 else if (GET_CODE (y) == PLUS)
 {
 /* The fact that Y is canonicalized means that this
 	 PLUS rtx is canonicalized.  */
 rtx y0 = XEXP (y, 0);
 rtx y1 = XEXP (y, 1);
-if (GET_CODE (y1) == CONST_INT)
+if (CONST_INT_P (y1))
 	return memrefs_conflict_p (xsize, x, ysize, y0, c + INTVAL (y1));
 else
 	return 1;
 }
 	  if (rtx_equal_for_memref_p (x0, y0))
 	    return (xsize == 0 || ysize == 0
 		    || (c >= 0 && xsize > c) || (c < 0 && ysize+c > 0));
 	  /* Can't properly adjust our sizes.  */
-	  if (GET_CODE (x1) != CONST_INT)
+	  if (!CONST_INT_P (x1))
 	    return 1;
 	  xsize /= INTVAL (x1);
 	  ysize /= INTVAL (x1);
 	  c /= INTVAL (x1);
 	  return memrefs_conflict_p (xsize, x0, ysize, y0, c);
 /* Treat an access through an AND (e.g. a subword access on an Alpha)
 as an access with indeterminate size.  Assume that references
 besides AND are aligned, so if the size of the other reference is
 at least as large as the alignment, assume no other overlap.  */
-if (GET_CODE (x) == AND && GET_CODE (XEXP (x, 1)) == CONST_INT)
+if (GET_CODE (x) == AND && CONST_INT_P (XEXP (x, 1)))
 {
 if (GET_CODE (y) == AND || ysize < -INTVAL (XEXP (x, 1)))
 	xsize = -1;
 return memrefs_conflict_p (xsize, canon_rtx (XEXP (x, 0)), ysize, y, c);
 }
-if (GET_CODE (y) == AND && GET_CODE (XEXP (y, 1)) == CONST_INT)
+if (GET_CODE (y) == AND && CONST_INT_P (XEXP (y, 1)))
 {
 /* ??? If we are indexing far enough into the array/structure, we
 	 may yet be able to determine that we can not overlap.  But we
 	 also need to that we are far enough from the end not to overlap
 	 a following reference, so we do nothing with that for now.  */
 return memrefs_conflict_p (xsize, x, ysize, canon_rtx (XEXP (y, 0)), c);
 }
 if (CONSTANT_P (x))
 {
-if (GET_CODE (x) == CONST_INT && GET_CODE (y) == CONST_INT)
+if (CONST_INT_P (x) && CONST_INT_P (y))
 	{
 	  c += (INTVAL (y) - INTVAL (x));
 	  return (xsize <= 0 || ysize <= 0
 		  || (c >= 0 && xsize > c) || (c < 0 && ysize+c > 0));
 	}
 }
 if (! DECL_P (exprx) || ! DECL_P (expry))
 return 0;
+/* With invalid code we can end up storing into the constant pool.
+Bail out to avoid ICEing when creating RTL for this.
+See gfortran.dg/lto/20091028-2_0.f90.  */
+if (TREE_CODE (exprx) == CONST_DECL
+|| TREE_CODE (expry) == CONST_DECL)
+return 1;
 rtlx = DECL_RTL (exprx);
 rtly = DECL_RTL (expry);
 /* If either RTL is not a MEM, it must be a REG or CONCAT, meaning they
 can't overlap unless they are the same because we never reuse that part
 of the stack frame used for locals for spilled pseudos.  */
 if ((!MEM_P (rtlx) || !MEM_P (rtly))
 && ! rtx_equal_p (rtlx, rtly))
 return 1;
+/* If we have MEMs refering to different address spaces (which can
+potentially overlap), we cannot easily tell from the addresses
+whether the references overlap.  */
+if (MEM_P (rtlx) && MEM_P (rtly)
+&& MEM_ADDR_SPACE (rtlx) != MEM_ADDR_SPACE (rtly))
+return 0;
 /* Get the base and offsets of both decls.  If either is a register, we
 know both are and are the same, so use that as the base.  The only
 we can avoid overlap is if we can deduce that they are nonoverlapping
 pieces of that decl, which is very rare.  */
 basex = MEM_P (rtlx) ? XEXP (rtlx, 0) : rtlx;
-if (GET_CODE (basex) == PLUS && GET_CODE (XEXP (basex, 1)) == CONST_INT)
+if (GET_CODE (basex) == PLUS && CONST_INT_P (XEXP (basex, 1)))
 offsetx = INTVAL (XEXP (basex, 1)), basex = XEXP (basex, 0);
 basey = MEM_P (rtly) ? XEXP (rtly, 0) : rtly;
-if (GET_CODE (basey) == PLUS && GET_CODE (XEXP (basey, 1)) == CONST_INT)
+if (GET_CODE (basey) == PLUS && CONST_INT_P (XEXP (basey, 1)))
 offsety = INTVAL (XEXP (basey, 1)), basey = XEXP (basey, 0);
 /* If the bases are different, we know they do not overlap if both
 are constants or if one is a constant and the other a pointer into the
 stack frame.  Otherwise a different base means we can't tell if they
 return 0;
 if (nonoverlapping_memrefs_p (mem, x))
 return 0;
+/* If we have MEMs refering to different address spaces (which can
+potentially overlap), we cannot easily tell from the addresses
+whether the references overlap.  */
+if (MEM_ADDR_SPACE (mem) != MEM_ADDR_SPACE (x))
+return 1;
 if (mem_mode == VOIDmode)
 mem_mode = GET_MODE (mem);
 x_addr = get_addr (XEXP (x, 0));
 mem_addr = get_addr (XEXP (mem, 0));
 /* In true_dependence we also allow BLKmode to alias anything.  Why
 don't we do this in anti_dependence and output_dependence?  */
 if (mem_mode == BLKmode || GET_MODE (x) == BLKmode)
 return 1;
-return ! fixed_scalar_and_varying_struct_p (mem, x, mem_addr, x_addr,
+if (fixed_scalar_and_varying_struct_p (mem, x, mem_addr, x_addr, varies))
-					      varies);
+return 0;
+return rtx_refs_may_alias_p (x, mem, true);
 }
 /* Canonical true dependence: X is read after store in MEM takes place.
 Variant of true_dependence which assumes MEM has already been
 canonicalized (hence we no longer do that here).
 return 0;
 if (nonoverlapping_memrefs_p (x, mem))
 return 0;
+/* If we have MEMs refering to different address spaces (which can
+potentially overlap), we cannot easily tell from the addresses
+whether the references overlap.  */
+if (MEM_ADDR_SPACE (mem) != MEM_ADDR_SPACE (x))
+return 1;
 if (! x_addr)
 x_addr = get_addr (XEXP (x, 0));
 if (! base_alias_check (x_addr, mem_addr, GET_MODE (x), mem_mode))
 return 0;
 /* In true_dependence we also allow BLKmode to alias anything.  Why
 don't we do this in anti_dependence and output_dependence?  */
 if (mem_mode == BLKmode || GET_MODE (x) == BLKmode)
 return 1;
-return ! fixed_scalar_and_varying_struct_p (mem, x, mem_addr, x_addr,
+if (fixed_scalar_and_varying_struct_p (mem, x, mem_addr, x_addr, varies))
-					      varies);
+return 0;
+return rtx_refs_may_alias_p (x, mem, true);
 }
 /* Returns nonzero if a write to X might alias a previous read from
 (or, if WRITEP is nonzero, a write to) MEM.  */
 return 1;
 if (MEM_ALIAS_SET (x) == ALIAS_SET_MEMORY_BARRIER
 || MEM_ALIAS_SET (mem) == ALIAS_SET_MEMORY_BARRIER)
 return 1;
-if (DIFFERENT_ALIAS_SETS_P (x, mem))
-return 0;
 /* A read from read-only memory can't conflict with read-write memory.  */
 if (!writep && MEM_READONLY_P (mem))
 return 0;
 if (nonoverlapping_memrefs_p (x, mem))
 return 0;
+/* If we have MEMs refering to different address spaces (which can
+potentially overlap), we cannot easily tell from the addresses
+whether the references overlap.  */
+if (MEM_ADDR_SPACE (mem) != MEM_ADDR_SPACE (x))
+return 1;
 x_addr = get_addr (XEXP (x, 0));
 mem_addr = get_addr (XEXP (mem, 0));
 if (! writep)
 fixed_scalar
 = fixed_scalar_and_varying_struct_p (mem, x, mem_addr, x_addr,
 					 rtx_addr_varies_p);
-return (!(fixed_scalar == mem && !aliases_everything_p (x))
+if ((fixed_scalar == mem && !aliases_everything_p (x))
-	  && !(fixed_scalar == x && !aliases_everything_p (mem)));
+|| (fixed_scalar == x && !aliases_everything_p (mem)))
+return 0;
+return rtx_refs_may_alias_p (x, mem, false);
 }
 /* Anti dependence: X is written after read in MEM takes place.  */
 int
 		    }
 		  else if (DF_REG_DEF_COUNT (regno) == 1
 			   && GET_CODE (src) == PLUS
 			   && REG_P (XEXP (src, 0))
 			   && (t = get_reg_known_value (REGNO (XEXP (src, 0))))
-			   && GET_CODE (XEXP (src, 1)) == CONST_INT)
+			   && CONST_INT_P (XEXP (src, 1)))
 		    {
 		      t = plus_constant (t, INTVAL (XEXP (src, 1)));
 		      set_reg_known_value (regno, t);
 		      set_reg_known_equiv_p (regno, 0);
 		    }

Mercurial > hg > CbC > CbC_gcc

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