Add slicing function extraction test; improve documentation; use lowercase for errors

Author: chios202

mlir/include/mlir/Query/Matcher/Marshallers.h

@@ -182,7 +182,7 @@ class VariadicOperatorMatcherDescriptor : public MatcherDescriptor {
       const VariantValue &value = arg.value;
       if (!value.isMatcher()) {
         addError(error, arg.range, ErrorType::RegistryWrongArgType,
-                 {llvm::Twine(i + 1), llvm::Twine("Matcher: "),
+                 {llvm::Twine(i + 1), llvm::Twine("matcher: "),
                   llvm::Twine(value.getTypeAsString())});
         return VariantMatcher();
       }

mlir/include/mlir/Query/Matcher/MatchersInternal.h

@@ -8,9 +8,9 @@
 //
 // Implements the base layer of the matcher framework.
 //
-// Matchers are methods that return a Matcher which provide a method
-// `match(...)` method. The method's parameters define the context of the match.
-// Support includes simple (unary) matchers as well as matcher combinators.
+// Matchers are methods that return a Matcher which provides a
+// `match(...)` method whose parameters define the context of the match.
+// Support includes simple (unary) matchers as well as matcher combinators
 // (anyOf, allOf, etc.)
 //
 // This file contains the wrapper classes needed to construct matchers for

mlir/include/mlir/Query/Matcher/SliceMatchers.h

@@ -143,7 +143,9 @@ class PredicateBackwardSliceMatcher {
       options.filter = [&](Operation *subOp) {
         return !filterMatcher.match(subOp);
       };
-      getBackwardSlice(rootOp, &backwardSlice, options);
+      LogicalResult result = getBackwardSlice(rootOp, &backwardSlice, options);
+      assert(result.succeeded() && "expected backward slice to succeed");
+      (void)result;
       return options.inclusive ? backwardSlice.size() > 1
                                : backwardSlice.size() >= 1;
     }

mlir/lib/Query/Query.cpp

@@ -69,7 +69,8 @@ static Operation *extractFunction(std::vector<Operation *> &ops,
   // Clone operations and build function body
   std::vector<Operation *> clonedOps;
   std::vector<Value> clonedVals;
-  // TODO: Handle extraction of operations containing block arguments.
+  // TODO: Handle extraction of operations with compute payloads defined via
+  // regions.
   for (Operation *slicedOp : slice) {
     Operation *clonedOp =
         clonedOps.emplace_back(builder.clone(*slicedOp, mapper));

mlir/test/mlir-query/forward-slice-by-predicate.mlir

@@ -1,4 +1,4 @@
-// RUN: mlir-query %s -c "m getUsersByPredicate(anyOf(hasOpName(\"memref.alloc\"),isConstantOp()),hasOpName(\"affine.load\"),true)" | FileCheck %s
+// RUN: mlir-query %s -c "m getUsersByPredicate(anyOf(hasOpName(\"memref.alloc\"),isConstantOp()),anyOf(hasOpName(\"affine.load\"), hasOpName(\"memref.dealloc\")),true)" | FileCheck %s
 
 func.func @slice_depth1_loop_nest_with_offsets() {
   %0 = memref.alloc() : memref<100xf32>

mlir/test/mlir-query/slice-function-extraction.mlir

@@ -0,0 +1,29 @@
+// RUN: mlir-query %s -c "m getDefinitionsByPredicate(hasOpName(\"memref.store\"),hasOpName(\"memref.alloc\"),true,false,false).extract(\"backward_slice\")" | FileCheck %s
+
+// CHECK:       func.func @backward_slice(%{{.*}}: memref<10xf32>) -> (f32, index, index, f32, index, index, f32) {
+// CHECK:         %[[CST0:.*]] = arith.constant 0.000000e+00 : f32
+// CHECK-NEXT:    %[[C0:.*]] = arith.constant 0 : index
+// CHECK-NEXT:    %[[I0:.*]] = affine.apply affine_map<()[s0] -> (s0)>()[%[[C0]]]
+// CHECK-NEXT:    memref.store %[[CST0]], %{{.*}}[%[[I0]]] : memref<10xf32>
+// CHECK-NEXT:    %[[CST2:.*]] = arith.constant 0.000000e+00 : f32
+// CHECK-NEXT:    %[[I1:.*]] = affine.apply affine_map<() -> (0)>()
+// CHECK-NEXT:    memref.store %[[CST2]], %{{.*}}[%[[I1]]] : memref<10xf32>
+// CHECK-NEXT:    %[[C1:.*]] = arith.constant 0 : index
+// CHECK-NEXT:    %[[LOAD:.*]] = memref.load %{{.*}}[%[[C1]]] : memref<10xf32>
+// CHECK-NEXT:    memref.store %[[LOAD]], %{{.*}}[%[[C1]]] : memref<10xf32>
+// CHECK-NEXT:    return %[[CST0]], %[[C0]], %[[I0]], %[[CST2]], %[[I1]], %[[C1]], %[[LOAD]] : f32, index, index, f32, index, index, f32
+
+func.func @slicing_memref_store_trivial() {
+  %0 = memref.alloc() : memref<10xf32>
+  %c0 = arith.constant 0 : index
+  %cst = arith.constant 0.000000e+00 : f32
+  affine.for %i1 = 0 to 10 {
+    %1 = affine.apply affine_map<()[s0] -> (s0)>()[%c0]
+    memref.store %cst, %0[%1] : memref<10xf32>
+    %2 = memref.load %0[%c0] : memref<10xf32>
+    %3 = affine.apply affine_map<()[] -> (0)>()[]
+    memref.store %cst, %0[%3] : memref<10xf32>
+    memref.store %2, %0[%c0] : memref<10xf32>
+  }
+  return
+}