llvm/tools/mlir/include/mlir/Dialect/XeGPU/IR/XeGPU.cpp.inc

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

#ifdef GET_OP_LIST
#undef GET_OP_LIST

::mlir::xegpu::AllocNbarrierOp,
::mlir::xegpu::AtomicRMWOp,
::mlir::xegpu::CreateDescOp,
::mlir::xegpu::CreateNdDescOp,
::mlir::xegpu::DpasOp,
::mlir::xegpu::FenceOp,
::mlir::xegpu::InitNbarrierOp,
::mlir::xegpu::LoadGatherOp,
::mlir::xegpu::LoadNdOp,
::mlir::xegpu::NbarrierArriveOp,
::mlir::xegpu::NbarrierWaitOp,
::mlir::xegpu::PrefetchNdOp,
::mlir::xegpu::PrefetchOp,
::mlir::xegpu::StoreNdOp,
::mlir::xegpu::StoreScatterOp,
::mlir::xegpu::UpdateNdOffsetOp,
::mlir::xegpu::UpdateOffsetOp
#endif  // GET_OP_LIST

#ifdef GET_OP_CLASSES
#undef GET_OP_CLASSES


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

namespace mlir {
namespace xegpu {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

//===----------------------------------------------------------------------===//
// ::mlir::xegpu::AllocNbarrierOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
AllocNbarrierOpGenericAdaptorBase::AllocNbarrierOpGenericAdaptorBase(AllocNbarrierOp op) : … { … }

uint64_t AllocNbarrierOpGenericAdaptorBase::getNbarrierNum() { … }

} // namespace detail
AllocNbarrierOpAdaptor::AllocNbarrierOpAdaptor(AllocNbarrierOp op) : … { … }

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

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

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

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

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

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

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

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

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

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

uint64_t AllocNbarrierOp::getNbarrierNum() { … }

void AllocNbarrierOp::setNbarrierNum(uint64_t attrValue) { … }

void AllocNbarrierOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::IntegerAttr nbarrier_num) { … }

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

void AllocNbarrierOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, uint64_t nbarrier_num) { … }

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

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

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

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

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

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

} // namespace xegpu
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::xegpu::AllocNbarrierOp)

namespace mlir {
namespace xegpu {

//===----------------------------------------------------------------------===//
// ::mlir::xegpu::AtomicRMWOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
AtomicRMWOpGenericAdaptorBase::AtomicRMWOpGenericAdaptorBase(AtomicRMWOp op) : … { … }

::mlir::arith::AtomicRMWKind AtomicRMWOpGenericAdaptorBase::getKind() { … }

} // namespace detail
AtomicRMWOpAdaptor::AtomicRMWOpAdaptor(AtomicRMWOp op) : … { … }

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

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

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

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

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

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

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

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

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

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

::mlir::arith::AtomicRMWKind AtomicRMWOp::getKind() { … }

void AtomicRMWOp::setKind(::mlir::arith::AtomicRMWKind attrValue) { … }

void AtomicRMWOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::arith::AtomicRMWKindAttr kind, ::mlir::Value tensorDesc, ::mlir::Value mask, ::mlir::Value value) { … }

void AtomicRMWOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::arith::AtomicRMWKindAttr kind, ::mlir::Value tensorDesc, ::mlir::Value mask, ::mlir::Value value) { … }

void AtomicRMWOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::arith::AtomicRMWKind kind, ::mlir::Value tensorDesc, ::mlir::Value mask, ::mlir::Value value) { … }

void AtomicRMWOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::arith::AtomicRMWKind kind, ::mlir::Value tensorDesc, ::mlir::Value mask, ::mlir::Value value) { … }

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

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

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

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

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

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

} // namespace xegpu
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::xegpu::AtomicRMWOp)

namespace mlir {
namespace xegpu {

//===----------------------------------------------------------------------===//
// ::mlir::xegpu::CreateDescOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
} // namespace detail
CreateDescOpAdaptor::CreateDescOpAdaptor(CreateDescOp op) : … { … }

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

void CreateDescOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type TensorDesc, ::mlir::Value source, ::mlir::Value offsets) { … }

void CreateDescOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value source, ::mlir::Value offsets) { … }

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

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

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

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

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

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

} // namespace xegpu
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::xegpu::CreateDescOp)

namespace mlir {
namespace xegpu {

//===----------------------------------------------------------------------===//
// ::mlir::xegpu::CreateNdDescOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
CreateNdDescOpGenericAdaptorBase::CreateNdDescOpGenericAdaptorBase(CreateNdDescOp op) : … { … }

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

::llvm::ArrayRef<int64_t> CreateNdDescOpGenericAdaptorBase::getConstOffsets() { … }

::std::optional<::llvm::ArrayRef<int64_t>> CreateNdDescOpGenericAdaptorBase::getConstShape() { … }

::std::optional<::llvm::ArrayRef<int64_t>> CreateNdDescOpGenericAdaptorBase::getConstStrides() { … }

} // namespace detail
CreateNdDescOpAdaptor::CreateNdDescOpAdaptor(CreateNdDescOp op) : … { … }

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

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

::mlir::MutableOperandRange CreateNdDescOp::getOffsetsMutable() { … }

::mlir::MutableOperandRange CreateNdDescOp::getShapeMutable() { … }

::mlir::MutableOperandRange CreateNdDescOp::getStridesMutable() { … }

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

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

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

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

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

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

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

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

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

::llvm::ArrayRef<int64_t> CreateNdDescOp::getConstOffsets() { … }

::std::optional<::llvm::ArrayRef<int64_t>> CreateNdDescOp::getConstShape() { … }

::std::optional<::llvm::ArrayRef<int64_t>> CreateNdDescOp::getConstStrides() { … }

void CreateNdDescOp::setConstOffsets(::llvm::ArrayRef<int64_t> attrValue) { … }

void CreateNdDescOp::setConstShape(::std::optional<::llvm::ArrayRef<int64_t>> attrValue) { … }

void CreateNdDescOp::setConstStrides(::std::optional<::llvm::ArrayRef<int64_t>> attrValue) { … }

void CreateNdDescOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type TensorDesc, ::mlir::Value source, ::mlir::ValueRange offsets, ::mlir::ValueRange shape, ::mlir::ValueRange strides, ::mlir::DenseI64ArrayAttr const_offsets, /*optional*/::mlir::DenseI64ArrayAttr const_shape, /*optional*/::mlir::DenseI64ArrayAttr const_strides) { … }

void CreateNdDescOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value source, ::mlir::ValueRange offsets, ::mlir::ValueRange shape, ::mlir::ValueRange strides, ::mlir::DenseI64ArrayAttr const_offsets, /*optional*/::mlir::DenseI64ArrayAttr const_shape, /*optional*/::mlir::DenseI64ArrayAttr const_strides) { … }

void CreateNdDescOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type TensorDesc, ::mlir::Value source, ::mlir::ValueRange offsets, ::mlir::ValueRange shape, ::mlir::ValueRange strides, ::llvm::ArrayRef<int64_t> const_offsets, /*optional*/::mlir::DenseI64ArrayAttr const_shape, /*optional*/::mlir::DenseI64ArrayAttr const_strides) { … }

void CreateNdDescOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value source, ::mlir::ValueRange offsets, ::mlir::ValueRange shape, ::mlir::ValueRange strides, ::llvm::ArrayRef<int64_t> const_offsets, /*optional*/::mlir::DenseI64ArrayAttr const_shape, /*optional*/::mlir::DenseI64ArrayAttr const_strides) { … }

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

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

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

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

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

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

} // namespace xegpu
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::xegpu::CreateNdDescOp)

namespace mlir {
namespace xegpu {

//===----------------------------------------------------------------------===//
// ::mlir::xegpu::DpasOp definitions
//===----------------------------------------------------------------------===//

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

} // namespace detail
DpasOpAdaptor::DpasOpAdaptor(DpasOp op) : … { … }

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

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

::mlir::MutableOperandRange DpasOp::getAccMutable() { … }

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

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

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

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

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

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

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

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

} // namespace xegpu
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::xegpu::DpasOp)

