[mlir][spirv] Convert call to spv.FunctionCall

[antiagainst]

Thanks! Just one comment about an additional test case.

mlir/test/Conversion/FuncToSPIRV/func-ops-to-spirv.mlir

40

Also add a test for calling function without return values?

[xndcn]

mlir/test/Conversion/FuncToSPIRV/func-ops-to-spirv.mlir

40

Thanks, updated calling @return_none_val

mlir/lib/Conversion/FuncToSPIRV/FuncToSPIRV.cpp

   }
 };
 
+/// Converts func.call to spv.FunctionCall.
+class CallOpPattern final : public OpConversionPattern<func::CallOp> {
+public:
+  using OpConversionPattern<func::CallOp>::OpConversionPattern;
+
+  LogicalResult
+  matchAndRewrite(func::CallOp callOp, OpAdaptor adaptor,
+                  ConversionPatternRewriter &rewriter) const override {
+    // multiple results func was not converted to spv.func
+    if (callOp.getNumResults() > 1)
+      return failure();
+    if (callOp.getNumResults() == 1) {
+      auto resultType =
+          getTypeConverter()->convertType(callOp.getResult(0).getType());
+      if (!resultType)
+        return failure();
+      rewriter.replaceOpWithNewOp<spirv::FunctionCallOp>(
+          callOp, resultType, adaptor.getOperands(), callOp->getAttrs());
+    } else {
+      rewriter.replaceOpWithNewOp<spirv::FunctionCallOp>(
+          callOp, TypeRange(), adaptor.getOperands(), callOp->getAttrs());
+    }
+    return success();
+  }
+};
+
 } // namespace
 
 //===----------------------------------------------------------------------===//

                                        RewritePatternSet &patterns) {
   MLIRContext *context = patterns.getContext();
 
-  patterns.add<ReturnOpPattern>(typeConverter, context);
+  patterns.add<ReturnOpPattern, CallOpPattern>(typeConverter, context);
 }

mlir/test/Conversion/FuncToSPIRV/func-ops-to-spirv.mlir

   spv.target_env = #spv.target_env<#spv.vce<v1.0, [], []>, {}>
 } {
 
+// CHECK-LABEL: spv.func @return_none_val
+func @return_none_val() {
+  // CHECK: spv.Return
+  return
+}
+
 // CHECK-LABEL: spv.func @return_one_val
 //  CHECK-SAME: (%[[ARG:.+]]: f32)
 func @return_one_val(%arg0: f32) -> f32 {

   return %arg0, %arg0: f32, f32
 }
 
+// CHECK-LABEL: spv.func @return_one_index
+//  CHECK-SAME: (%[[ARG:.+]]: i32)
+func @return_one_index(%arg0: index) -> index {
+  // CHECK: spv.ReturnValue %[[ARG]] : i32
+  return %arg0: index
+}
+
+// CHECK-LABEL: spv.func @call_functions
+//  CHECK-SAME: (%[[ARG:.+]]: i32)
+func @call_functions(%arg0: index) -> index {
+  // CHECK: spv.FunctionCall @return_none_val() : () -> ()
+  call @return_none_val(): () -> ()
+  // CHECK: {{%.*}} = spv.FunctionCall @return_one_index(%[[ARG]]) : (i32) -> i32
+  %0 = call @return_one_index(%arg0): (index) -> index
+  // CHECK: spv.ReturnValue {{%.*}} : i32
+  return %0: index
+}
+
 }
 
 // -----