llvm/tools/mlir/include/mlir/Dialect/ArmSME/IR/ArmSMEOps.cpp.inc

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

#ifdef GET_OP_LIST
#undef GET_OP_LIST

::mlir::arm_sme::CopyTileOp,
::mlir::arm_sme::ExtractTileSliceOp,
::mlir::arm_sme::FMopa2WayOp,
::mlir::arm_sme::FMops2WayOp,
::mlir::arm_sme::GetTileOp,
::mlir::arm_sme::InsertTileSliceOp,
::mlir::arm_sme::LoadTileSliceOp,
::mlir::arm_sme::OuterProductOp,
::mlir::arm_sme::SMopa2WayOp,
::mlir::arm_sme::SMopa4WayOp,
::mlir::arm_sme::SMops2WayOp,
::mlir::arm_sme::SMops4WayOp,
::mlir::arm_sme::StoreTileSliceOp,
::mlir::arm_sme::StreamingVLOp,
::mlir::arm_sme::SuMopa4WayOp,
::mlir::arm_sme::SuMops4WayOp,
::mlir::arm_sme::TileLoadOp,
::mlir::arm_sme::TileStoreOp,
::mlir::arm_sme::UMopa2WayOp,
::mlir::arm_sme::UMopa4WayOp,
::mlir::arm_sme::UMops2WayOp,
::mlir::arm_sme::UMops4WayOp,
::mlir::arm_sme::UsMopa4WayOp,
::mlir::arm_sme::UsMops4WayOp,
::mlir::arm_sme::ZeroOp
#endif  // GET_OP_LIST

#ifdef GET_OP_CLASSES
#undef GET_OP_CLASSES


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

namespace mlir {
namespace arm_sme {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

//===----------------------------------------------------------------------===//
// ::mlir::arm_sme::CopyTileOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
} // namespace detail
CopyTileOpAdaptor::CopyTileOpAdaptor(CopyTileOp op) :{}

::llvm::LogicalResult CopyTileOpAdaptor::verify(::mlir::Location loc) {}

void CopyTileOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value tile) {}

void CopyTileOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value tile) {}

void CopyTileOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value tile) {}

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

void CopyTileOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {}

::llvm::LogicalResult CopyTileOp::verifyInvariantsImpl() {}

::llvm::LogicalResult CopyTileOp::verifyInvariants() {}

::llvm::LogicalResult CopyTileOp::inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes) {}

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

void CopyTileOp::print(::mlir::OpAsmPrinter &_odsPrinter) {}

void CopyTileOp::getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {}

} // namespace arm_sme
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::CopyTileOp)

namespace mlir {
namespace arm_sme {

//===----------------------------------------------------------------------===//
// ::mlir::arm_sme::ExtractTileSliceOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
ExtractTileSliceOpGenericAdaptorBase::ExtractTileSliceOpGenericAdaptorBase(ExtractTileSliceOp op) :{}

::mlir::arm_sme::TileSliceLayoutAttr ExtractTileSliceOpGenericAdaptorBase::getLayoutAttr() {}

::mlir::arm_sme::TileSliceLayout ExtractTileSliceOpGenericAdaptorBase::getLayout() {}

} // namespace detail
ExtractTileSliceOpAdaptor::ExtractTileSliceOpAdaptor(ExtractTileSliceOp op) :{}

::llvm::LogicalResult ExtractTileSliceOpAdaptor::verify(::mlir::Location loc) {}

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

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

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

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

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

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

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

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

void ExtractTileSliceOp::writeProperties(::mlir::DialectBytecodeWriter &writer) {}

::mlir::arm_sme::TileSliceLayout ExtractTileSliceOp::getLayout() {}

void ExtractTileSliceOp::setLayout(::mlir::arm_sme::TileSliceLayout attrValue) {}

void ExtractTileSliceOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value tile, ::mlir::Value tile_slice_index, ::mlir::arm_sme::TileSliceLayoutAttr layout) {}

void ExtractTileSliceOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value tile, ::mlir::Value tile_slice_index, ::mlir::arm_sme::TileSliceLayoutAttr layout) {}

void ExtractTileSliceOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value tile, ::mlir::Value tile_slice_index, ::mlir::arm_sme::TileSliceLayoutAttr layout) {}

void ExtractTileSliceOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value tile, ::mlir::Value tile_slice_index, ::mlir::arm_sme::TileSliceLayout layout) {}

void ExtractTileSliceOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value tile, ::mlir::Value tile_slice_index, ::mlir::arm_sme::TileSliceLayout layout) {}

void ExtractTileSliceOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value tile, ::mlir::Value tile_slice_index, ::mlir::arm_sme::TileSliceLayout layout) {}

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

void ExtractTileSliceOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {}

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

::llvm::LogicalResult ExtractTileSliceOp::verifyInvariantsImpl() {}

::llvm::LogicalResult ExtractTileSliceOp::verifyInvariants() {}

::llvm::LogicalResult ExtractTileSliceOp::inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes) {}

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

void ExtractTileSliceOp::print(::mlir::OpAsmPrinter &_odsPrinter) {}

void ExtractTileSliceOp::getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {}

} // namespace arm_sme
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::ExtractTileSliceOp)

namespace mlir {
namespace arm_sme {

//===----------------------------------------------------------------------===//
// ::mlir::arm_sme::FMopa2WayOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
FMopa2WayOpGenericAdaptorBase::FMopa2WayOpGenericAdaptorBase(FMopa2WayOp op) :{}

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

} // namespace detail
FMopa2WayOpAdaptor::FMopa2WayOpAdaptor(FMopa2WayOp op) :{}

::llvm::LogicalResult FMopa2WayOpAdaptor::verify(::mlir::Location loc) {}

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

::mlir::MutableOperandRange FMopa2WayOp::getLhsMaskMutable() {}

::mlir::MutableOperandRange FMopa2WayOp::getRhsMaskMutable() {}

::mlir::MutableOperandRange FMopa2WayOp::getAccMutable() {}

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

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

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

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

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

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

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

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

void FMopa2WayOp::writeProperties(::mlir::DialectBytecodeWriter &writer) {}

void FMopa2WayOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::Value lhsMask, /*optional*/::mlir::Value rhsMask, /*optional*/::mlir::Value acc) {}

