llvm/tools/mlir/include/mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp.inc

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

#ifdef GET_OP_LIST
#undef GET_OP_LIST

::mlir::transform::ApplyEraseUnnecessaryInputsPatternsOp,
::mlir::transform::ApplyFoldUnitExtentDimsViaReshapesPatternsOp,
::mlir::transform::ApplyFoldUnitExtentDimsViaSlicesPatternsOp,
::mlir::transform::ApplyTilingCanonicalizationPatternsOp,
::mlir::transform::BufferizeToAllocationOp,
::mlir::transform::ContinuousTileSizesOp,
::mlir::transform::ConvertConv2DToImg2ColOp,
::mlir::transform::ConvertToLoopsOp,
::mlir::transform::DecomposeInterfaceOp,
::mlir::transform::DecomposeOp,
::mlir::transform::DecomposeWinogradOp,
::mlir::transform::EliminateLinalgOpAnchoredEmptyTensorsOp,
::mlir::transform::FlattenElementwiseLinalgOp,
::mlir::transform::FuseIntoContainingOp,
::mlir::transform::FuseOp,
::mlir::transform::GeneralizeOp,
::mlir::transform::HoistPadBuildPackingLoopNestOp,
::mlir::transform::HoistPadOp,
::mlir::transform::HoistRedundantVectorBroadcastsOp,
::mlir::transform::HoistRedundantVectorTransfersOp,
::mlir::transform::InsertSliceToCopyOp,
::mlir::transform::InterchangeOp,
::mlir::transform::LowerPackOp,
::mlir::transform::LowerUnPackOp,
::mlir::transform::MapCopyToThreadsOp,
::mlir::transform::MatchOp,
::mlir::transform::MultiTileSizesOp,
::mlir::transform::PackGreedilyOp,
::mlir::transform::PackOp,
::mlir::transform::PackTransposeOp,
::mlir::transform::PadOp,
::mlir::transform::PromoteOp,
::mlir::transform::ReplaceOp,
::mlir::transform::RewriteInDestinationPassingStyleOp,
::mlir::transform::ScalarizeOp,
::mlir::transform::SpecializeOp,
::mlir::transform::SplitOp,
::mlir::transform::SplitReductionOp,
::mlir::transform::TileReductionUsingForOp,
::mlir::transform::TileReductionUsingForallOp,
::mlir::transform::TileUsingForOp,
::mlir::transform::TileUsingForallOp,
::mlir::transform::TransposeConv2DOp,
::mlir::transform::TransposeMatmulOp,
::mlir::transform::VectorizeChildrenAndApplyPatternsOp,
::mlir::transform::VectorizeOp,
::mlir::transform::WinogradConv2DOp
#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_LinalgTransformOps1(
    ::mlir::Operation *op, ::mlir::Type type, ::llvm::StringRef valueKind,
    unsigned valueIndex) { … }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

static ::llvm::LogicalResult __mlir_ods_local_region_constraint_LinalgTransformOps1(
    ::mlir::Operation *op, ::mlir::Region &region, ::llvm::StringRef regionName,
    unsigned regionIndex) { … }
} // namespace transform
} // namespace mlir
namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::ApplyEraseUnnecessaryInputsPatternsOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
} // namespace detail
ApplyEraseUnnecessaryInputsPatternsOpAdaptor::ApplyEraseUnnecessaryInputsPatternsOpAdaptor(ApplyEraseUnnecessaryInputsPatternsOp op) : … { … }

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

void ApplyEraseUnnecessaryInputsPatternsOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState) { … }

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

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

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

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

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

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

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

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::ApplyFoldUnitExtentDimsViaReshapesPatternsOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
} // namespace detail
ApplyFoldUnitExtentDimsViaReshapesPatternsOpAdaptor::ApplyFoldUnitExtentDimsViaReshapesPatternsOpAdaptor(ApplyFoldUnitExtentDimsViaReshapesPatternsOp op) : … { … }

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

void ApplyFoldUnitExtentDimsViaReshapesPatternsOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState) { … }

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

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

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

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

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

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

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

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::ApplyFoldUnitExtentDimsViaSlicesPatternsOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
} // namespace detail
ApplyFoldUnitExtentDimsViaSlicesPatternsOpAdaptor::ApplyFoldUnitExtentDimsViaSlicesPatternsOpAdaptor(ApplyFoldUnitExtentDimsViaSlicesPatternsOp op) : … { … }

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

void ApplyFoldUnitExtentDimsViaSlicesPatternsOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState) { … }

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

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

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

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

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

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

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

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::ApplyTilingCanonicalizationPatternsOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
} // namespace detail
ApplyTilingCanonicalizationPatternsOpAdaptor::ApplyTilingCanonicalizationPatternsOpAdaptor(ApplyTilingCanonicalizationPatternsOp op) : … { … }

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

void ApplyTilingCanonicalizationPatternsOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState) { … }

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

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

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

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

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

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

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

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::BufferizeToAllocationOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
BufferizeToAllocationOpGenericAdaptorBase::BufferizeToAllocationOpGenericAdaptorBase(BufferizeToAllocationOp op) : … { … }

::std::optional<::mlir::Attribute> BufferizeToAllocationOpGenericAdaptorBase::getMemorySpace() { … }

::mlir::StringAttr BufferizeToAllocationOpGenericAdaptorBase::getMemcpyOpAttr() { … }

::llvm::StringRef BufferizeToAllocationOpGenericAdaptorBase::getMemcpyOp() { … }

::mlir::StringAttr BufferizeToAllocationOpGenericAdaptorBase::getAllocOpAttr() { … }

::llvm::StringRef BufferizeToAllocationOpGenericAdaptorBase::getAllocOp() { … }

::mlir::UnitAttr BufferizeToAllocationOpGenericAdaptorBase::getBufferizeDestinationOnlyAttr() { … }

bool BufferizeToAllocationOpGenericAdaptorBase::getBufferizeDestinationOnly() { … }

::mlir::UnitAttr BufferizeToAllocationOpGenericAdaptorBase::getEmitDeallocAttr() { … }

bool BufferizeToAllocationOpGenericAdaptorBase::getEmitDealloc() { … }

} // namespace detail
BufferizeToAllocationOpAdaptor::BufferizeToAllocationOpAdaptor(BufferizeToAllocationOp op) : … { … }

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

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

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

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

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

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

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

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

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

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

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

::std::optional<::mlir::Attribute> BufferizeToAllocationOp::getMemorySpace() { … }

::llvm::StringRef BufferizeToAllocationOp::getMemcpyOp() { … }

::llvm::StringRef BufferizeToAllocationOp::getAllocOp() { … }

bool BufferizeToAllocationOp::getBufferizeDestinationOnly() { … }

bool BufferizeToAllocationOp::getEmitDealloc() { … }

void BufferizeToAllocationOp::setMemcpyOp(::llvm::StringRef attrValue) { … }

void BufferizeToAllocationOp::setAllocOp(::llvm::StringRef attrValue) { … }

void BufferizeToAllocationOp::setBufferizeDestinationOnly(bool attrValue) { … }

void BufferizeToAllocationOp::setEmitDealloc(bool attrValue) { … }

void BufferizeToAllocationOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type allocated_buffer, ::mlir::Type new_ops, ::mlir::Value target, /*optional*/::mlir::Attribute memory_space, ::mlir::StringAttr memcpy_op, ::mlir::StringAttr alloc_op, /*optional*/::mlir::UnitAttr bufferize_destination_only, /*optional*/::mlir::UnitAttr emit_dealloc) { … }

void BufferizeToAllocationOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value target, /*optional*/::mlir::Attribute memory_space, ::mlir::StringAttr memcpy_op, ::mlir::StringAttr alloc_op, /*optional*/::mlir::UnitAttr bufferize_destination_only, /*optional*/::mlir::UnitAttr emit_dealloc) { … }

void BufferizeToAllocationOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type allocated_buffer, ::mlir::Type new_ops, ::mlir::Value target, /*optional*/::mlir::Attribute memory_space, ::llvm::StringRef memcpy_op, ::llvm::StringRef alloc_op, /*optional*/bool bufferize_destination_only, /*optional*/bool emit_dealloc) { … }

void BufferizeToAllocationOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value target, /*optional*/::mlir::Attribute memory_space, ::llvm::StringRef memcpy_op, ::llvm::StringRef alloc_op, /*optional*/bool bufferize_destination_only, /*optional*/bool emit_dealloc) { … }

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

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

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

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

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

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

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

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::ContinuousTileSizesOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
ContinuousTileSizesOpGenericAdaptorBase::ContinuousTileSizesOpGenericAdaptorBase(ContinuousTileSizesOp op) : … { … }

uint64_t ContinuousTileSizesOpGenericAdaptorBase::getDimension() { … }

uint64_t ContinuousTileSizesOpGenericAdaptorBase::getTargetSize() { … }

} // namespace detail
ContinuousTileSizesOpAdaptor::ContinuousTileSizesOpAdaptor(ContinuousTileSizesOp op) : … { … }

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

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

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

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

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

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

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

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

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

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

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

uint64_t ContinuousTileSizesOp::getDimension() { … }

uint64_t ContinuousTileSizesOp::getTargetSize() { … }

void ContinuousTileSizesOp::setDimension(uint64_t attrValue) { … }

void ContinuousTileSizesOp::setTargetSize(uint64_t attrValue) { … }

void ContinuousTileSizesOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type tile_sizes, ::mlir::Type chunk_sizes, ::mlir::Value target, ::mlir::IntegerAttr dimension, ::mlir::IntegerAttr target_size) { … }

void ContinuousTileSizesOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value target, ::mlir::IntegerAttr dimension, ::mlir::IntegerAttr target_size) { … }

void ContinuousTileSizesOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type tile_sizes, ::mlir::Type chunk_sizes, ::mlir::Value target, uint64_t dimension, uint64_t target_size) { … }

void ContinuousTileSizesOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value target, uint64_t dimension, uint64_t target_size) { … }

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

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

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

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

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

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

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::ConvertConv2DToImg2ColOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
} // namespace detail
ConvertConv2DToImg2ColOpAdaptor::ConvertConv2DToImg2ColOpAdaptor(ConvertConv2DToImg2ColOp op) : … { … }

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

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

void ConvertConv2DToImg2ColOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type img2col_tensor, ::mlir::Type transformed, ::mlir::Value target) { … }

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

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

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

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

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

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

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

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::ConvertToLoopsOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
} // namespace detail
ConvertToLoopsOpAdaptor::ConvertToLoopsOpAdaptor(ConvertToLoopsOp op) : … { … }

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

void ConvertToLoopsOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value target) { … }

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

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

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

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

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

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

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

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::DecomposeInterfaceOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
} // namespace detail
DecomposeInterfaceOpAdaptor::DecomposeInterfaceOpAdaptor(DecomposeInterfaceOp op) : … { … }

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

void DecomposeInterfaceOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type transformed, ::mlir::Value target) { … }

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

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

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

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

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

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

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

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::DecomposeOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
} // namespace detail
DecomposeOpAdaptor::DecomposeOpAdaptor(DecomposeOp op) : … { … }

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

void DecomposeOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type transformed, ::mlir::Value target) { … }

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

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

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

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

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

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

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

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::DecomposeWinogradOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
} // namespace detail
DecomposeWinogradOpAdaptor::DecomposeWinogradOpAdaptor(DecomposeWinogradOp op) : … { … }

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

void DecomposeWinogradOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type transformed, ::mlir::Value target) { … }

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

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

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

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

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

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

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

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::EliminateLinalgOpAnchoredEmptyTensorsOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
} // namespace detail
EliminateLinalgOpAnchoredEmptyTensorsOpAdaptor::EliminateLinalgOpAnchoredEmptyTensorsOpAdaptor(EliminateLinalgOpAnchoredEmptyTensorsOp op) : … { … }

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

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

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

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

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

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

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

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

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

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::FlattenElementwiseLinalgOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
} // namespace detail
FlattenElementwiseLinalgOpAdaptor::FlattenElementwiseLinalgOpAdaptor(FlattenElementwiseLinalgOp op) : … { … }

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

void FlattenElementwiseLinalgOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type transformed, ::mlir::Value target) { … }

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

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

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

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

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

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

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

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::FuseIntoContainingOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
} // namespace detail
FuseIntoContainingOpAdaptor::FuseIntoContainingOpAdaptor(FuseIntoContainingOp op) : … { … }

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

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

void FuseIntoContainingOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type fused_op, ::mlir::Type new_containing_op, ::mlir::Value producer_op, ::mlir::Value containing_op) { … }

void FuseIntoContainingOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value producer_op, ::mlir::Value containing_op) { … }

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

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

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

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

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

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

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::FuseOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
FuseOpGenericAdaptorBase::FuseOpGenericAdaptorBase(FuseOp op) : … { … }

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

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

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

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

} // namespace detail
FuseOpAdaptor::FuseOpAdaptor(FuseOp op) : … { … }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void FuseOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type transformed, ::mlir::TypeRange loops, ::mlir::Value target, ::mlir::ArrayAttr tile_sizes, ::mlir::ArrayAttr tile_interchange) { … }

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

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

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

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

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

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

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

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

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::GeneralizeOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
} // namespace detail
GeneralizeOpAdaptor::GeneralizeOpAdaptor(GeneralizeOp op) : … { … }

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

void GeneralizeOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type transformed, ::mlir::Value target) { … }

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

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

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

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

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

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

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

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::HoistPadBuildPackingLoopNestOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
HoistPadBuildPackingLoopNestOpGenericAdaptorBase::HoistPadBuildPackingLoopNestOpGenericAdaptorBase(HoistPadBuildPackingLoopNestOp op) : … { … }

::mlir::DenseI64ArrayAttr HoistPadBuildPackingLoopNestOpGenericAdaptorBase::getTransposeAttr() { … }

::llvm::ArrayRef<int64_t> HoistPadBuildPackingLoopNestOpGenericAdaptorBase::getTranspose() { … }

} // namespace detail
HoistPadBuildPackingLoopNestOpAdaptor::HoistPadBuildPackingLoopNestOpAdaptor(HoistPadBuildPackingLoopNestOp op) : … { … }

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

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

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

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

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

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

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

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

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

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

::llvm::ArrayRef<int64_t> HoistPadBuildPackingLoopNestOp::getTranspose() { … }

void HoistPadBuildPackingLoopNestOp::setTranspose(::llvm::ArrayRef<int64_t> attrValue) { … }

void HoistPadBuildPackingLoopNestOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type packing_loop, ::mlir::Value target, ::mlir::Value loop, ::mlir::DenseI64ArrayAttr transpose) { … }

void HoistPadBuildPackingLoopNestOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value target, ::mlir::Value loop, ::mlir::DenseI64ArrayAttr transpose) { … }

void HoistPadBuildPackingLoopNestOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type packing_loop, ::mlir::Value target, ::mlir::Value loop, ::llvm::ArrayRef<int64_t> transpose) { … }

void HoistPadBuildPackingLoopNestOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value target, ::mlir::Value loop, ::llvm::ArrayRef<int64_t> transpose) { … }

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

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

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

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

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

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

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

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::HoistPadOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
HoistPadOpGenericAdaptorBase::HoistPadOpGenericAdaptorBase(HoistPadOp op) : … { … }

uint64_t HoistPadOpGenericAdaptorBase::getNumLoops() { … }

::mlir::DenseI64ArrayAttr HoistPadOpGenericAdaptorBase::getTransposeAttr() { … }

::llvm::ArrayRef<int64_t> HoistPadOpGenericAdaptorBase::getTranspose() { … }

} // namespace detail
HoistPadOpAdaptor::HoistPadOpAdaptor(HoistPadOp op) : … { … }

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

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

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

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

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

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

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

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

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

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

uint64_t HoistPadOp::getNumLoops() { … }

::llvm::ArrayRef<int64_t> HoistPadOp::getTranspose() { … }

void HoistPadOp::setNumLoops(uint64_t attrValue) { … }

void HoistPadOp::setTranspose(::llvm::ArrayRef<int64_t> attrValue) { … }

void HoistPadOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type transformed, ::mlir::Value target, ::mlir::IntegerAttr num_loops, ::mlir::DenseI64ArrayAttr transpose) { … }

void HoistPadOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value target, ::mlir::IntegerAttr num_loops, ::mlir::DenseI64ArrayAttr transpose) { … }

void HoistPadOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type transformed, ::mlir::Value target, uint64_t num_loops, ::llvm::ArrayRef<int64_t> transpose) { … }

void HoistPadOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value target, uint64_t num_loops, ::llvm::ArrayRef<int64_t> transpose) { … }

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

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

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

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

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

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

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

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::HoistRedundantVectorBroadcastsOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
} // namespace detail
HoistRedundantVectorBroadcastsOpAdaptor::HoistRedundantVectorBroadcastsOpAdaptor(HoistRedundantVectorBroadcastsOp op) : … { … }

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

void HoistRedundantVectorBroadcastsOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type transformed, ::mlir::Value target) { … }

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

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

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

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

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

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

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

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::HoistRedundantVectorTransfersOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
} // namespace detail
HoistRedundantVectorTransfersOpAdaptor::HoistRedundantVectorTransfersOpAdaptor(HoistRedundantVectorTransfersOp op) : … { … }

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

void HoistRedundantVectorTransfersOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type transformed, ::mlir::Value target) { … }

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

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

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

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

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

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

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

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::InsertSliceToCopyOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
} // namespace detail
InsertSliceToCopyOpAdaptor::InsertSliceToCopyOpAdaptor(InsertSliceToCopyOp op) : … { … }

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

void InsertSliceToCopyOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type transformed, ::mlir::Value target) { … }

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

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

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

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

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

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

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

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::InterchangeOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
InterchangeOpGenericAdaptorBase::InterchangeOpGenericAdaptorBase(InterchangeOp op) : … { … }

::mlir::DenseI64ArrayAttr InterchangeOpGenericAdaptorBase::getIteratorInterchangeAttr() { … }

::llvm::ArrayRef<int64_t> InterchangeOpGenericAdaptorBase::getIteratorInterchange() { … }

} // namespace detail
InterchangeOpAdaptor::InterchangeOpAdaptor(InterchangeOp op) : … { … }

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

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

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

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

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

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

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

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

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

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

::llvm::ArrayRef<int64_t> InterchangeOp::getIteratorInterchange() { … }

void InterchangeOp::setIteratorInterchange(::std::optional<::llvm::ArrayRef<int64_t>> attrValue) { … }

void InterchangeOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type transformed, ::mlir::Value target, /*optional*/::mlir::DenseI64ArrayAttr iterator_interchange) { … }

void InterchangeOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value target, /*optional*/::mlir::DenseI64ArrayAttr iterator_interchange) { … }

void InterchangeOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type transformed, ::mlir::Value target, /*optional*/::llvm::ArrayRef<int64_t> iterator_interchange) { … }

void InterchangeOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value target, /*optional*/::llvm::ArrayRef<int64_t> iterator_interchange) { … }

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

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

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

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

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

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

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::LowerPackOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
} // namespace detail
LowerPackOpAdaptor::LowerPackOpAdaptor(LowerPackOp op) : … { … }

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

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

void LowerPackOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type pad_op, ::mlir::Type expand_shape_op, ::mlir::Type transpose_op, ::mlir::Value target) { … }

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

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

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

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

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

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

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

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::LowerUnPackOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
} // namespace detail
LowerUnPackOpAdaptor::LowerUnPackOpAdaptor(LowerUnPackOp op) : … { … }

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

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

void LowerUnPackOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type empty_op, ::mlir::Type transpose_op, ::mlir::Type collapse_shape_op, ::mlir::Type extract_slice_op, ::mlir::Value target) { … }

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

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

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

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

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

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

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

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::MapCopyToThreadsOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
MapCopyToThreadsOpGenericAdaptorBase::MapCopyToThreadsOpGenericAdaptorBase(MapCopyToThreadsOp op) : … { … }

uint64_t MapCopyToThreadsOpGenericAdaptorBase::getTotalNumThreads() { … }

uint64_t MapCopyToThreadsOpGenericAdaptorBase::getDesiredBitAlignment() { … }

} // namespace detail
MapCopyToThreadsOpAdaptor::MapCopyToThreadsOpAdaptor(MapCopyToThreadsOp op) : … { … }

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

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

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

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

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

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

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

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

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

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

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

uint64_t MapCopyToThreadsOp::getTotalNumThreads() { … }

uint64_t MapCopyToThreadsOp::getDesiredBitAlignment() { … }

void MapCopyToThreadsOp::setTotalNumThreads(uint64_t attrValue) { … }

void MapCopyToThreadsOp::setDesiredBitAlignment(uint64_t attrValue) { … }

void MapCopyToThreadsOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type forall_op, ::mlir::Type tiled_op, ::mlir::Value target, ::mlir::IntegerAttr total_num_threads, ::mlir::IntegerAttr desired_bit_alignment) { … }

void MapCopyToThreadsOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value target, ::mlir::IntegerAttr total_num_threads, ::mlir::IntegerAttr desired_bit_alignment) { … }

void MapCopyToThreadsOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type forall_op, ::mlir::Type tiled_op, ::mlir::Value target, uint64_t total_num_threads, uint64_t desired_bit_alignment) { … }

void MapCopyToThreadsOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value target, uint64_t total_num_threads, uint64_t desired_bit_alignment) { … }

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

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

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

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

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

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

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::MatchOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
MatchOpGenericAdaptorBase::MatchOpGenericAdaptorBase(MatchOp op) : … { … }

::std::optional< ::mlir::ArrayAttr > MatchOpGenericAdaptorBase::getOps() { … }

::std::optional<mlir::transform::MatchInterfaceEnum> MatchOpGenericAdaptorBase::getInterface() { … }

::std::optional< ::mlir::DictionaryAttr > MatchOpGenericAdaptorBase::getOpAttrs() { … }

::std::optional<::mlir::Type> MatchOpGenericAdaptorBase::getFilterResultType() { … }

::std::optional< ::mlir::ArrayAttr > MatchOpGenericAdaptorBase::getFilterOperandTypes() { … }

} // namespace detail
MatchOpAdaptor::MatchOpAdaptor(MatchOp op) : … { … }

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

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

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

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

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

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

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

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

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

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

::std::optional< ::mlir::ArrayAttr > MatchOp::getOps() { … }

::std::optional<mlir::transform::MatchInterfaceEnum> MatchOp::getInterface() { … }

::std::optional< ::mlir::DictionaryAttr > MatchOp::getOpAttrs() { … }

::std::optional<::mlir::Type> MatchOp::getFilterResultType() { … }

::std::optional< ::mlir::ArrayAttr > MatchOp::getFilterOperandTypes() { … }

void MatchOp::setInterface(::std::optional<mlir::transform::MatchInterfaceEnum> attrValue) { … }

void MatchOp::setFilterResultType(::std::optional<::mlir::Type> attrValue) { … }

void MatchOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type results, ::mlir::Value target, /*optional*/::mlir::ArrayAttr ops, /*optional*/mlir::transform::MatchInterfaceEnumAttr interface, /*optional*/::mlir::DictionaryAttr op_attrs, /*optional*/::mlir::TypeAttr filter_result_type, /*optional*/::mlir::ArrayAttr filter_operand_types) { … }

void MatchOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value target, /*optional*/::mlir::ArrayAttr ops, /*optional*/mlir::transform::MatchInterfaceEnumAttr interface, /*optional*/::mlir::DictionaryAttr op_attrs, /*optional*/::mlir::TypeAttr filter_result_type, /*optional*/::mlir::ArrayAttr filter_operand_types) { … }

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

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

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

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

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

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

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::MultiTileSizesOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
MultiTileSizesOpGenericAdaptorBase::MultiTileSizesOpGenericAdaptorBase(MultiTileSizesOp op) : … { … }

uint64_t MultiTileSizesOpGenericAdaptorBase::getDimension() { … }

uint64_t MultiTileSizesOpGenericAdaptorBase::getTargetSize() { … }

::mlir::IntegerAttr MultiTileSizesOpGenericAdaptorBase::getDivisorAttr() { … }

uint64_t MultiTileSizesOpGenericAdaptorBase::getDivisor() { … }

} // namespace detail
MultiTileSizesOpAdaptor::MultiTileSizesOpAdaptor(MultiTileSizesOp op) : … { … }

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

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

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

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

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

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

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

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

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

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

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

uint64_t MultiTileSizesOp::getDimension() { … }

uint64_t MultiTileSizesOp::getTargetSize() { … }

uint64_t MultiTileSizesOp::getDivisor() { … }

void MultiTileSizesOp::setDimension(uint64_t attrValue) { … }

void MultiTileSizesOp::setTargetSize(uint64_t attrValue) { … }

void MultiTileSizesOp::setDivisor(uint64_t attrValue) { … }

void MultiTileSizesOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type low_size, ::mlir::Type high_size, ::mlir::Type split_point, ::mlir::Value target, ::mlir::IntegerAttr dimension, ::mlir::IntegerAttr target_size, ::mlir::IntegerAttr divisor) { … }

void MultiTileSizesOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value target, ::mlir::IntegerAttr dimension, ::mlir::IntegerAttr target_size, ::mlir::IntegerAttr divisor) { … }

void MultiTileSizesOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type low_size, ::mlir::Type high_size, ::mlir::Type split_point, ::mlir::Value target, uint64_t dimension, uint64_t target_size, uint64_t divisor) { … }

void MultiTileSizesOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value target, uint64_t dimension, uint64_t target_size, uint64_t divisor) { … }

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

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

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

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

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

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

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

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::PackGreedilyOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
PackGreedilyOpGenericAdaptorBase::PackGreedilyOpGenericAdaptorBase(PackGreedilyOp op) : … { … }

std::pair<unsigned, unsigned> PackGreedilyOpGenericAdaptorBase::getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { … }

::mlir::DenseI64ArrayAttr PackGreedilyOpGenericAdaptorBase::getStaticMatmulPackedSizesAttr() { … }

::llvm::ArrayRef<int64_t> PackGreedilyOpGenericAdaptorBase::getStaticMatmulPackedSizes() { … }

::mlir::DenseI64ArrayAttr PackGreedilyOpGenericAdaptorBase::getMatmulPaddedSizesNextMultipleOfAttr() { … }

::llvm::ArrayRef<int64_t> PackGreedilyOpGenericAdaptorBase::getMatmulPaddedSizesNextMultipleOf() { … }

::mlir::DenseI64ArrayAttr PackGreedilyOpGenericAdaptorBase::getMatmulInnerDimsOrderAttr() { … }

::llvm::ArrayRef<int64_t> PackGreedilyOpGenericAdaptorBase::getMatmulInnerDimsOrder() { … }

} // namespace detail
PackGreedilyOpAdaptor::PackGreedilyOpAdaptor(PackGreedilyOp op) : … { … }

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

std::pair<unsigned, unsigned> PackGreedilyOp::getODSOperandIndexAndLength(unsigned index) { … }

::mlir::MutableOperandRange PackGreedilyOp::getMatmulPackedSizesMutable() { … }

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

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

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

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

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

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

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

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

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

::llvm::ArrayRef<int64_t> PackGreedilyOp::getStaticMatmulPackedSizes() { … }

::llvm::ArrayRef<int64_t> PackGreedilyOp::getMatmulPaddedSizesNextMultipleOf() { … }

::llvm::ArrayRef<int64_t> PackGreedilyOp::getMatmulInnerDimsOrder() { … }

void PackGreedilyOp::setStaticMatmulPackedSizes(::llvm::ArrayRef<int64_t> attrValue) { … }

void PackGreedilyOp::setMatmulPaddedSizesNextMultipleOf(::llvm::ArrayRef<int64_t> attrValue) { … }

void PackGreedilyOp::setMatmulInnerDimsOrder(::llvm::ArrayRef<int64_t> attrValue) { … }

void PackGreedilyOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type packed_op, ::mlir::Value target, ::mlir::ValueRange matmul_packed_sizes, ::mlir::DenseI64ArrayAttr static_matmul_packed_sizes, ::mlir::DenseI64ArrayAttr matmul_padded_sizes_next_multiple_of, ::mlir::DenseI64ArrayAttr matmul_inner_dims_order) { … }

void PackGreedilyOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value target, ::mlir::ValueRange matmul_packed_sizes, ::mlir::DenseI64ArrayAttr static_matmul_packed_sizes, ::mlir::DenseI64ArrayAttr matmul_padded_sizes_next_multiple_of, ::mlir::DenseI64ArrayAttr matmul_inner_dims_order) { … }

void PackGreedilyOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type packed_op, ::mlir::Value target, ::mlir::ValueRange matmul_packed_sizes, ::llvm::ArrayRef<int64_t> static_matmul_packed_sizes, ::llvm::ArrayRef<int64_t> matmul_padded_sizes_next_multiple_of, ::llvm::ArrayRef<int64_t> matmul_inner_dims_order) { … }

void PackGreedilyOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value target, ::mlir::ValueRange matmul_packed_sizes, ::llvm::ArrayRef<int64_t> static_matmul_packed_sizes, ::llvm::ArrayRef<int64_t> matmul_padded_sizes_next_multiple_of, ::llvm::ArrayRef<int64_t> matmul_inner_dims_order) { … }

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

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

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

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

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

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

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

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::PackOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
PackOpGenericAdaptorBase::PackOpGenericAdaptorBase(PackOp op) : … { … }

std::pair<unsigned, unsigned> PackOpGenericAdaptorBase::getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { … }

::mlir::DenseI64ArrayAttr PackOpGenericAdaptorBase::getStaticPackedSizesAttr() { … }

::llvm::ArrayRef<int64_t> PackOpGenericAdaptorBase::getStaticPackedSizes() { … }

} // namespace detail
PackOpAdaptor::PackOpAdaptor(PackOp op) : … { … }

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

std::pair<unsigned, unsigned> PackOp::getODSOperandIndexAndLength(unsigned index) { … }

::mlir::MutableOperandRange PackOp::getPackedSizesMutable() { … }

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

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

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

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

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

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

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

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

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

::llvm::ArrayRef<int64_t> PackOp::getStaticPackedSizes() { … }

void PackOp::setStaticPackedSizes(::llvm::ArrayRef<int64_t> attrValue) { … }

void PackOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type packed_op, ::mlir::Value target, ::mlir::ValueRange packed_sizes, ::mlir::DenseI64ArrayAttr static_packed_sizes) { … }

void PackOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value target, ::mlir::ValueRange packed_sizes, ::mlir::DenseI64ArrayAttr static_packed_sizes) { … }

void PackOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type packed_op, ::mlir::Value target, ::mlir::ValueRange packed_sizes, ::llvm::ArrayRef<int64_t> static_packed_sizes) { … }

void PackOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value target, ::mlir::ValueRange packed_sizes, ::llvm::ArrayRef<int64_t> static_packed_sizes) { … }

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

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

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

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

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

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

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

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::PackTransposeOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
PackTransposeOpGenericAdaptorBase::PackTransposeOpGenericAdaptorBase(PackTransposeOp op) : … { … }

::mlir::DenseI64ArrayAttr PackTransposeOpGenericAdaptorBase::getOuterPermAttr() { … }

::llvm::ArrayRef<int64_t> PackTransposeOpGenericAdaptorBase::getOuterPerm() { … }

::mlir::DenseI64ArrayAttr PackTransposeOpGenericAdaptorBase::getInnerPermAttr() { … }

::llvm::ArrayRef<int64_t> PackTransposeOpGenericAdaptorBase::getInnerPerm() { … }

} // namespace detail
PackTransposeOpAdaptor::PackTransposeOpAdaptor(PackTransposeOp op) : … { … }

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

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

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

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

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

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

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

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

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

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

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

::llvm::ArrayRef<int64_t> PackTransposeOp::getOuterPerm() { … }

::llvm::ArrayRef<int64_t> PackTransposeOp::getInnerPerm() { … }

void PackTransposeOp::setOuterPerm(::std::optional<::llvm::ArrayRef<int64_t>> attrValue) { … }

void PackTransposeOp::setInnerPerm(::std::optional<::llvm::ArrayRef<int64_t>> attrValue) { … }

void PackTransposeOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type packed_op, ::mlir::Type pack_op, ::mlir::Type un_pack_op, ::mlir::Value target_pack_or_un_pack_op, ::mlir::Value target_linalg_op, /*optional*/::mlir::DenseI64ArrayAttr outer_perm, /*optional*/::mlir::DenseI64ArrayAttr inner_perm) { … }

void PackTransposeOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value target_pack_or_un_pack_op, ::mlir::Value target_linalg_op, /*optional*/::mlir::DenseI64ArrayAttr outer_perm, /*optional*/::mlir::DenseI64ArrayAttr inner_perm) { … }

void PackTransposeOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type packed_op, ::mlir::Type pack_op, ::mlir::Type un_pack_op, ::mlir::Value target_pack_or_un_pack_op, ::mlir::Value target_linalg_op, /*optional*/::llvm::ArrayRef<int64_t> outer_perm, /*optional*/::llvm::ArrayRef<int64_t> inner_perm) { … }

void PackTransposeOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value target_pack_or_un_pack_op, ::mlir::Value target_linalg_op, /*optional*/::llvm::ArrayRef<int64_t> outer_perm, /*optional*/::llvm::ArrayRef<int64_t> inner_perm) { … }

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

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

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

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

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

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

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::PadOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
PadOpGenericAdaptorBase::PadOpGenericAdaptorBase(PadOp op) : … { … }

std::pair<unsigned, unsigned> PadOpGenericAdaptorBase::getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { … }

::mlir::ArrayAttr PadOpGenericAdaptorBase::getPaddingValuesAttr() { … }

::mlir::ArrayAttr PadOpGenericAdaptorBase::getPaddingValues() { … }

::mlir::ArrayAttr PadOpGenericAdaptorBase::getPaddingDimensionsAttr() { … }

::mlir::ArrayAttr PadOpGenericAdaptorBase::getPaddingDimensions() { … }

::mlir::DenseI64ArrayAttr PadOpGenericAdaptorBase::getStaticPadToMultipleOfAttr() { … }

::llvm::ArrayRef<int64_t> PadOpGenericAdaptorBase::getStaticPadToMultipleOf() { … }

::mlir::ArrayAttr PadOpGenericAdaptorBase::getPackPaddingsAttr() { … }

::mlir::ArrayAttr PadOpGenericAdaptorBase::getPackPaddings() { … }

::mlir::ArrayAttr PadOpGenericAdaptorBase::getTransposePaddingsAttr() { … }

::mlir::ArrayAttr PadOpGenericAdaptorBase::getTransposePaddings() { … }

::mlir::StringAttr PadOpGenericAdaptorBase::getCopyBackOpAttr() { … }

::llvm::StringRef PadOpGenericAdaptorBase::getCopyBackOp() { … }

} // namespace detail
PadOpAdaptor::PadOpAdaptor(PadOp op) : … { … }

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

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

std::pair<unsigned, unsigned> PadOp::getODSOperandIndexAndLength(unsigned index) { … }

::mlir::MutableOperandRange PadOp::getPadToMultipleOfMutable() { … }

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

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

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

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

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

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

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

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

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

::mlir::ArrayAttr PadOp::getPaddingValues() { … }

::mlir::ArrayAttr PadOp::getPaddingDimensions() { … }

::llvm::ArrayRef<int64_t> PadOp::getStaticPadToMultipleOf() { … }

::mlir::ArrayAttr PadOp::getPackPaddings() { … }

::mlir::ArrayAttr PadOp::getTransposePaddings() { … }

::llvm::StringRef PadOp::getCopyBackOp() { … }

void PadOp::setStaticPadToMultipleOf(::std::optional<::llvm::ArrayRef<int64_t>> attrValue) { … }

void PadOp::setCopyBackOp(::llvm::StringRef attrValue) { … }

void PadOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type padded, ::mlir::Type pad, ::mlir::Type copy, ::mlir::Value target, ::mlir::ArrayAttr padding_values, ::mlir::ArrayAttr padding_dimensions, ::mlir::ValueRange pad_to_multiple_of, /*optional*/::mlir::DenseI64ArrayAttr static_pad_to_multiple_of, ::mlir::ArrayAttr pack_paddings, ::mlir::ArrayAttr transpose_paddings, ::mlir::StringAttr copy_back_op) { … }

void PadOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value target, ::mlir::ArrayAttr padding_values, ::mlir::ArrayAttr padding_dimensions, ::mlir::ValueRange pad_to_multiple_of, /*optional*/::mlir::DenseI64ArrayAttr static_pad_to_multiple_of, ::mlir::ArrayAttr pack_paddings, ::mlir::ArrayAttr transpose_paddings, ::mlir::StringAttr copy_back_op) { … }

void PadOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type padded, ::mlir::Type pad, ::mlir::Type copy, ::mlir::Value target, ::mlir::ArrayAttr padding_values, ::mlir::ArrayAttr padding_dimensions, ::mlir::ValueRange pad_to_multiple_of, /*optional*/::llvm::ArrayRef<int64_t> static_pad_to_multiple_of, ::mlir::ArrayAttr pack_paddings, ::mlir::ArrayAttr transpose_paddings, ::llvm::StringRef copy_back_op) { … }

void PadOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value target, ::mlir::ArrayAttr padding_values, ::mlir::ArrayAttr padding_dimensions, ::mlir::ValueRange pad_to_multiple_of, /*optional*/::llvm::ArrayRef<int64_t> static_pad_to_multiple_of, ::mlir::ArrayAttr pack_paddings, ::mlir::ArrayAttr transpose_paddings, ::llvm::StringRef copy_back_op) { … }

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

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

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

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

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

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

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

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::PromoteOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
PromoteOpGenericAdaptorBase::PromoteOpGenericAdaptorBase(PromoteOp op) : … { … }

