[flang][OpenMP] Add parser support for order clause

[kavitha-natarajan]

Summary

Added parser support for OpenMP 5.0 feature ORDER(CONCURRENT) clause for the following OpenMP directives:
do
"simd"
do simd
parallel do
parallel do simd
target simd
target parallel do
target parallel do simd
teams distribute simd
teams distribute parallel do
teams distribute parallel do simd
target teams distribute simd
target teams distribute parallel do
target teams distribute parallel do simd
taskloop simd

Other OpenMP directives that are not yet supported by flang which has order(concurrent) clause:
loop
parallel loop
target parallel loop
teams loop
target teams loop
masked taskloop simd
parallel masked taskloop simd

[kavitha-natarajan]

Updated line number in flang/test/Examples/omp-order-clause.f90

[kiranchandramohan]

Looks good.
There are changes to this clause in 5.1 and later standards with an order-modifier added and the order clause applying to constructs like the distribute construct. Is the plan to add these later?

flang/lib/Parser/unparse.cpp

2626

OMP ORDER -> OMP order-type

[abidmalikwaterloo]

LGTM

[kavitha-natarajan]

In D142524#4081209, @kiranchandramohan wrote:

Looks good.
There are changes to this clause in 5.1 and later standards with an order-modifier added and the order clause applying to constructs like the distribute construct. Is the plan to add these later?

Thanks for reviewing. Currently, we are planning to support OpenMP 5.0 which does not have order-modifier. But I can add the parser support as this is the only change that would be required for order clause support. I shall update the patch with this change.
If I understand correctly, DISTRIBUTE region has to be strictly nested inside TEAMS region. In that case, I have added support for 'TEAMS DISTRIBUTE' and 'TARGET TEAMS DISTRIBUTE' constructs.

[kavitha-natarajan]

Enhanced ORDER(concurrent) clause to support OpenMP 5.1 feature which adds an optional order-modifier, such as, ORDER( [order-modifier :] concurrent ), where order-modifier can be 'reproducible' or 'unconstrained'.

[kavitha-natarajan]

Rebased.

[kiranchandramohan]

LGTM. Thanks for your first patch in Flang and welcome.

Two Nit comments inline.

flang/test/Parser/omp-order-clause02.f90

1 ↗

(On Diff #499068)

Nit: Use test_errors.py for error tests.

llvm/include/llvm/Frontend/OpenMP/OMP.td

2008

Nit: Isn't this also 50?

[kavitha-natarajan]

In D142524#4141088, @kiranchandramohan wrote:

LGTM. Thanks for your first patch in Flang and welcome.

Two Nit comments inline.

Thank you!

[kavitha-natarajan]

flang/test/Parser/omp-order-clause02.f90

1 ↗

(On Diff #499068)

test_errors.py and its modules are located in flang/test/Semantics/ directory. All the error tests in Parser directory are written this way. Do you think we should start using test_errors.py for all error tests? If so, we may have to relocate the scripts from Semantics directory. Please let me know your comments.

llvm/include/llvm/Frontend/OpenMP/OMP.td

2008

Yes, will change it.

[kiranchandramohan]

flang/test/Parser/omp-order-clause02.f90

1 ↗

(On Diff #499068)

I believe this is a Semantics error, so you can move the test itself to the Semantics directory.

[kavitha-natarajan]

flang/test/Parser/omp-order-clause02.f90

1 ↗

(On Diff #499068)

Sure. I agree.

[kavitha-natarajan]

Applied review comments.

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

#include "llvm/Frontend/OpenMP/OMP.inc"
   NODE_ENUM(OmpMapType, Type)
   static std::string GetNodeName(const llvm::omp::Clause &x) {
     return llvm::Twine(
         "llvm::omp::Clause = ", llvm::omp::getOpenMPClauseName(x))
         .str();
   }
   NODE(parser, OmpObject)
   NODE(parser, OmpObjectList)
+  NODE(parser, OmpOrderClause)
+  NODE_ENUM(OmpOrderClause, Type)
+  NODE(parser, OmpOrderModifier)
+  NODE_ENUM(OmpOrderModifier, Kind)
   NODE(parser, OmpProcBindClause)
   NODE_ENUM(OmpProcBindClause, Type)
   NODE(parser, OmpReductionClause)
   NODE(parser, OmpInReductionClause)
   NODE(parser, OmpReductionCombiner)
   NODE(OmpReductionCombiner, FunctionCombiner)
   NODE(parser, OmpReductionInitializerClause)
   NODE(parser, OmpReductionOperator)

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

 
 // 2.8.1 aligned-clause -> ALIGNED (variable-name-list[ : scalar-constant])
 struct OmpAlignedClause {
   TUPLE_CLASS_BOILERPLATE(OmpAlignedClause);
   CharBlock source;
   std::tuple<std::list<Name>, std::optional<ScalarIntConstantExpr>> t;
 };
 
+// 2.9.5 order-clause -> ORDER ([order-modifier :]concurrent)
+struct OmpOrderModifier {
+  UNION_CLASS_BOILERPLATE(OmpOrderModifier);
+  ENUM_CLASS(Kind, Reproducible, Unconstrained)
+  std::variant<Kind> u;
+};
+
+struct OmpOrderClause {
+  TUPLE_CLASS_BOILERPLATE(OmpOrderClause);
+  ENUM_CLASS(Type, Concurrent)
+  std::tuple<std::optional<OmpOrderModifier>, Type> t;
+};
+
 // 2.15.3.7 linear-modifier -> REF | VAL | UVAL
 struct OmpLinearModifier {
   ENUM_CLASS(Type, Ref, Val, Uval)
   WRAPPER_CLASS_BOILERPLATE(OmpLinearModifier, Type);
 };
 
 // 2.15.3.7 linear-clause -> LINEAR (linear-list[ : linear-step])
 //          linear-list -> list | linear-modifier(list)

flang/lib/Parser/openmp-parsers.cpp

construct<OmpLinearClause>(
             maybe(":" >> scalarIntConstantExpr))) ||
         construct<OmpLinearClause>(construct<OmpLinearClause::WithoutModifier>(
             nonemptyList(name), maybe(":" >> scalarIntConstantExpr)))))
 
 // 2.8.1 ALIGNED (list: alignment)
 TYPE_PARSER(construct<OmpAlignedClause>(
     nonemptyList(name), maybe(":" >> scalarIntConstantExpr)))
 
+// 2.9.5 ORDER ([order-modifier :]concurrent)
+TYPE_PARSER(construct<OmpOrderModifier>(
+    "REPRODUCIBLE" >> pure(OmpOrderModifier::Kind::Reproducible)) ||
+    construct<OmpOrderModifier>(
+    "UNCONSTRAINED" >> pure(OmpOrderModifier::Kind::Unconstrained)))
+
+TYPE_PARSER(construct<OmpOrderClause>(
+    maybe(Parser<OmpOrderModifier>{} / ":"),
+    "CONCURRENT" >> pure(OmpOrderClause::Type::Concurrent)))
+
 TYPE_PARSER(
     construct<OmpObject>(designator) || construct<OmpObject>("/" >> name / "/"))
 
 TYPE_PARSER(
     "ACQUIRE" >> construct<OmpClause>(construct<OmpClause::Acquire>()) ||
     "ACQ_REL" >> construct<OmpClause>(construct<OmpClause::AcqRel>()) ||
     "ALIGNED" >> construct<OmpClause>(construct<OmpClause::Aligned>(
                      parenthesized(Parser<OmpAlignedClause>{}))) ||
"NOTINBRANCH" >>
         construct<OmpClause>(construct<OmpClause::Notinbranch>()) ||
     "NOWAIT" >> construct<OmpClause>(construct<OmpClause::Nowait>()) ||
     "NUM_TASKS" >> construct<OmpClause>(construct<OmpClause::NumTasks>(
                        parenthesized(scalarIntExpr))) ||
     "NUM_TEAMS" >> construct<OmpClause>(construct<OmpClause::NumTeams>(
                        parenthesized(scalarIntExpr))) ||
     "NUM_THREADS" >> construct<OmpClause>(construct<OmpClause::NumThreads>(
                          parenthesized(scalarIntExpr))) ||
+    "ORDER" >> construct<OmpClause>(construct<OmpClause::Order>(
+                   parenthesized(Parser<OmpOrderClause>{}))) ||
     "ORDERED" >> construct<OmpClause>(construct<OmpClause::Ordered>(
                      maybe(parenthesized(scalarIntConstantExpr)))) ||
     "PARTIAL" >> construct<OmpClause>(construct<OmpClause::Partial>(
                      maybe(parenthesized(scalarIntConstantExpr)))) ||
     "PRIORITY" >> construct<OmpClause>(construct<OmpClause::Priority>(
                       parenthesized(scalarIntExpr))) ||
     "PRIVATE" >> construct<OmpClause>(construct<OmpClause::Private>(
                      parenthesized(Parser<OmpObjectList>{}))) ||

flang/lib/Parser/unparse.cpp

void Unparse(const OmpInReductionClause &x) {
     Put(":");
     Walk(std::get<OmpObjectList>(x.t));
   }
   void Unparse(const OmpAllocateClause &x) {
     Walk(std::get<std::optional<OmpAllocateClause::Allocator>>(x.t));
     Put(":");
     Walk(std::get<OmpObjectList>(x.t));
   }
+  void Unparse(const OmpOrderClause &x) {
+    Walk(std::get<std::optional<OmpOrderModifier>>(x.t), ":");
+    Walk(std::get<OmpOrderClause::Type>(x.t));
+  }
   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));
   }
