[mlir][arith] Improve EmulateWideInt diagnostics

[kuhar]

Summary

Print unsupported types on match failures.

Suggested by @Mogball and @jpienaar in D135204.

[Mogball]

many thanks

mlir/lib/Dialect/Arith/Transforms/EmulateWideInt.cpp

 //===- EmulateWideInt.cpp - Wide integer operation emulation ----*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/Arith/Transforms/Passes.h"
 
 #include "mlir/Dialect/Arith/IR/Arith.h"
 #include "mlir/Dialect/Arith/Transforms/WideIntEmulationConverter.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/Func/Transforms/FuncConversions.h"
 #include "mlir/Dialect/Vector/IR/VectorOps.h"
 #include "mlir/Transforms/DialectConversion.h"
+#include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/MathExtras.h"
 #include <cassert>
 
 namespace mlir::arith {
 #define GEN_PASS_DEF_ARITHEMULATEWIDEINT
 #include "mlir/Dialect/Arith/Transforms/Passes.h.inc"
 } // namespace mlir::arith
 
struct ConvertAddI final : OpConversionPattern<arith::AddIOp> {
   LogicalResult
   matchAndRewrite(arith::AddIOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     Location loc = op->getLoc();
     auto newTy = getTypeConverter()
                      ->convertType(op.getType())
                      .dyn_cast_or_null<VectorType>();
     if (!newTy)
-      return rewriter.notifyMatchFailure(loc, "expected scalar or vector type");
+      return rewriter.notifyMatchFailure(
+          loc, llvm::formatv("unsupported type: {0}", op.getType()));
 
     Type newElemTy = reduceInnermostDim(newTy);
 
     auto [lhsElem0, lhsElem1] =
         extractLastDimHalves(rewriter, loc, adaptor.getLhs());
     auto [rhsElem0, rhsElem1] =
         extractLastDimHalves(rewriter, loc, adaptor.getRhs());
 
struct ConvertBitwiseBinary final : OpConversionPattern<BinaryOp> {
   LogicalResult
   matchAndRewrite(BinaryOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     Location loc = op->getLoc();
     auto newTy = this->getTypeConverter()
                      ->convertType(op.getType())
                      .template dyn_cast_or_null<VectorType>();
     if (!newTy)
-      return rewriter.notifyMatchFailure(loc, "unsupported type");
+      return rewriter.notifyMatchFailure(
+          loc, llvm::formatv("unsupported type: {0}", op.getType()));
 
     auto [lhsElem0, lhsElem1] =
         extractLastDimHalves(rewriter, loc, adaptor.getLhs());
     auto [rhsElem0, rhsElem1] =
         extractLastDimHalves(rewriter, loc, adaptor.getRhs());
 
     Value resElem0 = rewriter.create<BinaryOp>(loc, lhsElem0, rhsElem0);
     Value resElem1 = rewriter.create<BinaryOp>(loc, lhsElem1, rhsElem1);
struct ConvertMulI final : OpConversionPattern<arith::MulIOp> {
   LogicalResult
   matchAndRewrite(arith::MulIOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     Location loc = op->getLoc();
     auto newTy = getTypeConverter()
                      ->convertType(op.getType())
                      .dyn_cast_or_null<VectorType>();
     if (!newTy)
-      return rewriter.notifyMatchFailure(loc, "expected scalar or vector type");
+      return rewriter.notifyMatchFailure(
+          loc, llvm::formatv("unsupported type: {0}", op.getType()));
 
     Type newElemTy = reduceInnermostDim(newTy);
     unsigned newBitWidth = newTy.getElementTypeBitWidth();
     unsigned digitBitWidth = newBitWidth / 2;
 
     auto [lhsElem0, lhsElem1] =
         extractLastDimHalves(rewriter, loc, adaptor.getLhs());
     auto [rhsElem0, rhsElem1] =
struct ConvertExtSI final : OpConversionPattern<arith::ExtSIOp> {
   LogicalResult
   matchAndRewrite(arith::ExtSIOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     Location loc = op->getLoc();
     auto newTy = getTypeConverter()
                      ->convertType(op.getType())
                      .dyn_cast_or_null<VectorType>();
     if (!newTy)
-      return rewriter.notifyMatchFailure(loc, "unsupported type");
+      return rewriter.notifyMatchFailure(
+          loc, llvm::formatv("unsupported type: {0}", op.getType()));
 
     Type newResultComponentTy = reduceInnermostDim(newTy);
 
     // Sign-extend the input value to determine the low half of the result.
     // Then, check if the low half is negative, and sign-extend the comparison
     // result to get the high half.
     Value newOperand = appendX1Dim(rewriter, loc, adaptor.getIn());
     Value extended = rewriter.createOrFold<arith::ExtSIOp>(
struct ConvertExtUI final : OpConversionPattern<arith::ExtUIOp> {
   LogicalResult
   matchAndRewrite(arith::ExtUIOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     Location loc = op->getLoc();
     auto newTy = getTypeConverter()
                      ->convertType(op.getType())
                      .dyn_cast_or_null<VectorType>();
     if (!newTy)
-      return rewriter.notifyMatchFailure(loc, "unsupported type");
+      return rewriter.notifyMatchFailure(
+          loc, llvm::formatv("unsupported type: {0}", op.getType()));
 
     Type newResultComponentTy = reduceInnermostDim(newTy);
 
     // Zero-extend the input value to determine the low half of the result.
     // The high half is always zero.
     Value newOperand = appendX1Dim(rewriter, loc, adaptor.getIn());
     Value extended = rewriter.createOrFold<arith::ExtUIOp>(
         loc, newResultComponentTy, newOperand);
struct ConvertShLI final : OpConversionPattern<arith::ShLIOp> {
   matchAndRewrite(arith::ShLIOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     Location loc = op->getLoc();
 
     Type oldTy = op.getType();
     auto newTy =
         getTypeConverter()->convertType(oldTy).dyn_cast_or_null<VectorType>();
     if (!newTy)
-      return rewriter.notifyMatchFailure(loc, "unsupported type");
+      return rewriter.notifyMatchFailure(
+          loc, llvm::formatv("unsupported type: {0}", op.getType()));
 
     Type newOperandTy = reduceInnermostDim(newTy);
     // `oldBitWidth` == `2 * newBitWidth`
     unsigned newBitWidth = newTy.getElementTypeBitWidth();
 
     auto [lhsElem0, lhsElem1] =
         extractLastDimHalves(rewriter, loc, adaptor.getLhs());
     Value rhsElem0 = extractLastDimSlice(rewriter, loc, adaptor.getRhs(), 0);
struct ConvertShRUI final : OpConversionPattern<arith::ShRUIOp> {
   matchAndRewrite(arith::ShRUIOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     Location loc = op->getLoc();
 
     Type oldTy = op.getType();
     auto newTy =
         getTypeConverter()->convertType(oldTy).dyn_cast_or_null<VectorType>();
     if (!newTy)
-      return rewriter.notifyMatchFailure(loc, "unsupported type");
+      return rewriter.notifyMatchFailure(
+          loc, llvm::formatv("unsupported type: {0}", op.getType()));
 
     Type newOperandTy = reduceInnermostDim(newTy);
     // `oldBitWidth` == `2 * newBitWidth`
     unsigned newBitWidth = newTy.getElementTypeBitWidth();
 
     auto [lhsElem0, lhsElem1] =
         extractLastDimHalves(rewriter, loc, adaptor.getLhs());
     Value rhsElem0 = extractLastDimSlice(rewriter, loc, adaptor.getRhs(), 0);
struct ConvertTruncI final : OpConversionPattern<arith::TruncIOp> {
 
   LogicalResult
   matchAndRewrite(arith::TruncIOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     Location loc = op.getLoc();
     // Check if the result type is legal for this target. Currently, we do not
     // support truncation to types wider than supported by the target.
     if (!getTypeConverter()->isLegal(op.getType()))
-      return rewriter.notifyMatchFailure(loc,
-                                         "unsupported truncation result type");
+      return rewriter.notifyMatchFailure(
+          loc, llvm::formatv("unsupported truncation result type: {0}",
+                             op.getType()));
 
     // Discard the high half of the input. Truncate the low half, if necessary.
     Value extracted = extractLastDimSlice(rewriter, loc, adaptor.getIn(), 0);
     extracted = dropTrailingX1Dim(rewriter, loc, extracted);
     Value truncated =
         rewriter.createOrFold<arith::TruncIOp>(loc, op.getType(), extracted);
     rewriter.replaceOp(op, truncated);
     return success();