1/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
2|* *|
3|* Interface Declarations *|
4|* *|
5|* Automatically generated file, do not edit! *|
6|* *|
7\*===----------------------------------------------------------------------===*/
8
9namespace mlir {
10/// A call-like operation is one that transfers control from one sub-routine to
11/// another. These operations may be traditional direct calls `call @foo`, or
12/// indirect calls to other operations `call_indirect %foo`. An operation that
13/// uses this interface, must *not* also provide the `CallableOpInterface`.
14class CallOpInterface;
15namespace detail {
16struct CallOpInterfaceInterfaceTraits {
17 struct Concept {
18 /// The methods defined by the interface.
19 ::mlir::CallInterfaceCallable (*getCallableForCallee)(const Concept *impl, ::mlir::Operation *);
20 void (*setCalleeFromCallable)(const Concept *impl, ::mlir::Operation *, ::mlir::CallInterfaceCallable);
21 ::mlir::Operation::operand_range (*getArgOperands)(const Concept *impl, ::mlir::Operation *);
22 ::mlir::MutableOperandRange (*getArgOperandsMutable)(const Concept *impl, ::mlir::Operation *);
23 ::mlir::Operation *(*resolveCallableInTable)(const Concept *impl, ::mlir::Operation *, ::mlir::SymbolTableCollection *);
24 ::mlir::Operation *(*resolveCallable)(const Concept *impl, ::mlir::Operation *);
25 ::mlir::ArrayAttr (*getArgAttrsAttr)(const Concept *impl, ::mlir::Operation *);
26 ::mlir::ArrayAttr (*getResAttrsAttr)(const Concept *impl, ::mlir::Operation *);
27 void (*setArgAttrsAttr)(const Concept *impl, ::mlir::Operation *, ::mlir::ArrayAttr);
28 void (*setResAttrsAttr)(const Concept *impl, ::mlir::Operation *, ::mlir::ArrayAttr);
29 ::mlir::Attribute (*removeArgAttrsAttr)(const Concept *impl, ::mlir::Operation *);
30 ::mlir::Attribute (*removeResAttrsAttr)(const Concept *impl, ::mlir::Operation *);
31 };
32 template<typename ConcreteOp>
33 class Model : public Concept {
34 public:
35 using Interface = ::mlir::CallOpInterface;
36 Model() : Concept{.getCallableForCallee: getCallableForCallee, .setCalleeFromCallable: setCalleeFromCallable, .getArgOperands: getArgOperands, .getArgOperandsMutable: getArgOperandsMutable, .resolveCallableInTable: resolveCallableInTable, .resolveCallable: resolveCallable, .getArgAttrsAttr: getArgAttrsAttr, .getResAttrsAttr: getResAttrsAttr, .setArgAttrsAttr: setArgAttrsAttr, .setResAttrsAttr: setResAttrsAttr, .removeArgAttrsAttr: removeArgAttrsAttr, .removeResAttrsAttr: removeResAttrsAttr} {}
37
38 static inline ::mlir::CallInterfaceCallable getCallableForCallee(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
39 static inline void setCalleeFromCallable(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::CallInterfaceCallable callee);
40 static inline ::mlir::Operation::operand_range getArgOperands(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
41 static inline ::mlir::MutableOperandRange getArgOperandsMutable(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
42 static inline ::mlir::Operation *resolveCallableInTable(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::SymbolTableCollection * symbolTable);
43 static inline ::mlir::Operation *resolveCallable(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
44 static inline ::mlir::ArrayAttr getArgAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
45 static inline ::mlir::ArrayAttr getResAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
46 static inline void setArgAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::ArrayAttr attrs);
47 static inline void setResAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::ArrayAttr attrs);
48 static inline ::mlir::Attribute removeArgAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
49 static inline ::mlir::Attribute removeResAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
50 };
51 template<typename ConcreteOp>
52 class FallbackModel : public Concept {
53 public:
54 using Interface = ::mlir::CallOpInterface;
55 FallbackModel() : Concept{.getCallableForCallee: getCallableForCallee, .setCalleeFromCallable: setCalleeFromCallable, .getArgOperands: getArgOperands, .getArgOperandsMutable: getArgOperandsMutable, .resolveCallableInTable: resolveCallableInTable, .resolveCallable: resolveCallable, .getArgAttrsAttr: getArgAttrsAttr, .getResAttrsAttr: getResAttrsAttr, .setArgAttrsAttr: setArgAttrsAttr, .setResAttrsAttr: setResAttrsAttr, .removeArgAttrsAttr: removeArgAttrsAttr, .removeResAttrsAttr: removeResAttrsAttr} {}
56
57 static inline ::mlir::CallInterfaceCallable getCallableForCallee(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
58 static inline void setCalleeFromCallable(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::CallInterfaceCallable callee);
59 static inline ::mlir::Operation::operand_range getArgOperands(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
60 static inline ::mlir::MutableOperandRange getArgOperandsMutable(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
61 static inline ::mlir::Operation *resolveCallableInTable(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::SymbolTableCollection * symbolTable);
62 static inline ::mlir::Operation *resolveCallable(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
63 static inline ::mlir::ArrayAttr getArgAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
64 static inline ::mlir::ArrayAttr getResAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
65 static inline void setArgAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::ArrayAttr attrs);
66 static inline void setResAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::ArrayAttr attrs);
67 static inline ::mlir::Attribute removeArgAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
68 static inline ::mlir::Attribute removeResAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
69 };
70 template<typename ConcreteModel, typename ConcreteOp>
71 class ExternalModel : public FallbackModel<ConcreteModel> {
72 public:
73 using ConcreteEntity = ConcreteOp;
74 ::mlir::Operation *resolveCallableInTable(::mlir::Operation *tablegen_opaque_val, ::mlir::SymbolTableCollection *symbolTable) const;
75 ::mlir::Operation *resolveCallable(::mlir::Operation *tablegen_opaque_val) const;
76 };
77};
78template <typename ConcreteOp>
79struct CallOpInterfaceTrait;
80
81} // namespace detail
82class CallOpInterface : public ::mlir::OpInterface<CallOpInterface, detail::CallOpInterfaceInterfaceTraits> {
83public:
84 using ::mlir::OpInterface<CallOpInterface, detail::CallOpInterfaceInterfaceTraits>::OpInterface;
85 template <typename ConcreteOp>
86 struct Trait : public detail::CallOpInterfaceTrait<ConcreteOp> {};
87
88 /// Returns the callee of this call-like operation. A `callee` is either a
89 /// reference to a symbol, via SymbolRefAttr, or a reference to a defined
90 /// SSA value. If the reference is an SSA value, the SSA value corresponds
91 /// to a region of a lambda-like operation.
92 ::mlir::CallInterfaceCallable getCallableForCallee();
93
94 /// Sets the callee of this call-like operation. A `callee` is either a
95 /// reference to a symbol, via SymbolRefAttr, or a reference to a defined
96 /// SSA value. The type of the `callee` is expected to be the same as the
97 /// return type of `getCallableForCallee`, e.g., `callee` should be
98 /// SymbolRefAttr for `func.call`.
99 void setCalleeFromCallable(::mlir::CallInterfaceCallable callee);
100
101 /// Returns the operands within this call that are used as arguments to the
102 /// callee.
103 ::mlir::Operation::operand_range getArgOperands();
104
105 /// Returns the operands within this call that are used as arguments to the
106 /// callee as a mutable range.
107 ::mlir::MutableOperandRange getArgOperandsMutable();
108
109 /// Resolve the callable operation for given callee to a
110 /// CallableOpInterface, or nullptr if a valid callable was not resolved.
111 /// `symbolTable` parameter allow for using a cached symbol table for symbol
112 /// lookups instead of performing an O(N) scan.
113 ::mlir::Operation *resolveCallableInTable(::mlir::SymbolTableCollection * symbolTable);
114
115 /// Resolve the callable operation for given callee to a
116 /// CallableOpInterface, or nullptr if a valid callable was not resolved.
117 ::mlir::Operation *resolveCallable();
118
119 /// Get the array of argument attribute dictionaries. The method should
120 /// return an array attribute containing only dictionary attributes equal in
121 /// number to the number of arguments. Alternatively, the method can
122 /// return null to indicate that there are no argument attributes.
123 ::mlir::ArrayAttr getArgAttrsAttr();
124
125 /// Get the array of result attribute dictionaries. The method should return
126 /// an array attribute containing only dictionary attributes equal in number
127 /// to the number of results. Alternatively, the method can return
128 /// null to indicate that there are no result attributes.
129 ::mlir::ArrayAttr getResAttrsAttr();
130
131 /// Set the array of argument attribute dictionaries.
132 void setArgAttrsAttr(::mlir::ArrayAttr attrs);
133
134 /// Set the array of result attribute dictionaries.
135 void setResAttrsAttr(::mlir::ArrayAttr attrs);
136
137 /// Remove the array of argument attribute dictionaries. This is the same as
138 /// setting all argument attributes to an empty dictionary. The method should
139 /// return the removed attribute.
140 ::mlir::Attribute removeArgAttrsAttr();
141
142 /// Remove the array of result attribute dictionaries. This is the same as
143 /// setting all result attributes to an empty dictionary. The method should
144 /// return the removed attribute.
145 ::mlir::Attribute removeResAttrsAttr();
146};
147namespace detail {
148 template <typename ConcreteOp>
149 struct CallOpInterfaceTrait : public ::mlir::OpInterface<CallOpInterface, detail::CallOpInterfaceInterfaceTraits>::Trait<ConcreteOp> {
150
151 /// Resolve the callable operation for given callee to a
152 /// CallableOpInterface, or nullptr if a valid callable was not resolved.
153 /// `symbolTable` parameter allow for using a cached symbol table for symbol
154 /// lookups instead of performing an O(N) scan.
155 ::mlir::Operation *resolveCallableInTable(::mlir::SymbolTableCollection * symbolTable) {
156 return ::mlir::call_interface_impl::resolveCallable(call: (*static_cast<ConcreteOp *>(this)), symbolTable);
157 }
158
159 /// Resolve the callable operation for given callee to a
160 /// CallableOpInterface, or nullptr if a valid callable was not resolved.
161 ::mlir::Operation *resolveCallable() {
162 return ::mlir::call_interface_impl::resolveCallable(call: (*static_cast<ConcreteOp *>(this)));
163 }
164 };
165}// namespace detail
166} // namespace mlir
167namespace mlir {
168/// A callable operation is one who represents a potential sub-routine, and may
169/// be a target for a call-like operation (those providing the CallOpInterface
170/// above). These operations may be traditional functional operation
171/// `func @foo(...)`, as well as function producing operations
172/// `%foo = dialect.create_function(...)`. These operations may only contain a
173/// single region, or subroutine.
174class CallableOpInterface;
175namespace detail {
176struct CallableOpInterfaceInterfaceTraits {
177 struct Concept {
178 /// The methods defined by the interface.
179 ::mlir::Region *(*getCallableRegion)(const Concept *impl, ::mlir::Operation *);
180 ::llvm::ArrayRef<::mlir::Type> (*getArgumentTypes)(const Concept *impl, ::mlir::Operation *);
181 ::llvm::ArrayRef<::mlir::Type> (*getResultTypes)(const Concept *impl, ::mlir::Operation *);
182 ::mlir::ArrayAttr (*getArgAttrsAttr)(const Concept *impl, ::mlir::Operation *);
183 ::mlir::ArrayAttr (*getResAttrsAttr)(const Concept *impl, ::mlir::Operation *);
184 void (*setArgAttrsAttr)(const Concept *impl, ::mlir::Operation *, ::mlir::ArrayAttr);
185 void (*setResAttrsAttr)(const Concept *impl, ::mlir::Operation *, ::mlir::ArrayAttr);
186 ::mlir::Attribute (*removeArgAttrsAttr)(const Concept *impl, ::mlir::Operation *);
187 ::mlir::Attribute (*removeResAttrsAttr)(const Concept *impl, ::mlir::Operation *);
188 };
189 template<typename ConcreteOp>
190 class Model : public Concept {
191 public:
192 using Interface = ::mlir::CallableOpInterface;
193 Model() : Concept{.getCallableRegion: getCallableRegion, .getArgumentTypes: getArgumentTypes, .getResultTypes: getResultTypes, .getArgAttrsAttr: getArgAttrsAttr, .getResAttrsAttr: getResAttrsAttr, .setArgAttrsAttr: setArgAttrsAttr, .setResAttrsAttr: setResAttrsAttr, .removeArgAttrsAttr: removeArgAttrsAttr, .removeResAttrsAttr: removeResAttrsAttr} {}
194
195 static inline ::mlir::Region *getCallableRegion(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
196 static inline ::llvm::ArrayRef<::mlir::Type> getArgumentTypes(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
197 static inline ::llvm::ArrayRef<::mlir::Type> getResultTypes(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
198 static inline ::mlir::ArrayAttr getArgAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
199 static inline ::mlir::ArrayAttr getResAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
200 static inline void setArgAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::ArrayAttr attrs);
201 static inline void setResAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::ArrayAttr attrs);
202 static inline ::mlir::Attribute removeArgAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
203 static inline ::mlir::Attribute removeResAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
204 };
205 template<typename ConcreteOp>
206 class FallbackModel : public Concept {
207 public:
208 using Interface = ::mlir::CallableOpInterface;
209 FallbackModel() : Concept{.getCallableRegion: getCallableRegion, .getArgumentTypes: getArgumentTypes, .getResultTypes: getResultTypes, .getArgAttrsAttr: getArgAttrsAttr, .getResAttrsAttr: getResAttrsAttr, .setArgAttrsAttr: setArgAttrsAttr, .setResAttrsAttr: setResAttrsAttr, .removeArgAttrsAttr: removeArgAttrsAttr, .removeResAttrsAttr: removeResAttrsAttr} {}
210
211 static inline ::mlir::Region *getCallableRegion(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
212 static inline ::llvm::ArrayRef<::mlir::Type> getArgumentTypes(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
213 static inline ::llvm::ArrayRef<::mlir::Type> getResultTypes(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
214 static inline ::mlir::ArrayAttr getArgAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
215 static inline ::mlir::ArrayAttr getResAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
216 static inline void setArgAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::ArrayAttr attrs);
217 static inline void setResAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::ArrayAttr attrs);
218 static inline ::mlir::Attribute removeArgAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
219 static inline ::mlir::Attribute removeResAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
220 };
221 template<typename ConcreteModel, typename ConcreteOp>
222 class ExternalModel : public FallbackModel<ConcreteModel> {
223 public:
224 using ConcreteEntity = ConcreteOp;
225 };
226};
227template <typename ConcreteOp>
228struct CallableOpInterfaceTrait;
229
230} // namespace detail
231class CallableOpInterface : public ::mlir::OpInterface<CallableOpInterface, detail::CallableOpInterfaceInterfaceTraits> {
232public:
233 using ::mlir::OpInterface<CallableOpInterface, detail::CallableOpInterfaceInterfaceTraits>::OpInterface;
234 template <typename ConcreteOp>
235 struct Trait : public detail::CallableOpInterfaceTrait<ConcreteOp> {};
236
237 /// Returns the region on the current operation that is callable. This may
238 /// return null in the case of an external callable object, e.g. an external
239 /// function.
240 ::mlir::Region *getCallableRegion();
241
242 /// Returns the callable's argument types based exclusively on the type (to
243 /// allow for this method may be called on function declarations).
244 ::llvm::ArrayRef<::mlir::Type> getArgumentTypes();
245
246 /// Returns the callable's result types based exclusively on the type (to
247 /// allow for this method may be called on function declarations).
248 ::llvm::ArrayRef<::mlir::Type> getResultTypes();
249
250 /// Get the array of argument attribute dictionaries. The method should
251 /// return an array attribute containing only dictionary attributes equal in
252 /// number to the number of arguments. Alternatively, the method can
253 /// return null to indicate that there are no argument attributes.
254 ::mlir::ArrayAttr getArgAttrsAttr();
255
256 /// Get the array of result attribute dictionaries. The method should return
257 /// an array attribute containing only dictionary attributes equal in number
258 /// to the number of results. Alternatively, the method can return
259 /// null to indicate that there are no result attributes.
260 ::mlir::ArrayAttr getResAttrsAttr();
261
262 /// Set the array of argument attribute dictionaries.
263 void setArgAttrsAttr(::mlir::ArrayAttr attrs);
264
265 /// Set the array of result attribute dictionaries.
266 void setResAttrsAttr(::mlir::ArrayAttr attrs);
267
268 /// Remove the array of argument attribute dictionaries. This is the same as
269 /// setting all argument attributes to an empty dictionary. The method should
270 /// return the removed attribute.
271 ::mlir::Attribute removeArgAttrsAttr();
272
273 /// Remove the array of result attribute dictionaries. This is the same as
274 /// setting all result attributes to an empty dictionary. The method should
275 /// return the removed attribute.
276 ::mlir::Attribute removeResAttrsAttr();
277};
278namespace detail {
279 template <typename ConcreteOp>
280 struct CallableOpInterfaceTrait : public ::mlir::OpInterface<CallableOpInterface, detail::CallableOpInterfaceInterfaceTraits>::Trait<ConcreteOp> {
281 };
282}// namespace detail
283} // namespace mlir
284namespace mlir {
285template<typename ConcreteOp>
286::mlir::CallInterfaceCallable detail::CallOpInterfaceInterfaceTraits::Model<ConcreteOp>::getCallableForCallee(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
287 return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).getCallableForCallee();
288}
289template<typename ConcreteOp>
290void detail::CallOpInterfaceInterfaceTraits::Model<ConcreteOp>::setCalleeFromCallable(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::CallInterfaceCallable callee) {
291 return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).setCalleeFromCallable(callee);
292}
293template<typename ConcreteOp>
294::mlir::Operation::operand_range detail::CallOpInterfaceInterfaceTraits::Model<ConcreteOp>::getArgOperands(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
295 return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).getArgOperands();
296}
297template<typename ConcreteOp>
298::mlir::MutableOperandRange detail::CallOpInterfaceInterfaceTraits::Model<ConcreteOp>::getArgOperandsMutable(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
299 return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).getArgOperandsMutable();
300}
301template<typename ConcreteOp>
302::mlir::Operation *detail::CallOpInterfaceInterfaceTraits::Model<ConcreteOp>::resolveCallableInTable(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::SymbolTableCollection * symbolTable) {
303 return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).resolveCallableInTable(symbolTable);
304}
305template<typename ConcreteOp>
306::mlir::Operation *detail::CallOpInterfaceInterfaceTraits::Model<ConcreteOp>::resolveCallable(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
307 return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).resolveCallable();
308}
309template<typename ConcreteOp>
310::mlir::ArrayAttr detail::CallOpInterfaceInterfaceTraits::Model<ConcreteOp>::getArgAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
311 return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).getArgAttrsAttr();
312}
313template<typename ConcreteOp>
314::mlir::ArrayAttr detail::CallOpInterfaceInterfaceTraits::Model<ConcreteOp>::getResAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
315 return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).getResAttrsAttr();
316}
317template<typename ConcreteOp>
318void detail::CallOpInterfaceInterfaceTraits::Model<ConcreteOp>::setArgAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::ArrayAttr attrs) {
319 return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).setArgAttrsAttr(attrs);
320}
321template<typename ConcreteOp>
322void detail::CallOpInterfaceInterfaceTraits::Model<ConcreteOp>::setResAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::ArrayAttr attrs) {
323 return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).setResAttrsAttr(attrs);
324}
325template<typename ConcreteOp>
326::mlir::Attribute detail::CallOpInterfaceInterfaceTraits::Model<ConcreteOp>::removeArgAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
327 return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).removeArgAttrsAttr();
328}
329template<typename ConcreteOp>
330::mlir::Attribute detail::CallOpInterfaceInterfaceTraits::Model<ConcreteOp>::removeResAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
331 return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).removeResAttrsAttr();
332}
333template<typename ConcreteOp>
334::mlir::CallInterfaceCallable detail::CallOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::getCallableForCallee(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
335 return static_cast<const ConcreteOp *>(impl)->getCallableForCallee(tablegen_opaque_val);
336}
337template<typename ConcreteOp>
338void detail::CallOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::setCalleeFromCallable(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::CallInterfaceCallable callee) {
339 return static_cast<const ConcreteOp *>(impl)->setCalleeFromCallable(tablegen_opaque_val, callee);
340}
341template<typename ConcreteOp>
342::mlir::Operation::operand_range detail::CallOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::getArgOperands(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
343 return static_cast<const ConcreteOp *>(impl)->getArgOperands(tablegen_opaque_val);
344}
345template<typename ConcreteOp>
346::mlir::MutableOperandRange detail::CallOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::getArgOperandsMutable(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
347 return static_cast<const ConcreteOp *>(impl)->getArgOperandsMutable(tablegen_opaque_val);
348}
349template<typename ConcreteOp>
350::mlir::Operation *detail::CallOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::resolveCallableInTable(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::SymbolTableCollection * symbolTable) {
351 return static_cast<const ConcreteOp *>(impl)->resolveCallableInTable(tablegen_opaque_val, symbolTable);
352}
353template<typename ConcreteOp>
354::mlir::Operation *detail::CallOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::resolveCallable(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
355 return static_cast<const ConcreteOp *>(impl)->resolveCallable(tablegen_opaque_val);
356}
357template<typename ConcreteOp>
358::mlir::ArrayAttr detail::CallOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::getArgAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
359 return static_cast<const ConcreteOp *>(impl)->getArgAttrsAttr(tablegen_opaque_val);
360}
361template<typename ConcreteOp>
362::mlir::ArrayAttr detail::CallOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::getResAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
363 return static_cast<const ConcreteOp *>(impl)->getResAttrsAttr(tablegen_opaque_val);
364}
365template<typename ConcreteOp>
366void detail::CallOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::setArgAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::ArrayAttr attrs) {
367 return static_cast<const ConcreteOp *>(impl)->setArgAttrsAttr(tablegen_opaque_val, attrs);
368}
369template<typename ConcreteOp>
370void detail::CallOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::setResAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::ArrayAttr attrs) {
371 return static_cast<const ConcreteOp *>(impl)->setResAttrsAttr(tablegen_opaque_val, attrs);
372}
373template<typename ConcreteOp>
374::mlir::Attribute detail::CallOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::removeArgAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
375 return static_cast<const ConcreteOp *>(impl)->removeArgAttrsAttr(tablegen_opaque_val);
376}
377template<typename ConcreteOp>
378::mlir::Attribute detail::CallOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::removeResAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
379 return static_cast<const ConcreteOp *>(impl)->removeResAttrsAttr(tablegen_opaque_val);
380}
381template<typename ConcreteModel, typename ConcreteOp>
382::mlir::Operation *detail::CallOpInterfaceInterfaceTraits::ExternalModel<ConcreteModel, ConcreteOp>::resolveCallableInTable(::mlir::Operation *tablegen_opaque_val, ::mlir::SymbolTableCollection *symbolTable) const {
383return ::mlir::call_interface_impl::resolveCallable(call: (llvm::cast<ConcreteOp>(tablegen_opaque_val)), symbolTable);
384}
385template<typename ConcreteModel, typename ConcreteOp>
386::mlir::Operation *detail::CallOpInterfaceInterfaceTraits::ExternalModel<ConcreteModel, ConcreteOp>::resolveCallable(::mlir::Operation *tablegen_opaque_val) const {
387return ::mlir::call_interface_impl::resolveCallable(call: (llvm::cast<ConcreteOp>(tablegen_opaque_val)));
388}
389} // namespace mlir
390namespace mlir {
391template<typename ConcreteOp>
392::mlir::Region *detail::CallableOpInterfaceInterfaceTraits::Model<ConcreteOp>::getCallableRegion(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
393 return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).getCallableRegion();
394}
395template<typename ConcreteOp>
396::llvm::ArrayRef<::mlir::Type> detail::CallableOpInterfaceInterfaceTraits::Model<ConcreteOp>::getArgumentTypes(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
397 return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).getArgumentTypes();
398}
399template<typename ConcreteOp>
400::llvm::ArrayRef<::mlir::Type> detail::CallableOpInterfaceInterfaceTraits::Model<ConcreteOp>::getResultTypes(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
401 return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).getResultTypes();
402}
403template<typename ConcreteOp>
404::mlir::ArrayAttr detail::CallableOpInterfaceInterfaceTraits::Model<ConcreteOp>::getArgAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
405 return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).getArgAttrsAttr();
406}
407template<typename ConcreteOp>
408::mlir::ArrayAttr detail::CallableOpInterfaceInterfaceTraits::Model<ConcreteOp>::getResAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
409 return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).getResAttrsAttr();
410}
411template<typename ConcreteOp>
412void detail::CallableOpInterfaceInterfaceTraits::Model<ConcreteOp>::setArgAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::ArrayAttr attrs) {
413 return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).setArgAttrsAttr(attrs);
414}
415template<typename ConcreteOp>
416void detail::CallableOpInterfaceInterfaceTraits::Model<ConcreteOp>::setResAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::ArrayAttr attrs) {
417 return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).setResAttrsAttr(attrs);
418}
419template<typename ConcreteOp>
420::mlir::Attribute detail::CallableOpInterfaceInterfaceTraits::Model<ConcreteOp>::removeArgAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
421 return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).removeArgAttrsAttr();
422}
423template<typename ConcreteOp>
424::mlir::Attribute detail::CallableOpInterfaceInterfaceTraits::Model<ConcreteOp>::removeResAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
425 return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).removeResAttrsAttr();
426}
427template<typename ConcreteOp>
428::mlir::Region *detail::CallableOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::getCallableRegion(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
429 return static_cast<const ConcreteOp *>(impl)->getCallableRegion(tablegen_opaque_val);
430}
431template<typename ConcreteOp>
432::llvm::ArrayRef<::mlir::Type> detail::CallableOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::getArgumentTypes(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
433 return static_cast<const ConcreteOp *>(impl)->getArgumentTypes(tablegen_opaque_val);
434}
435template<typename ConcreteOp>
436::llvm::ArrayRef<::mlir::Type> detail::CallableOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::getResultTypes(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
437 return static_cast<const ConcreteOp *>(impl)->getResultTypes(tablegen_opaque_val);
438}
439template<typename ConcreteOp>
440::mlir::ArrayAttr detail::CallableOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::getArgAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
441 return static_cast<const ConcreteOp *>(impl)->getArgAttrsAttr(tablegen_opaque_val);
442}
443template<typename ConcreteOp>
444::mlir::ArrayAttr detail::CallableOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::getResAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
445 return static_cast<const ConcreteOp *>(impl)->getResAttrsAttr(tablegen_opaque_val);
446}
447template<typename ConcreteOp>
448void detail::CallableOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::setArgAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::ArrayAttr attrs) {
449 return static_cast<const ConcreteOp *>(impl)->setArgAttrsAttr(tablegen_opaque_val, attrs);
450}
451template<typename ConcreteOp>
452void detail::CallableOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::setResAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::ArrayAttr attrs) {
453 return static_cast<const ConcreteOp *>(impl)->setResAttrsAttr(tablegen_opaque_val, attrs);
454}
455template<typename ConcreteOp>
456::mlir::Attribute detail::CallableOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::removeArgAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
457 return static_cast<const ConcreteOp *>(impl)->removeArgAttrsAttr(tablegen_opaque_val);
458}
459template<typename ConcreteOp>
460::mlir::Attribute detail::CallableOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::removeResAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
461 return static_cast<const ConcreteOp *>(impl)->removeResAttrsAttr(tablegen_opaque_val);
462}
463} // namespace mlir
464

source code of llvm_build/tools/mlir/include/mlir/Interfaces/CallInterfaces.h.inc