[Flang][openmp][2/5] Make Default clause part of OmpClause

[sameeranjoshi]

Summary

After discussion in D93482 we found that the some of the clauses were not
following the common OmpClause convention.

The benefits of using OmpClause:

• Functionalities from structure checker are mostly aligned to work with llvm::omp::Clause.
• The unparsing as well can take advantage.
• Homogeneity with OpenACC and rest of the clauses in OpenMP.
• Could even generate the parser with TableGen, when there is homogeneity.
• It becomes confusing when to use flangClass and flangClassValue inside TableGen, if incase we generate parser using TableGen we could have only a single let expression.

This patch makes OmpDefaultClause clause part of OmpClause.
The unparse function is dropped as the unparsing is done by WALK_NESTED_ENUM
for OmpDefaultClause.

[clementval]

LGTM

[kiranktp]

LGTM.

flang/lib/Lower/OpenMP.cpp

auto parallelOp = firOpBuilder.create<mlir::omp::ParallelOp>(
         currentLocation, argTy, ifClauseOperand, numThreadsClauseOperand,
         defaultClauseOperand.dyn_cast_or_null<StringAttr>(),
         privateClauseOperands, firstprivateClauseOperands, sharedClauseOperands,
         copyinClauseOperands, ValueRange(), ValueRange(),
         procBindClauseOperand.dyn_cast_or_null<StringAttr>());
     // Handle attribute based clauses.
     for (const auto &clause : parallelOpClauseList.v) {
       if (const auto &defaultClause =
-              std::get_if<Fortran::parser::OmpDefaultClause>(&clause.u)) {
-        switch (defaultClause->v) {
+              std::get_if<Fortran::parser::OmpClause::Default>(&clause.u)) {
+        const auto &ompDefaultClause{defaultClause->v};
+        switch (ompDefaultClause.v) {
         case Fortran::parser::OmpDefaultClause::Type::Private:
           parallelOp.default_valAttr(firOpBuilder.getStringAttr(
               omp::stringifyClauseDefault(omp::ClauseDefault::defprivate)));
           break;
         case Fortran::parser::OmpDefaultClause::Type::Firstprivate:
           parallelOp.default_valAttr(
               firOpBuilder.getStringAttr(omp::stringifyClauseDefault(
                   omp::ClauseDefault::deffirstprivate)));

flang/lib/Parser/openmp-parsers.cpp

TYPE_PARSER(
     "ALLOCATOR" >> construct<OmpClause>(construct<OmpClause::Allocator>(
                        parenthesized(scalarIntExpr))) ||
     "COLLAPSE" >> construct<OmpClause>(construct<OmpClause::Collapse>(
                       parenthesized(scalarIntConstantExpr))) ||
     "COPYIN" >> construct<OmpClause>(construct<OmpClause::Copyin>(
                     parenthesized(Parser<OmpObjectList>{}))) ||
     "COPYPRIVATE" >> construct<OmpClause>(construct<OmpClause::Copyprivate>(
                          (parenthesized(Parser<OmpObjectList>{})))) ||
-    "DEFAULT"_id >>
-        construct<OmpClause>(parenthesized(Parser<OmpDefaultClause>{})) ||
+    "DEFAULT"_id >> construct<OmpClause>(construct<OmpClause::Default>(
+                        parenthesized(Parser<OmpDefaultClause>{}))) ||
     "DEFAULTMAP" >>
         construct<OmpClause>(parenthesized(Parser<OmpDefaultmapClause>{})) ||
     "DEPEND" >>
         construct<OmpClause>(parenthesized(Parser<OmpDependClause>{})) ||
     "DEVICE" >> construct<OmpClause>(construct<OmpClause::Device>(
                     parenthesized(scalarIntExpr))) ||
     "DIST_SCHEDULE" >>
         construct<OmpClause>(construct<OmpDistScheduleClause>(

flang/lib/Parser/unparse.cpp

return std::visit(common::visitors{
                           },
                           [&](const OmpDependClause::InOut &) {
                             Word("DEPEND");
                             return true;
                           },
                       },
         x.u);
   }
-  bool Pre(const OmpDefaultClause &) {
-    Word("DEFAULT(");
-    return true;
-  }
-  void Post(const OmpDefaultClause &) { Put(")"); }
   bool Pre(const OmpProcBindClause &) {
     Word("PROC_BIND(");
     return true;
   }
   void Post(const OmpProcBindClause &) { Put(")"); }
   void Unparse(const OmpDefaultmapClause &x) {
     Word("DEFAULTMAP(");
     Walk(std::get<OmpDefaultmapClause::ImplicitBehavior>(x.t));

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

#include "llvm/Frontend/OpenMP/OMP.inc"
   void Enter(const parser::OmpClause::Inbranch &);
   void Enter(const parser::OmpClause::Mergeable &);
   void Enter(const parser::OmpClause::Nogroup &);
   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::Device &);
   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 &);
#include "llvm/Frontend/OpenMP/OMP.inc"
   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::OmpDefaultClause &);
   void Enter(const parser::OmpDefaultmapClause &);
   void Enter(const parser::OmpDependClause &);
   void Enter(const parser::OmpDistScheduleClause &);
   void Enter(const parser::OmpIfClause &);
   void Enter(const parser::OmpLinearClause &);
   void Enter(const parser::OmpMapClause &);
   void Enter(const parser::OmpProcBindClause &);
   void Enter(const parser::OmpReductionClause &);

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

void OmpStructureChecker::Enter(const parser::OmpClause &x) {
   SetContextClause(x);
 }
 
 // Following clauses do not have a seperate node in parse-tree.h.
 // They fall under 'struct OmpClause' in parse-tree.h.
 CHECK_SIMPLE_CLAUSE(Allocate, OMPC_allocate)
 CHECK_SIMPLE_CLAUSE(Copyin, OMPC_copyin)
 CHECK_SIMPLE_CLAUSE(Copyprivate, OMPC_copyprivate)
+CHECK_SIMPLE_CLAUSE(Default, OMPC_default)
 CHECK_SIMPLE_CLAUSE(Device, OMPC_device)
 CHECK_SIMPLE_CLAUSE(Final, OMPC_final)
 CHECK_SIMPLE_CLAUSE(Firstprivate, OMPC_firstprivate)
 CHECK_SIMPLE_CLAUSE(From, OMPC_from)
 CHECK_SIMPLE_CLAUSE(Inbranch, OMPC_inbranch)
 CHECK_SIMPLE_CLAUSE(IsDevicePtr, OMPC_is_device_ptr)
 CHECK_SIMPLE_CLAUSE(Lastprivate, OMPC_lastprivate)
 CHECK_SIMPLE_CLAUSE(Link, OMPC_link)
std::visit(
               }
             },
             [&](const parser::Name &name) {},
         },
         ompObject.u);
   }
 }
 // Following clauses have a seperate node in parse-tree.h.
