re PR rtl-optimization/63475 (Postreload CSE propagates aliased memory operand)

	PR rtl-optimization/63475
	* alias.c (true_dependence_1): Always use get_addr to extract
	true address operands from x_addr and mem_addr.  Use extracted
	address operands to check for references with alignment ANDs.
	Use extracted address operands with find_base_term and
	base_alias_check. For noncanonicalized operands call canon_rtx with
	extracted address operand.
	(write_dependence_1): Ditto.
	(may_alias_p): Ditto.  Remove unused calls to canon_rtx.

From-SVN: r216217

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 3fb8f2d092c616c5d99e1c3da3210bbbae04a482..647b3a441994eb41bfe958e8d23f465c4345d487 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,15 @@
+2014-10-14  Uros Bizjak  <ubizjak@gmail.com>
+
+       PR rtl-optimization/63475
+       * alias.c (true_dependence_1): Always use get_addr to extract
+       true address operands from x_addr and mem_addr.  Use extracted
+       address operands to check for references with alignment ANDs.
+       Use extracted address operands with find_base_term and
+       base_alias_check. For noncanonicalized operands call canon_rtx with
+       extracted address operand.
+       (write_dependence_1): Ditto.
+       (may_alias_p): Ditto.  Remove unused calls to canon_rtx.
+
 2014-10-14  Evgeny Stupachenko  <evstupac@gmail.com>
 
        PR target/63534

