[flang][directives] Use TableGen to generate clause unparsing

[clementval]

Summary

Use the TableGen directive back-end to generate code for the clauses unparsing.

[kiranchandramohan]

Do you plan to update the tests?

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

3471

Would it make sense to move dist_schedule out of OmpClause and have it as a separate struct?

[clementval]

In D85851#2213865, @kiranchandramohan wrote:

Do you plan to update the tests?

Yeah I forgot that. Will update the patch today with updated test.

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

3471

Yeah I thought about doing that. Might make it clearer that it's a specific case and doesn't fit in the generic ones.

[clementval]

Extract DistSchedule from OmpClause + add tests

[clementval]

@kiranchandramohan Just updated the patch.

[kiranchandramohan]

LGTM. I have mentioned a few nits. You also have some clang-tidy warnings to fix.

BTW, the tests do not seem to be using the new fields introduced in this patch. Would it make sense to use them in the test?

bit valueIsList = 0;
string defaultValue = "";

llvm/utils/TableGen/DirectiveEmitter.cpp

183

Nit: Should the name be isValueList to remain consistent with other boolean functions?

550–559

Nit: Was just checking whether this code can be improved.
At least printing of ");\n" can be common.

604

Nit: as -> is

[clementval]

Address review comment

[clementval]

@kiranchandramohan Thanks for the review. I have added test and corrected other stuffs. One clang-today warning will remain for the function name. It is not consistent with the rest of TableGen so I ignored it from the beginning.

[kiranchandramohan]

LGTM.

[sscalpone]

Looks good!

[clementval]

Rebase

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

#include "llvm/Frontend/OpenACC/ACC.cpp.inc"
   static std::string GetNodeName(const llvm::omp::Directive &x) {
     return llvm::Twine(
         "llvm::omp::Directive = ", llvm::omp::getOpenMPDirectiveName(x))
         .str();
   }
   NODE(parser, OmpCancelType)
   NODE_ENUM(OmpCancelType, Type)
   NODE(parser, OmpClause)
-  NODE(parser, OmpClauseList)
 #define GEN_FLANG_DUMP_PARSE_TREE_CLAUSES
 #include "llvm/Frontend/OpenMP/OMP.cpp.inc"
+  NODE(parser, OmpClauseList)
   NODE(parser, OmpCriticalDirective)
   NODE(OmpCriticalDirective, Hint)
   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, OmpDependClause)
   NODE(OmpDependClause, InOut)
   NODE(OmpDependClause, Sink)
   NODE(OmpDependClause, Source)
   NODE(parser, OmpDependenceType)
   NODE_ENUM(OmpDependenceType, Type)
   NODE(parser, OmpDependSinkVec)
   NODE(parser, OmpDependSinkVecLength)
+  NODE(parser, OmpDistScheduleClause)
   NODE(parser, OmpEndAtomic)
   NODE(parser, OmpEndBlockDirective)
   NODE(parser, OmpEndCriticalDirective)
   NODE(parser, OmpEndLoopDirective)
   NODE(parser, OmpEndSectionsDirective)
   NODE(parser, OmpIfClause)
   NODE_ENUM(OmpIfClause, DirectiveNameModifier)
   NODE(parser, OmpLinearClause)

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

struct InOut {
     std::tuple<OmpDependenceType, std::list<Designator>> t;
   };
   std::variant<Source, Sink, InOut> u;
 };
 
 // 2.7.1 nowait-clause -> NOWAIT
 EMPTY_CLASS(OmpNowait);
 
+// dist_schedule clause does not fit in generic clause class for tablegen.
+// Therefore it is declared separatly here.
+WRAPPER_CLASS(OmpDistScheduleClause, std::optional<ScalarIntExpr>);
+
 // OpenMP Clauses
 struct OmpClause {
   UNION_CLASS_BOILERPLATE(OmpClause);
 
 #define GEN_FLANG_CLAUSE_PARSER_CLASSES
 #include "llvm/Frontend/OpenMP/OMP.cpp.inc"
 
   CharBlock source;
 
   std::variant<
 #define GEN_FLANG_CLAUSE_PARSER_CLASSES_LIST
 #include "llvm/Frontend/OpenMP/OMP.cpp.inc"
       >
       u;
 };

