omp: Make OMP tablegen more like all other tablegens.

[thakis]

Summary

Generate a .inc file that's included by .h and .cpp files,
instead of generating all C++ code in tablegen. The surrounding
C++ is easier to write in a C++ file, and it's consistent with
how the rest of llvm/ looks.

No intended behavior change.

[thakis]

As discussed a while ago in D81736. It's about half as much code.

[clementval]

While I agree that this reduce the code size it also split the code generation in two. We are also generating new code for Flang and probably it will be used by clang when we move the rest of the OMPKinds.def to TableGen (see https://reviews.llvm.org/D83326). I don't have strong opinion on this but looks like going back to the OMPKinds.def which we are trying to remove. Maybe @jdoerfert can review/comment this better.

[thakis]

It puts the C++ code in C++ files :)

I agree there are merits to both approaches, but this is the one used ~everywhere else in LLVM and clang, so if it's a wash it seems good to stay consistent with the rest of the codebase.

[clementval]

In D83636#2147351, @thakis wrote:

It puts the C++ code in C++ files :)

The C++ code is currently in a C++ files (OMP.cpp that replaces OMPConstants.cpp). I don't get this comment.

I agree there are merits to both approaches, but this is the one used ~everywhere else in LLVM and clang, so if it's a wash it seems good to stay consistent with the rest of the codebase.

MLIR is using similar technics for the dialects code. As I said, I don't have a strong opinion on this but I would like @jdoerfert to have look at this before going forward if you don't mind. It feels just weird to me to re-generate macros to be used to generate code that we can generate directly.

[jdoerfert]

In D83636#2148958, @clementval wrote:

In D83636#2147351, @thakis wrote:

It puts the C++ code in C++ files :)

The C++ code is currently in a C++ files (OMP.cpp that replaces OMPConstants.cpp). I don't get this comment.

We currently generate C++ code via tablegen, now we don't (generate as much C++ code but have the boilerplate manually written in OMP.cpp).

I agree there are merits to both approaches, but this is the one used ~everywhere else in LLVM and clang, so if it's a wash it seems good to stay consistent with the rest of the codebase.

MLIR is using similar technics for the dialects code. As I said, I don't have a strong opinion on this but I would like @jdoerfert to have look at this before going forward if you don't mind. It feels just weird to me to re-generate macros to be used to generate code that we can generate directly.

OK, I do not have much tablegen experience nor a strong opinion on this either way. To me, having macros for switches is not the problem since we generate the content via tablegen and not the macro cascade we used before. That makes the difference wrt. type safety and complex relationships. That said, it seems there are certain things we still generate as C++ and then include, e.g., the stuff guarded by GET_IS_ALLOWED_CLAUSE_FOR_DIRECTIVE_IMPL. So at the end we replace mostly switch code with generated macros, and use a manually written C++ boilerplate instead of generating it. Both seem sensible given the code size/complexity reduction. And then there is the fact that, if all things are equal, matching LLVM is for sure the preferred way.

llvm/include/llvm/Frontend/OpenMP/OMP.h

1

file header missing.

53

Wrong guard naem?

[clementval]

In D83636#2152032, @jdoerfert wrote:

In D83636#2148958, @clementval wrote:

In D83636#2147351, @thakis wrote:

It puts the C++ code in C++ files :)

The C++ code is currently in a C++ files (OMP.cpp that replaces OMPConstants.cpp). I don't get this comment.

We currently generate C++ code via tablegen, now we don't (generate as much C++ code but have the boilerplate manually written in OMP.cpp).

I agree there are merits to both approaches, but this is the one used ~everywhere else in LLVM and clang, so if it's a wash it seems good to stay consistent with the rest of the codebase.

MLIR is using similar technics for the dialects code. As I said, I don't have a strong opinion on this but I would like @jdoerfert to have look at this before going forward if you don't mind. It feels just weird to me to re-generate macros to be used to generate code that we can generate directly.

