TransformationPasses.h.inc

Go to the documentation of this file.

/* Autogenerated by mlir-tblgen; don't manually edit */
 
#ifdef GEN_PASS_DECL
// Generate declarations for all passes.
#define GEN_PASS_DECL_EMPTYTEMPLATEREMOVALPASS
#define GEN_PASS_DECL_FLATTENINGPASS
#define GEN_PASS_DECL_TYPEVARINFERENCEPASS
#define GEN_PASS_DECL_WILDCARDARRAYSPECIALIZATIONPASS
#undef GEN_PASS_DECL
#endif // GEN_PASS_DECL
 
//===----------------------------------------------------------------------===//
// EmptyTemplateRemovalPass
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_EMPTYTEMPLATEREMOVALPASS
std::unique_ptr<::mlir::Pass> createEmptyTemplateRemovalPass();
#undef GEN_PASS_DECL_EMPTYTEMPLATEREMOVALPASS
#endif // GEN_PASS_DECL_EMPTYTEMPLATEREMOVALPASS
#ifdef GEN_PASS_DEF_EMPTYTEMPLATEREMOVALPASS
 
namespace impl {
  std::unique_ptr<::mlir::Pass> createEmptyTemplateRemovalPass();
} // namespace impl
namespace impl {
 
template <typename DerivedT>
class EmptyTemplateRemovalPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
public:
  using Base = EmptyTemplateRemovalPassBase;
 
  EmptyTemplateRemovalPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
  EmptyTemplateRemovalPassBase(const EmptyTemplateRemovalPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
  EmptyTemplateRemovalPassBase& operator=(const EmptyTemplateRemovalPassBase &) = delete;
  EmptyTemplateRemovalPassBase(EmptyTemplateRemovalPassBase &&) = delete;
  EmptyTemplateRemovalPassBase& operator=(EmptyTemplateRemovalPassBase &&) = delete;
  ~EmptyTemplateRemovalPassBase() = default;

  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("llzk-drop-empty-templates");
  }
  ::llvm::StringRef getArgument() const override { return "llzk-drop-empty-templates"; }
 
  ::llvm::StringRef getDescription() const override { return "Remove empty templates"; }

  static constexpr ::llvm::StringLiteral getPassName() {
    return ::llvm::StringLiteral("EmptyTemplateRemovalPass");
  }
  ::llvm::StringRef getName() const override { return "EmptyTemplateRemovalPass"; }

  static bool classof(const ::mlir::Pass *pass) {
    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
  }

  std::unique_ptr<::mlir::Pass> clonePass() const override {
    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
  }

  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
    registry.insert<llzk::LLZKDialect>();
    registry.insert<llzk::boolean::BoolDialect>();
    registry.insert<llzk::array::ArrayDialect>();
    registry.insert<llzk::component::StructDialect>();
    registry.insert<llzk::constrain::ConstrainDialect>();
    registry.insert<llzk::felt::FeltDialect>();
    registry.insert<llzk::global::GlobalDialect>();
    registry.insert<llzk::include::IncludeDialect>();
    registry.insert<llzk::function::FunctionDialect>();
    registry.insert<llzk::string::StringDialect>();
    registry.insert<llzk::polymorphic::PolymorphicDialect>();
    registry.insert<mlir::arith::ArithDialect>();
    registry.insert<mlir::scf::SCFDialect>();
  }

  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(EmptyTemplateRemovalPassBase<DerivedT>)
 
protected:
private:
 
  friend std::unique_ptr<::mlir::Pass> createEmptyTemplateRemovalPass() {
    return std::make_unique<DerivedT>();
  }
};
} // namespace impl
 
std::unique_ptr<::mlir::Pass> createEmptyTemplateRemovalPass() {
  return impl::createEmptyTemplateRemovalPass();
}
#undef GEN_PASS_DEF_EMPTYTEMPLATEREMOVALPASS
#endif // GEN_PASS_DEF_EMPTYTEMPLATEREMOVALPASS
 
//===----------------------------------------------------------------------===//
// FlatteningPass
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_FLATTENINGPASS
struct FlatteningPassOptions {
  unsigned iterationLimit = 1000;
  ::llzk::polymorphic::FlatteningCleanupMode cleanupMode = ::llzk::polymorphic::FlatteningCleanupMode::Unspecified;
};
std::unique_ptr<::mlir::Pass> createFlatteningPass();
std::unique_ptr<::mlir::Pass> createFlatteningPass(FlatteningPassOptions options);
#undef GEN_PASS_DECL_FLATTENINGPASS
#endif // GEN_PASS_DECL_FLATTENINGPASS
#ifdef GEN_PASS_DEF_FLATTENINGPASS
 
