+2009-09-02 Richard Guenther <rguenther@suse.de>
+
+ Revert
+ 2009-08-31 Richard Guenther <rguenther@suse.de>
+
+ * builtins.c (fold_builtin_memory_op): Use the alias oracle
+ to query if the memory regions for memmove overlap.
+ * tree-ssa-alias.c (ptr_deref_may_alias_decl_p): Relax the
+ asserts on pointers, instead deal with odd trees.
+ (ptr_derefs_may_alias_p): Likewise.
+ (refs_may_alias_p_1): Constructor bases also never alias.
+
2009-08-01 Christian Bruel <christian.bruel@st.com>
Revert:
if (endp == 3)
{
- ao_ref srcref, destref;
-
src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
dest_align = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
}
/* If *src and *dest can't overlap, optimize into memcpy as well. */
- ao_ref_init_from_ptr_and_size (&srcref, src, len);
- ao_ref_init_from_ptr_and_size (&destref, dest, len);
- if (!refs_may_alias_p_1 (&srcref, &destref, false))
+ srcvar = build_fold_indirect_ref_loc (loc, src);
+ destvar = build_fold_indirect_ref_loc (loc, dest);
+ if (srcvar
+ && !TREE_THIS_VOLATILE (srcvar)
+ && destvar
+ && !TREE_THIS_VOLATILE (destvar))
{
- tree fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
+ tree src_base, dest_base, fn;
+ HOST_WIDE_INT src_offset = 0, dest_offset = 0;
+ HOST_WIDE_INT size = -1;
+ HOST_WIDE_INT maxsize = -1;
+
+ src_base = srcvar;
+ if (handled_component_p (src_base))
+ src_base = get_ref_base_and_extent (src_base, &src_offset,
+ &size, &maxsize);
+ dest_base = destvar;
+ if (handled_component_p (dest_base))
+ dest_base = get_ref_base_and_extent (dest_base, &dest_offset,
+ &size, &maxsize);
+ if (host_integerp (len, 1))
+ {
+ maxsize = tree_low_cst (len, 1);
+ if (maxsize
+ > INTTYPE_MAXIMUM (HOST_WIDE_INT) / BITS_PER_UNIT)
+ maxsize = -1;
+ else
+ maxsize *= BITS_PER_UNIT;
+ }
+ else
+ maxsize = -1;
+ if (SSA_VAR_P (src_base)
+ && SSA_VAR_P (dest_base))
+ {
+ if (operand_equal_p (src_base, dest_base, 0)
+ && ranges_overlap_p (src_offset, maxsize,
+ dest_offset, maxsize))
+ return NULL_TREE;
+ }
+ else if (TREE_CODE (src_base) == INDIRECT_REF
+ && TREE_CODE (dest_base) == INDIRECT_REF)
+ {
+ if (! operand_equal_p (TREE_OPERAND (src_base, 0),
+ TREE_OPERAND (dest_base, 0), 0)
+ || ranges_overlap_p (src_offset, maxsize,
+ dest_offset, maxsize))
+ return NULL_TREE;
+ }
+ else
+ return NULL_TREE;
+
+ fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
if (!fn)
return NULL_TREE;
return build_call_expr_loc (loc, fn, 3, dest, src, len);
}
-
return NULL_TREE;
}
{
struct ptr_info_def *pi;
- gcc_assert (TREE_CODE (decl) == VAR_DECL
- || TREE_CODE (decl) == PARM_DECL
- || TREE_CODE (decl) == RESULT_DECL);
+ gcc_assert ((TREE_CODE (ptr) == SSA_NAME
+ || TREE_CODE (ptr) == ADDR_EXPR
+ || TREE_CODE (ptr) == INTEGER_CST)
+ && (TREE_CODE (decl) == VAR_DECL
+ || TREE_CODE (decl) == PARM_DECL
+ || TREE_CODE (decl) == RESULT_DECL));
/* Non-aliased variables can not be pointed to. */
if (!may_be_aliased (decl))
return true;
}
- /* We can end up with dereferencing non-SSA name pointers.
+ /* We can end up with dereferencing constant pointers.
Just bail out in this case. */
- if (TREE_CODE (ptr) != SSA_NAME)
+ if (TREE_CODE (ptr) == INTEGER_CST)
return true;
/* If we do not have useful points-to information for this pointer
{
struct ptr_info_def *pi1, *pi2;
+ gcc_assert ((TREE_CODE (ptr1) == SSA_NAME
+ || TREE_CODE (ptr1) == ADDR_EXPR
+ || TREE_CODE (ptr1) == INTEGER_CST)
+ && (TREE_CODE (ptr2) == SSA_NAME
+ || TREE_CODE (ptr2) == ADDR_EXPR
+ || TREE_CODE (ptr2) == INTEGER_CST));
+
/* ADDR_EXPR pointers either just offset another pointer or directly
specify the pointed-to set. */
if (TREE_CODE (ptr1) == ADDR_EXPR)
return true;
}
- /* We can end up with dereferencing non-SSA name pointers.
+ /* We can end up with dereferencing constant pointers.
Just bail out in this case. */
- if (TREE_CODE (ptr1) != SSA_NAME
- || TREE_CODE (ptr2) != SSA_NAME)
+ if (TREE_CODE (ptr1) == INTEGER_CST
+ || TREE_CODE (ptr2) == INTEGER_CST)
return true;
/* We may end up with two empty points-to solutions for two same pointers.
if (TREE_CODE (base1) == SSA_NAME
|| TREE_CODE (base2) == SSA_NAME
|| is_gimple_min_invariant (base1)
- || is_gimple_min_invariant (base2)
- || TREE_CODE (base1) == CONSTRUCTOR
- || TREE_CODE (base2) == CONSTRUCTOR)
+ || is_gimple_min_invariant (base2))
return false;
/* Defer to simple offset based disambiguation if we have