[mlir:PDLL] Add support for C++ generation

[rriddle]

Summary

This commits adds a C++ generator to PDLL that generates wrapper PDL patterns
directly usable in C++ code, and also generates the definitions of native constraints/rewrites
that have code bodies specified in PDLL. This generator is effectively the PDLL equivalent of
the current DRR generator, and will allow easy replacement of DRR patterns with PDLL patterns.
A followup will start to utilize this for end-to-end integration testing and show case how to
use this as a drop-in replacement for DRR tablegen usage.

[nicolasvasilache]

mlir/lib/Tools/PDLL/CodeGen/CPPGen.cpp

97

As currently implemented, we'd end up with C++ interspersed with PDL string representation.
I fear this will grow large and hard to manage.

Thinking a bit more, is this actually related to PDLL or just to PDL?
Wouldn't it be better if the struct took a ModuleOp + PdlPatternName and was always an information-less wrapper ?

This way there would be a single MLIR source of truth one can go look at.
The short-term downside is that we would need to handle files more explicitly (i.e. materialize the PDL file) and C++ would need to parse that file (i.e. at compiler runtime).

OTOH, this would allow behaviors that seem nicer in MLIR rather than PDLL.
I imagine we will soon need to separate multiple PDL .mlir files logically and start importing them from each other and from executable MLIR.
The notion of DCE is then dependent on context and since it is already builtin MLIR, this sounds preferable.
Then we can separate PDLL files and mix PDLL + hand-written MLIR-PDL transparently.

None of this would require looking at any generated C++.

188

Nothing here touches constParams.
I imagine this is related to the comment // FIXME: We currently do not have a modeling for the "constant params" in D119779 ?

[mehdi_amini]

mlir/lib/Tools/PDLL/CodeGen/CPPGen.cpp

97

We should print generic here, I still to have a build of MLIR that strips the custom assembly support.

Ideally we would even not including a string to be parsed at runtime, but emit the C++ that construct the IR! :)

[nicolasvasilache]

mlir/lib/Tools/PDLL/CodeGen/CPPGen.cpp

97

Ideally we would even not including a string to be parsed at runtime, but emit the C++ that construct the IR! :)

This sounds like a scary amount of duplication to me ..
I'd prefer we have a way to load all patterns we want dynamically and just call then by name.

[jpienaar]

mlir/lib/Tools/PDLL/CodeGen/CPPGen.cpp

8

File description?

71

OOC should there be a guard against a pattern named GeneratedPDLLPattern2? :)

93

