[flang] Add parser support for OpenMP allocate clause

[DavidTruby]

LGTM other than formatting, could you run clang-format over this please? Thanks!

flang/lib/Parser/openmp-parsers.cpp

109

I think this line would get split in 2 by clang-format as it is over 80 characters

[kiranchandramohan]

Thanks @Rin for this patch. A few minor comments.

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

3500–3502

Are the Omp*Clauses in alphabetic order?

flang/lib/Parser/openmp-parsers.cpp

214

Nit: Extraneous line?

flang/test/Semantics/omp-clause-validity01.f90

36

Nit:extra character (at end of line)?

48

Did a custom allocator test work fine?

[Rin]

[flang][OpenMP]Add parser support for OpenMP Allocate Clause Update
Added a test to check behaviour when handling a custom allocator as well as fixing formatting issues

1. Updating D85212: Add parser support for OpenMP allocate clause #
2. Enter a brief description of the changes included in this update.
3. The first line is used as subject, next lines as comment.

[Rin]

Update to get rid of formatting issues

[kiranchandramohan]

LGTM. Please wait for one more approval.

flang/test/Semantics/omp-clause-validity01.f90

65

Nit: extra line.
No further revision required for this issue. You change when you submit.

[DavidTruby]

LGTM

[sscalpone]

Do you have a negative test that checks for an out-of-place allocate?

[kiranktp]

LGTM

[kiranchandramohan]

In D85212#2196478, @sscalpone wrote:

Do you have a negative test that checks for an out-of-place allocate?

out of place as in for a different directive where it is not supported?

[sscalpone]

out of place as in for a different directive where it is not supported?

Yes.

[Rin]

In D85212#2196478, @sscalpone wrote:

Do you have a negative test that checks for an out-of-place allocate?

Not yet, but they will be added in the Semantic checks, which I'll work on next.

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

3500–3502

Yeah, you're right, I'll change that

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

#define NODE(T1, T2) NODE_NAME(T1::T2, #T2)
   NODE(parser, OmpObjectList)
   NODE(parser, OmpProcBindClause)
   NODE_ENUM(OmpProcBindClause, Type)
   NODE(parser, OmpReductionClause)
   NODE(parser, OmpReductionCombiner)
   NODE(OmpReductionCombiner, FunctionCombiner)
   NODE(parser, OmpReductionInitializerClause)
   NODE(parser, OmpReductionOperator)
+  NODE(parser, OmpAllocateClause)
+  NODE(OmpAllocateClause, Allocator)
   NODE(parser, OmpScheduleClause)
   NODE_ENUM(OmpScheduleClause, ScheduleType)
   NODE(parser, OmpScheduleModifier)
   NODE(OmpScheduleModifier, Modifier1)
   NODE(OmpScheduleModifier, Modifier2)
   NODE(parser, OmpScheduleModifierType)
   NODE_ENUM(OmpScheduleModifierType, ModType)
   NODE(parser, OmpSectionBlocks)

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

 
 // 2.15.3.6 reduction-clause -> REDUCTION (reduction-identifier:
 //                                         variable-name-list)
 struct OmpReductionClause {
   TUPLE_CLASS_BOILERPLATE(OmpReductionClause);
   std::tuple<OmpReductionOperator, std::list<Designator>> t;
 };
 
