[flang][OpenMP] Upgrade support for Flush, Depend, Taskwait construct to OpenMP 5.0

[kiranktp]

Summary

This patch enhances parser support for below OpenMP constructs to OpenMP 5.0.
Depend Clause
Flush Construct
Taskwait Construct

The patch includes code changes and testcase modifications.

[sscalpone]

@kiranktp Hi Kiran, Will any of the proposed OpenMP 5.1 features affect these features?

Thanks!

[kiranchandramohan]

We have tracking per OpenMP directives/constructs in a google docs spreadsheet (link below). This spreadsheet was already being used for the OpenMP IRBuilder work. So we just added additional sheets to cover Parsing, Semantics, Lowering to OpenMP MLIR, OpenMP Ops spec, Lowering to LLVM IR. There is also a master sheet. The new OpenMP 5.0 constructs are the ones in bold (updated in master, parsing sheets), the ones which have additional clauses in OpenMP 5.0 are listed in the third column (parsing sheet only).
https://docs.google.com/spreadsheets/d/1FvHPuSkGbl4mQZRAwCIndvQx9dQboffiD-xD0oqxgU0/edit#gid=0

[sscalpone]

In D81848#2093203, @kiranchandramohan wrote:

We have tracking per OpenMP directives/constructs in a google docs spreadsheet (link below).

Great! I have amended my questions.

[kiranktp]

In D81848#2093052, @sscalpone wrote:

@kiranktp Hi Kiran, Will any of the proposed OpenMP 5.1 features affect these features?

Thanks!

Hi Steve,
I referred to OpenMP 5.1 standard as well. Among these 3 constructs, only Depend clause has a new dependence type addition to it. I have taken care of that as well.

[kiranchandramohan]

@kiranktp Can we have separate patches for Flush, depend & iterator, taskwait? It will be easier to review.

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

457

Can this and the one below be in lowercase?

[kiranktp]

In D81848#2096663, @kiranchandramohan wrote:

@kiranktp Can we have separate patches for Flush, depend & iterator, taskwait? It will be easier to review.

Sure. I will divide this into 3 separate patches. I will abandon this review request.
I will take care of other review comments as well.

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

#define NODE(T1, T2) NODE_NAME(T1::T2, #T2)
   NODE(parser, OmpDeclareTargetSpecifier)
   NODE(parser, OmpDeclareTargetWithClause)
   NODE(parser, OmpDeclareTargetWithList)
   NODE(parser, OmpDefaultClause)
   NODE_ENUM(OmpDefaultClause, Type)
   NODE(parser, OmpDefaultmapClause)
   NODE_ENUM(OmpDefaultmapClause, ImplicitBehavior)
   NODE_ENUM(OmpDefaultmapClause, VariableCategory)
+  NODE(parser, OmpIteratorSpecifier)
+  NODE(parser, OmpIteratorSpecifierList)
+  NODE(parser, OmpIterator)
   NODE(parser, OmpDependClause)
   NODE(OmpDependClause, InOut)
   NODE(OmpDependClause, Sink)
   NODE(OmpDependClause, Source)
   NODE(parser, OmpDependenceType)
   NODE_ENUM(OmpDependenceType, Type)
   NODE(parser, OmpDependSinkVec)
   NODE(parser, OmpDependSinkVecLength)
#define NODE(T1, T2) NODE_NAME(T1::T2, #T2)
   NODE(OpenMPCancelConstruct, If)
   NODE(parser, OpenMPCancellationPointConstruct)
   NODE(parser, OpenMPConstruct)
   NODE(parser, OpenMPCriticalConstruct)
   NODE(parser, OpenMPDeclarativeConstruct)
   NODE(parser, OpenMPDeclareReductionConstruct)
   NODE(parser, OpenMPDeclareSimdConstruct)
   NODE(parser, OpenMPDeclareTargetConstruct)