void FMopa2WayOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::Value lhsMask, /*optional*/::mlir::Value rhsMask, /*optional*/::mlir::Value acc) {}

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

::llvm::LogicalResult FMopa2WayOp::verifyInvariantsImpl() {}

::llvm::LogicalResult FMopa2WayOp::verifyInvariants() {}

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

void FMopa2WayOp::print(::mlir::OpAsmPrinter &_odsPrinter) {}

void FMopa2WayOp::getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {}

} // namespace arm_sme
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::FMopa2WayOp)

namespace mlir {
namespace arm_sme {

//===----------------------------------------------------------------------===//
// ::mlir::arm_sme::FMops2WayOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
FMops2WayOpGenericAdaptorBase::FMops2WayOpGenericAdaptorBase(FMops2WayOp op) :{}

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

} // namespace detail
FMops2WayOpAdaptor::FMops2WayOpAdaptor(FMops2WayOp op) :{}

::llvm::LogicalResult FMops2WayOpAdaptor::verify(::mlir::Location loc) {}

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

::mlir::MutableOperandRange FMops2WayOp::getLhsMaskMutable() {}

::mlir::MutableOperandRange FMops2WayOp::getRhsMaskMutable() {}

::mlir::MutableOperandRange FMops2WayOp::getAccMutable() {}

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

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

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

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

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

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

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

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

void FMops2WayOp::writeProperties(::mlir::DialectBytecodeWriter &writer) {}

void FMops2WayOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::Value lhsMask, /*optional*/::mlir::Value rhsMask, /*optional*/::mlir::Value acc) {}

void FMops2WayOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::Value lhsMask, /*optional*/::mlir::Value rhsMask, /*optional*/::mlir::Value acc) {}

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

::llvm::LogicalResult FMops2WayOp::verifyInvariantsImpl() {}

::llvm::LogicalResult FMops2WayOp::verifyInvariants() {}

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

void FMops2WayOp::print(::mlir::OpAsmPrinter &_odsPrinter) {}

void FMops2WayOp::getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {}

} // namespace arm_sme
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::FMops2WayOp)

namespace mlir {
namespace arm_sme {

//===----------------------------------------------------------------------===//
// ::mlir::arm_sme::GetTileOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
} // namespace detail
GetTileOpAdaptor::GetTileOpAdaptor(GetTileOp op) :{}

::llvm::LogicalResult GetTileOpAdaptor::verify(::mlir::Location loc) {}

void GetTileOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type tile) {}

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

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

::llvm::LogicalResult GetTileOp::verifyInvariantsImpl() {}

::llvm::LogicalResult GetTileOp::verifyInvariants() {}

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

void GetTileOp::print(::mlir::OpAsmPrinter &_odsPrinter) {}

void GetTileOp::getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {}

} // namespace arm_sme
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::GetTileOp)

namespace mlir {
namespace arm_sme {

//===----------------------------------------------------------------------===//
// ::mlir::arm_sme::InsertTileSliceOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
InsertTileSliceOpGenericAdaptorBase::InsertTileSliceOpGenericAdaptorBase(InsertTileSliceOp op) :{}

::mlir::arm_sme::TileSliceLayoutAttr InsertTileSliceOpGenericAdaptorBase::getLayoutAttr() {}

::mlir::arm_sme::TileSliceLayout InsertTileSliceOpGenericAdaptorBase::getLayout() {}

} // namespace detail
InsertTileSliceOpAdaptor::InsertTileSliceOpAdaptor(InsertTileSliceOp op) :{}

::llvm::LogicalResult InsertTileSliceOpAdaptor::verify(::mlir::Location loc) {}

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

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

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

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

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

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

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

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

void InsertTileSliceOp::writeProperties(::mlir::DialectBytecodeWriter &writer) {}

::mlir::arm_sme::TileSliceLayout InsertTileSliceOp::getLayout() {}

void InsertTileSliceOp::setLayout(::mlir::arm_sme::TileSliceLayout attrValue) {}

void InsertTileSliceOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value vector, ::mlir::Value tile, ::mlir::Value tile_slice_index, ::mlir::arm_sme::TileSliceLayoutAttr layout) {}

void InsertTileSliceOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value vector, ::mlir::Value tile, ::mlir::Value tile_slice_index, ::mlir::arm_sme::TileSliceLayoutAttr layout) {}

void InsertTileSliceOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value vector, ::mlir::Value tile, ::mlir::Value tile_slice_index, ::mlir::arm_sme::TileSliceLayoutAttr layout) {}

void InsertTileSliceOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value vector, ::mlir::Value tile, ::mlir::Value tile_slice_index, ::mlir::arm_sme::TileSliceLayout layout) {}

void InsertTileSliceOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value vector, ::mlir::Value tile, ::mlir::Value tile_slice_index, ::mlir::arm_sme::TileSliceLayout layout) {}

void InsertTileSliceOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value vector, ::mlir::Value tile, ::mlir::Value tile_slice_index, ::mlir::arm_sme::TileSliceLayout layout) {}

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

void InsertTileSliceOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {}

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

::llvm::LogicalResult InsertTileSliceOp::verifyInvariantsImpl() {}

::llvm::LogicalResult InsertTileSliceOp::verifyInvariants() {}

::llvm::LogicalResult InsertTileSliceOp::inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes) {}

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

void InsertTileSliceOp::print(::mlir::OpAsmPrinter &_odsPrinter) {}

void InsertTileSliceOp::getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {}

} // namespace arm_sme
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::InsertTileSliceOp)

