[flang][openmp]At most one threads, simd and depend clause can appear on OpenMP ORDERED construct.

[sameeranjoshi]

Summary

Section 2.17.9 from omp 5.0 has a few restrictions related to ORDERED construct.

• At most one threads clause can appear on an ordered construct.
• At most one simd clause can appear on an ordered construct.
• At most one depend(source) clause can appear on an ordered construct.
• Either depend(sink:vec) clauses or depend(source) clauses may appear on an ordered construct, but not both.

This patch implements them by changing the TableGen file(OMP.td).
The dependencies Simd and Threads clauses were missing semantic checks and were added.

[kiranchandramohan]

Two quick questions.

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

489

Will this catch two or more depend(sink: v) clauses accidentally?

At most one depend(source) clause can appear on an ordered construct.

Can threads, simd occur with depend? Is that handled by the parser?

[clementval]

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

489

According to the standard multiple depend(sink: vec) are allowed so you will need to make a specific check for the depend clause since the general allowedOnce check does not support this.

@kiranchandramohan With the current patch threads, simd and depend are allowed together. The parser is not limiting clauses.

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

463–464

OMPC_Depend should probably be in allowedClauses and specific check done in check-omp-structure for the difference between depend(source) and depend(sink:vec)

[sameeranjoshi]

Summary of changes:

• Fix core dump in ordered construct due to missing tree node visit

for OpenMPSimpleStandaloneConstruct as ordered with a depend falls under it.

• Fix internal error in name resolution of depend clause.

Internal error for Critical construct seems to get fixed with this code change.
Not really sure how does that fix, but this will be revisited in D93051.

This diff doesn't yet work on the review comments so as to avoid confusions.

[kiranchandramohan]

Requesting changes as per review comments/questions before. Thanks @clementval.

[sameeranjoshi]

Summary of changes:

• Handle depend(source) and depend(sink:vec) separately.
• Handle one more restriction from standard[5.0][2.17.9] which was needed with this patch. Either depend(sink:vec) clauses or depend(source) clauses may appear on an ordered construct, but not both.

[clementval]

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

892

Why PC? You have Fortran::parser::OmpDependClause pointers directly.

[sameeranjoshi]

Tweak comments as suggested.

[sameeranjoshi]

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

489

Can threads, simd occur with depend? Is that handled by the parser?

They are not supposed to occur together.
No it's not caught in parser.
This will be handled separately. I am seeing some issues need to debug it.

[sameeranjoshi]

Ideally in the first look the checks would fit better for ordered construct
inside a single function CheckDependOnOrderedDir so we have them at a
single place , unfortunately it's harder to implement it in above function
considering that the information to differentiate between a
OmpBlockDirective and OmpSimpleStandaloneDirective is unavailable.

Hence the approach of checks inside the respective nodes was choosen.
Using FindClause doesn't work for some reason hence reverting to the old
school way of finding manually inside a list of OmpClause.

[kiranchandramohan]

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

223

Why is this handled on Leave and not Enter like others?

305–315

Same question here.

905–942

struct OmpDependenceType {
  ENUM_CLASS(Type, In, Out, Inout, Source, Sink)
  WRAPPER_CLASS_BOILERPLATE(OmpDependenceType, Type);
};

struct OmpDependClause {
....
  struct InOut {
    TUPLE_CLASS_BOILERPLATE(InOut);
    std::tuple<OmpDependenceType, std::list<Designator>> t;
  };
  std::variant<Source, Sink, InOut> u;
};

Can you use OmpDependenceType in OmpDependClause to simplify this logic? I think you can just count the source, sink and print out the error messages.

[clementval]

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

223

Good point.

[sameeranjoshi]

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

223

With the current approach (traversing an OmpClauseList) it could have worked inside Enter.
But here's are a few reasons not to use

