[openacc][openmp] Reduce number of generated file and prefer inclusion of .inc

[clementval]

Summary

Follow up from D92955 and D83636. This patch makes the base cpp files
OMP.cpp and ACC.cpp normal files and they now include the XXX.inc file
generated by tablegen. This reduces the number of file generated by the
DirectiveEmitter backend and makes it closer to the proposal in D83636.

[clementval]

Ping

[clementval]

Ping

[clementval]

@thakis If it still makes sense to make the directive TableGen backend closer to your initial proposal (D83636) please have a look. Otherwise I'll abandon this revision.
@jdoerfert

[Meinersbur]

Not generating a translation unit directly but including the generated part is great.

However, emitting everything into a single file and selecting using preprocessor directives doesn't seem what other tablegen targets are doing. E.g. for intrinsics there is IntrinsicImpl.inc, IntrinsicEnums.inc. Clang has Attrs.inc, AttrImpl.inc, AttrVisitor.inc, etc.

[clementval]

In D93560#2627056, @Meinersbur wrote:

However, emitting everything into a single file and selecting using preprocessor directives doesn't seem what other tablegen targets are doing. E.g. for intrinsics there is IntrinsicImpl.inc, IntrinsicEnums.inc. Clang has Attrs.inc, AttrImpl.inc, AttrVisitor.inc, etc.

This is what MLIR is doing with all its TableGen related code generation. Since we are generating lots of different code block, the number of files would probably explode.

[Meinersbur]

The reason why MLIR does not split declaration and implementation-generation might be that nobody yet wanted to invest the work to split them. While I would not request splitting tablegen-generated files into separate files, fusing feels like a step backwards. If only implementation details change, with a merged output everything that includes OMP.h must be recompiled as well. I don't see how a separation into declaration and implementation causes the number of files to explode.

[clementval]

In D93560#2629662, @Meinersbur wrote:

The reason why MLIR does not split declaration and implementation-generation might be that nobody yet wanted to invest the work to split them. While I would not request splitting tablegen-generated files into separate files, fusing feels like a step backwards. If only implementation details change, with a merged output everything that includes OMP.h must be recompiled as well. I don't see how a separation into declaration and implementation causes the number of files to explode.

We are not fusing header and implementation. We had initially 3 files and after comments from a previous patch it was recommended to reduce that to two files. So after this patch you will have one header file and the implementation with the different code block.

[Meinersbur]

OK, I found the header include is generated in CMakeLists.txt in include/llvm/Frontend. This patch removes the "-gen-directive-impl" target and integrates it into "-gen-directive-gen". IMHO "-gen-directive-impl" is the better name for for the implementation file, following the scheme set by "AttrImpl.inc" and "IntrinsicImpl.inc".

Sorry for me not noticing that there have been 3 tablegen targets per td.

[Meinersbur]

I'd prefer using the name "impl" for the implementation, but my LGTM does not depend on it.

llvm/utils/TableGen/TableGen.cpp

138

What does "part" refer to?

[clementval]

In D93560#2630347, @Meinersbur wrote:

I'd prefer using the name "impl" for the implementation, but my LGTM does not depend on it.

Thanks for the review.

I'm fine with changing the current name to impl. @kiranchandramohan What do you think about it?

llvm/utils/TableGen/TableGen.cpp

138

It refers to various code "part" needed in clang and flang and libFrontend. Not sure if we can be more precise here.

[Meinersbur]

llvm/utils/TableGen/TableGen.cpp

138

"part" seems to refer to -gen-directive-impl, as in "the other part of the implementation". Again, I suggest to keep the gen-directive-impl flag instead.

[clementval]

Rebase and address review comment

[thakis]

Great change, thanks for doing it!

Can we fold the .h.inc files into the .inc files too? I haven't seen .h.inc files elsewhere in the build.

[clementval]

In D93560#2644765, @thakis wrote:

Great change, thanks for doing it!

Can we fold the .h.inc files into the .inc files too? I haven't seen .h.inc files elsewhere in the build.