diff --git a/gcc/alias.c b/gcc/alias.c
index 134b6fb5485b3df600f16aeb3b4333c2579c845d..4ff0aacfba8f4f4d95f90d215ba14e5e10f7c8ca 100644 (file)
--- a/gcc/alias.c
+++ b/gcc/alias.c
@@ -2439,6 +2439,7 @@ static int
 true_dependence_1 (const_rtx mem, enum machine_mode mem_mode, rtx mem_addr,
                   const_rtx x, rtx x_addr, bool mem_canonicalized)
 {
+  rtx true_mem_addr;
   rtx base;
   int ret;
 
@@ -2458,28 +2459,17 @@ true_dependence_1 (const_rtx mem, enum machine_mode mem_mode, rtx mem_addr,
       || MEM_ALIAS_SET (mem) == ALIAS_SET_MEMORY_BARRIER)
     return 1;
 
+  if (! x_addr)
+    x_addr = XEXP (x, 0);
+  x_addr = get_addr (x_addr);
+
   if (! mem_addr)
     {
       mem_addr = XEXP (mem, 0);
       if (mem_mode == VOIDmode)
        mem_mode = GET_MODE (mem);
     }
-
-  if (! x_addr)
-    {
-      x_addr = XEXP (x, 0);
-      if (!((GET_CODE (x_addr) == VALUE
-            && GET_CODE (mem_addr) != VALUE
-            && reg_mentioned_p (x_addr, mem_addr))
-           || (GET_CODE (x_addr) != VALUE
-               && GET_CODE (mem_addr) == VALUE
-               && reg_mentioned_p (mem_addr, x_addr))))
-       {
-         x_addr = get_addr (x_addr);
-         if (! mem_canonicalized)
-           mem_addr = get_addr (mem_addr);
-       }
-    }
+  true_mem_addr = get_addr (mem_addr);
 
   /* Read-only memory is by definition never modified, and therefore can't
      conflict with anything.  However, don't assume anything when AND
@@ -2488,7 +2478,7 @@ true_dependence_1 (const_rtx mem, enum machine_mode mem_mode, rtx mem_addr,
      stupid user tricks can produce them, so don't die.  */
   if (MEM_READONLY_P (x)
       && GET_CODE (x_addr) != AND
-      && GET_CODE (mem_addr) != AND)
+      && GET_CODE (true_mem_addr) != AND)
     return 0;
 
   /* If we have MEMs referring to different address spaces (which can
@@ -2503,14 +2493,14 @@ true_dependence_1 (const_rtx mem, enum machine_mode mem_mode, rtx mem_addr,
                   && CONSTANT_POOL_ADDRESS_P (base))))
     return 0;
 
-  rtx mem_base = find_base_term (mem_addr);
-  if (! base_alias_check (x_addr, base, mem_addr, mem_base,
+  rtx mem_base = find_base_term (true_mem_addr);
+  if (! base_alias_check (x_addr, base, true_mem_addr, mem_base,
                          GET_MODE (x), mem_mode))
     return 0;
 
   x_addr = canon_rtx (x_addr);
   if (!mem_canonicalized)
-    mem_addr = canon_rtx (mem_addr);
+    mem_addr = canon_rtx (true_mem_addr);
 
   if ((ret = memrefs_conflict_p (GET_MODE_SIZE (mem_mode), mem_addr,
                                 SIZE_FOR_MODE (x), x_addr, 0)) != -1)
@@ -2560,6 +2550,7 @@ write_dependence_p (const_rtx mem,
                    bool mem_canonicalized, bool x_canonicalized, bool writep)
 {
   rtx mem_addr;
+  rtx true_mem_addr, true_x_addr;
   rtx base;
   int ret;
 
@@ -2580,30 +2571,20 @@ write_dependence_p (const_rtx mem,
       || MEM_ALIAS_SET (mem) == ALIAS_SET_MEMORY_BARRIER)
     return 1;
 
-  mem_addr = XEXP (mem, 0);
   if (!x_addr)
-    {
-      x_addr = XEXP (x, 0);
-      if (!((GET_CODE (x_addr) == VALUE
-            && GET_CODE (mem_addr) != VALUE
-            && reg_mentioned_p (x_addr, mem_addr))
-           || (GET_CODE (x_addr) != VALUE
-               && GET_CODE (mem_addr) == VALUE
-               && reg_mentioned_p (mem_addr, x_addr))))
-       {
-         x_addr = get_addr (x_addr);
-         if (!mem_canonicalized)
-           mem_addr = get_addr (mem_addr);
-       }
-    }
+    x_addr = XEXP (x, 0);
+  true_x_addr = get_addr (x_addr);
+
+  mem_addr = XEXP (mem, 0);
+  true_mem_addr = get_addr (mem_addr);
 
   /* A read from read-only memory can't conflict with read-write memory.
      Don't assume anything when AND addresses are involved and leave to
      the code below to determine dependence.  */
   if (!writep
       && MEM_READONLY_P (mem)
-      && GET_CODE (x_addr) != AND
-      && GET_CODE (mem_addr) != AND)
+      && GET_CODE (true_x_addr) != AND
+      && GET_CODE (true_mem_addr) != AND)
     return 0;
 
   /* If we have MEMs referring to different address spaces (which can
@@ -2612,7 +2593,7 @@ write_dependence_p (const_rtx mem,
   if (MEM_ADDR_SPACE (mem) != MEM_ADDR_SPACE (x))
     return 1;
 
-  base = find_base_term (mem_addr);
+  base = find_base_term (true_mem_addr);
   if (! writep
       && base
       && (GET_CODE (base) == LABEL_REF
@@ -2620,18 +2601,18 @@ write_dependence_p (const_rtx mem,
              && CONSTANT_POOL_ADDRESS_P (base))))
     return 0;
 
-  rtx x_base = find_base_term (x_addr);
-  if (! base_alias_check (x_addr, x_base, mem_addr, base, GET_MODE (x),
-                         GET_MODE (mem)))
+  rtx x_base = find_base_term (true_x_addr);
+  if (! base_alias_check (true_x_addr, x_base, true_mem_addr, base,
+                         GET_MODE (x), GET_MODE (mem)))
     return 0;
 
   if (!x_canonicalized)
     {
-      x_addr = canon_rtx (x_addr);
+      x_addr = canon_rtx (true_x_addr);
       x_mode = GET_MODE (x);
     }
   if (!mem_canonicalized)
-    mem_addr = canon_rtx (mem_addr);
+    mem_addr = canon_rtx (true_mem_addr);
 
   if ((ret = memrefs_conflict_p (SIZE_FOR_MODE (mem), mem_addr,
                                 GET_MODE_SIZE (x_mode), x_addr, 0)) != -1)
@@ -2700,17 +2681,10 @@ may_alias_p (const_rtx mem, const_rtx x)
     return 1;
 
   x_addr = XEXP (x, 0);
+  x_addr = get_addr (x_addr);
+
   mem_addr = XEXP (mem, 0);
-  if (!((GET_CODE (x_addr) == VALUE
-        && GET_CODE (mem_addr) != VALUE
-        && reg_mentioned_p (x_addr, mem_addr))
-       || (GET_CODE (x_addr) != VALUE
-           && GET_CODE (mem_addr) == VALUE
-           && reg_mentioned_p (mem_addr, x_addr))))
-    {
-      x_addr = get_addr (x_addr);
-      mem_addr = get_addr (mem_addr);
-    }
+  mem_addr = get_addr (mem_addr);
 
   /* Read-only memory is by definition never modified, and therefore can't
      conflict with anything.  However, don't assume anything when AND
@@ -2734,9 +2708,6 @@ may_alias_p (const_rtx mem, const_rtx x)
                          GET_MODE (x), GET_MODE (mem_addr)))
     return 0;
 
-  x_addr = canon_rtx (x_addr);
-  mem_addr = canon_rtx (mem_addr);
-
   if (nonoverlapping_memrefs_p (mem, x, true))
     return 0;