[FXML-4614] Use EmitC index types in all passes creating EmitC

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

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/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 <memory>
 
 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

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<PointerType, OpaqueType>(type);
     }
   }];

mlir/include/mlir/Dialect/EmitC/Transforms/TypeConversions.h

@@ -6,8 +6,12 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "mlir/Transforms/DialectConversion.h"
+#ifndef MLIR_DIALECT_EMITC_TRANSFORMS_TYPECONVERSIONS_H
+#define MLIR_DIALECT_EMITC_TRANSFORMS_TYPECONVERSIONS_H
 
 namespace mlir {
-void populateEmitCSizeTypeConversionPatterns(mlir::TypeConverter &converter);
+class TypeConverter;
+void populateEmitCSizeTypeConversions(TypeConverter &converter);
 } // namespace mlir
+
+#endif // MLIR_DIALECT_EMITC_TRANSFORMS_TYPECONVERSIONS_H

mlir/lib/Conversion/ArithToEmitC/ArithToEmitC.cpp

@@ -563,11 +563,11 @@ class ItoFCastOpConversion : public OpConversionPattern<CastOp> {
 // Pattern population
 //===----------------------------------------------------------------------===//
 
-void mlir::populateArithToEmitCPatterns(TypeConverter &typeConverter,
-                                        RewritePatternSet &patterns) {
+void mlir::populateArithToEmitCPatterns(RewritePatternSet &patterns,
+                                        TypeConverter &typeConverter) {
   MLIRContext *ctx = patterns.getContext();
 
-  mlir::populateEmitCSizeTypeConversionPatterns(typeConverter);
+  mlir::populateEmitCSizeTypeConversions(typeConverter);
 
   // clang-format off
   patterns.add<

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,11 @@ void ConvertArithToEmitC::runOnOperation() {
   RewritePatternSet patterns(&getContext());
 
   TypeConverter typeConverter;
-  typeConverter.addConversion([](Type type) { return type; });
-
-  populateArithToEmitCPatterns(typeConverter, patterns);
+  // 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(patterns, typeConverter);
 
   if (failed(
           applyPartialConversion(getOperation(), target, std::move(patterns))))

mlir/lib/Conversion/FuncToEmitC/FuncToEmitC.cpp

@@ -36,10 +36,17 @@ class CallOpConversion final : public OpConversionPattern<func::CallOp> {
       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<emitc::CallOp>(
-        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<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()) {
@@ -113,8 +141,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; });
+  populateEmitCSizeTypeConversions(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"
@@ -33,12 +34,13 @@ struct ConvertMemRefToEmitCPass
 
     // Fallback for other types.
     converter.addConversion([](Type type) -> std::optional<Type> {
-      if (isa<MemRefType>(type))
-        return {};
-      return type;
+      if (emitc::isSupportedEmitCType(type))
+        return type;
+      return {};
     });
 
     populateMemRefToEmitCTypeConversion(converter);
+    populateEmitCSizeTypeConversions(converter);
 
     RewritePatternSet patterns(&getContext());
     populateMemRefToEmitCConversionPatterns(patterns, converter);