/* Autogenerated by mlir-tblgen; don't manually edit */

#ifdef GEN_PASS_DECL
// Generate declarations for all passes.
#define GEN_PASS_DECL_BUFFERIZEHLFIR
#define GEN_PASS_DECL_CONVERTHLFIRTOFIR
#define GEN_PASS_DECL_EXPRESSIONSIMPLIFICATION
#define GEN_PASS_DECL_INLINEELEMENTALS
#define GEN_PASS_DECL_INLINEHLFIRASSIGN
#define GEN_PASS_DECL_INLINEHLFIRCOPY
#define GEN_PASS_DECL_LOWERHLFIRINTRINSICS
#define GEN_PASS_DECL_LOWERHLFIRORDEREDASSIGNMENTS
#define GEN_PASS_DECL_OPTIMIZEDBUFFERIZATION
#define GEN_PASS_DECL_PROPAGATEFORTRANVARIABLEATTRIBUTES
#define GEN_PASS_DECL_SEPARATEALLOCATABLEASSIGN
#define GEN_PASS_DECL_SIMPLIFYHLFIRINTRINSICS
#undef GEN_PASS_DECL
#endif // GEN_PASS_DECL

//===----------------------------------------------------------------------===//
// BufferizeHLFIR
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_BUFFERIZEHLFIR
struct BufferizeHLFIROptions {
  bool optimizeEmptyElementals = false;
};
std::unique_ptr<::mlir::Pass> createBufferizeHLFIR();
std::unique_ptr<::mlir::Pass> createBufferizeHLFIR(BufferizeHLFIROptions options);
#undef GEN_PASS_DECL_BUFFERIZEHLFIR
#endif // GEN_PASS_DECL_BUFFERIZEHLFIR
#ifdef GEN_PASS_DEF_BUFFERIZEHLFIR

namespace impl {
  std::unique_ptr<::mlir::Pass> createBufferizeHLFIR();
} // namespace impl

namespace impl {
  std::unique_ptr<::mlir::Pass> createBufferizeHLFIR(BufferizeHLFIROptions options);
} // namespace impl
namespace impl {

template <typename DerivedT>
class BufferizeHLFIRBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
public:
  using Base = BufferizeHLFIRBase;

  BufferizeHLFIRBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
  BufferizeHLFIRBase(const BufferizeHLFIRBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
  BufferizeHLFIRBase& operator=(const BufferizeHLFIRBase &) = delete;
  BufferizeHLFIRBase(BufferizeHLFIRBase &&) = delete;
  BufferizeHLFIRBase& operator=(BufferizeHLFIRBase &&) = delete;
  ~BufferizeHLFIRBase() = default;

  /// Returns the command-line argument attached to this pass.
  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("bufferize-hlfir");
  }
  ::llvm::StringRef getArgument() const override { return "bufferize-hlfir"; }

  ::llvm::StringRef getDescription() const override { return R"PD(Convert HLFIR operations operating on hlfir.expr into operations on memory)PD"; }

  /// Returns the derived pass name.
  static constexpr ::llvm::StringLiteral getPassName() {
    return ::llvm::StringLiteral("BufferizeHLFIR");
  }
  ::llvm::StringRef getName() const override { return "BufferizeHLFIR"; }

  /// Support isa/dyn_cast functionality for the derived pass class.
  static bool classof(const ::mlir::Pass *pass) {
    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
  }

  /// A clone method to create a copy of this pass.
  std::unique_ptr<::mlir::Pass> clonePass() const override {
    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
  }

  /// Return the dialect that must be loaded in the context before this pass.
  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
    
  }

  /// Explicitly declare the TypeID for this class. We declare an explicit private
  /// instantiation because Pass classes should only be visible by the current
  /// library.
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(BufferizeHLFIRBase<DerivedT>)

  BufferizeHLFIRBase(BufferizeHLFIROptions options) : BufferizeHLFIRBase() {
    optimizeEmptyElementals = std::move(options.optimizeEmptyElementals);
  }
protected:
  ::mlir::Pass::Option<bool> optimizeEmptyElementals{*this, "opt-empty-elementals", ::llvm::cl::desc(R"PO(When converting hlfir.elemental into a loop nest, check if the resulting expression is an empty array, and make sure none of the loops is executed.)PO"), ::llvm::cl::init(false)};
private:

  friend std::unique_ptr<::mlir::Pass> createBufferizeHLFIR() {
    return std::make_unique<DerivedT>();
  }

  friend std::unique_ptr<::mlir::Pass> createBufferizeHLFIR(BufferizeHLFIROptions options) {
    return std::make_unique<DerivedT>(std::move(options));
  }
};
} // namespace impl

std::unique_ptr<::mlir::Pass> createBufferizeHLFIR() {
  return impl::createBufferizeHLFIR();
}

std::unique_ptr<::mlir::Pass> createBufferizeHLFIR(BufferizeHLFIROptions options) {
  return impl::createBufferizeHLFIR(std::move(options));
}
#undef GEN_PASS_DEF_BUFFERIZEHLFIR
#endif // GEN_PASS_DEF_BUFFERIZEHLFIR

//===----------------------------------------------------------------------===//
// ConvertHLFIRtoFIR
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_CONVERTHLFIRTOFIR
std::unique_ptr<::mlir::Pass> createConvertHLFIRtoFIR();
#undef GEN_PASS_DECL_CONVERTHLFIRTOFIR
#endif // GEN_PASS_DECL_CONVERTHLFIRTOFIR
#ifdef GEN_PASS_DEF_CONVERTHLFIRTOFIR

namespace impl {
  std::unique_ptr<::mlir::Pass> createConvertHLFIRtoFIR();
} // namespace impl
namespace impl {

template <typename DerivedT>
class ConvertHLFIRtoFIRBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
public:
  using Base = ConvertHLFIRtoFIRBase;

  ConvertHLFIRtoFIRBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
  ConvertHLFIRtoFIRBase(const ConvertHLFIRtoFIRBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
  ConvertHLFIRtoFIRBase& operator=(const ConvertHLFIRtoFIRBase &) = delete;
  ConvertHLFIRtoFIRBase(ConvertHLFIRtoFIRBase &&) = delete;
  ConvertHLFIRtoFIRBase& operator=(ConvertHLFIRtoFIRBase &&) = delete;
  ~ConvertHLFIRtoFIRBase() = default;

  /// Returns the command-line argument attached to this pass.
  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("convert-hlfir-to-fir");
  }
  ::llvm::StringRef getArgument() const override { return "convert-hlfir-to-fir"; }

  ::llvm::StringRef getDescription() const override { return R"PD(Lower High-Level FIR to FIR)PD"; }

