Add interfaces for conversion

Author: Simon Camphausen

mlir/include/mlir/Conversion/ArithToEmitC/ArithToEmitC.h

@@ -10,11 +10,14 @@
 #define MLIR_CONVERSION_ARITHTOEMITC_ARITHTOEMITC_H
 
 namespace mlir {
+class DialectRegistry;
 class RewritePatternSet;
 class TypeConverter;
 
 void populateArithToEmitCPatterns(TypeConverter &typeConverter,
                                   RewritePatternSet &patterns);
+
+void registerConvertArithToEmitCInterface(DialectRegistry &registry);
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_ARITHTOEMITC_ARITHTOEMITC_H

mlir/include/mlir/Conversion/ConvertToEmitC/ConvertToEmitC.h

@@ -9,6 +9,8 @@
 #ifndef MLIR_CONVERSION_CONVERTTOEMITC_CONVERTTOEMITCPASS_H
 #define MLIR_CONVERSION_CONVERTTOEMITC_CONVERTTOEMITCPASS_H
 
+#include "llvm/ADT/SmallVector.h"
+
 #include <memory>
 
 namespace mlir {

mlir/include/mlir/Conversion/ConvertToEmitC/ConvertToEmitCPass.h

@@ -0,0 +1,52 @@
+//===- ToEmitCInterface.h - Conversion to EmitC iface ---*- 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_CONVERSION_CONVERTTOEMITC_TOEMITCINTERFACE_H
+#define MLIR_CONVERSION_CONVERTTOEMITC_TOEMITCINTERFACE_H
+
+#include "mlir/IR/DialectInterface.h"
+#include "mlir/IR/MLIRContext.h"
+#include "mlir/IR/OpDefinition.h"
+
+namespace mlir {
+class ConversionTarget;
+class TypeConverter;
+class MLIRContext;
+class Operation;
+class RewritePatternSet;
+class AnalysisManager;
+
+class ConvertToEmitCPatternInterface
+    : public DialectInterface::Base<ConvertToEmitCPatternInterface> {
+public:
+  ConvertToEmitCPatternInterface(Dialect *dialect) : Base(dialect) {}
+
+  /// Hook for derived dialect interface to load the dialects they
+  /// target. The EmitC dialect is implicitly already loaded, but this
+  /// method allows to load other intermediate dialects used in the
+  /// conversion, or target dialects like NVVM for example.
+  virtual void loadDependentDialects(MLIRContext *context) const {}
+
+  /// Hook for derived dialect interface to provide conversion patterns
+  /// and mark dialect legal for the conversion target.
+  virtual void populateConvertToEmitCConversionPatterns(
+      ConversionTarget &target, TypeConverter &typeConverter,
+      RewritePatternSet &patterns) const = 0;
+};
+
+/// Recursively walk the IR and collect all dialects implementing the interface,
+/// and populate the conversion patterns.
+void populateConversionTargetFromOperation(Operation *op,
+                                           ConversionTarget &target,
+                                           TypeConverter &typeConverter,
+                                           RewritePatternSet &patterns);
+
+} // namespace mlir
+
+
+#endif // MLIR_CONVERSION_CONVERTTOEMITC_TOEMITCINTERFACE_H

mlir/include/mlir/Conversion/ConvertToEmitC/ToEmitCInterface.h

@@ -10,11 +10,14 @@
 #define MLIR_CONVERSION_FUNCTOEMITC_FUNCTOEMITC_H
 
 namespace mlir {
+class DialectRegistry;
 class RewritePatternSet;
 class TypeConverter;
 
 void populateFuncToEmitCPatterns(const TypeConverter &typeConverter,
                                  RewritePatternSet &patterns);
+
+void registerConvertFuncToEmitCInterface(DialectRegistry &registry);
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_FUNCTOEMITC_FUNCTOEMITC_H

mlir/include/mlir/Conversion/FuncToEmitC/FuncToEmitC.h

@@ -9,13 +9,16 @@
 #define MLIR_CONVERSION_MEMREFTOEMITC_MEMREFTOEMITC_H
 
 namespace mlir {
+class DialectRegistry;
 class RewritePatternSet;
 class TypeConverter;
 
 void populateMemRefToEmitCTypeConversion(TypeConverter &typeConverter);
 
 void populateMemRefToEmitCConversionPatterns(RewritePatternSet &patterns,
                                              const TypeConverter &converter);
+
+void registerConvertMemRefToEmitCInterface(DialectRegistry &registry);
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_MEMREFTOEMITC_MEMREFTOEMITC_H

mlir/include/mlir/Conversion/MemRefToEmitC/MemRefToEmitC.h

@@ -21,8 +21,9 @@ def ConvertToEmitC : Pass<"convert-to-emitc"> {
   let description = [{
     This is a generic pass to convert to the EmitC dialect.
   }];
-  let dependentDialects = [
-    "emitc::EmitCDialect",
+  let options = [
+    ListOption<"filterDialects", "filter-dialects", "std::string",
+               "Test conversion patterns of only the specified dialects">,
   ];
 }
 

mlir/include/mlir/Conversion/Passes.td

@@ -13,6 +13,7 @@
 #include <memory>
 
 namespace mlir {
+class DialectRegistry;
 class Pass;
 class RewritePatternSet;
 
@@ -22,6 +23,8 @@ class RewritePatternSet;
 /// Collect a set of patterns to convert SCF operations to the EmitC dialect.
 void populateSCFToEmitCConversionPatterns(RewritePatternSet &patterns,
                                           TypeConverter &typeConverter);
+
+void registerConvertSCFToEmitCInterface(DialectRegistry &registry);
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_SCFTOEMITC_SCFTOEMITC_H

mlir/include/mlir/Conversion/SCFToEmitC/SCFToEmitC.h

@@ -14,17 +14,21 @@
 #ifndef MLIR_INITALLEXTENSIONS_H_
 #define MLIR_INITALLEXTENSIONS_H_
 
+#include "mlir/Conversion/ArithToEmitC/ArithToEmitC.h"
 #include "mlir/Conversion/ArithToLLVM/ArithToLLVM.h"
 #include "mlir/Conversion/ComplexToLLVM/ComplexToLLVM.h"
 #include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h"
+#include "mlir/Conversion/FuncToEmitC/FuncToEmitC.h"
 #include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h"
 #include "mlir/Conversion/GPUCommon/GPUToLLVM.h"
 #include "mlir/Conversion/GPUToNVVM/GPUToNVVM.h"
 #include "mlir/Conversion/IndexToLLVM/IndexToLLVM.h"
 #include "mlir/Conversion/MathToLLVM/MathToLLVM.h"
+#include "mlir/Conversion/MemRefToEmitC/MemRefToEmitC.h"
 #include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h"
 #include "mlir/Conversion/NVVMToLLVM/NVVMToLLVM.h"
 #include "mlir/Conversion/OpenMPToLLVM/ConvertOpenMPToLLVM.h"
+#include "mlir/Conversion/SCFToEmitC/SCFToEmitC.h"
 #include "mlir/Conversion/UBToLLVM/UBToLLVM.h"
 #include "mlir/Conversion/VectorToLLVM/ConvertVectorToLLVM.h"
 #include "mlir/Dialect/AMX/Transforms.h"
@@ -62,17 +66,21 @@ namespace mlir {
 /// pipelines and transformations you are using.
 inline void registerAllExtensions(DialectRegistry &registry) {
   // Register all conversions to LLVM extensions.
+  registerConvertArithToEmitCInterface(registry);
   arith::registerConvertArithToLLVMInterface(registry);
   registerConvertComplexToLLVMInterface(registry);
   cf::registerConvertControlFlowToLLVMInterface(registry);
   func::registerAllExtensions(registry);
   tensor::registerAllExtensions(registry);
+  registerConvertFuncToEmitCInterface(registry);
   registerConvertFuncToLLVMInterface(registry);
   index::registerConvertIndexToLLVMInterface(registry);
   registerConvertMathToLLVMInterface(registry);
+  registerConvertMemRefToEmitCInterface(registry);
   registerConvertMemRefToLLVMInterface(registry);
   registerConvertNVVMToLLVMInterface(registry);
   registerConvertOpenMPToLLVMInterface(registry);
+  registerConvertSCFToEmitCInterface(registry);
   ub::registerConvertUBToLLVMInterface(registry);
   registerConvertAMXToLLVMInterface(registry);
   gpu::registerConvertGpuToLLVMInterface(registry);

mlir/include/mlir/InitAllExtensions.h

@@ -13,6 +13,7 @@
 
 #include "mlir/Conversion/ArithToEmitC/ArithToEmitC.h"
 
+#include "mlir/Conversion/ConvertToEmitC/ToEmitCInterface.h"
 #include "mlir/Dialect/Arith/IR/Arith.h"
 #include "mlir/Dialect/EmitC/IR/EmitC.h"
 #include "mlir/Dialect/EmitC/Transforms/TypeConversions.h"
@@ -22,10 +23,37 @@
 
 using namespace mlir;
 
+namespace {
+/// Implement the interface to convert Arith to EmitC.
+struct ArithToEmitCDialectInterface : public ConvertToEmitCPatternInterface {
+  using ConvertToEmitCPatternInterface::ConvertToEmitCPatternInterface;
+  void loadDependentDialects(MLIRContext *context) const final {
+    context->loadDialect<emitc::EmitCDialect>();
+  }
+
+  /// Hook for derived dialect interface to provide conversion patterns
+  /// and mark dialect legal for the conversion target.
+  void populateConvertToEmitCConversionPatterns(
+      ConversionTarget &target, TypeConverter &typeConverter,
+      RewritePatternSet &patterns) const final {
+    populateArithToEmitCPatterns(typeConverter, patterns);
+  }
+};
+} // namespace
+
+void mlir::registerConvertArithToEmitCInterface(
+    DialectRegistry &registry) {
+  registry.addExtension(+[](MLIRContext *ctx, arith::ArithDialect *dialect) {
+    dialect->addInterfaces<ArithToEmitCDialectInterface>();
+  });
+}
+
+
 //===----------------------------------------------------------------------===//
 // Conversion Patterns
 //===----------------------------------------------------------------------===//
 
+
 namespace {
 class ArithConstantOpConversionPattern
     : public OpConversionPattern<arith::ConstantOp> {

mlir/lib/Conversion/ArithToEmitC/ArithToEmitC.cpp

@@ -1,6 +1,5 @@
 add_mlir_conversion_library(MLIRConvertToEmitC
   ConvertToEmitCPass.cpp
-  ConvertToEmitC.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/ConvertToEmitC