Nit: this form won't trigger the syntax highlighing added to vscode. These for me are just MLIR snippets inside C++ code and the fact that they include PDL ops isn't that interesting at this level (at least not to the level that I'd want to special case detection or would me act differently)

97

generic

That shouldn't really matter, these should only be generated and consumed at the same rev, this should be a build system artifact. That being said, this could reduce number of test case updates if syntax changes.

includes

Having something like #include "<pattern_name>.mlir here could be a compromise. Or are you proposing even beyond that : from a single generated pattern file one has these patterns merely refer into it?

If you had this in bytecode format, would that be too late for pattern optimization? (e.g., we want this in this form C++ side, vs serializing the bytecode variant here and then keeping the "raw" pattern in external file for dynamic loading etc)

[mehdi_amini]

mlir/lib/Tools/PDLL/CodeGen/CPPGen.cpp

97

This sounds like a scary amount of duplication to me ..

I'm not sure I see why? Talking about this with River I even think we could have a generic backend for mlir-translate that given an op emits the C++ calls to build it (including nested region).

I'd prefer we have a way to load all patterns we want dynamically and just call then by name.

Sure: the thing is that when you say "load all patterns dynamically" it begs the question about what is the storage format for the patterns. Ideally the engine does not really care: what it wants is a "in-memory" representation of a pattern a way to load it.
There can be multiple way to store this and get the in-memory representation form, above what I was pointing at is that "string" isn't a great production artifact for the storage.

[rriddle]

mlir/lib/Tools/PDLL/CodeGen/CPPGen.cpp

71

Haha, added.

93

Yeah, I had this written before we added support for that. Updated.

97

There are various different things at play here. There is the generated C++ API that is exposed to users, and the internal storage of the patterns that we use. As Mehdi mentions, the storage representation is generally opaque to the user, whether that be an inlined string/bitcode blob/directly using the builder API/etc.

As currently implemented, we'd end up with C++ interspersed with PDL string representation.
I fear this will grow large and hard to manage.

Thinking a bit more, is this actually related to PDLL or just to PDL?
Wouldn't it be better if the struct took a ModuleOp + PdlPatternName and was always an information-less wrapper ?

This way there would be a single MLIR source of truth one can go look at.
The short-term downside is that we would need to handle files more explicitly (i.e. materialize the PDL file) and C++ would need to parse that file (i.e. at compiler runtime).

OTOH, this would allow behaviors that seem nicer in MLIR rather than PDLL.

What behaviors do you have in mind here? The only thing PDLL is doing is generating MLIR and splatting that to the source file, all analysis/optimization/transformation of the PDL happens at runtime.

I imagine we will soon need to separate multiple PDL .mlir files logically and start importing them from each other and from executable MLIR.
The notion of DCE is then dependent on context and since it is already builtin MLIR, this sounds preferable.
Then we can separate PDLL files and mix PDLL + hand-written MLIR-PDL transparently.

None of this would require looking at any generated C++.

You can already mix PDLL generated patterns with PDL patterns from other places. Maybe I'm not understanding what kind of mixing you refer to here. The way that PDL works is that when the rewrite pattern set is frozen (i.e. when you create a FrozenRewritePatternSet) all of the PDL patterns are merged together into a single giant module, and then lowered/optimized together. Generating separate patterns or one giant pattern module has no effect on the end result, it's only about how you expose things to the user. Generating separate C++ patterns (one per PDLL pattern) allows for the user to directly reference specific patterns by name in the C++ API; e.g. if you had one .pdll file for canonicalization patterns of a dialect, you'd want to separate out the patterns for specific operations when adding them to the canonicalization pattern list for that op.

188

Yep, also added a comment here.

[rriddle]

ping. Any updates or fundamental blockers?

[jpienaar]

Looks good, I think this is fine starting point and can be refined from here.

mlir/lib/Tools/PDLL/CodeGen/CPPGen.cpp

108

Nice touch, if have forgotten this.

[nicolasvasilache]

LGTM

mlir/include/mlir/Tools/PDLL/CodeGen/CPPGen.h

+//===- CPPGen.h - MLIR PDLL CPP Code Generation -----------------*- 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_TOOLS_PDLL_CODEGEN_CPPGEN_H_
+#define MLIR_TOOLS_PDLL_CODEGEN_CPPGEN_H_
+
+#include "mlir/Support/LLVM.h"
+#include <memory>
+
+namespace mlir {
+class ModuleOp;
+
+namespace pdll {
+namespace ast {
+class Module;
+} // namespace ast
+
+void codegenPDLLToCPP(const ast::Module &astModule, ModuleOp module,
+                      raw_ostream &os);
+} // namespace pdll
+} // namespace mlir
+
+#endif // MLIR_TOOLS_PDLL_CODEGEN_CPPGEN_H_

mlir/lib/Tools/PDLL/CodeGen/CMakeLists.txt

 add_mlir_library(MLIRPDLLCodeGen
+  CPPGen.cpp
   MLIRGen.cpp
 
   LINK_LIBS PUBLIC
   MLIRParser
   MLIRPDLLAST
   MLIRPDL
   MLIRSupport
   )

mlir/lib/Tools/PDLL/CodeGen/CPPGen.cpp

+//===- CPPGen.cpp ---------------------------------------------------------===//
+//
+// 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 files contains a PDLL generator that outputs C++ code that defines PDLL
+// patterns as individual C++ PDLPatternModules for direct use in native code,
+// and also defines any native constraints whose bodies were defined in PDLL.
+//
+//===----------------------------------------------------------------------===//
+
+#include "mlir/Tools/PDLL/CodeGen/CPPGen.h"
+#include "mlir/Dialect/PDL/IR/PDL.h"
+#include "mlir/Dialect/PDL/IR/PDLOps.h"
+#include "mlir/IR/BuiltinOps.h"
+#include "mlir/Tools/PDLL/AST/Nodes.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/StringExtras.h"
+#include "llvm/ADT/StringSet.h"
+#include "llvm/ADT/TypeSwitch.h"
+#include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/FormatVariadic.h"
+
+using namespace mlir;
+using namespace mlir::pdll;
+
+//===----------------------------------------------------------------------===//
+// CodeGen
+//===----------------------------------------------------------------------===//
+
+namespace {
+class CodeGen {
+public:
+  CodeGen(raw_ostream &os) : os(os) {}
+
+  /// Generate C++ code for the given PDL pattern module.
+  void generate(const ast::Module &astModule, ModuleOp module);
+
+private:
+  void generate(pdl::PatternOp pattern, StringRef patternName,
+                StringSet<> &nativeFunctions);
+
+  /// Generate C++ code for all user defined constraints and rewrites with
+  /// native code.
+  void generateConstraintAndRewrites(const ast::Module &astModule,
+                                     ModuleOp module,
+                                     StringSet<> &nativeFunctions);
+  void generate(const ast::UserConstraintDecl *decl,
+                StringSet<> &nativeFunctions);
+  void generate(const ast::UserRewriteDecl *decl, StringSet<> &nativeFunctions);
+  void generateConstraintOrRewrite(StringRef name, bool isConstraint,
+                                   ArrayRef<ast::VariableDecl *> inputs,
+                                   StringRef codeBlock,
+                                   StringSet<> &nativeFunctions);
+
+  /// The stream to output to.
+  raw_ostream &os;
+};
+} // namespace
+
+void CodeGen::generate(const ast::Module &astModule, ModuleOp module) {
+  SetVector<std::string, SmallVector<std::string>, StringSet<>> patternNames;
+  StringSet<> nativeFunctions;
+
+  // Generate code for any native functions within the module.
+  generateConstraintAndRewrites(astModule, module, nativeFunctions);
+
+  os << "namespace {\n";
+  std::string basePatternName = "GeneratedPDLLPattern";
+  int patternIndex = 0;
+  for (pdl::PatternOp pattern : module.getOps<pdl::PatternOp>()) {
+    // If the pattern has a name, use that. Otherwise, generate a unique name.
+    if (Optional<StringRef> patternName = pattern.sym_name()) {
+      patternNames.insert(patternName->str());
+    } else {
+      std::string name;
+      do {
+        name = (basePatternName + Twine(patternIndex++)).str();
+      } while (!patternNames.insert(name));
+    }
+
+    generate(pattern, patternNames.back(), nativeFunctions);
+  }
+  os << "} // end namespace\n\n";
+
+  // Emit function to add the generated matchers to the pattern list.
+  os << "static void LLVM_ATTRIBUTE_UNUSED populateGeneratedPDLLPatterns("
+        "::mlir::RewritePatternSet &patterns) {\n";
+  for (const auto &name : patternNames)
+    os << "  patterns.add<" << name << ">(patterns.getContext());\n";
+  os << "}\n";
+}
+
+void CodeGen::generate(pdl::PatternOp pattern, StringRef patternName,
+                       StringSet<> &nativeFunctions) {
+  const char *patternClassStartStr = R"(
+struct {0} : ::mlir::PDLPatternModule {{
+  {0}(::mlir::MLIRContext *context)
+    : ::mlir::PDLPatternModule(::mlir::parseSourceString<::mlir::ModuleOp>(
+)";
+  os << llvm::formatv(patternClassStartStr, patternName);
+
+  os << "R\"mlir(";
+  pattern->print(os, OpPrintingFlags().enableDebugInfo());
+  os << "\n    )mlir\", context)) {\n";
+
+  // Register any native functions used within the pattern.
+  StringSet<> registeredNativeFunctions;
+  auto checkRegisterNativeFn = [&](StringRef fnName, StringRef fnType) {
+    if (!nativeFunctions.count(fnName) ||
+        !registeredNativeFunctions.insert(fnName).second)
+      return;
+    os << "    register" << fnType << "Function(\"" << fnName << "\", "
+       << fnName << "PDLFn);\n";
+  };
+  pattern.walk([&](Operation *op) {
+    if (auto constraintOp = dyn_cast<pdl::ApplyNativeConstraintOp>(op))
+      checkRegisterNativeFn(constraintOp.name(), "Constraint");
+    else if (auto rewriteOp = dyn_cast<pdl::ApplyNativeRewriteOp>(op))
+      checkRegisterNativeFn(rewriteOp.name(), "Rewrite");
+  });
+  os << "  }\n};\n\n";
+}
+
+void CodeGen::generateConstraintAndRewrites(const ast::Module &astModule,
+                                            ModuleOp module,
+                                            StringSet<> &nativeFunctions) {
+  // First check to see which constraints and rewrites are actually referenced
+  // in the module.
+  StringSet<> usedFns;
+  module.walk([&](Operation *op) {
+    TypeSwitch<Operation *>(op)
+        .Case<pdl::ApplyNativeConstraintOp, pdl::ApplyNativeRewriteOp>(
+            [&](auto op) { usedFns.insert(op.name()); });
+  });
+
+  for (const ast::Decl *decl : astModule.getChildren()) {
+    TypeSwitch<const ast::Decl *>(decl)
+        .Case<ast::UserConstraintDecl, ast::UserRewriteDecl>(
+            [&](const auto *decl) {
+              // We only generate code for inline native decls that have been
+              // referenced.
+              if (decl->getCodeBlock() &&
+                  usedFns.contains(decl->getName().getName()))
+                this->generate(decl, nativeFunctions);
+            });
+  }
+}
+
+void CodeGen::generate(const ast::UserConstraintDecl *decl,
+                       StringSet<> &nativeFunctions) {
+  return generateConstraintOrRewrite(decl->getName().getName(),
+                                     /*isConstraint=*/true, decl->getInputs(),
+                                     *decl->getCodeBlock(), nativeFunctions);
+}
+
+void CodeGen::generate(const ast::UserRewriteDecl *decl,
+                       StringSet<> &nativeFunctions) {
+  return generateConstraintOrRewrite(decl->getName().getName(),
+                                     /*isConstraint=*/false, decl->getInputs(),
+                                     *decl->getCodeBlock(), nativeFunctions);
+}
+
+void CodeGen::generateConstraintOrRewrite(StringRef name, bool isConstraint,
+                                          ArrayRef<ast::VariableDecl *> inputs,
+                                          StringRef codeBlock,
+                                          StringSet<> &nativeFunctions) {
+  nativeFunctions.insert(name);
+
+  // TODO: Should there be something explicit for handling optionality?
+  auto getCppType = [&](ast::Type type) -> StringRef {
+    return llvm::TypeSwitch<ast::Type, StringRef>(type)
+        .Case([&](ast::AttributeType) { return "::mlir::Attribute"; })
+        .Case([&](ast::OperationType) {
+          // TODO: Allow using the derived Op class when possible.
+          return "::mlir::Operation *";
+        })
+        .Case([&](ast::TypeType) { return "::mlir::Type"; })
+        .Case([&](ast::ValueType) { return "::mlir::Value"; })
+        .Case([&](ast::TypeRangeType) { return "::mlir::TypeRange"; })
+        .Case([&](ast::ValueRangeType) { return "::mlir::ValueRange"; });
+  };
+
+  // FIXME: We currently do not have a modeling for the "constant params"
+  // support PDL provides. We should either figure out a modeling for this, or
+  // refactor the support within PDL to be something a bit more reasonable for
+  // what we need as a frontend.
+  os << "static " << (isConstraint ? "::mlir::LogicalResult " : "void ") << name
+     << "PDLFn(::llvm::ArrayRef<::mlir::PDLValue> values, "
+        "::mlir::ArrayAttr constParams, ::mlir::PatternRewriter &rewriter"
+     << (isConstraint ? "" : ", ::mlir::PDLResultList &results") << ") {\n";
+
+  const char *argumentInitStr = R"(
+  {0} {1} = {{};
+  if (values[{2}])
+    {1} = values[{2}].cast<{0}>();
+  (void){1};
+)";
+  for (const auto &it : llvm::enumerate(inputs)) {
+    const ast::VariableDecl *input = it.value();
+    os << llvm::formatv(argumentInitStr, getCppType(input->getType()),
+                        input->getName().getName(), it.index());
+  }
+
+  os << "  " << codeBlock.trim() << "\n}\n";
+}
+
+//===----------------------------------------------------------------------===//
+// CPPGen
+//===----------------------------------------------------------------------===//
+
+void mlir::pdll::codegenPDLLToCPP(const ast::Module &astModule, ModuleOp module,
+                                  raw_ostream &os) {
+  CodeGen codegen(os);
+  codegen.generate(astModule, module);
+}

mlir/test/mlir-pdll/CodeGen/CPP/general.pdll

+// RUN: mlir-pdll %s -I %S -split-input-file -x cpp | FileCheck %s
+
+// Check that we generate a wrapper pattern for each PDL pattern. Also
+// add in a pattern awkwardly named the same as our generated patterns to
+// check that we handle overlap.
+
+// CHECK: struct GeneratedPDLLPattern0 : ::mlir::PDLPatternModule {
+// CHECK:  : ::mlir::PDLPatternModule(::mlir::parseSourceString<::mlir::ModuleOp>(
+// CHECK:  R"mlir(
+// CHECK:    pdl.pattern
+// CHECK:      operation "test.op"
+// CHECK:  )mlir", context))
+
+// CHECK: struct NamedPattern : ::mlir::PDLPatternModule {
+// CHECK:  : ::mlir::PDLPatternModule(::mlir::parseSourceString<::mlir::ModuleOp>(
+// CHECK:  R"mlir(
+// CHECK:    pdl.pattern
+// CHECK:      operation "test.op2"
+// CHECK:  )mlir", context))
+
+// CHECK: struct GeneratedPDLLPattern1 : ::mlir::PDLPatternModule {
+
+// CHECK: struct GeneratedPDLLPattern2 : ::mlir::PDLPatternModule {
+// CHECK:  : ::mlir::PDLPatternModule(::mlir::parseSourceString<::mlir::ModuleOp>(
+// CHECK:  R"mlir(
+// CHECK:    pdl.pattern
+// CHECK:      operation "test.op3"
+// CHECK:  )mlir", context))
+
+// CHECK:      static void LLVM_ATTRIBUTE_UNUSED populateGeneratedPDLLPatterns(::mlir::RewritePatternSet &patterns) {
+// CHECK-NEXT:   patterns.add<GeneratedPDLLPattern0>(patterns.getContext());
+// CHECK-NEXT:   patterns.add<NamedPattern>(patterns.getContext());
+// CHECK-NEXT:   patterns.add<GeneratedPDLLPattern1>(patterns.getContext());
+// CHECK-NEXT:   patterns.add<GeneratedPDLLPattern2>(patterns.getContext());
+// CHECK-NEXT: }
+
+Pattern => erase op<test.op>;
+Pattern NamedPattern => erase op<test.op2>;
+Pattern GeneratedPDLLPattern1 => erase op<>;
+Pattern => erase op<test.op3>;
+
+// -----
+
+// Check the generation of native constraints and rewrites.
+
+// CHECK:      static ::mlir::LogicalResult TestCstPDLFn(::llvm::ArrayRef<::mlir::PDLValue> values, ::mlir::ArrayAttr constParams,
+// CHECK-SAME:                                           ::mlir::PatternRewriter &rewriter) {
+// CHECK:   ::mlir::Attribute attr = {};
+// CHECK:   if (values[0])
+// CHECK:     attr = values[0].cast<::mlir::Attribute>();
+// CHECK:   ::mlir::Operation * op = {};
+// CHECK:   if (values[1])
+// CHECK:     op = values[1].cast<::mlir::Operation *>();
+// CHECK:   ::mlir::Type type = {};
+// CHECK:   if (values[2])
+// CHECK:     type = values[2].cast<::mlir::Type>();
+// CHECK:   ::mlir::Value value = {};
+// CHECK:   if (values[3])
+// CHECK:     value = values[3].cast<::mlir::Value>();
+// CHECK:   ::mlir::TypeRange typeRange = {};
+// CHECK:   if (values[4])
+// CHECK:     typeRange = values[4].cast<::mlir::TypeRange>();
+// CHECK:   ::mlir::ValueRange valueRange = {};
+// CHECK:   if (values[5])
+// CHECK:     valueRange = values[5].cast<::mlir::ValueRange>();
+
+// CHECK:   return success();
+// CHECK: }
+
+// CHECK-NOT: TestUnusedCst
+
+// CHECK: static void TestRewritePDLFn(::llvm::ArrayRef<::mlir::PDLValue> values, ::mlir::ArrayAttr constParams,
+// CHECK-SAME:                         ::mlir::PatternRewriter &rewriter, ::mlir::PDLResultList &results) {
+// CHECK:   ::mlir::Attribute attr = {};
+// CHECK:   ::mlir::Operation * op = {};
+// CHECK:   ::mlir::Type type = {};
+// CHECK:   ::mlir::Value value = {};
+// CHECK:   ::mlir::TypeRange typeRange = {};
+// CHECK:   ::mlir::ValueRange valueRange = {};
+
+// CHECK: foo;
+// CHECK: }
+
+// CHECK-NOT: TestUnusedRewrite
+
+// CHECK: struct TestCstAndRewrite : ::mlir::PDLPatternModule {
+// CHECK:   registerConstraintFunction("TestCst", TestCstPDLFn);
+// CHECK:   registerRewriteFunction("TestRewrite", TestRewritePDLFn);
+
+Constraint TestCst(attr: Attr, op: Op, type: Type, value: Value, typeRange: TypeRange, valueRange: ValueRange) [{
+  return success();
+}];
+Constraint TestUnusedCst() [{ return success(); }];
+
+Rewrite TestRewrite(attr: Attr, op: Op, type: Type, value: Value, typeRange: TypeRange, valueRange: ValueRange) [{ foo; }];
+Rewrite TestUnusedRewrite(op: Op) [{}];
+
+Pattern TestCstAndRewrite {
+  let root = op<>(operand: Value, operands: ValueRange) -> (type: Type, types: TypeRange);
+  TestCst(attr<"true">, root, type, operand, types, operands);
+  rewrite root with {
+    TestRewrite(attr<"true">, root, type, operand, types, operands);
+    erase root;
+  };
+}

mlir/tools/mlir-pdll/mlir-pdll.cpp

 //===- mlir-pdll.cpp - MLIR PDLL frontend -----------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/Support/FileUtilities.h"
 #include "mlir/Support/ToolUtilities.h"
 #include "mlir/Tools/PDLL/AST/Context.h"
 #include "mlir/Tools/PDLL/AST/Nodes.h"
+#include "mlir/Tools/PDLL/CodeGen/CPPGen.h"
 #include "mlir/Tools/PDLL/CodeGen/MLIRGen.h"
 #include "mlir/Tools/PDLL/Parser/Parser.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/ToolOutputFile.h"
 
 using namespace mlir;
 using namespace mlir::pdll;
 
 //===----------------------------------------------------------------------===//
 // main
 //===----------------------------------------------------------------------===//
 
 /// The desired output type.
 enum class OutputType {
   AST,
   MLIR,
+  CPP,
 };
 
 static LogicalResult
 processBuffer(raw_ostream &os, std::unique_ptr<llvm::MemoryBuffer> chunkBuffer,
               OutputType outputType, std::vector<std::string> &includeDirs) {
   llvm::SourceMgr sourceMgr;
   sourceMgr.setIncludeDirs(includeDirs);
   sourceMgr.AddNewSourceBuffer(std::move(chunkBuffer), SMLoc());
processBuffer(raw_ostream &os, std::unique_ptr<llvm::MemoryBuffer> chunkBuffer,
   }
 
   MLIRContext mlirContext;
   OwningOpRef<ModuleOp> pdlModule =
       codegenPDLLToMLIR(&mlirContext, astContext, sourceMgr, **module);
   if (!pdlModule)
     return failure();
 
+  if (outputType == OutputType::MLIR) {
     pdlModule->print(os, OpPrintingFlags().enableDebugInfo());
     return success();
   }
 
+  codegenPDLLToCPP(**module, *pdlModule, os);
+  return success();
+}
+
 int main(int argc, char **argv) {
   llvm::cl::opt<std::string> inputFilename(
       llvm::cl::Positional, llvm::cl::desc("<input file>"), llvm::cl::init("-"),
       llvm::cl::value_desc("filename"));
 
   llvm::cl::opt<std::string> outputFilename(
       "o", llvm::cl::desc("Output filename"), llvm::cl::value_desc("filename"),
       llvm::cl::init("-"));
 
   llvm::cl::list<std::string> includeDirs(
       "I", llvm::cl::desc("Directory of include files"),
       llvm::cl::value_desc("directory"), llvm::cl::Prefix);
 
   llvm::cl::opt<bool> splitInputFile(
       "split-input-file",
       llvm::cl::desc("Split the input file into pieces and process each "
                      "chunk independently"),
       llvm::cl::init(false));
   llvm::cl::opt<enum OutputType> outputType(
       "x", llvm::cl::init(OutputType::AST),
       llvm::cl::desc("The type of output desired"),
       llvm::cl::values(clEnumValN(OutputType::AST, "ast",
                                   "generate the AST for the input file"),
                        clEnumValN(OutputType::MLIR, "mlir",
-                                  "generate the PDL MLIR for the input file")));
+                                  "generate the PDL MLIR for the input file"),
+                       clEnumValN(OutputType::CPP, "cpp",
+                                  "generate a C++ source file containing the "
+                                  "patterns for the input file")));
 
   llvm::InitLLVM y(argc, argv);
   llvm::cl::ParseCommandLineOptions(argc, argv, "PDLL Frontend");
 
   // Set up the input file.
   std::string errorMessage;
   std::unique_ptr<llvm::MemoryBuffer> inputFile =
       openInputFile(inputFilename, &errorMessage);