[openmp] Move Directive and Clause helper function to tablegen

[clementval]

Summary

Follow up to D81736. Move getOpenMPDirectiveKind, getOpenMPClauseKind, getOpenMPDirectiveName and
getOpenMPClauseName to the new tablegen code generation. The code is generated in a new file named OMP.cpp.inc

[clementval]

Fix tiny formatting problem in DirectiveBase.td

[clementval]

Add alternative name and enforce implcit clause

[clementval]

Address some clang-tidy warnings

[clementval]

Fxi comment in DirectiveBase.td

[jdoerfert]

So the idea is we generate a single .inc file with multiple ifdef regions to choose from? Is that what is usually done? I would have thought multiple files are nicer but no strong feeling.

[clementval]

In D82405#2112272, @jdoerfert wrote:

So the idea is we generate a single .inc file with multiple ifdef regions to choose from? Is that what is usually done? I would have thought multiple files are nicer but no strong feeling.

I have no strong opinion on this as well. MLIR is generating two files for their dialects (1 `.h.inc and `.cpp.inc) but use the sections as well. We will probably need the sections as well even if we do two or more files.

[jdoerfert]

In D82405#2112451, @clementval wrote:

In D82405#2112272, @jdoerfert wrote:

So the idea is we generate a single .inc file with multiple ifdef regions to choose from? Is that what is usually done? I would have thought multiple files are nicer but no strong feeling.

I have no strong opinion on this as well. MLIR is generating two files for their dialects (1 `.h.inc and `.cpp.inc) but use the sections as well. We will probably need the sections as well even if we do two or more files.

Why do we need sections if we generate multiple files?

[clementval]

In D82405#2112482, @jdoerfert wrote:

In D82405#2112451, @clementval wrote:

In D82405#2112272, @jdoerfert wrote:

So the idea is we generate a single .inc file with multiple ifdef regions to choose from? Is that what is usually done? I would have thought multiple files are nicer but no strong feeling.

I have no strong opinion on this as well. MLIR is generating two files for their dialects (1 `.h.inc and `.cpp.inc) but use the sections as well. We will probably need the sections as well even if we do two or more files.

Why do we need sections if we generate multiple files?

So far if we have a .h.inc and a .cpp.inc there is no need for sections for the common parts related to enumerations but I can imagine that some part in clang or Flang which currently use OMPKinds.def need replacement code that are quite specific and might reside in a section. Does it make sense?

[jdenny]

In D82405#2112522, @clementval wrote:

In D82405#2112482, @jdoerfert wrote:

In D82405#2112451, @clementval wrote:

In D82405#2112272, @jdoerfert wrote:

So the idea is we generate a single .inc file with multiple ifdef regions to choose from? Is that what is usually done? I would have thought multiple files are nicer but no strong feeling.

I have no strong opinion on this as well. MLIR is generating two files for their dialects (1 `.h.inc and `.cpp.inc) but use the sections as well. We will probably need the sections as well even if we do two or more files.

Why do we need sections if we generate multiple files?

So far if we have a .h.inc and a .cpp.inc there is no need for sections for the common parts related to enumerations but I can imagine that some part in clang or Flang which currently use OMPKinds.def need replacement code that are quite specific and might reside in a section. Does it make sense?

That would be for tweaking parts of the content not for selecting entirely different content, right?

It seems unintuitive to me to force two completely different files into one file in this manner, but I have no strong opinion either. If that's the norm, then fine by me.

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

49

Could this comment clarify briefly how the alternative name might be used? Likewise for the one in Directive.

Also, minor nit: the comments in this file are not consistent about punctuation. My read of the style standard is that punctuation is preferred.

55–56

The effect of isImplicit and isDefault on get*ClauseKind is subtle. Can this be documented here?

llvm/test/TableGen/directive1.td

28

Is this CHECK instead of CHECK-NEXT because there are other lines before that shouldn't be checked? If, instead, this just handles empty lines, CHECK-EMPTY can do that but won't let additional non-empty lines slip in later.

Likewise for other cases below.

33

directive -> clause

44

Please consider using indentation within FileCheck directives like this one so that the embedded C++ here is more readable.

Also maybe consider using FileCheck -strict-whitespace -match-full-lines to be sure unintentional text or formatting doesn't slip in later. I'll admit, most tests don't do this so that they're less brittle, but I feel like that's not likely an issue here.

Of course, some of that might need to go in a later review so this review remains easy to read.

llvm/utils/TableGen/DirectiveEmitter.cpp

332

Please use the style /*ParamName=*/constant for arguments like false.

[clementval]

Address @jdenny comments

[clementval]

In D82405#2117219, @jdenny wrote:

In D82405#2112522, @clementval wrote:

In D82405#2112482, @jdoerfert wrote:

In D82405#2112451, @clementval wrote:

In D82405#2112272, @jdoerfert wrote:

So the idea is we generate a single .inc file with multiple ifdef regions to choose from? Is that what is usually done? I would have thought multiple files are nicer but no strong feeling.

I have no strong opinion on this as well. MLIR is generating two files for their dialects (1 `.h.inc and `.cpp.inc) but use the sections as well. We will probably need the sections as well even if we do two or more files.

