re PR middle-end/56883 (error openmp parallel for order)

	PR middle-end/56883
	* omp-low.c (expand_omp_for_generic, expand_omp_for_static_nochunk,
	expand_omp_for_static_chunk): Use simple_p = true in
	force_gimple_operand_gsi calls when assigning to addressable decls.

	* c-c++-common/gomp/pr56883.c: New test.

From-SVN: r197633

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index cd67f96f7cd50913ad13eda428ffe7a3c1c8aaf8..69cefc06f204ded1504e408adf4c1b6868dbce39 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,10 @@
+2013-04-09  Jakub Jelinek  <jakub@redhat.com>
+
+       PR middle-end/56883
+       * omp-low.c (expand_omp_for_generic, expand_omp_for_static_nochunk,
+       expand_omp_for_static_chunk): Use simple_p = true in
+       force_gimple_operand_gsi calls when assigning to addressable decls.
+
 2013-04-09  Jeff Law  <law@redhat.com>
 
        * tree-vrp.c (simplify_cond_using_ranges): Simplify test of boolean

diff --git a/gcc/omp-low.c b/gcc/omp-low.c
index ef4ed5e98ace39690d798e633830937ea09d64a6..3e519db79b67987e8ef302166a016e7a92c3cb75 100644 (file)
--- a/gcc/omp-low.c
+++ b/gcc/omp-low.c
@@ -3920,8 +3920,10 @@ expand_omp_for_generic (struct omp_region *region,
   if (POINTER_TYPE_P (type))
     t = fold_convert (signed_type_for (type), t);
   t = fold_convert (type, t);
-  t = force_gimple_operand_gsi (&gsi, t, false, NULL_TREE,
-                               false, GSI_CONTINUE_LINKING);
+  t = force_gimple_operand_gsi (&gsi, t,
+                               DECL_P (fd->loop.v)
+                               && TREE_ADDRESSABLE (fd->loop.v),
+                               NULL_TREE, false, GSI_CONTINUE_LINKING);
   stmt = gimple_build_assign (fd->loop.v, t);
   gsi_insert_after (&gsi, stmt, GSI_CONTINUE_LINKING);
 
@@ -3952,8 +3954,11 @@ expand_omp_for_generic (struct omp_region *region,
            t = fold_build_pointer_plus (fd->loops[i].n1, t);
          else
            t = fold_build2 (PLUS_EXPR, itype, fd->loops[i].n1, t);
-         t = force_gimple_operand_gsi (&gsi, t, false, NULL_TREE,
-                                       false, GSI_CONTINUE_LINKING);
+         t = force_gimple_operand_gsi (&gsi, t,
+                                       DECL_P (fd->loops[i].v)
+                                       && TREE_ADDRESSABLE (fd->loops[i].v),
+                                       NULL_TREE, false,
+                                       GSI_CONTINUE_LINKING);
          stmt = gimple_build_assign (fd->loops[i].v, t);
          gsi_insert_after (&gsi, stmt, GSI_CONTINUE_LINKING);
          if (i != 0)
@@ -3981,12 +3986,15 @@ expand_omp_for_generic (struct omp_region *region,
        t = fold_build_pointer_plus (vmain, fd->loop.step);
       else
        t = fold_build2 (PLUS_EXPR, type, vmain, fd->loop.step);
-      t = force_gimple_operand_gsi (&gsi, t, false, NULL_TREE,
-                                   true, GSI_SAME_STMT);
+      t = force_gimple_operand_gsi (&gsi, t,
+                                   DECL_P (vback) && TREE_ADDRESSABLE (vback),
+                                   NULL_TREE, true, GSI_SAME_STMT);
       stmt = gimple_build_assign (vback, t);
       gsi_insert_before (&gsi, stmt, GSI_SAME_STMT);
 
-      t = build2 (fd->loop.cond_code, boolean_type_node, vback, iend);
+      t = build2 (fd->loop.cond_code, boolean_type_node,
+                 DECL_P (vback) && TREE_ADDRESSABLE (vback) ? t : vback,
+                 iend);
       stmt = gimple_build_cond_empty (t);
       gsi_insert_before (&gsi, stmt, GSI_SAME_STMT);
 
@@ -4011,8 +4019,12 @@ expand_omp_for_generic (struct omp_region *region,
                  e->probability = REG_BR_PROB_BASE / 8;
 
                  t = fd->loops[i + 1].n1;
-                 t = force_gimple_operand_gsi (&gsi, t, false, NULL_TREE,
-                                               false, GSI_CONTINUE_LINKING);
+                 t = force_gimple_operand_gsi (&gsi, t,
+                                               DECL_P (fd->loops[i + 1].v)
+                                               && TREE_ADDRESSABLE
+                                                       (fd->loops[i + 1].v),
+                                               NULL_TREE, false,
+                                               GSI_CONTINUE_LINKING);
                  stmt = gimple_build_assign (fd->loops[i + 1].v, t);
                  gsi_insert_after (&gsi, stmt, GSI_CONTINUE_LINKING);
                }
@@ -4026,8 +4038,11 @@ expand_omp_for_generic (struct omp_region *region,
              else
                t = fold_build2 (PLUS_EXPR, vtype, fd->loops[i].v,
                                 fd->loops[i].step);
-             t = force_gimple_operand_gsi (&gsi, t, false, NULL_TREE,
-                                           false, GSI_CONTINUE_LINKING);
+             t = force_gimple_operand_gsi (&gsi, t,
+                                           DECL_P (fd->loops[i].v)
+                                           && TREE_ADDRESSABLE (fd->loops[i].v),
+                                           NULL_TREE, false,
+                                           GSI_CONTINUE_LINKING);
              stmt = gimple_build_assign (fd->loops[i].v, t);
              gsi_insert_after (&gsi, stmt, GSI_CONTINUE_LINKING);
 
@@ -4036,8 +4051,12 @@ expand_omp_for_generic (struct omp_region *region,
                  t = fd->loops[i].n2;
                  t = force_gimple_operand_gsi (&gsi, t, true, NULL_TREE,
                                                false, GSI_CONTINUE_LINKING);
+                 tree v = fd->loops[i].v;
+                 if (DECL_P (v) && TREE_ADDRESSABLE (v))
+                   v = force_gimple_operand_gsi (&gsi, v, true, NULL_TREE,
+                                                 false, GSI_CONTINUE_LINKING);
                  t = fold_build2 (fd->loops[i].cond_code, boolean_type_node,
-                                  fd->loops[i].v, t);
+                                  v, t);
                  stmt = gimple_build_cond_empty (t);
                  gsi_insert_after (&gsi, stmt, GSI_CONTINUE_LINKING);
                  e = make_edge (bb, l1_bb, EDGE_TRUE_VALUE);
@@ -4273,8 +4292,10 @@ expand_omp_for_static_nochunk (struct omp_region *region,
     t = fold_build_pointer_plus (fd->loop.n1, t);
   else
     t = fold_build2 (PLUS_EXPR, type, t, fd->loop.n1);
-  t = force_gimple_operand_gsi (&gsi, t, false, NULL_TREE,
-                               false, GSI_CONTINUE_LINKING);
+  t = force_gimple_operand_gsi (&gsi, t,
+                               DECL_P (fd->loop.v)
+                               && TREE_ADDRESSABLE (fd->loop.v),
+                               NULL_TREE, false, GSI_CONTINUE_LINKING);
   stmt = gimple_build_assign (fd->loop.v, t);
   gsi_insert_after (&gsi, stmt, GSI_CONTINUE_LINKING);
 
@@ -4299,12 +4320,14 @@ expand_omp_for_static_nochunk (struct omp_region *region,
     t = fold_build_pointer_plus (vmain, fd->loop.step);
   else
     t = fold_build2 (PLUS_EXPR, type, vmain, fd->loop.step);
-  t = force_gimple_operand_gsi (&gsi, t, false, NULL_TREE,
-                               true, GSI_SAME_STMT);
+  t = force_gimple_operand_gsi (&gsi, t,
+                               DECL_P (vback) && TREE_ADDRESSABLE (vback),
+                               NULL_TREE, true, GSI_SAME_STMT);
   stmt = gimple_build_assign (vback, t);
   gsi_insert_before (&gsi, stmt, GSI_SAME_STMT);
 
-  t = build2 (fd->loop.cond_code, boolean_type_node, vback, e);
+  t = build2 (fd->loop.cond_code, boolean_type_node,
+             DECL_P (vback) && TREE_ADDRESSABLE (vback) ? t : vback, e);
   gsi_insert_before (&gsi, gimple_build_cond_empty (t), GSI_SAME_STMT);
 
   /* Remove the GIMPLE_OMP_CONTINUE statement.  */
@@ -4504,8 +4527,10 @@ expand_omp_for_static_chunk (struct omp_region *region, struct omp_for_data *fd)
     t = fold_build_pointer_plus (fd->loop.n1, t);
   else
     t = fold_build2 (PLUS_EXPR, type, t, fd->loop.n1);
-  t = force_gimple_operand_gsi (&si, t, false, NULL_TREE,
-                               false, GSI_CONTINUE_LINKING);
+  t = force_gimple_operand_gsi (&si, t,
+                               DECL_P (fd->loop.v)
+                               && TREE_ADDRESSABLE (fd->loop.v),
+                               NULL_TREE, false, GSI_CONTINUE_LINKING);
   stmt = gimple_build_assign (fd->loop.v, t);
   gsi_insert_after (&si, stmt, GSI_CONTINUE_LINKING);
 
@@ -4530,10 +4555,15 @@ expand_omp_for_static_chunk (struct omp_region *region, struct omp_for_data *fd)
     t = fold_build_pointer_plus (v_main, fd->loop.step);
   else
     t = fold_build2 (PLUS_EXPR, type, v_main, fd->loop.step);
+  if (DECL_P (v_back) && TREE_ADDRESSABLE (v_back))
+    t = force_gimple_operand_gsi (&si, t, true, NULL_TREE,
+                                 true, GSI_SAME_STMT);
   stmt = gimple_build_assign (v_back, t);
   gsi_insert_before (&si, stmt, GSI_SAME_STMT);
 
-  t = build2 (fd->loop.cond_code, boolean_type_node, v_back, e);
+  t = build2 (fd->loop.cond_code, boolean_type_node,
+             DECL_P (v_back) && TREE_ADDRESSABLE (v_back)
+             ? t : v_back, e);
   gsi_insert_before (&si, gimple_build_cond_empty (t), GSI_SAME_STMT);
 
   /* Remove GIMPLE_OMP_CONTINUE.  */

diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
index ebdabc17e701beaff06bec780faef6d7d0972a94..f53c0d322c4511a52f5649fdda298741d24008bb 100644 (file)
--- a/gcc/testsuite/ChangeLog
+++ b/gcc/testsuite/ChangeLog
@@ -1,3 +1,8 @@
+2013-04-09  Jakub Jelinek  <jakub@redhat.com>
+
+       PR middle-end/56883
+       * c-c++-common/gomp/pr56883.c: New test.
+
 2013-04-09  Jeff Law  <law@redhat.com>
 
        * gcc.dg/tree-ssa/vrp87.c: New test.

diff --git a/gcc/testsuite/c-c++-common/gomp/pr56883.c b/gcc/testsuite/c-c++-common/gomp/pr56883.c
new file mode 100644 (file)
index 0000000..443906d
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/gomp/pr56883.c
@@ -0,0 +1,57 @@
+/* PR middle-end/56883 */
+/* { dg-do compile }
+/* { dg-options "-O2 -fopenmp" } */
+
+void
+f1 (int ***x)
+{
+  int i, j, k;
+#pragma omp parallel for
+  for (i = 0; i < 10; ++i)
+    {
+    #pragma omp parallel shared(j)
+      #pragma omp for
+       for (j = 0; j < 10; ++j)
+         {
+         #pragma omp parallel for
+             for (k = 0; k < 10; ++k)
+               x[i][j][k] = k;
+         }
+    }
+}
+
+void
+f2 (int ***x)
+{
+  int i, j, k;
+#pragma omp parallel for schedule(static,1)
+  for (i = 0; i < 10; ++i)
+    {
+    #pragma omp parallel shared(j)
+      #pragma omp for schedule(static,1)
+       for (j = 0; j < 10; ++j)
+         {
+         #pragma omp parallel for schedule(static,1)
+             for (k = 0; k < 10; ++k)
+               x[i][j][k] = k;
+         }
+    }
+}
+
+void
+f3 (int ***x)
+{
+  int i, j, k;
+#pragma omp parallel for schedule(runtime)
+  for (i = 0; i < 10; ++i)
+    {
+    #pragma omp parallel shared(j)
+      #pragma omp for schedule(runtime)
+       for (j = 0; j < 10; ++j)
+         {
+         #pragma omp parallel for schedule(runtime)
+             for (k = 0; k < 10; ++k)
+               x[i][j][k] = k;
+         }
+    }
+}