  /// Returns the derived pass name.
  static constexpr ::llvm::StringLiteral getPassName() {
    return ::llvm::StringLiteral("ConvertHLFIRtoFIR");
  }
  ::llvm::StringRef getName() const override { return "ConvertHLFIRtoFIR"; }

  /// Support isa/dyn_cast functionality for the derived pass class.
  static bool classof(const ::mlir::Pass *pass) {
    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
  }

  /// A clone method to create a copy of this pass.
  std::unique_ptr<::mlir::Pass> clonePass() const override {
    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
  }

  /// Return the dialect that must be loaded in the context before this pass.
  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
    registry.insert<mlir::func::FuncDialect>();
  }

  /// Explicitly declare the TypeID for this class. We declare an explicit private
  /// instantiation because Pass classes should only be visible by the current
  /// library.
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(ConvertHLFIRtoFIRBase<DerivedT>)

protected:
private:

  friend std::unique_ptr<::mlir::Pass> createConvertHLFIRtoFIR() {
    return std::make_unique<DerivedT>();
  }
};
} // namespace impl

std::unique_ptr<::mlir::Pass> createConvertHLFIRtoFIR() {
  return impl::createConvertHLFIRtoFIR();
}
#undef GEN_PASS_DEF_CONVERTHLFIRTOFIR
#endif // GEN_PASS_DEF_CONVERTHLFIRTOFIR

//===----------------------------------------------------------------------===//
// ExpressionSimplification
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_EXPRESSIONSIMPLIFICATION
std::unique_ptr<::mlir::Pass> createExpressionSimplification();
#undef GEN_PASS_DECL_EXPRESSIONSIMPLIFICATION
#endif // GEN_PASS_DECL_EXPRESSIONSIMPLIFICATION
#ifdef GEN_PASS_DEF_EXPRESSIONSIMPLIFICATION

namespace impl {
  std::unique_ptr<::mlir::Pass> createExpressionSimplification();
} // namespace impl
namespace impl {

template <typename DerivedT>
class ExpressionSimplificationBase : public ::mlir::OperationPass<> {
public:
  using Base = ExpressionSimplificationBase;

  ExpressionSimplificationBase() : ::mlir::OperationPass<>(::mlir::TypeID::get<DerivedT>()) {}
  ExpressionSimplificationBase(const ExpressionSimplificationBase &other) : ::mlir::OperationPass<>(other) {}
  ExpressionSimplificationBase& operator=(const ExpressionSimplificationBase &) = delete;
  ExpressionSimplificationBase(ExpressionSimplificationBase &&) = delete;
  ExpressionSimplificationBase& operator=(ExpressionSimplificationBase &&) = delete;
  ~ExpressionSimplificationBase() = default;

  /// Returns the command-line argument attached to this pass.
  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("hlfir-expression-simplification");
  }
  ::llvm::StringRef getArgument() const override { return "hlfir-expression-simplification"; }

  ::llvm::StringRef getDescription() const override { return R"PD(Simplify Fortran expressions)PD"; }

  /// Returns the derived pass name.
  static constexpr ::llvm::StringLiteral getPassName() {
    return ::llvm::StringLiteral("ExpressionSimplification");
  }
  ::llvm::StringRef getName() const override { return "ExpressionSimplification"; }

  /// Support isa/dyn_cast functionality for the derived pass class.
  static bool classof(const ::mlir::Pass *pass) {
    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
  }

  /// A clone method to create a copy of this pass.
  std::unique_ptr<::mlir::Pass> clonePass() const override {
    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
  }

  /// Return the dialect that must be loaded in the context before this pass.
  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
    
  }

  /// Explicitly declare the TypeID for this class. We declare an explicit private
  /// instantiation because Pass classes should only be visible by the current
  /// library.
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(ExpressionSimplificationBase<DerivedT>)

protected:
private:

  friend std::unique_ptr<::mlir::Pass> createExpressionSimplification() {
    return std::make_unique<DerivedT>();
  }
};
} // namespace impl

std::unique_ptr<::mlir::Pass> createExpressionSimplification() {
  return impl::createExpressionSimplification();
}
#undef GEN_PASS_DEF_EXPRESSIONSIMPLIFICATION
#endif // GEN_PASS_DEF_EXPRESSIONSIMPLIFICATION

//===----------------------------------------------------------------------===//
// InlineElementals
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_INLINEELEMENTALS
std::unique_ptr<::mlir::Pass> createInlineElementals();
#undef GEN_PASS_DECL_INLINEELEMENTALS
#endif // GEN_PASS_DECL_INLINEELEMENTALS
#ifdef GEN_PASS_DEF_INLINEELEMENTALS

namespace impl {
  std::unique_ptr<::mlir::Pass> createInlineElementals();
} // namespace impl
namespace impl {

template <typename DerivedT>
class InlineElementalsBase : public ::mlir::OperationPass<> {
public:
  using Base = InlineElementalsBase;

  InlineElementalsBase() : ::mlir::OperationPass<>(::mlir::TypeID::get<DerivedT>()) {}
  InlineElementalsBase(const InlineElementalsBase &other) : ::mlir::OperationPass<>(other) {}
  InlineElementalsBase& operator=(const InlineElementalsBase &) = delete;
  InlineElementalsBase(InlineElementalsBase &&) = delete;
  InlineElementalsBase& operator=(InlineElementalsBase &&) = delete;
  ~InlineElementalsBase() = default;

  /// Returns the command-line argument attached to this pass.
  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("inline-elementals");
  }
  ::llvm::StringRef getArgument() const override { return "inline-elementals"; }

  ::llvm::StringRef getDescription() const override { return R"PD(Inline chained hlfir.elemental operations)PD"; }

  /// Returns the derived pass name.
  static constexpr ::llvm::StringLiteral getPassName() {
    return ::llvm::StringLiteral("InlineElementals");
  }
  ::llvm::StringRef getName() const override { return "InlineElementals"; }

  /// Support isa/dyn_cast functionality for the derived pass class.
  static bool classof(const ::mlir::Pass *pass) {
    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
  }

  /// A clone method to create a copy of this pass.
  std::unique_ptr<::mlir::Pass> clonePass() const override {
    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
  }

  /// Return the dialect that must be loaded in the context before this pass.
  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
    
  }

  /// Explicitly declare the TypeID for this class. We declare an explicit private
  /// instantiation because Pass classes should only be visible by the current
  /// library.
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(InlineElementalsBase<DerivedT>)

protected:
private:

  friend std::unique_ptr<::mlir::Pass> createInlineElementals() {
    return std::make_unique<DerivedT>();
  }
};
} // namespace impl

