LLZK 3.0.0
An open-source IR for Zero Knowledge (ZK) circuits
Loading...
Searching...
No Matches
TransformationPasses.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_CONSTRAINTFLATTENINGPASS
6#define GEN_PASS_DECL_EMPTYTEMPLATEREMOVALPASS
7#define GEN_PASS_DECL_FLATTENINGPASS
8#define GEN_PASS_DECL_TEMPLATEMONOMORPHIZATIONPASS
9#define GEN_PASS_DECL_TYPEVARINFERENCEPASS
10#define GEN_PASS_DECL_WILDCARDARRAYSPECIALIZATIONPASS
11#undef GEN_PASS_DECL
12#endif // GEN_PASS_DECL
13
14//===----------------------------------------------------------------------===//
15// ConstraintFlatteningPass
16//===----------------------------------------------------------------------===//
17#ifdef GEN_PASS_DECL_CONSTRAINTFLATTENINGPASS
18std::unique_ptr<::mlir::Pass> createConstraintFlatteningPass();
19#undef GEN_PASS_DECL_CONSTRAINTFLATTENINGPASS
20#endif // GEN_PASS_DECL_CONSTRAINTFLATTENINGPASS
21#ifdef GEN_PASS_DEF_CONSTRAINTFLATTENINGPASS
22
23namespace impl {
24 std::unique_ptr<::mlir::Pass> createConstraintFlatteningPass();
25} // namespace impl
26namespace impl {
27
28template <typename DerivedT>
29class ConstraintFlatteningPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
30public:
31 using Base = ConstraintFlatteningPassBase;
32
33 ConstraintFlatteningPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
34 ConstraintFlatteningPassBase(const ConstraintFlatteningPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
35 ConstraintFlatteningPassBase& operator=(const ConstraintFlatteningPassBase &) = delete;
36 ConstraintFlatteningPassBase(ConstraintFlatteningPassBase &&) = delete;
37 ConstraintFlatteningPassBase& operator=(ConstraintFlatteningPassBase &&) = delete;
38 ~ConstraintFlatteningPassBase() = default;
39
41 static constexpr ::llvm::StringLiteral getArgumentName() {
42 return ::llvm::StringLiteral("llzk-flatten-constraints");
43 }
44 ::llvm::StringRef getArgument() const override { return "llzk-flatten-constraints"; }
45
46 ::llvm::StringRef getDescription() const override { return R"PD(Expand main constrain into straight-line constraints)PD"; }
47
49 static constexpr ::llvm::StringLiteral getPassName() {
50 return ::llvm::StringLiteral("ConstraintFlatteningPass");
51 }
52 ::llvm::StringRef getName() const override { return "ConstraintFlatteningPass"; }
53
55 static bool classof(const ::mlir::Pass *pass) {
56 return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
57 }
58
60 std::unique_ptr<::mlir::Pass> clonePass() const override {
61 return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
62 }
63
65 void getDependentDialects(::mlir::DialectRegistry &registry) const override {
66 registry.insert<llzk::LLZKDialect>();
67 registry.insert<llzk::boolean::BoolDialect>();
68 registry.insert<llzk::array::ArrayDialect>();
69 registry.insert<llzk::component::StructDialect>();
70 registry.insert<llzk::constrain::ConstrainDialect>();
71 registry.insert<llzk::felt::FeltDialect>();
72 registry.insert<llzk::global::GlobalDialect>();
73 registry.insert<llzk::include::IncludeDialect>();
74 registry.insert<llzk::function::FunctionDialect>();
75 registry.insert<llzk::string::StringDialect>();
76 registry.insert<llzk::polymorphic::PolymorphicDialect>();
77 registry.insert<mlir::arith::ArithDialect>();
78 registry.insert<mlir::scf::SCFDialect>();
79 }
80
84 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(ConstraintFlatteningPassBase<DerivedT>)
85
86protected:
87private:
88
89 friend std::unique_ptr<::mlir::Pass> createConstraintFlatteningPass() {
90 return std::make_unique<DerivedT>();
91 }
92};
93} // namespace impl
94
95std::unique_ptr<::mlir::Pass> createConstraintFlatteningPass() {
96 return impl::createConstraintFlatteningPass();
97}
98#undef GEN_PASS_DEF_CONSTRAINTFLATTENINGPASS
99#endif // GEN_PASS_DEF_CONSTRAINTFLATTENINGPASS
100
101//===----------------------------------------------------------------------===//
102// EmptyTemplateRemovalPass
103//===----------------------------------------------------------------------===//
104#ifdef GEN_PASS_DECL_EMPTYTEMPLATEREMOVALPASS
105std::unique_ptr<::mlir::Pass> createEmptyTemplateRemovalPass();
106#undef GEN_PASS_DECL_EMPTYTEMPLATEREMOVALPASS
107#endif // GEN_PASS_DECL_EMPTYTEMPLATEREMOVALPASS
108#ifdef GEN_PASS_DEF_EMPTYTEMPLATEREMOVALPASS
109
110namespace impl {
111 std::unique_ptr<::mlir::Pass> createEmptyTemplateRemovalPass();
112} // namespace impl
113namespace impl {
114
115template <typename DerivedT>
116class EmptyTemplateRemovalPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
117public:
118 using Base = EmptyTemplateRemovalPassBase;
119
120 EmptyTemplateRemovalPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
121 EmptyTemplateRemovalPassBase(const EmptyTemplateRemovalPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
122 EmptyTemplateRemovalPassBase& operator=(const EmptyTemplateRemovalPassBase &) = delete;
123 EmptyTemplateRemovalPassBase(EmptyTemplateRemovalPassBase &&) = delete;
124 EmptyTemplateRemovalPassBase& operator=(EmptyTemplateRemovalPassBase &&) = delete;
125 ~EmptyTemplateRemovalPassBase() = default;
126
128 static constexpr ::llvm::StringLiteral getArgumentName() {
129 return ::llvm::StringLiteral("llzk-drop-empty-templates");
130 }
131 ::llvm::StringRef getArgument() const override { return "llzk-drop-empty-templates"; }
132
133 ::llvm::StringRef getDescription() const override { return R"PD(Remove empty templates)PD"; }
134
136 static constexpr ::llvm::StringLiteral getPassName() {
137 return ::llvm::StringLiteral("EmptyTemplateRemovalPass");
138 }
139 ::llvm::StringRef getName() const override { return "EmptyTemplateRemovalPass"; }
140
142 static bool classof(const ::mlir::Pass *pass) {
143 return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
144 }
145
147 std::unique_ptr<::mlir::Pass> clonePass() const override {
148 return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
149 }
150
152 void getDependentDialects(::mlir::DialectRegistry &registry) const override {
153 registry.insert<llzk::LLZKDialect>();
154 registry.insert<llzk::boolean::BoolDialect>();
155 registry.insert<llzk::array::ArrayDialect>();
156 registry.insert<llzk::component::StructDialect>();
157 registry.insert<llzk::constrain::ConstrainDialect>();
158 registry.insert<llzk::felt::FeltDialect>();
159 registry.insert<llzk::global::GlobalDialect>();
160 registry.insert<llzk::include::IncludeDialect>();
161 registry.insert<llzk::function::FunctionDialect>();
162 registry.insert<llzk::string::StringDialect>();
163 registry.insert<llzk::polymorphic::PolymorphicDialect>();
164 registry.insert<mlir::arith::ArithDialect>();
165 registry.insert<mlir::scf::SCFDialect>();
166 }
167
171 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(EmptyTemplateRemovalPassBase<DerivedT>)
172
173protected:
174private:
175
176 friend std::unique_ptr<::mlir::Pass> createEmptyTemplateRemovalPass() {
177 return std::make_unique<DerivedT>();
178 }
179};
180} // namespace impl
181
182std::unique_ptr<::mlir::Pass> createEmptyTemplateRemovalPass() {
183 return impl::createEmptyTemplateRemovalPass();
184}
185#undef GEN_PASS_DEF_EMPTYTEMPLATEREMOVALPASS
186#endif // GEN_PASS_DEF_EMPTYTEMPLATEREMOVALPASS
187
188//===----------------------------------------------------------------------===//
189// FlatteningPass
190//===----------------------------------------------------------------------===//
191#ifdef GEN_PASS_DECL_FLATTENINGPASS
192struct FlatteningPassOptions {
193 unsigned iterationLimit = 1000;
194 ::llzk::polymorphic::FlatteningCleanupMode cleanupMode = ::llzk::polymorphic::FlatteningCleanupMode::Unspecified;
195};
196std::unique_ptr<::mlir::Pass> createFlatteningPass();
197std::unique_ptr<::mlir::Pass> createFlatteningPass(FlatteningPassOptions options);
198#undef GEN_PASS_DECL_FLATTENINGPASS
199#endif // GEN_PASS_DECL_FLATTENINGPASS
200#ifdef GEN_PASS_DEF_FLATTENINGPASS
201
202namespace impl {
203 std::unique_ptr<::mlir::Pass> createFlatteningPass();
204} // namespace impl
205
206namespace impl {
207 std::unique_ptr<::mlir::Pass> createFlatteningPass(FlatteningPassOptions options);
208} // namespace impl
209namespace impl {
210
211template <typename DerivedT>
212class FlatteningPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
213public:
214 using Base = FlatteningPassBase;
215
216 FlatteningPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
217 FlatteningPassBase(const FlatteningPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
218 FlatteningPassBase& operator=(const FlatteningPassBase &) = delete;
219 FlatteningPassBase(FlatteningPassBase &&) = delete;
220 FlatteningPassBase& operator=(FlatteningPassBase &&) = delete;
221 ~FlatteningPassBase() = default;
222
224 static constexpr ::llvm::StringLiteral getArgumentName() {
225 return ::llvm::StringLiteral("llzk-flatten");
226 }
227 ::llvm::StringRef getArgument() const override { return "llzk-flatten"; }
228
229 ::llvm::StringRef getDescription() const override { return R"PD(Flatten structs and unroll loops)PD"; }
230
232 static constexpr ::llvm::StringLiteral getPassName() {
233 return ::llvm::StringLiteral("FlatteningPass");
234 }
235 ::llvm::StringRef getName() const override { return "FlatteningPass"; }
236
238 static bool classof(const ::mlir::Pass *pass) {
239 return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
240 }
241
243 std::unique_ptr<::mlir::Pass> clonePass() const override {
244 return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
245 }
246
248 void getDependentDialects(::mlir::DialectRegistry &registry) const override {
249 registry.insert<llzk::LLZKDialect>();
250 registry.insert<llzk::boolean::BoolDialect>();
251 registry.insert<llzk::array::ArrayDialect>();
252 registry.insert<llzk::component::StructDialect>();
253 registry.insert<llzk::constrain::ConstrainDialect>();
254 registry.insert<llzk::felt::FeltDialect>();
255 registry.insert<llzk::global::GlobalDialect>();
256 registry.insert<llzk::include::IncludeDialect>();
257 registry.insert<llzk::function::FunctionDialect>();
258 registry.insert<llzk::string::StringDialect>();
259 registry.insert<llzk::polymorphic::PolymorphicDialect>();
260 registry.insert<mlir::arith::ArithDialect>();
261 registry.insert<mlir::scf::SCFDialect>();
262 }
263
267 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(FlatteningPassBase<DerivedT>)
268
269 FlatteningPassBase(FlatteningPassOptions options) : FlatteningPassBase() {
270 iterationLimit = std::move(options.iterationLimit);
271 cleanupMode = std::move(options.cleanupMode);
272 }
273protected:
274 ::mlir::Pass::Option<unsigned> iterationLimit{*this, "max-iter", ::llvm::cl::desc(R"PO(Maximum number of times the pass will run if a fixpoint is not reached earlier. Unrolling loops can provide more opportunities for instantiating structs but the converse is true as well. Thus, the pass will run multiple times until no further changes can be made or the upper limit provided in this option is reached.)PO"), ::llvm::cl::init(1000)};
275 ::mlir::Pass::Option<::llzk::polymorphic::FlatteningCleanupMode> cleanupMode{*this, "cleanup", ::llvm::cl::desc(R"PO(Specifies the extent to which unused parameterized definitions (i.e. structs or free functions within a `poly.template`) are removed during the flattening pass.)PO"), ::llvm::cl::init(::llzk::polymorphic::FlatteningCleanupMode::Unspecified), ::llvm::cl::values(
276 clEnumValN(::llzk::polymorphic::FlatteningCleanupMode::Unspecified,
277 stringifyFlatteningCleanupMode(::llzk::polymorphic::FlatteningCleanupMode::Unspecified),
278 "Use the cleanup mode specified by the calling pipeline (defaults to `preimage` if not specified)."),
279 clEnumValN(::llzk::polymorphic::FlatteningCleanupMode::Disabled,
280 stringifyFlatteningCleanupMode(::llzk::polymorphic::FlatteningCleanupMode::Disabled),
281 "No definitions are deleted."),
282 clEnumValN(::llzk::polymorphic::FlatteningCleanupMode::Preimage,
283 stringifyFlatteningCleanupMode(::llzk::polymorphic::FlatteningCleanupMode::Preimage),
284 "Only definitions that were replaced with concrete instantiations are deleted."),
285 clEnumValN(::llzk::polymorphic::FlatteningCleanupMode::ConcreteAsRoot,
286 stringifyFlatteningCleanupMode(::llzk::polymorphic::FlatteningCleanupMode::ConcreteAsRoot),
287 "All definitions that cannot be reached by a use-def chain from some concrete definition are deleted."),
288 clEnumValN(::llzk::polymorphic::FlatteningCleanupMode::MainAsRoot,
289 stringifyFlatteningCleanupMode(::llzk::polymorphic::FlatteningCleanupMode::MainAsRoot),
290 "All definitions that cannot be reached by a use-def chain from the \"Main\" struct are deleted.")
291 )};
292private:
293
294 friend std::unique_ptr<::mlir::Pass> createFlatteningPass() {
295 return std::make_unique<DerivedT>();
296 }
297
298 friend std::unique_ptr<::mlir::Pass> createFlatteningPass(FlatteningPassOptions options) {
299 return std::make_unique<DerivedT>(std::move(options));
300 }
301};
302} // namespace impl
303
304std::unique_ptr<::mlir::Pass> createFlatteningPass() {
305 return impl::createFlatteningPass();
306}
307
308std::unique_ptr<::mlir::Pass> createFlatteningPass(FlatteningPassOptions options) {
309 return impl::createFlatteningPass(std::move(options));
310}
311#undef GEN_PASS_DEF_FLATTENINGPASS
312#endif // GEN_PASS_DEF_FLATTENINGPASS
313
314//===----------------------------------------------------------------------===//
315// TemplateMonomorphizationPass
316//===----------------------------------------------------------------------===//
317#ifdef GEN_PASS_DECL_TEMPLATEMONOMORPHIZATIONPASS
318struct TemplateMonomorphizationPassOptions {
319 unsigned specializationLimit = 1000;
320};
321std::unique_ptr<::mlir::Pass> createTemplateMonomorphizationPass();
322std::unique_ptr<::mlir::Pass> createTemplateMonomorphizationPass(TemplateMonomorphizationPassOptions options);
323#undef GEN_PASS_DECL_TEMPLATEMONOMORPHIZATIONPASS
324#endif // GEN_PASS_DECL_TEMPLATEMONOMORPHIZATIONPASS
325#ifdef GEN_PASS_DEF_TEMPLATEMONOMORPHIZATIONPASS
326
327namespace impl {
328 std::unique_ptr<::mlir::Pass> createTemplateMonomorphizationPass();
329} // namespace impl
330
331namespace impl {
332 std::unique_ptr<::mlir::Pass> createTemplateMonomorphizationPass(TemplateMonomorphizationPassOptions options);
333} // namespace impl
334namespace impl {
335
336template <typename DerivedT>
337class TemplateMonomorphizationPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
338public:
339 using Base = TemplateMonomorphizationPassBase;
340
341 TemplateMonomorphizationPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
342 TemplateMonomorphizationPassBase(const TemplateMonomorphizationPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
343 TemplateMonomorphizationPassBase& operator=(const TemplateMonomorphizationPassBase &) = delete;
344 TemplateMonomorphizationPassBase(TemplateMonomorphizationPassBase &&) = delete;
345 TemplateMonomorphizationPassBase& operator=(TemplateMonomorphizationPassBase &&) = delete;
346 ~TemplateMonomorphizationPassBase() = default;
347
349 static constexpr ::llvm::StringLiteral getArgumentName() {
350 return ::llvm::StringLiteral("llzk-monomorphize-templates");
351 }
352 ::llvm::StringRef getArgument() const override { return "llzk-monomorphize-templates"; }
353
354 ::llvm::StringRef getDescription() const override { return R"PD(Specialize structs and free functions reachable from llzk.main)PD"; }
355
357 static constexpr ::llvm::StringLiteral getPassName() {
358 return ::llvm::StringLiteral("TemplateMonomorphizationPass");
359 }
360 ::llvm::StringRef getName() const override { return "TemplateMonomorphizationPass"; }
361
363 static bool classof(const ::mlir::Pass *pass) {
364 return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
365 }
366
368 std::unique_ptr<::mlir::Pass> clonePass() const override {
369 return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
370 }
371
373 void getDependentDialects(::mlir::DialectRegistry &registry) const override {
374 registry.insert<llzk::LLZKDialect>();
375 registry.insert<llzk::boolean::BoolDialect>();
376 registry.insert<llzk::array::ArrayDialect>();
377 registry.insert<llzk::component::StructDialect>();
378 registry.insert<llzk::constrain::ConstrainDialect>();
379 registry.insert<llzk::felt::FeltDialect>();
380 registry.insert<llzk::global::GlobalDialect>();
381 registry.insert<llzk::include::IncludeDialect>();
382 registry.insert<llzk::function::FunctionDialect>();
383 registry.insert<llzk::string::StringDialect>();
384 registry.insert<llzk::polymorphic::PolymorphicDialect>();
385 registry.insert<mlir::arith::ArithDialect>();
386 registry.insert<mlir::scf::SCFDialect>();
387 }
388
392 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TemplateMonomorphizationPassBase<DerivedT>)
393
394 TemplateMonomorphizationPassBase(TemplateMonomorphizationPassOptions options) : TemplateMonomorphizationPassBase() {
395 specializationLimit = std::move(options.specializationLimit);
396 }
397protected:
398 ::mlir::Pass::Option<unsigned> specializationLimit{*this, "max-specializations", ::llvm::cl::desc(R"PO(Maximum number of concrete struct and free-function definitions)PO"), ::llvm::cl::init(1000)};
399private:
400
401 friend std::unique_ptr<::mlir::Pass> createTemplateMonomorphizationPass() {
402 return std::make_unique<DerivedT>();
403 }
404
405 friend std::unique_ptr<::mlir::Pass> createTemplateMonomorphizationPass(TemplateMonomorphizationPassOptions options) {
406 return std::make_unique<DerivedT>(std::move(options));
407 }
408};
409} // namespace impl
410
411std::unique_ptr<::mlir::Pass> createTemplateMonomorphizationPass() {
412 return impl::createTemplateMonomorphizationPass();
413}
414
415std::unique_ptr<::mlir::Pass> createTemplateMonomorphizationPass(TemplateMonomorphizationPassOptions options) {
416 return impl::createTemplateMonomorphizationPass(std::move(options));
417}
418#undef GEN_PASS_DEF_TEMPLATEMONOMORPHIZATIONPASS
419#endif // GEN_PASS_DEF_TEMPLATEMONOMORPHIZATIONPASS
420
421//===----------------------------------------------------------------------===//
422// TypeVarInferencePass
423//===----------------------------------------------------------------------===//
424#ifdef GEN_PASS_DECL_TYPEVARINFERENCEPASS
425std::unique_ptr<::mlir::Pass> createTypeVarInferencePass();
426#undef GEN_PASS_DECL_TYPEVARINFERENCEPASS
427#endif // GEN_PASS_DECL_TYPEVARINFERENCEPASS
428#ifdef GEN_PASS_DEF_TYPEVARINFERENCEPASS
429
430namespace impl {
431 std::unique_ptr<::mlir::Pass> createTypeVarInferencePass();
432} // namespace impl
433namespace impl {
434
435template <typename DerivedT>
436class TypeVarInferencePassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
437public:
438 using Base = TypeVarInferencePassBase;
439
440 TypeVarInferencePassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
441 TypeVarInferencePassBase(const TypeVarInferencePassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
442 TypeVarInferencePassBase& operator=(const TypeVarInferencePassBase &) = delete;
443 TypeVarInferencePassBase(TypeVarInferencePassBase &&) = delete;
444 TypeVarInferencePassBase& operator=(TypeVarInferencePassBase &&) = delete;
445 ~TypeVarInferencePassBase() = default;
446
448 static constexpr ::llvm::StringLiteral getArgumentName() {
449 return ::llvm::StringLiteral("llzk-infer-tvar");
450 }
451 ::llvm::StringRef getArgument() const override { return "llzk-infer-tvar"; }
452
453 ::llvm::StringRef getDescription() const override { return R"PD(Infer concrete function types for polymorphic type variables)PD"; }
454
456 static constexpr ::llvm::StringLiteral getPassName() {
457 return ::llvm::StringLiteral("TypeVarInferencePass");
458 }
459 ::llvm::StringRef getName() const override { return "TypeVarInferencePass"; }
460
462 static bool classof(const ::mlir::Pass *pass) {
463 return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
464 }
465
467 std::unique_ptr<::mlir::Pass> clonePass() const override {
468 return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
469 }
470
472 void getDependentDialects(::mlir::DialectRegistry &registry) const override {
473 registry.insert<llzk::LLZKDialect>();
474 registry.insert<llzk::boolean::BoolDialect>();
475 registry.insert<llzk::array::ArrayDialect>();
476 registry.insert<llzk::component::StructDialect>();
477 registry.insert<llzk::constrain::ConstrainDialect>();
478 registry.insert<llzk::felt::FeltDialect>();
479 registry.insert<llzk::global::GlobalDialect>();
480 registry.insert<llzk::include::IncludeDialect>();
481 registry.insert<llzk::function::FunctionDialect>();
482 registry.insert<llzk::string::StringDialect>();
483 registry.insert<llzk::polymorphic::PolymorphicDialect>();
484 registry.insert<mlir::arith::ArithDialect>();
485 registry.insert<mlir::scf::SCFDialect>();
486 }
487
491 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TypeVarInferencePassBase<DerivedT>)
492
493protected:
494private:
495
496 friend std::unique_ptr<::mlir::Pass> createTypeVarInferencePass() {
497 return std::make_unique<DerivedT>();
498 }
499};
500} // namespace impl
501
502std::unique_ptr<::mlir::Pass> createTypeVarInferencePass() {
503 return impl::createTypeVarInferencePass();
504}
505#undef GEN_PASS_DEF_TYPEVARINFERENCEPASS
506#endif // GEN_PASS_DEF_TYPEVARINFERENCEPASS
507
508//===----------------------------------------------------------------------===//
509// WildcardArraySpecializationPass
510//===----------------------------------------------------------------------===//
511#ifdef GEN_PASS_DECL_WILDCARDARRAYSPECIALIZATIONPASS
512struct WildcardArraySpecializationPassOptions {
513 unsigned iterationLimit = 1000;
514};
515std::unique_ptr<::mlir::Pass> createWildcardArraySpecializationPass();
516std::unique_ptr<::mlir::Pass> createWildcardArraySpecializationPass(WildcardArraySpecializationPassOptions options);
517#undef GEN_PASS_DECL_WILDCARDARRAYSPECIALIZATIONPASS
518#endif // GEN_PASS_DECL_WILDCARDARRAYSPECIALIZATIONPASS
519#ifdef GEN_PASS_DEF_WILDCARDARRAYSPECIALIZATIONPASS
520
521namespace impl {
522 std::unique_ptr<::mlir::Pass> createWildcardArraySpecializationPass();
523} // namespace impl
524
525namespace impl {
526 std::unique_ptr<::mlir::Pass> createWildcardArraySpecializationPass(WildcardArraySpecializationPassOptions options);
527} // namespace impl
528namespace impl {
529
530template <typename DerivedT>
531class WildcardArraySpecializationPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
532public:
533 using Base = WildcardArraySpecializationPassBase;
534
535 WildcardArraySpecializationPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
536 WildcardArraySpecializationPassBase(const WildcardArraySpecializationPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
537 WildcardArraySpecializationPassBase& operator=(const WildcardArraySpecializationPassBase &) = delete;
538 WildcardArraySpecializationPassBase(WildcardArraySpecializationPassBase &&) = delete;
539 WildcardArraySpecializationPassBase& operator=(WildcardArraySpecializationPassBase &&) = delete;
540 ~WildcardArraySpecializationPassBase() = default;
541
543 static constexpr ::llvm::StringLiteral getArgumentName() {
544 return ::llvm::StringLiteral("llzk-specialize-wildcard-arrays");
545 }
546 ::llvm::StringRef getArgument() const override { return "llzk-specialize-wildcard-arrays"; }
547
548 ::llvm::StringRef getDescription() const override { return R"PD(Refine wildcard array casts and specialize concrete call targets)PD"; }
549
551 static constexpr ::llvm::StringLiteral getPassName() {
552 return ::llvm::StringLiteral("WildcardArraySpecializationPass");
553 }
554 ::llvm::StringRef getName() const override { return "WildcardArraySpecializationPass"; }
555
557 static bool classof(const ::mlir::Pass *pass) {
558 return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
559 }
560
562 std::unique_ptr<::mlir::Pass> clonePass() const override {
563 return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
564 }
565
567 void getDependentDialects(::mlir::DialectRegistry &registry) const override {
568 registry.insert<llzk::LLZKDialect>();
569 registry.insert<llzk::boolean::BoolDialect>();
570 registry.insert<llzk::array::ArrayDialect>();
571 registry.insert<llzk::component::StructDialect>();
572 registry.insert<llzk::constrain::ConstrainDialect>();
573 registry.insert<llzk::felt::FeltDialect>();
574 registry.insert<llzk::global::GlobalDialect>();
575 registry.insert<llzk::include::IncludeDialect>();
576 registry.insert<llzk::function::FunctionDialect>();
577 registry.insert<llzk::string::StringDialect>();
578 registry.insert<llzk::polymorphic::PolymorphicDialect>();
579 registry.insert<mlir::arith::ArithDialect>();
580 registry.insert<mlir::scf::SCFDialect>();
581 }
582
586 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(WildcardArraySpecializationPassBase<DerivedT>)
587
588 WildcardArraySpecializationPassBase(WildcardArraySpecializationPassOptions options) : WildcardArraySpecializationPassBase() {
589 iterationLimit = std::move(options.iterationLimit);
590 }
591protected:
592 ::mlir::Pass::Option<unsigned> iterationLimit{*this, "max-iter", ::llvm::cl::desc(R"PO(Maximum number of iterations before the pass gives up reaching a fixpoint.)PO"), ::llvm::cl::init(1000)};
593private:
594
595 friend std::unique_ptr<::mlir::Pass> createWildcardArraySpecializationPass() {
596 return std::make_unique<DerivedT>();
597 }
598
599 friend std::unique_ptr<::mlir::Pass> createWildcardArraySpecializationPass(WildcardArraySpecializationPassOptions options) {
600 return std::make_unique<DerivedT>(std::move(options));
601 }
602};
603} // namespace impl
604
605std::unique_ptr<::mlir::Pass> createWildcardArraySpecializationPass() {
606 return impl::createWildcardArraySpecializationPass();
607}
608
609std::unique_ptr<::mlir::Pass> createWildcardArraySpecializationPass(WildcardArraySpecializationPassOptions options) {
610 return impl::createWildcardArraySpecializationPass(std::move(options));
611}
612#undef GEN_PASS_DEF_WILDCARDARRAYSPECIALIZATIONPASS
613#endif // GEN_PASS_DEF_WILDCARDARRAYSPECIALIZATIONPASS
614#ifdef GEN_PASS_REGISTRATION
615// Generate registrations for all passes.
616#define GEN_PASS_REGISTRATION_CONSTRAINTFLATTENINGPASS
617#define GEN_PASS_REGISTRATION_EMPTYTEMPLATEREMOVALPASS
618#define GEN_PASS_REGISTRATION_FLATTENINGPASS
619#define GEN_PASS_REGISTRATION_TEMPLATEMONOMORPHIZATIONPASS
620#define GEN_PASS_REGISTRATION_TYPEVARINFERENCEPASS
621#define GEN_PASS_REGISTRATION_WILDCARDARRAYSPECIALIZATIONPASS
622#endif // GEN_PASS_REGISTRATION
623
624//===----------------------------------------------------------------------===//
625// ConstraintFlatteningPass Registration
626//===----------------------------------------------------------------------===//
627#ifdef GEN_PASS_REGISTRATION_CONSTRAINTFLATTENINGPASS
628
629inline void registerConstraintFlatteningPass() {
630 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
631 return createConstraintFlatteningPass();
632 });
633}
634
635// Old registration code, kept for temporary backwards compatibility.
636inline void registerConstraintFlatteningPassPass() {
637 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
638 return createConstraintFlatteningPass();
639 });
640}
641
642#undef GEN_PASS_REGISTRATION_CONSTRAINTFLATTENINGPASS
643#endif // GEN_PASS_REGISTRATION_CONSTRAINTFLATTENINGPASS
644
645//===----------------------------------------------------------------------===//
646// EmptyTemplateRemovalPass Registration
647//===----------------------------------------------------------------------===//
648#ifdef GEN_PASS_REGISTRATION_EMPTYTEMPLATEREMOVALPASS
649
650inline void registerEmptyTemplateRemovalPass() {
651 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
652 return createEmptyTemplateRemovalPass();
653 });
654}
655
656// Old registration code, kept for temporary backwards compatibility.
657inline void registerEmptyTemplateRemovalPassPass() {
658 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
659 return createEmptyTemplateRemovalPass();
660 });
661}
662
663#undef GEN_PASS_REGISTRATION_EMPTYTEMPLATEREMOVALPASS
664#endif // GEN_PASS_REGISTRATION_EMPTYTEMPLATEREMOVALPASS
665
666//===----------------------------------------------------------------------===//
667// FlatteningPass Registration
668//===----------------------------------------------------------------------===//
669#ifdef GEN_PASS_REGISTRATION_FLATTENINGPASS
670
671inline void registerFlatteningPass() {
672 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
673 return createFlatteningPass();
674 });
675}
676
677// Old registration code, kept for temporary backwards compatibility.
678inline void registerFlatteningPassPass() {
679 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
680 return createFlatteningPass();
681 });
682}
683
684#undef GEN_PASS_REGISTRATION_FLATTENINGPASS
685#endif // GEN_PASS_REGISTRATION_FLATTENINGPASS
686
687//===----------------------------------------------------------------------===//
688// TemplateMonomorphizationPass Registration
689//===----------------------------------------------------------------------===//
690#ifdef GEN_PASS_REGISTRATION_TEMPLATEMONOMORPHIZATIONPASS
691
692inline void registerTemplateMonomorphizationPass() {
693 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
694 return createTemplateMonomorphizationPass();
695 });
696}
697
698// Old registration code, kept for temporary backwards compatibility.
699inline void registerTemplateMonomorphizationPassPass() {
700 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
701 return createTemplateMonomorphizationPass();
702 });
703}
704
705#undef GEN_PASS_REGISTRATION_TEMPLATEMONOMORPHIZATIONPASS
706#endif // GEN_PASS_REGISTRATION_TEMPLATEMONOMORPHIZATIONPASS
707
708//===----------------------------------------------------------------------===//
709// TypeVarInferencePass Registration
710//===----------------------------------------------------------------------===//
711#ifdef GEN_PASS_REGISTRATION_TYPEVARINFERENCEPASS
712
713inline void registerTypeVarInferencePass() {
714 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
715 return createTypeVarInferencePass();
716 });
717}
718
719// Old registration code, kept for temporary backwards compatibility.
720inline void registerTypeVarInferencePassPass() {
721 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
722 return createTypeVarInferencePass();
723 });
724}
725
726#undef GEN_PASS_REGISTRATION_TYPEVARINFERENCEPASS
727#endif // GEN_PASS_REGISTRATION_TYPEVARINFERENCEPASS
728
729//===----------------------------------------------------------------------===//
730// WildcardArraySpecializationPass Registration
731//===----------------------------------------------------------------------===//
732#ifdef GEN_PASS_REGISTRATION_WILDCARDARRAYSPECIALIZATIONPASS
733
734inline void registerWildcardArraySpecializationPass() {
735 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
736 return createWildcardArraySpecializationPass();
737 });
738}
739
740// Old registration code, kept for temporary backwards compatibility.
741inline void registerWildcardArraySpecializationPassPass() {
742 ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
743 return createWildcardArraySpecializationPass();
744 });
745}
746
747#undef GEN_PASS_REGISTRATION_WILDCARDARRAYSPECIALIZATIONPASS
748#endif // GEN_PASS_REGISTRATION_WILDCARDARRAYSPECIALIZATIONPASS
749#ifdef GEN_PASS_REGISTRATION
750
751//===----------------------------------------------------------------------===//
752// Transformation Registration
753//===----------------------------------------------------------------------===//
754
755inline void registerTransformationPasses() {
756 registerConstraintFlatteningPass();
757 registerEmptyTemplateRemovalPass();
758 registerFlatteningPass();
759 registerTemplateMonomorphizationPass();
760 registerTypeVarInferencePass();
761 registerWildcardArraySpecializationPass();
762}
763#undef GEN_PASS_REGISTRATION
764#endif // GEN_PASS_REGISTRATION
765#ifdef GEN_PASS_CLASSES
766#error "GEN_PASS_CLASSES is deprecated; use per-pass macros"
767#undef GEN_PASS_CLASSES
768#endif // GEN_PASS_CLASSES
llzk::array::registerTransformationPasses
void registerTransformationPasses()
Definition TransformationPasses.h:237
llzk::polymorphic::impl::createConstraintFlatteningPass
std::unique_ptr<::mlir::Pass > createConstraintFlatteningPass()
Definition ConstraintFlatteningPass.cpp:90
llzk::polymorphic::impl::createEmptyTemplateRemovalPass
std::unique_ptr<::mlir::Pass > createEmptyTemplateRemovalPass()
Definition EmptyTemplateRemovalPass.cpp:177
llzk::polymorphic::impl::createFlatteningPass
std::unique_ptr<::mlir::Pass > createFlatteningPass()
Definition FlatteningPass.cpp:295
llzk::polymorphic::impl::createTemplateMonomorphizationPass
std::unique_ptr<::mlir::Pass > createTemplateMonomorphizationPass()
Definition TemplateMonomorphization.cpp:402
llzk::polymorphic::impl::createWildcardArraySpecializationPass
std::unique_ptr<::mlir::Pass > createWildcardArraySpecializationPass()
Definition WildcardArraySpecializationPass.cpp:596
llzk::polymorphic::impl::createTypeVarInferencePass
std::unique_ptr<::mlir::Pass > createTypeVarInferencePass()
Definition TypeVarInferencePass.cpp:497
llzk::polymorphic::registerConstraintFlatteningPassPass
void registerConstraintFlatteningPassPass()
Definition TransformationPasses.h:637
llzk::polymorphic::registerTemplateMonomorphizationPass
void registerTemplateMonomorphizationPass()
Definition TransformationPasses.h:693
llzk::polymorphic::stringifyFlatteningCleanupMode
::llvm::StringRef stringifyFlatteningCleanupMode(FlatteningCleanupMode val)
Definition TransformationPassEnums.cpp.inc:12
llzk::polymorphic::registerTemplateMonomorphizationPassPass
void registerTemplateMonomorphizationPassPass()
Definition TransformationPasses.h:700
llzk::polymorphic::registerWildcardArraySpecializationPass
void registerWildcardArraySpecializationPass()
Definition TransformationPasses.h:735
llzk::polymorphic::registerEmptyTemplateRemovalPassPass
void registerEmptyTemplateRemovalPassPass()
Definition TransformationPasses.h:658
llzk::polymorphic::registerWildcardArraySpecializationPassPass
void registerWildcardArraySpecializationPassPass()
Definition TransformationPasses.h:742