namespace mlir {
namespace arm_sme {

//===----------------------------------------------------------------------===//
// ::mlir::arm_sme::LoadTileSliceOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
LoadTileSliceOpGenericAdaptorBase::LoadTileSliceOpGenericAdaptorBase(LoadTileSliceOp op) :{}

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

::mlir::arm_sme::TileSliceLayoutAttr LoadTileSliceOpGenericAdaptorBase::getLayoutAttr() {}

::mlir::arm_sme::TileSliceLayout LoadTileSliceOpGenericAdaptorBase::getLayout() {}

} // namespace detail
LoadTileSliceOpAdaptor::LoadTileSliceOpAdaptor(LoadTileSliceOp op) :{}

::llvm::LogicalResult LoadTileSliceOpAdaptor::verify(::mlir::Location loc) {}

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

::mlir::MutableOperandRange LoadTileSliceOp::getIndicesMutable() {}

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

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

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

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

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

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

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

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

void LoadTileSliceOp::writeProperties(::mlir::DialectBytecodeWriter &writer) {}

::mlir::arm_sme::TileSliceLayout LoadTileSliceOp::getLayout() {}

void LoadTileSliceOp::setLayout(::mlir::arm_sme::TileSliceLayout attrValue) {}

void LoadTileSliceOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value base, ::mlir::Value mask, ::mlir::Value tile, ::mlir::ValueRange indices, ::mlir::Value tile_slice_index, ::mlir::arm_sme::TileSliceLayoutAttr layout) {}

void LoadTileSliceOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value base, ::mlir::Value mask, ::mlir::Value tile, ::mlir::ValueRange indices, ::mlir::Value tile_slice_index, ::mlir::arm_sme::TileSliceLayoutAttr layout) {}

void LoadTileSliceOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value base, ::mlir::Value mask, ::mlir::Value tile, ::mlir::ValueRange indices, ::mlir::Value tile_slice_index, ::mlir::arm_sme::TileSliceLayoutAttr layout) {}

void LoadTileSliceOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value base, ::mlir::Value mask, ::mlir::Value tile, ::mlir::ValueRange indices, ::mlir::Value tile_slice_index, ::mlir::arm_sme::TileSliceLayout layout) {}

void LoadTileSliceOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value base, ::mlir::Value mask, ::mlir::Value tile, ::mlir::ValueRange indices, ::mlir::Value tile_slice_index, ::mlir::arm_sme::TileSliceLayout layout) {}

void LoadTileSliceOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value base, ::mlir::Value mask, ::mlir::Value tile, ::mlir::ValueRange indices, ::mlir::Value tile_slice_index, ::mlir::arm_sme::TileSliceLayout layout) {}

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

void LoadTileSliceOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {}

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

::llvm::LogicalResult LoadTileSliceOp::verifyInvariantsImpl() {}

::llvm::LogicalResult LoadTileSliceOp::verifyInvariants() {}

::llvm::LogicalResult LoadTileSliceOp::inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes) {}

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

void LoadTileSliceOp::print(::mlir::OpAsmPrinter &_odsPrinter) {}

void LoadTileSliceOp::getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {}

} // namespace arm_sme
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::LoadTileSliceOp)

namespace mlir {
namespace arm_sme {

//===----------------------------------------------------------------------===//
// ::mlir::arm_sme::OuterProductOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
OuterProductOpGenericAdaptorBase::OuterProductOpGenericAdaptorBase(OuterProductOp op) :{}

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

::mlir::arm_sme::CombiningKindAttr OuterProductOpGenericAdaptorBase::getKindAttr() {}

::mlir::arm_sme::CombiningKind OuterProductOpGenericAdaptorBase::getKind() {}

} // namespace detail
OuterProductOpAdaptor::OuterProductOpAdaptor(OuterProductOp op) :{}

::llvm::LogicalResult OuterProductOpAdaptor::verify(::mlir::Location loc) {}

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

::mlir::MutableOperandRange OuterProductOp::getLhsMaskMutable() {}

::mlir::MutableOperandRange OuterProductOp::getRhsMaskMutable() {}

::mlir::MutableOperandRange OuterProductOp::getAccMutable() {}

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

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

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

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

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

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

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

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

void OuterProductOp::writeProperties(::mlir::DialectBytecodeWriter &writer) {}

::mlir::arm_sme::CombiningKind OuterProductOp::getKind() {}

void OuterProductOp::setKind(::mlir::arm_sme::CombiningKind attrValue) {}

void OuterProductOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::Value lhsMask, /*optional*/::mlir::Value rhsMask, /*optional*/::mlir::Value acc, ::mlir::arm_sme::CombiningKindAttr kind) {}

void OuterProductOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::Value lhsMask, /*optional*/::mlir::Value rhsMask, /*optional*/::mlir::Value acc, ::mlir::arm_sme::CombiningKindAttr kind) {}

void OuterProductOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::Value lhsMask, /*optional*/::mlir::Value rhsMask, /*optional*/::mlir::Value acc, ::mlir::arm_sme::CombiningKindAttr kind) {}

void OuterProductOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::Value lhsMask, /*optional*/::mlir::Value rhsMask, /*optional*/::mlir::Value acc, ::mlir::arm_sme::CombiningKind kind) {}

void OuterProductOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::Value lhsMask, /*optional*/::mlir::Value rhsMask, /*optional*/::mlir::Value acc, ::mlir::arm_sme::CombiningKind kind) {}

void OuterProductOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::Value lhsMask, /*optional*/::mlir::Value rhsMask, /*optional*/::mlir::Value acc, ::mlir::arm_sme::CombiningKind kind) {}

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

void OuterProductOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {}

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

::llvm::LogicalResult OuterProductOp::verifyInvariantsImpl() {}

::llvm::LogicalResult OuterProductOp::verifyInvariants() {}

::llvm::LogicalResult OuterProductOp::inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes) {}

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

void OuterProductOp::print(::mlir::OpAsmPrinter &_odsPrinter) {}

void OuterProductOp::getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {}

} // namespace arm_sme
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::OuterProductOp)

namespace mlir {
namespace arm_sme {

//===----------------------------------------------------------------------===//
// ::mlir::arm_sme::SMopa2WayOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
SMopa2WayOpGenericAdaptorBase::SMopa2WayOpGenericAdaptorBase(SMopa2WayOp op) :{}

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

} // namespace detail
SMopa2WayOpAdaptor::SMopa2WayOpAdaptor(SMopa2WayOp op) :{}

::llvm::LogicalResult SMopa2WayOpAdaptor::verify(::mlir::Location loc) {}

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

::mlir::MutableOperandRange SMopa2WayOp::getLhsMaskMutable() {}

::mlir::MutableOperandRange SMopa2WayOp::getRhsMaskMutable() {}

::mlir::MutableOperandRange SMopa2WayOp::getAccMutable() {}

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

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

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

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

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

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

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

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

void SMopa2WayOp::writeProperties(::mlir::DialectBytecodeWriter &writer) {}

void SMopa2WayOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::Value lhsMask, /*optional*/::mlir::Value rhsMask, /*optional*/::mlir::Value acc) {}

