diff mbox

derive alias information from named address spaces.

Message ID 7FB04A5C213E9943A72EE127DB74F0ADD15FCB0658@SJEXCHCCR02.corp.ad.broadcom.com
State New
Headers show

Commit Message

Bingfeng Mei Sept. 20, 2011, 8:46 a.m. UTC 
Hello,
The following patch is to derive more alias information from named address
spaces using existing target hook. It was discussed in 
http://gcc.gnu.org/ml/gcc/2011-09/msg00180.html

Bootstrapped and tested on x86-64. OK for trunk? 

Thanks,
Bingfeng


2011-09-20  Bingfeng Mei <bmei@broadcom.com>

	* alias.c (nonoverlapping_memrefs_p): derive alias information
	from named addresss space using target hook.
	(nonoverlapping_memrefs_p): ditto. (write_dependence_p): ditto.
	(write_dependence_p): ditto.

Comments

Richard Henderson Sept. 20, 2011, 4:14 p.m. UTC | #1 
On 09/20/2011 01:46 AM, Bingfeng Mei wrote:
>    if (MEM_P (rtlx) && MEM_P (rtly)
>        && MEM_ADDR_SPACE (rtlx) != MEM_ADDR_SPACE (rtly))
> -    return 0;
> +    {
> +      if (!targetm.addr_space.subset_p (MEM_ADDR_SPACE (rtlx),
> +                                        MEM_ADDR_SPACE (rtly))
> +         && !targetm.addr_space.subset_p (MEM_ADDR_SPACE (rtly),
> +                                          MEM_ADDR_SPACE (rtlx)))
> +        return 1;
> +      else
> +        return 0;
> +    }

You have 4 copies of this.  Please pull it out into
a new predicate function.


r~
diff mbox

Patch

Index: alias.c
===================================================================
--- alias.c	(revision 178972)
+++ alias.c	(working copy)
@@ -2306,11 +2306,19 @@  nonoverlapping_memrefs_p (const_rtx x, c
     return 1;
 
   /* If we have MEMs refering to different address spaces (which can
-     potentially overlap), we cannot easily tell from the addresses
-     whether the references overlap.  */
+     potentially overlap), they are not aliased if neither is subset
+     of the other one. */
   if (MEM_P (rtlx) && MEM_P (rtly)
       && MEM_ADDR_SPACE (rtlx) != MEM_ADDR_SPACE (rtly))
-    return 0;
+    {
+      if (!targetm.addr_space.subset_p (MEM_ADDR_SPACE (rtlx),
+                                        MEM_ADDR_SPACE (rtly))
+         && !targetm.addr_space.subset_p (MEM_ADDR_SPACE (rtly),
+                                          MEM_ADDR_SPACE (rtlx)))
+        return 1;
+      else
+        return 0;
+    }
 
   /* Get the base and offsets of both decls.  If either is a register, we
      know both are and are the same, so use that as the base.  The only
@@ -2417,10 +2425,18 @@  true_dependence_1 (const_rtx mem, enum m
     return 0;
 
   /* If we have MEMs refering to different address spaces (which can
-     potentially overlap), we cannot easily tell from the addresses
-     whether the references overlap.  */
+     potentially overlap), they are not aliased if neither is subset
+     of the other one. */
   if (MEM_ADDR_SPACE (mem) != MEM_ADDR_SPACE (x))
-    return 1;
+    {
+      if (!targetm.addr_space.subset_p (MEM_ADDR_SPACE (mem),
+                                        MEM_ADDR_SPACE (x))
+         && !targetm.addr_space.subset_p (MEM_ADDR_SPACE (x),
+                                          MEM_ADDR_SPACE (mem)))
+        return 0;
+      else
+        return 1;
+    }
 
   if (! mem_addr)
     {
@@ -2542,10 +2558,18 @@  write_dependence_p (const_rtx mem, const
     return 0;
 
   /* If we have MEMs refering to different address spaces (which can
-     potentially overlap), we cannot easily tell from the addresses
-     whether the references overlap.  */
+     potentially overlap), they are not aliased if neither is subset
+     of the other one. */
   if (MEM_ADDR_SPACE (mem) != MEM_ADDR_SPACE (x))
-    return 1;
+    {
+      if (!targetm.addr_space.subset_p (MEM_ADDR_SPACE (mem),
+                                        MEM_ADDR_SPACE (x))
+         && !targetm.addr_space.subset_p (MEM_ADDR_SPACE (x),
+                                          MEM_ADDR_SPACE (mem)))
+        return 0;
+      else
+        return 1;
+    }
 
   x_addr = XEXP (x, 0);
   mem_addr = XEXP (mem, 0);
@@ -2637,10 +2661,18 @@  may_alias_p (const_rtx mem, const_rtx x)
     return 0;
 
   /* If we have MEMs refering to different address spaces (which can
-     potentially overlap), we cannot easily tell from the addresses
-     whether the references overlap.  */
+     potentially overlap), they are not aliased if neither is subset
+     of the other one. */
   if (MEM_ADDR_SPACE (mem) != MEM_ADDR_SPACE (x))
-    return 1;
+    {
+      if (!targetm.addr_space.subset_p (MEM_ADDR_SPACE (mem),
+                                        MEM_ADDR_SPACE (x))
+         && !targetm.addr_space.subset_p (MEM_ADDR_SPACE (x),
+                                          MEM_ADDR_SPACE (mem)))
+        return 0;
+      else
+        return 1;
+    }
 
   x_addr = XEXP (x, 0);
   mem_addr = XEXP (mem, 0);