[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

49–53

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. 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/include/mlir/Interfaces/RuntimeVerifiableOpInterface.h

 //===- RuntimeVerifiableOpInterface.h - Op Verification ---------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_INTERFACES_RUNTIMEVERIFIABLEOPINTERFACE_H_
 #define MLIR_INTERFACES_RUNTIMEVERIFIABLEOPINTERFACE_H_
 
 #include "mlir/IR/OpDefinition.h"
 
 #include "llvm/ADT/SmallVector.h"
 
+namespace mlir {
+/// The condition of a runtime check can be assumed (asserted to be) satisfied
+/// at runtime. The message and placeholders can be used to emit descriptive
+/// error messages.
+struct RuntimeVerificationCheck {
+  RuntimeVerificationCheck(Value condition, StringAttr msg = {},
+                           ArrayRef<Value> msgPlaceholders = {});
+
+  Value condition;
+  StringAttr msg;
+  SmallVector<Value> msgPlaceholders;
+};
+} // namespace mlir
 /// Include the generated interface declarations.
 #include "mlir/Interfaces/RuntimeVerifiableOpInterface.h.inc"
 
 #endif // MLIR_INTERFACES_RUNTIMEVERIFIABLEOPINTERFACE_H_

mlir/include/mlir/Interfaces/RuntimeVerifiableOpInterface.td

let description = [{
     strides instead of static memref strides). Such cases can be checked at
     runtime. The op-specific checks are generated by this interface.
   }];
   let cppNamespace = "::mlir";
 
   let methods = [
     InterfaceMethod<
       /*desc=*/[{
-        Generate IR to verify this op at runtime. Return a list of i1-typed
-        values that are assumed (can be asserted to be) satisfied (`true`) at
-        runtime, along with corresponding error messages in case they are not
-        satisfied.
+        Generate IR to verify this op at runtime. Return a list of 
+        `RuntimeVerificationCheck` objects. Each object consists of:
+
+        1. A condition value that is assumed (can be asserted to be) satisfied
+           (`true`) at runtime.
+        2. An error message string in case the condition is not satisfied. The
+           error message may contain 'n' placeholders, each indicated by '{}'.
+        3. 'n' placeholder values.
+
+        Note: Placeholders can be used to generate descriptive error messages
+        based on runtime values.
       }],
-      /*retTy=*/"::llvm::SmallVector<::std::pair<::mlir::Value, ::mlir::StringAttr>>",
+      /*retTy=*/"::llvm::SmallVector<::mlir::RuntimeVerificationCheck>",
       /*methodName=*/"generateRuntimeVerification",
       /*args=*/(ins "::mlir::OpBuilder &":$builder,
                     "::mlir::Location":$loc)
     >,
   ];
 }
 
 #endif // MLIR_INTERFACES_RUNTIMEVERIFIABLEOPINTERFACE

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.push_back('\n');
+  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);
 }
 
