[PatternMatching] Add convenience insert method to OwningRewritePatternList. NFC.

[lattner]

Summary

This allows adding a C function pointer as a matchAndRewrite style pattern, which
is a very common case. This adopts it in ExpandTanh to show how it reduces a level
of nesting.

We could allow C++ lambdas here, but that doesn't work as well with type inference
in the common case. Instead of:

patterns.insert(convertTanhOp);

you need to specify:

patterns.insert<math::TanhOp>(convertTanhOp);

which is boilerplate'y. Capturing state like this is very uncommon, so we choose
to require clients to define their own structs and use the non-convenience method
when they need to do so.

[lattner]

Update the docs to mention the new form.

[rriddle]

mlir/include/mlir/IR/PatternMatch.h

796

I strongly prefer something like function_ref, or even llvm::unique_function here.

797

nit: The name folder doesn't really generalize here.

[jpienaar]

LG, thanks

[mehdi_amini]

I really like the reduced boilerplate here :)

[lattner]

mlir/include/mlir/IR/PatternMatch.h

796

Did you see the comment about this? The downside of this is that it breaks type inference for the simple and most common case, adding boilerplate back for generality that is served by the existing functionality.

797

I'm not sure what you mean. Do you have a suggested replacement for this?

[lattner]

mlir/include/mlir/IR/PatternMatch.h

796

Also, llvm::unique_function would add a new dependency on ADT/FunctionExtras.h, which seems like unnecessary overhead for builds.

[silvas]

Nice!

+1 on the c function to allow better type inference. Unless somebody has an immediate suggestion for how to achieve the same with more advanced metaprogramming, this LGTM.

[rriddle]

mlir/include/mlir/IR/PatternMatch.h

796

Sorry about that, I'm just missing all comments the past few days. C-function pointer sounds good for now. We can allow lambdas in the future if necessary (it is possible with template meta-programming, but we should only do that if necessary).

797

