[mlir][Pass] Add a tablegen backend for defining Pass information

[rriddle]

Summary

This will greatly simplify a number of things related to passes:

• Enables generation of pass registration
• Enables generation of boiler plate pass utilities
• Enables generation of pass documentation

This revision focuses on adding the basic structure and adds support for generating the registration for passes in the Transforms/ directory. Future revisions will add more support and move more passes over.

Depends On D76573

[jpienaar]

LG, thanks

mlir/lib/TableGen/Pass.cpp

2

Should this b TableGen (or ODS) pass related classes? Given it is not about Pass "IR side"

mlir/tools/mlir-tblgen/PassGen.cpp

32

I could have sworn I added a small helper class to automate this :)

[mehdi_amini]

mlir/include/mlir/TableGen/Pass.h

14

There is no vector use in this header?

[rriddle]

Rebase

mlir/include/mlir/CMakeLists.txt

 add_subdirectory(Dialect)
 add_subdirectory(IR)
 add_subdirectory(Interfaces)
+add_subdirectory(Transforms)

mlir/include/mlir/InitAllPasses.h

 #include "mlir/Dialect/LLVMIR/Transforms/LegalizeForExport.h"
 #include "mlir/Dialect/Linalg/Passes.h"
 #include "mlir/Dialect/LoopOps/Passes.h"
 #include "mlir/Dialect/Quant/Passes.h"
 #include "mlir/Dialect/SPIRV/Passes.h"
 #include "mlir/Quantizer/Transforms/Passes.h"
 #include "mlir/Transforms/LocationSnapshot.h"
 #include "mlir/Transforms/Passes.h"