#define WALK_NESTED_ENUM(CLASS, ENUM) \
   WALK_NESTED_ENUM(OmpLinearModifier, Type) // OMP linear-modifier
   WALK_NESTED_ENUM(OmpDependenceType, Type) // OMP dependence-type
   WALK_NESTED_ENUM(OmpMapType, Type) // OMP map-type
   WALK_NESTED_ENUM(OmpScheduleClause, ScheduleType) // OMP schedule-type
   WALK_NESTED_ENUM(OmpDeviceClause, DeviceModifier) // OMP device modifier
   WALK_NESTED_ENUM(OmpDeviceTypeClause, Type) // OMP DEVICE_TYPE
   WALK_NESTED_ENUM(OmpIfClause, DirectiveNameModifier) // OMP directive-modifier
   WALK_NESTED_ENUM(OmpCancelType, Type) // OMP cancel-type
+  WALK_NESTED_ENUM(OmpOrderClause, Type) // OMP order-type
+  WALK_NESTED_ENUM(OmpOrderModifier, Kind) // OMP order-modifier
 #undef WALK_NESTED_ENUM
 
   void Done() const { CHECK(indent_ == 0); }
 
 private:
   void Put(char);
   void Put(const char *);
   void Put(const std::string &);

flang/test/Examples/omp-order-clause.f90

+! REQUIRES: plugins, examples, shell
+
+! RUN: %flang_fc1 -load %llvmshlibdir/flangOmpReport.so -plugin flang-omp-report -fopenmp  %s -o - | FileCheck %s
+
+! Check for ORDER([order-modifier :]concurrent) clause on OpenMP constructs
+
+subroutine test_order()
+ integer :: i, j = 1
+ !$omp do order(concurrent)
+ do i=1,10
+  j = j + 1
+ end do
+ !$omp end do
+end subroutine
+
+!CHECK: - file:         {{.*}}
+!CHECK:   line:         9
+!CHECK:   construct:    do
+!CHECK:   clauses:
+!CHECK:     - clause:   order
+!CHECK:       details:  concurrent
+
+subroutine test_order_reproducible()
+ integer :: i, j = 1
+ !$omp simd order(reproducible:concurrent)
+ do i=1,10
+  j = j + 1
+ end do
+ !$omp end simd
+end subroutine
+
+!CHECK: - file:         {{.*}}
+!CHECK:   line:         25
+!CHECK:   construct:    simd
+!CHECK:   clauses:
+!CHECK:     - clause:   order
+!CHECK:       details:  'reproducible:concurrent'
+
+subroutine test_order_unconstrained()
+ integer :: i, j = 1
+ !$omp target teams distribute parallel do simd order(unconstrained:concurrent)
+ do i=1,10
+  j = j + 1
+ end do
+ !$omp end target teams distribute parallel do simd
+end subroutine
+
+!CHECK: - file:         {{.*}}
+!CHECK:   line:         41
+!CHECK:   construct:    target teams distribute parallel do simd
+!CHECK:   clauses:
+!CHECK:     - clause:   order
+!CHECK:       details:  'unconstrained:concurrent'

flang/test/Parser/omp-order-clause01.f90

