LinalgMatchOps.cpp.inc | Explore in Territory

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

#ifdef GET_OP_LIST
#undef GET_OP_LIST

::mlir::transform::MatchStructuredBodyOp,
::mlir::transform::MatchStructuredClassifyContractionDimsOp,
::mlir::transform::MatchStructuredClassifyConvolutionDimsOp,
::mlir::transform::MatchStructuredDimOp,
::mlir::transform::MatchStructuredElementalBitwidthOp,
::mlir::transform::MatchStructuredInitOp,
::mlir::transform::MatchStructuredInputOp,
::mlir::transform::MatchStructuredNumInitsOp,
::mlir::transform::MatchStructuredNumInputsOp,
::mlir::transform::MatchStructuredOp,
::mlir::transform::MatchStructuredRankOp,
::mlir::transform::MatchStructuredResultOp,
::mlir::transform::MatchStructuredYieldOp
#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_LinalgMatchOps1(
    ::mlir::Operation *op, ::mlir::Type type, ::llvm::StringRef valueKind,
    unsigned valueIndex) { … }

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

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

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

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

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

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

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

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

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

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

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

//===----------------------------------------------------------------------===//
// ::mlir::transform::MatchStructuredBodyOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
MatchStructuredBodyOpGenericAdaptorBase::MatchStructuredBodyOpGenericAdaptorBase(MatchStructuredBodyOp op) : … { … }

::std::optional<uint64_t> MatchStructuredBodyOpGenericAdaptorBase::getReductionPosition() { … }

::mlir::UnitAttr MatchStructuredBodyOpGenericAdaptorBase::getPassthroughAttr() { … }

bool MatchStructuredBodyOpGenericAdaptorBase::getPassthrough() { … }

::mlir::UnitAttr MatchStructuredBodyOpGenericAdaptorBase::getElementwiseAttr() { … }

bool MatchStructuredBodyOpGenericAdaptorBase::getElementwise() { … }

::std::optional< ::mlir::ArrayAttr > MatchStructuredBodyOpGenericAdaptorBase::getContraction() { … }

} // namespace detail
MatchStructuredBodyOpAdaptor::MatchStructuredBodyOpAdaptor(MatchStructuredBodyOp op) : … { … }

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

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

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

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

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

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

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

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

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

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

::std::optional<uint64_t> MatchStructuredBodyOp::getReductionPosition() { … }

bool MatchStructuredBodyOp::getPassthrough() { … }

bool MatchStructuredBodyOp::getElementwise() { … }

::std::optional< ::mlir::ArrayAttr > MatchStructuredBodyOp::getContraction() { … }

void MatchStructuredBodyOp::setReductionPosition(::std::optional<uint64_t> attrValue) { … }

void MatchStructuredBodyOp::setPassthrough(bool attrValue) { … }

void MatchStructuredBodyOp::setElementwise(bool attrValue) { … }

void MatchStructuredBodyOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value operand_handle, /*optional*/::mlir::IntegerAttr reduction_position, /*optional*/::mlir::UnitAttr passthrough, /*optional*/::mlir::UnitAttr elementwise, /*optional*/::mlir::ArrayAttr contraction) { … }

void MatchStructuredBodyOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value operand_handle, /*optional*/::mlir::IntegerAttr reduction_position, /*optional*/::mlir::UnitAttr passthrough, /*optional*/::mlir::UnitAttr elementwise, /*optional*/::mlir::ArrayAttr contraction) { … }

void MatchStructuredBodyOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value operand_handle, /*optional*/::mlir::IntegerAttr reduction_position, /*optional*/bool passthrough, /*optional*/bool elementwise, /*optional*/::mlir::ArrayAttr contraction) { … }

void MatchStructuredBodyOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value operand_handle, /*optional*/::mlir::IntegerAttr reduction_position, /*optional*/bool passthrough, /*optional*/bool elementwise, /*optional*/::mlir::ArrayAttr contraction) { … }

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

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

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

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

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

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

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::MatchStructuredClassifyContractionDimsOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
} // namespace detail
MatchStructuredClassifyContractionDimsOpAdaptor::MatchStructuredClassifyContractionDimsOpAdaptor(MatchStructuredClassifyContractionDimsOp op) : … { … }

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

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

void MatchStructuredClassifyContractionDimsOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type batch, ::mlir::Type m, ::mlir::Type n, ::mlir::Type k, ::mlir::Value operand_handle) { … }

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

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

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

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

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

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

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

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::MatchStructuredClassifyConvolutionDimsOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
} // namespace detail
MatchStructuredClassifyConvolutionDimsOpAdaptor::MatchStructuredClassifyConvolutionDimsOpAdaptor(MatchStructuredClassifyConvolutionDimsOp op) : … { … }

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

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

void MatchStructuredClassifyConvolutionDimsOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type batch, ::mlir::Type output_image, ::mlir::Type output_channel, ::mlir::Type filter_loop, ::mlir::Type input_channel, ::mlir::Type depth, ::mlir::Type strides, ::mlir::Type dilations, ::mlir::Value operand_handle) { … }

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

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

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

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

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

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

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

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::MatchStructuredDimOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
MatchStructuredDimOpGenericAdaptorBase::MatchStructuredDimOpGenericAdaptorBase(MatchStructuredDimOp op) : … { … }

::llvm::ArrayRef<int64_t> MatchStructuredDimOpGenericAdaptorBase::getRawDimList() { … }

::mlir::UnitAttr MatchStructuredDimOpGenericAdaptorBase::getIsInvertedAttr() { … }

bool MatchStructuredDimOpGenericAdaptorBase::getIsInverted() { … }

::mlir::UnitAttr MatchStructuredDimOpGenericAdaptorBase::getIsAllAttr() { … }

bool MatchStructuredDimOpGenericAdaptorBase::getIsAll() { … }

::mlir::UnitAttr MatchStructuredDimOpGenericAdaptorBase::getParallelAttr() { … }

bool MatchStructuredDimOpGenericAdaptorBase::getParallel() { … }

::mlir::UnitAttr MatchStructuredDimOpGenericAdaptorBase::getReductionAttr() { … }

bool MatchStructuredDimOpGenericAdaptorBase::getReduction() { … }

} // namespace detail
MatchStructuredDimOpAdaptor::MatchStructuredDimOpAdaptor(MatchStructuredDimOp op) : … { … }

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

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

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

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

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

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

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

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

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

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

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

::llvm::ArrayRef<int64_t> MatchStructuredDimOp::getRawDimList() { … }

bool MatchStructuredDimOp::getIsInverted() { … }

bool MatchStructuredDimOp::getIsAll() { … }

bool MatchStructuredDimOp::getParallel() { … }

bool MatchStructuredDimOp::getReduction() { … }

void MatchStructuredDimOp::setRawDimList(::llvm::ArrayRef<int64_t> attrValue) { … }

void MatchStructuredDimOp::setIsInverted(bool attrValue) { … }

void MatchStructuredDimOp::setIsAll(bool attrValue) { … }

void MatchStructuredDimOp::setParallel(bool attrValue) { … }

void MatchStructuredDimOp::setReduction(bool attrValue) { … }

void MatchStructuredDimOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, /*optional*/::mlir::Type result, ::mlir::Value operand_handle, ::mlir::DenseI64ArrayAttr raw_dim_list, /*optional*/::mlir::UnitAttr is_inverted, /*optional*/::mlir::UnitAttr is_all, /*optional*/::mlir::UnitAttr parallel, /*optional*/::mlir::UnitAttr reduction) { … }

void MatchStructuredDimOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value operand_handle, ::mlir::DenseI64ArrayAttr raw_dim_list, /*optional*/::mlir::UnitAttr is_inverted, /*optional*/::mlir::UnitAttr is_all, /*optional*/::mlir::UnitAttr parallel, /*optional*/::mlir::UnitAttr reduction) { … }

void MatchStructuredDimOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, /*optional*/::mlir::Type result, ::mlir::Value operand_handle, ::llvm::ArrayRef<int64_t> raw_dim_list, /*optional*/bool is_inverted, /*optional*/bool is_all, /*optional*/bool parallel, /*optional*/bool reduction) { … }

void MatchStructuredDimOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value operand_handle, ::llvm::ArrayRef<int64_t> raw_dim_list, /*optional*/bool is_inverted, /*optional*/bool is_all, /*optional*/bool parallel, /*optional*/bool reduction) { … }

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

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

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

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

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

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

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::MatchStructuredElementalBitwidthOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
} // namespace detail
MatchStructuredElementalBitwidthOpAdaptor::MatchStructuredElementalBitwidthOpAdaptor(MatchStructuredElementalBitwidthOp op) : … { … }

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

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

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

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

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

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

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

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

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

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::MatchStructuredInitOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
MatchStructuredInitOpGenericAdaptorBase::MatchStructuredInitOpGenericAdaptorBase(MatchStructuredInitOp op) : … { … }

::llvm::ArrayRef<int64_t> MatchStructuredInitOpGenericAdaptorBase::getRawPositionList() { … }

::mlir::UnitAttr MatchStructuredInitOpGenericAdaptorBase::getIsInvertedAttr() { … }

bool MatchStructuredInitOpGenericAdaptorBase::getIsInverted() { … }

::mlir::UnitAttr MatchStructuredInitOpGenericAdaptorBase::getIsAllAttr() { … }

bool MatchStructuredInitOpGenericAdaptorBase::getIsAll() { … }

::mlir::UnitAttr MatchStructuredInitOpGenericAdaptorBase::getPermutationAttr() { … }

bool MatchStructuredInitOpGenericAdaptorBase::getPermutation() { … }

::mlir::UnitAttr MatchStructuredInitOpGenericAdaptorBase::getProjectedPermutationAttr() { … }

bool MatchStructuredInitOpGenericAdaptorBase::getProjectedPermutation() { … }

} // namespace detail
MatchStructuredInitOpAdaptor::MatchStructuredInitOpAdaptor(MatchStructuredInitOp op) : … { … }

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

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

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

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

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

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

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

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

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

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

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

::llvm::ArrayRef<int64_t> MatchStructuredInitOp::getRawPositionList() { … }

bool MatchStructuredInitOp::getIsInverted() { … }

bool MatchStructuredInitOp::getIsAll() { … }

bool MatchStructuredInitOp::getPermutation() { … }

bool MatchStructuredInitOp::getProjectedPermutation() { … }

void MatchStructuredInitOp::setRawPositionList(::llvm::ArrayRef<int64_t> attrValue) { … }

void MatchStructuredInitOp::setIsInverted(bool attrValue) { … }

void MatchStructuredInitOp::setIsAll(bool attrValue) { … }

void MatchStructuredInitOp::setPermutation(bool attrValue) { … }

void MatchStructuredInitOp::setProjectedPermutation(bool attrValue) { … }

void MatchStructuredInitOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, /*optional*/::mlir::Type result, ::mlir::Value operand_handle, ::mlir::DenseI64ArrayAttr raw_position_list, /*optional*/::mlir::UnitAttr is_inverted, /*optional*/::mlir::UnitAttr is_all, /*optional*/::mlir::UnitAttr permutation, /*optional*/::mlir::UnitAttr projected_permutation) { … }

void MatchStructuredInitOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value operand_handle, ::mlir::DenseI64ArrayAttr raw_position_list, /*optional*/::mlir::UnitAttr is_inverted, /*optional*/::mlir::UnitAttr is_all, /*optional*/::mlir::UnitAttr permutation, /*optional*/::mlir::UnitAttr projected_permutation) { … }

void MatchStructuredInitOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, /*optional*/::mlir::Type result, ::mlir::Value operand_handle, ::llvm::ArrayRef<int64_t> raw_position_list, /*optional*/bool is_inverted, /*optional*/bool is_all, /*optional*/bool permutation, /*optional*/bool projected_permutation) { … }

void MatchStructuredInitOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value operand_handle, ::llvm::ArrayRef<int64_t> raw_position_list, /*optional*/bool is_inverted, /*optional*/bool is_all, /*optional*/bool permutation, /*optional*/bool projected_permutation) { … }

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

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

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

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

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

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

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::MatchStructuredInputOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
MatchStructuredInputOpGenericAdaptorBase::MatchStructuredInputOpGenericAdaptorBase(MatchStructuredInputOp op) : … { … }

::llvm::ArrayRef<int64_t> MatchStructuredInputOpGenericAdaptorBase::getRawPositionList() { … }

::mlir::UnitAttr MatchStructuredInputOpGenericAdaptorBase::getIsInvertedAttr() { … }

bool MatchStructuredInputOpGenericAdaptorBase::getIsInverted() { … }

::mlir::UnitAttr MatchStructuredInputOpGenericAdaptorBase::getIsAllAttr() { … }

bool MatchStructuredInputOpGenericAdaptorBase::getIsAll() { … }

::mlir::UnitAttr MatchStructuredInputOpGenericAdaptorBase::getPermutationAttr() { … }

bool MatchStructuredInputOpGenericAdaptorBase::getPermutation() { … }

::mlir::UnitAttr MatchStructuredInputOpGenericAdaptorBase::getProjectedPermutationAttr() { … }

bool MatchStructuredInputOpGenericAdaptorBase::getProjectedPermutation() { … }

} // namespace detail
MatchStructuredInputOpAdaptor::MatchStructuredInputOpAdaptor(MatchStructuredInputOp op) : … { … }

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

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

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

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

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

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

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

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

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

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

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

::llvm::ArrayRef<int64_t> MatchStructuredInputOp::getRawPositionList() { … }

bool MatchStructuredInputOp::getIsInverted() { … }

bool MatchStructuredInputOp::getIsAll() { … }

bool MatchStructuredInputOp::getPermutation() { … }

bool MatchStructuredInputOp::getProjectedPermutation() { … }

void MatchStructuredInputOp::setRawPositionList(::llvm::ArrayRef<int64_t> attrValue) { … }

void MatchStructuredInputOp::setIsInverted(bool attrValue) { … }

void MatchStructuredInputOp::setIsAll(bool attrValue) { … }

void MatchStructuredInputOp::setPermutation(bool attrValue) { … }

void MatchStructuredInputOp::setProjectedPermutation(bool attrValue) { … }

void MatchStructuredInputOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, /*optional*/::mlir::Type result, ::mlir::Value operand_handle, ::mlir::DenseI64ArrayAttr raw_position_list, /*optional*/::mlir::UnitAttr is_inverted, /*optional*/::mlir::UnitAttr is_all, /*optional*/::mlir::UnitAttr permutation, /*optional*/::mlir::UnitAttr projected_permutation) { … }

void MatchStructuredInputOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value operand_handle, ::mlir::DenseI64ArrayAttr raw_position_list, /*optional*/::mlir::UnitAttr is_inverted, /*optional*/::mlir::UnitAttr is_all, /*optional*/::mlir::UnitAttr permutation, /*optional*/::mlir::UnitAttr projected_permutation) { … }

void MatchStructuredInputOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, /*optional*/::mlir::Type result, ::mlir::Value operand_handle, ::llvm::ArrayRef<int64_t> raw_position_list, /*optional*/bool is_inverted, /*optional*/bool is_all, /*optional*/bool permutation, /*optional*/bool projected_permutation) { … }

void MatchStructuredInputOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value operand_handle, ::llvm::ArrayRef<int64_t> raw_position_list, /*optional*/bool is_inverted, /*optional*/bool is_all, /*optional*/bool permutation, /*optional*/bool projected_permutation) { … }

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

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

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

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

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

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

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::MatchStructuredNumInitsOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
} // namespace detail
MatchStructuredNumInitsOpAdaptor::MatchStructuredNumInitsOpAdaptor(MatchStructuredNumInitsOp op) : … { … }

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

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

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

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

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

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

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

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

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

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::MatchStructuredNumInputsOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
} // namespace detail
MatchStructuredNumInputsOpAdaptor::MatchStructuredNumInputsOpAdaptor(MatchStructuredNumInputsOp op) : … { … }

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

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

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

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

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

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

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

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

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

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::MatchStructuredOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
MatchStructuredOpGenericAdaptorBase::MatchStructuredOpGenericAdaptorBase(MatchStructuredOp op) : … { … }