+#include "mlir/Transforms/ViewOpGraph.h"
+#include "mlir/Transforms/ViewRegionGraph.h"
 
 #include <cstdlib>
 
 namespace mlir {
 
 // This function may be called to register the MLIR passes with the
 // global registry.
 // If you're building a compiler, you likely don't need this: you would build a
 // pipeline programmatically without the need to register with the global
 // registry, since it would already be calling the creation routine of the
 // individual passes.
 // The global registry is interesting to interact with the command-line tools.
 inline void registerAllPasses() {
+  // Init general passes
+#define GEN_PASS_REGISTRATION
+#include "mlir/Transforms/Passes.h.inc"
+
   // At the moment we still rely on global initializers for registering passes,
   // but we may not do it in the future.
   // We must reference the passes in such a way that compilers will not
   // delete it all as dead code, even with whole program optimization,
   // yet is effectively a NO-OP. As the compiler isn't smart enough
   // to know that getenv() never returns -1, this will do the job.
   if (std::getenv("bar") != (char *)-1)
     return;
 
-  // Init general passes
-  createCanonicalizerPass();
-  createCSEPass();
+  // Affine
   createSuperVectorizePass({});
   createLoopUnrollPass();
   createLoopUnrollAndJamPass();
   createSimplifyAffineStructuresPass();
-  createLoopFusionPass();
   createLoopInvariantCodeMotionPass();
   createAffineLoopInvariantCodeMotionPass();
-  createPipelineDataTransferPass();
   createLowerAffinePass();
   createLoopTilingPass(0);
-  createLoopCoalescingPass();
   createAffineDataCopyGenerationPass(0, 0);
   createMemRefDataFlowOptPass();
-  createStripDebugInfoPass();
-  createPrintOpStatsPass();
-  createInlinerPass();
-  createSymbolDCEPass();
-  createLocationSnapshotPass({});
 
   // AVX512
   createConvertAVX512ToLLVMPass();
 
   // GPUtoRODCLPass
   createLowerGpuOpsToROCDLOpsPass();
 
   // FxpOpsDialect passes

mlir/include/mlir/Pass/PassBase.td

+//===-- PassBase.td - Base pass 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 file contains definitions for defining pass registration and other
+// mechanisms.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_PASS_PASSBASE
+#define MLIR_PASS_PASSBASE
+
+//===----------------------------------------------------------------------===//
+// Pass
+//===----------------------------------------------------------------------===//
+
+class Pass<string passArg> {
+  // The command line argument of the pass.
+  string argument = passArg;
+
+  // A short 1-line summary of the pass.
+  string summary = "";
+
+  // A human readable description of the pass.
+  string description = "";
+
+  // A C++ constructor call to create an instance of this pass.
+  code constructor = [{}];
+}
+
+#endif // MLIR_PASS_PASSBASE

mlir/include/mlir/Pass/PassRegistry.h

 /// typically used through the PassPipelineRegistration template.
 void registerPassPipeline(
     StringRef arg, StringRef description, const PassRegistryFunction &function,
     std::function<void(function_ref<void(const detail::PassOptions &)>)>
         optHandler);
 
 /// Register a specific dialect pass allocator function with the system,
 /// typically used through the PassRegistration template.
-void registerPass(StringRef arg, StringRef description, const PassID *passID,
+void registerPass(StringRef arg, StringRef description,
                   const PassAllocatorFunction &function);
 
 /// PassRegistration provides a global initializer that registers a Pass
 /// allocation routine for a concrete pass instance. The third argument is
 /// optional and provides a callback to construct a pass that does not have
 /// a default constructor.
 ///
 /// Usage:
 ///
 ///   /// At namespace scope.
 ///   static PassRegistration<MyPass> reg("my-pass", "My Pass Description.");
 ///
 template <typename ConcretePass> struct PassRegistration {
   PassRegistration(StringRef arg, StringRef description,
                    const PassAllocatorFunction &constructor) {
-    registerPass(arg, description, PassID::getID<ConcretePass>(), constructor);
+    registerPass(arg, description, constructor);
   }
 
   PassRegistration(StringRef arg, StringRef description)
       : PassRegistration(arg, description,
                          [] { return std::make_unique<ConcretePass>(); }) {}
 };
 
 /// PassPipelineRegistration provides a global initializer that registers a Pass

mlir/include/mlir/TableGen/Pass.h

+//===- Pass.h - TableGen pass definitions -----------------------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_TABLEGEN_PASS_H_
+#define MLIR_TABLEGEN_PASS_H_
+
+#include "mlir/Support/LLVM.h"
+#include <vector>
+
+namespace llvm {
+class Record;
+} // end namespace llvm
+
+namespace mlir {
+namespace tblgen {
+//===----------------------------------------------------------------------===//
+// Pass
+//===----------------------------------------------------------------------===//
+
+/// Wrapper class providing helper methods for Passes defined in TableGen.
+class Pass {
+public:
+  explicit Pass(const llvm::Record *def);
+
+  /// Return the command line argument of the pass.
+  StringRef getArgument() const;
+
+  /// Return the short 1-line summary of the pass.
+  StringRef getSummary() const;
+
+  /// Return the description of the pass.
+  StringRef getDescription() const;
+
+  /// Return the C++ constructor call to create an instance of this pass.
+  StringRef getConstructor() const;
+
+private:
+  const llvm::Record *def;
+};
+
+} // end namespace tblgen
+} // end namespace mlir
+
+#endif // MLIR_TABLEGEN_PASS_H_

mlir/include/mlir/Transforms/CMakeLists.txt

+
+set(LLVM_TARGET_DEFINITIONS Passes.td)
+mlir_tablegen(Passes.h.inc -gen-pass-decls)
+add_public_tablegen_target(MLIRTransformsPassIncGen)

mlir/include/mlir/Transforms/LocationSnapshot.h

 /// file, and using the printed locations within that file. If `filename` is
 /// empty, a temporary file is generated instead. If a 'tag' is non-empty, the
 /// generated locations are represented as a NameLoc with the given tag as the
 /// name, and then fused with the existing locations. Otherwise, the existing
 /// locations are replaced.
 std::unique_ptr<Pass> createLocationSnapshotPass(OpPrintingFlags flags,
                                                  StringRef fileName = "",
                                                  StringRef tag = "");
+/// Overload utilizing pass options for initialization.
+std::unique_ptr<Pass> createLocationSnapshotPass();
 
 } // end namespace mlir
 
 #endif // MLIR_TRANSFORMS_LOCATIONSNAPSHOT_H

mlir/include/mlir/Transforms/Passes.td

+//===-- Passes.td - Transforms pass 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 file contains definitions for passes within the Transforms/ directory.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_TRANSFORMS_PASSES
+#define MLIR_TRANSFORMS_PASSES
+
+include "mlir/Pass/PassBase.td"
+
+def AffinePipelineDataTransfer : Pass<
+    "affine-pipeline-data-transfer"> {
+  let summary = "Pipeline non-blocking data transfers between explicitly "
+                "managed levels of the memory hierarchy";
+  let constructor = "mlir::createPipelineDataTransferPass()";
+}
+
+def AffineLoopFusion : Pass<"affine-loop-fusion"> {
+  let summary = "Fuse affine loop nests";
+  let constructor = "mlir::createLoopFusionPass()";
+}
+
+def Canonicalizer : Pass<"canonicalize"> {
+  let summary = "Canonicalize operations";
+  let constructor = "mlir::createCanonicalizerPass()";
+}
+
+def CSE : Pass<"cse"> {
+  let summary = "Eliminate common sub-expressions";
+  let constructor = "mlir::createCSEPass()";
+}
+
+def Inliner : Pass<"inline"> {
+  let summary = "Inline function calls";
+  let constructor = "mlir::createInlinerPass()";
+}
+
+def LocationSnapshot : Pass<"snapshot-op-locations"> {
+  let summary = "Generate new locations from the current IR";
+  let constructor = "mlir::createLocationSnapshotPass()";
+}
+
+def LoopCoalescing : Pass<"loop-coalescing"> {
+  let summary = "Coalesce nested loops with independent bounds into a single "
+                "loop";
+  let constructor = "mlir::createLoopCoalescingPass()";
+}
+
+def LoopInvariantCodeMotion : Pass<"loop-invariant-code-motion"> {
+  let summary = "Hoist loop invariant instructions outside of the loop";
+  let constructor = "mlir::createLoopInvariantCodeMotionPass()";
+}
+
+def MemRefDataFlowOpt : Pass<"memref-dataflow-opt"> {
+  let summary = "Perform store/load forwarding for memrefs";
+  let constructor = "mlir::createMemRefDataFlowOptPass()";
+}
+
+def ParallelLoopCollapsing : Pass<"parallel-loop-collapsing"> {
+  let summary = "Collapse parallel loops to use less induction variables";
+  let constructor = "mlir::createParallelLoopCollapsingPass()";
+}
+
+def PrintCFG : Pass<"print-cfg-graph"> {
+  let summary = "Print CFG graph per-Region";
+  let constructor = "mlir::createPrintCFGGraphPass()";
+}
+
+def PrintOpStats : Pass<"print-op-stats"> {
+  let summary = "Print statistics of operations";
+  let constructor = "mlir::createPrintOpStatsPass()";
+}
+
+def PrintOp : Pass<"print-op-graph"> {
+  let summary = "Print op graph per-Region";
+  let constructor = "mlir::createPrintOpGraphPass()";
+}
+
+def StripDebugInfo : Pass<"strip-debuginfo"> {
+  let summary = "Strip debug info from all operations";
+  let constructor = "mlir::createStripDebugInfoPass()";
+}
+
+def SymbolDCE : Pass<"symbol-dce"> {
+  let summary = "Eliminate dead symbols";
+  let constructor = "mlir::createSymbolDCEPass()";
+}
+
+#endif // MLIR_TRANSFORMS_PASSES

mlir/lib/Pass/PassRegistry.cpp

PassInfo::PassInfo(StringRef arg, StringRef description, const PassID *passID,
     : PassRegistryEntry(
           arg, description, buildDefaultRegistryFn(allocator),
           // Use a temporary pass to provide an options instance.
           [=](function_ref<void(const PassOptions &)> optHandler) {
             optHandler(allocator()->passOptions);
           }) {}
 
 void mlir::registerPass(StringRef arg, StringRef description,
-                        const PassID *passID,
                         const PassAllocatorFunction &function) {
+  // TODO: We should use the 'arg' as the lookup key instead of the pass id.
+  const PassID *passID = function()->getPassID();
   PassInfo passInfo(arg, description, passID, function);
   bool inserted = passRegistry->try_emplace(passID, passInfo).second;
   assert(inserted && "Pass registered multiple times");
   (void)inserted;
 }
 
 /// Returns the pass info for the specified pass class or null if unknown.
 const PassInfo *mlir::Pass::lookupPassInfo(const PassID *passID) {

mlir/lib/TableGen/CMakeLists.txt

 add_llvm_library(LLVMMLIRTableGen
   Argument.cpp
   Attribute.cpp
   Constraint.cpp
   Dialect.cpp
   Format.cpp
   Operator.cpp
   OpClass.cpp
   OpInterfaces.cpp
   OpTrait.cpp
+  Pass.cpp
   Pattern.cpp
   Predicate.cpp
   SideEffects.cpp
   Successor.cpp
   Type.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/TableGen
   )
 target_link_libraries(LLVMMLIRTableGen
   PUBLIC
   LLVMSupport
   LLVMTableGen)

mlir/lib/TableGen/Pass.cpp

+//===- Pass.cpp - Pass related classes ------------------------------------===//
+//
+// 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 "mlir/TableGen/Pass.h"
+#include "llvm/TableGen/Record.h"
+
+using namespace mlir;
+using namespace mlir::tblgen;
+
+//===----------------------------------------------------------------------===//
+// Pass
+//===----------------------------------------------------------------------===//
+
+Pass::Pass(const llvm::Record *def) : def(def) {}
+
+StringRef Pass::getArgument() const {
+  return def->getValueAsString("argument");
+}
+
+StringRef Pass::getSummary() const { return def->getValueAsString("summary"); }
+
+StringRef Pass::getDescription() const {
+  return def->getValueAsString("description");
+}
+
+StringRef Pass::getConstructor() const {
+  return def->getValueAsString("constructor");
+}

mlir/lib/Transforms/CMakeLists.txt

add_mlir_library(MLIRTransforms
   ViewOpGraph.cpp
   ViewRegionGraph.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Transforms
 
   DEPENDS
   MLIRStandardOpsIncGen
+  MLIRTransformsPassIncGen
   )
 
 target_link_libraries(MLIRTransforms
   PUBLIC
   MLIRAffine
   MLIRAnalysis
   MLIRLoopLikeInterface
   MLIRLoopOps
   MLIRPass
   MLIRTransformUtils
   MLIRVector
   )

mlir/lib/Transforms/CSE.cpp

void CSE::runOnOperation() {
   opsToErase.clear();
 
   // We currently don't remove region operations, so mark dominance as
   // preserved.
   markAnalysesPreserved<DominanceInfo, PostDominanceInfo>();
 }
 
 std::unique_ptr<Pass> mlir::createCSEPass() { return std::make_unique<CSE>(); }
-
-static PassRegistration<CSE> pass("cse", "Eliminate common sub-expressions");

mlir/lib/Transforms/Canonicalizer.cpp

struct Canonicalizer : public OperationPass<Canonicalizer> {
   }
 };
 } // end anonymous namespace
 
 /// Create a Canonicalizer pass.
 std::unique_ptr<Pass> mlir::createCanonicalizerPass() {
   return std::make_unique<Canonicalizer>();
 }
-
-static PassRegistration<Canonicalizer> pass("canonicalize",
-                                            "Canonicalize operations");

mlir/lib/Transforms/Inliner.cpp

void runOnOperation() override {
     });
   }
 };
 } // end anonymous namespace
 
 std::unique_ptr<Pass> mlir::createInlinerPass() {
   return std::make_unique<InlinerPass>();
 }