+// OMP 5.0 2.11.4 allocate-clause -> ALLOCATE ([allocator:] variable-name-list)
+struct OmpAllocateClause {
+  TUPLE_CLASS_BOILERPLATE(OmpAllocateClause);
+  WRAPPER_CLASS(Allocator, ScalarIntExpr);
+  std::tuple<std::optional<Allocator>, OmpObjectList> t;
+};
+
 // 2.13.9 depend-vec-length -> +/- non-negative-constant
 struct OmpDependSinkVecLength {
   TUPLE_CLASS_BOILERPLATE(OmpDependSinkVecLength);
   std::tuple<DefinedOperator, ScalarIntConstantExpr> t;
 };
 
 // 2.13.9 depend-vec -> iterator [+/- depend-vec-length],...,iterator[...]
 struct OmpDependSinkVec {
struct OmpClause {
   WRAPPER_CLASS(Uniform, std::list<Name>);
   WRAPPER_CLASS(UseDevicePtr, std::list<Name>);
   CharBlock source;
   std::variant<Inbranch, Mergeable, Nogroup, Notinbranch, OmpNowait, Untied,
       Threads, Simd, Collapse, Copyin, Copyprivate, Device, DistSchedule, Final,
       Firstprivate, From, Grainsize, Lastprivate, NumTasks, NumTeams,
       NumThreads, Ordered, Priority, Private, Safelen, Shared, Simdlen,
       ThreadLimit, To, Link, Uniform, UseDevicePtr, IsDevicePtr,
-      OmpAlignedClause, OmpDefaultClause, OmpDefaultmapClause, OmpDependClause,
-      OmpIfClause, OmpLinearClause, OmpMapClause, OmpProcBindClause,
-      OmpReductionClause, OmpScheduleClause>
+      OmpAlignedClause, OmpAllocateClause, OmpDefaultClause,
+      OmpDefaultmapClause, OmpDependClause, OmpIfClause, OmpLinearClause,
+      OmpMapClause, OmpProcBindClause, OmpReductionClause, OmpScheduleClause>
       u;
 };
 
 struct OmpClauseList {
   WRAPPER_CLASS_BOILERPLATE(OmpClauseList, std::list<OmpClause>);
   CharBlock source;
 };
 

flang/lib/Parser/openmp-parsers.cpp

 
 // 2.15.3.6 REDUCTION (reduction-identifier: variable-name-list)
 TYPE_PARSER(construct<OmpReductionOperator>(Parser<DefinedOperator>{}) ||
     construct<OmpReductionOperator>(Parser<ProcedureDesignator>{}))
 
 TYPE_PARSER(construct<OmpReductionClause>(
     Parser<OmpReductionOperator>{} / ":", nonemptyList(designator)))
 
+// OMP 5.0 2.11.4  ALLOCATE ([allocator:] variable-name-list)
+TYPE_PARSER(construct<OmpAllocateClause>(
+    maybe(construct<OmpAllocateClause::Allocator>(scalarIntExpr) / ":"),
+    Parser<OmpObjectList>{}))
+
 // 2.13.9 DEPEND (SOURCE | SINK : vec | (IN | OUT | INOUT) : list
 TYPE_PARSER(construct<OmpDependSinkVecLength>(
     Parser<DefinedOperator>{}, scalarIntConstantExpr))
 
 TYPE_PARSER(
     construct<OmpDependSinkVec>(name, maybe(Parser<OmpDependSinkVecLength>{})))
 
 TYPE_PARSER(
TYPE_PARSER("ALIGNED" >>
     "PRIORITY" >> construct<OmpClause>(construct<OmpClause::Priority>(
                       parenthesized(scalarIntExpr))) ||
     "PRIVATE" >> construct<OmpClause>(construct<OmpClause::Private>(
                      parenthesized(Parser<OmpObjectList>{}))) ||
     "PROC_BIND" >>
         construct<OmpClause>(parenthesized(Parser<OmpProcBindClause>{})) ||
     "REDUCTION" >>
         construct<OmpClause>(parenthesized(Parser<OmpReductionClause>{})) ||
+    "ALLOCATE" >>
+        construct<OmpClause>(parenthesized(Parser<OmpAllocateClause>{})) ||
     "SAFELEN" >> construct<OmpClause>(construct<OmpClause::Safelen>(
                      parenthesized(scalarIntConstantExpr))) ||
     "SCHEDULE" >>
         construct<OmpClause>(parenthesized(Parser<OmpScheduleClause>{})) ||
     "SHARED" >> construct<OmpClause>(construct<OmpClause::Shared>(
                     parenthesized(Parser<OmpObjectList>{}))) ||
     "SIMD"_id >> construct<OmpClause>(construct<OmpClause::Simd>()) ||
     "SIMDLEN" >> construct<OmpClause>(construct<OmpClause::Simdlen>(

flang/lib/Parser/unparse.cpp

#undef FMT
   }
   void Unparse(const OmpReductionClause &x) {
     Word("REDUCTION(");
     Walk(std::get<OmpReductionOperator>(x.t));
     Put(":");
     Walk(std::get<std::list<Designator>>(x.t), ",");
     Put(")");
   }
+  void Unparse(const OmpAllocateClause &x) {
+    Word("ALLOCATE(");
+    Walk(std::get<std::optional<OmpAllocateClause::Allocator>>(x.t), ":");
+    Walk(std::get<OmpObjectList>(x.t));
+    Put(")");
+  }
   void Unparse(const OmpDependSinkVecLength &x) {
     Walk(std::get<DefinedOperator>(x.t));
     Walk(std::get<ScalarIntConstantExpr>(x.t));
   }
   void Unparse(const OmpDependSinkVec &x) {
     Walk(std::get<Name>(x.t));
     Walk(std::get<std::optional<OmpDependSinkVecLength>>(x.t));
   }

flang/test/Semantics/omp-clause-validity01.f90

 ! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
-
+use omp_lib
 ! Check OpenMP clause validity for the following directives:
 !
 !    2.5 PARALLEL construct
 !    2.7.1 Loop construct
 !    ...
 
 ! TODO: all the internal errors
 
   integer :: b = 128
   integer :: c = 32
   integer, parameter :: num = 16
   real(8) :: arrayA(256), arrayB(512)
 
+  integer(omp_memspace_handle_kind) :: xy_memspace = omp_default_mem_space
+  type(omp_alloctrait) :: xy_traits(1) = [omp_alloctrait(omp_atk_alignment,64)]
+  integer(omp_allocator_handle_kind) :: xy_alloc
+  xy_alloc = omp_init_allocator(xy_memspace, 1, xy_traits)
+
   arrayA = 1.414
   arrayB = 3.14
   N = 1024
 
 ! 2.5 parallel-clause -> if-clause |
 !                        num-threads-clause |
 !                        default-clause |
 !                        private-clause |
 !                        firstprivate-clause |
 !                        shared-clause |
 !                        copyin-clause |
 !                        reduction-clause |
-!                        proc-bind-clause
+!                        proc-bind-clause |
+!                        allocate-clause
 
   !$omp parallel
   do i = 1, N
      a = 3.14
   enddo
   !$omp end parallel
 
+  !$omp parallel allocate(b)
+  do i = 1, N
+     a = 3.14
+  enddo
+  !$omp end parallel
+
+  !$omp parallel allocate(omp_default_mem_space : b, c)
+  do i = 1, N
+     a = 3.14
+  enddo
+  !$omp end parallel
+
+  !$omp parallel allocate(b) allocate(c)
+  do i = 1, N
+     a = 3.14
+  enddo
+  !$omp end parallel
+
+  !$omp parallel allocate(xy_alloc :b) 
+  do i = 1, N
+     a = 3.14
+  enddo
+  !$omp end parallel
+
   !ERROR: SCHEDULE clause is not allowed on the PARALLEL directive
   !$omp parallel schedule(static)
   do i = 1, N
      a = 3.14
   enddo
   !$omp end parallel
 
   !ERROR: COLLAPSE clause is not allowed on the PARALLEL directive