std::unique_ptr<::mlir::Pass> createInlineElementals() {
  return impl::createInlineElementals();
}
#undef GEN_PASS_DEF_INLINEELEMENTALS
#endif // GEN_PASS_DEF_INLINEELEMENTALS

//===----------------------------------------------------------------------===//
// InlineHLFIRAssign
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_INLINEHLFIRASSIGN
struct InlineHLFIRAssignOptions {
  bool onlyScalarRHS = false;
};
std::unique_ptr<::mlir::Pass> createInlineHLFIRAssign();
std::unique_ptr<::mlir::Pass> createInlineHLFIRAssign(InlineHLFIRAssignOptions options);
#undef GEN_PASS_DECL_INLINEHLFIRASSIGN
#endif // GEN_PASS_DECL_INLINEHLFIRASSIGN
#ifdef GEN_PASS_DEF_INLINEHLFIRASSIGN

namespace impl {
  std::unique_ptr<::mlir::Pass> createInlineHLFIRAssign();
} // namespace impl

namespace impl {
  std::unique_ptr<::mlir::Pass> createInlineHLFIRAssign(InlineHLFIRAssignOptions options);
} // namespace impl
namespace impl {

template <typename DerivedT>
class InlineHLFIRAssignBase : public ::mlir::OperationPass<> {
public:
  using Base = InlineHLFIRAssignBase;

  InlineHLFIRAssignBase() : ::mlir::OperationPass<>(::mlir::TypeID::get<DerivedT>()) {}
  InlineHLFIRAssignBase(const InlineHLFIRAssignBase &other) : ::mlir::OperationPass<>(other) {}
  InlineHLFIRAssignBase& operator=(const InlineHLFIRAssignBase &) = delete;
  InlineHLFIRAssignBase(InlineHLFIRAssignBase &&) = delete;
  InlineHLFIRAssignBase& operator=(InlineHLFIRAssignBase &&) = delete;
  ~InlineHLFIRAssignBase() = default;

  /// Returns the command-line argument attached to this pass.
  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("inline-hlfir-assign");
  }
  ::llvm::StringRef getArgument() const override { return "inline-hlfir-assign"; }

  ::llvm::StringRef getDescription() const override { return R"PD(Inline hlfir.assign operations)PD"; }

  /// Returns the derived pass name.
  static constexpr ::llvm::StringLiteral getPassName() {
    return ::llvm::StringLiteral("InlineHLFIRAssign");
  }
  ::llvm::StringRef getName() const override { return "InlineHLFIRAssign"; }

  /// Support isa/dyn_cast functionality for the derived pass class.
  static bool classof(const ::mlir::Pass *pass) {
    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
  }

  /// A clone method to create a copy of this pass.
  std::unique_ptr<::mlir::Pass> clonePass() const override {
    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
  }

  /// Return the dialect that must be loaded in the context before this pass.
  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
    
  }

  /// Explicitly declare the TypeID for this class. We declare an explicit private
  /// instantiation because Pass classes should only be visible by the current
  /// library.
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(InlineHLFIRAssignBase<DerivedT>)

  InlineHLFIRAssignBase(InlineHLFIRAssignOptions options) : InlineHLFIRAssignBase() {
    onlyScalarRHS = std::move(options.onlyScalarRHS);
  }
protected:
  ::mlir::Pass::Option<bool> onlyScalarRHS{*this, "only-scalar-rhs", ::llvm::cl::desc(R"PO(Only inline assignments where RHS is a numeric or logical scalar broadcast to an array LHS. Used at O0 to avoid runtime calls in device code without inlining all array assignments.)PO"), ::llvm::cl::init(false)};
private:

  friend std::unique_ptr<::mlir::Pass> createInlineHLFIRAssign() {
    return std::make_unique<DerivedT>();
  }

  friend std::unique_ptr<::mlir::Pass> createInlineHLFIRAssign(InlineHLFIRAssignOptions options) {
    return std::make_unique<DerivedT>(std::move(options));
  }
};
} // namespace impl

std::unique_ptr<::mlir::Pass> createInlineHLFIRAssign() {
  return impl::createInlineHLFIRAssign();
}

std::unique_ptr<::mlir::Pass> createInlineHLFIRAssign(InlineHLFIRAssignOptions options) {
  return impl::createInlineHLFIRAssign(std::move(options));
}
#undef GEN_PASS_DEF_INLINEHLFIRASSIGN
#endif // GEN_PASS_DEF_INLINEHLFIRASSIGN

//===----------------------------------------------------------------------===//
// InlineHLFIRCopy
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_INLINEHLFIRCOPY
std::unique_ptr<::mlir::Pass> createInlineHLFIRCopy();
#undef GEN_PASS_DECL_INLINEHLFIRCOPY
#endif // GEN_PASS_DECL_INLINEHLFIRCOPY
#ifdef GEN_PASS_DEF_INLINEHLFIRCOPY

namespace impl {
  std::unique_ptr<::mlir::Pass> createInlineHLFIRCopy();
} // namespace impl
namespace impl {

template <typename DerivedT>
class InlineHLFIRCopyBase : public ::mlir::OperationPass<> {
public:
  using Base = InlineHLFIRCopyBase;

  InlineHLFIRCopyBase() : ::mlir::OperationPass<>(::mlir::TypeID::get<DerivedT>()) {}
  InlineHLFIRCopyBase(const InlineHLFIRCopyBase &other) : ::mlir::OperationPass<>(other) {}
  InlineHLFIRCopyBase& operator=(const InlineHLFIRCopyBase &) = delete;
  InlineHLFIRCopyBase(InlineHLFIRCopyBase &&) = delete;
  InlineHLFIRCopyBase& operator=(InlineHLFIRCopyBase &&) = delete;
  ~InlineHLFIRCopyBase() = default;

  /// Returns the command-line argument attached to this pass.
  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("inline-hlfir-copy");
  }
  ::llvm::StringRef getArgument() const override { return "inline-hlfir-copy"; }

  ::llvm::StringRef getDescription() const override { return R"PD(Inline hlfir.copy_in and hlfir.copy_out operations)PD"; }

  /// Returns the derived pass name.
  static constexpr ::llvm::StringLiteral getPassName() {
    return ::llvm::StringLiteral("InlineHLFIRCopy");
  }
  ::llvm::StringRef getName() const override { return "InlineHLFIRCopy"; }

  /// Support isa/dyn_cast functionality for the derived pass class.
  static bool classof(const ::mlir::Pass *pass) {
    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
  }

  /// A clone method to create a copy of this pass.
  std::unique_ptr<::mlir::Pass> clonePass() const override {
    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
  }

