[flang]Add Parser Support for OpenMP Allocate Directive

[Rin]

Summary

This patch adds the Allocate Directive to the parser definition.

The OpenMP standard specifies that that the allocate directive is a declarative directive if it is not associated with an allocation statement, in which case it is executable.

OpenMP 5.0 standard specification: Section 2.11.3 Allocate Directive https://www.openmp.org/wp-content/uploads/OpenMP-API-Specification-5.0.pdf

[Rin]

clang-format

[Rin]

flang/include/flang/Parser/parse-tree.h

3625

The Allocate Directive can take the Allocator Clause as its only clause, but that clause doesn't seem to have been implemented yet. Should I add it myself before going forward with this patch or can this be done at a later time?

[kiranchandramohan]

Can you provide more information about the allocate directive in the summary/description of this patch?
-> Point to the section in the standard.
-> Explain that the standard specifies a declarative and executable version.

Also add tests for the executable version as well. Have both of them in the same test to show that the parser is not confused.
Add unparse tests for both versions.

flang/include/flang/Parser/parse-tree.h

3625

Yes, add that also.

[Rin]

Add Allocator Clause, Additional Tests and make the OmpObjectList optional for the Executable Allocate Clause

[clementval]

flang/include/flang/Parser/parse-tree.h

3628

You should use the OmpClauseList and let the semantic check do the work. Otherwise each directive will have there own parser for theirs associated directive and this duplicates the code a lot.

OMP.td is already good for this directive.

def OMP_Allocate : Directive<"allocate"> {
  let allowedClauses = [
    VersionedClause<OMPC_Allocator>
  ];
}

flang/lib/Parser/openmp-parsers.cpp

482

You should re-use OmpClause parser instead of duplicating the parsing. If it's not in the OmpClause parser, just add it there.

494

Same here for the parser.

[Rin]

Address review comments

[Rin]

flang/include/flang/Parser/parse-tree.h

3628

Thanks for that. I'll make sure to do so.

[clementval]

flang/include/flang/Parser/dump-parse-tree.h

553

Any reason to keep this?

561

Any reason to keep this?

flang/test/Parser/omp-allocate-unparse.f90

27 ↗