-CHECK_SIMPLE_PARSER_CLAUSE(OmpDefaultClause, OMPC_default)
 CHECK_SIMPLE_PARSER_CLAUSE(OmpDistScheduleClause, OMPC_dist_schedule)
 CHECK_SIMPLE_PARSER_CLAUSE(OmpNowait, OMPC_nowait)
 CHECK_SIMPLE_PARSER_CLAUSE(OmpProcBindClause, OMPC_proc_bind)
 CHECK_SIMPLE_PARSER_CLAUSE(OmpReductionClause, OMPC_reduction)
 // Atomic-clause
 CHECK_SIMPLE_PARSER_CLAUSE(OmpAtomicRead, OMPC_read)
 CHECK_SIMPLE_PARSER_CLAUSE(OmpAtomicWrite, OMPC_write)
 CHECK_SIMPLE_PARSER_CLAUSE(OmpAtomicUpdate, OMPC_update)

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

def OMPC_SimdLen : Clause<"simdlen"> {
   let flangClassValue = "ScalarIntConstantExpr";
 }
 def OMPC_Collapse : Clause<"collapse"> {
   let clangClass = "OMPCollapseClause";
   let flangClassValue = "ScalarIntConstantExpr";
 }
 def OMPC_Default : Clause<"default"> {
   let clangClass = "OMPDefaultClause";
-  let flangClass = "OmpDefaultClause";
+  let flangClassValue = "OmpDefaultClause";
 }
 def OMPC_Private : Clause<"private"> {
   let clangClass = "OMPPrivateClause";
   let flangClassValue = "OmpObjectList";
 }
 def OMPC_FirstPrivate : Clause<"firstprivate"> {
   let clangClass = "OMPFirstprivateClause";
   let flangClassValue = "OmpObjectList";