[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

if (returnOp.getNumOperands() == 1) {
           returnOp, adaptor.getOperands()[0]);
     } else {
       rewriter.replaceOpWithNewOp<spirv::ReturnOp>(returnOp);
     }
     return success();
   }
 };
 
+/// 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
 
 //===----------------------------------------------------------------------===//
 // Pattern population
 //===----------------------------------------------------------------------===//
 
 void mlir::populateFuncToSPIRVPatterns(SPIRVTypeConverter &typeConverter,
                                        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

 // RUN: mlir-opt -split-input-file -convert-func-to-spirv -verify-diagnostics %s | FileCheck %s
 
 //===----------------------------------------------------------------------===//
 // func.return
 //===----------------------------------------------------------------------===//
 
 module attributes {
   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 {
   // CHECK: spv.ReturnValue %[[ARG]] : f32
   return %arg0: f32
 }
 
 // Check that multiple-return functions are not converted.
 // CHECK-LABEL: func @return_multi_val
 func @return_multi_val(%arg0: f32) -> (f32, f32) {
   // CHECK: return
   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
+}
+
 }
 
 // -----