Added StandardOps DialectConversion support

[rsuderman]

Summary

CallOp will need to be converted when FuncOp's are converted. Added a
corresponding DialectConversion to the StandardOps dialect to support
this conversion.

[rsuderman]

Clang-format

mlir/include/mlir/Dialect/StandardOps/Transforms/DialectConversion.h

+//===- DialectConversion.h - MLIR dialect conversion pass -------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file declares a generic pass for converting between MLIR dialects
+// related to the StandardOps Dialect.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_DIALECT_STANDARDOPS_TRANSFORMS_DIALECTCONVERSION_H_
+#define MLIR_DIALECT_STANDARDOPS_TRANSFORMS_DIALECTCONVERSION_H_
+
+#include "mlir/IR/PatternMatch.h"
+#include "mlir/Support/LLVM.h"
+#include "mlir/Support/LogicalResult.h"
+#include "mlir/Transforms/DialectConversion.h"
+#include "llvm/ADT/MapVector.h"
+#include "llvm/ADT/StringMap.h"
+
+namespace mlir {
+
+// Forward declarations.
+class MLIRContext;
+
+/// Add a pattern to the given pattern list to convert the result types of a
+/// CallOp with the given type converter.
+void populateCallOpTypeConversionPattern(OwningRewritePatternList &patterns,
+                                         MLIRContext *ctx,
+                                         TypeConverter &converter);
+
+} // end namespace mlir
+
+#endif // MLIR_DIALECT_STANDARDOPS_TRANSFORMS_DIALECTCONVERSION_H_

mlir/lib/Dialect/StandardOps/CMakeLists.txt

target_link_libraries(MLIRStandardOps
   PUBLIC
   MLIRCallInterfaces
   MLIRControlFlowInterfaces
   MLIREDSC
   MLIRIR
   MLIRSideEffects
   LLVMSupport
   )
+
+add_subdirectory(Transforms)

mlir/lib/Dialect/StandardOps/Transforms/CMakeLists.txt

+add_mlir_dialect_library(MLIRStandardOpsTransforms
+  DialectConversion.cpp
+
+  ADDITIONAL_HEADER_DIRS
+  ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/StandardOps
+
+  DEPENDS
+  intrinsics_gen
+  )
+target_link_libraries(MLIRStandardOpsTransforms
+  PUBLIC
+  MLIRIR
+  MLIRPass
+  MLIRStandardOps
+  MLIRTransforms
+  )

mlir/lib/Dialect/StandardOps/Transforms/DialectConversion.cpp

+
+#include "mlir/Dialect/StandardOps/Transforms/DialectConversion.h"
+
+#include "mlir/Dialect/StandardOps/IR/Ops.h"
+
+namespace mlir {
+
+/// Create a default conversion pattern that rewrites the result type of a
+/// CallOp.
+namespace {
+
+struct CallOpSignatureConversion : public OpConversionPattern<CallOp> {
+  CallOpSignatureConversion(MLIRContext *ctx, TypeConverter &converter)
+      : OpConversionPattern(ctx), converter(converter) {}
+
+  /// Hook for derived classes to implement combined matching and rewriting.
+  PatternMatchResult
+  matchAndRewrite(CallOp callOp, ArrayRef<Value> operands,
+                  ConversionPatternRewriter &rewriter) const override {
+    FunctionType type = callOp.getCalleeType();
+
+    // Convert the original function results.
+    SmallVector<Type, 1> convertedResults;
+    if (failed(converter.convertTypes(type.getResults(), convertedResults)))
+      return matchFailure();
+
+    // Substitute with the new result types from the corresponding FuncType
+    // conversion.
+    rewriter.replaceOpWithNewOp<CallOp>(callOp, callOp.callee(),
+                                        convertedResults, operands);
+    return matchSuccess();
+  }
+
+  /// The type converter to use when rewriting the signature.
+  TypeConverter &converter;
+};
+
+} // end anonymous namespace
+} // namespace mlir
+
+void mlir::populateCallOpTypeConversionPattern(
+    OwningRewritePatternList &patterns, MLIRContext *ctx,
+    TypeConverter &converter) {
+  patterns.insert<CallOpSignatureConversion>(ctx, converter);
+}

