[mlir][emitc] Add type conversions to EmitC types to FuncToEmitC, MemRefToEmitC

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

mlir/lib/Conversion/FuncToEmitC/FuncToEmitC.cpp

@@ -36,9 +36,14 @@ class CallOpConversion final : public OpConversionPattern<func::CallOp> {
       return rewriter.notifyMatchFailure(
           callOp, "only functions with zero or one result can be converted");
 
-    rewriter.replaceOpWithNewOp<emitc::CallOp>(callOp, callOp.getResultTypes(),
-                                               adaptor.getOperands(),
-                                               callOp->getAttrs());
+    // Convert the original function results.
+    SmallVector<Type> types;
+    if (failed(typeConverter->convertTypes(callOp.getResultTypes(), types))) {
+      return rewriter.notifyMatchFailure(
+          callOp, "function return type conversion failed");
+    }
+    rewriter.replaceOpWithNewOp<emitc::CallOp>(
+        callOp, types, adaptor.getOperands(), callOp->getAttrs());
 
     return success();
   }
@@ -52,13 +57,34 @@ class FuncOpConversion final : public OpConversionPattern<func::FuncOp> {
   matchAndRewrite(func::FuncOp funcOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
 
-    if (funcOp.getFunctionType().getNumResults() > 1)
+    FunctionType type = 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<Type, 1> 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<emitc::FuncOp>(
-        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()) {
@@ -112,8 +138,10 @@ class ReturnOpConversion final : public OpConversionPattern<func::ReturnOp> {
 // Pattern population
 //===----------------------------------------------------------------------===//
 
-void mlir::populateFuncToEmitCPatterns(RewritePatternSet &patterns) {
+void mlir::populateFuncToEmitCPatterns(RewritePatternSet &patterns,
+                                       TypeConverter &typeConverter) {
   MLIRContext *ctx = patterns.getContext();
 
-  patterns.add<CallOpConversion, FuncOpConversion, ReturnOpConversion>(ctx);
+  patterns.add<CallOpConversion, FuncOpConversion, ReturnOpConversion>(
+      typeConverter, ctx);
 }

mlir/lib/Conversion/FuncToEmitC/FuncToEmitCPass.cpp

@@ -14,6 +14,7 @@
 
 #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/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"
@@ -33,13 +34,20 @@ struct ConvertFuncToEmitC
 } // namespace
 
 void ConvertFuncToEmitC::runOnOperation() {
+  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; });
+  populateEmitCSizeTTypeConversions(typeConverter);
+
   ConversionTarget target(getContext());
 
   target.addLegalDialect<emitc::EmitCDialect>();
   target.addIllegalOp<func::CallOp, func::FuncOp, func::ReturnOp>();
 
   RewritePatternSet patterns(&getContext());
-  populateFuncToEmitCPatterns(patterns);
+  populateFuncToEmitCPatterns(patterns, typeConverter);
 
   if (failed(
           applyPartialConversion(getOperation(), target, std::move(patterns))))

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);
+    populateEmitCSizeTTypeConversions(converter);
 
     auto materializeAsUnrealizedCast = [](OpBuilder &builder, Type resultType,
                                           ValueRange inputs,

mlir/test/Conversion/FuncToEmitC/func-to-emitc.mlir

@@ -74,3 +74,33 @@ func.func @call() {
   call @return_void() : () -> ()
   return
 }
+
+// -----
+
+// CHECK-LABEL: emitc.func @use_index
+// CHECK-SAME: (%[[Arg0:.*]]: !emitc.size_t) -> !emitc.size_t
+// CHECK: 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 = call @prototype_index(%arg0) : (!emitc.size_t) -> !emitc.size_t
+// CHECK-NEXT: return %0 : !emitc.size_t
+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
+}

mlir/test/Conversion/MemRefToEmitC/memref-to-emitc.mlir

@@ -12,9 +12,11 @@ func.func @alloca() {
 // CHECK-LABEL: memref_store
 // CHECK-SAME:  %[[buff:.*]]: memref<4x8xf32>, %[[v:.*]]: f32, %[[i:.*]]: index, %[[j:.*]]: index
 func.func @memref_store(%buff : memref<4x8xf32>, %v : f32, %i: index, %j: index) {
-  // CHECK-NEXT: %[[BUFFER:.*]] = builtin.unrealized_conversion_cast %[[buff]] : memref<4x8xf32> to !emitc.array<4x8xf32>
+  // CHECK-DAG: %[[IDX_I:.*]] = builtin.unrealized_conversion_cast %[[i]] : index to !emitc.size_t
+  // CHECK-DAG: %[[IDX_J:.*]] = builtin.unrealized_conversion_cast %[[j]] : index to !emitc.size_t
+  // CHECK-DAG: %[[BUFFER:.*]] = builtin.unrealized_conversion_cast %[[buff]] : memref<4x8xf32> to !emitc.array<4x8xf32>
 
-  // CHECK-NEXT: %[[SUBSCRIPT:.*]] = emitc.subscript %[[BUFFER]][%[[i]], %[[j]]] : (!emitc.array<4x8xf32>, index, index) -> !emitc.lvalue<f32>
+  // CHECK-NEXT: %[[SUBSCRIPT:.*]] = emitc.subscript %[[BUFFER]][%[[IDX_I]], %[[IDX_J]]] : (!emitc.array<4x8xf32>, !emitc.size_t, !emitc.size_t) -> !emitc.lvalue<f32>
   // CHECK-NEXT: emitc.assign %[[v]] : f32 to %[[SUBSCRIPT]] : <f32>
   memref.store %v, %buff[%i, %j] : memref<4x8xf32>
   return
@@ -25,9 +27,11 @@ func.func @memref_store(%buff : memref<4x8xf32>, %v : f32, %i: index, %j: index)
 // CHECK-LABEL: memref_load
 // CHECK-SAME:  %[[buff:.*]]: memref<4x8xf32>, %[[i:.*]]: index, %[[j:.*]]: index
 func.func @memref_load(%buff : memref<4x8xf32>, %i: index, %j: index) -> f32 {
-  // CHECK-NEXT: %[[BUFFER:.*]] = builtin.unrealized_conversion_cast %[[buff]] : memref<4x8xf32> to !emitc.array<4x8xf32>
+  // CHECK-DAG: %[[IDX_I:.*]] = builtin.unrealized_conversion_cast %[[i]] : index to !emitc.size_t
+  // CHECK-DAG: %[[IDX_J:.*]] = builtin.unrealized_conversion_cast %[[j]] : index to !emitc.size_t
+  // CHECK-DAG: %[[BUFFER:.*]] = builtin.unrealized_conversion_cast %[[buff]] : memref<4x8xf32> to !emitc.array<4x8xf32>
 
-  // CHECK-NEXT: %[[SUBSCRIPT:.*]] = emitc.subscript %[[BUFFER]][%[[i]], %[[j]]] : (!emitc.array<4x8xf32>, index, index) -> !emitc.lvalue<f32>
+  // CHECK-NEXT: %[[SUBSCRIPT:.*]] = emitc.subscript %[[BUFFER]][%[[IDX_I]], %[[IDX_J]]] : (!emitc.array<4x8xf32>, !emitc.size_t, !emitc.size_t) -> !emitc.lvalue<f32>
   // CHECK-NEXT: %[[LOAD:.*]] = emitc.load %[[SUBSCRIPT]] : <f32>
   %1 = memref.load %buff[%i, %j] : memref<4x8xf32>
   // CHECK-NEXT: return %[[LOAD]] : f32
@@ -52,3 +56,24 @@ 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-DAG: %[[i:.*]] = builtin.unrealized_conversion_cast %[[argi]] : index to !emitc.size_t
+  // CHECK-DAG: %[[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: %[[SUBSCRIPT:.*]] = emitc.subscript %[[ALLOCA]][%[[i]], %[[j]]] : (!emitc.array<4x8x!emitc.size_t>, !emitc.size_t, !emitc.size_t) -> !emitc.lvalue<!emitc.size_t>
+  // CHECK: %[[LOAD:.*]] = emitc.load %[[SUBSCRIPT]] : <!emitc.size_t>
+  %1 = memref.load %0[%i, %j] : memref<4x8xindex>
+
+  // CHECK: %[[CAST_RET:.*]] = builtin.unrealized_conversion_cast %[[LOAD]] : !emitc.size_t to index
+  // CHECK: return %[[CAST_RET]] : index
+  return %1 : index
+}