• I prefer doing checks inside Leave, so that the checks remain at a single location and Enter does the context pushing and other stuff.
• I had initially plan to use FindClause as that saves us from writing more code and code looks more readable, unfortunately that did not work in the first run as ResetPartialContext clears the members in DirectiveContext which has a reason because OmpBeginBlockDirective & OmpEndBlockDirective have different set of clauses based on the context.

To resolve this will add Leave for OmpBeginBlockDirective.

void Enter(const parser::OpenMPBlockConstruct &);
void Leave(const parser::OpenMPBlockConstruct &);
void Leave(const parser::OmpBeginBlockDirective &);
void Enter(const parser::OmpEndBlockDirective &);

• FindClause doesn't work inside Enter as the list is empty and it's populated only when we visit each clause. grep FindClause and see it's not found inside any Enter function.

305–315

The case of OpenMPSimpleStandaloneConstruct is different as there is no ResetPartialContext nor any end constructs nor directives for it.
So doing the check here has below reason:

• FindClause will only work inside Leave.
• A style approach.

With the next diff I have plan to use FindClause.

[sameeranjoshi]

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

905–942

Could anyone please elaborate more on above?
I couldn't understand .
parse-tree.h mentions

// 2.13.9 depend-type -> IN | OUT | INOUT | SOURCE | SINK
struct OmpDependenceType {
  ENUM_CLASS(Type, In, Out, Inout, Source, Sink)
  WRAPPER_CLASS_BOILERPLATE(OmpDependenceType, Type);
};

Where as parsers omit's the source and sink in OmpDependenceType in openmp-parsers.cpp

TYPE_PARSER(
    construct<OmpDependenceType>("IN"_id >> pure(OmpDependenceType::Type::In) ||
        "INOUT" >> pure(OmpDependenceType::Type::Inout) ||
        "OUT" >> pure(OmpDependenceType::Type::Out)))

I was confused if the parse tree has some issues.
Hence, if you somecan elaborate a bit on what exactly is expected that would be really helpful.
Or if there's a more better way of simplifying this code.

[clementval]

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

223

What is blocking you now to use FindClause? The ResetPartialContext should not prevent you to use FindClause since you are checking different sets of clauses.

[sameeranjoshi]

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

223

I will send a patch for the same.
I am trying to understand one more comment
https://reviews.llvm.org/D94087#inline-889166

[kiranchandramohan]

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

223

Isn't FindClause used when you are inside a clause and hence do not have access to the construct? If you do it in Enter or Leave of the construct you have access to all the clauses. You might be able to use parser::Unwrap and check whether a clause is present.

905–942

I was assuming that the dependence_type is set always. If it is not then can it be set in the parser and used? Is there any reason why it is not set?

[clementval]

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

223

FindClause might be faster since it's a simple query on a map already populated when the clause is check if it is allowed.

[sameeranjoshi]

Summary of changes:

• Refactor and simplify the algorithm without changes in parser.
• Added 2 routines for code cleanup, and help extended for the later checks. ChecksOnOrderedAsStandalone ChecksOnOrderedAsBlock
• Use FindClause to replace manual traversal of OmpClauseList. FindClause didn't work inside Leave(const parser::OpenMPBlockConstruct &) as the DirectiveContext gets reset before we reach the node. Hence checks are now done in Leave(const parser::OmpBeginBlockDirective &)

[sameeranjoshi]

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

905–942

I have updated to simplify the logic. I am trying to not change parser in first run as there might be some reason why that might have been designed by original authors.
I have no strong opinions to change the parser if this logic still seems harder.
Thanks for parser::Unwrap inputs that helped to simplify things @kiranchandramohan.

[clementval]

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

903

Clauses should be capitalized in message.

[sameeranjoshi]

Capitalized clauses in message.

[clementval]

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

891

What is the final reason to not use FindClause? It would be more efficient than iterate over the clause list once more.

[kiranchandramohan]

Will need a rebase now.

[peixin]

