From 0c47b6acdf1b1bbbc9828fd24baf8b0a5d2eb89d Mon Sep 17 00:00:00 2001 From: Corentin Ferry Date: Thu, 16 May 2024 13:16:30 +0100 Subject: [PATCH 01/17] Add EmitC index type converter to FuncToEmitC --- .../FuncToEmitC/FuncToEmitCPass.cpp | 48 +++++++++++++++++++ .../Conversion/FuncToEmitC/func-to-emitc.mlir | 22 +++++++++ 2 files changed, 70 insertions(+) diff --git a/mlir/lib/Conversion/FuncToEmitC/FuncToEmitCPass.cpp b/mlir/lib/Conversion/FuncToEmitC/FuncToEmitCPass.cpp index 0b97f2641ad08..fc20509057c4f 100644 --- a/mlir/lib/Conversion/FuncToEmitC/FuncToEmitCPass.cpp +++ b/mlir/lib/Conversion/FuncToEmitC/FuncToEmitCPass.cpp @@ -14,9 +14,12 @@ #include "mlir/Conversion/FuncToEmitC/FuncToEmitC.h" #include "mlir/Dialect/EmitC/IR/EmitC.h" +#include "mlir/Dialect/EmitC/Transforms/TypeConversions.h" #include "mlir/Dialect/Func/IR/FuncOps.h" +#include "mlir/Dialect/Func/Transforms/FuncConversions.h" #include "mlir/Pass/Pass.h" #include "mlir/Transforms/DialectConversion.h" +#include namespace mlir { #define GEN_PASS_DEF_CONVERTFUNCTOEMITC @@ -33,6 +36,51 @@ struct ConvertFuncToEmitC } // namespace void ConvertFuncToEmitC::runOnOperation() { + // Convert function interface types within the func dialect first to supported + // EmitC types + ConversionTarget interfaceConversionTarget(getContext()); + interfaceConversionTarget.addDynamicallyLegalOp( + [](func::CallOp op) { + auto operandTypes = op->getOperandTypes(); + if (std::any_of(operandTypes.begin(), operandTypes.end(), + [](Type t) { return isa(t); })) + return false; + auto resultTypes = op.getResultTypes(); + return !(std::any_of(resultTypes.begin(), resultTypes.end(), + [](Type t) { return isa(t); })); + }); + interfaceConversionTarget.addDynamicallyLegalOp( + [](func::FuncOp op) { + auto operandTypes = op->getOperandTypes(); + if (std::any_of(operandTypes.begin(), operandTypes.end(), + [](Type t) { return isa(t); })) + return false; + auto resultTypes = op.getResultTypes(); + return !(std::any_of(resultTypes.begin(), resultTypes.end(), + [](Type t) { return isa(t); })); + }); + interfaceConversionTarget.addDynamicallyLegalOp( + [](func::ReturnOp op) { + auto operandTypes = op->getOperandTypes(); + return !(std::any_of(operandTypes.begin(), operandTypes.end(), + [](Type t) { return isa(t); })); + }); + + RewritePatternSet interfaceRewritePatterns(&getContext()); + TypeConverter typeConverter; + typeConverter.addConversion([](Type type) { return type; }); + populateEmitCSizeTypeConversionPatterns(typeConverter); + populateReturnOpTypeConversionPattern(interfaceRewritePatterns, + typeConverter); + populateCallOpTypeConversionPattern(interfaceRewritePatterns, typeConverter); + populateFunctionOpInterfaceTypeConversionPattern( + interfaceRewritePatterns, typeConverter); + + if (failed(applyPartialConversion(getOperation(), interfaceConversionTarget, + std::move(interfaceRewritePatterns)))) + signalPassFailure(); + + // Then convert the func ops themselves to EmitC ConversionTarget target(getContext()); target.addLegalDialect(); diff --git a/mlir/test/Conversion/FuncToEmitC/func-to-emitc.mlir b/mlir/test/Conversion/FuncToEmitC/func-to-emitc.mlir index 5c96cf1ce0d34..8187b9b944234 100644 --- a/mlir/test/Conversion/FuncToEmitC/func-to-emitc.mlir +++ b/mlir/test/Conversion/FuncToEmitC/func-to-emitc.mlir @@ -58,3 +58,25 @@ func.func @call(%arg0: i32) -> i32 { // CHECK-LABEL: emitc.func private @return_i32(i32) -> i32 attributes {specifiers = ["extern"]} func.func private @return_i32(%arg0: i32) -> i32 + +// ----- + +// CHECK-LABEL: emitc.func @use_index +// CHECK-SAME: (%[[Arg0:.*]]: !emitc.size_t) -> !emitc.size_t +// CHECK: emitc.return %[[Arg0]] : !emitc.size_t +func.func @use_index(%arg0: index) -> index { + return %arg0 : index +} + +// ----- + +// CHECK-LABEL: emitc.func private @prototype_index(!emitc.size_t) -> !emitc.size_t attributes {specifiers = ["extern"]} +func.func private @prototype_index(%arg0: index) -> index + +// CHECK-LABEL: emitc.func @call(%arg0: !emitc.size_t) -> !emitc.size_t +// CHECK-NEXT: %0 = emitc.call @prototype_index(%arg0) : (!emitc.size_t) -> !emitc.size_t +// CHECK-NEXT: emitc.return %0 : !emitc.size_t +func.func @call(%arg0: index) -> index { + %0 = call @prototype_index(%arg0) : (index) -> (index) + return %0 : index +} From eb45e1a2d0fbed0576c3661c167715c92cf9edbb Mon Sep 17 00:00:00 2001 From: Corentin Ferry Date: Thu, 16 May 2024 16:03:30 +0100 Subject: [PATCH 02/17] FuncOps should have their arguments checked as well --- mlir/lib/Conversion/FuncToEmitC/FuncToEmitCPass.cpp | 4 ++++ mlir/test/Conversion/FuncToEmitC/func-to-emitc.mlir | 8 ++++++++ 2 files changed, 12 insertions(+) diff --git a/mlir/lib/Conversion/FuncToEmitC/FuncToEmitCPass.cpp b/mlir/lib/Conversion/FuncToEmitC/FuncToEmitCPass.cpp index fc20509057c4f..bd2cc2767cfd5 100644 --- a/mlir/lib/Conversion/FuncToEmitC/FuncToEmitCPass.cpp +++ b/mlir/lib/Conversion/FuncToEmitC/FuncToEmitCPass.cpp @@ -55,6 +55,10 @@ void ConvertFuncToEmitC::runOnOperation() { if (std::any_of(operandTypes.begin(), operandTypes.end(), [](Type t) { return isa(t); })) return false; + auto argumentTypes = op.getArgumentTypes(); + if (std::any_of(argumentTypes.begin(), argumentTypes.end(), + [](Type t) { return isa(t); })) + return false; auto resultTypes = op.getResultTypes(); return !(std::any_of(resultTypes.begin(), resultTypes.end(), [](Type t) { return isa(t); })); diff --git a/mlir/test/Conversion/FuncToEmitC/func-to-emitc.mlir b/mlir/test/Conversion/FuncToEmitC/func-to-emitc.mlir index 8187b9b944234..176a3e48dcbeb 100644 --- a/mlir/test/Conversion/FuncToEmitC/func-to-emitc.mlir +++ b/mlir/test/Conversion/FuncToEmitC/func-to-emitc.mlir @@ -80,3 +80,11 @@ func.func @call(%arg0: index) -> index { %0 = call @prototype_index(%arg0) : (index) -> (index) return %0 : index } + +// ----- + +// CHECK-LABEL: emitc.func @index_args_only(%arg0: !emitc.size_t) -> f32 +func.func @index_args_only(%i: index) -> f32 { + %0 = arith.constant 0.0 : f32 + return %0 : f32 +} \ No newline at end of file From 798529385e33a398cdc03170eaed82d23ddd0ac6 Mon Sep 17 00:00:00 2001 From: Corentin Ferry Date: Fri, 17 May 2024 08:52:17 +0100 Subject: [PATCH 03/17] add unrealized cast materializations --- .../EmitC/Transforms/TypeConversions.cpp | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/mlir/lib/Dialect/EmitC/Transforms/TypeConversions.cpp b/mlir/lib/Dialect/EmitC/Transforms/TypeConversions.cpp index d896f95b0ab8f..6fef114a6b076 100644 --- a/mlir/lib/Dialect/EmitC/Transforms/TypeConversions.cpp +++ b/mlir/lib/Dialect/EmitC/Transforms/TypeConversions.cpp @@ -12,7 +12,26 @@ using namespace mlir; +namespace { + +std::optional materializeAsUnrealizedCast(OpBuilder &builder, + Type resultType, + ValueRange inputs, + Location loc) { + if (inputs.size() != 1) + return std::nullopt; + + return builder.create(loc, resultType, inputs) + .getResult(0); +} + +} // namespace + void mlir::populateEmitCSizeTypeConversionPatterns(TypeConverter &converter) { converter.addConversion( [](IndexType type) { return emitc::SizeTType::get(type.getContext()); }); + + converter.addSourceMaterialization(materializeAsUnrealizedCast); + converter.addTargetMaterialization(materializeAsUnrealizedCast); + converter.addArgumentMaterialization(materializeAsUnrealizedCast); } From 8d9470f48531114e9c02047e18c031c39f4553d6 Mon Sep 17 00:00:00 2001 From: Corentin Ferry Date: Fri, 17 May 2024 08:53:07 +0100 Subject: [PATCH 04/17] use type converter in memref to emitc --- .../Conversion/MemRefToEmitC/MemRefToEmitCPass.cpp | 2 ++ .../Conversion/MemRefToEmitC/memref-to-emitc.mlir | 14 ++++++++++---- 2 files changed, 12 insertions(+), 4 deletions(-) diff --git a/mlir/lib/Conversion/MemRefToEmitC/MemRefToEmitCPass.cpp b/mlir/lib/Conversion/MemRefToEmitC/MemRefToEmitCPass.cpp index 4e5d1912d1572..21a5e7db761ac 100644 --- a/mlir/lib/Conversion/MemRefToEmitC/MemRefToEmitCPass.cpp +++ b/mlir/lib/Conversion/MemRefToEmitC/MemRefToEmitCPass.cpp @@ -14,6 +14,7 @@ #include "mlir/Conversion/MemRefToEmitC/MemRefToEmitC.h" #include "mlir/Dialect/EmitC/IR/EmitC.h" +#include "mlir/Dialect/EmitC/Transforms/TypeConversions.h" #include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Pass/Pass.h" #include "mlir/Transforms/DialectConversion.h" @@ -39,6 +40,7 @@ struct ConvertMemRefToEmitCPass }); populateMemRefToEmitCTypeConversion(converter); + populateEmitCSizeTypeConversionPatterns(converter); RewritePatternSet patterns(&getContext()); populateMemRefToEmitCConversionPatterns(patterns, converter); diff --git a/mlir/test/Conversion/MemRefToEmitC/memref-to-emitc.mlir b/mlir/test/Conversion/MemRefToEmitC/memref-to-emitc.mlir index bc40ef48268eb..093ceb304d97f 100644 --- a/mlir/test/Conversion/MemRefToEmitC/memref-to-emitc.mlir +++ b/mlir/test/Conversion/MemRefToEmitC/memref-to-emitc.mlir @@ -1,12 +1,15 @@ // RUN: mlir-opt -convert-memref-to-emitc %s -split-input-file | FileCheck %s // CHECK-LABEL: memref_store -// CHECK-SAME: %[[v:.*]]: f32, %[[i:.*]]: index, %[[j:.*]]: index +// CHECK-SAME: %[[v:.*]]: f32, %[[argi:.*]]: index, %[[argj:.*]]: index func.func @memref_store(%v : f32, %i: index, %j: index) { + // CHECK: %[[i:.*]] = builtin.unrealized_conversion_cast %[[argi]] : index to !emitc.size_t + // CHECK: %[[j:.*]] = builtin.unrealized_conversion_cast %[[argj]] : index to !emitc.size_t + // CHECK: %[[ALLOCA:.*]] = "emitc.variable"() <{value = #emitc.opaque<"">}> : () -> !emitc.array<4x8xf32> %0 = memref.alloca() : memref<4x8xf32> - // CHECK: %[[SUBSCRIPT:.*]] = emitc.subscript %[[ALLOCA]][%[[i]], %[[j]]] : (!emitc.array<4x8xf32>, index, index) -> f32 + // CHECK: %[[SUBSCRIPT:.*]] = emitc.subscript %[[ALLOCA]][%[[i]], %[[j]]] : (!emitc.array<4x8xf32>, !emitc.size_t, !emitc.size_t) -> f32 // CHECK: emitc.assign %[[v]] : f32 to %[[SUBSCRIPT:.*]] : f32 memref.store %v, %0[%i, %j] : memref<4x8xf32> return @@ -15,12 +18,15 @@ func.func @memref_store(%v : f32, %i: index, %j: index) { // ----- // CHECK-LABEL: memref_load -// CHECK-SAME: %[[i:.*]]: index, %[[j:.*]]: index +// CHECK-SAME: %[[argi:.*]]: index, %[[argj:.*]]: index func.func @memref_load(%i: index, %j: index) -> f32 { + // CHECK: %[[i:.*]] = builtin.unrealized_conversion_cast %[[argi]] : index to !emitc.size_t + // CHECK: %[[j:.*]] = builtin.unrealized_conversion_cast %[[argj]] : index to !emitc.size_t + // CHECK: %[[ALLOCA:.*]] = "emitc.variable"() <{value = #emitc.opaque<"">}> : () -> !emitc.array<4x8xf32> %0 = memref.alloca() : memref<4x8xf32> - // CHECK: %[[LOAD:.*]] = emitc.subscript %[[ALLOCA]][%[[i]], %[[j]]] : (!emitc.array<4x8xf32>, index, index) -> f32 + // CHECK: %[[LOAD:.*]] = emitc.subscript %[[ALLOCA]][%[[i]], %[[j]]] : (!emitc.array<4x8xf32>, !emitc.size_t, !emitc.size_t) -> f32 // CHECK: %[[VAR:.*]] = "emitc.variable"() <{value = #emitc.opaque<"">}> : () -> f32 // CHECK: emitc.assign %[[LOAD]] : f32 to %[[VAR]] : f32 %1 = memref.load %0[%i, %j] : memref<4x8xf32> From 3b5328a049a4c513f9402fb1f3e84ac3373bde7d Mon Sep 17 00:00:00 2001 From: Corentin Ferry Date: Fri, 17 May 2024 10:22:41 +0100 Subject: [PATCH 05/17] Rename conversion pattern population, provide default --- .../mlir/Dialect/EmitC/Transforms/TypeConversions.h | 3 ++- mlir/lib/Conversion/ArithToEmitC/ArithToEmitC.cpp | 2 +- mlir/lib/Conversion/ArithToEmitC/ArithToEmitCPass.cpp | 4 ++-- mlir/lib/Conversion/FuncToEmitC/FuncToEmitCPass.cpp | 4 ++-- .../Conversion/MemRefToEmitC/MemRefToEmitCPass.cpp | 4 ++-- mlir/lib/Dialect/EmitC/Transforms/TypeConversions.cpp | 11 ++++++++++- 6 files changed, 19 insertions(+), 9 deletions(-) diff --git a/mlir/include/mlir/Dialect/EmitC/Transforms/TypeConversions.h b/mlir/include/mlir/Dialect/EmitC/Transforms/TypeConversions.h index da16b336b8bc3..3ff5d249c1f28 100644 --- a/mlir/include/mlir/Dialect/EmitC/Transforms/TypeConversions.h +++ b/mlir/include/mlir/Dialect/EmitC/Transforms/TypeConversions.h @@ -9,5 +9,6 @@ #include "mlir/Transforms/DialectConversion.h" namespace mlir { -void populateEmitCSizeTypeConversionPatterns(mlir::TypeConverter &converter); +void populateEmitCSizeTypeConversions(mlir::TypeConverter &converter); +void populateEmitCDefaultTypeConversions(TypeConverter &converter); } // namespace mlir diff --git a/mlir/lib/Conversion/ArithToEmitC/ArithToEmitC.cpp b/mlir/lib/Conversion/ArithToEmitC/ArithToEmitC.cpp index 62067c5e25644..5449cbc3792c2 100644 --- a/mlir/lib/Conversion/ArithToEmitC/ArithToEmitC.cpp +++ b/mlir/lib/Conversion/ArithToEmitC/ArithToEmitC.cpp @@ -567,7 +567,7 @@ void mlir::populateArithToEmitCPatterns(TypeConverter &typeConverter, RewritePatternSet &patterns) { MLIRContext *ctx = patterns.getContext(); - mlir::populateEmitCSizeTypeConversionPatterns(typeConverter); + mlir::populateEmitCSizeTypeConversions(typeConverter); // clang-format off patterns.add< diff --git a/mlir/lib/Conversion/ArithToEmitC/ArithToEmitCPass.cpp b/mlir/lib/Conversion/ArithToEmitC/ArithToEmitCPass.cpp index 76e7707ce7109..69ea0fad21ec9 100644 --- a/mlir/lib/Conversion/ArithToEmitC/ArithToEmitCPass.cpp +++ b/mlir/lib/Conversion/ArithToEmitC/ArithToEmitCPass.cpp @@ -16,6 +16,7 @@ #include "mlir/Conversion/ArithToEmitC/ArithToEmitC.h" #include "mlir/Dialect/Arith/IR/Arith.h" #include "mlir/Dialect/EmitC/IR/EmitC.h" +#include "mlir/Dialect/EmitC/Transforms/TypeConversions.h" #include "mlir/Pass/Pass.h" #include "mlir/Transforms/DialectConversion.h" @@ -43,9 +44,8 @@ void ConvertArithToEmitC::runOnOperation() { RewritePatternSet patterns(&getContext()); TypeConverter typeConverter; - typeConverter.addConversion([](Type type) { return type; }); - populateArithToEmitCPatterns(typeConverter, patterns); + populateEmitCDefaultTypeConversions(typeConverter); if (failed( applyPartialConversion(getOperation(), target, std::move(patterns)))) diff --git a/mlir/lib/Conversion/FuncToEmitC/FuncToEmitCPass.cpp b/mlir/lib/Conversion/FuncToEmitC/FuncToEmitCPass.cpp index bd2cc2767cfd5..921fd66b12eb9 100644 --- a/mlir/lib/Conversion/FuncToEmitC/FuncToEmitCPass.cpp +++ b/mlir/lib/Conversion/FuncToEmitC/FuncToEmitCPass.cpp @@ -72,8 +72,8 @@ void ConvertFuncToEmitC::runOnOperation() { RewritePatternSet interfaceRewritePatterns(&getContext()); TypeConverter typeConverter; - typeConverter.addConversion([](Type type) { return type; }); - populateEmitCSizeTypeConversionPatterns(typeConverter); + populateEmitCSizeTypeConversions(typeConverter); + populateEmitCDefaultTypeConversions(typeConverter); populateReturnOpTypeConversionPattern(interfaceRewritePatterns, typeConverter); populateCallOpTypeConversionPattern(interfaceRewritePatterns, typeConverter); diff --git a/mlir/lib/Conversion/MemRefToEmitC/MemRefToEmitCPass.cpp b/mlir/lib/Conversion/MemRefToEmitC/MemRefToEmitCPass.cpp index 21a5e7db761ac..5d948d2a09813 100644 --- a/mlir/lib/Conversion/MemRefToEmitC/MemRefToEmitCPass.cpp +++ b/mlir/lib/Conversion/MemRefToEmitC/MemRefToEmitCPass.cpp @@ -34,13 +34,13 @@ struct ConvertMemRefToEmitCPass // Fallback for other types. converter.addConversion([](Type type) -> std::optional { - if (isa(type)) + if (isa(type)) return {}; return type; }); populateMemRefToEmitCTypeConversion(converter); - populateEmitCSizeTypeConversionPatterns(converter); + populateEmitCSizeTypeConversions(converter); RewritePatternSet patterns(&getContext()); populateMemRefToEmitCConversionPatterns(patterns, converter); diff --git a/mlir/lib/Dialect/EmitC/Transforms/TypeConversions.cpp b/mlir/lib/Dialect/EmitC/Transforms/TypeConversions.cpp index 6fef114a6b076..c4acd91214ce1 100644 --- a/mlir/lib/Dialect/EmitC/Transforms/TypeConversions.cpp +++ b/mlir/lib/Dialect/EmitC/Transforms/TypeConversions.cpp @@ -9,6 +9,7 @@ #include "mlir/Dialect/EmitC/Transforms/TypeConversions.h" #include "mlir/Dialect/EmitC/IR/EmitC.h" #include "mlir/IR/BuiltinTypes.h" +#include using namespace mlir; @@ -27,7 +28,7 @@ std::optional materializeAsUnrealizedCast(OpBuilder &builder, } // namespace -void mlir::populateEmitCSizeTypeConversionPatterns(TypeConverter &converter) { +void mlir::populateEmitCSizeTypeConversions(TypeConverter &converter) { converter.addConversion( [](IndexType type) { return emitc::SizeTType::get(type.getContext()); }); @@ -35,3 +36,11 @@ void mlir::populateEmitCSizeTypeConversionPatterns(TypeConverter &converter) { converter.addTargetMaterialization(materializeAsUnrealizedCast); converter.addArgumentMaterialization(materializeAsUnrealizedCast); } + +void mlir::populateEmitCDefaultTypeConversions(TypeConverter &converter) { + converter.addConversion([](Type type) -> std::optional { + if (!isa(type)) + return type; + return std::nullopt; + }); +} \ No newline at end of file From 2d6787890bfcf0591928908347c1f2c0936569df Mon Sep 17 00:00:00 2001 From: Corentin Ferry Date: Fri, 17 May 2024 10:24:26 +0100 Subject: [PATCH 06/17] Do not print emitc index types in for --- mlir/lib/Dialect/EmitC/IR/EmitC.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/mlir/lib/Dialect/EmitC/IR/EmitC.cpp b/mlir/lib/Dialect/EmitC/IR/EmitC.cpp index 71d354885a900..3411a37dbae90 100644 --- a/mlir/lib/Dialect/EmitC/IR/EmitC.cpp +++ b/mlir/lib/Dialect/EmitC/IR/EmitC.cpp @@ -431,7 +431,8 @@ void ForOp::print(OpAsmPrinter &p) { << getUpperBound() << " step " << getStep(); p << ' '; - if (Type t = getInductionVar().getType(); !t.isIndex()) + if (Type t = getInductionVar().getType(); + !(t.isIndex() || emitc::isAnySizeTType(t))) p << " : " << t << ' '; p.printRegion(getRegion(), /*printEntryBlockArgs=*/false, From 9334a7ef90d4c9cd148d21f00c9df6b60142feef Mon Sep 17 00:00:00 2001 From: Corentin Ferry Date: Fri, 17 May 2024 10:24:46 +0100 Subject: [PATCH 07/17] Add conversion patterns to SCF to EmitC --- .../mlir/Conversion/SCFToEmitC/SCFToEmitC.h | 4 +- mlir/lib/Conversion/SCFToEmitC/SCFToEmitC.cpp | 98 ++++++++++++------- mlir/test/Conversion/SCFToEmitC/for.mlir | 20 +++- .../Conversion/SCFToEmitC/nest_for_if.mlir | 33 +++++++ 4 files changed, 113 insertions(+), 42 deletions(-) create mode 100644 mlir/test/Conversion/SCFToEmitC/nest_for_if.mlir diff --git a/mlir/include/mlir/Conversion/SCFToEmitC/SCFToEmitC.h b/mlir/include/mlir/Conversion/SCFToEmitC/SCFToEmitC.h index 22df7f1c5dcf2..acc39e6acf726 100644 --- a/mlir/include/mlir/Conversion/SCFToEmitC/SCFToEmitC.h +++ b/mlir/include/mlir/Conversion/SCFToEmitC/SCFToEmitC.h @@ -9,6 +9,7 @@ #ifndef MLIR_CONVERSION_SCFTOEMITC_SCFTOEMITC_H #define MLIR_CONVERSION_SCFTOEMITC_SCFTOEMITC_H +#include "mlir/Transforms/DialectConversion.h" #include namespace mlir { @@ -19,7 +20,8 @@ class RewritePatternSet; #include "mlir/Conversion/Passes.h.inc" /// Collect a set of patterns to convert SCF operations to the EmitC dialect. -void populateSCFToEmitCConversionPatterns(RewritePatternSet &patterns); +void populateSCFToEmitCConversionPatterns(RewritePatternSet &patterns, + TypeConverter &typeConverter); } // namespace mlir #endif // MLIR_CONVERSION_SCFTOEMITC_SCFTOEMITC_H diff --git a/mlir/lib/Conversion/SCFToEmitC/SCFToEmitC.cpp b/mlir/lib/Conversion/SCFToEmitC/SCFToEmitC.cpp index 367142a520742..b1e4ec289f737 100644 --- a/mlir/lib/Conversion/SCFToEmitC/SCFToEmitC.cpp +++ b/mlir/lib/Conversion/SCFToEmitC/SCFToEmitC.cpp @@ -14,6 +14,7 @@ #include "mlir/Dialect/Arith/IR/Arith.h" #include "mlir/Dialect/EmitC/IR/EmitC.h" +#include "mlir/Dialect/EmitC/Transforms/TypeConversions.h" #include "mlir/Dialect/SCF/IR/SCF.h" #include "mlir/IR/Builders.h" #include "mlir/IR/BuiltinOps.h" @@ -21,7 +22,9 @@ #include "mlir/IR/MLIRContext.h" #include "mlir/IR/PatternMatch.h" #include "mlir/Transforms/DialectConversion.h" +#include "mlir/Transforms/OneToNTypeConversion.h" #include "mlir/Transforms/Passes.h" +#include namespace mlir { #define GEN_PASS_DEF_SCFTOEMITC @@ -39,21 +42,22 @@ struct SCFToEmitCPass : public impl::SCFToEmitCBase { // Lower scf::for to emitc::for, implementing result values using // emitc::variable's updated within the loop body. -struct ForLowering : public OpRewritePattern { - using OpRewritePattern::OpRewritePattern; +struct ForLowering : public OpConversionPattern { + using OpConversionPattern::OpConversionPattern; - LogicalResult matchAndRewrite(ForOp forOp, - PatternRewriter &rewriter) const override; + LogicalResult + matchAndRewrite(ForOp forOp, OpAdaptor adaptor, + ConversionPatternRewriter &rewriter) const override; }; // Create an uninitialized emitc::variable op for each result of the given op. template -static SmallVector createVariablesForResults(T op, - PatternRewriter &rewriter) { - SmallVector resultVariables; - +static LogicalResult +createVariablesForResults(T op, const TypeConverter *typeConverter, + ConversionPatternRewriter &rewriter, + SmallVector &resultVariables) { if (!op.getNumResults()) - return resultVariables; + return success(); Location loc = op->getLoc(); MLIRContext *context = op.getContext(); @@ -62,26 +66,29 @@ static SmallVector createVariablesForResults(T op, rewriter.setInsertionPoint(op); for (OpResult result : op.getResults()) { - Type resultType = result.getType(); + Type resultType = typeConverter->convertType(result.getType()); + if (!resultType) + return rewriter.notifyMatchFailure(op, "result type conversion failed"); emitc::OpaqueAttr noInit = emitc::OpaqueAttr::get(context, ""); emitc::VariableOp var = rewriter.create(loc, resultType, noInit); resultVariables.push_back(var); } - return resultVariables; + return success(); } // Create a series of assign ops assigning given values to given variables at // the current insertion point of given rewriter. static void assignValues(ValueRange values, SmallVector &variables, - PatternRewriter &rewriter, Location loc) { + ConversionPatternRewriter &rewriter, Location loc) { for (auto [value, var] : llvm::zip(values, variables)) rewriter.create(loc, var, value); } static void lowerYield(SmallVector &resultVariables, - PatternRewriter &rewriter, scf::YieldOp yield) { + ConversionPatternRewriter &rewriter, + scf::YieldOp yield) { Location loc = yield.getLoc(); ValueRange operands = yield.getOperands(); @@ -94,21 +101,28 @@ static void lowerYield(SmallVector &resultVariables, rewriter.eraseOp(yield); } -LogicalResult ForLowering::matchAndRewrite(ForOp forOp, - PatternRewriter &rewriter) const { +LogicalResult +ForLowering::matchAndRewrite(ForOp forOp, OpAdaptor adaptor, + ConversionPatternRewriter &rewriter) const { Location loc = forOp.getLoc(); // Create an emitc::variable op for each result. These variables will be // assigned to by emitc::assign ops within the loop body. - SmallVector resultVariables = - createVariablesForResults(forOp, rewriter); - SmallVector iterArgsVariables = - createVariablesForResults(forOp, rewriter); + SmallVector resultVariables; + if (failed(createVariablesForResults(forOp, getTypeConverter(), rewriter, + resultVariables))) + return rewriter.notifyMatchFailure(forOp, + "create variables for results failed"); + SmallVector iterArgsVariables; + if (failed(createVariablesForResults(forOp, getTypeConverter(), rewriter, + iterArgsVariables))) + return rewriter.notifyMatchFailure(forOp, + "create variables for iter args failed"); assignValues(forOp.getInits(), iterArgsVariables, rewriter, loc); emitc::ForOp loweredFor = rewriter.create( - loc, forOp.getLowerBound(), forOp.getUpperBound(), forOp.getStep()); + loc, adaptor.getLowerBound(), adaptor.getUpperBound(), adaptor.getStep()); Block *loweredBody = loweredFor.getBody(); @@ -119,7 +133,8 @@ LogicalResult ForLowering::matchAndRewrite(ForOp forOp, replacingValues.push_back(loweredFor.getInductionVar()); replacingValues.append(iterArgsVariables.begin(), iterArgsVariables.end()); - rewriter.mergeBlocks(forOp.getBody(), loweredBody, replacingValues); + Block *adaptorBody = &(adaptor.getRegion().front()); + rewriter.mergeBlocks(adaptorBody, loweredBody, replacingValues); lowerYield(iterArgsVariables, rewriter, cast(loweredBody->getTerminator())); @@ -132,23 +147,28 @@ LogicalResult ForLowering::matchAndRewrite(ForOp forOp, // Lower scf::if to emitc::if, implementing result values as emitc::variable's // updated within the then and else regions. -struct IfLowering : public OpRewritePattern { - using OpRewritePattern::OpRewritePattern; +struct IfLowering : public OpConversionPattern { + using OpConversionPattern::OpConversionPattern; - LogicalResult matchAndRewrite(IfOp ifOp, - PatternRewriter &rewriter) const override; + LogicalResult + matchAndRewrite(IfOp ifOp, OpAdaptor adaptor, + ConversionPatternRewriter &rewriter) const override; }; } // namespace -LogicalResult IfLowering::matchAndRewrite(IfOp ifOp, - PatternRewriter &rewriter) const { +LogicalResult +IfLowering::matchAndRewrite(IfOp ifOp, OpAdaptor adaptor, + ConversionPatternRewriter &rewriter) const { Location loc = ifOp.getLoc(); // Create an emitc::variable op for each result. These variables will be // assigned to by emitc::assign ops within the then & else regions. - SmallVector resultVariables = - createVariablesForResults(ifOp, rewriter); + SmallVector resultVariables; + if (failed(createVariablesForResults(ifOp, getTypeConverter(), rewriter, + resultVariables))) + return rewriter.notifyMatchFailure(ifOp, + "create variables for results failed"); // Utility function to lower the contents of an scf::if region to an emitc::if // region. The contents of the scf::if regions is moved into the respective @@ -162,13 +182,13 @@ LogicalResult IfLowering::matchAndRewrite(IfOp ifOp, lowerYield(resultVariables, rewriter, cast(terminator)); }; - Region &thenRegion = ifOp.getThenRegion(); - Region &elseRegion = ifOp.getElseRegion(); + Region &thenRegion = adaptor.getThenRegion(); + Region &elseRegion = adaptor.getElseRegion(); bool hasElseBlock = !elseRegion.empty(); auto loweredIf = - rewriter.create(loc, ifOp.getCondition(), false, false); + rewriter.create(loc, adaptor.getCondition(), false, false); Region &loweredThenRegion = loweredIf.getThenRegion(); lowerRegion(thenRegion, loweredThenRegion); @@ -182,18 +202,22 @@ LogicalResult IfLowering::matchAndRewrite(IfOp ifOp, return success(); } -void mlir::populateSCFToEmitCConversionPatterns(RewritePatternSet &patterns) { - patterns.add(patterns.getContext()); - patterns.add(patterns.getContext()); +void mlir::populateSCFToEmitCConversionPatterns(RewritePatternSet &patterns, + TypeConverter &typeConverter) { + patterns.add(typeConverter, patterns.getContext()); + patterns.add(typeConverter, patterns.getContext()); } void SCFToEmitCPass::runOnOperation() { RewritePatternSet patterns(&getContext()); - populateSCFToEmitCConversionPatterns(patterns); + TypeConverter typeConverter; + populateEmitCSizeTypeConversions(typeConverter); + populateEmitCDefaultTypeConversions(typeConverter); + populateSCFToEmitCConversionPatterns(patterns, typeConverter); // Configure conversion to lower out SCF operations. ConversionTarget target(getContext()); - target.addIllegalOp(); + target.addIllegalOp(); target.markUnknownOpDynamicallyLegal([](Operation *) { return true; }); if (failed( applyPartialConversion(getOperation(), target, std::move(patterns)))) diff --git a/mlir/test/Conversion/SCFToEmitC/for.mlir b/mlir/test/Conversion/SCFToEmitC/for.mlir index 7f90310af2189..ca8a6fb1f5905 100644 --- a/mlir/test/Conversion/SCFToEmitC/for.mlir +++ b/mlir/test/Conversion/SCFToEmitC/for.mlir @@ -7,7 +7,10 @@ func.func @simple_std_for_loop(%arg0 : index, %arg1 : index, %arg2 : index) { return } // CHECK-LABEL: func.func @simple_std_for_loop( -// CHECK-SAME: %[[VAL_0:.*]]: index, %[[VAL_1:.*]]: index, %[[VAL_2:.*]]: index) { +// CHECK-SAME: %[[ARG_0:.*]]: index, %[[ARG_1:.*]]: index, %[[ARG_2:.*]]: index) { +// CHECK-NEXT: %[[VAL_0:.*]] = builtin.unrealized_conversion_cast %[[ARG_0]] : index to !emitc.size_t +// CHECK-NEXT: %[[VAL_1:.*]] = builtin.unrealized_conversion_cast %[[ARG_1]] : index to !emitc.size_t +// CHECK-NEXT: %[[VAL_2:.*]] = builtin.unrealized_conversion_cast %[[ARG_2]] : index to !emitc.size_t // CHECK-NEXT: emitc.for %[[VAL_3:.*]] = %[[VAL_0]] to %[[VAL_1]] step %[[VAL_2]] { // CHECK-NEXT: %[[VAL_4:.*]] = arith.constant 1 : index // CHECK-NEXT: } @@ -24,7 +27,10 @@ func.func @simple_std_2_for_loops(%arg0 : index, %arg1 : index, %arg2 : index) { return } // CHECK-LABEL: func.func @simple_std_2_for_loops( -// CHECK-SAME: %[[VAL_0:.*]]: index, %[[VAL_1:.*]]: index, %[[VAL_2:.*]]: index) { +// CHECK-SAME: %[[ARG_0:.*]]: index, %[[ARG_1:.*]]: index, %[[ARG_2:.*]]: index) { +// CHECK-NEXT: %[[VAL_0:.*]] = builtin.unrealized_conversion_cast %[[ARG_0]] : index to !emitc.size_t +// CHECK-NEXT: %[[VAL_1:.*]] = builtin.unrealized_conversion_cast %[[ARG_1]] : index to !emitc.size_t +// CHECK-NEXT: %[[VAL_2:.*]] = builtin.unrealized_conversion_cast %[[ARG_2]] : index to !emitc.size_t // CHECK-NEXT: emitc.for %[[VAL_3:.*]] = %[[VAL_0]] to %[[VAL_1]] step %[[VAL_2]] { // CHECK-NEXT: %[[VAL_4:.*]] = arith.constant 1 : index // CHECK-NEXT: emitc.for %[[VAL_5:.*]] = %[[VAL_0]] to %[[VAL_1]] step %[[VAL_2]] { @@ -44,7 +50,10 @@ func.func @for_yield(%arg0 : index, %arg1 : index, %arg2 : index) -> (f32, f32) return %result#0, %result#1 : f32, f32 } // CHECK-LABEL: func.func @for_yield( -// CHECK-SAME: %[[VAL_0:.*]]: index, %[[VAL_1:.*]]: index, %[[VAL_2:.*]]: index) -> (f32, f32) { +// CHECK-SAME: %[[ARG_0:.*]]: index, %[[ARG_1:.*]]: index, %[[ARG_2:.*]]: index) -> (f32, f32) { +// CHECK-NEXT: %[[VAL_0:.*]] = builtin.unrealized_conversion_cast %[[ARG_0]] : index to !emitc.size_t +// CHECK-NEXT: %[[VAL_1:.*]] = builtin.unrealized_conversion_cast %[[ARG_1]] : index to !emitc.size_t +// CHECK-NEXT: %[[VAL_2:.*]] = builtin.unrealized_conversion_cast %[[ARG_2]] : index to !emitc.size_t // CHECK-NEXT: %[[VAL_3:.*]] = arith.constant 0.000000e+00 : f32 // CHECK-NEXT: %[[VAL_4:.*]] = arith.constant 1.000000e+00 : f32 // CHECK-NEXT: %[[VAL_5:.*]] = "emitc.variable"() <{value = #emitc.opaque<"">}> : () -> f32 @@ -75,7 +84,10 @@ func.func @nested_for_yield(%arg0 : index, %arg1 : index, %arg2 : index) -> f32 return %r : f32 } // CHECK-LABEL: func.func @nested_for_yield( -// CHECK-SAME: %[[VAL_0:.*]]: index, %[[VAL_1:.*]]: index, %[[VAL_2:.*]]: index) -> f32 { +// CHECK-SAME: %[[ARG_0:.*]]: index, %[[ARG_1:.*]]: index, %[[ARG_2:.*]]: index) -> f32 { +// CHECK-NEXT: %[[VAL_0:.*]] = builtin.unrealized_conversion_cast %[[ARG_0]] : index to !emitc.size_t +// CHECK-NEXT: %[[VAL_1:.*]] = builtin.unrealized_conversion_cast %[[ARG_1]] : index to !emitc.size_t +// CHECK-NEXT: %[[VAL_2:.*]] = builtin.unrealized_conversion_cast %[[ARG_2]] : index to !emitc.size_t // CHECK-NEXT: %[[VAL_3:.*]] = arith.constant 1.000000e+00 : f32 // CHECK-NEXT: %[[VAL_4:.*]] = "emitc.variable"() <{value = #emitc.opaque<"">}> : () -> f32 // CHECK-NEXT: %[[VAL_5:.*]] = "emitc.variable"() <{value = #emitc.opaque<"">}> : () -> f32 diff --git a/mlir/test/Conversion/SCFToEmitC/nest_for_if.mlir b/mlir/test/Conversion/SCFToEmitC/nest_for_if.mlir new file mode 100644 index 0000000000000..5e0cfd6f57e81 --- /dev/null +++ b/mlir/test/Conversion/SCFToEmitC/nest_for_if.mlir @@ -0,0 +1,33 @@ +// RUN: mlir-opt -allow-unregistered-dialect -convert-scf-to-emitc %s | FileCheck %s + +// CHECK-LABEL: func.func @nest_for_in_if +// CHECK-SAME: %[[ARG_0:.*]]: i1, %[[ARG_1:.*]]: index, %[[ARG_2:.*]]: index, %[[ARG_3:.*]]: index, %[[ARG_4:.*]]: f32 +// CHECK-NEXT: %[[CAST_0:.*]] = builtin.unrealized_conversion_cast %[[ARG_1]] : index to !emitc.size_t +// CHECK-NEXT: %[[CAST_1:.*]] = builtin.unrealized_conversion_cast %[[ARG_2]] : index to !emitc.size_t +// CHECK-NEXT: %[[CAST_2:.*]] = builtin.unrealized_conversion_cast %[[ARG_3]] : index to !emitc.size_t +// CHECK-NEXT: emitc.if %[[ARG_0]] { +// CHECK-NEXT: emitc.for %[[ARG_5:.*]] = %[[CAST_0]] to %[[CAST_1]] step %[[CAST_2]] { +// CHECK-NEXT: %[[CST_1:.*]] = arith.constant 1 : index +// CHECK-NEXT: %[[CAST_3:.*]] = builtin.unrealized_conversion_cast %[[CST_1]] : index to !emitc.size_t +// CHECK-NEXT: emitc.for %[[ARG_6:.*]] = %[[CAST_0]] to %[[CAST_1]] step %[[CAST_3]] { +// CHECK-NEXT: %[[CST_2:.*]] = arith.constant 1 : index +// CHECK-NEXT: } +// CHECK-NEXT: } +// CHECK-NEXT: } else { +// CHECK-NEXT: %3 = emitc.call_opaque "func_false"(%[[ARG_4]]) : (f32) -> i32 +// CHECK-NEXT: } +// CHECK-NEXT: return +// CHECK-NEXT: } +func.func @nest_for_in_if(%arg0: i1, %arg1: index, %arg2: index, %arg3: index, %arg4: f32) { + scf.if %arg0 { + scf.for %i0 = %arg1 to %arg2 step %arg3 { + %c1 = arith.constant 1 : index + scf.for %i1 = %arg1 to %arg2 step %c1 { + %c1_0 = arith.constant 1 : index + } + } + } else { + %0 = emitc.call_opaque "func_false"(%arg4) : (f32) -> i32 + } + return +} \ No newline at end of file From 3f742210c6adf5fe04702dcd391d9ad4a7547aec Mon Sep 17 00:00:00 2001 From: Corentin Ferry Date: Fri, 17 May 2024 10:31:02 +0100 Subject: [PATCH 08/17] Nits --- mlir/include/mlir/Dialect/EmitC/Transforms/TypeConversions.h | 5 +++++ mlir/lib/Dialect/EmitC/Transforms/TypeConversions.cpp | 2 +- mlir/test/Conversion/FuncToEmitC/func-to-emitc.mlir | 2 +- .../SCFToEmitC/{nest_for_if.mlir => nest-for-if.mlir} | 2 +- 4 files changed, 8 insertions(+), 3 deletions(-) rename mlir/test/Conversion/SCFToEmitC/{nest_for_if.mlir => nest-for-if.mlir} (99%) diff --git a/mlir/include/mlir/Dialect/EmitC/Transforms/TypeConversions.h b/mlir/include/mlir/Dialect/EmitC/Transforms/TypeConversions.h index 3ff5d249c1f28..0bb360f1ebe5e 100644 --- a/mlir/include/mlir/Dialect/EmitC/Transforms/TypeConversions.h +++ b/mlir/include/mlir/Dialect/EmitC/Transforms/TypeConversions.h @@ -6,9 +6,14 @@ // //===----------------------------------------------------------------------===// +#ifndef MLIR_DIALECT_EMITC_TRANSFORMS_TYPECONVERSIONS_H +#define MLIR_DIALECT_EMITC_TRANSFORMS_TYPECONVERSIONS_H + #include "mlir/Transforms/DialectConversion.h" namespace mlir { void populateEmitCSizeTypeConversions(mlir::TypeConverter &converter); void populateEmitCDefaultTypeConversions(TypeConverter &converter); } // namespace mlir + +#endif // MLIR_DIALECT_EMITC_TRANSFORMS_TYPECONVERSIONS_H \ No newline at end of file diff --git a/mlir/lib/Dialect/EmitC/Transforms/TypeConversions.cpp b/mlir/lib/Dialect/EmitC/Transforms/TypeConversions.cpp index c4acd91214ce1..784ed0f331076 100644 --- a/mlir/lib/Dialect/EmitC/Transforms/TypeConversions.cpp +++ b/mlir/lib/Dialect/EmitC/Transforms/TypeConversions.cpp @@ -43,4 +43,4 @@ void mlir::populateEmitCDefaultTypeConversions(TypeConverter &converter) { return type; return std::nullopt; }); -} \ No newline at end of file +} diff --git a/mlir/test/Conversion/FuncToEmitC/func-to-emitc.mlir b/mlir/test/Conversion/FuncToEmitC/func-to-emitc.mlir index 176a3e48dcbeb..854d8f3604f44 100644 --- a/mlir/test/Conversion/FuncToEmitC/func-to-emitc.mlir +++ b/mlir/test/Conversion/FuncToEmitC/func-to-emitc.mlir @@ -87,4 +87,4 @@ func.func @call(%arg0: index) -> index { func.func @index_args_only(%i: index) -> f32 { %0 = arith.constant 0.0 : f32 return %0 : f32 -} \ No newline at end of file +} diff --git a/mlir/test/Conversion/SCFToEmitC/nest_for_if.mlir b/mlir/test/Conversion/SCFToEmitC/nest-for-if.mlir similarity index 99% rename from mlir/test/Conversion/SCFToEmitC/nest_for_if.mlir rename to mlir/test/Conversion/SCFToEmitC/nest-for-if.mlir index 5e0cfd6f57e81..572ec657483ab 100644 --- a/mlir/test/Conversion/SCFToEmitC/nest_for_if.mlir +++ b/mlir/test/Conversion/SCFToEmitC/nest-for-if.mlir @@ -30,4 +30,4 @@ func.func @nest_for_in_if(%arg0: i1, %arg1: index, %arg2: index, %arg3: index, % %0 = emitc.call_opaque "func_false"(%arg4) : (f32) -> i32 } return -} \ No newline at end of file +} From 076fb0b5138a97475585c483013406da974fb945 Mon Sep 17 00:00:00 2001 From: Corentin Ferry Date: Fri, 17 May 2024 10:32:05 +0100 Subject: [PATCH 09/17] Forgot to add empty line --- mlir/include/mlir/Dialect/EmitC/Transforms/TypeConversions.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mlir/include/mlir/Dialect/EmitC/Transforms/TypeConversions.h b/mlir/include/mlir/Dialect/EmitC/Transforms/TypeConversions.h index 0bb360f1ebe5e..9abd8dc9dacd8 100644 --- a/mlir/include/mlir/Dialect/EmitC/Transforms/TypeConversions.h +++ b/mlir/include/mlir/Dialect/EmitC/Transforms/TypeConversions.h @@ -16,4 +16,4 @@ void populateEmitCSizeTypeConversions(mlir::TypeConverter &converter); void populateEmitCDefaultTypeConversions(TypeConverter &converter); } // namespace mlir -#endif // MLIR_DIALECT_EMITC_TRANSFORMS_TYPECONVERSIONS_H \ No newline at end of file +#endif // MLIR_DIALECT_EMITC_TRANSFORMS_TYPECONVERSIONS_H From 13df9432e7bfa4ba660cefcc0f7e0da582ae0937 Mon Sep 17 00:00:00 2001 From: Corentin Ferry Date: Fri, 17 May 2024 11:57:27 +0100 Subject: [PATCH 10/17] index is a valid data type for array --- .../mlir/Dialect/EmitC/IR/EmitCTypes.td | 1 + .../MemRefToEmitC/memref-to-emitc.mlir | 22 +++++++++++++++++++ 2 files changed, 23 insertions(+) diff --git a/mlir/include/mlir/Dialect/EmitC/IR/EmitCTypes.td b/mlir/include/mlir/Dialect/EmitC/IR/EmitCTypes.td index 0f080ac443327..f6a8bd4ef59e1 100644 --- a/mlir/include/mlir/Dialect/EmitC/IR/EmitCTypes.td +++ b/mlir/include/mlir/Dialect/EmitC/IR/EmitCTypes.td @@ -76,6 +76,7 @@ def EmitC_ArrayType : EmitC_Type<"Array", "array", [ShapedTypeInterface]> { static bool isValidElementType(Type type) { return type.isIntOrIndexOrFloat() || + emitc::isAnySizeTType(type) || llvm::isa(type); } }]; diff --git a/mlir/test/Conversion/MemRefToEmitC/memref-to-emitc.mlir b/mlir/test/Conversion/MemRefToEmitC/memref-to-emitc.mlir index 093ceb304d97f..7e7568dd6e6af 100644 --- a/mlir/test/Conversion/MemRefToEmitC/memref-to-emitc.mlir +++ b/mlir/test/Conversion/MemRefToEmitC/memref-to-emitc.mlir @@ -51,3 +51,25 @@ module @globals { return } } + +// ----- + +// CHECK-LABEL: memref_index_values +// CHECK-SAME: %[[argi:.*]]: index, %[[argj:.*]]: index +// CHECK-SAME -> index +func.func @memref_index_values(%i: index, %j: index) -> index { + // CHECK: %[[i:.*]] = builtin.unrealized_conversion_cast %[[argi]] : index to !emitc.size_t + // CHECK: %[[j:.*]] = builtin.unrealized_conversion_cast %[[argj]] : index to !emitc.size_t + + // CHECK: %[[ALLOCA:.*]] = "emitc.variable"() <{value = #emitc.opaque<"">}> : () -> !emitc.array<4x8x!emitc.size_t> + %0 = memref.alloca() : memref<4x8xindex> + + // CHECK: %[[LOAD:.*]] = emitc.subscript %[[ALLOCA]][%[[i]], %[[j]]] : (!emitc.array<4x8x!emitc.size_t>, !emitc.size_t, !emitc.size_t) -> !emitc.size_t + // CHECK: %[[VAR:.*]] = "emitc.variable"() <{value = #emitc.opaque<"">}> : () -> !emitc.size_t + // CHECK: emitc.assign %[[LOAD]] : !emitc.size_t to %[[VAR]] : !emitc.size_t + %1 = memref.load %0[%i, %j] : memref<4x8xindex> + + // CHECK: %[[CAST_RET:.*]] = builtin.unrealized_conversion_cast %[[VAR]] : !emitc.size_t to index + // CHECK: return %[[CAST_RET]] : index + return %1 : index +} From dd382252072106981777e73c25ec49dcbaae9122 Mon Sep 17 00:00:00 2001 From: Corentin Ferry Date: Fri, 17 May 2024 12:27:30 +0100 Subject: [PATCH 11/17] Review comments --- mlir/include/mlir/Dialect/EmitC/Transforms/TypeConversions.h | 2 +- mlir/lib/Conversion/SCFToEmitC/SCFToEmitC.cpp | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/mlir/include/mlir/Dialect/EmitC/Transforms/TypeConversions.h b/mlir/include/mlir/Dialect/EmitC/Transforms/TypeConversions.h index 9abd8dc9dacd8..cfe64642f476a 100644 --- a/mlir/include/mlir/Dialect/EmitC/Transforms/TypeConversions.h +++ b/mlir/include/mlir/Dialect/EmitC/Transforms/TypeConversions.h @@ -12,7 +12,7 @@ #include "mlir/Transforms/DialectConversion.h" namespace mlir { -void populateEmitCSizeTypeConversions(mlir::TypeConverter &converter); +void populateEmitCSizeTypeConversions(TypeConverter &converter); void populateEmitCDefaultTypeConversions(TypeConverter &converter); } // namespace mlir diff --git a/mlir/lib/Conversion/SCFToEmitC/SCFToEmitC.cpp b/mlir/lib/Conversion/SCFToEmitC/SCFToEmitC.cpp index b1e4ec289f737..7491d04d1248e 100644 --- a/mlir/lib/Conversion/SCFToEmitC/SCFToEmitC.cpp +++ b/mlir/lib/Conversion/SCFToEmitC/SCFToEmitC.cpp @@ -217,7 +217,7 @@ void SCFToEmitCPass::runOnOperation() { // Configure conversion to lower out SCF operations. ConversionTarget target(getContext()); - target.addIllegalOp(); + target.addIllegalOp(); target.markUnknownOpDynamicallyLegal([](Operation *) { return true; }); if (failed( applyPartialConversion(getOperation(), target, std::move(patterns)))) From f943f1e524130475ae7bf6b6a867a70965151afc Mon Sep 17 00:00:00 2001 From: Corentin Ferry Date: Fri, 17 May 2024 13:55:02 +0100 Subject: [PATCH 12/17] Fallback converter: use note --- .../mlir/Dialect/EmitC/Transforms/TypeConversions.h | 1 - mlir/lib/Conversion/ArithToEmitC/ArithToEmitCPass.cpp | 5 ++++- mlir/lib/Conversion/FuncToEmitC/FuncToEmitCPass.cpp | 5 ++++- mlir/lib/Conversion/SCFToEmitC/SCFToEmitC.cpp | 5 ++++- mlir/lib/Dialect/EmitC/Transforms/TypeConversions.cpp | 10 +--------- 5 files changed, 13 insertions(+), 13 deletions(-) diff --git a/mlir/include/mlir/Dialect/EmitC/Transforms/TypeConversions.h b/mlir/include/mlir/Dialect/EmitC/Transforms/TypeConversions.h index cfe64642f476a..db29f4603e2c0 100644 --- a/mlir/include/mlir/Dialect/EmitC/Transforms/TypeConversions.h +++ b/mlir/include/mlir/Dialect/EmitC/Transforms/TypeConversions.h @@ -13,7 +13,6 @@ namespace mlir { void populateEmitCSizeTypeConversions(TypeConverter &converter); -void populateEmitCDefaultTypeConversions(TypeConverter &converter); } // namespace mlir #endif // MLIR_DIALECT_EMITC_TRANSFORMS_TYPECONVERSIONS_H diff --git a/mlir/lib/Conversion/ArithToEmitC/ArithToEmitCPass.cpp b/mlir/lib/Conversion/ArithToEmitC/ArithToEmitCPass.cpp index 69ea0fad21ec9..a96c4744f353f 100644 --- a/mlir/lib/Conversion/ArithToEmitC/ArithToEmitCPass.cpp +++ b/mlir/lib/Conversion/ArithToEmitC/ArithToEmitCPass.cpp @@ -44,8 +44,11 @@ void ConvertArithToEmitC::runOnOperation() { RewritePatternSet patterns(&getContext()); TypeConverter typeConverter; + // Fallback converter + // See note https://mlir.llvm.org/docs/DialectConversion/#type-converter + // Type converters are called most to least recently inserted + typeConverter.addConversion([](Type t) { return t; }); populateArithToEmitCPatterns(typeConverter, patterns); - populateEmitCDefaultTypeConversions(typeConverter); if (failed( applyPartialConversion(getOperation(), target, std::move(patterns)))) diff --git a/mlir/lib/Conversion/FuncToEmitC/FuncToEmitCPass.cpp b/mlir/lib/Conversion/FuncToEmitC/FuncToEmitCPass.cpp index 921fd66b12eb9..372fccb8ee9b5 100644 --- a/mlir/lib/Conversion/FuncToEmitC/FuncToEmitCPass.cpp +++ b/mlir/lib/Conversion/FuncToEmitC/FuncToEmitCPass.cpp @@ -72,8 +72,11 @@ void ConvertFuncToEmitC::runOnOperation() { RewritePatternSet interfaceRewritePatterns(&getContext()); TypeConverter typeConverter; + // Fallback converter + // See note https://mlir.llvm.org/docs/DialectConversion/#type-converter + // Type converters are called most to least recently inserted + typeConverter.addConversion([](Type t) { return t; }); populateEmitCSizeTypeConversions(typeConverter); - populateEmitCDefaultTypeConversions(typeConverter); populateReturnOpTypeConversionPattern(interfaceRewritePatterns, typeConverter); populateCallOpTypeConversionPattern(interfaceRewritePatterns, typeConverter); diff --git a/mlir/lib/Conversion/SCFToEmitC/SCFToEmitC.cpp b/mlir/lib/Conversion/SCFToEmitC/SCFToEmitC.cpp index 7491d04d1248e..5344dfa56196d 100644 --- a/mlir/lib/Conversion/SCFToEmitC/SCFToEmitC.cpp +++ b/mlir/lib/Conversion/SCFToEmitC/SCFToEmitC.cpp @@ -211,8 +211,11 @@ void mlir::populateSCFToEmitCConversionPatterns(RewritePatternSet &patterns, void SCFToEmitCPass::runOnOperation() { RewritePatternSet patterns(&getContext()); TypeConverter typeConverter; + // Fallback converter + // See note https://mlir.llvm.org/docs/DialectConversion/#type-converter + // Type converters are called most to least recently inserted + typeConverter.addConversion([](Type t) { return t; }); populateEmitCSizeTypeConversions(typeConverter); - populateEmitCDefaultTypeConversions(typeConverter); populateSCFToEmitCConversionPatterns(patterns, typeConverter); // Configure conversion to lower out SCF operations. diff --git a/mlir/lib/Dialect/EmitC/Transforms/TypeConversions.cpp b/mlir/lib/Dialect/EmitC/Transforms/TypeConversions.cpp index 784ed0f331076..eeb3f22334bf1 100644 --- a/mlir/lib/Dialect/EmitC/Transforms/TypeConversions.cpp +++ b/mlir/lib/Dialect/EmitC/Transforms/TypeConversions.cpp @@ -35,12 +35,4 @@ void mlir::populateEmitCSizeTypeConversions(TypeConverter &converter) { converter.addSourceMaterialization(materializeAsUnrealizedCast); converter.addTargetMaterialization(materializeAsUnrealizedCast); converter.addArgumentMaterialization(materializeAsUnrealizedCast); -} - -void mlir::populateEmitCDefaultTypeConversions(TypeConverter &converter) { - converter.addConversion([](Type type) -> std::optional { - if (!isa(type)) - return type; - return std::nullopt; - }); -} +} \ No newline at end of file From e03e7504129b6e50ddc0fe0d97ccdf4c8acd4bad Mon Sep 17 00:00:00 2001 From: Corentin Ferry Date: Tue, 21 May 2024 07:11:36 +0100 Subject: [PATCH 13/17] Typo --- mlir/test/Conversion/MemRefToEmitC/memref-to-emitc.mlir | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mlir/test/Conversion/MemRefToEmitC/memref-to-emitc.mlir b/mlir/test/Conversion/MemRefToEmitC/memref-to-emitc.mlir index 7e7568dd6e6af..ffb0e10d80893 100644 --- a/mlir/test/Conversion/MemRefToEmitC/memref-to-emitc.mlir +++ b/mlir/test/Conversion/MemRefToEmitC/memref-to-emitc.mlir @@ -56,7 +56,7 @@ module @globals { // CHECK-LABEL: memref_index_values // CHECK-SAME: %[[argi:.*]]: index, %[[argj:.*]]: index -// CHECK-SAME -> index +// CHECK-SAME: -> index func.func @memref_index_values(%i: index, %j: index) -> index { // CHECK: %[[i:.*]] = builtin.unrealized_conversion_cast %[[argi]] : index to !emitc.size_t // CHECK: %[[j:.*]] = builtin.unrealized_conversion_cast %[[argj]] : index to !emitc.size_t From f88f79a93ae40feea0921df1c8ea0662456ff5ef Mon Sep 17 00:00:00 2001 From: Corentin Ferry Date: Tue, 21 May 2024 07:14:22 +0100 Subject: [PATCH 14/17] Swap ArithToEmitC pass arguments like other passes --- mlir/include/mlir/Conversion/ArithToEmitC/ArithToEmitC.h | 4 ++-- mlir/lib/Conversion/ArithToEmitC/ArithToEmitC.cpp | 4 ++-- mlir/lib/Conversion/ArithToEmitC/ArithToEmitCPass.cpp | 2 +- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/mlir/include/mlir/Conversion/ArithToEmitC/ArithToEmitC.h b/mlir/include/mlir/Conversion/ArithToEmitC/ArithToEmitC.h index 9cb43689d1ce6..9ef053f1e6636 100644 --- a/mlir/include/mlir/Conversion/ArithToEmitC/ArithToEmitC.h +++ b/mlir/include/mlir/Conversion/ArithToEmitC/ArithToEmitC.h @@ -13,8 +13,8 @@ namespace mlir { class RewritePatternSet; class TypeConverter; -void populateArithToEmitCPatterns(TypeConverter &typeConverter, - RewritePatternSet &patterns); +void populateArithToEmitCPatterns(RewritePatternSet &patterns, + TypeConverter &typeConverter); } // namespace mlir #endif // MLIR_CONVERSION_ARITHTOEMITC_ARITHTOEMITC_H diff --git a/mlir/lib/Conversion/ArithToEmitC/ArithToEmitC.cpp b/mlir/lib/Conversion/ArithToEmitC/ArithToEmitC.cpp index 5449cbc3792c2..04344b2c2ab3c 100644 --- a/mlir/lib/Conversion/ArithToEmitC/ArithToEmitC.cpp +++ b/mlir/lib/Conversion/ArithToEmitC/ArithToEmitC.cpp @@ -563,8 +563,8 @@ class ItoFCastOpConversion : public OpConversionPattern { // Pattern population //===----------------------------------------------------------------------===// -void mlir::populateArithToEmitCPatterns(TypeConverter &typeConverter, - RewritePatternSet &patterns) { +void mlir::populateArithToEmitCPatterns(RewritePatternSet &patterns, + TypeConverter &typeConverter) { MLIRContext *ctx = patterns.getContext(); mlir::populateEmitCSizeTypeConversions(typeConverter); diff --git a/mlir/lib/Conversion/ArithToEmitC/ArithToEmitCPass.cpp b/mlir/lib/Conversion/ArithToEmitC/ArithToEmitCPass.cpp index a96c4744f353f..7713506ef396b 100644 --- a/mlir/lib/Conversion/ArithToEmitC/ArithToEmitCPass.cpp +++ b/mlir/lib/Conversion/ArithToEmitC/ArithToEmitCPass.cpp @@ -48,7 +48,7 @@ void ConvertArithToEmitC::runOnOperation() { // See note https://mlir.llvm.org/docs/DialectConversion/#type-converter // Type converters are called most to least recently inserted typeConverter.addConversion([](Type t) { return t; }); - populateArithToEmitCPatterns(typeConverter, patterns); + populateArithToEmitCPatterns(patterns, typeConverter); if (failed( applyPartialConversion(getOperation(), target, std::move(patterns)))) From 42d2edb0955f95ce98827b66d19d36188dff9df9 Mon Sep 17 00:00:00 2001 From: Corentin Ferry Date: Tue, 21 May 2024 10:17:19 +0100 Subject: [PATCH 15/17] Perform type conversions within FuncToEmitC --- .../mlir/Conversion/FuncToEmitC/FuncToEmitC.h | 4 +- .../Conversion/FuncToEmitC/FuncToEmitC.cpp | 44 ++++++++++++++--- .../FuncToEmitC/FuncToEmitCPass.cpp | 47 +------------------ 3 files changed, 41 insertions(+), 54 deletions(-) diff --git a/mlir/include/mlir/Conversion/FuncToEmitC/FuncToEmitC.h b/mlir/include/mlir/Conversion/FuncToEmitC/FuncToEmitC.h index 5c7f87e470306..ac6fe2da7d42f 100644 --- a/mlir/include/mlir/Conversion/FuncToEmitC/FuncToEmitC.h +++ b/mlir/include/mlir/Conversion/FuncToEmitC/FuncToEmitC.h @@ -9,10 +9,12 @@ #ifndef MLIR_CONVERSION_FUNCTOEMITC_FUNCTOEMITC_H #define MLIR_CONVERSION_FUNCTOEMITC_FUNCTOEMITC_H +#include "mlir/Transforms/DialectConversion.h" namespace mlir { class RewritePatternSet; -void populateFuncToEmitCPatterns(RewritePatternSet &patterns); +void populateFuncToEmitCPatterns(RewritePatternSet &patterns, + TypeConverter &typeConverter); } // namespace mlir #endif // MLIR_CONVERSION_FUNCTOEMITC_FUNCTOEMITC_H diff --git a/mlir/lib/Conversion/FuncToEmitC/FuncToEmitC.cpp b/mlir/lib/Conversion/FuncToEmitC/FuncToEmitC.cpp index 6a8ecb7b00473..24ada1835c1ba 100644 --- a/mlir/lib/Conversion/FuncToEmitC/FuncToEmitC.cpp +++ b/mlir/lib/Conversion/FuncToEmitC/FuncToEmitC.cpp @@ -36,10 +36,17 @@ class CallOpConversion final : public OpConversionPattern { return rewriter.notifyMatchFailure( callOp, "only functions with zero or one result can be converted"); + // Convert the original function results. + Type resultTy = nullptr; + if (callOp.getNumResults()) { + resultTy = typeConverter->convertType(callOp.getResult(0).getType()); + if (!resultTy) + return rewriter.notifyMatchFailure( + callOp, "function return type conversion failed"); + } + rewriter.replaceOpWithNewOp( - callOp, - callOp.getNumResults() ? callOp.getResult(0).getType() : nullptr, - adaptor.getOperands(), callOp->getAttrs()); + callOp, resultTy, adaptor.getOperands(), callOp->getAttrs()); return success(); } @@ -53,13 +60,34 @@ class FuncOpConversion final : public OpConversionPattern { matchAndRewrite(func::FuncOp funcOp, OpAdaptor adaptor, ConversionPatternRewriter &rewriter) const override { - if (funcOp.getFunctionType().getNumResults() > 1) + FunctionType type = dyn_cast(funcOp.getFunctionType()); + if (!type) + return failure(); + + if (type.getNumResults() > 1) return rewriter.notifyMatchFailure( funcOp, "only functions with zero or one result can be converted"); + const TypeConverter *converter = getTypeConverter(); + + // Convert function signature + TypeConverter::SignatureConversion signatureConversion(type.getNumInputs()); + SmallVector convertedResults; + if (failed(converter->convertSignatureArgs(type.getInputs(), + signatureConversion)) || + failed(converter->convertTypes(type.getResults(), convertedResults)) || + failed(rewriter.convertRegionTypes(&funcOp.getFunctionBody(), + *converter, &signatureConversion))) + return rewriter.notifyMatchFailure(funcOp, "signature conversion failed"); + + // Convert the function type + auto convertedFunctionType = FunctionType::get( + rewriter.getContext(), signatureConversion.getConvertedTypes(), + convertedResults); + // Create the converted `emitc.func` op. emitc::FuncOp newFuncOp = rewriter.create( - funcOp.getLoc(), funcOp.getName(), funcOp.getFunctionType()); + funcOp.getLoc(), funcOp.getName(), convertedFunctionType); // Copy over all attributes other than the function name and type. for (const auto &namedAttr : funcOp->getAttrs()) { @@ -113,8 +141,10 @@ class ReturnOpConversion final : public OpConversionPattern { // Pattern population //===----------------------------------------------------------------------===// -void mlir::populateFuncToEmitCPatterns(RewritePatternSet &patterns) { +void mlir::populateFuncToEmitCPatterns(RewritePatternSet &patterns, + TypeConverter &typeConverter) { MLIRContext *ctx = patterns.getContext(); - patterns.add(ctx); + patterns.add( + typeConverter, ctx); } diff --git a/mlir/lib/Conversion/FuncToEmitC/FuncToEmitCPass.cpp b/mlir/lib/Conversion/FuncToEmitC/FuncToEmitCPass.cpp index 372fccb8ee9b5..19b8bcab4f7a3 100644 --- a/mlir/lib/Conversion/FuncToEmitC/FuncToEmitCPass.cpp +++ b/mlir/lib/Conversion/FuncToEmitC/FuncToEmitCPass.cpp @@ -36,65 +36,20 @@ struct ConvertFuncToEmitC } // namespace void ConvertFuncToEmitC::runOnOperation() { - // Convert function interface types within the func dialect first to supported - // EmitC types - ConversionTarget interfaceConversionTarget(getContext()); - interfaceConversionTarget.addDynamicallyLegalOp( - [](func::CallOp op) { - auto operandTypes = op->getOperandTypes(); - if (std::any_of(operandTypes.begin(), operandTypes.end(), - [](Type t) { return isa(t); })) - return false; - auto resultTypes = op.getResultTypes(); - return !(std::any_of(resultTypes.begin(), resultTypes.end(), - [](Type t) { return isa(t); })); - }); - interfaceConversionTarget.addDynamicallyLegalOp( - [](func::FuncOp op) { - auto operandTypes = op->getOperandTypes(); - if (std::any_of(operandTypes.begin(), operandTypes.end(), - [](Type t) { return isa(t); })) - return false; - auto argumentTypes = op.getArgumentTypes(); - if (std::any_of(argumentTypes.begin(), argumentTypes.end(), - [](Type t) { return isa(t); })) - return false; - auto resultTypes = op.getResultTypes(); - return !(std::any_of(resultTypes.begin(), resultTypes.end(), - [](Type t) { return isa(t); })); - }); - interfaceConversionTarget.addDynamicallyLegalOp( - [](func::ReturnOp op) { - auto operandTypes = op->getOperandTypes(); - return !(std::any_of(operandTypes.begin(), operandTypes.end(), - [](Type t) { return isa(t); })); - }); - - RewritePatternSet interfaceRewritePatterns(&getContext()); TypeConverter typeConverter; // Fallback converter // See note https://mlir.llvm.org/docs/DialectConversion/#type-converter // Type converters are called most to least recently inserted typeConverter.addConversion([](Type t) { return t; }); populateEmitCSizeTypeConversions(typeConverter); - populateReturnOpTypeConversionPattern(interfaceRewritePatterns, - typeConverter); - populateCallOpTypeConversionPattern(interfaceRewritePatterns, typeConverter); - populateFunctionOpInterfaceTypeConversionPattern( - interfaceRewritePatterns, typeConverter); - - if (failed(applyPartialConversion(getOperation(), interfaceConversionTarget, - std::move(interfaceRewritePatterns)))) - signalPassFailure(); - // Then convert the func ops themselves to EmitC ConversionTarget target(getContext()); target.addLegalDialect(); target.addIllegalOp(); RewritePatternSet patterns(&getContext()); - populateFuncToEmitCPatterns(patterns); + populateFuncToEmitCPatterns(patterns, typeConverter); if (failed( applyPartialConversion(getOperation(), target, std::move(patterns)))) From 4bce5879fc85151f6c3a2175ad9925be5e4d0f36 Mon Sep 17 00:00:00 2001 From: Corentin Ferry Date: Tue, 21 May 2024 10:21:51 +0100 Subject: [PATCH 16/17] Review comments --- mlir/lib/Conversion/MemRefToEmitC/MemRefToEmitCPass.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/mlir/lib/Conversion/MemRefToEmitC/MemRefToEmitCPass.cpp b/mlir/lib/Conversion/MemRefToEmitC/MemRefToEmitCPass.cpp index 5d948d2a09813..63ae47b32a590 100644 --- a/mlir/lib/Conversion/MemRefToEmitC/MemRefToEmitCPass.cpp +++ b/mlir/lib/Conversion/MemRefToEmitC/MemRefToEmitCPass.cpp @@ -34,9 +34,9 @@ struct ConvertMemRefToEmitCPass // Fallback for other types. converter.addConversion([](Type type) -> std::optional { - if (isa(type)) - return {}; - return type; + if (emitc::isSupportedEmitCType(type)) + return type; + return {}; }); populateMemRefToEmitCTypeConversion(converter); From 84dad58b0797063379e854d270824a6526756b87 Mon Sep 17 00:00:00 2001 From: Corentin Ferry Date: Tue, 21 May 2024 10:30:16 +0100 Subject: [PATCH 17/17] Review comments, bis --- mlir/include/mlir/Dialect/EmitC/Transforms/TypeConversions.h | 3 +-- mlir/lib/Conversion/FuncToEmitC/FuncToEmitC.cpp | 2 +- mlir/lib/Conversion/FuncToEmitC/FuncToEmitCPass.cpp | 2 -- mlir/lib/Conversion/SCFToEmitC/SCFToEmitC.cpp | 1 - mlir/lib/Dialect/EmitC/Transforms/TypeConversions.cpp | 3 ++- 5 files changed, 4 insertions(+), 7 deletions(-) diff --git a/mlir/include/mlir/Dialect/EmitC/Transforms/TypeConversions.h b/mlir/include/mlir/Dialect/EmitC/Transforms/TypeConversions.h index db29f4603e2c0..1c05a927e948a 100644 --- a/mlir/include/mlir/Dialect/EmitC/Transforms/TypeConversions.h +++ b/mlir/include/mlir/Dialect/EmitC/Transforms/TypeConversions.h @@ -9,9 +9,8 @@ #ifndef MLIR_DIALECT_EMITC_TRANSFORMS_TYPECONVERSIONS_H #define MLIR_DIALECT_EMITC_TRANSFORMS_TYPECONVERSIONS_H -#include "mlir/Transforms/DialectConversion.h" - namespace mlir { +class TypeConverter; void populateEmitCSizeTypeConversions(TypeConverter &converter); } // namespace mlir diff --git a/mlir/lib/Conversion/FuncToEmitC/FuncToEmitC.cpp b/mlir/lib/Conversion/FuncToEmitC/FuncToEmitC.cpp index 24ada1835c1ba..29c64487a2bc0 100644 --- a/mlir/lib/Conversion/FuncToEmitC/FuncToEmitC.cpp +++ b/mlir/lib/Conversion/FuncToEmitC/FuncToEmitC.cpp @@ -60,7 +60,7 @@ class FuncOpConversion final : public OpConversionPattern { matchAndRewrite(func::FuncOp funcOp, OpAdaptor adaptor, ConversionPatternRewriter &rewriter) const override { - FunctionType type = dyn_cast(funcOp.getFunctionType()); + FunctionType type = funcOp.getFunctionType(); if (!type) return failure(); diff --git a/mlir/lib/Conversion/FuncToEmitC/FuncToEmitCPass.cpp b/mlir/lib/Conversion/FuncToEmitC/FuncToEmitCPass.cpp index 19b8bcab4f7a3..65aa5bde96e5a 100644 --- a/mlir/lib/Conversion/FuncToEmitC/FuncToEmitCPass.cpp +++ b/mlir/lib/Conversion/FuncToEmitC/FuncToEmitCPass.cpp @@ -16,10 +16,8 @@ #include "mlir/Dialect/EmitC/IR/EmitC.h" #include "mlir/Dialect/EmitC/Transforms/TypeConversions.h" #include "mlir/Dialect/Func/IR/FuncOps.h" -#include "mlir/Dialect/Func/Transforms/FuncConversions.h" #include "mlir/Pass/Pass.h" #include "mlir/Transforms/DialectConversion.h" -#include namespace mlir { #define GEN_PASS_DEF_CONVERTFUNCTOEMITC diff --git a/mlir/lib/Conversion/SCFToEmitC/SCFToEmitC.cpp b/mlir/lib/Conversion/SCFToEmitC/SCFToEmitC.cpp index 5344dfa56196d..55b46b346949c 100644 --- a/mlir/lib/Conversion/SCFToEmitC/SCFToEmitC.cpp +++ b/mlir/lib/Conversion/SCFToEmitC/SCFToEmitC.cpp @@ -24,7 +24,6 @@ #include "mlir/Transforms/DialectConversion.h" #include "mlir/Transforms/OneToNTypeConversion.h" #include "mlir/Transforms/Passes.h" -#include namespace mlir { #define GEN_PASS_DEF_SCFTOEMITC diff --git a/mlir/lib/Dialect/EmitC/Transforms/TypeConversions.cpp b/mlir/lib/Dialect/EmitC/Transforms/TypeConversions.cpp index eeb3f22334bf1..02987df56f042 100644 --- a/mlir/lib/Dialect/EmitC/Transforms/TypeConversions.cpp +++ b/mlir/lib/Dialect/EmitC/Transforms/TypeConversions.cpp @@ -9,6 +9,7 @@ #include "mlir/Dialect/EmitC/Transforms/TypeConversions.h" #include "mlir/Dialect/EmitC/IR/EmitC.h" #include "mlir/IR/BuiltinTypes.h" +#include "mlir/Transforms/DialectConversion.h" #include using namespace mlir; @@ -35,4 +36,4 @@ void mlir::populateEmitCSizeTypeConversions(TypeConverter &converter) { converter.addSourceMaterialization(materializeAsUnrealizedCast); converter.addTargetMaterialization(materializeAsUnrealizedCast); converter.addArgumentMaterialization(materializeAsUnrealizedCast); -} \ No newline at end of file +}