[Flang] [OpenMP] Add function for mapping OpenMP Parser clause classes with the corresponding clause kind

[praveen]

Summary

1. Generate the mapping for clauses between the parser class and the corresponding clause kind for OpenMP and OpenACC using tablegen.

2, Add a common function to get the OmpObjectList from the OpenMP clauses to avoid repetition of code.

[clementval]

LGTM. Thanks for working on that. I'll probably make use of this in the OpenACC part where it makes sense.

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

1460

We could maybe generate this list from TableGen as well since we have the information. Anyway doesn't need to be done in this patch.

[kiranchandramohan]

Thanks for this patch. Couple of nits.

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

845–846

Nit: extra space?

llvm/utils/TableGen/DirectiveEmitter.cpp

652

Would it be possible to add a test in the following file?
test/TableGen/directive1.td

[clementval]

llvm/utils/TableGen/DirectiveEmitter.cpp

652

Right. I missed that point. +1

[praveen]

Update test case directive1.td for TableGen changes

[praveen]

@kiranchandramohan @clementval Thanks for the review . I have updated the test case for the Tablegen changes.

The clang-tidy seems to identify the case style as invalid for this function name GenerateFlangClauseParserKindMap
Any changes required regarding this ? All other functions in the file DirectiveEmitter.cpp follows the same naming convention.

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

1460

I have added this in TODO . Thanks

llvm/utils/TableGen/DirectiveEmitter.cpp

652

Updated the test file test/TableGen/directive1.td . Thanks

[clementval]

The clang-tidy seems to identify the case style as invalid for this function name GenerateFlangClauseParserKindMap
Any changes required regarding this ? All other functions in the file DirectiveEmitter.cpp follows the same naming convention.

Don't worry about this. All other TableGen backend follows this naming convention that's why we did it too.

[praveen]

In D98603#2629758, @clementval wrote:

The clang-tidy seems to identify the case style as invalid for this function name GenerateFlangClauseParserKindMap
Any changes required regarding this ? All other functions in the file DirectiveEmitter.cpp follows the same naming convention.

Don't worry about this. All other TableGen backend follows this naming convention that's why we did it too.

Thanks for the clarification. Will push the patch.

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

#include "llvm/Frontend/OpenMP/OMP.inc"
   void Enter(const parser::OmpAtomicUpdate &);
   void Leave(const parser::OmpAtomicUpdate &);
   void Enter(const parser::OmpAtomicCapture &);
   void Leave(const parser::OmpAtomic &);
 
 #define GEN_FLANG_CLAUSE_CHECK_ENTER
 #include "llvm/Frontend/OpenMP/OMP.inc"
 
+  // Get the OpenMP Clause Kind for the corresponding Parser class
+  template <typename A>
+  llvm::omp::Clause GetClauseKindForParserClass(const A &) {
+#define GEN_FLANG_CLAUSE_PARSER_KIND_MAP
+#include "llvm/Frontend/OpenMP/OMP.inc"
+  }
+
 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 &,
private:
   void CheckReductionTypeList(const parser::OmpClause::Reduction &);
   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 &);
 };
 } // namespace Fortran::semantics
 #endif // FORTRAN_SEMANTICS_CHECK_OMP_STRUCTURE_H_

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

