[flang][directive] Get rid of flangClassValue in TableGen

[clementval]

Summary

The TableGen emitter for directives has two slots for flangClass information and this was mainly
to be able to keep up with the legacy openmp parser at the time. Now that all clauses are encapsulated in
AccClause or OmpClause, these two strings are not necessary anymore and were the the source of couple
of problem while working with the generic structure checker for OpenMP.
This patch remove the flangClassValue string from DirectiveBase.td and use the string flangClass as the
placeholder for the encapsulated class.

[sameeranjoshi]

This was a much needed change. Thank you for the refactoring.
One of the typical and most common problems was FindClause did not work as expected given that CheckAllowed was correctly defined for the clauses.

I see tests failing defined with the target mentioned inline.

llvm/test/TableGen/directive2.td

17

Did you check with the target check-llvm-tablegen ?

[clementval]

llvm/test/TableGen/directive2.td

17

I did it but will double-check.

[clementval]

llvm/test/TableGen/directive2.td

17

All tests are passing on my side. What kind of error are you seeing?

[sameeranjoshi]

llvm/test/TableGen/directive2.td

17

Command Output (stderr):
--
directive2.td:17:1: error: Record `TDLC_ClauseA' does not have a field named `flangClassValue'!

def TDLC_ClauseA : Clause<"clausea"> {
^
FileCheck error: '<stdin>' is empty.
FileCheck command line:  /home/amd/f18_git/final_test/driver_build/bin/FileCheck -match-full-lines /home/amd/f18_git/final_test/llvm-project/llvm/test/TableGen/directive2.td -check-prefix=GEN

and for directive1.td.

Command Output (stderr):
--
/home/amd/f18_git/final_test/llvm-project/llvm/test/TableGen/directive1.td:97:16: error: CHECK-NEXT: expected string not found in input
// CHECK-NEXT: llvm::StringRef getTdlAKindName(AKind);

I even rebased on main .
I have gcc version 9.2.1. Maybe that's the source of problem.

[sameeranjoshi]

Ok a clang version 8.0.1 based build passes.
It's seems compiler version related issue.
BTW, is there a way to mitigate or conform such compiler version/build related issues?
LGTM.

[clementval]

In D94821#2505891, @sameeranjoshi wrote:

Ok a clang version 8.0.1 based build passes.
It's seems compiler version related issue.
BTW, is there a way to mitigate or conform such compiler version/build related issues?
LGTM.

Do you see a build failure or a test failure?

flang/lib/Lower/OpenMP.cpp

if (blockDirective.v == llvm::omp::OMPD_parallel) {
     SmallVector<Value, 4> privateClauseOperands, firstprivateClauseOperands,
         sharedClauseOperands, copyinClauseOperands;
     Attribute defaultClauseOperand, procBindClauseOperand;
 
     const auto &parallelOpClauseList =
         std::get<Fortran::parser::OmpClauseList>(beginBlockDirective.t);
     for (const auto &clause : parallelOpClauseList.v) {
       if (const auto &ifClause =
-              std::get_if<Fortran::parser::OmpIfClause>(&clause.u)) {
-        auto &expr = std::get<Fortran::parser::ScalarLogicalExpr>(ifClause->t);
+              std::get_if<Fortran::parser::OmpClause::If>(&clause.u)) {
+        auto &expr =
+            std::get<Fortran::parser::ScalarLogicalExpr>(ifClause->v.t);
         ifClauseOperand = fir::getBase(
             converter.genExprValue(*Fortran::semantics::GetExpr(expr)));
       } else if (const auto &numThreadsClause =
                      std::get_if<Fortran::parser::OmpClause::NumThreads>(
                          &clause.u)) {
         // OMPIRBuilder expects `NUM_THREAD` clause as a `Value`.
         numThreadsClauseOperand = fir::getBase(converter.genExprValue(
             *Fortran::semantics::GetExpr(numThreadsClause->v)));

flang/lib/Parser/openmp-parsers.cpp

TYPE_PARSER(construct<OmpAlignedClause>(
     nonemptyList(name), maybe(":" >> scalarIntConstantExpr)))
 
 TYPE_PARSER(
     construct<OmpObject>(designator) || construct<OmpObject>("/" >> name / "/"))
 
 TYPE_PARSER(
     "ACQUIRE" >> construct<OmpClause>(construct<OmpClause::Acquire>()) ||
     "ACQ_REL" >> construct<OmpClause>(construct<OmpClause::AcqRel>()) ||
-    "ALIGNED" >>
-        construct<OmpClause>(parenthesized(Parser<OmpAlignedClause>{})) ||
+    "ALIGNED" >> construct<OmpClause>(construct<OmpClause::Aligned>(
+                     parenthesized(Parser<OmpAlignedClause>{}))) ||
     "ALLOCATE" >> construct<OmpClause>(construct<OmpClause::Allocate>(
                       parenthesized(Parser<OmpAllocateClause>{}))) ||
     "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>(construct<OmpClause::Default>(
                         parenthesized(Parser<OmpDefaultClause>{}))) ||
-    "DEFAULTMAP" >>
-        construct<OmpClause>(parenthesized(Parser<OmpDefaultmapClause>{})) ||
-    "DEPEND" >>
-        construct<OmpClause>(parenthesized(Parser<OmpDependClause>{})) ||
+    "DEFAULTMAP" >> construct<OmpClause>(construct<OmpClause::Defaultmap>(
+                        parenthesized(Parser<OmpDefaultmapClause>{}))) ||
+    "DEPEND" >> construct<OmpClause>(construct<OmpClause::Depend>(
+                    parenthesized(Parser<OmpDependClause>{}))) ||
     "DEVICE" >> construct<OmpClause>(construct<OmpClause::Device>(
                     parenthesized(scalarIntExpr))) ||
     "DIST_SCHEDULE" >>
         construct<OmpClause>(construct<OmpClause::DistSchedule>(
             parenthesized("STATIC" >> maybe("," >> scalarIntExpr)))) ||
     "FINAL" >> construct<OmpClause>(construct<OmpClause::Final>(
                    parenthesized(scalarLogicalExpr))) ||
     "FIRSTPRIVATE" >> construct<OmpClause>(construct<OmpClause::Firstprivate>(
                           parenthesized(Parser<OmpObjectList>{}))) ||
     "FROM" >> construct<OmpClause>(construct<OmpClause::From>(
                   parenthesized(Parser<OmpObjectList>{}))) ||
     "GRAINSIZE" >> construct<OmpClause>(construct<OmpClause::Grainsize>(
                        parenthesized(scalarIntExpr))) ||
     "HINT" >> construct<OmpClause>(
                   construct<OmpClause::Hint>(parenthesized(constantExpr))) ||
-    "IF" >> construct<OmpClause>(parenthesized(Parser<OmpIfClause>{})) ||
+    "IF" >> construct<OmpClause>(construct<OmpClause::If>(
+                parenthesized(Parser<OmpIfClause>{}))) ||
     "INBRANCH" >> construct<OmpClause>(construct<OmpClause::Inbranch>()) ||
     "IS_DEVICE_PTR" >> construct<OmpClause>(construct<OmpClause::IsDevicePtr>(
                            parenthesized(nonemptyList(name)))) ||
     "LASTPRIVATE" >> construct<OmpClause>(construct<OmpClause::Lastprivate>(
                          parenthesized(Parser<OmpObjectList>{}))) ||
-    "LINEAR" >>
-        construct<OmpClause>(parenthesized(Parser<OmpLinearClause>{})) ||
+    "LINEAR" >> construct<OmpClause>(construct<OmpClause::Linear>(
+                    parenthesized(Parser<OmpLinearClause>{}))) ||
     "LINK" >> construct<OmpClause>(construct<OmpClause::Link>(
                   parenthesized(Parser<OmpObjectList>{}))) ||
-    "MAP" >> construct<OmpClause>(parenthesized(Parser<OmpMapClause>{})) ||
+    "MAP" >> construct<OmpClause>(construct<OmpClause::Map>(
+                 parenthesized(Parser<OmpMapClause>{}))) ||
     "MERGEABLE" >> construct<OmpClause>(construct<OmpClause::Mergeable>()) ||
     "NOGROUP" >> construct<OmpClause>(construct<OmpClause::Nogroup>()) ||
     "NOTINBRANCH" >>
         construct<OmpClause>(construct<OmpClause::Notinbranch>()) ||
     "NOWAIT" >> construct<OmpClause>(construct<OmpClause::Nowait>()) ||
     "NUM_TASKS" >> construct<OmpClause>(construct<OmpClause::NumTasks>(
                        parenthesized(scalarIntExpr))) ||
     "NUM_TEAMS" >> construct<OmpClause>(construct<OmpClause::NumTeams>(
"REDUCTION" >> construct<OmpClause>(construct<OmpClause::Reduction>(
                        parenthesized(Parser<OmpReductionClause>{}))) ||
     "TASK_REDUCTION" >>
         construct<OmpClause>(construct<OmpClause::TaskReduction>(
             parenthesized(Parser<OmpReductionClause>{}))) ||
     "RELAXED" >> construct<OmpClause>(construct<OmpClause::Relaxed>()) ||
     "RELEASE" >> construct<OmpClause>(construct<OmpClause::Release>()) ||
     "SAFELEN" >> construct<OmpClause>(construct<OmpClause::Safelen>(
                      parenthesized(scalarIntConstantExpr))) ||
-    "SCHEDULE" >>
-        construct<OmpClause>(parenthesized(Parser<OmpScheduleClause>{})) ||
+    "SCHEDULE" >> construct<OmpClause>(construct<OmpClause::Schedule>(
+                      parenthesized(Parser<OmpScheduleClause>{}))) ||
     "SEQ_CST" >> construct<OmpClause>(construct<OmpClause::SeqCst>()) ||
     "SHARED" >> construct<OmpClause>(construct<OmpClause::Shared>(
                     parenthesized(Parser<OmpObjectList>{}))) ||
     "SIMD"_id >> construct<OmpClause>(construct<OmpClause::Simd>()) ||
     "SIMDLEN" >> construct<OmpClause>(construct<OmpClause::Simdlen>(
                      parenthesized(scalarIntConstantExpr))) ||
     "THREADS" >> construct<OmpClause>(construct<OmpClause::Threads>()) ||
     "THREAD_LIMIT" >> construct<OmpClause>(construct<OmpClause::ThreadLimit>(

flang/lib/Parser/unparse.cpp

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 OmpMapClause &x) {
-    Word("MAP(");
     Walk(std::get<std::optional<OmpMapType>>(x.t), ":");
     Walk(std::get<OmpObjectList>(x.t));
-    Put(") ");
   }
   void Unparse(const OmpScheduleModifier &x) {
     Walk(std::get<OmpScheduleModifier::Modifier1>(x.t));
     Walk(",", std::get<std::optional<OmpScheduleModifier::Modifier2>>(x.t));
   }
   void Unparse(const OmpScheduleClause &x) {
-    Word("SCHEDULE(");
     Walk(std::get<std::optional<OmpScheduleModifier>>(x.t), ":");
     Walk(std::get<OmpScheduleClause::ScheduleType>(x.t));
     Walk(",", std::get<std::optional<ScalarIntExpr>>(x.t));
-    Put(")");
   }
   void Unparse(const OmpAlignedClause &x) {
-    Word("ALIGNED("), Walk(std::get<std::list<Name>>(x.t), ",");
+    Walk(std::get<std::list<Name>>(x.t), ",");
     Walk(std::get<std::optional<ScalarIntConstantExpr>>(x.t));
-    Put(") ");
   }
   void Unparse(const OmpIfClause &x) {
-    Word("IF("),
-        Walk(std::get<std::optional<OmpIfClause::DirectiveNameModifier>>(x.t),
-            ":");
+    Walk(std::get<std::optional<OmpIfClause::DirectiveNameModifier>>(x.t), ":");
     Walk(std::get<ScalarLogicalExpr>(x.t));
-    Put(") ");
   }
   void Unparse(const OmpLinearClause::WithoutModifier &x) {
-    Word("LINEAR("), Walk(x.names, ", ");
+    Walk(x.names, ", ");
     Walk(":", x.step);
-    Put(")");
   }
   void Unparse(const OmpLinearClause::WithModifier &x) {
-    Word("LINEAR("), Walk(x.modifier), Put("("), Walk(x.names, ","), Put(")");
+    Walk(x.modifier), Put("("), Walk(x.names, ","), Put(")");
     Walk(":", x.step);
-    Put(")");
   }
   void Unparse(const OmpReductionClause &x) {
     Walk(std::get<OmpReductionOperator>(x.t));
     Put(":");
     Walk(std::get<OmpObjectList>(x.t));
   }
   void Unparse(const OmpAllocateClause &x) {
     Walk(std::get<std::optional<OmpAllocateClause::Allocator>>(x.t));
void Unparse(const OmpDependClause::InOut &x) {
     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 &) {
-                            Word("DEPEND(SOURCE)");
+                            Word("SOURCE");
                             return false;
                           },
                           [&](const OmpDependClause::Sink &y) {
-                            Word("DEPEND(SINK:");
+                            Word("SINK:");
                             Walk(y.v);
                             Put(")");
                             return false;
                           },
-                          [&](const OmpDependClause::InOut &) {
-                            Word("DEPEND");
-                            return true;
-                          },
+                          [&](const OmpDependClause::InOut &) { return true; },
                       },
         x.u);
   }
   void Unparse(const OmpDefaultmapClause &x) {
-    Word("DEFAULTMAP(");
     Walk(std::get<OmpDefaultmapClause::ImplicitBehavior>(x.t));
     Walk(":",
         std::get<std::optional<OmpDefaultmapClause::VariableCategory>>(x.t));
-    Word(")");
   }
 #define GEN_FLANG_CLAUSE_UNPARSE
 #include "llvm/Frontend/OpenMP/OMP.inc"
   void Unparse(const OmpLoopDirective &x) {
     switch (x.v) {
     case llvm::omp::Directive::OMPD_distribute:
       Word("DISTRIBUTE ");
       break;

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

 // 2. Checks on clauses which fall under 'struct OmpClause' from parse-tree.h.
 // 3. Checks on clauses which are not in 'struct OmpClause' from parse-tree.h.
 
 void OmpStructureChecker::Leave(const parser::OmpClauseList &) {
   // 2.7 Loop Construct Restriction
   if (llvm::omp::doSet.test(GetContext().directive)) {
     if (auto *clause{FindClause(llvm::omp::Clause::OMPC_schedule)}) {
       // only one schedule clause is allowed
-      const auto &schedClause{std::get<parser::OmpScheduleClause>(clause->u)};
-      if (ScheduleModifierHasType(schedClause,
+      const auto &schedClause{std::get<parser::OmpClause::Schedule>(clause->u)};
+      if (ScheduleModifierHasType(schedClause.v,
               parser::OmpScheduleModifierType::ModType::Nonmonotonic)) {
         if (FindClause(llvm::omp::Clause::OMPC_ordered)) {
           context_.Say(clause->source,
               "The NONMONOTONIC modifier cannot be specified "
               "if an ORDERED clause is specified"_err_en_US);
         }
-        if (ScheduleModifierHasType(schedClause,
+        if (ScheduleModifierHasType(schedClause.v,
                 parser::OmpScheduleModifierType::ModType::Monotonic)) {
           context_.Say(clause->source,
               "The MONOTONIC and NONMONOTONIC modifiers "
               "cannot be both specified"_err_en_US);
         }
       }
     }
 

llvm/include/llvm/Frontend/Directive/DirectiveBase.td

class Clause<string c> {
   string name = c;
 
   // Define an alternative name return in get<LanguageName>ClauseName function.
   string alternativeName = "";
 
   // Optional class holding value of the clause in clang AST.
   string clangClass = "";
 
-  // Optional class holding the clause in flang AST. If left blank, the class
-  // is assumed to be the name of the clause with capitalized word and
-  // underscores removed.
-  // ex: async -> Async
-  //     num_threads -> NumThreads
-  string flangClass = "";
-
   // Optional class holding value of the clause in flang AST.
-  string flangClassValue = "";
+  string flangClass = "";
 
   // If set to true, value is optional. Not optional by default.
   bit isValueOptional = false;
 
   // Name of enum when there is a list of allowed clause values.
   string enumClauseValue = "";
 
   // List of allowed clause values

llvm/include/llvm/Frontend/OpenACC/ACC.td

 }
 
 //===----------------------------------------------------------------------===//
 // Definition of OpenACC clauses
 //===----------------------------------------------------------------------===//
 
 // 2.16.1
 def ACCC_Async : Clause<"async"> {
-  let flangClassValue = "ScalarIntExpr";
+  let flangClass = "ScalarIntExpr";
   let isValueOptional = true;
 }
 
 // 2.9.7
 def ACCC_Auto : Clause<"auto"> {}
 
 // 2.7.12
 def ACCC_Attach : Clause<"attach"> {
-  let flangClassValue = "AccObjectList";
+  let flangClass = "AccObjectList";
 }
 
 // 2.15.1
 def ACCC_Bind : Clause<"bind"> {
-  let flangClassValue = "AccBindClause";
+  let flangClass = "AccBindClause";
 }
 
 // 2.12
 def ACCC_Capture : Clause<"capture"> {
 }
 
 // 2.9.1
 def ACCC_Collapse : Clause<"collapse"> {
-  let flangClassValue = "ScalarIntConstantExpr";
+  let flangClass = "ScalarIntConstantExpr";
 }
 
 // 2.7.6
 def ACCC_Copy : Clause<"copy"> {
-  let flangClassValue = "AccObjectList";
+  let flangClass = "AccObjectList";
 }
 // 2.7.7
 def ACCC_Copyin : Clause<"copyin"> {
-  let flangClassValue = "AccObjectListWithModifier";
+  let flangClass = "AccObjectListWithModifier";
 }
 
 // 2.7.8
 def ACCC_Copyout : Clause<"copyout"> {
-  let flangClassValue = "AccObjectListWithModifier";
+  let flangClass = "AccObjectListWithModifier";
 }
 
 // 2.7.9
 def ACCC_Create : Clause<"create"> {
-  let flangClassValue = "AccObjectListWithModifier";
+  let flangClass = "AccObjectListWithModifier";
 }
 
 // 2.5.15
 def ACC_Default_none : ClauseVal<"none", 1, 1> { let isDefault = 1; }
 def ACC_Default_present : ClauseVal<"present", 0, 1> {}
 
 def ACCC_Default : Clause<"default"> {
-  let flangClassValue = "AccDefaultClause";
+  let flangClass = "AccDefaultClause";
   let enumClauseValue = "DefaultValue";
   let allowedClauseValues = [
     ACC_Default_present,
     ACC_Default_none
   ];
 }
 
 // 2.14.3
 def ACCC_DefaultAsync : Clause<"default_async"> {
-  let flangClassValue = "ScalarIntExpr";
+  let flangClass = "ScalarIntExpr";
 }
 
 // 2.7.11
 def ACCC_Delete : Clause<"delete"> {
-  let flangClassValue = "AccObjectList";
+  let flangClass = "AccObjectList";
 }
 
 // 2.7.13
 def ACCC_Detach : Clause<"detach"> {
-  let flangClassValue = "AccObjectList";
+  let flangClass = "AccObjectList";
 }
 
 // 2.14.4
 def ACCC_Device : Clause<"device"> {
-  let flangClassValue = "AccObjectList";
+  let flangClass = "AccObjectList";
 }
 
 // 2.14.1 - 2.14.2
 def ACCC_DeviceNum : Clause<"device_num">  {
-  let flangClassValue = "ScalarIntExpr";
+  let flangClass = "ScalarIntExpr";
 }
 
 // 2.7.4
 def ACCC_DevicePtr : Clause<"deviceptr"> {
-  let flangClassValue = "AccObjectList";
+  let flangClass = "AccObjectList";
 }
 
 // 2.13.1
 def ACCC_DeviceResident : Clause<"device_resident"> {
-  let flangClassValue = "AccObjectList";
+  let flangClass = "AccObjectList";
 }
 
 // 2.4
 def ACCC_DeviceType : Clause<"device_type"> {
-  let flangClassValue = "ScalarIntExpr";
+  let flangClass = "ScalarIntExpr";
   let defaultValue = "*";
   let isValueOptional = true;
   let isValueList = true;
 }
 
 // 2.6.6
 def ACCC_Finalize : Clause<"finalize"> {}
 
 // 2.5.13
 def ACCC_FirstPrivate : Clause<"firstprivate"> {
-  let flangClassValue = "AccObjectList";
+  let flangClass = "AccObjectList";
 }
 
 // 2.9.2
 def ACCC_Gang : Clause<"gang"> {
-  let flangClassValue = "AccGangArgument";
+  let flangClass = "AccGangArgument";
   let isValueOptional = true;
 }
 
 // 2.14.4
 def ACCC_Host : Clause<"host"> {
-  let flangClassValue = "AccObjectList";
+  let flangClass = "AccObjectList";
 }
 
 // 2.5.5
 def ACCC_If : Clause <"if"> {
-  let flangClassValue = "ScalarLogicalExpr";
+  let flangClass = "ScalarLogicalExpr";
 }
 
 // 2.14.4
 def ACCC_IfPresent : Clause<"if_present"> {}
 
 // 2.9.6
 def ACCC_Independent : Clause<"independent"> {}
 
 // 2.13.3
 def ACCC_Link : Clause<"link"> {
-  let flangClassValue = "AccObjectList";
+  let flangClass = "AccObjectList";
 }
 
 // 2.7.10
 def ACCC_NoCreate : Clause<"no_create"> {
-  let flangClassValue = "AccObjectList";
+  let flangClass = "AccObjectList";
 }
 
 // 2.15.1
 def ACCC_NoHost : Clause<"nohost"> {}
 
 // 2.5.9
 def ACCC_NumGangs : Clause<"num_gangs"> {
-  let flangClassValue = "ScalarIntExpr";
+  let flangClass = "ScalarIntExpr";
 }
 
 // 2.5.10
 def ACCC_NumWorkers : Clause<"num_workers"> {
-  let flangClassValue = "ScalarIntExpr";
+  let flangClass = "ScalarIntExpr";
 }
 
 // 2.7.5
 def ACCC_Present : Clause<"present"> {
-  let flangClassValue = "AccObjectList";
+  let flangClass = "AccObjectList";
 }
 
 // 2.5.12
 def ACCC_Private : Clause<"private"> {
-  let flangClassValue = "AccObjectList";
+  let flangClass = "AccObjectList";
 }
 
 // 2.9.8
 def ACCC_Tile : Clause <"tile"> {
-  let flangClassValue = "AccTileExprList";
+  let flangClass = "AccTileExprList";
 }
 
 // 2.8.1
 def ACCC_UseDevice : Clause <"use_device"> {
-  let flangClassValue = "AccObjectList";
+  let flangClass = "AccObjectList";
 }
 
 // 2.12
 def ACCC_Read : Clause<"read"> {}
 
 // 2.5.14
 def ACCC_Reduction : Clause<"reduction"> {
-  let flangClassValue = "AccObjectListWithReduction";
+  let flangClass = "AccObjectListWithReduction";
 }
 
 // 2.5.6
 def ACCC_Self : Clause<"self"> {
-  let flangClassValue = "AccSelfClause";
+  let flangClass = "AccSelfClause";
 }
 
 // 2.9.5
 def ACCC_Seq : Clause<"seq"> {}
 
 // 2.9.4
 def ACCC_Vector : Clause<"vector"> {
-  let flangClassValue = "ScalarIntExpr";
+  let flangClass = "ScalarIntExpr";
   let isValueOptional = true;
 }
 
 // 2.5.11
 def ACCC_VectorLength : Clause<"vector_length"> {
-  let flangClassValue = "ScalarIntExpr";
+  let flangClass = "ScalarIntExpr";
 }
 
 // 2.16.2
 def ACCC_Wait : Clause<"wait"> {
-  let flangClassValue = "AccWaitArgument";
+  let flangClass = "AccWaitArgument";
   let isValueOptional = true;
 }
 
 // 2.9.3
 def ACCC_Worker: Clause<"worker"> {
-  let flangClassValue = "ScalarIntExpr";
+  let flangClass = "ScalarIntExpr";
   let isValueOptional = true;
 }
 
 // 2.12
 def ACCC_Write : Clause<"write"> {}
 
 def ACCC_Unknown : Clause<"unknown"> {
   let isDefault = true;

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

 }
 
 //===----------------------------------------------------------------------===//
 // Definition of OpenMP clauses
 //===----------------------------------------------------------------------===//
 
 def OMPC_Allocator : Clause<"allocator"> {
   let clangClass = "OMPAllocatorClause";
-  let flangClassValue = "ScalarIntExpr";
+  let flangClass = "ScalarIntExpr";
 }
 def OMPC_If : Clause<"if"> {
   let clangClass = "OMPIfClause";
   let flangClass = "OmpIfClause";
 }
 def OMPC_Final : Clause<"final"> {
   let clangClass = "OMPFinalClause";
-  let flangClassValue = "ScalarLogicalExpr";
+  let flangClass = "ScalarLogicalExpr";
 }
 def OMPC_NumThreads : Clause<"num_threads"> {
   let clangClass = "OMPNumThreadsClause";
-  let flangClassValue = "ScalarIntExpr";
+  let flangClass = "ScalarIntExpr";
 }
 def OMPC_SafeLen : Clause<"safelen"> {
   let clangClass = "OMPSafelenClause";
-  let flangClassValue = "ScalarIntConstantExpr";
+  let flangClass = "ScalarIntConstantExpr";
 }
 def OMPC_SimdLen : Clause<"simdlen"> {
   let clangClass = "OMPSimdlenClause";
-  let flangClassValue = "ScalarIntConstantExpr";
+  let flangClass = "ScalarIntConstantExpr";
 }
 def OMPC_Collapse : Clause<"collapse"> {
   let clangClass = "OMPCollapseClause";
-  let flangClassValue = "ScalarIntConstantExpr";
+  let flangClass = "ScalarIntConstantExpr";
 }
 def OMPC_Default : Clause<"default"> {
   let clangClass = "OMPDefaultClause";
-  let flangClassValue = "OmpDefaultClause";
+  let flangClass = "OmpDefaultClause";
 }
 def OMPC_Private : Clause<"private"> {
   let clangClass = "OMPPrivateClause";
-  let flangClassValue = "OmpObjectList";
+  let flangClass = "OmpObjectList";
 }
 def OMPC_FirstPrivate : Clause<"firstprivate"> {
   let clangClass = "OMPFirstprivateClause";
-  let flangClassValue = "OmpObjectList";
+  let flangClass = "OmpObjectList";
 }
 def OMPC_LastPrivate : Clause<"lastprivate"> {
   let clangClass = "OMPLastprivateClause";
-  let flangClassValue = "OmpObjectList";
+  let flangClass = "OmpObjectList";
 }
 def OMPC_Shared : Clause<"shared"> {
   let clangClass = "OMPSharedClause";
-  let flangClassValue = "OmpObjectList";
+  let flangClass = "OmpObjectList";
 }
 def OMPC_Reduction : Clause<"reduction"> {
   let clangClass = "OMPReductionClause";
-  let flangClassValue = "OmpReductionClause";
+  let flangClass = "OmpReductionClause";
 }
 def OMPC_Linear : Clause<"linear"> {
   let clangClass = "OMPLinearClause";
   let flangClass = "OmpLinearClause";
 }
 def OMPC_Aligned : Clause<"aligned"> {
   let clangClass = "OMPAlignedClause";
   let flangClass = "OmpAlignedClause";
 }
 def OMPC_Copyin : Clause<"copyin"> {
   let clangClass = "OMPCopyinClause";
-  let flangClassValue = "OmpObjectList";
+  let flangClass = "OmpObjectList";
 }
 def OMPC_CopyPrivate : Clause<"copyprivate"> {
   let clangClass = "OMPCopyprivateClause";
-  let flangClassValue = "OmpObjectList";
+  let flangClass = "OmpObjectList";
 }
 def OMP_PROC_BIND_master : ClauseVal<"master",2,1> {}
 def OMP_PROC_BIND_close : ClauseVal<"close",3,1> {}
 def OMP_PROC_BIND_spread : ClauseVal<"spread",4,1> {}
 def OMP_PROC_BIND_default : ClauseVal<"default",5,0> {}
 def OMP_PROC_BIND_unknown : ClauseVal<"unknown",6,0> { let isDefault = true; }
 def OMPC_ProcBind : Clause<"proc_bind"> {
   let clangClass = "OMPProcBindClause";
-  let flangClassValue = "OmpProcBindClause";
+  let flangClass = "OmpProcBindClause";
   let enumClauseValue = "ProcBindKind";
   let allowedClauseValues = [
     OMP_PROC_BIND_master,
     OMP_PROC_BIND_close,
     OMP_PROC_BIND_spread,
     OMP_PROC_BIND_default,
     OMP_PROC_BIND_unknown
   ];
let allowedClauseValues = [
     OMP_SCHEDULE_Auto,
     OMP_SCHEDULE_Runtime,
     OMP_SCHEDULE_Default
   ];
 }
 
 def OMPC_Ordered : Clause<"ordered"> {
   let clangClass = "OMPOrderedClause";
-  let flangClassValue = "ScalarIntConstantExpr";
+  let flangClass = "ScalarIntConstantExpr";
   let isValueOptional = true;
 }
 def OMPC_NoWait : Clause<"nowait"> {
   let clangClass = "OMPNowaitClause";
 }
 def OMPC_Untied : Clause<"untied"> { let clangClass = "OMPUntiedClause"; }
 def OMPC_Mergeable : Clause<"mergeable"> {
   let clangClass = "OMPMergeableClause";
 }
 def OMPC_Read : Clause<"read"> { let clangClass = "OMPReadClause"; }
 def OMPC_Write : Clause<"write"> { let clangClass = "OMPWriteClause"; }
 def OMPC_Update : Clause<"update"> { let clangClass = "OMPUpdateClause"; }
 def OMPC_Capture : Clause<"capture"> { let clangClass = "OMPCaptureClause"; }
 def OMPC_SeqCst : Clause<"seq_cst"> { let clangClass = "OMPSeqCstClause"; }
 def OMPC_AcqRel : Clause<"acq_rel"> { let clangClass = "OMPAcqRelClause"; }
 def OMPC_Acquire : Clause<"acquire"> { let clangClass = "OMPAcquireClause"; }
 def OMPC_Release : Clause<"release"> { let clangClass = "OMPReleaseClause"; }
 def OMPC_Relaxed : Clause<"relaxed"> { let clangClass = "OMPRelaxedClause"; }
 def OMPC_Depend : Clause<"depend"> {
   let clangClass = "OMPDependClause";
   let flangClass = "OmpDependClause";
 }
 def OMPC_Device : Clause<"device"> {
   let clangClass = "OMPDeviceClause";
-  let flangClassValue = "ScalarIntExpr";
+  let flangClass = "ScalarIntExpr";
 }
 def OMPC_Threads : Clause<"threads"> { let clangClass = "OMPThreadsClause"; }
 def OMPC_Simd : Clause<"simd"> { let clangClass = "OMPSIMDClause"; }
 def OMPC_Map : Clause<"map"> {
   let clangClass = "OMPMapClause";
   let flangClass = "OmpMapClause";
 }
 def OMPC_NumTeams : Clause<"num_teams"> {
   let clangClass = "OMPNumTeamsClause";
-  let flangClassValue = "ScalarIntExpr";
+  let flangClass = "ScalarIntExpr";
 }
 def OMPC_ThreadLimit : Clause<"thread_limit"> {
   let clangClass = "OMPThreadLimitClause";
-  let flangClassValue = "ScalarIntExpr";
+  let flangClass = "ScalarIntExpr";
 }
 def OMPC_Priority : Clause<"priority"> {
   let clangClass = "OMPPriorityClause";
-  let flangClassValue = "ScalarIntExpr";
+  let flangClass = "ScalarIntExpr";
 }
 def OMPC_GrainSize : Clause<"grainsize"> {
   let clangClass = "OMPGrainsizeClause";
-  let flangClassValue = "ScalarIntExpr";
+  let flangClass = "ScalarIntExpr";
 }
 def OMPC_NoGroup : Clause<"nogroup"> {
   let clangClass = "OMPNogroupClause";
 }
 def OMPC_NumTasks : Clause<"num_tasks"> {
   let clangClass = "OMPNumTasksClause";
-  let flangClassValue = "ScalarIntExpr";
+  let flangClass = "ScalarIntExpr";
 }
 def OMPC_Hint : Clause<"hint"> {
   let clangClass = "OMPHintClause";
-  let flangClassValue = "ConstantExpr";
+  let flangClass = "ConstantExpr";
 }
 def OMPC_DistSchedule : Clause<"dist_schedule"> {
   let clangClass = "OMPDistScheduleClause";
-  let flangClassValue = "ScalarIntExpr";
+  let flangClass = "ScalarIntExpr";
   let isValueOptional = true;
 }
 def OMPC_DefaultMap : Clause<"defaultmap"> {
   let clangClass = "OMPDefaultmapClause";
   let flangClass = "OmpDefaultmapClause";
 }
 def OMPC_To : Clause<"to"> {
   let clangClass = "OMPToClause";
-  let flangClassValue = "OmpObjectList";
+  let flangClass = "OmpObjectList";
 }
 def OMPC_From : Clause<"from"> {
   let clangClass = "OMPFromClause";
-  let flangClassValue = "OmpObjectList";
+  let flangClass = "OmpObjectList";
 }
 def OMPC_UseDevicePtr : Clause<"use_device_ptr"> {
   let clangClass = "OMPUseDevicePtrClause";
-  let flangClassValue = "Name";
+  let flangClass = "Name";
   let isValueList = true;
 }
 def OMPC_IsDevicePtr : Clause<"is_device_ptr"> {
   let clangClass = "OMPIsDevicePtrClause";
-  let flangClassValue = "Name";
+  let flangClass = "Name";
   let isValueList = true;
 }
 def OMPC_TaskReduction : Clause<"task_reduction"> {
   let clangClass = "OMPTaskReductionClause";
-  let flangClassValue = "OmpReductionClause";
+  let flangClass = "OmpReductionClause";
 }
 def OMPC_InReduction : Clause<"in_reduction"> {
   let clangClass = "OMPInReductionClause";
 }
 def OMPC_UnifiedAddress : Clause<"unified_address"> {
   let clangClass = "OMPUnifiedAddressClause";
 }
 def OMPC_UnifiedSharedMemory : Clause<"unified_shared_memory"> {
   let clangClass = "OMPUnifiedSharedMemoryClause";
 }
 def OMPC_ReverseOffload : Clause<"reverse_offload"> {
   let clangClass = "OMPReverseOffloadClause";
 }
 def OMPC_DynamicAllocators : Clause<"dynamic_allocators"> {
   let clangClass = "OMPDynamicAllocatorsClause";
 }
 def OMPC_AtomicDefaultMemOrder : Clause<"atomic_default_mem_order"> {
   let clangClass = "OMPAtomicDefaultMemOrderClause";
 }
 def OMPC_Allocate : Clause<"allocate"> {
   let clangClass = "OMPAllocateClause";
-  let flangClassValue = "OmpAllocateClause";
+  let flangClass = "OmpAllocateClause";
 }
 def OMPC_NonTemporal : Clause<"nontemporal"> {
   let clangClass = "OMPNontemporalClause";
 }
 
 def OMP_ORDER_concurrent : ClauseVal<"default",2,0> { let isDefault = 1; }
 def OMPC_Order : Clause<"order"> {
   let clangClass = "OMPOrderClause";

 }
 def OMPC_Affinity : Clause<"affinity"> {
   let clangClass = "OMPAffinityClause";
 }
 def OMPC_UseDeviceAddr : Clause<"use_device_addr"> {
   let clangClass = "OMPUseDeviceAddrClause";
 }
 def OMPC_Uniform : Clause<"uniform"> {
-  let flangClassValue = "Name";
+  let flangClass = "Name";
   let isValueList = true;
 }
 def OMPC_DeviceType : Clause<"device_type"> {}
 def OMPC_Match : Clause<"match"> {}
 def OMPC_Depobj : Clause<"depobj"> {
   let clangClass = "OMPDepobjClause";
   let isImplicit = true;
 }
 def OMPC_Flush : Clause<"flush"> {
   let clangClass = "OMPFlushClause";
   let isImplicit = true;
 }
 def OMPC_ThreadPrivate : Clause<"threadprivate"> {
   let alternativeName = "threadprivate or thread local";
   let isImplicit = true;
 }
 def OMPC_Unknown : Clause<"unknown"> {
   let isImplicit = true;
   let isDefault = true;
 }
 def OMPC_Link : Clause<"link"> {
-  let flangClassValue = "OmpObjectList";
+  let flangClass = "OmpObjectList";
 }
 def OMPC_Inbranch : Clause<"inbranch"> {}
 def OMPC_Notinbranch : Clause<"notinbranch"> {}
 
 //===----------------------------------------------------------------------===//
 // Definition of OpenMP directives
 //===----------------------------------------------------------------------===//
 

llvm/include/llvm/TableGen/DirectiveEmitter.h

StringRef getClangClass() const {
     return Def->getValueAsString("clangClass");
   }
 
   // Optional field.
   StringRef getFlangClass() const {
     return Def->getValueAsString("flangClass");
   }
 
-  // Optional field.
-  StringRef getFlangClassValue() const {
-    return Def->getValueAsString("flangClassValue");
-  }
-
   // Get the formatted name for Flang parser class. The generic formatted class
   // name is constructed from the name were the first letter of each word is
   // captitalized and the underscores are removed.
   // ex: async -> Async
   //     num_threads -> NumThreads
   std::string getFormattedParserClassName() {
     StringRef Name = Def->getValueAsString("name");
     std::string N = Name.str();

llvm/test/TableGen/directive1.td

def TestDirectiveLanguage : DirectiveLanguage {
   let flangClauseBaseClass = "TdlClause";
 }
 
 def TDLCV_vala : ClauseVal<"vala",1,1> {}
 def TDLCV_valb : ClauseVal<"valb",2,1> {}
 def TDLCV_valc : ClauseVal<"valc",3,0> { let isDefault = 1; }
 
 def TDLC_ClauseA : Clause<"clausea"> {
-  let flangClass = "TdlClauseA";
   let enumClauseValue = "AKind";
   let allowedClauseValues = [
     TDLCV_vala,
     TDLCV_valb,
     TDLCV_valc
   ];
 }
 
 def TDLC_ClauseB : Clause<"clauseb"> {
-  let flangClassValue = "IntExpr";
+  let flangClass = "IntExpr";
   let isValueOptional = 1;
   let isDefault = 1;
 }
 
 def TDL_DirA : Directive<"dira"> {
   let allowedClauses = [
     VersionedClause<TDLC_ClauseA>,
     VersionedClause<TDLC_ClauseB>

 // GEN-NEXT:    },
 // GEN-NEXT:  }
 // GEN-EMPTY:
 // GEN-NEXT:  #endif // GEN_FLANG_DIRECTIVE_CLAUSE_MAP
 // GEN-EMPTY:
 // GEN-NEXT:  #ifdef GEN_FLANG_CLAUSE_PARSER_CLASSES
 // GEN-NEXT:  #undef GEN_FLANG_CLAUSE_PARSER_CLASSES
 // GEN-EMPTY:
+// GEN-NEXT:  EMPTY_CLASS(Clausea);
 // GEN-NEXT:  WRAPPER_CLASS(Clauseb, std::optional<IntExpr>);
 // GEN-EMPTY:
 // GEN-NEXT:  #endif // GEN_FLANG_CLAUSE_PARSER_CLASSES
 // GEN-EMPTY:
 // GEN-NEXT:  #ifdef GEN_FLANG_CLAUSE_PARSER_CLASSES_LIST
 // GEN-NEXT:  #undef GEN_FLANG_CLAUSE_PARSER_CLASSES_LIST
 // GEN-EMPTY:
-// GEN-NEXT:  TdlClauseA
+// GEN-NEXT:  Clausea
 // GEN-NEXT:  , Clauseb
 // GEN-EMPTY:
 // GEN-NEXT:  #endif // GEN_FLANG_CLAUSE_PARSER_CLASSES_LIST
 // GEN-EMPTY:
 // GEN-NEXT:  #ifdef GEN_FLANG_DUMP_PARSE_TREE_CLAUSES
 // GEN-NEXT:  #undef GEN_FLANG_DUMP_PARSE_TREE_CLAUSES
 // GEN-EMPTY:
+// GEN-NEXT:  NODE(TdlClause, Clausea)
 // GEN-NEXT:  NODE(TdlClause, Clauseb)
 // GEN-EMPTY:
 // GEN-NEXT:  #endif // GEN_FLANG_DUMP_PARSE_TREE_CLAUSES
 // GEN-EMPTY:
 // GEN-NEXT:  #ifdef GEN_FLANG_CLAUSE_UNPARSE
 // GEN-NEXT:  #undef GEN_FLANG_CLAUSE_UNPARSE
 // 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

llvm/test/TableGen/directive2.td

 // RUN: llvm-tblgen -gen-directive-decl -I %p/../../include %s | FileCheck -match-full-lines %s
 // RUN: llvm-tblgen -gen-directive-impl -I %p/../../include %s | FileCheck -match-full-lines %s -check-prefix=IMPL
 // RUN: llvm-tblgen -gen-directive-gen -I %p/../../include %s | FileCheck -match-full-lines %s -check-prefix=GEN
 
 include "llvm/Frontend/Directive/DirectiveBase.td"
 
 def TestDirectiveLanguage : DirectiveLanguage {
   let name = "Tdl";
 
   let cppNamespace = "tdl";
   let directivePrefix = "TDLD_";
   let clausePrefix = "TDLC_";
   let includeHeader = "tdl.h.inc";
   let flangClauseBaseClass = "TdlClause";
 }
 
 def TDLC_ClauseA : Clause<"clausea"> {
   let isImplicit = 1;
 }
 def TDLC_ClauseB : Clause<"clauseb"> {
   let isDefault = 1;
-  let flangClassValue = "IntExpr";
+  let flangClass = "IntExpr";
   let isValueList = 1;
 }
 def TDLC_ClauseC : Clause<"clausec"> {
   let clangClass = "ClauseC";
-  let flangClassValue = "Name";
+  let flangClass = "Name";
   let defaultValue = "*";
   let isValueOptional = 1;
 }
 def TDLC_ClauseD : Clause<"claused"> {
   let clangClass = "ClauseD";
   let isImplicit = 1;
 }
 

llvm/utils/TableGen/DirectiveEmitter.cpp

void GenerateFlangClauseParserClass(const DirectiveLanguage &DirLang,
                                     raw_ostream &OS) {
 
   IfDefScope Scope("GEN_FLANG_CLAUSE_PARSER_CLASSES", OS);
 
   OS << "\n";
 
   for (const auto &C : DirLang.getClauses()) {
     Clause Clause{C};
-    // Clause has a non generic class.
-    if (!Clause.getFlangClass().empty())
-      continue;
-    if (!Clause.getFlangClassValue().empty()) {
+    if (!Clause.getFlangClass().empty()) {
       OS << "WRAPPER_CLASS(" << Clause.getFormattedParserClassName() << ", ";
       if (Clause.isValueOptional() && Clause.isValueList()) {
-        OS << "std::optional<std::list<" << Clause.getFlangClassValue()
-           << ">>";
+        OS << "std::optional<std::list<" << Clause.getFlangClass() << ">>";
       } else if (Clause.isValueOptional()) {
-        OS << "std::optional<" << Clause.getFlangClassValue() << ">";
+        OS << "std::optional<" << Clause.getFlangClass() << ">";
       } else if (Clause.isValueList()) {
-        OS << "std::list<" << Clause.getFlangClassValue() << ">";
+        OS << "std::list<" << Clause.getFlangClass() << ">";
       } else {
-        OS << Clause.getFlangClassValue();
+        OS << Clause.getFlangClass();
       }
     } else {
       OS << "EMPTY_CLASS(" << Clause.getFormattedParserClassName();
     }
     OS << ");\n";
   }
 }
 
 // Generate a list of the different clause classes for Flang.
 void GenerateFlangClauseParserClassList(const DirectiveLanguage &DirLang,
                                         raw_ostream &OS) {
 
   IfDefScope Scope("GEN_FLANG_CLAUSE_PARSER_CLASSES_LIST", OS);
 
   OS << "\n";
   llvm::interleaveComma(DirLang.getClauses(), OS, [&](Record *C) {
     Clause Clause{C};
-    if (Clause.getFlangClass().empty())
-      OS << Clause.getFormattedParserClassName() << "\n";
-    else
-      OS << Clause.getFlangClass() << "\n";
   });
 }
 
 // Generate dump node list for the clauses holding a generic class name.
 void GenerateFlangClauseDump(const DirectiveLanguage &DirLang,
                              raw_ostream &OS) {
 
   IfDefScope Scope("GEN_FLANG_DUMP_PARSE_TREE_CLAUSES", OS);
 
   OS << "\n";
   for (const auto &C : DirLang.getClauses()) {
     Clause Clause{C};
-    // Clause has a non generic class.
-    if (!Clause.getFlangClass().empty())
-      continue;
-
     OS << "NODE(" << DirLang.getFlangClauseBaseClass() << ", "
        << Clause.getFormattedParserClassName() << ")\n";
   }
 }
 
 // Generate Unparse functions for clauses classes in the Flang parse-tree
 // If the clause is a non-generic class, no entry is generated.
 void GenerateFlangClauseUnparse(const DirectiveLanguage &DirLang,
                                 raw_ostream &OS) {
 
   IfDefScope Scope("GEN_FLANG_CLAUSE_UNPARSE", OS);
 
   OS << "\n";
 
   for (const auto &C : DirLang.getClauses()) {
     Clause Clause{C};
-    // Clause has a non generic class.
-    if (!Clause.getFlangClass().empty())
-      continue;
-    if (!Clause.getFlangClassValue().empty()) {
+    if (!Clause.getFlangClass().empty()) {
       if (Clause.isValueOptional() && Clause.getDefaultValue().empty()) {
         OS << "void Unparse(const " << DirLang.getFlangClauseBaseClass()
            << "::" << Clause.getFormattedParserClassName() << " &x) {\n";
         OS << "  Word(\"" << Clause.getName().upper() << "\");\n";
 
         OS << "  Walk(\"(\", x.v, \")\");\n";
         OS << "}\n";
       } else if (Clause.isValueOptional()) {