mlir/test/Transforms/test-legalizer.mlir

 func @remap_input_1_to_0(i16)
 
 // CHECK-LABEL: func @remap_input_1_to_1(%arg0: f64)
 func @remap_input_1_to_1(%arg0: i64) {
   // CHECK-NEXT: "test.valid"{{.*}} : (f64)
   "test.invalid"(%arg0) : (i64) -> ()
 }
 
+// CHECK-LABEL: func @remap_call_1_to_1(%arg0: f64)
+func @remap_call_1_to_1(%arg0: i64) {
+  // CHECK-NEXT: call @remap_input_1_to_1(%arg0) : (f64) -> ()
+  call @remap_input_1_to_1(%arg0) : (i64) -> ()
+  return
+}
+
 // CHECK-LABEL: func @remap_input_1_to_N({{.*}}f16, {{.*}}f16)
 func @remap_input_1_to_N(%arg0: f32) -> f32 {
  // CHECK-NEXT: "test.return"{{.*}} : (f16, f16) -> ()
  "test.return"(%arg0) : (f32) -> ()
 }
 
 // CHECK-LABEL: func @remap_input_1_to_N_remaining_use(%arg0: f16, %arg1: f16)
 func @remap_input_1_to_N_remaining_use(%arg0: f32) {

mlir/test/lib/TestDialect/CMakeLists.txt

 target_link_libraries(MLIRTestDialect
   PUBLIC
   MLIRControlFlowInterfaces
   MLIRDialect
   MLIRIR
   MLIRLinalgTransforms
   MLIRPass
   MLIRStandardOps
+  MLIRStandardOpsTransforms
   MLIRTransforms
   MLIRTransformUtils
   MLIRInferTypeOpInterface
   LLVMSupport
 )

mlir/test/lib/TestDialect/TestPatterns.cpp

 //===- TestPatterns.cpp - Test dialect pattern driver ---------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "TestDialect.h"
+#include "mlir/Dialect/StandardOps/Transforms/DialectConversion.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"
 using namespace mlir;
 
 // Native function for testing NativeCodeCall
 static Value chooseOperand(Value input1, Value input2, BoolAttr choice) {
   return choice.getValue() ? input1 : input2;
patterns
         .insert<TestRegionRewriteBlockMovement, TestRegionRewriteUndo,
                 TestPassthroughInvalidOp, TestSplitReturnType,
                 TestChangeProducerTypeI32ToF32, TestChangeProducerTypeF32ToF64,
                 TestChangeProducerTypeF32ToInvalid, TestUpdateConsumerType,
                 TestNonRootReplacement>(&getContext());
     patterns.insert<TestDropOpSignatureConversion>(&getContext(), converter);
     mlir::populateFuncOpTypeConversionPattern(patterns, &getContext(),
                                               converter);
+    mlir::populateCallOpTypeConversionPattern(patterns, &getContext(),
+                                              converter);
 
     // Define the conversion target used for the test.
     ConversionTarget target(getContext());
     target.addLegalOp<ModuleOp, ModuleTerminatorOp>();
     target.addLegalOp<LegalOpA, LegalOpB, TestCastOp, TestValidOp>();
     target
         .addIllegalOp<ILLegalOpF, TestRegionBuilderOp, TestOpWithRegionFold>();
     target.addDynamicallyLegalOp<TestReturnOp>([](TestReturnOp op) {

mlir/test/lib/Transforms/CMakeLists.txt

target_link_libraries(MLIRTestTransforms
   MLIRAnalysis
   MLIREDSC
   MLIRGPU
   MLIRLinalgOps
   MLIRLinalgTransforms
   MLIRLoopOps
   MLIRGPU
   MLIRPass
+  MLIRStandardOpsTransforms
   MLIRTestDialect
   MLIRTransformUtils
   MLIRVectorToLoops
   MLIRVectorOps
   )