Add EmitC index type converter to FuncToEmitC

Author: cferry-AMD

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 <algorithm>
 
 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>(
+      [](func::CallOp op) {
+        auto operandTypes = op->getOperandTypes();
+        if (std::any_of(operandTypes.begin(), operandTypes.end(),
+                        [](Type t) { return isa<IndexType>(t); }))
+          return false;
+        auto resultTypes = op.getResultTypes();
+        return !(std::any_of(resultTypes.begin(), resultTypes.end(),
+                             [](Type t) { return isa<IndexType>(t); }));
+      });
+  interfaceConversionTarget.addDynamicallyLegalOp<func::FuncOp>(
+      [](func::FuncOp op) {
+        auto operandTypes = op->getOperandTypes();
+        if (std::any_of(operandTypes.begin(), operandTypes.end(),
+                        [](Type t) { return isa<IndexType>(t); }))
+          return false;
+        auto resultTypes = op.getResultTypes();
+        return !(std::any_of(resultTypes.begin(), resultTypes.end(),
+                             [](Type t) { return isa<IndexType>(t); }));
+      });
+  interfaceConversionTarget.addDynamicallyLegalOp<func::ReturnOp>(
+      [](func::ReturnOp op) {
+        auto operandTypes = op->getOperandTypes();
+        return !(std::any_of(operandTypes.begin(), operandTypes.end(),
+                             [](Type t) { return isa<IndexType>(t); }));
+      });
+
+  RewritePatternSet interfaceRewritePatterns(&getContext());
+  TypeConverter typeConverter;
+  typeConverter.addConversion([](Type type) { return type; });
+  populateEmitCSizeTypeConversionPatterns(typeConverter);
+  populateReturnOpTypeConversionPattern(interfaceRewritePatterns,
+                                        typeConverter);
+  populateCallOpTypeConversionPattern(interfaceRewritePatterns, typeConverter);
+  populateFunctionOpInterfaceTypeConversionPattern<func::FuncOp>(
+      interfaceRewritePatterns, typeConverter);
+
+  if (failed(applyPartialConversion(getOperation(), interfaceConversionTarget,
+                                    std::move(interfaceRewritePatterns))))
+    signalPassFailure();
+
+  // Then convert the func ops themselves to EmitC
   ConversionTarget target(getContext());
 
   target.addLegalDialect<emitc::EmitCDialect>();

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
+}