[mlir] Graduate op availability to OpBase.td

[antiagainst]

Summary

This commit starts graduating op availability mechanisms
from the SPIR-V dialect into the core.

Op availability was designed in the beginning to be
flexible and extensible, so to support dialects with
versioning/availability requirements. It was prototyped
in the SPIR-V dialect and has been proven to work well
thus far. The prototype was written to be as detached
from SPIR-V as possible, in order to make graduation
easy.

See the RFCs for op availability:
https://groups.google.com/a/tensorflow.org/g/mlir/c/UinSwMkz5Fg/m/n6eNM0NiAwAJ
https://llvm.discourse.group/t/graduate-op-versioning-mechanism-to-opbase-td/3507

Depends on D108312

[jpienaar]

This seems like it is missing directed tests and documentation.

[antiagainst]

In D107846#2937526, @jpienaar wrote:

This seems like it is missing directed tests and documentation.

Yup. I added tests in a following up patch (https://reviews.llvm.org/D107851). Trying to make this patch mostly just shuffling code around so easier to review. I'll have another patch for the documentation. :)

[jpienaar]

mlir/include/mlir/IR/OpBase.td

2293

When would we have multiple? This seems like Availability is an interface and so could have been defined in interfaces instead of OpBase. Why isn't it?

Esp if you allow specifying an interfaceName that implies to me there isn't just one and it should probably not be in OpBase.

[rriddle]

Can you move the docs into this revision? It is a little hard to understand how these components are supposed to connect together which is making some parts a little more difficult to review.

mlir/include/mlir/IR/OpBase.td

2293

Yeah, do we actually need to move any of this into OpBase? This would be a good time to start decentralizing this file.

As to Jacques point, why couldn't this be defined like a normal interface?

[antiagainst]

Address comments

[antiagainst]

In D107846#2949908, @rriddle wrote:

Can you move the docs into this revision? It is a little hard to understand how these components are supposed to connect together which is making some parts a little more difficult to review.

I've added the doc in https://reviews.llvm.org/D108313. I can merge from this one up to D108313 if that's prefered. Let me know. :)

mlir/include/mlir/IR/OpBase.td

2293

Availability is a layer on top of op interface; it generates more stuff than just the op interface. The concrete implementation of those interface methods are automatically synthesized; if availability is attached to enum attributes, helper functions for querying them can also be generated. I've added the doc in https://reviews.llvm.org/D108313 so hopefully that will make things clearer.

When would we have multiple?

Actually MinVersionBase and MaxVersionBase are already two different interfaces. (We need to further customize them with a dialect-specific versioning scheme though given each dialect can have different versioning schemes.) In SPIR-V, I additionally have Extension and Capability. These are four different interfaces, each with its own way.

[rriddle]

In D107846#2952908, @antiagainst wrote:

In D107846#2949908, @rriddle wrote:

Can you move the docs into this revision? It is a little hard to understand how these components are supposed to connect together which is making some parts a little more difficult to review.

I've added the doc in https://reviews.llvm.org/D108313. I can merge from this one up to D108313 if that's prefered. Let me know. :)

Thanks! Can you roll that into this commit? I find the code easier for me to review alongside the docs.

[antiagainst]

Merge everything into one patch

[antiagainst]

Thanks! Can you roll that into this commit? I find the code easier for me to review alongside the docs.

Sure thing. Done now.

[antiagainst]

Add more docs

[mehdi_amini]

What would this look like without being a first class ODS concept?
I mean: this seems like just some sugar on top of interfaces, but how much sugar is there? Could this be less intrusive in ODS itself by exposing C++ helpers and reusing existing ODS concepts?

mlir/docs/OpDefinitions.md

950 ↗

(On Diff #367488)

so must does not seem grammatically correct to me here, can you reformulate?

956 ↗

(On Diff #367488)

I don't think "the _availability_ of ops" is all there is about: the characteristics of an op can evolve as well. An attribute can be added or removed, or some attributes values that were previously valid becomes invalid and vice versa.

(here despite the italic, I read "availability of ops" as an English sentence and not as the MLIR specific meaning of "availability").

959 ↗

(On Diff #367488)

966 ↗

(On Diff #367488)

1016 ↗

(On Diff #367488)

Can you add extensive comments in the TableGen code here describing what is each things' purpose and effects?
I can follow, but someone less MLIR savvy may be quickly lost.

1143 ↗

(On Diff #367488)

[mehdi_amini]

Also: the doc does not seem complete enough to me right now. It does not seem enough for figuring out how to develop a versioning strategy for a dialect, maybe mostly because other than describing some internals and the interface generated, it does not really tell me what do we do with the generated code then?

[antiagainst]

Address comments

[antiagainst]

What would this look like without being a first class ODS concept?
I mean: this seems like just some sugar on top of interfaces, but how much sugar is there? Could this be less intrusive in ODS itself by exposing C++ helpers and reusing existing ODS concepts?

It actually generates a lot more than just the op interface. There are basically there components generated: 1) C++ op interface, 2) concrete C++ impl methods for all ops for every interface, and 3) utility functions for enum attribute. 2) is the major part: each op can have different versioning/capability/extension requirements so each op will have a different impl of every op interface. Taking SPIR-V as an example, a large portion of ops have requirements wrt MinVersion/MaxVersion/Capability/Extension. That's a lot of code to implement (several thousands LOC). Defining it in ODS allows us to have a single source of truth and avoid all those boilerplate. Updating is also trivial given we can just read in the spec and automatically adjust everything. So no manual work here basically (other than running a shell command). :)

Also: the doc does not seem complete enough to me right now. It does not seem enough for figuring out how to develop a versioning strategy for a dialect, maybe mostly because other than describing some internals and the interface generated, it does not really tell me what do we do with the generated code then?

Good catch! Thanks for pointing it out! I tired to lay out the doc in a progressive way and focus on explaining general concepts and then how to use. The details of generated code actually are explained in the very last, if the reader is interested to define its own availability control. But I guess due to the large amount of details under the hood and some of them are necessary to understand the ideas, it can lose focus. So I refined many aspects and included a summary subsection to recap what's needed for using the versioning mechanism, which is also how one use whatever availability controls. Let me know if this is better. :)

mlir/docs/OpDefinitions.md

956 ↗

(On Diff #367488)

I see your points here. Revised to explain more w.r.t. it.

[antiagainst]

Refine a bit more

[mehdi_amini]

It actually generates a lot more than just the op interface. There are basically there components generated: 1) C++ op interface, 2) concrete C++ impl methods for all ops for every interface, and 3) utility functions for enum attribute. 2) is the major part: each op can have different versioning/capability/extension requirements so each op will have a different impl of every op interface. Taking SPIR-V as an example, a large portion of ops have requirements wrt MinVersion/MaxVersion/Capability/Extension. That's a lot of code to implement (several thousands LOC). Defining it in ODS allows us to have a single source of truth and avoid all those boilerplate.

It still isn't clear to me here: the concrete C++ could be delegated to other mechanism and still be defined in ODS. For example using derived attribute to expose the availability of an operation.
Yes what you're proposing is adding sugar, but I'd like to see the alternative design which would be using as much existing ODS feature as possible before we actually change ODS itself.

[antiagainst]

It still isn't clear to me here: the concrete C++ could be delegated to other mechanism and still be defined in ODS. For example using derived attribute to expose the availability of an operation.
Yes what you're proposing is adding sugar, but I'd like to see the alternative design which would be using as much existing ODS feature as possible before we actually change ODS itself.

Coming back to this. Thanks for the comment, Mehdi! Trying to understand your point and make sure I answer properly. Is the concern about introducing new ODS mechanisms?

My take on whether we should introduce mechanisms is depending on

• how common it is across multiple dialects,
• how much leverage we can have by introducing it.

What version/capability/etc. an op require is not as ubiquitous as op/attribute/etc., but they are common enough (esp. for edge dialects) to have its own modelling and definition. Having that improves consistency across dialects needing it and also brings benefits for better readability/understandability/knowledge transfer/etc.. For the second point, a separate availability concept really drives generating lots of boilerplate C++ code across multiple components (which I explained before), as we can just customize the C++ code generation anchoring on it. Using other mechanisms not designed for this purpose means we need to piggyback/shorehorn in various ways. It's not a clear representation and could be a maintenance burden for other mechanisms too.

Specifically I've checked derived attribute, but I'm not sure that's the suitable mechanism for supporting the availability for the following reasons:

• Derived attribute itself is already one level of interface. Using it for availability will mean we are effectively creating "interfaces" inside interfaces. IMO that's not the proper representation for a common concept like availability.
• Also with this nested level of "interfaces", we are trying to create structures inside the derived attribute itself: all ops will need to have the same exact named attribute and querying will first go through the derived attribute interface symbol DerivedAttributeOpInterface and then a strings like (isDerivedAttribute("min_version")/isDerivedAttribute("max_version")), instead of just one level QueryMinVersionInterface/QueryMaxVersionInterface symbol. I think one of the goals of ODS is to drive C++ code generation to reduce this stringish representations as they are hard to check/validate. So we use ODS to define ops instead of checking their string names in C++. One could argue it's similar here.
• Derived attribute requires having DerivedAttr on the op itself, with some code body embedded. That can introduce a lot of duplication and make it hard for readability. For example, many SPIR-V ops have multiple availability dimensions. It would mean defining multiple extra DerivedAttr on it like

def SPV_SomeOp ... {
  DerivedTypeAttr min_version = DerivedTypeAttr<"::mlir::spirv::Version", "<calling into some separately generated C++ utility function to compute as we cannot inline here given it's too complicated>">,
  DerivedTypeAttr max_version = DerivedTypeAttr<"::mlir::spirv::Version", "...">
  DerivedTypeAttr capabilities = DerivedTypeAttr<"::llvm::SmallVector<::llvm::ArrayRef<::mlir::spirv::Capability>, 1>", "...">
  DerivedTypeAttr extensions = DerivedTypeAttr<"::llvm::SmallVector<::llvm::ArrayRef<::mlir::spirv::Extension>, 1>", "...">
}

I find it hard to compare with the simplicity and conciseness of the following:

let availability = [
  MinVersion<SPV_V_1_3>,
  MaxVersion<SPV_V_1_5>,
  Extension<[]>,
  Capability<[SPV_C_GroupNonUniformBallot]>
];

Note that that above differs at a per-op level, as different ops have different requirements on version/capability/extension/etc.

• Derived attribute interface is for ops and it cannot be used on attributes. In SPIR-V it's fairly common to have enums values requiring different version/capability/etc. Being able to attach that directly on the attribute is better for representation and avoids lots of duplication (in all user ops).

I also checked other existing ODS mechanisms and I don't find other good hosts to handle the problem here. (But I might miss something so recommendations certainly welcome!) The goal is to generate all those boilerplate C++ code so that we have one concise single source of truth in ODS. I think even we can probably piggyback/shorehorn different components on different mechanisms, it looks a disintegrated solution that will cause confusion and maintenance burden: folks will have difficulty to understand how everything fits together and that means harder to debug/improve/etc.

What's introduced in ODS is really quite well isolated. Aside from the main Availability and the MinVersionBase/MaxVersionBase definitions, we just need one additional field on the op and the enum attribute. They defaults to none and it won't affect folks don't care about it at all.

Hopefully this addresses the concerns. Otherwise feel free to let me know where I should explain/improve more. Thanks. :)

[mehdi_amini]

. Is the concern about introducing new ODS mechanisms?

I would say it this way: the concern is about introducing ODS mechanisms instead of building on top of ODS and by composition of existing mechanisms. I believe that this can easily lead to bloating ODS (which is already a complex and not always consistent system), when we'd better modularize and make it possible to build on top of it.

There is also an aspect of maturity: I'm not sure how widespread the concept of "availability" is (you mention edge, we but don't even have a handful of examples right now) and it isn't clear to me that the requirements are clear enough to make it a feature that will work for everyone. It is easy to anchor to one example and provide something that does not generalize to what's needed.

def SPV_SomeOp ... {

DerivedTypeAttr min_version = DerivedTypeAttr<"::mlir::spirv::Version", "<calling into some separately generated C++ utility function to compute as we cannot inline here given it's too complicated>">,
DerivedTypeAttr max_version = DerivedTypeAttr<"::mlir::spirv::Version", "...">
DerivedTypeAttr capabilities = DerivedTypeAttr<"::llvm::SmallVector<::llvm::ArrayRef<::mlir::spirv::Capability>, 1>", "...">
DerivedTypeAttr extensions = DerivedTypeAttr<"::llvm::SmallVector<::llvm::ArrayRef<::mlir::spirv::Extension>, 1>", "...">

}
I find it hard to compare with the simplicity and conciseness of the following:

let availability = [

MinVersion<SPV_V_1_3>,
MaxVersion<SPV_V_1_5>,
Extension<[]>,
Capability<[SPV_C_GroupNonUniformBallot]>

];

Right, that's the kind of examples I'm after. So you showed how to do it inline with DerivedTypeAttr fully specified here. But can this be refactored?
I would expect that (without much change to ODS) we could get to a syntax that would look like:

def SPV_SomeOp : MinVersion<SPV_V_1_3>, MaxVersion<SPV_V_1_4> {
 ...
}

where MinVersion and MaxVersion would be parent classes defining the right derived attribute and hiding the C++ boilerplate.

Similarly for arguments, we have something to annotate them with "decorators" right now, for example the MemRead here:

let arguments = (ins 
    Arg<AnyMemRef, "the reference to load from", [MemRead]>:$base,

I would look into generic extension to such mechanism before adding anything first class for availability.

[chhe]

Any update on this?

mlir/include/mlir/Dialect/SPIRV/IR/CMakeLists.txt

 add_mlir_dialect(SPIRVOps spv)
 add_mlir_doc(SPIRVOps SPIRVOps Dialects/ -gen-op-doc)
 
 set(LLVM_TARGET_DEFINITIONS SPIRVBase.td)
 mlir_tablegen(SPIRVEnums.h.inc -gen-enum-decls)
 mlir_tablegen(SPIRVEnums.cpp.inc -gen-enum-defs)
 add_public_tablegen_target(MLIRSPIRVEnumsIncGen)
 add_dependencies(mlir-headers MLIRSPIRVEnumsIncGen)
 
 set(LLVM_TARGET_DEFINITIONS SPIRVBase.td)
-mlir_tablegen(SPIRVEnumAvailability.h.inc -gen-spirv-enum-avail-decls)
-mlir_tablegen(SPIRVEnumAvailability.cpp.inc -gen-spirv-enum-avail-defs)
+mlir_tablegen(SPIRVEnumAvailability.h.inc -gen-enum-avail-decls)
+mlir_tablegen(SPIRVEnumAvailability.cpp.inc -gen-enum-avail-defs)
 mlir_tablegen(SPIRVCapabilityImplication.inc -gen-spirv-capability-implication)
 add_public_tablegen_target(MLIRSPIRVEnumAvailabilityIncGen)
 add_dependencies(mlir-headers MLIRSPIRVEnumAvailabilityIncGen)
 
 set(LLVM_TARGET_DEFINITIONS SPIRVOps.td)
 mlir_tablegen(SPIRVAvailability.h.inc -gen-avail-interface-decls)
 mlir_tablegen(SPIRVAvailability.cpp.inc -gen-avail-interface-defs)
-mlir_tablegen(SPIRVOpAvailabilityImpl.inc -gen-spirv-avail-impls)
 add_public_tablegen_target(MLIRSPIRVAvailabilityIncGen)
 add_dependencies(mlir-headers MLIRSPIRVAvailabilityIncGen)
 
 set(LLVM_TARGET_DEFINITIONS SPIRVOps.td)
 mlir_tablegen(SPIRVSerialization.inc -gen-spirv-serialization)
 add_public_tablegen_target(MLIRSPIRVSerializationGen)
 add_dependencies(mlir-headers MLIRSPIRVSerializationGen)
 

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVAvailability.td

-//===- SPIRVAvailability.td - Op Availability Base file ----*- 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_DIALECT_SPIRV_IR_AVAILABILITY
-#define MLIR_DIALECT_SPIRV_IR_AVAILABILITY
-
-include "mlir/IR/OpBase.td"
-
-//===----------------------------------------------------------------------===//
-// Op availability definitions
-//===----------------------------------------------------------------------===//
-
-// The base class for defining op availability dimensions.
-class Availability {
-  // The following are fields for controlling the generated C++ OpInterface.
-
-  // The namespace for the generated C++ OpInterface subclass.
-  string interfaceNamespace = ?;
-  // The name for the generated C++ OpInterface subclass.
-  string interfaceName = ?;
-  // The documentation for the generated C++ OpInterface subclass.
-  string interfaceDescription = "";
-
-  // The following are fields for controlling the query function signature.
-
-  // The query function's return type in the generated C++ OpInterface subclass.
-  string queryFnRetType = ?;
-  // The query function's name in the generated C++ OpInterface subclass.
-  string queryFnName = ?;
-
-  // The following are fields for controlling the query function implementation.
-
-  // The logic for merging two availability requirements. This is used to derive
-  // the final availability requirement when, for example, an op has two
-  // operands and these two operands have different availability requirements.
-  //
-  // The code should use `$overall` as the placeholder for the final requirement
-  // and `$instance` for the current availability requirement instance.
-  code mergeAction = ?;
-  // The initializer for the final availability requirement.
-  string initializer = ?;
-  // An availability instance's type.
-  string instanceType = ?;
-
-  // The following are fields for a concrete availability instance.
-
-  // The code for preparing a concrete instance. This should be C++ statements
-  // and will be generated before the `mergeAction` logic.
-  code instancePreparation = "";
-  // The availability requirement carried by a concrete instance.
-  string instance = ?;
-}
-
-class MinVersionBase<string name, I32EnumAttr scheme, I32EnumAttrCase min>
-    : Availability {
-  let interfaceName = name;
-
-  let queryFnRetType = "llvm::Optional<" # scheme.returnType # ">";
-  let queryFnName = "getMinVersion";
-
-  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 = "llvm::Optional<" # scheme.returnType # ">";
-  let queryFnName = "getMaxVersion";
-
-  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;
-}
-
-#endif // MLIR_DIALECT_SPIRV_IR_AVAILABILITY

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVBase.td

 // for facilitating defining SPIR-V ops.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_SPIRV_IR_BASE
 #define MLIR_DIALECT_SPIRV_IR_BASE
 
 include "mlir/IR/OpBase.td"
-include "mlir/Dialect/SPIRV/IR/SPIRVAvailability.td"
 
 //===----------------------------------------------------------------------===//
 // SPIR-V dialect definitions
 //===----------------------------------------------------------------------===//
 
 def SPIRV_Dialect : Dialect {
   let name = "spv";
 

mlir/include/mlir/IR/OpBase.td

 }
 
 // The results of an op.
 class Results<dag rets> {
   dag results = rets;
 }
 
 //===----------------------------------------------------------------------===//
+// Availability definitions
+//===----------------------------------------------------------------------===//
+
+// The base class for defining op availability dimensions.
+class Availability {
+  // The following are fields for controlling the generated C++ OpInterface.
+
+  // The namespace for the generated C++ OpInterface subclass.
+  string interfaceNamespace = ?;
+  // The name for the generated C++ OpInterface subclass.
+  string interfaceName = ?;
+  // The documentation for the generated C++ OpInterface subclass.
+  string interfaceDescription = "";
+
+  // The following are fields for controlling the query function signature.
+
+  // The query function's return type in the generated C++ OpInterface subclass.
+  string queryFnRetType = ?;
+  // The query function's name in the generated C++ OpInterface subclass.
+  string queryFnName = ?;
+
+  // The following are fields for controlling the query function implementation.
+
+  // The logic for merging two availability requirements. This is used to derive
+  // the final availability requirement when, for example, an op has two
+  // operands and these two operands have different availability requirements.
+  //
+  // The code should use `$overall` as the placeholder for the final requirement
+  // and `$instance` for the current availability requirement instance.
+  code mergeAction = ?;
+  // The initializer for the final availability requirement.
+  string initializer = ?;
+  // An availability instance's type.
+  string instanceType = ?;
+
+  // The following are fields for a concrete availability instance.
+
+  // The code for preparing a concrete instance. This should be C++ statements
+  // and will be generated before the `mergeAction` logic.
+  code instancePreparation = "";
+  // The availability requirement carried by a concrete instance.
+  string instance = ?;
+}
+
+class MinVersionBase<string name, I32EnumAttr scheme, I32EnumAttrCase min>
+    : Availability {
+  let interfaceName = name;
+
+  let queryFnRetType = "llvm::Optional<" # scheme.returnType # ">";
+  let queryFnName = "getMinVersion";
+
+  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 = "llvm::Optional<" # scheme.returnType # ">";
+  let queryFnName = "getMaxVersion";
+
+  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
 //===----------------------------------------------------------------------===//
 
 def HasNoUseOf: Constraint<
     CPred<"$_self.use_empty()">, "has no use">;
 
 //===----------------------------------------------------------------------===//
 // Common op type constraints

mlir/include/mlir/TableGen/Availability.h

+//===- Availability.h - Availability wrapper class --------------*- 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Availability wrapper to simplify using TableGen Record defining a MLIR
+// Availability.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_TABLEGEN_AVAILABILITY_H_
+#define MLIR_TABLEGEN_AVAILABILITY_H_
+
+#include "mlir/Support/LLVM.h"
+
+namespace llvm {
+class Record;
+} // end namespace llvm
+
+namespace mlir {
+namespace tblgen {
+
+// Wrapper class with helper methods for accessing availability defined in
+// TableGen.
+class Availability {
+public:
+  explicit Availability(const llvm::Record *def);
+
+  // Returns the name of the direct TableGen class for this availability
+  // instance.
+  StringRef getClass() const;
+
+  // Returns the generated C++ interface's class namespace.
+  StringRef getInterfaceClassNamespace() const;
+
+  // Returns the generated C++ interface's class name.
+  StringRef getInterfaceClassName() const;
+
+  // Returns the generated C++ interface's description.
+  StringRef getInterfaceDescription() const;
+
+  // Returns the name of the query function insided the generated C++ interface.
+  StringRef getQueryFnName() const;
+
+  // Returns the return type of the query function insided the generated C++
+  // interface.
+  StringRef getQueryFnRetType() const;
+
+  // Returns the code for merging availability requirements.
+  StringRef getMergeActionCode() const;
+
+  // Returns the initializer expression for initializing the final availability
+  // requirements.
+  StringRef getMergeInitializer() const;
+
+  // Returns the C++ type for an availability instance.
+  StringRef getMergeInstanceType() const;
+
+  // Returns the C++ statements for preparing availability instance.
+  StringRef getMergeInstancePreparation() const;
+
+  // Returns the concrete availability instance carried in this case.
+  StringRef getMergeInstance() const;
+
+  // Returns the underlying LLVM TableGen Record.
+  const llvm::Record *getDef() const { return def; }
+
+private:
+  // The TableGen definition of this availability.
+  const llvm::Record *def;
+};
+
+} // end namespace tblgen
+} // end namespace mlir
+
+#endif // MLIR_TABLEGEN_AVAILABILITY_H_

mlir/lib/Dialect/SPIRV/IR/SPIRVOps.cpp

 
 // TableGen'erated operation interfaces for querying versions, extensions, and
 // capabilities.
 #include "mlir/Dialect/SPIRV/IR/SPIRVAvailability.cpp.inc"
 
 // TablenGen'erated operation definitions.
 #define GET_OP_CLASSES
 #include "mlir/Dialect/SPIRV/IR/SPIRVOps.cpp.inc"
-
-namespace mlir {
-namespace spirv {
-// TableGen'erated operation availability interface implementations.
-#include "mlir/Dialect/SPIRV/IR/SPIRVOpAvailabilityImpl.inc"
-} // namespace spirv
-} // namespace mlir

mlir/lib/TableGen/Availability.cpp

+//===- Availability.cpp - Availability definitions ------------------------===//
+//
+// 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/TableGen/Availability.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/TableGen/Error.h"
+#include "llvm/TableGen/Record.h"
+
+using namespace mlir;
+using namespace mlir::tblgen;
+
+Availability::Availability(const llvm::Record *def) : def(def) {
+  assert(def->isSubClassOf("Availability") &&
+         "must be subclass of TableGen 'Availability' class");
+}
+
+StringRef Availability::getClass() const {
+  SmallVector<llvm::Record *, 1> parentClass;
+  def->getDirectSuperClasses(parentClass);
+  if (parentClass.size() != 1) {
+    PrintFatalError(def->getLoc(),
+                    "expected to only have one direct superclass");
+  }
+  return parentClass.front()->getName();
+}
+
+StringRef Availability::getInterfaceClassNamespace() const {
+  return def->getValueAsString("interfaceNamespace");
+}
+
+StringRef Availability::getInterfaceClassName() const {
+  return def->getValueAsString("interfaceName");
+}
+
+StringRef Availability::getInterfaceDescription() const {
+  return def->getValueAsString("interfaceDescription");
+}
+
+StringRef Availability::getQueryFnRetType() const {
+  return def->getValueAsString("queryFnRetType");
+}
+
+StringRef Availability::getQueryFnName() const {
+  return def->getValueAsString("queryFnName");
+}
+
+StringRef Availability::getMergeActionCode() const {
+  return def->getValueAsString("mergeAction");
+}
+
+StringRef Availability::getMergeInitializer() const {
+  return def->getValueAsString("initializer");
+}
+
+StringRef Availability::getMergeInstanceType() const {
+  return def->getValueAsString("instanceType");
+}
+
+StringRef Availability::getMergeInstancePreparation() const {
+  return def->getValueAsString("instancePreparation");
+}
+
+StringRef Availability::getMergeInstance() const {
+  return def->getValueAsString("instance");
+}

mlir/lib/TableGen/CMakeLists.txt

 # This library is unusual, since mlir-tblgen depends on it, which is
 # built with DISABLE_LLVM_LINK_LLVM_DYLIB, this must also be built
 # with that option.  Otherwise builds with LLVM_BUILD_LLVM_DYLIB and
 # LLVM_LINK_LLVM_DYLIB fail.  (Note that even if this has no llvm
 # component dependencies, LLVM_LINK_LLVM_DYLIB tends to introduce a
 # dependence on libLLVM.so)  However, it must also be linkable against
 # libMLIR.so in some contexts (see unittests/Tablegen, for instance, which
 # has a dependence on MLIRIR, which must depend on libLLVM.so).  This works
 # in this special case because this library is static.
 
 llvm_add_library(MLIRTableGen STATIC
   Argument.cpp
   Attribute.cpp
   AttrOrTypeDef.cpp
+  Availability.cpp
   Builder.cpp
   Constraint.cpp
   Dialect.cpp
   Format.cpp
   Interfaces.cpp
   Operator.cpp
   OpClass.cpp
   Pass.cpp

mlir/tools/mlir-tblgen/AvailabilityInterfaceGen.cpp

+//===- AvailabilityInterfacesGen.cpp --------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// AvailabilityInterfacesGen generates definitions for availability interfaces.
+//
+//===----------------------------------------------------------------------===//
+
+#include "mlir/Support/LLVM.h"
+#include "mlir/TableGen/Availability.h"
+#include "mlir/TableGen/GenInfo.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/FormatVariadic.h"
+#include "llvm/Support/raw_ostream.h"
+#include "llvm/TableGen/Error.h"
+#include "llvm/TableGen/Record.h"
+#include "llvm/TableGen/TableGenBackend.h"
+
+using namespace mlir;
+using llvm::Record;
+using llvm::RecordKeeper;
+using mlir::tblgen::Availability;
+
+//===----------------------------------------------------------------------===//
+// Availability Interface Declarations AutoGen
+//===----------------------------------------------------------------------===//
+
+static void emitConceptDecl(const Availability &availability, raw_ostream &os) {
+  os << "  class Concept {\n"
+     << "  public:\n"
+     << "    virtual ~Concept() = default;\n"
+     << "    virtual " << availability.getQueryFnRetType() << " "
+     << availability.getQueryFnName()
+     << "(const Concept *impl, Operation *tblgen_opaque_op) const = 0;\n"
+     << "  };\n";
+}
+
+static void emitModelDecl(const Availability &availability, raw_ostream &os) {
+  for (const char *modelClass : {"Model", "FallbackModel"}) {
+    os << "  template<typename ConcreteOp>\n";
+    os << "  class " << modelClass << " : public Concept {\n"
+       << "  public:\n"
+       << "    " << availability.getQueryFnRetType() << " "
+       << availability.getQueryFnName()
+       << "(const Concept *impl, Operation *tblgen_opaque_op) const final {\n"
+       << "      auto op = llvm::cast<ConcreteOp>(tblgen_opaque_op);\n"
+       << "      (void)op;\n"
+       // Forward to the method on the concrete operation type.
+       << "      return op." << availability.getQueryFnName() << "();\n"
+       << "    }\n"
+       << "  };\n";
+  }
+  os << "  template<typename ConcreteModel, typename ConcreteOp>\n";
+  os << "  class ExternalModel : public FallbackModel<ConcreteOp> {};\n";
+}
+
+static void emitInterfaceDecl(const Availability &availability,
+                              raw_ostream &os) {
+  StringRef interfaceName = availability.getInterfaceClassName();
+  std::string interfaceTraitsName =
+      std::string(formatv("{0}Traits", interfaceName));
+
+  StringRef cppNamespace = availability.getInterfaceClassNamespace();
+  cppNamespace.consume_front("::");
+  SmallVector<StringRef> nsSegments;
+  llvm::SplitString(cppNamespace, nsSegments, "::");
+  for (StringRef segment : nsSegments)
+    os << "namespace " << segment << " {\n";
+
+  // Emit the traits struct containing the concept and model declarations.
+  os << "namespace detail {\n"
+     << "struct " << interfaceTraitsName << " {\n";
+  emitConceptDecl(availability, os);
+  os << '\n';
+  emitModelDecl(availability, os);
+  os << "};\n} // namespace detail\n\n";
+
+  // Emit the main interface class declaration.
+  os << "/*\n" << availability.getInterfaceDescription().trim() << "\n*/\n";
+  os << llvm::formatv("class {0} : public OpInterface<{1}, detail::{2}> {\n"
+                      "public:\n"
+                      "  using OpInterface<{1}, detail::{2}>::OpInterface;\n",
+                      interfaceName, interfaceName, interfaceTraitsName);
+
+  // Emit query function declaration.
+  os << "  " << availability.getQueryFnRetType() << " "
+     << availability.getQueryFnName() << "();\n";
+  os << "};\n\n";
+
+  for (StringRef segment : llvm::reverse(nsSegments))
+    os << "} // namespace " << segment << "\n";
+}
+
+static bool emitInterfaceDecls(const RecordKeeper &recordKeeper,
+                               raw_ostream &os) {
+  llvm::emitSourceFileHeader("Availability Interface Declarations", os);
+
+  auto defs = recordKeeper.getAllDerivedDefinitions("Availability");
+  SmallVector<const Record *, 4> handledClasses;
+  for (const Record *def : defs) {
+    SmallVector<Record *, 1> parent;
+    def->getDirectSuperClasses(parent);
+    if (parent.size() != 1) {
+      PrintFatalError(def->getLoc(),
+                      "expected to only have one direct superclass");
+    }
+    if (llvm::is_contained(handledClasses, parent.front()))
+      continue;
+
+    Availability avail(def);
+    emitInterfaceDecl(avail, os);
+    handledClasses.push_back(parent.front());
+  }
+  return false;
+}
+
+//===----------------------------------------------------------------------===//
+// Availability Interface Definitions AutoGen
+//===----------------------------------------------------------------------===//
+
+static void emitInterfaceDef(const Availability &availability,
+                             raw_ostream &os) {
+  os << availability.getQueryFnRetType() << " ";
+
+  StringRef cppNamespace = availability.getInterfaceClassNamespace();
+  cppNamespace.consume_front("::");
+  if (!cppNamespace.empty())
+    os << cppNamespace << "::";
+
+  StringRef methodName = availability.getQueryFnName();
+  os << availability.getInterfaceClassName() << "::" << methodName << "() {\n"
+     << "  return getImpl()->" << methodName << "(getImpl(), getOperation());\n"
+     << "}\n";
+}
+
+static bool emitInterfaceDefs(const RecordKeeper &recordKeeper,
+                              raw_ostream &os) {
+  llvm::emitSourceFileHeader("Availability Interface Definitions", os);
+
+  auto defs = recordKeeper.getAllDerivedDefinitions("Availability");
+  SmallVector<const Record *, 1> handledClasses;
+  for (const Record *def : defs) {
+    SmallVector<Record *, 1> parent;
+    def->getDirectSuperClasses(parent);
+    if (parent.size() != 1) {
+      PrintFatalError(def->getLoc(),
+                      "expected to only have one direct superclass");
+    }
+    if (llvm::is_contained(handledClasses, parent.front()))
+      continue;
+
+    Availability availability(def);
+    emitInterfaceDef(availability, os);
+    handledClasses.push_back(parent.front());
+  }
+  return false;
+}
+
+//===----------------------------------------------------------------------===//
+// Availability Interface Hook Registration
+//===----------------------------------------------------------------------===//
+
+// Registers the operation interface generator to mlir-tblgen.
+static mlir::GenRegistration
+    genInterfaceDecls("gen-avail-interface-decls",
+                      "Generate availability interface declarations",
+                      [](const RecordKeeper &records, raw_ostream &os) {
+                        return emitInterfaceDecls(records, os);
+                      });
+
+// Registers the operation interface generator to mlir-tblgen.
+static mlir::GenRegistration
+    genInterfaceDefs("gen-avail-interface-defs",
+                     "Generate op interface definitions",
+                     [](const RecordKeeper &records, raw_ostream &os) {
+                       return emitInterfaceDefs(records, os);
+                     });

mlir/tools/mlir-tblgen/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Demangle
   Support
   TableGen
 )
 
 add_tablegen(mlir-tblgen MLIR
   AttrOrTypeDefGen.cpp
+  AvailabilityInterfaceGen.cpp
   DialectGen.cpp
   DirectiveCommonGen.cpp
   EnumsGen.cpp
   LLVMIRConversionGen.cpp
   LLVMIRIntrinsicGen.cpp
   mlir-tblgen.cpp
   OpDefinitionsGen.cpp
   OpDocGen.cpp

mlir/tools/mlir-tblgen/EnumsGen.cpp

 //===- EnumsGen.cpp - MLIR enum utility generator -------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // EnumsGen generates common utility functions for enums.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/TableGen/Attribute.h"
+#include "mlir/TableGen/Availability.h"
 #include "mlir/TableGen/Format.h"
 #include "mlir/TableGen/GenInfo.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
+#include "llvm/ADT/StringSet.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Record.h"
 #include "llvm/TableGen/TableGenBackend.h"
 
 using llvm::formatv;
 using llvm::isDigit;
 using llvm::PrintFatalError;
 using llvm::raw_ostream;
 using llvm::Record;
 using llvm::RecordKeeper;
 using llvm::StringRef;
 using mlir::tblgen::Attribute;
+using mlir::tblgen::Availability;
 using mlir::tblgen::EnumAttr;
 using mlir::tblgen::EnumAttrCase;
 using mlir::tblgen::FmtContext;
 using mlir::tblgen::tgfmt;
 
 static std::string makeIdentifier(StringRef str) {
   if (!str.empty() && isDigit(static_cast<unsigned char>(str.front()))) {
     std::string newStr = std::string("_") + str.str();
     return newStr;
   }
   return str.str();
 }
 
+//===----------------------------------------------------------------------===//
+// Enum Utility AutoGen
+//===----------------------------------------------------------------------===//
+
 static void emitEnumClass(const Record &enumDef, StringRef enumName,
                           StringRef underlyingType, StringRef description,
                           const std::vector<EnumAttrCase> &enumerants,
                           raw_ostream &os) {
   os << "// " << description << "\n";
   os << "enum class " << enumName;
 
   if (!underlyingType.empty())
static bool emitEnumDefs(const RecordKeeper &recordKeeper, raw_ostream &os) {
 
   auto defs = recordKeeper.getAllDerivedDefinitions("EnumAttrInfo");
   for (const auto *def : defs)
     emitEnumDef(*def, os);
 
   return false;
 }
 
+//===----------------------------------------------------------------------===//
+// Enum Utility Query Hook Registration
+//===----------------------------------------------------------------------===//
+
 // Registers the enum utility generator to mlir-tblgen.
 static mlir::GenRegistration
     genEnumDecls("gen-enum-decls", "Generate enum utility declarations",
                  [](const RecordKeeper &records, raw_ostream &os) {
                    return emitEnumDecls(records, os);
                  });
 
 // Registers the enum utility generator to mlir-tblgen.
 static mlir::GenRegistration
     genEnumDefs("gen-enum-defs", "Generate enum utility definitions",
                 [](const RecordKeeper &records, raw_ostream &os) {
                   return emitEnumDefs(records, os);
                 });
+
+//===----------------------------------------------------------------------===//
+// Enum Availability Query AutoGen
+//===----------------------------------------------------------------------===//
+
+// Returns the availability spec of the given `def`.
+static std::vector<Availability> getAvailabilities(const llvm::Record &def) {
+  std::vector<Availability> availabilities;
+
+  if (def.getValue("availability")) {
+    std::vector<llvm::Record *> availDefs =
+        def.getValueAsListOfDefs("availability");
+    availabilities.reserve(availDefs.size());
+    for (const llvm::Record *avail : availDefs)
+      availabilities.emplace_back(avail);
+  }
+
+  return availabilities;
+}
+
+static void emitAvailabilityQueryForIntEnum(const Record &enumDef,
+                                            raw_ostream &os) {
+  EnumAttr enumAttr(enumDef);
+  StringRef enumName = enumAttr.getEnumClassName();
+  std::vector<EnumAttrCase> enumerants = enumAttr.getAllCases();
+
+  // Mapping from availability class name to (enumerant, availability
+  // specification) pairs.
+  llvm::StringMap<llvm::SmallVector<std::pair<EnumAttrCase, Availability>, 1>>
+      classCaseMap;
+
+  // Place all availability specifications to their corresponding
+  // availability classes.
+  for (const EnumAttrCase &enumerant : enumerants)
+    for (const Availability &avail : getAvailabilities(enumerant.getDef()))
+      classCaseMap[avail.getClass()].push_back({enumerant, avail});
+
+  for (const auto &classCasePair : classCaseMap) {
+    Availability avail = classCasePair.getValue().front().second;
+
+    os << formatv("llvm::Optional<{0}> {1}({2} value) {{\n",
+                  avail.getMergeInstanceType(), avail.getQueryFnName(),
+                  enumName);
+
+    os << "  switch (value) {\n";
+    for (const auto &caseSpecPair : classCasePair.getValue()) {
+      EnumAttrCase enumerant = caseSpecPair.first;
+      Availability avail = caseSpecPair.second;
+      os << formatv("  case {0}::{1}: { {2} return {3}({4}); }\n", enumName,
+                    enumerant.getSymbol(), avail.getMergeInstancePreparation(),
+                    avail.getMergeInstanceType(), avail.getMergeInstance());
+    }
+    // Only emit default if uncovered cases.
+    if (classCasePair.getValue().size() < enumAttr.getAllCases().size())
+      os << "  default: break;\n";
+    os << "  }\n"
+       << "  return llvm::None;\n"
+       << "}\n";
+  }
+}
+
+static void emitAvailabilityQueryForBitEnum(const Record &enumDef,
+                                            raw_ostream &os) {
+  EnumAttr enumAttr(enumDef);
+  StringRef enumName = enumAttr.getEnumClassName();
+  std::string underlyingType = std::string(enumAttr.getUnderlyingType());
+  std::vector<EnumAttrCase> enumerants = enumAttr.getAllCases();
+
+  // Mapping from availability class name to (enumerant, availability
+  // specification) pairs.
+  llvm::StringMap<llvm::SmallVector<std::pair<EnumAttrCase, Availability>, 1>>
+      classCaseMap;
+
+  // Place all availability specifications to their corresponding
+  // availability classes.
+  for (const EnumAttrCase &enumerant : enumerants)
+    for (const Availability &avail : getAvailabilities(enumerant.getDef()))
+      classCaseMap[avail.getClass()].push_back({enumerant, avail});
+
+  for (const auto &classCasePair : classCaseMap) {
+    Availability avail = classCasePair.getValue().front().second;
+
+    os << formatv("llvm::Optional<{0}> {1}({2} value) {{\n",
+                  avail.getMergeInstanceType(), avail.getQueryFnName(),
+                  enumName);
+
+    os << formatv(
+        "  assert(::llvm::countPopulation(static_cast<{0}>(value)) <= 1"
+        " && \"cannot have more than one bit set\");\n",
+        underlyingType);
+
+    os << "  switch (value) {\n";
+    for (const auto &caseSpecPair : classCasePair.getValue()) {
+      EnumAttrCase enumerant = caseSpecPair.first;
+      Availability avail = caseSpecPair.second;
+      os << formatv("  case {0}::{1}: { {2} return {3}({4}); }\n", enumName,
+                    enumerant.getSymbol(), avail.getMergeInstancePreparation(),
+                    avail.getMergeInstanceType(), avail.getMergeInstance());
+    }
+    os << "  default: break;\n";
+    os << "  }\n"
+       << "  return llvm::None;\n"
+       << "}\n";
+  }
+}
+
+static void emitEnumAvailDecl(const Record &enumDef, raw_ostream &os) {
+  EnumAttr enumAttr(enumDef);
+  StringRef enumName = enumAttr.getEnumClassName();
+  StringRef cppNamespace = enumAttr.getCppNamespace();
+  auto enumerants = enumAttr.getAllCases();
+
+  llvm::SmallVector<StringRef, 2> namespaces;
+  llvm::SplitString(cppNamespace, namespaces, "::");
+
+  for (auto ns : namespaces)
+    os << "namespace " << ns << " {\n";
+
+  llvm::StringSet<> handledClasses;
+
+  // Place all availability specifications to their corresponding
+  // availability classes.
+  for (const EnumAttrCase &enumerant : enumerants)
+    for (const Availability &avail : getAvailabilities(enumerant.getDef())) {
+      StringRef className = avail.getClass();
+      if (handledClasses.count(className))
+        continue;
+      os << formatv("llvm::Optional<{0}> {1}({2} value);\n",
+                    avail.getMergeInstanceType(), avail.getQueryFnName(),
+                    enumName);
+      handledClasses.insert(className);
+    }
+
+  for (auto ns : llvm::reverse(namespaces))
+    os << "} // namespace " << ns << "\n";
+}
+
+static bool emitEnumAvailDecls(const RecordKeeper &recordKeeper,
+                               raw_ostream &os) {
+  llvm::emitSourceFileHeader("Enum Availability Declarations", os);
+
+  auto defs = recordKeeper.getAllDerivedDefinitions("EnumAttrInfo");
+  for (const auto *def : defs)
+    emitEnumAvailDecl(*def, os);
+
+  return false;
+}
+
+static void emitEnumAvailDef(const Record &enumDef, raw_ostream &os) {
+  EnumAttr enumAttr(enumDef);
+  StringRef cppNamespace = enumAttr.getCppNamespace();
+
+  llvm::SmallVector<StringRef, 2> namespaces;
+  llvm::SplitString(cppNamespace, namespaces, "::");
+
+  for (auto ns : namespaces)
+    os << "namespace " << ns << " {\n";
+
+  if (enumAttr.isBitEnum()) {
+    emitAvailabilityQueryForBitEnum(enumDef, os);
+  } else {
+    emitAvailabilityQueryForIntEnum(enumDef, os);
+  }
+
+  for (auto ns : llvm::reverse(namespaces))
+    os << "} // namespace " << ns << "\n";
+  os << "\n";
+}
+
+static bool emitEnumAvailDefs(const RecordKeeper &recordKeeper,
+                              raw_ostream &os) {
+  llvm::emitSourceFileHeader("Enum Availability Definitions", os);
+
+  auto defs = recordKeeper.getAllDerivedDefinitions("EnumAttrInfo");
+  for (const auto *def : defs)
+    emitEnumAvailDef(*def, os);
+
+  return false;
+}
+
+//===----------------------------------------------------------------------===//
+// Enum Availability Query Hook Registration
+//===----------------------------------------------------------------------===//
+
+// Registers the enum utility generator to mlir-tblgen.
+static mlir::GenRegistration
+    genEnumAvailDecls("gen-enum-avail-decls",
+                      "Generate enum availability declarations",
+                      [](const RecordKeeper &records, raw_ostream &os) {
+                        return emitEnumAvailDecls(records, os);
+                      });
+
+// Registers the enum utility generator to mlir-tblgen.
+static mlir::GenRegistration
+    genEnumAvailDefs("gen-enum-avail-defs",
+                     "Generate enum availability definitions",
+                     [](const RecordKeeper &records, raw_ostream &os) {
+                       return emitEnumAvailDefs(records, os);
+                     });

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

 //===- OpDefinitionsGen.cpp - MLIR op definitions generator ---------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // OpDefinitionsGen uses the description of operations to generate C++
 // definitions for ops.
 //
 //===----------------------------------------------------------------------===//
 
 #include "OpFormatGen.h"
 #include "OpGenHelpers.h"
+#include "mlir/TableGen/Availability.h"
 #include "mlir/TableGen/CodeGenHelpers.h"
 #include "mlir/TableGen/Format.h"
 #include "mlir/TableGen/GenInfo.h"
 #include "mlir/TableGen/Interfaces.h"
 #include "mlir/TableGen/OpClass.h"
 #include "mlir/TableGen/Operator.h"
 #include "mlir/TableGen/SideEffects.h"
 #include "mlir/TableGen/Trait.h"
OpMethod *genOpInterfaceMethod(const tblgen::InterfaceMethod &method,
                                  bool declaration = true);
 
   // Generate the side effect interface methods.
   void genSideEffectInterfaceMethods();
 
   // Generate the type inference interface methods.
   void genTypeInterfaceMethods();
 
+  // Generate availability interface methods.
+  void genAvailabilityInterfaceMethods();
+
 private:
   // The TableGen record for this op.
   // TODO: OpEmitter should not have a Record directly,
   // it should rather go through the Operator for better abstraction.
   const Record &def;
 
   // The wrapper operator class for querying information from this op.
   Operator op;
OpEmitter::OpEmitter(const Operator &op,
   genAttrSetters();
   genOptionalAttrRemovers();
   genBuilder();
   genParser();
   genPrinter();
   genVerifier();
   genCanonicalizerDecls();
   genFolderDecls();
+  genAvailabilityInterfaceMethods();
   genTypeInterfaceMethods();
   genOpInterfaceMethods();
   generateOpFormat(op, opClass);
   genSideEffectInterfaceMethods();
 }
 void OpEmitter::emitDecl(
     const Operator &op, raw_ostream &os,
     const StaticVerifierFunctionEmitter &staticVerifierEmitter) {
for (auto &location : it.second) {
              << (location.kind == EffectKind::Operand ? "Operands" : "Results")
              << "(" << location.index << "))\n  "
              << llvm::formatv(addEffectCode, effect, "value, ", resource).str();
       }
     }
   }
 }
 
+// Returns the availability spec of the given `def`.
+static std::vector<Availability> getAvailabilities(const llvm::Record &def) {
+  std::vector<Availability> availabilities;
+
+  if (def.getValue("availability")) {
+    std::vector<llvm::Record *> availDefs =
+        def.getValueAsListOfDefs("availability");
+    availabilities.reserve(availDefs.size());
+    for (const llvm::Record *avail : availDefs)
+      availabilities.emplace_back(avail);
+  }
+
+  return availabilities;
+}
+
+void OpEmitter::genAvailabilityInterfaceMethods() {
+  mlir::tblgen::FmtContext fctx;
+  fctx.addSubst("overall", "tblgen_overall");
+
+  std::vector<Availability> opAvailabilities = getAvailabilities(op.getDef());
+
+  // First collect all availability classes this op should implement.
+  // All availability instances keep information for the generated interface and
+  // the instance's specific requirement. Here we remember a random instance so
+  // we can get the information regarding the generated interface.
+  llvm::StringMap<Availability> availClasses;
+  for (const Availability &avail : opAvailabilities)
+    availClasses.try_emplace(avail.getClass(), avail);
+  for (const NamedAttribute &namedAttr : op.getAttributes()) {
+    const auto *enumAttr = llvm::dyn_cast<EnumAttr>(&namedAttr.attr);
+    if (!enumAttr)
+      continue;
+
+    for (const EnumAttrCase &enumerant : enumAttr->getAllCases())
+      for (const Availability &caseAvail :
+           getAvailabilities(enumerant.getDef()))
+        availClasses.try_emplace(caseAvail.getClass(), caseAvail);
+  }
+
+  // Then generate implementation for each availability class.
+  for (const auto &availClass : availClasses) {
+    StringRef availClassName = availClass.getKey();
+    Availability avail = availClass.getValue();
+
+    auto *method = opClass.addMethodAndPrune(avail.getQueryFnRetType(),
+                                             avail.getQueryFnName());
+    assert(method && "method already registered!");
+    auto &body = method->body();
+
+    // Create the variable for the final requirement and initialize it.
+    body << formatv("  {0} tblgen_overall = {1};\n", avail.getQueryFnRetType(),
+                    avail.getMergeInitializer());
+
+    // Update with the op's specific availability spec.
+    for (const Availability &avail : opAvailabilities) {
+      if (avail.getClass() == availClassName &&
+          (!avail.getMergeInstancePreparation().empty() ||
+           !avail.getMergeActionCode().empty())) {
+        body << "  {\n    "
+             // Prepare this instance.
+             << avail.getMergeInstancePreparation()
+             << "\n    "
+             // Merge this instance.
+             << std::string(
+                    tgfmt(avail.getMergeActionCode(),
+                          &fctx.addSubst("instance", avail.getMergeInstance())))
+             << ";\n  }\n";
+      }
+    }
+
+    // Update with enum attributes' specific availability spec.
+    for (const NamedAttribute &namedAttr : op.getAttributes()) {
+      const auto *enumAttr = llvm::dyn_cast<EnumAttr>(&namedAttr.attr);
+      if (!enumAttr)
+        continue;
+
+      // (enumerant, availability specification) pairs for this availability
+      // class.
+      SmallVector<std::pair<EnumAttrCase, Availability>, 1> caseSpecs;
+
+      // Collect all cases' availability specs.
+      for (const EnumAttrCase &enumerant : enumAttr->getAllCases())
+        for (const Availability &caseAvail :
+             getAvailabilities(enumerant.getDef()))
+          if (availClassName == caseAvail.getClass())
+            caseSpecs.push_back({enumerant, caseAvail});
+
+      // If this attribute kind does not have any availability spec from any of
+      // its cases, no more work to do.
+      if (caseSpecs.empty())
+        continue;
+
+      if (enumAttr->isBitEnum()) {
+        // For BitEnumAttr, we need to iterate over each bit to query its
+        // availability spec.
+        body << formatv("  for (unsigned i = 0; "
+                        "i < std::numeric_limits<{0}>::digits; ++i) {{\n",
+                        enumAttr->getUnderlyingType());
+        body << formatv("    {0}::{1} tblgen_attrVal = this->{2}() & "
+                        "static_cast<{0}::{1}>(1 << i);\n",
+                        enumAttr->getCppNamespace(),
+                        enumAttr->getEnumClassName(), namedAttr.name);
+        body << formatv(
+            "    if (static_cast<{0}>(tblgen_attrVal) == 0) continue;\n",
+            enumAttr->getUnderlyingType());
+      } else {
+        // For IntEnumAttr, we just need to query the value as a whole.
+        body << "  {\n";
+        body << formatv("    auto tblgen_attrVal = this->{0}();\n",
+                        namedAttr.name);
+      }
+      body << formatv("    auto tblgen_instance = {0}::{1}(tblgen_attrVal);\n",
+                      enumAttr->getCppNamespace(), avail.getQueryFnName());
+      body << "    if (tblgen_instance) "
+           // TODO` here once ODS supports
+           // dialect-specific contents so that we can use not implementing the
+           // availability interface as indication of no requirements.
+           << std::string(tgfmt(caseSpecs.front().second.getMergeActionCode(),
+                                &fctx.addSubst("instance", "*tblgen_instance")))
+           << ";\n";
+      body << "  }\n";
+    }
+
+    body << "  return tblgen_overall;\n";
+  }
+}
+
 void OpEmitter::genTypeInterfaceMethods() {
   if (!op.allResultTypesKnown())
     return;
   // Generate 'inferReturnTypes' method declaration using the interface method
   // declared in 'InferTypeOpInterface' op interface.
   const auto *trait = dyn_cast<InterfaceTrait>(
       op.getTrait("::mlir::InferTypeOpInterface::Trait"));
   Interface interface = trait->getInterface();

mlir/tools/mlir-tblgen/SPIRVUtilsGen.cpp

 #include <list>
 
 using llvm::ArrayRef;
 using llvm::formatv;
 using llvm::raw_ostream;
 using llvm::raw_string_ostream;
 using llvm::Record;
 using llvm::RecordKeeper;
-using llvm::SmallVector;
 using llvm::SMLoc;
 using llvm::StringMap;
 using llvm::StringRef;
 using llvm::Twine;
 using mlir::tblgen::Attribute;
 using mlir::tblgen::EnumAttr;
 using mlir::tblgen::EnumAttrCase;
 using mlir::tblgen::NamedAttribute;
 using mlir::tblgen::NamedTypeConstraint;
 using mlir::tblgen::Operator;
 
 //===----------------------------------------------------------------------===//
-// Availability Wrapper Class
-//===----------------------------------------------------------------------===//
-
-namespace {
-// Wrapper class with helper methods for accessing availability defined in
-// TableGen.
-class Availability {
-public:
-  explicit Availability(const Record *def);
-
-  // Returns the name of the direct TableGen class for this availability
-  // instance.
-  StringRef getClass() const;
-
-  // Returns the generated C++ interface's class namespace.
-  StringRef getInterfaceClassNamespace() const;
-
-  // Returns the generated C++ interface's class name.
-  StringRef getInterfaceClassName() const;
-
-  // Returns the generated C++ interface's description.
-  StringRef getInterfaceDescription() const;
-
-  // Returns the name of the query function insided the generated C++ interface.
-  StringRef getQueryFnName() const;
-
-  // Returns the return type of the query function insided the generated C++
-  // interface.
-  StringRef getQueryFnRetType() const;
-
-  // Returns the code for merging availability requirements.
-  StringRef getMergeActionCode() const;
-
-  // Returns the initializer expression for initializing the final availability
-  // requirements.
-  StringRef getMergeInitializer() const;
-
-  // Returns the C++ type for an availability instance.
-  StringRef getMergeInstanceType() const;
-
-  // Returns the C++ statements for preparing availability instance.
-  StringRef getMergeInstancePreparation() const;
-
-  // Returns the concrete availability instance carried in this case.
-  StringRef getMergeInstance() const;
-
-  // Returns the underlying LLVM TableGen Record.
-  const llvm::Record *getDef() const { return def; }
-
-private:
-  // The TableGen definition of this availability.
-  const llvm::Record *def;
-};
-} // namespace
-
-Availability::Availability(const llvm::Record *def) : def(def) {
-  assert(def->isSubClassOf("Availability") &&
-         "must be subclass of TableGen 'Availability' class");
-}
-
-StringRef Availability::getClass() const {
-  SmallVector<Record *, 1> parentClass;
-  def->getDirectSuperClasses(parentClass);
-  if (parentClass.size() != 1) {
-    PrintFatalError(def->getLoc(),
-                    "expected to only have one direct superclass");
-  }
-  return parentClass.front()->getName();
-}
-
-StringRef Availability::getInterfaceClassNamespace() const {
-  return def->getValueAsString("interfaceNamespace");
-}
-
-StringRef Availability::getInterfaceClassName() const {
-  return def->getValueAsString("interfaceName");
-}
-
-StringRef Availability::getInterfaceDescription() const {
-  return def->getValueAsString("interfaceDescription");
-}
-
-StringRef Availability::getQueryFnRetType() const {
-  return def->getValueAsString("queryFnRetType");
-}
-
-StringRef Availability::getQueryFnName() const {
-  return def->getValueAsString("queryFnName");
-}
-
-StringRef Availability::getMergeActionCode() const {
-  return def->getValueAsString("mergeAction");
-}
-
-StringRef Availability::getMergeInitializer() const {
-  return def->getValueAsString("initializer");
-}
-
-StringRef Availability::getMergeInstanceType() const {
-  return def->getValueAsString("instanceType");
-}
-
-StringRef Availability::getMergeInstancePreparation() const {
-  return def->getValueAsString("instancePreparation");
-}
-
-StringRef Availability::getMergeInstance() const {
-  return def->getValueAsString("instance");
-}
-
-// Returns the availability spec of the given `def`.
-std::vector<Availability> getAvailabilities(const Record &def) {
-  std::vector<Availability> availabilities;
-
-  if (def.getValue("availability")) {
-    std::vector<Record *> availDefs = def.getValueAsListOfDefs("availability");
-    availabilities.reserve(availDefs.size());
-    for (const Record *avail : availDefs)
-      availabilities.emplace_back(avail);
-  }
-
-  return availabilities;
-}
-
-//===----------------------------------------------------------------------===//
-// Availability Interface Definitions AutoGen
-//===----------------------------------------------------------------------===//
-
-static void emitInterfaceDef(const Availability &availability,
-                             raw_ostream &os) {
-
-  os << availability.getQueryFnRetType() << " ";
-
-  StringRef cppNamespace = availability.getInterfaceClassNamespace();
-  cppNamespace.consume_front("::");
-  if (!cppNamespace.empty())
-    os << cppNamespace << "::";
-
-  StringRef methodName = availability.getQueryFnName();
-  os << availability.getInterfaceClassName() << "::" << methodName << "() {\n"
-     << "  return getImpl()->" << methodName << "(getImpl(), getOperation());\n"
-     << "}\n";
-}
-
-static bool emitInterfaceDefs(const RecordKeeper &recordKeeper,
-                              raw_ostream &os) {
-  llvm::emitSourceFileHeader("Availability Interface Definitions", os);
-
-  auto defs = recordKeeper.getAllDerivedDefinitions("Availability");
-  SmallVector<const Record *, 1> handledClasses;
-  for (const Record *def : defs) {
-    SmallVector<Record *, 1> parent;
-    def->getDirectSuperClasses(parent);
-    if (parent.size() != 1) {
-      PrintFatalError(def->getLoc(),
-                      "expected to only have one direct superclass");
-    }
-    if (llvm::is_contained(handledClasses, parent.front()))
-      continue;
-
-    Availability availability(def);
-    emitInterfaceDef(availability, os);
-    handledClasses.push_back(parent.front());
-  }
-  return false;
-}
-
-//===----------------------------------------------------------------------===//
-// Availability Interface Declarations AutoGen
-//===----------------------------------------------------------------------===//
-
-static void emitConceptDecl(const Availability &availability, raw_ostream &os) {
-  os << "  class Concept {\n"
-     << "  public:\n"
-     << "    virtual ~Concept() = default;\n"
-     << "    virtual " << availability.getQueryFnRetType() << " "
-     << availability.getQueryFnName()
-     << "(const Concept *impl, Operation *tblgen_opaque_op) const = 0;\n"
-     << "  };\n";
-}
-
-static void emitModelDecl(const Availability &availability, raw_ostream &os) {
-  for (const char *modelClass : {"Model", "FallbackModel"}) {
-    os << "  template<typename ConcreteOp>\n";
-    os << "  class " << modelClass << " : public Concept {\n"
-       << "  public:\n"
-       << "    " << availability.getQueryFnRetType() << " "
-       << availability.getQueryFnName()
-       << "(const Concept *impl, Operation *tblgen_opaque_op) const final {\n"
-       << "      auto op = llvm::cast<ConcreteOp>(tblgen_opaque_op);\n"
-       << "      (void)op;\n"
-       // Forward to the method on the concrete operation type.
-       << "      return op." << availability.getQueryFnName() << "();\n"
-       << "    }\n"
-       << "  };\n";
-  }
-  os << "  template<typename ConcreteModel, typename ConcreteOp>\n";
-  os << "  class ExternalModel : public FallbackModel<ConcreteOp> {};\n";
-}
-
-static void emitInterfaceDecl(const Availability &availability,
-                              raw_ostream &os) {
-  StringRef interfaceName = availability.getInterfaceClassName();
-  std::string interfaceTraitsName =
-      std::string(formatv("{0}Traits", interfaceName));
-
-  StringRef cppNamespace = availability.getInterfaceClassNamespace();
-  cppNamespace.consume_front("::");
-  SmallVector<StringRef> nsSegments;
-  llvm::SplitString(cppNamespace, nsSegments, "::");
-  for (StringRef segment : nsSegments)
-    os << "namespace " << segment << " {\n";
-
-  // Emit the traits struct containing the concept and model declarations.
-  os << "namespace detail {\n"
-     << "struct " << interfaceTraitsName << " {\n";
-  emitConceptDecl(availability, os);
-  os << '\n';
-  emitModelDecl(availability, os);
-  os << "};\n} // namespace detail\n\n";
-
-  // Emit the main interface class declaration.
-  os << "/*\n" << availability.getInterfaceDescription().trim() << "\n*/\n";
-  os << llvm::formatv("class {0} : public OpInterface<{1}, detail::{2}> {\n"
-                      "public:\n"
-                      "  using OpInterface<{1}, detail::{2}>::OpInterface;\n",
-                      interfaceName, interfaceName, interfaceTraitsName);
-
-  // Emit query function declaration.
-  os << "  " << availability.getQueryFnRetType() << " "
-     << availability.getQueryFnName() << "();\n";
-  os << "};\n\n";
-
-  for (StringRef segment : llvm::reverse(nsSegments))
-    os << "} // namespace " << segment << "\n";
-}
-
-static bool emitInterfaceDecls(const RecordKeeper &recordKeeper,
-                               raw_ostream &os) {
-  llvm::emitSourceFileHeader("Availability Interface Declarations", os);
-
-  auto defs = recordKeeper.getAllDerivedDefinitions("Availability");
-  SmallVector<const Record *, 4> handledClasses;
-  for (const Record *def : defs) {
-    SmallVector<Record *, 1> parent;
-    def->getDirectSuperClasses(parent);
-    if (parent.size() != 1) {
-      PrintFatalError(def->getLoc(),
-                      "expected to only have one direct superclass");
-    }
-    if (llvm::is_contained(handledClasses, parent.front()))
-      continue;
-
-    Availability avail(def);
-    emitInterfaceDecl(avail, os);
-    handledClasses.push_back(parent.front());
-  }
-  return false;
-}
-
-//===----------------------------------------------------------------------===//
-// Availability Interface Hook Registration
-//===----------------------------------------------------------------------===//
-
-// Registers the operation interface generator to mlir-tblgen.
-static mlir::GenRegistration
-    genInterfaceDecls("gen-avail-interface-decls",
-                      "Generate availability interface declarations",
-                      [](const RecordKeeper &records, raw_ostream &os) {
-                        return emitInterfaceDecls(records, os);
-                      });
-
-// Registers the operation interface generator to mlir-tblgen.
-static mlir::GenRegistration
-    genInterfaceDefs("gen-avail-interface-defs",
-                     "Generate op interface definitions",
-                     [](const RecordKeeper &records, raw_ostream &os) {
-                       return emitInterfaceDefs(records, os);
-                     });
-
-//===----------------------------------------------------------------------===//
-// Enum Availability Query AutoGen
-//===----------------------------------------------------------------------===//
-
-static void emitAvailabilityQueryForIntEnum(const Record &enumDef,
-                                            raw_ostream &os) {
-  EnumAttr enumAttr(enumDef);
-  StringRef enumName = enumAttr.getEnumClassName();
-  std::vector<EnumAttrCase> enumerants = enumAttr.getAllCases();
-
-  // Mapping from availability class name to (enumerant, availability
-  // specification) pairs.
-  llvm::StringMap<llvm::SmallVector<std::pair<EnumAttrCase, Availability>, 1>>
-      classCaseMap;
-
-  // Place all availability specifications to their corresponding
-  // availability classes.
-  for (const EnumAttrCase &enumerant : enumerants)
-    for (const Availability &avail : getAvailabilities(enumerant.getDef()))
-      classCaseMap[avail.getClass()].push_back({enumerant, avail});
-
-  for (const auto &classCasePair : classCaseMap) {
-    Availability avail = classCasePair.getValue().front().second;
-
-    os << formatv("llvm::Optional<{0}> {1}({2} value) {{\n",
-                  avail.getMergeInstanceType(), avail.getQueryFnName(),
-                  enumName);
-
-    os << "  switch (value) {\n";
-    for (const auto &caseSpecPair : classCasePair.getValue()) {
-      EnumAttrCase enumerant = caseSpecPair.first;
-      Availability avail = caseSpecPair.second;
-      os << formatv("  case {0}::{1}: { {2} return {3}({4}); }\n", enumName,
-                    enumerant.getSymbol(), avail.getMergeInstancePreparation(),
-                    avail.getMergeInstanceType(), avail.getMergeInstance());
-    }
-    // Only emit default if uncovered cases.
-    if (classCasePair.getValue().size() < enumAttr.getAllCases().size())
-      os << "  default: break;\n";
-    os << "  }\n"
-       << "  return llvm::None;\n"
-       << "}\n";
-  }
-}
-
-static void emitAvailabilityQueryForBitEnum(const Record &enumDef,
-                                            raw_ostream &os) {
-  EnumAttr enumAttr(enumDef);
-  StringRef enumName = enumAttr.getEnumClassName();
-  std::string underlyingType = std::string(enumAttr.getUnderlyingType());
-  std::vector<EnumAttrCase> enumerants = enumAttr.getAllCases();
-
-  // Mapping from availability class name to (enumerant, availability
-  // specification) pairs.
-  llvm::StringMap<llvm::SmallVector<std::pair<EnumAttrCase, Availability>, 1>>
-      classCaseMap;
-
-  // Place all availability specifications to their corresponding
-  // availability classes.
-  for (const EnumAttrCase &enumerant : enumerants)
-    for (const Availability &avail : getAvailabilities(enumerant.getDef()))
-      classCaseMap[avail.getClass()].push_back({enumerant, avail});
-
-  for (const auto &classCasePair : classCaseMap) {
-    Availability avail = classCasePair.getValue().front().second;
-
-    os << formatv("llvm::Optional<{0}> {1}({2} value) {{\n",
-                  avail.getMergeInstanceType(), avail.getQueryFnName(),
-                  enumName);
-
-    os << formatv(
-        "  assert(::llvm::countPopulation(static_cast<{0}>(value)) <= 1"
-        " && \"cannot have more than one bit set\");\n",
-        underlyingType);
-
-    os << "  switch (value) {\n";
-    for (const auto &caseSpecPair : classCasePair.getValue()) {
-      EnumAttrCase enumerant = caseSpecPair.first;
-      Availability avail = caseSpecPair.second;
-      os << formatv("  case {0}::{1}: { {2} return {3}({4}); }\n", enumName,
-                    enumerant.getSymbol(), avail.getMergeInstancePreparation(),
-                    avail.getMergeInstanceType(), avail.getMergeInstance());
-    }
-    os << "  default: break;\n";
-    os << "  }\n"
-       << "  return llvm::None;\n"
-       << "}\n";
-  }
-}
-
-static void emitEnumDecl(const Record &enumDef, raw_ostream &os) {
-  EnumAttr enumAttr(enumDef);
-  StringRef enumName = enumAttr.getEnumClassName();
-  StringRef cppNamespace = enumAttr.getCppNamespace();
-  auto enumerants = enumAttr.getAllCases();
-
-  llvm::SmallVector<StringRef, 2> namespaces;
-  llvm::SplitString(cppNamespace, namespaces, "::");
-
-  for (auto ns : namespaces)
-    os << "namespace " << ns << " {\n";
-
-  llvm::StringSet<> handledClasses;
-
-  // Place all availability specifications to their corresponding
-  // availability classes.
-  for (const EnumAttrCase &enumerant : enumerants)
-    for (const Availability &avail : getAvailabilities(enumerant.getDef())) {
-      StringRef className = avail.getClass();
-      if (handledClasses.count(className))
-        continue;
-      os << formatv("llvm::Optional<{0}> {1}({2} value);\n",
-                    avail.getMergeInstanceType(), avail.getQueryFnName(),
-                    enumName);
-      handledClasses.insert(className);
-    }
-
-  for (auto ns : llvm::reverse(namespaces))
-    os << "} // namespace " << ns << "\n";
-}
-
-static bool emitEnumDecls(const RecordKeeper &recordKeeper, raw_ostream &os) {
-  llvm::emitSourceFileHeader("SPIR-V Enum Availability Declarations", os);
-
-  auto defs = recordKeeper.getAllDerivedDefinitions("EnumAttrInfo");
-  for (const auto *def : defs)
-    emitEnumDecl(*def, os);
-
-  return false;
-}
-
-static void emitEnumDef(const Record &enumDef, raw_ostream &os) {
-  EnumAttr enumAttr(enumDef);
-  StringRef cppNamespace = enumAttr.getCppNamespace();
-
-  llvm::SmallVector<StringRef, 2> namespaces;
-  llvm::SplitString(cppNamespace, namespaces, "::");
-
-  for (auto ns : namespaces)
-    os << "namespace " << ns << " {\n";
-
-  if (enumAttr.isBitEnum()) {
-    emitAvailabilityQueryForBitEnum(enumDef, os);
-  } else {
-    emitAvailabilityQueryForIntEnum(enumDef, os);
-  }
-
-  for (auto ns : llvm::reverse(namespaces))
-    os << "} // namespace " << ns << "\n";
-  os << "\n";
-}
-
-static bool emitEnumDefs(const RecordKeeper &recordKeeper, raw_ostream &os) {
-  llvm::emitSourceFileHeader("SPIR-V Enum Availability Definitions", os);
-
-  auto defs = recordKeeper.getAllDerivedDefinitions("EnumAttrInfo");
-  for (const auto *def : defs)
-    emitEnumDef(*def, os);
-
-  return false;
-}
-
-//===----------------------------------------------------------------------===//
-// Enum Availability Query Hook Registration
-//===----------------------------------------------------------------------===//
-
-// Registers the enum utility generator to mlir-tblgen.
-static mlir::GenRegistration
-    genEnumDecls("gen-spirv-enum-avail-decls",
-                 "Generate SPIR-V enum availability declarations",
-                 [](const RecordKeeper &records, raw_ostream &os) {
-                   return emitEnumDecls(records, os);
-                 });
-
-// Registers the enum utility generator to mlir-tblgen.
-static mlir::GenRegistration
-    genEnumDefs("gen-spirv-enum-avail-defs",
-                "Generate SPIR-V enum availability definitions",
-                [](const RecordKeeper &records, raw_ostream &os) {
-                  return emitEnumDefs(records, os);
-                });
-
-//===----------------------------------------------------------------------===//
 // Serialization AutoGen
 //===----------------------------------------------------------------------===//
 
 /// Generates code to serialize attributes of a SPV_Op `op` into `os`. The
 /// generates code extracts the attribute with name `attrName` from
 /// `operandList` of `op`.
 static void emitAttributeSerialization(const Attribute &attr,
                                        ArrayRef<SMLoc> loc, StringRef tabs,

 static mlir::GenRegistration
     genOpUtils("gen-spirv-attr-utils",
                "Generate SPIR-V attribute utility definitions",
                [](const RecordKeeper &records, raw_ostream &os) {
                  return emitAttrUtils(records, os);
                });
 
 //===----------------------------------------------------------------------===//
-// SPIR-V Availability Impl AutoGen
-//===----------------------------------------------------------------------===//
-
-static void emitAvailabilityImpl(const Operator &srcOp, raw_ostream &os) {
-  mlir::tblgen::FmtContext fctx;
-  fctx.addSubst("overall", "tblgen_overall");
-
-  std::vector<Availability> opAvailabilities =
-      getAvailabilities(srcOp.getDef());
-
-  // First collect all availability classes this op should implement.
-  // All availability instances keep information for the generated interface and
-  // the instance's specific requirement. Here we remember a random instance so
-  // we can get the information regarding the generated interface.
-  llvm::StringMap<Availability> availClasses;
-  for (const Availability &avail : opAvailabilities)
-    availClasses.try_emplace(avail.getClass(), avail);
-  for (const NamedAttribute &namedAttr : srcOp.getAttributes()) {
-    const auto *enumAttr = llvm::dyn_cast<EnumAttr>(&namedAttr.attr);
-    if (!enumAttr)
-      continue;
-
-    for (const EnumAttrCase &enumerant : enumAttr->getAllCases())
-      for (const Availability &caseAvail :
-           getAvailabilities(enumerant.getDef()))
-        availClasses.try_emplace(caseAvail.getClass(), caseAvail);
-  }
-
-  // Then generate implementation for each availability class.
-  for (const auto &availClass : availClasses) {
-    StringRef availClassName = availClass.getKey();
-    Availability avail = availClass.getValue();
-
-    // Generate the implementation method signature.
-    os << formatv("{0} {1}::{2}() {{\n", avail.getQueryFnRetType(),
-                  srcOp.getCppClassName(), avail.getQueryFnName());
-
-    // Create the variable for the final requirement and initialize it.
-    os << formatv("  {0} tblgen_overall = {1};\n", avail.getQueryFnRetType(),
-                  avail.getMergeInitializer());
-
-    // Update with the op's specific availability spec.
-    for (const Availability &avail : opAvailabilities)
-      if (avail.getClass() == availClassName &&
-          (!avail.getMergeInstancePreparation().empty() ||
-           !avail.getMergeActionCode().empty())) {
-        os << "  {\n    "
-           // Prepare this instance.
-           << avail.getMergeInstancePreparation()
-           << "\n    "
-           // Merge this instance.
-           << std::string(
-                  tgfmt(avail.getMergeActionCode(),
-                        &fctx.addSubst("instance", avail.getMergeInstance())))
-           << ";\n  }\n";
-      }
-
-    // Update with enum attributes' specific availability spec.
-    for (const NamedAttribute &namedAttr : srcOp.getAttributes()) {
-      const auto *enumAttr = llvm::dyn_cast<EnumAttr>(&namedAttr.attr);
-      if (!enumAttr)
-        continue;
-
-      // (enumerant, availability specification) pairs for this availability
-      // class.
-      SmallVector<std::pair<EnumAttrCase, Availability>, 1> caseSpecs;
-
-      // Collect all cases' availability specs.
-      for (const EnumAttrCase &enumerant : enumAttr->getAllCases())
-        for (const Availability &caseAvail :
-             getAvailabilities(enumerant.getDef()))
-          if (availClassName == caseAvail.getClass())
-            caseSpecs.push_back({enumerant, caseAvail});
-
-      // If this attribute kind does not have any availability spec from any of
-      // its cases, no more work to do.
-      if (caseSpecs.empty())
-        continue;
-
-      if (enumAttr->isBitEnum()) {
-        // For BitEnumAttr, we need to iterate over each bit to query its
-        // availability spec.
-        os << formatv("  for (unsigned i = 0; "
-                      "i < std::numeric_limits<{0}>::digits; ++i) {{\n",
-                      enumAttr->getUnderlyingType());
-        os << formatv("    {0}::{1} tblgen_attrVal = this->{2}() & "
-                      "static_cast<{0}::{1}>(1 << i);\n",
-                      enumAttr->getCppNamespace(), enumAttr->getEnumClassName(),
-                      namedAttr.name);
-        os << formatv(
-            "    if (static_cast<{0}>(tblgen_attrVal) == 0) continue;\n",
-            enumAttr->getUnderlyingType());
-      } else {
-        // For IntEnumAttr, we just need to query the value as a whole.
-        os << "  {\n";
-        os << formatv("    auto tblgen_attrVal = this->{0}();\n",
-                      namedAttr.name);
-      }
-      os << formatv("    auto tblgen_instance = {0}::{1}(tblgen_attrVal);\n",
-                    enumAttr->getCppNamespace(), avail.getQueryFnName());
-      os << "    if (tblgen_instance) "
-         // TODO` here once ODS supports
-         // dialect-specific contents so that we can use not implementing the
-         // availability interface as indication of no requirements.
-         << std::string(tgfmt(caseSpecs.front().second.getMergeActionCode(),
-                              &fctx.addSubst("instance", "*tblgen_instance")))
-         << ";\n";
-      os << "  }\n";
-    }
-
-    os << "  return tblgen_overall;\n";
-    os << "}\n";
-  }
-}
-
-static bool emitAvailabilityImpl(const RecordKeeper &recordKeeper,
-                                 raw_ostream &os) {
-  llvm::emitSourceFileHeader("SPIR-V Op Availability Implementations", os);
-
-  auto defs = recordKeeper.getAllDerivedDefinitions("SPV_Op");
-  for (const auto *def : defs) {
-    Operator op(def);
-    emitAvailabilityImpl(op, os);
-  }
-  return false;
-}
-
-//===----------------------------------------------------------------------===//
-// Op Availability Implementation Hook Registration
-//===----------------------------------------------------------------------===//
-
-static mlir::GenRegistration
-    genOpAvailabilityImpl("gen-spirv-avail-impls",
-                          "Generate SPIR-V operation utility definitions",
-                          [](const RecordKeeper &records, raw_ostream &os) {
-                            return emitAvailabilityImpl(records, os);
-                          });
-
-//===----------------------------------------------------------------------===//
 // SPIR-V Capability Implication AutoGen
 //===----------------------------------------------------------------------===//
 
 static bool emitCapabilityImplication(const RecordKeeper &recordKeeper,
                                       raw_ostream &os) {
   llvm::emitSourceFileHeader("SPIR-V Capability Implication", os);
 
   EnumAttr enumAttr(recordKeeper.getDef("SPV_CapabilityAttr"));

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

tbl_outs = [
             ["-gen-enum-decls"],
             "include/mlir/Dialect/SPIRV/IR/SPIRVEnums.h.inc",
         ),
         (
             ["-gen-enum-defs"],
             "include/mlir/Dialect/SPIRV/IR/SPIRVEnums.cpp.inc",
         ),
         (
-            ["-gen-spirv-enum-avail-decls"],
+            ["-gen-enum-avail-decls"],
             "include/mlir/Dialect/SPIRV/IR/SPIRVEnumAvailability.h.inc",
         ),
         (
-            ["-gen-spirv-enum-avail-defs"],
+            ["-gen-enum-avail-defs"],
             "include/mlir/Dialect/SPIRV/IR/SPIRVEnumAvailability.cpp.inc",
         ),
         (
             ["-gen-spirv-capability-implication"],
             "include/mlir/Dialect/SPIRV/IR/SPIRVCapabilityImplication.inc",
         ),
     ],
     tblgen = ":mlir-tblgen",
tbl_outs = [
         (
             ["-gen-avail-interface-decls"],
             "include/mlir/Dialect/SPIRV/IR/SPIRVAvailability.h.inc",
         ),
         (
             ["-gen-avail-interface-defs"],
             "include/mlir/Dialect/SPIRV/IR/SPIRVAvailability.cpp.inc",
         ),
-        (
-            ["-gen-spirv-avail-impls"],
-            "include/mlir/Dialect/SPIRV/IR/SPIRVOpAvailabilityImpl.inc",
-        ),
     ],
     tblgen = ":mlir-tblgen",
     td_file = "include/mlir/Dialect/SPIRV/IR/SPIRVOps.td",
     deps = [":SPIRVOpsTdFiles"],
 )
 
 gentbl_cc_library(
     name = "SPIRVTargetAndABIStructGen",