BTW, the error of no symbol found in depend(sink: vec) should be fixed by https://reviews.llvm.org/D108530.

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

489

We may should also give error infomation when threads, simd occur with depend. Otherwise, the behavior would be unspecified. For current clang codegen, it generates the IR only for depend when threads, simd occur with depend. I am implementing the code for flang codegen. I should also use the similar method as clang codegen. The method should be like this:

if (isDependPresent) {
  // lowering depend
} else if (isSimdPresent) {
  // lowering simd
} else {
  // It does not matter if isThreadsPresent is true or false since the construct behaves as if threads is specified when no clause is specified.
}

I assume that this can be checked in Leave(const parser::OmpClauseList &) by using FindClause. The condition should be like this:

if ((isThreadsPresent || isSimdPresent) && isDependPresent) {
  // error report
}

Maybe there is one better place to check this.

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

#include "llvm/Frontend/OpenMP/OMP.inc"
 
   void Enter(const parser::OpenMPConstruct &);
   void Enter(const parser::OpenMPLoopConstruct &);
   void Leave(const parser::OpenMPLoopConstruct &);
   void Enter(const parser::OmpEndLoopDirective &);
 
   void Enter(const parser::OpenMPBlockConstruct &);
   void Leave(const parser::OpenMPBlockConstruct &);
+  void Leave(const parser::OmpBeginBlockDirective &);
   void Enter(const parser::OmpEndBlockDirective &);
 
   void Enter(const parser::OpenMPSectionsConstruct &);
   void Leave(const parser::OpenMPSectionsConstruct &);
   void Enter(const parser::OmpEndSectionsDirective &);
 
   void Enter(const parser::OpenMPDeclareSimdConstruct &);
   void Leave(const parser::OpenMPDeclareSimdConstruct &);
#include "llvm/Frontend/OpenMP/OMP.inc"
   void Enter(const parser::OmpClause::Nogroup &);
   void Enter(const parser::OmpClause::Nowait &);
   void Enter(const parser::OmpClause::Notinbranch &);
   void Enter(const parser::OmpClause::Untied &);
   void Enter(const parser::OmpClause::Collapse &);
   void Enter(const parser::OmpClause::Copyin &);
   void Enter(const parser::OmpClause::Copyprivate &);
   void Enter(const parser::OmpClause::Default &);
+  void Enter(const parser::OmpClause::Depend &);
   void Enter(const parser::OmpClause::Device &);
   void Enter(const parser::OmpClause::DistSchedule &);
   void Enter(const parser::OmpClause::Final &);
   void Enter(const parser::OmpClause::Firstprivate &);
   void Enter(const parser::OmpClause::From &);
   void Enter(const parser::OmpClause::Grainsize &);
   void Enter(const parser::OmpClause::Lastprivate &);
   void Enter(const parser::OmpClause::NumTasks &);
   void Enter(const parser::OmpClause::NumTeams &);
   void Enter(const parser::OmpClause::NumThreads &);
   void Enter(const parser::OmpClause::Ordered &);
   void Enter(const parser::OmpClause::Priority &);
   void Enter(const parser::OmpClause::Private &);
   void Enter(const parser::OmpClause::ProcBind &);
   void Enter(const parser::OmpClause::Reduction &);
   void Enter(const parser::OmpClause::Safelen &);
   void Enter(const parser::OmpClause::Shared &);
+  void Enter(const parser::OmpClause::Simd &);
   void Enter(const parser::OmpClause::Simdlen &);
   void Enter(const parser::OmpClause::TaskReduction &);
