mlir/linalg: improve debugging in LinalgTransformOps

[artagnon]

Summary

Make systematic use of notifyMatchFailure.

Signed-off-by: Ramkumar Ramachandra <[e-mail]>

[ftynse]

mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp

125–127

This isn't the right mechanism. This is intended to be called from within rewrite patterns, and this code isn't a pattern.

[artagnon]

Address @ftynse's review.

[artagnon]

Fixed, thanks.

[artagnon]

Hi @ftynse. I don't have commit access, so could you commit this change for me? Thanks.

[artagnon]

Committed as 57c89359.

mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp

for (Operation *target : payloadOps) {
     auto tilingInterfaceOp = dyn_cast<TilingInterface>(target);
     if (!tilingInterfaceOp)
       return transformOp->emitError("only TilingInterface ops are supported");
 
     TrivialPatternRewriter rewriter(target->getContext());
     rewriter.setInsertionPoint(target);
     FailureOr<scf::SCFTileAndFuseResult> tiledResults =
         applyFn(tilingInterfaceOp);
     if (failed(tiledResults))
-      return failure();
+      return rewriter.notifyMatchFailure(transformOp,
+                                         "unable to tile operation");
 
     // Perform the replacement of tiled and fused values.
     SmallVector<Operation *> opsToReplace{target};
     llvm::append_range(opsToReplace, tiledResults->fusedProducers);
     for (Operation *toReplace : opsToReplace) {
       SmallVector<Value> replacements;
       replacements.reserve(toReplace->getNumResults());
       for (OpResult res : toReplace->getResults()) {

 /// VectorizeOp::applyToOne.
 struct VectorizationPattern : public RewritePattern {
   explicit VectorizationPattern(MLIRContext *context)
       : RewritePattern(MatchAnyOpTypeTag(), /*benefit=*/1, context) {}
   LogicalResult matchAndRewrite(Operation *op,
                                 PatternRewriter &rewriter) const override {
     LinalgOp linalgOp = dyn_cast<LinalgOp>(op);
     if (!linalgOp)
-      return failure();
+      return rewriter.notifyMatchFailure(op, "expected Linalg Op");
     return vectorize(rewriter, linalgOp);
   }
 };
 } // namespace
 
 DiagnosedSilenceableFailure
 transform::VectorizeOp::applyToOne(Operation *target,
                                    SmallVectorImpl<Operation *> &results,