Why do we need sections if we generate multiple files?

So far if we have a .h.inc and a .cpp.inc there is no need for sections for the common parts related to enumerations but I can imagine that some part in clang or Flang which currently use OMPKinds.def need replacement code that are quite specific and might reside in a section. Does it make sense?

That would be for tweaking parts of the content not for selecting entirely different content, right?

That's used for selecting different part. It is done like this both in pure TableGen and miler-tablegen uses.

It seems unintuitive to me to force two completely different files into one file in this manner, but I have no strong opinion either. If that's the norm, then fine by me.

As I said, I have no strong opinion but we could at least keep a .h.inc file clean if we choose a two files approache.

[jdenny]

It would still be nice to see the normal C++ indentation in the generated file and in the test suite. As I said, that could go in a separate patch.

Otherwise, this LGTM. Please give others a few more days to review, especially given the discussion about splitting the .inc file.

[clementval]

In D82405#2117918, @jdenny wrote:

It would still be nice to see the normal C++ indentation in the generated file and in the test suite. As I said, that could go in a separate patch.

Otherwise, this LGTM. Please give others a few more days to review, especially given the discussion about splitting the .inc file.

Sure, I don't mind adding the indentation here or in a follow up. About the file splitting I would be in favor to split in at least two files but with no string opinion as said before. What about you @jdenny, @jdoerfert?

[jdenny]

In D82405#2118242, @clementval wrote:

About the file splitting I would be in favor to split in at least two files but with no string opinion as said before. What about you @jdenny, @jdoerfert?

So far, it seems that the three of us slightly prefer splitting, and it seems there's some precedent for this in mlir. If @thakis or others do not object today, then maybe just go with what you think is right. It can always be changed later.

[jdoerfert]

+1 for splitting it into logical consistent files.

One source that generates what you need in different places.

[clementval]

Split file and add some indentation to the generated code. @jdenny @jdoerfert It should be ready to land now.

[jdenny]

Be sure to update the summary where it talks about OMP.inc.

Thanks for adjusting the indentation.

llvm/test/TableGen/directive2.td

63

Why did .Default just show up here in this update?

[clementval]

llvm/test/TableGen/directive2.td

63

I forced to have at least one default now so this reflect here as well.

[jdenny]

llvm/test/TableGen/directive2.td

63

Before this update (Diff 7) to this review, TDLD_dira and TDLC_clauseb were already set as defaults, but .Default didn't show up in these switches. Was the test case broken, or did something subtle change in the emitter?

[clementval]

llvm/test/TableGen/directive2.td

63

The test was not correct. Default should be present as a default is mandatory by the emitter.

[jdenny]

Still LGTM.

llvm/test/TableGen/directive2.td

63

Thanks for clarifying.

[clementval]

In D82405#2121389, @jdenny wrote:

Still LGTM.

Thanks for the review. Will push this tomorrow if there is no other comment.

[jdoerfert]

LGTM

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

 //===-- DirectiveBase.td - Base directive definition file --*- tablegen -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This is the base definition file directives and clauses.
 //
 //===----------------------------------------------------------------------===//
 
 