void SMopa2WayOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::Value lhsMask, /*optional*/::mlir::Value rhsMask, /*optional*/::mlir::Value acc) {}

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

::llvm::LogicalResult SMopa2WayOp::verifyInvariantsImpl() {}

::llvm::LogicalResult SMopa2WayOp::verifyInvariants() {}

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

void SMopa2WayOp::print(::mlir::OpAsmPrinter &_odsPrinter) {}

void SMopa2WayOp::getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {}

} // namespace arm_sme
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::SMopa2WayOp)

namespace mlir {
namespace arm_sme {

//===----------------------------------------------------------------------===//
// ::mlir::arm_sme::SMopa4WayOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
SMopa4WayOpGenericAdaptorBase::SMopa4WayOpGenericAdaptorBase(SMopa4WayOp op) :{}

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

} // namespace detail
SMopa4WayOpAdaptor::SMopa4WayOpAdaptor(SMopa4WayOp op) :{}

::llvm::LogicalResult SMopa4WayOpAdaptor::verify(::mlir::Location loc) {}

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

::mlir::MutableOperandRange SMopa4WayOp::getLhsMaskMutable() {}

::mlir::MutableOperandRange SMopa4WayOp::getRhsMaskMutable() {}

::mlir::MutableOperandRange SMopa4WayOp::getAccMutable() {}

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

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

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

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

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

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

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

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

void SMopa4WayOp::writeProperties(::mlir::DialectBytecodeWriter &writer) {}

void SMopa4WayOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::Value lhsMask, /*optional*/::mlir::Value rhsMask, /*optional*/::mlir::Value acc) {}

void SMopa4WayOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::Value lhsMask, /*optional*/::mlir::Value rhsMask, /*optional*/::mlir::Value acc) {}

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

::llvm::LogicalResult SMopa4WayOp::verifyInvariantsImpl() {}

::llvm::LogicalResult SMopa4WayOp::verifyInvariants() {}

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

void SMopa4WayOp::print(::mlir::OpAsmPrinter &_odsPrinter) {}

void SMopa4WayOp::getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {}

} // namespace arm_sme
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::SMopa4WayOp)

namespace mlir {
namespace arm_sme {

//===----------------------------------------------------------------------===//
// ::mlir::arm_sme::SMops2WayOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
SMops2WayOpGenericAdaptorBase::SMops2WayOpGenericAdaptorBase(SMops2WayOp op) :{}

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

} // namespace detail
SMops2WayOpAdaptor::SMops2WayOpAdaptor(SMops2WayOp op) :{}

::llvm::LogicalResult SMops2WayOpAdaptor::verify(::mlir::Location loc) {}

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

::mlir::MutableOperandRange SMops2WayOp::getLhsMaskMutable() {}

::mlir::MutableOperandRange SMops2WayOp::getRhsMaskMutable() {}

::mlir::MutableOperandRange SMops2WayOp::getAccMutable() {}

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

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

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

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

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

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

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

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

void SMops2WayOp::writeProperties(::mlir::DialectBytecodeWriter &writer) {}

void SMops2WayOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::Value lhsMask, /*optional*/::mlir::Value rhsMask, /*optional*/::mlir::Value acc) {}

void SMops2WayOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::Value lhsMask, /*optional*/::mlir::Value rhsMask, /*optional*/::mlir::Value acc) {}

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

::llvm::LogicalResult SMops2WayOp::verifyInvariantsImpl() {}

::llvm::LogicalResult SMops2WayOp::verifyInvariants() {}

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

void SMops2WayOp::print(::mlir::OpAsmPrinter &_odsPrinter) {}

void SMops2WayOp::getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {}

} // namespace arm_sme
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::SMops2WayOp)

namespace mlir {
namespace arm_sme {

//===----------------------------------------------------------------------===//
// ::mlir::arm_sme::SMops4WayOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
SMops4WayOpGenericAdaptorBase::SMops4WayOpGenericAdaptorBase(SMops4WayOp op) :{}

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

} // namespace detail
SMops4WayOpAdaptor::SMops4WayOpAdaptor(SMops4WayOp op) :{}

::llvm::LogicalResult SMops4WayOpAdaptor::verify(::mlir::Location loc) {}

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

::mlir::MutableOperandRange SMops4WayOp::getLhsMaskMutable() {}

::mlir::MutableOperandRange SMops4WayOp::getRhsMaskMutable() {}

::mlir::MutableOperandRange SMops4WayOp::getAccMutable() {}

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

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

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

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

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

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

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

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

void SMops4WayOp::writeProperties(::mlir::DialectBytecodeWriter &writer) {}

void SMops4WayOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::Value lhsMask, /*optional*/::mlir::Value rhsMask, /*optional*/::mlir::Value acc) {}

void SMops4WayOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::Value lhsMask, /*optional*/::mlir::Value rhsMask, /*optional*/::mlir::Value acc) {}

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

::llvm::LogicalResult SMops4WayOp::verifyInvariantsImpl() {}

::llvm::LogicalResult SMops4WayOp::verifyInvariants() {}

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

void SMops4WayOp::print(::mlir::OpAsmPrinter &_odsPrinter) {}

void SMops4WayOp::getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {}

} // namespace arm_sme
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::SMops4WayOp)