-
-static PassRegistration<InlinerPass> pass("inline", "Inline function calls");

mlir/lib/Transforms/LocationSnapshot.cpp

 };
 } // end anonymous namespace
 
 std::unique_ptr<Pass> mlir::createLocationSnapshotPass(OpPrintingFlags flags,
                                                        StringRef fileName,
                                                        StringRef tag) {
   return std::make_unique<LocationSnapshotPass>(flags, fileName, tag);
 }
-
-static PassRegistration<LocationSnapshotPass>
-    reg("snapshot-op-locations", "generate new locations from the current IR");
+std::unique_ptr<Pass> mlir::createLocationSnapshotPass() {
+  return std::make_unique<LocationSnapshotPass>();
+}

mlir/lib/Transforms/LoopCoalescing.cpp

public:
   }
 };
 
 } // namespace
 
 std::unique_ptr<OpPassBase<FuncOp>> mlir::createLoopCoalescingPass() {
   return std::make_unique<LoopCoalescingPass>();
 }
-
-static PassRegistration<LoopCoalescingPass>
-    reg(PASS_NAME,
-        "coalesce nested loops with independent bounds into a single loop");

mlir/lib/Transforms/LoopFusion.cpp

void LoopFusion::runOnFunction() {
   if (clMaximalLoopFusion.getNumOccurrences() > 0)
     maximalFusion = clMaximalLoopFusion;
 
   MemRefDependenceGraph g;
   if (g.init(getFunction()))
     GreedyFusion(&g, localBufSizeThreshold, fastMemorySpace, maximalFusion)
         .run();
 }