+  NODE(parser, OmpFlushMemoryClause)
+  NODE_ENUM(OmpFlushMemoryClause, FlushMemoryOrder)
   NODE(parser, OpenMPFlushConstruct)
   NODE(parser, OpenMPLoopConstruct)
   NODE(parser, OpenMPSimpleStandaloneConstruct)
   NODE(parser, OpenMPStandaloneConstruct)
   NODE(parser, OpenMPSectionsConstruct)
   NODE(parser, OpenMPThreadprivate)
   NODE(parser, OpenStmt)
   NODE(parser, Optional)

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

 
 struct AssignedGotoStmt {
   TUPLE_CLASS_BOILERPLATE(AssignedGotoStmt);
   std::tuple<Name, std::list<Label>> t;
 };
 
 WRAPPER_CLASS(PauseStmt, std::optional<StopCode>);
 
-// Parse tree nodes for OpenMP 4.5 directives and clauses
+// Parse tree nodes for OpenMP 4.5/5.0 directives and clauses
+
+// 2.1.6 Iterators [OpenMP 5.0]
+// iterators-specifier -> [ iterator-type ] identifier = range-specification
+// iterator-type -> integer type
+// range-specification -> begin:end[:step]
+struct OmpIteratorSpecifier {
+  TUPLE_CLASS_BOILERPLATE(OmpIteratorSpecifier);
+  CharBlock source;
+  using Bounds = LoopBounds<DoVariable, ScalarIntExpr>;
+  std::tuple<std::optional<IntegerTypeSpec>, Bounds> t;
+};
+
+WRAPPER_CLASS(OmpIteratorSpecifierList, std::list<OmpIteratorSpecifier>);
+
+// 2.1.6 iterators -> iterator(iterators-definition)
+// iterators-definition -> iterator-specifier [, iterators-definition ]
+struct OmpIterator {
+  TUPLE_CLASS_BOILERPLATE(OmpIterator);
+  CharBlock source;
+  std::tuple<Verbatim, OmpIteratorSpecifierList> t;
+};
 
 // 2.5 proc-bind-clause -> PROC_BIND (MASTER | CLOSE | SPREAD)
 struct OmpProcBindClause {
   ENUM_CLASS(Type, Close, Master, Spread)
   WRAPPER_CLASS_BOILERPLATE(OmpProcBindClause, Type);
 };
 
 // 2.15.3.1 default-clause -> DEFAULT (PRIVATE | FIRSTPRIVATE | SHARED | NONE)

 
 // 2.15.3.6 reduction-clause -> REDUCTION (reduction-identifier:
 //                                         variable-name-list)
 struct OmpReductionClause {
   TUPLE_CLASS_BOILERPLATE(OmpReductionClause);
   std::tuple<OmpReductionOperator, std::list<Designator>> t;
 };
 
-// 2.13.9 depend-vec-length -> +/- non-negative-constant
+// 2.18.11 Depend Clause [OpenMP 5.0]
+// 2.18.11 depend-vec-length -> +/- non-negative-constant
 struct OmpDependSinkVecLength {
   TUPLE_CLASS_BOILERPLATE(OmpDependSinkVecLength);
   std::tuple<DefinedOperator, ScalarIntConstantExpr> t;
 };
 
-// 2.13.9 depend-vec -> iterator [+/- depend-vec-length],...,iterator[...]
+// 2.18.11 depend-vec -> iterator [+/- depend-vec-length],...,iterator[...]
 struct OmpDependSinkVec {
   TUPLE_CLASS_BOILERPLATE(OmpDependSinkVec);
   std::tuple<Name, std::optional<OmpDependSinkVecLength>> t;
 };
 
-// 2.13.9 depend-type -> IN | OUT | INOUT | SOURCE | SINK
+// 2.18.11 dependence-type -> IN | OUT | INOUT | MUTEXINOUTSET | INOUTSET |
+//                            DEPOBJ
 struct OmpDependenceType {
-  ENUM_CLASS(Type, In, Out, Inout, Source, Sink)
+  ENUM_CLASS(Type, In, Out, Inout, Mutexinoutset, Inoutset, Depobj)
   WRAPPER_CLASS_BOILERPLATE(OmpDependenceType, Type);
 };
 