  /// Return the dialect that must be loaded in the context before this pass.
  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
    
  }

  /// Explicitly declare the TypeID for this class. We declare an explicit private
  /// instantiation because Pass classes should only be visible by the current
  /// library.
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(InlineHLFIRCopyBase<DerivedT>)

protected:
private:

  friend std::unique_ptr<::mlir::Pass> createInlineHLFIRCopy() {
    return std::make_unique<DerivedT>();
  }
};
} // namespace impl

std::unique_ptr<::mlir::Pass> createInlineHLFIRCopy() {
  return impl::createInlineHLFIRCopy();
}
#undef GEN_PASS_DEF_INLINEHLFIRCOPY
#endif // GEN_PASS_DEF_INLINEHLFIRCOPY

//===----------------------------------------------------------------------===//
// LowerHLFIRIntrinsics
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_LOWERHLFIRINTRINSICS
std::unique_ptr<::mlir::Pass> createLowerHLFIRIntrinsics();
#undef GEN_PASS_DECL_LOWERHLFIRINTRINSICS
#endif // GEN_PASS_DECL_LOWERHLFIRINTRINSICS
#ifdef GEN_PASS_DEF_LOWERHLFIRINTRINSICS

namespace impl {
  std::unique_ptr<::mlir::Pass> createLowerHLFIRIntrinsics();
} // namespace impl
namespace impl {

template <typename DerivedT>
class LowerHLFIRIntrinsicsBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
public:
  using Base = LowerHLFIRIntrinsicsBase;

  LowerHLFIRIntrinsicsBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
  LowerHLFIRIntrinsicsBase(const LowerHLFIRIntrinsicsBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
  LowerHLFIRIntrinsicsBase& operator=(const LowerHLFIRIntrinsicsBase &) = delete;
  LowerHLFIRIntrinsicsBase(LowerHLFIRIntrinsicsBase &&) = delete;
  LowerHLFIRIntrinsicsBase& operator=(LowerHLFIRIntrinsicsBase &&) = delete;
  ~LowerHLFIRIntrinsicsBase() = default;

  /// Returns the command-line argument attached to this pass.
  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("lower-hlfir-intrinsics");
  }
  ::llvm::StringRef getArgument() const override { return "lower-hlfir-intrinsics"; }

  ::llvm::StringRef getDescription() const override { return R"PD(Lower HLFIR transformational intrinsic operations)PD"; }

  /// Returns the derived pass name.
  static constexpr ::llvm::StringLiteral getPassName() {
    return ::llvm::StringLiteral("LowerHLFIRIntrinsics");
  }
  ::llvm::StringRef getName() const override { return "LowerHLFIRIntrinsics"; }

  /// Support isa/dyn_cast functionality for the derived pass class.
  static bool classof(const ::mlir::Pass *pass) {
    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
  }

  /// A clone method to create a copy of this pass.
  std::unique_ptr<::mlir::Pass> clonePass() const override {
    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
  }

  /// Return the dialect that must be loaded in the context before this pass.
  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
    
  }

  /// Explicitly declare the TypeID for this class. We declare an explicit private
  /// instantiation because Pass classes should only be visible by the current
  /// library.
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(LowerHLFIRIntrinsicsBase<DerivedT>)

protected:
private:

  friend std::unique_ptr<::mlir::Pass> createLowerHLFIRIntrinsics() {
    return std::make_unique<DerivedT>();
  }
};
} // namespace impl

std::unique_ptr<::mlir::Pass> createLowerHLFIRIntrinsics() {
  return impl::createLowerHLFIRIntrinsics();
}
#undef GEN_PASS_DEF_LOWERHLFIRINTRINSICS
#endif // GEN_PASS_DEF_LOWERHLFIRINTRINSICS

//===----------------------------------------------------------------------===//
// LowerHLFIROrderedAssignments
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_LOWERHLFIRORDEREDASSIGNMENTS
struct LowerHLFIROrderedAssignmentsOptions {
  bool tryFusingAssignments = false;
};
std::unique_ptr<::mlir::Pass> createLowerHLFIROrderedAssignments();
std::unique_ptr<::mlir::Pass> createLowerHLFIROrderedAssignments(LowerHLFIROrderedAssignmentsOptions options);
#undef GEN_PASS_DECL_LOWERHLFIRORDEREDASSIGNMENTS
#endif // GEN_PASS_DECL_LOWERHLFIRORDEREDASSIGNMENTS
#ifdef GEN_PASS_DEF_LOWERHLFIRORDEREDASSIGNMENTS

namespace impl {
  std::unique_ptr<::mlir::Pass> createLowerHLFIROrderedAssignments();
} // namespace impl

namespace impl {
  std::unique_ptr<::mlir::Pass> createLowerHLFIROrderedAssignments(LowerHLFIROrderedAssignmentsOptions options);
} // namespace impl
namespace impl {

template <typename DerivedT>
class LowerHLFIROrderedAssignmentsBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
public:
  using Base = LowerHLFIROrderedAssignmentsBase;

  LowerHLFIROrderedAssignmentsBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
  LowerHLFIROrderedAssignmentsBase(const LowerHLFIROrderedAssignmentsBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
  LowerHLFIROrderedAssignmentsBase& operator=(const LowerHLFIROrderedAssignmentsBase &) = delete;
  LowerHLFIROrderedAssignmentsBase(LowerHLFIROrderedAssignmentsBase &&) = delete;
  LowerHLFIROrderedAssignmentsBase& operator=(LowerHLFIROrderedAssignmentsBase &&) = delete;
  ~LowerHLFIROrderedAssignmentsBase() = default;

  /// Returns the command-line argument attached to this pass.
  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("lower-hlfir-ordered-assignments");
  }
  ::llvm::StringRef getArgument() const override { return "lower-hlfir-ordered-assignments"; }

  ::llvm::StringRef getDescription() const override { return R"PD(Lower HLFIR ordered assignments like forall and where operations)PD"; }

  /// Returns the derived pass name.
  static constexpr ::llvm::StringLiteral getPassName() {
    return ::llvm::StringLiteral("LowerHLFIROrderedAssignments");
  }
  ::llvm::StringRef getName() const override { return "LowerHLFIROrderedAssignments"; }

  /// Support isa/dyn_cast functionality for the derived pass class.
  static bool classof(const ::mlir::Pass *pass) {
    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
  }

  /// A clone method to create a copy of this pass.
  std::unique_ptr<::mlir::Pass> clonePass() const override {
    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
  }

