diff mbox series

OpenMP (C only): omp allocate - extend parsing support, improve diagnostic (was: [Patch] OpenMP (C only): omp allocate - handle stack vars, improve diagnostic)

Message ID e368e8e6-1032-2dca-4a73-7c556b10d7f7@codesourcery.com
State Unresolved
Headers
Series OpenMP (C only): omp allocate - extend parsing support, improve diagnostic (was: [Patch] OpenMP (C only): omp allocate - handle stack vars, improve diagnostic) |

Checks

Context Check Description
snail/gcc-patch-check warning Git am fail log

Commit Message

Tobias Burnus Sept. 11, 2023, 11:44 a.m. UTC 
  The patch adds more check and fixes some minor FE bits, but it now has a
'sorry' for automatic/stack variables in the middle end.

I think it is useful by itself as it completes the C FE part and adds
diagnostic, even if the actual code generation is disabled.

Comments, remarks, suggestions?

The actual code generation works fine (see previous patch) but it fails
with OpenMP privatization and mapping; I have locally an incomplete WIP
patch to fix this. But until it works, the 'sorry' makes more sense.
Besides solving that issue, C++ needs to be updated to be on par with C
and my (not yet posted) Fortran patch also needs some changes for the C
and ME changes.

Tobias
-----------------
Siemens Electronic Design Automation GmbH; Anschrift: Arnulfstraße 201, 80634 München; Gesellschaft mit beschränkter Haftung; Geschäftsführer: Thomas Heurung, Frank Thürauf; Sitz der Gesellschaft: München; Registergericht München, HRB 106955

Comments

Jakub Jelinek Sept. 11, 2023, 11:54 a.m. UTC | #1 
Hi!

One question to David below, CCed.

On Mon, Sep 11, 2023 at 01:44:07PM +0200, Tobias Burnus wrote:
> --- a/gcc/c/c-decl.cc
> +++ b/gcc/c/c-decl.cc
> @@ -681,6 +681,11 @@ decl_jump_unsafe (tree decl)
>    if (VAR_P (decl) && C_DECL_COMPOUND_LITERAL_P (decl))
>      return false;
>  
> +  if (flag_openmp
> +      && VAR_P (decl)
> +      && lookup_attribute ("omp allocate", DECL_ATTRIBUTES (decl)))
> +    return true;
> +
>    /* Always warn about crossing variably modified types.  */
>    if ((VAR_P (decl) || TREE_CODE (decl) == TYPE_DECL)
>        && c_type_variably_modified_p (TREE_TYPE (decl)))
> @@ -724,6 +729,12 @@ c_print_identifier (FILE *file, tree node, int indent)
>    c_binding_oracle = save;
>  }
>  

I think we want a function comment here.