OK, I do not have much tablegen experience nor a strong opinion on this either way. To me, having macros for switches is not the problem since we generate the content via tablegen and not the macro cascade we used before. That makes the difference wrt. type safety and complex relationships. That said, it seems there are certain things we still generate as C++ and then include, e.g., the stuff guarded by GET_IS_ALLOWED_CLAUSE_FOR_DIRECTIVE_IMPL. So at the end we replace mostly switch code with generated macros, and use a manually written C++ boilerplate instead of generating it. Both seem sensible given the code size/complexity reduction. And then there is the fact that, if all things are equal, matching LLVM is for sure the preferred way.

There are some limitation to this approach. For example how to you generate the new directive-clauses map used in Flang and that will probably make its way to Clang at some point. I'm just wondering if we are not removing some code for later introducing more complexity. But as I said before I'm happy with whatever is decided.

[clementval]

@thakis Sorry this has been lying here for a while. I see the point of having this mixed "mode" where more complicated constructs are code gen inside the DirectiveEmitter and there is a way to do the simplest ones using macros and includes. Unfortunately, I think this patch is now behind the current version and OpenACC joined the frontend directory recently as it is under construction in Flang. If you think this is still valuable, I can offer to work on a new patch that cover both OpenMP and OpenACC and follow what you were trying to do here.

@jdoerfert Any comments?

[jdoerfert]

In D83636#2181588, @clementval wrote:

@jdoerfert Any comments?

Not really, assuming there is nothing specifically new since my last comment here.

[thakis]

I do think this is valuable. I was about to land it, but some change landed hours before I got the lg here and rebasing took me longer than 15 minutes, and I haven't had time to look at it again since then. If you could do something like this for ACC and OMP, I think that'd be great. As mentioned on the other review, having includes of "cpp.inc" files in .h files looks very unusual.

[clementval]

In D83636#2448764, @thakis wrote:

I do think this is valuable. I was about to land it, but some change landed hours before I got the lg here and rebasing took me longer than 15 minutes, and I haven't had time to look at it again since then. If you could do something like this for ACC and OMP, I think that'd be great. As mentioned on the other review, having includes of "cpp.inc" files in .h files looks very unusual.

I agree with the inclusion of .cpp.inc inclusion inside .h file. Since then we have more code generated by tablegen and the file is meant to be included by both cpp or .h file depending on which section of code you include. I don't think we are very far from your solution with D92955 as I renamed the file. I'm happy to introduce the changes left in a further patch (after D92955) that would include ACC as well.

[clementval]

Patch D92955 and D93576 are going in this sense.

[clementval]

Patch D92955 and D93576 were going in this sense and landed. Patch D93560 is moving all to .inc file.

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

class DirectiveLanguage {
 
   // Optional prefix used for the generation of the enumerator in the Directive
   // enum.
   string directivePrefix = "";
 
   // 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.
-  bit enableBitmaskEnumInNamespace = 0;
-
-  // Header file included in the implementation code generated. Ususally the
-  // output file of the declaration code generation. Can be left blank.
-  string includeHeader = "";
 }
 
 // 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.

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

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

llvm/include/llvm/Frontend/OpenMP/OMP.h