namespace impl {
  std::unique_ptr<::mlir::Pass> createFlatteningPass();
} // namespace impl
 
namespace impl {
  std::unique_ptr<::mlir::Pass> createFlatteningPass(FlatteningPassOptions options);
} // namespace impl
namespace impl {
 
template <typename DerivedT>
class FlatteningPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
public:
  using Base = FlatteningPassBase;
 
  FlatteningPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
  FlatteningPassBase(const FlatteningPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
  FlatteningPassBase& operator=(const FlatteningPassBase &) = delete;
  FlatteningPassBase(FlatteningPassBase &&) = delete;
  FlatteningPassBase& operator=(FlatteningPassBase &&) = delete;
  ~FlatteningPassBase() = default;

  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("llzk-flatten");
  }
  ::llvm::StringRef getArgument() const override { return "llzk-flatten"; }
 
  ::llvm::StringRef getDescription() const override { return "Flatten structs and unroll loops"; }

  static constexpr ::llvm::StringLiteral getPassName() {
    return ::llvm::StringLiteral("FlatteningPass");
  }
  ::llvm::StringRef getName() const override { return "FlatteningPass"; }

  static bool classof(const ::mlir::Pass *pass) {
    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
  }

  std::unique_ptr<::mlir::Pass> clonePass() const override {
    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
  }

  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
    registry.insert<llzk::LLZKDialect>();
    registry.insert<llzk::boolean::BoolDialect>();
    registry.insert<llzk::array::ArrayDialect>();
    registry.insert<llzk::component::StructDialect>();
    registry.insert<llzk::constrain::ConstrainDialect>();
    registry.insert<llzk::felt::FeltDialect>();
    registry.insert<llzk::global::GlobalDialect>();
    registry.insert<llzk::include::IncludeDialect>();
    registry.insert<llzk::function::FunctionDialect>();
    registry.insert<llzk::string::StringDialect>();
    registry.insert<llzk::polymorphic::PolymorphicDialect>();
    registry.insert<mlir::arith::ArithDialect>();
    registry.insert<mlir::scf::SCFDialect>();
  }

  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(FlatteningPassBase<DerivedT>)
 
  FlatteningPassBase(FlatteningPassOptions options) : FlatteningPassBase() {
    iterationLimit = std::move(options.iterationLimit);
    cleanupMode = std::move(options.cleanupMode);
  }
protected:
  ::mlir::Pass::Option<unsigned> iterationLimit{*this, "max-iter", ::llvm::cl::desc("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."), ::llvm::cl::init(1000)};
  ::mlir::Pass::Option<::llzk::polymorphic::FlatteningCleanupMode> cleanupMode{*this, "cleanup", ::llvm::cl::desc("Specifies the extent to which unused parameterized definitions (i.e. structs or free functions within a `poly.template`) are removed during the flattening pass."), ::llvm::cl::init(::llzk::polymorphic::FlatteningCleanupMode::Unspecified), ::llvm::cl::values(
                clEnumValN(::llzk::polymorphic::FlatteningCleanupMode::Unspecified,
                           stringifyFlatteningCleanupMode(::llzk::polymorphic::FlatteningCleanupMode::Unspecified),
                           "Use the cleanup mode specified by the calling pipeline (defaults to `preimage` if not specified)."),
                clEnumValN(::llzk::polymorphic::FlatteningCleanupMode::Disabled,
                           stringifyFlatteningCleanupMode(::llzk::polymorphic::FlatteningCleanupMode::Disabled),
                           "No definitions are deleted."),
                clEnumValN(::llzk::polymorphic::FlatteningCleanupMode::Preimage,
                           stringifyFlatteningCleanupMode(::llzk::polymorphic::FlatteningCleanupMode::Preimage),
                           "Only definitions that were replaced with concrete instantiations are deleted."),
                clEnumValN(::llzk::polymorphic::FlatteningCleanupMode::ConcreteAsRoot,
                           stringifyFlatteningCleanupMode(::llzk::polymorphic::FlatteningCleanupMode::ConcreteAsRoot),
                           "All definitions that cannot be reached by a use-def chain from some concrete definition are deleted."),
                clEnumValN(::llzk::polymorphic::FlatteningCleanupMode::MainAsRoot,
                           stringifyFlatteningCleanupMode(::llzk::polymorphic::FlatteningCleanupMode::MainAsRoot),
                           "All definitions that cannot be reached by a use-def chain from the \"Main\" struct are deleted.")
          )};