> +void
> +c_mark_decl_jump_unsafe_in_current_scope ()
> +{
> +  current_scope->has_jump_unsafe_decl = 1;
> +}
> +
> +	  if (DECL_SOURCE_LOCATION (allocator) > DECL_SOURCE_LOCATION (var))
> +	    {
> +	      error_at (OMP_CLAUSE_LOCATION (nl),
> +			"allocator variable %qD must be declared before %qD",
> +			allocator, var);
> +	      inform (DECL_SOURCE_LOCATION (allocator), "declared here");
> +	      inform (DECL_SOURCE_LOCATION (var), "declared here");

I think this will be confusing to users when the inform is the same in both
cases.  I'd use "allocator declared here" in the first case.

And, am really not sure if one can just simply compare location_t like that.
Isn't there some function which determines what source location is before
another one?  David?

> +		 if (EXPR_LOCATION (*l) < DECL_SOURCE_LOCATION (var))
> +		   break;

Likewise.

> --- /dev/null
> +++ b/gcc/testsuite/c-c++-common/gomp/allocate-12.c
> @@ -0,0 +1,46 @@
> +/* TODO: enable for C++ once implemented. */
> +/* { dg-do compile { target c } } */
> +
> +typedef enum omp_allocator_handle_t

I think all the c-c++-common tests declaring
omp_allocator_handle_t should have
#if __cplusplus >= 201103L
: __UINTPTR_TYPE__
#endif
here (even if they are just { target c } for now, we'd certainly
forget to adjust them).


	Jakub
David Malcolm Sept. 11, 2023, 1:07 p.m. UTC | #2 
On Mon, 2023-09-11 at 13:54 +0200, Jakub Jelinek wrote:
> Hi!
> 
> One question to David below, CCed.
> 
> On Mon, Sep 11, 2023 at 01:44:07PM +0200, Tobias Burnus wrote:

[...]

> 
> > +
> > +         if (DECL_SOURCE_LOCATION (allocator) >
> > DECL_SOURCE_LOCATION (var))
> > +           {
> > +             error_at (OMP_CLAUSE_LOCATION (nl),
> > +                       "allocator variable %qD must be declared
> > before %qD",
> > +                       allocator, var);
> > +             inform (DECL_SOURCE_LOCATION (allocator), "declared
> > here");
> > +             inform (DECL_SOURCE_LOCATION (var), "declared here");
> 
> I think this will be confusing to users when the inform is the same
> in both
> cases.  I'd use "allocator declared here" in the first case.
> 
> And, am really not sure if one can just simply compare location_t
> like that.
> Isn't there some function which determines what source location is
> before
> another one?  David?

Indeed, the numerical ordering of location_t values doesn't fully
correspond to declaration order.

Please use
  linemap_compare_locations
or
  linemap_location_before_p

> 
> > +                if (EXPR_LOCATION (*l) < DECL_SOURCE_LOCATION
> > (var))
> > +                  break;
> 
> Likewise.
> 


Dave
>
Tobias Burnus Sept. 11, 2023, 1:21 p.m. UTC | #3 
Hi,

thanks for the comments and for the line-number thing. (I wanted to
re-check it myself but then totally forgot about it.)

Attached is the updated patch, fixing the line-number comparison, the
C++ addition to the enum decl in two of the testcases, and adding
"allocator" to the one inform (both to the code and to one testcase).

Tobias
-----------------
Siemens Electronic Design Automation GmbH; Anschrift: Arnulfstraße 201, 80634 München; Gesellschaft mit beschränkter Haftung; Geschäftsführer: Thomas Heurung, Frank Thürauf; Sitz der Gesellschaft: München; Registergericht München, HRB 106955
Jakub Jelinek Sept. 11, 2023, 1:34 p.m. UTC | #4 
On Mon, Sep 11, 2023 at 03:21:54PM +0200, Tobias Burnus wrote:
> +      if (TREE_STATIC (var))
> +	{
> +	  if (allocator == NULL_TREE && allocator_loc == UNKNOWN_LOCATION)
> +	    error_at (loc, "%<allocator%> clause required for "
> +			   "static variable %qD", var);
> +	  else if (allocator
> +		   && (tree_int_cst_sgn (allocator) != 1
> +		       || tree_to_shwi (allocator) > 8))

Has anything checked that in this case allocator is actually INTEGER_CST
which fits into shwi?  Otherwise tree_to_shwi will ICE.
Consider say allocator argument of
329857234985743598347598437598347594835743895743wb
or (((unsigned __int128) 0x123456789abcdef0) << 64)
Either tree_fits_shwi_p (allocator) check would do it, or perhaps
else if (allocator
	 && TREE_CODE (allocator) == INTEGER_CST
	 && wi::to_widest (allocator) > 0
	 && wi::to_widest (allocator) <= 8)
?

> +      if (allocator
> +	  && TREE_CODE (allocator) == VAR_DECL
> +	  && c_check_in_current_scope (var))
> +	{
> +	  if (linemap_location_before_p (line_table, DECL_SOURCE_LOCATION (var),
> +					 DECL_SOURCE_LOCATION (allocator)))
> +	    {
> +	      error_at (OMP_CLAUSE_LOCATION (nl),
> +			"allocator variable %qD must be declared before %qD",
> +			allocator, var);
> +	      inform (DECL_SOURCE_LOCATION (allocator),
> +		      "allocator declared here");
> +	      inform (DECL_SOURCE_LOCATION (var), "declared here");
> +	    }
> +	  else
> +	   {
> +	     gcc_assert (cur_stmt_list
> +			 && TREE_CODE (cur_stmt_list) == STATEMENT_LIST);
> +	     tree_stmt_iterator l = tsi_last (cur_stmt_list);
> +	     while (!tsi_end_p (l))
> +	       {
> +		 if (linemap_location_before_p (line_table, EXPR_LOCATION (*l),
> +						DECL_SOURCE_LOCATION (var)))
> +		   break;
> +		 if (TREE_CODE (*l) == MODIFY_EXPR
> +		     && TREE_OPERAND (*l, 0) == allocator)
> +		   {
> +		     error_at (EXPR_LOCATION (*l),
> +			       "allocator variable %qD, used in the "
> +			       "%<allocate%> directive for %qD, must not be "
> +			       "modified between declaration of %qD and its "
> +			       "%<allocate%> directive",
> +			       allocator, var, var);
> +		     inform (DECL_SOURCE_LOCATION (var), "declared here");
> +		     inform (OMP_CLAUSE_LOCATION (nl), "used here");
> +		     break;
> +		  }
> +		--l;
> +	     }
> +	   }

BTW, it doesn't necessarily have to be just the simple case which you catch
here, namely that allocator is a VAR_DECL defined after var in current
scope.
One can have an expression which uses those other vars, say
  int v;
  int a = 1;
  int b[n]; // VLA
  b[a] = 5;
  #pragma omp allocate (v) allocator (foo (a, &b[a]))
where foo would be some function which returns omp_allocator_handle_t.
Or it could be e.g. lambda declared later, etc.
I bet we can't catch everything, but perhaps e.g. doing the first
diagnostics from within walk_tree might be better.

	Jakub
Tobias Burnus Sept. 12, 2023, 7:04 a.m. UTC | #5 
Hi Jakub,

thanks for the further suggestions; updated patch attached.

On 11.09.23 15:34, Jakub Jelinek wrote:
> On Mon, Sep 11, 2023 at 03:21:54PM +0200, Tobias Burnus wrote:
>> +      if (TREE_STATIC (var))
>> +    {
>> +      if (allocator == NULL_TREE && allocator_loc == UNKNOWN_LOCATION)
>> +        error_at (loc, "%<allocator%> clause required for "
>> +                       "static variable %qD", var);
>> +      else if (allocator
>> +               && (tree_int_cst_sgn (allocator) != 1
>> +                   || tree_to_shwi (allocator) > 8))
> Has anything checked that in this case allocator is actually INTEGER_CST
> which fits into shwi?  Otherwise tree_to_shwi will ICE.
> Consider say allocator argument of
> 329857234985743598347598437598347594835743895743wb
> or (((unsigned __int128) 0x123456789abcdef0) << 64)
> Either tree_fits_shwi_p (allocator) check would do it, or perhaps
> else if (allocator
>        && TREE_CODE (allocator) == INTEGER_CST
>        && wi::to_widest (allocator) > 0
>        && wi::to_widest (allocator) <= 8)
> ?
I have now used the latter. Using _BitInt and __int128 fails because the
type-check fails. I have not added them to the testsuite as not all
targets support the two. Using a casted -1 did ICE before I used to
wi::to_widest.
>> +          error_at (OMP_CLAUSE_LOCATION (nl),
>> +                    "allocator variable %qD must be declared before %qD",
>> +                    allocator, var);
...
>> +                 error_at (EXPR_LOCATION (*l),
>> +                           "allocator variable %qD, used in the "
>> +                           "%<allocate%> directive for %qD, must not be "
>> +                           "modified between declaration of %qD and its "
>> +                           "%<allocate%> directive",
>> +                           allocator, var, var);
> BTW, it doesn't necessarily have to be just the simple case which you catch
> here, namely that allocator is a VAR_DECL defined after var in current
> scope.
...
> I bet we can't catch everything, but perhaps e.g. doing the first
> diagnostics from within walk_tree might be better.

Done now. What's not caught is, e.g., a value change by calling a
function which modifies its parameter:

omp_allocator_t a = ...; int v; foo(a); #pragma omp allocate(v) allocator(a)

as the current check is only whether 'a' is declared before 'v' or
whether 'a' is assigned to between v's declaration and the pragma.

Any additional comments or suggestions?

Tobias
-----------------
Siemens Electronic Design Automation GmbH; Anschrift: Arnulfstraße 201, 80634 München; Gesellschaft mit beschränkter Haftung; Geschäftsführer: Thomas Heurung, Frank Thürauf; Sitz der Gesellschaft: München; Registergericht München, HRB 106955
Jakub Jelinek Sept. 12, 2023, 7:15 a.m. UTC | #6 
On Tue, Sep 12, 2023 at 09:04:16AM +0200, Tobias Burnus wrote:
> Done now. What's not caught is, e.g., a value change by calling a
> function which modifies its parameter:
> 
> omp_allocator_t a = ...; int v; foo(a); #pragma omp allocate(v) allocator(a)
> 
> as the current check is only whether 'a' is declared before 'v' or
> whether 'a' is assigned to between v's declaration and the pragma.
> 
> Any additional comments or suggestions?

As I said, we can't catch all the mistakes, the unfortunate thing is that
the syntax allows them.  I'll try to make omp::decl attribute working soon
and that will make that problem less severe when using that syntax.

	Jakub
Tobias Burnus Sept. 12, 2023, 8:55 a.m. UTC | #7 
Seems as if I missed a 'git add -u' yesterday evening + missed this when
rechecking this morning.

Now included as separate patch :-/
Unless there are comments, I intent to commit it very soon.

Namely, the actual c-parse.cc update was missing and only the updated
tests were included. In particular missing:

On 12.09.23 09:04, Tobias Burnus wrote:
>>> +          error_at (OMP_CLAUSE_LOCATION (nl),
>>> +                    "allocator variable %qD must be declared before
>>> %qD",
>>> +                    allocator, var);
> ...
> ...
>> I bet we can't catch everything, but perhaps e.g. doing the first
>> diagnostics from within walk_tree might be better.
>
> Done now.

(Or only via the attach patch.)

Tobias
-----------------
Siemens Electronic Design Automation GmbH; Anschrift: Arnulfstraße 201, 80634 München; Gesellschaft mit beschränkter Haftung; Geschäftsführer: Thomas Heurung, Frank Thürauf; Sitz der Gesellschaft: München; Registergericht München, HRB 106955
diff mbox series

Patch

OpenMP (C only): omp allocate - extend parsing support, improve diagnostic

The 'allocate' directive can be used for both stack and static variables.
While the parser in C and C++ was pre-existing, it missed several
diagnostics, which this commit adds - for now only for C.

While the "sorry, unimplemented" for static variables is still issues
during parsing, the sorry for stack variables is now issued in the
middle end, preparing for the actual implementation. (Again: only for C.)

gcc/c/ChangeLog:

	* c-parser.cc (c_parser_omp_construct): Move call to
	c_parser_omp_allocate to ...
	(c_parser_pragma): ... here.
	(c_parser_omp_allocate): Avoid ICE is allocator could not be
	parsed; set 'omp allocate' attribute for stack/automatic variables
	and only reject static variables; add several additional
	restriction checks.
	* c-tree.h (c_mark_decl_jump_unsafe_in_current_scope): New prototype.
	* c-decl.cc (decl_jump_unsafe): Return true for omp-allocated decls.
	(c_mark_decl_jump_unsafe_in_current_scope): New.
	(warn_about_goto, c_check_switch_jump_warnings): Add error for
	omp-allocated decls.

gcc/ChangeLog:

	* gimplify.cc (gimplify_bind_expr): Check for
	insertion after variable cleanup.  Convert 'omp allocate'
	var-decl attribute to GOMP_alloc/GOMP_free calls.

gcc/testsuite/ChangeLog:

	* c-c++-common/gomp/allocate-5.c: Fix testcase; make some
	dg-messages for 'sorry' as c++, only.
	* c-c++-common/gomp/directive-1.c: Make a 'sorry' c++ only.
	* c-c++-common/gomp/allocate-9.c: New test.
	* c-c++-common/gomp/allocate-11.c: New test.
	* c-c++-common/gomp/allocate-12.c: New test.
	* c-c++-common/gomp/allocate-14.c: New test.
	* c-c++-common/gomp/allocate-15.c: New test.

 gcc/c/c-decl.cc                               |  23 ++++++
 gcc/c/c-parser.cc                             | 112 +++++++++++++++++++++++---
 gcc/c/c-tree.h                                |   1 +
 gcc/gimplify.cc                               |  40 +++++++++
 gcc/testsuite/c-c++-common/gomp/allocate-11.c |  40 +++++++++
 gcc/testsuite/c-c++-common/gomp/allocate-12.c |  46 +++++++++++
 gcc/testsuite/c-c++-common/gomp/allocate-14.c |  26 ++++++
 gcc/testsuite/c-c++-common/gomp/allocate-15.c |  28 +++++++
 gcc/testsuite/c-c++-common/gomp/allocate-5.c  |  60 +++++++-------
 gcc/testsuite/c-c++-common/gomp/allocate-9.c  |  96 ++++++++++++++++++++++
 gcc/testsuite/c-c++-common/gomp/directive-1.c |   2 +-
 11 files changed, 432 insertions(+), 42 deletions(-)

diff --git a/gcc/c/c-decl.cc b/gcc/c/c-decl.cc
index 649c5ae66c2..05fdb9240ae 100644
--- a/gcc/c/c-decl.cc
+++ b/gcc/c/c-decl.cc
@@ -681,6 +681,11 @@  decl_jump_unsafe (tree decl)
   if (VAR_P (decl) && C_DECL_COMPOUND_LITERAL_P (decl))
     return false;
 
+  if (flag_openmp
+      && VAR_P (decl)
+      && lookup_attribute ("omp allocate", DECL_ATTRIBUTES (decl)))
+    return true;
+
   /* Always warn about crossing variably modified types.  */
   if ((VAR_P (decl) || TREE_CODE (decl) == TYPE_DECL)
       && c_type_variably_modified_p (TREE_TYPE (decl)))
@@ -724,6 +729,12 @@  c_print_identifier (FILE *file, tree node, int indent)
   c_binding_oracle = save;
 }
 
+void
+c_mark_decl_jump_unsafe_in_current_scope ()
+{
+  current_scope->has_jump_unsafe_decl = 1;
+}
+
 /* Establish a binding between NAME, an IDENTIFIER_NODE, and DECL,
    which may be any of several kinds of DECL or TYPE or error_mark_node,
    in the scope SCOPE.  */
@@ -3974,6 +3985,9 @@  warn_about_goto (location_t goto_loc, tree label, tree decl)
   if (c_type_variably_modified_p (TREE_TYPE (decl)))
     error_at (goto_loc,
 	      "jump into scope of identifier with variably modified type");
+  else if (flag_openmp
+	   && lookup_attribute ("omp allocate", DECL_ATTRIBUTES (decl)))
+    error_at (goto_loc, "jump skips OpenMP %<allocate%> allocation");
   else
     if (!warning_at (goto_loc, OPT_Wjump_misses_init,
 		     "jump skips variable initialization"))
@@ -4253,6 +4267,15 @@  c_check_switch_jump_warnings (struct c_spot_bindings *switch_bindings,
 			     "variably modified type"));
 		  emitted = true;
 		}
+	      else if (flag_openmp
+		       && lookup_attribute ("omp allocate",
+					    DECL_ATTRIBUTES (b->decl)))
+		{
+		  saw_error = true;
+		  error_at (case_loc,
+			    "switch jumps over OpenMP %<allocate%> allocation");
+		  emitted = true;
+		}
 	      else
 		emitted
 		  = warning_at (case_loc, OPT_Wjump_misses_init,
diff --git a/gcc/c/c-parser.cc b/gcc/c/c-parser.cc
index c04962d67a4..fb4e69fffb7 100644
--- a/gcc/c/c-parser.cc
+++ b/gcc/c/c-parser.cc
@@ -1681,6 +1681,7 @@  static bool c_parser_omp_declare (c_parser *, enum pragma_context);
 static void c_parser_omp_requires (c_parser *);
 static bool c_parser_omp_error (c_parser *, enum pragma_context);
 static void c_parser_omp_assumption_clauses (c_parser *, bool);
+static void c_parser_omp_allocate (c_parser *);
 static void c_parser_omp_assumes (c_parser *);
 static bool c_parser_omp_ordered (c_parser *, enum pragma_context, bool *);
 static void c_parser_oacc_routine (c_parser *, enum pragma_context);
@@ -13649,6 +13650,10 @@  c_parser_pragma (c_parser *parser, enum pragma_context context, bool *if_p)
       c_parser_omp_requires (parser);
       return false;
 
+    case PRAGMA_OMP_ALLOCATE:
+      c_parser_omp_allocate (parser);
+      return false;
+
     case PRAGMA_OMP_ASSUMES:
       if (context != pragma_external)
 	{
@@ -19348,10 +19353,13 @@  c_parser_oacc_wait (location_t loc, c_parser *parser, char *p_name)
    align (constant-expression)]  */
 
 static void
-c_parser_omp_allocate (location_t loc, c_parser *parser)
+c_parser_omp_allocate (c_parser *parser)
 {
   tree alignment = NULL_TREE;
   tree allocator = NULL_TREE;
+  c_parser_consume_pragma (parser);
+  location_t loc = c_parser_peek_token (parser)->location;
+  location_t allocator_loc = UNKNOWN_LOCATION;
   tree nl = c_parser_omp_var_list_parens (parser, OMP_CLAUSE_ALLOCATE, NULL_TREE);
   do
     {
@@ -19376,7 +19384,9 @@  c_parser_omp_allocate (location_t loc, c_parser *parser)
       c_expr expr = c_parser_expr_no_commas (parser, NULL);
       expr = convert_lvalue_to_rvalue (expr_loc, expr, false, true);
       expr_loc = c_parser_peek_token (parser)->location;
-      if (p[2] == 'i' && alignment)
+      if (expr.value == error_mark_node)
+	;
+      else if (p[2] == 'i' && alignment)
 	{
 	  error_at (expr_loc, "too many %qs clauses", "align");
 	  break;
@@ -19403,6 +19413,7 @@  c_parser_omp_allocate (location_t loc, c_parser *parser)
       else
 	{
 	  allocator = c_fully_fold (expr.value, false, NULL);
+	  allocator_loc = expr_loc;
 	  tree orig_type
 	    = expr.original_type ? expr.original_type : TREE_TYPE (allocator);
 	  orig_type = TYPE_MAIN_VARIANT (orig_type);
@@ -19422,14 +19433,92 @@  c_parser_omp_allocate (location_t loc, c_parser *parser)
     } while (true);
   c_parser_skip_to_pragma_eol (parser);
 
-  if (allocator || alignment)
-    for (tree c = nl; c != NULL_TREE; c = OMP_CLAUSE_CHAIN (c))
-      {
-	OMP_CLAUSE_ALLOCATE_ALLOCATOR (c) = allocator;
-	OMP_CLAUSE_ALLOCATE_ALIGN (c) = alignment;
-      }
-
-  sorry_at (loc, "%<#pragma omp allocate%> not yet supported");
+  c_mark_decl_jump_unsafe_in_current_scope ();
+  for (tree c = nl; c != NULL_TREE; c = OMP_CLAUSE_CHAIN (c))
+    {
+      tree var = OMP_CLAUSE_DECL (c);
+      if (TREE_CODE (var) == PARM_DECL)
+	{
+	  error_at (OMP_CLAUSE_LOCATION (nl),
+		    "function parameter %qD may not appear as list item in an "
+		    "%<allocate%> directive", var);
+	  continue;
+	}
+      if (!c_check_in_current_scope (var))
+	{
+	  error_at (OMP_CLAUSE_LOCATION (nl),
+		    "%<allocate%> directive must be in the same scope as %qD",
+		    var);
+	  inform (DECL_SOURCE_LOCATION (var), "declared here");
+	  continue;
+	}
+      if (lookup_attribute ("omp allocate", DECL_ATTRIBUTES (var)))
+	{
+	  error_at (OMP_CLAUSE_LOCATION (nl),
+		    "%qD already appeared as list item in an "
+		    "%<allocate%> directive", var);
+	  continue;
+	}
+      if (TREE_STATIC (var))
+	{
+	  if (allocator == NULL_TREE && allocator_loc == UNKNOWN_LOCATION)
+	    error_at (loc, "%<allocator%> clause required for "
+			   "static variable %qD", var);
+	  else if (allocator
+		   && (tree_int_cst_sgn (allocator) != 1
+		       || tree_to_shwi (allocator) > 8))
+	    /* 8 = largest predefined memory allocator. */
+	    error_at (allocator_loc,
+		      "%<allocator%> clause requires a predefined allocator as "
+		      "%qD is static", var);
+	  else
+	    sorry_at (OMP_CLAUSE_LOCATION (nl),
+		      "%<#pragma omp allocate%> for static variables like "
+		      "%qD not yet supported", var);
+	  continue;
+	}
+      if (allocator
+	  && TREE_CODE (allocator) == VAR_DECL
+	  && c_check_in_current_scope (var))
+	{
+	  if (DECL_SOURCE_LOCATION (allocator) > DECL_SOURCE_LOCATION (var))
+	    {
+	      error_at (OMP_CLAUSE_LOCATION (nl),
+			"allocator variable %qD must be declared before %qD",
+			allocator, var);
+	      inform (DECL_SOURCE_LOCATION (allocator), "declared here");
+	      inform (DECL_SOURCE_LOCATION (var), "declared here");
+	    }
+	  else
+	   {
+	     gcc_assert (cur_stmt_list
+			 && TREE_CODE (cur_stmt_list) == STATEMENT_LIST);
+	     tree_stmt_iterator l = tsi_last (cur_stmt_list);
+	     while (!tsi_end_p (l))
+	       {
+		 if (EXPR_LOCATION (*l) < DECL_SOURCE_LOCATION (var))
+		   break;
+		 if (TREE_CODE (*l) == MODIFY_EXPR
+		     && TREE_OPERAND (*l, 0) == allocator)
+		   {
+		     error_at (EXPR_LOCATION (*l),
+			       "allocator variable %qD, used in the "
+			       "%<allocate%> directive for %qD, must not be "
+			       "modified between declaration of %qD and its "
+			       "%<allocate%> directive",
+			       allocator, var, var);
+		     inform (DECL_SOURCE_LOCATION (var), "declared here");
+		     inform (OMP_CLAUSE_LOCATION (nl), "used here");
+		     break;
+		  }
+		--l;
+	     }
+	   }
+	}
+      DECL_ATTRIBUTES (var) = tree_cons (get_identifier ("omp allocate"),
+					 build_tree_list (allocator, alignment),
+					 DECL_ATTRIBUTES (var));
+    }
 }
 
 /* OpenMP 2.5:
@@ -24926,9 +25015,6 @@  c_parser_omp_construct (c_parser *parser, bool *if_p)
       strcpy (p_name, "#pragma wait");
       stmt = c_parser_oacc_wait (loc, parser, p_name);
       break;
-    case PRAGMA_OMP_ALLOCATE:
-      c_parser_omp_allocate (loc, parser);
-      return;
     case PRAGMA_OMP_ATOMIC:
       c_parser_omp_atomic (loc, parser, false);
       return;
diff --git a/gcc/c/c-tree.h b/gcc/c/c-tree.h
index f928137c8d4..2664354337b 100644
--- a/gcc/c/c-tree.h
+++ b/gcc/c/c-tree.h
@@ -626,6 +626,7 @@  extern unsigned int start_underspecified_init (location_t, tree);
 extern void finish_underspecified_init (tree, unsigned int);
 extern void push_scope (void);
 extern tree pop_scope (void);
+extern void c_mark_decl_jump_unsafe_in_current_scope ();
 extern void c_bindings_start_stmt_expr (struct c_spot_bindings *);
 extern void c_bindings_end_stmt_expr (struct c_spot_bindings *);
 
diff --git a/gcc/gimplify.cc b/gcc/gimplify.cc
index a49b50bc857..a0e8cc2199d 100644
--- a/gcc/gimplify.cc
+++ b/gcc/gimplify.cc
@@ -1363,6 +1363,46 @@  gimplify_bind_expr (tree *expr_p, gimple_seq *pre_p)
       if (VAR_P (t))
 	{
 	  struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
+	  tree attr;
+
+	  if (flag_openmp
+	      && !is_global_var (t)
+	      && DECL_CONTEXT (t) == current_function_decl
+	      && TREE_USED (t)
+	      && (attr = lookup_attribute ("omp allocate", DECL_ATTRIBUTES (t)))
+		 != NULL_TREE)
+	    {
+	      tree alloc = TREE_PURPOSE (TREE_VALUE (attr));
+	      tree align = TREE_VALUE (TREE_VALUE (attr));
+	      /* Allocate directives that appear in a target region must specify
+		 an allocator clause unless a requires directive with the
+		 dynamic_allocators clause is present in the same compilation
+		 unit.  */
+	      bool missing_dyn_alloc = false;
+	      if (alloc == NULL_TREE
+		  && ((omp_requires_mask & OMP_REQUIRES_DYNAMIC_ALLOCATORS)
+		      == 0))
+		{
+		  /* This comes too early for omp_discover_declare_target...,
+		     but should at least catch the most common cases.  */
+		  missing_dyn_alloc
+		    = cgraph_node::get (current_function_decl)->offloadable;
+		  for (struct gimplify_omp_ctx *ctx2 = ctx;
+		       ctx2 && !missing_dyn_alloc; ctx2 = ctx2->outer_context)
+		    if (ctx2->code == OMP_TARGET)
+		      missing_dyn_alloc = true;
+		}
+	      if (missing_dyn_alloc)
+		error_at (DECL_SOURCE_LOCATION (t),
+			  "%<allocate%> directive for %qD inside a target "
+			  "region must specify an %<allocator%> clause", t);
+	      else if (align != NULL_TREE
+		       || alloc == NULL_TREE
+		       || !integer_onep (alloc))
+	        sorry_at (DECL_SOURCE_LOCATION (t),
+			  "OpenMP %<allocate%> directive, used for %qD, not "
+			  "yet supported", t);
+	    }
 
 	  /* Mark variable as local.  */
 	  if (ctx && ctx->region_type != ORT_NONE && !DECL_EXTERNAL (t))
diff --git a/gcc/testsuite/c-c++-common/gomp/allocate-11.c b/gcc/testsuite/c-c++-common/gomp/allocate-11.c
new file mode 100644
index 00000000000..f9ad50abb7f
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/gomp/allocate-11.c
@@ -0,0 +1,40 @@ 
+/* TODO: enable for C++ once implemented. */
+/* { dg-do compile { target c } } */
+
+void bar();
+void use (int*);
+
+void
+f (int i)
+{
+  switch (i)  /* { dg-note "switch starts here" } */
+    {
+      int j;  /* { dg-note "'j' declared here" } */
+      /* { dg-message "sorry, unimplemented: OpenMP 'allocate' directive" "" { target *-*-* } .-1 } */
+      #pragma omp allocate(j)
+    case 42:  /* { dg-error "switch jumps over OpenMP 'allocate' allocation" } */
+      bar ();
+      /* { dg-warning "statement will never be executed \\\[-Wswitch-unreachable\\\]" "" { target *-*-* } .-1 } */
+      break;
+    case 51:  /* { dg-error "switch jumps over OpenMP 'allocate' allocation" } */
+      use (&j);
+      break;
+    }
+}
+
+int
+h (int i2)
+{
+  if (i2 == 5)
+    goto label; /* { dg-error "jump skips OpenMP 'allocate' allocation" } */
+  return 5;
+
+  int k2;  /* { dg-note "'k2' declared here" } */
+  /* { dg-message "sorry, unimplemented: OpenMP 'allocate' directive" "" { target *-*-* } .-1 } */
+  int j2 = 4;  /* { dg-note "'j2' declared here" } */
+  /* { dg-message "sorry, unimplemented: OpenMP 'allocate' directive" "" { target *-*-* } .-1 } */
+  #pragma omp allocate(k2, j2)
+label:  /* { dg-note "label 'label' defined here" } */
+  k2 = 4;
+  return j2 + k2;
+}
diff --git a/gcc/testsuite/c-c++-common/gomp/allocate-12.c b/gcc/testsuite/c-c++-common/gomp/allocate-12.c
new file mode 100644
index 00000000000..aeb38547ba5
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/gomp/allocate-12.c
@@ -0,0 +1,46 @@ 
+/* TODO: enable for C++ once implemented. */
+/* { dg-do compile { target c } } */
+
+typedef enum omp_allocator_handle_t
+{
+  omp_default_mem_alloc = 1,
+  omp_low_lat_mem_alloc = 5,
+  __omp_allocator_handle_t_max__ = __UINTPTR_MAX__
+} omp_allocator_handle_t;
+
+int
+f ()
+{
+  omp_allocator_handle_t my_allocator;
+  int n = 5;  /* { dg-note "declared here" } */
+  my_allocator = omp_default_mem_alloc;  /* { dg-error "allocator variable 'my_allocator', used in the 'allocate' directive for 'n', must not be modified between declaration of 'n' and its 'allocate' directive" } */
+  /* { dg-message "sorry, unimplemented: OpenMP 'allocate' directive" "" { target *-*-* } .-2 } */
+  #pragma omp allocate(n) allocator(my_allocator)  /* { dg-note "used here" } */
+  n = 7;
+  return n;
+}
+
+
+int
+g ()
+{
+  int n = 5;  /* { dg-note "declared here" } */
+  /* { dg-message "sorry, unimplemented: OpenMP 'allocate' directive" "" { target *-*-* } .-1 } */
+  omp_allocator_handle_t my_allocator = omp_low_lat_mem_alloc;  /* { dg-note "declared here" } */
+  #pragma omp allocate(n) allocator(my_allocator)  /* { dg-error "allocator variable 'my_allocator' must be declared before 'n'" } */
+  n = 7;
+  return n;
+}
+
+int
+h ()
+{
+  /* my_allocator uninitialized - but only diagnosed in the ME with -Wuninitialized;
+     see gomp/allocate-10.c.  */
+  omp_allocator_handle_t my_allocator;
+  int n = 5;
+  /* { dg-message "sorry, unimplemented: OpenMP 'allocate' directive" "" { target *-*-* } .-1 } */
+  #pragma omp allocate(n) allocator(my_allocator)
+  n = 7;
+  return n;
+}
diff --git a/gcc/testsuite/c-c++-common/gomp/allocate-14.c b/gcc/testsuite/c-c++-common/gomp/allocate-14.c
new file mode 100644
index 00000000000..b25da5497c5
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/gomp/allocate-14.c
@@ -0,0 +1,26 @@ 
+/* TODO: enable for C++ once implemented. */
+/* { dg-do compile { target c } } */
+
+#pragma omp begin declare target
+void
+f ()
+{
+
+  int var;  /* { dg-error "'allocate' directive for 'var' inside a target region must specify an 'allocator' clause" } */
+  #pragma omp allocate(var)
+  var = 5;
+}
+#pragma omp end declare target
+
+void
+h ()
+{
+  #pragma omp target
+   #pragma omp parallel
+    #pragma omp serial
+     {
+       int var2[5];  /* { dg-error "'allocate' directive for 'var2' inside a target region must specify an 'allocator' clause" } */
+       #pragma omp allocate(var2)
+       var2[0] = 7;
+     }
+}
diff --git a/gcc/testsuite/c-c++-common/gomp/allocate-15.c b/gcc/testsuite/c-c++-common/gomp/allocate-15.c
new file mode 100644
index 00000000000..d9600f96c46
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/gomp/allocate-15.c
@@ -0,0 +1,28 @@ 
+/* TODO: enable for C++ once implemented. */
+/* { dg-do compile { target c } } */
+
+#pragma omp requires dynamic_allocators
+
+#pragma omp begin declare target
+void
+f ()
+{
+
+  int var;  /* { dg-message "sorry, unimplemented: OpenMP 'allocate' directive, used for 'var', not yet supported" } */
+  #pragma omp allocate(var)
+  var = 5;
+}
+#pragma omp end declare target
+
+void
+h ()
+{
+  #pragma omp target
+   #pragma omp parallel
+    #pragma omp serial
+     {
+       int var2[5];  /* { dg-message "sorry, unimplemented: OpenMP 'allocate' directive, used for 'var2', not yet supported" } */
+       #pragma omp allocate(var2)
+       var2[0] = 7;
+     }
+}
diff --git a/gcc/testsuite/c-c++-common/gomp/allocate-5.c b/gcc/testsuite/c-c++-common/gomp/allocate-5.c
index 8a9181205f7..2ca4786264f 100644
--- a/gcc/testsuite/c-c++-common/gomp/allocate-5.c
+++ b/gcc/testsuite/c-c++-common/gomp/allocate-5.c
@@ -18,60 +18,64 @@  typedef enum omp_allocator_handle_t
 void
 foo ()
 {
+  omp_allocator_handle_t my_allocator = omp_default_mem_alloc;
   int a, b;
-  omp_allocator_handle_t my_allocator;
-#pragma omp allocate (a)  /* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" } */
-#pragma omp allocate (b) allocator(my_allocator)  /* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" } */
+  static int c;
+#pragma omp allocate (a)  /* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target c++ } } */
+#pragma omp allocate (b) allocator(my_allocator)  /* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target c++ } } */
+#pragma omp allocate(c) align(32)
+  /* { dg-message "'allocator' clause required for static variable 'c'" "" { target c } .-1 } */
+  /* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target c++ } .-2 } */
 }
 
 void
 bar ()
 {
-  int a, b;
+  int a, a2, b;
   omp_allocator_handle_t my_allocator;
 #pragma omp allocate  /* { dg-error "expected '\\(' before end of line" } */
-  /* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target *-*-* } .-1 } */
+  /* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target c++ } .-1 } */
 #pragma omp allocate allocator(my_allocator)  /* { dg-error "expected '\\(' before 'allocator'" } */
-  /* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target *-*-* } .-1 } */
+  /* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target c++ } .-1 } */
 #pragma omp allocate(a) foo(my_allocator) /* { dg-error "expected 'allocator'" } */
   /* { dg-error "expected end of line before '\\(' token" "" { target *-*-* } .-1 } */
-  /* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target *-*-* } .-2 } */
-#pragma omp allocate(a) allocator(b)  /* { dg-error "'allocator' clause allocator expression has type 'int' rather than 'omp_allocator_handle_t'" "todo: cp/semantics.c" { xfail c++ } } */
-  /* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target *-*-* } .-1 } */
+  /* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target c++ } .-2 } */
+#pragma omp allocate(a2) allocator(b)  /* { dg-error "'allocator' clause allocator expression has type 'int' rather than 'omp_allocator_handle_t'" "todo: cp/semantics.c" { xfail c++ } } */
+  /* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target c++ } .-1 } */
 }
 
 
 void
 align_test ()
 {
-  int i;
-  #pragma omp allocate(i) allocator(omp_default_mem_alloc), align(32)
-  /* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target *-*-* } .-1 } */
-  #pragma omp allocate(i) align ( 32 ),allocator(omp_default_mem_alloc)
-  /* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target *-*-* } .-1 } */
-  #pragma omp allocate(i),allocator(omp_default_mem_alloc) align(32)
-  /* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target *-*-* } .-1 } */
-  #pragma omp allocate(i) align ( 32 ) allocator(omp_default_mem_alloc)
-  /* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target *-*-* } .-1 } */
+  int i1,i2,i3,i4,i5,i6;
+  #pragma omp allocate(i1) allocator(omp_default_mem_alloc), align(32)
+  /* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target c++ } .-1 } */
+  #pragma omp allocate(i2) align ( 32 ),allocator(omp_default_mem_alloc)
+  /* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target c++ } .-1 } */
+  #pragma omp allocate(i3),allocator(omp_default_mem_alloc) align(32)
+  /* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target c++ } .-1 } */
+  #pragma omp allocate(i4) align ( 32 ) allocator(omp_default_mem_alloc)
+  /* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target c++ } .-1 } */
 
-  #pragma omp allocate(i) allocator ( omp_high_bw_mem_alloc ), align ( 32 ) allocator(omp_default_mem_alloc)
+  #pragma omp allocate(i5) allocator ( omp_high_bw_mem_alloc ), align ( 32 ) allocator(omp_default_mem_alloc)
   /* { dg-error "too many 'allocator' clauses" "" { target *-*-* } .-1 } */
   /* { dg-error "expected end of line before '\\)' token" "" { target *-*-* } .-2 } */
-  /* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target *-*-* } .-3 } */
-  #pragma omp allocate(i) align ( 32 ), align(32) allocator(omp_default_mem_alloc)
+  /* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target c++ } .-3 } */
+  #pragma omp allocate(i6) align ( 32 ), align(32) allocator(omp_default_mem_alloc)
   /* { dg-error "too many 'align' clauses" "" { target *-*-* } .-1 } */
   /* { dg-error "expected end of line before '\\)' token" "" { target *-*-* } .-2 } */
-  /* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target *-*-* } .-3 } */
+  /* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target c++ } .-3 } */
 }
 
 void
 align_test2 ()
 {
-  int i;
+  int i, i2,i3;
   #pragma omp allocate(i) align (32.0)  /* { dg-error "'align' clause argument needs to be positive constant power of two integer expression" } */
-  /* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target *-*-* } .-1 } */
-  #pragma omp allocate(i) align ( 31 )  /* { dg-error "'align' clause argument needs to be positive constant power of two integer expression" } */
-  /* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target *-*-* } .-1 } */
-  #pragma omp allocate(i) align ( -32 )  /* { dg-error "'align' clause argument needs to be positive constant power of two integer expression" } */
-  /* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target *-*-* } .-1 } */
+  /* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target c++ } .-1 } */
+  #pragma omp allocate(i2) align ( 31 )  /* { dg-error "'align' clause argument needs to be positive constant power of two integer expression" } */
+  /* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target c++ } .-1 } */
+  #pragma omp allocate(i3) align ( -32 )  /* { dg-error "'align' clause argument needs to be positive constant power of two integer expression" } */
+  /* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target c++ } .-1 } */
 }
diff --git a/gcc/testsuite/c-c++-common/gomp/allocate-9.c b/gcc/testsuite/c-c++-common/gomp/allocate-9.c
new file mode 100644
index 00000000000..6b2b9bfb6b5
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/gomp/allocate-9.c
@@ -0,0 +1,96 @@ 
+typedef enum omp_allocator_handle_t
+{
+  omp_null_allocator = 0,
+  omp_default_mem_alloc = 1,
+  omp_large_cap_mem_alloc = 2,
+  omp_const_mem_alloc = 3,
+  omp_high_bw_mem_alloc = 4,
+  omp_low_lat_mem_alloc = 5,
+  omp_cgroup_mem_alloc = 6,
+  omp_pteam_mem_alloc = 7,
+  omp_thread_mem_alloc = 8,
+  __ompx_last_mem_alloc = omp_thread_mem_alloc,
+  __omp_allocator_handle_t_max__ = __UINTPTR_MAX__
+} omp_allocator_handle_t;
+
+
+static int A[5] = {1,2,3,4,5};
+int B, C, D;
+
+/* If the following fails bacause of added predefined allocators, please update
+   - c/c-parser.c's c_parser_omp_allocate
+   - fortran/openmp.cc's is_predefined_allocator
+   - libgomp/env.c's parse_allocator
+   - libgomp/libgomp.texi (document the new values - multiple locations)
+   + ensure that the memory-spaces are also up to date. */
+
+#pragma omp allocate(A) align(32) allocator((omp_allocator_handle_t) 9) /* { dg-error "'allocator' clause requires a predefined allocator as 'A' is static" "" { xfail c++ } } */
+/* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target c++ } .-1 } */
+
+
+// typo in allocator name:
+#pragma omp allocate(A) allocator(omp_low_latency_mem_alloc)
+/* { dg-error "'omp_low_latency_mem_alloc' undeclared here \\(not in a function\\); did you mean 'omp_low_lat_mem_alloc'\\?" "" { target c } .-1 } */
+/* { dg-error "'omp_low_latency_mem_alloc' was not declared in this scope; did you mean 'omp_low_lat_mem_alloc'\\?" "" { target c++ } .-2 } */
+/* { dg-error "'allocator' clause required for static variable 'A'" "" { target c } .-3 } */
+/* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target c++ } .-4 } */
+
+/* align be const multiple of 2 */
+#pragma omp allocate(A) align(31) allocator(omp_default_mem_alloc) /* { dg-error "'align' clause argument needs to be positive constant power of two integer expression" } */
+/* { dg-message "sorry, unimplemented: '#pragma omp allocate' for static variables like 'A' not yet supported" "" { target c } .-1 } */
+/* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target c++ } .-2 } */
+
+/* allocator missing (required as A is static) */
+#pragma omp allocate(A) align(32) /* { dg-error "'allocator' clause required for static variable 'A'" "" { xfail c++ } } */
+/* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target c++ } .-1 } */
+
+/* "expression in the clause must be a constant expression that evaluates to one of the
+   predefined memory allocator values -> omp_low_lat_mem_alloc"  */
+#pragma omp allocate(B) allocator((omp_allocator_handle_t) (omp_high_bw_mem_alloc+1)) align(32) /* OK: omp_low_lat_mem_alloc */
+/* { dg-message "sorry, unimplemented: '#pragma omp allocate' for static variables like 'B' not yet supported" "" { target c } .-1 } */
+/* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target c++ } .-2 } */
+
+#pragma omp allocate(C) allocator((omp_allocator_handle_t) 2) /* OK: omp_large_cap_mem_alloc */
+/* { dg-message "sorry, unimplemented: '#pragma omp allocate' for static variables like 'C' not yet supported" "" { target c } .-1 } */
+/* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target c++ } .-2 } */
+
+#pragma omp allocate(A) align(32) allocator(omp_null_allocator) /* { dg-error "'allocator' clause requires a predefined allocator as 'A' is static" "" { xfail c++ } } */
+/* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target c++ } .-1 } */
+
+#pragma omp allocate(C) align(32) allocator(omp_large_cap_mem_alloc)  /* { dg-error "'C' already appeared as list item in an 'allocate' directive" "" { xfail *-*-* } } */
+/* { dg-message "sorry, unimplemented: '#pragma omp allocate' for static variables like 'C' not yet supported" "" { target c } .-1 } */
+/* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target c++ } .-2 } */
+
+// allocate directive in same TU
+int f()
+{
+  #pragma omp allocate(D) align(32) allocator(omp_large_cap_mem_alloc) /* { dg-error "'allocate' directive must be in the same scope as 'D'" "" { xfail c++ } } */
+/* { dg-note "declared here" "" { target c } 18 } */
+/* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target c++ } .-2 } */
+  return A[0];
+}
+
+int g()
+{
+  int a2=1, b2=2;
+  #pragma omp allocate(a2)
+/* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target c++ } .-1 } */
+  #pragma omp allocate(a2)  /* { dg-error "'a2' already appeared as list item in an 'allocate' directive" "" { xfail c++ } } */
+/* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target c++ } .-1 } */
+  {
+    int c2=3;
+    #pragma omp allocate(c2, b2) /* { dg-error "'allocate' directive must be in the same scope as 'b2'" "" { xfail c++ } } */
+/* { dg-note "declared here" "" { target c } .-8 } */
+/* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target c++ } .-2 } */
+    return c2+a2+b2;
+  /* { dg-message "sorry, unimplemented: OpenMP 'allocate' directive" "" { target c } .-5 } */
+  /* { dg-message "sorry, unimplemented: OpenMP 'allocate' directive" "" { target c } .-12 } */
+  }
+}
+
+int h(int q)
+{
+  #pragma omp allocate(q)  /* { dg-error "function parameter 'q' may not appear as list item in an 'allocate' directive" "" { xfail c++ } } */
+/* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target c++ } .-1 } */
+  return q;
+}
diff --git a/gcc/testsuite/c-c++-common/gomp/directive-1.c b/gcc/testsuite/c-c++-common/gomp/directive-1.c
index fc441538778..21ca319b9f9 100644
--- a/gcc/testsuite/c-c++-common/gomp/directive-1.c
+++ b/gcc/testsuite/c-c++-common/gomp/directive-1.c
@@ -19,7 +19,7 @@  foo (void)
   int i, k = 0, l = 0;
   #pragma omp allocate, (i)			/* { dg-error "expected '\\\(' before ',' token" } */
 						/* { dg-error "expected end of line before ',' token" "" { target c++ } .-1 } */
-						/* { dg-message "not yet supported" "" { target *-*-* } .-2 } */
+						/* { dg-message "not yet supported" "" { target c++ } .-2 } */
   #pragma omp critical, (bar)			/* { dg-error "expected an OpenMP clause before '\\\(' token" } */
   ;
   #pragma omp flush, (k, l)			/* { dg-error "expected '\\\(' or end of line before ',' token" "" { target c } } */