-// 2.13.9 depend-clause -> DEPEND (((IN | OUT | INOUT) : variable-name-list) |
-//                                 SOURCE | SINK : depend-vec)
+// 2.18.11 depend-clause -> DEPEND (([ITERATOR(iterators-definition),]
+//                                   (IN | OUT | INOUT | INOUTSET |
+//                                    MUTEXINOUTSET | DEPOBJ) :
+//                                   variable-name-list) |
+//                                  SOURCE |
+//                                  SINK : depend-vec)
 struct OmpDependClause {
   UNION_CLASS_BOILERPLATE(OmpDependClause);
   EMPTY_CLASS(Source);
   WRAPPER_CLASS(Sink, std::list<OmpDependSinkVec>);
   struct InOut {
     TUPLE_CLASS_BOILERPLATE(InOut);
-    std::tuple<OmpDependenceType, std::list<Designator>> t;
+    std::tuple<std::optional<OmpIterator>, OmpDependenceType,
+        std::list<Designator>>
+        t;
   };
+  CharBlock source;
   std::variant<Source, Sink, InOut> u;
 };
 
 // 2.7.1 nowait-clause -> NOWAIT
 EMPTY_CLASS(OmpNowait);
 
 // OpenMP Clauses
 struct OmpClause {

 // 2.14.1 cancel -> CANCEL construct-type-clause [ [,] if-clause]
 struct OpenMPCancelConstruct {
   TUPLE_CLASS_BOILERPLATE(OpenMPCancelConstruct);
   WRAPPER_CLASS(If, ScalarLogicalExpr);
   CharBlock source;
   std::tuple<Verbatim, OmpCancelType, std::optional<If>> t;
 };
 
-// 2.13.7 flush -> FLUSH [(variable-name-list)]
+// 2.18.8 Flush Construct [OpenMP 5.0]
+// memory-order-clause -> acq_rel
+//                        release
+//                        acquire
+struct OmpFlushMemoryClause {
+  ENUM_CLASS(FlushMemoryOrder, AcqRel, Release, Acquire)
+  WRAPPER_CLASS_BOILERPLATE(OmpFlushMemoryClause, FlushMemoryOrder);
+  CharBlock source;
+};
+
+// 2.18.8 flush -> FLUSH [memory-order-clause] [(variable-name-list)]
 struct OpenMPFlushConstruct {
   TUPLE_CLASS_BOILERPLATE(OpenMPFlushConstruct);
   CharBlock source;
-  std::tuple<Verbatim, std::optional<OmpObjectList>> t;
+  std::tuple<Verbatim, std::optional<OmpFlushMemoryClause>,
+      std::optional<OmpObjectList>>
+      t;
 };
 
 struct OmpSimpleStandaloneDirective {
   ENUM_CLASS(Directive, Barrier, Taskwait, Taskyield, TargetEnterData,
       TargetExitData, TargetUpdate, Ordered)
   WRAPPER_CLASS_BOILERPLATE(OmpSimpleStandaloneDirective, Directive);
   CharBlock source;
 };

flang/include/flang/Semantics/scope.h

 };
 using EquivalenceSet = std::vector<EquivalenceObject>;
 
 class Scope {
   using mapType = std::map<SourceName, MutableSymbolRef>;
 
 public:
   ENUM_CLASS(Kind, Global, Module, MainProgram, Subprogram, BlockData,
-      DerivedType, Block, Forall, ImpliedDos)
+      DerivedType, Block, Forall, ImpliedDos, OmpIterators)
   using ImportKind = common::ImportKind;
 
   // Create the Global scope -- the root of the scope tree
   Scope() : Scope{*this, Kind::Global, nullptr} {}
   Scope(Scope &parent, Kind kind, Symbol *symbol)
       : parent_{parent}, kind_{kind}, symbol_{symbol} {
     if (symbol) {
       symbol->set_scope(this);

flang/lib/Parser/expr-parsers.h

 inline constexpr auto loopBounds(decltype(scalarExpr) &p) {
   return construct<LoopBounds<ScalarName, ScalarExpr>>(
       scalar(name) / "=", p / ",", p, maybe("," >> p));
 }
 template <typename PA> inline constexpr auto loopBounds(const PA &p) {
   return construct<LoopBounds<DoVariable, typename PA::resultType>>(
       doVariable / "=", p / ",", p, maybe("," >> p));
 }
+template <typename PA> inline constexpr auto ompLoopBounds(const PA &p) {
+  return construct<LoopBounds<DoVariable, typename PA::resultType>>(
+      doVariable / "=", p / ":", p, maybe(":" >> p));
+}
 } // namespace Fortran::parser
 #endif

flang/lib/Parser/openmp-parsers.cpp

 
 constexpr auto startOmpLine = skipStuffBeforeStatement >> "!$OMP "_sptok;
 constexpr auto endOmpLine = space >> endOfLine;
 
 template <typename A> constexpr decltype(auto) verbatim(A x) {
   return sourced(construct<Verbatim>(x));
 }
 
+// 2.1.6 ITERATOR(iterators-definition)
+//        iterators-definition -> iterator-specifier [, iterators-definition ]
+//        iterator-specifier -> [ iterator-type ] identifier =
+//                                     range-specification
+TYPE_PARSER(sourced(construct<OmpIteratorSpecifier>(
+    maybe(integerTypeSpec / "::"), ompLoopBounds(scalarIntExpr))))
+
+TYPE_PARSER(construct<OmpIteratorSpecifierList>(
+    many(maybe(","_tok) >> Parser<OmpIteratorSpecifier>{})))
+
+TYPE_PARSER(sourced(construct<OmpIterator>(verbatim("ITERATOR"_tok),
+    parenthesized(Parser<OmpIteratorSpecifierList>{}))))
+
 // OpenMP Clauses
 // 2.15.3.1 DEFAULT (PRIVATE | FIRSTPRIVATE | SHARED | NONE)
 TYPE_PARSER(construct<OmpDefaultClause>(
     "PRIVATE" >> pure(OmpDefaultClause::Type::Private) ||
     "FIRSTPRIVATE" >> pure(OmpDefaultClause::Type::Firstprivate) ||
     "SHARED" >> pure(OmpDefaultClause::Type::Shared) ||
     "NONE" >> pure(OmpDefaultClause::Type::None)))
 

 
 // 2.15.3.6 REDUCTION (reduction-identifier: variable-name-list)
 TYPE_PARSER(construct<OmpReductionOperator>(Parser<DefinedOperator>{}) ||
     construct<OmpReductionOperator>(Parser<ProcedureDesignator>{}))
 
 TYPE_PARSER(construct<OmpReductionClause>(
     Parser<OmpReductionOperator>{} / ":", nonemptyList(designator)))
 
-// 2.13.9 DEPEND (SOURCE | SINK : vec | (IN | OUT | INOUT) : list
+// 2.18.11 DEPEND (source-dependence | sink-dependence | other-dependence)
+//          source-dependence -> SOURCE
+//          sink-dependence   -> SINK : vec
+//          other-dependence  -> dependence-modifier dependence-type : list
+//           dependence-modifier   -> [ITERATOR(iterators-definition), ]
+//           dependence-type   -> IN | OUT | INOUT | MUTEXINOUTSET | INOUTSET |
+//                                DEPOBJ
 TYPE_PARSER(construct<OmpDependSinkVecLength>(
     Parser<DefinedOperator>{}, scalarIntConstantExpr))
 
 TYPE_PARSER(
     construct<OmpDependSinkVec>(name, maybe(Parser<OmpDependSinkVecLength>{})))
 
 TYPE_PARSER(
     construct<OmpDependenceType>("IN"_id >> pure(OmpDependenceType::Type::In) ||
+        "OUT" >> pure(OmpDependenceType::Type::Out) ||
         "INOUT" >> pure(OmpDependenceType::Type::Inout) ||
-        "OUT" >> pure(OmpDependenceType::Type::Out)))
+        "MUTEXINOUTSET" >> pure(OmpDependenceType::Type::Mutexinoutset) ||
+        "INOUTSET" >> pure(OmpDependenceType::Type::Inoutset) ||
+        "DEPOBJ" >> pure(OmpDependenceType::Type::Depobj)))
 
 TYPE_CONTEXT_PARSER("Omp Depend clause"_en_US,
     construct<OmpDependClause>(construct<OmpDependClause::Sink>(
         "SINK :" >> nonemptyList(Parser<OmpDependSinkVec>{}))) ||
         construct<OmpDependClause>(
             construct<OmpDependClause::Source>("SOURCE"_tok)) ||
-        construct<OmpDependClause>(construct<OmpDependClause::InOut>(
-            Parser<OmpDependenceType>{}, ":" >> nonemptyList(designator))))
+        sourced(construct<OmpDependClause>(
+            construct<OmpDependClause::InOut>(maybe(Parser<OmpIterator>{}),
+                maybe(","_tok) >> Parser<OmpDependenceType>{},
+                ":" >> nonemptyList(designator)))))
 
 // 2.15.3.7 LINEAR (linear-list: linear-step)
 //          linear-list -> list | modifier(list)
 //          linear-modifier -> REF | VAL | UVAL
 TYPE_PARSER(
     construct<OmpLinearModifier>("REF" >> pure(OmpLinearModifier::Type::Ref) ||
         "VAL" >> pure(OmpLinearModifier::Type::Val) ||
         "UVAL" >> pure(OmpLinearModifier::Type::Uval)))

 TYPE_PARSER(sourced(construct<OpenMPCancellationPointConstruct>(
     verbatim("CANCELLATION POINT"_tok), Parser<OmpCancelType>{})))
 
 // 2.14.1 Cancel construct
 TYPE_PARSER(sourced(construct<OpenMPCancelConstruct>(verbatim("CANCEL"_tok),
     Parser<OmpCancelType>{}, maybe("IF" >> parenthesized(scalarLogicalExpr)))))
 
 // 2.13.7 Flush construct