private:
 
  friend std::unique_ptr<::mlir::Pass> createFlatteningPass() {
    return std::make_unique<DerivedT>();
  }
 
  friend std::unique_ptr<::mlir::Pass> createFlatteningPass(FlatteningPassOptions options) {
    return std::make_unique<DerivedT>(std::move(options));
  }
};
} // namespace impl
 
std::unique_ptr<::mlir::Pass> createFlatteningPass() {
  return impl::createFlatteningPass();
}
 
std::unique_ptr<::mlir::Pass> createFlatteningPass(FlatteningPassOptions options) {
  return impl::createFlatteningPass(std::move(options));
}
#undef GEN_PASS_DEF_FLATTENINGPASS
#endif // GEN_PASS_DEF_FLATTENINGPASS
 
//===----------------------------------------------------------------------===//
// TypeVarInferencePass
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_TYPEVARINFERENCEPASS
std::unique_ptr<::mlir::Pass> createTypeVarInferencePass();
#undef GEN_PASS_DECL_TYPEVARINFERENCEPASS
#endif // GEN_PASS_DECL_TYPEVARINFERENCEPASS
#ifdef GEN_PASS_DEF_TYPEVARINFERENCEPASS
 
namespace impl {
  std::unique_ptr<::mlir::Pass> createTypeVarInferencePass();
} // namespace impl
namespace impl {
 
template <typename DerivedT>
class TypeVarInferencePassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
public:
  using Base = TypeVarInferencePassBase;
 
  TypeVarInferencePassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
  TypeVarInferencePassBase(const TypeVarInferencePassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
  TypeVarInferencePassBase& operator=(const TypeVarInferencePassBase &) = delete;
  TypeVarInferencePassBase(TypeVarInferencePassBase &&) = delete;
  TypeVarInferencePassBase& operator=(TypeVarInferencePassBase &&) = delete;
  ~TypeVarInferencePassBase() = default;

  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("llzk-infer-tvar");
  }
  ::llvm::StringRef getArgument() const override { return "llzk-infer-tvar"; }
 
  ::llvm::StringRef getDescription() const override { return "Infer concrete function types for polymorphic type variables"; }

  static constexpr ::llvm::StringLiteral getPassName() {
    return ::llvm::StringLiteral("TypeVarInferencePass");
  }
  ::llvm::StringRef getName() const override { return "TypeVarInferencePass"; }

  static bool classof(const ::mlir::Pass *pass) {
    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
  }

  std::unique_ptr<::mlir::Pass> clonePass() const override {
    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
  }

  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
    registry.insert<llzk::LLZKDialect>();
    registry.insert<llzk::boolean::BoolDialect>();
    registry.insert<llzk::array::ArrayDialect>();
    registry.insert<llzk::component::StructDialect>();
    registry.insert<llzk::constrain::ConstrainDialect>();
    registry.insert<llzk::felt::FeltDialect>();
    registry.insert<llzk::global::GlobalDialect>();
    registry.insert<llzk::include::IncludeDialect>();
    registry.insert<llzk::function::FunctionDialect>();
    registry.insert<llzk::string::StringDialect>();
    registry.insert<llzk::polymorphic::PolymorphicDialect>();
    registry.insert<mlir::arith::ArithDialect>();
    registry.insert<mlir::scf::SCFDialect>();
  }

  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TypeVarInferencePassBase<DerivedT>)
 
protected:
private:
 
  friend std::unique_ptr<::mlir::Pass> createTypeVarInferencePass() {
    return std::make_unique<DerivedT>();
  }
};
} // namespace impl
 
std::unique_ptr<::mlir::Pass> createTypeVarInferencePass() {
  return impl::createTypeVarInferencePass();
}
#undef GEN_PASS_DEF_TYPEVARINFERENCEPASS
#endif // GEN_PASS_DEF_TYPEVARINFERENCEPASS
 