+  void Enter(const parser::OmpClause::Threads &);
   void Enter(const parser::OmpClause::ThreadLimit &);
   void Enter(const parser::OmpClause::To &);
   void Enter(const parser::OmpClause::Link &);
   void Enter(const parser::OmpClause::Uniform &);
   void Enter(const parser::OmpClause::UseDevicePtr &);
   void Enter(const parser::OmpClause::IsDevicePtr &);
   // Memory-order-clause
   void Enter(const parser::OmpClause::SeqCst &);
   void Enter(const parser::OmpClause::AcqRel &);
   void Enter(const parser::OmpClause::Release &);
   void Enter(const parser::OmpClause::Acquire &);
   void Enter(const parser::OmpClause::Relaxed &);
   void Enter(const parser::OmpClause::Hint &);
 
   void Enter(const parser::OmpAtomicRead &);
   void Leave(const parser::OmpAtomicRead &);
   void Enter(const parser::OmpAtomicWrite &);
   void Leave(const parser::OmpAtomicWrite &);
   void Enter(const parser::OmpAtomicUpdate &);
   void Leave(const parser::OmpAtomicUpdate &);
   void Enter(const parser::OmpAtomicCapture &);
   void Leave(const parser::OmpAtomic &);
   void Enter(const parser::OmpAlignedClause &);
   void Enter(const parser::OmpDefaultmapClause &);
-  void Enter(const parser::OmpDependClause &);
   void Enter(const parser::OmpIfClause &);
   void Enter(const parser::OmpLinearClause &);
   void Enter(const parser::OmpMapClause &);
   void Enter(const parser::OmpScheduleClause &);
 
 private:
   bool HasInvalidWorksharingNesting(
       const parser::CharBlock &, const OmpDirectiveSet &);
 
   // specific clause related
   bool ScheduleModifierHasType(const parser::OmpScheduleClause &,
       const parser::OmpScheduleModifierType::ModType &);
   void CheckAllowedMapTypes(const parser::OmpMapType::Type &,
       const std::list<parser::OmpMapType::Type> &);
   llvm::StringRef getClauseName(llvm::omp::Clause clause) override;
   llvm::StringRef getDirectiveName(llvm::omp::Directive directive) override;
 
   void CheckDependList(const parser::DataRef &);
   void CheckDependArraySection(
       const common::Indirection<parser::ArrayElement> &, const parser::Name &);
+  void ChecksOnOrderedAsStandalone(
+      const parser::OpenMPSimpleStandaloneConstruct &);
+  void ChecksOnOrderedAsBlock();
   void CheckIsVarPartOfAnotherVar(const parser::OmpObjectList &objList);
   void CheckIntentInPointer(
       const parser::OmpObjectList &, const llvm::omp::Clause);
   void GetSymbolsInObjectList(
       const parser::OmpObjectList &, std::vector<const Symbol *> &);
   const parser::Name GetLoopIndex(const parser::DoConstruct *x);
   void SetLoopInfo(const parser::OpenMPLoopConstruct &x);
   void CheckIsLoopIvPartOfClause(
       llvmOmpClause clause, const parser::OmpObjectList &ompObjectList);
   void CheckWorkshareBlockStmts(const parser::Block &, parser::CharBlock);
 };
 } // namespace Fortran::semantics
 #endif // FORTRAN_SEMANTICS_CHECK_OMP_STRUCTURE_H_

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

void OmpStructureChecker::Enter(const parser::OpenMPBlockConstruct &x) {
   case llvm::omp::OMPD_parallel_workshare:
     CheckWorkshareBlockStmts(block, beginDir.source);
     break;
   default:
     break;
   }
 }
 