-
-static PassRegistration<LoopFusion> pass("affine-loop-fusion",
-                                         "Fuse loop nests");

mlir/lib/Transforms/LoopInvariantCodeMotion.cpp

getOperation()->walk([&](LoopLikeOpInterface loopLike) {
     if (failed(moveLoopInvariantCode(loopLike)))
       signalPassFailure();
   });
 }
 
 std::unique_ptr<Pass> mlir::createLoopInvariantCodeMotionPass() {
   return std::make_unique<LoopInvariantCodeMotion>();
 }
-
-static PassRegistration<LoopInvariantCodeMotion>
-    pass("loop-invariant-code-motion",
-         "Hoist loop invariant instructions outside of the loop");

mlir/lib/Transforms/MemRefDataFlowOpt.cpp

if (llvm::any_of(memref.getUsers(), [&](Operation *ownerInst) {
       continue;
 
     // Erase all stores, the dealloc, and the alloc on the memref.
     for (auto *user : llvm::make_early_inc_range(memref.getUsers()))
       user->erase();
     defInst->erase();
   }
 }
-
-static PassRegistration<MemRefDataFlowOpt>
-    pass("memref-dataflow-opt", "Perform store/load forwarding for memrefs");

mlir/lib/Transforms/OpStats.cpp

for (const auto &key : sorted) {
     os << llvm::left_justify(opName, maxLenOpName) << " , " << opCount[key]
        << '\n';
   }
 }
 
 std::unique_ptr<OpPassBase<ModuleOp>> mlir::createPrintOpStatsPass() {
   return std::make_unique<PrintOpStatsPass>();
 }