-TYPE_PARSER(sourced(construct<OpenMPFlushConstruct>(
-    verbatim("FLUSH"_tok), maybe(parenthesized(Parser<OmpObjectList>{})))))
+//        flush -> FLUSH [memory-order-clause] [(variable-name-list)]
+//        memory-order-clause -> acq_rel
+//                               release
+//                               acquire
+TYPE_PARSER(sourced(construct<OmpFlushMemoryClause>(
+    "ACQ_REL" >> pure(OmpFlushMemoryClause::FlushMemoryOrder::AcqRel) ||
+    "RELEASE" >> pure(OmpFlushMemoryClause::FlushMemoryOrder::Release) ||
+    "ACQUIRE" >> pure(OmpFlushMemoryClause::FlushMemoryOrder::Acquire))))
+
+TYPE_PARSER(sourced(construct<OpenMPFlushConstruct>(verbatim("FLUSH"_tok),
+    maybe(Parser<OmpFlushMemoryClause>{}),
+    maybe(parenthesized(Parser<OmpObjectList>{})))))
 
 // Simple Standalone Directives
 TYPE_PARSER(sourced(construct<OmpSimpleStandaloneDirective>(first(
     "BARRIER" >> pure(OmpSimpleStandaloneDirective::Directive::Barrier),
     "ORDERED" >> pure(OmpSimpleStandaloneDirective::Directive::Ordered),
     "TARGET ENTER DATA" >>
         pure(OmpSimpleStandaloneDirective::Directive::TargetEnterData),
     "TARGET EXIT DATA" >>

flang/lib/Parser/unparse.cpp

if (!list.empty()) {
       for (const char *tkr : list) {
         Put(*tkr);
       }
       Put(") ");
     }
     Walk(std::get<Name>(x.t));
   }
   // OpenMP Clauses & Directives
+  void Unparse(const OmpIteratorSpecifier &x) {
+    Walk(std::get<std::optional<IntegerTypeSpec>>(x.t), "::");
+    const auto &bounds{std::get<OmpIteratorSpecifier::Bounds>(x.t)};
+    Walk(bounds.name), Put('=');
+    Walk(bounds.lower), Put(':'), Walk(bounds.upper), Walk(":", bounds.step);
+  }
+  void Unparse(const OmpIteratorSpecifierList &x) { Walk(" ", x.v, ", "); }
+  void Unparse(const OmpIterator &x) {
+    Word("ITERATOR(");
+    Walk(std::get<OmpIteratorSpecifierList>(x.t));
+    Put(")");
+  }
   void Unparse(const OmpObject &x) {
     std::visit(common::visitors{
                    [&](const Designator &y) { Walk(y); },
                    [&](const Name &y) { Put("/"), Walk(y), Put("/"); },
                },
         x.u);
   }
   void Unparse(const OmpMapType::Always &) { Word("ALWAYS,"); }
void Unparse(const OmpDependSinkVecLength &x) {
     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));
   }
   void Unparse(const OmpDependClause::InOut &x) {
     Put("(");
+    Walk(std::get<std::optional<OmpIterator>>(x.t), ", ");
     Walk(std::get<OmpDependenceType>(x.t));
     Put(":");
     Walk(std::get<std::list<Designator>>(x.t), ",");
     Put(")");
   }
   bool Pre(const OmpDependClause &x) {
     return std::visit(common::visitors{
                           [&](const OmpDependClause::Source &) {
#undef FMT
   void Unparse(const OpenMPCancelConstruct &x) {
     BeginOpenMP();
     Word("!$OMP CANCEL ");
     Walk(std::get<OmpCancelType>(x.t));
     Walk(std::get<std::optional<OpenMPCancelConstruct::If>>(x.t));
     Put("\n");
     EndOpenMP();
   }
+  void Unparse(const OmpFlushMemoryClause &x) {
+    switch (x.v) {
+    case OmpFlushMemoryClause::FlushMemoryOrder::AcqRel:
+      Word("ACQ_REL ");
+      break;
+    case OmpFlushMemoryClause::FlushMemoryOrder::Release:
+      Word("RELEASE ");
+      break;
+    case OmpFlushMemoryClause::FlushMemoryOrder::Acquire:
+      Word("ACQUIRE ");
+      break;
+    }
+  }
   void Unparse(const OpenMPFlushConstruct &x) {
     BeginOpenMP();
-    Word("!$OMP FLUSH");
-    Walk("(", std::get<std::optional<OmpObjectList>>(x.t), ")");
+    Word("!$OMP FLUSH ");
+    Walk(std::get<std::optional<OmpFlushMemoryClause>>(x.t));
+    Walk(" (", std::get<std::optional<OmpObjectList>>(x.t), ")");
     Put("\n");
     EndOpenMP();
   }
   void Unparse(const OmpEndLoopDirective &x) {
     BeginOpenMP();
     Word("!$OMP END ");
     Walk(std::get<OmpLoopDirective>(x.t));
     Walk(std::get<OmpClauseList>(x.t));

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

void OmpStructureChecker::Enter(
   switch (dir.v) {
   case parser::OmpSimpleStandaloneDirective::Directive::Barrier: {
     // 2.13.3 barrier
     PushContext(dir.source, OmpDirective::BARRIER);
   } break;
   case parser::OmpSimpleStandaloneDirective::Directive::Taskwait: {
     // 2.13.4 taskwait
     PushContext(dir.source, OmpDirective::TASKWAIT);
+    OmpClauseSet allowed{OmpClause::DEPEND};
+    SetContextAllowed(allowed);
   } break;
   case parser::OmpSimpleStandaloneDirective::Directive::Taskyield: {
     // 2.9.4 taskyield
     PushContext(dir.source, OmpDirective::TASKYIELD);
   } break;
   case parser::OmpSimpleStandaloneDirective::Directive::TargetEnterData: {
     // 2.10.2 target-enter-data-clause -> if-clause |
     //                                    device-clause |

flang/lib/Semantics/resolve-names.cpp

 
 // Create scopes for OpenMP constructs
 class OmpVisitor : public virtual DeclarationVisitor {
 public:
   void AddOmpSourceRange(const parser::CharBlock &);
 
   static bool NeedsScope(const parser::OpenMPBlockConstruct &);
 
+  bool Pre(const parser::OmpIteratorSpecifier &);
+  bool Pre(const parser::OmpDependClause &);
+  void Post(const parser::OmpDependClause &);
   bool Pre(const parser::OpenMPBlockConstruct &);
   void Post(const parser::OpenMPBlockConstruct &);
   bool Pre(const parser::OmpBeginBlockDirective &x) {
     AddOmpSourceRange(x.source);
     return true;
   }
   void Post(const parser::OmpBeginBlockDirective &) {
     messageHandler().set_currStmtSource(std::nullopt);
if (init) {
       }
     }
   }
 
   ResolveNamesVisitor &resolver_;
   bool pushedScope_{false};
 };
 
+bool OmpVisitor::Pre(const parser::OmpIteratorSpecifier &x) {
+  auto &type{std::get<std::optional<parser::IntegerTypeSpec>>(x.t)};
+  auto &bounds{std::get<parser::OmpIteratorSpecifier::Bounds>(x.t)};
+  DeclareStatementEntity(bounds.name.thing.thing, type);
+  Walk(bounds);
+  return false;
+}
+
+bool OmpVisitor::Pre(const parser::OmpDependClause &x) {
+  messageHandler().set_currStmtSource(x.source);
+  std::visit(
+      common::visitors{
+          [&](const parser::OmpDependClause::Source &) {},
+          [&](const parser::OmpDependClause::Sink &) {},
+          [&](const parser::OmpDependClause::InOut &y) {
+            PushScope(Scope::Kind::OmpIterators, nullptr);
+            Walk(y);
+            PopScope();
+          },
+      },
+      x.u);
+  return false;
+}
+
+void OmpVisitor::Post(const parser::OmpDependClause &) {
+  messageHandler().set_currStmtSource(std::nullopt);
+}
+
 bool OmpAttributeVisitor::Pre(const parser::OpenMPBlockConstruct &x) {
   const auto &beginBlockDir{std::get<parser::OmpBeginBlockDirective>(x.t)};
   const auto &beginDir{std::get<parser::OmpBlockDirective>(beginBlockDir.t)};
   switch (beginDir.v) {
   case parser::OmpBlockDirective::Directive::Master:
     PushContext(beginDir.source, OmpDirective::MASTER);
     break;
   case parser::OmpBlockDirective::Directive::Ordered:

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

 ! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
 
 ! Check OpenMP clause validity for the following directives:
 !
 !    2.5 PARALLEL construct
 !    2.7.1 Loop construct
 !    ...
 
 ! TODO: all the internal errors
 
   integer :: b = 128
   integer :: c = 32
+  integer :: val = 2
   integer, parameter :: num = 16
   real(8) :: arrayA(256), arrayB(512)
 
   arrayA = 1.414
   arrayB = 3.14
   N = 1024
 
 ! 2.5 parallel-clause -> if-clause |
! 2.13.1 master
   !$omp end 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 taskwait depend(iterator(integer :: it=1_4:100:2), IN:arrayA(it))
   ! !$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)
   !$omp ordered depend(source)
   !ERROR: Internal: no symbol found for 'i'
   !$omp ordered depend(sink:i-1)
   !$omp flush (c)
+  !$omp flush acq_rel
+  !$omp flush release
+  !$omp flush acquire
+  !$omp flush release (c)
   !$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
!                      priority-clause
   b = 1
   !$omp end task
 
   !ERROR: The parameter of the PRIORITY clause must be a positive integer expression
   !$omp task priority(-1) firstprivate(a) mergeable
   a = 3.14
   !$omp end task
 
+  !$OMP TASK DEPEND(ITERATOR( it=1_4:100:2), IN:arrayA(it))
+  a = 3.14
+  !$OMP END TASK
+
+  !$OMP TASK DEPEND(ITERATOR(integer :: it=1_4:100:2), IN:arrayA(it))
+  a = 3.14
+  !$OMP END TASK
+
+  !$omp task depend(in: b) depend(mutexinoutset: c)
+  a = 3.14
+  !$omp end task
+
+  !$omp task depend(depobj: obj)
+  a = 3.14
+  !$omp end task
+
+
 ! 2.9.3 taskloop-simd-clause -> taskloop-clause |
 !                               simd-clause
 
   !$omp taskloop simd
   do i = 1, N
      a = 3.14
   enddo
   !$omp end taskloop simd