(On Diff #300983)

Newline.

[Rin]

flang/include/flang/Parser/dump-parse-tree.h

553

None other than the fact that I didn't notice it when I was cleaning up the code. Really sorry about that. Will remove it straight away. Same for the other one.

[Rin]

Remove unnecessary comment and add newline to test

[Rin]

Does this look okay @clementval ?

[kiranchandramohan]

flang/lib/Parser/openmp-parsers.cpp

476

The standard supports a list of openmp allocates associated with a single fortran allocate. Can you extend this to include the list?

!$omp allocate[(list)] clause
[!$omp allocate[(list)] clause
[...]]

flang/test/Parser/omp-allocate-unparse.f90

26 ↗

(On Diff #301028)

This check is probably not sufficient. Can you check for all the openmp allocates and the fortran allocate statements?

[Rin]

Add support for list of OMP allocates and add additional checks in tests.

[clementval]

flang/include/flang/Parser/parse-tree.h

3627

Is there a good reason to have separate nodes (OpenMPDeclarativeAllocate, OpenMPExecutableAllocateList)? Both node have the same content.

[Rin]

flang/include/flang/Parser/parse-tree.h

3627

OpenMPDeclarativeAllocate is part of the Declarative construct, whereas OpenMPExecutableAllocateList is part of the Executable construct. I can't use OpenMPDeclarativeAllocate as an executable construct is expected.

[Rin]

flang/include/flang/Parser/parse-tree.h

3627

I had the same idea to use the OpenMPDeclarativeAllocate, but failed to find a way to make it work unfortunately :/

[clementval]

flang/include/flang/Parser/parse-tree.h

3627

You should be able to use the same node in the two variants. What kind of problem did you face?

[Rin]

flang/include/flang/Parser/parse-tree.h

3627

My issue was that OpenMPDeclarativeAllocate is a Declarative construct and an Executable construct was expected. I could add OpenMPDeclarativeAllocate to the Executable construct variant and see if that works

[Rin]

Remove unnecessary node

[clementval]

Just have a small comment. Otherwise I think it looks good to me. Please wait for the approval of someone on the OpenMP side.

flang/lib/Semantics/check-omp-structure.h

145 ↗

(On Diff #307892)

Can you move this up. I think the enter clause function are listed by alphabetical order.

[sameeranjoshi]

I can review it from start as I am now more familiar with the files in this patch.
Please give me a day or so to revert back.
If it's approved from someone else in OpenMP you can go ahead without waiting from my end.

[Rin]

flang/lib/Semantics/check-omp-structure.h

145 ↗

(On Diff #307892)

Yeah, sure thing, I'll do so right away.

[Rin]

Order Enter clase function in alphabetical order

[sameeranjoshi]

Thanks for working on this, I have mostly a few queries and some suggestions.

flang/include/flang/Parser/parse-tree.h

3621

Are you missing OpenMPDeclarativeAllocate in comments?

3627

Correct me if my interpretation from standard is wrong.

!$omp allocate[(list)] clause
[!$omp allocate(list)clause[...]]
allocate statement

the
std::optional<OpenMPDeclarativeAllocate> seem to be a list mentioned by elipsis, or is it that the there should be a list of clauses?

Althought there are tests(omp-allocate-directive.f90 line 19-23) which have a list of OpenMPDeclarativeAllocate for an OpenMPExecutableAllocate test.

flang/lib/Parser/openmp-parsers.cpp

479

In case of OpenMPExecutableAllocate are the clauses mandatory as the standard doesn't seem to have square brackets around them?
Or that's wrongly mentioned in standard.

As OmpClauseList is a list it can be optional.

!$omp allocate[(list)] clause
[!$omp allocate[(list)] clause
[...]]

So a test case like

!$omp allocate(a, b)
   allocate ( darray(a, b) )

becomes invalid in that case.

494

Does a test with no newline and an allocateStmt fall under OpenMPDeclarativeAllocate as per current implementations?

!$omp allocate(x, y) allocator(omp_default_mem_alloc) allocate( darray(x,y) )

flang/lib/Parser/unparse.cpp

2322

Why is there no Walk for std::optional<OpenMPDeclarativeAllocate> as parse-tree.h shows

std::tuple<Verbatim, std::optional<OmpObjectList>, OmpClauseList,
    std::optional<OpenMPDeclarativeAllocate>, Statement<AllocateStmt>>
    t;

flang/lib/Semantics/check-omp-structure.h

107 ↗

(On Diff #308616)

The commit title mentions this to be a parser change, are these semantic checks necessary with this patch?

flang/test/Parser/omp-allocate-unparse.f90

7 ↗

(On Diff #308616)

I see whitespaces at the end.

18 ↗

(On Diff #308616)

whitespace

20 ↗

(On Diff #308616)

whitespace.

22 ↗

(On Diff #308616)

whitespace

28 ↗

(On Diff #308616)

whitespace

flang/test/Semantics/omp-allocate-directive.f90

8 ↗

(On Diff #308616)

whitespace at end.

14 ↗

(On Diff #308616)

whitespace at end.

16 ↗

(On Diff #308616)

Is a test allowed with multiple clauses or will it be handled in semantic phase?

!$omp allocate(x, y) allocator(omp_default_mem_alloc) allocator(omp_default_mem_alloc)

17 ↗

(On Diff #308616)

whitespace at end.

23 ↗

(On Diff #308616)

whitespace at end.

[clementval]

flang/lib/Parser/openmp-parsers.cpp

479

If there are required clauses they are set in the TableGen file. OmpClauseList should be used in preference of a stricter parser.

494

I don't think the allocate statement in that case will be handle by the fortran parser. The whole line is considered as a "comment" so the Fortran parser will not try to infer what is inside of it.

[Rin]

flang/include/flang/Parser/parse-tree.h

3627

I'm not sure if I'm understanding the question correctly, but if you're asking about the (list), that refers to list-items.
What I get from this:

!$omp allocate[(list)] clause
[!$omp allocate(list)clause[...]]
allocate statement

Particularly this part: [!$omp allocate(list)clause[...]]

Is that an OpenMPExecutableAllocate can be followed by an optional list of OpenMPDeclarativeAllocate.

flang/lib/Parser/openmp-parsers.cpp

479

Hmm, I'm not too sure about this one. You're right that there are no square brackets, but then there are restrictions such as this one:

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.

Which specify when an allocator clause needs to be present on a directive. So maybe they are still optional? I can make them required if my assumption is wrong.

494

No, I think that would be a comment since the allocateStmt is a Fortran Statement rather than an OpenMP one, so the newline is required.

flang/lib/Parser/unparse.cpp

2322

Oh, the unparsing of OpenMPDeclarativeAllocate is done by the function which handles OpenMPDeclarativeAllocate.

flang/lib/Semantics/check-omp-structure.h

107 ↗

(On Diff #308616)

Yes, because the directive context needs to be pushed using the PushContextAndClauseSets() function, otherwise there is an error. So these semantic checks are necessary in this patch.

flang/test/Parser/omp-allocate-unparse.f90

7 ↗

(On Diff #308616)

I will take care of those in the next update. Sorry about that. Failed to notice this detail.

flang/test/Semantics/omp-allocate-directive.f90

16 ↗

(On Diff #308616)

This will be handled in the semantics patch. It's not allowed.

[Rin]

flang/lib/Parser/openmp-parsers.cpp

479

Oh yeah, I forgot about that, you're right.

[Rin]

Remove white spaces

[Rin]

flang/include/flang/Parser/parse-tree.h

3621

These are the comments for the OpenMPExecutableAllocate so I didn't think it necessary to add here the case where the Allocate Directive is Declarative.

[sameeranjoshi]

flang/include/flang/Parser/parse-tree.h

3621

I meant where is a reference for std::optional<OpenMPDeclarativeAllocate> in the comments ?

// 2.11.3 allocate -> ALLOCATE [(variable-name-list)] [clause]
//                             [ALLOCATE [(variable-name-list)] [clause] [...]]
//                             allocate-statement
//            clause -> allocator-clause

As there needs a stricter differentiation between both allocate directives to identify them.

3627

You got it correct, so why isn't
std::optional<OpenMPDeclarativeAllocate> in OpenMPExecutableAllocate not a std::list (std::optional<std::list<OpenMPDeclarativeAllocate>>)?

flang/lib/Parser/openmp-parsers.cpp

479

Hmm the restriction makes me think that the standard there is some ambiguity.
I am not sure what to do with such case.

[Rin]

flang/include/flang/Parser/parse-tree.h

3621

Oh, right, I misunderstood. I'll add those in the next update.

3627

I'll add it as a list in the next update. You're right. Sorry, I misread your question in the beginning.

flang/lib/Parser/openmp-parsers.cpp

479

If the clause is required, I can add it in the TableGen file like Valentin mentioned. I'm not sure what the best course of action would be in this case, so I'm open to suggestions.

[Rin]

flang/lib/Parser/openmp-parsers.cpp

479

I'm really unsure here, because the TableGen refers to both the Declarative and Executable case. So if I make the allocator clause required, then it will be required for both cases. And yeah, the standard is a bit ambiguous, so I'm quite unsure here.

[Rin]

Add DeclarativeAllocateDirective as a list within the ExecutableAllocateDirective construct

[sameeranjoshi]

Thanks and LGTM.

flang/lib/Parser/openmp-parsers.cpp

479

Seeing the ambiguity in standard and restrictions in semantics, looks like we should go with OmpClauseList.

flang/lib/Parser/type-parsers.h

94

You missed // R927 at the end.

[Rin]

flang/lib/Parser/openmp-parsers.cpp

479

Alright.

flang/lib/Parser/type-parsers.h

94

Thanks for pointing it out. I'll add it before I push this.

[Rin]

Add comment

[kiranchandramohan]

LGTM.

For semantics should have a check where the following case is caught.
!$omp allocate[(list)] clause
!$omp allocate(list)
!$omp allocate(list)

allocate statement

flang/include/flang/Parser/dump-parse-tree.h

 //===-- include/flang/Parser/dump-parse-tree.h ------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
#include "llvm/Frontend/OpenMP/OMP.cpp.inc"
   NODE(parser, OpenACCWaitConstruct)
   NODE(parser, OpenMPAtomicConstruct)
   NODE(parser, OpenMPBlockConstruct)
   NODE(parser, OpenMPCancelConstruct)
   NODE(OpenMPCancelConstruct, If)
   NODE(parser, OpenMPCancellationPointConstruct)
   NODE(parser, OpenMPConstruct)
   NODE(parser, OpenMPCriticalConstruct)
+  NODE(parser, OpenMPDeclarativeAllocate)
   NODE(parser, OpenMPDeclarativeConstruct)
   NODE(parser, OpenMPDeclareReductionConstruct)
   NODE(parser, OpenMPDeclareSimdConstruct)
   NODE(parser, OpenMPDeclareTargetConstruct)
   NODE(parser, OmpFlushMemoryClause)
   NODE(parser, OpenMPFlushConstruct)
   NODE(parser, OpenMPLoopConstruct)
+  NODE(parser, OpenMPExecutableAllocate)
   NODE(parser, OpenMPSimpleStandaloneConstruct)
   NODE(parser, OpenMPStandaloneConstruct)
   NODE(parser, OpenMPSectionsConstruct)
   NODE(parser, OpenMPThreadprivate)
   NODE(parser, OpenStmt)
   NODE(parser, Optional)
   NODE(parser, OptionalStmt)
   NODE(parser, OtherSpecificationStmt)
   NODE(parser, OutputImpliedDo)

flang/include/flang/Parser/parse-tree.h

 //===-- include/flang/Parser/parse-tree.h -----------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 

 
 // 2.15.2 threadprivate -> THREADPRIVATE (variable-name-list)
 struct OpenMPThreadprivate {
   TUPLE_CLASS_BOILERPLATE(OpenMPThreadprivate);
   CharBlock source;
   std::tuple<Verbatim, OmpObjectList> t;
 };
 
+// 2.11.3 allocate -> ALLOCATE (variable-name-list) [clause]
+struct OpenMPDeclarativeAllocate {
+  TUPLE_CLASS_BOILERPLATE(OpenMPDeclarativeAllocate);
+  CharBlock source;
+  std::tuple<Verbatim, OmpObjectList> t;
+};
+
 struct OpenMPDeclarativeConstruct {
   UNION_CLASS_BOILERPLATE(OpenMPDeclarativeConstruct);
   CharBlock source;
-  std::variant<OpenMPDeclareReductionConstruct, OpenMPDeclareSimdConstruct,
-      OpenMPDeclareTargetConstruct, OpenMPThreadprivate>
-      u;
+  std::variant<OpenMPDeclarativeAllocate, OpenMPDeclareReductionConstruct,
+      OpenMPDeclareSimdConstruct, OpenMPDeclareTargetConstruct,
+      OpenMPThreadprivate> u;
 };
 
 // HINT(hint-expression)
 WRAPPER_CLASS(OmpHintExpr, ConstantExpr);
 
 // 2.13.2 CRITICAL [Name] <block> END CRITICAL [Name]
 struct OmpCriticalDirective {
   TUPLE_CLASS_BOILERPLATE(OmpCriticalDirective);
   CharBlock source;
   std::tuple<Verbatim, std::optional<Name>, std::optional<OmpHintExpr>> t;
 };
 struct OmpEndCriticalDirective {
   TUPLE_CLASS_BOILERPLATE(OmpEndCriticalDirective);
   CharBlock source;
   std::tuple<Verbatim, std::optional<Name>> t;
 };
 struct OpenMPCriticalConstruct {
   TUPLE_CLASS_BOILERPLATE(OpenMPCriticalConstruct);
   std::tuple<OmpCriticalDirective, Block, OmpEndCriticalDirective> t;
 };
 
+// 2.11.3 allocate -> ALLOCATE (variable-name-list) [clause] allocate-statement
+//        clause -> allocator-clause
+struct OpenMPExecutableAllocate {
+  TUPLE_CLASS_BOILERPLATE(OpenMPExecutableAllocate);
+  CharBlock source;
+  std::tuple<Verbatim, OmpObjectList, Statement<AllocateStmt>> t;
+};
+
 // 2.17.7 atomic -> ATOMIC [clause[,]] atomic-clause [[,]clause] |
 //                  ATOMIC [clause]
 //        clause -> memory-order-clause | HINT(hint-expression)
 //        memory-order-clause -> SEQ_CST | ACQ_REL | RELEASE | ACQUIRE | RELAXED
 //        atomic-clause -> READ | WRITE | UPDATE | CAPTURE
 
 // END ATOMIC
 EMPTY_CLASS(OmpEndAtomic);
 
std::tuple<OmpBeginLoopDirective, std::optional<DoConstruct>,
       std::optional<OmpEndLoopDirective>>
       t;
 };
 
 struct OpenMPConstruct {
   UNION_CLASS_BOILERPLATE(OpenMPConstruct);
   std::variant<OpenMPStandaloneConstruct, OpenMPSectionsConstruct,
       OpenMPLoopConstruct, OpenMPBlockConstruct, OpenMPAtomicConstruct,
-      OpenMPCriticalConstruct>
+      OpenMPExecutableAllocate, OpenMPCriticalConstruct>
       u;
 };
 
 // Parse tree nodes for OpenACC 3.0 directives and clauses
 
 struct AccObject {
   UNION_CLASS_BOILERPLATE(AccObject);
   std::variant<Designator, /*common block*/ Name> u;

flang/lib/Lower/OpenMP.cpp

 //===-- OpenMP.cpp -- Open MP directive lowering --------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
std::visit(
                   &standaloneConstruct) {
             genOMP(converter, eval, standaloneConstruct);
           },
           [&](const Fortran::parser::OpenMPSectionsConstruct
                   &sectionsConstruct) { TODO(); },
           [&](const Fortran::parser::OpenMPLoopConstruct &loopConstruct) {
             TODO();
           },
+          [&](const Fortran::parser::OpenMPExecutableAllocate &execAllocConstruct) {
+            TODO();
+          },
           [&](const Fortran::parser::OpenMPBlockConstruct &blockConstruct) {
             genOMP(converter, eval, blockConstruct);
           },
           [&](const Fortran::parser::OpenMPAtomicConstruct &atomicConstruct) {
             TODO();
           },
           [&](const Fortran::parser::OpenMPCriticalConstruct
                   &criticalConstruct) { TODO(); },

flang/lib/Parser/openmp-parsers.cpp

 //===-- lib/Parser/openmp-parsers.cpp -------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
sourced(construct<OmpEndCriticalDirective>(
         endOmpLine)
 TYPE_PARSER(sourced(construct<OmpCriticalDirective>(verbatim("CRITICAL"_tok),
                 maybe(parenthesized(name)), maybe(Parser<OmpHintExpr>{}))) /
     endOmpLine)
 
 TYPE_PARSER(construct<OpenMPCriticalConstruct>(
     Parser<OmpCriticalDirective>{}, block, Parser<OmpEndCriticalDirective>{}))
 
+// 2.11.3 Executable Allocate directive
+TYPE_PARSER(sourced(construct<OpenMPExecutableAllocate>(
+    verbatim("ALLOCATE"_tok), parenthesized(Parser<OmpObjectList>{}) / endOmpLine,
+    statement(allocateStmt))))
+
 // 2.8.2 Declare Simd construct
 TYPE_PARSER(
     sourced(construct<OpenMPDeclareSimdConstruct>(verbatim("DECLARE SIMD"_tok),
         maybe(parenthesized(name)), Parser<OmpClauseList>{})))
 
 // 2.15.2 Threadprivate directive
 TYPE_PARSER(sourced(construct<OpenMPThreadprivate>(
     verbatim("THREADPRIVATE"_tok), parenthesized(Parser<OmpObjectList>{}))))
 
+// 2.11.3 Declarative Allocate directive
+TYPE_PARSER(sourced(construct<OpenMPDeclarativeAllocate>(
+    verbatim("ALLOCATE"_tok), parenthesized(Parser<OmpObjectList>{}))) / 
+    lookAhead(endOmpLine / !statement(allocateStmt)))
+
 // Declarative constructs
 TYPE_PARSER(startOmpLine >>
     sourced(construct<OpenMPDeclarativeConstruct>(
                 Parser<OpenMPDeclareReductionConstruct>{}) ||
         construct<OpenMPDeclarativeConstruct>(
             Parser<OpenMPDeclareSimdConstruct>{}) ||
         construct<OpenMPDeclarativeConstruct>(
             Parser<OpenMPDeclareTargetConstruct>{}) ||
+        construct<OpenMPDeclarativeConstruct>(
+            Parser<OpenMPDeclarativeAllocate>{}) ||
         construct<OpenMPDeclarativeConstruct>(Parser<OpenMPThreadprivate>{})) /
         endOmpLine)
 
 // Block Construct
 TYPE_PARSER(construct<OpenMPBlockConstruct>(
     Parser<OmpBeginBlockDirective>{} / endOmpLine, block,
     Parser<OmpEndBlockDirective>{} / endOmpLine))
 
TYPE_CONTEXT_PARSER("OpenMP construct"_en_US,
     startOmpLine >>
         first(construct<OpenMPConstruct>(Parser<OpenMPSectionsConstruct>{}),
             construct<OpenMPConstruct>(Parser<OpenMPLoopConstruct>{}),
             construct<OpenMPConstruct>(Parser<OpenMPBlockConstruct>{}),
             // OpenMPBlockConstruct is attempted before
             // OpenMPStandaloneConstruct to resolve !$OMP ORDERED
             construct<OpenMPConstruct>(Parser<OpenMPStandaloneConstruct>{}),
             construct<OpenMPConstruct>(Parser<OpenMPAtomicConstruct>{}),
+            construct<OpenMPConstruct>(Parser<OpenMPExecutableAllocate>{}),
             construct<OpenMPConstruct>(Parser<OpenMPCriticalConstruct>{})))
 
 // END OMP Block directives
 TYPE_PARSER(
     startOmpLine >> sourced(construct<OmpEndBlockDirective>(
                         sourced("END"_tok >> Parser<OmpBlockDirective>{}),
                         Parser<OmpClauseList>{})))
 

flang/lib/Parser/type-parsers.h

 //===-- lib/Parser/type-parsers.h -------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 

 constexpr Parser<DataRef> dataRef; // R911, R914, R917
 constexpr Parser<StructureComponent> structureComponent; // R913
 constexpr Parser<StatVariable> statVariable; // R929
 constexpr Parser<StatOrErrmsg> statOrErrmsg; // R942 & R1165
 constexpr Parser<DefinedOpName> definedOpName; // R1003, R1023, R1414, & R1415
 constexpr Parser<Expr> expr; // R1022
 constexpr Parser<SpecificationExpr> specificationExpr; // R1028
 constexpr Parser<AssignmentStmt> assignmentStmt; // R1032
+constexpr Parser<AllocateStmt> allocateStmt;
 constexpr Parser<PointerAssignmentStmt> pointerAssignmentStmt; // R1033
 constexpr Parser<WhereStmt> whereStmt; // R1041, R1045, R1046
 constexpr Parser<WhereConstruct> whereConstruct; // R1042
 constexpr Parser<WhereBodyConstruct> whereBodyConstruct; // R1044
 constexpr Parser<ForallConstruct> forallConstruct; // R1050
 constexpr Parser<ForallAssignmentStmt> forallAssignmentStmt; // R1053
 constexpr Parser<ForallStmt> forallStmt; // R1055
 constexpr Parser<Selector> selector; // R1105

flang/lib/Parser/unparse.cpp

 //===-- lib/Parser/unparse.cpp --------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
void Unparse(const OmpAtomicWrite &x) {
     Walk(std::get<OmpAtomicMemoryOrderClausePostList>(x.t));
     Put("\n");
     EndOpenMP();
     Walk(std::get<Statement<AssignmentStmt>>(x.t));
     BeginOpenMP();
     Walk(std::get<std::optional<OmpEndAtomic>>(x.t), "!$OMP END ATOMIC\n");
     EndOpenMP();
   }
+  void Unparse(const OpenMPExecutableAllocate &x) {
+    BeginOpenMP();
+    Word("!$OMP ALLOCATE (");
+    Walk(std::get<OmpObjectList>(x.t));
+    Put(")\n");
+    EndOpenMP();
+    Walk(std::get<Statement<AllocateStmt>>(x.t));
+  }
   void Unparse(const OmpCriticalDirective &x) {
     BeginOpenMP();
     Word("!$OMP CRITICAL");
     Walk(" (", std::get<std::optional<Name>>(x.t), ")");
     Walk(std::get<std::optional<OmpHintExpr>>(x.t));
     Put("\n");
     EndOpenMP();
   }
void Unparse(const OpenMPDeclareReductionConstruct &x) {
     Walk(std::get<OmpReductionCombiner>(x.t));
     Put(")");
     Walk(std::get<std::optional<OmpReductionInitializerClause>>(x.t));
   }
   bool Pre(const OpenMPDeclarativeConstruct &x) {
     BeginOpenMP();
     Word("!$OMP ");
     return std::visit(common::visitors{
+                          [&](const OpenMPDeclarativeAllocate &) {
+                            Word("ALLOCATE (");
+                            return true;
+                          },
                           [&](const OpenMPDeclareReductionConstruct &) {
                             Word("DECLARE REDUCTION ");
                             return true;
                           },
                           [&](const OpenMPDeclareSimdConstruct &y) {
                             Word("DECLARE SIMD ");
                             Walk("(", std::get<std::optional<Name>>(y.t), ")");
                             Walk(std::get<OmpClauseList>(y.t));
return std::visit(common::visitors{
                           },
                       },
         x.u);
   }
   void Post(const OpenMPDeclarativeConstruct &) {
     Put("\n");
     EndOpenMP();
   }
+   void Post(const OpenMPDeclarativeAllocate &) {
+    Put(")\n");
+    EndOpenMP();
+  }
   void Post(const OpenMPThreadprivate &) {
     Put(")\n");
     EndOpenMP();
   }
   void Unparse(const OmpSectionsDirective &x) {
     switch (x.v) {
     case llvm::omp::Directive::OMPD_sections:
       Word("SECTIONS ");

flang/test/Semantics/omp-declarative-directive.f90

 end subroutine declare_simd_2
 
 subroutine sub1 (x,y)
   integer, intent(in)::x, y
   print *, x+y
 end subroutine sub1
 
 ! 2.10.6 declare-target
+! 2.11.3 declarative allocate
 ! 2.15.2 threadprivate
 
 module m2
 contains
   subroutine foo
     !$omp declare target
     !$omp declare target (foo, N, M)
     !$omp declare target to(Q, S) link(R)
     !ERROR: MAP clause is not allowed on the DECLARE TARGET directive
     !$omp declare target map(from:Q)
     integer, parameter :: N=10000, M=1024
     integer :: i
     real :: Q(N, N), R(N,M), S(M,M)
+    !$omp allocate(i)
     !$omp threadprivate(i)
   end subroutine foo
 end module m2
 
 ! 2.16 declare-reduction
 
 ! subroutine declare_red_1()
 !   use omp_lib