//===----------------------------------------------------------------------===//
// WildcardArraySpecializationPass
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_WILDCARDARRAYSPECIALIZATIONPASS
struct WildcardArraySpecializationPassOptions {
  unsigned iterationLimit = 1000;
};
std::unique_ptr<::mlir::Pass> createWildcardArraySpecializationPass();
std::unique_ptr<::mlir::Pass> createWildcardArraySpecializationPass(WildcardArraySpecializationPassOptions options);
#undef GEN_PASS_DECL_WILDCARDARRAYSPECIALIZATIONPASS
#endif // GEN_PASS_DECL_WILDCARDARRAYSPECIALIZATIONPASS
#ifdef GEN_PASS_DEF_WILDCARDARRAYSPECIALIZATIONPASS
 
namespace impl {
  std::unique_ptr<::mlir::Pass> createWildcardArraySpecializationPass();
} // namespace impl
 
namespace impl {
  std::unique_ptr<::mlir::Pass> createWildcardArraySpecializationPass(WildcardArraySpecializationPassOptions options);
} // namespace impl
namespace impl {
 
template <typename DerivedT>
class WildcardArraySpecializationPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
public:
  using Base = WildcardArraySpecializationPassBase;
 
  WildcardArraySpecializationPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
  WildcardArraySpecializationPassBase(const WildcardArraySpecializationPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
  WildcardArraySpecializationPassBase& operator=(const WildcardArraySpecializationPassBase &) = delete;
  WildcardArraySpecializationPassBase(WildcardArraySpecializationPassBase &&) = delete;
  WildcardArraySpecializationPassBase& operator=(WildcardArraySpecializationPassBase &&) = delete;
  ~WildcardArraySpecializationPassBase() = default;

  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("llzk-specialize-wildcard-arrays");
  }
  ::llvm::StringRef getArgument() const override { return "llzk-specialize-wildcard-arrays"; }
 
  ::llvm::StringRef getDescription() const override { return "Refine wildcard array casts and specialize concrete call targets"; }

  static constexpr ::llvm::StringLiteral getPassName() {
    return ::llvm::StringLiteral("WildcardArraySpecializationPass");
  }
  ::llvm::StringRef getName() const override { return "WildcardArraySpecializationPass"; }

  static bool classof(const ::mlir::Pass *pass) {
    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
  }

  std::unique_ptr<::mlir::Pass> clonePass() const override {
    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
  }

  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
    registry.insert<llzk::LLZKDialect>();
    registry.insert<llzk::boolean::BoolDialect>();
    registry.insert<llzk::array::ArrayDialect>();
    registry.insert<llzk::component::StructDialect>();
    registry.insert<llzk::constrain::ConstrainDialect>();
    registry.insert<llzk::felt::FeltDialect>();
    registry.insert<llzk::global::GlobalDialect>();
    registry.insert<llzk::include::IncludeDialect>();
    registry.insert<llzk::function::FunctionDialect>();
    registry.insert<llzk::string::StringDialect>();
    registry.insert<llzk::polymorphic::PolymorphicDialect>();
    registry.insert<mlir::arith::ArithDialect>();
    registry.insert<mlir::scf::SCFDialect>();
  }

  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(WildcardArraySpecializationPassBase<DerivedT>)
 
  WildcardArraySpecializationPassBase(WildcardArraySpecializationPassOptions options) : WildcardArraySpecializationPassBase() {
    iterationLimit = std::move(options.iterationLimit);
  }
protected:
  ::mlir::Pass::Option<unsigned> iterationLimit{*this, "max-iter", ::llvm::cl::desc("Maximum number of iterations before the pass gives up reaching a fixpoint."), ::llvm::cl::init(1000)};
private:
 
  friend std::unique_ptr<::mlir::Pass> createWildcardArraySpecializationPass() {
    return std::make_unique<DerivedT>();
  }
 
  friend std::unique_ptr<::mlir::Pass> createWildcardArraySpecializationPass(WildcardArraySpecializationPassOptions options) {
    return std::make_unique<DerivedT>(std::move(options));
  }
};
} // namespace impl
 
std::unique_ptr<::mlir::Pass> createWildcardArraySpecializationPass() {
  return impl::createWildcardArraySpecializationPass();
}
 