-
-static PassRegistration<PrintOpStatsPass>
-    pass("print-op-stats", "Print statistics of operations");

mlir/lib/Transforms/ParallelLoopCollapsing.cpp

 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/LoopUtils.h"
 #include "mlir/Transforms/Passes.h"
 #include "mlir/Transforms/RegionUtils.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 
-#define PASS_NAME "parallel-loop-collapsing"
-#define DEBUG_TYPE PASS_NAME
+#define DEBUG_TYPE "parallel-loop-collapsing"
 
 using namespace mlir;
 
 namespace {
 struct ParallelLoopCollapsing : public OperationPass<ParallelLoopCollapsing> {
   ParallelLoopCollapsing() = default;
   ParallelLoopCollapsing(const ParallelLoopCollapsing &) {}
   void runOnOperation() override {
ListOption<unsigned> clCollapsedIndices2{
       llvm::cl::MiscFlags::CommaSeparated};
 };
 
 } // namespace
 
 std::unique_ptr<Pass> mlir::createParallelLoopCollapsingPass() {
   return std::make_unique<ParallelLoopCollapsing>();
 }
-
-static PassRegistration<ParallelLoopCollapsing>
-    reg(PASS_NAME, "collapse parallel loops to use less induction variables.");

mlir/lib/Transforms/PipelineDataTransfer.cpp

if (!isInstwiseShiftValid(forOp, shifts)) {
     return;
   }
 
   if (failed(affineForOpBodySkew(forOp, shifts))) {
     LLVM_DEBUG(llvm::dbgs() << "op body skewing failed - unexpected\n";);
     return;
   }
 }
-
-static PassRegistration<PipelineDataTransfer> pass(
-    "affine-pipeline-data-transfer",
-    "Pipeline non-blocking data transfers between explicitly managed levels of "
-    "the memory hierarchy");

mlir/lib/Transforms/StripDebugInfo.cpp

void StripDebugInfo::runOnOperation() {
   auto unknownLoc = UnknownLoc::get(&getContext());
   getOperation()->walk([&](Operation *op) { op->setLoc(unknownLoc); });
 }
 
 /// Creates a pass to strip debug information from a function.
 std::unique_ptr<Pass> mlir::createStripDebugInfoPass() {
   return std::make_unique<StripDebugInfo>();
 }
-
-static PassRegistration<StripDebugInfo>
-    pass("strip-debuginfo", "Strip debug info from all operations");

mlir/lib/Transforms/SymbolDCE.cpp

