[flang][openacc] Use TableGen to generate the clause parser

[clementval]

Summary

This patch introduce an automatic generation of the clause parser from the TableGen
information.

New information can be stored directly in the TableGen file:

• The different aliases that a clause support.
• prefix before a value.
• whether a prefix is optional or not.

Makes it easier to add new clauses and also avoid some error (write clause incorrect until now).

This patch is updating only the OpenACC part. A patch with a modification of the OpenMP clause parser will follow.

[clementval]

Rebase

[PeteSteinfeld]

All builds and tests correctly and looks good. But I don't understand this code very well. Someone with relevant expertise should approve.

[kiranchandramohan]

LGTM.

I have a Nit and a question.

flang/lib/Parser/openacc-parsers.cpp

25–27

Nit: Can you expand the comment to briefly describe what is the kind of clauses for which parsers can be autogenerated? Or alternatively, what kind of clause parsers are not autogenerated?

llvm/utils/TableGen/DirectiveEmitter.cpp

774

I see that this is autogenerating clause parsers for OpenMP as well. Will you be creating a patch for enabling it or would you like one of us to do it?

[kiranchandramohan]

llvm/utils/TableGen/DirectiveEmitter.cpp

774

I see that you have covered this in the summary. Thanks.

[clementval]

llvm/utils/TableGen/DirectiveEmitter.cpp

774

I'm not sure when I can work on that but it's on my todo list.