+! RUN: %flang_fc1 -fdebug-unparse -fopenmp %s | FileCheck --ignore-case %s
+! RUN: %flang_fc1 -fdebug-dump-parse-tree -fopenmp %s | FileCheck --check-prefix="PARSE-TREE" %s
+
+! Check for ORDER([order-modifier :]concurrent) clause on OpenMP constructs
+
+subroutine test_do_order()
+ integer :: i, j = 1
+ !CHECK: !$omp do order(concurrent)
+ !$omp do order(concurrent)
+ do i=1,10
+  j = j + 1
+ end do
+ !$omp end do
+end subroutine
+
+!PARSE-TREE: OpenMPConstruct -> OpenMPLoopConstruct
+!PARSE-TREE-NEXT: OmpBeginLoopDirective
+!PARSE-TREE-NEXT: OmpLoopDirective -> llvm::omp::Directive = do
+!PARSE-TREE-NEXT: OmpClauseList -> OmpClause -> Order -> OmpOrderClause
+!PARSE-TREE-NEXT: Type = Concurrent
+
+subroutine test_simd_order_reproducible()
+ integer :: i, j = 1
+ !CHECK: !$omp simd order(reproducible:concurrent)
+ !$omp simd order(reproducible:concurrent)
+ do i=1,10
+  j = j + 1
+ end do
+ !$omp end simd
+end subroutine
+
+!PARSE-TREE: OpenMPConstruct -> OpenMPLoopConstruct
+!PARSE-TREE-NEXT: OmpBeginLoopDirective
+!PARSE-TREE-NEXT: OmpLoopDirective -> llvm::omp::Directive = simd
+!PARSE-TREE-NEXT: OmpClauseList -> OmpClause -> Order -> OmpOrderClause
+!PARSE-TREE-NEXT: Kind = Reproducible
+!PARSE-TREE-NEXT: Type = Concurrent
+
+subroutine test_do_simd_order_unconstrained()
+ integer :: i, j = 1
+ !CHECK: !$omp do simd order(unconstrained:concurrent)
+ !$omp do simd order(unconstrained:concurrent)
+ do i=1,10
+  j = j + 1
+ end do
+ !$omp end do simd
+end subroutine
+
+!PARSE-TREE: OpenMPConstruct -> OpenMPLoopConstruct
+!PARSE-TREE-NEXT: OmpBeginLoopDirective
+!PARSE-TREE-NEXT: OmpLoopDirective -> llvm::omp::Directive = do simd
+!PARSE-TREE-NEXT: OmpClauseList -> OmpClause -> Order -> OmpOrderClause
+!PARSE-TREE-NEXT: Kind = Unconstrained
+!PARSE-TREE-NEXT: Type = Concurrent
+
+subroutine test_parallel_do_order()
+ integer :: i, j = 1
+ !CHECK: !$omp parallel do order(concurrent)
+ !$omp parallel do order(concurrent)
+ do i=1,10
+  j = j + 1
+ end do
+ !$omp end parallel do
+end subroutine
+
+!PARSE-TREE: OpenMPConstruct -> OpenMPLoopConstruct
+!PARSE-TREE-NEXT: OmpBeginLoopDirective
+!PARSE-TREE-NEXT: OmpLoopDirective -> llvm::omp::Directive = parallel do
+!PARSE-TREE-NEXT: OmpClauseList -> OmpClause -> Order -> OmpOrderClause
+!PARSE-TREE-NEXT: Type = Concurrent
+
+subroutine test_parallel_do_simd_order_reproducible()
+ integer :: i, j = 1
+ !CHECK: !$omp parallel do simd order(reproducible:concurrent)
+ !$omp parallel do simd order(reproducible:concurrent)
+ do i=1,10
+  j = j + 1
+ end do
+ !$omp end parallel do simd
+end subroutine
+
+!PARSE-TREE: OpenMPConstruct -> OpenMPLoopConstruct
+!PARSE-TREE-NEXT: OmpBeginLoopDirective
+!PARSE-TREE-NEXT: OmpLoopDirective -> llvm::omp::Directive = parallel do simd
+!PARSE-TREE-NEXT: OmpClauseList -> OmpClause -> Order -> OmpOrderClause
+!PARSE-TREE-NEXT: Kind = Reproducible
+!PARSE-TREE-NEXT: Type = Concurrent
+
+subroutine test_target_simd_order_unconstrained()
+ integer :: i, j = 1
+ !CHECK: !$omp target simd order(unconstrained:concurrent)
+ !$omp target simd order(unconstrained:concurrent)
+ do i=1,10
+  j = j + 1
+ end do
+ !$omp end target simd
+end subroutine
+
+!PARSE-TREE: OpenMPConstruct -> OpenMPLoopConstruct
+!PARSE-TREE-NEXT: OmpBeginLoopDirective
+!PARSE-TREE-NEXT: OmpLoopDirective -> llvm::omp::Directive = target simd
+!PARSE-TREE-NEXT: OmpClauseList -> OmpClause -> Order -> OmpOrderClause
+!PARSE-TREE-NEXT: Kind = Unconstrained
+!PARSE-TREE-NEXT: Type = Concurrent
+
+subroutine test_target_parallel_do_order()
+ integer :: i, j = 1
+ !CHECK: !$omp target parallel do order(concurrent)
+ !$omp target parallel do order(concurrent)
+ do i=1,10
+  j = j + 1
+ end do
+ !$omp end target parallel do
+end subroutine
+
+!PARSE-TREE: OpenMPConstruct -> OpenMPLoopConstruct
+!PARSE-TREE-NEXT: OmpBeginLoopDirective
+!PARSE-TREE-NEXT: OmpLoopDirective -> llvm::omp::Directive = target parallel do
+!PARSE-TREE-NEXT: OmpClauseList -> OmpClause -> Order -> OmpOrderClause
+!PARSE-TREE-NEXT: Type = Concurrent
+
+subroutine test_target_parallel_do_simd_order_reproducible()
+ integer :: i, j = 1
+ !CHECK: !$omp target parallel do simd order(reproducible:concurrent)
+ !$omp target parallel do simd order(reproducible:concurrent)
+ do i=1,10
+  j = j + 1
+ end do
+ !$omp end target parallel do simd
+end subroutine
+
+!PARSE-TREE: OpenMPConstruct -> OpenMPLoopConstruct
+!PARSE-TREE-NEXT: OmpBeginLoopDirective
+!PARSE-TREE-NEXT: OmpLoopDirective -> llvm::omp::Directive = target parallel do simd
+!PARSE-TREE-NEXT: OmpClauseList -> OmpClause -> Order -> OmpOrderClause
+!PARSE-TREE-NEXT: Kind = Reproducible
+!PARSE-TREE-NEXT: Type = Concurrent
+
+subroutine test_teams_distribute_simd_order_unconstrained()
+ integer :: i, j = 1
+ !CHECK: !$omp teams distribute simd order(unconstrained:concurrent)
+ !$omp teams distribute simd order(unconstrained:concurrent)
+ do i=1,10
+  j = j + 1
+ end do
+ !$omp end teams distribute simd
+end subroutine
+
+!PARSE-TREE: OpenMPConstruct -> OpenMPLoopConstruct
+!PARSE-TREE-NEXT: OmpBeginLoopDirective
+!PARSE-TREE-NEXT: OmpLoopDirective -> llvm::omp::Directive = teams distribute simd
+!PARSE-TREE-NEXT: OmpClauseList -> OmpClause -> Order -> OmpOrderClause
+!PARSE-TREE-NEXT: Kind = Unconstrained
+!PARSE-TREE-NEXT: Type = Concurrent
+
+subroutine test_teams_distribute_parallel_do_order()
+ integer :: i, j = 1
+ !CHECK: !$omp teams distribute parallel do order(concurrent)
+ !$omp teams distribute parallel do order(concurrent)
+ do i=1,10
+  j = j + 1
+ end do
+ !$omp end teams distribute parallel do
+end subroutine
+
+!PARSE-TREE: OpenMPConstruct -> OpenMPLoopConstruct
+!PARSE-TREE-NEXT: OmpBeginLoopDirective
+!PARSE-TREE-NEXT: OmpLoopDirective -> llvm::omp::Directive = teams distribute parallel do
+!PARSE-TREE-NEXT: OmpClauseList -> OmpClause -> Order -> OmpOrderClause
+!PARSE-TREE-NEXT: Type = Concurrent
+
+subroutine test_teams_distribute_parallel_do_simd_order_reproducible()
+ integer :: i, j = 1
+ !CHECK: !$omp teams distribute parallel do simd order(reproducible:concurrent)
+ !$omp teams distribute parallel do simd order(reproducible:concurrent)
+ do i=1,10
+  j = j + 1
+ end do
+ !$omp end teams distribute parallel do simd
+end subroutine
+
+!PARSE-TREE: OpenMPConstruct -> OpenMPLoopConstruct
+!PARSE-TREE-NEXT: OmpBeginLoopDirective
+!PARSE-TREE-NEXT: OmpLoopDirective -> llvm::omp::Directive = teams distribute parallel do simd
+!PARSE-TREE-NEXT: OmpClauseList -> OmpClause -> Order -> OmpOrderClause
+!PARSE-TREE-NEXT: Kind = Reproducible
+!PARSE-TREE-NEXT: Type = Concurrent
+
+subroutine test_target_teams_distribute_simd_order_unconstrained()
+ integer :: i, j = 1
+ !CHECK: !$omp target teams distribute simd order(unconstrained:concurrent)
+ !$omp target teams distribute simd order(unconstrained:concurrent)
+ do i=1,10
+  j = j + 1
+ end do
+ !$omp end target teams distribute simd
+end subroutine
+
+!PARSE-TREE: OpenMPConstruct -> OpenMPLoopConstruct
+!PARSE-TREE-NEXT: OmpBeginLoopDirective
+!PARSE-TREE-NEXT: OmpLoopDirective -> llvm::omp::Directive = target teams distribute simd
+!PARSE-TREE-NEXT: OmpClauseList -> OmpClause -> Order -> OmpOrderClause
+!PARSE-TREE-NEXT: Kind = Unconstrained
+!PARSE-TREE-NEXT: Type = Concurrent
+
+subroutine test_target_teams_distribute_parallel_do_order()
+ integer :: i, j = 1
+ !CHECK: !$omp target teams distribute parallel do order(concurrent)
+ !$omp target teams distribute parallel do order(concurrent)
+ do i=1,10
+  j = j + 1
+ end do
+ !$omp end target teams distribute parallel do
+end subroutine
+
+!PARSE-TREE: OpenMPConstruct -> OpenMPLoopConstruct
+!PARSE-TREE-NEXT: OmpBeginLoopDirective
+!PARSE-TREE-NEXT: OmpLoopDirective -> llvm::omp::Directive = target teams distribute parallel do
+!PARSE-TREE-NEXT: OmpClauseList -> OmpClause -> Order -> OmpOrderClause
+!PARSE-TREE-NEXT: Type = Concurrent
+
+subroutine test_target_teams_distribute_parallel_do_simd_order_reproducible()
+ integer :: i, j = 1
+ !CHECK: !$omp target teams distribute parallel do simd order(reproducible:concurrent)
+ !$omp target teams distribute parallel do simd order(reproducible:concurrent)
+ do i=1,10
+  j = j + 1
+ end do
+ !$omp end target teams distribute parallel do simd
+end subroutine
+
+!PARSE-TREE: OpenMPConstruct -> OpenMPLoopConstruct
+!PARSE-TREE-NEXT: OmpBeginLoopDirective
+!PARSE-TREE-NEXT: OmpLoopDirective -> llvm::omp::Directive = target teams distribute parallel do simd
+!PARSE-TREE-NEXT: OmpClauseList -> OmpClause -> Order -> OmpOrderClause
+!PARSE-TREE-NEXT: Kind = Reproducible
+!PARSE-TREE-NEXT: Type = Concurrent
+
+subroutine test_taskloop_simd_order_unconstrained()
+ integer :: i, j = 1
+ !CHECK: !$omp taskloop simd order(unconstrained:concurrent)
+ !$omp taskloop simd order(unconstrained:concurrent)
+ do i=1,10
+  j = j + 1
+ end do
+ !$omp end taskloop simd
+end subroutine
+
+!PARSE-TREE: OpenMPConstruct -> OpenMPLoopConstruct
+!PARSE-TREE-NEXT: OmpBeginLoopDirective
+!PARSE-TREE-NEXT: OmpLoopDirective -> llvm::omp::Directive = taskloop simd
+!PARSE-TREE-NEXT: OmpClauseList -> OmpClause -> Order -> OmpOrderClause
+!PARSE-TREE-NEXT: Kind = Unconstrained
+!PARSE-TREE-NEXT: Type = Concurrent