flang/lib/Parser/openmp-parsers.cpp

"DEFAULT"_id >>
         construct<OmpClause>(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<OmpClause::DistSchedule>(
+        construct<OmpClause>(construct<OmpDistScheduleClause>(
             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>(

flang/lib/Parser/unparse.cpp

void Unparse(const AccAtomicUpdate &x) {
     Walk(std::get<Statement<AssignmentStmt>>(x.t));
     BeginOpenACC();
     Walk(std::get<std::optional<AccEndAtomic>>(x.t), "!$ACC END ATOMIC\n");
     EndOpenACC();
   }
   void Unparse(const llvm::acc::Directive &x) {
     Word(llvm::acc::getOpenACCDirectiveName(x).str());
   }
-  void Before(const AccClause::Auto &) { Word("AUTO"); }
-  void Before(const AccClause::Capture &) { Word("CAPTURE"); }
-  void Before(const AccClause::Finalize &) { Word("FINALIZE"); }
-  void Before(const AccClause::IfPresent &) { Word("IF_PRESENT"); }
-  void Before(const AccClause::Independent &) { Word("INDEPENDENT"); }
-  void Before(const AccClause::Nohost &) { Word("NOHOST"); }
-  void Before(const AccClause::Read &) { Word("READ"); }
-  void Before(const AccClause::Seq &) { Word("SEQ"); }
-  void Before(const AccClause::Write &) { Word("WRITE"); }
-  void Before(const AccClause::Unknown &) { Word("UNKNOWN"); }
-  void Unparse(const AccClause::Attach &x) {
-    Word("ATTACH");
-    Put("(");
-    Walk(x.v);
-    Put(")");
-  }
-  void Unparse(const AccClause::Bind &x) {
-    Word("BIND");
-    Put("(");
-    Walk(x.v);
-    Put(")");
-  }
-  void Unparse(const AccClause::Collapse &x) {
-    Word("COLLAPSE");
-    Put("(");
-    Walk(x.v);
-    Put(")");
-  }
-  void Unparse(const AccClause::Copy &x) {
-    Word("COPY");
-    Put("(");
-    Walk(x.v);
-    Put(")");
-  }
-  void Unparse(const AccClause::Copyin &x) {
-    Word("COPYIN");
-    Put("(");
-    Walk(x.v);
-    Put(")");
-  }
-  void Unparse(const AccClause::Copyout &x) {
-    Word("COPYOUT");
-    Put("(");
-    Walk(x.v);
-    Put(")");
-  }
-  void Unparse(const AccClause::Create &x) {
-    Word("CREATE");
-    Put("(");
-    Walk(x.v);
-    Put(")");
-  }
-  void Unparse(const AccClause::Default &x) {
-    Word("DEFAULT");
-    Put("(");
-    Walk(x.v);
-    Put(")");
-  }
-  void Unparse(const AccClause::Delete &x) {
-    Word("DELETE");
-    Put("(");
-    Walk(x.v);
-    Put(")");
-  }
-  void Unparse(const AccClause::Detach &x) {
-    Word("DETACH");
-    Put("(");
-    Walk(x.v);
-    Put(")");
-  }
-  void Unparse(const AccClause::Device &x) {
-    Word("DEVICE");
-    Put("(");
-    Walk(x.v);
-    Put(")");
-  }
-  void Unparse(const AccClause::Deviceptr &x) {
-    Word("DEVICEPTR");
-    Put("(");
-    Walk(x.v);
-    Put(")");
-  }
-  void Unparse(const AccClause::DeviceResident &x) {
-    Word("DEVICE_RESIDENT");
-    Put("(");
-    Walk(x.v);
-    Put(")");
-  }
-  void Unparse(const AccClause::Firstprivate &x) {
-    Word("FIRSTPRIVATE");
-    Put("(");
-    Walk(x.v);
-    Put(")");
-  }
-  void Unparse(const AccClause::Host &x) {
-    Word("HOST");
-    Put("(");
-    Walk(x.v);
-    Put(")");
-  }
-  void Unparse(const AccClause::If &x) {
-    Word("IF");
-    Put("(");
-    Walk(x.v);
-    Put(")");
-  }
-  void Unparse(const AccClause::Link &x) {
-    Word("LINK");
-    Put("(");
-    Walk(x.v);
-    Put(")");
-  }
-  void Unparse(const AccClause::NumGangs &x) {
-    Word("NUM_GANGS");
-    Put("(");
-    Walk(x.v);
-    Put(")");
-  }
-  void Unparse(const AccClause::NumWorkers &x) {
-    Word("NUM_WORKERS");
-    Put("(");
-    Walk(x.v);
-    Put(")");
-  }
-  void Unparse(const AccClause::Present &x) {
-    Word("PRESENT");
-    Put("(");
-    Walk(x.v);
-    Put(")");
-  }
-  void Unparse(const AccClause::Private &x) {
-    Word("PRIVATE");
-    Put("(");
-    Walk(x.v);
-    Put(")");
-  }
-  void Unparse(const AccClause::Reduction &x) {
-    Word("REDUCTION");
-    Put("(");
-    Walk(x.v);
-    Put(")");
-  }
-  void Unparse(const AccClause::VectorLength &x) {
-    Word("VECTOR_LENGTH");
-    Put("(");
-    Walk(x.v);
-    Put(")");
-  }
-  void Unparse(const AccClause::Async &x) {
-    Word("ASYNC");
-    Walk("(", x.v, ")");
-  }
-  void Unparse(const AccClause::DefaultAsync &x) {
-    Word("DEFAULT_ASYNC");
-    Put("(");
-    Walk(x.v);
-    Put(")");
-  }
-  void Unparse(const AccClause::DeviceNum &x) {
-    Word("DEVICE_NUM");
-    Put("(");
-    Walk(x.v);
-    Put(")");
-  }
-  void Unparse(const AccClause::Gang &x) {
-    Word("GANG");
-    Walk("(", x.v, ")");
-  }
-  void Unparse(const AccClause::NoCreate &x) {
-    Word("NO_CREATE");
-    Put("(");
-    Walk(x.v);
-    Put(")");
-  }
-  void Unparse(const AccClause::UseDevice &x) {
-    Word("USE_DEVICE");
-    Put("(");
-    Walk(x.v);
-    Put(")");
-  }
-  void Unparse(const AccClause::Self &x) {
-    Word("SELF");
-    Walk("(", x.v, ")");
-  }
-  void Unparse(const AccClause::Vector &x) {
-    Word("VECTOR");
-    Walk("(", x.v, ")");
-  }
-  void Unparse(const AccClause::Wait &x) {
-    Word("WAIT");
-    Walk("(", x.v, ")");
-  }
-  void Unparse(const AccClause::Worker &x) {
-    Word("WORKER");
-    Walk("(", x.v, ")");
-  }
-  void Unparse(const AccClause::DeviceType &x) {
-    Word("DEVICE_TYPE");
-    Put("(");
-    if (x.v.has_value())
-      Walk(x.v);
-    else
-      Put("*");
-    Put(")");
-  }
+#define GEN_FLANG_CLAUSE_UNPARSE
+#include "llvm/Frontend/OpenACC/ACC.cpp.inc"
   void Unparse(const AccObjectListWithModifier &x) {
     Walk(std::get<std::optional<AccDataModifier>>(x.t), ":");
     Walk(std::get<AccObjectList>(x.t));
   }
   void Unparse(const AccDataModifier::Modifier &x) {
     Word(AccDataModifier::EnumToString(x));
   }
   void Unparse(const AccDefaultClause &x) {
#include "llvm/Frontend/OpenACC/ACC.cpp.inc"
   void Post(const OmpProcBindClause &) { Put(")"); }
   void Unparse(const OmpDefaultmapClause &x) {
     Word("DEFAULTMAP(");
     Walk(std::get<OmpDefaultmapClause::ImplicitBehavior>(x.t));
     Walk(":",
         std::get<std::optional<OmpDefaultmapClause::VariableCategory>>(x.t));
     Word(")");
   }
-  void Before(const OmpClause::Inbranch &) { Word("INBRANCH"); }
-  void Before(const OmpClause::Mergeable &) { Word("MERGEABLE"); }
-  void Before(const OmpClause::Nogroup &) { Word("NOGROUP"); }
-  void Before(const OmpClause::Notinbranch &) { Word("NOTINBRANCH"); }
-  void Before(const OmpClause::Untied &) { Word("UNTIED"); }
-  void Before(const OmpClause::Threads &) { Word("THREADS"); }
-  void Before(const OmpClause::Simd &) { Word("SIMD"); }
   void Unparse(const OmpNowait &) { Word("NOWAIT"); }
-  void Unparse(const OmpClause::Collapse &x) {
-    Word("COLLAPSE(");
-    Walk(x.v);
-    Put(")");
-  }
-  void Unparse(const OmpClause::Copyin &x) {
-    Word("COPYIN(");
-    Walk(x.v);
-    Put(")");
-  }
-  void Unparse(const OmpClause::Copyprivate &x) {
-    Word("COPYPRIVATE(");
-    Walk(x.v);
-    Put(")");
-  }
-  void Unparse(const OmpClause::Device &x) {
-    Word("DEVICE(");
-    Walk(x.v);
-    Put(")");
-  }
-  void Unparse(const OmpClause::DistSchedule &x) {
+  void Unparse(const OmpDistScheduleClause &x) {
     Word("DIST_SCHEDULE(STATIC");
     Walk(", ", x.v);
     Put(")");
   }
-  void Unparse(const OmpClause::Final &x) {
-    Word("FINAL(");
-    Walk(x.v);
-    Put(")");
-  }
-  void Unparse(const OmpClause::Firstprivate &x) {
-    Word("FIRSTPRIVATE(");
-    Walk(x.v);
-    Put(")");
-  }
-  void Unparse(const OmpClause::From &x) {
-    Word("FROM(");
-    Walk(x.v);
-    Put(")");
-  }
-  void Unparse(const OmpClause::Grainsize &x) {
-    Word("GRAINSIZE(");
-    Walk(x.v);
-    Put(")");
-  }
-  void Unparse(const OmpClause::Lastprivate &x) {
-    Word("LASTPRIVATE(");
-    Walk(x.v);
-    Put(")");
-  }
-  void Unparse(const OmpClause::NumTasks &x) {
-    Word("NUM_TASKS(");
-    Walk(x.v);
-    Put(")");
-  }
-  void Unparse(const OmpClause::NumTeams &x) {
-    Word("NUM_TEAMS(");
-    Walk(x.v);
-    Put(")");
-  }
-  void Unparse(const OmpClause::NumThreads &x) {
-    Word("NUM_THREADS(");
-    Walk(x.v);
-    Put(")");
-  }
-  void Unparse(const OmpClause::Ordered &x) {
-    Word("ORDERED");
-    Walk("(", x.v, ")");
-  }
-  void Unparse(const OmpClause::Priority &x) {
-    Word("PRIORITY(");
-    Walk(x.v);
-    Put(")");
-  }
-  void Unparse(const OmpClause::Private &x) {
-    Word("PRIVATE(");
-    Walk(x.v);
-    Put(")");
-  }
-  void Unparse(const OmpClause::Safelen &x) {
-    Word("SAFELEN(");
-    Walk(x.v);
-    Put(")");
-  }
-  void Unparse(const OmpClause::Simdlen &x) {
-    Word("SIMDLEN(");
-    Walk(x.v);
-    Put(")");
-  }
-  void Unparse(const OmpClause::ThreadLimit &x) {
-    Word("THREAD_LIMIT(");
-    Walk(x.v);
-    Put(")");
-  }
-  void Unparse(const OmpClause::Shared &x) {
-    Word("SHARED(");
-    Walk(x.v);
-    Put(")");
-  }
-  void Unparse(const OmpClause::To &x) {
-    Word("TO(");
-    Walk(x.v);
-    Put(")");
-  }
-  void Unparse(const OmpClause::Link &x) {
-    Word("LINK(");
-    Walk(x.v);
-    Put(")");
-  }
-  void Unparse(const OmpClause::Uniform &x) {
-    Word("UNIFORM(");
-    Walk(x.v, ",");
-    Put(")");
-  }
-  void Unparse(const OmpClause::UseDevicePtr &x) {
-    Word("USE_DEVICE_PTR(");
-    Walk(x.v, ",");
-    Put(")");
-  }
-  void Unparse(const OmpClause::IsDevicePtr &x) {
-    Word("IS_DEVICE_PTR(");
-    Walk(x.v, ",");
-    Put(")");
-  }
+#define GEN_FLANG_CLAUSE_UNPARSE
+#include "llvm/Frontend/OpenMP/OMP.cpp.inc"
   void Unparse(const OmpLoopDirective &x) {
     switch (x.v) {
     case llvm::omp::Directive::OMPD_distribute:
       Word("DISTRIBUTE ");
       break;
     case llvm::omp::Directive::OMPD_distribute_parallel_do:
       Word("DISTRIBUTE PARALLEL DO ");
       break;

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

#include "llvm/Frontend/OpenMP/OMP.cpp.inc"
   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::Device &);
-  void Enter(const parser::OmpClause::DistSchedule &);
   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 &);
   void Enter(const parser::OmpClause::NumThreads &);
#include "llvm/Frontend/OpenMP/OMP.cpp.inc"
   void Enter(const parser::OmpClause::Uniform &);
   void Enter(const parser::OmpClause::UseDevicePtr &);
   void Enter(const parser::OmpClause::IsDevicePtr &);
 
   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 &);
   void Enter(const parser::OmpScheduleClause &);
 
 private:

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

void OmpStructureChecker::Enter(const parser::OmpClause::Copyin &) {
   CheckAllowed(llvm::omp::Clause::OMPC_copyin);
 }
 void OmpStructureChecker::Enter(const parser::OmpClause::Copyprivate &) {
   CheckAllowed(llvm::omp::Clause::OMPC_copyprivate);
 }
 void OmpStructureChecker::Enter(const parser::OmpClause::Device &) {
   CheckAllowed(llvm::omp::Clause::OMPC_device);
 }
-void OmpStructureChecker::Enter(const parser::OmpClause::DistSchedule &) {
+void OmpStructureChecker::Enter(const parser::OmpDistScheduleClause &) {
   CheckAllowed(llvm::omp::Clause::OMPC_dist_schedule);
 }
 void OmpStructureChecker::Enter(const parser::OmpClause::Final &) {
   CheckAllowed(llvm::omp::Clause::OMPC_final);
 }
 void OmpStructureChecker::Enter(const parser::OmpClause::Firstprivate &) {
   CheckAllowed(llvm::omp::Clause::OMPC_firstprivate);
 }

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

class Clause<string c> {
   string flangClass = "";
 
   // Optional class holding value of the clause in flang AST.
   string flangClassValue = "";
 
   // If set to 1, value is optional. Not optional by default.
   bit isValueOptional = 0;
 
+  // If set to 1, value class is part of a list. Single class by default.
+  bit isValueList = 0;
+
+  // Define a default value such as "*".
+  string defaultValue = "";
+
   // Is clause implicit? If clause is set as implicit, the default kind will
   // be return in get<LanguageName>ClauseKind instead of their own kind.
   bit isImplicit = 0;
 
   // Set directive used by default when unknown. Function returning the kind
   // of enumeration will use this clause as the default.
   bit isDefault = 0;
 }

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

 
 // 2.13
 def ACCC_DeviceResident : Clause<"device_resident"> {
   let flangClassValue = "AccObjectList";
 }
 
 // 2.4
 def ACCC_DeviceType : Clause<"device_type"> {
-  // (DeviceType, "*"
-  let flangClassValue = "std::list<Name>";
+  let flangClassValue = "Name";
+  let defaultValue = "*";
   let isValueOptional = 1;
+  let isValueList = 1;
 }
 
 // 2.6.6
 def ACCC_Finalize : Clause<"finalize"> {}
 
 // 2.5.12
 def ACCC_FirstPrivate : Clause<"firstprivate"> {
   let flangClassValue = "AccObjectList";

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

def OMPC_NumTasks : Clause<"num_tasks"> {
   let clangClass = "OMPNumTasksClause";
   let flangClassValue = "ScalarIntExpr";
 }
 def OMPC_Hint : Clause<"hint"> {
   let clangClass = "OMPHintClause";
 }
 def OMPC_DistSchedule : Clause<"dist_schedule"> {
   let clangClass = "OMPDistScheduleClause";
+  let flangClass = "OmpDistScheduleClause";
   let flangClassValue = "ScalarIntExpr";
   let isValueOptional = 1;
 }
 def OMPC_DefaultMap : Clause<"defaultmap"> {
   let clangClass = "OMPDefaultmapClause";
   let flangClass = "OmpDefaultmapClause";
 }
 def OMPC_To : Clause<"to"> {
   let clangClass = "OMPToClause";
   let flangClassValue = "OmpObjectList";
 }
 def OMPC_From : Clause<"from"> {
   let clangClass = "OMPFromClause";
   let flangClassValue = "OmpObjectList";
 }
 def OMPC_UseDevicePtr : Clause<"use_device_ptr"> {
   let clangClass = "OMPUseDevicePtrClause";
-  let flangClassValue = "std::list<Name>";
+  let flangClassValue = "Name";
+  let isValueList = 1;
 }
 def OMPC_IsDevicePtr : Clause<"is_device_ptr"> {
   let clangClass = "OMPIsDevicePtrClause";
-  let flangClassValue = "std::list<Name>";
+  let flangClassValue = "Name";
+  let isValueList = 1;
 }
 def OMPC_TaskReduction : Clause<"task_reduction"> {
   let clangClass = "OMPTaskReductionClause";
 }
 def OMPC_InReduction : Clause<"in_reduction"> {
   let clangClass = "OMPInReductionClause";
 }
 def OMPC_UnifiedAddress : Clause<"unified_address"> {

 }
 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 = "std::list<Name>";
+  let flangClassValue = "Name";
+  let isValueList = 1;
 }
 def OMPC_DeviceType : Clause<"device_type"> {}
 def OMPC_Match : Clause<"match"> {}
 def OMPC_Depobj : Clause<"depobj"> {
   let clangClass = "OMPDepobjClause";
   let isImplicit = 1;
 }
 def OMPC_Flush : Clause<"flush"> {

llvm/test/TableGen/directive1.td

 // 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, 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 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

 }
 
 def TDLC_ClauseA : Clause<"clausea"> {
   let isImplicit = 1;
 }
 def TDLC_ClauseB : Clause<"clauseb"> {
   let isDefault = 1;
   let flangClassValue = "IntExpr";
+  let isValueList = 1;
+}
+def TDLC_ClauseC : Clause<"clausec"> {
+  let flangClassValue = "Name";
+  let defaultValue = "*";
+  let isValueOptional = 1;
 }
 
 def TDL_DirA : Directive<"dira"> {
   let allowedClauses = [
     VersionedClause<TDLC_ClauseA, 2, 4>,
     VersionedClause<TDLC_ClauseB, 2>
   ];
   let isDefault = 1;

 // CHECK-NEXT:    TDLD_dira,
 // CHECK-NEXT:  };
 // CHECK-EMPTY:
 // CHECK-NEXT:  static constexpr std::size_t Directive_enumSize = 1;
 // CHECK-EMPTY:
 // CHECK-NEXT:  enum class Clause {
 // CHECK-NEXT:    TDLC_clausea,
 // CHECK-NEXT:    TDLC_clauseb,
+// CHECK-NEXT:    TDLC_clausec,
 // CHECK-NEXT:  };
 // CHECK-EMPTY:
-// CHECK-NEXT:  static constexpr std::size_t Clause_enumSize = 2;
+// CHECK-NEXT:  static constexpr std::size_t Clause_enumSize = 3;
 // CHECK-EMPTY:
 // CHECK-NEXT:  // Enumeration helper functions
 // CHECK-NEXT:  Directive getTdlDirectiveKind(llvm::StringRef Str);
 // CHECK-EMPTY:
 // CHECK-NEXT:  llvm::StringRef getTdlDirectiveName(Directive D);
 // CHECK-EMPTY:
 // CHECK-NEXT:  Clause getTdlClauseKind(llvm::StringRef Str);
 // CHECK-EMPTY:

 // IMPL-NEXT:    }
 // IMPL-NEXT:    llvm_unreachable("Invalid Tdl Directive kind");
 // IMPL-NEXT:  }
 // IMPL-EMPTY:
 // IMPL-NEXT:  Clause llvm::tdl::getTdlClauseKind(llvm::StringRef Str) {
 // IMPL-NEXT:    return llvm::StringSwitch<Clause>(Str)
 // IMPL-NEXT:      .Case("clausea",TDLC_clauseb)
 // IMPL-NEXT:      .Case("clauseb",TDLC_clauseb)
+// IMPL-NEXT:      .Case("clausec",TDLC_clausec)
 // IMPL-NEXT:      .Default(TDLC_clauseb);
 // IMPL-NEXT:  }
 // IMPL-EMPTY:
 // IMPL-NEXT:  llvm::StringRef llvm::tdl::getTdlClauseName(Clause Kind) {
 // IMPL-NEXT:    switch (Kind) {
 // IMPL-NEXT:      case TDLC_clausea:
 // IMPL-NEXT:        return "clausea";
 // IMPL-NEXT:      case TDLC_clauseb:
 // IMPL-NEXT:        return "clauseb";
+// IMPL-NEXT:      case TDLC_clausec:
+// IMPL-NEXT:        return "clausec";
 // IMPL-NEXT:    }
 // IMPL-NEXT:    llvm_unreachable("Invalid Tdl Clause kind");
 // IMPL-NEXT:  }
 // IMPL-EMPTY:
 // IMPL-NEXT:  bool llvm::tdl::isAllowedClauseForDirective(Directive D, Clause C, unsigned Version) {
 // IMPL-NEXT:    assert(unsigned(D) <= llvm::tdl::Directive_enumSize);
 // IMPL-NEXT:    assert(unsigned(C) <= llvm::tdl::Clause_enumSize);
 // IMPL-NEXT:    switch (D) {

 // 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, IntExpr);
+// GEN-NEXT:  WRAPPER_CLASS(Clauseb, std::list<IntExpr>);
+// GEN-NEXT:  WRAPPER_CLASS(Clausec, std::optional<Name>);
 // 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:  Clausea
 // GEN-NEXT:  , Clauseb
+// GEN-NEXT:  , Clausec
 // 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-NEXT:  NODE(TdlClause, Clausec)
+// 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:    Put("(");
+// GEN-NEXT:    Walk(x.v, ",");
+// GEN-NEXT:    Put(")");
+// GEN-NEXT:  }
+// GEN-NEXT:  void Unparse(const TdlClause::Clausec &x) {
+// GEN-NEXT:  Word("CLAUSEC");
+// GEN-NEXT:    Put("(");
+// GEN-NEXT:    if (x.v.has_value())
+// GEN-NEXT:    Walk(x.v);
+// GEN-NEXT:    else
+// GEN-NEXT:    Put("*");
+// GEN-NEXT:    Put(")");
+// GEN-NEXT:  }
 // GEN-EMPTY:
-// GEN-NEXT:  #endif // GEN_FLANG_DUMP_PARSE_TREE_CLAUSES
+// GEN-NEXT:  #endif // GEN_FLANG_CLAUSE_UNPARSE
 

llvm/utils/TableGen/DirectiveEmitter.cpp

std::transform(N.begin(), N.end(), N.begin(), [&Cap](unsigned char C) {
       return C;
     });
     N.erase(std::remove(N.begin(), N.end(), '_'), N.end());
     return N;
   }
 
   bool isValueOptional() const { return Def->getValueAsBit("isValueOptional"); }
 
+  bool isValueList() const { return Def->getValueAsBit("isValueList"); }
+
+  StringRef getDefaultValue() const {
+    return Def->getValueAsString("defaultValue");
+  }
+
   bool isImplict() const { return Def->getValueAsBit("isImplicit"); }
 };
 
 // Wrapper class that contains VersionedClause's information defined in
 // DirectiveBase.td and provides helper methods for accessing it.
 class VersionedClause {
 public:
   explicit VersionedClause(const llvm::Record *Def) : Def(Def) {}
void GenerateFlangClauseParserClass(const std::vector<Record *> &Clauses,
 
   OS << "\n";
 
   for (const auto &C : Clauses) {
     Clause Clause{C};
     // Clause has a non generic class.
     if (!Clause.getFlangClass().empty())
       continue;
-    // G
     if (!Clause.getFlangClassValue().empty()) {
-      if (Clause.isValueOptional()) {
-        OS << "WRAPPER_CLASS(" << Clause.getFormattedParserClassName()
-           << ", std::optional<" << Clause.getFlangClassValue() << ">);\n";
+      OS << "WRAPPER_CLASS(" << Clause.getFormattedParserClassName() << ", ";
+      if (Clause.isValueOptional() && Clause.isValueList()) {
+        OS << "std::optional<std::list<" << Clause.getFlangClassValue()
+           << ">>";
+      } else if (Clause.isValueOptional()) {
+        OS << "std::optional<" << Clause.getFlangClassValue() << ">";
+      } else if (Clause.isValueList()) {
+        OS << "std::list<" << Clause.getFlangClassValue() << ">";
       } else {
-        OS << "WRAPPER_CLASS(" << Clause.getFormattedParserClassName() << ", "
-           << Clause.getFlangClassValue() << ");\n";
+        OS << Clause.getFlangClassValue();
       }
     } else {
-      OS << "EMPTY_CLASS(" << Clause.getFormattedParserClassName() << ");\n";
+      OS << "EMPTY_CLASS(" << Clause.getFormattedParserClassName();
     }
+    OS << ");\n";
   }
 }
 
 // Generate a list of the different clause classes for Flang.
 void GenerateFlangClauseParserClassList(const std::vector<Record *> &Clauses,
                                         raw_ostream &OS) {
 
   IfDefScope Scope("GEN_FLANG_CLAUSE_PARSER_CLASSES_LIST", OS);
for (const auto &C : Clauses) {
     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 std::vector<Record *> &Clauses,
+                                const DirectiveLanguage &DirLang,
+                                raw_ostream &OS) {
+
+  IfDefScope Scope("GEN_FLANG_CLAUSE_UNPARSE", OS);
+
+  OS << "\n";
+
+  for (const auto &C : Clauses) {
+    Clause Clause{C};
+    // Clause has a non generic class.
+    if (!Clause.getFlangClass().empty())
+      continue;
+    if (!Clause.getFlangClassValue().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()) {
+        OS << "void Unparse(const " << DirLang.getFlangClauseBaseClass()
+           << "::" << Clause.getFormattedParserClassName() << " &x) {\n";
+        OS << "  Word(\"" << Clause.getName().upper() << "\");\n";
+        OS << "  Put(\"(\");\n";
+        OS << "  if (x.v.has_value())\n";
+        if (Clause.isValueList())
+          OS << "    Walk(x.v, \",\");\n";
+        else
+          OS << "    Walk(x.v);\n";
+        OS << "  else\n";
+        OS << "    Put(\"" << Clause.getDefaultValue() << "\");\n";
+        OS << "  Put(\")\");\n";
+        OS << "}\n";
+      } else {
+        OS << "void Unparse(const " << DirLang.getFlangClauseBaseClass()
+           << "::" << Clause.getFormattedParserClassName() << " &x) {\n";
+        OS << "  Word(\"" << Clause.getName().upper() << "\");\n";
+        OS << "  Put(\"(\");\n";
+        if (Clause.isValueList())
+          OS << "  Walk(x.v, \",\");\n";
+        else
+          OS << "  Walk(x.v);\n";
+        OS << "  Put(\")\");\n";
+        OS << "}\n";
+      }
+    } else {
+      OS << "void Before(const " << DirLang.getFlangClauseBaseClass()
+         << "::" << Clause.getFormattedParserClassName() << " &) { Word(\""
+         << Clause.getName().upper() << "\"); }\n";
+    }
+  }
+}
+
 // Generate the implemenation section for the enumeration in the directive
 // language
 void EmitDirectivesFlangImpl(const std::vector<Record *> &Directives,
                              const std::vector<Record *> &Clauses,
                              raw_ostream &OS,
                              DirectiveLanguage &DirectiveLanguage) {
 
   GenerateDirectiveClauseSets(Directives, OS, DirectiveLanguage);
 
   GenerateDirectiveClauseMap(Directives, OS, DirectiveLanguage);
 
   GenerateFlangClauseParserClass(Clauses, OS);
 
   GenerateFlangClauseParserClassList(Clauses, OS);
 
   GenerateFlangClauseDump(Clauses, DirectiveLanguage, OS);
+
+  GenerateFlangClauseUnparse(Clauses, DirectiveLanguage, OS);
 }
 
 // Generate the implemenation section for the enumeration in the directive
 // language.
 void EmitDirectivesGen(RecordKeeper &Records, raw_ostream &OS) {
 
   const auto &DirectiveLanguages =
       Records.getAllDerivedDefinitions("DirectiveLanguage");