backport: re PR middle-end/66133 (Wrong-code with noreturn #pragma omp task body)

	Backported from mainline
	2015-05-13  Jakub Jelinek  <jakub@redhat.com>

	PR middle-end/66133
	* omp-low.c (expand_omp_taskreg): For GIMPLE_OMP_TASK expansion,
	make sure it is never noreturn, even when the task body does not
	return.
	(lower_omp_taskreg): For GIMPLE_OMP_TASK, emit GIMPLE_OMP_CONTINUE
	right before GIMPLE_OMP_RETURN.
	(make_gimple_omp_edges): Accept GIMPLE_OMP_CONTINUE as ->cont
	for GIMPLE_OMP_TASK.  For GIMPLE_OMP_RETURN corresponding to
	GIMPLE_OMP_TASK add an EDGE_ABNORMAL edge from entry to exit.

	* testsuite/libgomp.c/pr66133.c: New test.

From-SVN: r224093

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index cf6b60c4c2a085427c0a0a15127d53716422bbff..512d82789ee7184438bca99f8eb720314599fa4f 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,6 +1,18 @@
 2015-06-03  Jakub Jelinek  <jakub@redhat.com>
 
        Backported from mainline
+       2015-05-13  Jakub Jelinek  <jakub@redhat.com>
+
+       PR middle-end/66133
+       * omp-low.c (expand_omp_taskreg): For GIMPLE_OMP_TASK expansion,
+       make sure it is never noreturn, even when the task body does not
+       return.
+       (lower_omp_taskreg): For GIMPLE_OMP_TASK, emit GIMPLE_OMP_CONTINUE
+       right before GIMPLE_OMP_RETURN.
+       (make_gimple_omp_edges): Accept GIMPLE_OMP_CONTINUE as ->cont
+       for GIMPLE_OMP_TASK.  For GIMPLE_OMP_RETURN corresponding to
+       GIMPLE_OMP_TASK add an EDGE_ABNORMAL edge from entry to exit.
+
        2015-05-04  Jakub Jelinek  <jakub@redhat.com>
  
        PR tree-optimization/65984

diff --git a/gcc/omp-low.c b/gcc/omp-low.c
index f42c1d266cb5c5347852bbd2e9c2ec431e7b1a41..b6ddf4883cbc7736f77576ca908aeabc67a562d1 100644 (file)
--- a/gcc/omp-low.c
+++ b/gcc/omp-low.c
@@ -4786,7 +4786,10 @@ expand_omp_taskreg (struct omp_region *region)
   child_cfun = DECL_STRUCT_FUNCTION (child_fn);
 
   entry_bb = region->entry;
-  exit_bb = region->exit;
+  if (gimple_code (entry_stmt) == GIMPLE_OMP_TASK)
+    exit_bb = region->cont;
+  else
+    exit_bb = region->exit;
 
   if (is_combined_parallel (region))
     ws_args = region->ws_args;
@@ -4835,7 +4838,9 @@ expand_omp_taskreg (struct omp_region *region)
         variable.  In which case, we need to keep the assignment.  */
       if (gimple_omp_taskreg_data_arg (entry_stmt))
        {
-         basic_block entry_succ_bb = single_succ (entry_bb);
+         basic_block entry_succ_bb
+           = single_succ_p (entry_bb) ? single_succ (entry_bb)
+                                      : FALLTHRU_EDGE (entry_bb)->dest;
          gimple_stmt_iterator gsi;
          tree arg, narg;
          gimple parcopy_stmt = NULL;
@@ -4924,14 +4929,28 @@ expand_omp_taskreg (struct omp_region *region)
       gsi_remove (&gsi, true);
       e = split_block (entry_bb, stmt);
       entry_bb = e->dest;
-      single_succ_edge (entry_bb)->flags = EDGE_FALLTHRU;
+      edge e2 = NULL;
+      if (gimple_code (entry_stmt) == GIMPLE_OMP_PARALLEL)
+       single_succ_edge (entry_bb)->flags = EDGE_FALLTHRU;
+      else
+       {
+         e2 = make_edge (e->src, BRANCH_EDGE (entry_bb)->dest, EDGE_ABNORMAL);
+         gcc_assert (e2->dest == region->exit);
+         remove_edge (BRANCH_EDGE (entry_bb));
+         set_immediate_dominator (CDI_DOMINATORS, e2->dest, e->src);
+         gsi = gsi_last_bb (region->exit);
+         gcc_assert (!gsi_end_p (gsi)
+                     && gimple_code (gsi_stmt (gsi)) == GIMPLE_OMP_RETURN);
+         gsi_remove (&gsi, true);
+       }
 
-      /* Convert GIMPLE_OMP_RETURN into a RETURN_EXPR.  */
+      /* Convert GIMPLE_OMP_{RETURN,CONTINUE} into a RETURN_EXPR.  */
       if (exit_bb)
        {
          gsi = gsi_last_bb (exit_bb);
          gcc_assert (!gsi_end_p (gsi)
-                     && gimple_code (gsi_stmt (gsi)) == GIMPLE_OMP_RETURN);
+                     && (gimple_code (gsi_stmt (gsi))
+                         == (e2 ? GIMPLE_OMP_CONTINUE : GIMPLE_OMP_RETURN)));
          stmt = gimple_build_return (NULL);
          gsi_insert_after (&gsi, stmt, GSI_SAME_STMT);
          gsi_remove (&gsi, true);
@@ -4952,6 +4971,14 @@ expand_omp_taskreg (struct omp_region *region)
       new_bb = move_sese_region_to_fn (child_cfun, entry_bb, exit_bb, block);
       if (exit_bb)
        single_succ_edge (new_bb)->flags = EDGE_FALLTHRU;
+      if (e2)
+       {
+         basic_block dest_bb = e2->dest;
+         if (!exit_bb)
+           make_edge (new_bb, dest_bb, EDGE_FALLTHRU);
+         remove_edge (e2);
+         set_immediate_dominator (CDI_DOMINATORS, dest_bb, new_bb);
+       }
       /* When the OMP expansion process cannot guarantee an up-to-date
          loop tree arrange for the child function to fixup loops.  */
       if (loops_state_satisfies_p (LOOPS_NEED_FIXUP))
@@ -9701,6 +9728,10 @@ lower_omp_taskreg (gimple_stmt_iterator *gsi_p, omp_context *ctx)
     gimple_seq_add_stmt (&new_body, gimple_build_label (ctx->cancel_label));
   gimple_seq_add_seq (&new_body, par_olist);
   new_body = maybe_catch_exception (new_body);
+  if (gimple_code (stmt) == GIMPLE_OMP_TASK)
+    gimple_seq_add_stmt (&new_body,
+                        gimple_build_omp_continue (integer_zero_node,
+                                                   integer_zero_node));
   gimple_seq_add_stmt (&new_body, gimple_build_omp_return (false));
   gimple_omp_set_body (stmt, new_body);
 
@@ -10701,6 +10732,10 @@ make_gimple_omp_edges (basic_block bb, struct omp_region **region,
         somewhere other than the next block.  This will be
         created later.  */
       cur_region->exit = bb;
+      if (cur_region->type == GIMPLE_OMP_TASK)
+       /* Add an edge corresponding to not scheduling the task
+          immediately.  */
+       make_edge (cur_region->entry, bb, EDGE_ABNORMAL);
       fallthru = cur_region->type != GIMPLE_OMP_SECTION;
       cur_region = cur_region->outer;
       break;
@@ -10749,6 +10784,10 @@ make_gimple_omp_edges (basic_block bb, struct omp_region **region,
          }
          break;
 
+       case GIMPLE_OMP_TASK:
+         fallthru = true;
+         break;
+
        default:
          gcc_unreachable ();
        }

diff --git a/libgomp/ChangeLog b/libgomp/ChangeLog
index 2062d3c8cb8289eca618ba836fec4733e1e64786..a7b39c844b2aaa8d0d60420991c9c01f51d076f9 100644 (file)
--- a/libgomp/ChangeLog
+++ b/libgomp/ChangeLog
@@ -1,6 +1,11 @@
 2015-06-03  Jakub Jelinek  <jakub@redhat.com>
 
        Backported from mainline
+       2015-05-13  Jakub Jelinek  <jakub@redhat.com>
+
+       PR middle-end/66133
+       * testsuite/libgomp.c/pr66133.c: New test.
+
        2015-03-30  Jakub Jelinek  <jakub@redhat.com>
 
        PR fortran/65597

diff --git a/libgomp/testsuite/libgomp.c/pr66133.c b/libgomp/testsuite/libgomp.c/pr66133.c
new file mode 100644 (file)
index 0000000..e98e5aa
--- /dev/null
+++ b/libgomp/testsuite/libgomp.c/pr66133.c
@@ -0,0 +1,35 @@
+/* PR middle-end/66133 */
+/* { dg-do run } */
+/* { dg-options "-O2 -fopenmp" } */
+
+#include <stdlib.h>
+#include <unistd.h>
+
+volatile int x;
+
+__attribute__((noinline)) void
+foo (void)
+{
+  if (x == 0)
+    {
+      #pragma omp task
+       {
+         usleep (2000);
+         exit (0);
+       }
+    }
+  else
+    abort ();
+}
+
+int
+main ()
+{
+  #pragma omp parallel num_threads (2)
+    {
+      #pragma omp barrier
+      #pragma omp single
+       foo ();
+    }
+  exit (0);
+}