  /// Return the dialect that must be loaded in the context before this pass.
  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
    
  }

  /// Explicitly declare the TypeID for this class. We declare an explicit private
  /// instantiation because Pass classes should only be visible by the current
  /// library.
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(LowerHLFIROrderedAssignmentsBase<DerivedT>)

  LowerHLFIROrderedAssignmentsBase(LowerHLFIROrderedAssignmentsOptions options) : LowerHLFIROrderedAssignmentsBase() {
    tryFusingAssignments = std::move(options.tryFusingAssignments);
  }
protected:
  ::mlir::Pass::Option<bool> tryFusingAssignments{*this, "fuse-assignments", ::llvm::cl::desc(R"PO(Fuse Forall and Where assignments in the same loop nest when legal.It is not clear yet if this is always beneficial. It may be best toleave this to later loop optimizations.Hence this is off by default.)PO"), ::llvm::cl::init(false)};
private:

  friend std::unique_ptr<::mlir::Pass> createLowerHLFIROrderedAssignments() {
    return std::make_unique<DerivedT>();
  }

  friend std::unique_ptr<::mlir::Pass> createLowerHLFIROrderedAssignments(LowerHLFIROrderedAssignmentsOptions options) {
    return std::make_unique<DerivedT>(std::move(options));
  }
};
} // namespace impl

std::unique_ptr<::mlir::Pass> createLowerHLFIROrderedAssignments() {
  return impl::createLowerHLFIROrderedAssignments();
}

std::unique_ptr<::mlir::Pass> createLowerHLFIROrderedAssignments(LowerHLFIROrderedAssignmentsOptions options) {
  return impl::createLowerHLFIROrderedAssignments(std::move(options));
}
#undef GEN_PASS_DEF_LOWERHLFIRORDEREDASSIGNMENTS
#endif // GEN_PASS_DEF_LOWERHLFIRORDEREDASSIGNMENTS

//===----------------------------------------------------------------------===//
// OptimizedBufferization
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_OPTIMIZEDBUFFERIZATION
std::unique_ptr<::mlir::Pass> createOptimizedBufferization();
#undef GEN_PASS_DECL_OPTIMIZEDBUFFERIZATION
#endif // GEN_PASS_DECL_OPTIMIZEDBUFFERIZATION
#ifdef GEN_PASS_DEF_OPTIMIZEDBUFFERIZATION

namespace impl {
  std::unique_ptr<::mlir::Pass> createOptimizedBufferization();
} // namespace impl
namespace impl {

template <typename DerivedT>
class OptimizedBufferizationBase : public ::mlir::OperationPass<> {
public:
  using Base = OptimizedBufferizationBase;

  OptimizedBufferizationBase() : ::mlir::OperationPass<>(::mlir::TypeID::get<DerivedT>()) {}
  OptimizedBufferizationBase(const OptimizedBufferizationBase &other) : ::mlir::OperationPass<>(other) {}
  OptimizedBufferizationBase& operator=(const OptimizedBufferizationBase &) = delete;
  OptimizedBufferizationBase(OptimizedBufferizationBase &&) = delete;
  OptimizedBufferizationBase& operator=(OptimizedBufferizationBase &&) = delete;
  ~OptimizedBufferizationBase() = default;

  /// Returns the command-line argument attached to this pass.
  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("opt-bufferization");
  }
  ::llvm::StringRef getArgument() const override { return "opt-bufferization"; }

  ::llvm::StringRef getDescription() const override { return R"PD(Special cases for hlfir.expr bufferization where we can avoid a temporary which would be created by the generic bufferization pass)PD"; }

  /// Returns the derived pass name.
  static constexpr ::llvm::StringLiteral getPassName() {
    return ::llvm::StringLiteral("OptimizedBufferization");
  }
  ::llvm::StringRef getName() const override { return "OptimizedBufferization"; }

  /// Support isa/dyn_cast functionality for the derived pass class.
  static bool classof(const ::mlir::Pass *pass) {
    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
  }

  /// A clone method to create a copy of this pass.
  std::unique_ptr<::mlir::Pass> clonePass() const override {
    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
  }

  /// Return the dialect that must be loaded in the context before this pass.
  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
    
  }

  /// Explicitly declare the TypeID for this class. We declare an explicit private
  /// instantiation because Pass classes should only be visible by the current
  /// library.
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(OptimizedBufferizationBase<DerivedT>)

protected:
private:

  friend std::unique_ptr<::mlir::Pass> createOptimizedBufferization() {
    return std::make_unique<DerivedT>();
  }
};
} // namespace impl

std::unique_ptr<::mlir::Pass> createOptimizedBufferization() {
  return impl::createOptimizedBufferization();
}
#undef GEN_PASS_DEF_OPTIMIZEDBUFFERIZATION
#endif // GEN_PASS_DEF_OPTIMIZEDBUFFERIZATION

//===----------------------------------------------------------------------===//
// PropagateFortranVariableAttributes
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_PROPAGATEFORTRANVARIABLEATTRIBUTES
std::unique_ptr<::mlir::Pass> createPropagateFortranVariableAttributes();
#undef GEN_PASS_DECL_PROPAGATEFORTRANVARIABLEATTRIBUTES
#endif // GEN_PASS_DECL_PROPAGATEFORTRANVARIABLEATTRIBUTES
#ifdef GEN_PASS_DEF_PROPAGATEFORTRANVARIABLEATTRIBUTES

namespace impl {
  std::unique_ptr<::mlir::Pass> createPropagateFortranVariableAttributes();
} // namespace impl
namespace impl {

template <typename DerivedT>
class PropagateFortranVariableAttributesBase : public ::mlir::OperationPass<> {
public:
  using Base = PropagateFortranVariableAttributesBase;

  PropagateFortranVariableAttributesBase() : ::mlir::OperationPass<>(::mlir::TypeID::get<DerivedT>()) {}
  PropagateFortranVariableAttributesBase(const PropagateFortranVariableAttributesBase &other) : ::mlir::OperationPass<>(other) {}
  PropagateFortranVariableAttributesBase& operator=(const PropagateFortranVariableAttributesBase &) = delete;
  PropagateFortranVariableAttributesBase(PropagateFortranVariableAttributesBase &&) = delete;
  PropagateFortranVariableAttributesBase& operator=(PropagateFortranVariableAttributesBase &&) = delete;
  ~PropagateFortranVariableAttributesBase() = default;

  /// Returns the command-line argument attached to this pass.
  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("propagate-fortran-attrs");
  }
  ::llvm::StringRef getArgument() const override { return "propagate-fortran-attrs"; }

  ::llvm::StringRef getDescription() const override { return R"PD(Propagate FortranVariableFlagsAttr attributes through HLFIR)PD"; }

