[Mlir-commits] [mlir] [mlir] Expose optional `PatternBenefit` to `func` populate functions (NFC) (PR #159986)

[llvmlistbot at llvm.org]

llvmbot wrote:


<!--LLVM PR SUMMARY COMMENT-->

@llvm/pr-subscribers-mlir-func

Author: Matthias Springer (matthias-springer)

<details>
<summary>Changes</summary>

Pattern benefit allows users to give priority to a pattern.

---
Full diff: https://github.com/llvm/llvm-project/pull/159986.diff


2 Files Affected:

- (modified) mlir/include/mlir/Dialect/Func/Transforms/FuncConversions.h (+7-3) 
- (modified) mlir/lib/Dialect/Func/Transforms/FuncConversions.cpp (+15-8) 


``````````diff
diff --git a/mlir/include/mlir/Dialect/Func/Transforms/FuncConversions.h b/mlir/include/mlir/Dialect/Func/Transforms/FuncConversions.h
index 642f704c14430..4f3bbb00fe62a 100644
--- a/mlir/include/mlir/Dialect/Func/Transforms/FuncConversions.h
+++ b/mlir/include/mlir/Dialect/Func/Transforms/FuncConversions.h
@@ -23,13 +23,15 @@ class BranchOpInterface;
 class ConversionTarget;
 class MLIRContext;
 class Operation;
+class PatternBenefit;
 class TypeConverter;
 class RewritePatternSet;
 
 /// 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(RewritePatternSet &patterns,
-                                         const TypeConverter &converter);
+                                         const TypeConverter &converter,
+                                         PatternBenefit benefit = 1);
 
 /// Add a pattern to the given pattern list to rewrite branch operations to use
 /// operands that have been legalized by the conversion framework. This can only
@@ -43,7 +45,8 @@ void populateCallOpTypeConversionPattern(RewritePatternSet &patterns,
 void populateBranchOpInterfaceTypeConversionPattern(
     RewritePatternSet &patterns, const TypeConverter &converter,
     function_ref<bool(BranchOpInterface branchOp, int idx)>
-        shouldConvertBranchOperand = nullptr);
+        shouldConvertBranchOperand = nullptr,
+    PatternBenefit benefit = 1);
 
 /// Return true if op is a BranchOpInterface op whose operands are all legal
 /// according to converter.
@@ -53,7 +56,8 @@ bool isLegalForBranchOpInterfaceTypeConversionPattern(
 /// Add a pattern to the given pattern list to rewrite `return` ops to use
 /// operands that have been legalized by the conversion framework.
 void populateReturnOpTypeConversionPattern(RewritePatternSet &patterns,
-                                           const TypeConverter &converter);
+                                           const TypeConverter &converter,
+                                           PatternBenefit benefit = 1);
 
 /// For ReturnLike ops (except `return`), return True. If op is a `return` &&
 /// returnOpAlwaysLegal is false, legalize op according to converter. Otherwise,
diff --git a/mlir/lib/Dialect/Func/Transforms/FuncConversions.cpp b/mlir/lib/Dialect/Func/Transforms/FuncConversions.cpp
index b6c8cdf2f495a..216401a80c9f8 100644
--- a/mlir/lib/Dialect/Func/Transforms/FuncConversions.cpp
+++ b/mlir/lib/Dialect/Func/Transforms/FuncConversions.cpp
@@ -65,8 +65,10 @@ struct CallOpSignatureConversion : public OpConversionPattern<CallOp> {
 } // namespace
 
 void mlir::populateCallOpTypeConversionPattern(RewritePatternSet &patterns,
-                                               const TypeConverter &converter) {
-  patterns.add<CallOpSignatureConversion>(converter, patterns.getContext());
+                                               const TypeConverter &converter,
+                                               PatternBenefit benefit) {
+  patterns.add<CallOpSignatureConversion>(converter, patterns.getContext(),
+                                          benefit);
 }
 
 namespace {
@@ -81,8 +83,9 @@ class BranchOpInterfaceTypeConversion
 
   BranchOpInterfaceTypeConversion(
       const TypeConverter &typeConverter, MLIRContext *ctx,
-      function_ref<bool(BranchOpInterface, int)> shouldConvertBranchOperand)
-      : OpInterfaceConversionPattern(typeConverter, ctx, /*benefit=*/1),
+      function_ref<bool(BranchOpInterface, int)> shouldConvertBranchOperand,
+      PatternBenefit benefit)
+      : OpInterfaceConversionPattern(typeConverter, ctx, benefit),
         shouldConvertBranchOperand(shouldConvertBranchOperand) {}
 
   LogicalResult
@@ -135,9 +138,11 @@ class ReturnOpTypeConversion : public OpConversionPattern<ReturnOp> {
 
 void mlir::populateBranchOpInterfaceTypeConversionPattern(
     RewritePatternSet &patterns, const TypeConverter &typeConverter,
-    function_ref<bool(BranchOpInterface, int)> shouldConvertBranchOperand) {
+    function_ref<bool(BranchOpInterface, int)> shouldConvertBranchOperand,
+    PatternBenefit benefit) {
   patterns.add<BranchOpInterfaceTypeConversion>(
-      typeConverter, patterns.getContext(), shouldConvertBranchOperand);
+      typeConverter, patterns.getContext(), shouldConvertBranchOperand,
+      benefit);
 }
 
 bool mlir::isLegalForBranchOpInterfaceTypeConversionPattern(
@@ -157,8 +162,10 @@ bool mlir::isLegalForBranchOpInterfaceTypeConversionPattern(
 }
 
 void mlir::populateReturnOpTypeConversionPattern(
-    RewritePatternSet &patterns, const TypeConverter &typeConverter) {
-  patterns.add<ReturnOpTypeConversion>(typeConverter, patterns.getContext());
+    RewritePatternSet &patterns, const TypeConverter &typeConverter,
+    PatternBenefit benefit) {
+  patterns.add<ReturnOpTypeConversion>(typeConverter, patterns.getContext(),
+                                       benefit);
 }
 
 bool mlir::isLegalForReturnOpTypeConversionPattern(

``````````

</details>


https://github.com/llvm/llvm-project/pull/159986