LLZK 0.1.0
Veridise's ZK Language IR
Loading...
Searching...
No Matches
LLZKTransformationPasses.h.inc
Go to the documentation of this file.
1/* Autogenerated by mlir-tblgen; don't manually edit */
2
3#ifdef GEN_PASS_DECL
4// Generate declarations for all passes.
5#define GEN_PASS_DECL_COMPUTECONSTRAINTOPRODUCTPASS
6#define GEN_PASS_DECL_INLINESTRUCTSPASS
7#define GEN_PASS_DECL_PCLLOWERINGPASS
8#define GEN_PASS_DECL_POLYLOWERINGPASS
9#define GEN_PASS_DECL_R1CSLOWERINGPASS
10#define GEN_PASS_DECL_REDUNDANTOPERATIONELIMINATIONPASS
11#define GEN_PASS_DECL_REDUNDANTREADANDWRITEELIMINATIONPASS
12#define GEN_PASS_DECL_UNUSEDDECLARATIONELIMINATIONPASS
13#undef GEN_PASS_DECL
14#endif // GEN_PASS_DECL
15
16//===----------------------------------------------------------------------===//
17// ComputeConstrainToProductPass
18//===----------------------------------------------------------------------===//
19#ifdef GEN_PASS_DECL_COMPUTECONSTRAINTOPRODUCTPASS
20struct ComputeConstrainToProductPassOptions {
21 std::string rootStruct = "@Main";
22};
23#undef GEN_PASS_DECL_COMPUTECONSTRAINTOPRODUCTPASS
24#endif // GEN_PASS_DECL_COMPUTECONSTRAINTOPRODUCTPASS
25#ifdef GEN_PASS_DEF_COMPUTECONSTRAINTOPRODUCTPASS
26namespace impl {
27
28template <typename DerivedT>
29class ComputeConstrainToProductPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
30public:
31 using Base = ComputeConstrainToProductPassBase;
32
33 ComputeConstrainToProductPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
34 ComputeConstrainToProductPassBase(const ComputeConstrainToProductPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
35 ComputeConstrainToProductPassBase& operator=(const ComputeConstrainToProductPassBase &) = delete;
36 ComputeConstrainToProductPassBase(ComputeConstrainToProductPassBase &&) = delete;
37 ComputeConstrainToProductPassBase& operator=(ComputeConstrainToProductPassBase &&) = delete;
38 ~ComputeConstrainToProductPassBase() = default;
39
41 static constexpr ::llvm::StringLiteral getArgumentName() {
42 return ::llvm::StringLiteral("llzk-compute-constrain-to-product");
43 }
44 ::llvm::StringRef getArgument() const override { return "llzk-compute-constrain-to-product"; }
45
46 ::llvm::StringRef getDescription() const override { return "Replaces separate @compute and @constrain functions in a struct with a single @product function"; }
47
49 static constexpr ::llvm::StringLiteral getPassName() {
50 return ::llvm::StringLiteral("ComputeConstrainToProductPass");
51 }
52 ::llvm::StringRef getName() const override { return "ComputeConstrainToProductPass"; }
53
55 static bool classof(const ::mlir::Pass *pass) {
56 return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
57 }
58
60 std::unique_ptr<::mlir::Pass> clonePass() const override {
61 return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
62 }
63
65 void getDependentDialects(::mlir::DialectRegistry &registry) const override {
66 registry.insert<llzk::LLZKDialect>();
67 registry.insert<llzk::boolean::BoolDialect>();
68 registry.insert<llzk::array::ArrayDialect>();
69 registry.insert<llzk::component::StructDialect>();
70 registry.insert<llzk::constrain::ConstrainDialect>();
71 registry.insert<llzk::felt::FeltDialect>();
72 registry.insert<llzk::global::GlobalDialect>();
73 registry.insert<llzk::include::IncludeDialect>();
74 registry.insert<llzk::function::FunctionDialect>();
75 registry.insert<llzk::string::StringDialect>();
76 registry.insert<llzk::polymorphic::PolymorphicDialect>();
77 registry.insert<llzk::undef::UndefDialect>();
78 registry.insert<mlir::arith::ArithDialect>();
79 registry.insert<mlir::scf::SCFDialect>();
80 }
81
85 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(ComputeConstrainToProductPassBase<DerivedT>)
86
87 ComputeConstrainToProductPassBase(ComputeConstrainToProductPassOptions options) : ComputeConstrainToProductPassBase() {
88 rootStruct = std::move(options.rootStruct);
89 }
90protected:
91 ::mlir::Pass::Option<std::string> rootStruct{*this, "root-struct", ::llvm::cl::desc("Root struct at which to start alignment (default to `@Main`)"), ::llvm::cl::init("@Main")};
92private:
93};
94} // namespace impl
95#undef GEN_PASS_DEF_COMPUTECONSTRAINTOPRODUCTPASS
96#endif // GEN_PASS_DEF_COMPUTECONSTRAINTOPRODUCTPASS
97
98//===----------------------------------------------------------------------===//
99// InlineStructsPass
100//===----------------------------------------------------------------------===//
101#ifdef GEN_PASS_DECL_INLINESTRUCTSPASS
102struct InlineStructsPassOptions {
103 uint64_t maxComplexity = 0;
104};
105#undef GEN_PASS_DECL_INLINESTRUCTSPASS
106#endif // GEN_PASS_DECL_INLINESTRUCTSPASS
107#ifdef GEN_PASS_DEF_INLINESTRUCTSPASS
108namespace impl {
109
110template <typename DerivedT>
111class InlineStructsPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
112public:
113 using Base = InlineStructsPassBase;
114
115 InlineStructsPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
116 InlineStructsPassBase(const InlineStructsPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
117 InlineStructsPassBase& operator=(const InlineStructsPassBase &) = delete;
118 InlineStructsPassBase(InlineStructsPassBase &&) = delete;
119 InlineStructsPassBase& operator=(InlineStructsPassBase &&) = delete;
120 ~InlineStructsPassBase() = default;
121
123 static constexpr ::llvm::StringLiteral getArgumentName() {
124 return ::llvm::StringLiteral("llzk-inline-structs");
125 }
126 ::llvm::StringRef getArgument() const override { return "llzk-inline-structs"; }
127
128 ::llvm::StringRef getDescription() const override { return "Inlines nested structs (i.e., subcomponents)."; }
129
131 static constexpr ::llvm::StringLiteral getPassName() {
132 return ::llvm::StringLiteral("InlineStructsPass");
133 }
134 ::llvm::StringRef getName() const override { return "InlineStructsPass"; }
135
137 static bool classof(const ::mlir::Pass *pass) {
138 return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
139 }
140
142 std::unique_ptr<::mlir::Pass> clonePass() const override {
143 return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
144 }
145
147 void getDependentDialects(::mlir::DialectRegistry &registry) const override {
148 registry.insert<llzk::LLZKDialect>();
149 registry.insert<llzk::boolean::BoolDialect>();
150 registry.insert<llzk::array::ArrayDialect>();
151 registry.insert<llzk::component::StructDialect>();
152 registry.insert<llzk::constrain::ConstrainDialect>();
153 registry.insert<llzk::felt::FeltDialect>();
154 registry.insert<llzk::global::GlobalDialect>();
155 registry.insert<llzk::include::IncludeDialect>();
156 registry.insert<llzk::function::FunctionDialect>();
157 registry.insert<llzk::string::StringDialect>();
158 registry.insert<llzk::polymorphic::PolymorphicDialect>();
159 registry.insert<llzk::undef::UndefDialect>();
160 registry.insert<mlir::arith::ArithDialect>();
161 registry.insert<mlir::scf::SCFDialect>();
162 }
163
167 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(InlineStructsPassBase<DerivedT>)
168
169 InlineStructsPassBase(InlineStructsPassOptions options) : InlineStructsPassBase() {
170 maxComplexity = std::move(options.maxComplexity);
171 }
172protected:
173 ::mlir::Pass::Option<uint64_t> maxComplexity{*this, "max-merge-complexity", ::llvm::cl::desc("Maximum allowed constraint+multiplications in merged @constrain functions"), ::llvm::cl::init(0)};
174private:
175};
176} // namespace impl
177#undef GEN_PASS_DEF_INLINESTRUCTSPASS
178#endif // GEN_PASS_DEF_INLINESTRUCTSPASS
179
180//===----------------------------------------------------------------------===//
181// PCLLoweringPass
182//===----------------------------------------------------------------------===//
183#ifdef GEN_PASS_DECL_PCLLOWERINGPASS
184struct PCLLoweringPassOptions {
185 ::llvm::APInt prime = llvm::APInt(31, 2130706433);
186};
187#undef GEN_PASS_DECL_PCLLOWERINGPASS
188#endif // GEN_PASS_DECL_PCLLOWERINGPASS
189#ifdef GEN_PASS_DEF_PCLLOWERINGPASS
190namespace impl {
191
192template <typename DerivedT>
193class PCLLoweringPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
194public:
195 using Base = PCLLoweringPassBase;
196
197 PCLLoweringPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
198 PCLLoweringPassBase(const PCLLoweringPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
199 PCLLoweringPassBase& operator=(const PCLLoweringPassBase &) = delete;
200 PCLLoweringPassBase(PCLLoweringPassBase &&) = delete;
201 PCLLoweringPassBase& operator=(PCLLoweringPassBase &&) = delete;
202 ~PCLLoweringPassBase() = default;
203
205 static constexpr ::llvm::StringLiteral getArgumentName() {
206 return ::llvm::StringLiteral("llzk-to-pcl");
207 }
208 ::llvm::StringRef getArgument() const override { return "llzk-to-pcl"; }
209
210 ::llvm::StringRef getDescription() const override { return "Rewrites constraints to be compatible with PCL constraints used by Picus"; }
211
213 static constexpr ::llvm::StringLiteral getPassName() {
214 return ::llvm::StringLiteral("PCLLoweringPass");
215 }
216 ::llvm::StringRef getName() const override { return "PCLLoweringPass"; }
217
219 static bool classof(const ::mlir::Pass *pass) {
220 return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
221 }
222
224 std::unique_ptr<::mlir::Pass> clonePass() const override {
225 return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
226 }
227
229 void getDependentDialects(::mlir::DialectRegistry &registry) const override {
230 registry.insert<llzk::LLZKDialect>();
231 registry.insert<llzk::boolean::BoolDialect>();
232 registry.insert<llzk::array::ArrayDialect>();
233 registry.insert<llzk::component::StructDialect>();
234 registry.insert<llzk::constrain::ConstrainDialect>();
235 registry.insert<llzk::felt::FeltDialect>();
236 registry.insert<llzk::global::GlobalDialect>();
237 registry.insert<llzk::include::IncludeDialect>();
238 registry.insert<llzk::function::FunctionDialect>();
239 registry.insert<llzk::string::StringDialect>();
240 registry.insert<llzk::polymorphic::PolymorphicDialect>();
241 registry.insert<llzk::undef::UndefDialect>();
242 registry.insert<mlir::arith::ArithDialect>();
243 registry.insert<mlir::scf::SCFDialect>();
244 }
245
249 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(PCLLoweringPassBase<DerivedT>)
250
251 PCLLoweringPassBase(PCLLoweringPassOptions options) : PCLLoweringPassBase() {
252 prime = std::move(options.prime);
253 }
254protected:
255 ::mlir::Pass::Option<::llvm::APInt> prime{*this, "prime", ::llvm::cl::desc("The prime field that the constraints operate over. This is required by PCL, and the prime must be passed in digits."), ::llvm::cl::init(llvm::APInt(31, 2130706433))};
256private:
257};
258} // namespace impl
259#undef GEN_PASS_DEF_PCLLOWERINGPASS
260#endif // GEN_PASS_DEF_PCLLOWERINGPASS
261
262//===----------------------------------------------------------------------===//
263// PolyLoweringPass
264//===----------------------------------------------------------------------===//
265#ifdef GEN_PASS_DECL_POLYLOWERINGPASS
266struct PolyLoweringPassOptions {
267 unsigned maxDegree = 2;
268};
269#undef GEN_PASS_DECL_POLYLOWERINGPASS
270#endif // GEN_PASS_DECL_POLYLOWERINGPASS
271#ifdef GEN_PASS_DEF_POLYLOWERINGPASS
272namespace impl {
273
274template <typename DerivedT>
275class PolyLoweringPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
276public:
277 using Base = PolyLoweringPassBase;
278
279 PolyLoweringPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
280 PolyLoweringPassBase(const PolyLoweringPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
281 PolyLoweringPassBase& operator=(const PolyLoweringPassBase &) = delete;
282 PolyLoweringPassBase(PolyLoweringPassBase &&) = delete;
283 PolyLoweringPassBase& operator=(PolyLoweringPassBase &&) = delete;
284 ~PolyLoweringPassBase() = default;
285
287 static constexpr ::llvm::StringLiteral getArgumentName() {
288 return ::llvm::StringLiteral("llzk-poly-lowering-pass");
289 }
290 ::llvm::StringRef getArgument() const override { return "llzk-poly-lowering-pass"; }
291
292 ::llvm::StringRef getDescription() const override { return "Lowers the degree of all polynomial equations to a specified maximum"; }
293
295 static constexpr ::llvm::StringLiteral getPassName() {
296 return ::llvm::StringLiteral("PolyLoweringPass");
297 }
298 ::llvm::StringRef getName() const override { return "PolyLoweringPass"; }
299
301 static bool classof(const ::mlir::Pass *pass) {
302 return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
303 }
304
306 std::unique_ptr<::mlir::Pass> clonePass() const override {
307 return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
308 }
309
311 void getDependentDialects(::mlir::DialectRegistry &registry) const override {
312 registry.insert<llzk::LLZKDialect>();
313 registry.insert<llzk::boolean::BoolDialect>();
314 registry.insert<llzk::array::ArrayDialect>();
315 registry.insert<llzk::component::StructDialect>();
316 registry.insert<llzk::constrain::ConstrainDialect>();
317 registry.insert<llzk::felt::FeltDialect>();
318 registry.insert<llzk::global::GlobalDialect>();
319 registry.insert<llzk::include::IncludeDialect>();
320 registry.insert<llzk::function::FunctionDialect>();
321 registry.insert<llzk::string::StringDialect>();
322 registry.insert<llzk::polymorphic::PolymorphicDialect>();
323 registry.insert<llzk::undef::UndefDialect>();
324 registry.insert<mlir::arith::ArithDialect>();
325 registry.insert<mlir::scf::SCFDialect>();
326 }
327
331 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(PolyLoweringPassBase<DerivedT>)
332
333 PolyLoweringPassBase(PolyLoweringPassOptions options) : PolyLoweringPassBase() {
334 maxDegree = std::move(options.maxDegree);
335 }
336protected:
337 ::mlir::Pass::Option<unsigned> maxDegree{*this, "max-degree", ::llvm::cl::desc("Maximum degree of constraint polynomials (default 2, minimum 2)"), ::llvm::cl::init(2)};
338private:
339};
340} // namespace impl
341#undef GEN_PASS_DEF_POLYLOWERINGPASS
342#endif // GEN_PASS_DEF_POLYLOWERINGPASS
343
344//===----------------------------------------------------------------------===//
345// R1CSLoweringPass
346//===----------------------------------------------------------------------===//
347#ifdef GEN_PASS_DECL_R1CSLOWERINGPASS
348#undef GEN_PASS_DECL_R1CSLOWERINGPASS
349#endif // GEN_PASS_DECL_R1CSLOWERINGPASS
350#ifdef GEN_PASS_DEF_R1CSLOWERINGPASS
351namespace impl {
352
353template <typename DerivedT>
354class R1CSLoweringPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
355public:
356 using Base = R1CSLoweringPassBase;
357
358 R1CSLoweringPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
359 R1CSLoweringPassBase(const R1CSLoweringPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
360 R1CSLoweringPassBase& operator=(const R1CSLoweringPassBase &) = delete;
361 R1CSLoweringPassBase(R1CSLoweringPassBase &&) = delete;
362 R1CSLoweringPassBase& operator=(R1CSLoweringPassBase &&) = delete;
363 ~R1CSLoweringPassBase() = default;
364
366 static constexpr ::llvm::StringLiteral getArgumentName() {
367 return ::llvm::StringLiteral("llzk-r1cs-lowering");
368 }
369 ::llvm::StringRef getArgument() const override { return "llzk-r1cs-lowering"; }
370
371 ::llvm::StringRef getDescription() const override { return "Rewrites constraints to be compatible with R1CS constraints i.e a*b - c = 0"; }
372
374 static constexpr ::llvm::StringLiteral getPassName() {
375 return ::llvm::StringLiteral("R1CSLoweringPass");
376 }
377 ::llvm::StringRef getName() const override { return "R1CSLoweringPass"; }
378
380 static bool classof(const ::mlir::Pass *pass) {
381 return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
382 }
383
385 std::unique_ptr<::mlir::Pass> clonePass() const override {
386 return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
387 }
388
390 void getDependentDialects(::mlir::DialectRegistry &registry) const override {
391 registry.insert<llzk::LLZKDialect>();
392 registry.insert<llzk::boolean::BoolDialect>();
393 registry.insert<llzk::array::ArrayDialect>();
394 registry.insert<llzk::component::StructDialect>();
395 registry.insert<llzk::constrain::ConstrainDialect>();
396 registry.insert<llzk::felt::FeltDialect>();
397 registry.insert<llzk::global::GlobalDialect>();
398 registry.insert<llzk::include::IncludeDialect>();
399 registry.insert<llzk::function::FunctionDialect>();
400 registry.insert<llzk::string::StringDialect>();
401 registry.insert<llzk::polymorphic::PolymorphicDialect>();
402 registry.insert<llzk::undef::UndefDialect>();
403 registry.insert<mlir::arith::ArithDialect>();
404 registry.insert<mlir::scf::SCFDialect>();
405 }
406
410 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(R1CSLoweringPassBase<DerivedT>)
411
412protected:
413private:
414};
415} // namespace impl
416#undef GEN_PASS_DEF_R1CSLOWERINGPASS
417#endif // GEN_PASS_DEF_R1CSLOWERINGPASS
418
419//===----------------------------------------------------------------------===//
420// RedundantOperationEliminationPass
421//===----------------------------------------------------------------------===//
422#ifdef GEN_PASS_DECL_REDUNDANTOPERATIONELIMINATIONPASS
423#undef GEN_PASS_DECL_REDUNDANTOPERATIONELIMINATIONPASS
424#endif // GEN_PASS_DECL_REDUNDANTOPERATIONELIMINATIONPASS
425#ifdef GEN_PASS_DEF_REDUNDANTOPERATIONELIMINATIONPASS
426namespace impl {
427
428template <typename DerivedT>
429class RedundantOperationEliminationPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
430public:
431 using Base = RedundantOperationEliminationPassBase;
432
433 RedundantOperationEliminationPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
434 RedundantOperationEliminationPassBase(const RedundantOperationEliminationPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
435 RedundantOperationEliminationPassBase& operator=(const RedundantOperationEliminationPassBase &) = delete;
436 RedundantOperationEliminationPassBase(RedundantOperationEliminationPassBase &&) = delete;
437 RedundantOperationEliminationPassBase& operator=(RedundantOperationEliminationPassBase &&) = delete;
438 ~RedundantOperationEliminationPassBase() = default;
439
441 static constexpr ::llvm::StringLiteral getArgumentName() {
442 return ::llvm::StringLiteral("llzk-duplicate-op-elim");
443 }
444 ::llvm::StringRef getArgument() const override { return "llzk-duplicate-op-elim"; }
445
446 ::llvm::StringRef getDescription() const override { return "Remove redundant operations"; }
447
449 static constexpr ::llvm::StringLiteral getPassName() {
450 return ::llvm::StringLiteral("RedundantOperationEliminationPass");
451 }
452 ::llvm::StringRef getName() const override { return "RedundantOperationEliminationPass"; }
453
455 static bool classof(const ::mlir::Pass *pass) {
456 return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
457 }
458
460 std::unique_ptr<::mlir::Pass> clonePass() const override {
461 return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
462 }
463
465 void getDependentDialects(::mlir::DialectRegistry &registry) const override {
466 registry.insert<llzk::LLZKDialect>();
467 registry.insert<llzk::boolean::BoolDialect>();
468 registry.insert<llzk::array::ArrayDialect>();
469 registry.insert<llzk::component::StructDialect>();
470 registry.insert<llzk::constrain::ConstrainDialect>();
471 registry.insert<llzk::felt::FeltDialect>();
472 registry.insert<llzk::global::GlobalDialect>();
473 registry.insert<llzk::include::IncludeDialect>();
474 registry.insert<llzk::function::FunctionDialect>();
475 registry.insert<llzk::string::StringDialect>();
476 registry.insert<llzk::polymorphic::PolymorphicDialect>();
477 registry.insert<llzk::undef::UndefDialect>();
478 registry.insert<mlir::arith::ArithDialect>();
479 registry.insert<mlir::scf::SCFDialect>();
480 }
481
485 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(RedundantOperationEliminationPassBase<DerivedT>)
486
487protected:
488private:
489};
490} // namespace impl
491#undef GEN_PASS_DEF_REDUNDANTOPERATIONELIMINATIONPASS
492#endif // GEN_PASS_DEF_REDUNDANTOPERATIONELIMINATIONPASS
493
494//===----------------------------------------------------------------------===//
495// RedundantReadAndWriteEliminationPass
496//===----------------------------------------------------------------------===//
497#ifdef GEN_PASS_DECL_REDUNDANTREADANDWRITEELIMINATIONPASS
498#undef GEN_PASS_DECL_REDUNDANTREADANDWRITEELIMINATIONPASS
499#endif // GEN_PASS_DECL_REDUNDANTREADANDWRITEELIMINATIONPASS
500#ifdef GEN_PASS_DEF_REDUNDANTREADANDWRITEELIMINATIONPASS
501namespace impl {
502
503template <typename DerivedT>
504class RedundantReadAndWriteEliminationPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
505public:
506 using Base = RedundantReadAndWriteEliminationPassBase;
507
508 RedundantReadAndWriteEliminationPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
509 RedundantReadAndWriteEliminationPassBase(const RedundantReadAndWriteEliminationPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
510 RedundantReadAndWriteEliminationPassBase& operator=(const RedundantReadAndWriteEliminationPassBase &) = delete;
511 RedundantReadAndWriteEliminationPassBase(RedundantReadAndWriteEliminationPassBase &&) = delete;
512 RedundantReadAndWriteEliminationPassBase& operator=(RedundantReadAndWriteEliminationPassBase &&) = delete;
513 ~RedundantReadAndWriteEliminationPassBase() = default;
514
516 static constexpr ::llvm::StringLiteral getArgumentName() {
517 return ::llvm::StringLiteral("llzk-duplicate-read-write-elim");
518 }
519 ::llvm::StringRef getArgument() const override { return "llzk-duplicate-read-write-elim"; }
520
521 ::llvm::StringRef getDescription() const override { return "Remove redundant reads and writes"; }
522
524 static constexpr ::llvm::StringLiteral getPassName() {
525 return ::llvm::StringLiteral("RedundantReadAndWriteEliminationPass");
526 }
527 ::llvm::StringRef getName() const override { return "RedundantReadAndWriteEliminationPass"; }
528
530 static bool classof(const ::mlir::Pass *pass) {
531 return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
532 }
533
535 std::unique_ptr<::mlir::Pass> clonePass() const override {
536 return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
537 }
538
540 void getDependentDialects(::mlir::DialectRegistry &registry) const override {
541 registry.insert<llzk::LLZKDialect>();
542 registry.insert<llzk::boolean::BoolDialect>();
543 registry.insert<llzk::array::ArrayDialect>();
544 registry.insert<llzk::component::StructDialect>();
545 registry.insert<llzk::constrain::ConstrainDialect>();
546 registry.insert<llzk::felt::FeltDialect>();
547 registry.insert<llzk::global::GlobalDialect>();
548 registry.insert<llzk::include::IncludeDialect>();
549 registry.insert<llzk::function::FunctionDialect>();
550 registry.insert<llzk::string::StringDialect>();
551 registry.insert<llzk::polymorphic::PolymorphicDialect>();
552 registry.insert<llzk::undef::UndefDialect>();
553 registry.insert<mlir::arith::ArithDialect>();
554 registry.insert<mlir::scf::SCFDialect>();
555 }
556
560 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(RedundantReadAndWriteEliminationPassBase<DerivedT>)
561
562protected:
563private:
564};
565} // namespace impl
566#undef GEN_PASS_DEF_REDUNDANTREADANDWRITEELIMINATIONPASS
567#endif // GEN_PASS_DEF_REDUNDANTREADANDWRITEELIMINATIONPASS
568
569//===----------------------------------------------------------------------===//
570// UnusedDeclarationEliminationPass
571//===----------------------------------------------------------------------===//
572#ifdef GEN_PASS_DECL_UNUSEDDECLARATIONELIMINATIONPASS
573struct UnusedDeclarationEliminationPassOptions {
574 bool removeStructs = false;
575};
576#undef GEN_PASS_DECL_UNUSEDDECLARATIONELIMINATIONPASS
577#endif // GEN_PASS_DECL_UNUSEDDECLARATIONELIMINATIONPASS
578#ifdef GEN_PASS_DEF_UNUSEDDECLARATIONELIMINATIONPASS
579namespace impl {
580
581template <typename DerivedT>
582class UnusedDeclarationEliminationPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
583public:
584 using Base = UnusedDeclarationEliminationPassBase;
585
586 UnusedDeclarationEliminationPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
587 UnusedDeclarationEliminationPassBase(const UnusedDeclarationEliminationPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
588 UnusedDeclarationEliminationPassBase& operator=(const UnusedDeclarationEliminationPassBase &) = delete;
589 UnusedDeclarationEliminationPassBase(UnusedDeclarationEliminationPassBase &&) = delete;
590 UnusedDeclarationEliminationPassBase& operator=(UnusedDeclarationEliminationPassBase &&) = delete;
591 ~UnusedDeclarationEliminationPassBase() = default;
592
594 static constexpr ::llvm::StringLiteral getArgumentName() {
595 return ::llvm::StringLiteral("llzk-unused-declaration-elim");
596 }
597 ::llvm::StringRef getArgument() const override { return "llzk-unused-declaration-elim"; }
598
599 ::llvm::StringRef getDescription() const override { return "Remove unused field and struct declarations"; }
600
602 static constexpr ::llvm::StringLiteral getPassName() {
603 return ::llvm::StringLiteral("UnusedDeclarationEliminationPass");
604 }
605 ::llvm::StringRef getName() const override { return "UnusedDeclarationEliminationPass"; }
606
608 static bool classof(const ::mlir::Pass *pass) {
609 return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
610 }
611
613 std::unique_ptr<::mlir::Pass> clonePass() const override {
614 return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
615 }
616
618 void getDependentDialects(::mlir::DialectRegistry &registry) const override {
619 registry.insert<llzk::LLZKDialect>();
620 registry.insert<llzk::boolean::BoolDialect>();
621 registry.insert<llzk::array::ArrayDialect>();
622 registry.insert<llzk::component::StructDialect>();
623 registry.insert<llzk::constrain::ConstrainDialect>();
624 registry.insert<llzk::felt::FeltDialect>();
625 registry.insert<llzk::global::GlobalDialect>();
626 registry.insert<llzk::include::IncludeDialect>();
627 registry.insert<llzk::function::FunctionDialect>();
628 registry.insert<llzk::string::StringDialect>();
629 registry.insert<llzk::polymorphic::PolymorphicDialect>();
630 registry.insert<llzk::undef::UndefDialect>();
631 registry.insert<mlir::arith::ArithDialect>();
632 registry.insert<mlir::scf::SCFDialect>();
633 }
634
638 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(UnusedDeclarationEliminationPassBase<DerivedT>)
639
640 UnusedDeclarationEliminationPassBase(UnusedDeclarationEliminationPassOptions options) : UnusedDeclarationEliminationPassBase() {
641 removeStructs = std::move(options.removeStructs);
642 }
643protected:
644 ::mlir::Pass::Option<bool> removeStructs{*this, "remove-structs", ::llvm::cl::desc("Whether to remove unused struct definitions as well. Requires module to declare a Main component, otherwise all components will appear unused."), ::llvm::cl::init(false)};
645private:
646};
647} // namespace impl
648#undef GEN_PASS_DEF_UNUSEDDECLARATIONELIMINATIONPASS
649#endif // GEN_PASS_DEF_UNUSEDDECLARATIONELIMINATIONPASS
650#ifdef GEN_PASS_REGISTRATION
651
652//===----------------------------------------------------------------------===//
653// ComputeConstrainToProductPass Registration
654//===----------------------------------------------------------------------===//
655
656inline void registerComputeConstrainToProductPass() {
657 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
658 return llzk::createComputeConstrainToProductPass();
659 });
660}
661
662// Old registration code, kept for temporary backwards compatibility.
663inline void registerComputeConstrainToProductPassPass() {
664 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
665 return llzk::createComputeConstrainToProductPass();
666 });
667}
668
669//===----------------------------------------------------------------------===//
670// InlineStructsPass Registration
671//===----------------------------------------------------------------------===//
672
673inline void registerInlineStructsPass() {
674 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
675 return llzk::createInlineStructsPass();
676 });
677}
678
679// Old registration code, kept for temporary backwards compatibility.
680inline void registerInlineStructsPassPass() {
681 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
682 return llzk::createInlineStructsPass();
683 });
684}
685
686//===----------------------------------------------------------------------===//
687// PCLLoweringPass Registration
688//===----------------------------------------------------------------------===//
689
690inline void registerPCLLoweringPass() {
691 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
692 return llzk::createPCLLoweringPass();
693 });
694}
695
696// Old registration code, kept for temporary backwards compatibility.
697inline void registerPCLLoweringPassPass() {
698 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
699 return llzk::createPCLLoweringPass();
700 });
701}
702
703//===----------------------------------------------------------------------===//
704// PolyLoweringPass Registration
705//===----------------------------------------------------------------------===//
706
707inline void registerPolyLoweringPass() {
708 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
709 return llzk::createPolyLoweringPass();
710 });
711}
712
713// Old registration code, kept for temporary backwards compatibility.
714inline void registerPolyLoweringPassPass() {
715 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
716 return llzk::createPolyLoweringPass();
717 });
718}
719
720//===----------------------------------------------------------------------===//
721// R1CSLoweringPass Registration
722//===----------------------------------------------------------------------===//
723
724inline void registerR1CSLoweringPass() {
725 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
726 return llzk::createR1CSLoweringPass();
727 });
728}
729
730// Old registration code, kept for temporary backwards compatibility.
731inline void registerR1CSLoweringPassPass() {
732 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
733 return llzk::createR1CSLoweringPass();
734 });
735}
736
737//===----------------------------------------------------------------------===//
738// RedundantOperationEliminationPass Registration
739//===----------------------------------------------------------------------===//
740
741inline void registerRedundantOperationEliminationPass() {
742 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
743 return llzk::createRedundantOperationEliminationPass();
744 });
745}
746
747// Old registration code, kept for temporary backwards compatibility.
748inline void registerRedundantOperationEliminationPassPass() {
749 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
750 return llzk::createRedundantOperationEliminationPass();
751 });
752}
753
754//===----------------------------------------------------------------------===//
755// RedundantReadAndWriteEliminationPass Registration
756//===----------------------------------------------------------------------===//
757
758inline void registerRedundantReadAndWriteEliminationPass() {
759 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
760 return llzk::createRedundantReadAndWriteEliminationPass();
761 });
762}
763
764// Old registration code, kept for temporary backwards compatibility.
765inline void registerRedundantReadAndWriteEliminationPassPass() {
766 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
767 return llzk::createRedundantReadAndWriteEliminationPass();
768 });
769}
770
771//===----------------------------------------------------------------------===//
772// UnusedDeclarationEliminationPass Registration
773//===----------------------------------------------------------------------===//
774
775inline void registerUnusedDeclarationEliminationPass() {
776 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
777 return llzk::createUnusedDeclarationEliminationPass();
778 });
779}
780
781// Old registration code, kept for temporary backwards compatibility.
782inline void registerUnusedDeclarationEliminationPassPass() {
783 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
784 return llzk::createUnusedDeclarationEliminationPass();
785 });
786}
787
788//===----------------------------------------------------------------------===//
789// Transformation Registration
790//===----------------------------------------------------------------------===//
791
792inline void registerTransformationPasses() {
793 registerComputeConstrainToProductPass();
794 registerInlineStructsPass();
795 registerPCLLoweringPass();
796 registerPolyLoweringPass();
797 registerR1CSLoweringPass();
798 registerRedundantOperationEliminationPass();
799 registerRedundantReadAndWriteEliminationPass();
800 registerUnusedDeclarationEliminationPass();
801}
802#undef GEN_PASS_REGISTRATION
803#endif // GEN_PASS_REGISTRATION
804// Deprecated. Please use the new per-pass macros.
805#ifdef GEN_PASS_CLASSES
806
807template <typename DerivedT>
808class ComputeConstrainToProductPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
809public:
810 using Base = ComputeConstrainToProductPassBase;
811
812 ComputeConstrainToProductPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
813 ComputeConstrainToProductPassBase(const ComputeConstrainToProductPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
814 ComputeConstrainToProductPassBase& operator=(const ComputeConstrainToProductPassBase &) = delete;
815 ComputeConstrainToProductPassBase(ComputeConstrainToProductPassBase &&) = delete;
816 ComputeConstrainToProductPassBase& operator=(ComputeConstrainToProductPassBase &&) = delete;
817 ~ComputeConstrainToProductPassBase() = default;
818
820 static constexpr ::llvm::StringLiteral getArgumentName() {
821 return ::llvm::StringLiteral("llzk-compute-constrain-to-product");
822 }
823 ::llvm::StringRef getArgument() const override { return "llzk-compute-constrain-to-product"; }
824
825 ::llvm::StringRef getDescription() const override { return "Replaces separate @compute and @constrain functions in a struct with a single @product function"; }
826
828 static constexpr ::llvm::StringLiteral getPassName() {
829 return ::llvm::StringLiteral("ComputeConstrainToProductPass");
830 }
831 ::llvm::StringRef getName() const override { return "ComputeConstrainToProductPass"; }
832
834 static bool classof(const ::mlir::Pass *pass) {
835 return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
836 }
837
839 std::unique_ptr<::mlir::Pass> clonePass() const override {
840 return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
841 }
842
844 void getDependentDialects(::mlir::DialectRegistry &registry) const override {
845 registry.insert<llzk::LLZKDialect>();
846 registry.insert<llzk::boolean::BoolDialect>();
847 registry.insert<llzk::array::ArrayDialect>();
848 registry.insert<llzk::component::StructDialect>();
849 registry.insert<llzk::constrain::ConstrainDialect>();
850 registry.insert<llzk::felt::FeltDialect>();
851 registry.insert<llzk::global::GlobalDialect>();
852 registry.insert<llzk::include::IncludeDialect>();
853 registry.insert<llzk::function::FunctionDialect>();
854 registry.insert<llzk::string::StringDialect>();
855 registry.insert<llzk::polymorphic::PolymorphicDialect>();
856 registry.insert<llzk::undef::UndefDialect>();
857 registry.insert<mlir::arith::ArithDialect>();
858 registry.insert<mlir::scf::SCFDialect>();
859 }
860
864 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(ComputeConstrainToProductPassBase<DerivedT>)
865
866protected:
867 ::mlir::Pass::Option<std::string> rootStruct{*this, "root-struct", ::llvm::cl::desc("Root struct at which to start alignment (default to `@Main`)"), ::llvm::cl::init("@Main")};
868};
869
870template <typename DerivedT>
871class InlineStructsPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
872public:
873 using Base = InlineStructsPassBase;
874
875 InlineStructsPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
876 InlineStructsPassBase(const InlineStructsPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
877 InlineStructsPassBase& operator=(const InlineStructsPassBase &) = delete;
878 InlineStructsPassBase(InlineStructsPassBase &&) = delete;
879 InlineStructsPassBase& operator=(InlineStructsPassBase &&) = delete;
880 ~InlineStructsPassBase() = default;
881
883 static constexpr ::llvm::StringLiteral getArgumentName() {
884 return ::llvm::StringLiteral("llzk-inline-structs");
885 }
886 ::llvm::StringRef getArgument() const override { return "llzk-inline-structs"; }
887
888 ::llvm::StringRef getDescription() const override { return "Inlines nested structs (i.e., subcomponents)."; }
889
891 static constexpr ::llvm::StringLiteral getPassName() {
892 return ::llvm::StringLiteral("InlineStructsPass");
893 }
894 ::llvm::StringRef getName() const override { return "InlineStructsPass"; }
895
897 static bool classof(const ::mlir::Pass *pass) {
898 return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
899 }
900
902 std::unique_ptr<::mlir::Pass> clonePass() const override {
903 return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
904 }
905
907 void getDependentDialects(::mlir::DialectRegistry &registry) const override {
908 registry.insert<llzk::LLZKDialect>();
909 registry.insert<llzk::boolean::BoolDialect>();
910 registry.insert<llzk::array::ArrayDialect>();
911 registry.insert<llzk::component::StructDialect>();
912 registry.insert<llzk::constrain::ConstrainDialect>();
913 registry.insert<llzk::felt::FeltDialect>();
914 registry.insert<llzk::global::GlobalDialect>();
915 registry.insert<llzk::include::IncludeDialect>();
916 registry.insert<llzk::function::FunctionDialect>();
917 registry.insert<llzk::string::StringDialect>();
918 registry.insert<llzk::polymorphic::PolymorphicDialect>();
919 registry.insert<llzk::undef::UndefDialect>();
920 registry.insert<mlir::arith::ArithDialect>();
921 registry.insert<mlir::scf::SCFDialect>();
922 }
923
927 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(InlineStructsPassBase<DerivedT>)
928
929protected:
930 ::mlir::Pass::Option<uint64_t> maxComplexity{*this, "max-merge-complexity", ::llvm::cl::desc("Maximum allowed constraint+multiplications in merged @constrain functions"), ::llvm::cl::init(0)};
931};
932
933template <typename DerivedT>
934class PCLLoweringPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
935public:
936 using Base = PCLLoweringPassBase;
937
938 PCLLoweringPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
939 PCLLoweringPassBase(const PCLLoweringPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
940 PCLLoweringPassBase& operator=(const PCLLoweringPassBase &) = delete;
941 PCLLoweringPassBase(PCLLoweringPassBase &&) = delete;
942 PCLLoweringPassBase& operator=(PCLLoweringPassBase &&) = delete;
943 ~PCLLoweringPassBase() = default;
944
946 static constexpr ::llvm::StringLiteral getArgumentName() {
947 return ::llvm::StringLiteral("llzk-to-pcl");
948 }
949 ::llvm::StringRef getArgument() const override { return "llzk-to-pcl"; }
950
951 ::llvm::StringRef getDescription() const override { return "Rewrites constraints to be compatible with PCL constraints used by Picus"; }
952
954 static constexpr ::llvm::StringLiteral getPassName() {
955 return ::llvm::StringLiteral("PCLLoweringPass");
956 }
957 ::llvm::StringRef getName() const override { return "PCLLoweringPass"; }
958
960 static bool classof(const ::mlir::Pass *pass) {
961 return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
962 }
963
965 std::unique_ptr<::mlir::Pass> clonePass() const override {
966 return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
967 }
968
970 void getDependentDialects(::mlir::DialectRegistry &registry) const override {
971 registry.insert<llzk::LLZKDialect>();
972 registry.insert<llzk::boolean::BoolDialect>();
973 registry.insert<llzk::array::ArrayDialect>();
974 registry.insert<llzk::component::StructDialect>();
975 registry.insert<llzk::constrain::ConstrainDialect>();
976 registry.insert<llzk::felt::FeltDialect>();
977 registry.insert<llzk::global::GlobalDialect>();
978 registry.insert<llzk::include::IncludeDialect>();
979 registry.insert<llzk::function::FunctionDialect>();
980 registry.insert<llzk::string::StringDialect>();
981 registry.insert<llzk::polymorphic::PolymorphicDialect>();
982 registry.insert<llzk::undef::UndefDialect>();
983 registry.insert<mlir::arith::ArithDialect>();
984 registry.insert<mlir::scf::SCFDialect>();
985 }
986
990 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(PCLLoweringPassBase<DerivedT>)
991
992protected:
993 ::mlir::Pass::Option<::llvm::APInt> prime{*this, "prime", ::llvm::cl::desc("The prime field that the constraints operate over. This is required by PCL, and the prime must be passed in digits."), ::llvm::cl::init(llvm::APInt(31, 2130706433))};
994};
995
996template <typename DerivedT>
997class PolyLoweringPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
998public:
999 using Base = PolyLoweringPassBase;
1000
1001 PolyLoweringPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
1002 PolyLoweringPassBase(const PolyLoweringPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
1003 PolyLoweringPassBase& operator=(const PolyLoweringPassBase &) = delete;
1004 PolyLoweringPassBase(PolyLoweringPassBase &&) = delete;
1005 PolyLoweringPassBase& operator=(PolyLoweringPassBase &&) = delete;
1006 ~PolyLoweringPassBase() = default;
1007
1009 static constexpr ::llvm::StringLiteral getArgumentName() {
1010 return ::llvm::StringLiteral("llzk-poly-lowering-pass");
1011 }
1012 ::llvm::StringRef getArgument() const override { return "llzk-poly-lowering-pass"; }
1013
1014 ::llvm::StringRef getDescription() const override { return "Lowers the degree of all polynomial equations to a specified maximum"; }
1015
1017 static constexpr ::llvm::StringLiteral getPassName() {
1018 return ::llvm::StringLiteral("PolyLoweringPass");
1019 }
1020 ::llvm::StringRef getName() const override { return "PolyLoweringPass"; }
1021
1023 static bool classof(const ::mlir::Pass *pass) {
1024 return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
1025 }
1026
1028 std::unique_ptr<::mlir::Pass> clonePass() const override {
1029 return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
1030 }
1031
1033 void getDependentDialects(::mlir::DialectRegistry &registry) const override {
1034 registry.insert<llzk::LLZKDialect>();
1035 registry.insert<llzk::boolean::BoolDialect>();
1036 registry.insert<llzk::array::ArrayDialect>();
1037 registry.insert<llzk::component::StructDialect>();
1038 registry.insert<llzk::constrain::ConstrainDialect>();
1039 registry.insert<llzk::felt::FeltDialect>();
1040 registry.insert<llzk::global::GlobalDialect>();
1041 registry.insert<llzk::include::IncludeDialect>();
1042 registry.insert<llzk::function::FunctionDialect>();
1043 registry.insert<llzk::string::StringDialect>();
1044 registry.insert<llzk::polymorphic::PolymorphicDialect>();
1045 registry.insert<llzk::undef::UndefDialect>();
1046 registry.insert<mlir::arith::ArithDialect>();
1047 registry.insert<mlir::scf::SCFDialect>();
1048 }
1049
1053 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(PolyLoweringPassBase<DerivedT>)
1054
1055protected:
1056 ::mlir::Pass::Option<unsigned> maxDegree{*this, "max-degree", ::llvm::cl::desc("Maximum degree of constraint polynomials (default 2, minimum 2)"), ::llvm::cl::init(2)};
1057};
1058
1059template <typename DerivedT>
1060class R1CSLoweringPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
1061public:
1062 using Base = R1CSLoweringPassBase;
1063
1064 R1CSLoweringPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
1065 R1CSLoweringPassBase(const R1CSLoweringPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
1066 R1CSLoweringPassBase& operator=(const R1CSLoweringPassBase &) = delete;
1067 R1CSLoweringPassBase(R1CSLoweringPassBase &&) = delete;
1068 R1CSLoweringPassBase& operator=(R1CSLoweringPassBase &&) = delete;
1069 ~R1CSLoweringPassBase() = default;
1070
1072 static constexpr ::llvm::StringLiteral getArgumentName() {
1073 return ::llvm::StringLiteral("llzk-r1cs-lowering");
1074 }
1075 ::llvm::StringRef getArgument() const override { return "llzk-r1cs-lowering"; }
1076
1077 ::llvm::StringRef getDescription() const override { return "Rewrites constraints to be compatible with R1CS constraints i.e a*b - c = 0"; }
1078
1080 static constexpr ::llvm::StringLiteral getPassName() {
1081 return ::llvm::StringLiteral("R1CSLoweringPass");
1082 }
1083 ::llvm::StringRef getName() const override { return "R1CSLoweringPass"; }
1084
1086 static bool classof(const ::mlir::Pass *pass) {
1087 return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
1088 }
1089
1091 std::unique_ptr<::mlir::Pass> clonePass() const override {
1092 return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
1093 }
1094
1096 void getDependentDialects(::mlir::DialectRegistry &registry) const override {
1097 registry.insert<llzk::LLZKDialect>();
1098 registry.insert<llzk::boolean::BoolDialect>();
1099 registry.insert<llzk::array::ArrayDialect>();
1100 registry.insert<llzk::component::StructDialect>();
1101 registry.insert<llzk::constrain::ConstrainDialect>();
1102 registry.insert<llzk::felt::FeltDialect>();
1103 registry.insert<llzk::global::GlobalDialect>();
1104 registry.insert<llzk::include::IncludeDialect>();
1105 registry.insert<llzk::function::FunctionDialect>();
1106 registry.insert<llzk::string::StringDialect>();
1107 registry.insert<llzk::polymorphic::PolymorphicDialect>();
1108 registry.insert<llzk::undef::UndefDialect>();
1109 registry.insert<mlir::arith::ArithDialect>();
1110 registry.insert<mlir::scf::SCFDialect>();
1111 }
1112
1116 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(R1CSLoweringPassBase<DerivedT>)
1117
1118protected:
1119};
1120
1121template <typename DerivedT>
1122class RedundantOperationEliminationPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
1123public:
1124 using Base = RedundantOperationEliminationPassBase;
1125
1126 RedundantOperationEliminationPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
1127 RedundantOperationEliminationPassBase(const RedundantOperationEliminationPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
1128 RedundantOperationEliminationPassBase& operator=(const RedundantOperationEliminationPassBase &) = delete;
1129 RedundantOperationEliminationPassBase(RedundantOperationEliminationPassBase &&) = delete;
1130 RedundantOperationEliminationPassBase& operator=(RedundantOperationEliminationPassBase &&) = delete;
1131 ~RedundantOperationEliminationPassBase() = default;
1132
1134 static constexpr ::llvm::StringLiteral getArgumentName() {
1135 return ::llvm::StringLiteral("llzk-duplicate-op-elim");
1136 }
1137 ::llvm::StringRef getArgument() const override { return "llzk-duplicate-op-elim"; }
1138
1139 ::llvm::StringRef getDescription() const override { return "Remove redundant operations"; }
1140
1142 static constexpr ::llvm::StringLiteral getPassName() {
1143 return ::llvm::StringLiteral("RedundantOperationEliminationPass");
1144 }
1145 ::llvm::StringRef getName() const override { return "RedundantOperationEliminationPass"; }
1146
1148 static bool classof(const ::mlir::Pass *pass) {
1149 return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
1150 }
1151
1153 std::unique_ptr<::mlir::Pass> clonePass() const override {
1154 return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
1155 }
1156
1158 void getDependentDialects(::mlir::DialectRegistry &registry) const override {
1159 registry.insert<llzk::LLZKDialect>();
1160 registry.insert<llzk::boolean::BoolDialect>();
1161 registry.insert<llzk::array::ArrayDialect>();
1162 registry.insert<llzk::component::StructDialect>();
1163 registry.insert<llzk::constrain::ConstrainDialect>();
1164 registry.insert<llzk::felt::FeltDialect>();
1165 registry.insert<llzk::global::GlobalDialect>();
1166 registry.insert<llzk::include::IncludeDialect>();
1167 registry.insert<llzk::function::FunctionDialect>();
1168 registry.insert<llzk::string::StringDialect>();
1169 registry.insert<llzk::polymorphic::PolymorphicDialect>();
1170 registry.insert<llzk::undef::UndefDialect>();
1171 registry.insert<mlir::arith::ArithDialect>();
1172 registry.insert<mlir::scf::SCFDialect>();
1173 }
1174
1178 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(RedundantOperationEliminationPassBase<DerivedT>)
1179
1180protected:
1181};
1182
1183template <typename DerivedT>
1184class RedundantReadAndWriteEliminationPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
1185public:
1186 using Base = RedundantReadAndWriteEliminationPassBase;
1187
1188 RedundantReadAndWriteEliminationPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
1189 RedundantReadAndWriteEliminationPassBase(const RedundantReadAndWriteEliminationPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
1190 RedundantReadAndWriteEliminationPassBase& operator=(const RedundantReadAndWriteEliminationPassBase &) = delete;
1191 RedundantReadAndWriteEliminationPassBase(RedundantReadAndWriteEliminationPassBase &&) = delete;
1192 RedundantReadAndWriteEliminationPassBase& operator=(RedundantReadAndWriteEliminationPassBase &&) = delete;
1193 ~RedundantReadAndWriteEliminationPassBase() = default;
1194
1196 static constexpr ::llvm::StringLiteral getArgumentName() {
1197 return ::llvm::StringLiteral("llzk-duplicate-read-write-elim");
1198 }
1199 ::llvm::StringRef getArgument() const override { return "llzk-duplicate-read-write-elim"; }
1200
1201 ::llvm::StringRef getDescription() const override { return "Remove redundant reads and writes"; }
1202
1204 static constexpr ::llvm::StringLiteral getPassName() {
1205 return ::llvm::StringLiteral("RedundantReadAndWriteEliminationPass");
1206 }
1207 ::llvm::StringRef getName() const override { return "RedundantReadAndWriteEliminationPass"; }
1208
1210 static bool classof(const ::mlir::Pass *pass) {
1211 return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
1212 }
1213
1215 std::unique_ptr<::mlir::Pass> clonePass() const override {
1216 return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
1217 }
1218
1220 void getDependentDialects(::mlir::DialectRegistry &registry) const override {
1221 registry.insert<llzk::LLZKDialect>();
1222 registry.insert<llzk::boolean::BoolDialect>();
1223 registry.insert<llzk::array::ArrayDialect>();
1224 registry.insert<llzk::component::StructDialect>();
1225 registry.insert<llzk::constrain::ConstrainDialect>();
1226 registry.insert<llzk::felt::FeltDialect>();
1227 registry.insert<llzk::global::GlobalDialect>();
1228 registry.insert<llzk::include::IncludeDialect>();
1229 registry.insert<llzk::function::FunctionDialect>();
1230 registry.insert<llzk::string::StringDialect>();
1231 registry.insert<llzk::polymorphic::PolymorphicDialect>();
1232 registry.insert<llzk::undef::UndefDialect>();
1233 registry.insert<mlir::arith::ArithDialect>();
1234 registry.insert<mlir::scf::SCFDialect>();
1235 }
1236
1240 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(RedundantReadAndWriteEliminationPassBase<DerivedT>)
1241
1242protected:
1243};
1244
1245template <typename DerivedT>
1246class UnusedDeclarationEliminationPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
1247public:
1248 using Base = UnusedDeclarationEliminationPassBase;
1249
1250 UnusedDeclarationEliminationPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
1251 UnusedDeclarationEliminationPassBase(const UnusedDeclarationEliminationPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
1252 UnusedDeclarationEliminationPassBase& operator=(const UnusedDeclarationEliminationPassBase &) = delete;
1253 UnusedDeclarationEliminationPassBase(UnusedDeclarationEliminationPassBase &&) = delete;
1254 UnusedDeclarationEliminationPassBase& operator=(UnusedDeclarationEliminationPassBase &&) = delete;
1255 ~UnusedDeclarationEliminationPassBase() = default;
1256
1258 static constexpr ::llvm::StringLiteral getArgumentName() {
1259 return ::llvm::StringLiteral("llzk-unused-declaration-elim");
1260 }
1261 ::llvm::StringRef getArgument() const override { return "llzk-unused-declaration-elim"; }
1262
1263 ::llvm::StringRef getDescription() const override { return "Remove unused field and struct declarations"; }
1264
1266 static constexpr ::llvm::StringLiteral getPassName() {
1267 return ::llvm::StringLiteral("UnusedDeclarationEliminationPass");
1268 }
1269 ::llvm::StringRef getName() const override { return "UnusedDeclarationEliminationPass"; }
1270
1272 static bool classof(const ::mlir::Pass *pass) {
1273 return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
1274 }
1275
1277 std::unique_ptr<::mlir::Pass> clonePass() const override {
1278 return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
1279 }
1280
1282 void getDependentDialects(::mlir::DialectRegistry &registry) const override {
1283 registry.insert<llzk::LLZKDialect>();
1284 registry.insert<llzk::boolean::BoolDialect>();
1285 registry.insert<llzk::array::ArrayDialect>();
1286 registry.insert<llzk::component::StructDialect>();
1287 registry.insert<llzk::constrain::ConstrainDialect>();
1288 registry.insert<llzk::felt::FeltDialect>();
1289 registry.insert<llzk::global::GlobalDialect>();
1290 registry.insert<llzk::include::IncludeDialect>();
1291 registry.insert<llzk::function::FunctionDialect>();
1292 registry.insert<llzk::string::StringDialect>();
1293 registry.insert<llzk::polymorphic::PolymorphicDialect>();
1294 registry.insert<llzk::undef::UndefDialect>();
1295 registry.insert<mlir::arith::ArithDialect>();
1296 registry.insert<mlir::scf::SCFDialect>();
1297 }
1298
1302 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(UnusedDeclarationEliminationPassBase<DerivedT>)
1303
1304protected:
1305 ::mlir::Pass::Option<bool> removeStructs{*this, "remove-structs", ::llvm::cl::desc("Whether to remove unused struct definitions as well. Requires module to declare a Main component, otherwise all components will appear unused."), ::llvm::cl::init(false)};
1306};
1307#undef GEN_PASS_CLASSES
1308#endif // GEN_PASS_CLASSES
llzk::array::registerTransformationPasses
void registerTransformationPasses()
Definition TransformationPasses.h:107
llzk::registerUnusedDeclarationEliminationPassPass
void registerUnusedDeclarationEliminationPassPass()
Definition LLZKTransformationPasses.h:783
llzk::createRedundantOperationEliminationPass
std::unique_ptr< mlir::Pass > createRedundantOperationEliminationPass()
Definition LLZKRedundantOperationEliminationPass.cpp:285
llzk::registerR1CSLoweringPass
void registerR1CSLoweringPass()
Definition LLZKTransformationPasses.h:725
llzk::registerRedundantOperationEliminationPass
void registerRedundantOperationEliminationPass()
Definition LLZKTransformationPasses.h:742
llzk::createComputeConstrainToProductPass
std::unique_ptr< mlir::Pass > createComputeConstrainToProductPass()
Definition LLZKComputeConstrainToProductPass.cpp:247
llzk::registerPolyLoweringPassPass
void registerPolyLoweringPassPass()
Definition LLZKTransformationPasses.h:715
llzk::registerUnusedDeclarationEliminationPass
void registerUnusedDeclarationEliminationPass()
Definition LLZKTransformationPasses.h:776
llzk::registerComputeConstrainToProductPassPass
void registerComputeConstrainToProductPassPass()
Definition LLZKTransformationPasses.h:664
llzk::registerRedundantOperationEliminationPassPass
void registerRedundantOperationEliminationPassPass()
Definition LLZKTransformationPasses.h:749
llzk::registerPCLLoweringPass
void registerPCLLoweringPass()
Definition LLZKTransformationPasses.h:691
llzk::createRedundantReadAndWriteEliminationPass
std::unique_ptr< mlir::Pass > createRedundantReadAndWriteEliminationPass()
Definition LLZKRedundantReadAndWriteEliminationPass.cpp:680
llzk::registerR1CSLoweringPassPass
void registerR1CSLoweringPassPass()
Definition LLZKTransformationPasses.h:732
llzk::registerInlineStructsPassPass
void registerInlineStructsPassPass()
Definition LLZKTransformationPasses.h:681
llzk::createUnusedDeclarationEliminationPass
std::unique_ptr< mlir::Pass > createUnusedDeclarationEliminationPass()
Definition LLZKUnusedDeclarationEliminationPass.cpp:233
llzk::registerComputeConstrainToProductPass
void registerComputeConstrainToProductPass()
Definition LLZKTransformationPasses.h:657
llzk::createPolyLoweringPass
std::unique_ptr< mlir::Pass > createPolyLoweringPass()
Definition LLZKPolyLoweringPass.cpp:335
llzk::registerRedundantReadAndWriteEliminationPass
void registerRedundantReadAndWriteEliminationPass()
Definition LLZKTransformationPasses.h:759
llzk::registerPolyLoweringPass
void registerPolyLoweringPass()
Definition LLZKTransformationPasses.h:708
llzk::registerRedundantReadAndWriteEliminationPassPass
void registerRedundantReadAndWriteEliminationPassPass()
Definition LLZKTransformationPasses.h:766
llzk::registerPCLLoweringPassPass
void registerPCLLoweringPassPass()
Definition LLZKTransformationPasses.h:698
llzk::createInlineStructsPass
std::unique_ptr< mlir::Pass > createInlineStructsPass()
Definition LLZKInlineStructsPass.cpp:1080
llzk::createR1CSLoweringPass
std::unique_ptr< mlir::Pass > createR1CSLoweringPass()
Definition LLZKR1CSLoweringPass.cpp:691
llzk::registerInlineStructsPass
void registerInlineStructsPass()
Definition LLZKTransformationPasses.h:674