  /// Returns the derived pass name.
  static constexpr ::llvm::StringLiteral getPassName() {
    return ::llvm::StringLiteral("PropagateFortranVariableAttributes");
  }
  ::llvm::StringRef getName() const override { return "PropagateFortranVariableAttributes"; }

  /// Support isa/dyn_cast functionality for the derived pass class.
  static bool classof(const ::mlir::Pass *pass) {
    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
  }

  /// A clone method to create a copy of this pass.
  std::unique_ptr<::mlir::Pass> clonePass() const override {
    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
  }

  /// Return the dialect that must be loaded in the context before this pass.
  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
    
  }

  /// Explicitly declare the TypeID for this class. We declare an explicit private
  /// instantiation because Pass classes should only be visible by the current
  /// library.
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(PropagateFortranVariableAttributesBase<DerivedT>)

protected:
private:

  friend std::unique_ptr<::mlir::Pass> createPropagateFortranVariableAttributes() {
    return std::make_unique<DerivedT>();
  }
};
} // namespace impl

std::unique_ptr<::mlir::Pass> createPropagateFortranVariableAttributes() {
  return impl::createPropagateFortranVariableAttributes();
}
#undef GEN_PASS_DEF_PROPAGATEFORTRANVARIABLEATTRIBUTES
#endif // GEN_PASS_DEF_PROPAGATEFORTRANVARIABLEATTRIBUTES

//===----------------------------------------------------------------------===//
// SeparateAllocatableAssign
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_SEPARATEALLOCATABLEASSIGN
std::unique_ptr<::mlir::Pass> createSeparateAllocatableAssign();
#undef GEN_PASS_DECL_SEPARATEALLOCATABLEASSIGN
#endif // GEN_PASS_DECL_SEPARATEALLOCATABLEASSIGN
#ifdef GEN_PASS_DEF_SEPARATEALLOCATABLEASSIGN

namespace impl {
  std::unique_ptr<::mlir::Pass> createSeparateAllocatableAssign();
} // namespace impl
namespace impl {

template <typename DerivedT>
class SeparateAllocatableAssignBase : public ::mlir::OperationPass<> {
public:
  using Base = SeparateAllocatableAssignBase;

  SeparateAllocatableAssignBase() : ::mlir::OperationPass<>(::mlir::TypeID::get<DerivedT>()) {}
  SeparateAllocatableAssignBase(const SeparateAllocatableAssignBase &other) : ::mlir::OperationPass<>(other) {}
  SeparateAllocatableAssignBase& operator=(const SeparateAllocatableAssignBase &) = delete;
  SeparateAllocatableAssignBase(SeparateAllocatableAssignBase &&) = delete;
  SeparateAllocatableAssignBase& operator=(SeparateAllocatableAssignBase &&) = delete;
  ~SeparateAllocatableAssignBase() = default;

  /// Returns the command-line argument attached to this pass.
  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("separate-allocatable-assign");
  }
  ::llvm::StringRef getArgument() const override { return "separate-allocatable-assign"; }

  ::llvm::StringRef getDescription() const override { return R"PD(Separate reallocation from allocatable array assignments)PD"; }

  /// Returns the derived pass name.
  static constexpr ::llvm::StringLiteral getPassName() {
    return ::llvm::StringLiteral("SeparateAllocatableAssign");
  }
  ::llvm::StringRef getName() const override { return "SeparateAllocatableAssign"; }

  /// Support isa/dyn_cast functionality for the derived pass class.
  static bool classof(const ::mlir::Pass *pass) {
    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
  }

  /// A clone method to create a copy of this pass.
  std::unique_ptr<::mlir::Pass> clonePass() const override {
    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
  }

  /// Return the dialect that must be loaded in the context before this pass.
  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
    
  }

  /// Explicitly declare the TypeID for this class. We declare an explicit private
  /// instantiation because Pass classes should only be visible by the current
  /// library.
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(SeparateAllocatableAssignBase<DerivedT>)

protected:
private:

  friend std::unique_ptr<::mlir::Pass> createSeparateAllocatableAssign() {
    return std::make_unique<DerivedT>();
  }
};
} // namespace impl

std::unique_ptr<::mlir::Pass> createSeparateAllocatableAssign() {
  return impl::createSeparateAllocatableAssign();
}
#undef GEN_PASS_DEF_SEPARATEALLOCATABLEASSIGN
#endif // GEN_PASS_DEF_SEPARATEALLOCATABLEASSIGN

//===----------------------------------------------------------------------===//
// SimplifyHLFIRIntrinsics
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_SIMPLIFYHLFIRINTRINSICS
struct SimplifyHLFIRIntrinsicsOptions {
  bool allowNewSideEffects = false;
  Fortran::common::FPMaxminBehavior fpMaxminBehavior = Fortran::common::FPMaxminBehavior::Legacy;
};
std::unique_ptr<::mlir::Pass> createSimplifyHLFIRIntrinsics();
std::unique_ptr<::mlir::Pass> createSimplifyHLFIRIntrinsics(SimplifyHLFIRIntrinsicsOptions options);
#undef GEN_PASS_DECL_SIMPLIFYHLFIRINTRINSICS
#endif // GEN_PASS_DECL_SIMPLIFYHLFIRINTRINSICS
#ifdef GEN_PASS_DEF_SIMPLIFYHLFIRINTRINSICS

namespace impl {
  std::unique_ptr<::mlir::Pass> createSimplifyHLFIRIntrinsics();
} // namespace impl

namespace impl {
  std::unique_ptr<::mlir::Pass> createSimplifyHLFIRIntrinsics(SimplifyHLFIRIntrinsicsOptions options);
} // namespace impl
namespace impl {

template <typename DerivedT>
class SimplifyHLFIRIntrinsicsBase : public ::mlir::OperationPass<> {
public:
  using Base = SimplifyHLFIRIntrinsicsBase;

  SimplifyHLFIRIntrinsicsBase() : ::mlir::OperationPass<>(::mlir::TypeID::get<DerivedT>()) {}
  SimplifyHLFIRIntrinsicsBase(const SimplifyHLFIRIntrinsicsBase &other) : ::mlir::OperationPass<>(other) {}
  SimplifyHLFIRIntrinsicsBase& operator=(const SimplifyHLFIRIntrinsicsBase &) = delete;
  SimplifyHLFIRIntrinsicsBase(SimplifyHLFIRIntrinsicsBase &&) = delete;
  SimplifyHLFIRIntrinsicsBase& operator=(SimplifyHLFIRIntrinsicsBase &&) = delete;
  ~SimplifyHLFIRIntrinsicsBase() = default;

  /// Returns the command-line argument attached to this pass.
  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("simplify-hlfir-intrinsics");
  }
  ::llvm::StringRef getArgument() const override { return "simplify-hlfir-intrinsics"; }