Sorry for being terse(didn't have a lot of time to comment over the weekend). Folder reminds me of the fold hooks, and not all patterns have fold-like behavior. Could we rename this to something like FnPattern? This is definitely not a blocker (and really not that important given that this is an implementation detail).

[rriddle]

Thanks for adding this!

[lattner]

rename class per River's suggestion

mlir/docs/Tutorials/QuickstartRewrites.md

 
 /// Single-step rewrite with "matchAndRewrite". This allows for performing the
 /// rewrite immediately upon a successful match.
 struct ConvertTFLeakyRelu : public RewritePattern {
   ConvertTFLeakyRelu(MLIRContext *context)
       : RewritePattern("tf.LeakyRelu", 1, context) {}
 
   LogicalResult matchAndRewrite(Operation *op,
-                                     PatternRewriter &rewriter) const override {
     rewriter.replaceOpWithNewOp<TFL::LeakyReluOp>(
         op, op->getResult(0).getType(), op->getOperand(0),
         /*alpha=*/op->getAttrOfType<FloatAttr>("alpha"));
     return success();
   }
 };
 ```
 
 In the C++ rewrite the static benefit of the rewrite pattern is specified at
 construction. While in the pattern generator a simple heuristic is currently
 employed based around the number of ops matched and replaced.
 
+In the case where you have a registered op and want to use a benefit of 1, you
+can even define the pattern as a C function:
+
+```c++
+static LogicalResult
+convertTFLeakyRelu(TFLeakyReluOp op, PatternRewriter &rewriter) {
+  rewriter.replaceOpWithNewOp<TFL::LeakyReluOp>(
+      op, op->getResult(0).getType(), op->getOperand(0),
+      /*alpha=*/op->getAttrOfType<FloatAttr>("alpha"));
+  return success();
+}
+```
+
 The above rule did not capture the matching operands/attributes, but in general
 the `match` function in a multi-step rewrite may populate and return a
 `PatternState` (or class derived from one) to pass information extracted during
 matching to the rewrite. A single-step rewrite with the `matchAndRewrite`
 function has the benefit of being able to directly use any values created when
 matching; removing the need for `PatternState`.
 
 ## Testing

mlir/include/mlir/IR/PatternMatch.h

public:
 
   /// Add the given PDL pattern to the pattern list. Return a reference to
   /// `this` for chaining insertions.
   OwningRewritePatternList &insert(PDLPatternModule &&pattern) {
     pdlPatterns.mergeIn(std::move(pattern));
     return *this;
   }
 
+  // Add a matchAndRewrite style pattern represented as a C function pointer.
+  template <typename OpType>
+  OwningRewritePatternList &
+  insert(LogicalResult (*implFn)(OpType, PatternRewriter &rewriter)) {
+    struct FnPattern final : public OpRewritePattern<OpType> {
+      FnPattern(LogicalResult (*implFn)(OpType, PatternRewriter &rewriter),
+                MLIRContext *context)
+          : OpRewritePattern<OpType>(context), implFn(implFn) {}
+
+      LogicalResult matchAndRewrite(OpType op,
+                                    PatternRewriter &rewriter) const override {
+        return implFn(op, rewriter);
+      }
+
+    private:
+      LogicalResult (*implFn)(OpType, PatternRewriter &rewriter);
+    };
+    insert(std::make_unique<FnPattern>(std::move(implFn), getContext()));
+    return *this;
+  }
+
 private:
   /// Add an instance of the pattern type 'T'. Return a reference to `this` for
   /// chaining insertions.
   template <typename T, typename... Args>
   std::enable_if_t<std::is_base_of<RewritePattern, T>::value>
   insertImpl(Args &&... args) {
     nativePatterns.emplace_back(
         std::make_unique<T>(std::forward<Args>(args)...));

mlir/lib/Dialect/Math/Transforms/ExpandTanh.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/Math/IR/Math.h"
 #include "mlir/Dialect/Math/Transforms/Passes.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/Transforms/DialectConversion.h"
-
 using namespace mlir;
 
-namespace {
 /// Expands tanh op into
 ///   1) 1-exp^{-2x} / 1+exp^{-2x}, if x => 0
 ///   2) exp^{2x}-1 / exp^{2x}+1  , if x < 0
-struct TanhOpConverter : public OpRewritePattern<math::TanhOp> {
-public:
-  using OpRewritePattern::OpRewritePattern;
-
-  LogicalResult matchAndRewrite(math::TanhOp op,
-                                PatternRewriter &rewriter) const final {
-    auto floatType = op.operand().getType();
-    Location loc = op.getLoc();
-    auto floatOne = rewriter.getFloatAttr(floatType, 1.0);
-    auto floatTwo = rewriter.getFloatAttr(floatType, 2.0);
-    Value one = rewriter.create<ConstantOp>(loc, floatOne);
-    Value two = rewriter.create<ConstantOp>(loc, floatTwo);
-    Value doubledX = rewriter.create<MulFOp>(loc, op.operand(), two);
+static LogicalResult convertTanhOp(math::TanhOp op, PatternRewriter &rewriter) {
 
-    // Case 1: tanh(x) = 1-exp^{-2x} / 1+exp^{-2x}
-    Value negDoubledX = rewriter.create<NegFOp>(loc, doubledX);
-    Value exp2x = rewriter.create<math::ExpOp>(loc, negDoubledX);
-    Value dividend = rewriter.create<SubFOp>(loc, one, exp2x);
-    Value divisor = rewriter.create<AddFOp>(loc, one, exp2x);
-    Value positiveRes = rewriter.create<DivFOp>(loc, dividend, divisor);
 
-    // Case 2: tanh(x) = exp^{2x}-1 / exp^{2x}+1
-    exp2x = rewriter.create<math::ExpOp>(loc, doubledX);
-    dividend = rewriter.create<SubFOp>(loc, exp2x, one);
-    divisor = rewriter.create<AddFOp>(loc, exp2x, one);
-    Value negativeRes = rewriter.create<DivFOp>(loc, dividend, divisor);
 
-    // tanh(x) = x >= 0 ? positiveRes : negativeRes
-    auto floatZero = rewriter.getFloatAttr(floatType, 0.0);
-    Value zero = rewriter.create<ConstantOp>(loc, floatZero);
-    Value cmpRes =
-        rewriter.create<CmpFOp>(loc, CmpFPredicate::OGE, op.operand(), zero);
-    rewriter.replaceOpWithNewOp<SelectOp>(op, cmpRes, positiveRes, negativeRes);
-    return success();
-  }
-};
-} // namespace
 
 void mlir::populateExpandTanhPattern(OwningRewritePatternList &patterns) {
-  patterns.insert<TanhOpConverter>(patterns.getContext());
+  patterns.insert(convertTanhOp);
 }