[flang][OpenMP] Add semantic checks of nesting of region about ordered construct

[peixin]

Summary

This patch supports the following checks for ORDERED construct:

[5.1] 2.19.9 ORDERED Construct
The worksharing-loop or worksharing-loop SIMD region to which an ordered
region corresponding to an ordered construct without a depend clause
binds must have an ordered clause without the parameter specified on the 
corresponding worksharing-loop or worksharing-loop SIMD directive.
The worksharing-loop region to which an ordered region that corresponds
to an ordered construct with any depend clauses binds must have an
ordered clause with the parameter specified on the corresponding
worksharing-loop directive.
An ordered construct with the depend clause specified must be closely
nested inside a worksharing-loop (or parallel worksharing-loop)
construct.
An ordered region that corresponds to an ordered construct with the simd
clause specified must be closely nested inside a simd or
worksharing-loop SIMD region.

[peixin]

The following two checks cannot be fully supported because of limited inter-procedure analysis.

An ordered region that corresponds to an ordered construct without the simd clause specified must be closely nested inside a worksharing-loop region.
During execution of an iteration of a worksharing-loop or a loop nest within a worksharing-loop, simd, or worksharing-loop SIMD region, a thread must not execute more than one ordered region that corresponds to an ordered construct without a depend clause.

Up to now, all the semantic checks of nesting of regions about ordered construct nested in worksharing-loop, SIMD, or worksharing-loop SIMD region are supported.

[NimishMishra]

LGTM. I had concerns about removal of OmpStructureChecker::CheckIfDoOrderedClause but I guess condensing all checks in one function is a better decision. We could wait for others' comments before landing the patch

[shraiysh]

Hi @peixin. Thanks for the patch. I had a few comments.

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

772

There are too many branches inside the for loop. Can we make it of the form?

for(...) {
  isNestedInDo = ...
  isNestedInSIMD = ...
  ... <same for other bool variables> ...
  if (isNestedInDo || isNestedInSIMD || ...)
    break;
}

That would be more readable and will reduce the branching in this code.

774–775

Suggestion: Considering changing this to

isNestedInDoSIMD = llvm::omp::doSimdSet.test(dirContext_[i].directive)

780–782

Can we change this to

isOrderedClauseWithPara = GetIntValue(orderedClause.v) > 0;

784

