[mlir] Support SSA values in runtime op verification errors

[springerm]

Summary

This change allows additional msgArgs SSA values in cf.assert. The assert message is now a simple format string. E.g.:

cf.assert %condition, "found {}, expected {}"(%0, %1) : index, index

The runtime op verifier of memref.cast is extended such that it generates more descriptive runtime errors with full memref types. E.g.:

memref.cast: invalid cast from memref<5xf32, strided<[1], offset: 0> to memref<10xf32>

This change also adds a printStr helper function to the runtime library. puts can no longer be used because it automatically adds a new-line character. fputs cannot be used either because it requires an additional output stream argument, which is hard to produce in LLVMIR. (fputs does not add a new-line character.)

Depends On D138671

[springerm]

rebase

[springerm]

rebase

[springerm]

mlir/lib/ExecutionEngine/CRunnerUtils.cpp

50–54

I don't know how to do this without adding a new function here. puts cannot be used because it adds \n to the string. fputs cannot be used because I don't know how to pass stderr as an argument from LLVMIR.

[springerm]

simplify code and rebase

[rriddle]

mlir/include/mlir/Dialect/ControlFlow/IR/ControlFlowOps.td

48–51

What are the formatting semantics for the provided arguments? Implementation defined?

Also, why not use an indexed placeholder approach?

[springerm]

better error handling

[springerm]

mlir/include/mlir/Dialect/ControlFlow/IR/ControlFlowOps.td

48–51

Only I64, F32 and F64 is supported at the moment. For other types that may be added in the future, I would say implementation defined.

By "indexed placeholder", do you mean {0}, {1}, etc.? I thought about this but {}` seemed simpler. Index placeholder would be beneficial if the same value is used multiple times in the msg string, but this is usually not the case in error messages.

[springerm]

update op documentation

[springerm]

rebase

[springerm]

rebase

mlir/include/mlir/Dialect/ControlFlow/IR/ControlFlowOps.td

 //===----------------------------------------------------------------------===//
 // AssertOp
 //===----------------------------------------------------------------------===//
 
 def AssertOp : CF_Op<"assert"> {
   let summary = "Assert operation with message attribute";
   let description = [{
     Assert operation with single boolean operand and an error message attribute.
-    If the argument is `true` this operation has no effect. Otherwise, the
+    If the `condition` is `true` this operation has no effect. Otherwise, the
     program execution will abort. The provided error message may be used by a
     runtime to propagate the error to the user.
     
+    Additional error message args can be provided to produce more descriptive
+    error messages with runtime information. Message args are referenced with
+    "{}" placeholders inside the error message string and printed in an
+    implementation-defined fashion. The number of message args must match the
+    number of placeholders.
+
     Example:
 
     ```mlir
