[mlir] Add RuntimeVerifiableOpInterface and transform

[springerm]

Summary

Static op verification cannot detect cases where an op is valid at compile time but may be invalid at runtime.

An example of such an op is memref::ExpandShapeOp.

Invalid at compile time: memref.expand_shape %m [[0, 1]] : memref<11xf32> into memref<2x5xf32>

Valid at compile time (because we do not know any better): memref.expand_shape %m [[0, 1]] : memref<?xf32> into memref<?x5xf32>. This op may or may not be valid at runtime depending on the runtime shape of %m.

Invalid runtime ops such as the one above are hard to debug because they can crash the program execution at a seemingly unrelated position or (even worse) compute an invalid result without crashing.

This revision adds a new op interface RuntimeVerifiableOpInterface that can be implemented by ops that provide additional runtime verification. Such runtime verification can be computationally expensive, so it is only generated on an opt-in basis by running -generate-runtime-verification. A simple runtime verifier for memref::ExpandShapeOp is provided as an example.

[rriddle]

This looks like something that needs an RFC. I'd like to see a post on discourse proposing something here.

[springerm]

Related RFC: https://discourse.llvm.org/t/rfc-runtime-op-verification/66776

[springerm]

return values and strings instead of generating AssertOps in the interface impl

[springerm]

fix cmake

[springerm]

fix cmake

[springerm]

rebase

[springerm]

address RFC comments

[springerm]

rebase

[springerm]

rebase

[mehdi_amini]

Fine with me, @rriddle has the RFC been discussed enough to satisfy your block?

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

68

you depend on cf as well here...

mlir/lib/Transforms/GenerateRuntimeVerification.cpp

34

