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

#ifdef GEN_PASS_DECL
// Generate declarations for all passes.
#define GEN_PASS_DECL_LLVMTARGETTODATALAYOUT
#define GEN_PASS_DECL_LLVMTARGETTOTARGETFEATURES
#undef GEN_PASS_DECL
#endif // GEN_PASS_DECL

//===----------------------------------------------------------------------===//
// LLVMTargetToDataLayout
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_LLVMTARGETTODATALAYOUT
struct LLVMTargetToDataLayoutOptions {
  bool initializeLLVMTargets = true;
};
std::unique_ptr<::mlir::Pass> createLLVMTargetToDataLayout();
std::unique_ptr<::mlir::Pass> createLLVMTargetToDataLayout(LLVMTargetToDataLayoutOptions options);
#undef GEN_PASS_DECL_LLVMTARGETTODATALAYOUT
#endif // GEN_PASS_DECL_LLVMTARGETTODATALAYOUT
#ifdef GEN_PASS_DEF_LLVMTARGETTODATALAYOUT

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

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

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

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

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

  ::llvm::StringRef getDescription() const override { return R"PD(Derive data layout attributes from LLVM target attributes)PD"; }

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

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

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

  LLVMTargetToDataLayoutBase(LLVMTargetToDataLayoutOptions options) : LLVMTargetToDataLayoutBase() {
    initializeLLVMTargets = std::move(options.initializeLLVMTargets);
  }
protected:
  ::mlir::Pass::Option<bool> initializeLLVMTargets{*this, "initialize-llvm-targets", ::llvm::cl::desc(R"PO(Whether to pre-load all available target machines, that LLVM is configured to support, into the TargetRegistry.)PO"), ::llvm::cl::init(true)};
private:

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

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

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

std::unique_ptr<::mlir::Pass> createLLVMTargetToDataLayout(LLVMTargetToDataLayoutOptions options) {
  return impl::createLLVMTargetToDataLayout(std::move(options));
}
#undef GEN_PASS_DEF_LLVMTARGETTODATALAYOUT
#endif // GEN_PASS_DEF_LLVMTARGETTODATALAYOUT

//===----------------------------------------------------------------------===//
// LLVMTargetToTargetFeatures
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_LLVMTARGETTOTARGETFEATURES
struct LLVMTargetToTargetFeaturesOptions {
  bool initializeLLVMTargets = true;
};
std::unique_ptr<::mlir::Pass> createLLVMTargetToTargetFeatures();
std::unique_ptr<::mlir::Pass> createLLVMTargetToTargetFeatures(LLVMTargetToTargetFeaturesOptions options);
#undef GEN_PASS_DECL_LLVMTARGETTOTARGETFEATURES
#endif // GEN_PASS_DECL_LLVMTARGETTOTARGETFEATURES
#ifdef GEN_PASS_DEF_LLVMTARGETTOTARGETFEATURES

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

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

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

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

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

  ::llvm::StringRef getDescription() const override { return R"PD(Update attached #llvm.target's features per the described target)PD"; }

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

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

  LLVMTargetToTargetFeaturesBase(LLVMTargetToTargetFeaturesOptions options) : LLVMTargetToTargetFeaturesBase() {
    initializeLLVMTargets = std::move(options.initializeLLVMTargets);
  }
protected:
  ::mlir::Pass::Option<bool> initializeLLVMTargets{*this, "initialize-llvm-targets", ::llvm::cl::desc(R"PO(Whether to pre-load all available target machines, that LLVM is configured to support, into the TargetRegistry.)PO"), ::llvm::cl::init(true)};
private:

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

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

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

std::unique_ptr<::mlir::Pass> createLLVMTargetToTargetFeatures(LLVMTargetToTargetFeaturesOptions options) {
  return impl::createLLVMTargetToTargetFeatures(std::move(options));
}
#undef GEN_PASS_DEF_LLVMTARGETTOTARGETFEATURES
#endif // GEN_PASS_DEF_LLVMTARGETTOTARGETFEATURES
#ifdef GEN_PASS_REGISTRATION
// Generate registrations for all passes.
#define GEN_PASS_REGISTRATION_LLVMTARGETTODATALAYOUT
#define GEN_PASS_REGISTRATION_LLVMTARGETTOTARGETFEATURES
#endif // GEN_PASS_REGISTRATION

//===----------------------------------------------------------------------===//
// LLVMTargetToDataLayout Registration
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_REGISTRATION_LLVMTARGETTODATALAYOUT

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

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

#undef GEN_PASS_REGISTRATION_LLVMTARGETTODATALAYOUT
#endif // GEN_PASS_REGISTRATION_LLVMTARGETTODATALAYOUT

//===----------------------------------------------------------------------===//
// LLVMTargetToTargetFeatures Registration
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_REGISTRATION_LLVMTARGETTOTARGETFEATURES

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

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

#undef GEN_PASS_REGISTRATION_LLVMTARGETTOTARGETFEATURES
#endif // GEN_PASS_REGISTRATION_LLVMTARGETTOTARGETFEATURES
#ifdef GEN_PASS_REGISTRATION

//===----------------------------------------------------------------------===//
// TargetLLVMIRTransforms Registration
//===----------------------------------------------------------------------===//

inline void registerTargetLLVMIRTransformsPasses() {
  registerLLVMTargetToDataLayout();
  registerLLVMTargetToTargetFeatures();
}
#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
