LLZKTransformationPasses.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_POLYLOWERINGPASS
#define GEN_PASS_DECL_REDUNDANTOPERATIONELIMINATIONPASS
#define GEN_PASS_DECL_REDUNDANTREADANDWRITEELIMINATIONPASS
#define GEN_PASS_DECL_UNUSEDDECLARATIONELIMINATIONPASS
#undef GEN_PASS_DECL
#endif // GEN_PASS_DECL
 
//===----------------------------------------------------------------------===//
// PolyLoweringPass
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_POLYLOWERINGPASS
struct PolyLoweringPassOptions {
  unsigned maxDegree = 2;
};
#undef GEN_PASS_DECL_POLYLOWERINGPASS
#endif // GEN_PASS_DECL_POLYLOWERINGPASS
#ifdef GEN_PASS_DEF_POLYLOWERINGPASS
namespace impl {
 
template <typename DerivedT>
class PolyLoweringPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
public:
  using Base = PolyLoweringPassBase;
 
  PolyLoweringPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
  PolyLoweringPassBase(const PolyLoweringPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}

  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("llzk-poly-lowering-pass");
  }
  ::llvm::StringRef getArgument() const override { return "llzk-poly-lowering-pass"; }
 
  ::llvm::StringRef getDescription() const override { return "Lowers the degree of all polynomial equations to a specified maximum"; }

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

  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<llzk::undef::UndefDialect>();
    registry.insert<mlir::arith::ArithDialect>();
    registry.insert<mlir::scf::SCFDialect>();
  }

  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(PolyLoweringPassBase<DerivedT>)
 
  PolyLoweringPassBase(const PolyLoweringPassOptions &options) : PolyLoweringPassBase() {
    maxDegree = options.maxDegree;
  }
protected:
  ::mlir::Pass::Option<unsigned> maxDegree{*this, "max-degree", ::llvm::cl::desc("Maximum degree of constraint polynomials (default 2, minimum 2)"), ::llvm::cl::init(2)};
private:
};
} // namespace impl
#undef GEN_PASS_DEF_POLYLOWERINGPASS
#endif // GEN_PASS_DEF_POLYLOWERINGPASS
 
//===----------------------------------------------------------------------===//
// RedundantOperationEliminationPass
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_REDUNDANTOPERATIONELIMINATIONPASS
#undef GEN_PASS_DECL_REDUNDANTOPERATIONELIMINATIONPASS
#endif // GEN_PASS_DECL_REDUNDANTOPERATIONELIMINATIONPASS
#ifdef GEN_PASS_DEF_REDUNDANTOPERATIONELIMINATIONPASS
namespace impl {
 
template <typename DerivedT>
class RedundantOperationEliminationPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
public:
  using Base = RedundantOperationEliminationPassBase;
 
  RedundantOperationEliminationPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
  RedundantOperationEliminationPassBase(const RedundantOperationEliminationPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}

  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("llzk-duplicate-op-elim");
  }
  ::llvm::StringRef getArgument() const override { return "llzk-duplicate-op-elim"; }
 
  ::llvm::StringRef getDescription() const override { return "Remove redundant operations"; }

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

  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<llzk::undef::UndefDialect>();
    registry.insert<mlir::arith::ArithDialect>();
    registry.insert<mlir::scf::SCFDialect>();
  }

  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(RedundantOperationEliminationPassBase<DerivedT>)
 
protected:
private:
};
} // namespace impl
#undef GEN_PASS_DEF_REDUNDANTOPERATIONELIMINATIONPASS
#endif // GEN_PASS_DEF_REDUNDANTOPERATIONELIMINATIONPASS
 
//===----------------------------------------------------------------------===//
// RedundantReadAndWriteEliminationPass
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_REDUNDANTREADANDWRITEELIMINATIONPASS
#undef GEN_PASS_DECL_REDUNDANTREADANDWRITEELIMINATIONPASS
#endif // GEN_PASS_DECL_REDUNDANTREADANDWRITEELIMINATIONPASS
#ifdef GEN_PASS_DEF_REDUNDANTREADANDWRITEELIMINATIONPASS
namespace impl {
 
template <typename DerivedT>
class RedundantReadAndWriteEliminationPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
public:
  using Base = RedundantReadAndWriteEliminationPassBase;
 
  RedundantReadAndWriteEliminationPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
  RedundantReadAndWriteEliminationPassBase(const RedundantReadAndWriteEliminationPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}

  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("llzk-duplicate-read-write-elim");
  }
  ::llvm::StringRef getArgument() const override { return "llzk-duplicate-read-write-elim"; }
 
  ::llvm::StringRef getDescription() const override { return "Remove redundant reads and writes"; }

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

  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<llzk::undef::UndefDialect>();
    registry.insert<mlir::arith::ArithDialect>();
    registry.insert<mlir::scf::SCFDialect>();
  }

  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(RedundantReadAndWriteEliminationPassBase<DerivedT>)
 
protected:
private:
};
} // namespace impl
#undef GEN_PASS_DEF_REDUNDANTREADANDWRITEELIMINATIONPASS
#endif // GEN_PASS_DEF_REDUNDANTREADANDWRITEELIMINATIONPASS
 
//===----------------------------------------------------------------------===//
// UnusedDeclarationEliminationPass
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_UNUSEDDECLARATIONELIMINATIONPASS
struct UnusedDeclarationEliminationPassOptions {
  bool removeStructs = false;
};
#undef GEN_PASS_DECL_UNUSEDDECLARATIONELIMINATIONPASS
#endif // GEN_PASS_DECL_UNUSEDDECLARATIONELIMINATIONPASS
#ifdef GEN_PASS_DEF_UNUSEDDECLARATIONELIMINATIONPASS
namespace impl {
 
template <typename DerivedT>
class UnusedDeclarationEliminationPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
public:
  using Base = UnusedDeclarationEliminationPassBase;
 
  UnusedDeclarationEliminationPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
  UnusedDeclarationEliminationPassBase(const UnusedDeclarationEliminationPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}

  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("llzk-unused-declaration-elim");
  }
  ::llvm::StringRef getArgument() const override { return "llzk-unused-declaration-elim"; }
 
  ::llvm::StringRef getDescription() const override { return "Remove unused field and struct declarations"; }

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

  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<llzk::undef::UndefDialect>();
    registry.insert<mlir::arith::ArithDialect>();
    registry.insert<mlir::scf::SCFDialect>();
  }

  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(UnusedDeclarationEliminationPassBase<DerivedT>)
 
  UnusedDeclarationEliminationPassBase(const UnusedDeclarationEliminationPassOptions &options) : UnusedDeclarationEliminationPassBase() {
    removeStructs = options.removeStructs;
  }
protected:
  ::mlir::Pass::Option<bool> removeStructs{*this, "remove-structs", ::llvm::cl::desc("Whether to remove unused struct definitions as well. Requires module to declare a Main component, otherwise all components will appear unused."), ::llvm::cl::init(false)};
private:
};
} // namespace impl
#undef GEN_PASS_DEF_UNUSEDDECLARATIONELIMINATIONPASS
#endif // GEN_PASS_DEF_UNUSEDDECLARATIONELIMINATIONPASS
#ifdef GEN_PASS_REGISTRATION
 
//===----------------------------------------------------------------------===//
// PolyLoweringPass Registration
//===----------------------------------------------------------------------===//
 
inline void registerPolyLoweringPass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return llzk::createPolyLoweringPass();
  });
}
 
// Old registration code, kept for temporary backwards compatibility.
inline void registerPolyLoweringPassPass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return llzk::createPolyLoweringPass();
  });
}
 
//===----------------------------------------------------------------------===//
// RedundantOperationEliminationPass Registration
//===----------------------------------------------------------------------===//
 
inline void registerRedundantOperationEliminationPass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return llzk::createRedundantOperationEliminationPass();
  });
}
 
// Old registration code, kept for temporary backwards compatibility.
inline void registerRedundantOperationEliminationPassPass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return llzk::createRedundantOperationEliminationPass();
  });
}
 
//===----------------------------------------------------------------------===//
// RedundantReadAndWriteEliminationPass Registration
//===----------------------------------------------------------------------===//
 
inline void registerRedundantReadAndWriteEliminationPass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return llzk::createRedundantReadAndWriteEliminationPass();
  });
}
 
// Old registration code, kept for temporary backwards compatibility.
inline void registerRedundantReadAndWriteEliminationPassPass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return llzk::createRedundantReadAndWriteEliminationPass();
  });
}
 
//===----------------------------------------------------------------------===//
// UnusedDeclarationEliminationPass Registration
//===----------------------------------------------------------------------===//
 
inline void registerUnusedDeclarationEliminationPass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return llzk::createUnusedDeclarationEliminationPass();
  });
}
 