namespace mlir {
namespace xegpu {

//===----------------------------------------------------------------------===//
// ::mlir::xegpu::FenceOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
FenceOpGenericAdaptorBase::FenceOpGenericAdaptorBase(FenceOp op) : … { … }

::mlir::xegpu::MemorySpace FenceOpGenericAdaptorBase::getMemoryKind() { … }

::mlir::xegpu::FenceScope FenceOpGenericAdaptorBase::getFenceScope() { … }

} // namespace detail
FenceOpAdaptor::FenceOpAdaptor(FenceOp op) : … { … }

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

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

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

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

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

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

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

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

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

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

::mlir::xegpu::MemorySpace FenceOp::getMemoryKind() { … }

::mlir::xegpu::FenceScope FenceOp::getFenceScope() { … }

void FenceOp::setMemoryKind(::mlir::xegpu::MemorySpace attrValue) { … }

void FenceOp::setFenceScope(::mlir::xegpu::FenceScope attrValue) { … }

void FenceOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::xegpu::MemorySpaceAttr memory_kind, ::mlir::xegpu::FenceScopeAttr fence_scope) { … }

void FenceOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::xegpu::MemorySpaceAttr memory_kind, ::mlir::xegpu::FenceScopeAttr fence_scope) { … }

void FenceOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::xegpu::MemorySpace memory_kind, ::mlir::xegpu::FenceScope fence_scope) { … }

void FenceOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::xegpu::MemorySpace memory_kind, ::mlir::xegpu::FenceScope fence_scope) { … }

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

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

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

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

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

} // namespace xegpu
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::xegpu::FenceOp)

namespace mlir {
namespace xegpu {

//===----------------------------------------------------------------------===//
// ::mlir::xegpu::InitNbarrierOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
} // namespace detail
InitNbarrierOpAdaptor::InitNbarrierOpAdaptor(InitNbarrierOp op) : … { … }

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

void InitNbarrierOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value nbarrier_id, ::mlir::Value participant_thread_num) { … }

void InitNbarrierOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value nbarrier_id, ::mlir::Value participant_thread_num) { … }

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

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

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

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

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

} // namespace xegpu
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::xegpu::InitNbarrierOp)

namespace mlir {
namespace xegpu {

//===----------------------------------------------------------------------===//
// ::mlir::xegpu::LoadGatherOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
LoadGatherOpGenericAdaptorBase::LoadGatherOpGenericAdaptorBase(LoadGatherOp op) : … { … }

::std::optional<bool> LoadGatherOpGenericAdaptorBase::getTranspose() { … }

::std::optional<::mlir::xegpu::CachePolicy> LoadGatherOpGenericAdaptorBase::getL1Hint() { … }

::std::optional<::mlir::xegpu::CachePolicy> LoadGatherOpGenericAdaptorBase::getL2Hint() { … }

::std::optional<::mlir::xegpu::CachePolicy> LoadGatherOpGenericAdaptorBase::getL3Hint() { … }

} // namespace detail
LoadGatherOpAdaptor::LoadGatherOpAdaptor(LoadGatherOp op) : … { … }

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

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

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

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

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

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

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

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

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

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

::std::optional<bool> LoadGatherOp::getTranspose() { … }

::std::optional<::mlir::xegpu::CachePolicy> LoadGatherOp::getL1Hint() { … }

::std::optional<::mlir::xegpu::CachePolicy> LoadGatherOp::getL2Hint() { … }

::std::optional<::mlir::xegpu::CachePolicy> LoadGatherOp::getL3Hint() { … }

void LoadGatherOp::setTranspose(bool attrValue) { … }

void LoadGatherOp::setL1Hint(::std::optional<::mlir::xegpu::CachePolicy> attrValue) { … }

void LoadGatherOp::setL2Hint(::std::optional<::mlir::xegpu::CachePolicy> attrValue) { … }

void LoadGatherOp::setL3Hint(::std::optional<::mlir::xegpu::CachePolicy> attrValue) { … }

void LoadGatherOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type value, ::mlir::Value TensorDesc, ::mlir::Value mask, /*optional*/::mlir::UnitAttr transpose, /*optional*/::mlir::xegpu::CachePolicyAttr l1_hint, /*optional*/::mlir::xegpu::CachePolicyAttr l2_hint, /*optional*/::mlir::xegpu::CachePolicyAttr l3_hint) { … }

void LoadGatherOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value TensorDesc, ::mlir::Value mask, /*optional*/::mlir::UnitAttr transpose, /*optional*/::mlir::xegpu::CachePolicyAttr l1_hint, /*optional*/::mlir::xegpu::CachePolicyAttr l2_hint, /*optional*/::mlir::xegpu::CachePolicyAttr l3_hint) { … }

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

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

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

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

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

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

} // namespace xegpu
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::xegpu::LoadGatherOp)

namespace mlir {
namespace xegpu {

//===----------------------------------------------------------------------===//
// ::mlir::xegpu::LoadNdOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
LoadNdOpGenericAdaptorBase::LoadNdOpGenericAdaptorBase(LoadNdOp op) : … { … }

::std::optional<bool> LoadNdOpGenericAdaptorBase::getPacked() { … }

::std::optional<::llvm::ArrayRef<int64_t>> LoadNdOpGenericAdaptorBase::getTranspose() { … }

::std::optional<::mlir::xegpu::CachePolicy> LoadNdOpGenericAdaptorBase::getL1Hint() { … }

::std::optional<::mlir::xegpu::CachePolicy> LoadNdOpGenericAdaptorBase::getL2Hint() { … }

::std::optional<::mlir::xegpu::CachePolicy> LoadNdOpGenericAdaptorBase::getL3Hint() { … }

} // namespace detail
LoadNdOpAdaptor::LoadNdOpAdaptor(LoadNdOp op) : … { … }

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

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

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

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

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

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

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

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

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

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

::std::optional<bool> LoadNdOp::getPacked() { … }

::std::optional<::llvm::ArrayRef<int64_t>> LoadNdOp::getTranspose() { … }

::std::optional<::mlir::xegpu::CachePolicy> LoadNdOp::getL1Hint() { … }

::std::optional<::mlir::xegpu::CachePolicy> LoadNdOp::getL2Hint() { … }

::std::optional<::mlir::xegpu::CachePolicy> LoadNdOp::getL3Hint() { … }

void LoadNdOp::setPacked(bool attrValue) { … }

void LoadNdOp::setTranspose(::std::optional<::llvm::ArrayRef<int64_t>> attrValue) { … }

void LoadNdOp::setL1Hint(::std::optional<::mlir::xegpu::CachePolicy> attrValue) { … }

void LoadNdOp::setL2Hint(::std::optional<::mlir::xegpu::CachePolicy> attrValue) { … }

void LoadNdOp::setL3Hint(::std::optional<::mlir::xegpu::CachePolicy> attrValue) { … }

void LoadNdOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type value, ::mlir::Value TensorDesc, /*optional*/::mlir::UnitAttr packed, /*optional*/::mlir::DenseI64ArrayAttr transpose, /*optional*/::mlir::xegpu::CachePolicyAttr l1_hint, /*optional*/::mlir::xegpu::CachePolicyAttr l2_hint, /*optional*/::mlir::xegpu::CachePolicyAttr l3_hint) { … }

void LoadNdOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value TensorDesc, /*optional*/::mlir::UnitAttr packed, /*optional*/::mlir::DenseI64ArrayAttr transpose, /*optional*/::mlir::xegpu::CachePolicyAttr l1_hint, /*optional*/::mlir::xegpu::CachePolicyAttr l2_hint, /*optional*/::mlir::xegpu::CachePolicyAttr l3_hint) { … }

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

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

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

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

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

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

} // namespace xegpu
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::xegpu::LoadNdOp)

namespace mlir {
namespace xegpu {

//===----------------------------------------------------------------------===//
// ::mlir::xegpu::NbarrierArriveOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
} // namespace detail
NbarrierArriveOpAdaptor::NbarrierArriveOpAdaptor(NbarrierArriveOp op) : … { … }

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

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

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

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

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

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

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

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

} // namespace xegpu
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::xegpu::NbarrierArriveOp)