+void OmpStructureChecker::Leave(
+    const parser::OmpBeginBlockDirective &beginBlockDir) {
+  const auto &beginDir{std::get<parser::OmpBlockDirective>(beginBlockDir.t)};
+  switch (beginDir.v) {
+  case llvm::omp::OMPD_ordered: {
+    // [5.0] 2.17.9 Ordered Construct Restriction
+    ChecksOnOrderedAsBlock();
+  } break;
+  default:
+    break;
+  }
+}
+
 void OmpStructureChecker::Leave(const parser::OpenMPBlockConstruct &) {
   dirContext_.pop_back();
 }
 
 void OmpStructureChecker::Enter(const parser::OpenMPSectionsConstruct &x) {
   const auto &beginSectionsDir{
       std::get<parser::OmpBeginSectionsDirective>(x.t)};
   const auto &endSectionsDir{std::get<parser::OmpEndSectionsDirective>(x.t)};
   const auto &beginDir{

 
 void OmpStructureChecker::Enter(
     const parser::OpenMPSimpleStandaloneConstruct &x) {
   const auto &dir{std::get<parser::OmpSimpleStandaloneDirective>(x.t)};
   PushContextAndClauseSets(dir.source, dir.v);
 }
 
 void OmpStructureChecker::Leave(
-    const parser::OpenMPSimpleStandaloneConstruct &) {
+    const parser::OpenMPSimpleStandaloneConstruct &x) {
+  const auto &beginStandaloneDir{
+      std::get<parser::OmpSimpleStandaloneDirective>(x.t)};
+  switch (beginStandaloneDir.v) {
+  case llvm::omp::OMPD_ordered: {
+    // [5.0] 2.17.9 Ordered Construct Restriction
+    ChecksOnOrderedAsStandalone(x);
+  } break;
+  default:
+    break;
+  }
   dirContext_.pop_back();
 }
 
 void OmpStructureChecker::Enter(const parser::OpenMPFlushConstruct &x) {
   const auto &dir{std::get<parser::Verbatim>(x.t)};
   PushContextAndClauseSets(dir.source, llvm::omp::Directive::OMPD_flush);
 }
 

 CHECK_SIMPLE_CLAUSE(UseDevicePtr, OMPC_use_device_ptr)
 CHECK_SIMPLE_CLAUSE(AcqRel, OMPC_acq_rel)
 CHECK_SIMPLE_CLAUSE(Acquire, OMPC_acquire)
 CHECK_SIMPLE_CLAUSE(SeqCst, OMPC_seq_cst)
 CHECK_SIMPLE_CLAUSE(Release, OMPC_release)
 CHECK_SIMPLE_CLAUSE(Relaxed, OMPC_relaxed)
 CHECK_SIMPLE_CLAUSE(Hint, OMPC_hint)
 CHECK_SIMPLE_CLAUSE(ProcBind, OMPC_proc_bind)
+CHECK_SIMPLE_CLAUSE(Simd, OMPC_simd)
+CHECK_SIMPLE_CLAUSE(Threads, OMPC_threads)
 CHECK_SIMPLE_CLAUSE(DistSchedule, OMPC_dist_schedule)
 
 CHECK_REQ_SCALAR_INT_CLAUSE(Allocator, OMPC_allocator)
 CHECK_REQ_SCALAR_INT_CLAUSE(Grainsize, OMPC_grainsize)
 CHECK_REQ_SCALAR_INT_CLAUSE(NumTasks, OMPC_num_tasks)
 CHECK_REQ_SCALAR_INT_CLAUSE(NumTeams, OMPC_num_teams)
 CHECK_REQ_SCALAR_INT_CLAUSE(NumThreads, OMPC_num_threads)
 CHECK_REQ_SCALAR_INT_CLAUSE(Priority, OMPC_priority)
if (ScheduleModifierHasType(
         context_.Say(GetContext().clauseSource,
             "The NONMONOTONIC modifier can only be specified with "
             "SCHEDULE(DYNAMIC) or SCHEDULE(GUIDED)"_err_en_US);
       }
     }
   }
 }
 
