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

#ifdef GEN_PASS_DECL
// Generate declarations for all passes.
#define GEN_PASS_DECL_AUTOMAPTOTARGETDATAPASS
#define GEN_PASS_DECL_DELETEUNREACHABLETARGETSPASS
#define GEN_PASS_DECL_DOCONCURRENTCONVERSIONPASS
#define GEN_PASS_DECL_FUNCTIONFILTERINGPASS
#define GEN_PASS_DECL_GENERICLOOPCONVERSIONPASS
#define GEN_PASS_DECL_HOSTOPFILTERINGPASS
#define GEN_PASS_DECL_LOWERNONTEMPORALPASS
#define GEN_PASS_DECL_LOWERWORKDISTRIBUTE
#define GEN_PASS_DECL_LOWERWORKSHARE
#define GEN_PASS_DECL_MAPINFOFINALIZATIONPASS
#define GEN_PASS_DECL_MAPSFORPRIVATIZEDSYMBOLSPASS
#define GEN_PASS_DECL_SIMDONLYPASS
#undef GEN_PASS_DECL
#endif // GEN_PASS_DECL

//===----------------------------------------------------------------------===//
// AutomapToTargetDataPass
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_AUTOMAPTOTARGETDATAPASS
std::unique_ptr<::mlir::Pass> createAutomapToTargetDataPass();
#undef GEN_PASS_DECL_AUTOMAPTOTARGETDATAPASS
#endif // GEN_PASS_DECL_AUTOMAPTOTARGETDATAPASS
#ifdef GEN_PASS_DEF_AUTOMAPTOTARGETDATAPASS

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

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

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

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

  ::llvm::StringRef getDescription() const override { return R"PD(Insert OpenMP target data operations for AUTOMAP variables)PD"; }

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

  /// 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::omp::OpenMPDialect>();
  }

  /// 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(AutomapToTargetDataPassBase<DerivedT>)

protected:
private:

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

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

//===----------------------------------------------------------------------===//
// DeleteUnreachableTargetsPass
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_DELETEUNREACHABLETARGETSPASS
std::unique_ptr<::mlir::Pass> createDeleteUnreachableTargetsPass();
#undef GEN_PASS_DECL_DELETEUNREACHABLETARGETSPASS
#endif // GEN_PASS_DECL_DELETEUNREACHABLETARGETSPASS
#ifdef GEN_PASS_DEF_DELETEUNREACHABLETARGETSPASS

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

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

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

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

  ::llvm::StringRef getDescription() const override { return R"PD(Deletes OpenMP target operations in unreachable code)PD"; }

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

  /// 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::omp::OpenMPDialect>();
  }

  /// 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(DeleteUnreachableTargetsPassBase<DerivedT>)

protected:
private:

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

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

//===----------------------------------------------------------------------===//
// DoConcurrentConversionPass
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_DOCONCURRENTCONVERSIONPASS
struct DoConcurrentConversionPassOptions {
  flangomp::DoConcurrentMappingKind mapTo = flangomp::DoConcurrentMappingKind::DCMK_None;
};
std::unique_ptr<::mlir::Pass> createDoConcurrentConversionPass();
std::unique_ptr<::mlir::Pass> createDoConcurrentConversionPass(DoConcurrentConversionPassOptions options);
#undef GEN_PASS_DECL_DOCONCURRENTCONVERSIONPASS
#endif // GEN_PASS_DECL_DOCONCURRENTCONVERSIONPASS
#ifdef GEN_PASS_DEF_DOCONCURRENTCONVERSIONPASS

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

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

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

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

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

  ::llvm::StringRef getDescription() const override { return R"PD(Map `DO CONCURRENT` loops to OpenMP worksharing loops.)PD"; }

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

  /// 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::omp::OpenMPDialect>();
  }

  /// 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(DoConcurrentConversionPassBase<DerivedT>)

  DoConcurrentConversionPassBase(DoConcurrentConversionPassOptions options) : DoConcurrentConversionPassBase() {
    mapTo = std::move(options.mapTo);
  }
protected:
  ::mlir::Pass::Option<flangomp::DoConcurrentMappingKind> mapTo{*this, "map-to", ::llvm::cl::desc(R"PO(Try to map `do concurrent` loops to OpenMP [none|host|device])PO"), ::llvm::cl::init(flangomp::DoConcurrentMappingKind::DCMK_None), ::llvm::cl::values(
               clEnumValN(flangomp::DoConcurrentMappingKind::DCMK_None,
                          "none", "Do not lower `do concurrent` to OpenMP"),
               clEnumValN(flangomp::DoConcurrentMappingKind::DCMK_Host,
                          "host", "Lower to run in parallel on the CPU"),
               clEnumValN(flangomp::DoConcurrentMappingKind::DCMK_Device,
                          "device", "Lower to run in parallel on the GPU")
           )};
