recog.c (store_data_bypass_p): Add support to allow IN_INSN to be a PARALLEL containing sets.

	* recog.c (store_data_bypass_p): Add support to allow IN_INSN to
	be a PARALLEL containing sets.  Return false when out_pat is not
	a PARALLEL insn.

From-SVN: r118199

gcc/ChangeLog

+2006-10-30  Pete Steinmetz  <steinmtz@us.ibm.com>
+
+	* recog.c (store_data_bypass_p): Add support to allow IN_INSN to
+	be a PARALLEL containing sets.	Return false when out_pat is not
+	a PARALLEL insn.
+
 2006-10-30  Richard Sandiford  <richard@codesourcery.com>
 
 	* config/mips/mips.md (mul<mode>3): Split into...

gcc/recog.c

@@ -3344,18 +3344,20 @@ peephole2_optimize (void)
 /* Common predicates for use with define_bypass.  */
 
 /* True if the dependency between OUT_INSN and IN_INSN is on the store
-   data not the address operand(s) of the store.  IN_INSN must be
-   single_set.  OUT_INSN must be either a single_set or a PARALLEL with
-   SETs inside.  */
+   data not the address operand(s) of the store.  IN_INSN and OUT_INSN
+   must be either a single_set or a PARALLEL with SETs inside.  */
 
 int
 store_data_bypass_p (rtx out_insn, rtx in_insn)
 {
   rtx out_set, in_set;
+  rtx out_pat, in_pat;
+  rtx out_exp, in_exp;
+  int i, j;
 
   in_set = single_set (in_insn);
-  gcc_assert (in_set);
-
+  if (in_set)
+    {
       if (!MEM_P (SET_DEST (in_set)))
 	return false;
 
@@ -3367,25 +3369,68 @@ store_data_bypass_p (rtx out_insn, rtx in_insn)
         }
       else
         {
-      rtx out_pat;
-      int i;
+          out_pat = PATTERN (out_insn);
+
+	  if (GET_CODE (out_pat) != PARALLEL)
+	    return false;
+
+          for (i = 0; i < XVECLEN (out_pat, 0); i++)
+          {
+            out_exp = XVECEXP (out_pat, 0, i);
+
+            if (GET_CODE (out_exp) == CLOBBER)
+              continue;
+
+            gcc_assert (GET_CODE (out_exp) == SET);
+
+            if (reg_mentioned_p (SET_DEST (out_exp), SET_DEST (in_set)))
+              return false;
+          }
+      }
+    }
+  else
+    {
+      in_pat = PATTERN (in_insn);
+      gcc_assert (GET_CODE (in_pat) == PARALLEL);
 
+      for (i = 0; i < XVECLEN (in_pat, 0); i++)
+	{
+	  in_exp = XVECEXP (in_pat, 0, i);
+
+	  if (GET_CODE (in_exp) == CLOBBER)
+	    continue;
+
+	  gcc_assert (GET_CODE (in_exp) == SET);
+
+	  if (!MEM_P (SET_DEST (in_exp)))
+	    return false;
+
+          out_set = single_set (out_insn);
+          if (out_set)
+            {
+              if (reg_mentioned_p (SET_DEST (out_set), SET_DEST (in_exp)))
+                return false;
+            }
+          else
+            {
               out_pat = PATTERN (out_insn);
               gcc_assert (GET_CODE (out_pat) == PARALLEL);
 
-      for (i = 0; i < XVECLEN (out_pat, 0); i++)
+              for (j = 0; j < XVECLEN (out_pat, 0); j++)
                 {
-	  rtx exp = XVECEXP (out_pat, 0, i);
+                  out_exp = XVECEXP (out_pat, 0, j);
 
-	  if (GET_CODE (exp) == CLOBBER)
+                  if (GET_CODE (out_exp) == CLOBBER)
                     continue;
 
-	  gcc_assert (GET_CODE (exp) == SET);
+                  gcc_assert (GET_CODE (out_exp) == SET);
 
-	  if (reg_mentioned_p (SET_DEST (exp), SET_DEST (in_set)))
+                  if (reg_mentioned_p (SET_DEST (out_exp), SET_DEST (in_exp)))
                     return false;
                 }
             }
+        }
+    }
 
   return true;
 }