Mercurial > hg > CbC > CbC_gcc
diff 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 |
line wrap: on
line diff
--- a/gcc/alias.c Sun Feb 07 18:28:00 2010 +0900 +++ b/gcc/alias.c Fri Feb 12 23:39:51 2010 +0900 @@ -46,6 +46,9 @@ #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: @@ -128,8 +131,7 @@ 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; @@ -146,7 +148,7 @@ `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); @@ -156,7 +158,6 @@ 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)); @@ -251,6 +252,107 @@ /* 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. */ @@ -350,8 +452,8 @@ { if (alias_sets_conflict_p (MEM_ALIAS_SET(*x), MEM_ALIAS_SET(mem))) return 1; - - return -1; + + return -1; } return 0; } @@ -365,7 +467,7 @@ 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; @@ -423,54 +525,6 @@ 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. @@ -518,6 +572,51 @@ } } +/* 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. */ @@ -541,7 +640,7 @@ 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. */ @@ -550,74 +649,24 @@ 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; - - if (TREE_CODE (TREE_OPERAND (inner, 0)) == SSA_NAME) - 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; + set = get_deref_alias_set_1 (TREE_OPERAND (inner, 0)); + if (set != -1) + return set; } /* Otherwise, pick up the outermost object that we could have a pointer @@ -640,11 +689,27 @@ } /* Variant qualifiers don't affect the alias set, so get the main - variant. Always use the canonical type as well. - If this is a type with a known alias set, return it. */ + variant. */ 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); @@ -752,7 +817,7 @@ { /* 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); @@ -979,9 +1044,9 @@ /* 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; @@ -995,11 +1060,16 @@ 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. */ @@ -1014,6 +1084,12 @@ 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)); @@ -1137,7 +1213,7 @@ 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: @@ -1230,9 +1306,9 @@ 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); } @@ -1406,6 +1482,11 @@ 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. */ @@ -1420,6 +1501,12 @@ 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)); @@ -1472,10 +1559,18 @@ /* 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. */ @@ -1506,7 +1601,7 @@ } 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; @@ -1569,11 +1664,11 @@ 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; @@ -1734,21 +1829,21 @@ 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) @@ -1758,7 +1853,7 @@ 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; @@ -1784,7 +1879,7 @@ || (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); @@ -1800,13 +1895,13 @@ 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 @@ -1819,7 +1914,7 @@ 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 @@ -2110,6 +2205,13 @@ 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); @@ -2120,16 +2222,23 @@ && ! 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 @@ -2211,6 +2320,12 @@ 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); @@ -2246,8 +2361,10 @@ if (mem_mode == BLKmode || GET_MODE (x) == BLKmode) return 1; - return ! fixed_scalar_and_varying_struct_p (mem, x, mem_addr, x_addr, - varies); + if (fixed_scalar_and_varying_struct_p (mem, x, mem_addr, x_addr, varies)) + return 0; + + return rtx_refs_may_alias_p (x, mem, true); } /* Canonical true dependence: X is read after store in MEM takes place. @@ -2286,6 +2403,12 @@ 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)); @@ -2310,8 +2433,10 @@ if (mem_mode == BLKmode || GET_MODE (x) == BLKmode) return 1; - return ! fixed_scalar_and_varying_struct_p (mem, x, mem_addr, x_addr, - varies); + if (fixed_scalar_and_varying_struct_p (mem, x, mem_addr, x_addr, 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 @@ -2337,9 +2462,6 @@ || 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; @@ -2347,6 +2469,12 @@ 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)); @@ -2374,8 +2502,11 @@ = fixed_scalar_and_varying_struct_p (mem, x, mem_addr, x_addr, rtx_addr_varies_p); - return (!(fixed_scalar == mem && !aliases_everything_p (x)) - && !(fixed_scalar == x && !aliases_everything_p (mem))); + if ((fixed_scalar == mem && !aliases_everything_p (x)) + || (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. */ @@ -2586,7 +2717,7 @@ && 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);