namespace mlir {
namespace arm_sme {

//===----------------------------------------------------------------------===//
// ::mlir::arm_sme::StoreTileSliceOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
StoreTileSliceOpGenericAdaptorBase::StoreTileSliceOpGenericAdaptorBase(StoreTileSliceOp op) :{}

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

::mlir::arm_sme::TileSliceLayoutAttr StoreTileSliceOpGenericAdaptorBase::getLayoutAttr() {}

::mlir::arm_sme::TileSliceLayout StoreTileSliceOpGenericAdaptorBase::getLayout() {}

} // namespace detail
StoreTileSliceOpAdaptor::StoreTileSliceOpAdaptor(StoreTileSliceOp op) :{}

::llvm::LogicalResult StoreTileSliceOpAdaptor::verify(::mlir::Location loc) {}

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

::mlir::MutableOperandRange StoreTileSliceOp::getIndicesMutable() {}

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

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

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

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

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

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

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

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

void StoreTileSliceOp::writeProperties(::mlir::DialectBytecodeWriter &writer) {}

::mlir::arm_sme::TileSliceLayout StoreTileSliceOp::getLayout() {}

void StoreTileSliceOp::setLayout(::mlir::arm_sme::TileSliceLayout attrValue) {}

void StoreTileSliceOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value tile, ::mlir::Value tile_slice_index, ::mlir::Value mask, ::mlir::Value base, ::mlir::ValueRange indices, ::mlir::arm_sme::TileSliceLayoutAttr layout) {}

void StoreTileSliceOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value tile, ::mlir::Value tile_slice_index, ::mlir::Value mask, ::mlir::Value base, ::mlir::ValueRange indices, ::mlir::arm_sme::TileSliceLayoutAttr layout) {}

void StoreTileSliceOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value tile, ::mlir::Value tile_slice_index, ::mlir::Value mask, ::mlir::Value base, ::mlir::ValueRange indices, ::mlir::arm_sme::TileSliceLayout layout) {}

void StoreTileSliceOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value tile, ::mlir::Value tile_slice_index, ::mlir::Value mask, ::mlir::Value base, ::mlir::ValueRange indices, ::mlir::arm_sme::TileSliceLayout layout) {}

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

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

::llvm::LogicalResult StoreTileSliceOp::verifyInvariantsImpl() {}

::llvm::LogicalResult StoreTileSliceOp::verifyInvariants() {}

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

void StoreTileSliceOp::print(::mlir::OpAsmPrinter &_odsPrinter) {}

void StoreTileSliceOp::getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {}

} // namespace arm_sme
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::StoreTileSliceOp)

namespace mlir {
namespace arm_sme {

//===----------------------------------------------------------------------===//
// ::mlir::arm_sme::StreamingVLOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
StreamingVLOpGenericAdaptorBase::StreamingVLOpGenericAdaptorBase(StreamingVLOp op) :{}

::mlir::arm_sme::TypeSize StreamingVLOpGenericAdaptorBase::getTypeSize() {}

} // namespace detail
StreamingVLOpAdaptor::StreamingVLOpAdaptor(StreamingVLOp op) :{}

::llvm::LogicalResult StreamingVLOpAdaptor::verify(::mlir::Location loc) {}

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

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

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

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

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

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

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

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

void StreamingVLOp::writeProperties(::mlir::DialectBytecodeWriter &writer) {}

::mlir::arm_sme::TypeSize StreamingVLOp::getTypeSize() {}

void StreamingVLOp::setTypeSize(::mlir::arm_sme::TypeSize attrValue) {}

void StreamingVLOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type resultType0, ::mlir::arm_sme::TypeSizeAttr type_size) {}

void StreamingVLOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::arm_sme::TypeSizeAttr type_size) {}

void StreamingVLOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::arm_sme::TypeSizeAttr type_size) {}

void StreamingVLOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type resultType0, ::mlir::arm_sme::TypeSize type_size) {}

void StreamingVLOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::arm_sme::TypeSize type_size) {}

void StreamingVLOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::arm_sme::TypeSize type_size) {}

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

void StreamingVLOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {}

::llvm::LogicalResult StreamingVLOp::verifyInvariantsImpl() {}

::llvm::LogicalResult StreamingVLOp::verifyInvariants() {}

::llvm::LogicalResult StreamingVLOp::inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes) {}

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

void StreamingVLOp::print(::mlir::OpAsmPrinter &_odsPrinter) {}

void StreamingVLOp::getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {}

} // namespace arm_sme
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::StreamingVLOp)

namespace mlir {
namespace arm_sme {

//===----------------------------------------------------------------------===//
// ::mlir::arm_sme::SuMopa4WayOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
SuMopa4WayOpGenericAdaptorBase::SuMopa4WayOpGenericAdaptorBase(SuMopa4WayOp op) :{}

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

} // namespace detail
SuMopa4WayOpAdaptor::SuMopa4WayOpAdaptor(SuMopa4WayOp op) :{}

::llvm::LogicalResult SuMopa4WayOpAdaptor::verify(::mlir::Location loc) {}

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

::mlir::MutableOperandRange SuMopa4WayOp::getLhsMaskMutable() {}

::mlir::MutableOperandRange SuMopa4WayOp::getRhsMaskMutable() {}

::mlir::MutableOperandRange SuMopa4WayOp::getAccMutable() {}

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

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

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

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

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

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

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

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

void SuMopa4WayOp::writeProperties(::mlir::DialectBytecodeWriter &writer) {}

void SuMopa4WayOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::Value lhsMask, /*optional*/::mlir::Value rhsMask, /*optional*/::mlir::Value acc) {}

void SuMopa4WayOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::Value lhsMask, /*optional*/::mlir::Value rhsMask, /*optional*/::mlir::Value acc) {}

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

::llvm::LogicalResult SuMopa4WayOp::verifyInvariantsImpl() {}

::llvm::LogicalResult SuMopa4WayOp::verifyInvariants() {}

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

void SuMopa4WayOp::print(::mlir::OpAsmPrinter &_odsPrinter) {}

void SuMopa4WayOp::getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {}

} // namespace arm_sme
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::SuMopa4WayOp)

