public inbox for fortran@gcc.gnu.org
 help / color / mirror / Atom feed
* [committed] openmp, fortran: Improve !$omp atomic checks [PR104328]
@ 2022-02-03  8:08 Jakub Jelinek
  0 siblings, 0 replies; only message in thread
From: Jakub Jelinek @ 2022-02-03  8:08 UTC (permalink / raw)
  To: gcc-patches, fortran; +Cc: Tobias Burnus

Hi!

The testcase shows some cases that weren't verified and we ICE on
invalid because of that.
One problem is that unlike before, we weren't checking if some expression
is EXPR_VARIABLE with non-NULL symtree in the case where there was
a conversion around it.
The other two issues is that we check that in an IF ->block is non-NULL
and then immediately dereference ->block->next->op, but on invalid
code with no statements in the then clause ->block->next might be NULL.

Bootstrapped/regtested on x86_64-linux and i686-linux, committed to
trunk.

2022-02-02  Jakub Jelinek  <jakub@redhat.com>

	PR fortran/104328
	* openmp.cc (is_scalar_intrinsic_expr): If must_be_var && conv_ok
	and expr is conversion, verify it is a conversion from EXPR_VARIABLE
	with non-NULL symtree.  Check ->block->next before dereferencing it.

	* gfortran.dg/gomp/atomic-27.f90: New test.

--- gcc/fortran/openmp.cc.jj	2022-01-21 11:01:12.458449420 +0100
+++ gcc/fortran/openmp.cc	2022-02-02 20:20:22.020000000 +0100
@@ -7660,9 +7660,16 @@ static bool
 is_scalar_intrinsic_expr (gfc_expr *expr, bool must_be_var, bool conv_ok)
 {
   if (must_be_var
-      && (expr->expr_type != EXPR_VARIABLE || !expr->symtree)
-      && (!conv_ok || !is_conversion (expr, true, true)))
-    return false;
+      && (expr->expr_type != EXPR_VARIABLE || !expr->symtree))
+    {
+      if (!conv_ok)
+	return false;
+      gfc_expr *conv = is_conversion (expr, true, true);
+      if (!conv)
+	return false;
+      if (conv->expr_type != EXPR_VARIABLE || !conv->symtree)
+	return false;
+    }
   return (expr->rank == 0
 	  && !gfc_is_coindexed (expr)
 	  && (expr->ts.type == BT_INTEGER
@@ -7705,6 +7712,7 @@ resolve_omp_atomic (gfc_code *code)
       if (next->op == EXEC_IF
 	  && next->block
 	  && next->block->op == EXEC_IF
+	  && next->block->next
 	  && next->block->next->op == EXEC_ASSIGN)
 	{
 	  comp_cond = next->block->expr1;
@@ -7757,6 +7765,7 @@ resolve_omp_atomic (gfc_code *code)
       if (code->op == EXEC_IF
 	  && code->block
 	  && code->block->op == EXEC_IF
+	  && code->block->next
 	  && code->block->next->op == EXEC_ASSIGN)
 	{
 	  comp_cond = code->block->expr1;
--- gcc/testsuite/gfortran.dg/gomp/atomic-27.f90.jj	2022-02-02 20:30:44.101437198 +0100
+++ gcc/testsuite/gfortran.dg/gomp/atomic-27.f90	2022-02-02 20:29:50.651217307 +0100
@@ -0,0 +1,34 @@
+! PR fortran/104328
+! { dg-do compile }
+
+subroutine foo
+  integer :: k = 1
+  !$omp atomic compare
+  if ( k == 2 ) then	! { dg-error "unexpected !.OMP ATOMIC expression" }
+  end if
+end
+subroutine bar
+  real :: x = 1
+  !$omp atomic compare
+  if ( x == 2 ) then	! { dg-error "unexpected !.OMP ATOMIC expression" }
+  end if
+end
+subroutine baz
+  integer :: i
+  !$omp atomic capture
+  i = 1
+  i = i + 1.		! { dg-error "!.OMP ATOMIC capture-statement requires a scalar variable of intrinsic type" }
+end
+subroutine qux
+  integer :: i = 0
+  !$omp atomic capture
+  i = i + 1.0
+  i = i + 1.0		! { dg-error "!.OMP ATOMIC capture-statement requires a scalar variable of intrinsic type" }
+end
+subroutine garply
+  logical :: k = .true.
+  !$omp atomic capture compare
+  if ( k ) then		! { dg-error "unexpected !.OMP ATOMIC expression" }
+  else
+  end if
+end


	Jakub


^ permalink raw reply	[flat|nested] only message in thread

only message in thread, other threads:[~2022-02-03  8:08 UTC | newest]

Thread overview: (only message) (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2022-02-03  8:08 [committed] openmp, fortran: Improve !$omp atomic checks [PR104328] Jakub Jelinek

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).