LLZK 3.0.0
An open-source IR for Zero Knowledge (ZK) circuits
Loading...
Searching...
No Matches
OpInterfaces.h.inc
Go to the documentation of this file.
1/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
2|* *|
3|* Interface Declarations *|
4|* *|
5|* Automatically generated file, do not edit! *|
6|* *|
7\*===----------------------------------------------------------------------===*/
8
9namespace llzk {
10namespace verif {
11class ConditionOpInterface;
12namespace detail {
13struct ConditionOpInterfaceInterfaceTraits {
14 struct Concept {
16 ::mlir::TypedValue<::mlir::IntegerType> (*getCondition)(const Concept *impl, ::mlir::Operation *);
18 const ::mlir::MemoryEffectOpInterface::Concept *implMemoryEffectOpInterface = nullptr;
19
20 void initializeInterfaceConcept(::mlir::detail::InterfaceMap &interfaceMap) {
21 implMemoryEffectOpInterface = interfaceMap.lookup<::mlir::MemoryEffectOpInterface>();
22 assert(implMemoryEffectOpInterface && "`::llzk::verif::ConditionOpInterface` expected its base interface `::mlir::MemoryEffectOpInterface` to be registered");
23 }
24 };
25 template<typename ConcreteOp>
26 class Model : public Concept {
27 public:
28 using Interface = ::llzk::verif::ConditionOpInterface;
29 Model() : Concept{getCondition} {}
30
31 static inline ::mlir::TypedValue<::mlir::IntegerType> getCondition(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
32 };
33 template<typename ConcreteOp>
34 class FallbackModel : public Concept {
35 public:
36 using Interface = ::llzk::verif::ConditionOpInterface;
37 FallbackModel() : Concept{getCondition} {}
38
39 static inline ::mlir::TypedValue<::mlir::IntegerType> getCondition(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
40 };
41 template<typename ConcreteModel, typename ConcreteOp>
42 class ExternalModel : public FallbackModel<ConcreteModel> {
43 public:
44 using ConcreteEntity = ConcreteOp;
45 };
46};
47template <typename ConcreteOp>
48struct ConditionOpInterfaceTrait;
49
50} // namespace detail
51class ConditionOpInterface : public ::mlir::OpInterface<ConditionOpInterface, detail::ConditionOpInterfaceInterfaceTraits> {
52public:
53 using ::mlir::OpInterface<ConditionOpInterface, detail::ConditionOpInterfaceInterfaceTraits>::OpInterface;
54 template <typename ConcreteOp>
55 struct Trait : public detail::ConditionOpInterfaceTrait<ConcreteOp> {};
57 ::mlir::TypedValue<::mlir::IntegerType> getCondition();
58 //===----------------------------------------------------------------===//
59 // Inherited from ::mlir::MemoryEffectOpInterface
60 //===----------------------------------------------------------------===//
61
62 operator ::mlir::MemoryEffectOpInterface () const {
63 if (!*this) return nullptr;
64 return ::mlir::MemoryEffectOpInterface(*this, getImpl()->implMemoryEffectOpInterface);
65 }
66
68 void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> & effects);
69};
70namespace detail {
71 template <typename ConcreteOp>
72 struct ConditionOpInterfaceTrait : public ::mlir::OpInterface<ConditionOpInterface, detail::ConditionOpInterfaceInterfaceTraits>::Trait<ConcreteOp> {
73 };
74}// namespace detail
75} // namespace verif
76} // namespace llzk
77namespace llzk {
78namespace verif {
79class PreconditionOpInterface;
80namespace detail {
81struct PreconditionOpInterfaceInterfaceTraits {
82 struct Concept {
85 const ::mlir::MemoryEffectOpInterface::Concept *implMemoryEffectOpInterface = nullptr;
86 const ::llzk::verif::ConditionOpInterface::Concept *implConditionOpInterface = nullptr;
87
88 void initializeInterfaceConcept(::mlir::detail::InterfaceMap &interfaceMap) {
89 implMemoryEffectOpInterface = interfaceMap.lookup<::mlir::MemoryEffectOpInterface>();
90 assert(implMemoryEffectOpInterface && "`::llzk::verif::PreconditionOpInterface` expected its base interface `::mlir::MemoryEffectOpInterface` to be registered");
91 implConditionOpInterface = interfaceMap.lookup<::llzk::verif::ConditionOpInterface>();
92 assert(implConditionOpInterface && "`::llzk::verif::PreconditionOpInterface` expected its base interface `::llzk::verif::ConditionOpInterface` to be registered");
93 }
94 };
95 template<typename ConcreteOp>
96 class Model : public Concept {
97 public:
98 using Interface = ::llzk::verif::PreconditionOpInterface;
99 Model() : Concept{} {}
100
101 };
102 template<typename ConcreteOp>
109 template<typename ConcreteModel, typename ConcreteOp>
110 class ExternalModel : public FallbackModel<ConcreteModel> {
111 public:
112 using ConcreteEntity = ConcreteOp;
113 };
114};
115template <typename ConcreteOp>
116struct PreconditionOpInterfaceTrait;
117
118} // namespace detail
119class PreconditionOpInterface : public ::mlir::OpInterface<PreconditionOpInterface, detail::PreconditionOpInterfaceInterfaceTraits> {
120public:
121 using ::mlir::OpInterface<PreconditionOpInterface, detail::PreconditionOpInterfaceInterfaceTraits>::OpInterface;
122 template <typename ConcreteOp>
123 struct Trait : public detail::PreconditionOpInterfaceTrait<ConcreteOp> {};
124 //===----------------------------------------------------------------===//
125 // Inherited from ::mlir::MemoryEffectOpInterface
126 //===----------------------------------------------------------------===//
127
128 operator ::mlir::MemoryEffectOpInterface () const {
129 if (!*this) return nullptr;
130 return ::mlir::MemoryEffectOpInterface(*this, getImpl()->implMemoryEffectOpInterface);
131 }
132
134 void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> & effects);
135 //===----------------------------------------------------------------===//
136 // Inherited from ::llzk::verif::ConditionOpInterface
137 //===----------------------------------------------------------------===//
138
139 operator ::llzk::verif::ConditionOpInterface () const {
140 if (!*this) return nullptr;
141 return ::llzk::verif::ConditionOpInterface(*this, getImpl()->implConditionOpInterface);
142 }
143
145 ::mlir::TypedValue<::mlir::IntegerType> getCondition();
146};
147namespace detail {
148 template <typename ConcreteOp>
149 struct PreconditionOpInterfaceTrait : public ::mlir::OpInterface<PreconditionOpInterface, detail::PreconditionOpInterfaceInterfaceTraits>::Trait<ConcreteOp> {
150 };
151}// namespace detail
152} // namespace verif
153} // namespace llzk
154namespace llzk {
155namespace verif {
156class PostconditionOpInterface;
157namespace detail {
158struct PostconditionOpInterfaceInterfaceTraits {
159 struct Concept {
162 const ::mlir::MemoryEffectOpInterface::Concept *implMemoryEffectOpInterface = nullptr;
163 const ::llzk::verif::ConditionOpInterface::Concept *implConditionOpInterface = nullptr;
164
165 void initializeInterfaceConcept(::mlir::detail::InterfaceMap &interfaceMap) {
166 implMemoryEffectOpInterface = interfaceMap.lookup<::mlir::MemoryEffectOpInterface>();
167 assert(implMemoryEffectOpInterface && "`::llzk::verif::PostconditionOpInterface` expected its base interface `::mlir::MemoryEffectOpInterface` to be registered");
168 implConditionOpInterface = interfaceMap.lookup<::llzk::verif::ConditionOpInterface>();
169 assert(implConditionOpInterface && "`::llzk::verif::PostconditionOpInterface` expected its base interface `::llzk::verif::ConditionOpInterface` to be registered");
170 }
171 };
172 template<typename ConcreteOp>
173 class Model : public Concept {
174 public:
175 using Interface = ::llzk::verif::PostconditionOpInterface;
176 Model() : Concept{} {}
177
178 };
179 template<typename ConcreteOp>
186 template<typename ConcreteModel, typename ConcreteOp>
187 class ExternalModel : public FallbackModel<ConcreteModel> {
188 public:
189 using ConcreteEntity = ConcreteOp;
190 };
191};
192template <typename ConcreteOp>
193struct PostconditionOpInterfaceTrait;
194
195} // namespace detail
196class PostconditionOpInterface : public ::mlir::OpInterface<PostconditionOpInterface, detail::PostconditionOpInterfaceInterfaceTraits> {
197public:
198 using ::mlir::OpInterface<PostconditionOpInterface, detail::PostconditionOpInterfaceInterfaceTraits>::OpInterface;
199 template <typename ConcreteOp>
200 struct Trait : public detail::PostconditionOpInterfaceTrait<ConcreteOp> {};
201 //===----------------------------------------------------------------===//
202 // Inherited from ::mlir::MemoryEffectOpInterface
203 //===----------------------------------------------------------------===//
204
205 operator ::mlir::MemoryEffectOpInterface () const {
206 if (!*this) return nullptr;
207 return ::mlir::MemoryEffectOpInterface(*this, getImpl()->implMemoryEffectOpInterface);
208 }
209
211 void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> & effects);
212 //===----------------------------------------------------------------===//
213 // Inherited from ::llzk::verif::ConditionOpInterface
214 //===----------------------------------------------------------------===//
215
216 operator ::llzk::verif::ConditionOpInterface () const {
217 if (!*this) return nullptr;
218 return ::llzk::verif::ConditionOpInterface(*this, getImpl()->implConditionOpInterface);
219 }
220
222 ::mlir::TypedValue<::mlir::IntegerType> getCondition();
223};
224namespace detail {
225 template <typename ConcreteOp>
226 struct PostconditionOpInterfaceTrait : public ::mlir::OpInterface<PostconditionOpInterface, detail::PostconditionOpInterfaceInterfaceTraits>::Trait<ConcreteOp> {
227 };
228}// namespace detail
229} // namespace verif
230} // namespace llzk
231namespace llzk {
232namespace verif {
233class InvariantTargetOpInterface;
234namespace detail {
235struct InvariantTargetOpInterfaceInterfaceTraits {
236 struct Concept {
238 ::mlir::FailureOr<::mlir::StringRef> (*getLabel)(const Concept *impl, ::mlir::Operation *);
239 ::mlir::SmallVector<::mlir::Type> (*getArgumentTypes)(const Concept *impl, ::mlir::Operation *);
240 };
241 template<typename ConcreteOp>
242 class Model : public Concept {
243 public:
244 using Interface = ::llzk::verif::InvariantTargetOpInterface;
245 Model() : Concept{getLabel, getArgumentTypes} {}
246
247 static inline ::mlir::FailureOr<::mlir::StringRef> getLabel(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
248 static inline ::mlir::SmallVector<::mlir::Type> getArgumentTypes(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
249 };
250 template<typename ConcreteOp>
251 class FallbackModel : public Concept {
252 public:
253 using Interface = ::llzk::verif::InvariantTargetOpInterface;
254 FallbackModel() : Concept{getLabel, getArgumentTypes} {}
255
256 static inline ::mlir::FailureOr<::mlir::StringRef> getLabel(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
257 static inline ::mlir::SmallVector<::mlir::Type> getArgumentTypes(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
258 };
259 template<typename ConcreteModel, typename ConcreteOp>
260 class ExternalModel : public FallbackModel<ConcreteModel> {
261 public:
262 using ConcreteEntity = ConcreteOp;
263 };
264};
265template <typename ConcreteOp>
266struct InvariantTargetOpInterfaceTrait;
267
268} // namespace detail
269class InvariantTargetOpInterface : public ::mlir::OpInterface<InvariantTargetOpInterface, detail::InvariantTargetOpInterfaceInterfaceTraits> {
270public:
271 using ::mlir::OpInterface<InvariantTargetOpInterface, detail::InvariantTargetOpInterfaceInterfaceTraits>::OpInterface;
272 template <typename ConcreteOp>
273 struct Trait : public detail::InvariantTargetOpInterfaceTrait<ConcreteOp> {};
275 ::mlir::FailureOr<::mlir::StringRef> getLabel();
277 ::mlir::SmallVector<::mlir::Type> getArgumentTypes();
278};
279namespace detail {
280 template <typename ConcreteOp>
281 struct InvariantTargetOpInterfaceTrait : public ::mlir::OpInterface<InvariantTargetOpInterface, detail::InvariantTargetOpInterfaceInterfaceTraits>::Trait<ConcreteOp> {
282 };
283}// namespace detail
284} // namespace verif
285} // namespace llzk
286namespace llzk {
287namespace verif {
288class ContractTargetOpInterface;
289namespace detail {
290struct ContractTargetOpInterfaceInterfaceTraits {
291 struct Concept {
293 ::llvm::SmallVector<::llzk::verif::InvariantTargetOpInterface> (*getLoops)(const Concept *impl, ::mlir::Operation *);
295 const ::mlir::SymbolOpInterface::Concept *implSymbolOpInterface = nullptr;
296
297 void initializeInterfaceConcept(::mlir::detail::InterfaceMap &interfaceMap) {
298 implSymbolOpInterface = interfaceMap.lookup<::mlir::SymbolOpInterface>();
299 assert(implSymbolOpInterface && "`::llzk::verif::ContractTargetOpInterface` expected its base interface `::mlir::SymbolOpInterface` to be registered");
300 }
301 };
302 template<typename ConcreteOp>
303 class Model : public Concept {
304 public:
305 using Interface = ::llzk::verif::ContractTargetOpInterface;
306 Model() : Concept{getLoops} {}
307
308 static inline ::llvm::SmallVector<::llzk::verif::InvariantTargetOpInterface> getLoops(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
309 };
310 template<typename ConcreteOp>
311 class FallbackModel : public Concept {
312 public:
313 using Interface = ::llzk::verif::ContractTargetOpInterface;
314 FallbackModel() : Concept{getLoops} {}
315
316 static inline ::llvm::SmallVector<::llzk::verif::InvariantTargetOpInterface> getLoops(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
317 };
318 template<typename ConcreteModel, typename ConcreteOp>
319 class ExternalModel : public FallbackModel<ConcreteModel> {
320 public:
321 using ConcreteEntity = ConcreteOp;
322 };
323};
324template <typename ConcreteOp>
325struct ContractTargetOpInterfaceTrait;
326
327} // namespace detail
328class ContractTargetOpInterface : public ::mlir::OpInterface<ContractTargetOpInterface, detail::ContractTargetOpInterfaceInterfaceTraits> {
329public:
330 using ::mlir::OpInterface<ContractTargetOpInterface, detail::ContractTargetOpInterfaceInterfaceTraits>::OpInterface;
331 template <typename ConcreteOp>
332 struct Trait : public detail::ContractTargetOpInterfaceTrait<ConcreteOp> {};
334 ::llvm::SmallVector<::llzk::verif::InvariantTargetOpInterface> getLoops();
335
337 static ::mlir::StringLiteral getOperationName() {
338 return ::mlir::StringLiteral("contract target interface implementation");
339 }
340 //===----------------------------------------------------------------===//
341 // Inherited from ::mlir::SymbolOpInterface
342 //===----------------------------------------------------------------===//
343
344 operator ::mlir::SymbolOpInterface () const {
345 if (!*this) return nullptr;
346 return ::mlir::SymbolOpInterface(*this, getImpl()->implSymbolOpInterface);
347 }
348
350 ::mlir::StringAttr getNameAttr();
352 void setName(::mlir::StringAttr name);
354 mlir::SymbolTable::Visibility getVisibility();
356 bool isNested();
358 bool isPrivate();
360 bool isPublic();
362 void setVisibility(mlir::SymbolTable::Visibility vis);
364 void setNested();
366 void setPrivate();
368 void setPublic();
372 ::std::optional<::mlir::SymbolTable::UseRange> getSymbolUses(::mlir::Operation * from);
376 bool symbolKnownUseEmpty(::mlir::Operation * from);
380 ::llvm::LogicalResult replaceAllSymbolUses(::mlir::StringAttr newSymbol, ::mlir::Operation * from);
383 bool isOptionalSymbol();
386 bool canDiscardOnUseEmpty();
389 bool isDeclaration();
390
391 using Visibility = mlir::SymbolTable::Visibility;
392
394 ::mlir::StringRef getName() {
395 return getNameAttr().getValue();
396 }
397
399 void setName(::mlir::StringRef name) {
400 setName(::mlir::StringAttr::get((*this)->getContext(), name));
401 }
402};
403namespace detail {
404 template <typename ConcreteOp>
405 struct ContractTargetOpInterfaceTrait : public ::mlir::OpInterface<ContractTargetOpInterface, detail::ContractTargetOpInterfaceInterfaceTraits>::Trait<ConcreteOp> {
406 };
407}// namespace detail
408} // namespace verif
409} // namespace llzk
410namespace llzk {
411namespace verif {
412template<typename ConcreteOp>
413::mlir::TypedValue<::mlir::IntegerType> detail::ConditionOpInterfaceInterfaceTraits::Model<ConcreteOp>::getCondition(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
414 return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).getCondition();
415}
416template<typename ConcreteOp>
417::mlir::TypedValue<::mlir::IntegerType> detail::ConditionOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::getCondition(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
418 return static_cast<const ConcreteOp *>(impl)->getCondition(tablegen_opaque_val);
419}
420} // namespace verif
421} // namespace llzk
422namespace llzk {
423namespace verif {
424} // namespace verif
425} // namespace llzk
426namespace llzk {
427namespace verif {
428} // namespace verif
429} // namespace llzk
430namespace llzk {
431namespace verif {
432template<typename ConcreteOp>
433::mlir::FailureOr<::mlir::StringRef> detail::InvariantTargetOpInterfaceInterfaceTraits::Model<ConcreteOp>::getLabel(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
434 auto attr = ::mlir::dyn_cast_or_null<::mlir::StringAttr>((llvm::cast<ConcreteOp>(tablegen_opaque_val))->getDiscardableAttr("loop_label"));
435 if (!attr) return ::mlir::failure();
436 return attr.getValue();
437}
438template<typename ConcreteOp>
439::mlir::SmallVector<::mlir::Type> detail::InvariantTargetOpInterfaceInterfaceTraits::Model<ConcreteOp>::getArgumentTypes(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
440 return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).getArgumentTypes();
441}
442template<typename ConcreteOp>
443::mlir::FailureOr<::mlir::StringRef> detail::InvariantTargetOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::getLabel(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
444 return static_cast<const ConcreteOp *>(impl)->getLabel(tablegen_opaque_val);
445}
446template<typename ConcreteOp>
447::mlir::SmallVector<::mlir::Type> detail::InvariantTargetOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::getArgumentTypes(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
448 return static_cast<const ConcreteOp *>(impl)->getArgumentTypes(tablegen_opaque_val);
449}
450} // namespace verif
451} // namespace llzk
452namespace llzk {
453namespace verif {
454template<typename ConcreteOp>
455::llvm::SmallVector<::llzk::verif::InvariantTargetOpInterface> detail::ContractTargetOpInterfaceInterfaceTraits::Model<ConcreteOp>::getLoops(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
456 auto op = (llvm::cast<ConcreteOp>(tablegen_opaque_val)); // walkCollect expects an l-value but the expansion of (llvm::cast<ConcreteOp>(tablegen_opaque_val)) is not.
457 return walkCollect<::llzk::verif::InvariantTargetOpInterface>(op);
458}
459template<typename ConcreteOp>
460::llvm::SmallVector<::llzk::verif::InvariantTargetOpInterface> detail::ContractTargetOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::getLoops(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
461 return static_cast<const ConcreteOp *>(impl)->getLoops(tablegen_opaque_val);
462}
463} // namespace verif
464} // namespace llzk
from
Apache License January AND DISTRIBUTION Definitions License shall mean the terms and conditions for and distribution as defined by Sections through of this document Licensor shall mean the copyright owner or entity authorized by the copyright owner that is granting the License Legal Entity shall mean the union of the acting entity and all other entities that control are controlled by or are under common control with that entity For the purposes of this definition control direct or to cause the direction or management of such whether by contract or including but not limited to software source documentation and configuration files Object form shall mean any form resulting from mechanical transformation or translation of a Source including but not limited to compiled object generated and conversions to other media types Work shall mean the work of whether in Source or Object made available under the as indicated by a copyright notice that is included in or attached to the whether in Source or Object that is based or other modifications as a an original work of authorship For the purposes of this Derivative Works shall not include works that remain separable from
Definition LICENSE.txt:45
llzk::verif::ConditionOpInterface::getEffects
void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect > > &effects)
Collects all of the operation's effects into effects.
Definition OpInterfaces.cpp.inc:14
llzk::verif::ConditionOpInterface::getCondition
::mlir::TypedValue<::mlir::IntegerType > getCondition()
Gets the SSA Value for the condition operand.
Definition OpInterfaces.cpp.inc:10
llzk::verif::ContractTargetOpInterface::isPublic
bool isPublic()
Returns true if this symbol has public visibility.
Definition OpInterfaces.cpp.inc:42
llzk::verif::ContractTargetOpInterface::setPublic
void setPublic()
Sets the visibility of this symbol to be public.
Definition OpInterfaces.cpp.inc:58
llzk::verif::ContractTargetOpInterface::isPrivate
bool isPrivate()
Returns true if this symbol has private visibility.
Definition OpInterfaces.cpp.inc:38
llzk::verif::ContractTargetOpInterface::getNameAttr
::mlir::StringAttr getNameAttr()
Returns the name of this symbol.
Definition OpInterfaces.cpp.inc:22
llzk::verif::ContractTargetOpInterface::setPrivate
void setPrivate()
Sets the visibility of this symbol to be private.
Definition OpInterfaces.cpp.inc:54
llzk::verif::ContractTargetOpInterface::setName
void setName(::mlir::StringAttr name)
Sets the name of this symbol.
Definition OpInterfaces.cpp.inc:26
llzk::verif::ContractTargetOpInterface::isDeclaration
bool isDeclaration()
Returns true if this operation is a declaration of a symbol (as opposed to a definition).
Definition OpInterfaces.cpp.inc:91
llzk::verif::ContractTargetOpInterface::setVisibility
void setVisibility(mlir::SymbolTable::Visibility vis)
Sets the visibility of this symbol.
Definition OpInterfaces.cpp.inc:46
llzk::verif::ContractTargetOpInterface::isNested
bool isNested()
Returns true if this symbol has nested visibility.
Definition OpInterfaces.cpp.inc:34
llzk::verif::ContractTargetOpInterface::getSymbolUses
::std::optional<::mlir::SymbolTable::UseRange > getSymbolUses(::mlir::Operation *from)
Get all of the uses of the current symbol that are nested within the given operation 'from'.
Definition OpInterfaces.cpp.inc:64
llzk::verif::ContractTargetOpInterface::Visibility
mlir::SymbolTable::Visibility Visibility
Definition OpInterfaces.h.inc:391
llzk::verif::ContractTargetOpInterface::setNested
void setNested()
Sets the visibility of this symbol to be nested.
Definition OpInterfaces.cpp.inc:50
llzk::verif::ContractTargetOpInterface::getLoops
::llvm::SmallVector<::llzk::verif::InvariantTargetOpInterface > getLoops()
Gets the ops that can be targeted by invariant ops.
Definition OpInterfaces.cpp.inc:18
llzk::verif::ContractTargetOpInterface::replaceAllSymbolUses
::llvm::LogicalResult replaceAllSymbolUses(::mlir::StringAttr newSymbol, ::mlir::Operation *from)
Attempt to replace all uses of the current symbol with the provided symbol 'newSymbol' that are neste...
Definition OpInterfaces.cpp.inc:76
llzk::verif::ContractTargetOpInterface::getName
::mlir::StringRef getName()
Convenience version of getNameAttr that returns a StringRef.
Definition OpInterfaces.h.inc:394
llzk::verif::ContractTargetOpInterface::symbolKnownUseEmpty
bool symbolKnownUseEmpty(::mlir::Operation *from)
Return if the current symbol is known to have no uses that are nested within the given operation 'fro...
Definition OpInterfaces.cpp.inc:70
llzk::verif::ContractTargetOpInterface::canDiscardOnUseEmpty
bool canDiscardOnUseEmpty()
Returns true if this operation can be discarded if it has no remaining symbol uses.
Definition OpInterfaces.cpp.inc:86
llzk::verif::ContractTargetOpInterface::getOperationName
::mlir::StringLiteral getOperationName()
Emulates the static method with the same name found in operations.
Definition OpInterfaces.h.inc:337
llzk::verif::ContractTargetOpInterface::getVisibility
mlir::SymbolTable::Visibility getVisibility()
Gets the visibility of this symbol.
Definition OpInterfaces.cpp.inc:30
llzk::verif::ContractTargetOpInterface::setName
void setName(::mlir::StringRef name)
Convenience version of setName that take a StringRef.
Definition OpInterfaces.h.inc:399
llzk::verif::ContractTargetOpInterface::isOptionalSymbol
bool isOptionalSymbol()
Returns true if this operation optionally defines a symbol based on the presence of the symbol name.
Definition OpInterfaces.cpp.inc:81
llzk::verif::InvariantTargetOpInterface::getLabel
::mlir::FailureOr<::mlir::StringRef > getLabel()
Gets the label of the loop, if available.
Definition OpInterfaces.cpp.inc:95
llzk::verif::InvariantTargetOpInterface::getArgumentTypes
::mlir::SmallVector<::mlir::Type > getArgumentTypes()
Gets the types of the values that the invariant binds inside its body.
Definition OpInterfaces.cpp.inc:99
llzk::verif::PostconditionOpInterface::getCondition
::mlir::TypedValue<::mlir::IntegerType > getCondition()
Gets the SSA Value for the condition operand.
Definition OpInterfaces.cpp.inc:107
llzk::verif::PostconditionOpInterface::getEffects
void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect > > &effects)
Collects all of the operation's effects into effects.
Definition OpInterfaces.cpp.inc:103
llzk::verif::PreconditionOpInterface::getCondition
::mlir::TypedValue<::mlir::IntegerType > getCondition()
Gets the SSA Value for the condition operand.
Definition OpInterfaces.cpp.inc:115
llzk::verif::PreconditionOpInterface::getEffects
void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect > > &effects)
Collects all of the operation's effects into effects.
Definition OpInterfaces.cpp.inc:111
llzk::verif::detail::ConditionOpInterfaceInterfaceTraits::FallbackModel::getCondition
static inline ::mlir::TypedValue<::mlir::IntegerType > getCondition(const Concept *impl, ::mlir::Operation *tablegen_opaque_val)
Definition OpInterfaces.h.inc:417
llzk::verif::detail::ConditionOpInterfaceInterfaceTraits::Model::getCondition
static inline ::mlir::TypedValue<::mlir::IntegerType > getCondition(const Concept *impl, ::mlir::Operation *tablegen_opaque_val)
Definition OpInterfaces.h.inc:413
llzk::verif::detail::ContractTargetOpInterfaceInterfaceTraits::FallbackModel::getLoops
static inline ::llvm::SmallVector<::llzk::verif::InvariantTargetOpInterface > getLoops(const Concept *impl, ::mlir::Operation *tablegen_opaque_val)
Definition OpInterfaces.h.inc:460
llzk::verif::detail::ContractTargetOpInterfaceInterfaceTraits::Model::getLoops
static inline ::llvm::SmallVector<::llzk::verif::InvariantTargetOpInterface > getLoops(const Concept *impl, ::mlir::Operation *tablegen_opaque_val)
Definition OpInterfaces.h.inc:455
llzk::verif::detail::InvariantTargetOpInterfaceInterfaceTraits::FallbackModel::getLabel
static inline ::mlir::FailureOr<::mlir::StringRef > getLabel(const Concept *impl, ::mlir::Operation *tablegen_opaque_val)
Definition OpInterfaces.h.inc:443
llzk::verif::detail::InvariantTargetOpInterfaceInterfaceTraits::FallbackModel::getArgumentTypes
static inline ::mlir::SmallVector<::mlir::Type > getArgumentTypes(const Concept *impl, ::mlir::Operation *tablegen_opaque_val)
Definition OpInterfaces.h.inc:447
llzk::verif::detail::InvariantTargetOpInterfaceInterfaceTraits::Model::getArgumentTypes
static inline ::mlir::SmallVector<::mlir::Type > getArgumentTypes(const Concept *impl, ::mlir::Operation *tablegen_opaque_val)
Definition OpInterfaces.h.inc:439
llzk::verif::detail::InvariantTargetOpInterfaceInterfaceTraits::Model::getLabel
static inline ::mlir::FailureOr<::mlir::StringRef > getLabel(const Concept *impl, ::mlir::Operation *tablegen_opaque_val)
Definition OpInterfaces.h.inc:433
llzk::verif::detail::ConditionOpInterfaceInterfaceTraits::Concept::implMemoryEffectOpInterface
const ::mlir::MemoryEffectOpInterface::Concept * implMemoryEffectOpInterface
The base classes of this interface.
Definition OpInterfaces.h.inc:18
llzk::verif::detail::ConditionOpInterfaceInterfaceTraits::Concept::initializeInterfaceConcept
void initializeInterfaceConcept(::mlir::detail::InterfaceMap &interfaceMap)
Definition OpInterfaces.h.inc:20
llzk::verif::detail::ConditionOpInterfaceInterfaceTraits::Concept::getCondition
::mlir::TypedValue<::mlir::IntegerType >(* getCondition)(const Concept *impl, ::mlir::Operation *)
The methods defined by the interface.
Definition OpInterfaces.h.inc:16
llzk::verif::detail::ContractTargetOpInterfaceInterfaceTraits::Concept::initializeInterfaceConcept
void initializeInterfaceConcept(::mlir::detail::InterfaceMap &interfaceMap)
Definition OpInterfaces.h.inc:297
llzk::verif::detail::ContractTargetOpInterfaceInterfaceTraits::Concept::getLoops
::llvm::SmallVector<::llzk::verif::InvariantTargetOpInterface >(* getLoops)(const Concept *impl, ::mlir::Operation *)
The methods defined by the interface.
Definition OpInterfaces.h.inc:293
llzk::verif::detail::ContractTargetOpInterfaceInterfaceTraits::Concept::implSymbolOpInterface
const ::mlir::SymbolOpInterface::Concept * implSymbolOpInterface
The base classes of this interface.
Definition OpInterfaces.h.inc:295
llzk::verif::detail::InvariantTargetOpInterfaceInterfaceTraits::Concept::getLabel
::mlir::FailureOr<::mlir::StringRef >(* getLabel)(const Concept *impl, ::mlir::Operation *)
The methods defined by the interface.
Definition OpInterfaces.h.inc:238
llzk::verif::detail::InvariantTargetOpInterfaceInterfaceTraits::Concept::getArgumentTypes
::mlir::SmallVector<::mlir::Type >(* getArgumentTypes)(const Concept *impl, ::mlir::Operation *)
Definition OpInterfaces.h.inc:239
llzk::verif::detail::PostconditionOpInterfaceInterfaceTraits::Concept::implMemoryEffectOpInterface
const ::mlir::MemoryEffectOpInterface::Concept * implMemoryEffectOpInterface
The methods defined by the interface.
Definition OpInterfaces.h.inc:162
llzk::verif::detail::PostconditionOpInterfaceInterfaceTraits::Concept::implConditionOpInterface
const ::llzk::verif::ConditionOpInterface::Concept * implConditionOpInterface
Definition OpInterfaces.h.inc:163
llzk::verif::detail::PostconditionOpInterfaceInterfaceTraits::Concept::initializeInterfaceConcept
void initializeInterfaceConcept(::mlir::detail::InterfaceMap &interfaceMap)
Definition OpInterfaces.h.inc:165
llzk::verif::detail::PreconditionOpInterfaceInterfaceTraits::Concept::implMemoryEffectOpInterface
const ::mlir::MemoryEffectOpInterface::Concept * implMemoryEffectOpInterface
The methods defined by the interface.
Definition OpInterfaces.h.inc:85
llzk::verif::detail::PreconditionOpInterfaceInterfaceTraits::Concept::initializeInterfaceConcept
void initializeInterfaceConcept(::mlir::detail::InterfaceMap &interfaceMap)
Definition OpInterfaces.h.inc:88
llzk::verif::detail::PreconditionOpInterfaceInterfaceTraits::Concept::implConditionOpInterface
const ::llzk::verif::ConditionOpInterface::Concept * implConditionOpInterface
Definition OpInterfaces.h.inc:86