llvm/tools/mlir/test/lib/Interfaces/TilingInterface/TestTilingInterfaceTransformOps.cpp.inc

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

#ifdef GET_OP_LIST
#undef GET_OP_LIST

::mlir::transform::TestFuseAndYieldOp,
::mlir::transform::TestFuseConsumerOp,
::mlir::transform::TestFuseUsingForallOp,
::mlir::transform::TestTileUsingForallOp
#endif  // GET_OP_LIST

#ifdef GET_OP_CLASSES
#undef GET_OP_CLASSES


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

namespace mlir {
namespace transform {

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

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

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

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

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

//===----------------------------------------------------------------------===//
// ::mlir::transform::TestFuseAndYieldOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
TestFuseAndYieldOpGenericAdaptorBase::TestFuseAndYieldOpGenericAdaptorBase(TestFuseAndYieldOp op) : … { … }

::mlir::ArrayAttr TestFuseAndYieldOpGenericAdaptorBase::getTileSizesAttr() { … }

::mlir::ArrayAttr TestFuseAndYieldOpGenericAdaptorBase::getTileSizes() { … }

::mlir::ArrayAttr TestFuseAndYieldOpGenericAdaptorBase::getTileInterchangeAttr() { … }

::mlir::ArrayAttr TestFuseAndYieldOpGenericAdaptorBase::getTileInterchange() { … }

::mlir::BoolAttr TestFuseAndYieldOpGenericAdaptorBase::getUseForallAttr() { … }

bool TestFuseAndYieldOpGenericAdaptorBase::getUseForall() { … }

} // namespace detail
TestFuseAndYieldOpAdaptor::TestFuseAndYieldOpAdaptor(TestFuseAndYieldOp op) : … { … }

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

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

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

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

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

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

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

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

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

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

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

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

::mlir::ArrayAttr TestFuseAndYieldOp::getTileSizes() { … }

::mlir::ArrayAttr TestFuseAndYieldOp::getTileInterchange() { … }

bool TestFuseAndYieldOp::getUseForall() { … }

void TestFuseAndYieldOp::setUseForall(bool attrValue) { … }

void TestFuseAndYieldOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type transfomed, ::mlir::TypeRange loops, ::mlir::Value target, ::mlir::ArrayAttr tile_sizes, ::mlir::ArrayAttr tile_interchange, ::mlir::BoolAttr use_forall) { … }

void TestFuseAndYieldOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value target, ::mlir::ArrayAttr tile_sizes, ::mlir::ArrayAttr tile_interchange, ::mlir::BoolAttr use_forall) { … }

void TestFuseAndYieldOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type transfomed, ::mlir::TypeRange loops, ::mlir::Value target, ::mlir::ArrayAttr tile_sizes, ::mlir::ArrayAttr tile_interchange, bool use_forall) { … }

void TestFuseAndYieldOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value target, ::mlir::ArrayAttr tile_sizes, ::mlir::ArrayAttr tile_interchange, bool use_forall) { … }

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

void TestFuseAndYieldOp::populateDefaultProperties(::mlir::OperationName opName, Properties &properties) { … }

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

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

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

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

} // namespace transform
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::transform::TestFuseAndYieldOp)

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::TestFuseConsumerOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
} // namespace detail
TestFuseConsumerOpAdaptor::TestFuseConsumerOpAdaptor(TestFuseConsumerOp op) : … { … }

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

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

void TestFuseConsumerOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type consumer, ::mlir::Type fused_consumer, ::mlir::Value target) { … }

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

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

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

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

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

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

} // namespace transform
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::transform::TestFuseConsumerOp)

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::TestFuseUsingForallOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
TestFuseUsingForallOpGenericAdaptorBase::TestFuseUsingForallOpGenericAdaptorBase(TestFuseUsingForallOp op) : … { … }

::mlir::ArrayAttr TestFuseUsingForallOpGenericAdaptorBase::getTileSizesAttr() { … }

::mlir::ArrayAttr TestFuseUsingForallOpGenericAdaptorBase::getTileSizes() { … }

::mlir::ArrayAttr TestFuseUsingForallOpGenericAdaptorBase::getInterchangeAttr() { … }

::mlir::ArrayAttr TestFuseUsingForallOpGenericAdaptorBase::getInterchange() { … }

::std::optional< ::mlir::ArrayAttr > TestFuseUsingForallOpGenericAdaptorBase::getMapping() { … }

} // namespace detail
TestFuseUsingForallOpAdaptor::TestFuseUsingForallOpAdaptor(TestFuseUsingForallOp op) : … { … }

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

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

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

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

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

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

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

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

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

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

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

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

::mlir::ArrayAttr TestFuseUsingForallOp::getTileSizes() { … }

::mlir::ArrayAttr TestFuseUsingForallOp::getInterchange() { … }

::std::optional< ::mlir::ArrayAttr > TestFuseUsingForallOp::getMapping() { … }

void TestFuseUsingForallOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type tiled_ops, ::mlir::TypeRange loops, ::mlir::Value root_op, ::mlir::ArrayAttr tile_sizes, /*optional*/::mlir::ArrayAttr interchange, /*optional*/::mlir::ArrayAttr mapping) { … }

void TestFuseUsingForallOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value root_op, ::mlir::ArrayAttr tile_sizes, /*optional*/::mlir::ArrayAttr interchange, /*optional*/::mlir::ArrayAttr mapping) { … }

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

void TestFuseUsingForallOp::populateDefaultProperties(::mlir::OperationName opName, Properties &properties) { … }

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

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

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

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

} // namespace transform
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::transform::TestFuseUsingForallOp)

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::TestTileUsingForallOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
TestTileUsingForallOpGenericAdaptorBase::TestTileUsingForallOpGenericAdaptorBase(TestTileUsingForallOp op) : … { … }

::mlir::ArrayAttr TestTileUsingForallOpGenericAdaptorBase::getTileSizesAttr() { … }

::mlir::ArrayAttr TestTileUsingForallOpGenericAdaptorBase::getTileSizes() { … }

::mlir::ArrayAttr TestTileUsingForallOpGenericAdaptorBase::getInterchangeAttr() { … }

::mlir::ArrayAttr TestTileUsingForallOpGenericAdaptorBase::getInterchange() { … }

::std::optional< ::mlir::ArrayAttr > TestTileUsingForallOpGenericAdaptorBase::getMapping() { … }

} // namespace detail
TestTileUsingForallOpAdaptor::TestTileUsingForallOpAdaptor(TestTileUsingForallOp op) : … { … }

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

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

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

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

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

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

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

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

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

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

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

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

::mlir::ArrayAttr TestTileUsingForallOp::getTileSizes() { … }

::mlir::ArrayAttr TestTileUsingForallOp::getInterchange() { … }

::std::optional< ::mlir::ArrayAttr > TestTileUsingForallOp::getMapping() { … }

void TestTileUsingForallOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type tiled_op, ::mlir::TypeRange loops, ::mlir::Value target, ::mlir::ArrayAttr tile_sizes, /*optional*/::mlir::ArrayAttr interchange, /*optional*/::mlir::ArrayAttr mapping) { … }

void TestTileUsingForallOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value target, ::mlir::ArrayAttr tile_sizes, /*optional*/::mlir::ArrayAttr interchange, /*optional*/::mlir::ArrayAttr mapping) { … }

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

void TestTileUsingForallOp::populateDefaultProperties(::mlir::OperationName opName, Properties &properties) { … }

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

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

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

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

} // namespace transform
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::transform::TestTileUsingForallOp)


#endif  // GET_OP_CLASSES