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

#ifdef GEN_PASS_DECL
// Generate declarations for all passes.
#define GEN_PASS_DECL_CONVERTASSERTS
#define GEN_PASS_DECL_CONVERTCUSTOMCALLS
#define GEN_PASS_DECL_CONVERTRUNTIMETOLLVMPASS
#define GEN_PASS_DECL_EXPORTFUNCTIONS
#define GEN_PASS_DECL_ORDINALASSIGNMENT
#undef GEN_PASS_DECL
#endif // GEN_PASS_DECL

//===----------------------------------------------------------------------===//
// ConvertAsserts
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_CONVERTASSERTS
#undef GEN_PASS_DECL_CONVERTASSERTS
#endif // GEN_PASS_DECL_CONVERTASSERTS
#ifdef GEN_PASS_DEF_CONVERTASSERTS
namespace impl {

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

  ConvertAssertsBase() : ::mlir::OperationPass<ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
  ConvertAssertsBase(const ConvertAssertsBase &other) : ::mlir::OperationPass<ModuleOp>(other) {}

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

  ::llvm::StringRef getDescription() const override { return "Converts asserts in exported functions to run-time errors"; }

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

  /// 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<xla::runtime::RuntimeDialect>();

  }

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

protected:
private:
};
} // namespace impl
#undef GEN_PASS_DEF_CONVERTASSERTS
#endif // GEN_PASS_DEF_CONVERTASSERTS

//===----------------------------------------------------------------------===//
// ConvertCustomCalls
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_CONVERTCUSTOMCALLS
#undef GEN_PASS_DECL_CONVERTCUSTOMCALLS
#endif // GEN_PASS_DECL_CONVERTCUSTOMCALLS
#ifdef GEN_PASS_DEF_CONVERTCUSTOMCALLS
namespace impl {

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

  ConvertCustomCallsBase() : ::mlir::OperationPass<ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
  ConvertCustomCallsBase(const ConvertCustomCallsBase &other) : ::mlir::OperationPass<ModuleOp>(other) {}

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

  ::llvm::StringRef getDescription() const override { return "Converts custom calls to explicit `rt.custom_call` operations"; }

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

  /// 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<xla::runtime::RuntimeDialect>();

  }

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

protected:
private:
};
} // namespace impl
#undef GEN_PASS_DEF_CONVERTCUSTOMCALLS
#endif // GEN_PASS_DEF_CONVERTCUSTOMCALLS

//===----------------------------------------------------------------------===//
// ConvertRuntimeToLLVMPass
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_CONVERTRUNTIMETOLLVMPASS
#undef GEN_PASS_DECL_CONVERTRUNTIMETOLLVMPASS
#endif // GEN_PASS_DECL_CONVERTRUNTIMETOLLVMPASS
#ifdef GEN_PASS_DEF_CONVERTRUNTIMETOLLVMPASS
namespace impl {

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

  ConvertRuntimeToLLVMPassBase() : ::mlir::OperationPass<ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
  ConvertRuntimeToLLVMPassBase(const ConvertRuntimeToLLVMPassBase &other) : ::mlir::OperationPass<ModuleOp>(other) {}

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

  ::llvm::StringRef getDescription() const override { return "Convert RT dialect to LLVM dialect"; }

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

  /// 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::LLVM::LLVMDialect>();

  }

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

protected:
private:
};
} // namespace impl
#undef GEN_PASS_DEF_CONVERTRUNTIMETOLLVMPASS
#endif // GEN_PASS_DEF_CONVERTRUNTIMETOLLVMPASS

//===----------------------------------------------------------------------===//
// ExportFunctions
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_EXPORTFUNCTIONS
#undef GEN_PASS_DECL_EXPORTFUNCTIONS
#endif // GEN_PASS_DECL_EXPORTFUNCTIONS
#ifdef GEN_PASS_DEF_EXPORTFUNCTIONS
namespace impl {

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

  ExportFunctionsBase() : ::mlir::OperationPass<mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
  ExportFunctionsBase(const ExportFunctionsBase &other) : ::mlir::OperationPass<mlir::ModuleOp>(other) {}

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

  ::llvm::StringRef getDescription() const override { return "Exports function(s) to Xla runtime"; }

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

  /// 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<xla::runtime::RuntimeDialect>();

  }

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

protected:
private:
};
} // namespace impl
#undef GEN_PASS_DEF_EXPORTFUNCTIONS
#endif // GEN_PASS_DEF_EXPORTFUNCTIONS

//===----------------------------------------------------------------------===//
// OrdinalAssignment
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_ORDINALASSIGNMENT
#undef GEN_PASS_DECL_ORDINALASSIGNMENT
#endif // GEN_PASS_DECL_ORDINALASSIGNMENT
#ifdef GEN_PASS_DEF_ORDINALASSIGNMENT
namespace impl {

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

