[MLIR] Unique autogenerated file for tablegen passes

[mscuttari]

Summary

Being the generated code macro-guarded, the autogenerated .cpp.inc file has been merged into the .h.inc to reduce the build steps.

[mscuttari]

Fix formatting

[rriddle]

Nice work!

mlir/tools/mlir-tblgen/PassGen.cpp

444

[mscuttari]

Fix formatting

mlir/docs/PassManagement.md

def MyPass : Pass<"my-pass", "ModuleOp"> {
 
   // Specify any statistics.
   let statistics = [
     Statistic<"statistic", "example-statistic", "An example statistic">
   ];
 }
 ```
 
-Using the `gen-pass-decls` and `gen-pass-defs` generators, we can generate most
-of the boilerplate above automatically.
-
-The `gen-pass-decls` generator takes as an input a `-name` parameter, that
+Using the `gen-pass-decls` generator, we can generate most of the boilerplate
+above automatically. This generator takes as an input a `-name` parameter, that
 provides a tag for the group of passes that are being generated. This generator
-produces code with two purposes:
+produces code with multiple purposes:
 
 The first is to register the declared passes with the global registry. For
 each pass, the generator produces a `registerPassName` where
 `PassName` is the name of the definition specified in tablegen. It also
 generates a `registerGroupPasses`, where `Group` is the tag provided via the
 `-name` input parameter, that registers all of the passes present.
 
 ```c++

 
 std::unique_ptr<::mlir::Pass> createMyPass();
 std::unique_ptr<::mlir::Pass> createMyPass(const MyPassOptions &options);
 
 #undef GEN_PASS_DECL_MYPASS
 #endif // GEN_PASS_DECL_MYPASS
 ```
 
-The `gen-pass-defs` generator produces the definitions to be used for the pass
-implementation.
-
-It generates a base class for each of the passes, containing most of the boiler
-plate related to pass definitions. These classes are named in the form of
-`MyPassBase` and are declared inside the `impl` namespace, where `MyPass` is
-the name of the pass definition in tablegen. We can update the original C++
-pass definition as so:
+The last purpose of this generator is to emit a base class for each of the
+passes, containing most of the boiler plate related to pass definitions. These
+classes are named in the form of `MyPassBase` and are declared inside the
+`impl` namespace, where `MyPass` is the name of the pass definition in
+tablegen. We can update the original C++ pass definition as so:
 
 ```c++
 // MyPass.cpp
 
 /// Include the generated base pass class definitions.
 namespace foo {
 #define GEN_PASS_DEF_MYPASS
-#include "Passes.cpp.inc"
+#include "Passes.h.inc"
 }
 
 /// Define the main class as deriving from the generated base class.
 struct MyPass : foo::impl::MyPassBase<MyPass> {
   using MyPassBase::MyPassBase;
 
   /// The definitions of the options and statistics are now generated within
   /// the base class, but are accessible in the same way.
 };
 ```
 
-Similarly to the previous generator, the definitions can be enabled on a
-per-pass basis by defining the appropriate preprocessor `GEN_PASS_DEF_PASSNAME`
-macro, with `PASSNAME` equal to the uppercase version of the name of the pass
+Similarly to the previous cases, the definitions can be enabled on a per-pass
+basis by defining the appropriate preprocessor `GEN_PASS_DEF_PASSNAME` macro,
+with `PASSNAME` equal to the uppercase version of the name of the pass
 definition in tablegen.
 If the `constructor` field has not been specified in tablegen, then the default
 constructors are also defined and expect the name of the actual pass class to
 be equal to the name defined in tablegen.
 
 Using the `gen-pass-doc` generator, markdown documentation for each of the
 passes can be generated. See [Passes.md](Passes.md) for example output of real
 MLIR passes.

mlir/tools/mlir-tblgen/PassGen.cpp

 }
 
 /// Emit the code to be included in the public header of the pass.
 static void emitPassDecls(const Pass &pass, raw_ostream &os) {
   StringRef passName = pass.getDef()->getName();
   std::string enableVarName = "GEN_PASS_DECL_" + passName.upper();
 
   os << "#ifdef " << enableVarName << "\n";
-  os << llvm::formatv(passHeader, passName);
-
   emitPassOptionsStruct(pass, os);
 
   if (StringRef constructor = pass.getConstructor(); constructor.empty()) {
     // Default constructor declaration.
     os << "std::unique_ptr<::mlir::Pass> create" << passName << "();\n";
 
     // Declaration of the constructor with options.
     if (ArrayRef<PassOption> options = pass.getOptions(); !options.empty())
static void emitRegistrations(llvm::ArrayRef<Pass> passes, raw_ostream &os) {
   for (const Pass &pass : passes)
     os << "  register" << pass.getDef()->getName() << "();\n";
 
   os << "}\n";
   os << "#undef GEN_PASS_REGISTRATION\n";
   os << "#endif // GEN_PASS_REGISTRATION\n";
 }
 
-static void emitDecls(const llvm::RecordKeeper &recordKeeper, raw_ostream &os) {
-  std::vector<Pass> passes = getPasses(recordKeeper);
-  os << "/* Autogenerated by mlir-tblgen; don't manually edit */\n";
-
-  for (const Pass &pass : passes)
-    emitPassDecls(pass, os);
-
-  emitRegistrations(passes, os);
-
-  // TODO drop old pass declarations
-  // Emit the old code until all the passes have switched to the new design.
-  os << "#ifdef GEN_PASS_CLASSES\n";
-  for (const Pass &pass : passes)
-    emitOldPassDecl(pass, os);
-  os << "#undef GEN_PASS_CLASSES\n";
-  os << "#endif // GEN_PASS_CLASSES\n";
-}
-
 //===----------------------------------------------------------------------===//
 // GEN: Pass base class generation
 //===----------------------------------------------------------------------===//
 
 /// The code snippet used to generate the start of a pass base class.
 ///
 /// {0}: The def name of the pass record.
 /// {1}: The base class for the pass.

 /// Emit the code to be used in the implementation of the pass.
 static void emitPassDefs(const Pass &pass, raw_ostream &os) {
   StringRef passName = pass.getDef()->getName();
   std::string enableVarName = "GEN_PASS_DEF_" + passName.upper();
   bool emitDefaultConstructors = pass.getConstructor().empty();
   bool emitDefaultConstructorWithOptions = !pass.getOptions().empty();
 
   os << "#ifdef " << enableVarName << "\n";
-  os << llvm::formatv(passHeader, passName);
 
   if (emitDefaultConstructors) {
     os << llvm::formatv(friendDefaultConstructorDeclTemplate, passName);
 
     if (emitDefaultConstructorWithOptions)
       os << llvm::formatv(friendDefaultConstructorWithOptionsDeclTemplate,
                           passName);
   }
if (emitDefaultConstructors) {
     if (emitDefaultConstructorWithOptions)
       os << llvm::formatv(defaultConstructorWithOptionsDefTemplate, passName);
   }
 
   os << "#undef " << enableVarName << "\n";
   os << "#endif // " << enableVarName << "\n";
 }
 
-static void emitDefs(const llvm::RecordKeeper &recordKeeper, raw_ostream &os) {
-  std::vector<Pass> passes = getPasses(recordKeeper);
-  os << "/* Autogenerated by mlir-tblgen; don't manually edit */\n";
-
-  for (const Pass &pass : passes)
-    emitPassDefs(pass, os);
-}
-
 // TODO drop old pass declarations
 // The old pass base class is being kept until all the passes have switched to
 // the new decls/defs design.
 const char *const oldPassDeclBegin = R"(
 template <typename DerivedT>
 class {0}Base : public {1} {
 public:
   using Base = {0}Base;
static void emitOldPassDecl(const Pass &pass, raw_ostream &os) {
   os << llvm::formatv(oldPassDeclBegin, defName, pass.getBaseClass(),
                       pass.getArgument(), pass.getSummary(),
                       dependentDialectRegistrations);
   emitPassOptionDecls(pass, os);
   emitPassStatisticDecls(pass, os);
   os << "};\n";
 }
 
-static mlir::GenRegistration
-    genPassDecls("gen-pass-decls", "Generate pass declarations",
-                 [](const llvm::RecordKeeper &records, raw_ostream &os) {
-                   emitDecls(records, os);
-                   return false;
-                 });
+static void emitPass(const Pass &pass, raw_ostream &os) {
+  StringRef passName = pass.getDef()->getName();
+  os << llvm::formatv(passHeader, passName);
+
+  emitPassDecls(pass, os);
+  emitPassDefs(pass, os);
+}
+
+static void emitPasses(const llvm::RecordKeeper &recordKeeper,
+                       raw_ostream &os) {
+  std::vector<Pass> passes = getPasses(recordKeeper);
+  os << "/* Autogenerated by mlir-tblgen; don't manually edit */\n";
+
+  for (const Pass &pass : passes)
+    emitPass(pass, os);
+
+  emitRegistrations(passes, os);
+
+  // TODO: Drop old pass declarations.
+  // Emit the old code until all the passes have switched to the new design.
+  os << "#ifdef GEN_PASS_CLASSES\n";
+  for (const Pass &pass : passes)
+    emitOldPassDecl(pass, os);
+  os << "#undef GEN_PASS_CLASSES\n";
+  os << "#endif // GEN_PASS_CLASSES\n";
+}
 
 static mlir::GenRegistration
-    genPassDefs("gen-pass-defs", "Generate pass definitions",
+    genPassDecls("gen-pass-decls", "Generate pass declarations",
                  [](const llvm::RecordKeeper &records, raw_ostream &os) {
-                  emitDefs(records, os);
+                   emitPasses(records, os);
                    return false;
                  });

mlir/unittests/TableGen/CMakeLists.txt

 set(LLVM_TARGET_DEFINITIONS enums.td)
 mlir_tablegen(EnumsGenTest.h.inc -gen-enum-decls)
 mlir_tablegen(EnumsGenTest.cpp.inc -gen-enum-defs)
 add_public_tablegen_target(MLIRTableGenEnumsIncGen)
 
 set(LLVM_TARGET_DEFINITIONS passes.td)
 mlir_tablegen(PassGenTest.h.inc -gen-pass-decls -name TableGenTest)
-mlir_tablegen(PassGenTest.cpp.inc -gen-pass-defs -name TableGenTest)
 add_public_tablegen_target(MLIRTableGenTestPassIncGen)
 
 add_mlir_unittest(MLIRTableGenTests
   EnumsGenTest.cpp
   FormatTest.cpp
   OpBuildGen.cpp
   PassGenTest.cpp
 )

mlir/unittests/TableGen/PassGenTest.cpp

 #define GEN_PASS_DECL_TESTPASSWITHOPTIONS
 #define GEN_PASS_DECL_TESTPASSWITHCUSTOMCONSTRUCTOR
 #define GEN_PASS_REGISTRATION
 #include "PassGenTest.h.inc"
 
 #define GEN_PASS_DEF_TESTPASS
 #define GEN_PASS_DEF_TESTPASSWITHOPTIONS
 #define GEN_PASS_DEF_TESTPASSWITHCUSTOMCONSTRUCTOR
-#include "PassGenTest.cpp.inc"
+#include "PassGenTest.h.inc"
 
 struct TestPass : public impl::TestPassBase<TestPass> {
   using TestPassBase::TestPassBase;
 
   void runOnOperation() override {}
 
   std::unique_ptr<mlir::Pass> clone() const {
     return TestPassBase<TestPass>::clone();