changed. A volatile and non-volatile reference can be interchanged
though.
- A MEM_IN_STRUCT reference at a non-QImode non-AND varying address can never
- conflict with a non-MEM_IN_STRUCT reference at a fixed address. We must
- allow QImode aliasing because the ANSI C standard allows character
- pointers to alias anything. We are assuming that characters are
- always QImode here. We also must allow AND addresses, because they may
- generate accesses outside the object being referenced. This is used to
- generate aligned addresses from unaligned addresses, for instance, the
- alpha storeqi_unaligned pattern. */
+ A MEM_IN_STRUCT reference at a non-AND varying address can never
+ conflict with a non-MEM_IN_STRUCT reference at a fixed address. We
+ also must allow AND addresses, because they may generate accesses
+ outside the object being referenced. This is used to generate
+ aligned addresses from unaligned addresses, for instance, the alpha
+ storeqi_unaligned pattern. */
/* Read dependence: X is read after read in MEM takes place. There can
only be a dependence here if both reads are volatile. */
aliases_everything_p (mem)
rtx mem;
{
- if (GET_MODE (mem) == QImode)
- /* ANSI C says that a `char*' can point to anything. */
- return 1;
-
if (GET_CODE (XEXP (mem, 0)) == AND)
/* If the address is an AND, its very hard to know at what it is
actually pointing. */
if (t == error_mark_node)
return 0;
- type = (TYPE_P (t)) ? t : TREE_TYPE (t);
+ /* For a bit field reference that's not to a specific field,
+ all we can say is the aliasing information for the underlying object. */
+ if (TREE_CODE (t) == BIT_FIELD_REF)
+ t = TREE_OPERAND (t, 0);
+ /* If this is a type, use it, otherwise get the type of the expression.
+ If the type is an error type, say this may alias anything. */
+ type = TYPE_P (t) ? t : TREE_TYPE (t);
if (type == error_mark_node)
return 0;
/* Deal with special cases first; for certain kinds of references
we're interested in more than just the type. */
- if (TREE_CODE (t) == BIT_FIELD_REF)
- /* Perhaps reads and writes to this piece of data alias fields
- neighboring the bitfield. Perhaps that's impossible. For now,
- let's just assume that bitfields can alias everything, which is
- the conservative assumption. */
- return 0;
-
/* Permit type-punning when accessing a union, provided the access
is directly through the union. For example, this code does not
permit taking the address of a union member and then storing
if (TREE_CODE (t) == INDIRECT_REF)
{
/* Check for accesses through restrict-qualified pointers. */
- tree decl = c_find_base_decl (TREE_OPERAND (t, 0));
+ tree op = TREE_OPERAND (t, 0);
+ tree decl = c_find_base_decl (op);
if (decl && DECL_POINTER_ALIAS_SET_KNOWN_P (decl))
/* We use the alias set indicated in the declaration. */
return DECL_POINTER_ALIAS_SET (decl);
+
+ /* If this is a char *, the ANSI C standard says it can alias
+ anything. */
+ if (TREE_CODE (TREE_TYPE (op)) == INTEGER_TYPE
+ && (TYPE_PRECISION (TREE_TYPE (op))
+ == TYPE_PRECISION (char_type_node)))
+ return 0;
}
/* From here on, only the type matters. */
whose type is the same as one of the fields, recursively, but
we don't yet make any use of that information.) */
TYPE_ALIAS_SET (type) = 0;
- else if (TREE_CODE (type) == POINTER_TYPE
- || TREE_CODE (type) == REFERENCE_TYPE)
+ else if (POINTER_TYPE_P (type))
{
tree t;
TYPE_ALIAS_SET (type) = c_get_alias_set (t);
}
- if (!TYPE_ALIAS_SET_KNOWN_P (type))
+ if (! TYPE_ALIAS_SET_KNOWN_P (type))
/* TYPE is something we haven't seen before. Put it in a new
alias set. */
TYPE_ALIAS_SET (type) = new_alias_set ();