if (const auto *dataRef{parser::Unwrap<parser::DataRef>(ompObject)}) {
         }
       }
     }
   }
 }
 
 void OmpStructureChecker::CheckMultipleAppearanceAcrossContext(
     const parser::OmpObjectList &redObjectList) {
-  const parser::OmpObjectList *objList{nullptr};
   //  TODO: Verify the assumption here that the immediately enclosing region is
   //  the parallel region to which the worksharing construct having reduction
   //  binds to.
   if (auto *enclosingContext{GetEnclosingDirContext()}) {
     for (auto it : enclosingContext->clauseInfo) {
       llvmOmpClause type = it.first;
       const auto *clause = it.second;
-      if (type == llvm::omp::Clause::OMPC_private) {
-        const auto &pClause{std::get<parser::OmpClause::Private>(clause->u)};
-        objList = &pClause.v;
-      } else if (type == llvm::omp::Clause::OMPC_firstprivate) {
-        const auto &fpClause{
-            std::get<parser::OmpClause::Firstprivate>(clause->u)};
-        objList = &fpClause.v;
-      } else if (type == llvm::omp::Clause::OMPC_lastprivate) {
-        const auto &lpClause{
-            std::get<parser::OmpClause::Lastprivate>(clause->u)};
-        objList = &lpClause.v;
-      } else if (type == llvm::omp::Clause::OMPC_reduction) {
-        const auto &rClause{std::get<parser::OmpClause::Reduction>(clause->u)};
-        const auto &olist{std::get<1>(rClause.v.t)};
-        objList = &olist;
-      }
-      if (objList) {
+      if (llvm::omp::privateReductionSet.test(type)) {
+        if (const auto *objList{GetOmpObjectList(*clause)}) {
           for (const auto &ompObject : objList->v) {
             if (const auto *name{parser::Unwrap<parser::Name>(ompObject)}) {
               if (const auto *symbol{name->symbol}) {
                 for (const auto &redOmpObject : redObjectList.v) {
                   if (const auto *rname{
                           parser::Unwrap<parser::Name>(redOmpObject)}) {
                     if (const auto *rsymbol{rname->symbol}) {
                       if (rsymbol->name() == symbol->name()) {
                         context_.Say(GetContext().clauseSource,
                             "%s variable '%s' is %s in outer context must"
                             " be shared in the parallel regions to which any"
                             " of the worksharing regions arising from the "
                             "worksharing"
                             " construct bind."_err_en_US,
                             parser::ToUpperCaseLetters(
                                 getClauseName(llvm::omp::Clause::OMPC_reduction)
                                     .str()),
                             symbol->name(),
                             parser::ToUpperCaseLetters(
                                 getClauseName(type).str()));
                       }
                     }
                   }
                 }
               }
             }
           }
         }
       }
     }
   }
+}
 
 void OmpStructureChecker::Enter(const parser::OmpClause::Ordered &x) {
   CheckAllowed(llvm::omp::Clause::OMPC_ordered);
   // the parameter of ordered clause is optional
   if (const auto &expr{x.v}) {
     RequiresConstantPositiveParameter(llvm::omp::Clause::OMPC_ordered, *expr);
     // 2.8.3 Loop SIMD Construct Restriction
     if (llvm::omp::doSimdSet.test(GetContext().directive)) {

 }
 
 void OmpStructureChecker::Enter(const parser::OmpClause::Lastprivate &x) {
   CheckAllowed(llvm::omp::Clause::OMPC_lastprivate);
 
   DirectivesClauseTriple dirClauseTriple;
   SymbolSourceMap currSymbols;
   GetSymbolsInObjectList(x.v, currSymbols);
-  CheckDefinableObjects(currSymbols, llvm::omp::Clause::OMPC_lastprivate);
+  CheckDefinableObjects(currSymbols, GetClauseKindForParserClass(x));
 
   // Check lastprivate variables in worksharing constructs
   dirClauseTriple.emplace(llvm::omp::Directive::OMPD_do,
       std::make_pair(
           llvm::omp::Directive::OMPD_parallel, llvm::omp::privateReductionSet));
   dirClauseTriple.emplace(llvm::omp::Directive::OMPD_sections,
       std::make_pair(
           llvm::omp::Directive::OMPD_parallel, llvm::omp::privateReductionSet));
 
   CheckPrivateSymbolsInOuterCxt(
-      currSymbols, dirClauseTriple, llvm::omp::Clause::OMPC_lastprivate);
+      currSymbols, dirClauseTriple, GetClauseKindForParserClass(x));
 }
 
 llvm::StringRef OmpStructureChecker::getClauseName(llvm::omp::Clause clause) {
   return llvm::omp::getOpenMPClauseName(clause);
 }
 
 llvm::StringRef OmpStructureChecker::getDirectiveName(
     llvm::omp::Directive directive) {
void OmpStructureChecker::CheckPrivateSymbolsInOuterCxt(
   SymbolSourceMap enclosingSymbols;
   auto range{dirClauseTriple.equal_range(GetContext().directive)};
   for (auto dirIter{range.first}; dirIter != range.second; ++dirIter) {
     auto enclosingDir{dirIter->second.first};
     auto enclosingClauseSet{dirIter->second.second};
     if (auto *enclosingContext{GetEnclosingContextWithDir(enclosingDir)}) {
       for (auto it{enclosingContext->clauseInfo.begin()};
            it != enclosingContext->clauseInfo.end(); ++it) {
-        // TODO: Replace the hard-coded clause names by using autogen checks or
-        // a function which maps parser::OmpClause::<name> to the corresponding
-        // llvm::omp::Clause::OMPC_<name>
-        std::visit(common::visitors{
-                       [&](const parser::OmpClause::Private &x) {
-                         if (enclosingClauseSet.test(
-                                 llvm::omp::Clause::OMPC_private)) {
-                           GetSymbolsInObjectList(x.v, enclosingSymbols);
-                         }
-                       },
-                       [&](const parser::OmpClause::Firstprivate &x) {
-                         if (enclosingClauseSet.test(
-                                 llvm::omp::Clause::OMPC_firstprivate)) {
-                           GetSymbolsInObjectList(x.v, enclosingSymbols);
-                         }
-                       },
-                       [&](const parser::OmpClause::Lastprivate &x) {
-                         if (enclosingClauseSet.test(
-                                 llvm::omp::Clause::OMPC_lastprivate)) {
-                           GetSymbolsInObjectList(x.v, enclosingSymbols);
-                         }
-                       },
-                       [&](const parser::OmpClause::Reduction &x) {
-                         if (enclosingClauseSet.test(
-                                 llvm::omp::Clause::OMPC_reduction)) {
-                           const auto &ompObjectList{
-                               std::get<parser::OmpObjectList>(x.v.t)};
-                           GetSymbolsInObjectList(
-                               ompObjectList, enclosingSymbols);
-                         }
-                       },
-                       [&](const auto &) {},
-                   },
-            it->second->u);
+        if (enclosingClauseSet.test(it->first)) {
+          if (const auto *ompObjectList{GetOmpObjectList(*it->second)}) {
+            GetSymbolsInObjectList(*ompObjectList, enclosingSymbols);
       }
 
       // Check if the symbols in current context are private in outer context
       for (auto iter{currSymbols.begin()}; iter != currSymbols.end(); ++iter) {
         const auto *symbol{iter->first};
         const auto source{iter->second};
         if (enclosingSymbols.find(symbol) != enclosingSymbols.end()) {
           context_.Say(source,
if (parser::Unwrap<parser::AssignmentStmt>(*it) ||
       context_.Say(source,
           "The structured block in a WORKSHARE construct may consist of only "
           "SCALAR or ARRAY assignments, FORALL or WHERE statements, "
           "FORALL, WHERE, ATOMIC, CRITICAL or PARALLEL constructs"_err_en_US);
     }
   }
 }
 
+const parser::OmpObjectList *OmpStructureChecker::GetOmpObjectList(
+    const parser::OmpClause &clause) {
+
+  // Clauses with OmpObjectList as its data member
+  using MemberObjectListClauses = std::tuple<parser::OmpClause::Copyprivate,
+      parser::OmpClause::Copyin, parser::OmpClause::Firstprivate,
+      parser::OmpClause::From, parser::OmpClause::Lastprivate,
+      parser::OmpClause::Link, parser::OmpClause::Private,
+      parser::OmpClause::Shared, parser::OmpClause::To>;
+
+  // Clauses with OmpObjectList in the tuple
+  using TupleObjectListClauses = std::tuple<parser::OmpClause::Allocate,
+      parser::OmpClause::Map, parser::OmpClause::Reduction>;
+
+  // TODO:: Generate the tuples using TableGen.
+  // Handle other constructs with OmpObjectList such as OpenMPThreadprivate.
+  return std::visit(
+      common::visitors{
+          [&](const auto &x) -> const parser::OmpObjectList * {
+            using Ty = std::decay_t<decltype(x)>;
+            if constexpr (common::HasMember<Ty, MemberObjectListClauses>) {
+              return &x.v;
+            } else if constexpr (common::HasMember<Ty,
+                                     TupleObjectListClauses>) {
+              return &(std::get<parser::OmpObjectList>(x.v.t));
+            } else {
+              return nullptr;
+            }
+          },
+      },
+      clause.u);
+}
+
 } // namespace Fortran::semantics

llvm/test/TableGen/directive1.td

 // GEN-EMPTY:
 // GEN-NEXT:  void Before(const TdlClause::Clausea &) { Word("CLAUSEA"); }
 // GEN-NEXT:  void Unparse(const TdlClause::Clauseb &x) {
 // GEN-NEXT:    Word("CLAUSEB");
 // GEN-NEXT:    Walk("(", x.v, ")");
 // GEN-NEXT:  }
 // GEN-EMPTY:
 // GEN-NEXT:  #endif // GEN_FLANG_CLAUSE_UNPARSE
+// GEN-EMPTY:
+// GEN-NEXT:  #ifdef GEN_FLANG_CLAUSE_CHECK_ENTER
+// GEN-NEXT:  #undef GEN_FLANG_CLAUSE_CHECK_ENTER
+// GEN-EMPTY:
+// GEN-NEXT:  void Enter(const parser::TdlClause::Clausea &);
+// GEN-NEXT:  void Enter(const parser::TdlClause::Clauseb &);
+// GEN-EMPTY:
+// GEN-NEXT:  #endif // GEN_FLANG_CLAUSE_CHECK_ENTER
+// GEN-EMPTY:
+// GEN-NEXT:  #ifdef GEN_FLANG_CLAUSE_PARSER_KIND_MAP
+// GEN-NEXT:  #undef GEN_FLANG_CLAUSE_PARSER_KIND_MAP
+// GEN-EMPTY:
+// GEN-NEXT:  if constexpr (std::is_same_v<A, parser::TdlClause::Clausea>)
+// GEN-NEXT:    return llvm::tdl::Clause::TDLC_clausea;
+// GEN-NEXT:  if constexpr (std::is_same_v<A, parser::TdlClause::Clauseb>)
+// GEN-NEXT:    return llvm::tdl::Clause::TDLC_clauseb;
+// GEN-NEXT:  llvm_unreachable("Invalid Tdl Parser clause");
+// GEN-EMPTY:
+// GEN-NEXT:  #endif // GEN_FLANG_CLAUSE_PARSER_KIND_MAP
+// GEN-EMPTY:

llvm/utils/TableGen/DirectiveEmitter.cpp

void GenerateFlangClauseCheckPrototypes(const DirectiveLanguage &DirLang,
   OS << "\n";
   for (const auto &C : DirLang.getClauses()) {
     Clause Clause{C};
     OS << "void Enter(const parser::" << DirLang.getFlangClauseBaseClass()
        << "::" << Clause.getFormattedParserClassName() << " &);\n";
   }
 }
 
+// Generate the mapping for clauses between the parser class and the
+// corresponding clause Kind
+void GenerateFlangClauseParserKindMap(const DirectiveLanguage &DirLang,
+                                      raw_ostream &OS) {
+
+  IfDefScope Scope("GEN_FLANG_CLAUSE_PARSER_KIND_MAP", OS);
+
+  OS << "\n";
+  for (const auto &C : DirLang.getClauses()) {
+    Clause Clause{C};
+    OS << "if constexpr (std::is_same_v<A, parser::"
+       << DirLang.getFlangClauseBaseClass()
+       << "::" << Clause.getFormattedParserClassName();
+    OS << ">)\n";
+    OS << "  return llvm::" << DirLang.getCppNamespace()
+       << "::Clause::" << DirLang.getClausePrefix() << Clause.getFormattedName()
+       << ";\n";
+  }
+
+  OS << "llvm_unreachable(\"Invalid " << DirLang.getName()
+     << " Parser clause\");\n";
+}
+
 // Generate the implementation section for the enumeration in the directive
 // language
 void EmitDirectivesFlangImpl(const DirectiveLanguage &DirLang,
                              raw_ostream &OS) {
 
   GenerateDirectiveClauseSets(DirLang, OS);
 
   GenerateDirectiveClauseMap(DirLang, OS);
 
   GenerateFlangClauseParserClass(DirLang, OS);
 
   GenerateFlangClauseParserClassList(DirLang, OS);
 
   GenerateFlangClauseDump(DirLang, OS);
 
   GenerateFlangClauseUnparse(DirLang, OS);
 
   GenerateFlangClauseCheckPrototypes(DirLang, OS);
+
+  GenerateFlangClauseParserKindMap(DirLang, OS);
 }
 
 void GenerateClauseClassMacro(const DirectiveLanguage &DirLang,
                               raw_ostream &OS) {
   // Generate macros style information for legacy code in clang
   IfDefScope Scope("GEN_CLANG_CLAUSE_CLASS", OS);
 
   OS << "\n";