MPIOps.cpp.inc | Explore in Territory

/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
|*                                                                            *|
|* Op Definitions                                                             *|
|*                                                                            *|
|* Automatically generated file, do not edit!                                 *|
|* From: MPIOps.td                                                            *|
|*                                                                            *|
\*===----------------------------------------------------------------------===*/

#ifdef GET_OP_LIST
#undef GET_OP_LIST

::mlir::mpi::CommRankOp,
::mlir::mpi::ErrorClassOp,
::mlir::mpi::FinalizeOp,
::mlir::mpi::InitOp,
::mlir::mpi::RecvOp,
::mlir::mpi::RetvalCheckOp,
::mlir::mpi::SendOp
#endif  // GET_OP_LIST

#ifdef GET_OP_CLASSES
#undef GET_OP_CLASSES


//===----------------------------------------------------------------------===//
// Local Utility Method Definitions
//===----------------------------------------------------------------------===//

namespace mlir {
namespace mpi {

static ::llvm::LogicalResult __mlir_ods_local_type_constraint_MPIOps1(
    ::mlir::Operation *op, ::mlir::Type type, ::llvm::StringRef valueKind,
    unsigned valueIndex) { … }

static ::llvm::LogicalResult __mlir_ods_local_type_constraint_MPIOps2(
    ::mlir::Operation *op, ::mlir::Type type, ::llvm::StringRef valueKind,
    unsigned valueIndex) { … }

static ::llvm::LogicalResult __mlir_ods_local_type_constraint_MPIOps3(
    ::mlir::Operation *op, ::mlir::Type type, ::llvm::StringRef valueKind,
    unsigned valueIndex) { … }

static ::llvm::LogicalResult __mlir_ods_local_type_constraint_MPIOps4(
    ::mlir::Operation *op, ::mlir::Type type, ::llvm::StringRef valueKind,
    unsigned valueIndex) { … }

static ::llvm::LogicalResult __mlir_ods_local_attr_constraint_MPIOps1(
    ::mlir::Attribute attr, ::llvm::StringRef attrName, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) { … }
static ::llvm::LogicalResult __mlir_ods_local_attr_constraint_MPIOps1(
    ::mlir::Operation *op, ::mlir::Attribute attr, ::llvm::StringRef attrName) { … }
} // namespace mpi
} // namespace mlir
namespace mlir {
namespace mpi {

//===----------------------------------------------------------------------===//
// ::mlir::mpi::CommRankOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
} // namespace detail
CommRankOpAdaptor::CommRankOpAdaptor(CommRankOp op) : … { … }

::llvm::LogicalResult CommRankOpAdaptor::verify(::mlir::Location loc) { … }

void CommRankOp::getAsmResultNames(::mlir::OpAsmSetValueNameFn setNameFn) { … }

std::pair<unsigned, unsigned> CommRankOp::getODSResultIndexAndLength(unsigned index) { … }

void CommRankOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, /*optional*/::mlir::Type retval, ::mlir::Type rank) { … }

void CommRankOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes) { … }

void CommRankOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) { … }

::llvm::LogicalResult CommRankOp::verifyInvariantsImpl() { … }

::llvm::LogicalResult CommRankOp::verifyInvariants() { … }

::mlir::ParseResult CommRankOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) { … }

void CommRankOp::print(::mlir::OpAsmPrinter &_odsPrinter) { … }

} // namespace mpi
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::mpi::CommRankOp)

namespace mlir {
namespace mpi {

//===----------------------------------------------------------------------===//
// ::mlir::mpi::ErrorClassOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
} // namespace detail
ErrorClassOpAdaptor::ErrorClassOpAdaptor(ErrorClassOp op) : … { … }

::llvm::LogicalResult ErrorClassOpAdaptor::verify(::mlir::Location loc) { … }

void ErrorClassOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type errclass, ::mlir::Value val) { … }

void ErrorClassOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value val) { … }

void ErrorClassOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) { … }

::llvm::LogicalResult ErrorClassOp::verifyInvariantsImpl() { … }

::llvm::LogicalResult ErrorClassOp::verifyInvariants() { … }

::mlir::ParseResult ErrorClassOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) { … }

void ErrorClassOp::print(::mlir::OpAsmPrinter &_odsPrinter) { … }

} // namespace mpi
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::mpi::ErrorClassOp)

namespace mlir {
namespace mpi {

//===----------------------------------------------------------------------===//
// ::mlir::mpi::FinalizeOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
} // namespace detail
FinalizeOpAdaptor::FinalizeOpAdaptor(FinalizeOp op) : … { … }

::llvm::LogicalResult FinalizeOpAdaptor::verify(::mlir::Location loc) { … }

std::pair<unsigned, unsigned> FinalizeOp::getODSResultIndexAndLength(unsigned index) { … }

void FinalizeOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, /*optional*/::mlir::Type retval) { … }

void FinalizeOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes) { … }

void FinalizeOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) { … }

::llvm::LogicalResult FinalizeOp::verifyInvariantsImpl() { … }

::llvm::LogicalResult FinalizeOp::verifyInvariants() { … }

::mlir::ParseResult FinalizeOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) { … }

void FinalizeOp::print(::mlir::OpAsmPrinter &_odsPrinter) { … }

} // namespace mpi
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::mpi::FinalizeOp)