namespace mlir {
namespace arm_sme {

//===----------------------------------------------------------------------===//
// ::mlir::arm_sme::SuMops4WayOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
SuMops4WayOpGenericAdaptorBase::SuMops4WayOpGenericAdaptorBase(SuMops4WayOp op) :{}

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

} // namespace detail
SuMops4WayOpAdaptor::SuMops4WayOpAdaptor(SuMops4WayOp op) :{}

::llvm::LogicalResult SuMops4WayOpAdaptor::verify(::mlir::Location loc) {}

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

::mlir::MutableOperandRange SuMops4WayOp::getLhsMaskMutable() {}

::mlir::MutableOperandRange SuMops4WayOp::getRhsMaskMutable() {}

::mlir::MutableOperandRange SuMops4WayOp::getAccMutable() {}

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

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

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

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

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

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

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

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

void SuMops4WayOp::writeProperties(::mlir::DialectBytecodeWriter &writer) {}

void SuMops4WayOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::Value lhsMask, /*optional*/::mlir::Value rhsMask, /*optional*/::mlir::Value acc) {}

void SuMops4WayOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::Value lhsMask, /*optional*/::mlir::Value rhsMask, /*optional*/::mlir::Value acc) {}

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

::llvm::LogicalResult SuMops4WayOp::verifyInvariantsImpl() {}

::llvm::LogicalResult SuMops4WayOp::verifyInvariants() {}

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

void SuMops4WayOp::print(::mlir::OpAsmPrinter &_odsPrinter) {}

void SuMops4WayOp::getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {}

} // namespace arm_sme
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::SuMops4WayOp)

namespace mlir {
namespace arm_sme {

//===----------------------------------------------------------------------===//
// ::mlir::arm_sme::TileLoadOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
TileLoadOpGenericAdaptorBase::TileLoadOpGenericAdaptorBase(TileLoadOp op) :{}

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

::mlir::arm_sme::TileSliceLayoutAttr TileLoadOpGenericAdaptorBase::getLayoutAttr() {}

::mlir::arm_sme::TileSliceLayout TileLoadOpGenericAdaptorBase::getLayout() {}

} // namespace detail
TileLoadOpAdaptor::TileLoadOpAdaptor(TileLoadOp op) :{}

::llvm::LogicalResult TileLoadOpAdaptor::verify(::mlir::Location loc) {}

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

::mlir::MutableOperandRange TileLoadOp::getIndicesMutable() {}

::mlir::MutableOperandRange TileLoadOp::getPaddingMutable() {}

::mlir::MutableOperandRange TileLoadOp::getMaskMutable() {}

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

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

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

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

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

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

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

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

void TileLoadOp::writeProperties(::mlir::DialectBytecodeWriter &writer) {}

::mlir::arm_sme::TileSliceLayout TileLoadOp::getLayout() {}

void TileLoadOp::setLayout(::mlir::arm_sme::TileSliceLayout attrValue) {}

void TileLoadOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, VectorType resultType, Value base, ValueRange indices, TileSliceLayout layout) {}

void TileLoadOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, VectorType resultType, Value base, ValueRange indices) {}

void TileLoadOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value base, ::mlir::ValueRange indices, /*optional*/::mlir::Value padding, /*optional*/::mlir::Value mask, ::mlir::arm_sme::TileSliceLayoutAttr layout) {}

void TileLoadOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value base, ::mlir::ValueRange indices, /*optional*/::mlir::Value padding, /*optional*/::mlir::Value mask, ::mlir::arm_sme::TileSliceLayoutAttr layout) {}

void TileLoadOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value base, ::mlir::ValueRange indices, /*optional*/::mlir::Value padding, /*optional*/::mlir::Value mask, ::mlir::arm_sme::TileSliceLayout layout) {}

void TileLoadOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value base, ::mlir::ValueRange indices, /*optional*/::mlir::Value padding, /*optional*/::mlir::Value mask, ::mlir::arm_sme::TileSliceLayout layout) {}

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

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

::llvm::LogicalResult TileLoadOp::verifyInvariantsImpl() {}

::llvm::LogicalResult TileLoadOp::verifyInvariants() {}

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

void TileLoadOp::print(::mlir::OpAsmPrinter &_odsPrinter) {}

void TileLoadOp::getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {}

} // namespace arm_sme
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::TileLoadOp)

namespace mlir {
namespace arm_sme {

//===----------------------------------------------------------------------===//
// ::mlir::arm_sme::TileStoreOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
TileStoreOpGenericAdaptorBase::TileStoreOpGenericAdaptorBase(TileStoreOp op) :{}

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

::mlir::arm_sme::TileSliceLayoutAttr TileStoreOpGenericAdaptorBase::getLayoutAttr() {}

::mlir::arm_sme::TileSliceLayout TileStoreOpGenericAdaptorBase::getLayout() {}

} // namespace detail
TileStoreOpAdaptor::TileStoreOpAdaptor(TileStoreOp op) :{}

::llvm::LogicalResult TileStoreOpAdaptor::verify(::mlir::Location loc) {}

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

::mlir::MutableOperandRange TileStoreOp::getIndicesMutable() {}

::mlir::MutableOperandRange TileStoreOp::getMaskMutable() {}

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

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

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

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

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

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

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

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

void TileStoreOp::writeProperties(::mlir::DialectBytecodeWriter &writer) {}

::mlir::arm_sme::TileSliceLayout TileStoreOp::getLayout() {}

void TileStoreOp::setLayout(::mlir::arm_sme::TileSliceLayout attrValue) {}

void TileStoreOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Value valueToStore, Value base, ValueRange indices) {}

void TileStoreOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value valueToStore, ::mlir::Value base, ::mlir::ValueRange indices, /*optional*/::mlir::Value mask, ::mlir::arm_sme::TileSliceLayoutAttr layout) {}

void TileStoreOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value valueToStore, ::mlir::Value base, ::mlir::ValueRange indices, /*optional*/::mlir::Value mask, ::mlir::arm_sme::TileSliceLayoutAttr layout) {}

void TileStoreOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value valueToStore, ::mlir::Value base, ::mlir::ValueRange indices, /*optional*/::mlir::Value mask, ::mlir::arm_sme::TileSliceLayout layout) {}

void TileStoreOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value valueToStore, ::mlir::Value base, ::mlir::ValueRange indices, /*optional*/::mlir::Value mask, ::mlir::arm_sme::TileSliceLayout layout) {}

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

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

::llvm::LogicalResult TileStoreOp::verifyInvariantsImpl() {}

::llvm::LogicalResult TileStoreOp::verifyInvariants() {}

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