+#ifndef LLVM_OPENMP_OMP_H
+#define LLVM_OPENMP_OMP_H
+
+
+#include "llvm/ADT/BitmaskEnum.h"
+
+namespace llvm {
+class StringRef;
+namespace omp {
+
+LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();
+
+enum class Directive {
+#define DIRECTIVE(name, _) OMPD_ ## name,
+#include "llvm/Frontend/OpenMP/OMP.inc"
+#undef DIRECTIVE
+};
+#define DIRECTIVE_SIZE(n) static constexpr std::size_t Directive_enumSize = n;
+#include "llvm/Frontend/OpenMP/OMP.inc"
+#undef DIRECTIVE_SIZE
+
+#define DIRECTIVE(name, _) constexpr auto OMPD_ ## name = Directive::OMPD_ ## name;
+#include "llvm/Frontend/OpenMP/OMP.inc"
+#undef DIRECTIVE
+
+enum class Clause {
+#define CLAUSE(name) OMPC_ ## name,
+#include "llvm/Frontend/OpenMP/OMP.inc"
+#undef CLAUSE
+};
+#define CLAUSE_SIZE(n) static constexpr std::size_t Clause_enumSize = n;
+#include "llvm/Frontend/OpenMP/OMP.inc"
+#undef CLAUSE_SIZE
+
+#define CLAUSE(name) constexpr auto OMPC_ ## name = Clause::OMPC_ ## name;
+#include "llvm/Frontend/OpenMP/OMP.inc"
+#undef CLAUSE
+
+// Enumeration helper functions
+Directive getOpenMPDirectiveKind(llvm::StringRef Str);
+
+llvm::StringRef getOpenMPDirectiveName(Directive D);
+
+Clause getOpenMPClauseKind(llvm::StringRef Str);
+
+llvm::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);
+
+} // namespace omp
+} // namespace llvm
+#endif // LLVM_OpenMP_INC

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

 // Definition of general OpenMP information
 //===----------------------------------------------------------------------===//
 
 def OpenMP : DirectiveLanguage {
   let name = "OpenMP";
   let cppNamespace = "omp"; // final namespace will be llvm::omp
   let directivePrefix = "OMPD_";
   let clausePrefix = "OMPC_";
-  let makeEnumAvailableInNamespace = 1;
-  let enableBitmaskEnumInNamespace = 1;
-  let includeHeader = "llvm/Frontend/OpenMP/OMP.h.inc";
 }
 
 //===----------------------------------------------------------------------===//
 // Definition of OpenMP clauses
 //===----------------------------------------------------------------------===//
 
 def OMPC_Allocator : Clause<"allocator"> {
   let clangClass = "OMPAllocatorClause";

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

 //===- OMPConstants.h - OpenMP related constants and helpers ------ C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 /// \file
 ///
-/// This file defines constans and helpers used when dealing with OpenMP.
+/// This file defines constants and helpers used when dealing with OpenMP.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_OPENMP_CONSTANTS_H
 #define LLVM_OPENMP_CONSTANTS_H
 
 #include "llvm/ADT/BitmaskEnum.h"
 

llvm/lib/Frontend/OpenMP/CMakeLists.txt

-set(LLVM_TARGET_DEFINITIONS ${LLVM_MAIN_INCLUDE_DIR}/llvm/Frontend/OpenMP/OMP.td)
-tablegen(LLVM OMP.cpp --gen-directive-impl)
-add_public_tablegen_target(omp_cpp)
-
 add_llvm_component_library(LLVMFrontendOpenMP
-  OMP.cpp # Generated by tablegen above
+  OMP.cpp
   OMPContext.cpp
   OMPIRBuilder.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/Frontend
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/Frontend/OpenMP
 
   DEPENDS
   intrinsics_gen
   omp_gen
-  omp_cpp
   )

llvm/lib/Frontend/OpenMP/OMP.cpp

+#include "llvm/Frontend/OpenMP/OMP.h"
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/StringSwitch.h"
+
+using namespace llvm;
+using namespace omp;
+
+#include "llvm/Frontend/OpenMP/OMP.inc"
+
+Directive llvm::omp::getOpenMPDirectiveKind(llvm::StringRef Str) {
+  return llvm::StringSwitch<Directive>(Str)
+#define DIRECTIVE(a, b) .Case(b, OMPD_##a)
+#include "llvm/Frontend/OpenMP/OMP.inc"
+#undef DIRECTIVE
+    .Default(OMPD_unknown);
+}
+
+llvm::StringRef llvm::omp::getOpenMPDirectiveName(Directive Kind) {
+  switch (Kind) {
+#define DIRECTIVE(a, b) case OMPD_##a: return b;
+#include "llvm/Frontend/OpenMP/OMP.inc"
+#undef DIRECTIVE
+  }
+  llvm_unreachable("Invalid OpenMP Directive kind");
+}
+
+Clause llvm::omp::getOpenMPClauseKind(llvm::StringRef Str) {
+  return llvm::StringSwitch<Clause>(Str)
+#define CLAUSE(name) .Case(#name, OMPC_##name)
+#include "llvm/Frontend/OpenMP/OMP.inc"
+#undef CLAUSE
+    .Default(OMPC_unknown);
+}
+
+llvm::StringRef llvm::omp::getOpenMPClauseName(Clause Kind) {
+  switch (Kind) {
+#define CLAUSE(name) case OMPC_##name: return #name;
+#include "llvm/Frontend/OpenMP/OMP.inc"
+#undef CLAUSE
+  }
+  llvm_unreachable("Invalid OpenMP Clause kind");
+}
+
+#define GET_IS_ALLOWED_CLAUSE_FOR_DIRECTIVE_IMPL
+#include "llvm/Frontend/OpenMP/OMP.inc"
+#undef GET_IS_ALLOWED_CLAUSE_FOR_DIRECTIVE_IMPL

llvm/test/TableGen/directive1.td

-// RUN: llvm-tblgen -gen-directive-decl -I %p/../../include %s | FileCheck -match-full-lines %s
-// RUN: llvm-tblgen -gen-directive-impl -I %p/../../include %s | FileCheck -match-full-lines %s -check-prefix=IMPL
+// RUN: llvm-tblgen -gen-directive -I %p/../../include %s | FileCheck -match-full-lines %s
 
 include "llvm/Frontend/Directive/DirectiveBase.td"
 
 def TestDirectiveLanguage : DirectiveLanguage {
   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"> {
   let isDefault = 1;
 }
 
 def TDL_DirA : Directive<"dira"> {
   let allowedClauses = [
     VersionedClause<TDLC_ClauseA>,
     VersionedClause<TDLC_ClauseB>
   ];
   let isDefault = 1;
 }
 
-// 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:  /// 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:  } // 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-EMPTY:
-// IMPL-NEXT:  using namespace llvm;
-// IMPL-NEXT:  using namespace tdl;
-// IMPL-EMPTY:
-// IMPL-NEXT:  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:  }
-// 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;
-// IMPL-NEXT:          case TDLC_clauseb:
-// IMPL-NEXT:            return 1 <= Version && 2147483647 >= Version;
-// IMPL-NEXT:          default:
-// IMPL-NEXT:            return false;
-// IMPL-NEXT:        }
-// IMPL-NEXT:        break;
-// IMPL-NEXT:    }
-// IMPL-NEXT:    llvm_unreachable("Invalid Tdl Directive kind");
-// IMPL-NEXT:  }
+// CHECK: // Generated by llvm-tblgen. Do not edit.
+// CHECK-EMPTY: 
+// CHECK-NEXT: #ifdef DIRECTIVE
+// CHECK-NEXT: DIRECTIVE(dira, "dira")
+// CHECK-NEXT: #endif
+// CHECK-EMPTY: 
+// CHECK-NEXT: #ifdef DIRECTIVE_SIZE
+// CHECK-NEXT: DIRECTIVE_SIZE(1)
+// CHECK-NEXT: #endif
+// CHECK-EMPTY: 
+// CHECK-NEXT: #ifdef CLAUSE
+// CHECK-NEXT: CLAUSE(clausea)
+// CHECK-NEXT: CLAUSE(clauseb)
+// CHECK-NEXT: #endif
+// CHECK-EMPTY: 
+// CHECK-NEXT: #ifdef CLAUSE_SIZE
+// CHECK-NEXT: CLAUSE_SIZE(2)
+// CHECK-NEXT: #endif
+// CHECK-EMPTY: 
+// CHECK-NEXT: #ifdef GET_IS_ALLOWED_CLAUSE_FOR_DIRECTIVE_IMPL
+// CHECK-NEXT: bool llvm::tdl::isAllowedClauseForDirective(Directive D, Clause C, unsigned Version) {
+// CHECK-NEXT:   assert(unsigned(D) <= llvm::tdl::Directive_enumSize);
+// CHECK-NEXT:   assert(unsigned(C) <= llvm::tdl::Clause_enumSize);
+// CHECK-NEXT:   switch (D) {
+// CHECK-NEXT:     case TDLD_dira:
+// CHECK-NEXT:       switch (C) {
+// CHECK-NEXT:         case TDLC_clausea:
+// CHECK-NEXT:           return 1 <= Version && 2147483647 >= Version;
+// CHECK-NEXT:         case TDLC_clauseb:
+// CHECK-NEXT:           return 1 <= Version && 2147483647 >= Version;
+// CHECK-NEXT:         default:
+// CHECK-NEXT:           return false;
+// CHECK-NEXT:       }
+// CHECK-NEXT:       break;
+// CHECK-NEXT:   }
+// CHECK-NEXT:   llvm_unreachable("Invalid Tdl Directive kind");
+// CHECK-NEXT: }
+// CHECK-NEXT: #endif

llvm/test/TableGen/directive2.td

-// RUN: llvm-tblgen -gen-directive-decl -I %p/../../include %s | FileCheck -match-full-lines %s
-// RUN: llvm-tblgen -gen-directive-impl -I %p/../../include %s | FileCheck -match-full-lines %s -check-prefix=IMPL
+// RUN: llvm-tblgen -gen-directive -I %p/../../include %s | FileCheck -match-full-lines %s
 
 include "llvm/Frontend/Directive/DirectiveBase.td"
 
 def TestDirectiveLanguage : DirectiveLanguage {
   let name = "Tdl";
 
   let cppNamespace = "tdl";
   let directivePrefix = "TDLD_";
   let clausePrefix = "TDLC_";
-  let includeHeader = "tdl.h.inc";
 }
 
 def TDLC_ClauseA : Clause<"clausea"> {
   let isImplicit = 1;
 }
 def TDLC_ClauseB : Clause<"clauseb"> {
   let isDefault = 1;
 }
 
 def TDL_DirA : Directive<"dira"> {
   let allowedClauses = [
     VersionedClause<TDLC_ClauseA, 2, 4>,
     VersionedClause<TDLC_ClauseB, 2>
   ];
   let isDefault = 1;
 }
 
-// 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:  /// 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:  } // namespace tdl
-// CHECK-NEXT:  } // namespace llvm
-// CHECK-NEXT:  #endif // LLVM_Tdl_INC
-
-// IMPL:       #include "tdl.h.inc"
-// IMPL-EMPTY:
-// IMPL-NEXT:  #include "llvm/ADT/StringRef.h"
-// IMPL-NEXT:  #include "llvm/ADT/StringSwitch.h"
-// IMPL-EMPTY:
-// IMPL-NEXT:  using namespace llvm;
-// IMPL-NEXT:  using namespace tdl;
-// IMPL-EMPTY:
-// 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:  }
-// 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 2 <= Version && 4 >= Version;
-// IMPL-NEXT:          case TDLC_clauseb:
-// IMPL-NEXT:            return 2 <= Version && 2147483647 >= Version;
-// IMPL-NEXT:          default:
-// IMPL-NEXT:            return false;
-// IMPL-NEXT:        }
-// IMPL-NEXT:        break;
-// IMPL-NEXT:    }
-// IMPL-NEXT:    llvm_unreachable("Invalid Tdl Directive kind");
-// IMPL-NEXT:  }
+// CHECK: // Generated by llvm-tblgen. Do not edit.
+// CHECK-EMPTY: 
+// CHECK-NEXT: #ifdef DIRECTIVE
+// CHECK-NEXT: DIRECTIVE(dira, "dira")
+// CHECK-NEXT: #endif
+// CHECK-EMPTY: 
+// CHECK-NEXT: #ifdef DIRECTIVE_SIZE
+// CHECK-NEXT: DIRECTIVE_SIZE(1)
+// CHECK-NEXT: #endif
+// CHECK-EMPTY: 
+// CHECK-NEXT: #ifdef CLAUSE
+// CHECK-NEXT: CLAUSE(clausea)
+// CHECK-NEXT: CLAUSE(clauseb)
+// CHECK-NEXT: #endif
+// CHECK-EMPTY: 
+// CHECK-NEXT: #ifdef CLAUSE_SIZE
+// CHECK-NEXT: CLAUSE_SIZE(2)
+// CHECK-NEXT: #endif
+// CHECK-EMPTY: 
+// CHECK-NEXT: #ifdef GET_IS_ALLOWED_CLAUSE_FOR_DIRECTIVE_IMPL
+// CHECK-NEXT: bool llvm::tdl::isAllowedClauseForDirective(Directive D, Clause C, unsigned Version) {
+// CHECK-NEXT:   assert(unsigned(D) <= llvm::tdl::Directive_enumSize);
+// CHECK-NEXT:   assert(unsigned(C) <= llvm::tdl::Clause_enumSize);
+// CHECK-NEXT:   switch (D) {
+// CHECK-NEXT:     case TDLD_dira:
+// CHECK-NEXT:       switch (C) {
+// CHECK-NEXT:         case TDLC_clausea:
+// CHECK-NEXT:           return 2 <= Version && 4 >= Version;
+// CHECK-NEXT:         case TDLC_clauseb:
+// CHECK-NEXT:           return 2 <= Version && 2147483647 >= Version;
+// CHECK-NEXT:         default:
+// CHECK-NEXT:           return false;
+// CHECK-NEXT:       }
+// CHECK-NEXT:       break;
+// CHECK-NEXT:   }
+// CHECK-NEXT:   llvm_unreachable("Invalid Tdl Directive kind");
+// CHECK-NEXT: }
+// CHECK-NEXT: #endif

llvm/utils/TableGen/DirectiveEmitter.cpp

 // Get Directive or Clause name formatted by replacing whitespaces with
 // underscores.
 std::string getFormattedName(StringRef Name) {
   std::string N = Name.str();
   std::replace(N.begin(), N.end(), ' ', '_');
   return N;
 }
 
-// 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");
-    OS << "  " << Prefix << getFormattedName(Name) << ",\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 FormattedName = getFormattedName(R->getValueAsString("name"));
-      OS << "constexpr auto " << Prefix << FormattedName << " = "
-         << "llvm::" << CppNamespace << "::" << Enum << "::" << Prefix
-         << FormattedName << ";\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 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";
-
-  if (EnableBitmaskEnumInNamespace)
-    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 << "\nLLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();\n";
-
-  // Emit Directive enumeration
-  const auto &Directives = Records.getAllDerivedDefinitions("Directive");
-  GenerateEnumClass(Directives, OS, "Directive", DirectivePrefix, CppNamespace,
-                    MakeEnumAvailableInNamespace);
-
-  // Emit Clause enumeration
-  const auto &Clauses = Records.getAllDerivedDefinitions("Clause");
-  GenerateEnumClass(Clauses, OS, "Clause", ClausePrefix, CppNamespace,
-                    MakeEnumAvailableInNamespace);
-
-  // 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";
-  OS << "/// Return true if \\p C is a valid clause for \\p D in version \\p "
-     << "Version.\n";
-  OS << "bool isAllowedClauseForDirective(Directive D, "
-     << "Clause C, unsigned Version);\n";
-  OS << "\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 << getFormattedName(Name) << ":\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;
-  }
-
-  const auto FormattedDefaultName =
-      getFormattedName((*DefaultIt)->getValueAsString("name"));
-
-  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");
-    if (ImplicitAsUnknown && R->getValueAsBit("isImplicit")) {
-      OS << "    .Case(\"" << Name << "\"," << Prefix << FormattedDefaultName
-         << ")\n";
-    } else {
-      OS << "    .Case(\"" << Name << "\"," << Prefix << getFormattedName(Name)
-         << ")\n";
-    }
-  }
-  OS << "    .Default(" << Prefix << FormattedDefaultName << ");\n";
-  OS << "}\n";
-}
-
 void GenerateCaseForVersionedClauses(const std::vector<Record *> &Clauses,
                                      raw_ostream &OS, StringRef DirectiveName,
                                      StringRef DirectivePrefix,
                                      StringRef ClausePrefix) {
   for (const auto &C : Clauses) {
     const auto MinVersion = C->getValueAsInt("minVersion");
     const auto MaxVersion = C->getValueAsInt("maxVersion");
     const auto SpecificClause = C->getValueAsDef("clause");
     const auto ClauseName = SpecificClause->getValueAsString("name");
     OS << "        case " << ClausePrefix << getFormattedName(ClauseName)
        << ":\n";
     OS << "          return " << MinVersion << " <= Version && " << MaxVersion
        << " >= Version;\n";
   }
 }
 
 // Generate the isAllowedClauseForDirective function implementation.
 void GenerateIsAllowedClause(const std::vector<Record *> &Directives,
                              raw_ostream &OS, StringRef LanguageName,
                              StringRef DirectivePrefix, StringRef ClausePrefix,
                              StringRef CppNamespace) {
-  OS << "\n";
   OS << "bool llvm::" << CppNamespace << "::isAllowedClauseForDirective("
      << "Directive D, Clause C, unsigned Version) {\n";
   OS << "  assert(unsigned(D) <= llvm::" << CppNamespace
      << "::Directive_enumSize);\n";
   OS << "  assert(unsigned(C) <= llvm::" << CppNamespace
      << "::Clause_enumSize);\n";
 
   OS << "  switch (D) {\n";
void GenerateIsAllowedClause(const std::vector<Record *> &Directives,
   }
 
   OS << "  }\n"; // End of directives switch
   OS << "  llvm_unreachable(\"Invalid " << LanguageName
      << " Directive kind\");\n";
   OS << "}\n"; // End of function isAllowedClauseForDirective
 }
 
