* init.c (build_new): Allow enumeration types for the array-bounds

[pf3gnuchains/gcc-fork.git] / gcc / alias.c

diff --git a/gcc/alias.c b/gcc/alias.c
index 235d299..85bce38 100644 (file)
--- a/gcc/alias.c
+++ b/gcc/alias.c
@@ -309,21 +309,24 @@ int
 objects_must_conflict_p (t1, t2)
      tree t1, t2;
 {
+  /* If one or the other has readonly fields or is readonly,
+     then they may not conflict.  */
+  if ((t1 != 0 && readonly_fields_p (t1))
+      || (t2 != 0 && readonly_fields_p (t2))
+      || (t1 != 0 && TYPE_READONLY (t1))
+      || (t2 != 0 && TYPE_READONLY (t2)))
+    return 0;
+
   /* If they are the same type, they must conflict.  */
   if (t1 == t2
       /* Likewise if both are volatile.  */
       || (t1 != 0 && TYPE_VOLATILE (t1) && t2 != 0 && TYPE_VOLATILE (t2)))
     return 1;
 
-  /* We now know they are different types.  If one or both has readonly fields
-     or if one is readonly and the other not, they may not conflict.
-     Likewise if one is aggregate and the other is scalar.  */
-  if ((t1 != 0 && readonly_fields_p (t1))
-      || (t2 != 0 && readonly_fields_p (t2))
-      || ((t1 != 0 && TYPE_READONLY (t1))
-         != (t2 != 0 && TYPE_READONLY (t2)))
-      || ((t1 != 0 && AGGREGATE_TYPE_P (t1))
-         != (t2 != 0 && AGGREGATE_TYPE_P (t2))))
+  /* If one is aggregate and the other is scalar then they may not
+     conflict.  */
+  if ((t1 != 0 && AGGREGATE_TYPE_P (t1))
+      != (t2 != 0 && AGGREGATE_TYPE_P (t2)))
     return 0;
 
   /* Otherwise they conflict only if the alias sets conflict. */
@@ -759,6 +762,10 @@ find_base_value (src)
        return find_base_value (XEXP (src, 0));
       return 0;
 
+    case TRUNCATE:
+      if (GET_MODE_SIZE (GET_MODE (src)) < GET_MODE_SIZE (Pmode))
+       break;
+      /* Fall through.  */
     case ZERO_EXTEND:
     case SIGN_EXTEND:  /* used for NT/Alpha pointers */
     case HIGH:
@@ -832,11 +839,26 @@ record_set (dest, set, data)
     switch (GET_CODE (src))
       {
       case LO_SUM:
-      case PLUS:
       case MINUS:
        if (XEXP (src, 0) != dest && XEXP (src, 1) != dest)
          new_reg_base_value[regno] = 0;
        break;
+      case PLUS:
+       /* If the value we add in the PLUS is also a valid base value,
+          this might be the actual base value, and the original value
+          an index.  */
+       {
+         rtx other = NULL_RTX;
+
+         if (XEXP (src, 0) == dest)
+           other = XEXP (src, 1);
+         else if (XEXP (src, 1) == dest)
+           other = XEXP (src, 0);
+
+         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)
          new_reg_base_value[regno] = 0;
@@ -988,8 +1010,8 @@ rtx_equal_for_memref_p (x, y)
       return 0;
 
     case ADDRESSOF:
-      return (REGNO (XEXP (x, 0)) == REGNO (XEXP (y, 0))
-             && XINT (x, 1) == XINT (y, 1));
+      return (XINT (x, 1) == XINT (y, 1)
+             && rtx_equal_for_memref_p (XEXP (x, 0), XEXP (y, 0)));
 
     default:
       break;