[mlir] Add test case using variadic operand pattern

[jpienaar]

Summary

Shows converting between variadic and non-variadic form. Some of these should
be made into OpBase.td proper defs.

mlir/test/lib/Dialect/Test/TestOps.td

 // Generates an op with variadic results using nested pattern.
 def : Pat<(OneI32ResultOp),
           (MixedVOperandOp3
               (MixedVResultOp3:$results__0 ConstantAttr<I32Attr, "2">),
               (replaceWithValue $results__1),
               (replaceWithValue $results__2),
               ConstantAttr<I32Attr, "2">)>;
 
+def FooVariadicConsumer : TEST_Op<"foo_variadic_consume"> {
+  let arguments = (ins Variadic<I32>:$arg);
+  let results = (outs I32);
+}
+def FooBinaryConsumer : TEST_Op<"foo_binary_consume"> {
+  let arguments = (ins I32:$arg0, I32:$arg1);
+  let results = (outs I32);
+}
+
+def Front: NativeCodeCall<"$0.front()", 1>;
+def DropFront: NativeCodeCall<"$0.drop_front()", 1>;
+class HasMoreValuesThan<int n>: Constraint<CPred<"$0.size() > " # n>,
+  "has more than " # n # " values">;
+class HasExactValues<int n>: Constraint<CPred<"$0.size() == " # n>,
+  "has exactly " # n # " values">;
+def : Pat<(FooVariadicConsumer $varg),
+          (FooBinaryConsumer (Front $varg),
+                             (FooVariadicConsumer (DropFront $varg))),
+          [(HasMoreValuesThan<3> $varg)]>;
+// This could also have been a canonicalization.
+def : Pat<(FooVariadicConsumer $varg),
+          (FooBinaryConsumer (Front $varg),
+                             (Front (DropFront $varg))),
+          [(HasExactValues<2> $varg)]>;
+// This could be generalized (using C++ helper) to handle arbitrary number of
+// operands including variadic ones.
+def Concat3: NativeCodeCall<"SmallVector<Value, 3>{$0, $1, $2}", 1>;
+def : Pat<(FooBinaryConsumer $o1, (FooBinaryConsumer $o2, $o3)),
+          (FooVariadicConsumer (Concat3 $o1, $o2, $o3))>;
+
 //===----------------------------------------------------------------------===//
 // Test Patterns (either)
 
 def TestEitherOpA : TEST_Op<"either_op_a"> {
   let arguments = (ins AnyInteger:$arg0, AnyInteger:$arg1, AnyInteger:$arg2);
   let results = (outs I32:$output);
 }
 

mlir/test/mlir-tblgen/pattern.mlir

 // CHECK-LABEL: redundantTest
 func @redundantTest(%arg0: i32) -> i32 {
   %0 = "test.op_m"(%arg0) : (i32) -> i32
   // CHECK: "test.op_m"(%arg0) {optional_attr = 314159265 : i32} : (i32) -> i32
   return %0 : i32
 }
 
 //===----------------------------------------------------------------------===//
+// Test variadic operands rewrites using native calls.
+//===----------------------------------------------------------------------===//
+
+func @testVariadicToBinary1(%arg0: i32, %arg1: i32, %arg2: i32, %arg3: i32) {
+  %0 = "test.foo_variadic_consume"(%arg0, %arg1, %arg2, %arg3) : (i32, i32, i32, i32) -> (i32)
+  // CHECK-LABEL:   func @testVariadicToBinary1(
+  // CHECK-SAME:                                %[[VAL_0:[^ ]*]]: i32
+  // CHECK-SAME:                                %[[VAL_1:[^ ]*]]: i32
+  // CHECK-SAME:                                %[[VAL_2:[^ ]*]]: i32
+  // CHECK-SAME:                                %[[VAL_3:[^ ]*]]: i32
+  // CHECK:           %[[VAL_4:.*]] = "test.foo_variadic_consume"(%[[VAL_1]], %[[VAL_2]], %[[VAL_3]]) : (i32, i32, i32) -> i32
+  // CHECK:           %[[VAL_5:.*]] = "test.foo_binary_consume"(%[[VAL_0]], %[[VAL_4]]) : (i32, i32) -> i32
+  return
+}
+
+func @testVariadicToBinary2(%arg0: i32, %arg1: i32) {
+  %0 = "test.foo_variadic_consume"(%arg0, %arg1) : (i32, i32) -> (i32)
+  // CHECK-LABEL:   func @testVariadicToBinary2(
+  // CHECK-SAME:                                %[[VAL_0:[^ ]*]]: i32
+  // CHECK-SAME:                                %[[VAL_1:[^ ]*]]: i32
+  // CHECK:           %[[VAL_2:.*]] = "test.foo_binary_consume"(%[[VAL_0]], %[[VAL_1]]) : (i32, i32) -> i32
+  return
+}
+
+func @testBinaryToVariadic(%arg0: i32, %arg1: i32, %arg2: i32) {
+  %0 = "test.foo_binary_consume"(%arg1, %arg2) : (i32, i32) -> (i32)
+  %1 = "test.foo_binary_consume"(%arg0, %0) : (i32, i32) -> (i32)
+  // CHECK-LABEL:   func @testBinaryToVariadic(
+  // CHECK-SAME:                               %[[VAL_0:[^ ]*]]: i32
+  // CHECK-SAME:                               %[[VAL_1:[^ ]*]]: i32
+  // CHECK-SAME:                               %[[VAL_2:[^ ]*]]: i32
+  // The pattern doesn't delete the intermediate result, if side-effect
+  // free then DCE will remove next.
+  // CHECK:           %[[VAL_3:.*]] = "test.foo_binary_consume"(%[[VAL_1]], %[[VAL_2]]) : (i32, i32) -> i32
+  // CHECK:           %[[VAL_4:.*]] = "test.foo_variadic_consume"(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) : (i32, i32, i32) -> i32
+  return
+}
+
+//===----------------------------------------------------------------------===//
 // Test either directive
 //===----------------------------------------------------------------------===//
 
 // CHECK: @either_dag_leaf_only
 func @either_dag_leaf_only_1(%arg0 : i32, %arg1 : i16, %arg2 : i8) -> () {
   // CHECK: "test.either_op_b"(%arg1) : (i16) -> i32
   %0 = "test.either_op_a"(%arg0, %arg1, %arg2) : (i32, i16, i8) -> i32
   // CHECK: "test.either_op_b"(%arg1) : (i16) -> i32