Just a nit, but does getOperation()->walk([&](RuntimeVerifiableOpInterface verifiableOp) work?

[springerm]

address comments

mlir/lib/Transforms/GenerateRuntimeVerification.cpp

34

Yes it does

[rriddle]

Looks reasonable to me!

mlir/include/mlir/Interfaces/RuntimeVerifiableOpInterface.td

30

mlir/lib/Transforms/GenerateRuntimeVerification.cpp

34

Why not just create the builder here? I don't think you save much by creating the builder outside.

[rriddle]

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

18–20

59–61

[guraypp]

This comment was removed by guraypp.

mlir/include/mlir/Dialect/MemRef/Transforms/RuntimeOpVerification.h

+//===- RuntimeOpVerification.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_DIALECT_MEMREF_RUNTIMEOPVERIFICATION_H
+#define MLIR_DIALECT_MEMREF_RUNTIMEOPVERIFICATION_H
+
+namespace mlir {
+class DialectRegistry;
+
+namespace memref {
+void registerRuntimeVerifiableOpInterfaceExternalModels(
+    DialectRegistry &registry);
+} // namespace memref
+} // namespace mlir
+
+#endif // MLIR_DIALECT_MEMREF_RUNTIMEOPVERIFICATION_H

mlir/include/mlir/InitAllDialects.h

 #include "mlir/Dialect/Linalg/IR/Linalg.h"
 #include "mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.h"
 #include "mlir/Dialect/Linalg/Transforms/BufferizableOpInterfaceImpl.h"
 #include "mlir/Dialect/Linalg/Transforms/TilingInterfaceImpl.h"
 #include "mlir/Dialect/MLProgram/IR/MLProgram.h"
 #include "mlir/Dialect/Math/IR/Math.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/MemRef/TransformOps/MemRefTransformOps.h"
+#include "mlir/Dialect/MemRef/Transforms/RuntimeOpVerification.h"
 #include "mlir/Dialect/NVGPU/IR/NVGPUDialect.h"
 #include "mlir/Dialect/OpenACC/OpenACC.h"
 #include "mlir/Dialect/OpenMP/OpenMPDialect.h"
 #include "mlir/Dialect/PDL/IR/PDL.h"
 #include "mlir/Dialect/PDLInterp/IR/PDLInterp.h"
 #include "mlir/Dialect/Quant/QuantOps.h"
 #include "mlir/Dialect/SCF/IR/SCF.h"
 #include "mlir/Dialect/SCF/TransformOps/SCFTransformOps.h"
inline void registerAllDialects(DialectRegistry &registry) {
   vector::registerTransformDialectExtension(registry);
 
   // Register all external models.
   arith::registerBufferizableOpInterfaceExternalModels(registry);
   bufferization::func_ext::registerBufferizableOpInterfaceExternalModels(
       registry);
   linalg::registerBufferizableOpInterfaceExternalModels(registry);
   linalg::registerTilingInterfaceExternalModels(registry);
+  memref::registerRuntimeVerifiableOpInterfaceExternalModels(registry);
   scf::registerBufferizableOpInterfaceExternalModels(registry);
   shape::registerBufferizableOpInterfaceExternalModels(registry);
   sparse_tensor::registerBufferizableOpInterfaceExternalModels(registry);
   tensor::registerBufferizableOpInterfaceExternalModels(registry);
   tensor::registerInferTypeOpInterfaceExternalModels(registry);
   tensor::registerTilingInterfaceExternalModels(registry);
   vector::registerBufferizableOpInterfaceExternalModels(registry);
 }

mlir/include/mlir/Interfaces/CMakeLists.txt

 add_mlir_interface(CallInterfaces)
 add_mlir_interface(CastInterfaces)
 add_mlir_interface(ControlFlowInterfaces)
 add_mlir_interface(CopyOpInterface)
 add_mlir_interface(DerivedAttributeOpInterface)
 add_mlir_interface(DestinationStyleOpInterface)
 add_mlir_interface(InferIntRangeInterface)
 add_mlir_interface(InferTypeOpInterface)
 add_mlir_interface(LoopLikeInterface)
 add_mlir_interface(ParallelCombiningOpInterface)
+add_mlir_interface(RuntimeVerifiableOpInterface)
 add_mlir_interface(ShapedOpInterfaces)
 add_mlir_interface(SideEffectInterfaces)
 add_mlir_interface(TilingInterface)
 add_mlir_interface(VectorInterfaces)
 add_mlir_interface(ViewLikeInterface)
 
 set(LLVM_TARGET_DEFINITIONS DataLayoutInterfaces.td)
 mlir_tablegen(DataLayoutAttrInterface.h.inc -gen-attr-interface-decls)

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 the generated interface declarations.
+#include "mlir/Interfaces/RuntimeVerifiableOpInterface.h.inc"
+
+#endif // MLIR_INTERFACES_RUNTIMEVERIFIABLEOPINTERFACE_H_

mlir/include/mlir/Interfaces/RuntimeVerifiableOpInterface.td

+//===- RuntimeVerifiableOpInterface.td - Op Verification ---*- tablegen -*-===//
+//
+// 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
+#define MLIR_INTERFACES_RUNTIMEVERIFIABLEOPINTERFACE
+
+include "mlir/IR/OpBase.td"
+
+def RuntimeVerifiableOpInterface : OpInterface<"RuntimeVerifiableOpInterface"> {
+  let description = [{
+    Implementations of this interface generate IR for runtime op verification.
+
+    Incorrect op usage can often be caught by op verifiers based on static
+    program information. However, in the absence of static program information,
+    it can remain undetected at compile time (e.g., in case of dynamic memref
+    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, aborting runtime execution if
+        verification fails.
+      }],
+      /*retTy=*/"void",
+      /*methodName=*/"generateRuntimeVerification",
+      /*args=*/(ins "::mlir::OpBuilder &":$builder,
+                    "::mlir::Location":$loc)
+    >,
+  ];
+}
+
+#endif // MLIR_INTERFACES_RUNTIMEVERIFIABLEOPINTERFACE

mlir/include/mlir/Transforms/Passes.h

createCanonicalizerPass(const GreedyRewriteConfig &config,
                         ArrayRef<std::string> enabledPatterns = std::nullopt);
 
 /// Creates a pass to perform control-flow sinking.
 std::unique_ptr<Pass> createControlFlowSinkPass();
 
 /// Creates a pass to perform common sub expression elimination.
 std::unique_ptr<Pass> createCSEPass();
 
+/// Creates a pass that generates IR to verify ops at runtime.
+std::unique_ptr<Pass> createGenerateRuntimeVerificationPass();
+
 /// Creates a loop invariant code motion pass that hoists loop invariant
 /// instructions out of the loop.
 std::unique_ptr<Pass> createLoopInvariantCodeMotionPass();
 
 /// Creates a pass to strip debug information from a function.
 std::unique_ptr<Pass> createStripDebugInfoPass();
 
 /// Creates a pass which prints the list of ops and the number of occurrences in

mlir/include/mlir/Transforms/Passes.td

def CSE : Pass<"cse"> {
   }];
   let constructor = "mlir::createCSEPass()";
   let statistics = [
     Statistic<"numCSE", "num-cse'd", "Number of operations CSE'd">,
     Statistic<"numDCE", "num-dce'd", "Number of operations DCE'd">
   ];
 }
 