::mlir::ArrayAttr PromoteOpGenericAdaptorBase::getOperandsToPromoteAttr() { … }

::mlir::ArrayAttr PromoteOpGenericAdaptorBase::getOperandsToPromote() { … }

::mlir::ArrayAttr PromoteOpGenericAdaptorBase::getUseFullTileBuffersAttr() { … }

::mlir::ArrayAttr PromoteOpGenericAdaptorBase::getUseFullTileBuffers() { … }

::mlir::UnitAttr PromoteOpGenericAdaptorBase::getUseFullTilesByDefaultAttr() { … }

bool PromoteOpGenericAdaptorBase::getUseFullTilesByDefault() { … }

::mlir::UnitAttr PromoteOpGenericAdaptorBase::getUseAllocaAttr() { … }

bool PromoteOpGenericAdaptorBase::getUseAlloca() { … }

::std::optional<::mlir::Attribute> PromoteOpGenericAdaptorBase::getMemorySpace() { … }

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

::std::optional<uint64_t> PromoteOpGenericAdaptorBase::getAlignment() { … }

} // namespace detail
PromoteOpAdaptor::PromoteOpAdaptor(PromoteOp op) : … { … }

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

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

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

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

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

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

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

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

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

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

::mlir::ArrayAttr PromoteOp::getOperandsToPromote() { … }

::mlir::ArrayAttr PromoteOp::getUseFullTileBuffers() { … }

bool PromoteOp::getUseFullTilesByDefault() { … }

bool PromoteOp::getUseAlloca() { … }

::std::optional<::mlir::Attribute> PromoteOp::getMemorySpace() { … }

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

::std::optional<uint64_t> PromoteOp::getAlignment() { … }

void PromoteOp::setUseFullTilesByDefault(bool attrValue) { … }

void PromoteOp::setUseAlloca(bool attrValue) { … }

void PromoteOp::setAlignment(::std::optional<uint64_t> attrValue) { … }

void PromoteOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type transformed, ::mlir::Value target, ::mlir::ArrayAttr operands_to_promote, ::mlir::ArrayAttr use_full_tile_buffers, /*optional*/::mlir::UnitAttr use_full_tiles_by_default, /*optional*/::mlir::UnitAttr use_alloca, /*optional*/::mlir::Attribute memory_space, /*optional*/::mlir::ArrayAttr mapping, /*optional*/::mlir::IntegerAttr alignment) { … }

void PromoteOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value target, ::mlir::ArrayAttr operands_to_promote, ::mlir::ArrayAttr use_full_tile_buffers, /*optional*/::mlir::UnitAttr use_full_tiles_by_default, /*optional*/::mlir::UnitAttr use_alloca, /*optional*/::mlir::Attribute memory_space, /*optional*/::mlir::ArrayAttr mapping, /*optional*/::mlir::IntegerAttr alignment) { … }

void PromoteOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type transformed, ::mlir::Value target, ::mlir::ArrayAttr operands_to_promote, ::mlir::ArrayAttr use_full_tile_buffers, /*optional*/bool use_full_tiles_by_default, /*optional*/bool use_alloca, /*optional*/::mlir::Attribute memory_space, /*optional*/::mlir::ArrayAttr mapping, /*optional*/::mlir::IntegerAttr alignment) { … }

void PromoteOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value target, ::mlir::ArrayAttr operands_to_promote, ::mlir::ArrayAttr use_full_tile_buffers, /*optional*/bool use_full_tiles_by_default, /*optional*/bool use_alloca, /*optional*/::mlir::Attribute memory_space, /*optional*/::mlir::ArrayAttr mapping, /*optional*/::mlir::IntegerAttr alignment) { … }

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

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

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

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

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

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

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

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::ReplaceOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
} // namespace detail
ReplaceOpAdaptor::ReplaceOpAdaptor(ReplaceOp op) : … { … }

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

void ReplaceOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type replacement, ::mlir::Value target) { … }

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

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

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

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

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

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

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

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::RewriteInDestinationPassingStyleOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
} // namespace detail
RewriteInDestinationPassingStyleOpAdaptor::RewriteInDestinationPassingStyleOpAdaptor(RewriteInDestinationPassingStyleOp op) : … { … }

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

void RewriteInDestinationPassingStyleOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type transformed, ::mlir::Value target) { … }

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

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

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

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

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

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

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

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::ScalarizeOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
} // namespace detail
ScalarizeOpAdaptor::ScalarizeOpAdaptor(ScalarizeOp op) : … { … }

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

void ScalarizeOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value target) { … }

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

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

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

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

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

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

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

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::SpecializeOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
} // namespace detail
SpecializeOpAdaptor::SpecializeOpAdaptor(SpecializeOp op) : … { … }

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

void SpecializeOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type transformed, ::mlir::Value target) { … }

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

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

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

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

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

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

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

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::SplitOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
SplitOpGenericAdaptorBase::SplitOpGenericAdaptorBase(SplitOp op) : … { … }

std::pair<unsigned, unsigned> SplitOpGenericAdaptorBase::getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { … }

uint64_t SplitOpGenericAdaptorBase::getDimension() { … }

uint64_t SplitOpGenericAdaptorBase::getStaticChunkSizes() { … }

::mlir::UnitAttr SplitOpGenericAdaptorBase::getMultiwayAttr() { … }

bool SplitOpGenericAdaptorBase::getMultiway() { … }

} // namespace detail
SplitOpAdaptor::SplitOpAdaptor(SplitOp op) : … { … }

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

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

std::pair<unsigned, unsigned> SplitOp::getODSOperandIndexAndLength(unsigned index) { … }

::mlir::MutableOperandRange SplitOp::getDynamicChunkSizesMutable() { … }

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

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

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

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

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

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

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

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

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

uint64_t SplitOp::getDimension() { … }

uint64_t SplitOp::getStaticChunkSizes() { … }

bool SplitOp::getMultiway() { … }

void SplitOp::setDimension(uint64_t attrValue) { … }

void SplitOp::setStaticChunkSizes(uint64_t attrValue) { … }

void SplitOp::setMultiway(bool attrValue) { … }

void SplitOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type first, ::mlir::Type second, ::mlir::Value target, ::mlir::IntegerAttr dimension, /*optional*/::mlir::Value dynamic_chunk_sizes, ::mlir::IntegerAttr static_chunk_sizes, /*optional*/::mlir::UnitAttr multiway) { … }

void SplitOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value target, ::mlir::IntegerAttr dimension, /*optional*/::mlir::Value dynamic_chunk_sizes, ::mlir::IntegerAttr static_chunk_sizes, /*optional*/::mlir::UnitAttr multiway) { … }

void SplitOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type first, ::mlir::Type second, ::mlir::Value target, uint64_t dimension, /*optional*/::mlir::Value dynamic_chunk_sizes, uint64_t static_chunk_sizes, /*optional*/bool multiway) { … }

void SplitOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value target, uint64_t dimension, /*optional*/::mlir::Value dynamic_chunk_sizes, uint64_t static_chunk_sizes, /*optional*/bool multiway) { … }

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

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

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

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

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::SplitReductionOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
SplitReductionOpGenericAdaptorBase::SplitReductionOpGenericAdaptorBase(SplitReductionOp op) : … { … }

::mlir::IntegerAttr SplitReductionOpGenericAdaptorBase::getSplitFactorAttr() { … }

uint64_t SplitReductionOpGenericAdaptorBase::getSplitFactor() { … }

::mlir::IntegerAttr SplitReductionOpGenericAdaptorBase::getInsertSplitDimensionAttr() { … }

uint64_t SplitReductionOpGenericAdaptorBase::getInsertSplitDimension() { … }

::mlir::UnitAttr SplitReductionOpGenericAdaptorBase::getInnerParallelAttr() { … }

bool SplitReductionOpGenericAdaptorBase::getInnerParallel() { … }

::mlir::UnitAttr SplitReductionOpGenericAdaptorBase::getUseScalingAlgorithmAttr() { … }

bool SplitReductionOpGenericAdaptorBase::getUseScalingAlgorithm() { … }

::mlir::UnitAttr SplitReductionOpGenericAdaptorBase::getUseAllocAttr() { … }

bool SplitReductionOpGenericAdaptorBase::getUseAlloc() { … }

} // namespace detail
SplitReductionOpAdaptor::SplitReductionOpAdaptor(SplitReductionOp op) : … { … }

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

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

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

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

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

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

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

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

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

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

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

uint64_t SplitReductionOp::getSplitFactor() { … }

uint64_t SplitReductionOp::getInsertSplitDimension() { … }

bool SplitReductionOp::getInnerParallel() { … }

bool SplitReductionOp::getUseScalingAlgorithm() { … }

bool SplitReductionOp::getUseAlloc() { … }

void SplitReductionOp::setSplitFactor(uint64_t attrValue) { … }

void SplitReductionOp::setInsertSplitDimension(uint64_t attrValue) { … }

void SplitReductionOp::setInnerParallel(bool attrValue) { … }

void SplitReductionOp::setUseScalingAlgorithm(bool attrValue) { … }

void SplitReductionOp::setUseAlloc(bool attrValue) { … }

void SplitReductionOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type init_or_alloc_op, ::mlir::Type fill_op, ::mlir::Type split_linalg_op, ::mlir::Type combining_linalg_op, ::mlir::Value target, ::mlir::IntegerAttr split_factor, ::mlir::IntegerAttr insert_split_dimension, /*optional*/::mlir::UnitAttr inner_parallel, /*optional*/::mlir::UnitAttr use_scaling_algorithm, /*optional*/::mlir::UnitAttr use_alloc) { … }

void SplitReductionOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value target, ::mlir::IntegerAttr split_factor, ::mlir::IntegerAttr insert_split_dimension, /*optional*/::mlir::UnitAttr inner_parallel, /*optional*/::mlir::UnitAttr use_scaling_algorithm, /*optional*/::mlir::UnitAttr use_alloc) { … }

void SplitReductionOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type init_or_alloc_op, ::mlir::Type fill_op, ::mlir::Type split_linalg_op, ::mlir::Type combining_linalg_op, ::mlir::Value target, uint64_t split_factor, uint64_t insert_split_dimension, /*optional*/bool inner_parallel, /*optional*/bool use_scaling_algorithm, /*optional*/bool use_alloc) { … }

void SplitReductionOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value target, uint64_t split_factor, uint64_t insert_split_dimension, /*optional*/bool inner_parallel, /*optional*/bool use_scaling_algorithm, /*optional*/bool use_alloc) { … }

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

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

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

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

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

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

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

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::TileReductionUsingForOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
TileReductionUsingForOpGenericAdaptorBase::TileReductionUsingForOpGenericAdaptorBase(TileReductionUsingForOp op) : … { … }

::mlir::DenseI64ArrayAttr TileReductionUsingForOpGenericAdaptorBase::getTileSizesAttr() { … }

::llvm::ArrayRef<int64_t> TileReductionUsingForOpGenericAdaptorBase::getTileSizes() { … }

} // namespace detail
TileReductionUsingForOpAdaptor::TileReductionUsingForOpAdaptor(TileReductionUsingForOp op) : … { … }

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

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

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

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

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

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

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

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

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

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

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

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

::llvm::ArrayRef<int64_t> TileReductionUsingForOp::getTileSizes() { … }

void TileReductionUsingForOp::setTileSizes(::llvm::ArrayRef<int64_t> attrValue) { … }

void TileReductionUsingForOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange fill_op, ::mlir::Type split_linalg_op, ::mlir::Type combining_linalg_op, ::mlir::Type for_op, ::mlir::Value target, ::mlir::DenseI64ArrayAttr tile_sizes) { … }

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

void TileReductionUsingForOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange fill_op, ::mlir::Type split_linalg_op, ::mlir::Type combining_linalg_op, ::mlir::Type for_op, ::mlir::Value target, ::llvm::ArrayRef<int64_t> tile_sizes) { … }

void TileReductionUsingForOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value target, ::llvm::ArrayRef<int64_t> tile_sizes) { … }

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

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

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

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

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

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

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

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::TileReductionUsingForallOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
TileReductionUsingForallOpGenericAdaptorBase::TileReductionUsingForallOpGenericAdaptorBase(TileReductionUsingForallOp op) : … { … }

::mlir::DenseI64ArrayAttr TileReductionUsingForallOpGenericAdaptorBase::getNumThreadsAttr() { … }

::llvm::ArrayRef<int64_t> TileReductionUsingForallOpGenericAdaptorBase::getNumThreads() { … }

::mlir::DenseI64ArrayAttr TileReductionUsingForallOpGenericAdaptorBase::getTileSizesAttr() { … }

::llvm::ArrayRef<int64_t> TileReductionUsingForallOpGenericAdaptorBase::getTileSizes() { … }

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

} // namespace detail
TileReductionUsingForallOpAdaptor::TileReductionUsingForallOpAdaptor(TileReductionUsingForallOp op) : … { … }

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

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

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

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

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

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

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

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

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

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

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

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

::llvm::ArrayRef<int64_t> TileReductionUsingForallOp::getNumThreads() { … }

::llvm::ArrayRef<int64_t> TileReductionUsingForallOp::getTileSizes() { … }

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

void TileReductionUsingForallOp::setNumThreads(::llvm::ArrayRef<int64_t> attrValue) { … }

void TileReductionUsingForallOp::setTileSizes(::llvm::ArrayRef<int64_t> attrValue) { … }

void TileReductionUsingForallOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange fill_op, ::mlir::Type split_linalg_op, ::mlir::Type combining_linalg_op, ::mlir::Type forall_op, ::mlir::Value target, ::mlir::DenseI64ArrayAttr num_threads, ::mlir::DenseI64ArrayAttr tile_sizes, /*optional*/::mlir::ArrayAttr mapping) { … }

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

void TileReductionUsingForallOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange fill_op, ::mlir::Type split_linalg_op, ::mlir::Type combining_linalg_op, ::mlir::Type forall_op, ::mlir::Value target, ::llvm::ArrayRef<int64_t> num_threads, ::llvm::ArrayRef<int64_t> tile_sizes, /*optional*/::mlir::ArrayAttr mapping) { … }

void TileReductionUsingForallOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value target, ::llvm::ArrayRef<int64_t> num_threads, ::llvm::ArrayRef<int64_t> tile_sizes, /*optional*/::mlir::ArrayAttr mapping) { … }

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

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

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

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

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

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

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

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::TileUsingForOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
TileUsingForOpGenericAdaptorBase::TileUsingForOpGenericAdaptorBase(TileUsingForOp op) : … { … }

std::pair<unsigned, unsigned> TileUsingForOpGenericAdaptorBase::getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { … }

::mlir::DenseI64ArrayAttr TileUsingForOpGenericAdaptorBase::getStaticSizesAttr() { … }

::llvm::ArrayRef<int64_t> TileUsingForOpGenericAdaptorBase::getStaticSizes() { … }

::mlir::DenseI64ArrayAttr TileUsingForOpGenericAdaptorBase::getInterchangeAttr() { … }

::llvm::ArrayRef<int64_t> TileUsingForOpGenericAdaptorBase::getInterchange() { … }

::mlir::DenseBoolArrayAttr TileUsingForOpGenericAdaptorBase::getScalableSizesAttr() { … }

::llvm::ArrayRef<bool> TileUsingForOpGenericAdaptorBase::getScalableSizes() { … }

} // namespace detail
TileUsingForOpAdaptor::TileUsingForOpAdaptor(TileUsingForOp op) : … { … }

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

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

std::pair<unsigned, unsigned> TileUsingForOp::getODSOperandIndexAndLength(unsigned index) { … }

::mlir::MutableOperandRange TileUsingForOp::getDynamicSizesMutable() { … }

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

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

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

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

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

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

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

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

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

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

::llvm::ArrayRef<int64_t> TileUsingForOp::getStaticSizes() { … }

::llvm::ArrayRef<int64_t> TileUsingForOp::getInterchange() { … }

::llvm::ArrayRef<bool> TileUsingForOp::getScalableSizes() { … }

void TileUsingForOp::setStaticSizes(::std::optional<::llvm::ArrayRef<int64_t>> attrValue) { … }

void TileUsingForOp::setInterchange(::std::optional<::llvm::ArrayRef<int64_t>> attrValue) { … }

void TileUsingForOp::setScalableSizes(::std::optional<::llvm::ArrayRef<bool>> attrValue) { … }

void TileUsingForOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type tiled_linalg_op, ::mlir::TypeRange loops, ::mlir::Value target, ::mlir::ValueRange dynamic_sizes, /*optional*/::mlir::DenseI64ArrayAttr static_sizes, /*optional*/::mlir::DenseI64ArrayAttr interchange, /*optional*/::mlir::DenseBoolArrayAttr scalable_sizes) { … }

void TileUsingForOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value target, ::mlir::ValueRange dynamic_sizes, /*optional*/::mlir::DenseI64ArrayAttr static_sizes, /*optional*/::mlir::DenseI64ArrayAttr interchange, /*optional*/::mlir::DenseBoolArrayAttr scalable_sizes) { … }

void TileUsingForOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type tiled_linalg_op, ::mlir::TypeRange loops, ::mlir::Value target, ::mlir::ValueRange dynamic_sizes, /*optional*/::llvm::ArrayRef<int64_t> static_sizes, /*optional*/::llvm::ArrayRef<int64_t> interchange, /*optional*/::llvm::ArrayRef<bool> scalable_sizes) { … }

void TileUsingForOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value target, ::mlir::ValueRange dynamic_sizes, /*optional*/::llvm::ArrayRef<int64_t> static_sizes, /*optional*/::llvm::ArrayRef<int64_t> interchange, /*optional*/::llvm::ArrayRef<bool> scalable_sizes) { … }

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

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

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

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

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

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

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::TileUsingForallOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
TileUsingForallOpGenericAdaptorBase::TileUsingForallOpGenericAdaptorBase(TileUsingForallOp op) : … { … }

std::pair<unsigned, unsigned> TileUsingForallOpGenericAdaptorBase::getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { … }

::mlir::DenseI64ArrayAttr TileUsingForallOpGenericAdaptorBase::getStaticNumThreadsAttr() { … }

::llvm::ArrayRef<int64_t> TileUsingForallOpGenericAdaptorBase::getStaticNumThreads() { … }

::mlir::DenseI64ArrayAttr TileUsingForallOpGenericAdaptorBase::getStaticTileSizesAttr() { … }

::llvm::ArrayRef<int64_t> TileUsingForallOpGenericAdaptorBase::getStaticTileSizes() { … }

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

} // namespace detail
TileUsingForallOpAdaptor::TileUsingForallOpAdaptor(TileUsingForallOp op) : … { … }

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

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