  OrdinalAssignmentBase() : ::mlir::OperationPass<mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
  OrdinalAssignmentBase(const OrdinalAssignmentBase &other) : ::mlir::OperationPass<mlir::ModuleOp>(other) {}

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

  ::llvm::StringRef getDescription() const override { return "Assigns ordinals to all exported functions"; }

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

  /// 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<xla::runtime::RuntimeDialect>();

  }

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

protected:
private:
};
} // namespace impl
#undef GEN_PASS_DEF_ORDINALASSIGNMENT
#endif // GEN_PASS_DEF_ORDINALASSIGNMENT
#ifdef GEN_PASS_REGISTRATION

//===----------------------------------------------------------------------===//
// ConvertAsserts Registration
//===----------------------------------------------------------------------===//

inline void registerConvertAsserts() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return xla::runtime::CreateConvertAssertsPass();
  });
}

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

//===----------------------------------------------------------------------===//
// ConvertCustomCalls Registration
//===----------------------------------------------------------------------===//

inline void registerConvertCustomCalls() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return xla::runtime::CreateConvertCustomCallsPass();
  });
}

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

//===----------------------------------------------------------------------===//
// ConvertRuntimeToLLVMPass Registration
//===----------------------------------------------------------------------===//

inline void registerConvertRuntimeToLLVMPass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return ::xla::runtime::CreateConvertRuntimeToLLVMPass();
  });
}

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

//===----------------------------------------------------------------------===//
// ExportFunctions Registration
//===----------------------------------------------------------------------===//

inline void registerExportFunctions() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return xla::runtime::CreateExportRuntimeFunctionsPass();
  });
}

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

//===----------------------------------------------------------------------===//
// OrdinalAssignment Registration
//===----------------------------------------------------------------------===//

inline void registerOrdinalAssignment() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return xla::runtime::CreateOrdinalAssignmentPass();
  });
}

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

//===----------------------------------------------------------------------===//
// RuntimeTransforms Registration
//===----------------------------------------------------------------------===//

inline void registerRuntimeTransformsPasses() {
  registerConvertAsserts();
  registerConvertCustomCalls();
  registerConvertRuntimeToLLVMPass();
  registerExportFunctions();
  registerOrdinalAssignment();
}
#undef GEN_PASS_REGISTRATION
#endif // GEN_PASS_REGISTRATION
// Deprecated. Please use the new per-pass macros.
#ifdef GEN_PASS_CLASSES

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

  ConvertAssertsBase() : ::mlir::OperationPass<ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
  ConvertAssertsBase(const ConvertAssertsBase &other) : ::mlir::OperationPass<ModuleOp>(other) {}

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

  ::llvm::StringRef getDescription() const override { return "Converts asserts in exported functions to run-time errors"; }

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

  /// 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<xla::runtime::RuntimeDialect>();

  }

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

protected:
};

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

  ConvertCustomCallsBase() : ::mlir::OperationPass<ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
  ConvertCustomCallsBase(const ConvertCustomCallsBase &other) : ::mlir::OperationPass<ModuleOp>(other) {}

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

  ::llvm::StringRef getDescription() const override { return "Converts custom calls to explicit `rt.custom_call` operations"; }

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

  /// 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<xla::runtime::RuntimeDialect>();

  }

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

protected:
};

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

  ConvertRuntimeToLLVMPassBase() : ::mlir::OperationPass<ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
  ConvertRuntimeToLLVMPassBase(const ConvertRuntimeToLLVMPassBase &other) : ::mlir::OperationPass<ModuleOp>(other) {}

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

  ::llvm::StringRef getDescription() const override { return "Convert RT dialect to LLVM dialect"; }

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

  /// 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::LLVM::LLVMDialect>();

  }

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

protected:
};

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

  ExportFunctionsBase() : ::mlir::OperationPass<mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
  ExportFunctionsBase(const ExportFunctionsBase &other) : ::mlir::OperationPass<mlir::ModuleOp>(other) {}

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

  ::llvm::StringRef getDescription() const override { return "Exports function(s) to Xla runtime"; }

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

  /// 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<xla::runtime::RuntimeDialect>();

  }

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

protected:
};

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

  OrdinalAssignmentBase() : ::mlir::OperationPass<mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
  OrdinalAssignmentBase(const OrdinalAssignmentBase &other) : ::mlir::OperationPass<mlir::ModuleOp>(other) {}

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

  ::llvm::StringRef getDescription() const override { return "Assigns ordinals to all exported functions"; }

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

  /// 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<xla::runtime::RuntimeDialect>();

  }

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

protected:
};
#undef GEN_PASS_CLASSES
#endif // GEN_PASS_CLASSES