+def GenerateRuntimeVerification : Pass<"generate-runtime-verification"> {
+  let summary = "Generate additional runtime op verification checks";
+  let description = [{
+    This pass generates op-specific runtime checks using the
+    `RuntimeVerifiableOpInterface`. It can be run for debugging purposes after
+    passes that are suspected to introduce faulty IR.
+  }];
+  let constructor = "mlir::createGenerateRuntimeVerificationPass()";
+}
+
 def Inliner : Pass<"inline"> {
   let summary = "Inline function calls";
   let constructor = "mlir::createInlinerPass()";
   let options = [
     Option<"defaultPipelineStr", "default-pipeline", "std::string",
            /*default=*/"", "The default optimizer pipeline used for callables">,
     ListOption<"opPipelineList", "op-pipelines", "OpPassManager",
                "Callable operation specific optimizer pipelines (in the form "

mlir/lib/Dialect/MemRef/Transforms/CMakeLists.txt

 add_mlir_dialect_library(MLIRMemRefTransforms
   ComposeSubView.cpp
   ExpandOps.cpp
   ExpandStridedMetadata.cpp
   EmulateWideInt.cpp
   FoldMemRefAliasOps.cpp
   MultiBuffer.cpp
   NormalizeMemRefs.cpp
   ResolveShapedTypeResultDims.cpp
+  RuntimeOpVerification.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/MemRef
 
   DEPENDS
   MLIRMemRefPassIncGen
 
   LINK_LIBS PUBLIC

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"
+
+namespace mlir {
+namespace memref {
+namespace {
+struct ExpandShapeOpInterface
+    : public RuntimeVerifiableOpInterface::ExternalModel<ExpandShapeOpInterface,
+                                                         ExpandShapeOp> {
+  void generateRuntimeVerification(Operation *op, OpBuilder &builder,
+                                   Location loc) const {
+    auto expandShapeOp = cast<ExpandShapeOp>(op);
+
+    // 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 (int64_t resultDim : it.value()) {
+        if (expandShapeOp.getResultType().isDynamicDim(resultDim)) {
+          // Keep this assert here in case the op is extended in the future.
+          assert(!foundDynamicDim &&
+                 "more than one dynamic dim found in reassoc group");
+          foundDynamicDim = true;
+          continue;
+        }
+        groupSz *= expandShapeOp.getResultType().getDimSize(resultDim);
+      }
+      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));
+      builder.create<cf::AssertOp>(
+          loc, isModZero,
+          "static result dims in reassoc group do not divide src dim evenly");
+    }
+  }
+};
+} // namespace
+} // namespace memref
+} // namespace mlir
+
+void mlir::memref::registerRuntimeVerifiableOpInterfaceExternalModels(
+    DialectRegistry &registry) {
+  registry.addExtension(+[](MLIRContext *ctx, memref::MemRefDialect *dialect) {
+    ExpandShapeOp::attachInterface<ExpandShapeOpInterface>(*ctx);
+
+    // Load additional dialects of which ops may get created.
+    ctx->loadDialect<arith::ArithDialect, cf::ControlFlowDialect>();
+  });
+}

mlir/lib/Interfaces/CMakeLists.txt

 set(LLVM_OPTIONAL_SOURCES
   CallInterfaces.cpp
   CastInterfaces.cpp
   ControlFlowInterfaces.cpp
   CopyOpInterface.cpp
   DataLayoutInterfaces.cpp
   DerivedAttributeOpInterface.cpp
   DestinationStyleOpInterface.cpp
   InferIntRangeInterface.cpp
   InferTypeOpInterface.cpp
   LoopLikeInterface.cpp
   ParallelCombiningOpInterface.cpp
+  RuntimeVerifiableOpInterface.cpp
   ShapedOpInterfaces.cpp
   SideEffectInterfaces.cpp
   TilingInterface.cpp
   VectorInterfaces.cpp
   ViewLikeInterface.cpp
   )
 
 function(add_mlir_interface_library name)

 add_mlir_interface_library(CopyOpInterface)
 add_mlir_interface_library(DataLayoutInterfaces)
 add_mlir_interface_library(DerivedAttributeOpInterface)
 add_mlir_interface_library(DestinationStyleOpInterface)
 add_mlir_interface_library(InferIntRangeInterface)
 add_mlir_interface_library(InferTypeOpInterface)
 add_mlir_interface_library(LoopLikeInterface)
 add_mlir_interface_library(ParallelCombiningOpInterface)