namespace mlir {
namespace xegpu {

//===----------------------------------------------------------------------===//
// ::mlir::xegpu::NbarrierWaitOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
} // namespace detail
NbarrierWaitOpAdaptor::NbarrierWaitOpAdaptor(NbarrierWaitOp op) : … { … }

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

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

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

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

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

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

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

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

} // namespace xegpu
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::xegpu::NbarrierWaitOp)

namespace mlir {
namespace xegpu {

//===----------------------------------------------------------------------===//
// ::mlir::xegpu::PrefetchNdOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
PrefetchNdOpGenericAdaptorBase::PrefetchNdOpGenericAdaptorBase(PrefetchNdOp op) : … { … }

::std::optional<::mlir::xegpu::CachePolicy> PrefetchNdOpGenericAdaptorBase::getL1Hint() { … }

::std::optional<::mlir::xegpu::CachePolicy> PrefetchNdOpGenericAdaptorBase::getL2Hint() { … }

::std::optional<::mlir::xegpu::CachePolicy> PrefetchNdOpGenericAdaptorBase::getL3Hint() { … }

} // namespace detail
PrefetchNdOpAdaptor::PrefetchNdOpAdaptor(PrefetchNdOp op) : … { … }

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

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

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

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

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

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

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

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

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

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

::std::optional<::mlir::xegpu::CachePolicy> PrefetchNdOp::getL1Hint() { … }

::std::optional<::mlir::xegpu::CachePolicy> PrefetchNdOp::getL2Hint() { … }

::std::optional<::mlir::xegpu::CachePolicy> PrefetchNdOp::getL3Hint() { … }

void PrefetchNdOp::setL1Hint(::std::optional<::mlir::xegpu::CachePolicy> attrValue) { … }

void PrefetchNdOp::setL2Hint(::std::optional<::mlir::xegpu::CachePolicy> attrValue) { … }

void PrefetchNdOp::setL3Hint(::std::optional<::mlir::xegpu::CachePolicy> attrValue) { … }

void PrefetchNdOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value TensorDesc, /*optional*/::mlir::xegpu::CachePolicyAttr l1_hint, /*optional*/::mlir::xegpu::CachePolicyAttr l2_hint, /*optional*/::mlir::xegpu::CachePolicyAttr l3_hint) { … }

void PrefetchNdOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value TensorDesc, /*optional*/::mlir::xegpu::CachePolicyAttr l1_hint, /*optional*/::mlir::xegpu::CachePolicyAttr l2_hint, /*optional*/::mlir::xegpu::CachePolicyAttr l3_hint) { … }

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

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

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

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

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

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

} // namespace xegpu
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::xegpu::PrefetchNdOp)

namespace mlir {
namespace xegpu {

//===----------------------------------------------------------------------===//
// ::mlir::xegpu::PrefetchOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
PrefetchOpGenericAdaptorBase::PrefetchOpGenericAdaptorBase(PrefetchOp op) : … { … }

::std::optional<::mlir::xegpu::CachePolicy> PrefetchOpGenericAdaptorBase::getL1Hint() { … }

::std::optional<::mlir::xegpu::CachePolicy> PrefetchOpGenericAdaptorBase::getL2Hint() { … }

::std::optional<::mlir::xegpu::CachePolicy> PrefetchOpGenericAdaptorBase::getL3Hint() { … }

} // namespace detail
PrefetchOpAdaptor::PrefetchOpAdaptor(PrefetchOp op) : … { … }

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

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

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

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

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

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

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

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

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

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

::std::optional<::mlir::xegpu::CachePolicy> PrefetchOp::getL1Hint() { … }

::std::optional<::mlir::xegpu::CachePolicy> PrefetchOp::getL2Hint() { … }

::std::optional<::mlir::xegpu::CachePolicy> PrefetchOp::getL3Hint() { … }

void PrefetchOp::setL1Hint(::std::optional<::mlir::xegpu::CachePolicy> attrValue) { … }

void PrefetchOp::setL2Hint(::std::optional<::mlir::xegpu::CachePolicy> attrValue) { … }

void PrefetchOp::setL3Hint(::std::optional<::mlir::xegpu::CachePolicy> attrValue) { … }

void PrefetchOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value TensorDesc, /*optional*/::mlir::xegpu::CachePolicyAttr l1_hint, /*optional*/::mlir::xegpu::CachePolicyAttr l2_hint, /*optional*/::mlir::xegpu::CachePolicyAttr l3_hint) { … }

void PrefetchOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value TensorDesc, /*optional*/::mlir::xegpu::CachePolicyAttr l1_hint, /*optional*/::mlir::xegpu::CachePolicyAttr l2_hint, /*optional*/::mlir::xegpu::CachePolicyAttr l3_hint) { … }

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

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

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

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

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

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

} // namespace xegpu
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::xegpu::PrefetchOp)

namespace mlir {
namespace xegpu {

//===----------------------------------------------------------------------===//
// ::mlir::xegpu::StoreNdOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
StoreNdOpGenericAdaptorBase::StoreNdOpGenericAdaptorBase(StoreNdOp op) : … { … }

::std::optional<::mlir::xegpu::CachePolicy> StoreNdOpGenericAdaptorBase::getL1Hint() { … }

::std::optional<::mlir::xegpu::CachePolicy> StoreNdOpGenericAdaptorBase::getL2Hint() { … }

::std::optional<::mlir::xegpu::CachePolicy> StoreNdOpGenericAdaptorBase::getL3Hint() { … }

} // namespace detail
StoreNdOpAdaptor::StoreNdOpAdaptor(StoreNdOp op) : … { … }

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

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

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

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

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

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

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

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

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

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

::std::optional<::mlir::xegpu::CachePolicy> StoreNdOp::getL1Hint() { … }

::std::optional<::mlir::xegpu::CachePolicy> StoreNdOp::getL2Hint() { … }

::std::optional<::mlir::xegpu::CachePolicy> StoreNdOp::getL3Hint() { … }

void StoreNdOp::setL1Hint(::std::optional<::mlir::xegpu::CachePolicy> attrValue) { … }

void StoreNdOp::setL2Hint(::std::optional<::mlir::xegpu::CachePolicy> attrValue) { … }

void StoreNdOp::setL3Hint(::std::optional<::mlir::xegpu::CachePolicy> attrValue) { … }

void StoreNdOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value value, ::mlir::Value TensorDesc, /*optional*/::mlir::xegpu::CachePolicyAttr l1_hint, /*optional*/::mlir::xegpu::CachePolicyAttr l2_hint, /*optional*/::mlir::xegpu::CachePolicyAttr l3_hint) { … }

void StoreNdOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value value, ::mlir::Value TensorDesc, /*optional*/::mlir::xegpu::CachePolicyAttr l1_hint, /*optional*/::mlir::xegpu::CachePolicyAttr l2_hint, /*optional*/::mlir::xegpu::CachePolicyAttr l3_hint) { … }

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

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

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

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

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

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

} // namespace xegpu
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::xegpu::StoreNdOp)