-// General information about the directive language
+// General information about the directive language.
 class DirectiveLanguage {
   // Name of the directive language such as omp or acc.
   string name = ?;
 
   // The C++ namespace that code of this directive language should be placed
   // into. This namespace is nested in llvm namespace.
   //
   // By default, uses the name of the directive language as the only namespace.
class DirectiveLanguage {
   // Optional prefix used for the generation of the enumerator in the Clause
   // enum.
   string clausePrefix = "";
 
   // Make the enum values available in the namespace. This allows us to
   // write something like Enum_X if we have a `using namespace cppNamespace`.
   bit makeEnumAvailableInNamespace = 0;
 
-  // Generate include and macro to enable LLVM BitmaskEnum
+  // Generate include and macro to enable LLVM BitmaskEnum.
   bit enableBitmaskEnumInNamespace = 0;
 }
 
-// Information about a specific clause
+// Information about a specific clause.
 class Clause<string c> {
-  // Name of the clause
+  // Name of the clause.
   string name = c;
 
-  // Optional class holding value of the clause in clang AST
+  // Define an alternative name return in get<LanguageName>ClauseName function.
+  string alternativeName = "";
+
+  // Optional class holding value of the clause in clang AST.
   string clangClass = ?;
 
-  // Is clause implicit?
+  // 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;
 }
 
 // Information about a specific directive
 class Directive<string d> {
   // Name of the directive. Can be composite directive sepearted by whitespace.
   string name = d;
 
+  // Define an alternative name return in get<LanguageName>DirectiveName
+  // function.
+  string alternativeName = "";
+
   // List of allowed clauses for the directive.
   list<Clause> allowedClauses = ?;
 
   // List of clauses that are allowed to appear only once.
   list<Clause> allowedOnceClauses = ?;
 
   // List of clauses that are required.
   list<Clause> requiredClauses = ?;
+
+  // Set directive used by default when unknown.
+  bit isDefault = 0;
 }

llvm/include/llvm/Frontend/OpenMP/CMakeLists.txt

 set(LLVM_TARGET_DEFINITIONS OMP.td)
-tablegen(LLVM OMP.h.inc --gen-directive-decls)
+tablegen(LLVM OMP.h.inc --gen-directive-decl)
+tablegen(LLVM OMP.cpp.inc --gen-directive-impl)
 add_public_tablegen_target(omp_gen)

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

def OMPC_Depobj : Clause<"depobj"> {
   let clangClass = "OMPDepobjClause";
   let isImplicit = 1;
 }
 def OMPC_Flush : Clause<"flush"> {
   let clangClass = "OMPFlushClause";
   let isImplicit = 1;
 }
 def OMPC_ThreadPrivate : Clause<"threadprivate"> {
-  // threadprivate or thread local
+  let alternativeName = "threadprivate or thread local";
   let isImplicit = 1;
 }
 def OMPC_Unknown : Clause<"unknown"> {
   let isImplicit = 1;
+  let isDefault = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // Definition of OpenMP directives
 //===----------------------------------------------------------------------===//
 
 def OMP_ThreadPrivate : Directive<"threadprivate"> {}
 def OMP_Parallel : Directive<"parallel"> {

 def OMP_Depobj : Directive<"depobj"> {
   let allowedClauses = [OMPC_Depend, OMPC_Destroy, OMPC_Update, OMPC_Depobj];
 }
 def OMP_Scan : Directive<"scan"> {
   let allowedClauses = [OMPC_Inclusive, OMPC_Exclusive];
 }
 def OMP_BeginDeclareVariant : Directive<"begin declare variant"> {}
 def OMP_EndDeclareVariant : Directive<"end declare variant"> {}
-def OMP_Unknown : Directive<"unknown"> {}
+def OMP_Unknown : Directive<"unknown"> {
+  let isDefault = 1;
+}

llvm/include/llvm/Frontend/OpenMP/OMPConstants.h

 /// This file defines constans and helpers used when dealing with OpenMP.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_OPENMP_CONSTANTS_H
 #define LLVM_OPENMP_CONSTANTS_H
 
 #include "llvm/ADT/BitmaskEnum.h"
+
 #include "llvm/Frontend/OpenMP/OMP.h.inc"
 
 namespace llvm {
 class Type;
 class Module;
 class ArrayType;
 class StructType;
 class PointerType;

 #define OMP_IDENT_FLAG(Enum, Str, Value) Enum = Value,
 #include "llvm/Frontend/OpenMP/OMPKinds.def"
   LLVM_MARK_AS_BITMASK_ENUM(0x7FFFFFFF)
 };
 
 #define OMP_IDENT_FLAG(Enum, ...) constexpr auto Enum = omp::IdentFlag::Enum;
 #include "llvm/Frontend/OpenMP/OMPKinds.def"
 
-/// Parse \p Str and return the directive it matches or OMPD_unknown if none.
-Directive getOpenMPDirectiveKind(StringRef Str);
-
-/// Return a textual representation of the directive \p D.
-StringRef getOpenMPDirectiveName(Directive D);
-
-/// Parse \p Str and return the clause it matches or OMPC_unknown if none.
-Clause getOpenMPClauseKind(StringRef Str);
-
-/// Return a textual representation of the clause \p C.
-StringRef getOpenMPClauseName(Clause C);
-
 /// Return true if \p C is a valid clause for \p D in version \p Version.
 bool isAllowedClauseForDirective(Directive D, Clause C, unsigned Version);
 
 /// Forward declarations for LLVM-IR types (simple, function and structure) are
 /// generated below. Their names are defined and used in OpenMP/OMPKinds.def.
 /// Here we provide the forward declarations, the initializeTypes function will
 /// provide the values.
 ///

llvm/lib/Frontend/OpenMP/OMPConstants.cpp

 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Type.h"
 
 using namespace llvm;
 using namespace omp;
 using namespace types;
 
-Directive llvm::omp::getOpenMPDirectiveKind(StringRef Str) {
-  return llvm::StringSwitch<Directive>(Str)
-#define OMP_DIRECTIVE(Enum, Str) .Case(Str, Enum)
-#include "llvm/Frontend/OpenMP/OMPKinds.def"
-      .Default(OMPD_unknown);
-}
-
-StringRef llvm::omp::getOpenMPDirectiveName(Directive Kind) {
-  switch (Kind) {
-#define OMP_DIRECTIVE(Enum, Str)                                               \
-  case Enum:                                                                   \
-    return Str;
-#include "llvm/Frontend/OpenMP/OMPKinds.def"
-  }
-  llvm_unreachable("Invalid OpenMP directive kind");
-}
-
-Clause llvm::omp::getOpenMPClauseKind(StringRef Str) {
-  return llvm::StringSwitch<Clause>(Str)
-#define OMP_CLAUSE(Enum, Str, Implicit)                                        \
-  .Case(Str, Implicit ? OMPC_unknown : Enum)
-#include "llvm/Frontend/OpenMP/OMPKinds.def"
-      .Default(OMPC_unknown);
-}
-
-StringRef llvm::omp::getOpenMPClauseName(Clause C) {
-  switch (C) {
-#define OMP_CLAUSE(Enum, Str, ...)                                             \
-  case Enum:                                                                   \
-    return Str;
-#include "llvm/Frontend/OpenMP/OMPKinds.def"
-  }
-  llvm_unreachable("Invalid OpenMP clause kind");
-}
+#include "llvm/Frontend/OpenMP/OMP.cpp.inc"
 
 bool llvm::omp::isAllowedClauseForDirective(Directive D, Clause C,
                                             unsigned Version) {
   assert(unsigned(D) <= llvm::omp::Directive_enumSize);
   assert(unsigned(C) <= llvm::omp::Clause_enumSize);
 #define OMP_DIRECTIVE_CLAUSE(Dir, MinVersion, MaxVersion, Cl)                  \
   if (D == Dir && C == Cl && MinVersion <= Version && MaxVersion >= Version)   \
     return true;

llvm/test/TableGen/directive1.td

-// RUN: llvm-tblgen -gen-directive-decls -I %p/../../include %s | FileCheck %s
+// 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
 
 include "llvm/Frontend/Directive/DirectiveBase.td"
 
 def TestDirectiveLanguage : DirectiveLanguage {
-  let name = "tdl";
+  let name = "Tdl";
 
   let cppNamespace = "tdl";
   let directivePrefix = "TDLD_";
   let clausePrefix = "TDLC_";
   let makeEnumAvailableInNamespace = 1;
   let enableBitmaskEnumInNamespace = 1;
 }
 
 def TDLC_ClauseA : Clause<"clausea"> {}
-def TDLC_ClauseB : Clause<"clauseb"> {}
+def TDLC_ClauseB : Clause<"clauseb"> {
+  let isDefault = 1;
+}
 
 def TDL_DirA : Directive<"dira"> {
   let allowedClauses = [TDLC_ClauseA, TDLC_ClauseB];
+  let isDefault = 1;
 }
 
-// CHECK: #ifndef LLVM_tdl_INC
-// CHECK-NEXT: #define LLVM_tdl_INC
-// CHECK-NEXT: #include "llvm/ADT/BitmaskEnum.h"
-// CHECK-NEXT: namespace llvm {
-// CHECK-NEXT: namespace tdl {
-// CHECK-NEXT: LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();
-// CHECK-NEXT: enum class Directive {
-// CHECK-NEXT: TDLD_dira,
-// CHECK-NEXT: }
-// CHECK-NEXT: static constexpr std::size_t Directive_enumSize = 1;
-// CHECK-NEXT: enum class Clause {
-// CHECK-NEXT: TDLC_clausea,
-// CHECK-NEXT: TDLC_clauseb,
-// CHECK-NEXT: }
-// CHECK-NEXT: static constexpr std::size_t Clause_enumSize = 2;
-// CHECK-NEXT: constexpr auto TDLD_dira = tdl::Directive::TDLD_dira;
-// CHECK-NEXT: constexpr auto TDLC_clausea = tdl::Clause::TDLC_clausea;
-// CHECK-NEXT: constexpr auto TDLC_clauseb = tdl::Clause::TDLC_clauseb;
-// CHECK-NEXT: }
-// CHECK-NEXT: }
-// CHECK-NEXT: #endif
+// CHECK:       #ifndef LLVM_Tdl_INC
+// CHECK-NEXT:  #define LLVM_Tdl_INC
+// CHECK-EMPTY:
+// CHECK-NEXT:  #include "llvm/ADT/BitmaskEnum.h"
+// CHECK-EMPTY:
+// CHECK-NEXT:  namespace llvm {
+// CHECK-NEXT:  class StringRef;
+// CHECK-NEXT:  namespace tdl {
+// CHECK-EMPTY:
+// CHECK-NEXT:  LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();
+// CHECK-EMPTY:
+// CHECK-NEXT:  enum class Directive {
+// CHECK-NEXT:    TDLD_dira,
+// CHECK-NEXT:  };
+// CHECK-EMPTY:
+// CHECK-NEXT:  static constexpr std::size_t Directive_enumSize = 1;
+// CHECK-EMPTY:
+// CHECK-NEXT:  constexpr auto TDLD_dira = llvm::tdl::Directive::TDLD_dira;
+// CHECK-EMPTY:
+// CHECK-NEXT:  enum class Clause {
+// CHECK-NEXT:    TDLC_clausea,
+// CHECK-NEXT:    TDLC_clauseb,
+// CHECK-NEXT:  };
+// CHECK-EMPTY:
+// CHECK-NEXT:  static constexpr std::size_t Clause_enumSize = 2;
+// CHECK-EMPTY:
+// CHECK-NEXT:  constexpr auto TDLC_clausea = llvm::tdl::Clause::TDLC_clausea;
+// CHECK-NEXT:  constexpr auto TDLC_clauseb = llvm::tdl::Clause::TDLC_clauseb;
+// 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:
+// CHECK-NEXT:  llvm::StringRef getTdlClauseName(Clause C);
+// CHECK-EMPTY:
+// CHECK-NEXT:  } // namespace tdl
+// CHECK-NEXT:  } // namespace llvm
+// CHECK-NEXT:  #endif // LLVM_Tdl_INC
+
+
+// IMPL:       Directive llvm::tdl::getTdlDirectiveKind(llvm::StringRef Str) {
+// IMPL-NEXT:    return llvm::StringSwitch<Directive>(Str)
+// IMPL-NEXT:      .Case("dira",TDLD_dira)
+// IMPL-NEXT:      .Default(TDLD_dira);
+// IMPL-NEXT:  }
+// IMPL-EMPTY:
+// IMPL-NEXT:  llvm::StringRef llvm::tdl::getTdlDirectiveName(Directive Kind) {
+// IMPL-NEXT:    switch (Kind) {
+// IMPL-NEXT:      case TDLD_dira:
+// IMPL-NEXT:        return "dira";
+// 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_clausea)
+// IMPL-NEXT:      .Case("clauseb",TDLC_clauseb)
+// 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:    }
+// IMPL-NEXT:    llvm_unreachable("Invalid Tdl Clause kind");
+// IMPL-NEXT:  }

llvm/test/TableGen/directive2.td

-// RUN: llvm-tblgen -gen-directive-decls -I %p/../../include %s | FileCheck %s
+// 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
 
 include "llvm/Frontend/Directive/DirectiveBase.td"
 
 def TestDirectiveLanguage : DirectiveLanguage {
-  let name = "tdl";
+  let name = "Tdl";
 
   let cppNamespace = "tdl";
   let directivePrefix = "TDLD_";
   let clausePrefix = "TDLC_";
 }
 
-def TDLC_ClauseA : Clause<"clausea"> {}
-def TDLC_ClauseB : Clause<"clauseb"> {}
+def TDLC_ClauseA : Clause<"clausea"> {
+  let isImplicit = 1;
+}
+def TDLC_ClauseB : Clause<"clauseb"> {
+  let isDefault = 1;
+}
 
 def TDL_DirA : Directive<"dira"> {
   let allowedClauses = [TDLC_ClauseA, TDLC_ClauseB];
+  let isDefault = 1;
 }
 
-// CHECK: #ifndef LLVM_tdl_INC
-// CHECK-NEXT: #define LLVM_tdl_INC
-// CHECK-NEXT: namespace llvm {
-// CHECK-NEXT: namespace tdl {
-// CHECK-NEXT: enum class Directive {
-// CHECK-NEXT: TDLD_dira,
-// CHECK-NEXT: }
-// CHECK-NEXT: static constexpr std::size_t Directive_enumSize = 1;
-// CHECK-NEXT: enum class Clause {
-// CHECK-NEXT: TDLC_clausea,
-// CHECK-NEXT: TDLC_clauseb,
-// CHECK-NEXT: }
-// CHECK-NEXT: static constexpr std::size_t Clause_enumSize = 2;
-// CHECK-NEXT: }
-// CHECK-NEXT: }
-// CHECK-NEXT: #endif
+// CHECK:       #ifndef LLVM_Tdl_INC
+// CHECK-NEXT:  #define LLVM_Tdl_INC
+// CHECK-EMPTY:
+// CHECK-NEXT:  namespace llvm {
+// CHECK-NEXT:  class StringRef;
+// CHECK-NEXT:  namespace tdl {
+// CHECK-EMPTY:
+// CHECK-NEXT:  enum class Directive {
+// 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:  };
+// CHECK-EMPTY:
+// CHECK-NEXT:  static constexpr std::size_t Clause_enumSize = 2;
+// 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:
+// CHECK-NEXT:  llvm::StringRef getTdlClauseName(Clause C);
+// CHECK-EMPTY:
+// CHECK-NEXT:  } // namespace tdl
+// CHECK-NEXT:  } // namespace llvm
+// CHECK-NEXT:  #endif // LLVM_Tdl_INC
+
+
+// IMPL:       Directive llvm::tdl::getTdlDirectiveKind(llvm::StringRef Str) {
+// IMPL-NEXT:    return llvm::StringSwitch<Directive>(Str)
+// IMPL-NEXT:      .Case("dira",TDLD_dira)
+// IMPL-NEXT:      .Default(TDLD_dira);
+// IMPL-NEXT:  }
+// IMPL-EMPTY:
+// IMPL-NEXT:  llvm::StringRef llvm::tdl::getTdlDirectiveName(Directive Kind) {
+// IMPL-NEXT:    switch (Kind) {
+// IMPL-NEXT:      case TDLD_dira:
+// IMPL-NEXT:        return "dira";
+// 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:      .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:    }
+// IMPL-NEXT:    llvm_unreachable("Invalid Tdl Clause kind");
+// IMPL-NEXT:  }
 No newline at end of file

llvm/utils/TableGen/DirectiveEmitter.cpp

 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Record.h"
 #include "llvm/TableGen/TableGenBackend.h"
 
+using namespace llvm;
+
 namespace llvm {
-void EmitDirectivesEnums(RecordKeeper &Records, raw_ostream &OS) {
+
+// Generate enum class
+void GenerateEnumClass(const std::vector<Record *> &Records, raw_ostream &OS,
+                       StringRef Enum, StringRef Prefix, StringRef CppNamespace,
+                       bool MakeEnumAvailableInNamespace) {
+  OS << "\n";
+  OS << "enum class " << Enum << " {\n";
+  for (const auto &R : Records) {
+    const auto Name = R->getValueAsString("name");
+    std::string N = Name.str();
+    std::replace(N.begin(), N.end(), ' ', '_');
+    OS << "  " << Prefix << N << ",\n";
+  }
+  OS << "};\n";
+  OS << "\n";
+  OS << "static constexpr std::size_t " << Enum
+     << "_enumSize = " << Records.size() << ";\n";
+
+  // Make the enum values available in the defined namespace. This allows us to
+  // write something like Enum_X if we have a `using namespace <CppNamespace>`.
+  // At the same time we do not loose the strong type guarantees of the enum
+  // class, that is we cannot pass an unsigned as Directive without an explicit
+  // cast.
+  if (MakeEnumAvailableInNamespace) {
+    OS << "\n";
+    for (const auto &R : Records) {
+      const auto Name = R->getValueAsString("name");
+      std::string N = Name.str();
+      std::replace(N.begin(), N.end(), ' ', '_');
+      OS << "constexpr auto " << Prefix << N << " = "
+         << "llvm::" << CppNamespace << "::" << Enum << "::" << Prefix << N
+         << ";\n";
+    }
+  }
+}
+
+// Generate the declaration section for the enumeration in the directive
+// language
+void EmitDirectivesDecl(RecordKeeper &Records, raw_ostream &OS) {
 
   const auto &DirectiveLanguages =
       Records.getAllDerivedDefinitions("DirectiveLanguage");
 
   if (DirectiveLanguages.size() != 1) {
     PrintError("A single definition of DirectiveLanguage is needed.");
     return;
   }
 
   const auto &DirectiveLanguage = DirectiveLanguages[0];
-  StringRef languageName = DirectiveLanguage->getValueAsString("name");
+  StringRef LanguageName = DirectiveLanguage->getValueAsString("name");
   StringRef DirectivePrefix =
       DirectiveLanguage->getValueAsString("directivePrefix");
   StringRef ClausePrefix = DirectiveLanguage->getValueAsString("clausePrefix");
   StringRef CppNamespace = DirectiveLanguage->getValueAsString("cppNamespace");
   bool MakeEnumAvailableInNamespace =
       DirectiveLanguage->getValueAsBit("makeEnumAvailableInNamespace");
   bool EnableBitmaskEnumInNamespace =
       DirectiveLanguage->getValueAsBit("enableBitmaskEnumInNamespace");
 
-  OS << "#ifndef LLVM_" << languageName << "_INC\n";
-  OS << "#define LLVM_" << languageName << "_INC\n";
+  OS << "#ifndef LLVM_" << LanguageName << "_INC\n";
+  OS << "#define LLVM_" << LanguageName << "_INC\n";
 
   if (EnableBitmaskEnumInNamespace)
-    OS << "#include \"llvm/ADT/BitmaskEnum.h\"\n";
+    OS << "\n#include \"llvm/ADT/BitmaskEnum.h\"\n";
 
+  OS << "\n";
   OS << "namespace llvm {\n";
+  OS << "class StringRef;\n";
 
   // Open namespaces defined in the directive language
   llvm::SmallVector<StringRef, 2> Namespaces;
   llvm::SplitString(CppNamespace, Namespaces, "::");
   for (auto Ns : Namespaces)
     OS << "namespace " << Ns << " {\n";
 
   if (EnableBitmaskEnumInNamespace)
-    OS << "LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();\n";
+    OS << "\nLLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();\n";
 
   // Emit Directive enumeration
-  OS << "enum class Directive {\n";
   const auto &Directives = Records.getAllDerivedDefinitions("Directive");
-  for (const auto &D : Directives) {
-    const auto Name = D->getValueAsString("name");
-    std::string N = Name.str();
-    std::replace(N.begin(), N.end(), ' ', '_');
-    OS << DirectivePrefix << N << ",\n";
-  }
-  OS << "};\n";
-
-  OS << "static constexpr std::size_t Directive_enumSize = "
-     << Directives.size() << ";\n";
+  GenerateEnumClass(Directives, OS, "Directive", DirectivePrefix, CppNamespace,
+                    MakeEnumAvailableInNamespace);
 
   // Emit Clause enumeration
-  OS << "enum class Clause {\n";
   const auto &Clauses = Records.getAllDerivedDefinitions("Clause");
-  for (const auto &C : Clauses) {
-    const auto Name = C->getValueAsString("name");
-    OS << ClausePrefix << Name << ",\n";
-  }
-  OS << "};\n";
+  GenerateEnumClass(Clauses, OS, "Clause", ClausePrefix, CppNamespace,
+                    MakeEnumAvailableInNamespace);
 
-  OS << "static constexpr std::size_t Clause_enumSize = " << Clauses.size()
-     << ";\n";
+  // Generic function signatures
+  OS << "\n";
+  OS << "// Enumeration helper functions\n";
+  OS << "Directive get" << LanguageName
+     << "DirectiveKind(llvm::StringRef Str);\n";
+  OS << "\n";
+  OS << "llvm::StringRef get" << LanguageName
+     << "DirectiveName(Directive D);\n";
+  OS << "\n";
+  OS << "Clause get" << LanguageName << "ClauseKind(llvm::StringRef Str);\n";
+  OS << "\n";
+  OS << "llvm::StringRef get" << LanguageName << "ClauseName(Clause C);\n";
+  OS << "\n";
 
-  // Make the enum values available in the defined namespace. This allows us to
-  // write something like Enum_X if we have a `using namespace <CppNamespace>`.
-  // At the same time we do not loose the strong type guarantees of the enum
-  // class, that is we cannot pass an unsigned as Directive without an explicit
-  // cast.
-  if (MakeEnumAvailableInNamespace) {
-    for (const auto &D : Directives) {
-      const auto Name = D->getValueAsString("name");
-      std::string N = Name.str();
-      std::replace(N.begin(), N.end(), ' ', '_');
-      OS << "constexpr auto " << DirectivePrefix << N << " = " << CppNamespace
-         << "::Directive::" << DirectivePrefix << N << ";\n";
-    }
+  // Closing namespaces
+  for (auto Ns : llvm::reverse(Namespaces))
+    OS << "} // namespace " << Ns << "\n";
+
+  OS << "} // namespace llvm\n";
+
+  OS << "#endif // LLVM_" << LanguageName << "_INC\n";
+}
+
+// Generate function implementation for get<Enum>Name(StringRef Str)
+void GenerateGetName(const std::vector<Record *> &Records, raw_ostream &OS,
+                     StringRef Enum, StringRef Prefix, StringRef LanguageName,
+                     StringRef Namespace) {
+  OS << "\n";
+  OS << "llvm::StringRef llvm::" << Namespace << "::get" << LanguageName << Enum
+     << "Name(" << Enum << " Kind) {\n";
+  OS << "  switch (Kind) {\n";
+  for (const auto &R : Records) {
+    const auto Name = R->getValueAsString("name");
+    const auto AlternativeName = R->getValueAsString("alternativeName");
+    OS << "    case " << Prefix << N << ":\n";
+    OS << "      return \"";
+    if (AlternativeName.empty())
+      OS << Name;
+    else
+      OS << AlternativeName;
+    OS << "\";\n";
+  }
+  OS << "  }\n"; // switch
+  OS << "  llvm_unreachable(\"Invalid " << LanguageName << " " << Enum
+     << " kind\");\n";
+  OS << "}\n";
+}
+
+// Generate function implementation for get<Enum>Kind(StringRef Str)
+void GenerateGetKind(const std::vector<Record *> &Records, raw_ostream &OS,
+                     StringRef Enum, StringRef Prefix, StringRef LanguageName,
+                     StringRef Namespace, bool ImplicitAsUnknown) {
+
+  auto DefaultIt = std::find_if(Records.begin(), Records.end(), [](Record *R) {
+    return R->getValueAsBit("isDefault") == true;
+  });
+
+  if (DefaultIt == Records.end()) {
+    PrintError("A least one " + Enum + " must be defined as default.");
+    return;
 
-    for (const auto &C : Clauses) {
-      const auto Name = C->getValueAsString("name");
-      OS << "constexpr auto " << ClausePrefix << Name << " = " << CppNamespace
-         << "::Clause::" << ClausePrefix << Name << ";\n";
-    }
-  }
+  const auto DefaultName = (*DefaultIt)->getValueAsString("name");
+  std::string DefaultEnum = DefaultName.str();
+  std::replace(DefaultEnum.begin(), DefaultEnum.end(), ' ', '_');
+
+  OS << "\n";
+  OS << Enum << " llvm::" << Namespace << "::get" << LanguageName << Enum
+     << "Kind(llvm::StringRef Str) {\n";
+  OS << "  return llvm::StringSwitch<" << Enum << ">(Str)\n";
+
+  for (const auto &R : Records) {
+    const auto Name = R->getValueAsString("name");
+    std::string N = Name.str();
+    std::replace(N.begin(), N.end(), ' ', '_');
+    if (ImplicitAsUnknown && R->getValueAsBit("isImplicit")) {
+      OS << "    .Case(\"" << Name << "\"," << Prefix << DefaultEnum << ")\n";
+    } else {
+      OS << "    .Case(\"" << Name << "\"," << Prefix << N << ")\n";
+    }
+  OS << "    .Default(" << Prefix << DefaultEnum << ");\n";
+  OS << "}\n";
 
-  // Closing namespaces
-  for (auto Ns : llvm::reverse(Namespaces))
-    OS << "} // namespace " << Ns << "\n";
+// Generate the implemenation section for the enumeration in the directive
+// language
+void EmitDirectivesImpl(RecordKeeper &Records, raw_ostream &OS) {
 
-  OS << "} // namespace llvm\n";
+  const auto &DirectiveLanguages =
+      Records.getAllDerivedDefinitions("DirectiveLanguage");
 
-  OS << "#endif";
+  if (DirectiveLanguages.size() != 1) {
+    PrintError("A single definition of DirectiveLanguage is needed.");
+    return;
   }
+
+  const auto &DirectiveLanguage = DirectiveLanguages[0];
+  StringRef DirectivePrefix =
+      DirectiveLanguage->getValueAsString("directivePrefix");
+  StringRef LanguageName = DirectiveLanguage->getValueAsString("name");
+  StringRef ClausePrefix = DirectiveLanguage->getValueAsString("clausePrefix");
+  StringRef CppNamespace = DirectiveLanguage->getValueAsString("cppNamespace");
+
+  const auto &Directives = Records.getAllDerivedDefinitions("Directive");
+  const auto &Clauses = Records.getAllDerivedDefinitions("Clause");
+
+  // getDirectiveKind(StringRef Str)
+  GenerateGetKind(Directives, OS, "Directive", DirectivePrefix, LanguageName,
+                  CppNamespace, /*ImplicitAsUnknown=*/false);
+
+  // getDirectiveName(Directive Kind)
+  GenerateGetName(Directives, OS, "Directive", DirectivePrefix, LanguageName,
+                  CppNamespace);
+
+  // getClauseKind(StringRef Str)
+  GenerateGetKind(Clauses, OS, "Clause", ClausePrefix, LanguageName,
+                  CppNamespace, /*ImplicitAsUnknown=*/true);
+
+  // getClauseName(Clause Kind)
+  GenerateGetName(Clauses, OS, "Clause", ClausePrefix, LanguageName,
+                  CppNamespace);
+}
+
 } // namespace llvm

llvm/utils/TableGen/TableGen.cpp

enum ActionType {
   GenSearchableTables,
   GenGlobalISel,
   GenGICombiner,
   GenX86EVEX2VEXTables,
   GenX86FoldTables,
   GenRegisterBank,
   GenExegesis,
   GenAutomata,
-  GenDirectivesEnums,
+  GenDirectivesEnumDecl,
+  GenDirectivesEnumImpl,
 };
 
 namespace llvm {
 /// Storage for TimeRegionsOpt as a global so that backends aren't required to
 /// include CommandLine.h
 bool TimeRegions = false;
 cl::opt<bool> EmitLongStrLiterals(
     "long-string-literals",
cl::values(
                    "Generate X86 EVEX to VEX compress tables"),
         clEnumValN(GenX86FoldTables, "gen-x86-fold-tables",
                    "Generate X86 fold tables"),
         clEnumValN(GenRegisterBank, "gen-register-bank",
                    "Generate registers bank descriptions"),
         clEnumValN(GenExegesis, "gen-exegesis",
                    "Generate llvm-exegesis tables"),
         clEnumValN(GenAutomata, "gen-automata", "Generate generic automata"),
-        clEnumValN(GenDirectivesEnums, "gen-directive-decls",
-                   "Generate directive related declaration code")));
+        clEnumValN(GenDirectivesEnumDecl, "gen-directive-decl",
+                   "Generate directive related declaration code"),
+        clEnumValN(GenDirectivesEnumImpl, "gen-directive-impl",
+                   "Generate directive related implementation code")));
 
 cl::OptionCategory PrintEnumsCat("Options for -print-enums");
 cl::opt<std::string> Class("class", cl::desc("Print Enum list for this class"),
                            cl::value_desc("class name"),
                            cl::cat(PrintEnumsCat));
 
 cl::opt<bool, true>
     TimeRegionsOpt("time-regions",
case GenX86FoldTables:
     EmitX86FoldTables(Records, OS);
     break;
   case GenExegesis:
     EmitExegesis(Records, OS);
     break;
   case GenAutomata:
     EmitAutomata(Records, OS);
     break;
-  case GenDirectivesEnums:
-    EmitDirectivesEnums(Records, OS);
+  case GenDirectivesEnumDecl:
+    EmitDirectivesDecl(Records, OS);
+    break;
+  case GenDirectivesEnumImpl:
+    EmitDirectivesImpl(Records, OS);
     break;
   }
 
   return false;
 }
 }
 
 int main(int argc, char **argv) {

llvm/utils/TableGen/TableGenBackends.h

 void EmitSearchableTables(RecordKeeper &RK, raw_ostream &OS);
 void EmitGlobalISel(RecordKeeper &RK, raw_ostream &OS);
 void EmitGICombiner(RecordKeeper &RK, raw_ostream &OS);
 void EmitX86EVEX2VEXTables(RecordKeeper &RK, raw_ostream &OS);
 void EmitX86FoldTables(RecordKeeper &RK, raw_ostream &OS);
 void EmitRegisterBank(RecordKeeper &RK, raw_ostream &OS);
 void EmitExegesis(RecordKeeper &RK, raw_ostream &OS);
 void EmitAutomata(RecordKeeper &RK, raw_ostream &OS);
-void EmitDirectivesEnums(RecordKeeper &RK, raw_ostream &OS);
+void EmitDirectivesDecl(RecordKeeper &RK, raw_ostream &OS);
+void EmitDirectivesImpl(RecordKeeper &RK, raw_ostream &OS);
 
 } // End llvm namespace
 
 #endif