[flang][OpenMP] Add support for getting parent context and clauses and modify the relevant sema checks to use the new functions.

[arnamoy10]

Summary

rGa59665930b87 introduced a different algorithm to check context nesting. With each nested context, we push an entry in the dirContext_ vector. Therefore intuitively, a the current context should be considered nested when the size of the vector is at least 2 e.g.

!$ omp do  --> context pushed in vector, size 1
  !$omp single --> context pushed in vector, size 2

With the change introduced in rGa59665930b87 , 4 test cases were failing. Those tests were to do with nesting checking, BUT the nesting check was being done BEFORE pushing the current context into the vector. That was counterintuitive.

This patch fixes the code (that was causing test failure) and uses the more intuitive structure of ALWAYS pushing the context first while visiting a construct, and then implement checks that are dependent on nesting check.

Also introduces helper functions for getting the parent context and checking whether a clause is present in the parent context.

These helper functions help in the implementation of more sema checks that requires getting information about the parent context.

[arnamoy10]

Clang-formatting

[kiranchandramohan]

LGTM. Approving quickly since it fixes failures. Might need to do a recce and check that usage is consistent.

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

155

Nit: Are both checks necessary, given that the second includes the first?

[bryanpkc]

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

207

Nit: No need to wrap line here, or the comment below for FindClauseParent.

[kiranchandramohan]

@arnamoy10 can you submit this?

[arnamoy10]

Doing it now

[arnamoy10]

Addressing reviewers' comments.

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

protected:
   void SetLoopIv(Symbol *symbol) { GetContext().loopIV = symbol; }
 
   // back() is the top of the stack
   DirectiveContext &GetContext() {
     CHECK(!dirContext_.empty());
     return dirContext_.back();
   }
 
+  DirectiveContext &GetContextParent() {
+    CHECK(dirContext_.size() >= 2);
+    return dirContext_[dirContext_.size() - 2];
+  }
+
   void SetContextClause(const PC &clause) {
     GetContext().clauseSource = clause.source;
     GetContext().clause = &clause;
   }
 
   void ResetPartialContext(const parser::CharBlock &source) {
     CHECK(!dirContext_.empty());
     SetContextDirectiveSource(source);
protected:
   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()) {
       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());

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

private:
   std::int64_t cycleLevel_;
   std::map<std::string, std::int64_t> labelNamesandLevels_;
 };
 
 bool OmpStructureChecker::HasInvalidWorksharingNesting(
     const parser::CharBlock &source, const OmpDirectiveSet &set) {
   // set contains all the invalid closely nested directives
   // for the given directive (`source` here)
-  if (CurrentDirectiveIsNested() && set.test(GetContext().directive)) {
+  if (CurrentDirectiveIsNested() && set.test(GetContextParent().directive)) {
     context_.Say(source,
         "A worksharing region may not be closely nested inside a "
         "worksharing, explicit task, taskloop, critical, ordered, atomic, or "
         "master region"_err_en_US);
     return true;
   }
   return false;
 }
void OmpStructureChecker::Enter(const parser::OpenMPLoopConstruct &x) {
   if (const auto &endLoopDir{
           std::get<std::optional<parser::OmpEndLoopDirective>>(x.t)}) {
     const auto &endDir{
         std::get<parser::OmpLoopDirective>(endLoopDir.value().t)};
 
     CheckMatching<parser::OmpLoopDirective>(beginDir, endDir);
   }
 
-  if (beginDir.v != llvm::omp::Directive::OMPD_do) {
-    PushContextAndClauseSets(beginDir.source, beginDir.v);
-  } else {
+
+  if (beginDir.v == llvm::omp::Directive::OMPD_do) {
     // 2.7.1 do-clause -> private-clause |
     //                    firstprivate-clause |
     //                    lastprivate-clause |
     //                    linear-clause |
     //                    reduction-clause |
     //                    schedule-clause |
     //                    collapse-clause |
     //                    ordered-clause
 
     // nesting check
     HasInvalidWorksharingNesting(beginDir.source,
         {llvm::omp::Directive::OMPD_do, llvm::omp::Directive::OMPD_sections,
             llvm::omp::Directive::OMPD_single,
             llvm::omp::Directive::OMPD_workshare,
             llvm::omp::Directive::OMPD_task,
             llvm::omp::Directive::OMPD_taskloop,
             llvm::omp::Directive::OMPD_critical,
             llvm::omp::Directive::OMPD_ordered,
             llvm::omp::Directive::OMPD_atomic,
             llvm::omp::Directive::OMPD_master});
-    PushContextAndClauseSets(beginDir.source, llvm::omp::Directive::OMPD_do);
   }
   SetLoopInfo(x);
 
   if (const auto &doConstruct{
           std::get<std::optional<parser::DoConstruct>>(x.t)}) {
     const auto &doBlock{std::get<parser::Block>(doConstruct->t)};
     CheckNoBranching(doBlock, beginDir.v, beginDir.source);
   }
void OmpStructureChecker::Enter(const parser::OpenMPBlockConstruct &x) {
   const auto &beginBlockDir{std::get<parser::OmpBeginBlockDirective>(x.t)};
   const auto &endBlockDir{std::get<parser::OmpEndBlockDirective>(x.t)};
   const auto &beginDir{std::get<parser::OmpBlockDirective>(beginBlockDir.t)};
   const auto &endDir{std::get<parser::OmpBlockDirective>(endBlockDir.t)};
   const parser::Block &block{std::get<parser::Block>(x.t)};
 
   CheckMatching<parser::OmpBlockDirective>(beginDir, endDir);
 
+  PushContextAndClauseSets(beginDir.source, beginDir.v);
+
   // TODO: This check needs to be extended while implementing nesting of regions
   // checks.
   if (beginDir.v == llvm::omp::Directive::OMPD_single) {
     HasInvalidWorksharingNesting(
         beginDir.source, {llvm::omp::Directive::OMPD_do});
   }
+  if (CurrentDirectiveIsNested())
     CheckIfDoOrderedClause(beginDir);
 
-  PushContextAndClauseSets(beginDir.source, beginDir.v);
   CheckNoBranching(block, beginDir.v, beginDir.source);
 
   switch (beginDir.v) {
   case llvm::omp::OMPD_workshare:
   case llvm::omp::OMPD_parallel_workshare:
     CheckWorkshareBlockStmts(block, beginDir.source);
     break;
   default:
     break;
   }
 }
 
 void OmpStructureChecker::CheckIfDoOrderedClause(
     const parser::OmpBlockDirective &blkDirective) {
   if (blkDirective.v == llvm::omp::OMPD_ordered) {
-    if (!FindClause(llvm::omp::Clause::OMPC_ordered)) {
+    if (!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);
     }
   }
 }