// Old registration code, kept for temporary backwards compatibility.
inline void registerUnusedDeclarationEliminationPassPass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return llzk::createUnusedDeclarationEliminationPass();
  });
}
 
//===----------------------------------------------------------------------===//
// Transformation Registration
//===----------------------------------------------------------------------===//
 
inline void registerTransformationPasses() {
  registerPolyLoweringPass();
  registerRedundantOperationEliminationPass();
  registerRedundantReadAndWriteEliminationPass();
  registerUnusedDeclarationEliminationPass();
}
#undef GEN_PASS_REGISTRATION
#endif // GEN_PASS_REGISTRATION
// Deprecated. Please use the new per-pass macros.
#ifdef GEN_PASS_CLASSES
 
template <typename DerivedT>
class PolyLoweringPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
public:
  using Base = PolyLoweringPassBase;
 
  PolyLoweringPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
  PolyLoweringPassBase(const PolyLoweringPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}

  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("llzk-poly-lowering-pass");
  }
  ::llvm::StringRef getArgument() const override { return "llzk-poly-lowering-pass"; }
 
  ::llvm::StringRef getDescription() const override { return "Lowers the degree of all polynomial equations to a specified maximum"; }

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

  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<llzk::undef::UndefDialect>();
    registry.insert<mlir::arith::ArithDialect>();
    registry.insert<mlir::scf::SCFDialect>();
  }

  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(PolyLoweringPassBase<DerivedT>)
 
protected:
  ::mlir::Pass::Option<unsigned> maxDegree{*this, "max-degree", ::llvm::cl::desc("Maximum degree of constraint polynomials (default 2, minimum 2)"), ::llvm::cl::init(2)};
};
 
template <typename DerivedT>
class RedundantOperationEliminationPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
public:
  using Base = RedundantOperationEliminationPassBase;
 
  RedundantOperationEliminationPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
  RedundantOperationEliminationPassBase(const RedundantOperationEliminationPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}

  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("llzk-duplicate-op-elim");
  }
  ::llvm::StringRef getArgument() const override { return "llzk-duplicate-op-elim"; }
 
  ::llvm::StringRef getDescription() const override { return "Remove redundant operations"; }

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

  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<llzk::undef::UndefDialect>();
    registry.insert<mlir::arith::ArithDialect>();
    registry.insert<mlir::scf::SCFDialect>();
  }

  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(RedundantOperationEliminationPassBase<DerivedT>)
 
protected:
};
 
template <typename DerivedT>
class RedundantReadAndWriteEliminationPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
public:
  using Base = RedundantReadAndWriteEliminationPassBase;
 
  RedundantReadAndWriteEliminationPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
  RedundantReadAndWriteEliminationPassBase(const RedundantReadAndWriteEliminationPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}

  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("llzk-duplicate-read-write-elim");
  }
  ::llvm::StringRef getArgument() const override { return "llzk-duplicate-read-write-elim"; }
 
  ::llvm::StringRef getDescription() const override { return "Remove redundant reads and writes"; }

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

  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<llzk::undef::UndefDialect>();
    registry.insert<mlir::arith::ArithDialect>();
    registry.insert<mlir::scf::SCFDialect>();
  }

  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(RedundantReadAndWriteEliminationPassBase<DerivedT>)
 
protected:
};
 
template <typename DerivedT>
class UnusedDeclarationEliminationPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
public:
  using Base = UnusedDeclarationEliminationPassBase;
 
  UnusedDeclarationEliminationPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
  UnusedDeclarationEliminationPassBase(const UnusedDeclarationEliminationPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}

  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("llzk-unused-declaration-elim");
  }
  ::llvm::StringRef getArgument() const override { return "llzk-unused-declaration-elim"; }
 
  ::llvm::StringRef getDescription() const override { return "Remove unused field and struct declarations"; }

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

  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<llzk::undef::UndefDialect>();
    registry.insert<mlir::arith::ArithDialect>();
    registry.insert<mlir::scf::SCFDialect>();
  }

  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(UnusedDeclarationEliminationPassBase<DerivedT>)
 
protected:
  ::mlir::Pass::Option<bool> removeStructs{*this, "remove-structs", ::llvm::cl::desc("Whether to remove unused struct definitions as well. Requires module to declare a Main component, otherwise all components will appear unused."), ::llvm::cl::init(false)};
};
#undef GEN_PASS_CLASSES
#endif // GEN_PASS_CLASSES