::std::optional<::mlir::transform::FailurePropagationMode> MatchStructuredOpGenericAdaptorBase::getFailurePropagationMode() { … }

} // namespace detail
MatchStructuredOpAdaptor::MatchStructuredOpAdaptor(MatchStructuredOp op) : … { … }

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

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

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

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

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

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

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

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

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

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

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

::std::optional<::mlir::transform::FailurePropagationMode> MatchStructuredOp::getFailurePropagationMode() { … }

void MatchStructuredOp::setFailurePropagationMode(::std::optional<::mlir::transform::FailurePropagationMode> attrValue) { … }

void MatchStructuredOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange outputs, ::mlir::Value current, /*optional*/::mlir::transform::FailurePropagationModeAttr failure_propagation_mode) { … }

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

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

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

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

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

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

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::MatchStructuredRankOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
} // namespace detail
MatchStructuredRankOpAdaptor::MatchStructuredRankOpAdaptor(MatchStructuredRankOp op) : … { … }

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

void MatchStructuredRankOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type rank, ::mlir::Value operand_handle) { … }

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

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

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

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

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

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

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

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::MatchStructuredResultOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
MatchStructuredResultOpGenericAdaptorBase::MatchStructuredResultOpGenericAdaptorBase(MatchStructuredResultOp op) : … { … }

uint64_t MatchStructuredResultOpGenericAdaptorBase::getPosition() { … }

::mlir::UnitAttr MatchStructuredResultOpGenericAdaptorBase::getAnyAttr() { … }

bool MatchStructuredResultOpGenericAdaptorBase::getAny() { … }

::mlir::UnitAttr MatchStructuredResultOpGenericAdaptorBase::getSingleAttr() { … }

bool MatchStructuredResultOpGenericAdaptorBase::getSingle() { … }

} // namespace detail
MatchStructuredResultOpAdaptor::MatchStructuredResultOpAdaptor(MatchStructuredResultOp op) : … { … }

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

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

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

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

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

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

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

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

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

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

uint64_t MatchStructuredResultOp::getPosition() { … }

bool MatchStructuredResultOp::getAny() { … }

bool MatchStructuredResultOp::getSingle() { … }

void MatchStructuredResultOp::setPosition(uint64_t attrValue) { … }

void MatchStructuredResultOp::setAny(bool attrValue) { … }

void MatchStructuredResultOp::setSingle(bool attrValue) { … }

void MatchStructuredResultOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand_handle, ::mlir::IntegerAttr position, /*optional*/::mlir::UnitAttr any, /*optional*/::mlir::UnitAttr single) { … }

void MatchStructuredResultOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value operand_handle, ::mlir::IntegerAttr position, /*optional*/::mlir::UnitAttr any, /*optional*/::mlir::UnitAttr single) { … }

void MatchStructuredResultOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand_handle, uint64_t position, /*optional*/bool any, /*optional*/bool single) { … }

void MatchStructuredResultOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value operand_handle, uint64_t position, /*optional*/bool any, /*optional*/bool single) { … }

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

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

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

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

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

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

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::MatchStructuredYieldOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
std::pair<unsigned, unsigned> MatchStructuredYieldOpGenericAdaptorBase::getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { … }

} // namespace detail
MatchStructuredYieldOpAdaptor::MatchStructuredYieldOpAdaptor(MatchStructuredYieldOp op) : … { … }

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

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

::mlir::MutableOperandRange MatchStructuredYieldOp::getHandlesMutable() { … }

void MatchStructuredYieldOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange handles) { … }

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

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

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

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

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

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


#endif  // GET_OP_CLASSES
llvm/tools/mlir/include/mlir/Dialect/Linalg/TransformOps/LinalgMatchOps.cpp.inc