LogicalResult SymbolDCE::computeLiveness(Operation *symbolTableOp,
   }
 
   return success();
 }
 
 std::unique_ptr<Pass> mlir::createSymbolDCEPass() {
   return std::make_unique<SymbolDCE>();
 }
-
-static PassRegistration<SymbolDCE> pass("symbol-dce", "Eliminate dead symbols");

mlir/lib/Transforms/ViewOpGraph.cpp

raw_ostream &mlir::writeGraph(raw_ostream &os, Block &block, bool shortNames,
   return llvm::WriteGraph(os, &block, shortNames, title);
 }
 
 std::unique_ptr<OpPassBase<ModuleOp>>
 mlir::createPrintOpGraphPass(raw_ostream &os, bool shortNames,
                              const Twine &title) {
   return std::make_unique<PrintOpPass>(os, shortNames, title);
 }
-
-static PassRegistration<PrintOpPass> pass("print-op-graph",
-                                          "Print op graph per region");

mlir/lib/Transforms/ViewRegionGraph.cpp

 };
 } // namespace
 
 std::unique_ptr<mlir::OpPassBase<mlir::FuncOp>>
 mlir::createPrintCFGGraphPass(raw_ostream &os, bool shortNames,
                               const Twine &title) {
   return std::make_unique<PrintCFGPass>(os, shortNames, title);
 }
-
-static PassRegistration<PrintCFGPass> pass("print-cfg-graph",
-                                           "Print CFG graph per Function");

mlir/tools/mlir-tblgen/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   MLIRTableGen
   Support
   )
 
 add_tablegen(mlir-tblgen MLIR
   DialectGen.cpp
   EnumsGen.cpp
   LLVMIRConversionGen.cpp
   LLVMIRIntrinsicGen.cpp
   mlir-tblgen.cpp
   OpDefinitionsGen.cpp
   OpDocGen.cpp
   OpFormatGen.cpp
   OpInterfacesGen.cpp
+  PassGen.cpp
   RewriterGen.cpp
   SPIRVUtilsGen.cpp
   StructsGen.cpp
   )
 set_target_properties(mlir-tblgen PROPERTIES FOLDER "Tablegenning")

mlir/tools/mlir-tblgen/PassGen.cpp

+//===- Pass.cpp - MLIR pass registration generator ------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// PassGen uses the description of passes to generate base classes for passes
+// and command line registration.
+//
+//===----------------------------------------------------------------------===//
+
+#include "mlir/TableGen/GenInfo.h"
+#include "mlir/TableGen/Pass.h"
+#include "llvm/ADT/StringExtras.h"
+#include "llvm/Support/FormatVariadic.h"
+#include "llvm/TableGen/Error.h"
+#include "llvm/TableGen/Record.h"
+
+using namespace mlir;
+using namespace mlir::tblgen;
+
+//===----------------------------------------------------------------------===//
+// GEN: Pass registration generation
+//===----------------------------------------------------------------------===//
+
+/// Emit the code for registering each of the given passes with the global
+/// PassRegistry.
+static void emitRegistration(ArrayRef<Pass> passes, raw_ostream &os) {
+  os << "#ifdef GEN_PASS_REGISTRATION\n";
+  for (const Pass &pass : passes) {
+    os << llvm::formatv("::mlir::registerPass(\"{0}\", \"{1}\", []() -> "
+                        "std::unique_ptr<Pass> {{ return {2}; });\n",
+                        pass.getArgument(), pass.getSummary(),
+                        pass.getConstructor());
+  }
+  os << "#undef GEN_PASS_REGISTRATION\n";
+  os << "#endif // GEN_PASS_REGISTRATION\n";
+}
+
+//===----------------------------------------------------------------------===//
+// GEN: Registration hooks
+//===----------------------------------------------------------------------===//
+
+static void emitDecls(const llvm::RecordKeeper &recordKeeper, raw_ostream &os) {
+  os << "/* Autogenerated by mlir-tblgen; don't manually edit */\n";
+
+  std::vector<Pass> passes;
+  for (const llvm::Record *def : recordKeeper.getAllDerivedDefinitions("Pass"))
+    passes.push_back(Pass(def));
+  emitRegistration(passes, os);
+}
+
+static mlir::GenRegistration
+    genRegister("gen-pass-decls", "Generate operation documentation",
+                [](const llvm::RecordKeeper &records, raw_ostream &os) {
+                  emitDecls(records, os);
+                  return false;
+                });