We can do it as well if necessary. MLIR has a lot of .h.inc.

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

 
 def OpenACC : DirectiveLanguage {
   let name = "OpenACC";
   let cppNamespace = "acc"; // final namespace will be llvm::acc
   let directivePrefix = "ACCD_";
   let clausePrefix = "ACCC_";
   let makeEnumAvailableInNamespace = true;
   let enableBitmaskEnumInNamespace = true;
-  let includeHeader = "llvm/Frontend/OpenACC/ACC.h.inc";
   let clauseEnumSetClass = "AccClauseSet";
   let flangClauseBaseClass = "AccClause";
 }
 
 //===----------------------------------------------------------------------===//
 // Definition of OpenACC clauses
 //===----------------------------------------------------------------------===//
 

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

 
 def OpenMP : DirectiveLanguage {
   let name = "OpenMP";
   let cppNamespace = "omp"; // final namespace will be llvm::omp
   let directivePrefix = "OMPD_";
   let clausePrefix = "OMPC_";
   let makeEnumAvailableInNamespace = true;
   let enableBitmaskEnumInNamespace = true;
-  let includeHeader = "llvm/Frontend/OpenMP/OMP.h.inc";
   let clauseEnumSetClass = "OmpClauseSet";
   let flangClauseBaseClass = "OmpClause";
 }
 
 //===----------------------------------------------------------------------===//
 // Definition of OpenMP clauses
 //===----------------------------------------------------------------------===//
 

llvm/include/llvm/TableGen/DirectiveEmitter.h

public:
   StringRef getDirectivePrefix() const {
     return Def->getValueAsString("directivePrefix");
   }
 
   StringRef getClausePrefix() const {
     return Def->getValueAsString("clausePrefix");
   }
 
-  StringRef getIncludeHeader() const {
-    return Def->getValueAsString("includeHeader");
-  }
-
   StringRef getClauseEnumSetClass() const {
     return Def->getValueAsString("clauseEnumSetClass");
   }
 
   StringRef getFlangClauseBaseClass() const {
     return Def->getValueAsString("flangClauseBaseClass");
   }
 

llvm/lib/Frontend/OpenACC/ACC.cpp

+//===- ACC.cpp ------ Collection of helpers for OpenACC -------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Frontend/OpenACC/ACC.h.inc"
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/StringSwitch.h"
+#include "llvm/Support/ErrorHandling.h"
+
+using namespace llvm;
+using namespace acc;
+
+#define GEN_DIRECTIVES_IMPL
+#include "llvm/Frontend/OpenACC/ACC.inc"

llvm/lib/Frontend/OpenACC/CMakeLists.txt

-set(LLVM_TARGET_DEFINITIONS ${LLVM_MAIN_INCLUDE_DIR}/llvm/Frontend/OpenACC/ACC.td)
-tablegen(LLVM ACC.cpp --gen-directive-impl)
-add_public_tablegen_target(acc_cpp)
-
 add_llvm_component_library(LLVMFrontendOpenACC
-  ACC.cpp # Generated by tablegen above
+  ACC.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/Frontend
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/Frontend/OpenACC
 
   DEPENDS
   acc_gen
-  acc_cpp
 )
 
 target_link_libraries(LLVMFrontendOpenACC LLVMSupport)
 

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
 
   LINK_COMPONENTS
   Core
   Support
   TransformUtils
   )

llvm/lib/Frontend/OpenMP/OMP.cpp