void TileStoreOp::print(::mlir::OpAsmPrinter &_odsPrinter) {}

void TileStoreOp::getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {}

} // namespace arm_sme
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::TileStoreOp)

namespace mlir {
namespace arm_sme {

//===----------------------------------------------------------------------===//
// ::mlir::arm_sme::UMopa2WayOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
UMopa2WayOpGenericAdaptorBase::UMopa2WayOpGenericAdaptorBase(UMopa2WayOp op) :{}

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

} // namespace detail
UMopa2WayOpAdaptor::UMopa2WayOpAdaptor(UMopa2WayOp op) :{}

::llvm::LogicalResult UMopa2WayOpAdaptor::verify(::mlir::Location loc) {}

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

::mlir::MutableOperandRange UMopa2WayOp::getLhsMaskMutable() {}

::mlir::MutableOperandRange UMopa2WayOp::getRhsMaskMutable() {}

::mlir::MutableOperandRange UMopa2WayOp::getAccMutable() {}

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

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

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

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

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

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

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

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

void UMopa2WayOp::writeProperties(::mlir::DialectBytecodeWriter &writer) {}

void UMopa2WayOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::Value lhsMask, /*optional*/::mlir::Value rhsMask, /*optional*/::mlir::Value acc) {}

void UMopa2WayOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::Value lhsMask, /*optional*/::mlir::Value rhsMask, /*optional*/::mlir::Value acc) {}

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

::llvm::LogicalResult UMopa2WayOp::verifyInvariantsImpl() {}

::llvm::LogicalResult UMopa2WayOp::verifyInvariants() {}

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

void UMopa2WayOp::print(::mlir::OpAsmPrinter &_odsPrinter) {}

void UMopa2WayOp::getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {}

} // namespace arm_sme
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::UMopa2WayOp)

namespace mlir {
namespace arm_sme {

//===----------------------------------------------------------------------===//
// ::mlir::arm_sme::UMopa4WayOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
UMopa4WayOpGenericAdaptorBase::UMopa4WayOpGenericAdaptorBase(UMopa4WayOp op) :{}

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

} // namespace detail
UMopa4WayOpAdaptor::UMopa4WayOpAdaptor(UMopa4WayOp op) :{}

::llvm::LogicalResult UMopa4WayOpAdaptor::verify(::mlir::Location loc) {}

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

::mlir::MutableOperandRange UMopa4WayOp::getLhsMaskMutable() {}

::mlir::MutableOperandRange UMopa4WayOp::getRhsMaskMutable() {}

::mlir::MutableOperandRange UMopa4WayOp::getAccMutable() {}

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

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

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

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

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

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

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

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

void UMopa4WayOp::writeProperties(::mlir::DialectBytecodeWriter &writer) {}

void UMopa4WayOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::Value lhsMask, /*optional*/::mlir::Value rhsMask, /*optional*/::mlir::Value acc) {}

void UMopa4WayOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::Value lhsMask, /*optional*/::mlir::Value rhsMask, /*optional*/::mlir::Value acc) {}

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

::llvm::LogicalResult UMopa4WayOp::verifyInvariantsImpl() {}

::llvm::LogicalResult UMopa4WayOp::verifyInvariants() {}

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