+/// Generate IR that prints the given value.
+static void createPrintValue(OpBuilder &builder,
+                             LLVMTypeConverter *typeConverter, Location loc,
+                             ModuleOp moduleOp, Value value) {
+  Operation *printer =
+      llvm::TypeSwitch<Type, Operation *>(value.getType())
+          .Case<IntegerType>([&](IntegerType intTy) {
+            if (intTy.isInteger(64) && !intTy.isUnsigned())
+              return LLVM::lookupOrCreatePrintI64Fn(moduleOp).getOperation();
+            return static_cast<Operation *>(nullptr);
+          })
+          .Default([](Type t) { return nullptr; });
+
+  // Add support for additional types as needed.
+  assert(printer && "unsupported type");
+  builder.create<LLVM::CallOp>(loc, TypeRange(), SymbolRefAttr::get(printer),
+                               value);
+}
+
+/// Generate IR that prints the given message and interleaved message args.
+static void createPrintMsg(OpBuilder &builder, LLVMTypeConverter *typeConverter,
+                           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.
+      createPrintValue(builder, typeConverter, loc, moduleOp,
+                       remainingArgs.front());
+      remainingArgs = remainingArgs.drop_front();
+    }
+    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 {
     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(), 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, llvm::None);
       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/ControlFlow/Transforms/GenerateRuntimeVerification.cpp

 };
 } // namespace
 
 void GenerateRuntimeVerificationPass::runOnOperation() {
   OpBuilder builder(getOperation()->getContext());
   getOperation()->walk([&](Operation *op) {
     if (auto verifiableOp = dyn_cast<RuntimeVerifiableOpInterface>(op)) {
       builder.setInsertionPoint(op);
-      SmallVector<std::pair<Value, StringAttr>> checks =
+      SmallVector<RuntimeVerificationCheck> checks =
           verifiableOp.generateRuntimeVerification(builder, op->getLoc());
       for (const auto &check : checks)
-        builder.create<cf::AssertOp>(op->getLoc(), check.first, check.second);
+        builder.create<cf::AssertOp>(op->getLoc(), check.condition, check.msg,
+                                     check.msgPlaceholders);
     }
   });
 }
 
 std::unique_ptr<Pass> mlir::cf::createGenerateRuntimeVerificationPass() {
   return std::make_unique<GenerateRuntimeVerificationPass>();
 }

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/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.
+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) {
+    if (rankedMemrefType.isDynamicDim(i)) {
+      stream << "{}";
+      placeholders.push_back(metadataOp.getResult(2 + i));
+    } else {
+      stream << std::to_string(rankedMemrefType.getDimSize(i));
+    }
+    stream << "x";
+  }
+
+  // Print element type.
+  rankedMemrefType.getElementType().print(stream);
+
+  // Get result offset and strides.
+  int64_t resultOffset;
+  SmallVector<int64_t> resultStrides;
+  if (failed(
+          getStridesAndOffset(rankedMemrefType, resultStrides, resultOffset)))
+    llvm_unreachable("could not get strides and offset");
+
+  // Print strides and offset.
+  stream << ", strided<[";
+  for (int64_t i = 0; i < rankedMemrefType.getRank(); ++i) {
+    if (resultStrides[i] == ShapedType::kDynamic) {
+      stream << "{}";
+      placeholders.push_back(
+          metadataOp.getResult(2 + rankedMemrefType.getRank() + i));
+    } else {
+      stream << std::to_string(resultStrides[i]);
+    }
+
+    if (i < rankedMemrefType.getRank() - 1)
+      stream << ", ";
+  }
+  stream << "], offset: ";
+  if (resultOffset == ShapedType::kDynamic) {
+    stream << "{}";
+    placeholders.push_back(metadataOp.getResult(1));
+  } else {
+    stream << std::to_string(resultOffset);
+  }
+  stream << ">";
+
+  return std::make_pair(stream.str(), placeholders);
+}
+
+/// Generate an "invalid" memref.cast error message with placeholders for
+/// dynamic dims/strides/offset.
+static std::pair<std::string, SmallVector<Value>>
+generateInvalidCastMessage(OpBuilder &builder, 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);
+  return std::make_pair(stream.str(), placeholders);
+}
+
+/// Generate a RuntimeVerificationCheck with the given condition for an invalid
+/// memref.cast op.
+static RuntimeVerificationCheck
+generateInvalidCastCheck(OpBuilder &builder, Value condition,
+                         MemRefType srcType, MemRefType targetType,
+                         ExtractStridedMetadataOp metadataOp) {
+  std::string msg;
+  SmallVector<Value> placeholders;
+  std::tie(msg, placeholders) =
+      generateInvalidCastMessage(builder, srcType, targetType, metadataOp);
+  return RuntimeVerificationCheck(condition, builder.getStringAttr(msg),
+                                  placeholders);
+}
+
 namespace mlir {
 namespace memref {
 namespace {
 struct CastOpInterface
     : public RuntimeVerifiableOpInterface::ExternalModel<CastOpInterface,
                                                          CastOp> {
-  SmallVector<std::pair<Value, StringAttr>>
+  SmallVector<RuntimeVerificationCheck>
   generateRuntimeVerification(Operation *op, OpBuilder &builder,
                               Location loc) const {
     auto castOp = cast<CastOp>(op);
     auto srcType = castOp.getSource().getType().cast<BaseMemRefType>();
-    SmallVector<std::pair<Value, StringAttr>> result;
+    SmallVector<RuntimeVerificationCheck> checks;
 
     // Nothing to check if the result is an unranked memref.
     auto resultType = castOp.getType().dyn_cast<MemRefType>();
     if (!resultType)
-      return result;
+      return checks;
 
     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);
-      result.emplace_back(
-          isSameRank, builder.getStringAttr("memref::CastOp: rank mismatch"));
+      checks.emplace_back(
+          isSameRank,
+          builder.getStringAttr("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 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 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);
-      result.emplace_back(
-          isSameSz,
-          builder.getStringAttr("memref::CastOp: size mismatch of dim " +
-                                std::to_string(it.index())));
+      checks.push_back(generateInvalidCastCheck(
+          builder, 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 result;
+      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);
-      result.emplace_back(isSameOffset, builder.getStringAttr(
-                                            "memref::CastOp: offset mismatch"));
+      checks.push_back(generateInvalidCastCheck(
+          builder, 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);
-      result.emplace_back(
-          isSameStride,
-          builder.getStringAttr("memref::CastOp: stride mismatch of dim " +
-                                std::to_string(it.index())));
+      checks.push_back(generateInvalidCastCheck(
+          builder, isSameStride, rankedSrcType, resultType, metadataOp));
     }
 
-    return result;
+    return checks;
   }
 };
 
 struct ExpandShapeOpInterface
     : public RuntimeVerifiableOpInterface::ExternalModel<ExpandShapeOpInterface,
                                                          ExpandShapeOp> {
-  SmallVector<std::pair<Value, StringAttr>>
+  SmallVector<RuntimeVerificationCheck>
   generateRuntimeVerification(Operation *op, OpBuilder &builder,
                               Location loc) const {
     auto expandShapeOp = cast<ExpandShapeOp>(op);
-    SmallVector<std::pair<Value, StringAttr>> result;
+    SmallVector<RuntimeVerificationCheck> checks;
 
     // Verify that the expanded dim sizes are a product of the collapsed dim
     // size.
     for (auto it : llvm::enumerate(expandShapeOp.getReassociationIndices())) {
       Value srcDimSz =
           builder.create<DimOp>(loc, expandShapeOp.getSrc(), it.index());
       int64_t groupSz = 1;
       bool foundDynamicDim = false;
for (auto it : llvm::enumerate(expandShapeOp.getReassociationIndices())) {
       Value staticResultDimSz =
           builder.create<arith::ConstantIndexOp>(loc, groupSz);
       // staticResultDimSz must divide srcDimSz evenly.
       Value mod =
           builder.create<arith::RemSIOp>(loc, srcDimSz, staticResultDimSz);
       Value isModZero = builder.create<arith::CmpIOp>(
           loc, arith::CmpIPredicate::eq, mod,
           builder.create<arith::ConstantIndexOp>(loc, 0));
-      result.emplace_back(
+      checks.emplace_back(
           isModZero,
           builder.getStringAttr("memref::ExpandShapeOp: static result dims in "
                                 "reassoc group do not divide src dim evenly"));
     }
 
-    return result;
+    return checks;
   }
 };
 } // namespace
 } // namespace memref
 } // namespace mlir
 
 void mlir::memref::registerRuntimeVerifiableOpInterfaceExternalModels(
     DialectRegistry &registry) {
   registry.addExtension(+[](MLIRContext *ctx, memref::MemRefDialect *dialect) {
     CastOp::attachInterface<CastOpInterface>(*ctx);
     ExpandShapeOp::attachInterface<ExpandShapeOpInterface>(*ctx);
 
     // Load additional dialects of which ops may get created.
     ctx->loadDialect<arith::ArithDialect>();
   });
 }

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) {
-  fputs(reinterpret_cast<char *>(str), stderr);
+  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/lib/Interfaces/RuntimeVerifiableOpInterface.cpp

 //===- RuntimeVerifiableOpInterface.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/Interfaces/RuntimeVerifiableOpInterface.h"
 
 namespace mlir {
 class Location;
 class OpBuilder;
 } // namespace mlir
 
+using namespace mlir;
+
+RuntimeVerificationCheck::RuntimeVerificationCheck(
+    Value condition, StringAttr msg, ArrayRef<Value> msgPlaceholders)
+    : condition(condition), msg(msg), msgPlaceholders(msgPlaceholders) {
+  assert(!msg || msg.strref().count("{}") == msgPlaceholders.size() &&
+                     "invalid number of placeholders");
+}
+
 /// Include the definitions of the interface.
 #include "mlir/Interfaces/RuntimeVerifiableOpInterface.cpp.inc"

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

 // RUN: mlir-opt %s -convert-cf-to-llvm="abort-on-failed-assert=0" \
-// RUN:     -convert-func-to-llvm | \
+// 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 2>&1 | \
 // RUN: FileCheck %s
 
 func.func @main() {
   %a = arith.constant 0 : i1
   %b = arith.constant 1 : i1
+  %cst = arith.constant 123 : index
   // 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
   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
 }