+add_mlir_interface_library(RuntimeVerifiableOpInterface)
 add_mlir_interface_library(ShapedOpInterfaces)
 add_mlir_interface_library(SideEffectInterfaces)
 add_mlir_interface_library(TilingInterface)
 add_mlir_interface_library(VectorInterfaces)
 add_mlir_interface_library(ViewLikeInterface)

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
+
+/// Include the definitions of the interface.
+#include "mlir/Interfaces/RuntimeVerifiableOpInterface.cpp.inc"

mlir/lib/Transforms/CMakeLists.txt

 add_subdirectory(Utils)
 
 add_mlir_library(MLIRTransforms
   Canonicalizer.cpp
   ControlFlowSink.cpp
   CSE.cpp
+  GenerateRuntimeVerification.cpp
   Inliner.cpp
   LocationSnapshot.cpp
   LoopInvariantCodeMotion.cpp
   OpStats.cpp
   SCCP.cpp
   StripDebugInfo.cpp
   SymbolDCE.cpp
   SymbolPrivatize.cpp
   TopologicalSort.cpp
   ViewOpGraph.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Transforms
 
   DEPENDS
   MLIRTransformsPassIncGen
 
   LINK_LIBS PUBLIC
   MLIRAnalysis
   MLIRCopyOpInterface
   MLIRLoopLikeInterface
   MLIRPass
+  MLIRRuntimeVerifiableOpInterface
   MLIRSideEffectInterfaces
   MLIRSupport
   MLIRTransformUtils
   )

mlir/lib/Transforms/GenerateRuntimeVerification.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/Transforms/Passes.h"
+
+#include "mlir/IR/Builders.h"
+#include "mlir/IR/Operation.h"
+#include "mlir/Interfaces/RuntimeVerifiableOpInterface.h"
+
+namespace mlir {
+#define GEN_PASS_DEF_GENERATERUNTIMEVERIFICATION
+#include "mlir/Transforms/Passes.h.inc"
+} // namespace mlir
+
+using namespace mlir;
+
+namespace {
+struct GenerateRuntimeVerificationPass
+    : public impl::GenerateRuntimeVerificationBase<
+          GenerateRuntimeVerificationPass> {
+  void runOnOperation() override;
+};
+} // namespace
+
+void GenerateRuntimeVerificationPass::runOnOperation() {
+  getOperation()->walk([&](RuntimeVerifiableOpInterface verifiableOp) {
+    OpBuilder builder(getOperation()->getContext());
+    builder.setInsertionPoint(verifiableOp);
+    verifiableOp.generateRuntimeVerification(builder, verifiableOp.getLoc());
+  });
+}
+
+std::unique_ptr<Pass> mlir::createGenerateRuntimeVerificationPass() {
+  return std::make_unique<GenerateRuntimeVerificationPass>();
+}

mlir/test/Dialect/MemRef/runtime-verification.mlir

+// RUN: mlir-opt %s -generate-runtime-verification -cse | FileCheck %s
+
+// CHECK-LABEL: func @expand_shape(
+//  CHECK-SAME:     %[[m:.*]]: memref<?xf32>
+//   CHECK-DAG:   %[[c0:.*]] = arith.constant 0 : index
+//   CHECK-DAG:   %[[c5:.*]] = arith.constant 5 : index
+//   CHECK-DAG:   %[[dim:.*]] = memref.dim %[[m]], %[[c0]]
+//       CHECK:   %[[mod:.*]] = arith.remsi %[[dim]], %[[c5]]
+//       CHECK:   %[[cmpi:.*]] = arith.cmpi eq, %[[mod]], %[[c0]]
+//       CHECK:   cf.assert %[[cmpi]], "static result dims in reassoc group do not divide src dim evenly"
+func.func @expand_shape(%m: memref<?xf32>) -> memref<?x5xf32> {
+  %0 = memref.expand_shape %m [[0, 1]] : memref<?xf32> into memref<?x5xf32>
+  return %0 : memref<?x5xf32>
+}