-void OmpStructureChecker::Enter(const parser::OmpDependClause &x) {
+void OmpStructureChecker::Enter(const parser::OmpClause::Depend &x) {
   CheckAllowed(llvm::omp::Clause::OMPC_depend);
-  if (const auto *inOut{std::get_if<parser::OmpDependClause::InOut>(&x.u)}) {
+  if (const auto *inOut{std::get_if<parser::OmpDependClause::InOut>(&x.v.u)}) {
     const auto &designators{std::get<std::list<parser::Designator>>(inOut->t)};
     for (const auto &ele : designators) {
       if (const auto *dataRef{std::get_if<parser::DataRef>(&ele.u)}) {
         CheckDependList(*dataRef);
         if (const auto *arr{
                 std::get_if<common::Indirection<parser::ArrayElement>>(
                     &dataRef->u)}) {
           CheckDependArraySection(*arr, GetLastName(*dataRef));
if (const auto *triplet{
               name.ToString());
           break;
         }
       }
     }
   }
 }
 
+void OmpStructureChecker::ChecksOnOrderedAsStandalone(
+    const parser::OpenMPSimpleStandaloneConstruct &x) {
+  const auto &ompClauseList{std::get<parser::OmpClauseList>(x.t)};
+  bool isSourcePresent{false};
+  bool isSinkPresent{false};
+  int dependSourceCount{0};
+  for (const auto &clause : ompClauseList.v) {
+    if (const auto *dependClause{
+            parser::Unwrap<parser::OmpClause::Depend>(clause.u)}) {
+      if (parser::Unwrap<parser::OmpDependClause::Source>(*dependClause)) {
+        isSourcePresent = true;
+        dependSourceCount++;
+      }
+      if (parser::Unwrap<parser::OmpDependClause::Sink>(*dependClause)) {
+        isSinkPresent = true;
+      }
+    } else { // SIMD/THREADS not allowed.
+      context_.Say(parser::FindSourceLocation(clause),
+          "THREADS, SIMD clauses are not allowed when ORDERED construct is a "
+          "standalone "
+          "construct with no ORDERED region"_err_en_US);
+    }
+  }
+  if (isSourcePresent && isSinkPresent) {
+    context_.Say(ompClauseList.source,
+        "DEPEND(SINK:vec) is not allowed when DEPEND(SOURCE) is present on"
+        " the ORDERED directive"_err_en_US);
+  }
+  if (dependSourceCount > 1) {
+    context_.Say(ompClauseList.source,
+        "At most one DEPEND(SOURCE) clause can appear on the ORDERED"
+        " directive"_err_en_US);
+  }
+}
+
+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);
+  }
+}
+
 void OmpStructureChecker::CheckIntentInPointer(
     const parser::OmpObjectList &objectList, const llvm::omp::Clause clause) {
   std::vector<const Symbol *> symbols;
   GetSymbolsInObjectList(objectList, symbols);
   for (const auto *symbol : symbols) {
     if (IsPointer(*symbol) && IsIntentIn(*symbol)) {
       context_.Say(GetContext().clauseSource,
           "Pointer '%s' with the INTENT(IN) attribute may not appear "
           "in a %s clause"_err_en_US,
           symbol->name(),
           parser::ToUpperCaseLetters(getClauseName(clause).str()));
     }
   }
 }
 
 void OmpStructureChecker::GetSymbolsInObjectList(
     const parser::OmpObjectList &objectList,
     std::vector<const Symbol *> &symbols) {
   for (const auto &ompObject : objectList.v) {
     if (const auto *name{parser::Unwrap<parser::Name>(ompObject)}) {
       if (const auto *symbol{name->symbol}) {
         if (const auto *commonBlockDetails{
                 symbol->detailsIf<CommonBlockDetails>()}) {

flang/lib/Semantics/resolve-directives.cpp

if (const auto *expr{GetExpr(parsedExpr)}) {
       }
     }
     return true;
   }
 
   bool Pre(const parser::OpenMPBlockConstruct &);
   void Post(const parser::OpenMPBlockConstruct &);
 
+  bool Pre(const parser::OpenMPSimpleStandaloneConstruct &);
+  void Post(const parser::OpenMPSimpleStandaloneConstruct &) { PopContext(); }
+
   void Post(const parser::OmpBeginBlockDirective &) {
     GetContext().withinConstruct = true;
   }
 
   bool Pre(const parser::OpenMPLoopConstruct &);
   void Post(const parser::OpenMPLoopConstruct &) { PopContext(); }
   void Post(const parser::OmpBeginLoopDirective &) {
     GetContext().withinConstruct = true;
std::visit(common::visitors{
         x.u);
     return false;
   }
   bool Pre(const parser::OmpAlignedClause &x) {
     const auto &alignedNameList{std::get<std::list<parser::Name>>(x.t)};
     ResolveOmpNameList(alignedNameList, Symbol::Flag::OmpAligned);
     return false;
   }
+  bool Pre(const parser::OmpDependClause &x) {
+    if (const auto *dependSink{
+            std::get_if<parser::OmpDependClause::Sink>(&x.u)}) {
+      const auto &dependSinkVec{dependSink->v};
+      for (const auto &dependSinkElement : dependSinkVec) {
+        const auto &name{std::get<parser::Name>(dependSinkElement.t)};
+        if (!ResolveName(&name)) {
+          context_.Say(
+              name.source, "No type declared for '%s'"_err_en_US, name.source);
+        }
+      }
+    }
+    return false;
+  }
   void Post(const parser::Name &);
 
   const parser::OmpClause *associatedClause{nullptr};
   void SetAssociatedClause(const parser::OmpClause &c) {
     associatedClause = &c;
   }
   const parser::OmpClause *GetAssociatedClause() { return associatedClause; }
 
case llvm::omp::Directive::OMPD_target_parallel: {
     break;
   }
   default:
     break;
   }
   PopContext();
 }
 
+bool OmpAttributeVisitor::Pre(
+    const parser::OpenMPSimpleStandaloneConstruct &x) {
+  const auto &standaloneDir{
+      std::get<parser::OmpSimpleStandaloneDirective>(x.t)};
+  switch (standaloneDir.v) {
+  case llvm::omp::Directive::OMPD_barrier:
+  case llvm::omp::Directive::OMPD_ordered:
+  case llvm::omp::Directive::OMPD_target_enter_data:
+  case llvm::omp::Directive::OMPD_target_exit_data:
+  case llvm::omp::Directive::OMPD_target_update:
+  case llvm::omp::Directive::OMPD_taskwait:
+  case llvm::omp::Directive::OMPD_taskyield:
+    PushContext(standaloneDir.source, standaloneDir.v);
+    break;
+  default:
+    break;
+  }
+  ClearDataSharingAttributeObjects();
+  return true;
+}
+
 bool OmpAttributeVisitor::Pre(const parser::OpenMPLoopConstruct &x) {
   const auto &beginLoopDir{std::get<parser::OmpBeginLoopDirective>(x.t)};
   const auto &beginDir{std::get<parser::OmpLoopDirective>(beginLoopDir.t)};
   const auto &clauseList{std::get<parser::OmpClauseList>(beginLoopDir.t)};
   switch (beginDir.v) {
   case llvm::omp::Directive::OMPD_distribute:
   case llvm::omp::Directive::OMPD_distribute_parallel_do:
   case llvm::omp::Directive::OMPD_distribute_parallel_do_simd:

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

! 2.13.1 master
   !$omp end parallel
 
 ! Standalone Directives (basic)
 
   !$omp taskyield
   !$omp barrier
   !$omp taskwait
   !$omp taskwait depend(source)
-  !ERROR: Internal: no symbol found for 'i'
   !$omp taskwait depend(sink:i-1)
   ! !$omp target enter data map(to:arrayA) map(alloc:arrayB)
   ! !$omp target update from(arrayA) to(arrayB)
   ! !$omp target exit data map(from:arrayA) map(delete:arrayB)
+
+  ![5.0][2.17.9] Ordered construct
   !$omp ordered depend(source)
-  !ERROR: Internal: no symbol found for 'i'
   !$omp ordered depend(sink:i-1)
+  !ERROR: No type declared for 'undecvar'
+  !$omp ordered depend(sink:undecvar-1)
+  !There is no sink/source
+  !$omp ordered depend(in:p) depend(in:q) depend(out:r)
+  !Multiple sink allowed but not source.
+  !$omp ordered depend(sink:i-1) depend(sink:i-1)
+  !$omp ordered depend(sink:i-1) depend(sink:i-1) depend(in:p) depend(out:p)
+  !$omp ordered depend(out:p) depend(in:p)
+  !ERROR: At most one DEPEND(SOURCE) clause can appear on the ORDERED directive
+  !$omp ordered depend(source) depend(source)
+  !ERROR: At most one DEPEND(SOURCE) clause can appear on the ORDERED directive
+  !$omp ordered depend(source) depend(in:p) depend(source)
+  !ERROR: DEPEND(SINK:vec) is not allowed when DEPEND(SOURCE) is present on the ORDERED directive
+  !$omp ordered depend(source) depend(sink:i-1)
+  !ERROR: At most one THREADS clause can appear on the ORDERED directive
+  !$omp ordered threads threads
+  !$omp end ordered
+  !$omp ordered simd
+  !$omp end ordered
+  !ERROR: DEPEND(*) clauses are not allowed when ORDERED construct is a block construct with an ORDERED region
+  !$omp ordered depend(source)
+  !$omp end ordered
+  !ERROR: DEPEND(*) clauses are not allowed when ORDERED construct is a block construct with an ORDERED region
+  !$omp ordered depend(sink:i-4)
+  !$omp end ordered
+  !ERROR: At most one SIMD clause can appear on the ORDERED directive
+  !$omp ordered simd simd
+  !$omp end ordered
+  !ERROR: THREADS, SIMD clauses are not allowed when ORDERED construct is a standalone construct with no ORDERED region
+  !$omp ordered simd
+  !ERROR: THREADS, SIMD clauses are not allowed when ORDERED construct is a standalone construct with no ORDERED region
+  !$omp ordered threads
+
   !$omp flush (c)
   !$omp flush acq_rel
   !$omp flush release
   !$omp flush acquire
   !ERROR: If memory-order-clause is RELEASE, ACQUIRE, or ACQ_REL, list items must not be specified on the FLUSH directive
   !$omp flush release (c)
   !ERROR: SEQ_CST clause is not allowed on the FLUSH directive
   !$omp flush seq_cst
   !ERROR: RELAXED clause is not allowed on the FLUSH directive
   !$omp flush relaxed
 
   !$omp cancel DO
   !$omp cancellation point parallel
 
 ! 2.13.2 critical Construct
 
-  !ERROR: Internal: no symbol found for 'first'
   !$omp critical (first)
   a = 3.14
-  !ERROR: Internal: no symbol found for 'first'
   !$omp end critical (first)
 
 ! 2.9.1 task-clause -> if-clause |
 !                      final-clause |
 !                      untied-clause |
 !                      default-clause |
 !                      mergeable-clause |
 !                      private-clause |

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

let allowedOnceClauses = [
     VersionedClause<OMPC_Release, 50>,
     // TODO This should ne `none` instead. Comment carried over from
     // OMPKinds.def.
     VersionedClause<OMPC_Flush>
   ];
 }
 def OMP_Ordered : Directive<"ordered"> {
   let allowedClauses = [
+    VersionedClause<OMPC_Depend>
+  ];
+  let allowedOnceClauses = [
     VersionedClause<OMPC_Threads>,
     VersionedClause<OMPC_Simd>,
-    VersionedClause<OMPC_Depend>
   ];
 }
 def OMP_Atomic : Directive<"atomic"> {
   let allowedClauses = [
     VersionedClause<OMPC_Read>,
     VersionedClause<OMPC_Write>,
     VersionedClause<OMPC_Update>,
     VersionedClause<OMPC_Capture>,
   ];