private:

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

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

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

std::unique_ptr<::mlir::Pass> createDoConcurrentConversionPass(DoConcurrentConversionPassOptions options) {
  return impl::createDoConcurrentConversionPass(std::move(options));
}
#undef GEN_PASS_DEF_DOCONCURRENTCONVERSIONPASS
#endif // GEN_PASS_DEF_DOCONCURRENTCONVERSIONPASS

//===----------------------------------------------------------------------===//
// FunctionFilteringPass
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_FUNCTIONFILTERINGPASS
std::unique_ptr<::mlir::Pass> createFunctionFilteringPass();
#undef GEN_PASS_DECL_FUNCTIONFILTERINGPASS
#endif // GEN_PASS_DECL_FUNCTIONFILTERINGPASS
#ifdef GEN_PASS_DEF_FUNCTIONFILTERINGPASS

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

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

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

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

  ::llvm::StringRef getDescription() const override { return R"PD(Filters out functions intended for the host when compiling for the target device.)PD"; }

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

  /// 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>();
    registry.insert<fir::FIROpsDialect>();
    registry.insert<mlir::omp::OpenMPDialect>();
  }

  /// 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(FunctionFilteringPassBase<DerivedT>)

protected:
private:

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

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

//===----------------------------------------------------------------------===//
// GenericLoopConversionPass
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_GENERICLOOPCONVERSIONPASS
std::unique_ptr<::mlir::Pass> createGenericLoopConversionPass();
#undef GEN_PASS_DECL_GENERICLOOPCONVERSIONPASS
#endif // GEN_PASS_DECL_GENERICLOOPCONVERSIONPASS
#ifdef GEN_PASS_DEF_GENERICLOOPCONVERSIONPASS

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

template <typename DerivedT>
class GenericLoopConversionPassBase : public ::mlir::OperationPass<mlir::func::FuncOp> {
public:
  using Base = GenericLoopConversionPassBase;

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

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

  ::llvm::StringRef getDescription() const override { return R"PD(Converts OpenMP generic `omp.loop` to semantically equivalent OpenMP ops)PD"; }

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

  /// 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::omp::OpenMPDialect>();
  }

  /// 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(GenericLoopConversionPassBase<DerivedT>)

protected:
private:

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

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

//===----------------------------------------------------------------------===//
// HostOpFilteringPass
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_HOSTOPFILTERINGPASS
std::unique_ptr<::mlir::Pass> createHostOpFilteringPass();
#undef GEN_PASS_DECL_HOSTOPFILTERINGPASS
#endif // GEN_PASS_DECL_HOSTOPFILTERINGPASS
#ifdef GEN_PASS_DEF_HOSTOPFILTERINGPASS

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

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

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

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

  ::llvm::StringRef getDescription() const override { return R"PD(Removes host-only operations from host functions retained by the function filtering pass when compiling for a target device.)PD"; }

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

  /// 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::arith::ArithDialect>();
    registry.insert<mlir::func::FuncDialect>();
    registry.insert<fir::FIROpsDialect>();
  }

  /// 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(HostOpFilteringPassBase<DerivedT>)

protected:
private:

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

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

//===----------------------------------------------------------------------===//
// LowerNontemporalPass
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_LOWERNONTEMPORALPASS
std::unique_ptr<::mlir::Pass> createLowerNontemporalPass();
#undef GEN_PASS_DECL_LOWERNONTEMPORALPASS
#endif // GEN_PASS_DECL_LOWERNONTEMPORALPASS
#ifdef GEN_PASS_DEF_LOWERNONTEMPORALPASS

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

template <typename DerivedT>
class LowerNontemporalPassBase : public ::mlir::OperationPass<mlir::func::FuncOp> {
public:
  using Base = LowerNontemporalPassBase;

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

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

  ::llvm::StringRef getDescription() const override { return R"PD(Adds nontemporal attribute to loads and stores performed on the list items specified in the nontemporal clause of omp.simd.)PD"; }

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

  /// 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::omp::OpenMPDialect>();
  }

  /// 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(LowerNontemporalPassBase<DerivedT>)

protected:
private:

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

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

//===----------------------------------------------------------------------===//
// LowerWorkdistribute
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_LOWERWORKDISTRIBUTE
std::unique_ptr<::mlir::Pass> createLowerWorkdistribute();
#undef GEN_PASS_DECL_LOWERWORKDISTRIBUTE
#endif // GEN_PASS_DECL_LOWERWORKDISTRIBUTE
#ifdef GEN_PASS_DEF_LOWERWORKDISTRIBUTE

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

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

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

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

  ::llvm::StringRef getDescription() const override { return R"PD(Lower workdistribute construct)PD"; }

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

  /// 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(LowerWorkdistributeBase<DerivedT>)

