Introduced CallOp Dialect Conversion

[rsuderman]

Summary

Utility to perform CallOp Dialect conversion, specifically handling cases where
an argument type has changed and the corresponding CallOp needs to be updated.

[rriddle]

Looks good, just have a question about the location.

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

1 ↗

(On Diff #250899)

Would this make more sense in the Conversion directory? Say mlir/Conversion/StandardToStandard?

9 ↗

(On Diff #250899)

This seems like it should be updated, likely should just mention that it contains patterns for lowering within standard dialect.

17 ↗

(On Diff #250899)

I think we can trim all of these and just use forward declarations.

29 ↗

(On Diff #250899)

operand and result types?

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

1 ↗

(On Diff #250899)

Missing a file header here.

6 ↗

(On Diff #250899)

nit: prefer using namespace mlir in .cpp files

[rsuderman]

Update for rriddle@ comments

[rsuderman]

Missed updated comment.

[rsuderman]

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

1 ↗

(On Diff #250899)

Works for me.

[rsuderman]

Second comment update.

[rsuderman]

Updated comment in DialectConversion.cpp

[rriddle]

LGTM after resolving last comments.

mlir/include/mlir/Conversion/StandardToStandard/StandardToStandard.h

2

This needs to be updated.

mlir/lib/Conversion/StandardToStandard/DialectConversion.cpp

1 ↗

(On Diff #251215)

Can we name this file the same as the header?

[rsuderman]

Updated for final comments

mlir/include/mlir/Conversion/StandardToStandard/StandardToStandard.h

+//===- StandardToStandard.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 files contains patterns for lowering within the Standard dialect.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_CONVERSION_STANDARDTOSTANDARD_STANDARDTOSTANDARD_H_
+#define MLIR_CONVERSION_STANDARDTOSTANDARD_STANDARDTOSTANDARD_H_
+
+namespace mlir {
+
+// Forward declarations.
+class MLIRContext;
+class OwningRewritePatternList;
+class TypeConverter;
+
+/// Add a pattern to the given pattern list to convert the operand and result
+/// types of a CallOp with the given type converter.
+void populateCallOpTypeConversionPattern(OwningRewritePatternList &patterns,
+                                         MLIRContext *ctx,
+                                         TypeConverter &converter);
+
+} // end namespace mlir
+
+#endif // MLIR_CONVERSION_STANDARDTOSTANDARD_STANDARDTOSTANDARD_H_

mlir/lib/Conversion/CMakeLists.txt

 add_subdirectory(AffineToStandard)
 add_subdirectory(GPUToCUDA)
 add_subdirectory(GPUToNVVM)
 add_subdirectory(GPUToROCDL)
 add_subdirectory(GPUToSPIRV)
 add_subdirectory(GPUToVulkan)
 add_subdirectory(LinalgToLLVM)
 add_subdirectory(LinalgToSPIRV)
 add_subdirectory(LoopsToGPU)
 add_subdirectory(LoopToStandard)
 add_subdirectory(StandardToLLVM)
 add_subdirectory(StandardToSPIRV)
+add_subdirectory(StandardToStandard)
 add_subdirectory(VectorToLLVM)
 add_subdirectory(VectorToLoops)

mlir/lib/Conversion/StandardToStandard/CMakeLists.txt

+add_mlir_conversion_library(MLIRStandardToStandard
+  DialectConversion.cpp
+
+  ADDITIONAL_HEADER_DIRS
+  ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/StandardToStandard
+
+  DEPENDS
+  intrinsics_gen
+  )
+target_link_libraries(MLIRStandardToStandard
+  PUBLIC
+  MLIRIR
+  MLIRPass
+  MLIRStandardOps
+  MLIRTransforms
+  )

mlir/lib/Conversion/StandardToStandard/StandardToStandard.cpp

+//===- StandardToStandard.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 "mlir/Conversion/StandardToStandard/StandardToStandard.h"
+#include "mlir/Dialect/StandardOps/IR/Ops.h"
+#include "mlir/Transforms/DialectConversion.h"
+
+using namespace mlir;
+
+namespace {
+
+// Converts the operand and result types of the Standard's CallOp, used together
+// with the FuncOpSignatureConversion.
+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
+
+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/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/Conversion/StandardToStandard/StandardToStandard.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
+  MLIRStandardToStandard
   MLIRTestDialect
   MLIRTransformUtils
   MLIRVectorToLoops
   MLIRVectorOps
   )