1/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
2|* *|
3|* Availability Interface Declarations *|
4|* *|
5|* Automatically generated file, do not edit! *|
6|* From: SPIRVOps.td *|
7|* *|
8\*===----------------------------------------------------------------------===*/
9
10namespace mlir::spirv {
11
12class QueryExtensionInterface;
13
14namespace detail {
15struct QueryExtensionInterfaceTraits {
16 class Concept {
17 public:
18 virtual ~Concept() = default;
19 virtual ::llvm::SmallVector<::llvm::ArrayRef<::mlir::spirv::Extension>, 1> getExtensions(const Concept *impl, Operation *tblgen_opaque_op) const = 0;
20 };
21
22 template<typename ConcreteOp>
23 class Model : public Concept {
24 public:
25 using Interface = QueryExtensionInterface;
26 ::llvm::SmallVector<::llvm::ArrayRef<::mlir::spirv::Extension>, 1> getExtensions(const Concept *impl, Operation *tblgen_opaque_op) const final {
27 auto op = llvm::cast<ConcreteOp>(tblgen_opaque_op);
28 (void)op;
29 return op.getExtensions();
30 }
31 };
32 template<typename ConcreteOp>
33 class FallbackModel : public Concept {
34 public:
35 using Interface = QueryExtensionInterface;
36 ::llvm::SmallVector<::llvm::ArrayRef<::mlir::spirv::Extension>, 1> getExtensions(const Concept *impl, Operation *tblgen_opaque_op) const final {
37 auto op = llvm::cast<ConcreteOp>(tblgen_opaque_op);
38 (void)op;
39 return op.getExtensions();
40 }
41 };
42 template<typename ConcreteModel, typename ConcreteOp>
43 class ExternalModel : public FallbackModel<ConcreteOp> {};
44};
45} // namespace detail
46
47/*
48Querying interface for required SPIR-V extensions.
49
50 This interface provides a `getExtensions()` method to query the required
51 extensions for the implementing SPIR-V operation. The returned value
52 is a nested vector whose element is `mlir::spirv::Extension`s. The outer
53 vector's elements (which are vectors) should be interpreted as conjunction
54 while the inner vector's elements (which are `mlir::spirv::Extension`s)
55 should be interpreted as disjunction. For example, given
56
57 ```
58 {{Extension::A, Extension::B}, {Extension::C}, {{Extension::D, Extension::E}}
59 ```
60
61 The operation instance is available when (`Extension::A` OR `Extension::B`)
62 AND (`Extension::C`) AND (`Extension::D` OR `Extension::E`) is enabled.
63*/
64class QueryExtensionInterface : public OpInterface<QueryExtensionInterface, detail::QueryExtensionInterfaceTraits> {
65public:
66 using OpInterface<QueryExtensionInterface, detail::QueryExtensionInterfaceTraits>::OpInterface;
67 ::llvm::SmallVector<::llvm::ArrayRef<::mlir::spirv::Extension>, 1> getExtensions();
68};
69
70
71} // namespace mlir::spirv
72namespace mlir::spirv {
73
74class QueryMinVersionInterface;
75
76namespace detail {
77struct QueryMinVersionInterfaceTraits {
78 class Concept {
79 public:
80 virtual ~Concept() = default;
81 virtual std::optional<::mlir::spirv::Version> getMinVersion(const Concept *impl, Operation *tblgen_opaque_op) const = 0;
82 };
83
84 template<typename ConcreteOp>
85 class Model : public Concept {
86 public:
87 using Interface = QueryMinVersionInterface;
88 std::optional<::mlir::spirv::Version> getMinVersion(const Concept *impl, Operation *tblgen_opaque_op) const final {
89 auto op = llvm::cast<ConcreteOp>(tblgen_opaque_op);
90 (void)op;
91 return op.getMinVersion();
92 }
93 };
94 template<typename ConcreteOp>
95 class FallbackModel : public Concept {
96 public:
97 using Interface = QueryMinVersionInterface;
98 std::optional<::mlir::spirv::Version> getMinVersion(const Concept *impl, Operation *tblgen_opaque_op) const final {
99 auto op = llvm::cast<ConcreteOp>(tblgen_opaque_op);
100 (void)op;
101 return op.getMinVersion();
102 }
103 };
104 template<typename ConcreteModel, typename ConcreteOp>
105 class ExternalModel : public FallbackModel<ConcreteOp> {};
106};
107} // namespace detail
108
109/*
110Querying interface for minimal required SPIR-V version.
111
112 This interface provides a `getMinVersion()` method to query the minimal
113 required version for the implementing SPIR-V operation. The returned value
114 is a `mlir::spirv::Version` enumerant.
115*/
116class QueryMinVersionInterface : public OpInterface<QueryMinVersionInterface, detail::QueryMinVersionInterfaceTraits> {
117public:
118 using OpInterface<QueryMinVersionInterface, detail::QueryMinVersionInterfaceTraits>::OpInterface;
119 std::optional<::mlir::spirv::Version> getMinVersion();
120};
121
122
123} // namespace mlir::spirv
124namespace mlir::spirv {
125
126class QueryCapabilityInterface;
127
128namespace detail {
129struct QueryCapabilityInterfaceTraits {
130 class Concept {
131 public:
132 virtual ~Concept() = default;
133 virtual ::llvm::SmallVector<::llvm::ArrayRef<::mlir::spirv::Capability>, 1> getCapabilities(const Concept *impl, Operation *tblgen_opaque_op) const = 0;
134 };
135
136 template<typename ConcreteOp>
137 class Model : public Concept {
138 public:
139 using Interface = QueryCapabilityInterface;
140 ::llvm::SmallVector<::llvm::ArrayRef<::mlir::spirv::Capability>, 1> getCapabilities(const Concept *impl, Operation *tblgen_opaque_op) const final {
141 auto op = llvm::cast<ConcreteOp>(tblgen_opaque_op);
142 (void)op;
143 return op.getCapabilities();
144 }
145 };
146 template<typename ConcreteOp>
147 class FallbackModel : public Concept {
148 public:
149 using Interface = QueryCapabilityInterface;
150 ::llvm::SmallVector<::llvm::ArrayRef<::mlir::spirv::Capability>, 1> getCapabilities(const Concept *impl, Operation *tblgen_opaque_op) const final {
151 auto op = llvm::cast<ConcreteOp>(tblgen_opaque_op);
152 (void)op;
153 return op.getCapabilities();
154 }
155 };
156 template<typename ConcreteModel, typename ConcreteOp>
157 class ExternalModel : public FallbackModel<ConcreteOp> {};
158};
159} // namespace detail
160
161/*
162Querying interface for required SPIR-V capabilities.
163
164 This interface provides a `getCapabilities()` method to query the required
165 capabilities for the implementing SPIR-V operation. The returned value
166 is a nested vector whose element is `mlir::spirv::Capability`s. The outer
167 vector's elements (which are vectors) should be interpreted as conjunction
168 while the inner vector's elements (which are `mlir::spirv::Capability`s)
169 should be interpreted as disjunction. For example, given
170
171 ```
172 {{Capability::A, Capability::B}, {Capability::C}, {{Capability::D, Capability::E}}
173 ```
174
175 The operation instance is available when (`Capability::A` OR `Capability::B`)
176 AND (`Capability::C`) AND (`Capability::D` OR `Capability::E`) is enabled.
177*/
178class QueryCapabilityInterface : public OpInterface<QueryCapabilityInterface, detail::QueryCapabilityInterfaceTraits> {
179public:
180 using OpInterface<QueryCapabilityInterface, detail::QueryCapabilityInterfaceTraits>::OpInterface;
181 ::llvm::SmallVector<::llvm::ArrayRef<::mlir::spirv::Capability>, 1> getCapabilities();
182};
183
184
185} // namespace mlir::spirv
186namespace mlir::spirv {
187
188class QueryMaxVersionInterface;
189
190namespace detail {
191struct QueryMaxVersionInterfaceTraits {
192 class Concept {
193 public:
194 virtual ~Concept() = default;
195 virtual std::optional<::mlir::spirv::Version> getMaxVersion(const Concept *impl, Operation *tblgen_opaque_op) const = 0;
196 };
197
198 template<typename ConcreteOp>
199 class Model : public Concept {
200 public:
201 using Interface = QueryMaxVersionInterface;
202 std::optional<::mlir::spirv::Version> getMaxVersion(const Concept *impl, Operation *tblgen_opaque_op) const final {
203 auto op = llvm::cast<ConcreteOp>(tblgen_opaque_op);
204 (void)op;
205 return op.getMaxVersion();
206 }
207 };
208 template<typename ConcreteOp>
209 class FallbackModel : public Concept {
210 public:
211 using Interface = QueryMaxVersionInterface;
212 std::optional<::mlir::spirv::Version> getMaxVersion(const Concept *impl, Operation *tblgen_opaque_op) const final {
213 auto op = llvm::cast<ConcreteOp>(tblgen_opaque_op);
214 (void)op;
215 return op.getMaxVersion();
216 }
217 };
218 template<typename ConcreteModel, typename ConcreteOp>
219 class ExternalModel : public FallbackModel<ConcreteOp> {};
220};
221} // namespace detail
222
223/*
224Querying interface for maximal supported SPIR-V version.
225
226 This interface provides a `getMaxVersion()` method to query the maximal
227 supported version for the implementing SPIR-V operation. The returned value
228 is a `mlir::spirv::Version` enumerant.
229*/
230class QueryMaxVersionInterface : public OpInterface<QueryMaxVersionInterface, detail::QueryMaxVersionInterfaceTraits> {
231public:
232 using OpInterface<QueryMaxVersionInterface, detail::QueryMaxVersionInterfaceTraits>::OpInterface;
233 std::optional<::mlir::spirv::Version> getMaxVersion();
234};
235
236
237} // namespace mlir::spirv
238