flang/test/Semantics/OpenMP/omp-order-clause01.f90

+! RUN: %python %S/../test_errors.py %s %flang_fc1 -fopenmp
+
+subroutine omp_order()
+ integer :: i, j = 1
+ !ERROR: At most one ORDER clause can appear on the SIMD directive
+ !$omp simd order(concurrent) order(concurrent)
+ do i=1,10
+  j = j + 1
+ end do
+end subroutine omp_order

llvm/include/llvm/Frontend/OpenMP/OMP.td

def OMPC_NonTemporal : Clause<"nontemporal"> {
   let flangClass = "Name";
   let isValueList = true;
 }
 
 def OMP_ORDER_concurrent : ClauseVal<"concurrent",1,1> {}
 def OMP_ORDER_unknown : ClauseVal<"unknown",2,0> { let isDefault = 1; }
 def OMPC_Order : Clause<"order"> {
   let clangClass = "OMPOrderClause";
+  let flangClass = "OmpOrderClause";
   let enumClauseValue = "OrderKind";
   let allowedClauseValues = [
     OMP_ORDER_unknown,
     OMP_ORDER_concurrent
   ];
 }
 def OMPC_Init : Clause<"init"> {
   let clangClass = "OMPInitClause";
def OMP_Simd : Directive<"simd"> {
   let allowedClauses = [
     VersionedClause<OMPC_Private>,
     VersionedClause<OMPC_LastPrivate>,
     VersionedClause<OMPC_Linear>,
     VersionedClause<OMPC_Aligned>,
     VersionedClause<OMPC_Reduction>,
     VersionedClause<OMPC_Allocate>,
     VersionedClause<OMPC_NonTemporal, 50>,
-    VersionedClause<OMPC_Order, 50>
   ];
   let allowedOnceClauses = [
     VersionedClause<OMPC_Collapse>,
     VersionedClause<OMPC_SafeLen>,
     VersionedClause<OMPC_SimdLen>,
     VersionedClause<OMPC_If, 50>,
+    VersionedClause<OMPC_Order, 50>
   ];
 }
 def OMP_Tile : Directive<"tile"> {
   let allowedOnceClauses = [
     VersionedClause<OMPC_Sizes, 51>,
   ];
 }
 def OMP_Unroll : Directive<"unroll"> {
let allowedClauses = [
     VersionedClause<OMPC_LastPrivate>,
     VersionedClause<OMPC_Linear>,
     VersionedClause<OMPC_Reduction>
   ];
   let allowedOnceClauses = [
     VersionedClause<OMPC_Schedule>,
     VersionedClause<OMPC_Collapse>,
     VersionedClause<OMPC_Ordered>,
-    VersionedClause<OMPC_NoWait>
+    VersionedClause<OMPC_NoWait>,
+    VersionedClause<OMPC_Order, 50>
   ];
 }
 def OMP_Sections : Directive<"sections"> {
   let allowedClauses = [
     VersionedClause<OMPC_Private>,
     VersionedClause<OMPC_LastPrivate>,
     VersionedClause<OMPC_FirstPrivate>,
     VersionedClause<OMPC_Reduction>,
let allowedClauses = [
     VersionedClause<OMPC_LastPrivate>,
     VersionedClause<OMPC_Depend>,
     VersionedClause<OMPC_Shared>,
     VersionedClause<OMPC_Reduction>,
     VersionedClause<OMPC_Linear>,
     VersionedClause<OMPC_IsDevicePtr>,
     VersionedClause<OMPC_HasDeviceAddr, 51>,
     VersionedClause<OMPC_Allocator>,
-    VersionedClause<OMPC_Order>,
     VersionedClause<OMPC_UsesAllocators>,
     VersionedClause<OMPC_Default>,
     VersionedClause<OMPC_Copyin>
   ];
   let allowedOnceClauses = [
     VersionedClause<OMPC_If>,
     VersionedClause<OMPC_NumThreads>,
     VersionedClause<OMPC_ProcBind>,
     VersionedClause<OMPC_Device>,
     VersionedClause<OMPC_DefaultMap>,
     VersionedClause<OMPC_Schedule>,
     VersionedClause<OMPC_Collapse>,
     VersionedClause<OMPC_Ordered>,
-    VersionedClause<OMPC_NoWait>
+    VersionedClause<OMPC_NoWait>,
+    VersionedClause<OMPC_Order, 50>
   ];
 }
 def OMP_TargetUpdate : Directive<"target update"> {
   let allowedClauses = [
     VersionedClause<OMPC_To>,
     VersionedClause<OMPC_From>,
     VersionedClause<OMPC_Depend>
   ];
let allowedClauses = [
     VersionedClause<OMPC_Linear>
   ];
   let allowedOnceClauses = [
     VersionedClause<OMPC_If>,
     VersionedClause<OMPC_NumThreads>,
     VersionedClause<OMPC_ProcBind>,
     VersionedClause<OMPC_Schedule>,
     VersionedClause<OMPC_Ordered>,
-    VersionedClause<OMPC_Collapse>
+    VersionedClause<OMPC_Collapse>,
+    VersionedClause<OMPC_Order, 50>
   ];
 }
 def OMP_ParallelForSimd : Directive<"parallel for simd"> {
   let allowedClauses = [
     VersionedClause<OMPC_If>,
     VersionedClause<OMPC_NumThreads>,
     VersionedClause<OMPC_Default>,
     VersionedClause<OMPC_ProcBind>,
let allowedClauses = [
     VersionedClause<OMPC_Shared>,
     VersionedClause<OMPC_Reduction>,
     VersionedClause<OMPC_Copyin>,
     VersionedClause<OMPC_LastPrivate>,
     VersionedClause<OMPC_Linear>,
     VersionedClause<OMPC_Aligned>,
     VersionedClause<OMPC_Allocate>,
     VersionedClause<OMPC_NonTemporal>,
-    VersionedClause<OMPC_Order>
   ];
   let allowedOnceClauses = [
     VersionedClause<OMPC_If>,
     VersionedClause<OMPC_NumThreads>,
     VersionedClause<OMPC_ProcBind>,
     VersionedClause<OMPC_Schedule>,
     VersionedClause<OMPC_Ordered>,
     VersionedClause<OMPC_Collapse>,
     VersionedClause<OMPC_SafeLen>,
-    VersionedClause<OMPC_SimdLen>
+    VersionedClause<OMPC_SimdLen>,
+    VersionedClause<OMPC_Order, 50>
   ];
 }
 def OMP_ParallelMaster : Directive<"parallel master"> {
   let allowedClauses = [
     VersionedClause<OMPC_If>,
     VersionedClause<OMPC_NumThreads>,
     VersionedClause<OMPC_Default>,
     VersionedClause<OMPC_Private>,
let allowedClauses = [
     VersionedClause<OMPC_SafeLen>,
     VersionedClause<OMPC_SimdLen>,
     VersionedClause<OMPC_Linear>,
     VersionedClause<OMPC_Aligned>,
     VersionedClause<OMPC_Ordered>,
     VersionedClause<OMPC_Allocate>,
     VersionedClause<OMPC_If, 50>,
     VersionedClause<OMPC_NonTemporal, 50>,
-    VersionedClause<OMPC_Order, 50>,
+    VersionedClause<OMPC_Order, 50>
   ];
 }
 def OMP_DoSimd : Directive<"do simd"> {
   let allowedClauses = [
     VersionedClause<OMPC_Aligned>,
     VersionedClause<OMPC_Private>,
     VersionedClause<OMPC_FirstPrivate>,
     VersionedClause<OMPC_LastPrivate>,
     VersionedClause<OMPC_Linear>,
     VersionedClause<OMPC_Reduction>
   ];
   let allowedOnceClauses = [
     VersionedClause<OMPC_Schedule>,
     VersionedClause<OMPC_Collapse>,
     VersionedClause<OMPC_Ordered>,
     VersionedClause<OMPC_SafeLen>,
     VersionedClause<OMPC_SimdLen>,
-    VersionedClause<OMPC_NoWait>
+    VersionedClause<OMPC_NoWait>,
+    VersionedClause<OMPC_Order, 50>
   ];
 }
 def OMP_CancellationPoint : Directive<"cancellation point"> {}
 def OMP_DeclareReduction : Directive<"declare reduction"> {}
 def OMP_DeclareMapper : Directive<"declare mapper"> {
   let allowedClauses = [
     VersionedClause<OMPC_Map>
   ];
let allowedClauses = [
     VersionedClause<OMPC_Default>,
     VersionedClause<OMPC_FirstPrivate>,
     VersionedClause<OMPC_InReduction>,
     VersionedClause<OMPC_LastPrivate>,
     VersionedClause<OMPC_Linear>,
     VersionedClause<OMPC_Mergeable>,
     VersionedClause<OMPC_NoGroup>,
     VersionedClause<OMPC_NonTemporal, 50>,
-    VersionedClause<OMPC_Order, 50>,
     VersionedClause<OMPC_Private>,
     VersionedClause<OMPC_Reduction>,
     VersionedClause<OMPC_Shared>,
     VersionedClause<OMPC_Untied>
   ];
   let allowedOnceClauses = [
     VersionedClause<OMPC_If>,
     VersionedClause<OMPC_Collapse>,
     VersionedClause<OMPC_SafeLen>,
     VersionedClause<OMPC_SimdLen>,
     VersionedClause<OMPC_Final>,
-    VersionedClause<OMPC_Priority>
+    VersionedClause<OMPC_Priority>,
+    VersionedClause<OMPC_Order, 50>
   ];
   let allowedExclusiveClauses = [
     VersionedClause<OMPC_GrainSize>,
     VersionedClause<OMPC_NumTasks>
   ];
 }
 def OMP_Distribute : Directive<"distribute"> {
   let allowedClauses = [
def OMP_DistributeParallelFor : Directive<"distribute parallel for"> {
   ];
 }
 def OMP_DistributeParallelDo : Directive<"distribute parallel do"> {
   let allowedClauses = [
     VersionedClause<OMPC_Private>,
     VersionedClause<OMPC_FirstPrivate>,
     VersionedClause<OMPC_LastPrivate>,
     VersionedClause<OMPC_Allocate>,
-    VersionedClause<OMPC_Order>,
     VersionedClause<OMPC_Default>,
     VersionedClause<OMPC_Shared>,
     VersionedClause<OMPC_Reduction>,
     VersionedClause<OMPC_Copyin>,
     VersionedClause<OMPC_Linear>
   ];
   let allowedOnceClauses = [
     VersionedClause<OMPC_Collapse>,
     VersionedClause<OMPC_DistSchedule>,
     VersionedClause<OMPC_If>,
     VersionedClause<OMPC_NumThreads>,
     VersionedClause<OMPC_ProcBind>,
     VersionedClause<OMPC_Schedule>,
-    VersionedClause<OMPC_Ordered>
+    VersionedClause<OMPC_Ordered>,
+    VersionedClause<OMPC_Order, 50>
   ];
 }
 def OMP_DistributeParallelForSimd : Directive<"distribute parallel for simd"> {
   let allowedClauses = [
     VersionedClause<OMPC_FirstPrivate>,
     VersionedClause<OMPC_LastPrivate>,
     VersionedClause<OMPC_Collapse>,
     VersionedClause<OMPC_DistSchedule>,
let allowedClauses = [
     VersionedClause<OMPC_Copyin>,
     VersionedClause<OMPC_Schedule>,
     VersionedClause<OMPC_Linear>,
     VersionedClause<OMPC_Aligned>,
     VersionedClause<OMPC_SafeLen>,
     VersionedClause<OMPC_SimdLen>,
     VersionedClause<OMPC_Allocate>,
     VersionedClause<OMPC_NonTemporal>,
-    VersionedClause<OMPC_Order>
+    VersionedClause<OMPC_Order, 50>
   ];
 }
 def OMP_DistributeSimd : Directive<"distribute simd"> {
   let allowedClauses = [
     VersionedClause<OMPC_Aligned>,
     VersionedClause<OMPC_Allocate>,
     VersionedClause<OMPC_Copyin>,
     VersionedClause<OMPC_Default>,
     VersionedClause<OMPC_Linear>,
     VersionedClause<OMPC_FirstPrivate>,
     VersionedClause<OMPC_LastPrivate>,
     VersionedClause<OMPC_NonTemporal, 50>,
-    VersionedClause<OMPC_Order, 50>,
     VersionedClause<OMPC_Private>,
     VersionedClause<OMPC_Reduction>
   ];
   let allowedOnceClauses = [
     VersionedClause<OMPC_Collapse>,
     VersionedClause<OMPC_DistSchedule>,
     VersionedClause<OMPC_If, 50>,
     VersionedClause<OMPC_NumThreads>,
     VersionedClause<OMPC_Ordered>,
     VersionedClause<OMPC_ProcBind>,
     VersionedClause<OMPC_Schedule>,
     VersionedClause<OMPC_SafeLen>,
-    VersionedClause<OMPC_SimdLen>
+    VersionedClause<OMPC_SimdLen>,
+    VersionedClause<OMPC_Order, 50>
   ];
 }
 
 def OMP_TargetParallelForSimd : Directive<"target parallel for simd"> {
   let allowedClauses = [
     VersionedClause<OMPC_If>,
     VersionedClause<OMPC_Device>,
     VersionedClause<OMPC_Map>,
let allowedClauses = [
     VersionedClause<OMPC_Linear>,
     VersionedClause<OMPC_SafeLen>,
     VersionedClause<OMPC_SimdLen>,
     VersionedClause<OMPC_Aligned>,
     VersionedClause<OMPC_IsDevicePtr>,
     VersionedClause<OMPC_HasDeviceAddr, 51>,
     VersionedClause<OMPC_Allocate>,
     VersionedClause<OMPC_NonTemporal>,
-    VersionedClause<OMPC_Order>,
+    VersionedClause<OMPC_Order, 50>,
     VersionedClause<OMPC_UsesAllocators>
   ];
 }
 def OMP_TargetSimd : Directive<"target simd"> {
   let allowedClauses = [
     VersionedClause<OMPC_Aligned>,
     VersionedClause<OMPC_Allocate>,
     VersionedClause<OMPC_Depend>,
     VersionedClause<OMPC_FirstPrivate>,
     VersionedClause<OMPC_IsDevicePtr>,
     VersionedClause<OMPC_HasDeviceAddr, 51>,
     VersionedClause<OMPC_LastPrivate>,
     VersionedClause<OMPC_Linear>,
     VersionedClause<OMPC_Map>,
     VersionedClause<OMPC_NonTemporal, 50>,
     VersionedClause<OMPC_NoWait>,
-    VersionedClause<OMPC_Order, 50>,
     VersionedClause<OMPC_Private>,
     VersionedClause<OMPC_Reduction>,
     VersionedClause<OMPC_Shared>,
     VersionedClause<OMPC_UsesAllocators, 50>
   ];
   let allowedOnceClauses = [
     VersionedClause<OMPC_Collapse>,
     VersionedClause<OMPC_SafeLen>,
     VersionedClause<OMPC_SimdLen>,
     VersionedClause<OMPC_If>,
     VersionedClause<OMPC_NumThreads>,
     VersionedClause<OMPC_ProcBind>,
     VersionedClause<OMPC_Device>,
     VersionedClause<OMPC_DefaultMap>,
     VersionedClause<OMPC_Schedule>,
     VersionedClause<OMPC_OMPX_DynCGroupMem>,
+    VersionedClause<OMPC_Order, 50>
   ];
 }
 def OMP_TeamsDistribute : Directive<"teams distribute"> {
   let allowedClauses = [
     VersionedClause<OMPC_Default>,
     VersionedClause<OMPC_Private>,
     VersionedClause<OMPC_FirstPrivate>,
     VersionedClause<OMPC_Shared>,

 def OMP_TeamsDistributeSimd : Directive<"teams distribute simd"> {
   let allowedClauses = [
     VersionedClause<OMPC_Aligned>,
     VersionedClause<OMPC_Allocate>,
     VersionedClause<OMPC_FirstPrivate>,
     VersionedClause<OMPC_LastPrivate>,
     VersionedClause<OMPC_Linear>,
     VersionedClause<OMPC_NonTemporal, 50>,
-    VersionedClause<OMPC_Order, 50>,
     VersionedClause<OMPC_Private>,
     VersionedClause<OMPC_Reduction>,
     VersionedClause<OMPC_Shared>
   ];
   let allowedOnceClauses = [
     VersionedClause<OMPC_Collapse>,
     VersionedClause<OMPC_Default>,
     VersionedClause<OMPC_DistSchedule>,
     VersionedClause<OMPC_If, 50>,
     VersionedClause<OMPC_NumTeams>,
     VersionedClause<OMPC_SafeLen>,
     VersionedClause<OMPC_SimdLen>,
-    VersionedClause<OMPC_ThreadLimit>
+    VersionedClause<OMPC_ThreadLimit>,
+    VersionedClause<OMPC_Order, 50>
   ];
 }
 
 def OMP_TeamsDistributeParallelForSimd :
     Directive<"teams distribute parallel for simd"> {
   let allowedClauses = [
     VersionedClause<OMPC_FirstPrivate>,
     VersionedClause<OMPC_LastPrivate>,
def OMP_TeamsDistributeParallelDoSimd :
   let allowedClauses = [
     VersionedClause<OMPC_Private>,
     VersionedClause<OMPC_FirstPrivate>,
     VersionedClause<OMPC_LastPrivate>,
     VersionedClause<OMPC_Allocate>,
     VersionedClause<OMPC_Shared>,
     VersionedClause<OMPC_Reduction>,
     VersionedClause<OMPC_Linear>,
-    VersionedClause<OMPC_Order>,
     VersionedClause<OMPC_Aligned>,
     VersionedClause<OMPC_NonTemporal>
   ];
   let allowedOnceClauses = [
     VersionedClause<OMPC_Default>,
     VersionedClause<OMPC_NumTeams>,
     VersionedClause<OMPC_ThreadLimit>,
     VersionedClause<OMPC_Collapse>,
     VersionedClause<OMPC_DistSchedule>,
     VersionedClause<OMPC_NumThreads>,
     VersionedClause<OMPC_ProcBind>,
     VersionedClause<OMPC_Schedule>,
     VersionedClause<OMPC_SafeLen>,
     VersionedClause<OMPC_SimdLen>,
     VersionedClause<OMPC_If>,
+    VersionedClause<OMPC_Order, 50>
   ];
 }
 def OMP_TeamsDistributeParallelFor :
     Directive<"teams distribute parallel for"> {
   let allowedClauses = [
     VersionedClause<OMPC_FirstPrivate>,
     VersionedClause<OMPC_LastPrivate>,
     VersionedClause<OMPC_Collapse>,
def OMP_TeamsDistributeParallelDo :
   ];
 let allowedOnceClauses = [
     VersionedClause<OMPC_NumTeams>,
     VersionedClause<OMPC_ThreadLimit>,
     VersionedClause<OMPC_Default>,
     VersionedClause<OMPC_Collapse>,
     VersionedClause<OMPC_DistSchedule>,
     VersionedClause<OMPC_Ordered>,
-    VersionedClause<OMPC_Order>,
     VersionedClause<OMPC_If>,
     VersionedClause<OMPC_NumThreads>,
     VersionedClause<OMPC_ProcBind>,
-    VersionedClause<OMPC_Schedule>
+    VersionedClause<OMPC_Schedule>,
+    VersionedClause<OMPC_Order, 50>
   ];
 }
 def OMP_TargetTeams : Directive<"target teams"> {
   let allowedClauses = [
     VersionedClause<OMPC_If>,
     VersionedClause<OMPC_Map>,
     VersionedClause<OMPC_Private>,
     VersionedClause<OMPC_Depend>,
let allowedClauses = [
     VersionedClause<OMPC_Reduction>,
     VersionedClause<OMPC_Allocate>,
     VersionedClause<OMPC_UsesAllocators>,
     VersionedClause<OMPC_Shared>,
     VersionedClause<OMPC_LastPrivate>,
     VersionedClause<OMPC_Copyin>,
     VersionedClause<OMPC_Linear>,
     VersionedClause<OMPC_Ordered>,
-    VersionedClause<OMPC_Order>
   ];
   let allowedOnceClauses = [
     VersionedClause<OMPC_Device>,
     VersionedClause<OMPC_DefaultMap>,
     VersionedClause<OMPC_NoWait>,
     VersionedClause<OMPC_Default>,
     VersionedClause<OMPC_NumTeams>,
     VersionedClause<OMPC_ThreadLimit>,
     VersionedClause<OMPC_Collapse>,
     VersionedClause<OMPC_DistSchedule>,
     VersionedClause<OMPC_NumThreads>,
     VersionedClause<OMPC_ProcBind>,
     VersionedClause<OMPC_Schedule>,
+    VersionedClause<OMPC_Order, 50>
   ];
 }
 def OMP_TargetTeamsDistributeParallelForSimd :
     Directive<"target teams distribute parallel for simd"> {
   let allowedClauses = [
     VersionedClause<OMPC_If>,
     VersionedClause<OMPC_Device>,
     VersionedClause<OMPC_Map>,
let allowedClauses = [
     VersionedClause<OMPC_Reduction>,
     VersionedClause<OMPC_Allocate>,
     VersionedClause<OMPC_UsesAllocators>,
     VersionedClause<OMPC_Shared>,
     VersionedClause<OMPC_LastPrivate>,
     VersionedClause<OMPC_Copyin>,
     VersionedClause<OMPC_Linear>,
     VersionedClause<OMPC_Ordered>,
-    VersionedClause<OMPC_Order>,
     VersionedClause<OMPC_Aligned>,
     VersionedClause<OMPC_NonTemporal>
   ];
   let allowedOnceClauses = [
     VersionedClause<OMPC_If>,
     VersionedClause<OMPC_Device>,
     VersionedClause<OMPC_NoWait>,
     VersionedClause<OMPC_DefaultMap>,
     VersionedClause<OMPC_Default>,
     VersionedClause<OMPC_NumTeams>,
     VersionedClause<OMPC_ThreadLimit>,
     VersionedClause<OMPC_Collapse>,
     VersionedClause<OMPC_DistSchedule>,
     VersionedClause<OMPC_NumThreads>,
     VersionedClause<OMPC_ProcBind>,
     VersionedClause<OMPC_Schedule>,
     VersionedClause<OMPC_SafeLen>,
-    VersionedClause<OMPC_SimdLen>
+    VersionedClause<OMPC_SimdLen>,
+    VersionedClause<OMPC_Order, 50>
   ];
 }
 def OMP_TargetTeamsDistributeSimd :
     Directive<"target teams distribute simd"> {
   let allowedClauses = [
     VersionedClause<OMPC_Aligned>,
     VersionedClause<OMPC_Allocate>,
     VersionedClause<OMPC_Depend>,
     VersionedClause<OMPC_FirstPrivate>,
     VersionedClause<OMPC_If>,
     VersionedClause<OMPC_IsDevicePtr>,
     VersionedClause<OMPC_HasDeviceAddr, 51>,
     VersionedClause<OMPC_LastPrivate>,
     VersionedClause<OMPC_Linear>,
     VersionedClause<OMPC_Map>,
     VersionedClause<OMPC_NonTemporal, 50>,
-    VersionedClause<OMPC_Order, 50>,
     VersionedClause<OMPC_Private>,
     VersionedClause<OMPC_Reduction>,
     VersionedClause<OMPC_Shared>,
     VersionedClause<OMPC_UsesAllocators, 50>
   ];
   let allowedOnceClauses = [
     VersionedClause<OMPC_Device>,
     VersionedClause<OMPC_DefaultMap>,
     VersionedClause<OMPC_NoWait>,
     VersionedClause<OMPC_NumTeams>,
     VersionedClause<OMPC_ThreadLimit>,
     VersionedClause<OMPC_Collapse>,
     VersionedClause<OMPC_DistSchedule>,
     VersionedClause<OMPC_SafeLen>,
     VersionedClause<OMPC_SimdLen>,
     VersionedClause<OMPC_OMPX_DynCGroupMem>,
+    VersionedClause<OMPC_Order, 50>
   ];
 }
 def OMP_Allocate : Directive<"allocate"> {
   let allowedOnceClauses = [
     VersionedClause<OMPC_Allocator>,
     VersionedClause<OMPC_Align, 51>
   ];
 }
def OMP_loop : Directive<"loop"> {
   let allowedClauses = [
     VersionedClause<OMPC_LastPrivate>,
     VersionedClause<OMPC_Private>,
     VersionedClause<OMPC_Reduction>,
   ];
   let allowedOnceClauses = [
     VersionedClause<OMPC_Bind, 50>,
     VersionedClause<OMPC_Collapse>,
-    VersionedClause<OMPC_Order>,
+    VersionedClause<OMPC_Order, 50>
   ];
 }
 def OMP_teams_loop : Directive<"teams loop"> {
   let allowedClauses = [
     VersionedClause<OMPC_Allocate>,
     VersionedClause<OMPC_FirstPrivate>,
     VersionedClause<OMPC_LastPrivate>,
     VersionedClause<OMPC_Private>,