std::pair<unsigned, unsigned> TileUsingForallOp::getODSOperandIndexAndLength(unsigned index) { … }

::mlir::MutableOperandRange TileUsingForallOp::getNumThreadsMutable() { … }

::mlir::MutableOperandRange TileUsingForallOp::getTileSizesMutable() { … }

::mlir::MutableOperandRange TileUsingForallOp::getPackedNumThreadsMutable() { … }

::mlir::MutableOperandRange TileUsingForallOp::getPackedTileSizesMutable() { … }

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

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

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

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

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

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

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

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

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

::llvm::ArrayRef<int64_t> TileUsingForallOp::getStaticNumThreads() { … }

::llvm::ArrayRef<int64_t> TileUsingForallOp::getStaticTileSizes() { … }

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

void TileUsingForallOp::setStaticNumThreads(::std::optional<::llvm::ArrayRef<int64_t>> attrValue) { … }

void TileUsingForallOp::setStaticTileSizes(::std::optional<::llvm::ArrayRef<int64_t>> attrValue) { … }

void TileUsingForallOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type tiled_op, ::mlir::Type forall_op, ::mlir::Value target, ::mlir::ValueRange num_threads, ::mlir::ValueRange tile_sizes, /*optional*/::mlir::Value packed_num_threads, /*optional*/::mlir::Value packed_tile_sizes, /*optional*/::mlir::DenseI64ArrayAttr static_num_threads, /*optional*/::mlir::DenseI64ArrayAttr static_tile_sizes, /*optional*/::mlir::ArrayAttr mapping) { … }

void TileUsingForallOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value target, ::mlir::ValueRange num_threads, ::mlir::ValueRange tile_sizes, /*optional*/::mlir::Value packed_num_threads, /*optional*/::mlir::Value packed_tile_sizes, /*optional*/::mlir::DenseI64ArrayAttr static_num_threads, /*optional*/::mlir::DenseI64ArrayAttr static_tile_sizes, /*optional*/::mlir::ArrayAttr mapping) { … }

void TileUsingForallOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type tiled_op, ::mlir::Type forall_op, ::mlir::Value target, ::mlir::ValueRange num_threads, ::mlir::ValueRange tile_sizes, /*optional*/::mlir::Value packed_num_threads, /*optional*/::mlir::Value packed_tile_sizes, /*optional*/::llvm::ArrayRef<int64_t> static_num_threads, /*optional*/::llvm::ArrayRef<int64_t> static_tile_sizes, /*optional*/::mlir::ArrayAttr mapping) { … }void TileUsingForallOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value target, ::mlir::ValueRange num_threads, ::mlir::ValueRange tile_sizes, /*optional*/::mlir::Value packed_num_threads, /*optional*/::mlir::Value packed_tile_sizes, /*optional*/::llvm::ArrayRef<int64_t> static_num_threads, /*optional*/::llvm::ArrayRef<int64_t> static_tile_sizes, /*optional*/::mlir::ArrayAttr mapping) { … }void TileUsingForallOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) { … }::llvm::LogicalResult TileUsingForallOp::verifyInvariantsImpl() { … }::llvm::LogicalResult TileUsingForallOp::verifyInvariants() { … }::mlir::ParseResult TileUsingForallOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) { … }void TileUsingForallOp::print(::mlir::OpAsmPrinter &_odsPrinter) { … }MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::transform::TileUsingForallOp)TransposeConv2DOpAdaptor::TransposeConv2DOpAdaptor(TransposeConv2DOp op) : … { … }::llvm::LogicalResult TransposeConv2DOpAdaptor::verify(::mlir::Location loc) { … }void TransposeConv2DOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type transformed, ::mlir::Value target) { … }void TransposeConv2DOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value target) { … }void TransposeConv2DOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) { … }::llvm::LogicalResult TransposeConv2DOp::verifyInvariantsImpl() { … }::llvm::LogicalResult TransposeConv2DOp::verifyInvariants() { … }::mlir::ParseResult TransposeConv2DOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) { … }void TransposeConv2DOp::print(::mlir::OpAsmPrinter &_odsPrinter) { … }MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::transform::TransposeConv2DOp)TransposeMatmulOpGenericAdaptorBase::TransposeMatmulOpGenericAdaptorBase(TransposeMatmulOp op) : … { … }mlir::transform::TransposeMatmulInputAttr TransposeMatmulOpGenericAdaptorBase::getInputToTransposeAttr() { … }mlir::transform::TransposeMatmulInput TransposeMatmulOpGenericAdaptorBase::getInputToTranspose() { … }TransposeMatmulOpAdaptor::TransposeMatmulOpAdaptor(TransposeMatmulOp op) : … { … }::llvm::LogicalResult TransposeMatmulOpAdaptor::verify(::mlir::Location loc) { … }::llvm::LogicalResult TransposeMatmulOp::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) { … }::mlir::Attribute TransposeMatmulOp::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) { … }llvm::hash_code TransposeMatmulOp::computePropertiesHash(const Properties &prop) { … }std::optional<mlir::Attribute> TransposeMatmulOp::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) { … }void TransposeMatmulOp::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) { … }void TransposeMatmulOp::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) { … }::llvm::LogicalResult TransposeMatmulOp::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) { … }::llvm::LogicalResult TransposeMatmulOp::readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state) { … }void TransposeMatmulOp::writeProperties(::mlir::DialectBytecodeWriter &writer) { … }mlir::transform::TransposeMatmulInput TransposeMatmulOp::getInputToTranspose() { … }void TransposeMatmulOp::setInputToTranspose(mlir::transform::TransposeMatmulInput attrValue) { … }void TransposeMatmulOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type transformed, ::mlir::Value target, mlir::transform::TransposeMatmulInputAttr inputToTranspose) { … }void TransposeMatmulOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value target, mlir::transform::TransposeMatmulInputAttr inputToTranspose) { … }void TransposeMatmulOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type transformed, ::mlir::Value target, mlir::transform::TransposeMatmulInput inputToTranspose) { … }void TransposeMatmulOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value target, mlir::transform::TransposeMatmulInput inputToTranspose) { … }void TransposeMatmulOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) { … }void TransposeMatmulOp::populateDefaultProperties(::mlir::OperationName opName, Properties &properties) { … }::llvm::LogicalResult TransposeMatmulOp::verifyInvariantsImpl() { … }::llvm::LogicalResult TransposeMatmulOp::verifyInvariants() { … }::mlir::ParseResult TransposeMatmulOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) { … }void TransposeMatmulOp::print(::mlir::OpAsmPrinter &_odsPrinter) { … }MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::transform::TransposeMatmulOp)VectorizeChildrenAndApplyPatternsOpGenericAdaptorBase::VectorizeChildrenAndApplyPatternsOpGenericAdaptorBase(VectorizeChildrenAndApplyPatternsOp op) : … { … }::mlir::UnitAttr VectorizeChildrenAndApplyPatternsOpGenericAdaptorBase::getVectorizePaddingAttr() { … }bool VectorizeChildrenAndApplyPatternsOpGenericAdaptorBase::getVectorizePadding() { … }::mlir::UnitAttr VectorizeChildrenAndApplyPatternsOpGenericAdaptorBase::getVectorizeNdExtractAttr() { … }bool VectorizeChildrenAndApplyPatternsOpGenericAdaptorBase::getVectorizeNdExtract() { … }::mlir::UnitAttr VectorizeChildrenAndApplyPatternsOpGenericAdaptorBase::getFlatten_1dDepthwiseConvAttr() { … }bool VectorizeChildrenAndApplyPatternsOpGenericAdaptorBase::getFlatten_1dDepthwiseConv() { … }::mlir::UnitAttr VectorizeChildrenAndApplyPatternsOpGenericAdaptorBase::getDisableMultiReductionToContractPatternsAttr() { … }bool VectorizeChildrenAndApplyPatternsOpGenericAdaptorBase::getDisableMultiReductionToContractPatterns() { … }::mlir::UnitAttr VectorizeChildrenAndApplyPatternsOpGenericAdaptorBase::getDisableTransferPermutationMapLoweringPatternsAttr() { … }bool VectorizeChildrenAndApplyPatternsOpGenericAdaptorBase::getDisableTransferPermutationMapLoweringPatterns() { … }VectorizeChildrenAndApplyPatternsOpAdaptor::VectorizeChildrenAndApplyPatternsOpAdaptor(VectorizeChildrenAndApplyPatternsOp op) : … { … }::llvm::LogicalResult VectorizeChildrenAndApplyPatternsOpAdaptor::verify(::mlir::Location loc) { … }::llvm::LogicalResult VectorizeChildrenAndApplyPatternsOp::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) { … }::mlir::Attribute VectorizeChildrenAndApplyPatternsOp::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) { … }llvm::hash_code VectorizeChildrenAndApplyPatternsOp::computePropertiesHash(const Properties &prop) { … }std::optional<mlir::Attribute> VectorizeChildrenAndApplyPatternsOp::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) { … }void VectorizeChildrenAndApplyPatternsOp::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) { … }void VectorizeChildrenAndApplyPatternsOp::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) { … }::llvm::LogicalResult VectorizeChildrenAndApplyPatternsOp::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) { … }::llvm::LogicalResult VectorizeChildrenAndApplyPatternsOp::readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state) { … }void VectorizeChildrenAndApplyPatternsOp::writeProperties(::mlir::DialectBytecodeWriter &writer) { … }bool VectorizeChildrenAndApplyPatternsOp::getVectorizePadding() { … }bool VectorizeChildrenAndApplyPatternsOp::getVectorizeNdExtract() { … }bool VectorizeChildrenAndApplyPatternsOp::getFlatten_1dDepthwiseConv() { … }bool VectorizeChildrenAndApplyPatternsOp::getDisableMultiReductionToContractPatterns() { … }bool VectorizeChildrenAndApplyPatternsOp::getDisableTransferPermutationMapLoweringPatterns() { … }void VectorizeChildrenAndApplyPatternsOp::setVectorizePadding(bool attrValue) { … }void VectorizeChildrenAndApplyPatternsOp::setVectorizeNdExtract(bool attrValue) { … }void VectorizeChildrenAndApplyPatternsOp::setFlatten_1dDepthwiseConv(bool attrValue) { … }void VectorizeChildrenAndApplyPatternsOp::setDisableMultiReductionToContractPatterns(bool attrValue) { … }void VectorizeChildrenAndApplyPatternsOp::setDisableTransferPermutationMapLoweringPatterns(bool attrValue) { … }void VectorizeChildrenAndApplyPatternsOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type transformed, ::mlir::Value target, /*optional*/::mlir::UnitAttr vectorize_padding, /*optional*/::mlir::UnitAttr vectorize_nd_extract, /*optional*/::mlir::UnitAttr flatten_1d_depthwise_conv, /*optional*/::mlir::UnitAttr disable_multi_reduction_to_contract_patterns, /*optional*/::mlir::UnitAttr disable_transfer_permutation_map_lowering_patterns) { … }void VectorizeChildrenAndApplyPatternsOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value target, /*optional*/::mlir::UnitAttr vectorize_padding, /*optional*/::mlir::UnitAttr vectorize_nd_extract, /*optional*/::mlir::UnitAttr flatten_1d_depthwise_conv, /*optional*/::mlir::UnitAttr disable_multi_reduction_to_contract_patterns, /*optional*/::mlir::UnitAttr disable_transfer_permutation_map_lowering_patterns) { … }void VectorizeChildrenAndApplyPatternsOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type transformed, ::mlir::Value target, /*optional*/bool vectorize_padding, /*optional*/bool vectorize_nd_extract, /*optional*/bool flatten_1d_depthwise_conv, /*optional*/bool disable_multi_reduction_to_contract_patterns, /*optional*/bool disable_transfer_permutation_map_lowering_patterns) { … }void VectorizeChildrenAndApplyPatternsOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value target, /*optional*/bool vectorize_padding, /*optional*/bool vectorize_nd_extract, /*optional*/bool flatten_1d_depthwise_conv, /*optional*/bool disable_multi_reduction_to_contract_patterns, /*optional*/bool disable_transfer_permutation_map_lowering_patterns) { … }void VectorizeChildrenAndApplyPatternsOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) { … }::llvm::LogicalResult VectorizeChildrenAndApplyPatternsOp::verifyInvariantsImpl() { … }::llvm::LogicalResult VectorizeChildrenAndApplyPatternsOp::verifyInvariants() { … }::mlir::ParseResult VectorizeChildrenAndApplyPatternsOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) { … }void VectorizeChildrenAndApplyPatternsOp::print(::mlir::OpAsmPrinter &_odsPrinter) { … }MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::transform::VectorizeChildrenAndApplyPatternsOp)VectorizeOpGenericAdaptorBase::VectorizeOpGenericAdaptorBase(VectorizeOp op) : … { … }std::pair<unsigned, unsigned> VectorizeOpGenericAdaptorBase::getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { … }::mlir::DenseI64ArrayAttr VectorizeOpGenericAdaptorBase::getStaticVectorSizesAttr() { … }::llvm::ArrayRef<int64_t> VectorizeOpGenericAdaptorBase::getStaticVectorSizes() { … }::std::optional<bool> VectorizeOpGenericAdaptorBase::getVectorizeNdExtract() { … }::mlir::DenseBoolArrayAttr VectorizeOpGenericAdaptorBase::getScalableSizesAttr() { … }::llvm::ArrayRef<bool> VectorizeOpGenericAdaptorBase::getScalableSizes() { … }VectorizeOpAdaptor::VectorizeOpAdaptor(VectorizeOp op) : … { … }::llvm::LogicalResult VectorizeOpAdaptor::verify(::mlir::Location loc) { … }std::pair<unsigned, unsigned> VectorizeOp::getODSOperandIndexAndLength(unsigned index) { … }::mlir::MutableOperandRange VectorizeOp::getVectorSizesMutable() { … }::llvm::LogicalResult VectorizeOp::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) { … }::mlir::Attribute VectorizeOp::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) { … }llvm::hash_code VectorizeOp::computePropertiesHash(const Properties &prop) { … }std::optional<mlir::Attribute> VectorizeOp::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) { … }void VectorizeOp::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) { … }void VectorizeOp::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) { … }::llvm::LogicalResult VectorizeOp::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) { … }::llvm::LogicalResult VectorizeOp::readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state) { … }void VectorizeOp::writeProperties(::mlir::DialectBytecodeWriter &writer) { … }::llvm::ArrayRef<int64_t> VectorizeOp::getStaticVectorSizes() { … }::std::optional<bool> VectorizeOp::getVectorizeNdExtract() { … }::llvm::ArrayRef<bool> VectorizeOp::getScalableSizes() { … }void VectorizeOp::setStaticVectorSizes(::std::optional<::llvm::ArrayRef<int64_t>> attrValue) { … }void VectorizeOp::setVectorizeNdExtract(bool attrValue) { … }void VectorizeOp::setScalableSizes(::std::optional<::llvm::ArrayRef<bool>> attrValue) { … }void VectorizeOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value target, ::mlir::ValueRange vector_sizes, /*optional*/::mlir::DenseI64ArrayAttr static_vector_sizes, /*optional*/::mlir::UnitAttr vectorize_nd_extract, /*optional*/::mlir::DenseBoolArrayAttr scalable_sizes) { … }void VectorizeOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value target, ::mlir::ValueRange vector_sizes, /*optional*/::mlir::DenseI64ArrayAttr static_vector_sizes, /*optional*/::mlir::UnitAttr vectorize_nd_extract, /*optional*/::mlir::DenseBoolArrayAttr scalable_sizes) { … }void VectorizeOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value target, ::mlir::ValueRange vector_sizes, /*optional*/::llvm::ArrayRef<int64_t> static_vector_sizes, /*optional*/::mlir::UnitAttr vectorize_nd_extract, /*optional*/::llvm::ArrayRef<bool> scalable_sizes) { … }void VectorizeOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value target, ::mlir::ValueRange vector_sizes, /*optional*/::llvm::ArrayRef<int64_t> static_vector_sizes, /*optional*/::mlir::UnitAttr vectorize_nd_extract, /*optional*/::llvm::ArrayRef<bool> scalable_sizes) { … }void VectorizeOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) { … }::llvm::LogicalResult VectorizeOp::verifyInvariantsImpl() { … }::llvm::LogicalResult VectorizeOp::verifyInvariants() { … }::mlir::ParseResult VectorizeOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) { … }void VectorizeOp::print(::mlir::OpAsmPrinter &_odsPrinter) { … }MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::transform::VectorizeOp)WinogradConv2DOpGenericAdaptorBase::WinogradConv2DOpGenericAdaptorBase(WinogradConv2DOp op) : … { … }uint64_t WinogradConv2DOpGenericAdaptorBase::getM() { … }uint64_t WinogradConv2DOpGenericAdaptorBase::getR() { … }WinogradConv2DOpAdaptor::WinogradConv2DOpAdaptor(WinogradConv2DOp op) : … { … }::llvm::LogicalResult WinogradConv2DOpAdaptor::verify(::mlir::Location loc) { … }::llvm::LogicalResult WinogradConv2DOp::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) { … }::mlir::Attribute WinogradConv2DOp::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) { … }llvm::hash_code WinogradConv2DOp::computePropertiesHash(const Properties &prop) { … }std::optional<mlir::Attribute> WinogradConv2DOp::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) { … }void WinogradConv2DOp::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) { … }void WinogradConv2DOp::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) { … }::llvm::LogicalResult WinogradConv2DOp::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) { … }::llvm::LogicalResult WinogradConv2DOp::readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state) { … }void WinogradConv2DOp::writeProperties(::mlir::DialectBytecodeWriter &writer) { … }uint64_t WinogradConv2DOp::getM() { … }uint64_t WinogradConv2DOp::getR() { … }void WinogradConv2DOp::setM(uint64_t attrValue) { … }void WinogradConv2DOp::setR(uint64_t attrValue) { … }void WinogradConv2DOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type transformed, ::mlir::Value target, ::mlir::IntegerAttr m, ::mlir::IntegerAttr r) { … }void WinogradConv2DOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value target, ::mlir::IntegerAttr m, ::mlir::IntegerAttr r) { … }void WinogradConv2DOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type transformed, ::mlir::Value target, uint64_t m, uint64_t r) { … }void WinogradConv2DOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value target, uint64_t m, uint64_t r) { … }void WinogradConv2DOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) { … }::llvm::LogicalResult WinogradConv2DOp::verifyInvariantsImpl() { … }::llvm::LogicalResult WinogradConv2DOp::verifyInvariants() { … }::mlir::ParseResult WinogradConv2DOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) { … }void WinogradConv2DOp::print(::mlir::OpAsmPrinter &_odsPrinter) { … }MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::transform::WinogradConv2DOp)#endif  // GET_OP_CLASSES