  ::llvm::StringRef getDescription() const override { return R"PD(Simplify HLFIR intrinsic operations that don't need to result in runtime calls)PD"; }

  /// Returns the derived pass name.
  static constexpr ::llvm::StringLiteral getPassName() {
    return ::llvm::StringLiteral("SimplifyHLFIRIntrinsics");
  }
  ::llvm::StringRef getName() const override { return "SimplifyHLFIRIntrinsics"; }

  /// Support isa/dyn_cast functionality for the derived pass class.
  static bool classof(const ::mlir::Pass *pass) {
    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
  }

  /// A clone method to create a copy of this pass.
  std::unique_ptr<::mlir::Pass> clonePass() const override {
    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
  }

  /// Return the dialect that must be loaded in the context before this pass.
  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
    
  }

  /// Explicitly declare the TypeID for this class. We declare an explicit private
  /// instantiation because Pass classes should only be visible by the current
  /// library.
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(SimplifyHLFIRIntrinsicsBase<DerivedT>)

  SimplifyHLFIRIntrinsicsBase(SimplifyHLFIRIntrinsicsOptions options) : SimplifyHLFIRIntrinsicsBase() {
    allowNewSideEffects = std::move(options.allowNewSideEffects);
    fpMaxminBehavior = std::move(options.fpMaxminBehavior);
  }
protected:
  ::mlir::Pass::Option<bool> allowNewSideEffects{*this, "allow-new-side-effects", ::llvm::cl::desc(R"PO(If enabled, then the HLFIR operations simplification may introduce operations with side effects. For example, hlfir.matmul may be inlined as and hlfir.eval_in_mem with hlfir.assign inside it.The hlfir.assign has a write effect on the memory argument of hlfir.eval_in_mem, which may block some existing MLIR transformations (e.g. CSE) that otherwise would have been possible across the hlfir.matmul.)PO"), ::llvm::cl::init(false)};
  ::mlir::Pass::Option<Fortran::common::FPMaxminBehavior> fpMaxminBehavior{*this, "fp-maxmin-behavior", ::llvm::cl::desc(R"PO(This option defines the FP max/min behavior.)PO"), ::llvm::cl::init(Fortran::common::FPMaxminBehavior::Legacy), ::llvm::cl::values(
               clEnumValN(Fortran::common::FPMaxminBehavior::Legacy,
                          "legacy", "cmp+select"),
               clEnumValN(Fortran::common::FPMaxminBehavior::Portable,
                          "portable", "same as legacy, except that "
                          "arith.max/minnumf may be used when nnan "
                          "and nsz fast math flags are enabled"),
               clEnumValN(Fortran::common::FPMaxminBehavior::Extremum,
                          "extremum", "arith.max/minimumf"),
               clEnumValN(Fortran::common::FPMaxminBehavior::ExtremeNum,
                          "extremenum", "arith.max/minnumf"))};
private:

  friend std::unique_ptr<::mlir::Pass> createSimplifyHLFIRIntrinsics() {
    return std::make_unique<DerivedT>();
  }

  friend std::unique_ptr<::mlir::Pass> createSimplifyHLFIRIntrinsics(SimplifyHLFIRIntrinsicsOptions options) {
    return std::make_unique<DerivedT>(std::move(options));
  }
};
} // namespace impl

std::unique_ptr<::mlir::Pass> createSimplifyHLFIRIntrinsics() {
  return impl::createSimplifyHLFIRIntrinsics();
}

std::unique_ptr<::mlir::Pass> createSimplifyHLFIRIntrinsics(SimplifyHLFIRIntrinsicsOptions options) {
  return impl::createSimplifyHLFIRIntrinsics(std::move(options));
}
#undef GEN_PASS_DEF_SIMPLIFYHLFIRINTRINSICS
#endif // GEN_PASS_DEF_SIMPLIFYHLFIRINTRINSICS
#ifdef GEN_PASS_REGISTRATION
// Generate registrations for all passes.
#define GEN_PASS_REGISTRATION_BUFFERIZEHLFIR
#define GEN_PASS_REGISTRATION_CONVERTHLFIRTOFIR
#define GEN_PASS_REGISTRATION_EXPRESSIONSIMPLIFICATION
#define GEN_PASS_REGISTRATION_INLINEELEMENTALS
#define GEN_PASS_REGISTRATION_INLINEHLFIRASSIGN
#define GEN_PASS_REGISTRATION_INLINEHLFIRCOPY
#define GEN_PASS_REGISTRATION_LOWERHLFIRINTRINSICS
#define GEN_PASS_REGISTRATION_LOWERHLFIRORDEREDASSIGNMENTS
#define GEN_PASS_REGISTRATION_OPTIMIZEDBUFFERIZATION
#define GEN_PASS_REGISTRATION_PROPAGATEFORTRANVARIABLEATTRIBUTES
#define GEN_PASS_REGISTRATION_SEPARATEALLOCATABLEASSIGN
#define GEN_PASS_REGISTRATION_SIMPLIFYHLFIRINTRINSICS
#endif // GEN_PASS_REGISTRATION

//===----------------------------------------------------------------------===//
// BufferizeHLFIR Registration
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_REGISTRATION_BUFFERIZEHLFIR

inline void registerBufferizeHLFIR() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createBufferizeHLFIR();
  });
}

// Old registration code, kept for temporary backwards compatibility.
inline void registerBufferizeHLFIRPass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createBufferizeHLFIR();
  });
}

#undef GEN_PASS_REGISTRATION_BUFFERIZEHLFIR
#endif // GEN_PASS_REGISTRATION_BUFFERIZEHLFIR

//===----------------------------------------------------------------------===//
// ConvertHLFIRtoFIR Registration
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_REGISTRATION_CONVERTHLFIRTOFIR

inline void registerConvertHLFIRtoFIR() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createConvertHLFIRtoFIR();
  });
}

// Old registration code, kept for temporary backwards compatibility.
inline void registerConvertHLFIRtoFIRPass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createConvertHLFIRtoFIR();
  });
}

#undef GEN_PASS_REGISTRATION_CONVERTHLFIRTOFIR
#endif // GEN_PASS_REGISTRATION_CONVERTHLFIRTOFIR

//===----------------------------------------------------------------------===//
// ExpressionSimplification Registration
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_REGISTRATION_EXPRESSIONSIMPLIFICATION

inline void registerExpressionSimplification() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createExpressionSimplification();
  });
}

// Old registration code, kept for temporary backwards compatibility.
inline void registerExpressionSimplificationPass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createExpressionSimplification();
  });
}

