[openacc] Use TableGen enum for default clause value

[clementval]

Summary

Use the TableGen feature to have enum values for clauses.
Next step will be to extend the MLIR part used currently by OpenMP
to use the same enum on the dialect side.

This patch also add function that convert the enum to StringRef to be
used on the dump-parse-tree from flang.

[jdoerfert]

Typo in the commit message, otherwise LGTM.

[sameeranjoshi]

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

84

Trying to understand -
class ClauseVal<string n, int v, bit uv> mentions second parameter (i.e v)as value of clause.

Is there are reason to start the numbering from 0?
In OMP.td as well I see they always start with index 2, any defined pattern used here?

[clementval]

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

84

The enum in OMP.td starts at 2 to follow the one already defined for Clang here: llvm/include/llvm/Frontend/OpenMP/OMPKinds.def In the long term the OMPKinds.def file is supposed to go away gradually.

This is my guess but @kiranchandramohan can confirm since he introduced those change for OpenMP.

[kiranchandramohan]

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

84

What @clementval says and also The standard sometimes defines values for the clauses which are constants. For e.g. for proc_bind.
integer (kind=omp_proc_bind_kind), parameter :: omp_proc_bind_false = 0
integer (kind=omp_proc_bind_kind), parameter :: omp_proc_bind_true = 1
integer (kind=omp_proc_bind_kind), parameter :: omp_proc_bind_master = 2
integer (kind=omp_proc_bind_kind), parameter :: omp_proc_bind_close = 3
integer (kind=omp_proc_bind_kind), parameter :: omp_proc_bind_spread = 4

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

#define NODE(T1, T2) NODE_NAME(T1::T2, #T2)
   NODE(parser, AccBeginCombinedDirective)
   NODE(parser, AccBeginLoopDirective)
   NODE(parser, AccBlockDirective)
   NODE(parser, AccClause)
 #define GEN_FLANG_DUMP_PARSE_TREE_CLAUSES
 #include "llvm/Frontend/OpenACC/ACC.cpp.inc"
   NODE(parser, AccBindClause)
   NODE(parser, AccDefaultClause)
-  NODE_ENUM(parser::AccDefaultClause, Arg)
+  static std::string GetNodeName(const llvm::acc::DefaultValue &x) {
+    return llvm::Twine(
+        "llvm::acc::DefaultValue = ", llvm::acc::getOpenACCDefaultValueName(x))
+        .str();
+  }
   NODE(parser, AccClauseList)
   NODE(parser, AccCombinedDirective)
   NODE(parser, AccDataModifier)
   NODE_ENUM(parser::AccDataModifier, Modifier)
   NODE(parser, AccDeclarativeDirective)
   NODE(parser, AccEndAtomic)
   NODE(parser, AccEndBlockDirective)
   NODE(parser, AccEndCombinedDirective)

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

 // OpenACC Clauses
 struct AccBindClause {
   UNION_CLASS_BOILERPLATE(AccBindClause);
   std::variant<Name, ScalarDefaultCharExpr> u;
   CharBlock source;
 };
 
 struct AccDefaultClause {
-  ENUM_CLASS(Arg, None, Present)
-  WRAPPER_CLASS_BOILERPLATE(AccDefaultClause, Arg);
+  WRAPPER_CLASS_BOILERPLATE(AccDefaultClause, llvm::acc::DefaultValue);
   CharBlock source;
 };
 
 struct AccDataModifier {
   ENUM_CLASS(Modifier, ReadOnly, Zero)
   WRAPPER_CLASS_BOILERPLATE(AccDataModifier, Modifier);
   CharBlock source;
 };

flang/lib/Parser/openacc-parsers.cpp

