gcse.c (load_kills_store, [...]): Keep track of the correct dependency function to...

	* gcse.c (load_kills_store, find_loads, store_killed_in_insn,
	store_killed_after, store_killed_before): Keep track of the correct
	dependency function to use.

From-SVN: r69198

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 0349f051e4742c84a31903d2765f420751a1b67c..fa80ec781b3b734566c4f983ba163aa4d77ce34d 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,9 @@
+2003-07-10  Zdenek Dvorak  <rakdver@atrey.karlin.mff.cuni.cz>
+
+       * gcse.c (load_kills_store, find_loads, store_killed_in_insn,
+       store_killed_after, store_killed_before): Keep track of the correct
+       dependency function to use.
+
 2003-07-10  Steven Bosscher  <steven@gcc.gnu.org>
        * toplev.c (do_compile): Don't try to open dump files before
        lang_dependent_init initializes dump_base_name.

diff --git a/gcc/gcse.c b/gcc/gcse.c
index 9d83f05903969d1d5ea322d1763f2142a59143aa..8ddcd73621ec3108dd223259e87e39ad312e9851 100644 (file)
--- a/gcc/gcse.c
+++ b/gcc/gcse.c
@@ -682,9 +682,9 @@ static rtx extract_mentioned_regs (rtx);
 static rtx extract_mentioned_regs_helper (rtx, rtx);
 static void find_moveable_store (rtx, int *, int *);
 static int compute_store_table (void);
-static bool load_kills_store (rtx, rtx);
-static bool find_loads (rtx, rtx);
-static bool store_killed_in_insn (rtx, rtx, rtx);
+static bool load_kills_store (rtx, rtx, int);
+static bool find_loads (rtx, rtx, int);
+static bool store_killed_in_insn (rtx, rtx, rtx, int);
 static bool store_killed_after (rtx, rtx, rtx, basic_block, int *, rtx *);
 static bool store_killed_before (rtx, rtx, rtx, basic_block, int *);
 static void build_store_vectors (void);
@@ -7186,21 +7186,27 @@ compute_store_table (void)
   return ret;
 }
 
-/* Check to see if the load X is aliased with STORE_PATTERN.  */
+/* Check to see if the load X is aliased with STORE_PATTERN.
+   AFTER is true if we are checking the case when STORE_PATTERN occurs
+   after the X.  */
 
 static bool
-load_kills_store (rtx x, rtx store_pattern)
+load_kills_store (rtx x, rtx store_pattern, int after)
 {
-  if (true_dependence (x, GET_MODE (x), store_pattern, rtx_addr_varies_p))
-    return true;
-  return false;
+  if (after)
+    return anti_dependence (x, store_pattern);
+  else
+    return true_dependence (store_pattern, GET_MODE (store_pattern), x,
+                           rtx_addr_varies_p);
 }
 
 /* Go through the entire insn X, looking for any loads which might alias
-   STORE_PATTERN.  Return true if found.  */
+   STORE_PATTERN.  Return true if found.
+   AFTER is true if we are checking the case when STORE_PATTERN occurs
+   after the insn X.  */
 
 static bool
-find_loads (rtx x, rtx store_pattern)
+find_loads (rtx x, rtx store_pattern, int after)
 {
   const char * fmt;
   int i, j;
@@ -7214,7 +7220,7 @@ find_loads (rtx x, rtx store_pattern)
 
   if (GET_CODE (x) == MEM)
     {
-      if (load_kills_store (x, store_pattern))
+      if (load_kills_store (x, store_pattern, after))
        return true;
     }
 
@@ -7224,19 +7230,20 @@ find_loads (rtx x, rtx store_pattern)
   for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0 && !ret; i--)
     {
       if (fmt[i] == 'e')
-       ret |= find_loads (XEXP (x, i), store_pattern);
+       ret |= find_loads (XEXP (x, i), store_pattern, after);
       else if (fmt[i] == 'E')
        for (j = XVECLEN (x, i) - 1; j >= 0; j--)
-         ret |= find_loads (XVECEXP (x, i, j), store_pattern);
+         ret |= find_loads (XVECEXP (x, i, j), store_pattern, after);
     }
   return ret;
 }
 
 /* Check if INSN kills the store pattern X (is aliased with it).
-   Return true if it it does.  */
+   AFTER is true if we are checking the case when store X occurs
+   after the insn.  Return true if it it does.  */
 
 static bool
-store_killed_in_insn (rtx x, rtx x_regs, rtx insn)
+store_killed_in_insn (rtx x, rtx x_regs, rtx insn, int after)
 {
   rtx reg, base;
 
@@ -7268,15 +7275,31 @@ store_killed_in_insn (rtx x, rtx x_regs, rtx insn)
   if (GET_CODE (PATTERN (insn)) == SET)
     {
       rtx pat = PATTERN (insn);
+      rtx dest = SET_DEST (pat);
+
+      if (GET_CODE (dest) == SIGN_EXTRACT
+         || GET_CODE (dest) == ZERO_EXTRACT)
+       dest = XEXP (dest, 0);
+
       /* Check for memory stores to aliased objects.  */
-      if (GET_CODE (SET_DEST (pat)) == MEM && !expr_equiv_p (SET_DEST (pat), x))
-       /* pretend its a load and check for aliasing.  */
-       if (find_loads (SET_DEST (pat), x))
-         return true;
-      return find_loads (SET_SRC (pat), x);
+      if (GET_CODE (dest) == MEM
+         && !expr_equiv_p (dest, x))
+       {
+         if (after)
+           {
+             if (output_dependence (dest, x))
+               return true;
+           }
+         else
+           {
+             if (output_dependence (x, dest))
+               return true;
+           }
+       }
+      return find_loads (SET_SRC (pat), x, after);
     }
   else
-    return find_loads (PATTERN (insn), x);
+    return find_loads (PATTERN (insn), x, after);
 }
 
 /* Returns true if the expression X is loaded or clobbered on or after INSN
@@ -7300,7 +7323,7 @@ store_killed_after (rtx x, rtx x_regs, rtx insn, basic_block bb,
 
   /* Scan from the end, so that fail_insn is determined correctly.  */
   for (act = last; act != PREV_INSN (insn); act = PREV_INSN (act))
-    if (store_killed_in_insn (x, x_regs, act))
+    if (store_killed_in_insn (x, x_regs, act, false))
       {
        if (fail_insn)
          *fail_insn = act;
@@ -7323,7 +7346,7 @@ store_killed_before (rtx x, rtx x_regs, rtx insn, basic_block bb,
     return true;
 
   for ( ; insn != PREV_INSN (first); insn = PREV_INSN (insn))
-    if (store_killed_in_insn (x, x_regs, insn))
+    if (store_killed_in_insn (x, x_regs, insn, true))
       return true;
 
   return false;