void UMopa4WayOp::print(::mlir::OpAsmPrinter &_odsPrinter) {}void UMopa4WayOp::getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {}MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::UMopa4WayOp)UMops2WayOpGenericAdaptorBase::UMops2WayOpGenericAdaptorBase(UMops2WayOp op) :{}std::pair<unsigned, unsigned> UMops2WayOpGenericAdaptorBase::getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {}UMops2WayOpAdaptor::UMops2WayOpAdaptor(UMops2WayOp op) :{}::llvm::LogicalResult UMops2WayOpAdaptor::verify(::mlir::Location loc) {}std::pair<unsigned, unsigned> UMops2WayOp::getODSOperandIndexAndLength(unsigned index) {}::mlir::MutableOperandRange UMops2WayOp::getLhsMaskMutable() {}::mlir::MutableOperandRange UMops2WayOp::getRhsMaskMutable() {}::mlir::MutableOperandRange UMops2WayOp::getAccMutable() {}::llvm::LogicalResult UMops2WayOp::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {}::mlir::Attribute UMops2WayOp::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) {}llvm::hash_code UMops2WayOp::computePropertiesHash(const Properties &prop) {}std::optional<mlir::Attribute> UMops2WayOp::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) {}void UMops2WayOp::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) {}void UMops2WayOp::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) {}::llvm::LogicalResult UMops2WayOp::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {}::llvm::LogicalResult UMops2WayOp::readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state) {}void UMops2WayOp::writeProperties(::mlir::DialectBytecodeWriter &writer) {}void UMops2WayOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::Value lhsMask, /*optional*/::mlir::Value rhsMask, /*optional*/::mlir::Value acc) {}void UMops2WayOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::Value lhsMask, /*optional*/::mlir::Value rhsMask, /*optional*/::mlir::Value acc) {}void UMops2WayOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {}::llvm::LogicalResult UMops2WayOp::verifyInvariantsImpl() {}::llvm::LogicalResult UMops2WayOp::verifyInvariants() {}::mlir::ParseResult UMops2WayOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {}void UMops2WayOp::print(::mlir::OpAsmPrinter &_odsPrinter) {}void UMops2WayOp::getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {}MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::UMops2WayOp)UMops4WayOpGenericAdaptorBase::UMops4WayOpGenericAdaptorBase(UMops4WayOp op) :{}std::pair<unsigned, unsigned> UMops4WayOpGenericAdaptorBase::getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {}UMops4WayOpAdaptor::UMops4WayOpAdaptor(UMops4WayOp op) :{}::llvm::LogicalResult UMops4WayOpAdaptor::verify(::mlir::Location loc) {}std::pair<unsigned, unsigned> UMops4WayOp::getODSOperandIndexAndLength(unsigned index) {}::mlir::MutableOperandRange UMops4WayOp::getLhsMaskMutable() {}::mlir::MutableOperandRange UMops4WayOp::getRhsMaskMutable() {}::mlir::MutableOperandRange UMops4WayOp::getAccMutable() {}::llvm::LogicalResult UMops4WayOp::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {}::mlir::Attribute UMops4WayOp::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) {}llvm::hash_code UMops4WayOp::computePropertiesHash(const Properties &prop) {}std::optional<mlir::Attribute> UMops4WayOp::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) {}void UMops4WayOp::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) {}void UMops4WayOp::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) {}::llvm::LogicalResult UMops4WayOp::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {}::llvm::LogicalResult UMops4WayOp::readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state) {}void UMops4WayOp::writeProperties(::mlir::DialectBytecodeWriter &writer) {}void UMops4WayOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::Value lhsMask, /*optional*/::mlir::Value rhsMask, /*optional*/::mlir::Value acc) {}void UMops4WayOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::Value lhsMask, /*optional*/::mlir::Value rhsMask, /*optional*/::mlir::Value acc) {}void UMops4WayOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {}::llvm::LogicalResult UMops4WayOp::verifyInvariantsImpl() {}::llvm::LogicalResult UMops4WayOp::verifyInvariants() {}::mlir::ParseResult UMops4WayOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {}void UMops4WayOp::print(::mlir::OpAsmPrinter &_odsPrinter) {}void UMops4WayOp::getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {}MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::UMops4WayOp)UsMopa4WayOpGenericAdaptorBase::UsMopa4WayOpGenericAdaptorBase(UsMopa4WayOp op) :{}std::pair<unsigned, unsigned> UsMopa4WayOpGenericAdaptorBase::getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {}UsMopa4WayOpAdaptor::UsMopa4WayOpAdaptor(UsMopa4WayOp op) :{}::llvm::LogicalResult UsMopa4WayOpAdaptor::verify(::mlir::Location loc) {}std::pair<unsigned, unsigned> UsMopa4WayOp::getODSOperandIndexAndLength(unsigned index) {}::mlir::MutableOperandRange UsMopa4WayOp::getLhsMaskMutable() {}::mlir::MutableOperandRange UsMopa4WayOp::getRhsMaskMutable() {}::mlir::MutableOperandRange UsMopa4WayOp::getAccMutable() {}::llvm::LogicalResult UsMopa4WayOp::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {}::mlir::Attribute UsMopa4WayOp::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) {}llvm::hash_code UsMopa4WayOp::computePropertiesHash(const Properties &prop) {}std::optional<mlir::Attribute> UsMopa4WayOp::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) {}void UsMopa4WayOp::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) {}void UsMopa4WayOp::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) {}::llvm::LogicalResult UsMopa4WayOp::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {}::llvm::LogicalResult UsMopa4WayOp::readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state) {}void UsMopa4WayOp::writeProperties(::mlir::DialectBytecodeWriter &writer) {}void UsMopa4WayOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::Value lhsMask, /*optional*/::mlir::Value rhsMask, /*optional*/::mlir::Value acc) {}void UsMopa4WayOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::Value lhsMask, /*optional*/::mlir::Value rhsMask, /*optional*/::mlir::Value acc) {}void UsMopa4WayOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {}::llvm::LogicalResult UsMopa4WayOp::verifyInvariantsImpl() {}::llvm::LogicalResult UsMopa4WayOp::verifyInvariants() {}::mlir::ParseResult UsMopa4WayOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {}void UsMopa4WayOp::print(::mlir::OpAsmPrinter &_odsPrinter) {}void UsMopa4WayOp::getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {}MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::UsMopa4WayOp)UsMops4WayOpGenericAdaptorBase::UsMops4WayOpGenericAdaptorBase(UsMops4WayOp op) :{}std::pair<unsigned, unsigned> UsMops4WayOpGenericAdaptorBase::getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {}UsMops4WayOpAdaptor::UsMops4WayOpAdaptor(UsMops4WayOp op) :{}::llvm::LogicalResult UsMops4WayOpAdaptor::verify(::mlir::Location loc) {}std::pair<unsigned, unsigned> UsMops4WayOp::getODSOperandIndexAndLength(unsigned index) {}::mlir::MutableOperandRange UsMops4WayOp::getLhsMaskMutable() {}::mlir::MutableOperandRange UsMops4WayOp::getRhsMaskMutable() {}::mlir::MutableOperandRange UsMops4WayOp::getAccMutable() {}::llvm::LogicalResult UsMops4WayOp::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {}::mlir::Attribute UsMops4WayOp::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) {}llvm::hash_code UsMops4WayOp::computePropertiesHash(const Properties &prop) {}std::optional<mlir::Attribute> UsMops4WayOp::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) {}void UsMops4WayOp::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) {}void UsMops4WayOp::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) {}::llvm::LogicalResult UsMops4WayOp::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {}::llvm::LogicalResult UsMops4WayOp::readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state) {}void UsMops4WayOp::writeProperties(::mlir::DialectBytecodeWriter &writer) {}void UsMops4WayOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::Value lhsMask, /*optional*/::mlir::Value rhsMask, /*optional*/::mlir::Value acc) {}void UsMops4WayOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::Value lhsMask, /*optional*/::mlir::Value rhsMask, /*optional*/::mlir::Value acc) {}void UsMops4WayOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {}::llvm::LogicalResult UsMops4WayOp::verifyInvariantsImpl() {}::llvm::LogicalResult UsMops4WayOp::verifyInvariants() {}::mlir::ParseResult UsMops4WayOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {}void UsMops4WayOp::print(::mlir::OpAsmPrinter &_odsPrinter) {}void UsMops4WayOp::getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {}MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::UsMops4WayOp)ZeroOpAdaptor::ZeroOpAdaptor(ZeroOp op) :{}::llvm::LogicalResult ZeroOpAdaptor::verify(::mlir::Location loc) {}void ZeroOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res) {}void ZeroOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes) {}void ZeroOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {}::llvm::LogicalResult ZeroOp::verifyInvariantsImpl() {}::llvm::LogicalResult ZeroOp::verifyInvariants() {}::mlir::ParseResult ZeroOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {}void ZeroOp::print(::mlir::OpAsmPrinter &_odsPrinter) {}void ZeroOp::getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {}MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::ZeroOp)#endif  // GET_OP_CLASSES