#undef GEN_PASS_REGISTRATION_EXPRESSIONSIMPLIFICATION
#endif // GEN_PASS_REGISTRATION_EXPRESSIONSIMPLIFICATION

//===----------------------------------------------------------------------===//
// InlineElementals Registration
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_REGISTRATION_INLINEELEMENTALS

inline void registerInlineElementals() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createInlineElementals();
  });
}

// Old registration code, kept for temporary backwards compatibility.
inline void registerInlineElementalsPass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createInlineElementals();
  });
}

#undef GEN_PASS_REGISTRATION_INLINEELEMENTALS
#endif // GEN_PASS_REGISTRATION_INLINEELEMENTALS

//===----------------------------------------------------------------------===//
// InlineHLFIRAssign Registration
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_REGISTRATION_INLINEHLFIRASSIGN

inline void registerInlineHLFIRAssign() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createInlineHLFIRAssign();
  });
}

// Old registration code, kept for temporary backwards compatibility.
inline void registerInlineHLFIRAssignPass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createInlineHLFIRAssign();
  });
}

#undef GEN_PASS_REGISTRATION_INLINEHLFIRASSIGN
#endif // GEN_PASS_REGISTRATION_INLINEHLFIRASSIGN

//===----------------------------------------------------------------------===//
// InlineHLFIRCopy Registration
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_REGISTRATION_INLINEHLFIRCOPY

inline void registerInlineHLFIRCopy() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createInlineHLFIRCopy();
  });
}

// Old registration code, kept for temporary backwards compatibility.
inline void registerInlineHLFIRCopyPass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createInlineHLFIRCopy();
  });
}

#undef GEN_PASS_REGISTRATION_INLINEHLFIRCOPY
#endif // GEN_PASS_REGISTRATION_INLINEHLFIRCOPY

//===----------------------------------------------------------------------===//
// LowerHLFIRIntrinsics Registration
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_REGISTRATION_LOWERHLFIRINTRINSICS

inline void registerLowerHLFIRIntrinsics() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createLowerHLFIRIntrinsics();
  });
}

// Old registration code, kept for temporary backwards compatibility.
inline void registerLowerHLFIRIntrinsicsPass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createLowerHLFIRIntrinsics();
  });
}

#undef GEN_PASS_REGISTRATION_LOWERHLFIRINTRINSICS
#endif // GEN_PASS_REGISTRATION_LOWERHLFIRINTRINSICS

//===----------------------------------------------------------------------===//
// LowerHLFIROrderedAssignments Registration
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_REGISTRATION_LOWERHLFIRORDEREDASSIGNMENTS

inline void registerLowerHLFIROrderedAssignments() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createLowerHLFIROrderedAssignments();
  });
}

// Old registration code, kept for temporary backwards compatibility.
inline void registerLowerHLFIROrderedAssignmentsPass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createLowerHLFIROrderedAssignments();
  });
}

#undef GEN_PASS_REGISTRATION_LOWERHLFIRORDEREDASSIGNMENTS
#endif // GEN_PASS_REGISTRATION_LOWERHLFIRORDEREDASSIGNMENTS

//===----------------------------------------------------------------------===//
// OptimizedBufferization Registration
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_REGISTRATION_OPTIMIZEDBUFFERIZATION

inline void registerOptimizedBufferization() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createOptimizedBufferization();
  });
}

// Old registration code, kept for temporary backwards compatibility.
inline void registerOptimizedBufferizationPass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createOptimizedBufferization();
  });
}

#undef GEN_PASS_REGISTRATION_OPTIMIZEDBUFFERIZATION
#endif // GEN_PASS_REGISTRATION_OPTIMIZEDBUFFERIZATION

//===----------------------------------------------------------------------===//
// PropagateFortranVariableAttributes Registration
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_REGISTRATION_PROPAGATEFORTRANVARIABLEATTRIBUTES

inline void registerPropagateFortranVariableAttributes() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createPropagateFortranVariableAttributes();
  });
}

// Old registration code, kept for temporary backwards compatibility.
inline void registerPropagateFortranVariableAttributesPass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createPropagateFortranVariableAttributes();
  });
}

#undef GEN_PASS_REGISTRATION_PROPAGATEFORTRANVARIABLEATTRIBUTES
#endif // GEN_PASS_REGISTRATION_PROPAGATEFORTRANVARIABLEATTRIBUTES

//===----------------------------------------------------------------------===//
// SeparateAllocatableAssign Registration
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_REGISTRATION_SEPARATEALLOCATABLEASSIGN

inline void registerSeparateAllocatableAssign() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createSeparateAllocatableAssign();
  });
}

// Old registration code, kept for temporary backwards compatibility.
inline void registerSeparateAllocatableAssignPass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createSeparateAllocatableAssign();
  });
}

#undef GEN_PASS_REGISTRATION_SEPARATEALLOCATABLEASSIGN
#endif // GEN_PASS_REGISTRATION_SEPARATEALLOCATABLEASSIGN

//===----------------------------------------------------------------------===//
// SimplifyHLFIRIntrinsics Registration
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_REGISTRATION_SIMPLIFYHLFIRINTRINSICS

inline void registerSimplifyHLFIRIntrinsics() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createSimplifyHLFIRIntrinsics();
  });
}

// Old registration code, kept for temporary backwards compatibility.
inline void registerSimplifyHLFIRIntrinsicsPass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createSimplifyHLFIRIntrinsics();
  });
}

#undef GEN_PASS_REGISTRATION_SIMPLIFYHLFIRINTRINSICS
#endif // GEN_PASS_REGISTRATION_SIMPLIFYHLFIRINTRINSICS
#ifdef GEN_PASS_REGISTRATION

//===----------------------------------------------------------------------===//
// HLFIR Registration
//===----------------------------------------------------------------------===//

inline void registerHLFIRPasses() {
  registerBufferizeHLFIR();
  registerConvertHLFIRtoFIR();
  registerExpressionSimplification();
  registerInlineElementals();
  registerInlineHLFIRAssign();
  registerInlineHLFIRCopy();
  registerLowerHLFIRIntrinsics();
  registerLowerHLFIROrderedAssignments();
  registerOptimizedBufferization();
  registerPropagateFortranVariableAttributes();
  registerSeparateAllocatableAssign();
  registerSimplifyHLFIRIntrinsics();
}
#undef GEN_PASS_REGISTRATION
#endif // GEN_PASS_REGISTRATION
#ifdef GEN_PASS_CLASSES
#error "GEN_PASS_CLASSES is deprecated; use per-pass macros"
#undef GEN_PASS_CLASSES
#endif // GEN_PASS_CLASSES