std::unique_ptr<::mlir::Pass> createWildcardArraySpecializationPass(WildcardArraySpecializationPassOptions options) {
  return impl::createWildcardArraySpecializationPass(std::move(options));
}
#undef GEN_PASS_DEF_WILDCARDARRAYSPECIALIZATIONPASS
#endif // GEN_PASS_DEF_WILDCARDARRAYSPECIALIZATIONPASS
#ifdef GEN_PASS_REGISTRATION
 
//===----------------------------------------------------------------------===//
// EmptyTemplateRemovalPass Registration
//===----------------------------------------------------------------------===//
 
inline void registerEmptyTemplateRemovalPass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createEmptyTemplateRemovalPass();
  });
}
 
// Old registration code, kept for temporary backwards compatibility.
inline void registerEmptyTemplateRemovalPassPass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createEmptyTemplateRemovalPass();
  });
}
 
//===----------------------------------------------------------------------===//
// FlatteningPass Registration
//===----------------------------------------------------------------------===//
 
inline void registerFlatteningPass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createFlatteningPass();
  });
}
 
// Old registration code, kept for temporary backwards compatibility.
inline void registerFlatteningPassPass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createFlatteningPass();
  });
}
 
//===----------------------------------------------------------------------===//
// TypeVarInferencePass Registration
//===----------------------------------------------------------------------===//
 
inline void registerTypeVarInferencePass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createTypeVarInferencePass();
  });
}
 
// Old registration code, kept for temporary backwards compatibility.
inline void registerTypeVarInferencePassPass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createTypeVarInferencePass();
  });
}
 
//===----------------------------------------------------------------------===//
// WildcardArraySpecializationPass Registration
//===----------------------------------------------------------------------===//
 
inline void registerWildcardArraySpecializationPass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createWildcardArraySpecializationPass();
  });
}
 
// Old registration code, kept for temporary backwards compatibility.
inline void registerWildcardArraySpecializationPassPass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createWildcardArraySpecializationPass();
  });
}
 
//===----------------------------------------------------------------------===//
// Transformation Registration
//===----------------------------------------------------------------------===//
 
inline void registerTransformationPasses() {
  registerEmptyTemplateRemovalPass();
  registerFlatteningPass();
  registerTypeVarInferencePass();
  registerWildcardArraySpecializationPass();
}
#undef GEN_PASS_REGISTRATION
#endif // GEN_PASS_REGISTRATION
// Deprecated. Please use the new per-pass macros.
#ifdef GEN_PASS_CLASSES
 
template <typename DerivedT>
class EmptyTemplateRemovalPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
public:
  using Base = EmptyTemplateRemovalPassBase;
 
  EmptyTemplateRemovalPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
  EmptyTemplateRemovalPassBase(const EmptyTemplateRemovalPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
  EmptyTemplateRemovalPassBase& operator=(const EmptyTemplateRemovalPassBase &) = delete;
  EmptyTemplateRemovalPassBase(EmptyTemplateRemovalPassBase &&) = delete;
  EmptyTemplateRemovalPassBase& operator=(EmptyTemplateRemovalPassBase &&) = delete;
  ~EmptyTemplateRemovalPassBase() = default;

  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("llzk-drop-empty-templates");
  }
  ::llvm::StringRef getArgument() const override { return "llzk-drop-empty-templates"; }
 
  ::llvm::StringRef getDescription() const override { return "Remove empty templates"; }

  static constexpr ::llvm::StringLiteral getPassName() {
    return ::llvm::StringLiteral("EmptyTemplateRemovalPass");
  }
  ::llvm::StringRef getName() const override { return "EmptyTemplateRemovalPass"; }

  static bool classof(const ::mlir::Pass *pass) {
    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
  }

  std::unique_ptr<::mlir::Pass> clonePass() const override {
    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
  }

  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
    registry.insert<llzk::LLZKDialect>();
    registry.insert<llzk::boolean::BoolDialect>();
    registry.insert<llzk::array::ArrayDialect>();
    registry.insert<llzk::component::StructDialect>();
    registry.insert<llzk::constrain::ConstrainDialect>();
    registry.insert<llzk::felt::FeltDialect>();
    registry.insert<llzk::global::GlobalDialect>();
    registry.insert<llzk::include::IncludeDialect>();
    registry.insert<llzk::function::FunctionDialect>();
    registry.insert<llzk::string::StringDialect>();
    registry.insert<llzk::polymorphic::PolymorphicDialect>();
    registry.insert<mlir::arith::ArithDialect>();
    registry.insert<mlir::scf::SCFDialect>();
  }

  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(EmptyTemplateRemovalPassBase<DerivedT>)
 