utils/bazel/llvm-project-overlay/mlir/BUILD.bazel

 td_library(
     name = "ParallelCombiningOpInterfaceTdFiles",
     srcs = ["include/mlir/Interfaces/ParallelCombiningOpInterface.td"],
     includes = ["include"],
     deps = [":OpBaseTdFiles"],
 )
 
 td_library(
+    name = "RuntimeVerifiableOpInterfaceTdFiles",
+    srcs = ["include/mlir/Interfaces/RuntimeVerifiableOpInterface.td"],
+    includes = ["include"],
+    deps = [":OpBaseTdFiles"],
+)
+
+td_library(
     name = "SideEffectInterfacesTdFiles",
     srcs = [
         "include/mlir/Interfaces/SideEffectInterfaceBase.td",
         "include/mlir/Interfaces/SideEffectInterfaces.td",
     ],
     includes = ["include"],
     deps = [":OpBaseTdFiles"],
 )
cc_library(
     deps = [
         ":IR",
         ":ParallelCombiningOpInterfaceIncGen",
         "//llvm:Support",
     ],
 )
 
 cc_library(
+    name = "RuntimeVerifiableOpInterface",
+    srcs = ["lib/Interfaces/RuntimeVerifiableOpInterface.cpp"],
+    hdrs = ["include/mlir/Interfaces/RuntimeVerifiableOpInterface.h"],
+    includes = ["include"],
+    deps = [
+        ":IR",
+        ":RuntimeVerifiableOpInterfaceIncGen",
+        "//llvm:Support",
+    ],
+)
+
+cc_library(
     name = "VectorInterfaces",
     srcs = ["lib/Interfaces/VectorInterfaces.cpp"],
     hdrs = ["include/mlir/Interfaces/VectorInterfaces.h"],
     includes = ["include"],
     deps = [
         ":IR",
         ":VectorInterfacesIncGen",
     ],
tbl_outs = [
         ),
     ],
     tblgen = ":mlir-tblgen",
     td_file = "include/mlir/Interfaces/ParallelCombiningOpInterface.td",
     deps = [":ParallelCombiningOpInterfaceTdFiles"],
 )
 
 gentbl_cc_library(
+    name = "RuntimeVerifiableOpInterfaceIncGen",
+    strip_include_prefix = "include",
+    tbl_outs = [
+        (
+            ["-gen-op-interface-decls"],
+            "include/mlir/Interfaces/RuntimeVerifiableOpInterface.h.inc",
+        ),
+        (
+            ["-gen-op-interface-defs"],
+            "include/mlir/Interfaces/RuntimeVerifiableOpInterface.cpp.inc",
+        ),
+    ],
+    tblgen = ":mlir-tblgen",
+    td_file = "include/mlir/Interfaces/RuntimeVerifiableOpInterface.td",
+    deps = [":RuntimeVerifiableOpInterfaceTdFiles"],
+)
+
+gentbl_cc_library(
     name = "VectorInterfacesIncGen",
     strip_include_prefix = "include",
     tbl_outs = [
         (
             ["-gen-op-interface-decls"],
             "include/mlir/Interfaces/VectorInterfaces.h.inc",
         ),
         (
cc_library(
     includes = ["include"],
     deps = [
         ":Analysis",
         ":ControlFlowInterfaces",
         ":IR",
         ":LoopLikeInterface",
         ":Pass",
         ":Rewrite",
+        ":RuntimeVerifiableOpInterface",
         ":SideEffectInterfaces",
         ":Support",
         ":TransformUtils",
         ":TransformsPassIncGen",
         "//llvm:Support",
     ],
 )
 
cc_library(
     hdrs = glob(["include/mlir/Dialect/MemRef/Transforms/*.h"]),
     includes = ["include"],
     deps = [
         ":AffineDialect",
         ":AffineUtils",
         ":ArithDialect",
         ":ArithTransforms",
         ":ArithUtils",
+        ":ControlFlowDialect",
         ":DialectUtils",
         ":FuncDialect",
         ":IR",
         ":InferTypeOpInterface",
         ":LoopLikeInterface",
         ":MemRefDialect",
         ":MemRefPassIncGen",
         ":Pass",
+        ":RuntimeVerifiableOpInterface",
         ":TensorDialect",
         ":Transforms",
         ":VectorDialect",
         "//llvm:Support",
     ],
 )
 
 td_library(