-// Generate the implemenation section for the enumeration in the directive
+// Generate the declaration section for the enumeration in the directive
 // language
-void EmitDirectivesImpl(RecordKeeper &Records, raw_ostream &OS) {
-
+void EmitDirectives(RecordKeeper &Records, raw_ostream &OS) {
   const auto &DirectiveLanguages =
       Records.getAllDerivedDefinitions("DirectiveLanguage");
 
   if (DirectiveLanguages.size() != 1) {
     PrintError("A single definition of DirectiveLanguage is needed.");
     return;
   }
 
+  OS << "// Generated by llvm-tblgen. Do not edit.\n";
+
+  // Emit Directive enumeration
+  const auto &Directives = Records.getAllDerivedDefinitions("Directive");
+  OS << "\n#ifdef DIRECTIVE\n";
+  for (const auto &D : Directives) {
+    const auto& Name = D->getValueAsString("name");
+    OS << "DIRECTIVE(" << getFormattedName(Name) << ", \"" << Name
+       << "\")\n";
+  }
+  OS << "#endif\n";
+  OS << "\n#ifdef DIRECTIVE_SIZE\n";
+  OS << "DIRECTIVE_SIZE(" << Directives.size() << ")\n";
+  OS << "#endif\n";
+
+  // Emit Clause enumeration
+  const auto &Clauses = Records.getAllDerivedDefinitions("Clause");
+  OS << "\n#ifdef CLAUSE\n";
+  for (const auto &C : Clauses) {
+    const auto& Name = C->getValueAsString("name");
+    OS << "CLAUSE(" << Name << ")\n";
+  }
+  OS << "#endif\n";
+  OS << "\n#ifdef CLAUSE_SIZE\n";
+  OS << "CLAUSE_SIZE(" << Clauses.size() << ")\n";
+  OS << "#endif\n";
+
   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");
-  StringRef IncludeHeader =
-      DirectiveLanguage->getValueAsString("includeHeader");
-
-  const auto &Directives = Records.getAllDerivedDefinitions("Directive");
-  const auto &Clauses = Records.getAllDerivedDefinitions("Clause");
-
-  if (!IncludeHeader.empty())
-    OS << "#include \"" << IncludeHeader << "\"\n\n";
-
-  OS << "#include \"llvm/ADT/StringRef.h\"\n";
-  OS << "#include \"llvm/ADT/StringSwitch.h\"\n";
-  OS << "\n";
-  OS << "using namespace llvm;\n";
-  llvm::SmallVector<StringRef, 2> Namespaces;
-  llvm::SplitString(CppNamespace, Namespaces, "::");
-  for (auto Ns : Namespaces)
-    OS << "using namespace " << Ns << ";\n";
-
-  // 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);
-
+  OS << "\n#ifdef GET_IS_ALLOWED_CLAUSE_FOR_DIRECTIVE_IMPL\n";
   GenerateIsAllowedClause(Directives, OS, LanguageName, DirectivePrefix,
                           ClausePrefix, CppNamespace);
+  OS << "#endif\n";
 }
 
 } // namespace llvm

