alias.c (aliases_everything_p): Don't special-case QImode here.

	* alias.c (aliases_everything_p): Don't special-case QImode here.
	* c-common.c (c_get_alias_set): Do it here.
	Handle BIT_FIELD_REF by getting alias info for arg.
	Use POINTER_TYPE_P.

From-SVN: r34050

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 2ee83e3b86831cd58ba0281cb8a920802ae74790..6f8d3966b79c3afe736395c6a1e957487e9f9ac1 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,10 @@
+Sat May 20 09:30:55 2000  Richard Kenner  <kenner@vlsi1.ultra.nyu.edu>
+
+       * alias.c (aliases_everything_p): Don't special-case QImode here.
+       * c-common.c (c_get_alias_set): Do it here.
+       Handle BIT_FIELD_REF by getting alias info for arg.
+       Use POINTER_TYPE_P.
+
 2000-05-20  Alexandre Oliva  <aoliva@cygnus.com>
 
        * mklibgcc.in: Restore rule to create ${dir}.

diff --git a/gcc/alias.c b/gcc/alias.c
index 56dfc9d63874386845dfe22207205fc6435c0408..897c27d08afa33c30b496ce1b035048f3abb8394 100644 (file)
--- a/gcc/alias.c
+++ b/gcc/alias.c
@@ -1213,14 +1213,12 @@ memrefs_conflict_p (xsize, x, ysize, y, c)
    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.  */
@@ -1269,10 +1267,6 @@ static int
 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.  */

diff --git a/gcc/c-common.c b/gcc/c-common.c
index 30985b560f8e05d28f5a0bec8dc94886a648de78..4631417b90d94c561b1d2f174080a2dab0398eef 100644 (file)
--- a/gcc/c-common.c
+++ b/gcc/c-common.c
@@ -3332,21 +3332,20 @@ c_get_alias_set (t)
   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
@@ -3363,11 +3362,19 @@ c_get_alias_set (t)
   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.  */
@@ -3424,8 +3431,7 @@ c_get_alias_set (t)
        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;
 
@@ -3459,7 +3465,7 @@ c_get_alias_set (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 ();