namespace mlir {
namespace xegpu {

//===----------------------------------------------------------------------===//
// ::mlir::xegpu::StoreScatterOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
StoreScatterOpGenericAdaptorBase::StoreScatterOpGenericAdaptorBase(StoreScatterOp op) : … { … }

::std::optional<bool> StoreScatterOpGenericAdaptorBase::getTranspose() { … }

::std::optional<::mlir::xegpu::CachePolicy> StoreScatterOpGenericAdaptorBase::getL1Hint() { … }

::std::optional<::mlir::xegpu::CachePolicy> StoreScatterOpGenericAdaptorBase::getL2Hint() { … }

::std::optional<::mlir::xegpu::CachePolicy> StoreScatterOpGenericAdaptorBase::getL3Hint() { … }

} // namespace detail
StoreScatterOpAdaptor::StoreScatterOpAdaptor(StoreScatterOp op) : … { … }

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

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

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

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

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

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

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

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

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

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

::std::optional<bool> StoreScatterOp::getTranspose() { … }

::std::optional<::mlir::xegpu::CachePolicy> StoreScatterOp::getL1Hint() { … }

::std::optional<::mlir::xegpu::CachePolicy> StoreScatterOp::getL2Hint() { … }

::std::optional<::mlir::xegpu::CachePolicy> StoreScatterOp::getL3Hint() { … }

void StoreScatterOp::setTranspose(bool attrValue) { … }

void StoreScatterOp::setL1Hint(::std::optional<::mlir::xegpu::CachePolicy> attrValue) { … }

void StoreScatterOp::setL2Hint(::std::optional<::mlir::xegpu::CachePolicy> attrValue) { … }

void StoreScatterOp::setL3Hint(::std::optional<::mlir::xegpu::CachePolicy> attrValue) { … }

void StoreScatterOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value value, ::mlir::Value TensorDesc, ::mlir::Value mask, /*optional*/::mlir::UnitAttr transpose, /*optional*/::mlir::xegpu::CachePolicyAttr l1_hint, /*optional*/::mlir::xegpu::CachePolicyAttr l2_hint, /*optional*/::mlir::xegpu::CachePolicyAttr l3_hint) { … }

void StoreScatterOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value value, ::mlir::Value TensorDesc, ::mlir::Value mask, /*optional*/::mlir::UnitAttr transpose, /*optional*/::mlir::xegpu::CachePolicyAttr l1_hint, /*optional*/::mlir::xegpu::CachePolicyAttr l2_hint, /*optional*/::mlir::xegpu::CachePolicyAttr l3_hint) { … }

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

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

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

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

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

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

} // namespace xegpu
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::xegpu::StoreScatterOp)

namespace mlir {
namespace xegpu {

//===----------------------------------------------------------------------===//
// ::mlir::xegpu::UpdateNdOffsetOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
UpdateNdOffsetOpGenericAdaptorBase::UpdateNdOffsetOpGenericAdaptorBase(UpdateNdOffsetOp op) : … { … }

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

::llvm::ArrayRef<int64_t> UpdateNdOffsetOpGenericAdaptorBase::getConstOffsets() { … }

} // namespace detail
UpdateNdOffsetOpAdaptor::UpdateNdOffsetOpAdaptor(UpdateNdOffsetOp op) : … { … }

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

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

::mlir::MutableOperandRange UpdateNdOffsetOp::getOffsetsMutable() { … }

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

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

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

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

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

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

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

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

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

::llvm::ArrayRef<int64_t> UpdateNdOffsetOp::getConstOffsets() { … }

void UpdateNdOffsetOp::setConstOffsets(::llvm::ArrayRef<int64_t> attrValue) { … }

void UpdateNdOffsetOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value TensorDesc, ::mlir::ValueRange offsets, ::mlir::DenseI64ArrayAttr const_offsets) { … }

void UpdateNdOffsetOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value TensorDesc, ::mlir::ValueRange offsets, ::mlir::DenseI64ArrayAttr const_offsets) { … }

void UpdateNdOffsetOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value TensorDesc, ::mlir::ValueRange offsets, ::llvm::ArrayRef<int64_t> const_offsets) { … }

void UpdateNdOffsetOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value TensorDesc, ::mlir::ValueRange offsets, ::llvm::ArrayRef<int64_t> const_offsets) { … }

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

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

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

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

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

} // namespace xegpu
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::xegpu::UpdateNdOffsetOp)

namespace mlir {
namespace xegpu {

//===----------------------------------------------------------------------===//
// ::mlir::xegpu::UpdateOffsetOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
} // namespace detail
UpdateOffsetOpAdaptor::UpdateOffsetOpAdaptor(UpdateOffsetOp op) : … { … }

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

void UpdateOffsetOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value TensorDesc, ::mlir::Value offsets) { … }

void UpdateOffsetOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value TensorDesc, ::mlir::Value offsets) { … }

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

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

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

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

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

} // namespace xegpu
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::xegpu::UpdateOffsetOp)


#endif  // GET_OP_CLASSES