protected:
};
 
template <typename DerivedT>
class FlatteningPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
public:
  using Base = FlatteningPassBase;
 
  FlatteningPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
  FlatteningPassBase(const FlatteningPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
  FlatteningPassBase& operator=(const FlatteningPassBase &) = delete;
  FlatteningPassBase(FlatteningPassBase &&) = delete;
  FlatteningPassBase& operator=(FlatteningPassBase &&) = delete;
  ~FlatteningPassBase() = default;

  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("llzk-flatten");
  }
  ::llvm::StringRef getArgument() const override { return "llzk-flatten"; }
 
  ::llvm::StringRef getDescription() const override { return "Flatten structs and unroll loops"; }

  static constexpr ::llvm::StringLiteral getPassName() {
    return ::llvm::StringLiteral("FlatteningPass");
  }
  ::llvm::StringRef getName() const override { return "FlatteningPass"; }

  static bool classof(const ::mlir::Pass *pass) {
    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
  }

  std::unique_ptr<::mlir::Pass> clonePass() const override {
    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
  }

  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
    registry.insert<llzk::LLZKDialect>();
    registry.insert<llzk::boolean::BoolDialect>();
    registry.insert<llzk::array::ArrayDialect>();
    registry.insert<llzk::component::StructDialect>();
    registry.insert<llzk::constrain::ConstrainDialect>();
    registry.insert<llzk::felt::FeltDialect>();
    registry.insert<llzk::global::GlobalDialect>();
    registry.insert<llzk::include::IncludeDialect>();
    registry.insert<llzk::function::FunctionDialect>();
    registry.insert<llzk::string::StringDialect>();
    registry.insert<llzk::polymorphic::PolymorphicDialect>();
    registry.insert<mlir::arith::ArithDialect>();
    registry.insert<mlir::scf::SCFDialect>();
  }

  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(FlatteningPassBase<DerivedT>)
 
protected:
  ::mlir::Pass::Option<unsigned> iterationLimit{*this, "max-iter", ::llvm::cl::desc("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."), ::llvm::cl::init(1000)};
  ::mlir::Pass::Option<::llzk::polymorphic::FlatteningCleanupMode> cleanupMode{*this, "cleanup", ::llvm::cl::desc("Specifies the extent to which unused parameterized definitions (i.e. structs or free functions within a `poly.template`) are removed during the flattening pass."), ::llvm::cl::init(::llzk::polymorphic::FlatteningCleanupMode::Unspecified), ::llvm::cl::values(
                clEnumValN(::llzk::polymorphic::FlatteningCleanupMode::Unspecified,
                           stringifyFlatteningCleanupMode(::llzk::polymorphic::FlatteningCleanupMode::Unspecified),
                           "Use the cleanup mode specified by the calling pipeline (defaults to `preimage` if not specified)."),
                clEnumValN(::llzk::polymorphic::FlatteningCleanupMode::Disabled,
                           stringifyFlatteningCleanupMode(::llzk::polymorphic::FlatteningCleanupMode::Disabled),
                           "No definitions are deleted."),
                clEnumValN(::llzk::polymorphic::FlatteningCleanupMode::Preimage,
                           stringifyFlatteningCleanupMode(::llzk::polymorphic::FlatteningCleanupMode::Preimage),
                           "Only definitions that were replaced with concrete instantiations are deleted."),
                clEnumValN(::llzk::polymorphic::FlatteningCleanupMode::ConcreteAsRoot,
                           stringifyFlatteningCleanupMode(::llzk::polymorphic::FlatteningCleanupMode::ConcreteAsRoot),
                           "All definitions that cannot be reached by a use-def chain from some concrete definition are deleted."),
                clEnumValN(::llzk::polymorphic::FlatteningCleanupMode::MainAsRoot,
                           stringifyFlatteningCleanupMode(::llzk::polymorphic::FlatteningCleanupMode::MainAsRoot),
                           "All definitions that cannot be reached by a use-def chain from the \"Main\" struct are deleted.")
          )};
};
 