protected:
private:

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

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

//===----------------------------------------------------------------------===//
// LowerWorkshare
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_LOWERWORKSHARE
std::unique_ptr<::mlir::Pass> createLowerWorkshare();
#undef GEN_PASS_DECL_LOWERWORKSHARE
#endif // GEN_PASS_DECL_LOWERWORKSHARE
#ifdef GEN_PASS_DEF_LOWERWORKSHARE

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

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

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

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

  ::llvm::StringRef getDescription() const override { return R"PD(Lower workshare construct)PD"; }

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

  /// 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(LowerWorkshareBase<DerivedT>)

protected:
private:

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

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

//===----------------------------------------------------------------------===//
// MapInfoFinalizationPass
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_MAPINFOFINALIZATIONPASS
std::unique_ptr<::mlir::Pass> createMapInfoFinalizationPass();
#undef GEN_PASS_DECL_MAPINFOFINALIZATIONPASS
#endif // GEN_PASS_DECL_MAPINFOFINALIZATIONPASS
#ifdef GEN_PASS_DEF_MAPINFOFINALIZATIONPASS

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

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

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

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

  ::llvm::StringRef getDescription() const override { return R"PD(expands OpenMP MapInfo operations containing descriptors)PD"; }

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

  /// 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::omp::OpenMPDialect>();
  }

  /// 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(MapInfoFinalizationPassBase<DerivedT>)

protected:
private:

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

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

//===----------------------------------------------------------------------===//
// MapsForPrivatizedSymbolsPass
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_MAPSFORPRIVATIZEDSYMBOLSPASS
std::unique_ptr<::mlir::Pass> createMapsForPrivatizedSymbolsPass();
#undef GEN_PASS_DECL_MAPSFORPRIVATIZEDSYMBOLSPASS
#endif // GEN_PASS_DECL_MAPSFORPRIVATIZEDSYMBOLSPASS
#ifdef GEN_PASS_DEF_MAPSFORPRIVATIZEDSYMBOLSPASS

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

template <typename DerivedT>
class MapsForPrivatizedSymbolsPassBase : public ::mlir::OperationPass<mlir::func::FuncOp> {
public:
  using Base = MapsForPrivatizedSymbolsPassBase;

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

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

  ::llvm::StringRef getDescription() const override { return R"PD(Creates MapInfoOp instances for privatized symbols when needed)PD"; }

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

  /// 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::omp::OpenMPDialect>();
  }

  /// 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(MapsForPrivatizedSymbolsPassBase<DerivedT>)

protected:
private:

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

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

//===----------------------------------------------------------------------===//
// SimdOnlyPass
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_SIMDONLYPASS
std::unique_ptr<::mlir::Pass> createSimdOnlyPass();
#undef GEN_PASS_DECL_SIMDONLYPASS
#endif // GEN_PASS_DECL_SIMDONLYPASS
#ifdef GEN_PASS_DEF_SIMDONLYPASS

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

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

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

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

  ::llvm::StringRef getDescription() const override { return R"PD(Filters out non-simd OpenMP constructs)PD"; }

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

  /// 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::omp::OpenMPDialect>();
  }

  /// 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(SimdOnlyPassBase<DerivedT>)

protected:
private:

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

std::unique_ptr<::mlir::Pass> createSimdOnlyPass() {
  return impl::createSimdOnlyPass();
}
#undef GEN_PASS_DEF_SIMDONLYPASS
#endif // GEN_PASS_DEF_SIMDONLYPASS
#ifdef GEN_PASS_REGISTRATION
// Generate registrations for all passes.
#define GEN_PASS_REGISTRATION_AUTOMAPTOTARGETDATAPASS
#define GEN_PASS_REGISTRATION_DELETEUNREACHABLETARGETSPASS
#define GEN_PASS_REGISTRATION_DOCONCURRENTCONVERSIONPASS
#define GEN_PASS_REGISTRATION_FUNCTIONFILTERINGPASS
#define GEN_PASS_REGISTRATION_GENERICLOOPCONVERSIONPASS
#define GEN_PASS_REGISTRATION_HOSTOPFILTERINGPASS
#define GEN_PASS_REGISTRATION_LOWERNONTEMPORALPASS
#define GEN_PASS_REGISTRATION_LOWERWORKDISTRIBUTE
#define GEN_PASS_REGISTRATION_LOWERWORKSHARE
#define GEN_PASS_REGISTRATION_MAPINFOFINALIZATIONPASS
#define GEN_PASS_REGISTRATION_MAPSFORPRIVATIZEDSYMBOLSPASS
#define GEN_PASS_REGISTRATION_SIMDONLYPASS
#endif // GEN_PASS_REGISTRATION

//===----------------------------------------------------------------------===//
// AutomapToTargetDataPass Registration
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_REGISTRATION_AUTOMAPTOTARGETDATAPASS

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

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