first("+" >> pure(AccReductionOperator::Operator::Plus),
         ".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))))
 
 // 2.5.14 Default clause
-TYPE_PARSER(construct<AccDefaultClause>(
-    parenthesized(first("NONE" >> pure(AccDefaultClause::Arg::None),
-        "PRESENT" >> pure(AccDefaultClause::Arg::Present)))))
+TYPE_PARSER(construct<AccDefaultClause>(parenthesized(
+    first("NONE" >> pure(llvm::acc::DefaultValue::ACC_Default_none),
+        "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>(parenthesized(Parser<AccObjectList>{})) ||
     construct<AccSelfClause>(maybe(parenthesized(scalarLogicalExpr))))
 
 // Modifier for copyin, copyout, cache and create

flang/lib/Parser/unparse.cpp

std::visit(common::visitors{
                    [&](const ScalarDefaultCharExpr &y) {
                      Put('('), Walk(y), Put(')');
                    },
                },
         x.u);
   }
   void Unparse(const AccDefaultClause &x) {
     switch (x.v) {
-    case AccDefaultClause::Arg::None:
+    case llvm::acc::DefaultValue::ACC_Default_none:
       Put("NONE");
       break;
-    case AccDefaultClause::Arg::Present:
+    case llvm::acc::DefaultValue::ACC_Default_present:
       Put("PRESENT");
       break;
     }
   }
   void Unparse(const AccClauseList &x) { Walk(" ", x.v, " "); }
   void Unparse(const AccGangArgument &x) {
     Walk("NUM:", std::get<std::optional<ScalarIntExpr>>(x.t));
     Walk(", STATIC:", std::get<std::optional<AccSizeExpr>>(x.t));

flang/lib/Semantics/resolve-directives.cpp

for (const parser::DoConstruct *loop{&*outer}; loop && level > 0; --level) {
     loop = it != block.end() ? GetDoConstructIf(*it) : nullptr;
   }
   CHECK(level == 0);
 }
 
 void AccAttributeVisitor::Post(const parser::AccDefaultClause &x) {
   if (!dirContext_.empty()) {
     switch (x.v) {
-    case parser::AccDefaultClause::Arg::Present:
+    case llvm::acc::DefaultValue::ACC_Default_present:
       SetContextDefaultDSA(Symbol::Flag::AccPresent);
       break;
-    case parser::AccDefaultClause::Arg::None:
+    case llvm::acc::DefaultValue::ACC_Default_none:
       SetContextDefaultDSA(Symbol::Flag::AccNone);
       break;
     }
   }
 }
 
 // For OpenACC constructs, check all the data-refs within the constructs
 // and adjust the symbol for each Name if necessary

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

 }
 
 // 2.7.9
 def ACCC_Create : Clause<"create"> {
   let flangClassValue = "AccObjectListWithModifier";
 }
 
 // 2.5.15
+def ACC_Default_none : ClauseVal<"none", 1, 0> { let isDefault = 1; }
+def ACC_Default_present : ClauseVal<"present", 0, 0> {}
+
 def ACCC_Default : Clause<"default"> {
   let flangClassValue = "AccDefaultClause";
+  let enumClauseValue = "DefaultValue";
+  let allowedClauseValues = [
+    ACC_Default_present,
+    ACC_Default_none
+  ];
 }
 
 // 2.14.3
 def ACCC_DefaultAsync : Clause<"default_async"> {
   let flangClassValue = "ScalarIntExpr";
 }
 
 // 2.7.11

llvm/test/TableGen/directive1.td

 // CHECK-NEXT:  Clause getTdlClauseKind(llvm::StringRef Str);
 // CHECK-EMPTY:
 // CHECK-NEXT:  llvm::StringRef getTdlClauseName(Clause C);
 // CHECK-EMPTY:
 // CHECK-NEXT:  /// Return true if \p C is a valid clause for \p D in version \p Version.
 // CHECK-NEXT:  bool isAllowedClauseForDirective(Directive D, Clause C, unsigned Version);
 // CHECK-EMPTY:
 // CHECK-NEXT:  AKind getAKind(StringRef);
+// CHECK-NEXT:  llvm::StringRef getTdlAKindName(AKind);
 // CHECK-EMPTY:
 // CHECK-NEXT:  } // namespace tdl
 // CHECK-NEXT:  } // namespace llvm
 // CHECK-NEXT:  #endif // LLVM_Tdl_INC
 
 
 // IMPL:       #include "llvm/ADT/StringRef.h"
 // IMPL-NEXT:  #include "llvm/ADT/StringSwitch.h"

 // IMPL-NEXT:  AKind llvm::tdl::getAKind(llvm::StringRef Str) {
 // IMPL-NEXT:    return llvm::StringSwitch<AKind>(Str)
 // IMPL-NEXT:      .Case("vala",TDLCV_vala)
 // IMPL-NEXT:      .Case("valb",TDLCV_valb)
 // IMPL-NEXT:      .Case("valc",TDLCV_valc)
 // IMPL-NEXT:      .Default(TDLCV_valc);
 // IMPL-NEXT:  }
 // IMPL-EMPTY:
+// IMPL-NEXT:  llvm::StringRef llvm::tdl::getTdlAKindName(llvm::tdl::AKind x) {
+// IMPL-NEXT:    switch (x) {
+// IMPL-NEXT:      case TDLCV_vala:
+// IMPL-NEXT:        return "vala";
+// IMPL-NEXT:      case TDLCV_valb:
+// IMPL-NEXT:        return "valb";
+// IMPL-NEXT:      case TDLCV_valc:
+// IMPL-NEXT:        return "valc";
+// IMPL-NEXT:    }
+// IMPL-NEXT:    llvm_unreachable("Invalid Tdl AKind 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) {
 // IMPL-NEXT:      case TDLD_dira:
 // IMPL-NEXT:        switch (C) {
 // IMPL-NEXT:          case TDLC_clausea:
 // IMPL-NEXT:            return 1 <= Version && 2147483647 >= Version;

llvm/utils/TableGen/DirectiveEmitter.cpp

if (DirLang.hasMakeEnumAvailableInNamespace()) {
       for (const auto &CV : ClauseVals) {
         OS << "constexpr auto " << CV->getName() << " = "
            << "llvm::" << DirLang.getCppNamespace() << "::" << EnumName
            << "::" << CV->getName() << ";\n";
       }
       EnumHelperFuncs += (llvm::Twine(EnumName) + llvm::Twine(" get") +
                           llvm::Twine(EnumName) + llvm::Twine("(StringRef);\n"))
                              .str();
+
+      EnumHelperFuncs +=
+          (llvm::Twine("llvm::StringRef get") + llvm::Twine(DirLang.getName()) +
+           llvm::Twine(EnumName) + llvm::Twine("Name(") +
+           llvm::Twine(EnumName) + llvm::Twine(");\n"))
+              .str();
     }
   }
 }
 
 bool HasDuplicateClauses(const std::vector<Record *> &Clauses,
                          const Directive &Directive,
                          llvm::StringSet<> &CrtClauses) {
   bool HasError = false;
for (const auto &R : DirLang.getClauses()) {
     OS << "  return llvm::StringSwitch<" << EnumName << ">(Str)\n";
     for (const auto &CV : ClauseVals) {
       ClauseVal CVal{CV};
       OS << "    .Case(\"" << CVal.getFormattedName() << "\"," << CV->getName()
          << ")\n";
     }
     OS << "    .Default(" << DefaultName << ");\n";
     OS << "}\n";
+
+    OS << "\n";
+    OS << "llvm::StringRef llvm::" << DirLang.getCppNamespace() << "::get"
+       << DirLang.getName() << EnumName
+       << "Name(llvm::" << DirLang.getCppNamespace() << "::" << EnumName
+       << " x) {\n";
+    OS << "  switch (x) {\n";
+    for (const auto &CV : ClauseVals) {
+      ClauseVal CVal{CV};
+      OS << "    case " << CV->getName() << ":\n";
+      OS << "      return \"" << CVal.getFormattedName() << "\";\n";
+    }
+    OS << "  }\n"; // switch
+    OS << "  llvm_unreachable(\"Invalid " << DirLang.getName() << " "
+       << EnumName << " kind\");\n";
+    OS << "}\n";
   }
 }
 
 void GenerateCaseForVersionedClauses(const std::vector<Record *> &Clauses,
                                      raw_ostream &OS, StringRef DirectiveName,
                                      const DirectiveLanguage &DirLang,
                                      llvm::StringSet<> &Cases) {
   for (const auto &C : Clauses) {