LLZK 3.0.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_ENFORCENOMEMBEROVERWRITEPASS
7#define GEN_PASS_DECL_FUSEPRODUCTCONTROLFLOWPASS
8#define GEN_PASS_DECL_INLINEFREEFUNCTIONSPASS
9#define GEN_PASS_DECL_POLYLOWERINGPASS
10#define GEN_PASS_DECL_REDUNDANTOPERATIONELIMINATIONPASS
11#define GEN_PASS_DECL_REDUNDANTREADANDWRITEELIMINATIONPASS
12#define GEN_PASS_DECL_REMOVEUNUSEDDISCARDABLEALLOCATIONSPASS
13#define GEN_PASS_DECL_UNUSEDDECLARATIONELIMINATIONPASS
14#define GEN_PASS_DECL_WHILETOFORPASS
15#undef GEN_PASS_DECL
16#endif // GEN_PASS_DECL
17
18//===----------------------------------------------------------------------===//
19// ComputeConstrainToProductPass
20//===----------------------------------------------------------------------===//
21#ifdef GEN_PASS_DECL_COMPUTECONSTRAINTOPRODUCTPASS
22struct ComputeConstrainToProductPassOptions {
23 std::string rootStruct = "Main";
24};
25std::unique_ptr<::mlir::Pass> createComputeConstrainToProductPass();
26std::unique_ptr<::mlir::Pass> createComputeConstrainToProductPass(ComputeConstrainToProductPassOptions options);
27#undef GEN_PASS_DECL_COMPUTECONSTRAINTOPRODUCTPASS
28#endif // GEN_PASS_DECL_COMPUTECONSTRAINTOPRODUCTPASS
29#ifdef GEN_PASS_DEF_COMPUTECONSTRAINTOPRODUCTPASS
30
31namespace impl {
32 std::unique_ptr<::mlir::Pass> createComputeConstrainToProductPass();
33} // namespace impl
34
35namespace impl {
36 std::unique_ptr<::mlir::Pass> createComputeConstrainToProductPass(ComputeConstrainToProductPassOptions options);
37} // namespace impl
38namespace impl {
39
40template <typename DerivedT>
41class ComputeConstrainToProductPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
42public:
43 using Base = ComputeConstrainToProductPassBase;
44
45 ComputeConstrainToProductPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
46 ComputeConstrainToProductPassBase(const ComputeConstrainToProductPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
47 ComputeConstrainToProductPassBase& operator=(const ComputeConstrainToProductPassBase &) = delete;
48 ComputeConstrainToProductPassBase(ComputeConstrainToProductPassBase &&) = delete;
49 ComputeConstrainToProductPassBase& operator=(ComputeConstrainToProductPassBase &&) = delete;
50 ~ComputeConstrainToProductPassBase() = default;
51
53 static constexpr ::llvm::StringLiteral getArgumentName() {
54 return ::llvm::StringLiteral("llzk-compute-constrain-to-product");
55 }
56 ::llvm::StringRef getArgument() const override { return "llzk-compute-constrain-to-product"; }
57
58 ::llvm::StringRef getDescription() const override { return R"PD(Replace separate `@compute` and `@constrain` functions in a struct with a single `@product` function)PD"; }
59
61 static constexpr ::llvm::StringLiteral getPassName() {
62 return ::llvm::StringLiteral("ComputeConstrainToProductPass");
63 }
64 ::llvm::StringRef getName() const override { return "ComputeConstrainToProductPass"; }
65
67 static bool classof(const ::mlir::Pass *pass) {
68 return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
69 }
70
72 std::unique_ptr<::mlir::Pass> clonePass() const override {
73 return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
74 }
75
77 void getDependentDialects(::mlir::DialectRegistry &registry) const override {
78 registry.insert<llzk::LLZKDialect>();
79 registry.insert<llzk::boolean::BoolDialect>();
80 registry.insert<llzk::array::ArrayDialect>();
81 registry.insert<llzk::component::StructDialect>();
82 registry.insert<llzk::constrain::ConstrainDialect>();
83 registry.insert<llzk::felt::FeltDialect>();
84 registry.insert<llzk::global::GlobalDialect>();
85 registry.insert<llzk::include::IncludeDialect>();
86 registry.insert<llzk::function::FunctionDialect>();
87 registry.insert<llzk::string::StringDialect>();
88 registry.insert<llzk::polymorphic::PolymorphicDialect>();
89 registry.insert<mlir::arith::ArithDialect>();
90 registry.insert<mlir::scf::SCFDialect>();
91 }
92
96 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(ComputeConstrainToProductPassBase<DerivedT>)
97
98 ComputeConstrainToProductPassBase(ComputeConstrainToProductPassOptions options) : ComputeConstrainToProductPassBase() {
99 rootStruct = std::move(options.rootStruct);
100 }
101protected:
102 ::mlir::Pass::Option<std::string> rootStruct{*this, "root-struct", ::llvm::cl::desc(R"PO(Root struct at which to start alignment (default to `@Main`))PO"), ::llvm::cl::init("Main")};
103private:
104
105 friend std::unique_ptr<::mlir::Pass> createComputeConstrainToProductPass() {
106 return std::make_unique<DerivedT>();
107 }
108
109 friend std::unique_ptr<::mlir::Pass> createComputeConstrainToProductPass(ComputeConstrainToProductPassOptions options) {
110 return std::make_unique<DerivedT>(std::move(options));
111 }
112};
113} // namespace impl
114
115std::unique_ptr<::mlir::Pass> createComputeConstrainToProductPass() {
116 return impl::createComputeConstrainToProductPass();
117}
118
119std::unique_ptr<::mlir::Pass> createComputeConstrainToProductPass(ComputeConstrainToProductPassOptions options) {
120 return impl::createComputeConstrainToProductPass(std::move(options));
121}
122#undef GEN_PASS_DEF_COMPUTECONSTRAINTOPRODUCTPASS
123#endif // GEN_PASS_DEF_COMPUTECONSTRAINTOPRODUCTPASS
124
125//===----------------------------------------------------------------------===//
126// EnforceNoMemberOverwritePass
127//===----------------------------------------------------------------------===//
128#ifdef GEN_PASS_DECL_ENFORCENOMEMBEROVERWRITEPASS
129std::unique_ptr<::mlir::Pass> createEnforceNoMemberOverwritePass();
130#undef GEN_PASS_DECL_ENFORCENOMEMBEROVERWRITEPASS
131#endif // GEN_PASS_DECL_ENFORCENOMEMBEROVERWRITEPASS
132#ifdef GEN_PASS_DEF_ENFORCENOMEMBEROVERWRITEPASS
133
134namespace impl {
135 std::unique_ptr<::mlir::Pass> createEnforceNoMemberOverwritePass();
136} // namespace impl
137namespace impl {
138
139template <typename DerivedT>
140class EnforceNoMemberOverwritePassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
141public:
142 using Base = EnforceNoMemberOverwritePassBase;
143
144 EnforceNoMemberOverwritePassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
145 EnforceNoMemberOverwritePassBase(const EnforceNoMemberOverwritePassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
146 EnforceNoMemberOverwritePassBase& operator=(const EnforceNoMemberOverwritePassBase &) = delete;
147 EnforceNoMemberOverwritePassBase(EnforceNoMemberOverwritePassBase &&) = delete;
148 EnforceNoMemberOverwritePassBase& operator=(EnforceNoMemberOverwritePassBase &&) = delete;
149 ~EnforceNoMemberOverwritePassBase() = default;
150
152 static constexpr ::llvm::StringLiteral getArgumentName() {
153 return ::llvm::StringLiteral("llzk-enforce-no-overwrite");
154 }
155 ::llvm::StringRef getArgument() const override { return "llzk-enforce-no-overwrite"; }
156
157 ::llvm::StringRef getDescription() const override { return R"PD(Checks that every struct member is written exactly once)PD"; }
158
160 static constexpr ::llvm::StringLiteral getPassName() {
161 return ::llvm::StringLiteral("EnforceNoMemberOverwritePass");
162 }
163 ::llvm::StringRef getName() const override { return "EnforceNoMemberOverwritePass"; }
164
166 static bool classof(const ::mlir::Pass *pass) {
167 return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
168 }
169
171 std::unique_ptr<::mlir::Pass> clonePass() const override {
172 return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
173 }
174
176 void getDependentDialects(::mlir::DialectRegistry &registry) const override {
177 registry.insert<llzk::LLZKDialect>();
178 registry.insert<llzk::boolean::BoolDialect>();
179 registry.insert<llzk::array::ArrayDialect>();
180 registry.insert<llzk::component::StructDialect>();
181 registry.insert<llzk::constrain::ConstrainDialect>();
182 registry.insert<llzk::felt::FeltDialect>();
183 registry.insert<llzk::global::GlobalDialect>();
184 registry.insert<llzk::include::IncludeDialect>();
185 registry.insert<llzk::function::FunctionDialect>();
186 registry.insert<llzk::string::StringDialect>();
187 registry.insert<llzk::polymorphic::PolymorphicDialect>();
188 registry.insert<mlir::arith::ArithDialect>();
189 registry.insert<mlir::scf::SCFDialect>();
190 }
191
195 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(EnforceNoMemberOverwritePassBase<DerivedT>)
196
197protected:
198private:
199
200 friend std::unique_ptr<::mlir::Pass> createEnforceNoMemberOverwritePass() {
201 return std::make_unique<DerivedT>();
202 }
203};
204} // namespace impl
205
206std::unique_ptr<::mlir::Pass> createEnforceNoMemberOverwritePass() {
207 return impl::createEnforceNoMemberOverwritePass();
208}
209#undef GEN_PASS_DEF_ENFORCENOMEMBEROVERWRITEPASS
210#endif // GEN_PASS_DEF_ENFORCENOMEMBEROVERWRITEPASS
211
212//===----------------------------------------------------------------------===//
213// FuseProductControlFlowPass
214//===----------------------------------------------------------------------===//
215#ifdef GEN_PASS_DECL_FUSEPRODUCTCONTROLFLOWPASS
216std::unique_ptr<::mlir::Pass> createFuseProductControlFlowPass();
217#undef GEN_PASS_DECL_FUSEPRODUCTCONTROLFLOWPASS
218#endif // GEN_PASS_DECL_FUSEPRODUCTCONTROLFLOWPASS
219#ifdef GEN_PASS_DEF_FUSEPRODUCTCONTROLFLOWPASS
220
221namespace impl {
222 std::unique_ptr<::mlir::Pass> createFuseProductControlFlowPass();
223} // namespace impl
224namespace impl {
225
226template <typename DerivedT>
227class FuseProductControlFlowPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
228public:
229 using Base = FuseProductControlFlowPassBase;
230
231 FuseProductControlFlowPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
232 FuseProductControlFlowPassBase(const FuseProductControlFlowPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
233 FuseProductControlFlowPassBase& operator=(const FuseProductControlFlowPassBase &) = delete;
234 FuseProductControlFlowPassBase(FuseProductControlFlowPassBase &&) = delete;
235 FuseProductControlFlowPassBase& operator=(FuseProductControlFlowPassBase &&) = delete;
236 ~FuseProductControlFlowPassBase() = default;
237
239 static constexpr ::llvm::StringLiteral getArgumentName() {
240 return ::llvm::StringLiteral("llzk-fuse-product-control-flow");
241 }
242 ::llvm::StringRef getArgument() const override { return "llzk-fuse-product-control-flow"; }
243
244 ::llvm::StringRef getDescription() const override { return R"PD(Fuse matching compute/constrain control flow in a `@product` function)PD"; }
245
247 static constexpr ::llvm::StringLiteral getPassName() {
248 return ::llvm::StringLiteral("FuseProductControlFlowPass");
249 }
250 ::llvm::StringRef getName() const override { return "FuseProductControlFlowPass"; }
251
253 static bool classof(const ::mlir::Pass *pass) {
254 return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
255 }
256
258 std::unique_ptr<::mlir::Pass> clonePass() const override {
259 return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
260 }
261
263 void getDependentDialects(::mlir::DialectRegistry &registry) const override {
264 registry.insert<llzk::LLZKDialect>();
265 registry.insert<llzk::boolean::BoolDialect>();
266 registry.insert<llzk::array::ArrayDialect>();
267 registry.insert<llzk::component::StructDialect>();
268 registry.insert<llzk::constrain::ConstrainDialect>();
269 registry.insert<llzk::felt::FeltDialect>();
270 registry.insert<llzk::global::GlobalDialect>();
271 registry.insert<llzk::include::IncludeDialect>();
272 registry.insert<llzk::function::FunctionDialect>();
273 registry.insert<llzk::string::StringDialect>();
274 registry.insert<llzk::polymorphic::PolymorphicDialect>();
275 registry.insert<mlir::arith::ArithDialect>();
276 registry.insert<mlir::scf::SCFDialect>();
277 }
278
282 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(FuseProductControlFlowPassBase<DerivedT>)
283
284protected:
285private:
286
287 friend std::unique_ptr<::mlir::Pass> createFuseProductControlFlowPass() {
288 return std::make_unique<DerivedT>();
289 }
290};
291} // namespace impl
292
293std::unique_ptr<::mlir::Pass> createFuseProductControlFlowPass() {
294 return impl::createFuseProductControlFlowPass();
295}
296#undef GEN_PASS_DEF_FUSEPRODUCTCONTROLFLOWPASS
297#endif // GEN_PASS_DEF_FUSEPRODUCTCONTROLFLOWPASS
298
299//===----------------------------------------------------------------------===//
300// InlineFreeFunctionsPass
301//===----------------------------------------------------------------------===//
302#ifdef GEN_PASS_DECL_INLINEFREEFUNCTIONSPASS
303std::unique_ptr<::mlir::Pass> createInlineFreeFunctionsPass();
304#undef GEN_PASS_DECL_INLINEFREEFUNCTIONSPASS
305#endif // GEN_PASS_DECL_INLINEFREEFUNCTIONSPASS
306#ifdef GEN_PASS_DEF_INLINEFREEFUNCTIONSPASS
307
308namespace impl {
309 std::unique_ptr<::mlir::Pass> createInlineFreeFunctionsPass();
310} // namespace impl
311namespace impl {
312
313template <typename DerivedT>
314class InlineFreeFunctionsPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
315public:
316 using Base = InlineFreeFunctionsPassBase;
317
318 InlineFreeFunctionsPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
319 InlineFreeFunctionsPassBase(const InlineFreeFunctionsPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
320 InlineFreeFunctionsPassBase& operator=(const InlineFreeFunctionsPassBase &) = delete;
321 InlineFreeFunctionsPassBase(InlineFreeFunctionsPassBase &&) = delete;
322 InlineFreeFunctionsPassBase& operator=(InlineFreeFunctionsPassBase &&) = delete;
323 ~InlineFreeFunctionsPassBase() = default;
324
326 static constexpr ::llvm::StringLiteral getArgumentName() {
327 return ::llvm::StringLiteral("llzk-inline-free-functions");
328 }
329 ::llvm::StringRef getArgument() const override { return "llzk-inline-free-functions"; }
330
331 ::llvm::StringRef getDescription() const override { return R"PD(Inline calls to free functions)PD"; }
332
334 static constexpr ::llvm::StringLiteral getPassName() {
335 return ::llvm::StringLiteral("InlineFreeFunctionsPass");
336 }
337 ::llvm::StringRef getName() const override { return "InlineFreeFunctionsPass"; }
338
340 static bool classof(const ::mlir::Pass *pass) {
341 return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
342 }
343
345 std::unique_ptr<::mlir::Pass> clonePass() const override {
346 return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
347 }
348
350 void getDependentDialects(::mlir::DialectRegistry &registry) const override {
351 registry.insert<llzk::LLZKDialect>();
352 registry.insert<llzk::boolean::BoolDialect>();
353 registry.insert<llzk::array::ArrayDialect>();
354 registry.insert<llzk::component::StructDialect>();
355 registry.insert<llzk::constrain::ConstrainDialect>();
356 registry.insert<llzk::felt::FeltDialect>();
357 registry.insert<llzk::global::GlobalDialect>();
358 registry.insert<llzk::include::IncludeDialect>();
359 registry.insert<llzk::function::FunctionDialect>();
360 registry.insert<llzk::string::StringDialect>();
361 registry.insert<llzk::polymorphic::PolymorphicDialect>();
362 registry.insert<mlir::arith::ArithDialect>();
363 registry.insert<mlir::scf::SCFDialect>();
364 }
365
369 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(InlineFreeFunctionsPassBase<DerivedT>)
370
371protected:
372private:
373
374 friend std::unique_ptr<::mlir::Pass> createInlineFreeFunctionsPass() {
375 return std::make_unique<DerivedT>();
376 }
377};
378} // namespace impl
379
380std::unique_ptr<::mlir::Pass> createInlineFreeFunctionsPass() {
381 return impl::createInlineFreeFunctionsPass();
382}
383#undef GEN_PASS_DEF_INLINEFREEFUNCTIONSPASS
384#endif // GEN_PASS_DEF_INLINEFREEFUNCTIONSPASS
385
386//===----------------------------------------------------------------------===//
387// PolyLoweringPass
388//===----------------------------------------------------------------------===//
389#ifdef GEN_PASS_DECL_POLYLOWERINGPASS
390struct PolyLoweringPassOptions {
391 unsigned maxDegree = 2;
392};
393std::unique_ptr<::mlir::Pass> createPolyLoweringPass();
394std::unique_ptr<::mlir::Pass> createPolyLoweringPass(PolyLoweringPassOptions options);
395#undef GEN_PASS_DECL_POLYLOWERINGPASS
396#endif // GEN_PASS_DECL_POLYLOWERINGPASS
397#ifdef GEN_PASS_DEF_POLYLOWERINGPASS
398
399namespace impl {
400 std::unique_ptr<::mlir::Pass> createPolyLoweringPass();
401} // namespace impl
402
403namespace impl {
404 std::unique_ptr<::mlir::Pass> createPolyLoweringPass(PolyLoweringPassOptions options);
405} // namespace impl
406namespace impl {
407
408template <typename DerivedT>
409class PolyLoweringPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
410public:
411 using Base = PolyLoweringPassBase;
412
413 PolyLoweringPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
414 PolyLoweringPassBase(const PolyLoweringPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
415 PolyLoweringPassBase& operator=(const PolyLoweringPassBase &) = delete;
416 PolyLoweringPassBase(PolyLoweringPassBase &&) = delete;
417 PolyLoweringPassBase& operator=(PolyLoweringPassBase &&) = delete;
418 ~PolyLoweringPassBase() = default;
419
421 static constexpr ::llvm::StringLiteral getArgumentName() {
422 return ::llvm::StringLiteral("llzk-poly-lowering-pass");
423 }
424 ::llvm::StringRef getArgument() const override { return "llzk-poly-lowering-pass"; }
425
426 ::llvm::StringRef getDescription() const override { return R"PD(Lower the degree of all polynomial equations to a specified maximum)PD"; }
427
429 static constexpr ::llvm::StringLiteral getPassName() {
430 return ::llvm::StringLiteral("PolyLoweringPass");
431 }
432 ::llvm::StringRef getName() const override { return "PolyLoweringPass"; }
433
435 static bool classof(const ::mlir::Pass *pass) {
436 return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
437 }
438
440 std::unique_ptr<::mlir::Pass> clonePass() const override {
441 return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
442 }
443
445 void getDependentDialects(::mlir::DialectRegistry &registry) const override {
446 registry.insert<llzk::LLZKDialect>();
447 registry.insert<llzk::boolean::BoolDialect>();
448 registry.insert<llzk::array::ArrayDialect>();
449 registry.insert<llzk::component::StructDialect>();
450 registry.insert<llzk::constrain::ConstrainDialect>();
451 registry.insert<llzk::felt::FeltDialect>();
452 registry.insert<llzk::global::GlobalDialect>();
453 registry.insert<llzk::include::IncludeDialect>();
454 registry.insert<llzk::function::FunctionDialect>();
455 registry.insert<llzk::string::StringDialect>();
456 registry.insert<llzk::polymorphic::PolymorphicDialect>();
457 registry.insert<mlir::arith::ArithDialect>();
458 registry.insert<mlir::scf::SCFDialect>();
459 }
460
464 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(PolyLoweringPassBase<DerivedT>)
465
466 PolyLoweringPassBase(PolyLoweringPassOptions options) : PolyLoweringPassBase() {
467 maxDegree = std::move(options.maxDegree);
468 }
469protected:
470 ::mlir::Pass::Option<unsigned> maxDegree{*this, "max-degree", ::llvm::cl::desc(R"PO(Maximum degree of constraint polynomials (default 2, minimum 2))PO"), ::llvm::cl::init(2)};
471private:
472
473 friend std::unique_ptr<::mlir::Pass> createPolyLoweringPass() {
474 return std::make_unique<DerivedT>();
475 }
476
477 friend std::unique_ptr<::mlir::Pass> createPolyLoweringPass(PolyLoweringPassOptions options) {
478 return std::make_unique<DerivedT>(std::move(options));
479 }
480};
481} // namespace impl
482
483std::unique_ptr<::mlir::Pass> createPolyLoweringPass() {
484 return impl::createPolyLoweringPass();
485}
486
487std::unique_ptr<::mlir::Pass> createPolyLoweringPass(PolyLoweringPassOptions options) {
488 return impl::createPolyLoweringPass(std::move(options));
489}
490#undef GEN_PASS_DEF_POLYLOWERINGPASS
491#endif // GEN_PASS_DEF_POLYLOWERINGPASS
492
493//===----------------------------------------------------------------------===//
494// RedundantOperationEliminationPass
495//===----------------------------------------------------------------------===//
496#ifdef GEN_PASS_DECL_REDUNDANTOPERATIONELIMINATIONPASS
497std::unique_ptr<::mlir::Pass> createRedundantOperationEliminationPass();
498#undef GEN_PASS_DECL_REDUNDANTOPERATIONELIMINATIONPASS
499#endif // GEN_PASS_DECL_REDUNDANTOPERATIONELIMINATIONPASS
500#ifdef GEN_PASS_DEF_REDUNDANTOPERATIONELIMINATIONPASS
501
502namespace impl {
503 std::unique_ptr<::mlir::Pass> createRedundantOperationEliminationPass();
504} // namespace impl
505namespace impl {
506
507template <typename DerivedT>
508class RedundantOperationEliminationPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
509public:
510 using Base = RedundantOperationEliminationPassBase;
511
512 RedundantOperationEliminationPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
513 RedundantOperationEliminationPassBase(const RedundantOperationEliminationPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
514 RedundantOperationEliminationPassBase& operator=(const RedundantOperationEliminationPassBase &) = delete;
515 RedundantOperationEliminationPassBase(RedundantOperationEliminationPassBase &&) = delete;
516 RedundantOperationEliminationPassBase& operator=(RedundantOperationEliminationPassBase &&) = delete;
517 ~RedundantOperationEliminationPassBase() = default;
518
520 static constexpr ::llvm::StringLiteral getArgumentName() {
521 return ::llvm::StringLiteral("llzk-duplicate-op-elim");
522 }
523 ::llvm::StringRef getArgument() const override { return "llzk-duplicate-op-elim"; }
524
525 ::llvm::StringRef getDescription() const override { return R"PD(Remove redundant operations)PD"; }
526
528 static constexpr ::llvm::StringLiteral getPassName() {
529 return ::llvm::StringLiteral("RedundantOperationEliminationPass");
530 }
531 ::llvm::StringRef getName() const override { return "RedundantOperationEliminationPass"; }
532
534 static bool classof(const ::mlir::Pass *pass) {
535 return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
536 }
537
539 std::unique_ptr<::mlir::Pass> clonePass() const override {
540 return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
541 }
542
544 void getDependentDialects(::mlir::DialectRegistry &registry) const override {
545 registry.insert<llzk::LLZKDialect>();
546 registry.insert<llzk::boolean::BoolDialect>();
547 registry.insert<llzk::array::ArrayDialect>();
548 registry.insert<llzk::component::StructDialect>();
549 registry.insert<llzk::constrain::ConstrainDialect>();
550 registry.insert<llzk::felt::FeltDialect>();
551 registry.insert<llzk::global::GlobalDialect>();
552 registry.insert<llzk::include::IncludeDialect>();
553 registry.insert<llzk::function::FunctionDialect>();
554 registry.insert<llzk::string::StringDialect>();
555 registry.insert<llzk::polymorphic::PolymorphicDialect>();
556 registry.insert<mlir::arith::ArithDialect>();
557 registry.insert<mlir::scf::SCFDialect>();
558 }
559
563 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(RedundantOperationEliminationPassBase<DerivedT>)
564
565protected:
566private:
567
568 friend std::unique_ptr<::mlir::Pass> createRedundantOperationEliminationPass() {
569 return std::make_unique<DerivedT>();
570 }
571};
572} // namespace impl
573
574std::unique_ptr<::mlir::Pass> createRedundantOperationEliminationPass() {
575 return impl::createRedundantOperationEliminationPass();
576}
577#undef GEN_PASS_DEF_REDUNDANTOPERATIONELIMINATIONPASS
578#endif // GEN_PASS_DEF_REDUNDANTOPERATIONELIMINATIONPASS
579
580//===----------------------------------------------------------------------===//
581// RedundantReadAndWriteEliminationPass
582//===----------------------------------------------------------------------===//
583#ifdef GEN_PASS_DECL_REDUNDANTREADANDWRITEELIMINATIONPASS
584std::unique_ptr<::mlir::Pass> createRedundantReadAndWriteEliminationPass();
585#undef GEN_PASS_DECL_REDUNDANTREADANDWRITEELIMINATIONPASS
586#endif // GEN_PASS_DECL_REDUNDANTREADANDWRITEELIMINATIONPASS
587#ifdef GEN_PASS_DEF_REDUNDANTREADANDWRITEELIMINATIONPASS
588
589namespace impl {
590 std::unique_ptr<::mlir::Pass> createRedundantReadAndWriteEliminationPass();
591} // namespace impl
592namespace impl {
593
594template <typename DerivedT>
595class RedundantReadAndWriteEliminationPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
596public:
597 using Base = RedundantReadAndWriteEliminationPassBase;
598
599 RedundantReadAndWriteEliminationPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
600 RedundantReadAndWriteEliminationPassBase(const RedundantReadAndWriteEliminationPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
601 RedundantReadAndWriteEliminationPassBase& operator=(const RedundantReadAndWriteEliminationPassBase &) = delete;
602 RedundantReadAndWriteEliminationPassBase(RedundantReadAndWriteEliminationPassBase &&) = delete;
603 RedundantReadAndWriteEliminationPassBase& operator=(RedundantReadAndWriteEliminationPassBase &&) = delete;
604 ~RedundantReadAndWriteEliminationPassBase() = default;
605
607 static constexpr ::llvm::StringLiteral getArgumentName() {
608 return ::llvm::StringLiteral("llzk-duplicate-read-write-elim");
609 }
610 ::llvm::StringRef getArgument() const override { return "llzk-duplicate-read-write-elim"; }
611
612 ::llvm::StringRef getDescription() const override { return R"PD(Remove redundant reads and writes)PD"; }
613
615 static constexpr ::llvm::StringLiteral getPassName() {
616 return ::llvm::StringLiteral("RedundantReadAndWriteEliminationPass");
617 }
618 ::llvm::StringRef getName() const override { return "RedundantReadAndWriteEliminationPass"; }
619
621 static bool classof(const ::mlir::Pass *pass) {
622 return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
623 }
624
626 std::unique_ptr<::mlir::Pass> clonePass() const override {
627 return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
628 }
629
631 void getDependentDialects(::mlir::DialectRegistry &registry) const override {
632 registry.insert<llzk::LLZKDialect>();
633 registry.insert<llzk::boolean::BoolDialect>();
634 registry.insert<llzk::array::ArrayDialect>();
635 registry.insert<llzk::component::StructDialect>();
636 registry.insert<llzk::constrain::ConstrainDialect>();
637 registry.insert<llzk::felt::FeltDialect>();
638 registry.insert<llzk::global::GlobalDialect>();
639 registry.insert<llzk::include::IncludeDialect>();
640 registry.insert<llzk::function::FunctionDialect>();
641 registry.insert<llzk::string::StringDialect>();
642 registry.insert<llzk::polymorphic::PolymorphicDialect>();
643 registry.insert<mlir::arith::ArithDialect>();
644 registry.insert<mlir::scf::SCFDialect>();
645 }
646
650 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(RedundantReadAndWriteEliminationPassBase<DerivedT>)
651
652protected:
653private:
654
655 friend std::unique_ptr<::mlir::Pass> createRedundantReadAndWriteEliminationPass() {
656 return std::make_unique<DerivedT>();
657 }
658};
659} // namespace impl
660
661std::unique_ptr<::mlir::Pass> createRedundantReadAndWriteEliminationPass() {
662 return impl::createRedundantReadAndWriteEliminationPass();
663}
664#undef GEN_PASS_DEF_REDUNDANTREADANDWRITEELIMINATIONPASS
665#endif // GEN_PASS_DEF_REDUNDANTREADANDWRITEELIMINATIONPASS
666
667//===----------------------------------------------------------------------===//
668// RemoveUnusedDiscardableAllocationsPass
669//===----------------------------------------------------------------------===//
670#ifdef GEN_PASS_DECL_REMOVEUNUSEDDISCARDABLEALLOCATIONSPASS
671struct RemoveUnusedDiscardableAllocationsPassOptions {
672 std::string allocatorOpName = "";
673};
674std::unique_ptr<::mlir::Pass> createRemoveUnusedDiscardableAllocationsPass();
675std::unique_ptr<::mlir::Pass> createRemoveUnusedDiscardableAllocationsPass(RemoveUnusedDiscardableAllocationsPassOptions options);
676#undef GEN_PASS_DECL_REMOVEUNUSEDDISCARDABLEALLOCATIONSPASS
677#endif // GEN_PASS_DECL_REMOVEUNUSEDDISCARDABLEALLOCATIONSPASS
678#ifdef GEN_PASS_DEF_REMOVEUNUSEDDISCARDABLEALLOCATIONSPASS
679
680namespace impl {
681 std::unique_ptr<::mlir::Pass> createRemoveUnusedDiscardableAllocationsPass();
682} // namespace impl
683
684namespace impl {
685 std::unique_ptr<::mlir::Pass> createRemoveUnusedDiscardableAllocationsPass(RemoveUnusedDiscardableAllocationsPassOptions options);
686} // namespace impl
687namespace impl {
688
689template <typename DerivedT>
690class RemoveUnusedDiscardableAllocationsPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
691public:
692 using Base = RemoveUnusedDiscardableAllocationsPassBase;
693
694 RemoveUnusedDiscardableAllocationsPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
695 RemoveUnusedDiscardableAllocationsPassBase(const RemoveUnusedDiscardableAllocationsPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
696 RemoveUnusedDiscardableAllocationsPassBase& operator=(const RemoveUnusedDiscardableAllocationsPassBase &) = delete;
697 RemoveUnusedDiscardableAllocationsPassBase(RemoveUnusedDiscardableAllocationsPassBase &&) = delete;
698 RemoveUnusedDiscardableAllocationsPassBase& operator=(RemoveUnusedDiscardableAllocationsPassBase &&) = delete;
699 ~RemoveUnusedDiscardableAllocationsPassBase() = default;
700
702 static constexpr ::llvm::StringLiteral getArgumentName() {
703 return ::llvm::StringLiteral("llzk-remove-unused-discardable-allocations");
704 }
705 ::llvm::StringRef getArgument() const override { return "llzk-remove-unused-discardable-allocations"; }
706
707 ::llvm::StringRef getDescription() const override { return R"PD(Remove unread discardable allocations and their dead stores)PD"; }
708
710 static constexpr ::llvm::StringLiteral getPassName() {
711 return ::llvm::StringLiteral("RemoveUnusedDiscardableAllocationsPass");
712 }
713 ::llvm::StringRef getName() const override { return "RemoveUnusedDiscardableAllocationsPass"; }
714
716 static bool classof(const ::mlir::Pass *pass) {
717 return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
718 }
719
721 std::unique_ptr<::mlir::Pass> clonePass() const override {
722 return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
723 }
724
726 void getDependentDialects(::mlir::DialectRegistry &registry) const override {
727 registry.insert<llzk::LLZKDialect>();
728 registry.insert<llzk::boolean::BoolDialect>();
729 registry.insert<llzk::array::ArrayDialect>();
730 registry.insert<llzk::component::StructDialect>();
731 registry.insert<llzk::constrain::ConstrainDialect>();
732 registry.insert<llzk::felt::FeltDialect>();
733 registry.insert<llzk::global::GlobalDialect>();
734 registry.insert<llzk::include::IncludeDialect>();
735 registry.insert<llzk::function::FunctionDialect>();
736 registry.insert<llzk::string::StringDialect>();
737 registry.insert<llzk::polymorphic::PolymorphicDialect>();
738 registry.insert<mlir::arith::ArithDialect>();
739 registry.insert<mlir::scf::SCFDialect>();
740 }
741
745 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(RemoveUnusedDiscardableAllocationsPassBase<DerivedT>)
746
747 RemoveUnusedDiscardableAllocationsPassBase(RemoveUnusedDiscardableAllocationsPassOptions options) : RemoveUnusedDiscardableAllocationsPassBase() {
748 allocatorOpName = std::move(options.allocatorOpName);
749 }
750protected:
751 ::mlir::Pass::Option<std::string> allocatorOpName{*this, "allocator-op", ::llvm::cl::desc(R"PO(Operation name of the discardable allocator to remove)PO"), ::llvm::cl::init("")};
752private:
753
754 friend std::unique_ptr<::mlir::Pass> createRemoveUnusedDiscardableAllocationsPass() {
755 return std::make_unique<DerivedT>();
756 }
757
758 friend std::unique_ptr<::mlir::Pass> createRemoveUnusedDiscardableAllocationsPass(RemoveUnusedDiscardableAllocationsPassOptions options) {
759 return std::make_unique<DerivedT>(std::move(options));
760 }
761};
762} // namespace impl
763
764std::unique_ptr<::mlir::Pass> createRemoveUnusedDiscardableAllocationsPass() {
765 return impl::createRemoveUnusedDiscardableAllocationsPass();
766}
767
768std::unique_ptr<::mlir::Pass> createRemoveUnusedDiscardableAllocationsPass(RemoveUnusedDiscardableAllocationsPassOptions options) {
769 return impl::createRemoveUnusedDiscardableAllocationsPass(std::move(options));
770}
771#undef GEN_PASS_DEF_REMOVEUNUSEDDISCARDABLEALLOCATIONSPASS
772#endif // GEN_PASS_DEF_REMOVEUNUSEDDISCARDABLEALLOCATIONSPASS
773
774//===----------------------------------------------------------------------===//
775// UnusedDeclarationEliminationPass
776//===----------------------------------------------------------------------===//
777#ifdef GEN_PASS_DECL_UNUSEDDECLARATIONELIMINATIONPASS
778struct UnusedDeclarationEliminationPassOptions {
779 bool removeStructs = false;
780};
781std::unique_ptr<::mlir::Pass> createUnusedDeclarationEliminationPass();
782std::unique_ptr<::mlir::Pass> createUnusedDeclarationEliminationPass(UnusedDeclarationEliminationPassOptions options);
783#undef GEN_PASS_DECL_UNUSEDDECLARATIONELIMINATIONPASS
784#endif // GEN_PASS_DECL_UNUSEDDECLARATIONELIMINATIONPASS
785#ifdef GEN_PASS_DEF_UNUSEDDECLARATIONELIMINATIONPASS
786
787namespace impl {
788 std::unique_ptr<::mlir::Pass> createUnusedDeclarationEliminationPass();
789} // namespace impl
790
791namespace impl {
792 std::unique_ptr<::mlir::Pass> createUnusedDeclarationEliminationPass(UnusedDeclarationEliminationPassOptions options);
793} // namespace impl
794namespace impl {
795
796template <typename DerivedT>
797class UnusedDeclarationEliminationPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
798public:
799 using Base = UnusedDeclarationEliminationPassBase;
800
801 UnusedDeclarationEliminationPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
802 UnusedDeclarationEliminationPassBase(const UnusedDeclarationEliminationPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
803 UnusedDeclarationEliminationPassBase& operator=(const UnusedDeclarationEliminationPassBase &) = delete;
804 UnusedDeclarationEliminationPassBase(UnusedDeclarationEliminationPassBase &&) = delete;
805 UnusedDeclarationEliminationPassBase& operator=(UnusedDeclarationEliminationPassBase &&) = delete;
806 ~UnusedDeclarationEliminationPassBase() = default;
807
809 static constexpr ::llvm::StringLiteral getArgumentName() {
810 return ::llvm::StringLiteral("llzk-unused-declaration-elim");
811 }
812 ::llvm::StringRef getArgument() const override { return "llzk-unused-declaration-elim"; }
813
814 ::llvm::StringRef getDescription() const override { return R"PD(Remove unused member and struct declarations)PD"; }
815
817 static constexpr ::llvm::StringLiteral getPassName() {
818 return ::llvm::StringLiteral("UnusedDeclarationEliminationPass");
819 }
820 ::llvm::StringRef getName() const override { return "UnusedDeclarationEliminationPass"; }
821
823 static bool classof(const ::mlir::Pass *pass) {
824 return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
825 }
826
828 std::unique_ptr<::mlir::Pass> clonePass() const override {
829 return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
830 }
831
833 void getDependentDialects(::mlir::DialectRegistry &registry) const override {
834 registry.insert<llzk::LLZKDialect>();
835 registry.insert<llzk::boolean::BoolDialect>();
836 registry.insert<llzk::array::ArrayDialect>();
837 registry.insert<llzk::component::StructDialect>();
838 registry.insert<llzk::constrain::ConstrainDialect>();
839 registry.insert<llzk::felt::FeltDialect>();
840 registry.insert<llzk::global::GlobalDialect>();
841 registry.insert<llzk::include::IncludeDialect>();
842 registry.insert<llzk::function::FunctionDialect>();
843 registry.insert<llzk::string::StringDialect>();
844 registry.insert<llzk::polymorphic::PolymorphicDialect>();
845 registry.insert<mlir::arith::ArithDialect>();
846 registry.insert<mlir::scf::SCFDialect>();
847 }
848
852 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(UnusedDeclarationEliminationPassBase<DerivedT>)
853
854 UnusedDeclarationEliminationPassBase(UnusedDeclarationEliminationPassOptions options) : UnusedDeclarationEliminationPassBase() {
855 removeStructs = std::move(options.removeStructs);
856 }
857protected:
858 ::mlir::Pass::Option<bool> removeStructs{*this, "remove-structs", ::llvm::cl::desc(R"PO(Whether to remove unused struct definitions as well. Requires module to declare a Main component, otherwise all components will appear unused.)PO"), ::llvm::cl::init(false)};
859private:
860
861 friend std::unique_ptr<::mlir::Pass> createUnusedDeclarationEliminationPass() {
862 return std::make_unique<DerivedT>();
863 }
864
865 friend std::unique_ptr<::mlir::Pass> createUnusedDeclarationEliminationPass(UnusedDeclarationEliminationPassOptions options) {
866 return std::make_unique<DerivedT>(std::move(options));
867 }
868};
869} // namespace impl
870
871std::unique_ptr<::mlir::Pass> createUnusedDeclarationEliminationPass() {
872 return impl::createUnusedDeclarationEliminationPass();
873}
874
875std::unique_ptr<::mlir::Pass> createUnusedDeclarationEliminationPass(UnusedDeclarationEliminationPassOptions options) {
876 return impl::createUnusedDeclarationEliminationPass(std::move(options));
877}
878#undef GEN_PASS_DEF_UNUSEDDECLARATIONELIMINATIONPASS
879#endif // GEN_PASS_DEF_UNUSEDDECLARATIONELIMINATIONPASS
880
881//===----------------------------------------------------------------------===//
882// WhileToForPass
883//===----------------------------------------------------------------------===//
884#ifdef GEN_PASS_DECL_WHILETOFORPASS
885std::unique_ptr<::mlir::Pass> createWhileToForPass();
886#undef GEN_PASS_DECL_WHILETOFORPASS
887#endif // GEN_PASS_DECL_WHILETOFORPASS
888#ifdef GEN_PASS_DEF_WHILETOFORPASS
889
890namespace impl {
891 std::unique_ptr<::mlir::Pass> createWhileToForPass();
892} // namespace impl
893namespace impl {
894
895template <typename DerivedT>
896class WhileToForPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
897public:
898 using Base = WhileToForPassBase;
899
900 WhileToForPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
901 WhileToForPassBase(const WhileToForPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
902 WhileToForPassBase& operator=(const WhileToForPassBase &) = delete;
903 WhileToForPassBase(WhileToForPassBase &&) = delete;
904 WhileToForPassBase& operator=(WhileToForPassBase &&) = delete;
905 ~WhileToForPassBase() = default;
906
908 static constexpr ::llvm::StringLiteral getArgumentName() {
909 return ::llvm::StringLiteral("llzk-while-to-for");
910 }
911 ::llvm::StringRef getArgument() const override { return "llzk-while-to-for"; }
912
913 ::llvm::StringRef getDescription() const override { return R"PD(Converts scf.while loops to equivalent scf.for loops when possible)PD"; }
914
916 static constexpr ::llvm::StringLiteral getPassName() {
917 return ::llvm::StringLiteral("WhileToForPass");
918 }
919 ::llvm::StringRef getName() const override { return "WhileToForPass"; }
920
922 static bool classof(const ::mlir::Pass *pass) {
923 return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
924 }
925
927 std::unique_ptr<::mlir::Pass> clonePass() const override {
928 return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
929 }
930
932 void getDependentDialects(::mlir::DialectRegistry &registry) const override {
933 registry.insert<llzk::LLZKDialect>();
934 registry.insert<llzk::boolean::BoolDialect>();
935 registry.insert<llzk::array::ArrayDialect>();
936 registry.insert<llzk::component::StructDialect>();
937 registry.insert<llzk::constrain::ConstrainDialect>();
938 registry.insert<llzk::felt::FeltDialect>();
939 registry.insert<llzk::global::GlobalDialect>();
940 registry.insert<llzk::include::IncludeDialect>();
941 registry.insert<llzk::function::FunctionDialect>();
942 registry.insert<llzk::string::StringDialect>();
943 registry.insert<llzk::polymorphic::PolymorphicDialect>();
944 registry.insert<mlir::arith::ArithDialect>();
945 registry.insert<mlir::scf::SCFDialect>();
946 }
947
951 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(WhileToForPassBase<DerivedT>)
952
953protected:
954private:
955
956 friend std::unique_ptr<::mlir::Pass> createWhileToForPass() {
957 return std::make_unique<DerivedT>();
958 }
959};
960} // namespace impl
961
962std::unique_ptr<::mlir::Pass> createWhileToForPass() {
963 return impl::createWhileToForPass();
964}
965#undef GEN_PASS_DEF_WHILETOFORPASS
966#endif // GEN_PASS_DEF_WHILETOFORPASS
967#ifdef GEN_PASS_REGISTRATION
968// Generate registrations for all passes.
969#define GEN_PASS_REGISTRATION_COMPUTECONSTRAINTOPRODUCTPASS
970#define GEN_PASS_REGISTRATION_ENFORCENOMEMBEROVERWRITEPASS
971#define GEN_PASS_REGISTRATION_FUSEPRODUCTCONTROLFLOWPASS
972#define GEN_PASS_REGISTRATION_INLINEFREEFUNCTIONSPASS
973#define GEN_PASS_REGISTRATION_POLYLOWERINGPASS
974#define GEN_PASS_REGISTRATION_REDUNDANTOPERATIONELIMINATIONPASS
975#define GEN_PASS_REGISTRATION_REDUNDANTREADANDWRITEELIMINATIONPASS
976#define GEN_PASS_REGISTRATION_REMOVEUNUSEDDISCARDABLEALLOCATIONSPASS
977#define GEN_PASS_REGISTRATION_UNUSEDDECLARATIONELIMINATIONPASS
978#define GEN_PASS_REGISTRATION_WHILETOFORPASS
979#endif // GEN_PASS_REGISTRATION
980
981//===----------------------------------------------------------------------===//
982// ComputeConstrainToProductPass Registration
983//===----------------------------------------------------------------------===//
984#ifdef GEN_PASS_REGISTRATION_COMPUTECONSTRAINTOPRODUCTPASS
985
986inline void registerComputeConstrainToProductPass() {
987 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
988 return createComputeConstrainToProductPass();
989 });
990}
991
992// Old registration code, kept for temporary backwards compatibility.
993inline void registerComputeConstrainToProductPassPass() {
994 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
995 return createComputeConstrainToProductPass();
996 });
997}
998
999#undef GEN_PASS_REGISTRATION_COMPUTECONSTRAINTOPRODUCTPASS
1000#endif // GEN_PASS_REGISTRATION_COMPUTECONSTRAINTOPRODUCTPASS
1001
1002//===----------------------------------------------------------------------===//
1003// EnforceNoMemberOverwritePass Registration
1004//===----------------------------------------------------------------------===//
1005#ifdef GEN_PASS_REGISTRATION_ENFORCENOMEMBEROVERWRITEPASS
1006
1007inline void registerEnforceNoMemberOverwritePass() {
1008 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
1009 return createEnforceNoMemberOverwritePass();
1010 });
1011}
1012
1013// Old registration code, kept for temporary backwards compatibility.
1014inline void registerEnforceNoMemberOverwritePassPass() {
1015 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
1016 return createEnforceNoMemberOverwritePass();
1017 });
1018}
1019
1020#undef GEN_PASS_REGISTRATION_ENFORCENOMEMBEROVERWRITEPASS
1021#endif // GEN_PASS_REGISTRATION_ENFORCENOMEMBEROVERWRITEPASS
1022
1023//===----------------------------------------------------------------------===//
1024// FuseProductControlFlowPass Registration
1025//===----------------------------------------------------------------------===//
1026#ifdef GEN_PASS_REGISTRATION_FUSEPRODUCTCONTROLFLOWPASS
1027
1028inline void registerFuseProductControlFlowPass() {
1029 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
1030 return createFuseProductControlFlowPass();
1031 });
1032}
1033
1034// Old registration code, kept for temporary backwards compatibility.
1035inline void registerFuseProductControlFlowPassPass() {
1036 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
1037 return createFuseProductControlFlowPass();
1038 });
1039}
1040
1041#undef GEN_PASS_REGISTRATION_FUSEPRODUCTCONTROLFLOWPASS
1042#endif // GEN_PASS_REGISTRATION_FUSEPRODUCTCONTROLFLOWPASS
1043
1044//===----------------------------------------------------------------------===//
1045// InlineFreeFunctionsPass Registration
1046//===----------------------------------------------------------------------===//
1047#ifdef GEN_PASS_REGISTRATION_INLINEFREEFUNCTIONSPASS
1048
1049inline void registerInlineFreeFunctionsPass() {
1050 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
1051 return createInlineFreeFunctionsPass();
1052 });
1053}
1054
1055// Old registration code, kept for temporary backwards compatibility.
1056inline void registerInlineFreeFunctionsPassPass() {
1057 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
1058 return createInlineFreeFunctionsPass();
1059 });
1060}
1061
1062#undef GEN_PASS_REGISTRATION_INLINEFREEFUNCTIONSPASS
1063#endif // GEN_PASS_REGISTRATION_INLINEFREEFUNCTIONSPASS
1064
1065//===----------------------------------------------------------------------===//
1066// PolyLoweringPass Registration
1067//===----------------------------------------------------------------------===//
1068#ifdef GEN_PASS_REGISTRATION_POLYLOWERINGPASS
1069
1070inline void registerPolyLoweringPass() {
1071 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
1072 return createPolyLoweringPass();
1073 });
1074}
1075
1076// Old registration code, kept for temporary backwards compatibility.
1077inline void registerPolyLoweringPassPass() {
1078 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
1079 return createPolyLoweringPass();
1080 });
1081}
1082
1083#undef GEN_PASS_REGISTRATION_POLYLOWERINGPASS
1084#endif // GEN_PASS_REGISTRATION_POLYLOWERINGPASS
1085
1086//===----------------------------------------------------------------------===//
1087// RedundantOperationEliminationPass Registration
1088//===----------------------------------------------------------------------===//
1089#ifdef GEN_PASS_REGISTRATION_REDUNDANTOPERATIONELIMINATIONPASS
1090
1091inline void registerRedundantOperationEliminationPass() {
1092 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
1093 return createRedundantOperationEliminationPass();
1094 });
1095}
1096
1097// Old registration code, kept for temporary backwards compatibility.
1098inline void registerRedundantOperationEliminationPassPass() {
1099 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
1100 return createRedundantOperationEliminationPass();
1101 });
1102}
1103
1104#undef GEN_PASS_REGISTRATION_REDUNDANTOPERATIONELIMINATIONPASS
1105#endif // GEN_PASS_REGISTRATION_REDUNDANTOPERATIONELIMINATIONPASS
1106
1107//===----------------------------------------------------------------------===//
1108// RedundantReadAndWriteEliminationPass Registration
1109//===----------------------------------------------------------------------===//
1110#ifdef GEN_PASS_REGISTRATION_REDUNDANTREADANDWRITEELIMINATIONPASS
1111
1112inline void registerRedundantReadAndWriteEliminationPass() {
1113 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
1114 return createRedundantReadAndWriteEliminationPass();
1115 });
1116}
1117
1118// Old registration code, kept for temporary backwards compatibility.
1119inline void registerRedundantReadAndWriteEliminationPassPass() {
1120 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
1121 return createRedundantReadAndWriteEliminationPass();
1122 });
1123}
1124
1125#undef GEN_PASS_REGISTRATION_REDUNDANTREADANDWRITEELIMINATIONPASS
1126#endif // GEN_PASS_REGISTRATION_REDUNDANTREADANDWRITEELIMINATIONPASS
1127
1128//===----------------------------------------------------------------------===//
1129// RemoveUnusedDiscardableAllocationsPass Registration
1130//===----------------------------------------------------------------------===//
1131#ifdef GEN_PASS_REGISTRATION_REMOVEUNUSEDDISCARDABLEALLOCATIONSPASS
1132
1133inline void registerRemoveUnusedDiscardableAllocationsPass() {
1134 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
1135 return createRemoveUnusedDiscardableAllocationsPass();
1136 });
1137}
1138
1139// Old registration code, kept for temporary backwards compatibility.
1140inline void registerRemoveUnusedDiscardableAllocationsPassPass() {
1141 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
1142 return createRemoveUnusedDiscardableAllocationsPass();
1143 });
1144}
1145
1146#undef GEN_PASS_REGISTRATION_REMOVEUNUSEDDISCARDABLEALLOCATIONSPASS
1147#endif // GEN_PASS_REGISTRATION_REMOVEUNUSEDDISCARDABLEALLOCATIONSPASS
1148
1149//===----------------------------------------------------------------------===//
1150// UnusedDeclarationEliminationPass Registration
1151//===----------------------------------------------------------------------===//
1152#ifdef GEN_PASS_REGISTRATION_UNUSEDDECLARATIONELIMINATIONPASS
1153
1154inline void registerUnusedDeclarationEliminationPass() {
1155 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
1156 return createUnusedDeclarationEliminationPass();
1157 });
1158}
1159
1160// Old registration code, kept for temporary backwards compatibility.
1161inline void registerUnusedDeclarationEliminationPassPass() {
1162 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
1163 return createUnusedDeclarationEliminationPass();
1164 });
1165}
1166
1167#undef GEN_PASS_REGISTRATION_UNUSEDDECLARATIONELIMINATIONPASS
1168#endif // GEN_PASS_REGISTRATION_UNUSEDDECLARATIONELIMINATIONPASS
1169
1170//===----------------------------------------------------------------------===//
1171// WhileToForPass Registration
1172//===----------------------------------------------------------------------===//
1173#ifdef GEN_PASS_REGISTRATION_WHILETOFORPASS
1174
1175inline void registerWhileToForPass() {
1176 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
1177 return createWhileToForPass();
1178 });
1179}
1180
1181// Old registration code, kept for temporary backwards compatibility.
1182inline void registerWhileToForPassPass() {
1183 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
1184 return createWhileToForPass();
1185 });
1186}
1187
1188#undef GEN_PASS_REGISTRATION_WHILETOFORPASS
1189#endif // GEN_PASS_REGISTRATION_WHILETOFORPASS
1190#ifdef GEN_PASS_REGISTRATION
1191
1192//===----------------------------------------------------------------------===//
1193// Transformation Registration
1194//===----------------------------------------------------------------------===//
1195
1196inline void registerTransformationPasses() {
1197 registerComputeConstrainToProductPass();
1198 registerEnforceNoMemberOverwritePass();
1199 registerFuseProductControlFlowPass();
1200 registerInlineFreeFunctionsPass();
1201 registerPolyLoweringPass();
1202 registerRedundantOperationEliminationPass();
1203 registerRedundantReadAndWriteEliminationPass();
1204 registerRemoveUnusedDiscardableAllocationsPass();
1205 registerUnusedDeclarationEliminationPass();
1206 registerWhileToForPass();
1207}
1208#undef GEN_PASS_REGISTRATION
1209#endif // GEN_PASS_REGISTRATION
1210#ifdef GEN_PASS_CLASSES
1211#error "GEN_PASS_CLASSES is deprecated; use per-pass macros"
1212#undef GEN_PASS_CLASSES
1213#endif // GEN_PASS_CLASSES
llzk::array::registerTransformationPasses
void registerTransformationPasses()
Definition TransformationPasses.h:237
llzk::impl::createFuseProductControlFlowPass
std::unique_ptr<::mlir::Pass > createFuseProductControlFlowPass()
Definition LLZKFuseProductControlFlowPass.cpp:288
llzk::impl::createUnusedDeclarationEliminationPass
std::unique_ptr<::mlir::Pass > createUnusedDeclarationEliminationPass()
Definition LLZKUnusedDeclarationEliminationPass.cpp:862
llzk::impl::createPolyLoweringPass
std::unique_ptr<::mlir::Pass > createPolyLoweringPass()
Definition LLZKPolyLoweringPass.cpp:474
llzk::impl::createRemoveUnusedDiscardableAllocationsPass
std::unique_ptr<::mlir::Pass > createRemoveUnusedDiscardableAllocationsPass()
Definition LLZKRemoveUnusedDiscardableAllocationsPass.cpp:755
llzk::impl::createInlineFreeFunctionsPass
std::unique_ptr<::mlir::Pass > createInlineFreeFunctionsPass()
Definition LLZKInlineFreeFunctionsPass.cpp:375
llzk::impl::createRedundantReadAndWriteEliminationPass
std::unique_ptr<::mlir::Pass > createRedundantReadAndWriteEliminationPass()
Definition LLZKRedundantReadAndWriteEliminationPass.cpp:656
llzk::impl::createRedundantOperationEliminationPass
std::unique_ptr<::mlir::Pass > createRedundantOperationEliminationPass()
Definition LLZKRedundantOperationEliminationPass.cpp:569
llzk::impl::createWhileToForPass
std::unique_ptr<::mlir::Pass > createWhileToForPass()
Definition LLZKWhileToForPass.cpp:957
llzk::impl::createComputeConstrainToProductPass
std::unique_ptr<::mlir::Pass > createComputeConstrainToProductPass()
Definition LLZKComputeConstrainToProductPass.cpp:106
llzk::impl::createEnforceNoMemberOverwritePass
std::unique_ptr<::mlir::Pass > createEnforceNoMemberOverwritePass()
Definition LLZKEnforceNoOverwritePass.cpp:201
llzk::registerUnusedDeclarationEliminationPassPass
void registerUnusedDeclarationEliminationPassPass()
Definition LLZKTransformationPasses.h:1162
llzk::registerWhileToForPassPass
void registerWhileToForPassPass()
Definition LLZKTransformationPasses.h:1183
llzk::registerWhileToForPass
void registerWhileToForPass()
Definition LLZKTransformationPasses.h:1176
llzk::registerInlineFreeFunctionsPass
void registerInlineFreeFunctionsPass()
Definition LLZKTransformationPasses.h:1050
llzk::registerRedundantOperationEliminationPass
void registerRedundantOperationEliminationPass()
Definition LLZKTransformationPasses.h:1092
llzk::registerEnforceNoMemberOverwritePassPass
void registerEnforceNoMemberOverwritePassPass()
Definition LLZKTransformationPasses.h:1015
llzk::registerPolyLoweringPassPass
void registerPolyLoweringPassPass()
Definition LLZKTransformationPasses.h:1078
llzk::registerUnusedDeclarationEliminationPass
void registerUnusedDeclarationEliminationPass()
Definition LLZKTransformationPasses.h:1155
llzk::registerComputeConstrainToProductPassPass
void registerComputeConstrainToProductPassPass()
Definition LLZKTransformationPasses.h:994
llzk::registerFuseProductControlFlowPass
void registerFuseProductControlFlowPass()
Definition LLZKTransformationPasses.h:1029
llzk::registerRedundantOperationEliminationPassPass
void registerRedundantOperationEliminationPassPass()
Definition LLZKTransformationPasses.h:1099
llzk::registerFuseProductControlFlowPassPass
void registerFuseProductControlFlowPassPass()
Definition LLZKTransformationPasses.h:1036
llzk::registerRemoveUnusedDiscardableAllocationsPass
void registerRemoveUnusedDiscardableAllocationsPass()
Definition LLZKTransformationPasses.h:1134
llzk::registerComputeConstrainToProductPass
void registerComputeConstrainToProductPass()
Definition LLZKTransformationPasses.h:987
llzk::registerRedundantReadAndWriteEliminationPass
void registerRedundantReadAndWriteEliminationPass()
Definition LLZKTransformationPasses.h:1113
llzk::registerPolyLoweringPass
void registerPolyLoweringPass()
Definition LLZKTransformationPasses.h:1071
llzk::registerInlineFreeFunctionsPassPass
void registerInlineFreeFunctionsPassPass()
Definition LLZKTransformationPasses.h:1057
llzk::registerRedundantReadAndWriteEliminationPassPass
void registerRedundantReadAndWriteEliminationPassPass()
Definition LLZKTransformationPasses.h:1120
llzk::registerRemoveUnusedDiscardableAllocationsPassPass
void registerRemoveUnusedDiscardableAllocationsPassPass()
Definition LLZKTransformationPasses.h:1141
llzk::registerEnforceNoMemberOverwritePass
void registerEnforceNoMemberOverwritePass()
Definition LLZKTransformationPasses.h:1008