#undef GEN_PASS_REGISTRATION_AUTOMAPTOTARGETDATAPASS
#endif // GEN_PASS_REGISTRATION_AUTOMAPTOTARGETDATAPASS

//===----------------------------------------------------------------------===//
// DeleteUnreachableTargetsPass Registration
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_REGISTRATION_DELETEUNREACHABLETARGETSPASS

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

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

#undef GEN_PASS_REGISTRATION_DELETEUNREACHABLETARGETSPASS
#endif // GEN_PASS_REGISTRATION_DELETEUNREACHABLETARGETSPASS

//===----------------------------------------------------------------------===//
// DoConcurrentConversionPass Registration
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_REGISTRATION_DOCONCURRENTCONVERSIONPASS

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

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

#undef GEN_PASS_REGISTRATION_DOCONCURRENTCONVERSIONPASS
#endif // GEN_PASS_REGISTRATION_DOCONCURRENTCONVERSIONPASS

//===----------------------------------------------------------------------===//
// FunctionFilteringPass Registration
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_REGISTRATION_FUNCTIONFILTERINGPASS

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

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

#undef GEN_PASS_REGISTRATION_FUNCTIONFILTERINGPASS
#endif // GEN_PASS_REGISTRATION_FUNCTIONFILTERINGPASS

//===----------------------------------------------------------------------===//
// GenericLoopConversionPass Registration
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_REGISTRATION_GENERICLOOPCONVERSIONPASS

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

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

#undef GEN_PASS_REGISTRATION_GENERICLOOPCONVERSIONPASS
#endif // GEN_PASS_REGISTRATION_GENERICLOOPCONVERSIONPASS

//===----------------------------------------------------------------------===//
// HostOpFilteringPass Registration
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_REGISTRATION_HOSTOPFILTERINGPASS

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

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

#undef GEN_PASS_REGISTRATION_HOSTOPFILTERINGPASS
#endif // GEN_PASS_REGISTRATION_HOSTOPFILTERINGPASS

//===----------------------------------------------------------------------===//
// LowerNontemporalPass Registration
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_REGISTRATION_LOWERNONTEMPORALPASS

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

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

#undef GEN_PASS_REGISTRATION_LOWERNONTEMPORALPASS
#endif // GEN_PASS_REGISTRATION_LOWERNONTEMPORALPASS

//===----------------------------------------------------------------------===//
// LowerWorkdistribute Registration
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_REGISTRATION_LOWERWORKDISTRIBUTE

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

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

#undef GEN_PASS_REGISTRATION_LOWERWORKDISTRIBUTE
#endif // GEN_PASS_REGISTRATION_LOWERWORKDISTRIBUTE

//===----------------------------------------------------------------------===//
// LowerWorkshare Registration
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_REGISTRATION_LOWERWORKSHARE

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

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

#undef GEN_PASS_REGISTRATION_LOWERWORKSHARE
#endif // GEN_PASS_REGISTRATION_LOWERWORKSHARE

//===----------------------------------------------------------------------===//
// MapInfoFinalizationPass Registration
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_REGISTRATION_MAPINFOFINALIZATIONPASS

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

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

#undef GEN_PASS_REGISTRATION_MAPINFOFINALIZATIONPASS
#endif // GEN_PASS_REGISTRATION_MAPINFOFINALIZATIONPASS

//===----------------------------------------------------------------------===//
// MapsForPrivatizedSymbolsPass Registration
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_REGISTRATION_MAPSFORPRIVATIZEDSYMBOLSPASS

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

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

#undef GEN_PASS_REGISTRATION_MAPSFORPRIVATIZEDSYMBOLSPASS
#endif // GEN_PASS_REGISTRATION_MAPSFORPRIVATIZEDSYMBOLSPASS

//===----------------------------------------------------------------------===//
// SimdOnlyPass Registration
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_REGISTRATION_SIMDONLYPASS

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

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

#undef GEN_PASS_REGISTRATION_SIMDONLYPASS
#endif // GEN_PASS_REGISTRATION_SIMDONLYPASS
#ifdef GEN_PASS_REGISTRATION

//===----------------------------------------------------------------------===//
// FlangOpenMP Registration
//===----------------------------------------------------------------------===//

inline void registerFlangOpenMPPasses() {
  registerAutomapToTargetDataPass();
  registerDeleteUnreachableTargetsPass();
  registerDoConcurrentConversionPass();
  registerFunctionFilteringPass();
  registerGenericLoopConversionPass();
  registerHostOpFilteringPass();
  registerLowerNontemporalPass();
  registerLowerWorkdistribute();
  registerLowerWorkshare();
  registerMapInfoFinalizationPass();
  registerMapsForPrivatizedSymbolsPass();
  registerSimdOnlyPass();
}
#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