+//===- OMP.cpp ------ Collection of helpers for OpenMP --------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Frontend/OpenMP/OMP.h.inc"
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/StringSwitch.h"
+#include "llvm/Support/ErrorHandling.h"
+
+using namespace llvm;
+using namespace omp;
+
+#define GEN_DIRECTIVES_IMPL
+#include "llvm/Frontend/OpenMP/OMP.inc"

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-gen -I %p/../../include %s | FileCheck -match-full-lines %s -check-prefix=GEN
 
 include "llvm/Frontend/Directive/DirectiveBase.td"
 
 def TestDirectiveLanguage : DirectiveLanguage {
   let name = "Tdl";
 
   let cppNamespace = "tdl";

 // CHECK-EMPTY:
 // CHECK-NEXT:  AKind getAKind(StringRef);
 // 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:  #include "llvm/Support/ErrorHandling.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:  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:  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:  }
-// IMPL-EMPTY:
-
-
-
 // GEN:       #ifdef GEN_FLANG_DIRECTIVE_CLAUSE_SETS
 // GEN-NEXT:  #undef GEN_FLANG_DIRECTIVE_CLAUSE_SETS
 // GEN-EMPTY:
 // GEN-NEXT:  namespace llvm {
 // GEN-NEXT:  namespace tdl {
 // GEN-EMPTY:
 // GEN-NEXT:    // Sets for dira
 // GEN-EMPTY:

 // GEN-NEXT:  #undef GEN_FLANG_CLAUSE_UNPARSE
 // GEN-EMPTY:
 // GEN-NEXT:  void Unparse(const TdlClause::Clauseb &x) {
 // GEN-NEXT:    Word("CLAUSEB");
 // GEN-NEXT:    Walk("(", x.v, ")");
 // GEN-NEXT:  }
 // GEN-EMPTY:
 // GEN-NEXT:  #endif // GEN_FLANG_CLAUSE_UNPARSE
+
+// GEN:       #ifdef GEN_DIRECTIVES_IMPL
+// GEN-NEXT:  #undef GEN_DIRECTIVES_IMPL
+// GEN-EMPTY:
+// GEN-NEXT:  Directive llvm::tdl::getTdlDirectiveKind(llvm::StringRef Str) {
+// GEN-NEXT:    return llvm::StringSwitch<Directive>(Str)
+// GEN-NEXT:      .Case("dira",TDLD_dira)
+// GEN-NEXT:      .Default(TDLD_dira);
+// GEN-NEXT:  }
+// GEN-EMPTY:
+// GEN-NEXT:  llvm::StringRef llvm::tdl::getTdlDirectiveName(Directive Kind) {
+// GEN-NEXT:    switch (Kind) {
+// GEN-NEXT:      case TDLD_dira:
+// GEN-NEXT:        return "dira";
+// GEN-NEXT:    }
+// GEN-NEXT:    llvm_unreachable("Invalid Tdl Directive kind");
+// GEN-NEXT:  }
+// GEN-EMPTY:
+// GEN-NEXT:  Clause llvm::tdl::getTdlClauseKind(llvm::StringRef Str) {
+// GEN-NEXT:    return llvm::StringSwitch<Clause>(Str)
+// GEN-NEXT:      .Case("clausea",TDLC_clausea)
+// GEN-NEXT:      .Case("clauseb",TDLC_clauseb)
+// GEN-NEXT:      .Default(TDLC_clauseb);
+// GEN-NEXT:  }
+// GEN-EMPTY:
+// GEN-NEXT:  llvm::StringRef llvm::tdl::getTdlClauseName(Clause Kind) {
+// GEN-NEXT:    switch (Kind) {
+// GEN-NEXT:      case TDLC_clausea:
+// GEN-NEXT:        return "clausea";
+// GEN-NEXT:      case TDLC_clauseb:
+// GEN-NEXT:        return "clauseb";
+// GEN-NEXT:    }
+// GEN-NEXT:    llvm_unreachable("Invalid Tdl Clause kind");
+// GEN-NEXT:  }
+// GEN-EMPTY:
+// GEN-NEXT:  AKind llvm::tdl::getAKind(llvm::StringRef Str) {
+// GEN-NEXT:    return llvm::StringSwitch<AKind>(Str)
+// GEN-NEXT:      .Case("vala",TDLCV_vala)
+// GEN-NEXT:      .Case("valb",TDLCV_valb)
+// GEN-NEXT:      .Case("valc",TDLCV_valc)
+// GEN-NEXT:      .Default(TDLCV_valc);
+// GEN-NEXT:  }
+// GEN-EMPTY:
+// GEN-NEXT:  bool llvm::tdl::isAllowedClauseForDirective(Directive D, Clause C, unsigned Version) {
+// GEN-NEXT:    assert(unsigned(D) <= llvm::tdl::Directive_enumSize);
+// GEN-NEXT:    assert(unsigned(C) <= llvm::tdl::Clause_enumSize);
+// GEN-NEXT:    switch (D) {
+// GEN-NEXT:      case TDLD_dira:
+// GEN-NEXT:        switch (C) {
+// GEN-NEXT:          case TDLC_clausea:
+// GEN-NEXT:            return 1 <= Version && 2147483647 >= Version;
+// GEN-NEXT:          case TDLC_clauseb:
+// GEN-NEXT:            return 1 <= Version && 2147483647 >= Version;
+// GEN-NEXT:          default:
+// GEN-NEXT:            return false;
+// GEN-NEXT:        }
+// GEN-NEXT:        break;
+// GEN-NEXT:    }
+// GEN-NEXT:    llvm_unreachable("Invalid Tdl Directive kind");
+// GEN-NEXT:  }
+// GEN-EMPTY:
+// GEN-NEXT:  #endif // GEN_DIRECTIVES_IMPL
 No newline at end of file

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-gen -I %p/../../include %s | FileCheck -match-full-lines %s -check-prefix=GEN
 
 include "llvm/Frontend/Directive/DirectiveBase.td"
 
 def TestDirectiveLanguage : DirectiveLanguage {
   let name = "Tdl";
 
   let cppNamespace = "tdl";

 // 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-NEXT:  #include "llvm/Support/ErrorHandling.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_clauseb)
-// IMPL-NEXT:      .Case("clauseb",TDLC_clauseb)
-// IMPL-NEXT:      .Case("clausec",TDLC_clausec)
-// IMPL-NEXT:      .Case("claused",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:      case TDLC_clausec:
-// IMPL-NEXT:        return "clausec";
-// IMPL-NEXT:      case TDLC_claused:
-// IMPL-NEXT:        return "claused";
-// 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:  }
-
-
 // GEN:      #ifdef GEN_FLANG_DIRECTIVE_CLAUSE_SETS
 // GEN-NEXT: #undef GEN_FLANG_DIRECTIVE_CLAUSE_SETS
 // GEN-EMPTY:
 // GEN-NEXT: namespace llvm {
 // GEN-NEXT: namespace tdl {
 // GEN-EMPTY:
 // GEN-NEXT:   // Sets for dira
 // GEN-EMPTY:

 // GEN-NEXT:  #undef __IMPLICIT_CLAUSE_CLASS
 // GEN-NEXT:  #undef __CLAUSE
 // GEN-NEXT:  #undef CLAUSE_NO_CLASS
 // GEN-NEXT:  #undef CLAUSE_CLASS
 // GEN-NEXT:  #undef CLAUSE
 // GEN-EMPTY:
 // GEN-NEXT:  #endif // GEN_CLANG_CLAUSE_CLASS
 
+
+// GEN:       #ifdef GEN_DIRECTIVES_IMPL
+// GEN-NEXT:  #undef GEN_DIRECTIVES_IMPL
+// GEN-EMPTY:
+// GEN-NEXT:  Directive llvm::tdl::getTdlDirectiveKind(llvm::StringRef Str) {
+// GEN-NEXT:    return llvm::StringSwitch<Directive>(Str)
+// GEN-NEXT:      .Case("dira",TDLD_dira)
+// GEN-NEXT:      .Default(TDLD_dira);
+// GEN-NEXT:  }
+// GEN-EMPTY:
+// GEN-NEXT:  llvm::StringRef llvm::tdl::getTdlDirectiveName(Directive Kind) {
+// GEN-NEXT:    switch (Kind) {
+// GEN-NEXT:      case TDLD_dira:
+// GEN-NEXT:        return "dira";
+// GEN-NEXT:    }
+// GEN-NEXT:    llvm_unreachable("Invalid Tdl Directive kind");
+// GEN-NEXT:  }
+// GEN-EMPTY:
+// GEN-NEXT:  Clause llvm::tdl::getTdlClauseKind(llvm::StringRef Str) {
+// GEN-NEXT:    return llvm::StringSwitch<Clause>(Str)
+// GEN-NEXT:      .Case("clausea",TDLC_clauseb)
+// GEN-NEXT:      .Case("clauseb",TDLC_clauseb)
+// GEN-NEXT:      .Case("clausec",TDLC_clausec)
+// GEN-NEXT:      .Case("claused",TDLC_clauseb)
+// GEN-NEXT:      .Default(TDLC_clauseb);
+// GEN-NEXT:  }
+// GEN-EMPTY:
+// GEN-NEXT:  llvm::StringRef llvm::tdl::getTdlClauseName(Clause Kind) {
+// GEN-NEXT:    switch (Kind) {
+// GEN-NEXT:      case TDLC_clausea:
+// GEN-NEXT:        return "clausea";
+// GEN-NEXT:      case TDLC_clauseb:
+// GEN-NEXT:        return "clauseb";
+// GEN-NEXT:      case TDLC_clausec:
+// GEN-NEXT:        return "clausec";
+// GEN-NEXT:      case TDLC_claused:
+// GEN-NEXT:        return "claused";
+// GEN-NEXT:    }
+// GEN-NEXT:    llvm_unreachable("Invalid Tdl Clause kind");
+// GEN-NEXT:  }
+// GEN-EMPTY:
+// GEN-NEXT:  bool llvm::tdl::isAllowedClauseForDirective(Directive D, Clause C, unsigned Version) {
+// GEN-NEXT:    assert(unsigned(D) <= llvm::tdl::Directive_enumSize);
+// GEN-NEXT:    assert(unsigned(C) <= llvm::tdl::Clause_enumSize);
+// GEN-NEXT:    switch (D) {
+// GEN-NEXT:      case TDLD_dira:
+// GEN-NEXT:        switch (C) {
+// GEN-NEXT:          case TDLC_clausea:
+// GEN-NEXT:            return 2 <= Version && 4 >= Version;
+// GEN-NEXT:          case TDLC_clauseb:
+// GEN-NEXT:            return 2 <= Version && 2147483647 >= Version;
+// GEN-NEXT:          default:
+// GEN-NEXT:            return false;
+// GEN-NEXT:        }
+// GEN-NEXT:        break;
+// GEN-NEXT:    }
+// GEN-NEXT:    llvm_unreachable("Invalid Tdl Directive kind");
+// GEN-NEXT:  }
+// GEN-EMPTY:
+// GEN-NEXT:  #endif // GEN_DIRECTIVES_IMPL

llvm/test/TableGen/directive3.td

 // RUN: not llvm-tblgen -gen-directive-decl -I %p/../../include %s 2>&1 | FileCheck -match-full-lines %s
-// RUN: not llvm-tblgen -gen-directive-impl -I %p/../../include %s 2>&1 | FileCheck -match-full-lines %s
 // RUN: not llvm-tblgen -gen-directive-gen -I %p/../../include %s 2>&1 | FileCheck -match-full-lines %s
 
 include "llvm/Frontend/Directive/DirectiveBase.td"
 
 def TestDirectiveLanguage : DirectiveLanguage {
   let name = "TdlError";
 }
 

llvm/utils/TableGen/DirectiveEmitter.cpp

void GenerateClauseClassMacro(const DirectiveLanguage &DirLang,
   OS << "#undef __IMPLICIT_CLAUSE_NO_CLASS\n";
   OS << "#undef __IMPLICIT_CLAUSE_CLASS\n";
   OS << "#undef __CLAUSE\n";
   OS << "#undef CLAUSE_NO_CLASS\n";
   OS << "#undef CLAUSE_CLASS\n";
   OS << "#undef CLAUSE\n";
 }
 
-// Generate the implemenation section for the enumeration in the directive
-// language.
-void EmitDirectivesGen(RecordKeeper &Records, raw_ostream &OS) {
-  const auto DirLang = DirectiveLanguage{Records};
-  if (DirLang.HasValidityErrors())
-    return;
-
-  EmitDirectivesFlangImpl(DirLang, OS);
-
-  GenerateClauseClassMacro(DirLang, OS);
-}
-
 // Generate the implemenation for the enumeration in the directive
 // language. This code can be included in library.
-void EmitDirectivesImpl(RecordKeeper &Records, raw_ostream &OS) {
-  const auto DirLang = DirectiveLanguage{Records};
-  if (DirLang.HasValidityErrors())
-    return;
-
-  if (!DirLang.getIncludeHeader().empty())
-    OS << "#include \"" << DirLang.getIncludeHeader() << "\"\n\n";
+void EmitDirectivesImpl(const DirectiveLanguage &DirLang, raw_ostream &OS) {
+  IfDefScope Scope("GEN_DIRECTIVES_IMPL", OS);
 
-  OS << "#include \"llvm/ADT/StringRef.h\"\n";
-  OS << "#include \"llvm/ADT/StringSwitch.h\"\n";
-  OS << "#include \"llvm/Support/ErrorHandling.h\"\n";
   OS << "\n";
-  OS << "using namespace llvm;\n";
-  llvm::SmallVector<StringRef, 2> Namespaces;
-  llvm::SplitString(DirLang.getCppNamespace(), Namespaces, "::");
-  for (auto Ns : Namespaces)
-    OS << "using namespace " << Ns << ";\n";
 
   // getDirectiveKind(StringRef Str)
   GenerateGetKind(DirLang.getDirectives(), OS, "Directive", DirLang,
                   DirLang.getDirectivePrefix(), /*ImplicitAsUnknown=*/false);
 
   // getDirectiveName(Directive Kind)
   GenerateGetName(DirLang.getDirectives(), OS, "Directive", DirLang,
                   DirLang.getDirectivePrefix());
void EmitDirectivesImpl(const DirectiveLanguage &DirLang, raw_ostream &OS) {
 
   // get<ClauseVal>Kind(StringRef Str)
   GenerateGetKindClauseVal(DirLang, OS);
 
   // isAllowedClauseForDirective(Directive D, Clause C, unsigned Version)
   GenerateIsAllowedClause(DirLang, OS);
 }
 
+// Generate the implemenation section for the enumeration in the directive
+// language.
+void EmitDirectivesGen(RecordKeeper &Records, raw_ostream &OS) {
+  const auto DirLang = DirectiveLanguage{Records};
+  if (DirLang.HasValidityErrors())
+    return;
+
+  EmitDirectivesFlangImpl(DirLang, OS);
+
+  GenerateClauseClassMacro(DirLang, OS);
+
+  EmitDirectivesImpl(DirLang, OS);
+}
+
 } // namespace llvm

llvm/utils/TableGen/TableGen.cpp

enum ActionType {
   GenGlobalISel,
   GenGICombiner,
   GenX86EVEX2VEXTables,
   GenX86FoldTables,
   GenRegisterBank,
   GenExegesis,
   GenAutomata,
   GenDirectivesEnumDecl,
-  GenDirectivesEnumImpl,
   GenDirectivesEnumGen,
 };
 
 namespace llvm {
 cl::opt<bool> EmitLongStrLiterals(
     "long-string-literals",
     cl::desc("when emitting large string tables, prefer string literals over "
              "comma-separated char literals. This can be a readability and "
cl::values(
                    "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 (header file)"),
-        clEnumValN(GenDirectivesEnumImpl, "gen-directive-impl",
-                   "Generate directive related implementation code"),
         clEnumValN(GenDirectivesEnumGen, "gen-directive-gen",
                    "Generate directive related implementation code part")));
 
 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));
 
 bool LLVMTableGenMain(raw_ostream &OS, RecordKeeper &Records) {
   switch (Action) {
case GenExegesis:
     EmitExegesis(Records, OS);
     break;
   case GenAutomata:
     EmitAutomata(Records, OS);
     break;
   case GenDirectivesEnumDecl:
     EmitDirectivesDecl(Records, OS);
     break;
-  case GenDirectivesEnumImpl:
-    EmitDirectivesImpl(Records, OS);
-    break;
   case GenDirectivesEnumGen:
     EmitDirectivesGen(Records, OS);
     break;
   }
 
   return false;
 }
 }