flang/lib/Parser/openacc-parsers.cpp

 #include "flang/Parser/parse-tree.h"
 
 // OpenACC Directives and Clauses
 namespace Fortran::parser {
 
 constexpr auto startAccLine = skipStuffBeforeStatement >> "!$ACC "_sptok;
 constexpr auto endAccLine = space >> endOfLine;
 
-// Basic clauses
-TYPE_PARSER("AUTO" >> construct<AccClause>(construct<AccClause::Auto>()) ||
-    "ASYNC" >> construct<AccClause>(construct<AccClause::Async>(
-                   maybe(parenthesized(scalarIntExpr)))) ||
-    "ATTACH" >> construct<AccClause>(construct<AccClause::Attach>(
-                    parenthesized(Parser<AccObjectList>{}))) ||
-    "BIND" >> construct<AccClause>(
-                  construct<AccClause::Bind>(Parser<AccBindClause>{})) ||
-    "CAPTURE" >> construct<AccClause>(construct<AccClause::Capture>()) ||
-    "COLLAPSE" >> construct<AccClause>(construct<AccClause::Collapse>(
-                      parenthesized(scalarIntConstantExpr))) ||
-    ("COPY"_tok || "PRESENT_OR_COPY"_tok || "PCOPY"_tok) >>
-        construct<AccClause>(construct<AccClause::Copy>(
-            parenthesized(Parser<AccObjectList>{}))) ||
-    ("COPYIN"_tok || "PRESENT_OR_COPYIN"_tok || "PCOPYIN"_tok) >>
-        construct<AccClause>(construct<AccClause::Copyin>(
-            parenthesized(Parser<AccObjectListWithModifier>{}))) ||
-    ("COPYOUT"_tok || "PRESENT_OR_COPYOUT"_tok || "PCOPYOUT"_tok) >>
-        construct<AccClause>(construct<AccClause::Copyout>(
-            parenthesized(Parser<AccObjectListWithModifier>{}))) ||
-    ("CREATE"_tok || "PRESENT_OR_CREATE"_tok || "PCREATE"_tok) >>
-        construct<AccClause>(construct<AccClause::Create>(
-            parenthesized(Parser<AccObjectListWithModifier>{}))) ||
-    "DEFAULT" >> construct<AccClause>(construct<AccClause::Default>(
-                     Parser<AccDefaultClause>{})) ||
-    "DEFAULT_ASYNC" >> construct<AccClause>(construct<AccClause::DefaultAsync>(
-                           parenthesized(scalarIntExpr))) ||
-    "DELETE" >> construct<AccClause>(construct<AccClause::Delete>(
-                    parenthesized(Parser<AccObjectList>{}))) ||
-    "DETACH" >> construct<AccClause>(construct<AccClause::Detach>(
-                    parenthesized(Parser<AccObjectList>{}))) ||
-    "DEVICE" >> construct<AccClause>(construct<AccClause::Device>(
-                    parenthesized(Parser<AccObjectList>{}))) ||
-    "DEVICEPTR" >> construct<AccClause>(construct<AccClause::Deviceptr>(
-                       parenthesized(Parser<AccObjectList>{}))) ||
-    "DEVICE_NUM" >> construct<AccClause>(construct<AccClause::DeviceNum>(
-                        parenthesized(scalarIntExpr))) ||
-    "DEVICE_RESIDENT" >>
-        construct<AccClause>(construct<AccClause::DeviceResident>(
-            parenthesized(Parser<AccObjectList>{}))) ||
-    ("DEVICE_TYPE"_tok || "DTYPE"_tok) >>
-        construct<AccClause>(construct<AccClause::DeviceType>(parenthesized(
-            Parser<AccDeviceTypeExprList>{}))) ||
-    "FINALIZE" >> construct<AccClause>(construct<AccClause::Finalize>()) ||
-    "FIRSTPRIVATE" >> construct<AccClause>(construct<AccClause::Firstprivate>(
-                          parenthesized(Parser<AccObjectList>{}))) ||
-    "GANG" >> construct<AccClause>(construct<AccClause::Gang>(
-                  maybe(parenthesized(Parser<AccGangArgument>{})))) ||
-    "HOST" >> construct<AccClause>(construct<AccClause::Host>(
-                  parenthesized(Parser<AccObjectList>{}))) ||
-    "IF" >> construct<AccClause>(
-                construct<AccClause::If>(parenthesized(scalarLogicalExpr))) ||
-    "IF_PRESENT" >> construct<AccClause>(construct<AccClause::IfPresent>()) ||
-    "INDEPENDENT" >>
-        construct<AccClause>(construct<AccClause::Independent>()) ||
-    "LINK" >> construct<AccClause>(construct<AccClause::Link>(
-                  parenthesized(Parser<AccObjectList>{}))) ||
-    "NO_CREATE" >> construct<AccClause>(construct<AccClause::NoCreate>(
-                       parenthesized(Parser<AccObjectList>{}))) ||
-    "NOHOST" >> construct<AccClause>(construct<AccClause::Nohost>()) ||
-    "NUM_GANGS" >> construct<AccClause>(construct<AccClause::NumGangs>(
-                       parenthesized(scalarIntExpr))) ||
-    "NUM_WORKERS" >> construct<AccClause>(construct<AccClause::NumWorkers>(
-                         parenthesized(scalarIntExpr))) ||
-    "PRESENT" >> construct<AccClause>(construct<AccClause::Present>(
-                     parenthesized(Parser<AccObjectList>{}))) ||
-    "PRIVATE" >> construct<AccClause>(construct<AccClause::Private>(
-                     parenthesized(Parser<AccObjectList>{}))) ||
-    "READ" >> construct<AccClause>(construct<AccClause::Read>()) ||
-    "REDUCTION" >> construct<AccClause>(construct<AccClause::Reduction>(
-                       parenthesized(construct<AccObjectListWithReduction>(
-                           Parser<AccReductionOperator>{} / ":",
-                           Parser<AccObjectList>{})))) ||
-    "SELF" >> construct<AccClause>(
-                  construct<AccClause::Self>(maybe(parenthesized(Parser<AccSelfClause>{})))) ||
-    "SEQ" >> construct<AccClause>(construct<AccClause::Seq>()) ||
-    "TILE" >> construct<AccClause>(construct<AccClause::Tile>(
-                  parenthesized(Parser<AccTileExprList>{}))) ||
-    "USE_DEVICE" >> construct<AccClause>(construct<AccClause::UseDevice>(
-                        parenthesized(Parser<AccObjectList>{}))) ||
-    "VECTOR_LENGTH" >> construct<AccClause>(construct<AccClause::VectorLength>(
-                           parenthesized(scalarIntExpr))) ||
-    "VECTOR" >>
-        construct<AccClause>(construct<AccClause::Vector>(maybe(
-            parenthesized(("LENGTH:" >> scalarIntExpr || scalarIntExpr))))) ||
-    "WAIT" >> construct<AccClause>(construct<AccClause::Wait>(
-                  maybe(parenthesized(Parser<AccWaitArgument>{})))) ||
-    "WORKER" >>
-        construct<AccClause>(construct<AccClause::Worker>(maybe(
-            parenthesized(("NUM:" >> scalarIntExpr || scalarIntExpr))))) ||
-    "WRITE" >> construct<AccClause>(construct<AccClause::Auto>()))
+// Basic clause parser
+#define GEN_FLANG_CLAUSES_PARSER
+#include "llvm/Frontend/OpenACC/ACC.inc"
 
 TYPE_PARSER(
     construct<AccObject>(designator) || construct<AccObject>("/" >> name / "/"))
 
 TYPE_PARSER(construct<AccObjectList>(nonemptyList(Parser<AccObject>{})))
 
 TYPE_PARSER(construct<AccObjectListWithModifier>(
     maybe(Parser<AccDataModifier>{}), Parser<AccObjectList>{}))
 
+TYPE_PARSER(construct<AccObjectListWithReduction>(
+    Parser<AccReductionOperator>{} / ":", Parser<AccObjectList>{}))
+
 // 2.16.3 (2485) wait-argument is:
 //   [devnum : int-expr :] [queues :] int-expr-list
 TYPE_PARSER(construct<AccWaitArgument>(maybe("DEVNUM:" >> scalarIntExpr / ":"),
     "QUEUES:" >> nonemptyList(scalarIntExpr) || nonemptyList(scalarIntExpr)))
 
 // 2.9 (1609) size-expr is one of:
 //   * (represented as an empty std::optional<ScalarIntExpr>)
 //   int-expr
first("+" >> pure(AccReductionOperator::Operator::Plus),
         "IOR" >> pure(AccReductionOperator::Operator::Ior),
         "IEOR" >> pure(AccReductionOperator::Operator::Ieor),
         ".AND." >> pure(AccReductionOperator::Operator::And),
         ".OR." >> pure(AccReductionOperator::Operator::Or),
         ".EQV." >> pure(AccReductionOperator::Operator::Eqv),
         ".NEQV." >> pure(AccReductionOperator::Operator::Neqv)))))
 
 // 2.15.1 Bind clause
