LLZK 0.1.0
An open-source IR for Zero Knowledge (ZK) circuits
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_FUSEPRODUCTLOOPSPASS
7#define GEN_PASS_DECL_INLINESTRUCTSPASS
8#define GEN_PASS_DECL_PCLLOWERINGPASS
9#define GEN_PASS_DECL_POLYLOWERINGPASS
10#define GEN_PASS_DECL_R1CSLOWERINGPASS
11#define GEN_PASS_DECL_REDUNDANTOPERATIONELIMINATIONPASS
12#define GEN_PASS_DECL_REDUNDANTREADANDWRITEELIMINATIONPASS
13#define GEN_PASS_DECL_UNUSEDDECLARATIONELIMINATIONPASS
14#undef GEN_PASS_DECL
15#endif // GEN_PASS_DECL
16
17//===----------------------------------------------------------------------===//
18// ComputeConstrainToProductPass
19//===----------------------------------------------------------------------===//
20#ifdef GEN_PASS_DECL_COMPUTECONSTRAINTOPRODUCTPASS
21struct ComputeConstrainToProductPassOptions {
22 std::string rootStruct = "@Main";
23};
24#undef GEN_PASS_DECL_COMPUTECONSTRAINTOPRODUCTPASS
25#endif // GEN_PASS_DECL_COMPUTECONSTRAINTOPRODUCTPASS
26#ifdef GEN_PASS_DEF_COMPUTECONSTRAINTOPRODUCTPASS
27namespace impl {
28
29template <typename DerivedT>
30class ComputeConstrainToProductPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
31public:
32 using Base = ComputeConstrainToProductPassBase;
33
34 ComputeConstrainToProductPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
35 ComputeConstrainToProductPassBase(const ComputeConstrainToProductPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
36 ComputeConstrainToProductPassBase& operator=(const ComputeConstrainToProductPassBase &) = delete;
37 ComputeConstrainToProductPassBase(ComputeConstrainToProductPassBase &&) = delete;
38 ComputeConstrainToProductPassBase& operator=(ComputeConstrainToProductPassBase &&) = delete;
39 ~ComputeConstrainToProductPassBase() = default;
40
42 static constexpr ::llvm::StringLiteral getArgumentName() {
43 return ::llvm::StringLiteral("llzk-compute-constrain-to-product");
44 }
45 ::llvm::StringRef getArgument() const override { return "llzk-compute-constrain-to-product"; }
46
47 ::llvm::StringRef getDescription() const override { return "Replaces separate @compute and @constrain functions in a struct with a single @product function"; }
48
50 static constexpr ::llvm::StringLiteral getPassName() {
51 return ::llvm::StringLiteral("ComputeConstrainToProductPass");
52 }
53 ::llvm::StringRef getName() const override { return "ComputeConstrainToProductPass"; }
54
56 static bool classof(const ::mlir::Pass *pass) {
57 return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
58 }
59
61 std::unique_ptr<::mlir::Pass> clonePass() const override {
62 return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
63 }
64
66 void getDependentDialects(::mlir::DialectRegistry &registry) const override {
67 registry.insert<llzk::LLZKDialect>();
68 registry.insert<llzk::boolean::BoolDialect>();
69 registry.insert<llzk::array::ArrayDialect>();
70 registry.insert<llzk::component::StructDialect>();
71 registry.insert<llzk::constrain::ConstrainDialect>();
72 registry.insert<llzk::felt::FeltDialect>();
73 registry.insert<llzk::global::GlobalDialect>();
74 registry.insert<llzk::include::IncludeDialect>();
75 registry.insert<llzk::function::FunctionDialect>();
76 registry.insert<llzk::string::StringDialect>();
77 registry.insert<llzk::polymorphic::PolymorphicDialect>();
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// FuseProductLoopsPass
100//===----------------------------------------------------------------------===//
101#ifdef GEN_PASS_DECL_FUSEPRODUCTLOOPSPASS
102#undef GEN_PASS_DECL_FUSEPRODUCTLOOPSPASS
103#endif // GEN_PASS_DECL_FUSEPRODUCTLOOPSPASS
104#ifdef GEN_PASS_DEF_FUSEPRODUCTLOOPSPASS
105namespace impl {
106
107template <typename DerivedT>
108class FuseProductLoopsPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
109public:
110 using Base = FuseProductLoopsPassBase;
111
112 FuseProductLoopsPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
113 FuseProductLoopsPassBase(const FuseProductLoopsPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
114 FuseProductLoopsPassBase& operator=(const FuseProductLoopsPassBase &) = delete;
115 FuseProductLoopsPassBase(FuseProductLoopsPassBase &&) = delete;
116 FuseProductLoopsPassBase& operator=(FuseProductLoopsPassBase &&) = delete;
117 ~FuseProductLoopsPassBase() = default;
118
120 static constexpr ::llvm::StringLiteral getArgumentName() {
121 return ::llvm::StringLiteral("llzk-fuse-product-loops");
122 }
123 ::llvm::StringRef getArgument() const override { return "llzk-fuse-product-loops"; }
124
125 ::llvm::StringRef getDescription() const override { return "Fuses matching witness/constraint loops in a @product function"; }
126
128 static constexpr ::llvm::StringLiteral getPassName() {
129 return ::llvm::StringLiteral("FuseProductLoopsPass");
130 }
131 ::llvm::StringRef getName() const override { return "FuseProductLoopsPass"; }
132
134 static bool classof(const ::mlir::Pass *pass) {
135 return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
136 }
137
139 std::unique_ptr<::mlir::Pass> clonePass() const override {
140 return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
141 }
142
144 void getDependentDialects(::mlir::DialectRegistry &registry) const override {
145 registry.insert<llzk::LLZKDialect>();
146 registry.insert<llzk::boolean::BoolDialect>();
147 registry.insert<llzk::array::ArrayDialect>();
148 registry.insert<llzk::component::StructDialect>();
149 registry.insert<llzk::constrain::ConstrainDialect>();
150 registry.insert<llzk::felt::FeltDialect>();
151 registry.insert<llzk::global::GlobalDialect>();
152 registry.insert<llzk::include::IncludeDialect>();
153 registry.insert<llzk::function::FunctionDialect>();
154 registry.insert<llzk::string::StringDialect>();
155 registry.insert<llzk::polymorphic::PolymorphicDialect>();
156 registry.insert<mlir::arith::ArithDialect>();
157 registry.insert<mlir::scf::SCFDialect>();
158 }
159
163 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(FuseProductLoopsPassBase<DerivedT>)
164
165protected:
166private:
167};
168} // namespace impl
169#undef GEN_PASS_DEF_FUSEPRODUCTLOOPSPASS
170#endif // GEN_PASS_DEF_FUSEPRODUCTLOOPSPASS
171
172//===----------------------------------------------------------------------===//
173// InlineStructsPass
174//===----------------------------------------------------------------------===//
175#ifdef GEN_PASS_DECL_INLINESTRUCTSPASS
176struct InlineStructsPassOptions {
177 uint64_t maxComplexity = 0;
178};
179#undef GEN_PASS_DECL_INLINESTRUCTSPASS
180#endif // GEN_PASS_DECL_INLINESTRUCTSPASS
181#ifdef GEN_PASS_DEF_INLINESTRUCTSPASS
182namespace impl {
183
184template <typename DerivedT>
185class InlineStructsPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
186public:
187 using Base = InlineStructsPassBase;
188
189 InlineStructsPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
190 InlineStructsPassBase(const InlineStructsPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
191 InlineStructsPassBase& operator=(const InlineStructsPassBase &) = delete;
192 InlineStructsPassBase(InlineStructsPassBase &&) = delete;
193 InlineStructsPassBase& operator=(InlineStructsPassBase &&) = delete;
194 ~InlineStructsPassBase() = default;
195
197 static constexpr ::llvm::StringLiteral getArgumentName() {
198 return ::llvm::StringLiteral("llzk-inline-structs");
199 }
200 ::llvm::StringRef getArgument() const override { return "llzk-inline-structs"; }
201
202 ::llvm::StringRef getDescription() const override { return "Inlines nested structs (i.e., subcomponents)."; }
203
205 static constexpr ::llvm::StringLiteral getPassName() {
206 return ::llvm::StringLiteral("InlineStructsPass");
207 }
208 ::llvm::StringRef getName() const override { return "InlineStructsPass"; }
209
211 static bool classof(const ::mlir::Pass *pass) {
212 return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
213 }
214
216 std::unique_ptr<::mlir::Pass> clonePass() const override {
217 return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
218 }
219
221 void getDependentDialects(::mlir::DialectRegistry &registry) const override {
222 registry.insert<llzk::LLZKDialect>();
223 registry.insert<llzk::boolean::BoolDialect>();
224 registry.insert<llzk::array::ArrayDialect>();
225 registry.insert<llzk::component::StructDialect>();
226 registry.insert<llzk::constrain::ConstrainDialect>();
227 registry.insert<llzk::felt::FeltDialect>();
228 registry.insert<llzk::global::GlobalDialect>();
229 registry.insert<llzk::include::IncludeDialect>();
230 registry.insert<llzk::function::FunctionDialect>();
231 registry.insert<llzk::string::StringDialect>();
232 registry.insert<llzk::polymorphic::PolymorphicDialect>();
233 registry.insert<mlir::arith::ArithDialect>();
234 registry.insert<mlir::scf::SCFDialect>();
235 }
236
240 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(InlineStructsPassBase<DerivedT>)
241
242 InlineStructsPassBase(InlineStructsPassOptions options) : InlineStructsPassBase() {
243 maxComplexity = std::move(options.maxComplexity);
244 }
245protected:
246 ::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)};
247private:
248};
249} // namespace impl
250#undef GEN_PASS_DEF_INLINESTRUCTSPASS
251#endif // GEN_PASS_DEF_INLINESTRUCTSPASS
252
253//===----------------------------------------------------------------------===//
254// PCLLoweringPass
255//===----------------------------------------------------------------------===//
256#ifdef GEN_PASS_DECL_PCLLOWERINGPASS
257struct PCLLoweringPassOptions {
258 ::llvm::APInt prime = llvm::APInt(31, 2130706433);
259};
260#undef GEN_PASS_DECL_PCLLOWERINGPASS
261#endif // GEN_PASS_DECL_PCLLOWERINGPASS
262#ifdef GEN_PASS_DEF_PCLLOWERINGPASS
263namespace impl {
264
265template <typename DerivedT>
266class PCLLoweringPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
267public:
268 using Base = PCLLoweringPassBase;
269
270 PCLLoweringPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
271 PCLLoweringPassBase(const PCLLoweringPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
272 PCLLoweringPassBase& operator=(const PCLLoweringPassBase &) = delete;
273 PCLLoweringPassBase(PCLLoweringPassBase &&) = delete;
274 PCLLoweringPassBase& operator=(PCLLoweringPassBase &&) = delete;
275 ~PCLLoweringPassBase() = default;
276
278 static constexpr ::llvm::StringLiteral getArgumentName() {
279 return ::llvm::StringLiteral("llzk-to-pcl");
280 }
281 ::llvm::StringRef getArgument() const override { return "llzk-to-pcl"; }
282
283 ::llvm::StringRef getDescription() const override { return "Rewrites constraints to be compatible with PCL constraints used by Picus"; }
284
286 static constexpr ::llvm::StringLiteral getPassName() {
287 return ::llvm::StringLiteral("PCLLoweringPass");
288 }
289 ::llvm::StringRef getName() const override { return "PCLLoweringPass"; }
290
292 static bool classof(const ::mlir::Pass *pass) {
293 return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
294 }
295
297 std::unique_ptr<::mlir::Pass> clonePass() const override {
298 return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
299 }
300
302 void getDependentDialects(::mlir::DialectRegistry &registry) const override {
303 registry.insert<llzk::LLZKDialect>();
304 registry.insert<llzk::boolean::BoolDialect>();
305 registry.insert<llzk::array::ArrayDialect>();
306 registry.insert<llzk::component::StructDialect>();
307 registry.insert<llzk::constrain::ConstrainDialect>();
308 registry.insert<llzk::felt::FeltDialect>();
309 registry.insert<llzk::global::GlobalDialect>();
310 registry.insert<llzk::include::IncludeDialect>();
311 registry.insert<llzk::function::FunctionDialect>();
312 registry.insert<llzk::string::StringDialect>();
313 registry.insert<llzk::polymorphic::PolymorphicDialect>();
314 registry.insert<mlir::arith::ArithDialect>();
315 registry.insert<mlir::scf::SCFDialect>();
316 }
317
321 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(PCLLoweringPassBase<DerivedT>)
322
323 PCLLoweringPassBase(PCLLoweringPassOptions options) : PCLLoweringPassBase() {
324 prime = std::move(options.prime);
325 }
326protected:
327 ::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))};
328private:
329};
330} // namespace impl
331#undef GEN_PASS_DEF_PCLLOWERINGPASS
332#endif // GEN_PASS_DEF_PCLLOWERINGPASS
333
334//===----------------------------------------------------------------------===//
335// PolyLoweringPass
336//===----------------------------------------------------------------------===//
337#ifdef GEN_PASS_DECL_POLYLOWERINGPASS
338struct PolyLoweringPassOptions {
339 unsigned maxDegree = 2;
340};
341#undef GEN_PASS_DECL_POLYLOWERINGPASS
342#endif // GEN_PASS_DECL_POLYLOWERINGPASS
343#ifdef GEN_PASS_DEF_POLYLOWERINGPASS
344namespace impl {
345
346template <typename DerivedT>
347class PolyLoweringPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
348public:
349 using Base = PolyLoweringPassBase;
350
351 PolyLoweringPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
352 PolyLoweringPassBase(const PolyLoweringPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
353 PolyLoweringPassBase& operator=(const PolyLoweringPassBase &) = delete;
354 PolyLoweringPassBase(PolyLoweringPassBase &&) = delete;
355 PolyLoweringPassBase& operator=(PolyLoweringPassBase &&) = delete;
356 ~PolyLoweringPassBase() = default;
357
359 static constexpr ::llvm::StringLiteral getArgumentName() {
360 return ::llvm::StringLiteral("llzk-poly-lowering-pass");
361 }
362 ::llvm::StringRef getArgument() const override { return "llzk-poly-lowering-pass"; }
363
364 ::llvm::StringRef getDescription() const override { return "Lowers the degree of all polynomial equations to a specified maximum"; }
365
367 static constexpr ::llvm::StringLiteral getPassName() {
368 return ::llvm::StringLiteral("PolyLoweringPass");
369 }
370 ::llvm::StringRef getName() const override { return "PolyLoweringPass"; }
371
373 static bool classof(const ::mlir::Pass *pass) {
374 return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
375 }
376
378 std::unique_ptr<::mlir::Pass> clonePass() const override {
379 return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
380 }
381
383 void getDependentDialects(::mlir::DialectRegistry &registry) const override {
384 registry.insert<llzk::LLZKDialect>();
385 registry.insert<llzk::boolean::BoolDialect>();
386 registry.insert<llzk::array::ArrayDialect>();
387 registry.insert<llzk::component::StructDialect>();
388 registry.insert<llzk::constrain::ConstrainDialect>();
389 registry.insert<llzk::felt::FeltDialect>();
390 registry.insert<llzk::global::GlobalDialect>();
391 registry.insert<llzk::include::IncludeDialect>();
392 registry.insert<llzk::function::FunctionDialect>();
393 registry.insert<llzk::string::StringDialect>();
394 registry.insert<llzk::polymorphic::PolymorphicDialect>();
395 registry.insert<mlir::arith::ArithDialect>();
396 registry.insert<mlir::scf::SCFDialect>();
397 }
398
402 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(PolyLoweringPassBase<DerivedT>)
403
404 PolyLoweringPassBase(PolyLoweringPassOptions options) : PolyLoweringPassBase() {
405 maxDegree = std::move(options.maxDegree);
406 }
407protected:
408 ::mlir::Pass::Option<unsigned> maxDegree{*this, "max-degree", ::llvm::cl::desc("Maximum degree of constraint polynomials (default 2, minimum 2)"), ::llvm::cl::init(2)};
409private:
410};
411} // namespace impl
412#undef GEN_PASS_DEF_POLYLOWERINGPASS
413#endif // GEN_PASS_DEF_POLYLOWERINGPASS
414
415//===----------------------------------------------------------------------===//
416// R1CSLoweringPass
417//===----------------------------------------------------------------------===//
418#ifdef GEN_PASS_DECL_R1CSLOWERINGPASS
419#undef GEN_PASS_DECL_R1CSLOWERINGPASS
420#endif // GEN_PASS_DECL_R1CSLOWERINGPASS
421#ifdef GEN_PASS_DEF_R1CSLOWERINGPASS
422namespace impl {
423
424template <typename DerivedT>
425class R1CSLoweringPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
426public:
427 using Base = R1CSLoweringPassBase;
428
429 R1CSLoweringPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
430 R1CSLoweringPassBase(const R1CSLoweringPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
431 R1CSLoweringPassBase& operator=(const R1CSLoweringPassBase &) = delete;
432 R1CSLoweringPassBase(R1CSLoweringPassBase &&) = delete;
433 R1CSLoweringPassBase& operator=(R1CSLoweringPassBase &&) = delete;
434 ~R1CSLoweringPassBase() = default;
435
437 static constexpr ::llvm::StringLiteral getArgumentName() {
438 return ::llvm::StringLiteral("llzk-r1cs-lowering");
439 }
440 ::llvm::StringRef getArgument() const override { return "llzk-r1cs-lowering"; }
441
442 ::llvm::StringRef getDescription() const override { return "Rewrites constraints to be compatible with R1CS constraints i.e a*b - c = 0"; }
443
445 static constexpr ::llvm::StringLiteral getPassName() {
446 return ::llvm::StringLiteral("R1CSLoweringPass");
447 }
448 ::llvm::StringRef getName() const override { return "R1CSLoweringPass"; }
449
451 static bool classof(const ::mlir::Pass *pass) {
452 return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
453 }
454
456 std::unique_ptr<::mlir::Pass> clonePass() const override {
457 return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
458 }
459
461 void getDependentDialects(::mlir::DialectRegistry &registry) const override {
462 registry.insert<llzk::LLZKDialect>();
463 registry.insert<llzk::boolean::BoolDialect>();
464 registry.insert<llzk::array::ArrayDialect>();
465 registry.insert<llzk::component::StructDialect>();
466 registry.insert<llzk::constrain::ConstrainDialect>();
467 registry.insert<llzk::felt::FeltDialect>();
468 registry.insert<llzk::global::GlobalDialect>();
469 registry.insert<llzk::include::IncludeDialect>();
470 registry.insert<llzk::function::FunctionDialect>();
471 registry.insert<llzk::string::StringDialect>();
472 registry.insert<llzk::polymorphic::PolymorphicDialect>();
473 registry.insert<mlir::arith::ArithDialect>();
474 registry.insert<mlir::scf::SCFDialect>();
475 }
476
480 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(R1CSLoweringPassBase<DerivedT>)
481
482protected:
483private:
484};
485} // namespace impl
486#undef GEN_PASS_DEF_R1CSLOWERINGPASS
487#endif // GEN_PASS_DEF_R1CSLOWERINGPASS
488
489//===----------------------------------------------------------------------===//
490// RedundantOperationEliminationPass
491//===----------------------------------------------------------------------===//
492#ifdef GEN_PASS_DECL_REDUNDANTOPERATIONELIMINATIONPASS
493#undef GEN_PASS_DECL_REDUNDANTOPERATIONELIMINATIONPASS
494#endif // GEN_PASS_DECL_REDUNDANTOPERATIONELIMINATIONPASS
495#ifdef GEN_PASS_DEF_REDUNDANTOPERATIONELIMINATIONPASS
496namespace impl {
497
498template <typename DerivedT>
499class RedundantOperationEliminationPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
500public:
501 using Base = RedundantOperationEliminationPassBase;
502
503 RedundantOperationEliminationPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
504 RedundantOperationEliminationPassBase(const RedundantOperationEliminationPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
505 RedundantOperationEliminationPassBase& operator=(const RedundantOperationEliminationPassBase &) = delete;
506 RedundantOperationEliminationPassBase(RedundantOperationEliminationPassBase &&) = delete;
507 RedundantOperationEliminationPassBase& operator=(RedundantOperationEliminationPassBase &&) = delete;
508 ~RedundantOperationEliminationPassBase() = default;
509
511 static constexpr ::llvm::StringLiteral getArgumentName() {
512 return ::llvm::StringLiteral("llzk-duplicate-op-elim");
513 }
514 ::llvm::StringRef getArgument() const override { return "llzk-duplicate-op-elim"; }
515
516 ::llvm::StringRef getDescription() const override { return "Remove redundant operations"; }
517
519 static constexpr ::llvm::StringLiteral getPassName() {
520 return ::llvm::StringLiteral("RedundantOperationEliminationPass");
521 }
522 ::llvm::StringRef getName() const override { return "RedundantOperationEliminationPass"; }
523
525 static bool classof(const ::mlir::Pass *pass) {
526 return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
527 }
528
530 std::unique_ptr<::mlir::Pass> clonePass() const override {
531 return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
532 }
533
535 void getDependentDialects(::mlir::DialectRegistry &registry) const override {
536 registry.insert<llzk::LLZKDialect>();
537 registry.insert<llzk::boolean::BoolDialect>();
538 registry.insert<llzk::array::ArrayDialect>();
539 registry.insert<llzk::component::StructDialect>();
540 registry.insert<llzk::constrain::ConstrainDialect>();
541 registry.insert<llzk::felt::FeltDialect>();
542 registry.insert<llzk::global::GlobalDialect>();
543 registry.insert<llzk::include::IncludeDialect>();
544 registry.insert<llzk::function::FunctionDialect>();
545 registry.insert<llzk::string::StringDialect>();
546 registry.insert<llzk::polymorphic::PolymorphicDialect>();
547 registry.insert<mlir::arith::ArithDialect>();
548 registry.insert<mlir::scf::SCFDialect>();
549 }
550
554 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(RedundantOperationEliminationPassBase<DerivedT>)
555
556protected:
557private:
558};
559} // namespace impl
560#undef GEN_PASS_DEF_REDUNDANTOPERATIONELIMINATIONPASS
561#endif // GEN_PASS_DEF_REDUNDANTOPERATIONELIMINATIONPASS
562
563//===----------------------------------------------------------------------===//
564// RedundantReadAndWriteEliminationPass
565//===----------------------------------------------------------------------===//
566#ifdef GEN_PASS_DECL_REDUNDANTREADANDWRITEELIMINATIONPASS
567#undef GEN_PASS_DECL_REDUNDANTREADANDWRITEELIMINATIONPASS
568#endif // GEN_PASS_DECL_REDUNDANTREADANDWRITEELIMINATIONPASS
569#ifdef GEN_PASS_DEF_REDUNDANTREADANDWRITEELIMINATIONPASS
570namespace impl {
571
572template <typename DerivedT>
573class RedundantReadAndWriteEliminationPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
574public:
575 using Base = RedundantReadAndWriteEliminationPassBase;
576
577 RedundantReadAndWriteEliminationPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
578 RedundantReadAndWriteEliminationPassBase(const RedundantReadAndWriteEliminationPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
579 RedundantReadAndWriteEliminationPassBase& operator=(const RedundantReadAndWriteEliminationPassBase &) = delete;
580 RedundantReadAndWriteEliminationPassBase(RedundantReadAndWriteEliminationPassBase &&) = delete;
581 RedundantReadAndWriteEliminationPassBase& operator=(RedundantReadAndWriteEliminationPassBase &&) = delete;
582 ~RedundantReadAndWriteEliminationPassBase() = default;
583
585 static constexpr ::llvm::StringLiteral getArgumentName() {
586 return ::llvm::StringLiteral("llzk-duplicate-read-write-elim");
587 }
588 ::llvm::StringRef getArgument() const override { return "llzk-duplicate-read-write-elim"; }
589
590 ::llvm::StringRef getDescription() const override { return "Remove redundant reads and writes"; }
591
593 static constexpr ::llvm::StringLiteral getPassName() {
594 return ::llvm::StringLiteral("RedundantReadAndWriteEliminationPass");
595 }
596 ::llvm::StringRef getName() const override { return "RedundantReadAndWriteEliminationPass"; }
597
599 static bool classof(const ::mlir::Pass *pass) {
600 return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
601 }
602
604 std::unique_ptr<::mlir::Pass> clonePass() const override {
605 return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
606 }
607
609 void getDependentDialects(::mlir::DialectRegistry &registry) const override {
610 registry.insert<llzk::LLZKDialect>();
611 registry.insert<llzk::boolean::BoolDialect>();
612 registry.insert<llzk::array::ArrayDialect>();
613 registry.insert<llzk::component::StructDialect>();
614 registry.insert<llzk::constrain::ConstrainDialect>();
615 registry.insert<llzk::felt::FeltDialect>();
616 registry.insert<llzk::global::GlobalDialect>();
617 registry.insert<llzk::include::IncludeDialect>();
618 registry.insert<llzk::function::FunctionDialect>();
619 registry.insert<llzk::string::StringDialect>();
620 registry.insert<llzk::polymorphic::PolymorphicDialect>();
621 registry.insert<mlir::arith::ArithDialect>();
622 registry.insert<mlir::scf::SCFDialect>();
623 }
624
628 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(RedundantReadAndWriteEliminationPassBase<DerivedT>)
629
630protected:
631private:
632};
633} // namespace impl
634#undef GEN_PASS_DEF_REDUNDANTREADANDWRITEELIMINATIONPASS
635#endif // GEN_PASS_DEF_REDUNDANTREADANDWRITEELIMINATIONPASS
636
637//===----------------------------------------------------------------------===//
638// UnusedDeclarationEliminationPass
639//===----------------------------------------------------------------------===//
640#ifdef GEN_PASS_DECL_UNUSEDDECLARATIONELIMINATIONPASS
641struct UnusedDeclarationEliminationPassOptions {
642 bool removeStructs = false;
643};
644#undef GEN_PASS_DECL_UNUSEDDECLARATIONELIMINATIONPASS
645#endif // GEN_PASS_DECL_UNUSEDDECLARATIONELIMINATIONPASS
646#ifdef GEN_PASS_DEF_UNUSEDDECLARATIONELIMINATIONPASS
647namespace impl {
648
649template <typename DerivedT>
650class UnusedDeclarationEliminationPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
651public:
652 using Base = UnusedDeclarationEliminationPassBase;
653
654 UnusedDeclarationEliminationPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
655 UnusedDeclarationEliminationPassBase(const UnusedDeclarationEliminationPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
656 UnusedDeclarationEliminationPassBase& operator=(const UnusedDeclarationEliminationPassBase &) = delete;
657 UnusedDeclarationEliminationPassBase(UnusedDeclarationEliminationPassBase &&) = delete;
658 UnusedDeclarationEliminationPassBase& operator=(UnusedDeclarationEliminationPassBase &&) = delete;
659 ~UnusedDeclarationEliminationPassBase() = default;
660
662 static constexpr ::llvm::StringLiteral getArgumentName() {
663 return ::llvm::StringLiteral("llzk-unused-declaration-elim");
664 }
665 ::llvm::StringRef getArgument() const override { return "llzk-unused-declaration-elim"; }
666
667 ::llvm::StringRef getDescription() const override { return "Remove unused member and struct declarations"; }
668
670 static constexpr ::llvm::StringLiteral getPassName() {
671 return ::llvm::StringLiteral("UnusedDeclarationEliminationPass");
672 }
673 ::llvm::StringRef getName() const override { return "UnusedDeclarationEliminationPass"; }
674
676 static bool classof(const ::mlir::Pass *pass) {
677 return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
678 }
679
681 std::unique_ptr<::mlir::Pass> clonePass() const override {
682 return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
683 }
684
686 void getDependentDialects(::mlir::DialectRegistry &registry) const override {
687 registry.insert<llzk::LLZKDialect>();
688 registry.insert<llzk::boolean::BoolDialect>();
689 registry.insert<llzk::array::ArrayDialect>();
690 registry.insert<llzk::component::StructDialect>();
691 registry.insert<llzk::constrain::ConstrainDialect>();
692 registry.insert<llzk::felt::FeltDialect>();
693 registry.insert<llzk::global::GlobalDialect>();
694 registry.insert<llzk::include::IncludeDialect>();
695 registry.insert<llzk::function::FunctionDialect>();
696 registry.insert<llzk::string::StringDialect>();
697 registry.insert<llzk::polymorphic::PolymorphicDialect>();
698 registry.insert<mlir::arith::ArithDialect>();
699 registry.insert<mlir::scf::SCFDialect>();
700 }
701
705 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(UnusedDeclarationEliminationPassBase<DerivedT>)
706
707 UnusedDeclarationEliminationPassBase(UnusedDeclarationEliminationPassOptions options) : UnusedDeclarationEliminationPassBase() {
708 removeStructs = std::move(options.removeStructs);
709 }
710protected:
711 ::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)};
712private:
713};
714} // namespace impl
715#undef GEN_PASS_DEF_UNUSEDDECLARATIONELIMINATIONPASS
716#endif // GEN_PASS_DEF_UNUSEDDECLARATIONELIMINATIONPASS
717#ifdef GEN_PASS_REGISTRATION
718
719//===----------------------------------------------------------------------===//
720// ComputeConstrainToProductPass Registration
721//===----------------------------------------------------------------------===//
722
723inline void registerComputeConstrainToProductPass() {
724 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
725 return llzk::createComputeConstrainToProductPass();
726 });
727}
728
729// Old registration code, kept for temporary backwards compatibility.
730inline void registerComputeConstrainToProductPassPass() {
731 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
732 return llzk::createComputeConstrainToProductPass();
733 });
734}
735
736//===----------------------------------------------------------------------===//
737// FuseProductLoopsPass Registration
738//===----------------------------------------------------------------------===//
739
740inline void registerFuseProductLoopsPass() {
741 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
742 return llzk::createFuseProductLoopsPass();
743 });
744}
745
746// Old registration code, kept for temporary backwards compatibility.
747inline void registerFuseProductLoopsPassPass() {
748 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
749 return llzk::createFuseProductLoopsPass();
750 });
751}
752
753//===----------------------------------------------------------------------===//
754// InlineStructsPass Registration
755//===----------------------------------------------------------------------===//
756
757inline void registerInlineStructsPass() {
758 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
759 return llzk::createInlineStructsPass();
760 });
761}
762
763// Old registration code, kept for temporary backwards compatibility.
764inline void registerInlineStructsPassPass() {
765 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
766 return llzk::createInlineStructsPass();
767 });
768}
769
770//===----------------------------------------------------------------------===//
771// PCLLoweringPass Registration
772//===----------------------------------------------------------------------===//
773
774inline void registerPCLLoweringPass() {
775 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
776 return llzk::createPCLLoweringPass();
777 });
778}
779
780// Old registration code, kept for temporary backwards compatibility.
781inline void registerPCLLoweringPassPass() {
782 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
783 return llzk::createPCLLoweringPass();
784 });
785}
786
787//===----------------------------------------------------------------------===//
788// PolyLoweringPass Registration
789//===----------------------------------------------------------------------===//
790
791inline void registerPolyLoweringPass() {
792 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
793 return llzk::createPolyLoweringPass();
794 });
795}
796
797// Old registration code, kept for temporary backwards compatibility.
798inline void registerPolyLoweringPassPass() {
799 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
800 return llzk::createPolyLoweringPass();
801 });
802}
803
804//===----------------------------------------------------------------------===//
805// R1CSLoweringPass Registration
806//===----------------------------------------------------------------------===//
807
808inline void registerR1CSLoweringPass() {
809 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
810 return llzk::createR1CSLoweringPass();
811 });
812}
813
814// Old registration code, kept for temporary backwards compatibility.
815inline void registerR1CSLoweringPassPass() {
816 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
817 return llzk::createR1CSLoweringPass();
818 });
819}
820
821//===----------------------------------------------------------------------===//
822// RedundantOperationEliminationPass Registration
823//===----------------------------------------------------------------------===//
824
825inline void registerRedundantOperationEliminationPass() {
826 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
827 return llzk::createRedundantOperationEliminationPass();
828 });
829}
830
831// Old registration code, kept for temporary backwards compatibility.
832inline void registerRedundantOperationEliminationPassPass() {
833 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
834 return llzk::createRedundantOperationEliminationPass();
835 });
836}
837
838//===----------------------------------------------------------------------===//
839// RedundantReadAndWriteEliminationPass Registration
840//===----------------------------------------------------------------------===//
841
842inline void registerRedundantReadAndWriteEliminationPass() {
843 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
844 return llzk::createRedundantReadAndWriteEliminationPass();
845 });
846}
847
848// Old registration code, kept for temporary backwards compatibility.
849inline void registerRedundantReadAndWriteEliminationPassPass() {
850 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
851 return llzk::createRedundantReadAndWriteEliminationPass();
852 });
853}
854
855//===----------------------------------------------------------------------===//
856// UnusedDeclarationEliminationPass Registration
857//===----------------------------------------------------------------------===//
858
859inline void registerUnusedDeclarationEliminationPass() {
860 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
861 return llzk::createUnusedDeclarationEliminationPass();
862 });
863}
864
865// Old registration code, kept for temporary backwards compatibility.
866inline void registerUnusedDeclarationEliminationPassPass() {
867 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
868 return llzk::createUnusedDeclarationEliminationPass();
869 });
870}
871
872//===----------------------------------------------------------------------===//
873// Transformation Registration
874//===----------------------------------------------------------------------===//
875
876inline void registerTransformationPasses() {
877 registerComputeConstrainToProductPass();
878 registerFuseProductLoopsPass();
879 registerInlineStructsPass();
880 registerPCLLoweringPass();
881 registerPolyLoweringPass();
882 registerR1CSLoweringPass();
883 registerRedundantOperationEliminationPass();
884 registerRedundantReadAndWriteEliminationPass();
885 registerUnusedDeclarationEliminationPass();
886}
887#undef GEN_PASS_REGISTRATION
888#endif // GEN_PASS_REGISTRATION
889// Deprecated. Please use the new per-pass macros.
890#ifdef GEN_PASS_CLASSES
891
892template <typename DerivedT>
893class ComputeConstrainToProductPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
894public:
895 using Base = ComputeConstrainToProductPassBase;
896
897 ComputeConstrainToProductPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
898 ComputeConstrainToProductPassBase(const ComputeConstrainToProductPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
899 ComputeConstrainToProductPassBase& operator=(const ComputeConstrainToProductPassBase &) = delete;
900 ComputeConstrainToProductPassBase(ComputeConstrainToProductPassBase &&) = delete;
901 ComputeConstrainToProductPassBase& operator=(ComputeConstrainToProductPassBase &&) = delete;
902 ~ComputeConstrainToProductPassBase() = default;
903
905 static constexpr ::llvm::StringLiteral getArgumentName() {
906 return ::llvm::StringLiteral("llzk-compute-constrain-to-product");
907 }
908 ::llvm::StringRef getArgument() const override { return "llzk-compute-constrain-to-product"; }
909
910 ::llvm::StringRef getDescription() const override { return "Replaces separate @compute and @constrain functions in a struct with a single @product function"; }
911
913 static constexpr ::llvm::StringLiteral getPassName() {
914 return ::llvm::StringLiteral("ComputeConstrainToProductPass");
915 }
916 ::llvm::StringRef getName() const override { return "ComputeConstrainToProductPass"; }
917
919 static bool classof(const ::mlir::Pass *pass) {
920 return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
921 }
922
924 std::unique_ptr<::mlir::Pass> clonePass() const override {
925 return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
926 }
927
929 void getDependentDialects(::mlir::DialectRegistry &registry) const override {
930 registry.insert<llzk::LLZKDialect>();
931 registry.insert<llzk::boolean::BoolDialect>();
932 registry.insert<llzk::array::ArrayDialect>();
933 registry.insert<llzk::component::StructDialect>();
934 registry.insert<llzk::constrain::ConstrainDialect>();
935 registry.insert<llzk::felt::FeltDialect>();
936 registry.insert<llzk::global::GlobalDialect>();
937 registry.insert<llzk::include::IncludeDialect>();
938 registry.insert<llzk::function::FunctionDialect>();
939 registry.insert<llzk::string::StringDialect>();
940 registry.insert<llzk::polymorphic::PolymorphicDialect>();
941 registry.insert<mlir::arith::ArithDialect>();
942 registry.insert<mlir::scf::SCFDialect>();
943 }
944
948 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(ComputeConstrainToProductPassBase<DerivedT>)
949
950protected:
951 ::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")};
952};
953
954template <typename DerivedT>
955class FuseProductLoopsPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
956public:
957 using Base = FuseProductLoopsPassBase;
958
959 FuseProductLoopsPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
960 FuseProductLoopsPassBase(const FuseProductLoopsPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
961 FuseProductLoopsPassBase& operator=(const FuseProductLoopsPassBase &) = delete;
962 FuseProductLoopsPassBase(FuseProductLoopsPassBase &&) = delete;
963 FuseProductLoopsPassBase& operator=(FuseProductLoopsPassBase &&) = delete;
964 ~FuseProductLoopsPassBase() = default;
965
967 static constexpr ::llvm::StringLiteral getArgumentName() {
968 return ::llvm::StringLiteral("llzk-fuse-product-loops");
969 }
970 ::llvm::StringRef getArgument() const override { return "llzk-fuse-product-loops"; }
971
972 ::llvm::StringRef getDescription() const override { return "Fuses matching witness/constraint loops in a @product function"; }
973
975 static constexpr ::llvm::StringLiteral getPassName() {
976 return ::llvm::StringLiteral("FuseProductLoopsPass");
977 }
978 ::llvm::StringRef getName() const override { return "FuseProductLoopsPass"; }
979
981 static bool classof(const ::mlir::Pass *pass) {
982 return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
983 }
984
986 std::unique_ptr<::mlir::Pass> clonePass() const override {
987 return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
988 }
989
991 void getDependentDialects(::mlir::DialectRegistry &registry) const override {
992 registry.insert<llzk::LLZKDialect>();
993 registry.insert<llzk::boolean::BoolDialect>();
994 registry.insert<llzk::array::ArrayDialect>();
995 registry.insert<llzk::component::StructDialect>();
996 registry.insert<llzk::constrain::ConstrainDialect>();
997 registry.insert<llzk::felt::FeltDialect>();
998 registry.insert<llzk::global::GlobalDialect>();
999 registry.insert<llzk::include::IncludeDialect>();
1000 registry.insert<llzk::function::FunctionDialect>();
1001 registry.insert<llzk::string::StringDialect>();
1002 registry.insert<llzk::polymorphic::PolymorphicDialect>();
1003 registry.insert<mlir::arith::ArithDialect>();
1004 registry.insert<mlir::scf::SCFDialect>();
1005 }
1006
1010 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(FuseProductLoopsPassBase<DerivedT>)
1011
1012protected:
1013};
1014
1015template <typename DerivedT>
1016class InlineStructsPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
1017public:
1018 using Base = InlineStructsPassBase;
1019
1020 InlineStructsPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
1021 InlineStructsPassBase(const InlineStructsPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
1022 InlineStructsPassBase& operator=(const InlineStructsPassBase &) = delete;
1023 InlineStructsPassBase(InlineStructsPassBase &&) = delete;
1024 InlineStructsPassBase& operator=(InlineStructsPassBase &&) = delete;
1025 ~InlineStructsPassBase() = default;
1026
1028 static constexpr ::llvm::StringLiteral getArgumentName() {
1029 return ::llvm::StringLiteral("llzk-inline-structs");
1030 }
1031 ::llvm::StringRef getArgument() const override { return "llzk-inline-structs"; }
1032
1033 ::llvm::StringRef getDescription() const override { return "Inlines nested structs (i.e., subcomponents)."; }
1034
1036 static constexpr ::llvm::StringLiteral getPassName() {
1037 return ::llvm::StringLiteral("InlineStructsPass");
1038 }
1039 ::llvm::StringRef getName() const override { return "InlineStructsPass"; }
1040
1042 static bool classof(const ::mlir::Pass *pass) {
1043 return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
1044 }
1045
1047 std::unique_ptr<::mlir::Pass> clonePass() const override {
1048 return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
1049 }
1050
1052 void getDependentDialects(::mlir::DialectRegistry &registry) const override {
1053 registry.insert<llzk::LLZKDialect>();
1054 registry.insert<llzk::boolean::BoolDialect>();
1055 registry.insert<llzk::array::ArrayDialect>();
1056 registry.insert<llzk::component::StructDialect>();
1057 registry.insert<llzk::constrain::ConstrainDialect>();
1058 registry.insert<llzk::felt::FeltDialect>();
1059 registry.insert<llzk::global::GlobalDialect>();
1060 registry.insert<llzk::include::IncludeDialect>();
1061 registry.insert<llzk::function::FunctionDialect>();
1062 registry.insert<llzk::string::StringDialect>();
1063 registry.insert<llzk::polymorphic::PolymorphicDialect>();
1064 registry.insert<mlir::arith::ArithDialect>();
1065 registry.insert<mlir::scf::SCFDialect>();
1066 }
1067
1071 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(InlineStructsPassBase<DerivedT>)
1072
1073protected:
1074 ::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)};
1075};
1076
1077template <typename DerivedT>
1078class PCLLoweringPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
1079public:
1080 using Base = PCLLoweringPassBase;
1081
1082 PCLLoweringPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
1083 PCLLoweringPassBase(const PCLLoweringPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
1084 PCLLoweringPassBase& operator=(const PCLLoweringPassBase &) = delete;
1085 PCLLoweringPassBase(PCLLoweringPassBase &&) = delete;
1086 PCLLoweringPassBase& operator=(PCLLoweringPassBase &&) = delete;
1087 ~PCLLoweringPassBase() = default;
1088
1090 static constexpr ::llvm::StringLiteral getArgumentName() {
1091 return ::llvm::StringLiteral("llzk-to-pcl");
1092 }
1093 ::llvm::StringRef getArgument() const override { return "llzk-to-pcl"; }
1094
1095 ::llvm::StringRef getDescription() const override { return "Rewrites constraints to be compatible with PCL constraints used by Picus"; }
1096
1098 static constexpr ::llvm::StringLiteral getPassName() {
1099 return ::llvm::StringLiteral("PCLLoweringPass");
1100 }
1101 ::llvm::StringRef getName() const override { return "PCLLoweringPass"; }
1102
1104 static bool classof(const ::mlir::Pass *pass) {
1105 return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
1106 }
1107
1109 std::unique_ptr<::mlir::Pass> clonePass() const override {
1110 return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
1111 }
1112
1114 void getDependentDialects(::mlir::DialectRegistry &registry) const override {
1115 registry.insert<llzk::LLZKDialect>();
1116 registry.insert<llzk::boolean::BoolDialect>();
1117 registry.insert<llzk::array::ArrayDialect>();
1118 registry.insert<llzk::component::StructDialect>();
1119 registry.insert<llzk::constrain::ConstrainDialect>();
1120 registry.insert<llzk::felt::FeltDialect>();
1121 registry.insert<llzk::global::GlobalDialect>();
1122 registry.insert<llzk::include::IncludeDialect>();
1123 registry.insert<llzk::function::FunctionDialect>();
1124 registry.insert<llzk::string::StringDialect>();
1125 registry.insert<llzk::polymorphic::PolymorphicDialect>();
1126 registry.insert<mlir::arith::ArithDialect>();
1127 registry.insert<mlir::scf::SCFDialect>();
1128 }
1129
1133 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(PCLLoweringPassBase<DerivedT>)
1134
1135protected:
1136 ::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))};
1137};
1138
1139template <typename DerivedT>
1140class PolyLoweringPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
1141public:
1142 using Base = PolyLoweringPassBase;
1143
1144 PolyLoweringPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
1145 PolyLoweringPassBase(const PolyLoweringPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
1146 PolyLoweringPassBase& operator=(const PolyLoweringPassBase &) = delete;
1147 PolyLoweringPassBase(PolyLoweringPassBase &&) = delete;
1148 PolyLoweringPassBase& operator=(PolyLoweringPassBase &&) = delete;
1149 ~PolyLoweringPassBase() = default;
1150
1152 static constexpr ::llvm::StringLiteral getArgumentName() {
1153 return ::llvm::StringLiteral("llzk-poly-lowering-pass");
1154 }
1155 ::llvm::StringRef getArgument() const override { return "llzk-poly-lowering-pass"; }
1156
1157 ::llvm::StringRef getDescription() const override { return "Lowers the degree of all polynomial equations to a specified maximum"; }
1158
1160 static constexpr ::llvm::StringLiteral getPassName() {
1161 return ::llvm::StringLiteral("PolyLoweringPass");
1162 }
1163 ::llvm::StringRef getName() const override { return "PolyLoweringPass"; }
1164
1166 static bool classof(const ::mlir::Pass *pass) {
1167 return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
1168 }
1169
1171 std::unique_ptr<::mlir::Pass> clonePass() const override {
1172 return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
1173 }
1174
1176 void getDependentDialects(::mlir::DialectRegistry &registry) const override {
1177 registry.insert<llzk::LLZKDialect>();
1178 registry.insert<llzk::boolean::BoolDialect>();
1179 registry.insert<llzk::array::ArrayDialect>();
1180 registry.insert<llzk::component::StructDialect>();
1181 registry.insert<llzk::constrain::ConstrainDialect>();
1182 registry.insert<llzk::felt::FeltDialect>();
1183 registry.insert<llzk::global::GlobalDialect>();
1184 registry.insert<llzk::include::IncludeDialect>();
1185 registry.insert<llzk::function::FunctionDialect>();
1186 registry.insert<llzk::string::StringDialect>();
1187 registry.insert<llzk::polymorphic::PolymorphicDialect>();
1188 registry.insert<mlir::arith::ArithDialect>();
1189 registry.insert<mlir::scf::SCFDialect>();
1190 }
1191
1195 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(PolyLoweringPassBase<DerivedT>)
1196
1197protected:
1198 ::mlir::Pass::Option<unsigned> maxDegree{*this, "max-degree", ::llvm::cl::desc("Maximum degree of constraint polynomials (default 2, minimum 2)"), ::llvm::cl::init(2)};
1199};
1200
1201template <typename DerivedT>
1202class R1CSLoweringPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
1203public:
1204 using Base = R1CSLoweringPassBase;
1205
1206 R1CSLoweringPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
1207 R1CSLoweringPassBase(const R1CSLoweringPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
1208 R1CSLoweringPassBase& operator=(const R1CSLoweringPassBase &) = delete;
1209 R1CSLoweringPassBase(R1CSLoweringPassBase &&) = delete;
1210 R1CSLoweringPassBase& operator=(R1CSLoweringPassBase &&) = delete;
1211 ~R1CSLoweringPassBase() = default;
1212
1214 static constexpr ::llvm::StringLiteral getArgumentName() {
1215 return ::llvm::StringLiteral("llzk-r1cs-lowering");
1216 }
1217 ::llvm::StringRef getArgument() const override { return "llzk-r1cs-lowering"; }
1218
1219 ::llvm::StringRef getDescription() const override { return "Rewrites constraints to be compatible with R1CS constraints i.e a*b - c = 0"; }
1220
1222 static constexpr ::llvm::StringLiteral getPassName() {
1223 return ::llvm::StringLiteral("R1CSLoweringPass");
1224 }
1225 ::llvm::StringRef getName() const override { return "R1CSLoweringPass"; }
1226
1228 static bool classof(const ::mlir::Pass *pass) {
1229 return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
1230 }
1231
1233 std::unique_ptr<::mlir::Pass> clonePass() const override {
1234 return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
1235 }
1236
1238 void getDependentDialects(::mlir::DialectRegistry &registry) const override {
1239 registry.insert<llzk::LLZKDialect>();
1240 registry.insert<llzk::boolean::BoolDialect>();
1241 registry.insert<llzk::array::ArrayDialect>();
1242 registry.insert<llzk::component::StructDialect>();
1243 registry.insert<llzk::constrain::ConstrainDialect>();
1244 registry.insert<llzk::felt::FeltDialect>();
1245 registry.insert<llzk::global::GlobalDialect>();
1246 registry.insert<llzk::include::IncludeDialect>();
1247 registry.insert<llzk::function::FunctionDialect>();
1248 registry.insert<llzk::string::StringDialect>();
1249 registry.insert<llzk::polymorphic::PolymorphicDialect>();
1250 registry.insert<mlir::arith::ArithDialect>();
1251 registry.insert<mlir::scf::SCFDialect>();
1252 }
1253
1257 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(R1CSLoweringPassBase<DerivedT>)
1258
1259protected:
1260};
1261
1262template <typename DerivedT>
1263class RedundantOperationEliminationPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
1264public:
1265 using Base = RedundantOperationEliminationPassBase;
1266
1267 RedundantOperationEliminationPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
1268 RedundantOperationEliminationPassBase(const RedundantOperationEliminationPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
1269 RedundantOperationEliminationPassBase& operator=(const RedundantOperationEliminationPassBase &) = delete;
1270 RedundantOperationEliminationPassBase(RedundantOperationEliminationPassBase &&) = delete;
1271 RedundantOperationEliminationPassBase& operator=(RedundantOperationEliminationPassBase &&) = delete;
1272 ~RedundantOperationEliminationPassBase() = default;
1273
1275 static constexpr ::llvm::StringLiteral getArgumentName() {
1276 return ::llvm::StringLiteral("llzk-duplicate-op-elim");
1277 }
1278 ::llvm::StringRef getArgument() const override { return "llzk-duplicate-op-elim"; }
1279
1280 ::llvm::StringRef getDescription() const override { return "Remove redundant operations"; }
1281
1283 static constexpr ::llvm::StringLiteral getPassName() {
1284 return ::llvm::StringLiteral("RedundantOperationEliminationPass");
1285 }
1286 ::llvm::StringRef getName() const override { return "RedundantOperationEliminationPass"; }
1287
1289 static bool classof(const ::mlir::Pass *pass) {
1290 return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
1291 }
1292
1294 std::unique_ptr<::mlir::Pass> clonePass() const override {
1295 return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
1296 }
1297
1299 void getDependentDialects(::mlir::DialectRegistry &registry) const override {
1300 registry.insert<llzk::LLZKDialect>();
1301 registry.insert<llzk::boolean::BoolDialect>();
1302 registry.insert<llzk::array::ArrayDialect>();
1303 registry.insert<llzk::component::StructDialect>();
1304 registry.insert<llzk::constrain::ConstrainDialect>();
1305 registry.insert<llzk::felt::FeltDialect>();
1306 registry.insert<llzk::global::GlobalDialect>();
1307 registry.insert<llzk::include::IncludeDialect>();
1308 registry.insert<llzk::function::FunctionDialect>();
1309 registry.insert<llzk::string::StringDialect>();
1310 registry.insert<llzk::polymorphic::PolymorphicDialect>();
1311 registry.insert<mlir::arith::ArithDialect>();
1312 registry.insert<mlir::scf::SCFDialect>();
1313 }
1314
1318 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(RedundantOperationEliminationPassBase<DerivedT>)
1319
1320protected:
1321};
1322
1323template <typename DerivedT>
1324class RedundantReadAndWriteEliminationPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
1325public:
1326 using Base = RedundantReadAndWriteEliminationPassBase;
1327
1328 RedundantReadAndWriteEliminationPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
1329 RedundantReadAndWriteEliminationPassBase(const RedundantReadAndWriteEliminationPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
1330 RedundantReadAndWriteEliminationPassBase& operator=(const RedundantReadAndWriteEliminationPassBase &) = delete;
1331 RedundantReadAndWriteEliminationPassBase(RedundantReadAndWriteEliminationPassBase &&) = delete;
1332 RedundantReadAndWriteEliminationPassBase& operator=(RedundantReadAndWriteEliminationPassBase &&) = delete;
1333 ~RedundantReadAndWriteEliminationPassBase() = default;
1334
1336 static constexpr ::llvm::StringLiteral getArgumentName() {
1337 return ::llvm::StringLiteral("llzk-duplicate-read-write-elim");
1338 }
1339 ::llvm::StringRef getArgument() const override { return "llzk-duplicate-read-write-elim"; }
1340
1341 ::llvm::StringRef getDescription() const override { return "Remove redundant reads and writes"; }
1342
1344 static constexpr ::llvm::StringLiteral getPassName() {
1345 return ::llvm::StringLiteral("RedundantReadAndWriteEliminationPass");
1346 }
1347 ::llvm::StringRef getName() const override { return "RedundantReadAndWriteEliminationPass"; }
1348
1350 static bool classof(const ::mlir::Pass *pass) {
1351 return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
1352 }
1353
1355 std::unique_ptr<::mlir::Pass> clonePass() const override {
1356 return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
1357 }
1358
1360 void getDependentDialects(::mlir::DialectRegistry &registry) const override {
1361 registry.insert<llzk::LLZKDialect>();
1362 registry.insert<llzk::boolean::BoolDialect>();
1363 registry.insert<llzk::array::ArrayDialect>();
1364 registry.insert<llzk::component::StructDialect>();
1365 registry.insert<llzk::constrain::ConstrainDialect>();
1366 registry.insert<llzk::felt::FeltDialect>();
1367 registry.insert<llzk::global::GlobalDialect>();
1368 registry.insert<llzk::include::IncludeDialect>();
1369 registry.insert<llzk::function::FunctionDialect>();
1370 registry.insert<llzk::string::StringDialect>();
1371 registry.insert<llzk::polymorphic::PolymorphicDialect>();
1372 registry.insert<mlir::arith::ArithDialect>();
1373 registry.insert<mlir::scf::SCFDialect>();
1374 }
1375
1379 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(RedundantReadAndWriteEliminationPassBase<DerivedT>)
1380
1381protected:
1382};
1383
1384template <typename DerivedT>
1385class UnusedDeclarationEliminationPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
1386public:
1387 using Base = UnusedDeclarationEliminationPassBase;
1388
1389 UnusedDeclarationEliminationPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
1390 UnusedDeclarationEliminationPassBase(const UnusedDeclarationEliminationPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
1391 UnusedDeclarationEliminationPassBase& operator=(const UnusedDeclarationEliminationPassBase &) = delete;
1392 UnusedDeclarationEliminationPassBase(UnusedDeclarationEliminationPassBase &&) = delete;
1393 UnusedDeclarationEliminationPassBase& operator=(UnusedDeclarationEliminationPassBase &&) = delete;
1394 ~UnusedDeclarationEliminationPassBase() = default;
1395
1397 static constexpr ::llvm::StringLiteral getArgumentName() {
1398 return ::llvm::StringLiteral("llzk-unused-declaration-elim");
1399 }
1400 ::llvm::StringRef getArgument() const override { return "llzk-unused-declaration-elim"; }
1401
1402 ::llvm::StringRef getDescription() const override { return "Remove unused member and struct declarations"; }
1403
1405 static constexpr ::llvm::StringLiteral getPassName() {
1406 return ::llvm::StringLiteral("UnusedDeclarationEliminationPass");
1407 }
1408 ::llvm::StringRef getName() const override { return "UnusedDeclarationEliminationPass"; }
1409
1411 static bool classof(const ::mlir::Pass *pass) {
1412 return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
1413 }
1414
1416 std::unique_ptr<::mlir::Pass> clonePass() const override {
1417 return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
1418 }
1419
1421 void getDependentDialects(::mlir::DialectRegistry &registry) const override {
1422 registry.insert<llzk::LLZKDialect>();
1423 registry.insert<llzk::boolean::BoolDialect>();
1424 registry.insert<llzk::array::ArrayDialect>();
1425 registry.insert<llzk::component::StructDialect>();
1426 registry.insert<llzk::constrain::ConstrainDialect>();
1427 registry.insert<llzk::felt::FeltDialect>();
1428 registry.insert<llzk::global::GlobalDialect>();
1429 registry.insert<llzk::include::IncludeDialect>();
1430 registry.insert<llzk::function::FunctionDialect>();
1431 registry.insert<llzk::string::StringDialect>();
1432 registry.insert<llzk::polymorphic::PolymorphicDialect>();
1433 registry.insert<mlir::arith::ArithDialect>();
1434 registry.insert<mlir::scf::SCFDialect>();
1435 }
1436
1440 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(UnusedDeclarationEliminationPassBase<DerivedT>)
1441
1442protected:
1443 ::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)};
1444};
1445#undef GEN_PASS_CLASSES
1446#endif // GEN_PASS_CLASSES
llzk::array::registerTransformationPasses
void registerTransformationPasses()
Definition TransformationPasses.h:106
llzk::registerUnusedDeclarationEliminationPassPass
void registerUnusedDeclarationEliminationPassPass()
Definition LLZKTransformationPasses.h:867
llzk::createRedundantOperationEliminationPass
std::unique_ptr< mlir::Pass > createRedundantOperationEliminationPass()
Definition LLZKRedundantOperationEliminationPass.cpp:285
llzk::registerFuseProductLoopsPassPass
void registerFuseProductLoopsPassPass()
Definition LLZKTransformationPasses.h:748
llzk::registerR1CSLoweringPass
void registerR1CSLoweringPass()
Definition LLZKTransformationPasses.h:809
llzk::registerRedundantOperationEliminationPass
void registerRedundantOperationEliminationPass()
Definition LLZKTransformationPasses.h:826
llzk::createComputeConstrainToProductPass
std::unique_ptr< Pass > createComputeConstrainToProductPass()
Definition LLZKComputeConstrainToProductPass.cpp:242
llzk::registerPolyLoweringPassPass
void registerPolyLoweringPassPass()
Definition LLZKTransformationPasses.h:799
llzk::registerUnusedDeclarationEliminationPass
void registerUnusedDeclarationEliminationPass()
Definition LLZKTransformationPasses.h:860
llzk::registerComputeConstrainToProductPassPass
void registerComputeConstrainToProductPassPass()
Definition LLZKTransformationPasses.h:731
llzk::registerRedundantOperationEliminationPassPass
void registerRedundantOperationEliminationPassPass()
Definition LLZKTransformationPasses.h:833
llzk::registerPCLLoweringPass
void registerPCLLoweringPass()
Definition LLZKTransformationPasses.h:775
llzk::createRedundantReadAndWriteEliminationPass
std::unique_ptr< mlir::Pass > createRedundantReadAndWriteEliminationPass()
Definition LLZKRedundantReadAndWriteEliminationPass.cpp:680
llzk::registerR1CSLoweringPassPass
void registerR1CSLoweringPassPass()
Definition LLZKTransformationPasses.h:816
llzk::registerInlineStructsPassPass
void registerInlineStructsPassPass()
Definition LLZKTransformationPasses.h:765
llzk::createUnusedDeclarationEliminationPass
std::unique_ptr< mlir::Pass > createUnusedDeclarationEliminationPass()
Definition LLZKUnusedDeclarationEliminationPass.cpp:233
llzk::registerComputeConstrainToProductPass
void registerComputeConstrainToProductPass()
Definition LLZKTransformationPasses.h:724
llzk::createPolyLoweringPass
std::unique_ptr< mlir::Pass > createPolyLoweringPass()
Definition LLZKPolyLoweringPass.cpp:335
llzk::registerRedundantReadAndWriteEliminationPass
void registerRedundantReadAndWriteEliminationPass()
Definition LLZKTransformationPasses.h:843
llzk::registerPolyLoweringPass
void registerPolyLoweringPass()
Definition LLZKTransformationPasses.h:792
llzk::registerRedundantReadAndWriteEliminationPassPass
void registerRedundantReadAndWriteEliminationPassPass()
Definition LLZKTransformationPasses.h:850
llzk::registerPCLLoweringPassPass
void registerPCLLoweringPassPass()
Definition LLZKTransformationPasses.h:782
llzk::createInlineStructsPass
std::unique_ptr< mlir::Pass > createInlineStructsPass()
Definition LLZKInlineStructsPass.cpp:1086
llzk::createR1CSLoweringPass
std::unique_ptr< mlir::Pass > createR1CSLoweringPass()
Definition LLZKR1CSLoweringPass.cpp:692
llzk::createFuseProductLoopsPass
std::unique_ptr< mlir::Pass > createFuseProductLoopsPass()
Definition LLZKFuseProductLoopsPass.cpp:175
llzk::registerInlineStructsPass
void registerInlineStructsPass()
Definition LLZKTransformationPasses.h:758
llzk::registerFuseProductLoopsPass
void registerFuseProductLoopsPass()
Definition LLZKTransformationPasses.h:741