[mlir] Add tests for op availability

[antiagainst]

Summary

This checks ops declaring version requirements
properly implements various interfaces, with
proper composition of version requirements
coming from multiple parts of the op, including
the op itself and enum attributes.

Depends On D107847

[rriddle]

mlir/include/mlir/IR/OpBase.td

2345

This looks like a bug fix. Is there a reason this is a separate commit? as opposed to rolling this into the parent(given that it is still under review/hasn't landed)? or would it be possible to move this part to before the parent(i.e. before moving things out of SPIRV), and move the tests into the parent?

[antiagainst]

Address comments

[antiagainst]

mlir/include/mlir/IR/OpBase.td

2345

SG. I've moved the bug fix to https://reviews.llvm.org/D108312. I can also merge this into its parent but I was worried that it will create a gigantic patch which will make it harder to review. But if you think that's fine, I can merge all patches together since https://reviews.llvm.org/D107846.

[antiagainst]

Merged into D107846

mlir/include/mlir/IR/OpBase.td

class Availability {
   // The availability requirement carried by a concrete instance.
   string instance = ?;
 }
 
 class MinVersionBase<string name, I32EnumAttr scheme, I32EnumAttrCase min>
     : Availability {
   let interfaceName = name;
 
-  let queryFnRetType = scheme.returnType;
+  let queryFnRetType = "llvm::Optional<" # scheme.returnType # ">";
   let queryFnName = "getMinVersion";
 
-  let mergeAction = "$overall = static_cast<" # scheme.returnType # ">("
-                      "std::max($overall, $instance))";
-  let initializer = "static_cast<" # scheme.returnType # ">(uint32_t(0))";
+  let mergeAction = "{ "
+    "if ($overall.hasValue()) { "
+      "$overall = static_cast<" # scheme.returnType # ">("
+                  "std::max(*$overall, $instance)); "
+    "} else { $overall = $instance; }}";
+  let initializer = "::llvm::None";
   let instanceType = scheme.cppNamespace # "::" # scheme.className;
 
   let instance = scheme.cppNamespace # "::" # scheme.className # "::" #
                  min.symbol;
 }
 
 class MaxVersionBase<string name, I32EnumAttr scheme, I32EnumAttrCase max>
     : Availability {
   let interfaceName = name;
 
-  let queryFnRetType = scheme.returnType;
+  let queryFnRetType = "llvm::Optional<" # scheme.returnType # ">";
   let queryFnName = "getMaxVersion";
 
-  let mergeAction = "$overall = static_cast<" # scheme.returnType # ">("
-                      "std::min($overall, $instance))";
-  let initializer = "static_cast<" # scheme.returnType # ">(~uint32_t(0))";
+  let mergeAction = "{ "
+    "if ($overall.hasValue()) { "
+      "$overall = static_cast<" # scheme.returnType # ">("
+                  "std::min(*$overall, $instance)); "
+    "} else { $overall = $instance; }}";
+  let initializer = "::llvm::None";
   let instanceType = scheme.cppNamespace # "::" # scheme.className;
 
   let instance = scheme.cppNamespace # "::" # scheme.className # "::" #
                  max.symbol;
 }
 
 //===----------------------------------------------------------------------===//
 // Common value constraints

mlir/lib/Dialect/SPIRV/Transforms/SPIRVConversion.cpp

 
 SPIRVConversionTarget::SPIRVConversionTarget(spirv::TargetEnvAttr targetAttr)
     : ConversionTarget(*targetAttr.getContext()), targetEnv(targetAttr) {}
 
 bool SPIRVConversionTarget::isLegalOp(Operation *op) {
   // Make sure this op is available at the given version. Ops not implementing
   // QueryMinVersionInterface/QueryMaxVersionInterface are available to all
   // SPIR-V versions.
-  if (auto minVersion = dyn_cast<spirv::QueryMinVersionInterface>(op))
-    if (minVersion.getMinVersion() > this->targetEnv.getVersion()) {
+  if (auto minVersionIfx = dyn_cast<spirv::QueryMinVersionInterface>(op)) {
+    Optional<spirv::Version> minVersion = minVersionIfx.getMinVersion();
+    if (minVersion && *minVersion > this->targetEnv.getVersion()) {
       LLVM_DEBUG(llvm::dbgs()
                  << op->getName() << " illegal: requiring min version "
-                 << spirv::stringifyVersion(minVersion.getMinVersion())
-                 << "\n");
+                 << spirv::stringifyVersion(*minVersion) << "\n");
       return false;
     }
-  if (auto maxVersion = dyn_cast<spirv::QueryMaxVersionInterface>(op))
-    if (maxVersion.getMaxVersion() < this->targetEnv.getVersion()) {
+  }
+  if (auto maxVersionIfx = dyn_cast<spirv::QueryMaxVersionInterface>(op)) {
+    Optional<spirv::Version> maxVersion = maxVersionIfx.getMaxVersion();
+    if (maxVersion && *maxVersion < this->targetEnv.getVersion()) {
       LLVM_DEBUG(llvm::dbgs()
                  << op->getName() << " illegal: requiring max version "
-                 << spirv::stringifyVersion(maxVersion.getMaxVersion())
-                 << "\n");
+                 << spirv::stringifyVersion(*maxVersion) << "\n");
       return false;
     }
+  }
 
   // Make sure this op's required extensions are allowed to use. Ops not
   // implementing QueryExtensionInterface do not require extensions to be
   // available.
   if (auto extensions = dyn_cast<spirv::QueryExtensionInterface>(op))
     if (failed(checkExtensionRequirements(op->getName(), this->targetEnv,
                                           extensions.getExtensions())))
       return false;

mlir/lib/Dialect/SPIRV/Transforms/UpdateVCEPass.cpp

void UpdateVCEPass::runOnOperation() {
   spirv::Version deducedVersion = spirv::Version::V_1_0;
   SetVector<spirv::Extension> deducedExtensions;
   SetVector<spirv::Capability> deducedCapabilities;
 
   // Walk each SPIR-V op to deduce the minimal version/extension/capability
   // requirements.
   WalkResult walkResult = module.walk([&](Operation *op) -> WalkResult {
     // Op min version requirements
-    if (auto minVersion = dyn_cast<spirv::QueryMinVersionInterface>(op)) {
-      deducedVersion = std::max(deducedVersion, minVersion.getMinVersion());
+    if (auto minVersionIfx = dyn_cast<spirv::QueryMinVersionInterface>(op)) {
+      Optional<spirv::Version> minVersion = minVersionIfx.getMinVersion();
+      if (minVersion) {
+        deducedVersion = std::max(deducedVersion, *minVersion);
         if (deducedVersion > allowedVersion) {
-        return op->emitError("'") << op->getName() << "' requires min version "
-                                  << spirv::stringifyVersion(deducedVersion)
-                                  << " but target environment allows up to "
-                                  << spirv::stringifyVersion(allowedVersion);
+          return op->emitError("'")
+                 << op->getName() << "' requires min version "
         }
       }
+    }
 
     // Op extension requirements
     if (auto extensions = dyn_cast<spirv::QueryExtensionInterface>(op))
       if (failed(checkAndUpdateExtensionRequirements(
               op, targetEnv, extensions.getExtensions(), deducedExtensions)))
         return WalkResult::interrupt();
 
     // Op capability requirements

mlir/test/IR/op-availability.mlir

+// RUN: mlir-opt -mlir-disable-threading -test-op-availability %s | FileCheck %s
+
+// CHECK-LABEL: availability in @min_version
+func @min_version() {
+  // CHECK: test.min_version_op min version: v1.1
+  // CHECK: test.min_version_op has no max version requirements
+  "test.min_version_op"() : () -> ()
+  return
+}
+
+// CHECK-LABEL: availability in @max_version
+func @max_version() {
+  // CHECK: test.max_version_op has no min version requirements
+  // CHECK: test.max_version_op max version: v1.2
+  "test.max_version_op"() : () -> ()
+  return
+}
+
+// CHECK-LABEL: availability in @min_max_version
+func @min_max_version() {
+  // CHECK: test.min_max_version_op min version: v1.0
+  // CHECK: test.min_max_version_op max version: v1.3
+  "test.min_max_version_op"() : () -> ()
+  return
+}
+
+// Enum case A (0): no version requirements
+// Enum case B (1): <= v1.2
+// Enum case C (2): >= v1.1
+
+// CHECK-LABEL: availability in @one_versioned_attr_op
+func @one_versioned_attr_op() {
+  // CHECK: test.one_versioned_attr_op min version: None
+  // CHECK: test.one_versioned_attr_op max version: None
+  "test.one_versioned_attr_op"() {attr = 0: i32} : () -> ()
+
+  // CHECK: test.one_versioned_attr_op min version: None
+  // CHECK: test.one_versioned_attr_op max version: v1.2
+  "test.one_versioned_attr_op"() {attr = 1: i32} : () -> ()
+
+  // CHECK: test.one_versioned_attr_op min version: v1.1
+  // CHECK: test.one_versioned_attr_op max version: None
+  "test.one_versioned_attr_op"() {attr = 2: i32} : () -> ()
+  return
+}
+
+// CHECK-LABEL: availability in @two_versioned_attr_op
+func @two_versioned_attr_op() {
+  // CHECK: test.two_versioned_attr_op min version: None
+  // CHECK: test.two_versioned_attr_op max version: v1.2
+  "test.two_versioned_attr_op"() {attr1 = 0: i32, attr2 = 1: i32} : () -> ()
+
+  // CHECK: test.two_versioned_attr_op min version: v1.1
+  // CHECK: test.two_versioned_attr_op max version: None
+  "test.two_versioned_attr_op"() {attr1 = 0: i32, attr2 = 2: i32} : () -> ()
+
+  // CHECK: test.two_versioned_attr_op min version: v1.1
+  // CHECK: test.two_versioned_attr_op max version: v1.2
+  "test.two_versioned_attr_op"() {attr1 = 1: i32, attr2 = 2: i32} : () -> ()
+  return
+}
+
+
+// CHECK-LABEL: availability in @mix_versioned_attr_op
+func @mix_versioned_attr_op() {
+  // CHECK: test.mix_versioned_attr_op min version: v1.0
+  // CHECK: test.mix_versioned_attr_op max version: v1.2
+  "test.mix_versioned_attr_op"() {attr1 = 0: i32, attr2 = 1: i32} : () -> ()
+
+  // CHECK: test.mix_versioned_attr_op min version: v1.1
+  // CHECK: test.mix_versioned_attr_op max version: v1.3
+  "test.mix_versioned_attr_op"() {attr1 = 0: i32, attr2 = 2: i32} : () -> ()
+
+  // CHECK: test.mix_versioned_attr_op min version: v1.1
+  // CHECK: test.mix_versioned_attr_op max version: v1.2
+  "test.mix_versioned_attr_op"() {attr1 = 1: i32, attr2 = 2: i32} : () -> ()
+  return
+}

mlir/test/lib/Dialect/SPIRV/TestAvailability.cpp

void PrintOpAvailability::runOnFunction() {
 
   f->walk([&](Operation *op) {
     if (op->getDialect() != spvDialect)
       return WalkResult::advance();
 
     auto opName = op->getName();
     auto &os = llvm::outs();
 
-    if (auto minVersion = dyn_cast<spirv::QueryMinVersionInterface>(op))
-      os << opName << " min version: "
-         << spirv::stringifyVersion(minVersion.getMinVersion()) << "\n";
-
-    if (auto maxVersion = dyn_cast<spirv::QueryMaxVersionInterface>(op))
-      os << opName << " max version: "
-         << spirv::stringifyVersion(maxVersion.getMaxVersion()) << "\n";
+    if (auto minVersionIfx = dyn_cast<spirv::QueryMinVersionInterface>(op)) {
+      Optional<spirv::Version> minVersion = minVersionIfx.getMinVersion();
+      os << opName << " min version: ";
+      if (minVersion)
+        os << spirv::stringifyVersion(*minVersion) << "\n";
+      else
+        os << "None\n";
+    }
+
+    if (auto maxVersionIfx = dyn_cast<spirv::QueryMaxVersionInterface>(op)) {
+      Optional<spirv::Version> maxVersion = maxVersionIfx.getMaxVersion();
+      os << opName << " max version: ";
+      if (maxVersion)
+        os << spirv::stringifyVersion(*maxVersion) << "\n";
+      else
+        os << "None\n";
+    }
 
     if (auto extension = dyn_cast<spirv::QueryExtensionInterface>(op)) {
       os << opName << " extensions: [";
       for (const auto &exts : extension.getExtensions()) {
         os << " [";
         llvm::interleaveComma(exts, os, [&](spirv::Extension ext) {
           os << spirv::stringifyExtension(ext);
         });
f->walk([&](Operation *op) {
     }
     os.flush();
 
     return WalkResult::advance();
   });
 }
 
 namespace mlir {
-void registerPrintOpAvailabilityPass() {
+void registerPrintSpirvAvailabilityPass() {
   PassRegistration<PrintOpAvailability>();
 }
 } // namespace mlir
 
 //===----------------------------------------------------------------------===//
 // Converting target environment pass
 //===----------------------------------------------------------------------===//
 

mlir/test/lib/Dialect/Test/CMakeLists.txt

 mlir_tablegen(TestOps.cpp.inc -gen-op-defs)
 mlir_tablegen(TestOpsDialect.h.inc -gen-dialect-decls -dialect=test)
 mlir_tablegen(TestOpsDialect.cpp.inc -gen-dialect-defs -dialect=test)
 mlir_tablegen(TestOpEnums.h.inc -gen-enum-decls)
 mlir_tablegen(TestOpEnums.cpp.inc -gen-enum-defs)
 mlir_tablegen(TestOpStructs.h.inc -gen-struct-attr-decls)
 mlir_tablegen(TestOpStructs.cpp.inc -gen-struct-attr-defs)
 mlir_tablegen(TestPatterns.inc -gen-rewriters)
+mlir_tablegen(TestOpAvailability.h.inc -gen-avail-interface-decls)
+mlir_tablegen(TestOpAvailability.cpp.inc -gen-avail-interface-defs)
+mlir_tablegen(TestEnumAvailability.h.inc -gen-enum-avail-decls)
+mlir_tablegen(TestEnumAvailability.cpp.inc -gen-enum-avail-defs)
 add_public_tablegen_target(MLIRTestOpsIncGen)
 
 # Exclude tests from libMLIR.so
 add_mlir_library(MLIRTestDialect
   TestAttributes.cpp
   TestDialect.cpp
   TestInterfaces.cpp
+  TestOpAvailability.cpp
   TestPatterns.cpp
   TestTraits.cpp
   TestTypes.cpp
 
   EXCLUDE_FROM_LIBMLIR
 
   DEPENDS
   MLIRTestAttrDefIncGen

mlir/test/lib/Dialect/Test/TestDialect.h

 class RewritePatternSet;
 } // namespace mlir
 
 #include "TestOpEnums.h.inc"
 #include "TestOpInterfaces.h.inc"
 #include "TestOpStructs.h.inc"
 #include "TestOpsDialect.h.inc"
 
+// This needs to be included after TestOpEnums.h.inc due to symbol dependency.
+#include "TestEnumAvailability.h.inc"
+
+namespace mlir {
+namespace test {
+#include "TestOpAvailability.h.inc"
+} // namespace test
+} // namespace mlir
+
 #define GET_OP_CLASSES
 #include "TestOps.h.inc"
 
 namespace mlir {
 namespace test {
 void registerTestDialect(DialectRegistry &registry);
 void populateTestReductionPatterns(RewritePatternSet &patterns);
 } // namespace test
 } // namespace mlir
 
 #endif // MLIR_TESTDIALECT_H

mlir/test/lib/Dialect/Test/TestOpAvailability.cpp

+//===- TestOpAvailability.cpp - Pass to test op availability --------------===//
+//
+// 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 "TestDialect.h"
+#include "mlir/Pass/Pass.h"
+#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
+
+using namespace mlir;
+
+#include "TestEnumAvailability.cpp.inc"
+
+namespace mlir {
+namespace test {
+#include "TestOpAvailability.cpp.inc"
+} // namespace test
+} // namespace mlir
+
+//===----------------------------------------------------------------------===//
+// Printing op availability pass
+//===----------------------------------------------------------------------===//
+
+namespace {
+/// A pass for testing SPIR-V op availability.
+struct PrintOpAvailability
+    : public PassWrapper<PrintOpAvailability, FunctionPass> {
+  StringRef getArgument() const final { return "test-op-availability"; }
+  StringRef getDescription() const final { return "Test op availability"; }
+
+  void runOnFunction() override;
+};
+} // end anonymous namespace
+
+void PrintOpAvailability::runOnFunction() {
+  auto f = getFunction();
+  llvm::outs() << "availability in @" << f.getName() << "\n";
+
+  Dialect *spvDialect = getContext().getLoadedDialect("test");
+
+  f->walk([&](Operation *op) {
+    if (op->getDialect() != spvDialect)
+      return WalkResult::advance();
+
+    auto opName = op->getName();
+    auto &os = llvm::outs();
+
+    // Check that we can access TestQueryMinVersionInterface.
+    if (auto minVersionIfx = dyn_cast<test::TestQueryMinVersionInterface>(op)) {
+      auto minVersion = minVersionIfx.getMinVersion();
+      os << opName << " min version: ";
+      if (minVersion.hasValue())
+        os << stringifyVersion(minVersion.getValue()) << "\n";
+      else
+        os << "None\n";
+    } else {
+      os << opName << " has no min version requirements\n";
+    }
+
+    // Check that we can access TestQueryMaxVersionInterface.
+    if (auto maxVersionIfx = dyn_cast<test::TestQueryMaxVersionInterface>(op)) {
+      auto maxVersion = maxVersionIfx.getMaxVersion();
+      os << opName << " max version: ";
+      if (maxVersion.hasValue())
+        os << stringifyVersion(maxVersion.getValue()) << "\n";
+      else
+        os << "None\n";
+    } else {
+      os << opName << " has no max version requirements\n";
+    }
+
+    os.flush();
+
+    return WalkResult::advance();
+  });
+}
+
+namespace mlir {
+void registerPrintOpAvailabilityPass() {
+  PassRegistration<PrintOpAvailability>();
+}
+} // namespace mlir

mlir/test/lib/Dialect/Test/TestOps.td

 }
 
 def OpCrashShort : TEST_Op<"op_crash_short"> {
   let results = (outs I32);
 }
 
 def : Pat<(OpCrashLong $_, $_, $_), (OpCrashShort)>;
 
+//===----------------------------------------------------------------------===//
+// Test Op Availability
+//===----------------------------------------------------------------------===//
+
+def Test_V_1_0 : I32EnumAttrCase<"V_1_0", 0, "v1.0">;
+def Test_V_1_1 : I32EnumAttrCase<"V_1_1", 1, "v1.1">;
+def Test_V_1_2 : I32EnumAttrCase<"V_1_2", 2, "v1.2">;
+def Test_V_1_3 : I32EnumAttrCase<"V_1_3", 3, "v1.3">;
+
+def Test_VersionAttr : I32EnumAttr<"Version", "valid version numbers", [
+    Test_V_1_0, Test_V_1_1, Test_V_1_2, Test_V_1_3]>;
+
+class Test_MinVersion<I32EnumAttrCase min> : MinVersionBase<
+    "TestQueryMinVersionInterface", Test_VersionAttr, min> {
+  let interfaceDescription = [{
+    Querying interface for minimal required version.
+  }];
+  let interfaceNamespace = "::mlir::test";
+}
+
+class Test_MaxVersion<I32EnumAttrCase max> : MaxVersionBase<
+    "TestQueryMaxVersionInterface", Test_VersionAttr, max> {
+  let interfaceDescription = [{
+    Querying interface for maximal supported version.
+  }];
+  let interfaceNamespace = "::mlir::test";
+}
+
+// Test op with only min version availability.
+def MinVersionOp : TEST_Op<"min_version_op"> {
+  let arguments = (ins);
+  let results = (outs);
+
+  let availability = [Test_MinVersion<Test_V_1_1>];
+}
+
+// Test op with only max version availability.
+def MaxVersionOp : TEST_Op<"max_version_op"> {
+  let arguments = (ins);
+  let results = (outs);
+
+  let availability = [Test_MaxVersion<Test_V_1_2>];
+}
+
+// Test op with both min and max version availability.
+def MinMaxVersionOp : TEST_Op<"min_max_version_op"> {
+  let arguments = (ins);
+  let results = (outs);
+
+  let availability = [
+    Test_MinVersion<Test_V_1_0>,
+    Test_MaxVersion<Test_V_1_3>
+  ];
+}
+
+def VersionedEnumCaseA : I32EnumAttrCase<"A", 0> {
+  // No version requirements.
+}
+def VersionedEnumCaseB : I32EnumAttrCase<"B", 1> {
+  // Removed since v1.3.
+  let availability = [Test_MaxVersion<Test_V_1_2>];
+}
+def VersionedEnumCaseC : I32EnumAttrCase<"C", 2> {
+  // Added since v1.1.
+  let availability = [Test_MinVersion<Test_V_1_1>];
+}
+
+def VersionedEnumAttr : I32EnumAttr<"VersionedEnum", "valid enum cases", [
+  VersionedEnumCaseA, VersionedEnumCaseB, VersionedEnumCaseC]> {
+  let cppNamespace = "::mlir::test";
+}
+
+// Test op having one versioned enum attribute.
+def OneVersionedAttrOp : TEST_Op<"one_versioned_attr_op"> {
+  let arguments = (ins VersionedEnumAttr:$attr);
+  let results = (outs);
+}
+
+// Test op having two versioned enum attribute--the final version requirements
+// need to consider both.
+def TwoVersionedAttrOp : TEST_Op<"two_versioned_attr_op"> {
+  let arguments = (ins VersionedEnumAttr:$attr1, VersionedEnumAttr:$attr2);
+  let results = (outs);
+}
+
+// Test op having availability on itself and two versioned enum attribute--
+// the final version requirements need to consider everything.
+def MixVersionedAttrOp : TEST_Op<"mix_versioned_attr_op"> {
+  let arguments = (ins VersionedEnumAttr:$attr1, VersionedEnumAttr:$attr2);
+  let results = (outs);
+
+  let availability = [
+    Test_MinVersion<Test_V_1_0>,
+    Test_MaxVersion<Test_V_1_3>
+  ];
+}
+
 #endif // TEST_OPS

mlir/tools/mlir-opt/mlir-opt.cpp

 using namespace llvm;
 using namespace mlir;
 
 // Defined in the test directory, no public header.
 namespace mlir {
 void registerConvertToTargetEnvPass();
 void registerPassManagerTestPass();
 void registerPrintOpAvailabilityPass();
+void registerPrintSpirvAvailabilityPass();
 void registerShapeFunctionTestPasses();
 void registerSideEffectTestPasses();
 void registerSliceAnalysisTestPass();
 void registerSymbolTestPasses();
 void registerTestAffineDataCopyPass();
 void registerTestAffineLoopUnswitchingPass();
 void registerTestAllReduceLoweringPass();
 void registerTestFunc();

 } // namespace test
 } // namespace mlir
 
 #ifdef MLIR_INCLUDE_TESTS
 void registerTestPasses() {
   registerConvertToTargetEnvPass();
   registerPassManagerTestPass();
   registerPrintOpAvailabilityPass();
+  registerPrintSpirvAvailabilityPass();
   registerShapeFunctionTestPasses();
   registerSideEffectTestPasses();
   registerSliceAnalysisTestPass();
   registerSymbolTestPasses();
   registerTestAffineDataCopyPass();
   registerTestAffineLoopUnswitchingPass();
   registerTestAllReduceLoweringPass();
   registerTestFunc();

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

tbl_outs = [
         (
             ["-gen-struct-attr-defs"],
             "lib/Dialect/Test/TestOpStructs.cpp.inc",
         ),
         (
             ["-gen-rewriters"],
             "lib/Dialect/Test/TestPatterns.inc",
         ),
+        (
+            ["-gen-avail-interface-decls"],
+            "lib/Dialect/Test/TestOpAvailability.h.inc",
+        ),
+        (
+            ["-gen-avail-interface-defs"],
+            "lib/Dialect/Test/TestOpAvailability.cpp.inc",
+        ),
+        (
+            ["-gen-enum-avail-decls"],
+            "lib/Dialect/Test/TestEnumAvailability.h.inc",
+        ),
+        (
+            ["-gen-enum-avail-defs"],
+            "lib/Dialect/Test/TestEnumAvailability.cpp.inc",
+        ),
     ],
     tblgen = "//mlir:mlir-tblgen",
     td_file = "lib/Dialect/Test/TestOps.td",
     test = True,
     deps = [
         ":TestOpTdFiles",
     ],
 )

 )
 
 cc_library(
     name = "TestDialect",
     srcs = [
         "lib/Dialect/Test/TestAttributes.cpp",
         "lib/Dialect/Test/TestDialect.cpp",
         "lib/Dialect/Test/TestInterfaces.cpp",
+        "lib/Dialect/Test/TestOpAvailability.cpp",
         "lib/Dialect/Test/TestPatterns.cpp",
         "lib/Dialect/Test/TestTraits.cpp",
         "lib/Dialect/Test/TestTypes.cpp",
     ],
     hdrs = [
         "lib/Dialect/Test/TestAttributes.h",
         "lib/Dialect/Test/TestDialect.h",
         "lib/Dialect/Test/TestInterfaces.h",