namespace mlir {
namespace mpi {

//===----------------------------------------------------------------------===//
// ::mlir::mpi::InitOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
} // namespace detail
InitOpAdaptor::InitOpAdaptor(InitOp op) : … { … }

::llvm::LogicalResult InitOpAdaptor::verify(::mlir::Location loc) { … }

std::pair<unsigned, unsigned> InitOp::getODSResultIndexAndLength(unsigned index) { … }

void InitOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, /*optional*/::mlir::Type retval) { … }

void InitOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes) { … }

void InitOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) { … }

::llvm::LogicalResult InitOp::verifyInvariantsImpl() { … }

::llvm::LogicalResult InitOp::verifyInvariants() { … }

::mlir::ParseResult InitOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) { … }

void InitOp::print(::mlir::OpAsmPrinter &_odsPrinter) { … }

} // namespace mpi
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::mpi::InitOp)

namespace mlir {
namespace mpi {

//===----------------------------------------------------------------------===//
// ::mlir::mpi::RecvOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
} // namespace detail
RecvOpAdaptor::RecvOpAdaptor(RecvOp op) : … { … }

::llvm::LogicalResult RecvOpAdaptor::verify(::mlir::Location loc) { … }

std::pair<unsigned, unsigned> RecvOp::getODSResultIndexAndLength(unsigned index) { … }

void RecvOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, /*optional*/::mlir::Type retval, ::mlir::Value ref, ::mlir::Value tag, ::mlir::Value rank) { … }

void RecvOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value ref, ::mlir::Value tag, ::mlir::Value rank) { … }

void RecvOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) { … }

::llvm::LogicalResult RecvOp::verifyInvariantsImpl() { … }

::llvm::LogicalResult RecvOp::verifyInvariants() { … }

::mlir::ParseResult RecvOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) { … }

void RecvOp::print(::mlir::OpAsmPrinter &_odsPrinter) { … }

} // namespace mpi
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::mpi::RecvOp)

namespace mlir {
namespace mpi {

//===----------------------------------------------------------------------===//
// ::mlir::mpi::RetvalCheckOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
RetvalCheckOpGenericAdaptorBase::RetvalCheckOpGenericAdaptorBase(RetvalCheckOp op) : … { … }

::mlir::mpi::MPI_ErrorClassEnum RetvalCheckOpGenericAdaptorBase::getErrclass() { … }

} // namespace detail
RetvalCheckOpAdaptor::RetvalCheckOpAdaptor(RetvalCheckOp op) : … { … }

::llvm::LogicalResult RetvalCheckOpAdaptor::verify(::mlir::Location loc) { … }

::llvm::LogicalResult RetvalCheckOp::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) { … }

::mlir::Attribute RetvalCheckOp::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) { … }

llvm::hash_code RetvalCheckOp::computePropertiesHash(const Properties &prop) { … }

std::optional<mlir::Attribute> RetvalCheckOp::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) { … }

void RetvalCheckOp::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) { … }

void RetvalCheckOp::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) { … }

::llvm::LogicalResult RetvalCheckOp::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) { … }

::llvm::LogicalResult RetvalCheckOp::readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state) { … }

void RetvalCheckOp::writeProperties(::mlir::DialectBytecodeWriter &writer) { … }

::mlir::mpi::MPI_ErrorClassEnum RetvalCheckOp::getErrclass() { … }

void RetvalCheckOp::setErrclass(::mlir::mpi::MPI_ErrorClassEnum attrValue) { … }

void RetvalCheckOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value val, ::mlir::mpi::MPI_ErrorClassEnumAttr errclass) { … }

void RetvalCheckOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value val, ::mlir::mpi::MPI_ErrorClassEnumAttr errclass) { … }

void RetvalCheckOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value val, ::mlir::mpi::MPI_ErrorClassEnum errclass) { … }

void RetvalCheckOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value val, ::mlir::mpi::MPI_ErrorClassEnum errclass) { … }

void RetvalCheckOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) { … }

::llvm::LogicalResult RetvalCheckOp::verifyInvariantsImpl() { … }

::llvm::LogicalResult RetvalCheckOp::verifyInvariants() { … }

::mlir::ParseResult RetvalCheckOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) { … }

void RetvalCheckOp::print(::mlir::OpAsmPrinter &_odsPrinter) { … }

} // namespace mpi
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::mpi::RetvalCheckOp)

namespace mlir {
namespace mpi {

//===----------------------------------------------------------------------===//
// ::mlir::mpi::SendOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
} // namespace detail
SendOpAdaptor::SendOpAdaptor(SendOp op) : … { … }

::llvm::LogicalResult SendOpAdaptor::verify(::mlir::Location loc) { … }

std::pair<unsigned, unsigned> SendOp::getODSResultIndexAndLength(unsigned index) { … }

void SendOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, /*optional*/::mlir::Type retval, ::mlir::Value ref, ::mlir::Value tag, ::mlir::Value rank) { … }

void SendOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value ref, ::mlir::Value tag, ::mlir::Value rank) { … }

void SendOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) { … }

::llvm::LogicalResult SendOp::verifyInvariantsImpl() { … }

::llvm::LogicalResult SendOp::verifyInvariants() { … }

::mlir::ParseResult SendOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) { … }

void SendOp::print(::mlir::OpAsmPrinter &_odsPrinter) { … }

} // namespace mpi
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::mpi::SendOp)


#endif  // GET_OP_CLASSES
llvm/tools/mlir/include/mlir/Dialect/MPI/IR/MPIOps.cpp.inc