template <typename DerivedT>
class TypeVarInferencePassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
public:
  using Base = TypeVarInferencePassBase;
 
  TypeVarInferencePassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
  TypeVarInferencePassBase(const TypeVarInferencePassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
  TypeVarInferencePassBase& operator=(const TypeVarInferencePassBase &) = delete;
  TypeVarInferencePassBase(TypeVarInferencePassBase &&) = delete;
  TypeVarInferencePassBase& operator=(TypeVarInferencePassBase &&) = delete;
  ~TypeVarInferencePassBase() = default;

  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("llzk-infer-tvar");
  }
  ::llvm::StringRef getArgument() const override { return "llzk-infer-tvar"; }
 
  ::llvm::StringRef getDescription() const override { return "Infer concrete function types for polymorphic type variables"; }

  static constexpr ::llvm::StringLiteral getPassName() {
    return ::llvm::StringLiteral("TypeVarInferencePass");
  }
  ::llvm::StringRef getName() const override { return "TypeVarInferencePass"; }

  static bool classof(const ::mlir::Pass *pass) {
    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
  }

  std::unique_ptr<::mlir::Pass> clonePass() const override {
    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
  }

  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
    registry.insert<llzk::LLZKDialect>();
    registry.insert<llzk::boolean::BoolDialect>();
    registry.insert<llzk::array::ArrayDialect>();
    registry.insert<llzk::component::StructDialect>();
    registry.insert<llzk::constrain::ConstrainDialect>();
    registry.insert<llzk::felt::FeltDialect>();
    registry.insert<llzk::global::GlobalDialect>();
    registry.insert<llzk::include::IncludeDialect>();
    registry.insert<llzk::function::FunctionDialect>();
    registry.insert<llzk::string::StringDialect>();
    registry.insert<llzk::polymorphic::PolymorphicDialect>();
    registry.insert<mlir::arith::ArithDialect>();
    registry.insert<mlir::scf::SCFDialect>();
  }

  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TypeVarInferencePassBase<DerivedT>)
 
protected:
};
 
template <typename DerivedT>
class WildcardArraySpecializationPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
public:
  using Base = WildcardArraySpecializationPassBase;
 
  WildcardArraySpecializationPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
  WildcardArraySpecializationPassBase(const WildcardArraySpecializationPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
  WildcardArraySpecializationPassBase& operator=(const WildcardArraySpecializationPassBase &) = delete;
  WildcardArraySpecializationPassBase(WildcardArraySpecializationPassBase &&) = delete;
  WildcardArraySpecializationPassBase& operator=(WildcardArraySpecializationPassBase &&) = delete;
  ~WildcardArraySpecializationPassBase() = default;

  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("llzk-specialize-wildcard-arrays");
  }
  ::llvm::StringRef getArgument() const override { return "llzk-specialize-wildcard-arrays"; }
 
  ::llvm::StringRef getDescription() const override { return "Refine wildcard array casts and specialize concrete call targets"; }

  static constexpr ::llvm::StringLiteral getPassName() {
    return ::llvm::StringLiteral("WildcardArraySpecializationPass");
  }
  ::llvm::StringRef getName() const override { return "WildcardArraySpecializationPass"; }

  static bool classof(const ::mlir::Pass *pass) {
    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
  }

  std::unique_ptr<::mlir::Pass> clonePass() const override {
    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
  }

  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
    registry.insert<llzk::LLZKDialect>();
    registry.insert<llzk::boolean::BoolDialect>();
    registry.insert<llzk::array::ArrayDialect>();
    registry.insert<llzk::component::StructDialect>();
    registry.insert<llzk::constrain::ConstrainDialect>();
    registry.insert<llzk::felt::FeltDialect>();
    registry.insert<llzk::global::GlobalDialect>();
    registry.insert<llzk::include::IncludeDialect>();
    registry.insert<llzk::function::FunctionDialect>();
    registry.insert<llzk::string::StringDialect>();
    registry.insert<llzk::polymorphic::PolymorphicDialect>();
    registry.insert<mlir::arith::ArithDialect>();
    registry.insert<mlir::scf::SCFDialect>();
  }

  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(WildcardArraySpecializationPassBase<DerivedT>)
 
protected:
  ::mlir::Pass::Option<unsigned> iterationLimit{*this, "max-iter", ::llvm::cl::desc("Maximum number of iterations before the pass gives up reaching a fixpoint."), ::llvm::cl::init(1000)};
};
#undef GEN_PASS_CLASSES
#endif // GEN_PASS_CLASSES