-    assert %b, "Expected ... to be true"
+    assert %condition, "Expected ... to be true"
+    ```
+
+    ```mlir
+    assert %condition, "Expected {}, found {}"(%0, %1) : index, index
     ```
   }];
 
-  let arguments = (ins I1:$arg, StrAttr:$msg);
+  let arguments = (ins I1:$condition, StrAttr:$msg, Variadic<AnyType>:$msgArgs);
+
+  let builders = [
+    OpBuilder<(ins "Value":$condition)>,
+    OpBuilder<(ins "Value":$condition, "StringAttr":$msg)>,
+    OpBuilder<(ins "Value":$condition, "StringRef":$msg)>,
+  ];
+
+  let assemblyFormat = [{
+    $condition `,` $msg (`(` $msgArgs^ `)`)? attr-dict (`:` type($msgArgs)^)?
+  }];
 
-  let assemblyFormat = "$arg `,` $msg attr-dict";
   let hasCanonicalizeMethod = 1;
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // BranchOp
 //===----------------------------------------------------------------------===//
 
 def BranchOp : CF_Op<"br", [
     DeclareOpInterfaceMethods<BranchOpInterface, ["getSuccessorForOperands"]>,

mlir/lib/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.cpp

 #include "mlir/Conversion/LLVMCommon/VectorPattern.h"
 #include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
 #include "mlir/Dialect/LLVMIR/FunctionCallUtils.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"
+
 #include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/TypeSwitch.h"
 #include <functional>
 
 namespace mlir {
 #define GEN_PASS_DEF_CONVERTCONTROLFLOWTOLLVM
 #include "mlir/Conversion/Passes.h.inc"
 } // namespace mlir
 
 using namespace mlir;
 
 #define PASS_NAME "convert-cf-to-llvm"
 
-static std::string generateGlobalMsgSymbolName(ModuleOp moduleOp) {
-  std::string prefix = "assert_msg_";
+static std::string generateGlobalStrSymbolName(ModuleOp moduleOp) {
+  std::string prefix = "assert_str_";
   int counter = 0;
   while (moduleOp.lookupSymbol(prefix + std::to_string(counter)))
     ++counter;
   return prefix + std::to_string(counter);
 }
 
-/// Generate IR that prints the given string to stderr.
-static void createPrintMsg(OpBuilder &builder, Location loc, ModuleOp moduleOp,
-                           StringRef msg) {
+/// Generate IR that prints the given string.
+static void createPrintStr(OpBuilder &builder, Location loc, ModuleOp moduleOp,
+                           StringRef str) {
   auto ip = builder.saveInsertionPoint();
   builder.setInsertionPointToStart(moduleOp.getBody());
   MLIRContext *ctx = builder.getContext();
 
   // Create a zero-terminated byte representation and allocate global symbol.
   SmallVector<uint8_t> elementVals;
-  elementVals.append(msg.begin(), msg.end());
+  elementVals.append(str.begin(), str.end());
   elementVals.push_back(0);
   auto dataAttrType = RankedTensorType::get(
       {static_cast<int64_t>(elementVals.size())}, builder.getI8Type());
   auto dataAttr =
       DenseElementsAttr::get(dataAttrType, llvm::makeArrayRef(elementVals));
   auto arrayTy =
       LLVM::LLVMArrayType::get(IntegerType::get(ctx, 8), elementVals.size());
-  std::string symbolName = generateGlobalMsgSymbolName(moduleOp);
+  std::string symbolName = generateGlobalStrSymbolName(moduleOp);
   auto globalOp = builder.create<LLVM::GlobalOp>(
       loc, arrayTy, /*constant=*/true, LLVM::Linkage::Private, symbolName,
       dataAttr);
 
   // Emit call to `printStr` in runtime library.
   builder.restoreInsertionPoint(ip);
-  auto msgAddr = builder.create<LLVM::AddressOfOp>(
+  auto strAddr = builder.create<LLVM::AddressOfOp>(
       loc, LLVM::LLVMPointerType::get(arrayTy), globalOp.getName());
   SmallVector<LLVM::GEPArg> indices(1, 0);
   Value gep = builder.create<LLVM::GEPOp>(
-      loc, LLVM::LLVMPointerType::get(builder.getI8Type()), msgAddr, indices);
+      loc, LLVM::LLVMPointerType::get(builder.getI8Type()), strAddr, indices);
   Operation *printer = LLVM::lookupOrCreatePrintStrFn(moduleOp);
   builder.create<LLVM::CallOp>(loc, TypeRange(), SymbolRefAttr::get(printer),
                                gep);
 }
 
+using MsgPrinterFns = DenseMap<Type, std::function<LLVM::LLVMFuncOp(ModuleOp)>>;
+
+/// Generate IR that prints the given message and interleaved message args.
+static void createPrintMsg(OpBuilder &builder, LLVMTypeConverter *typeConverter,
+                           const MsgPrinterFns &printerFns, Location loc,
+                           ModuleOp moduleOp, StringRef msg,
+                           ValueRange msgArgs) {
+  StringRef remainingStr = msg;
+  ValueRange remainingArgs = msgArgs;
+  while (!remainingStr.empty()) {
+    bool hasPlaceholder = remainingStr.contains("{}");
+    std::pair<StringRef, StringRef> sep = remainingStr.split("{}");
+    createPrintStr(builder, loc, moduleOp, sep.first);
+    if (hasPlaceholder) {
+      // A separator was found.
+      Value value = remainingArgs.front();
+      remainingArgs = remainingArgs.drop_front();
+      auto it = printerFns.find(value.getType());
+      assert(it != printerFns.end() && "unsupported type");
+      Operation *printer = it->second(moduleOp).getOperation();
+      assert(printer && "unsupported type");
+      builder.create<LLVM::CallOp>(loc, TypeRange(),
+                                   SymbolRefAttr::get(printer), value);
+    }
+    remainingStr = sep.second;
+  }
+
+  // Print new line.
+  Operation *newLinePrinter = LLVM::lookupOrCreatePrintNewlineFn(moduleOp);
+  builder.create<LLVM::CallOp>(
+      loc, TypeRange(), SymbolRefAttr::get(newLinePrinter), ValueRange());
+}
+
 namespace {
 /// Lower `cf.assert`. The default lowering calls the `abort` function if the
 /// assertion is violated and has no effect otherwise. The failure message is
 /// ignored by the default lowering but should be propagated by any custom
 /// lowering.
 struct AssertOpLowering : public ConvertOpToLLVMPattern<cf::AssertOp> {
   explicit AssertOpLowering(LLVMTypeConverter &typeConverter,
                             bool abortOnFailedAssert = true)
       : ConvertOpToLLVMPattern<cf::AssertOp>(typeConverter, /*benefit=*/1),
         abortOnFailedAssert(abortOnFailedAssert) {}
 
   LogicalResult
   matchAndRewrite(cf::AssertOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
+    // Add support for additional types as needed.
+    MsgPrinterFns printerFns;
+    printerFns[rewriter.getI64Type()] = LLVM::lookupOrCreatePrintI64Fn;
+    printerFns[rewriter.getF32Type()] = LLVM::lookupOrCreatePrintF32Fn;
+    printerFns[rewriter.getF64Type()] = LLVM::lookupOrCreatePrintF64Fn;
+    // Do not lower this op if at least one of the message args cannot be
+    // printed.
+    bool unsupportedMsgArgs = llvm::any_of(adaptor.getMsgArgs(), [&](Value v) {
+      return printerFns.count(v.getType()) == 0;
+    });
+    if (unsupportedMsgArgs)
+      return failure();
+
     auto loc = op.getLoc();
     auto module = op->getParentOfType<ModuleOp>();
 
     // Split block at `assert` operation.
     Block *opBlock = rewriter.getInsertionBlock();
     auto opPosition = rewriter.getInsertionPoint();
     Block *continuationBlock = rewriter.splitBlock(opBlock, opPosition);
 
     // Failed block: Generate IR to print the message and call `abort`.
     Block *failureBlock = rewriter.createBlock(opBlock->getParent());
-    createPrintMsg(rewriter, loc, module, op.getMsg());
+    createPrintMsg(rewriter, getTypeConverter(), printerFns, loc, module,
+                   op.getMsg(), adaptor.getMsgArgs());
     if (abortOnFailedAssert) {
       // Insert the `abort` declaration if necessary.
       auto abortFunc = module.lookupSymbol<LLVM::LLVMFuncOp>("abort");
       if (!abortFunc) {
         OpBuilder::InsertionGuard guard(rewriter);
         rewriter.setInsertionPointToStart(module.getBody());
         auto abortFuncTy = LLVM::LLVMFunctionType::get(getVoidType(), {});
         abortFunc = rewriter.create<LLVM::LLVMFuncOp>(rewriter.getUnknownLoc(),
                                                       "abort", abortFuncTy);
       }
       rewriter.create<LLVM::CallOp>(loc, abortFunc, std::nullopt);
       rewriter.create<LLVM::UnreachableOp>(loc);
     } else {
       rewriter.create<LLVM::BrOp>(loc, ValueRange(), continuationBlock);
     }
 
     // Generate assertion test.
     rewriter.setInsertionPointToEnd(opBlock);
     rewriter.replaceOpWithNewOp<LLVM::CondBrOp>(
-        op, adaptor.getArg(), continuationBlock, failureBlock);
+        op, adaptor.getCondition(), continuationBlock, failureBlock);
 
     return success();
   }
 
 private:
   /// If set to `false`, messages are printed but program execution continues.
   /// This is useful for testing asserts.
   bool abortOnFailedAssert = true;

mlir/lib/Dialect/Async/Transforms/AsyncToAsyncRuntime.cpp

if (funcCoro == coros_->end())
       return rewriter.notifyMatchFailure(
           op, "operation is not inside the async coroutine function");
 
     Location loc = op->getLoc();
     CoroMachinery &coro = funcCoro->getSecond();
 
     Block *cont = rewriter.splitBlock(op->getBlock(), Block::iterator(op));
     rewriter.setInsertionPointToEnd(cont->getPrevNode());
-    rewriter.create<cf::CondBranchOp>(loc, adaptor.getArg(),
+    rewriter.create<cf::CondBranchOp>(loc, adaptor.getCondition(),
                                       /*trueDest=*/cont,
                                       /*trueArgs=*/ArrayRef<Value>(),
                                       /*falseDest=*/setupSetErrorBlock(coro),
                                       /*falseArgs=*/ArrayRef<Value>());
     rewriter.eraseOp(op);
 
     return success();
   }

mlir/lib/Dialect/ControlFlow/IR/ControlFlowOps.cpp

 }
 
 //===----------------------------------------------------------------------===//
 // AssertOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult AssertOp::canonicalize(AssertOp op, PatternRewriter &rewriter) {
   // Erase assertion if argument is constant true.
-  if (matchPattern(op.getArg(), m_One())) {
+  if (matchPattern(op.getCondition(), m_One())) {
     rewriter.eraseOp(op);
     return success();
   }
   return failure();
 }
 
+void AssertOp::build(OpBuilder &builder, OperationState &result,
+                     Value condition) {
+  build(builder, result, condition, /*msg=*/StringAttr());
+}
+
+void AssertOp::build(OpBuilder &builder, OperationState &result,
+                     Value condition, StringAttr msg) {
+  build(builder, result, condition, msg, /*msgArgs=*/ValueRange());
+}
+
+void AssertOp::build(OpBuilder &builder, OperationState &result,
+                     Value condition, StringRef msg) {
+  build(builder, result, condition, msg, /*msgArgs=*/ValueRange());
+}
+
+LogicalResult AssertOp::verify() {
+  int64_t expectedNumMsgArgs = getMsg().count("{}");
+  if (expectedNumMsgArgs != getMsgArgs().size())
+    return emitOpError() << "expected " << expectedNumMsgArgs
+                         << " msgArgs but found " << getMsgArgs().size();
+  return success();
+}
+
 //===----------------------------------------------------------------------===//
 // BranchOp
 //===----------------------------------------------------------------------===//
 
 /// Given a successor, try to collapse it to a new destination if it only
 /// contains a passthrough unconditional branch. If the successor is
 /// collapsable, `successor` and `successorOperands` are updated to reference
 /// the new destination and values. `argStorage` is used as storage if operands

mlir/lib/Dialect/LLVMIR/IR/FunctionCallUtils.cpp

 /// Helper functions to lookup or create the declaration for commonly used
 /// external C function calls. The list of functions provided here must be
 /// implemented separately (e.g. as  part of a support runtime library or as
 /// part of the libc).
 static constexpr llvm::StringRef kPrintI64 = "printI64";
 static constexpr llvm::StringRef kPrintU64 = "printU64";
 static constexpr llvm::StringRef kPrintF32 = "printF32";
 static constexpr llvm::StringRef kPrintF64 = "printF64";
-static constexpr llvm::StringRef kPrintStr = "puts";
+static constexpr llvm::StringRef kPrintStr = "printStr";
 static constexpr llvm::StringRef kPrintOpen = "printOpen";
 static constexpr llvm::StringRef kPrintClose = "printClose";
 static constexpr llvm::StringRef kPrintComma = "printComma";
 static constexpr llvm::StringRef kPrintNewline = "printNewline";
 static constexpr llvm::StringRef kMalloc = "malloc";
 static constexpr llvm::StringRef kAlignedAlloc = "aligned_alloc";
 static constexpr llvm::StringRef kFree = "free";
 static constexpr llvm::StringRef kGenericAlloc = "_mlir_memref_to_llvm_alloc";

mlir/lib/Dialect/MemRef/Transforms/RuntimeOpVerification.cpp

 //===- RuntimeOpVerification.cpp - Op Verification ------------------------===//
 //
 // 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/MemRef/Transforms/RuntimeOpVerification.h"
 
 #include "mlir/Dialect/Arith/IR/Arith.h"
 #include "mlir/Dialect/ControlFlow/IR/ControlFlow.h"
 #include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Interfaces/RuntimeVerifiableOpInterface.h"
 
+using namespace mlir;
+using namespace mlir::memref;
+
+/// Generate a string representation of the given MemRef type with placeholders.
+/// Placeholders are represented by {} in the result string.
+static std::pair<std::string, SmallVector<Value>>
+generateMemRefTypePrinter(BaseMemRefType type,
+                          ExtractStridedMetadataOp metadataOp) {
+  SmallVector<Value> placeholders;
+  std::string buffer;
+  llvm::raw_string_ostream stream(buffer);
+
+  // Unranked memref: directly print the type.
+  if (auto unrankedMemrefType = type.dyn_cast<UnrankedMemRefType>()) {
+    unrankedMemrefType.print(stream);
+    return std::make_pair(stream.str(), placeholders);
+  }
+
+  // Print shape of the memref.
+  auto rankedMemrefType = type.dyn_cast<MemRefType>();
+  stream << "memref<";
+  for (int64_t i = 0; i < rankedMemrefType.getRank(); ++i) {
+    stream << "{}x";
+    placeholders.push_back(metadataOp.getResult(2 + i));
+  }
+
+  // Print element type.
+  rankedMemrefType.getElementType().print(stream);
+
+  // Print strides and offset.
+  stream << ", strided<[";
+  for (int64_t i = 0; i < rankedMemrefType.getRank(); ++i) {
+    stream << "{}";
+    placeholders.push_back(
+        metadataOp.getResult(2 + rankedMemrefType.getRank() + i));
+    if (i < rankedMemrefType.getRank() - 1)
+      stream << ", ";
+  }
+  stream << "], offset: {}>";
+  placeholders.push_back(metadataOp.getResult(1));
+
+  return std::make_pair(stream.str(), placeholders);
+}
+
+/// Generate a runtime assertion with the given condition value and an
+/// "invalid cast" error message indicating the type mismatch.
+static void generateInvalidCastCheck(OpBuilder &builder, Location loc,
+                                     Value condition, MemRefType srcType,
+                                     MemRefType targetType,
+                                     ExtractStridedMetadataOp metadataOp) {
+  SmallVector<Value> placeholders;
+  std::string srcTypeStr;
+  std::tie(srcTypeStr, placeholders) =
+      generateMemRefTypePrinter(srcType, metadataOp);
+
+  std::string buffer;
+  llvm::raw_string_ostream stream(buffer);
+  stream << "memref.cast: invalid cast from " << srcTypeStr << " to ";
+  targetType.print(stream);
+  builder.create<cf::AssertOp>(loc, condition, stream.str(), placeholders);
+}
+
 namespace mlir {
 namespace memref {
 namespace {
 struct CastOpInterface
     : public RuntimeVerifiableOpInterface::ExternalModel<CastOpInterface,
                                                          CastOp> {
   void generateRuntimeVerification(Operation *op, OpBuilder &builder,
                                    Location loc) const {
     auto castOp = cast<CastOp>(op);
     auto srcType = castOp.getSource().getType().cast<BaseMemRefType>();
 
     // Nothing to check if the result is an unranked memref.
     auto resultType = castOp.getType().dyn_cast<MemRefType>();
     if (!resultType)
       return;
 
     if (srcType.isa<UnrankedMemRefType>()) {
       // Check rank.
       Value srcRank = builder.create<RankOp>(loc, castOp.getSource());
       Value resultRank =
           builder.create<arith::ConstantIndexOp>(loc, resultType.getRank());
       Value isSameRank = builder.create<arith::CmpIOp>(
           loc, arith::CmpIPredicate::eq, srcRank, resultRank);
-      builder.create<cf::AssertOp>(loc, isSameRank,
-                                   "memref::CastOp: rank mismatch");
+      builder.create<cf::AssertOp>(
+          loc, isSameRank,
+          "memref.cast: invalid cast from rank {} to " +
+              std::to_string(resultType.getRank()),
+          ArrayRef<Value>{srcRank});
     }
 
+    // Get source offset and strides. We do not have an op to get offsets and
+    // strides from unranked memrefs, so cast the source to a type with fully
+    // dynamic layout, from which we can then extract the offset and strides.
+    // (Rank was already verified.)
+    int64_t dynamicOffset = ShapedType::kDynamic;
+    SmallVector<int64_t> dynamicShape(resultType.getRank(),
+                                      ShapedType::kDynamic);
+    auto stridedLayout = StridedLayoutAttr::get(builder.getContext(),
+                                                dynamicOffset, dynamicShape);
+    auto rankedSrcType =
+        MemRefType::get(dynamicShape, resultType.getElementType(),
+                        stridedLayout, resultType.getMemorySpace());
+    Value helperCast =
+        builder.create<CastOp>(loc, rankedSrcType, castOp.getSource());
+    auto metadataOp = builder.create<ExtractStridedMetadataOp>(loc, helperCast);
+
     // Check dimension sizes.
     for (const auto &it : llvm::enumerate(resultType.getShape())) {
       // Static dim size -> static/dynamic dim size does not need verification.
       if (auto rankedSrcType = srcType.dyn_cast<MemRefType>())
         if (!rankedSrcType.isDynamicDim(it.index()))
           continue;
 
       // Static/dynamic dim size -> dynamic dim size does not need verification.
       if (resultType.isDynamicDim(it.index()))
         continue;
 
       Value srcDimSz =
           builder.create<DimOp>(loc, castOp.getSource(), it.index());
       Value resultDimSz =
           builder.create<arith::ConstantIndexOp>(loc, it.value());
       Value isSameSz = builder.create<arith::CmpIOp>(
           loc, arith::CmpIPredicate::eq, srcDimSz, resultDimSz);
-      builder.create<cf::AssertOp>(loc, isSameSz,
-                                   "memref::CastOp: size mismatch of dim " +
-                                       std::to_string(it.index()));
+      generateInvalidCastCheck(builder, loc, isSameSz, rankedSrcType,
+                               resultType, metadataOp);
     }
 
-    // Get source offset and strides. We do not have an op to get extract
-    // offsets and strides from unranked memrefs, so cast the source to a type
-    // with fully dynamic layout, from which we can then extract the offset and
-    // strides. (Rank was already verified.)
-    int64_t dynamicOffset = ShapedType::kDynamic;
-    SmallVector<int64_t> dynamicShape(resultType.getRank(),
-                                      ShapedType::kDynamic);
-    auto stridedLayout = StridedLayoutAttr::get(builder.getContext(),
-                                                dynamicOffset, dynamicShape);
-    auto dynStridesType =
-        MemRefType::get(dynamicShape, resultType.getElementType(),
-                        stridedLayout, resultType.getMemorySpace());
-    Value helperCast =
-        builder.create<CastOp>(loc, dynStridesType, castOp.getSource());
-    auto metadataOp = builder.create<ExtractStridedMetadataOp>(loc, helperCast);
-
     // Get result offset and strides.
     int64_t resultOffset;
     SmallVector<int64_t> resultStrides;
     if (failed(getStridesAndOffset(resultType, resultStrides, resultOffset)))
-      return;
+      llvm_unreachable("could not get strides and offset");
 
     // Check offset.
     if (resultOffset != ShapedType::kDynamic) {
       // Static/dynamic offset -> dynamic offset does not need verification.
       Value srcOffset = metadataOp.getResult(1);
       Value resultOffsetVal =
           builder.create<arith::ConstantIndexOp>(loc, resultOffset);
       Value isSameOffset = builder.create<arith::CmpIOp>(
           loc, arith::CmpIPredicate::eq, srcOffset, resultOffsetVal);
-      builder.create<cf::AssertOp>(loc, isSameOffset,
-                                   "memref::CastOp: offset mismatch");
+      generateInvalidCastCheck(builder, loc, isSameOffset, rankedSrcType,
+                               resultType, metadataOp);
     }
 
     // Check strides.
     for (const auto &it : llvm::enumerate(resultStrides)) {
       // Static/dynamic stride -> dynamic stride does not need verification.
       if (it.value() == ShapedType::kDynamic)
         continue;
 
       Value srcStride =
           metadataOp.getResult(2 + resultType.getRank() + it.index());
       Value resultStrideVal =
           builder.create<arith::ConstantIndexOp>(loc, it.value());
       Value isSameStride = builder.create<arith::CmpIOp>(
           loc, arith::CmpIPredicate::eq, srcStride, resultStrideVal);
-      builder.create<cf::AssertOp>(loc, isSameStride,
-                                   "memref::CastOp: stride mismatch of dim " +
-                                       std::to_string(it.index()));
+      generateInvalidCastCheck(builder, loc, isSameStride, rankedSrcType,
+                               resultType, metadataOp);
     }
   }
 };
 
 struct ExpandShapeOpInterface
     : public RuntimeVerifiableOpInterface::ExternalModel<ExpandShapeOpInterface,
                                                          ExpandShapeOp> {
   void generateRuntimeVerification(Operation *op, OpBuilder &builder,

mlir/lib/ExecutionEngine/CRunnerUtils.cpp

 extern "C" void printU64(uint64_t u) { fprintf(stdout, "%" PRIu64, u); }
 extern "C" void printF32(float f) { fprintf(stdout, "%g", f); }
 extern "C" void printF64(double d) { fprintf(stdout, "%lg", d); }
 extern "C" void printOpen() { fputs("( ", stdout); }
 extern "C" void printClose() { fputs(" )", stdout); }
 extern "C" void printComma() { fputs(", ", stdout); }
 extern "C" void printNewline() { fputc('\n', stdout); }
 
+// For debug assertions only: Print the given string.
+extern "C" void printStr(int8_t *str) {
+  // Note: puts adds a new line, fputs does not add a new line.
+  fputs(reinterpret_cast<char *>(str), stdout);
+}
+
 extern "C" void memrefCopy(int64_t elemSize, UnrankedMemRefType<char> *srcArg,
                            UnrankedMemRefType<char> *dstArg) {
   DynamicMemRefType<char> src(*srcArg);
   DynamicMemRefType<char> dst(*dstArg);
 
   int64_t rank = src.rank;
   MLIR_MSAN_MEMORY_IS_INITIALIZED(src.sizes, rank * sizeof(int64_t));
 

mlir/test/Integration/Dialect/ControlFlow/assert.mlir

 // RUN: mlir-opt %s -test-cf-assert \
-// RUN:     -convert-func-to-llvm | \
-// RUN: mlir-cpu-runner -e main -entry-point-result=void | \
+// RUN:     -convert-func-to-llvm -reconcile-unrealized-casts | \
+// RUN: mlir-cpu-runner -e main -entry-point-result=void \
+// RUN:     -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext | \
 // RUN: FileCheck %s
 
 func.func @main() {
   %a = arith.constant 0 : i1
   %b = arith.constant 1 : i1
+  %cst = arith.constant 123 : index
+  %f = arith.constant 5.6 : f32
   // CHECK: assertion foo
   cf.assert %a, "assertion foo"
   // CHECK-NOT: assertion bar
   cf.assert %b, "assertion bar"
+  // CHECK: assertion 123 foo
+  cf.assert %a, "assertion {} foo"(%cst) : index
+  // CHECK: assertion 5.6 qux
+  cf.assert %a, "assertion {} qux"(%f) : f32
   return
 }

mlir/test/Integration/Dialect/Memref/cast-runtime-verification.mlir

%0 = memref.cast %m : memref<?xf32, strided<[?], offset: ?>>
                      to memref<?xf32, strided<[9], offset: 5>>
   return %0 : memref<?xf32, strided<[9], offset: 5>>
 }
 
 func.func @main() {
   // All casts inside the called functions are invalid at runtime.
   %alloc = memref.alloc() : memref<5xf32>
 
-  // CHECK: memref::CastOp: size mismatch of dim 0
+  // CHECK: memref.cast: invalid cast from memref<5xf32, strided<[1], offset: 0> to memref<10xf32>
   %1 = memref.cast %alloc : memref<5xf32> to memref<?xf32>
   func.call @cast_to_static_dim(%1) : (memref<?xf32>) -> (memref<10xf32>)
 
-  // CHECK-NEXT: memref::CastOp: rank mismatch
+  // CHECK-NEXT: memref.cast: invalid cast from rank 1 to 0
   %3 = memref.cast %alloc : memref<5xf32> to memref<*xf32>
   func.call @cast_to_ranked(%3) : (memref<*xf32>) -> (memref<f32>)
 
-  // CHECK-NEXT: memref::CastOp: offset mismatch
-  // CHECK-NEXT: memref::CastOp: stride mismatch of dim 0
+  // Next error is printed twice (because of abort-on-failed-assert=0). One for
+  // the stride and one for the offset.
+  // CHECK-NEXT: memref.cast: invalid cast from memref<5xf32, strided<[1], offset: 0> to memref<?xf32, strided<[9], offset: 5>>
+  // CHECK-NEXT: memref.cast: invalid cast from memref<5xf32, strided<[1], offset: 0> to memref<?xf32, strided<[9], offset: 5>>
   %4 = memref.cast %alloc
       : memref<5xf32> to memref<?xf32, strided<[?], offset: ?>>
   func.call @cast_to_static_strides(%4)
       : (memref<?xf32, strided<[?], offset: ?>>)
      -> (memref<?xf32, strided<[9], offset: 5>>)
 
   return
 }