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::verif {
10
15class ConditionOpInterface;
16
17} // namespace llzk::verif
18namespace llzk::verif {
19
21class PreconditionOpInterface;
22
23} // namespace llzk::verif
24namespace llzk::verif {
25
27class PostconditionOpInterface;
28
29} // namespace llzk::verif
30namespace llzk::verif {
31
35class InvariantTargetOpInterface;
36
37} // namespace llzk::verif
38namespace llzk::verif {
39
43class ContractTargetOpInterface;
44
45} // namespace llzk::verif
46namespace llzk::verif {
47
52namespace detail {
53struct ConditionOpInterfaceInterfaceTraits {
54 struct Concept {
56 ::mlir::TypedValue<::mlir::IntegerType> (*getCondition)(const Concept *impl, ::mlir::Operation *);
58 const ::mlir::MemoryEffectOpInterface::Concept *implMemoryEffectOpInterface = nullptr;
59
60 void initializeInterfaceConcept(::mlir::detail::InterfaceMap &interfaceMap) {
61 implMemoryEffectOpInterface = interfaceMap.lookup<::mlir::MemoryEffectOpInterface>();
62 assert(implMemoryEffectOpInterface && "`::llzk::verif::ConditionOpInterface` expected its base interface `::mlir::MemoryEffectOpInterface` to be registered");
63 }
64 };
65 template<typename ConcreteOp>
66 class Model : public Concept {
67 public:
68 using Interface = ::llzk::verif::ConditionOpInterface;
69 Model() : Concept{getCondition} {}
70
71 static inline ::mlir::TypedValue<::mlir::IntegerType> getCondition(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
72 };
73 template<typename ConcreteOp>
74 class FallbackModel : public Concept {
75 public:
76 using Interface = ::llzk::verif::ConditionOpInterface;
77 FallbackModel() : Concept{getCondition} {}
78
79 static inline ::mlir::TypedValue<::mlir::IntegerType> getCondition(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
80 };
81 template<typename ConcreteModel, typename ConcreteOp>
82 class ExternalModel : public FallbackModel<ConcreteModel> {
83 public:
84 using ConcreteEntity = ConcreteOp;
85 };
86};
87template <typename ConcreteOp>
88struct ConditionOpInterfaceTrait;
89
90} // namespace detail
91class ConditionOpInterface : public ::mlir::OpInterface<ConditionOpInterface, detail::ConditionOpInterfaceInterfaceTraits> {
92public:
93 using ::mlir::OpInterface<ConditionOpInterface, detail::ConditionOpInterfaceInterfaceTraits>::OpInterface;
94 template <typename ConcreteOp>
95 struct Trait : public detail::ConditionOpInterfaceTrait<ConcreteOp> {};
96
98 ::mlir::TypedValue<::mlir::IntegerType> getCondition();
99 //===----------------------------------------------------------------===//
100 // Inherited from ::mlir::MemoryEffectOpInterface
101 //===----------------------------------------------------------------===//
102
103 operator ::mlir::MemoryEffectOpInterface () const {
104 if (!*this) return nullptr;
105 return ::mlir::MemoryEffectOpInterface(*this, getImpl()->implMemoryEffectOpInterface);
106 }
107
108
110 void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> & effects);
111};
112
113} // namespace llzk::verif
114namespace llzk::verif {
115
117namespace detail {
118struct PreconditionOpInterfaceInterfaceTraits {
119 struct Concept {
122 const ::mlir::MemoryEffectOpInterface::Concept *implMemoryEffectOpInterface = nullptr;
123 const ::llzk::verif::ConditionOpInterface::Concept *implConditionOpInterface = nullptr;
124
125 void initializeInterfaceConcept(::mlir::detail::InterfaceMap &interfaceMap) {
126 implMemoryEffectOpInterface = interfaceMap.lookup<::mlir::MemoryEffectOpInterface>();
127 assert(implMemoryEffectOpInterface && "`::llzk::verif::PreconditionOpInterface` expected its base interface `::mlir::MemoryEffectOpInterface` to be registered");
128 implConditionOpInterface = interfaceMap.lookup<::llzk::verif::ConditionOpInterface>();
129 assert(implConditionOpInterface && "`::llzk::verif::PreconditionOpInterface` expected its base interface `::llzk::verif::ConditionOpInterface` to be registered");
130 }
131 };
132 template<typename ConcreteOp>
133 class Model : public Concept {
134 public:
135 using Interface = ::llzk::verif::PreconditionOpInterface;
136 Model() : Concept{} {}
137
138 };
139 template<typename ConcreteOp>
146 template<typename ConcreteModel, typename ConcreteOp>
147 class ExternalModel : public FallbackModel<ConcreteModel> {
148 public:
149 using ConcreteEntity = ConcreteOp;
150 };
151};
152template <typename ConcreteOp>
153struct PreconditionOpInterfaceTrait;
154
155} // namespace detail
156class PreconditionOpInterface : public ::mlir::OpInterface<PreconditionOpInterface, detail::PreconditionOpInterfaceInterfaceTraits> {
157public:
158 using ::mlir::OpInterface<PreconditionOpInterface, detail::PreconditionOpInterfaceInterfaceTraits>::OpInterface;
159 template <typename ConcreteOp>
160 struct Trait : public detail::PreconditionOpInterfaceTrait<ConcreteOp> {};
161 //===----------------------------------------------------------------===//
162 // Inherited from ::mlir::MemoryEffectOpInterface
163 //===----------------------------------------------------------------===//
164
165 operator ::mlir::MemoryEffectOpInterface () const {
166 if (!*this) return nullptr;
167 return ::mlir::MemoryEffectOpInterface(*this, getImpl()->implMemoryEffectOpInterface);
168 }
169
170
172 void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> & effects);
173 //===----------------------------------------------------------------===//
174 // Inherited from ::llzk::verif::ConditionOpInterface
175 //===----------------------------------------------------------------===//
176
177 operator ::llzk::verif::ConditionOpInterface () const {
178 if (!*this) return nullptr;
179 return ::llzk::verif::ConditionOpInterface(*this, getImpl()->implConditionOpInterface);
180 }
181
182
184 ::mlir::TypedValue<::mlir::IntegerType> getCondition();
185};
186
187} // namespace llzk::verif
188namespace llzk::verif {
189
191namespace detail {
192struct PostconditionOpInterfaceInterfaceTraits {
193 struct Concept {
196 const ::mlir::MemoryEffectOpInterface::Concept *implMemoryEffectOpInterface = nullptr;
197 const ::llzk::verif::ConditionOpInterface::Concept *implConditionOpInterface = nullptr;
198
199 void initializeInterfaceConcept(::mlir::detail::InterfaceMap &interfaceMap) {
200 implMemoryEffectOpInterface = interfaceMap.lookup<::mlir::MemoryEffectOpInterface>();
201 assert(implMemoryEffectOpInterface && "`::llzk::verif::PostconditionOpInterface` expected its base interface `::mlir::MemoryEffectOpInterface` to be registered");
202 implConditionOpInterface = interfaceMap.lookup<::llzk::verif::ConditionOpInterface>();
203 assert(implConditionOpInterface && "`::llzk::verif::PostconditionOpInterface` expected its base interface `::llzk::verif::ConditionOpInterface` to be registered");
204 }
205 };
206 template<typename ConcreteOp>
207 class Model : public Concept {
208 public:
209 using Interface = ::llzk::verif::PostconditionOpInterface;
210 Model() : Concept{} {}
211
212 };
213 template<typename ConcreteOp>
220 template<typename ConcreteModel, typename ConcreteOp>
221 class ExternalModel : public FallbackModel<ConcreteModel> {
222 public:
223 using ConcreteEntity = ConcreteOp;
224 };
225};
226template <typename ConcreteOp>
227struct PostconditionOpInterfaceTrait;
228
229} // namespace detail
230class PostconditionOpInterface : public ::mlir::OpInterface<PostconditionOpInterface, detail::PostconditionOpInterfaceInterfaceTraits> {
231public:
232 using ::mlir::OpInterface<PostconditionOpInterface, detail::PostconditionOpInterfaceInterfaceTraits>::OpInterface;
233 template <typename ConcreteOp>
234 struct Trait : public detail::PostconditionOpInterfaceTrait<ConcreteOp> {};
235 //===----------------------------------------------------------------===//
236 // Inherited from ::mlir::MemoryEffectOpInterface
237 //===----------------------------------------------------------------===//
238
239 operator ::mlir::MemoryEffectOpInterface () const {
240 if (!*this) return nullptr;
241 return ::mlir::MemoryEffectOpInterface(*this, getImpl()->implMemoryEffectOpInterface);
242 }
243
244
246 void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> & effects);
247 //===----------------------------------------------------------------===//
248 // Inherited from ::llzk::verif::ConditionOpInterface
249 //===----------------------------------------------------------------===//
250
251 operator ::llzk::verif::ConditionOpInterface () const {
252 if (!*this) return nullptr;
253 return ::llzk::verif::ConditionOpInterface(*this, getImpl()->implConditionOpInterface);
254 }
255
256
258 ::mlir::TypedValue<::mlir::IntegerType> getCondition();
259};
260
261} // namespace llzk::verif
262namespace llzk::verif {
263
267namespace detail {
268struct InvariantTargetOpInterfaceInterfaceTraits {
269 struct Concept {
271 ::mlir::FailureOr<::mlir::StringRef> (*getLabel)(const Concept *impl, ::mlir::Operation *);
272 ::mlir::SmallVector<::mlir::Type> (*getArgumentTypes)(const Concept *impl, ::mlir::Operation *);
273 };
274 template<typename ConcreteOp>
275 class Model : public Concept {
276 public:
277 using Interface = ::llzk::verif::InvariantTargetOpInterface;
278 Model() : Concept{getLabel, getArgumentTypes} {}
279
280 static inline ::mlir::FailureOr<::mlir::StringRef> getLabel(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
281 static inline ::mlir::SmallVector<::mlir::Type> getArgumentTypes(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
282 };
283 template<typename ConcreteOp>
284 class FallbackModel : public Concept {
285 public:
286 using Interface = ::llzk::verif::InvariantTargetOpInterface;
287 FallbackModel() : Concept{getLabel, getArgumentTypes} {}
288
289 static inline ::mlir::FailureOr<::mlir::StringRef> getLabel(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
290 static inline ::mlir::SmallVector<::mlir::Type> getArgumentTypes(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
291 };
292 template<typename ConcreteModel, typename ConcreteOp>
293 class ExternalModel : public FallbackModel<ConcreteModel> {
294 public:
295 using ConcreteEntity = ConcreteOp;
296 };
297};
298template <typename ConcreteOp>
299struct InvariantTargetOpInterfaceTrait;
300
301} // namespace detail
302class InvariantTargetOpInterface : public ::mlir::OpInterface<InvariantTargetOpInterface, detail::InvariantTargetOpInterfaceInterfaceTraits> {
303public:
304 using ::mlir::OpInterface<InvariantTargetOpInterface, detail::InvariantTargetOpInterfaceInterfaceTraits>::OpInterface;
305 template <typename ConcreteOp>
306 struct Trait : public detail::InvariantTargetOpInterfaceTrait<ConcreteOp> {};
307
309 ::mlir::FailureOr<::mlir::StringRef> getLabel();
310
312 ::mlir::SmallVector<::mlir::Type> getArgumentTypes();
313};
314
315} // namespace llzk::verif
316namespace llzk::verif {
317
321namespace detail {
322struct ContractTargetOpInterfaceInterfaceTraits {
323 struct Concept {
325 ::llvm::SmallVector<::llzk::verif::InvariantTargetOpInterface> (*getLoops)(const Concept *impl, ::mlir::Operation *);
327 const ::mlir::SymbolOpInterface::Concept *implSymbolOpInterface = nullptr;
328
329 void initializeInterfaceConcept(::mlir::detail::InterfaceMap &interfaceMap) {
330 implSymbolOpInterface = interfaceMap.lookup<::mlir::SymbolOpInterface>();
331 assert(implSymbolOpInterface && "`::llzk::verif::ContractTargetOpInterface` expected its base interface `::mlir::SymbolOpInterface` to be registered");
332 }
333 };
334 template<typename ConcreteOp>
335 class Model : public Concept {
336 public:
337 using Interface = ::llzk::verif::ContractTargetOpInterface;
338 Model() : Concept{getLoops} {}
339
340 static inline ::llvm::SmallVector<::llzk::verif::InvariantTargetOpInterface> getLoops(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
341 };
342 template<typename ConcreteOp>
343 class FallbackModel : public Concept {
344 public:
345 using Interface = ::llzk::verif::ContractTargetOpInterface;
346 FallbackModel() : Concept{getLoops} {}
347
348 static inline ::llvm::SmallVector<::llzk::verif::InvariantTargetOpInterface> getLoops(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
349 };
350 template<typename ConcreteModel, typename ConcreteOp>
351 class ExternalModel : public FallbackModel<ConcreteModel> {
352 public:
353 using ConcreteEntity = ConcreteOp;
354 };
355};
356template <typename ConcreteOp>
357struct ContractTargetOpInterfaceTrait;
358
359} // namespace detail
360class ContractTargetOpInterface : public ::mlir::OpInterface<ContractTargetOpInterface, detail::ContractTargetOpInterfaceInterfaceTraits> {
361public:
362 using ::mlir::OpInterface<ContractTargetOpInterface, detail::ContractTargetOpInterfaceInterfaceTraits>::OpInterface;
363 template <typename ConcreteOp>
364 struct Trait : public detail::ContractTargetOpInterfaceTrait<ConcreteOp> {};
365
367 ::llvm::SmallVector<::llzk::verif::InvariantTargetOpInterface> getLoops();
368
370 static ::mlir::StringLiteral getOperationName() {
371 return ::mlir::StringLiteral("contract target interface implementation");
372 }
373 //===----------------------------------------------------------------===//
374 // Inherited from ::mlir::SymbolOpInterface
375 //===----------------------------------------------------------------===//
376
377 operator ::mlir::SymbolOpInterface () const {
378 if (!*this) return nullptr;
379 return ::mlir::SymbolOpInterface(*this, getImpl()->implSymbolOpInterface);
380 }
381
382
384 ::mlir::StringAttr getNameAttr();
385
387 void setName(::mlir::StringAttr name);
388
390 mlir::SymbolTable::Visibility getVisibility();
391
393 bool isNested();
394
396 bool isPrivate();
397
399 bool isPublic();
400
402 void setVisibility(mlir::SymbolTable::Visibility vis);
403
405 void setNested();
406
408 void setPrivate();
409
411 void setPublic();
412
416 ::std::optional<::mlir::SymbolTable::UseRange> getSymbolUses(::mlir::Operation * from);
417
421 bool symbolKnownUseEmpty(::mlir::Operation * from);
422
426 ::llvm::LogicalResult replaceAllSymbolUses(::mlir::StringAttr newSymbol, ::mlir::Operation * from);
427
430 bool isOptionalSymbol();
431
434 bool canDiscardOnUseEmpty();
435
438 bool isDeclaration();
439
440 using Visibility = mlir::SymbolTable::Visibility;
441
443 ::mlir::StringRef getName() {
444 return getNameAttr().getValue();
445 }
446
448 void setName(::mlir::StringRef name) {
449 setName(::mlir::StringAttr::get((*this)->getContext(), name));
450 }
451};
452
453} // namespace llzk::verif
454namespace llzk::verif::detail {
455
456 template <typename ConcreteOp>
457 struct ConditionOpInterfaceTrait : public ::mlir::OpInterface<ConditionOpInterface, detail::ConditionOpInterfaceInterfaceTraits>::Trait<ConcreteOp> {
458 };
459
460} // namespace llzk::verif::detail
461namespace llzk::verif::detail {
462
463 template <typename ConcreteOp>
464 struct PreconditionOpInterfaceTrait : public ::mlir::OpInterface<PreconditionOpInterface, detail::PreconditionOpInterfaceInterfaceTraits>::Trait<ConcreteOp> {
465 };
466
467} // namespace llzk::verif::detail
468namespace llzk::verif::detail {
469
470 template <typename ConcreteOp>
471 struct PostconditionOpInterfaceTrait : public ::mlir::OpInterface<PostconditionOpInterface, detail::PostconditionOpInterfaceInterfaceTraits>::Trait<ConcreteOp> {
472 };
473
474} // namespace llzk::verif::detail
475namespace llzk::verif::detail {
476
477 template <typename ConcreteOp>
478 struct InvariantTargetOpInterfaceTrait : public ::mlir::OpInterface<InvariantTargetOpInterface, detail::InvariantTargetOpInterfaceInterfaceTraits>::Trait<ConcreteOp> {
479 };
480
481} // namespace llzk::verif::detail
482namespace llzk::verif::detail {
483
484 template <typename ConcreteOp>
485 struct ContractTargetOpInterfaceTrait : public ::mlir::OpInterface<ContractTargetOpInterface, detail::ContractTargetOpInterfaceInterfaceTraits>::Trait<ConcreteOp> {
486 };
487
488} // namespace llzk::verif::detail
489namespace llzk::verif {
490
491template<typename ConcreteOp>
492::mlir::TypedValue<::mlir::IntegerType> detail::ConditionOpInterfaceInterfaceTraits::Model<ConcreteOp>::getCondition(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
493 return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).getCondition();
494}
495template<typename ConcreteOp>
496::mlir::TypedValue<::mlir::IntegerType> detail::ConditionOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::getCondition(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
497 return static_cast<const ConcreteOp *>(impl)->getCondition(tablegen_opaque_val);
498}
499
500} // namespace llzk::verif
501namespace llzk::verif {
502
503
504} // namespace llzk::verif
505namespace llzk::verif {
506
507
508} // namespace llzk::verif
509namespace llzk::verif {
510
511template<typename ConcreteOp>
512::mlir::FailureOr<::mlir::StringRef> detail::InvariantTargetOpInterfaceInterfaceTraits::Model<ConcreteOp>::getLabel(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
513 auto attr = ::llvm::dyn_cast_or_null<::mlir::StringAttr>((llvm::cast<ConcreteOp>(tablegen_opaque_val))->getDiscardableAttr("loop_label"));
514 if (!attr) return ::mlir::failure();
515 return attr.getValue();
516}
517template<typename ConcreteOp>
518::mlir::SmallVector<::mlir::Type> detail::InvariantTargetOpInterfaceInterfaceTraits::Model<ConcreteOp>::getArgumentTypes(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
519 return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).getArgumentTypes();
520}
521template<typename ConcreteOp>
522::mlir::FailureOr<::mlir::StringRef> detail::InvariantTargetOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::getLabel(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
523 return static_cast<const ConcreteOp *>(impl)->getLabel(tablegen_opaque_val);
524}
525template<typename ConcreteOp>
526::mlir::SmallVector<::mlir::Type> detail::InvariantTargetOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::getArgumentTypes(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
527 return static_cast<const ConcreteOp *>(impl)->getArgumentTypes(tablegen_opaque_val);
528}
529
530} // namespace llzk::verif
531namespace llzk::verif {
532
533template<typename ConcreteOp>
534::llvm::SmallVector<::llzk::verif::InvariantTargetOpInterface> detail::ContractTargetOpInterfaceInterfaceTraits::Model<ConcreteOp>::getLoops(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
535 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.
536 return walkCollect<::llzk::verif::InvariantTargetOpInterface>(op);
537}
538template<typename ConcreteOp>
539::llvm::SmallVector<::llzk::verif::InvariantTargetOpInterface> detail::ContractTargetOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::getLoops(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
540 return static_cast<const ConcreteOp *>(impl)->getLoops(tablegen_opaque_val);
541}
542
543} // namespace llzk::verif
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:16
llzk::verif::ConditionOpInterface::getCondition
::mlir::TypedValue<::mlir::IntegerType > getCondition()
Gets the SSA Value for the condition operand.
Definition OpInterfaces.cpp.inc:11
llzk::verif::ContractTargetOpInterface::isPublic
bool isPublic()
Returns true if this symbol has public visibility.
Definition OpInterfaces.cpp.inc:51
llzk::verif::ContractTargetOpInterface::setPublic
void setPublic()
Sets the visibility of this symbol to be public.
Definition OpInterfaces.cpp.inc:71
llzk::verif::ContractTargetOpInterface::isPrivate
bool isPrivate()
Returns true if this symbol has private visibility.
Definition OpInterfaces.cpp.inc:46
llzk::verif::ContractTargetOpInterface::getNameAttr
::mlir::StringAttr getNameAttr()
Returns the name of this symbol.
Definition OpInterfaces.cpp.inc:26
llzk::verif::ContractTargetOpInterface::setPrivate
void setPrivate()
Sets the visibility of this symbol to be private.
Definition OpInterfaces.cpp.inc:66
llzk::verif::ContractTargetOpInterface::setName
void setName(::mlir::StringAttr name)
Sets the name of this symbol.
Definition OpInterfaces.cpp.inc:31
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:110
llzk::verif::ContractTargetOpInterface::setVisibility
void setVisibility(mlir::SymbolTable::Visibility vis)
Sets the visibility of this symbol.
Definition OpInterfaces.cpp.inc:56
llzk::verif::ContractTargetOpInterface::isNested
bool isNested()
Returns true if this symbol has nested visibility.
Definition OpInterfaces.cpp.inc:41
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:78
llzk::verif::ContractTargetOpInterface::Visibility
mlir::SymbolTable::Visibility Visibility
Definition OpInterfaces.h.inc:440
llzk::verif::ContractTargetOpInterface::setNested
void setNested()
Sets the visibility of this symbol to be nested.
Definition OpInterfaces.cpp.inc:61
llzk::verif::ContractTargetOpInterface::getLoops
::llvm::SmallVector<::llzk::verif::InvariantTargetOpInterface > getLoops()
Gets the ops that can be targeted by invariant ops.
Definition OpInterfaces.cpp.inc:21
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:92
llzk::verif::ContractTargetOpInterface::getName
::mlir::StringRef getName()
Convenience version of getNameAttr that returns a StringRef.
Definition OpInterfaces.h.inc:443
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:85
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:104
llzk::verif::ContractTargetOpInterface::getOperationName
::mlir::StringLiteral getOperationName()
Emulates the static method with the same name found in operations.
Definition OpInterfaces.h.inc:370
llzk::verif::ContractTargetOpInterface::getVisibility
mlir::SymbolTable::Visibility getVisibility()
Gets the visibility of this symbol.
Definition OpInterfaces.cpp.inc:36
llzk::verif::ContractTargetOpInterface::setName
void setName(::mlir::StringRef name)
Convenience version of setName that take a StringRef.
Definition OpInterfaces.h.inc:448
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:98
llzk::verif::InvariantTargetOpInterface::getLabel
::mlir::FailureOr<::mlir::StringRef > getLabel()
Gets the label of the loop, if available.
Definition OpInterfaces.cpp.inc:115
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:120
llzk::verif::PostconditionOpInterface::getCondition
::mlir::TypedValue<::mlir::IntegerType > getCondition()
Gets the SSA Value for the condition operand.
Definition OpInterfaces.cpp.inc:130
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:125
llzk::verif::PreconditionOpInterface::getCondition
::mlir::TypedValue<::mlir::IntegerType > getCondition()
Gets the SSA Value for the condition operand.
Definition OpInterfaces.cpp.inc:140
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:135
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:496
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:492
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:539
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:534
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:522
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:526
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:518
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:512
llzk::verif::detail
Common interface for precondition and postcondition operations.
Definition OpInterfaces.h.inc:52
llzk::verif::detail::ConditionOpInterfaceInterfaceTraits::Concept::implMemoryEffectOpInterface
const ::mlir::MemoryEffectOpInterface::Concept * implMemoryEffectOpInterface
The base classes of this interface.
Definition OpInterfaces.h.inc:58
llzk::verif::detail::ConditionOpInterfaceInterfaceTraits::Concept::initializeInterfaceConcept
void initializeInterfaceConcept(::mlir::detail::InterfaceMap &interfaceMap)
Definition OpInterfaces.h.inc:60
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:56
llzk::verif::detail::ContractTargetOpInterfaceInterfaceTraits::Concept::initializeInterfaceConcept
void initializeInterfaceConcept(::mlir::detail::InterfaceMap &interfaceMap)
Definition OpInterfaces.h.inc:329
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:325
llzk::verif::detail::ContractTargetOpInterfaceInterfaceTraits::Concept::implSymbolOpInterface
const ::mlir::SymbolOpInterface::Concept * implSymbolOpInterface
The base classes of this interface.
Definition OpInterfaces.h.inc:327
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:271
llzk::verif::detail::InvariantTargetOpInterfaceInterfaceTraits::Concept::getArgumentTypes
::mlir::SmallVector<::mlir::Type >(* getArgumentTypes)(const Concept *impl, ::mlir::Operation *)
Definition OpInterfaces.h.inc:272
llzk::verif::detail::PostconditionOpInterfaceInterfaceTraits::Concept::implMemoryEffectOpInterface
const ::mlir::MemoryEffectOpInterface::Concept * implMemoryEffectOpInterface
The methods defined by the interface.
Definition OpInterfaces.h.inc:196
llzk::verif::detail::PostconditionOpInterfaceInterfaceTraits::Concept::implConditionOpInterface
const ::llzk::verif::ConditionOpInterface::Concept * implConditionOpInterface
Definition OpInterfaces.h.inc:197
llzk::verif::detail::PostconditionOpInterfaceInterfaceTraits::Concept::initializeInterfaceConcept
void initializeInterfaceConcept(::mlir::detail::InterfaceMap &interfaceMap)
Definition OpInterfaces.h.inc:199
llzk::verif::detail::PreconditionOpInterfaceInterfaceTraits::Concept::implMemoryEffectOpInterface
const ::mlir::MemoryEffectOpInterface::Concept * implMemoryEffectOpInterface
The methods defined by the interface.
Definition OpInterfaces.h.inc:122
llzk::verif::detail::PreconditionOpInterfaceInterfaceTraits::Concept::initializeInterfaceConcept
void initializeInterfaceConcept(::mlir::detail::InterfaceMap &interfaceMap)
Definition OpInterfaces.h.inc:125
llzk::verif::detail::PreconditionOpInterfaceInterfaceTraits::Concept::implConditionOpInterface
const ::llzk::verif::ConditionOpInterface::Concept * implConditionOpInterface
Definition OpInterfaces.h.inc:123