llvm/utils/TableGen/TableGen.cpp

enum ActionType {
   GenSearchableTables,
   GenGlobalISel,
   GenGICombiner,
   GenX86EVEX2VEXTables,
   GenX86FoldTables,
   GenRegisterBank,
   GenExegesis,
   GenAutomata,
-  GenDirectivesEnumDecl,
-  GenDirectivesEnumImpl,
+  GenDirectives,
 };
 
 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(GenDirectivesEnumDecl, "gen-directive-decl",
-                   "Generate directive related declaration code"),
-        clEnumValN(GenDirectivesEnumImpl, "gen-directive-impl",
-                   "Generate directive related implementation code")));
+        clEnumValN(GenDirectives, "gen-directive",
+                   "Generate directive related 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 GenDirectivesEnumDecl:
-    EmitDirectivesDecl(Records, OS);
-    break;
-  case GenDirectivesEnumImpl:
-    EmitDirectivesImpl(Records, OS);
+  case GenDirectives:
+    EmitDirectives(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 EmitDirectivesDecl(RecordKeeper &RK, raw_ostream &OS);
-void EmitDirectivesImpl(RecordKeeper &RK, raw_ostream &OS);
+void EmitDirectives(RecordKeeper &RK, raw_ostream &OS);
 
 } // End llvm namespace
 
 #endif

llvm/utils/gn/secondary/llvm/include/llvm/Frontend/OpenMP/BUILD.gn

 import("//llvm/utils/TableGen/tablegen.gni")
 
 tablegen("OMP") {
   visibility = [ ":public_tablegen" ]
-  args = [ "-gen-directive-decl" ]
-  output_name = "OMP.h.inc"
+  args = [ "-gen-directive" ]
 }
 
 # Groups all tablegen() calls that create .inc files that are included in
 # Frontent/OpenMP's public headers (just one so far).
 # //llvm/lib/Frontend/OpenMP has this as a public_dep, so targets depending on
 # //llvm/lib/Frontend/OpenMP don't need to depend on this.
 group("public_tablegen") {
   public_deps = [
-    # Frontend/OpenMP's public headers include OMP.h.inc.
+    # Frontend/OpenMP's public headers include OMP.inc.
     ":OMP",
   ]
 }

llvm/utils/gn/secondary/llvm/lib/Frontend/OpenMP/BUILD.gn

-import("//llvm/utils/TableGen/tablegen.gni")
-
-tablegen("OMPImpl") {
-  visibility = [ ":OpenMP" ]
-  args = [ "-gen-directive-impl" ]
-  td_file = "//llvm/include/llvm/Frontend/OpenMP/OMP.td"
-  output_name = "OMP.cpp"
-}
-
 static_library("OpenMP") {
   output_name = "LLVMFrontendOpenMP"
   deps = [
-    ":OMPImpl",
     "//llvm/lib/IR",
     "//llvm/lib/Support",
     "//llvm/lib/Transforms/Utils",
   ]
   public_deps = [ "//llvm/include/llvm/Frontend/OpenMP:public_tablegen" ]
   sources = [
+    "OMP.cpp",
     "OMPContext.cpp",
     "OMPIRBuilder.cpp",
-  ] + get_target_outputs(":OMPImpl")
+  ]
 }