Dialect Conversion

lib/Conversion/PolyToStandard/BUILD

@@ -0,0 +1,39 @@
+load("@llvm-project//mlir:tblgen.bzl", "gentbl_cc_library")
+
+package(
+    default_visibility = ["//visibility:public"],
+)
+
+gentbl_cc_library(
+    name = "pass_inc_gen",
+    tbl_outs = [
+        (
+            [
+                "-gen-pass-decls",
+                "-name=PolyToStandard",
+            ],
+            "PolyToStandard.h.inc",
+        ),
+    ],
+    tblgen = "@llvm-project//mlir:mlir-tblgen",
+    td_file = "PolyToStandard.td",
+    deps = [
+        "@llvm-project//mlir:OpBaseTdFiles",
+        "@llvm-project//mlir:PassBaseTdFiles",
+    ],
+)
+
+cc_library(
+    name = "PolyToStandard",
+    srcs = ["PolyToStandard.cpp"],
+    hdrs = ["PolyToStandard.h"],
+    deps = [
+        "pass_inc_gen",
+        "//lib/Dialect/Poly",
+        "@llvm-project//mlir:ArithDialect",
+        "@llvm-project//mlir:IR",
+        "@llvm-project//mlir:Pass",
+        "@llvm-project//mlir:TensorDialect",
+        "@llvm-project//mlir:Transforms",
+    ],
+)

lib/Conversion/PolyToStandard/PolyToStandard.cpp

@@ -0,0 +1,72 @@
+#include "lib/Conversion/PolyToStandard/PolyToStandard.h"
+
+#include "lib/Dialect/Poly/PolyOps.h"
+#include "lib/Dialect/Poly/PolyTypes.h"
+#include "mlir/include/mlir/Transforms/DialectConversion.h"  // from @llvm-project
+
+namespace mlir {
+namespace tutorial {
+namespace poly {
+
+#define GEN_PASS_DEF_POLYTOSTANDARD
+#include "lib/Conversion/PolyToStandard/PolyToStandard.h.inc"
+
+class PolyToStandardTypeConverter : public TypeConverter {
+ public:
+  PolyToStandardTypeConverter(MLIRContext *ctx) {
+    addConversion([](Type type) { return type; });
+    addConversion([ctx](PolynomialType type) -> Type {
+      int degreeBound = type.getDegreeBound();
+      IntegerType elementTy =
+          IntegerType::get(ctx, 32, IntegerType::SignednessSemantics::Signless);
+      return RankedTensorType::get({degreeBound}, elementTy);
+    });
+
+    // We don't include any custom materialization hooks because this lowering
+    // is all done in a single pass. The dialect conversion framework works by
+    // resolving intermediate (mid-pass) type conflicts by inserting
+    // unrealized_conversion_cast ops, and only converting those to custom
+    // materializations if they persist at the end of the pass. In our case,
+    // we'd only need to use custom materializations if we split this lowering
+    // across multiple passes.
+  }
+};
+
+struct ConvertAdd : public OpConversionPattern<AddOp> {
+  ConvertAdd(mlir::MLIRContext *context)
+      : OpConversionPattern<AddOp>(context) {}
+
+  using OpConversionPattern::OpConversionPattern;
+
+  LogicalResult matchAndRewrite(
+      AddOp op, OpAdaptor adaptor,
+      ConversionPatternRewriter &rewriter) const override {
+    // TODO: implement
+    return success();
+  }
+};
+
+struct PolyToStandard : impl::PolyToStandardBase<PolyToStandard> {
+  using PolyToStandardBase::PolyToStandardBase;
+
+  void runOnOperation() override {
+    MLIRContext *context = &getContext();
+    auto *module = getOperation();
+
+    ConversionTarget target(*context);
+    target.addLegalDialect<arith::ArithDialect>();
+    target.addIllegalDialect<PolyDialect>();
+
+    RewritePatternSet patterns(context);
+    PolyToStandardTypeConverter typeConverter(context);
+    patterns.add<ConvertAdd>(typeConverter, context);
+
+    if (failed(applyPartialConversion(module, target, std::move(patterns)))) {
+      signalPassFailure();
+    }
+  }
+};
+
+}  // namespace poly
+}  // namespace tutorial
+}  // namespace mlir

lib/Conversion/PolyToStandard/PolyToStandard.h

@@ -0,0 +1,24 @@
+#ifndef LIB_CONVERSION_POLYTOSTANDARD_POLYTOSTANDARD_H_
+#define LIB_CONVERSION_POLYTOSTANDARD_POLYTOSTANDARD_H_
+
+#include "mlir/include/mlir/Pass/Pass.h"  // from @llvm-project
+
+// Extra includes needed for dependent dialects
+#include "mlir/include/mlir/Dialect/Arith/IR/Arith.h"   // from @llvm-project
+#include "mlir/include/mlir/Dialect/Tensor/IR/Tensor.h"  // from @llvm-project
+
+namespace mlir {
+namespace tutorial {
+namespace poly {
+
+#define GEN_PASS_DECL
+#include "lib/Conversion/PolyToStandard/PolyToStandard.h.inc"
+
+#define GEN_PASS_REGISTRATION
+#include "lib/Conversion/PolyToStandard/PolyToStandard.h.inc"
+
+}  // namespace poly
+}  // namespace tutorial
+}  // namespace mlir
+
+#endif  // LIB_CONVERSION_POLYTOSTANDARD_POLYTOSTANDARD_H_

lib/Conversion/PolyToStandard/PolyToStandard.td

@@ -0,0 +1,20 @@
+#ifndef LIB_CONVERSION_POLYTOSTANDARD_POLYTOSTANDARD_TD_
+#define LIB_CONVERSION_POLYTOSTANDARD_POLYTOSTANDARD_TD_
+
+include "mlir/Pass/PassBase.td"
+
+def PolyToStandard : Pass<"poly-to-standard"> {
+  let summary = "Lower `poly` to standard MLIR dialects.";
+
+  let description = [{
+    This pass lowers the `poly` dialect to standard MLIR, a mixture of affine,
+    tensor, and arith.
+  }];
+  let dependentDialects = [
+    "mlir::arith::ArithDialect",
+    "mlir::tutorial::poly::PolyDialect",
+    "mlir::tensor::TensorDialect",
+  ];
+}
+
+#endif  // LIB_CONVERSION_POLYTOSTANDARD_POLYTOSTANDARD_TD_

tools/BUILD

@@ -11,6 +11,7 @@ cc_binary(
     srcs = ["tutorial-opt.cpp"],
     includes = ["include"],
     deps = [
+        "//lib/Conversion/PolyToStandard",
         "//lib/Dialect/Poly",
         "//lib/Transform/Affine:Passes",
         "//lib/Transform/Arith:Passes",

tools/tutorial-opt.cpp

@@ -1,3 +1,4 @@
+#include "lib/Conversion/PolyToStandard/PolyToStandard.h"
 #include "lib/Dialect/Poly/PolyDialect.h"
 #include "lib/Transform/Affine/Passes.h"
 #include "lib/Transform/Arith/Passes.h"
@@ -16,6 +17,9 @@ int main(int argc, char **argv) {
   mlir::tutorial::registerAffinePasses();
   mlir::tutorial::registerArithPasses();
 
+  // Dialect conversion passes
+  mlir::tutorial::poly::registerPolyToStandardPasses();
+
   return mlir::asMainReturnCode(
       mlir::MlirOptMain(argc, argv, "Tutorial Pass Driver", registry));
 }