-TYPE_PARSER(sourced(construct<AccBindClause>(parenthesized(name))) ||
-    sourced(construct<AccBindClause>(parenthesized(scalarDefaultCharExpr))))
+TYPE_PARSER(sourced(construct<AccBindClause>(name)) ||
+    sourced(construct<AccBindClause>(scalarDefaultCharExpr)))
 
 // 2.5.14 Default clause
-TYPE_PARSER(construct<AccDefaultClause>(parenthesized(
+TYPE_PARSER(construct<AccDefaultClause>(
     first("NONE" >> pure(llvm::acc::DefaultValue::ACC_Default_none),
-        "PRESENT" >> pure(llvm::acc::DefaultValue::ACC_Default_present)))))
+        "PRESENT" >> pure(llvm::acc::DefaultValue::ACC_Default_present))))
 
 // SELF clause is either a simple optional condition for compute construct
 // or a synonym of the HOST clause for the update directive 2.14.4 holding
 // an object list.
 TYPE_PARSER(construct<AccSelfClause>(Parser<AccObjectList>{}) ||
     construct<AccSelfClause>(scalarLogicalExpr))
 
 // Modifier for copyin, copyout, cache and create

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

 // Information about a specific clause.
 class Clause<string c> {
   // Name of the clause.
   string name = c;
 
   // Define an alternative name return in get<LanguageName>ClauseName function.
   string alternativeName = "";
 
+  // Define aliases used in the parser.
+  list<string> aliases = [];
+
   // Optional class holding value of the clause in clang AST.
   string clangClass = "";
 
   // Optional class holding value of the clause in flang AST.
   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
   list<ClauseVal> allowedClauseValues = [];
+
   // If set to true, value class is part of a list. Single class by default.
   bit isValueList = false;
 
   // 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 = false;
 
   // Set clause used by default when unknown. Function returning the kind
   // of enumeration will use this clause as the default.
   bit isDefault = false;
+
+  // Prefix before the actual value. Used in the parser generation.
+  // `clause(prefix: value)`
+  string prefix = "";
+
+  // Set the prefix as optional.
+  // `clause([prefix]: value)`
+  bit isPrefixOptional = true;
 }
 
 // Hold information about clause validity by version.
 class VersionedClause<Clause c, int min = 1, int max = 0x7FFFFFFF> {
   // Actual clause.
   Clause clause = c;
 
   // Mininum version number where this clause is valid.

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

 // 2.9.1
 def ACCC_Collapse : Clause<"collapse"> {
   let flangClass = "ScalarIntConstantExpr";
 }
 
 // 2.7.6
 def ACCC_Copy : Clause<"copy"> {
   let flangClass = "AccObjectList";
+  let aliases = ["present_or_copy", "pcopy"];
 }
 // 2.7.7
 def ACCC_Copyin : Clause<"copyin"> {
   let flangClass = "AccObjectListWithModifier";
+  let aliases = ["present_or_copyin", "pcopyin"];
 }
 
 // 2.7.8
 def ACCC_Copyout : Clause<"copyout"> {
   let flangClass = "AccObjectListWithModifier";
+  let aliases = ["present_or_copyout", "pcopyout"];
 }
 
 // 2.7.9
 def ACCC_Create : Clause<"create"> {
   let flangClass = "AccObjectListWithModifier";
+  let aliases = ["present_or_create", "pcreate"];
 }
 
 // 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 flangClass = "AccDefaultClause";

 def ACCC_DeviceResident : Clause<"device_resident"> {
   let flangClass = "AccObjectList";
 }
 
 // 2.4
 def ACCC_DeviceType : Clause<"device_type"> {
   let flangClass = "AccDeviceTypeExprList";
   let defaultValue = "*";
+  let aliases = ["dtype"];
 }
 
 // 2.6.6
 def ACCC_Finalize : Clause<"finalize"> {}
 
 // 2.5.13
 def ACCC_FirstPrivate : Clause<"firstprivate"> {
   let flangClass = "AccObjectList";

 
 // 2.9.5
 def ACCC_Seq : Clause<"seq"> {}
 
 // 2.9.4
 def ACCC_Vector : Clause<"vector"> {
   let flangClass = "ScalarIntExpr";
   let isValueOptional = true;
+  let prefix = "length";
 }
 
 // 2.5.11
 def ACCC_VectorLength : Clause<"vector_length"> {
   let flangClass = "ScalarIntExpr";
 }
 
 // 2.16.2
 def ACCC_Wait : Clause<"wait"> {
   let flangClass = "AccWaitArgument";
   let isValueOptional = true;
 }
 
 // 2.9.3
 def ACCC_Worker: Clause<"worker"> {
   let flangClass = "ScalarIntExpr";
   let isValueOptional = true;
+  let prefix = "num";
 }
 
 // 2.12
 def ACCC_Write : Clause<"write"> {}
 
 def ACCC_Unknown : Clause<"unknown"> {
   let isDefault = true;
 }

llvm/include/llvm/TableGen/DirectiveEmitter.h

public:
 
   bool isValueList() const { return Def->getValueAsBit("isValueList"); }
 
   StringRef getDefaultValue() const {
     return Def->getValueAsString("defaultValue");
   }
 
   bool isImplicit() const { return Def->getValueAsBit("isImplicit"); }
+
+  std::vector<StringRef> getAliases() const {
+    return Def->getValueAsListOfStrings("aliases");
+  }
+
+  StringRef getPrefix() const { return Def->getValueAsString("prefix"); }
+
+  bool isPrefixOptional() const {
+    return Def->getValueAsBit("isPrefixOptional");
+  }
 };
 
 // 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) {}
 

llvm/test/TableGen/directive1.td

 // IMPL-NEXT:  if constexpr (std::is_same_v<A, parser::TdlClause::Clausea>)
 // IMPL-NEXT:    return llvm::tdl::Clause::TDLC_clausea;
 // IMPL-NEXT:  if constexpr (std::is_same_v<A, parser::TdlClause::Clauseb>)
 // IMPL-NEXT:    return llvm::tdl::Clause::TDLC_clauseb;
 // IMPL-NEXT:  llvm_unreachable("Invalid Tdl Parser clause");
 // IMPL-EMPTY:
 // IMPL-NEXT:  #endif // GEN_FLANG_CLAUSE_PARSER_KIND_MAP
 // IMPL-EMPTY:
+// IMPL-NEXT: #ifdef GEN_FLANG_CLAUSES_PARSER
+// IMPL-NEXT: #undef GEN_FLANG_CLAUSES_PARSER
+// IMPL-EMPTY:
+// IMPL-NEXT:  TYPE_PARSER(
+// IMPL-NEXT:    "clauseb" >> construct<TdlClause>(construct<TdlClause::Clauseb>(maybe(parenthesized(Parser<IntExpr>{})))) ||
+// IMPL-NEXT:    "clausea" >> construct<TdlClause>(construct<TdlClause::Clausea>())
+// IMPL-NEXT:  )
+// IMPL-EMPTY:
+// IMPL-NEXT:  #endif // GEN_FLANG_CLAUSES_PARSER
+// IMPL-EMPTY:
 // IMPL-NEXT:  #ifdef GEN_CLANG_CLAUSE_CLASS
 // IMPL-NEXT:  #undef GEN_CLANG_CLAUSE_CLASS
 // IMPL-EMPTY:
 // IMPL-NEXT:  #ifndef CLAUSE
 // IMPL-NEXT:  #define CLAUSE(Enum, Str, Implicit)
 // IMPL-NEXT:  #endif
 // IMPL-NEXT:  #ifndef CLAUSE_CLASS
 // IMPL-NEXT:  #define CLAUSE_CLASS(Enum, Str, Class)

llvm/utils/TableGen/DirectiveEmitter.cpp

 // common code declarations to be used in Frontends.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/TableGen/DirectiveEmitter.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringSet.h"
+#include "llvm/ADT/StringSwitch.h"
 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Record.h"
 #include "llvm/TableGen/TableGenBackend.h"
 
 using namespace llvm;
 
 namespace {
 // Simple RAII helper for defining ifdef-undef-endif scopes.
OS << "  return llvm::" << DirLang.getCppNamespace()
        << "::Clause::" << DirLang.getClausePrefix() << Clause.getFormattedName()
        << ";\n";
   }
 
   OS << "llvm_unreachable(\"Invalid " << DirLang.getName()
      << " Parser clause\");\n";
 }
 
