re PR tree-optimization/47001 (segmentation fault in vect_mark_slp_stmts)

        PR tree-optimization/47001
        * tree-vect-slp.c (vect_supported_load_permutation_p): Check
        that the loads in reduction are different and there are no gaps
        between them.

From-SVN: r168123

gcc/ChangeLog

+2010-12-21  Ira Rosen  <irar@il.ibm.com>
+
+	PR tree-optimization/47001
+	* tree-vect-slp.c (vect_supported_load_permutation_p): Check that
+	the loads in reduction are different and there are no gaps between
+	them.
+
 2010-12-21  Steven Bosscher  <steven@gcc.gnu.org>
 
 	PR middle-end/45310

gcc/testsuite/ChangeLog

+2010-12-21  Ira Rosen  <irar@il.ibm.com>i
+
+	PR tree-optimization/47001
+	* gcc.dg/vect/pr47001.c: New.
+
 2010-12-21  Nicola Pero  <nicola.pero@meta-innovation.com>
 
 	PR libobjc/16110

gcc/testsuite/gcc.dg/vect/pr47001.c

+/* { dg-do compile } */
+
+#include <stdlib.h>
+
+#define N 128
+
+int a[N];
+
+int main1 (int res0, int res1)
+{
+  int i;
+  int sum0 = 0, sum1 = 0;
+
+  for (i = 0; i < N/2; i++) {
+    sum1 += a[2*i];
+    sum0 += a[2*i];
+  }
+
+  /* Check results:  */
+  if (sum0 != res0
+      || sum1 != res1)
+    abort ();
+
+  return 0;
+}
+
+/* { dg-final { cleanup-tree-dump "vect" } } */

gcc/tree-vect-slp.c

@@ -1002,7 +1002,36 @@ vect_supported_load_permutation_p (slp_instance slp_instn, int group_size,
 
       if (!bad_permutation)
         {
-          /* This permutaion is valid for reduction.  Since the order of the
+          /* Check that the loads in the first sequence are different and there
+             are no gaps between them.  */
+          load_index = sbitmap_alloc (group_size);
+          sbitmap_zero (load_index);
+          for (k = 0; k < group_size; k++)
+            {
+              first_group_load_index = VEC_index (int, load_permutation, k);
+              if (TEST_BIT (load_index, first_group_load_index))
+                {
+                  bad_permutation = true;
+                  break;
+                }
+
+              SET_BIT (load_index, first_group_load_index);
+            }
+
+          if (!bad_permutation)
+            for (k = 0; k < group_size; k++)
+              if (!TEST_BIT (load_index, k))
+                {
+                  bad_permutation = true;
+                  break;
+                }
+
+          sbitmap_free (load_index);
+        }
+
+      if (!bad_permutation)
+        {
+          /* This permutation is valid for reduction.  Since the order of the
              statements in the nodes is not important unless they are memory
              accesses, we can rearrange the statements in all the nodes 
              according to the order of the loads.  */