Instead of having the bool noOrderedClause we can probably save the clause (Line #776) as a nullptr which can be used for checking later by simply checking !clause. (again, aiming at reducing the branches in code to make it more readable).

794

There is no test case for this.

818

Nit: error message is inconsistent with others (others do not use parentheses).

flang/test/Semantics/omp-do06.f90

24

As far as I can tell there is no "good" testcase for this. Like

!$omp do ordered
do i = 1, 10
  print *, i
  !$omp ordered
      print *,i
  !$omp end ordered
end do
!$omp end do

Can we maybe add such testcase, if it is not already there?

[peixin]

Update and rebase.

[peixin]

Thanks @shraiysh for the review. Addressed the comments.

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

772

These bool variables cannot declared inside the for loop. They are collected when going through all the nested direcitives and checked to emit the error messages later.

774–775

Fixed.

780–782

Fixed.

784

noOrderedClause defines what it means. I think it's better to store one bool variable instead of one class object. The branches cannot be reduced even if save the clause.

794

This check is moved from CheckIfDoOrderedClause and the test case omp-ordered-simd.f90 has been added before.

818

Please check the commit message. These error messages are from the standard. I use the original restrictions of the standard.

flang/test/Semantics/omp-do06.f90

24

Added in omp_ordered02.f90.

[shraiysh]

Thanks for addressing the comments @peixin. One minor comment, rest LGTM. (Please wait for one more review because I am not an expert in this part of the code).

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

771–799

I meant changing it this way. This will eliminate constructs like this -

if(condition)
  var = true;

by setting var = condition. This change passes all the tests in the current patch. Please let me know if I have missed something here.

784

Okay.

794

Oh okay, thanks for the clarification.

[peixin]

In D113399#3230599, @shraiysh wrote:

Thanks for addressing the comments @peixin. One minor comment, rest LGTM. (Please wait for one more review because I am not an expert in this part of the code).

Sure. Thanks for the notice.

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

771–799

Oh. This change sacrifice the time cost. For example, isOrderedClauseWithPara is true for !$omp simd ordered(2). Actually, the code inside the if condition of (llvm::omp::doSet.test(dirContext_[i].directive)) should never be run for this case. So, the left if conditions are useful to avoid extra operations. What do you think?

[peixin]

Reformat the if conditions.

[peixin]

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

771–799

@shraiysh I reformat these checks. The current code should be more readable.

[peixin]

Rebase and ping @kiranchandramohan

[kiranchandramohan]

I have a few comments, mostly Nits.

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

274

Can you move this closer to the FindClause function above and define the above FindClause function in terms of this?

const PC *FindClause(C type) {
  return FindClause(GetContext(), type);
}

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

764–769

Nit: for all above please use braced initialization

808

Nit: Use curlies

812

Nit: Use curlies

1142

Nit: curlies

[peixin]

Addressed comments from @kiranchandramohan .

[kiranchandramohan]

LGTM. Thanks @peixin and apologies for the long wait.

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

1110

Nit: braced init.

1136

Nit: Braced init if possible.

[peixin]

Fix two nits and rebase to test CI before land.

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

void SetContextClauseInfo(C type) {
     GetContext().clauseInfo.emplace(type, GetContext().clause);
   }
 
   void AddClauseToCrtContext(C type) {
     GetContext().actualClauses.push_back(type);
   }
 
   // Check if the given clause is present in the current context
-  const PC *FindClause(C type) {
-    auto it{GetContext().clauseInfo.find(type)};
-    if (it != GetContext().clauseInfo.end()) {
+  const PC *FindClause(C type) { return FindClause(GetContext(), type); }
+
+  // Check if the given clause is present in the given context
+  const PC *FindClause(DirectiveContext &context, C type) {
+    auto it{context.clauseInfo.find(type)};
+    if (it != context.clauseInfo.end()) {
       return it->second;
     }
     return nullptr;
   }
 
   // Check if the given clause is present in the parent context
   const PC *FindClauseParent(C type) {
     auto it{GetContextParent().clauseInfo.find(type)};
     if (it != GetContextParent().clauseInfo.end()) {
       return it->second;
     }
     return nullptr;
   }
 
   std::pair<typename ClauseMapTy::iterator, typename ClauseMapTy::iterator>
   FindClauses(C type) {
     auto it{GetContext().clauseInfo.equal_range(type)};
     return it;
   }
 
   DirectiveContext *GetEnclosingDirContext() {
     CHECK(!dirContext_.empty());
     auto it{dirContext_.rbegin()};
     if (++it != dirContext_.rend()) {

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

private:
   void CheckAtomicUpdateAssignmentStmt(const parser::AssignmentStmt &);
   void CheckAtomicConstructStructure(const parser::OpenMPAtomicConstruct &);
   void CheckDistLinear(const parser::OpenMPLoopConstruct &x);
   void CheckSIMDNest(const parser::OpenMPConstruct &x);
   void CheckTargetNest(const parser::OpenMPConstruct &x);
   void CheckCancellationNest(
       const parser::CharBlock &source, const parser::OmpCancelType::Type &type);
   std::int64_t GetOrdCollapseLevel(const parser::OpenMPLoopConstruct &x);
-  void CheckIfDoOrderedClause(const parser::OmpBlockDirective &blkDirectiv);
   bool CheckReductionOperators(const parser::OmpClause::Reduction &);
   bool CheckIntrinsicOperator(
       const parser::DefinedOperator::IntrinsicOperator &);
   void CheckReductionTypeList(const parser::OmpClause::Reduction &);
   void CheckMasterNesting(const parser::OpenMPBlockConstruct &x);
   void ChecksOnOrderedAsBlock();
   void CheckBarrierNesting(const parser::OpenMPSimpleStandaloneConstruct &x);
   void ChecksOnOrderedAsStandalone();
+  void CheckOrderedDependClause(std::optional<std::int64_t> orderedValue);
   void CheckReductionArraySection(const parser::OmpObjectList &ompObjectList);
   void CheckIntentInPointerAndDefinable(
       const parser::OmpObjectList &, const llvm::omp::Clause);
   void CheckArraySection(const parser::ArrayElement &arrayElement,
       const parser::Name &name, const llvm::omp::Clause clause);
   void CheckMultipleAppearanceAcrossContext(
       const parser::OmpObjectList &ompObjectList);
   const parser::OmpObjectList *GetOmpObjectList(const parser::OmpClause &);

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

void OmpStructureChecker::Enter(const parser::OpenMPBlockConstruct &x) {
   CheckMatching<parser::OmpBlockDirective>(beginDir, endDir);
 
   PushContextAndClauseSets(beginDir.source, beginDir.v);
   if (GetContext().directive == llvm::omp::Directive::OMPD_target) {
     EnterDirectiveNest(TargetNest);
   }
 
   if (CurrentDirectiveIsNested()) {
-    CheckIfDoOrderedClause(beginDir);
     if (llvm::omp::teamSet.test(GetContextParent().directive)) {
       HasInvalidTeamsNesting(beginDir.v, beginDir.source);
     }
     if (GetContext().directive == llvm::omp::Directive::OMPD_master) {
       CheckMasterNesting(x);
     }
     // A teams region can only be strictly nested within the implicit parallel
     // region or a target region.
void OmpStructureChecker::CheckMasterNesting(
   if (IsCloselyNestedRegion(llvm::omp::nestedMasterErrSet)) {
     context_.Say(parser::FindSourceLocation(x),
         "`MASTER` region may not be closely nested inside of `WORKSHARING`, "
         "`LOOP`, `TASK`, `TASKLOOP`,"
         " or `ATOMIC` region."_err_en_US);
   }
 }
 
-void OmpStructureChecker::CheckIfDoOrderedClause(
-    const parser::OmpBlockDirective &blkDirective) {
-  if (blkDirective.v == llvm::omp::OMPD_ordered) {
-    // Loops
-    if (llvm::omp::doSet.test(GetContextParent().directive) &&
-        !FindClauseParent(llvm::omp::Clause::OMPC_ordered)) {
-      context_.Say(blkDirective.source,
-          "The ORDERED clause must be present on the loop"
-          " construct if any ORDERED region ever binds"
-          " to a loop region arising from the loop construct."_err_en_US);
-    }
-    // Other disallowed nestings, these directives do not support
-    // ordered clause in them, so no need to check
-    else if (IsCloselyNestedRegion(llvm::omp::nestedOrderedErrSet)) {
-      context_.Say(blkDirective.source,
-          "`ORDERED` region may not be closely nested inside of "
-          "`CRITICAL`, `ORDERED`, explicit `TASK` or `TASKLOOP` region."_err_en_US);
-    }
-  }
-}
-
 void OmpStructureChecker::Leave(const parser::OpenMPBlockConstruct &) {
   if (GetDirectiveNest(TargetBlockOnlyTeams)) {
     ExitDirectiveNest(TargetBlockOnlyTeams);
   }
   if (GetContext().directive == llvm::omp::Directive::OMPD_target) {
     ExitDirectiveNest(TargetNest);
   }
   dirContext_.pop_back();
 }
 
 void OmpStructureChecker::ChecksOnOrderedAsBlock() {
   if (FindClause(llvm::omp::Clause::OMPC_depend)) {
     context_.Say(GetContext().clauseSource,
         "DEPEND(*) clauses are not allowed when ORDERED construct is a block"
         " construct with an ORDERED region"_err_en_US);
+    return;
+  }
+
+  OmpDirectiveSet notAllowedParallelSet{llvm::omp::Directive::OMPD_parallel,
+      llvm::omp::Directive::OMPD_target_parallel,
+      llvm::omp::Directive::OMPD_parallel_sections,
+      llvm::omp::Directive::OMPD_parallel_workshare};
+  bool isNestedInDo{false};
+  bool isNestedInDoSIMD{false};
+  bool isNestedInSIMD{false};
+  bool noOrderedClause{false};
+  bool isOrderedClauseWithPara{false};
+  bool isCloselyNestedRegion{true};
+  if (CurrentDirectiveIsNested()) {
+    for (int i = (int)dirContext_.size() - 2; i >= 0; i--) {
+      if (llvm::omp::nestedOrderedErrSet.test(dirContext_[i].directive)) {
+        context_.Say(GetContext().directiveSource,
+            "`ORDERED` region may not be closely nested inside of `CRITICAL`, "
+            "`ORDERED`, explicit `TASK` or `TASKLOOP` region."_err_en_US);
+        break;
+      } else if (llvm::omp::doSet.test(dirContext_[i].directive)) {
+        isNestedInDo = true;
+        isNestedInDoSIMD = llvm::omp::doSimdSet.test(dirContext_[i].directive);
+        if (const auto *clause{
+                FindClause(dirContext_[i], llvm::omp::Clause::OMPC_ordered)}) {
+          const auto &orderedClause{
+              std::get<parser::OmpClause::Ordered>(clause->u)};
+          const auto orderedValue{GetIntValue(orderedClause.v)};
+          isOrderedClauseWithPara = orderedValue > 0;
+        } else {
+          noOrderedClause = true;
+        }
+        break;
+      } else if (llvm::omp::simdSet.test(dirContext_[i].directive)) {
+        isNestedInSIMD = true;
+        break;
+      } else if (notAllowedParallelSet.test(dirContext_[i].directive)) {
+        isCloselyNestedRegion = false;
+        break;
+      }
+    }
+  }
+
+  if (!isCloselyNestedRegion) {
+    context_.Say(GetContext().directiveSource,
+        "An ORDERED directive without the DEPEND clause must be closely nested "
+        "in a SIMD, worksharing-loop, or worksharing-loop SIMD "
+        "region"_err_en_US);
+  } else {
+    if (CurrentDirectiveIsNested() &&
+        FindClause(llvm::omp::Clause::OMPC_simd) &&
+        (!isNestedInDoSIMD && !isNestedInSIMD)) {
+      context_.Say(GetContext().directiveSource,
+          "An ORDERED directive with SIMD clause must be closely nested in a "
+          "SIMD or worksharing-loop SIMD region"_err_en_US);
+    }
+    if (isNestedInDo && (noOrderedClause || isOrderedClauseWithPara)) {
+      context_.Say(GetContext().directiveSource,
+          "An ORDERED directive without the DEPEND clause must be closely "
+          "nested in a worksharing-loop (or worksharing-loop SIMD) region with "
+          "ORDERED clause without the parameter"_err_en_US);
+    }
   }
 }
 
 void OmpStructureChecker::Leave(const parser::OmpBeginBlockDirective &) {
   switch (GetContext().directive) {
   case llvm::omp::Directive::OMPD_ordered:
     // [5.1] 2.19.9 Ordered Construct Restriction
     ChecksOnOrderedAsBlock();
if (std::get_if<parser::OmpDependClause::Source>(&dependClause.v.u)) {
       }
     } else {
       context_.Say(itr->second->source,
           "Only DEPEND(SOURCE) or DEPEND(SINK: vec) are allowed when ORDERED "
           "construct is a standalone construct with no ORDERED "
           "region"_err_en_US);
     }
   }
+
+  OmpDirectiveSet allowedDoSet{llvm::omp::Directive::OMPD_do,
+      llvm::omp::Directive::OMPD_parallel_do,
+      llvm::omp::Directive::OMPD_target_parallel_do};
+  bool isNestedInDoOrderedWithPara{false};
+  if (CurrentDirectiveIsNested() &&
+      allowedDoSet.test(GetContextParent().directive)) {
+    if (const auto *clause{
+            FindClause(GetContextParent(), llvm::omp::Clause::OMPC_ordered)}) {
+      const auto &orderedClause{
+          std::get<parser::OmpClause::Ordered>(clause->u)};
+      const auto orderedValue{GetIntValue(orderedClause.v)};
+      if (orderedValue > 0) {
+        isNestedInDoOrderedWithPara = true;
+        CheckOrderedDependClause(orderedValue);
+      }
+    }
+  }
+
+  if (FindClause(llvm::omp::Clause::OMPC_depend) &&
+      !isNestedInDoOrderedWithPara) {
+    context_.Say(GetContext().clauseSource,
+        "An ORDERED construct with the DEPEND clause must be closely nested "
+        "in a worksharing-loop (or parallel worksharing-loop) construct with "
+        "ORDERED clause with a parameter"_err_en_US);
+  }
+}
+
+void OmpStructureChecker::CheckOrderedDependClause(
+    std::optional<std::int64_t> orderedValue) {
+  auto clauseAll{FindClauses(llvm::omp::Clause::OMPC_depend)};
+  for (auto itr = clauseAll.first; itr != clauseAll.second; ++itr) {
+    const auto &dependClause{
+        std::get<parser::OmpClause::Depend>(itr->second->u)};
+    if (const auto *sinkVectors{
+            std::get_if<parser::OmpDependClause::Sink>(&dependClause.v.u)}) {
+      std::int64_t numVar = sinkVectors->v.size();
+      if (orderedValue != numVar) {
+        context_.Say(itr->second->source,
+            "The number of variables in DEPEND(SINK: vec) clause does not "
+            "match the parameter specified in ORDERED clause"_err_en_US);
+      }
+    }
+  }
 }
 
 void OmpStructureChecker::Enter(
     const parser::OpenMPSimpleStandaloneConstruct &x) {
   const auto &dir{std::get<parser::OmpSimpleStandaloneDirective>(x.t)};
   PushContextAndClauseSets(dir.source, dir.v);
   CheckBarrierNesting(x);
 }

flang/test/Semantics/omp-do-ordered-positivecases.f90

do j=1,10
       !DEF: /omp_doordered/Block2/k (OmpPrivate, OmpPreDetermined) HostAssoc INTEGER(4)
       do k=1,10
         print *, "hello"
       end do
       !$omp end do
     end do
   end do
 
-  !$omp do  ordered(1)
+  !$omp do ordered
   !DEF: /omp_doordered/Block3/i (OmpPrivate, OmpPreDetermined) HostAssoc INTEGER(4)
   do i=1,10
     !$omp ordered
     !REF: /omp_doordered/j
     do j=1,10
       print *, "hello"
     end do
     !$omp end ordered
   end do
   !$omp end do
 
   !$omp do  collapse(1) ordered(2)
   !DEF: /omp_doordered/Block4/i (OmpPrivate, OmpPreDetermined) HostAssoc INTEGER(4)
   do i=1,10
     !DEF: /omp_doordered/Block4/j (OmpPrivate, OmpPreDetermined) HostAssoc INTEGER(4)
     do j=1,10
       print *, "hello"
     end do
   end do
   !$omp end do
 
   !$omp parallel  num_threads(4)
-  !$omp do  ordered(1) collapse(1)
+  !$omp do ordered collapse(1)
   !DEF: /omp_doordered/Block5/Block1/i (OmpPrivate, OmpPreDetermined) HostAssoc INTEGER(4)
   do i=1,10
     !$omp ordered
     !DEF: /omp_doordered/Block5/j (OmpPrivate, OmpPreDetermined) HostAssoc INTEGER(4)
     do j=1,10
       print *, "hello"
     end do
     !$omp end ordered
   end do
   !$omp end parallel
 end program omp_doordered

flang/test/Semantics/omp-do-ordered.f90

do j = 1, 10
       end do
       !$omp end do
     end do
   end do
 
   !ERROR: The value of the parameter in the COLLAPSE or ORDERED clause must not be larger than the number of nested loops following the construct.
   !$omp do ordered(2)
   do i = 1,10
+    !ERROR: An ORDERED directive without the DEPEND clause must be closely nested in a worksharing-loop (or worksharing-loop SIMD) region with ORDERED clause without the parameter
     !$omp ordered
     do j = 1, 10
        print *, "hello"
     end do
     !$omp end ordered
   end do
   !$omp end do
 
   !ERROR: The value of the parameter in the COLLAPSE or ORDERED clause must not be larger than the number of nested loops following the construct.
   !$omp do collapse(1) ordered(3)
   do i = 1,10
     do j = 1, 10
        print *, "hello"
     end do
   end do
   !$omp end do
 
   !$omp parallel num_threads(4)
   !ERROR: The value of the parameter in the COLLAPSE or ORDERED clause must not be larger than the number of nested loops following the construct.
   !$omp do ordered(2) collapse(1)
   do i = 1,10
+    !ERROR: An ORDERED directive without the DEPEND clause must be closely nested in a worksharing-loop (or worksharing-loop SIMD) region with ORDERED clause without the parameter
     !$omp ordered
     do j = 1, 10
        print *, "hello"
     end do
     !$omp end ordered
   end do
   !$omp end parallel
 end program omp_doOrdered

flang/test/Semantics/omp-do06.f90

 ! RUN: %python %S/test_errors.py %s %flang -fopenmp
 ! OpenMP Version 4.5
 ! 2.7.1 Loop Construct
 ! The ordered clause must be present on the loop construct if any ordered
 ! region ever binds to a loop region arising from the loop construct.
 
 program omp_do
   integer i, j, k
 
   !$omp do
   do i = 1, 10
-    !ERROR: The ORDERED clause must be present on the loop construct if any ORDERED region ever binds to a loop region arising from the loop construct.
+    !ERROR: An ORDERED directive without the DEPEND clause must be closely nested in a worksharing-loop (or worksharing-loop SIMD) region with ORDERED clause without the parameter
     !$omp ordered
     call my_func()
     !$omp end ordered
   end do
   !$omp end do
 
   !$omp do ordered private(i)
   do i = 1, 10
     !$omp parallel do
     do j = 1, 10
       print *,i
-      !ERROR: The ORDERED clause must be present on the loop construct if any ORDERED region ever binds to a loop region arising from the loop construct.
+      !ERROR: An ORDERED directive without the DEPEND clause must be closely nested in a worksharing-loop (or worksharing-loop SIMD) region with ORDERED clause without the parameter
       !$omp ordered
       print *,i
       !$omp end ordered
     end do
     !$omp end parallel do
   end do
   !$omp end do
 
 end program omp_do

flang/test/Semantics/omp-ordered-simd.f90

 
 SUBROUTINE ORDERED_BAD(N)
   INTEGER N, I, A(10), B(10), C(10)
 
   !$OMP DO SIMD
   DO I = 1,N
     IF (I <= 10) THEN
       !ERROR: The only OpenMP constructs that can be encountered during execution of a 'SIMD' region are the `ATOMIC` construct, the `LOOP` construct, the `SIMD` construct and the `ORDERED` construct with the `SIMD` clause.
-      !ERROR: The ORDERED clause must be present on the loop construct if any ORDERED region ever binds to a loop region arising from the loop construct.
+      !ERROR: An ORDERED directive without the DEPEND clause must be closely nested in a worksharing-loop (or worksharing-loop SIMD) region with ORDERED clause without the parameter
       !$OMP ORDERED 
       CALL WORK(I)
       !$OMP END ORDERED
     ENDIF
   END DO
   !$OMP END DO SIMD
 
   !$OMP PARALLEL DO
   DO I = 1,N
     IF (I <= 10) THEN
-      !ERROR: The ORDERED clause must be present on the loop construct if any ORDERED region ever binds to a loop region arising from the loop construct.
+      !ERROR: An ORDERED directive without the DEPEND clause must be closely nested in a worksharing-loop (or worksharing-loop SIMD) region with ORDERED clause without the parameter
       !$OMP ORDERED 
       CALL WORK(I)
       !$OMP END ORDERED
     ENDIF
   END DO
   !$OMP END PARALLEL DO
 
   !$OMP CRITICAL  

flang/test/Semantics/omp-ordered02.f90

+! RUN: %python %S/test_errors.py %s %flang -fopenmp
+! OpenMP Version 5.1
+! Check OpenMP construct validity for the following directives:
+! 2.19.9 Ordered Construct
+
+subroutine sub1()
+  integer :: i, j, N = 10
+  real :: arrayA(10), arrayB(10)
+  real, external :: foo, bar
+
+  !$omp ordered
+  arrayA(i) = foo(i)
+  !$omp end ordered
+
+  !$omp ordered threads
+  arrayA(i) = foo(i)
+  !$omp end ordered
+
+  !$omp ordered simd
+  arrayA(i) = foo(i)
+  !$omp end ordered
+
+  !$omp sections
+  do i = 1, N
+    !$omp ordered
+    arrayA(i) = foo(i)
+    !$omp end ordered
+  end do
+  !$omp end sections
+
+  !$omp do ordered
+  do i = 1, N
+    arrayB(i) = bar(i)
+    !$omp ordered
+    arrayA(i) = foo(i)
+    !$omp end ordered
+  end do
+  !$omp end do
+
+  !$omp sections
+  do i = 1, N
+    !ERROR: An ORDERED directive with SIMD clause must be closely nested in a SIMD or worksharing-loop SIMD region
+    !$omp ordered simd
+    arrayA(i) = foo(i)
+    !$omp end ordered
+  end do
+  !$omp end sections
+
+  !$omp do ordered
+  do i = 1, N
+    !$omp parallel
+    do j = 1, N
+      !ERROR: An ORDERED directive without the DEPEND clause must be closely nested in a SIMD, worksharing-loop, or worksharing-loop SIMD region
+      !$omp ordered
+      arrayA(i) = foo(i)
+      !$omp end ordered
+    end do
+    !$omp end parallel
+  end do
+  !$omp end do
+
+  !$omp do ordered
+  do i = 1, N
+    !$omp target parallel
+    do j = 1, N
+      !ERROR: An ORDERED directive without the DEPEND clause must be closely nested in a SIMD, worksharing-loop, or worksharing-loop SIMD region
+      !$omp ordered
+      arrayA(i) = foo(i)
+      !$omp end ordered
+    end do
+    !$omp end target parallel
+  end do
+  !$omp end do
+
+  !$omp do
+  do i = 1, N
+    !ERROR: An ORDERED directive without the DEPEND clause must be closely nested in a worksharing-loop (or worksharing-loop SIMD) region with ORDERED clause without the parameter
+    !$omp ordered
+    arrayA(i) = foo(i)
+    !$omp end ordered
+  end do
+  !$omp end do
+
+  !$omp do
+  do i = 1, N
+    !ERROR: An ORDERED directive without the DEPEND clause must be closely nested in a worksharing-loop (or worksharing-loop SIMD) region with ORDERED clause without the parameter
+    !$omp ordered threads
+    arrayA(i) = foo(i)
+    !$omp end ordered
+  end do
+  !$omp end do
+
+  !$omp do ordered(1)
+  do i = 1, N
+    !ERROR: An ORDERED directive without the DEPEND clause must be closely nested in a worksharing-loop (or worksharing-loop SIMD) region with ORDERED clause without the parameter
+    !$omp ordered
+    arrayA(i) = foo(i)
+    !$omp end ordered
+  end do
+  !$omp end do
+
+  !$omp do ordered(1)
+  do i = 1, N
+    !ERROR: An ORDERED directive without the DEPEND clause must be closely nested in a worksharing-loop (or worksharing-loop SIMD) region with ORDERED clause without the parameter
+    !$omp ordered threads
+    arrayA(i) = foo(i)
+    !$omp end ordered
+  end do
+  !$omp end do
+
+  !$omp parallel do ordered(1)
+  do i = 1, N
+    !ERROR: An ORDERED directive without the DEPEND clause must be closely nested in a worksharing-loop (or worksharing-loop SIMD) region with ORDERED clause without the parameter
+    !$omp ordered
+    arrayA(i) = foo(i)
+    !$omp end ordered
+  end do
+  !$omp end parallel do
+
+  !$omp parallel do ordered(1)
+  do i = 1, N
+    !ERROR: An ORDERED directive without the DEPEND clause must be closely nested in a worksharing-loop (or worksharing-loop SIMD) region with ORDERED clause without the parameter
+    !$omp ordered threads
+    arrayA(i) = foo(i)
+    !$omp end ordered
+  end do
+  !$omp end parallel do
+
+  !$omp target parallel do ordered(1)
+  do i = 1, N
+    !ERROR: An ORDERED directive without the DEPEND clause must be closely nested in a worksharing-loop (or worksharing-loop SIMD) region with ORDERED clause without the parameter
+    !$omp ordered
+    arrayA(i) = foo(i)
+    !$omp end ordered
+  end do
+  !$omp end target parallel do
+
+  !$omp target parallel do ordered(1)
+  do i = 1, N
+    !ERROR: An ORDERED directive without the DEPEND clause must be closely nested in a worksharing-loop (or worksharing-loop SIMD) region with ORDERED clause without the parameter
+    !$omp ordered threads
+    arrayA(i) = foo(i)
+    !$omp end ordered
+  end do
+  !$omp end target parallel do
+end

flang/test/Semantics/omp-ordered03.f90

+! RUN: %python %S/test_errors.py %s %flang -fopenmp
+! OpenMP Version 5.1
+! Check OpenMP construct validity for the following directives:
+! 2.19.9 Ordered Construct
+
+subroutine sub1()
+  integer :: i, j, N = 10
+  real :: arrayA(10), arrayB(10)
+  real, external :: foo, bar
+
+  !$omp do ordered(1)
+  do i = 1, N
+    !$omp ordered depend(source)
+    arrayA(i) = foo(i)
+    !$omp ordered depend(sink: i - 1)
+    arrayB(i) = bar(i - 1)
+  end do
+  !$omp end do
+
+  !$omp do ordered(1)
+  do i = 1, N
+    !$omp target
+    do j = 1, N
+      !ERROR: An ORDERED construct with the DEPEND clause must be closely nested in a worksharing-loop (or parallel worksharing-loop) construct with ORDERED clause with a parameter
+      !$omp ordered depend(source)
+      arrayA(i) = foo(i)
+      !ERROR: An ORDERED construct with the DEPEND clause must be closely nested in a worksharing-loop (or parallel worksharing-loop) construct with ORDERED clause with a parameter
+      !$omp ordered depend(sink: i - 1)
+      arrayB(i) = bar(i - 1)
+    end do
+    !$omp end target
+  end do
+  !$omp end do
+
+  !$omp target
+  !$omp parallel do ordered(1)
+  do i = 1, N
+    !$omp ordered depend(source)
+    arrayA(i) = foo(i)
+    !$omp ordered depend(sink: i - 1)
+    arrayB(i) = bar(i - 1)
+  end do
+  !$omp end parallel do
+  !$omp end target
+
+  !$omp target parallel do ordered(1)
+  do i = 1, N
+    !$omp ordered depend(source)
+    arrayA(i) = foo(i)
+    !$omp ordered depend(sink: i - 1)
+    arrayB(i) = bar(i - 1)
+  end do
+  !$omp end target parallel do
+
+  !$omp target teams distribute parallel do ordered(1)
+  do i = 1, N
+    !ERROR: An ORDERED construct with the DEPEND clause must be closely nested in a worksharing-loop (or parallel worksharing-loop) construct with ORDERED clause with a parameter
+    !$omp ordered depend(source)
+    arrayA(i) = foo(i)
+    !ERROR: An ORDERED construct with the DEPEND clause must be closely nested in a worksharing-loop (or parallel worksharing-loop) construct with ORDERED clause with a parameter
+    !$omp ordered depend(sink: i - 1)
+    arrayB(i) = bar(i - 1)
+  end do
+  !$omp end target teams distribute parallel do
+
+  !$omp do ordered
+  do i = 1, N
+    !ERROR: An ORDERED construct with the DEPEND clause must be closely nested in a worksharing-loop (or parallel worksharing-loop) construct with ORDERED clause with a parameter
+    !$omp ordered depend(source)
+    arrayA(i) = foo(i)
+    !ERROR: An ORDERED construct with the DEPEND clause must be closely nested in a worksharing-loop (or parallel worksharing-loop) construct with ORDERED clause with a parameter
+    !$omp ordered depend(sink: i - 1)
+    arrayB(i) = bar(i - 1)
+  end do
+  !$omp end do
+
+  !$omp parallel do ordered
+  do i = 1, N
+    !ERROR: An ORDERED construct with the DEPEND clause must be closely nested in a worksharing-loop (or parallel worksharing-loop) construct with ORDERED clause with a parameter
+    !$omp ordered depend(source)
+    arrayA(i) = foo(i)
+    !ERROR: An ORDERED construct with the DEPEND clause must be closely nested in a worksharing-loop (or parallel worksharing-loop) construct with ORDERED clause with a parameter
+    !$omp ordered depend(sink: i - 1)
+    arrayB(i) = bar(i - 1)
+  end do
+  !$omp end parallel do
+
+  !$omp target parallel do ordered
+  do i = 1, N
+    !ERROR: An ORDERED construct with the DEPEND clause must be closely nested in a worksharing-loop (or parallel worksharing-loop) construct with ORDERED clause with a parameter
+    !$omp ordered depend(source)
+    arrayA(i) = foo(i)
+    !ERROR: An ORDERED construct with the DEPEND clause must be closely nested in a worksharing-loop (or parallel worksharing-loop) construct with ORDERED clause with a parameter
+    !$omp ordered depend(sink: i - 1)
+    arrayB(i) = bar(i - 1)
+  end do
+  !$omp end target parallel do
+
+  !$omp do ordered(1)
+  do i = 1, N
+    !ERROR: The number of variables in DEPEND(SINK: vec) clause does not match the parameter specified in ORDERED clause
+    !$omp ordered depend(sink: i - 1) depend(sink: i - 1, j)
+    arrayB(i) = bar(i - 1, j)
+  end do
+  !$omp end do
+
+  !$omp do ordered(2)
+  do i = 1, N
+    do j = 1, N
+      !ERROR: The number of variables in DEPEND(SINK: vec) clause does not match the parameter specified in ORDERED clause
+      !$omp ordered depend(sink: i - 1) depend(sink: i - 1, j)
+      arrayB(i) = foo(i - 1) + bar(i - 1, j)
+    end do
+  end do
+  !$omp end do
+
+  !ERROR: An ORDERED construct with the DEPEND clause must be closely nested in a worksharing-loop (or parallel worksharing-loop) construct with ORDERED clause with a parameter
+  !$omp ordered depend(source)
+
+  !ERROR: An ORDERED construct with the DEPEND clause must be closely nested in a worksharing-loop (or parallel worksharing-loop) construct with ORDERED clause with a parameter
+  !$omp ordered depend(sink: i - 1)
+end