+bool compareClauseName(Record *R1, Record *R2) {
+  Clause C1{R1};
+  Clause C2{R2};
+  return (C1.getName() > C2.getName());
+}
+
+// Generate the parser for the clauses.
+void GenerateFlangClausesParser(const DirectiveLanguage &DirLang,
+                                raw_ostream &OS) {
+  std::vector<Record *> Clauses = DirLang.getClauses();
+  // Sort clauses in reverse alphabetical order so with clauses with same
+  // beginning, the longer option is tried before.
+  std::sort(Clauses.begin(), Clauses.end(), compareClauseName);
+  IfDefScope Scope("GEN_FLANG_CLAUSES_PARSER", OS);
+  OS << "\n";
+  unsigned index = 0;
+  unsigned lastClauseIndex = DirLang.getClauses().size() - 1;
+  OS << "TYPE_PARSER(\n";
+  for (const auto &C : Clauses) {
+    Clause Clause{C};
+    if (Clause.getAliases().empty()) {
+      OS << "  \"" << Clause.getName() << "\"";
+    } else {
+      OS << "  ("
+         << "\"" << Clause.getName() << "\"_tok";
+      for (StringRef alias : Clause.getAliases()) {
+        OS << " || \"" << alias << "\"_tok";
+      }
+      OS << ")";
+    }
+
+    OS << " >> construct<" << DirLang.getFlangClauseBaseClass()
+       << ">(construct<" << DirLang.getFlangClauseBaseClass()
+       << "::" << Clause.getFormattedParserClassName() << ">(";
+    if (Clause.getFlangClass().empty()) {
+      OS << "))";
+      if (index != lastClauseIndex)
+        OS << " ||";
+      OS << "\n";
+      ++index;
+      continue;
+    }
+
+    if (Clause.isValueOptional())
+      OS << "maybe(";
+    OS << "parenthesized(";
+
+    if (!Clause.getPrefix().empty())
+      OS << "\"" << Clause.getPrefix() << ":\" >> ";
+
+    // The common Flang parser are used directly. Their name is identical to
+    // the Flang class with first letter as lowercase. If the Flang class is
+    // not a common class, we assume there is a specific Parser<>{} with the
+    // Flang class name provided.
+    llvm::SmallString<128> Scratch;
+    StringRef Parser =
+        llvm::StringSwitch<StringRef>(Clause.getFlangClass())
+            .Case("Name", "name")
+            .Case("ScalarIntConstantExpr", "scalarIntConstantExpr")
+            .Case("ScalarIntExpr", "scalarIntExpr")
+            .Case("ScalarLogicalExpr", "scalarLogicalExpr")
+            .Default(("Parser<" + Clause.getFlangClass() + ">{}")
+                         .toStringRef(Scratch));
+    OS << Parser;
+    if (!Clause.getPrefix().empty() && Clause.isPrefixOptional())
+      OS << " || " << Parser;
+    OS << ")"; // close parenthesized(.
+
+    if (Clause.isValueOptional()) // close maybe(.
+      OS << ")";
+    OS << "))";
+    if (index != lastClauseIndex)
+      OS << " ||";
+    OS << "\n";
+    ++index;
+  }
+  OS << ")\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);
+
+  GenerateFlangClausesParser(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";