14408 lines
790 KiB
C++
14408 lines
790 KiB
C++
/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
|
|
|* *|
|
|
|* Op Definitions *|
|
|
|* *|
|
|
|* Automatically generated file, do not edit! *|
|
|
|* From: ArmSMEIntrinsicOps.td *|
|
|
|* *|
|
|
\*===----------------------------------------------------------------------===*/
|
|
|
|
#ifdef GET_OP_LIST
|
|
#undef GET_OP_LIST
|
|
|
|
::mlir::arm_sme::aarch64_sme_cntsd,
|
|
::mlir::arm_sme::aarch64_sme_ld1b_horiz,
|
|
::mlir::arm_sme::aarch64_sme_ld1b_vert,
|
|
::mlir::arm_sme::aarch64_sme_ld1d_horiz,
|
|
::mlir::arm_sme::aarch64_sme_ld1d_vert,
|
|
::mlir::arm_sme::aarch64_sme_ld1h_horiz,
|
|
::mlir::arm_sme::aarch64_sme_ld1h_vert,
|
|
::mlir::arm_sme::aarch64_sme_ld1q_horiz,
|
|
::mlir::arm_sme::aarch64_sme_ld1q_vert,
|
|
::mlir::arm_sme::aarch64_sme_ld1w_horiz,
|
|
::mlir::arm_sme::aarch64_sme_ld1w_vert,
|
|
::mlir::arm_sme::aarch64_sme_mopa,
|
|
::mlir::arm_sme::aarch64_sme_mopa_wide,
|
|
::mlir::arm_sme::aarch64_sme_mops,
|
|
::mlir::arm_sme::aarch64_sme_mops_wide,
|
|
::mlir::arm_sme::aarch64_sme_read_horiz,
|
|
::mlir::arm_sme::aarch64_sme_read_vert,
|
|
::mlir::arm_sme::aarch64_sme_smopa_wide,
|
|
::mlir::arm_sme::aarch64_sme_smopa_za32,
|
|
::mlir::arm_sme::aarch64_sme_smops_wide,
|
|
::mlir::arm_sme::aarch64_sme_smops_za32,
|
|
::mlir::arm_sme::aarch64_sme_st1b_horiz,
|
|
::mlir::arm_sme::aarch64_sme_st1b_vert,
|
|
::mlir::arm_sme::aarch64_sme_st1d_horiz,
|
|
::mlir::arm_sme::aarch64_sme_st1d_vert,
|
|
::mlir::arm_sme::aarch64_sme_st1h_horiz,
|
|
::mlir::arm_sme::aarch64_sme_st1h_vert,
|
|
::mlir::arm_sme::aarch64_sme_st1q_horiz,
|
|
::mlir::arm_sme::aarch64_sme_st1q_vert,
|
|
::mlir::arm_sme::aarch64_sme_st1w_horiz,
|
|
::mlir::arm_sme::aarch64_sme_st1w_vert,
|
|
::mlir::arm_sme::aarch64_sme_str,
|
|
::mlir::arm_sme::aarch64_sme_sumopa_wide,
|
|
::mlir::arm_sme::aarch64_sme_sumops_wide,
|
|
::mlir::arm_sme::aarch64_sme_umopa_wide,
|
|
::mlir::arm_sme::aarch64_sme_umopa_za32,
|
|
::mlir::arm_sme::aarch64_sme_umops_wide,
|
|
::mlir::arm_sme::aarch64_sme_umops_za32,
|
|
::mlir::arm_sme::aarch64_sme_usmopa_wide,
|
|
::mlir::arm_sme::aarch64_sme_usmops_wide,
|
|
::mlir::arm_sme::aarch64_sme_write_horiz,
|
|
::mlir::arm_sme::aarch64_sme_write_vert,
|
|
::mlir::arm_sme::aarch64_sme_zero
|
|
#endif // GET_OP_LIST
|
|
|
|
#ifdef GET_OP_CLASSES
|
|
#undef GET_OP_CLASSES
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Local Utility Method Definitions
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
static ::llvm::LogicalResult __mlir_ods_local_type_constraint_ArmSMEIntrinsicOps1(
|
|
::mlir::Operation *op, ::mlir::Type type, ::llvm::StringRef valueKind,
|
|
unsigned valueIndex) {
|
|
if (!((::mlir::LLVM::isCompatibleOuterType(type)))) {
|
|
return op->emitOpError(valueKind) << " #" << valueIndex
|
|
<< " must be LLVM dialect-compatible type, but got " << type;
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
static ::llvm::LogicalResult __mlir_ods_local_type_constraint_ArmSMEIntrinsicOps2(
|
|
::mlir::Operation *op, ::mlir::Type type, ::llvm::StringRef valueKind,
|
|
unsigned valueIndex) {
|
|
if (!((((::llvm::isa<::mlir::ScalableVectorType>(type))) && ((::llvm::cast<::mlir::VectorType>(type).getRank()
|
|
== 1))) && (((::llvm::isa<::mlir::ScalableVectorType>(type))) && ([](::mlir::Type elementType) { return (elementType.isSignlessInteger(1)); }(::llvm::cast<::mlir::ShapedType>(type).getElementType()))) && (((::llvm::isa<::mlir::ScalableVectorType>(type))) && (((::llvm::cast<::mlir::VectorType>(type).getNumElements()
|
|
== 16)) || ((::llvm::cast<::mlir::VectorType>(type).getNumElements()
|
|
== 8)) || ((::llvm::cast<::mlir::VectorType>(type).getNumElements()
|
|
== 4)) || ((::llvm::cast<::mlir::VectorType>(type).getNumElements()
|
|
== 2)) || ((::llvm::cast<::mlir::VectorType>(type).getNumElements()
|
|
== 1)))))) {
|
|
return op->emitOpError(valueKind) << " #" << valueIndex
|
|
<< " must be a vector type that matches the size of a SVE predicate, but got " << type;
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
static ::llvm::LogicalResult __mlir_ods_local_type_constraint_ArmSMEIntrinsicOps3(
|
|
::mlir::Operation *op, ::mlir::Type type, ::llvm::StringRef valueKind,
|
|
unsigned valueIndex) {
|
|
if (!((::llvm::isa<::mlir::LLVM::LLVMPointerType>(type)))) {
|
|
return op->emitOpError(valueKind) << " #" << valueIndex
|
|
<< " must be LLVM pointer type, but got " << type;
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
static ::llvm::LogicalResult __mlir_ods_local_type_constraint_ArmSMEIntrinsicOps4(
|
|
::mlir::Operation *op, ::mlir::Type type, ::llvm::StringRef valueKind,
|
|
unsigned valueIndex) {
|
|
if (!((type.isSignlessInteger(32)))) {
|
|
return op->emitOpError(valueKind) << " #" << valueIndex
|
|
<< " must be 32-bit signless integer, but got " << type;
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
static ::llvm::LogicalResult __mlir_ods_local_type_constraint_ArmSMEIntrinsicOps5(
|
|
::mlir::Operation *op, ::mlir::Type type, ::llvm::StringRef valueKind,
|
|
unsigned valueIndex) {
|
|
if (!((((::llvm::isa<::mlir::ScalableVectorType>(type))) && ((::llvm::cast<::mlir::VectorType>(type).getRank()
|
|
== 1))) && (((::llvm::isa<::mlir::ScalableVectorType>(type))) && ([](::mlir::Type elementType) { return (elementType.isSignlessInteger(1)); }(::llvm::cast<::mlir::ShapedType>(type).getElementType()))) && (((::llvm::isa<::mlir::ScalableVectorType>(type))) && (((::llvm::cast<::mlir::VectorType>(type).getNumElements()
|
|
== 16)) || ((::llvm::cast<::mlir::VectorType>(type).getNumElements()
|
|
== 8)) || ((::llvm::cast<::mlir::VectorType>(type).getNumElements()
|
|
== 4)) || ((::llvm::cast<::mlir::VectorType>(type).getNumElements()
|
|
== 2)))))) {
|
|
return op->emitOpError(valueKind) << " #" << valueIndex
|
|
<< " must be a vector type that is a supported predicate for the SME MOP instructions, but got " << type;
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
static ::llvm::LogicalResult __mlir_ods_local_type_constraint_ArmSMEIntrinsicOps6(
|
|
::mlir::Operation *op, ::mlir::Type type, ::llvm::StringRef valueKind,
|
|
unsigned valueIndex) {
|
|
if (!((((::llvm::isa<::mlir::ScalableVectorType>(type))) && ((::llvm::cast<::mlir::VectorType>(type).getRank()
|
|
== 1))) && (((::llvm::isa<::mlir::ScalableVectorType>(type))) && ([](::mlir::Type elementType) { return ((elementType.isSignlessInteger(8))) || ((elementType.isSignlessInteger(16))) || ((::llvm::isa<::mlir::BFloat16Type>(elementType))) || ((elementType.isF16())) || ((elementType.isF32())) || ((elementType.isF64())); }(::llvm::cast<::mlir::ShapedType>(type).getElementType()))) && (((::llvm::isa<::mlir::ScalableVectorType>(type))) && (((::llvm::cast<::mlir::VectorType>(type).getNumElements()
|
|
== 16)) || ((::llvm::cast<::mlir::VectorType>(type).getNumElements()
|
|
== 8)) || ((::llvm::cast<::mlir::VectorType>(type).getNumElements()
|
|
== 4)) || ((::llvm::cast<::mlir::VectorType>(type).getNumElements()
|
|
== 2)))))) {
|
|
return op->emitOpError(valueKind) << " #" << valueIndex
|
|
<< " must be a vector type that is a supported input for the SME MOP instructions, but got " << type;
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
static ::llvm::LogicalResult __mlir_ods_local_type_constraint_ArmSMEIntrinsicOps7(
|
|
::mlir::Operation *op, ::mlir::Type type, ::llvm::StringRef valueKind,
|
|
unsigned valueIndex) {
|
|
if (!((((::llvm::isa<::mlir::ScalableVectorType>(type))) && ((::llvm::cast<::mlir::VectorType>(type).getRank()
|
|
== 1))) && (((::llvm::isa<::mlir::ScalableVectorType>(type))) && ([](::mlir::Type elementType) { return ((elementType.isSignlessInteger(8))) || ((elementType.isSignlessInteger(16))) || ((elementType.isSignlessInteger(32))) || ((elementType.isSignlessInteger(64))) || ((elementType.isSignlessInteger(128))) || ((elementType.isF16())) || ((::llvm::isa<::mlir::BFloat16Type>(elementType))) || ((elementType.isF32())) || ((elementType.isF64())); }(::llvm::cast<::mlir::ShapedType>(type).getElementType()))) && (((::llvm::isa<::mlir::ScalableVectorType>(type))) && (((::llvm::cast<::mlir::VectorType>(type).getNumElements()
|
|
== 16)) || ((::llvm::cast<::mlir::VectorType>(type).getNumElements()
|
|
== 8)) || ((::llvm::cast<::mlir::VectorType>(type).getNumElements()
|
|
== 4)) || ((::llvm::cast<::mlir::VectorType>(type).getNumElements()
|
|
== 2)) || ((::llvm::cast<::mlir::VectorType>(type).getNumElements()
|
|
== 1)))))) {
|
|
return op->emitOpError(valueKind) << " #" << valueIndex
|
|
<< " must be a vector type that matches the size of a SVE vector, but got " << type;
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
static ::llvm::LogicalResult __mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(
|
|
::mlir::Attribute attr, ::llvm::StringRef attrName, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
if (attr && !(((::llvm::isa<::mlir::IntegerAttr>(attr))) && ((::llvm::cast<::mlir::IntegerAttr>(attr).getType().isSignlessInteger(32)))))
|
|
return emitError() << "attribute '" << attrName
|
|
<< "' failed to satisfy constraint: 32-bit signless integer attribute";
|
|
return ::mlir::success();
|
|
}
|
|
static ::llvm::LogicalResult __mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(
|
|
::mlir::Operation *op, ::mlir::Attribute attr, ::llvm::StringRef attrName) {
|
|
return __mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(attr, attrName, [op]() {
|
|
return op->emitOpError();
|
|
});
|
|
}
|
|
namespace mlir::arm_sme {
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ::mlir::arm_sme::aarch64_sme_cntsd definitions
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace detail {
|
|
|
|
aarch64_sme_cntsdGenericAdaptorBase::aarch64_sme_cntsdGenericAdaptorBase(aarch64_sme_cntsd op) : odsAttrs(op->getRawDictionaryAttrs()), odsOpName(op->getName()), properties(op.getProperties()), odsRegions(op->getRegions()) {}
|
|
|
|
|
|
} // namespace detail
|
|
aarch64_sme_cntsdAdaptor::aarch64_sme_cntsdAdaptor(aarch64_sme_cntsd op) : aarch64_sme_cntsdGenericAdaptor(op->getOperands(), op) {}
|
|
|
|
::llvm::LogicalResult aarch64_sme_cntsdAdaptor::verify(::mlir::Location loc) {
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_cntsd::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::mlir::Attribute aarch64_sme_cntsd::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) {
|
|
::mlir::SmallVector<::mlir::NamedAttribute> attrs;
|
|
::mlir::Builder odsBuilder{ctx};
|
|
|
|
if (!attrs.empty())
|
|
return odsBuilder.getDictionaryAttr(attrs);
|
|
return {};
|
|
}
|
|
|
|
llvm::hash_code aarch64_sme_cntsd::computePropertiesHash(const Properties &prop) {
|
|
using llvm::hash_value;
|
|
return llvm::hash_combine();
|
|
}
|
|
|
|
std::optional<mlir::Attribute> aarch64_sme_cntsd::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) {
|
|
return std::nullopt;
|
|
}
|
|
|
|
void aarch64_sme_cntsd::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) {
|
|
}
|
|
|
|
void aarch64_sme_cntsd::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) {
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_cntsd::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_cntsd::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res) {
|
|
odsState.addTypes(res);
|
|
}
|
|
|
|
aarch64_sme_cntsd aarch64_sme_cntsd::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(res)>(res));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_cntsd>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_cntsd aarch64_sme_cntsd::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(res)>(res));
|
|
}
|
|
|
|
void aarch64_sme_cntsd::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes) {
|
|
assert(resultTypes.size() == 1u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_cntsd aarch64_sme_cntsd::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_cntsd>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_cntsd aarch64_sme_cntsd::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes));
|
|
}
|
|
|
|
void aarch64_sme_cntsd::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
assert(operands.size() == 0u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.addAttributes(attributes);
|
|
assert(resultTypes.size() == 1u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_cntsd aarch64_sme_cntsd::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_cntsd>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_cntsd aarch64_sme_cntsd::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
}
|
|
|
|
void aarch64_sme_cntsd::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
assert(operands.size() == 0u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.useProperties(const_cast<Properties&>(properties));
|
|
odsState.addAttributes(discardableAttributes);
|
|
assert(resultTypes.size() == 1u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_cntsd aarch64_sme_cntsd::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_cntsd>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_cntsd aarch64_sme_cntsd::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_cntsd::verifyInvariantsImpl() {
|
|
{
|
|
unsigned index = 0; (void)index;
|
|
auto valueGroup0 = getODSResults(0);
|
|
|
|
for (auto v : valueGroup0) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps1(*this, v.getType(), "result", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
if (!(((*this->getODSResults(0).begin()).getType().isSignlessInteger(64))))
|
|
return emitOpError("failed to verify that `res` is i64");
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_cntsd::verifyInvariants() {
|
|
return verifyInvariantsImpl();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_cntsd::setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
// keep track of used keys in the input dictionary to be able to error out
|
|
// if there are some unknown ones.
|
|
::mlir::DenseSet<::mlir::StringAttr> usedKeys;
|
|
::mlir::MLIRContext *ctx = dict.getContext();
|
|
(void)ctx;
|
|
|
|
for (::mlir::NamedAttribute attr : dict) {
|
|
if (!usedKeys.contains(attr.getName()))
|
|
return emitError() << "unknown key '" << attr.getName() <<
|
|
"' when parsing properties dictionary";
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
|
|
} // namespace mlir::arm_sme
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::aarch64_sme_cntsd)
|
|
|
|
namespace mlir::arm_sme {
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ::mlir::arm_sme::aarch64_sme_ld1b_horiz definitions
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace detail {
|
|
|
|
aarch64_sme_ld1b_horizGenericAdaptorBase::aarch64_sme_ld1b_horizGenericAdaptorBase(aarch64_sme_ld1b_horiz op) : odsAttrs(op->getRawDictionaryAttrs()), odsOpName(op->getName()), properties(op.getProperties()), odsRegions(op->getRegions()) {}
|
|
|
|
uint32_t aarch64_sme_ld1b_horizGenericAdaptorBase::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
|
|
} // namespace detail
|
|
aarch64_sme_ld1b_horizAdaptor::aarch64_sme_ld1b_horizAdaptor(aarch64_sme_ld1b_horiz op) : aarch64_sme_ld1b_horizGenericAdaptor(op->getOperands(), op) {}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1b_horizAdaptor::verify(::mlir::Location loc) {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitError(loc, "'arm_sme.intr.ld1b.horiz' op requires attribute 'tile_id'");
|
|
|
|
if (tblgen_tile_id && !(((::llvm::isa<::mlir::IntegerAttr>(tblgen_tile_id))) && ((::llvm::cast<::mlir::IntegerAttr>(tblgen_tile_id).getType().isSignlessInteger(32)))))
|
|
return emitError(loc, "'arm_sme.intr.ld1b.horiz' op attribute 'tile_id' failed to satisfy constraint: 32-bit signless integer attribute");
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1b_horiz::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
|
|
{
|
|
auto &propStorage = prop.tile_id;
|
|
auto attr = dict.get("tile_id");
|
|
if (attr) {
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::mlir::Attribute aarch64_sme_ld1b_horiz::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) {
|
|
::mlir::SmallVector<::mlir::NamedAttribute> attrs;
|
|
::mlir::Builder odsBuilder{ctx};
|
|
|
|
{
|
|
const auto &propStorage = prop.tile_id;
|
|
if (propStorage)
|
|
attrs.push_back(odsBuilder.getNamedAttr("tile_id",
|
|
propStorage));
|
|
}
|
|
|
|
if (!attrs.empty())
|
|
return odsBuilder.getDictionaryAttr(attrs);
|
|
return {};
|
|
}
|
|
|
|
llvm::hash_code aarch64_sme_ld1b_horiz::computePropertiesHash(const Properties &prop) {
|
|
using llvm::hash_value;
|
|
return llvm::hash_combine(
|
|
llvm::hash_value(prop.tile_id.getAsOpaquePointer()));
|
|
}
|
|
|
|
std::optional<mlir::Attribute> aarch64_sme_ld1b_horiz::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) {
|
|
if (name == "tile_id")
|
|
return prop.tile_id;
|
|
return std::nullopt;
|
|
}
|
|
|
|
void aarch64_sme_ld1b_horiz::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) {
|
|
if (name == "tile_id") {
|
|
prop.tile_id = ::llvm::dyn_cast_or_null<std::remove_reference_t<decltype(prop.tile_id)>>(value);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void aarch64_sme_ld1b_horiz::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) {
|
|
if (prop.tile_id) attrs.append("tile_id", prop.tile_id);
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1b_horiz::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
{
|
|
::mlir::Attribute attr = attrs.get(getTileIdAttrName(opName));
|
|
if (attr && ::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(attr, "tile_id", emitError)))
|
|
return ::mlir::failure();
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1b_horiz::readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state) {
|
|
auto &prop = state.getOrAddProperties<Properties>(); (void)prop;
|
|
if (::mlir::failed(reader.readAttribute(prop.tile_id)))
|
|
return ::mlir::failure();
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_ld1b_horiz::writeProperties(::mlir::DialectBytecodeWriter &writer) {
|
|
auto &prop = getProperties(); (void)prop;
|
|
writer.writeAttribute(prop.tile_id);
|
|
}
|
|
|
|
uint32_t aarch64_sme_ld1b_horiz::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
void aarch64_sme_ld1b_horiz::setTileId(uint32_t attrValue) {
|
|
getProperties().tile_id = ::mlir::Builder((*this)->getContext()).getIntegerAttr(::mlir::Builder((*this)->getContext()).getIntegerType(32), attrValue);
|
|
}
|
|
|
|
void aarch64_sme_ld1b_horiz::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(load_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
}
|
|
|
|
aarch64_sme_ld1b_horiz aarch64_sme_ld1b_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1b_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1b_horiz aarch64_sme_ld1b_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_ld1b_horiz::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(load_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_ld1b_horiz aarch64_sme_ld1b_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1b_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1b_horiz aarch64_sme_ld1b_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_ld1b_horiz::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(load_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
}
|
|
|
|
aarch64_sme_ld1b_horiz aarch64_sme_ld1b_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1b_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1b_horiz aarch64_sme_ld1b_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_ld1b_horiz::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(load_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_ld1b_horiz aarch64_sme_ld1b_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1b_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1b_horiz aarch64_sme_ld1b_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_ld1b_horiz::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
assert(operands.size() == 3u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.addAttributes(attributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
|
|
if (!attributes.empty()) {
|
|
(void)odsState.getOrAddProperties<aarch64_sme_ld1b_horiz::Properties>();
|
|
::mlir::PropertyRef properties = odsState.getRawProperties();
|
|
std::optional<::mlir::RegisteredOperationName> info =
|
|
odsState.name.getRegisteredInfo();
|
|
if (failed(info->setOpPropertiesFromAttribute(odsState.name, properties,
|
|
odsState.attributes.getDictionary(odsState.getContext()), nullptr)))
|
|
::llvm::report_fatal_error("Property conversion failed.");
|
|
}
|
|
}
|
|
|
|
aarch64_sme_ld1b_horiz aarch64_sme_ld1b_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1b_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1b_horiz aarch64_sme_ld1b_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
}
|
|
|
|
void aarch64_sme_ld1b_horiz::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
assert(operands.size() == 3u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.useProperties(const_cast<Properties&>(properties));
|
|
odsState.addAttributes(discardableAttributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_ld1b_horiz aarch64_sme_ld1b_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1b_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1b_horiz aarch64_sme_ld1b_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1b_horiz::verifyInvariantsImpl() {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitOpError("requires attribute 'tile_id'");
|
|
|
|
if (::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(*this, tblgen_tile_id, "tile_id")))
|
|
return ::mlir::failure();
|
|
{
|
|
unsigned index = 0; (void)index;
|
|
auto valueGroup0 = getODSOperands(0);
|
|
|
|
for (auto v : valueGroup0) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps2(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup1 = getODSOperands(1);
|
|
|
|
for (auto v : valueGroup1) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps3(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup2 = getODSOperands(2);
|
|
|
|
for (auto v : valueGroup2) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps4(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1b_horiz::verifyInvariants() {
|
|
return verifyInvariantsImpl();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1b_horiz::setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
// keep track of used keys in the input dictionary to be able to error out
|
|
// if there are some unknown ones.
|
|
::mlir::DenseSet<::mlir::StringAttr> usedKeys;
|
|
::mlir::MLIRContext *ctx = dict.getContext();
|
|
(void)ctx;
|
|
{
|
|
|
|
auto &propStorage = prop.tile_id;
|
|
auto tile_idAttrName = ::mlir::StringAttr::get(ctx, "tile_id");
|
|
auto attr = dict.get(tile_idAttrName);
|
|
usedKeys.insert(tile_idAttrName);
|
|
if (attr || /*isRequired=*/true) {
|
|
if (!attr) {
|
|
emitError() << "expected key entry for tile_id in DictionaryAttr to set "
|
|
"Properties.";
|
|
return ::mlir::failure();
|
|
}
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
|
|
for (::mlir::NamedAttribute attr : dict) {
|
|
if (!usedKeys.contains(attr.getName()))
|
|
return emitError() << "unknown key '" << attr.getName() <<
|
|
"' when parsing properties dictionary";
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
|
|
} // namespace mlir::arm_sme
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::aarch64_sme_ld1b_horiz)
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::detail::aarch64_sme_ld1b_horizGenericAdaptorBase::Properties)
|
|
|
|
namespace mlir::arm_sme {
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ::mlir::arm_sme::aarch64_sme_ld1b_vert definitions
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace detail {
|
|
|
|
aarch64_sme_ld1b_vertGenericAdaptorBase::aarch64_sme_ld1b_vertGenericAdaptorBase(aarch64_sme_ld1b_vert op) : odsAttrs(op->getRawDictionaryAttrs()), odsOpName(op->getName()), properties(op.getProperties()), odsRegions(op->getRegions()) {}
|
|
|
|
uint32_t aarch64_sme_ld1b_vertGenericAdaptorBase::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
|
|
} // namespace detail
|
|
aarch64_sme_ld1b_vertAdaptor::aarch64_sme_ld1b_vertAdaptor(aarch64_sme_ld1b_vert op) : aarch64_sme_ld1b_vertGenericAdaptor(op->getOperands(), op) {}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1b_vertAdaptor::verify(::mlir::Location loc) {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitError(loc, "'arm_sme.intr.ld1b.vert' op requires attribute 'tile_id'");
|
|
|
|
if (tblgen_tile_id && !(((::llvm::isa<::mlir::IntegerAttr>(tblgen_tile_id))) && ((::llvm::cast<::mlir::IntegerAttr>(tblgen_tile_id).getType().isSignlessInteger(32)))))
|
|
return emitError(loc, "'arm_sme.intr.ld1b.vert' op attribute 'tile_id' failed to satisfy constraint: 32-bit signless integer attribute");
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1b_vert::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
|
|
{
|
|
auto &propStorage = prop.tile_id;
|
|
auto attr = dict.get("tile_id");
|
|
if (attr) {
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::mlir::Attribute aarch64_sme_ld1b_vert::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) {
|
|
::mlir::SmallVector<::mlir::NamedAttribute> attrs;
|
|
::mlir::Builder odsBuilder{ctx};
|
|
|
|
{
|
|
const auto &propStorage = prop.tile_id;
|
|
if (propStorage)
|
|
attrs.push_back(odsBuilder.getNamedAttr("tile_id",
|
|
propStorage));
|
|
}
|
|
|
|
if (!attrs.empty())
|
|
return odsBuilder.getDictionaryAttr(attrs);
|
|
return {};
|
|
}
|
|
|
|
llvm::hash_code aarch64_sme_ld1b_vert::computePropertiesHash(const Properties &prop) {
|
|
using llvm::hash_value;
|
|
return llvm::hash_combine(
|
|
llvm::hash_value(prop.tile_id.getAsOpaquePointer()));
|
|
}
|
|
|
|
std::optional<mlir::Attribute> aarch64_sme_ld1b_vert::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) {
|
|
if (name == "tile_id")
|
|
return prop.tile_id;
|
|
return std::nullopt;
|
|
}
|
|
|
|
void aarch64_sme_ld1b_vert::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) {
|
|
if (name == "tile_id") {
|
|
prop.tile_id = ::llvm::dyn_cast_or_null<std::remove_reference_t<decltype(prop.tile_id)>>(value);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void aarch64_sme_ld1b_vert::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) {
|
|
if (prop.tile_id) attrs.append("tile_id", prop.tile_id);
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1b_vert::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
{
|
|
::mlir::Attribute attr = attrs.get(getTileIdAttrName(opName));
|
|
if (attr && ::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(attr, "tile_id", emitError)))
|
|
return ::mlir::failure();
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1b_vert::readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state) {
|
|
auto &prop = state.getOrAddProperties<Properties>(); (void)prop;
|
|
if (::mlir::failed(reader.readAttribute(prop.tile_id)))
|
|
return ::mlir::failure();
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_ld1b_vert::writeProperties(::mlir::DialectBytecodeWriter &writer) {
|
|
auto &prop = getProperties(); (void)prop;
|
|
writer.writeAttribute(prop.tile_id);
|
|
}
|
|
|
|
uint32_t aarch64_sme_ld1b_vert::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
void aarch64_sme_ld1b_vert::setTileId(uint32_t attrValue) {
|
|
getProperties().tile_id = ::mlir::Builder((*this)->getContext()).getIntegerAttr(::mlir::Builder((*this)->getContext()).getIntegerType(32), attrValue);
|
|
}
|
|
|
|
void aarch64_sme_ld1b_vert::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(load_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
}
|
|
|
|
aarch64_sme_ld1b_vert aarch64_sme_ld1b_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1b_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1b_vert aarch64_sme_ld1b_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_ld1b_vert::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(load_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_ld1b_vert aarch64_sme_ld1b_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1b_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1b_vert aarch64_sme_ld1b_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_ld1b_vert::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(load_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
}
|
|
|
|
aarch64_sme_ld1b_vert aarch64_sme_ld1b_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1b_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1b_vert aarch64_sme_ld1b_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_ld1b_vert::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(load_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_ld1b_vert aarch64_sme_ld1b_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1b_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1b_vert aarch64_sme_ld1b_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_ld1b_vert::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
assert(operands.size() == 3u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.addAttributes(attributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
|
|
if (!attributes.empty()) {
|
|
(void)odsState.getOrAddProperties<aarch64_sme_ld1b_vert::Properties>();
|
|
::mlir::PropertyRef properties = odsState.getRawProperties();
|
|
std::optional<::mlir::RegisteredOperationName> info =
|
|
odsState.name.getRegisteredInfo();
|
|
if (failed(info->setOpPropertiesFromAttribute(odsState.name, properties,
|
|
odsState.attributes.getDictionary(odsState.getContext()), nullptr)))
|
|
::llvm::report_fatal_error("Property conversion failed.");
|
|
}
|
|
}
|
|
|
|
aarch64_sme_ld1b_vert aarch64_sme_ld1b_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1b_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1b_vert aarch64_sme_ld1b_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
}
|
|
|
|
void aarch64_sme_ld1b_vert::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
assert(operands.size() == 3u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.useProperties(const_cast<Properties&>(properties));
|
|
odsState.addAttributes(discardableAttributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_ld1b_vert aarch64_sme_ld1b_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1b_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1b_vert aarch64_sme_ld1b_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1b_vert::verifyInvariantsImpl() {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitOpError("requires attribute 'tile_id'");
|
|
|
|
if (::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(*this, tblgen_tile_id, "tile_id")))
|
|
return ::mlir::failure();
|
|
{
|
|
unsigned index = 0; (void)index;
|
|
auto valueGroup0 = getODSOperands(0);
|
|
|
|
for (auto v : valueGroup0) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps2(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup1 = getODSOperands(1);
|
|
|
|
for (auto v : valueGroup1) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps3(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup2 = getODSOperands(2);
|
|
|
|
for (auto v : valueGroup2) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps4(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1b_vert::verifyInvariants() {
|
|
return verifyInvariantsImpl();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1b_vert::setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
// keep track of used keys in the input dictionary to be able to error out
|
|
// if there are some unknown ones.
|
|
::mlir::DenseSet<::mlir::StringAttr> usedKeys;
|
|
::mlir::MLIRContext *ctx = dict.getContext();
|
|
(void)ctx;
|
|
{
|
|
|
|
auto &propStorage = prop.tile_id;
|
|
auto tile_idAttrName = ::mlir::StringAttr::get(ctx, "tile_id");
|
|
auto attr = dict.get(tile_idAttrName);
|
|
usedKeys.insert(tile_idAttrName);
|
|
if (attr || /*isRequired=*/true) {
|
|
if (!attr) {
|
|
emitError() << "expected key entry for tile_id in DictionaryAttr to set "
|
|
"Properties.";
|
|
return ::mlir::failure();
|
|
}
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
|
|
for (::mlir::NamedAttribute attr : dict) {
|
|
if (!usedKeys.contains(attr.getName()))
|
|
return emitError() << "unknown key '" << attr.getName() <<
|
|
"' when parsing properties dictionary";
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
|
|
} // namespace mlir::arm_sme
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::aarch64_sme_ld1b_vert)
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::detail::aarch64_sme_ld1b_vertGenericAdaptorBase::Properties)
|
|
|
|
namespace mlir::arm_sme {
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ::mlir::arm_sme::aarch64_sme_ld1d_horiz definitions
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace detail {
|
|
|
|
aarch64_sme_ld1d_horizGenericAdaptorBase::aarch64_sme_ld1d_horizGenericAdaptorBase(aarch64_sme_ld1d_horiz op) : odsAttrs(op->getRawDictionaryAttrs()), odsOpName(op->getName()), properties(op.getProperties()), odsRegions(op->getRegions()) {}
|
|
|
|
uint32_t aarch64_sme_ld1d_horizGenericAdaptorBase::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
|
|
} // namespace detail
|
|
aarch64_sme_ld1d_horizAdaptor::aarch64_sme_ld1d_horizAdaptor(aarch64_sme_ld1d_horiz op) : aarch64_sme_ld1d_horizGenericAdaptor(op->getOperands(), op) {}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1d_horizAdaptor::verify(::mlir::Location loc) {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitError(loc, "'arm_sme.intr.ld1d.horiz' op requires attribute 'tile_id'");
|
|
|
|
if (tblgen_tile_id && !(((::llvm::isa<::mlir::IntegerAttr>(tblgen_tile_id))) && ((::llvm::cast<::mlir::IntegerAttr>(tblgen_tile_id).getType().isSignlessInteger(32)))))
|
|
return emitError(loc, "'arm_sme.intr.ld1d.horiz' op attribute 'tile_id' failed to satisfy constraint: 32-bit signless integer attribute");
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1d_horiz::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
|
|
{
|
|
auto &propStorage = prop.tile_id;
|
|
auto attr = dict.get("tile_id");
|
|
if (attr) {
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::mlir::Attribute aarch64_sme_ld1d_horiz::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) {
|
|
::mlir::SmallVector<::mlir::NamedAttribute> attrs;
|
|
::mlir::Builder odsBuilder{ctx};
|
|
|
|
{
|
|
const auto &propStorage = prop.tile_id;
|
|
if (propStorage)
|
|
attrs.push_back(odsBuilder.getNamedAttr("tile_id",
|
|
propStorage));
|
|
}
|
|
|
|
if (!attrs.empty())
|
|
return odsBuilder.getDictionaryAttr(attrs);
|
|
return {};
|
|
}
|
|
|
|
llvm::hash_code aarch64_sme_ld1d_horiz::computePropertiesHash(const Properties &prop) {
|
|
using llvm::hash_value;
|
|
return llvm::hash_combine(
|
|
llvm::hash_value(prop.tile_id.getAsOpaquePointer()));
|
|
}
|
|
|
|
std::optional<mlir::Attribute> aarch64_sme_ld1d_horiz::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) {
|
|
if (name == "tile_id")
|
|
return prop.tile_id;
|
|
return std::nullopt;
|
|
}
|
|
|
|
void aarch64_sme_ld1d_horiz::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) {
|
|
if (name == "tile_id") {
|
|
prop.tile_id = ::llvm::dyn_cast_or_null<std::remove_reference_t<decltype(prop.tile_id)>>(value);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void aarch64_sme_ld1d_horiz::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) {
|
|
if (prop.tile_id) attrs.append("tile_id", prop.tile_id);
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1d_horiz::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
{
|
|
::mlir::Attribute attr = attrs.get(getTileIdAttrName(opName));
|
|
if (attr && ::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(attr, "tile_id", emitError)))
|
|
return ::mlir::failure();
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1d_horiz::readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state) {
|
|
auto &prop = state.getOrAddProperties<Properties>(); (void)prop;
|
|
if (::mlir::failed(reader.readAttribute(prop.tile_id)))
|
|
return ::mlir::failure();
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_ld1d_horiz::writeProperties(::mlir::DialectBytecodeWriter &writer) {
|
|
auto &prop = getProperties(); (void)prop;
|
|
writer.writeAttribute(prop.tile_id);
|
|
}
|
|
|
|
uint32_t aarch64_sme_ld1d_horiz::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
void aarch64_sme_ld1d_horiz::setTileId(uint32_t attrValue) {
|
|
getProperties().tile_id = ::mlir::Builder((*this)->getContext()).getIntegerAttr(::mlir::Builder((*this)->getContext()).getIntegerType(32), attrValue);
|
|
}
|
|
|
|
void aarch64_sme_ld1d_horiz::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(load_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
}
|
|
|
|
aarch64_sme_ld1d_horiz aarch64_sme_ld1d_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1d_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1d_horiz aarch64_sme_ld1d_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_ld1d_horiz::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(load_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_ld1d_horiz aarch64_sme_ld1d_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1d_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1d_horiz aarch64_sme_ld1d_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_ld1d_horiz::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(load_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
}
|
|
|
|
aarch64_sme_ld1d_horiz aarch64_sme_ld1d_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1d_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1d_horiz aarch64_sme_ld1d_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_ld1d_horiz::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(load_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_ld1d_horiz aarch64_sme_ld1d_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1d_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1d_horiz aarch64_sme_ld1d_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_ld1d_horiz::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
assert(operands.size() == 3u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.addAttributes(attributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
|
|
if (!attributes.empty()) {
|
|
(void)odsState.getOrAddProperties<aarch64_sme_ld1d_horiz::Properties>();
|
|
::mlir::PropertyRef properties = odsState.getRawProperties();
|
|
std::optional<::mlir::RegisteredOperationName> info =
|
|
odsState.name.getRegisteredInfo();
|
|
if (failed(info->setOpPropertiesFromAttribute(odsState.name, properties,
|
|
odsState.attributes.getDictionary(odsState.getContext()), nullptr)))
|
|
::llvm::report_fatal_error("Property conversion failed.");
|
|
}
|
|
}
|
|
|
|
aarch64_sme_ld1d_horiz aarch64_sme_ld1d_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1d_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1d_horiz aarch64_sme_ld1d_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
}
|
|
|
|
void aarch64_sme_ld1d_horiz::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
assert(operands.size() == 3u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.useProperties(const_cast<Properties&>(properties));
|
|
odsState.addAttributes(discardableAttributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_ld1d_horiz aarch64_sme_ld1d_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1d_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1d_horiz aarch64_sme_ld1d_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1d_horiz::verifyInvariantsImpl() {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitOpError("requires attribute 'tile_id'");
|
|
|
|
if (::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(*this, tblgen_tile_id, "tile_id")))
|
|
return ::mlir::failure();
|
|
{
|
|
unsigned index = 0; (void)index;
|
|
auto valueGroup0 = getODSOperands(0);
|
|
|
|
for (auto v : valueGroup0) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps2(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup1 = getODSOperands(1);
|
|
|
|
for (auto v : valueGroup1) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps3(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup2 = getODSOperands(2);
|
|
|
|
for (auto v : valueGroup2) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps4(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1d_horiz::verifyInvariants() {
|
|
return verifyInvariantsImpl();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1d_horiz::setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
// keep track of used keys in the input dictionary to be able to error out
|
|
// if there are some unknown ones.
|
|
::mlir::DenseSet<::mlir::StringAttr> usedKeys;
|
|
::mlir::MLIRContext *ctx = dict.getContext();
|
|
(void)ctx;
|
|
{
|
|
|
|
auto &propStorage = prop.tile_id;
|
|
auto tile_idAttrName = ::mlir::StringAttr::get(ctx, "tile_id");
|
|
auto attr = dict.get(tile_idAttrName);
|
|
usedKeys.insert(tile_idAttrName);
|
|
if (attr || /*isRequired=*/true) {
|
|
if (!attr) {
|
|
emitError() << "expected key entry for tile_id in DictionaryAttr to set "
|
|
"Properties.";
|
|
return ::mlir::failure();
|
|
}
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
|
|
for (::mlir::NamedAttribute attr : dict) {
|
|
if (!usedKeys.contains(attr.getName()))
|
|
return emitError() << "unknown key '" << attr.getName() <<
|
|
"' when parsing properties dictionary";
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
|
|
} // namespace mlir::arm_sme
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::aarch64_sme_ld1d_horiz)
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::detail::aarch64_sme_ld1d_horizGenericAdaptorBase::Properties)
|
|
|
|
namespace mlir::arm_sme {
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ::mlir::arm_sme::aarch64_sme_ld1d_vert definitions
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace detail {
|
|
|
|
aarch64_sme_ld1d_vertGenericAdaptorBase::aarch64_sme_ld1d_vertGenericAdaptorBase(aarch64_sme_ld1d_vert op) : odsAttrs(op->getRawDictionaryAttrs()), odsOpName(op->getName()), properties(op.getProperties()), odsRegions(op->getRegions()) {}
|
|
|
|
uint32_t aarch64_sme_ld1d_vertGenericAdaptorBase::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
|
|
} // namespace detail
|
|
aarch64_sme_ld1d_vertAdaptor::aarch64_sme_ld1d_vertAdaptor(aarch64_sme_ld1d_vert op) : aarch64_sme_ld1d_vertGenericAdaptor(op->getOperands(), op) {}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1d_vertAdaptor::verify(::mlir::Location loc) {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitError(loc, "'arm_sme.intr.ld1d.vert' op requires attribute 'tile_id'");
|
|
|
|
if (tblgen_tile_id && !(((::llvm::isa<::mlir::IntegerAttr>(tblgen_tile_id))) && ((::llvm::cast<::mlir::IntegerAttr>(tblgen_tile_id).getType().isSignlessInteger(32)))))
|
|
return emitError(loc, "'arm_sme.intr.ld1d.vert' op attribute 'tile_id' failed to satisfy constraint: 32-bit signless integer attribute");
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1d_vert::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
|
|
{
|
|
auto &propStorage = prop.tile_id;
|
|
auto attr = dict.get("tile_id");
|
|
if (attr) {
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::mlir::Attribute aarch64_sme_ld1d_vert::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) {
|
|
::mlir::SmallVector<::mlir::NamedAttribute> attrs;
|
|
::mlir::Builder odsBuilder{ctx};
|
|
|
|
{
|
|
const auto &propStorage = prop.tile_id;
|
|
if (propStorage)
|
|
attrs.push_back(odsBuilder.getNamedAttr("tile_id",
|
|
propStorage));
|
|
}
|
|
|
|
if (!attrs.empty())
|
|
return odsBuilder.getDictionaryAttr(attrs);
|
|
return {};
|
|
}
|
|
|
|
llvm::hash_code aarch64_sme_ld1d_vert::computePropertiesHash(const Properties &prop) {
|
|
using llvm::hash_value;
|
|
return llvm::hash_combine(
|
|
llvm::hash_value(prop.tile_id.getAsOpaquePointer()));
|
|
}
|
|
|
|
std::optional<mlir::Attribute> aarch64_sme_ld1d_vert::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) {
|
|
if (name == "tile_id")
|
|
return prop.tile_id;
|
|
return std::nullopt;
|
|
}
|
|
|
|
void aarch64_sme_ld1d_vert::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) {
|
|
if (name == "tile_id") {
|
|
prop.tile_id = ::llvm::dyn_cast_or_null<std::remove_reference_t<decltype(prop.tile_id)>>(value);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void aarch64_sme_ld1d_vert::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) {
|
|
if (prop.tile_id) attrs.append("tile_id", prop.tile_id);
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1d_vert::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
{
|
|
::mlir::Attribute attr = attrs.get(getTileIdAttrName(opName));
|
|
if (attr && ::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(attr, "tile_id", emitError)))
|
|
return ::mlir::failure();
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1d_vert::readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state) {
|
|
auto &prop = state.getOrAddProperties<Properties>(); (void)prop;
|
|
if (::mlir::failed(reader.readAttribute(prop.tile_id)))
|
|
return ::mlir::failure();
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_ld1d_vert::writeProperties(::mlir::DialectBytecodeWriter &writer) {
|
|
auto &prop = getProperties(); (void)prop;
|
|
writer.writeAttribute(prop.tile_id);
|
|
}
|
|
|
|
uint32_t aarch64_sme_ld1d_vert::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
void aarch64_sme_ld1d_vert::setTileId(uint32_t attrValue) {
|
|
getProperties().tile_id = ::mlir::Builder((*this)->getContext()).getIntegerAttr(::mlir::Builder((*this)->getContext()).getIntegerType(32), attrValue);
|
|
}
|
|
|
|
void aarch64_sme_ld1d_vert::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(load_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
}
|
|
|
|
aarch64_sme_ld1d_vert aarch64_sme_ld1d_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1d_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1d_vert aarch64_sme_ld1d_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_ld1d_vert::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(load_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_ld1d_vert aarch64_sme_ld1d_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1d_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1d_vert aarch64_sme_ld1d_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_ld1d_vert::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(load_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
}
|
|
|
|
aarch64_sme_ld1d_vert aarch64_sme_ld1d_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1d_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1d_vert aarch64_sme_ld1d_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_ld1d_vert::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(load_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_ld1d_vert aarch64_sme_ld1d_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1d_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1d_vert aarch64_sme_ld1d_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_ld1d_vert::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
assert(operands.size() == 3u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.addAttributes(attributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
|
|
if (!attributes.empty()) {
|
|
(void)odsState.getOrAddProperties<aarch64_sme_ld1d_vert::Properties>();
|
|
::mlir::PropertyRef properties = odsState.getRawProperties();
|
|
std::optional<::mlir::RegisteredOperationName> info =
|
|
odsState.name.getRegisteredInfo();
|
|
if (failed(info->setOpPropertiesFromAttribute(odsState.name, properties,
|
|
odsState.attributes.getDictionary(odsState.getContext()), nullptr)))
|
|
::llvm::report_fatal_error("Property conversion failed.");
|
|
}
|
|
}
|
|
|
|
aarch64_sme_ld1d_vert aarch64_sme_ld1d_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1d_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1d_vert aarch64_sme_ld1d_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
}
|
|
|
|
void aarch64_sme_ld1d_vert::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
assert(operands.size() == 3u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.useProperties(const_cast<Properties&>(properties));
|
|
odsState.addAttributes(discardableAttributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_ld1d_vert aarch64_sme_ld1d_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1d_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1d_vert aarch64_sme_ld1d_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1d_vert::verifyInvariantsImpl() {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitOpError("requires attribute 'tile_id'");
|
|
|
|
if (::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(*this, tblgen_tile_id, "tile_id")))
|
|
return ::mlir::failure();
|
|
{
|
|
unsigned index = 0; (void)index;
|
|
auto valueGroup0 = getODSOperands(0);
|
|
|
|
for (auto v : valueGroup0) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps2(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup1 = getODSOperands(1);
|
|
|
|
for (auto v : valueGroup1) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps3(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup2 = getODSOperands(2);
|
|
|
|
for (auto v : valueGroup2) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps4(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1d_vert::verifyInvariants() {
|
|
return verifyInvariantsImpl();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1d_vert::setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
// keep track of used keys in the input dictionary to be able to error out
|
|
// if there are some unknown ones.
|
|
::mlir::DenseSet<::mlir::StringAttr> usedKeys;
|
|
::mlir::MLIRContext *ctx = dict.getContext();
|
|
(void)ctx;
|
|
{
|
|
|
|
auto &propStorage = prop.tile_id;
|
|
auto tile_idAttrName = ::mlir::StringAttr::get(ctx, "tile_id");
|
|
auto attr = dict.get(tile_idAttrName);
|
|
usedKeys.insert(tile_idAttrName);
|
|
if (attr || /*isRequired=*/true) {
|
|
if (!attr) {
|
|
emitError() << "expected key entry for tile_id in DictionaryAttr to set "
|
|
"Properties.";
|
|
return ::mlir::failure();
|
|
}
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
|
|
for (::mlir::NamedAttribute attr : dict) {
|
|
if (!usedKeys.contains(attr.getName()))
|
|
return emitError() << "unknown key '" << attr.getName() <<
|
|
"' when parsing properties dictionary";
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
|
|
} // namespace mlir::arm_sme
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::aarch64_sme_ld1d_vert)
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::detail::aarch64_sme_ld1d_vertGenericAdaptorBase::Properties)
|
|
|
|
namespace mlir::arm_sme {
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ::mlir::arm_sme::aarch64_sme_ld1h_horiz definitions
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace detail {
|
|
|
|
aarch64_sme_ld1h_horizGenericAdaptorBase::aarch64_sme_ld1h_horizGenericAdaptorBase(aarch64_sme_ld1h_horiz op) : odsAttrs(op->getRawDictionaryAttrs()), odsOpName(op->getName()), properties(op.getProperties()), odsRegions(op->getRegions()) {}
|
|
|
|
uint32_t aarch64_sme_ld1h_horizGenericAdaptorBase::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
|
|
} // namespace detail
|
|
aarch64_sme_ld1h_horizAdaptor::aarch64_sme_ld1h_horizAdaptor(aarch64_sme_ld1h_horiz op) : aarch64_sme_ld1h_horizGenericAdaptor(op->getOperands(), op) {}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1h_horizAdaptor::verify(::mlir::Location loc) {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitError(loc, "'arm_sme.intr.ld1h.horiz' op requires attribute 'tile_id'");
|
|
|
|
if (tblgen_tile_id && !(((::llvm::isa<::mlir::IntegerAttr>(tblgen_tile_id))) && ((::llvm::cast<::mlir::IntegerAttr>(tblgen_tile_id).getType().isSignlessInteger(32)))))
|
|
return emitError(loc, "'arm_sme.intr.ld1h.horiz' op attribute 'tile_id' failed to satisfy constraint: 32-bit signless integer attribute");
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1h_horiz::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
|
|
{
|
|
auto &propStorage = prop.tile_id;
|
|
auto attr = dict.get("tile_id");
|
|
if (attr) {
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::mlir::Attribute aarch64_sme_ld1h_horiz::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) {
|
|
::mlir::SmallVector<::mlir::NamedAttribute> attrs;
|
|
::mlir::Builder odsBuilder{ctx};
|
|
|
|
{
|
|
const auto &propStorage = prop.tile_id;
|
|
if (propStorage)
|
|
attrs.push_back(odsBuilder.getNamedAttr("tile_id",
|
|
propStorage));
|
|
}
|
|
|
|
if (!attrs.empty())
|
|
return odsBuilder.getDictionaryAttr(attrs);
|
|
return {};
|
|
}
|
|
|
|
llvm::hash_code aarch64_sme_ld1h_horiz::computePropertiesHash(const Properties &prop) {
|
|
using llvm::hash_value;
|
|
return llvm::hash_combine(
|
|
llvm::hash_value(prop.tile_id.getAsOpaquePointer()));
|
|
}
|
|
|
|
std::optional<mlir::Attribute> aarch64_sme_ld1h_horiz::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) {
|
|
if (name == "tile_id")
|
|
return prop.tile_id;
|
|
return std::nullopt;
|
|
}
|
|
|
|
void aarch64_sme_ld1h_horiz::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) {
|
|
if (name == "tile_id") {
|
|
prop.tile_id = ::llvm::dyn_cast_or_null<std::remove_reference_t<decltype(prop.tile_id)>>(value);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void aarch64_sme_ld1h_horiz::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) {
|
|
if (prop.tile_id) attrs.append("tile_id", prop.tile_id);
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1h_horiz::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
{
|
|
::mlir::Attribute attr = attrs.get(getTileIdAttrName(opName));
|
|
if (attr && ::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(attr, "tile_id", emitError)))
|
|
return ::mlir::failure();
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1h_horiz::readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state) {
|
|
auto &prop = state.getOrAddProperties<Properties>(); (void)prop;
|
|
if (::mlir::failed(reader.readAttribute(prop.tile_id)))
|
|
return ::mlir::failure();
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_ld1h_horiz::writeProperties(::mlir::DialectBytecodeWriter &writer) {
|
|
auto &prop = getProperties(); (void)prop;
|
|
writer.writeAttribute(prop.tile_id);
|
|
}
|
|
|
|
uint32_t aarch64_sme_ld1h_horiz::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
void aarch64_sme_ld1h_horiz::setTileId(uint32_t attrValue) {
|
|
getProperties().tile_id = ::mlir::Builder((*this)->getContext()).getIntegerAttr(::mlir::Builder((*this)->getContext()).getIntegerType(32), attrValue);
|
|
}
|
|
|
|
void aarch64_sme_ld1h_horiz::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(load_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
}
|
|
|
|
aarch64_sme_ld1h_horiz aarch64_sme_ld1h_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1h_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1h_horiz aarch64_sme_ld1h_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_ld1h_horiz::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(load_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_ld1h_horiz aarch64_sme_ld1h_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1h_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1h_horiz aarch64_sme_ld1h_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_ld1h_horiz::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(load_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
}
|
|
|
|
aarch64_sme_ld1h_horiz aarch64_sme_ld1h_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1h_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1h_horiz aarch64_sme_ld1h_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_ld1h_horiz::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(load_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_ld1h_horiz aarch64_sme_ld1h_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1h_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1h_horiz aarch64_sme_ld1h_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_ld1h_horiz::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
assert(operands.size() == 3u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.addAttributes(attributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
|
|
if (!attributes.empty()) {
|
|
(void)odsState.getOrAddProperties<aarch64_sme_ld1h_horiz::Properties>();
|
|
::mlir::PropertyRef properties = odsState.getRawProperties();
|
|
std::optional<::mlir::RegisteredOperationName> info =
|
|
odsState.name.getRegisteredInfo();
|
|
if (failed(info->setOpPropertiesFromAttribute(odsState.name, properties,
|
|
odsState.attributes.getDictionary(odsState.getContext()), nullptr)))
|
|
::llvm::report_fatal_error("Property conversion failed.");
|
|
}
|
|
}
|
|
|
|
aarch64_sme_ld1h_horiz aarch64_sme_ld1h_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1h_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1h_horiz aarch64_sme_ld1h_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
}
|
|
|
|
void aarch64_sme_ld1h_horiz::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
assert(operands.size() == 3u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.useProperties(const_cast<Properties&>(properties));
|
|
odsState.addAttributes(discardableAttributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_ld1h_horiz aarch64_sme_ld1h_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1h_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1h_horiz aarch64_sme_ld1h_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1h_horiz::verifyInvariantsImpl() {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitOpError("requires attribute 'tile_id'");
|
|
|
|
if (::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(*this, tblgen_tile_id, "tile_id")))
|
|
return ::mlir::failure();
|
|
{
|
|
unsigned index = 0; (void)index;
|
|
auto valueGroup0 = getODSOperands(0);
|
|
|
|
for (auto v : valueGroup0) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps2(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup1 = getODSOperands(1);
|
|
|
|
for (auto v : valueGroup1) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps3(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup2 = getODSOperands(2);
|
|
|
|
for (auto v : valueGroup2) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps4(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1h_horiz::verifyInvariants() {
|
|
return verifyInvariantsImpl();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1h_horiz::setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
// keep track of used keys in the input dictionary to be able to error out
|
|
// if there are some unknown ones.
|
|
::mlir::DenseSet<::mlir::StringAttr> usedKeys;
|
|
::mlir::MLIRContext *ctx = dict.getContext();
|
|
(void)ctx;
|
|
{
|
|
|
|
auto &propStorage = prop.tile_id;
|
|
auto tile_idAttrName = ::mlir::StringAttr::get(ctx, "tile_id");
|
|
auto attr = dict.get(tile_idAttrName);
|
|
usedKeys.insert(tile_idAttrName);
|
|
if (attr || /*isRequired=*/true) {
|
|
if (!attr) {
|
|
emitError() << "expected key entry for tile_id in DictionaryAttr to set "
|
|
"Properties.";
|
|
return ::mlir::failure();
|
|
}
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
|
|
for (::mlir::NamedAttribute attr : dict) {
|
|
if (!usedKeys.contains(attr.getName()))
|
|
return emitError() << "unknown key '" << attr.getName() <<
|
|
"' when parsing properties dictionary";
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
|
|
} // namespace mlir::arm_sme
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::aarch64_sme_ld1h_horiz)
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::detail::aarch64_sme_ld1h_horizGenericAdaptorBase::Properties)
|
|
|
|
namespace mlir::arm_sme {
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ::mlir::arm_sme::aarch64_sme_ld1h_vert definitions
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace detail {
|
|
|
|
aarch64_sme_ld1h_vertGenericAdaptorBase::aarch64_sme_ld1h_vertGenericAdaptorBase(aarch64_sme_ld1h_vert op) : odsAttrs(op->getRawDictionaryAttrs()), odsOpName(op->getName()), properties(op.getProperties()), odsRegions(op->getRegions()) {}
|
|
|
|
uint32_t aarch64_sme_ld1h_vertGenericAdaptorBase::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
|
|
} // namespace detail
|
|
aarch64_sme_ld1h_vertAdaptor::aarch64_sme_ld1h_vertAdaptor(aarch64_sme_ld1h_vert op) : aarch64_sme_ld1h_vertGenericAdaptor(op->getOperands(), op) {}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1h_vertAdaptor::verify(::mlir::Location loc) {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitError(loc, "'arm_sme.intr.ld1h.vert' op requires attribute 'tile_id'");
|
|
|
|
if (tblgen_tile_id && !(((::llvm::isa<::mlir::IntegerAttr>(tblgen_tile_id))) && ((::llvm::cast<::mlir::IntegerAttr>(tblgen_tile_id).getType().isSignlessInteger(32)))))
|
|
return emitError(loc, "'arm_sme.intr.ld1h.vert' op attribute 'tile_id' failed to satisfy constraint: 32-bit signless integer attribute");
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1h_vert::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
|
|
{
|
|
auto &propStorage = prop.tile_id;
|
|
auto attr = dict.get("tile_id");
|
|
if (attr) {
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::mlir::Attribute aarch64_sme_ld1h_vert::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) {
|
|
::mlir::SmallVector<::mlir::NamedAttribute> attrs;
|
|
::mlir::Builder odsBuilder{ctx};
|
|
|
|
{
|
|
const auto &propStorage = prop.tile_id;
|
|
if (propStorage)
|
|
attrs.push_back(odsBuilder.getNamedAttr("tile_id",
|
|
propStorage));
|
|
}
|
|
|
|
if (!attrs.empty())
|
|
return odsBuilder.getDictionaryAttr(attrs);
|
|
return {};
|
|
}
|
|
|
|
llvm::hash_code aarch64_sme_ld1h_vert::computePropertiesHash(const Properties &prop) {
|
|
using llvm::hash_value;
|
|
return llvm::hash_combine(
|
|
llvm::hash_value(prop.tile_id.getAsOpaquePointer()));
|
|
}
|
|
|
|
std::optional<mlir::Attribute> aarch64_sme_ld1h_vert::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) {
|
|
if (name == "tile_id")
|
|
return prop.tile_id;
|
|
return std::nullopt;
|
|
}
|
|
|
|
void aarch64_sme_ld1h_vert::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) {
|
|
if (name == "tile_id") {
|
|
prop.tile_id = ::llvm::dyn_cast_or_null<std::remove_reference_t<decltype(prop.tile_id)>>(value);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void aarch64_sme_ld1h_vert::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) {
|
|
if (prop.tile_id) attrs.append("tile_id", prop.tile_id);
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1h_vert::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
{
|
|
::mlir::Attribute attr = attrs.get(getTileIdAttrName(opName));
|
|
if (attr && ::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(attr, "tile_id", emitError)))
|
|
return ::mlir::failure();
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1h_vert::readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state) {
|
|
auto &prop = state.getOrAddProperties<Properties>(); (void)prop;
|
|
if (::mlir::failed(reader.readAttribute(prop.tile_id)))
|
|
return ::mlir::failure();
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_ld1h_vert::writeProperties(::mlir::DialectBytecodeWriter &writer) {
|
|
auto &prop = getProperties(); (void)prop;
|
|
writer.writeAttribute(prop.tile_id);
|
|
}
|
|
|
|
uint32_t aarch64_sme_ld1h_vert::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
void aarch64_sme_ld1h_vert::setTileId(uint32_t attrValue) {
|
|
getProperties().tile_id = ::mlir::Builder((*this)->getContext()).getIntegerAttr(::mlir::Builder((*this)->getContext()).getIntegerType(32), attrValue);
|
|
}
|
|
|
|
void aarch64_sme_ld1h_vert::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(load_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
}
|
|
|
|
aarch64_sme_ld1h_vert aarch64_sme_ld1h_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1h_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1h_vert aarch64_sme_ld1h_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_ld1h_vert::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(load_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_ld1h_vert aarch64_sme_ld1h_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1h_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1h_vert aarch64_sme_ld1h_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_ld1h_vert::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(load_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
}
|
|
|
|
aarch64_sme_ld1h_vert aarch64_sme_ld1h_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1h_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1h_vert aarch64_sme_ld1h_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_ld1h_vert::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(load_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_ld1h_vert aarch64_sme_ld1h_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1h_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1h_vert aarch64_sme_ld1h_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_ld1h_vert::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
assert(operands.size() == 3u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.addAttributes(attributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
|
|
if (!attributes.empty()) {
|
|
(void)odsState.getOrAddProperties<aarch64_sme_ld1h_vert::Properties>();
|
|
::mlir::PropertyRef properties = odsState.getRawProperties();
|
|
std::optional<::mlir::RegisteredOperationName> info =
|
|
odsState.name.getRegisteredInfo();
|
|
if (failed(info->setOpPropertiesFromAttribute(odsState.name, properties,
|
|
odsState.attributes.getDictionary(odsState.getContext()), nullptr)))
|
|
::llvm::report_fatal_error("Property conversion failed.");
|
|
}
|
|
}
|
|
|
|
aarch64_sme_ld1h_vert aarch64_sme_ld1h_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1h_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1h_vert aarch64_sme_ld1h_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
}
|
|
|
|
void aarch64_sme_ld1h_vert::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
assert(operands.size() == 3u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.useProperties(const_cast<Properties&>(properties));
|
|
odsState.addAttributes(discardableAttributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_ld1h_vert aarch64_sme_ld1h_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1h_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1h_vert aarch64_sme_ld1h_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1h_vert::verifyInvariantsImpl() {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitOpError("requires attribute 'tile_id'");
|
|
|
|
if (::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(*this, tblgen_tile_id, "tile_id")))
|
|
return ::mlir::failure();
|
|
{
|
|
unsigned index = 0; (void)index;
|
|
auto valueGroup0 = getODSOperands(0);
|
|
|
|
for (auto v : valueGroup0) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps2(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup1 = getODSOperands(1);
|
|
|
|
for (auto v : valueGroup1) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps3(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup2 = getODSOperands(2);
|
|
|
|
for (auto v : valueGroup2) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps4(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1h_vert::verifyInvariants() {
|
|
return verifyInvariantsImpl();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1h_vert::setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
// keep track of used keys in the input dictionary to be able to error out
|
|
// if there are some unknown ones.
|
|
::mlir::DenseSet<::mlir::StringAttr> usedKeys;
|
|
::mlir::MLIRContext *ctx = dict.getContext();
|
|
(void)ctx;
|
|
{
|
|
|
|
auto &propStorage = prop.tile_id;
|
|
auto tile_idAttrName = ::mlir::StringAttr::get(ctx, "tile_id");
|
|
auto attr = dict.get(tile_idAttrName);
|
|
usedKeys.insert(tile_idAttrName);
|
|
if (attr || /*isRequired=*/true) {
|
|
if (!attr) {
|
|
emitError() << "expected key entry for tile_id in DictionaryAttr to set "
|
|
"Properties.";
|
|
return ::mlir::failure();
|
|
}
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
|
|
for (::mlir::NamedAttribute attr : dict) {
|
|
if (!usedKeys.contains(attr.getName()))
|
|
return emitError() << "unknown key '" << attr.getName() <<
|
|
"' when parsing properties dictionary";
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
|
|
} // namespace mlir::arm_sme
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::aarch64_sme_ld1h_vert)
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::detail::aarch64_sme_ld1h_vertGenericAdaptorBase::Properties)
|
|
|
|
namespace mlir::arm_sme {
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ::mlir::arm_sme::aarch64_sme_ld1q_horiz definitions
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace detail {
|
|
|
|
aarch64_sme_ld1q_horizGenericAdaptorBase::aarch64_sme_ld1q_horizGenericAdaptorBase(aarch64_sme_ld1q_horiz op) : odsAttrs(op->getRawDictionaryAttrs()), odsOpName(op->getName()), properties(op.getProperties()), odsRegions(op->getRegions()) {}
|
|
|
|
uint32_t aarch64_sme_ld1q_horizGenericAdaptorBase::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
|
|
} // namespace detail
|
|
aarch64_sme_ld1q_horizAdaptor::aarch64_sme_ld1q_horizAdaptor(aarch64_sme_ld1q_horiz op) : aarch64_sme_ld1q_horizGenericAdaptor(op->getOperands(), op) {}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1q_horizAdaptor::verify(::mlir::Location loc) {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitError(loc, "'arm_sme.intr.ld1q.horiz' op requires attribute 'tile_id'");
|
|
|
|
if (tblgen_tile_id && !(((::llvm::isa<::mlir::IntegerAttr>(tblgen_tile_id))) && ((::llvm::cast<::mlir::IntegerAttr>(tblgen_tile_id).getType().isSignlessInteger(32)))))
|
|
return emitError(loc, "'arm_sme.intr.ld1q.horiz' op attribute 'tile_id' failed to satisfy constraint: 32-bit signless integer attribute");
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1q_horiz::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
|
|
{
|
|
auto &propStorage = prop.tile_id;
|
|
auto attr = dict.get("tile_id");
|
|
if (attr) {
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::mlir::Attribute aarch64_sme_ld1q_horiz::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) {
|
|
::mlir::SmallVector<::mlir::NamedAttribute> attrs;
|
|
::mlir::Builder odsBuilder{ctx};
|
|
|
|
{
|
|
const auto &propStorage = prop.tile_id;
|
|
if (propStorage)
|
|
attrs.push_back(odsBuilder.getNamedAttr("tile_id",
|
|
propStorage));
|
|
}
|
|
|
|
if (!attrs.empty())
|
|
return odsBuilder.getDictionaryAttr(attrs);
|
|
return {};
|
|
}
|
|
|
|
llvm::hash_code aarch64_sme_ld1q_horiz::computePropertiesHash(const Properties &prop) {
|
|
using llvm::hash_value;
|
|
return llvm::hash_combine(
|
|
llvm::hash_value(prop.tile_id.getAsOpaquePointer()));
|
|
}
|
|
|
|
std::optional<mlir::Attribute> aarch64_sme_ld1q_horiz::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) {
|
|
if (name == "tile_id")
|
|
return prop.tile_id;
|
|
return std::nullopt;
|
|
}
|
|
|
|
void aarch64_sme_ld1q_horiz::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) {
|
|
if (name == "tile_id") {
|
|
prop.tile_id = ::llvm::dyn_cast_or_null<std::remove_reference_t<decltype(prop.tile_id)>>(value);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void aarch64_sme_ld1q_horiz::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) {
|
|
if (prop.tile_id) attrs.append("tile_id", prop.tile_id);
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1q_horiz::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
{
|
|
::mlir::Attribute attr = attrs.get(getTileIdAttrName(opName));
|
|
if (attr && ::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(attr, "tile_id", emitError)))
|
|
return ::mlir::failure();
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1q_horiz::readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state) {
|
|
auto &prop = state.getOrAddProperties<Properties>(); (void)prop;
|
|
if (::mlir::failed(reader.readAttribute(prop.tile_id)))
|
|
return ::mlir::failure();
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_ld1q_horiz::writeProperties(::mlir::DialectBytecodeWriter &writer) {
|
|
auto &prop = getProperties(); (void)prop;
|
|
writer.writeAttribute(prop.tile_id);
|
|
}
|
|
|
|
uint32_t aarch64_sme_ld1q_horiz::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
void aarch64_sme_ld1q_horiz::setTileId(uint32_t attrValue) {
|
|
getProperties().tile_id = ::mlir::Builder((*this)->getContext()).getIntegerAttr(::mlir::Builder((*this)->getContext()).getIntegerType(32), attrValue);
|
|
}
|
|
|
|
void aarch64_sme_ld1q_horiz::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(load_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
}
|
|
|
|
aarch64_sme_ld1q_horiz aarch64_sme_ld1q_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1q_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1q_horiz aarch64_sme_ld1q_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_ld1q_horiz::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(load_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_ld1q_horiz aarch64_sme_ld1q_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1q_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1q_horiz aarch64_sme_ld1q_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_ld1q_horiz::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(load_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
}
|
|
|
|
aarch64_sme_ld1q_horiz aarch64_sme_ld1q_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1q_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1q_horiz aarch64_sme_ld1q_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_ld1q_horiz::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(load_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_ld1q_horiz aarch64_sme_ld1q_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1q_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1q_horiz aarch64_sme_ld1q_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_ld1q_horiz::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
assert(operands.size() == 3u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.addAttributes(attributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
|
|
if (!attributes.empty()) {
|
|
(void)odsState.getOrAddProperties<aarch64_sme_ld1q_horiz::Properties>();
|
|
::mlir::PropertyRef properties = odsState.getRawProperties();
|
|
std::optional<::mlir::RegisteredOperationName> info =
|
|
odsState.name.getRegisteredInfo();
|
|
if (failed(info->setOpPropertiesFromAttribute(odsState.name, properties,
|
|
odsState.attributes.getDictionary(odsState.getContext()), nullptr)))
|
|
::llvm::report_fatal_error("Property conversion failed.");
|
|
}
|
|
}
|
|
|
|
aarch64_sme_ld1q_horiz aarch64_sme_ld1q_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1q_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1q_horiz aarch64_sme_ld1q_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
}
|
|
|
|
void aarch64_sme_ld1q_horiz::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
assert(operands.size() == 3u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.useProperties(const_cast<Properties&>(properties));
|
|
odsState.addAttributes(discardableAttributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_ld1q_horiz aarch64_sme_ld1q_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1q_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1q_horiz aarch64_sme_ld1q_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1q_horiz::verifyInvariantsImpl() {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitOpError("requires attribute 'tile_id'");
|
|
|
|
if (::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(*this, tblgen_tile_id, "tile_id")))
|
|
return ::mlir::failure();
|
|
{
|
|
unsigned index = 0; (void)index;
|
|
auto valueGroup0 = getODSOperands(0);
|
|
|
|
for (auto v : valueGroup0) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps2(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup1 = getODSOperands(1);
|
|
|
|
for (auto v : valueGroup1) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps3(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup2 = getODSOperands(2);
|
|
|
|
for (auto v : valueGroup2) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps4(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1q_horiz::verifyInvariants() {
|
|
return verifyInvariantsImpl();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1q_horiz::setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
// keep track of used keys in the input dictionary to be able to error out
|
|
// if there are some unknown ones.
|
|
::mlir::DenseSet<::mlir::StringAttr> usedKeys;
|
|
::mlir::MLIRContext *ctx = dict.getContext();
|
|
(void)ctx;
|
|
{
|
|
|
|
auto &propStorage = prop.tile_id;
|
|
auto tile_idAttrName = ::mlir::StringAttr::get(ctx, "tile_id");
|
|
auto attr = dict.get(tile_idAttrName);
|
|
usedKeys.insert(tile_idAttrName);
|
|
if (attr || /*isRequired=*/true) {
|
|
if (!attr) {
|
|
emitError() << "expected key entry for tile_id in DictionaryAttr to set "
|
|
"Properties.";
|
|
return ::mlir::failure();
|
|
}
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
|
|
for (::mlir::NamedAttribute attr : dict) {
|
|
if (!usedKeys.contains(attr.getName()))
|
|
return emitError() << "unknown key '" << attr.getName() <<
|
|
"' when parsing properties dictionary";
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
|
|
} // namespace mlir::arm_sme
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::aarch64_sme_ld1q_horiz)
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::detail::aarch64_sme_ld1q_horizGenericAdaptorBase::Properties)
|
|
|
|
namespace mlir::arm_sme {
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ::mlir::arm_sme::aarch64_sme_ld1q_vert definitions
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace detail {
|
|
|
|
aarch64_sme_ld1q_vertGenericAdaptorBase::aarch64_sme_ld1q_vertGenericAdaptorBase(aarch64_sme_ld1q_vert op) : odsAttrs(op->getRawDictionaryAttrs()), odsOpName(op->getName()), properties(op.getProperties()), odsRegions(op->getRegions()) {}
|
|
|
|
uint32_t aarch64_sme_ld1q_vertGenericAdaptorBase::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
|
|
} // namespace detail
|
|
aarch64_sme_ld1q_vertAdaptor::aarch64_sme_ld1q_vertAdaptor(aarch64_sme_ld1q_vert op) : aarch64_sme_ld1q_vertGenericAdaptor(op->getOperands(), op) {}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1q_vertAdaptor::verify(::mlir::Location loc) {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitError(loc, "'arm_sme.intr.ld1q.vert' op requires attribute 'tile_id'");
|
|
|
|
if (tblgen_tile_id && !(((::llvm::isa<::mlir::IntegerAttr>(tblgen_tile_id))) && ((::llvm::cast<::mlir::IntegerAttr>(tblgen_tile_id).getType().isSignlessInteger(32)))))
|
|
return emitError(loc, "'arm_sme.intr.ld1q.vert' op attribute 'tile_id' failed to satisfy constraint: 32-bit signless integer attribute");
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1q_vert::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
|
|
{
|
|
auto &propStorage = prop.tile_id;
|
|
auto attr = dict.get("tile_id");
|
|
if (attr) {
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::mlir::Attribute aarch64_sme_ld1q_vert::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) {
|
|
::mlir::SmallVector<::mlir::NamedAttribute> attrs;
|
|
::mlir::Builder odsBuilder{ctx};
|
|
|
|
{
|
|
const auto &propStorage = prop.tile_id;
|
|
if (propStorage)
|
|
attrs.push_back(odsBuilder.getNamedAttr("tile_id",
|
|
propStorage));
|
|
}
|
|
|
|
if (!attrs.empty())
|
|
return odsBuilder.getDictionaryAttr(attrs);
|
|
return {};
|
|
}
|
|
|
|
llvm::hash_code aarch64_sme_ld1q_vert::computePropertiesHash(const Properties &prop) {
|
|
using llvm::hash_value;
|
|
return llvm::hash_combine(
|
|
llvm::hash_value(prop.tile_id.getAsOpaquePointer()));
|
|
}
|
|
|
|
std::optional<mlir::Attribute> aarch64_sme_ld1q_vert::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) {
|
|
if (name == "tile_id")
|
|
return prop.tile_id;
|
|
return std::nullopt;
|
|
}
|
|
|
|
void aarch64_sme_ld1q_vert::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) {
|
|
if (name == "tile_id") {
|
|
prop.tile_id = ::llvm::dyn_cast_or_null<std::remove_reference_t<decltype(prop.tile_id)>>(value);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void aarch64_sme_ld1q_vert::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) {
|
|
if (prop.tile_id) attrs.append("tile_id", prop.tile_id);
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1q_vert::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
{
|
|
::mlir::Attribute attr = attrs.get(getTileIdAttrName(opName));
|
|
if (attr && ::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(attr, "tile_id", emitError)))
|
|
return ::mlir::failure();
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1q_vert::readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state) {
|
|
auto &prop = state.getOrAddProperties<Properties>(); (void)prop;
|
|
if (::mlir::failed(reader.readAttribute(prop.tile_id)))
|
|
return ::mlir::failure();
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_ld1q_vert::writeProperties(::mlir::DialectBytecodeWriter &writer) {
|
|
auto &prop = getProperties(); (void)prop;
|
|
writer.writeAttribute(prop.tile_id);
|
|
}
|
|
|
|
uint32_t aarch64_sme_ld1q_vert::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
void aarch64_sme_ld1q_vert::setTileId(uint32_t attrValue) {
|
|
getProperties().tile_id = ::mlir::Builder((*this)->getContext()).getIntegerAttr(::mlir::Builder((*this)->getContext()).getIntegerType(32), attrValue);
|
|
}
|
|
|
|
void aarch64_sme_ld1q_vert::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(load_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
}
|
|
|
|
aarch64_sme_ld1q_vert aarch64_sme_ld1q_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1q_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1q_vert aarch64_sme_ld1q_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_ld1q_vert::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(load_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_ld1q_vert aarch64_sme_ld1q_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1q_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1q_vert aarch64_sme_ld1q_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_ld1q_vert::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(load_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
}
|
|
|
|
aarch64_sme_ld1q_vert aarch64_sme_ld1q_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1q_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1q_vert aarch64_sme_ld1q_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_ld1q_vert::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(load_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_ld1q_vert aarch64_sme_ld1q_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1q_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1q_vert aarch64_sme_ld1q_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_ld1q_vert::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
assert(operands.size() == 3u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.addAttributes(attributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
|
|
if (!attributes.empty()) {
|
|
(void)odsState.getOrAddProperties<aarch64_sme_ld1q_vert::Properties>();
|
|
::mlir::PropertyRef properties = odsState.getRawProperties();
|
|
std::optional<::mlir::RegisteredOperationName> info =
|
|
odsState.name.getRegisteredInfo();
|
|
if (failed(info->setOpPropertiesFromAttribute(odsState.name, properties,
|
|
odsState.attributes.getDictionary(odsState.getContext()), nullptr)))
|
|
::llvm::report_fatal_error("Property conversion failed.");
|
|
}
|
|
}
|
|
|
|
aarch64_sme_ld1q_vert aarch64_sme_ld1q_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1q_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1q_vert aarch64_sme_ld1q_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
}
|
|
|
|
void aarch64_sme_ld1q_vert::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
assert(operands.size() == 3u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.useProperties(const_cast<Properties&>(properties));
|
|
odsState.addAttributes(discardableAttributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_ld1q_vert aarch64_sme_ld1q_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1q_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1q_vert aarch64_sme_ld1q_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1q_vert::verifyInvariantsImpl() {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitOpError("requires attribute 'tile_id'");
|
|
|
|
if (::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(*this, tblgen_tile_id, "tile_id")))
|
|
return ::mlir::failure();
|
|
{
|
|
unsigned index = 0; (void)index;
|
|
auto valueGroup0 = getODSOperands(0);
|
|
|
|
for (auto v : valueGroup0) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps2(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup1 = getODSOperands(1);
|
|
|
|
for (auto v : valueGroup1) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps3(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup2 = getODSOperands(2);
|
|
|
|
for (auto v : valueGroup2) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps4(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1q_vert::verifyInvariants() {
|
|
return verifyInvariantsImpl();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1q_vert::setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
// keep track of used keys in the input dictionary to be able to error out
|
|
// if there are some unknown ones.
|
|
::mlir::DenseSet<::mlir::StringAttr> usedKeys;
|
|
::mlir::MLIRContext *ctx = dict.getContext();
|
|
(void)ctx;
|
|
{
|
|
|
|
auto &propStorage = prop.tile_id;
|
|
auto tile_idAttrName = ::mlir::StringAttr::get(ctx, "tile_id");
|
|
auto attr = dict.get(tile_idAttrName);
|
|
usedKeys.insert(tile_idAttrName);
|
|
if (attr || /*isRequired=*/true) {
|
|
if (!attr) {
|
|
emitError() << "expected key entry for tile_id in DictionaryAttr to set "
|
|
"Properties.";
|
|
return ::mlir::failure();
|
|
}
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
|
|
for (::mlir::NamedAttribute attr : dict) {
|
|
if (!usedKeys.contains(attr.getName()))
|
|
return emitError() << "unknown key '" << attr.getName() <<
|
|
"' when parsing properties dictionary";
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
|
|
} // namespace mlir::arm_sme
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::aarch64_sme_ld1q_vert)
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::detail::aarch64_sme_ld1q_vertGenericAdaptorBase::Properties)
|
|
|
|
namespace mlir::arm_sme {
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ::mlir::arm_sme::aarch64_sme_ld1w_horiz definitions
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace detail {
|
|
|
|
aarch64_sme_ld1w_horizGenericAdaptorBase::aarch64_sme_ld1w_horizGenericAdaptorBase(aarch64_sme_ld1w_horiz op) : odsAttrs(op->getRawDictionaryAttrs()), odsOpName(op->getName()), properties(op.getProperties()), odsRegions(op->getRegions()) {}
|
|
|
|
uint32_t aarch64_sme_ld1w_horizGenericAdaptorBase::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
|
|
} // namespace detail
|
|
aarch64_sme_ld1w_horizAdaptor::aarch64_sme_ld1w_horizAdaptor(aarch64_sme_ld1w_horiz op) : aarch64_sme_ld1w_horizGenericAdaptor(op->getOperands(), op) {}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1w_horizAdaptor::verify(::mlir::Location loc) {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitError(loc, "'arm_sme.intr.ld1w.horiz' op requires attribute 'tile_id'");
|
|
|
|
if (tblgen_tile_id && !(((::llvm::isa<::mlir::IntegerAttr>(tblgen_tile_id))) && ((::llvm::cast<::mlir::IntegerAttr>(tblgen_tile_id).getType().isSignlessInteger(32)))))
|
|
return emitError(loc, "'arm_sme.intr.ld1w.horiz' op attribute 'tile_id' failed to satisfy constraint: 32-bit signless integer attribute");
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1w_horiz::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
|
|
{
|
|
auto &propStorage = prop.tile_id;
|
|
auto attr = dict.get("tile_id");
|
|
if (attr) {
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::mlir::Attribute aarch64_sme_ld1w_horiz::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) {
|
|
::mlir::SmallVector<::mlir::NamedAttribute> attrs;
|
|
::mlir::Builder odsBuilder{ctx};
|
|
|
|
{
|
|
const auto &propStorage = prop.tile_id;
|
|
if (propStorage)
|
|
attrs.push_back(odsBuilder.getNamedAttr("tile_id",
|
|
propStorage));
|
|
}
|
|
|
|
if (!attrs.empty())
|
|
return odsBuilder.getDictionaryAttr(attrs);
|
|
return {};
|
|
}
|
|
|
|
llvm::hash_code aarch64_sme_ld1w_horiz::computePropertiesHash(const Properties &prop) {
|
|
using llvm::hash_value;
|
|
return llvm::hash_combine(
|
|
llvm::hash_value(prop.tile_id.getAsOpaquePointer()));
|
|
}
|
|
|
|
std::optional<mlir::Attribute> aarch64_sme_ld1w_horiz::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) {
|
|
if (name == "tile_id")
|
|
return prop.tile_id;
|
|
return std::nullopt;
|
|
}
|
|
|
|
void aarch64_sme_ld1w_horiz::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) {
|
|
if (name == "tile_id") {
|
|
prop.tile_id = ::llvm::dyn_cast_or_null<std::remove_reference_t<decltype(prop.tile_id)>>(value);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void aarch64_sme_ld1w_horiz::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) {
|
|
if (prop.tile_id) attrs.append("tile_id", prop.tile_id);
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1w_horiz::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
{
|
|
::mlir::Attribute attr = attrs.get(getTileIdAttrName(opName));
|
|
if (attr && ::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(attr, "tile_id", emitError)))
|
|
return ::mlir::failure();
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1w_horiz::readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state) {
|
|
auto &prop = state.getOrAddProperties<Properties>(); (void)prop;
|
|
if (::mlir::failed(reader.readAttribute(prop.tile_id)))
|
|
return ::mlir::failure();
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_ld1w_horiz::writeProperties(::mlir::DialectBytecodeWriter &writer) {
|
|
auto &prop = getProperties(); (void)prop;
|
|
writer.writeAttribute(prop.tile_id);
|
|
}
|
|
|
|
uint32_t aarch64_sme_ld1w_horiz::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
void aarch64_sme_ld1w_horiz::setTileId(uint32_t attrValue) {
|
|
getProperties().tile_id = ::mlir::Builder((*this)->getContext()).getIntegerAttr(::mlir::Builder((*this)->getContext()).getIntegerType(32), attrValue);
|
|
}
|
|
|
|
void aarch64_sme_ld1w_horiz::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(load_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
}
|
|
|
|
aarch64_sme_ld1w_horiz aarch64_sme_ld1w_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1w_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1w_horiz aarch64_sme_ld1w_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_ld1w_horiz::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(load_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_ld1w_horiz aarch64_sme_ld1w_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1w_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1w_horiz aarch64_sme_ld1w_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_ld1w_horiz::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(load_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
}
|
|
|
|
aarch64_sme_ld1w_horiz aarch64_sme_ld1w_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1w_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1w_horiz aarch64_sme_ld1w_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_ld1w_horiz::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(load_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_ld1w_horiz aarch64_sme_ld1w_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1w_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1w_horiz aarch64_sme_ld1w_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_ld1w_horiz::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
assert(operands.size() == 3u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.addAttributes(attributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
|
|
if (!attributes.empty()) {
|
|
(void)odsState.getOrAddProperties<aarch64_sme_ld1w_horiz::Properties>();
|
|
::mlir::PropertyRef properties = odsState.getRawProperties();
|
|
std::optional<::mlir::RegisteredOperationName> info =
|
|
odsState.name.getRegisteredInfo();
|
|
if (failed(info->setOpPropertiesFromAttribute(odsState.name, properties,
|
|
odsState.attributes.getDictionary(odsState.getContext()), nullptr)))
|
|
::llvm::report_fatal_error("Property conversion failed.");
|
|
}
|
|
}
|
|
|
|
aarch64_sme_ld1w_horiz aarch64_sme_ld1w_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1w_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1w_horiz aarch64_sme_ld1w_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
}
|
|
|
|
void aarch64_sme_ld1w_horiz::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
assert(operands.size() == 3u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.useProperties(const_cast<Properties&>(properties));
|
|
odsState.addAttributes(discardableAttributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_ld1w_horiz aarch64_sme_ld1w_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1w_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1w_horiz aarch64_sme_ld1w_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1w_horiz::verifyInvariantsImpl() {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitOpError("requires attribute 'tile_id'");
|
|
|
|
if (::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(*this, tblgen_tile_id, "tile_id")))
|
|
return ::mlir::failure();
|
|
{
|
|
unsigned index = 0; (void)index;
|
|
auto valueGroup0 = getODSOperands(0);
|
|
|
|
for (auto v : valueGroup0) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps2(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup1 = getODSOperands(1);
|
|
|
|
for (auto v : valueGroup1) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps3(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup2 = getODSOperands(2);
|
|
|
|
for (auto v : valueGroup2) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps4(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1w_horiz::verifyInvariants() {
|
|
return verifyInvariantsImpl();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1w_horiz::setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
// keep track of used keys in the input dictionary to be able to error out
|
|
// if there are some unknown ones.
|
|
::mlir::DenseSet<::mlir::StringAttr> usedKeys;
|
|
::mlir::MLIRContext *ctx = dict.getContext();
|
|
(void)ctx;
|
|
{
|
|
|
|
auto &propStorage = prop.tile_id;
|
|
auto tile_idAttrName = ::mlir::StringAttr::get(ctx, "tile_id");
|
|
auto attr = dict.get(tile_idAttrName);
|
|
usedKeys.insert(tile_idAttrName);
|
|
if (attr || /*isRequired=*/true) {
|
|
if (!attr) {
|
|
emitError() << "expected key entry for tile_id in DictionaryAttr to set "
|
|
"Properties.";
|
|
return ::mlir::failure();
|
|
}
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
|
|
for (::mlir::NamedAttribute attr : dict) {
|
|
if (!usedKeys.contains(attr.getName()))
|
|
return emitError() << "unknown key '" << attr.getName() <<
|
|
"' when parsing properties dictionary";
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
|
|
} // namespace mlir::arm_sme
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::aarch64_sme_ld1w_horiz)
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::detail::aarch64_sme_ld1w_horizGenericAdaptorBase::Properties)
|
|
|
|
namespace mlir::arm_sme {
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ::mlir::arm_sme::aarch64_sme_ld1w_vert definitions
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace detail {
|
|
|
|
aarch64_sme_ld1w_vertGenericAdaptorBase::aarch64_sme_ld1w_vertGenericAdaptorBase(aarch64_sme_ld1w_vert op) : odsAttrs(op->getRawDictionaryAttrs()), odsOpName(op->getName()), properties(op.getProperties()), odsRegions(op->getRegions()) {}
|
|
|
|
uint32_t aarch64_sme_ld1w_vertGenericAdaptorBase::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
|
|
} // namespace detail
|
|
aarch64_sme_ld1w_vertAdaptor::aarch64_sme_ld1w_vertAdaptor(aarch64_sme_ld1w_vert op) : aarch64_sme_ld1w_vertGenericAdaptor(op->getOperands(), op) {}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1w_vertAdaptor::verify(::mlir::Location loc) {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitError(loc, "'arm_sme.intr.ld1w.vert' op requires attribute 'tile_id'");
|
|
|
|
if (tblgen_tile_id && !(((::llvm::isa<::mlir::IntegerAttr>(tblgen_tile_id))) && ((::llvm::cast<::mlir::IntegerAttr>(tblgen_tile_id).getType().isSignlessInteger(32)))))
|
|
return emitError(loc, "'arm_sme.intr.ld1w.vert' op attribute 'tile_id' failed to satisfy constraint: 32-bit signless integer attribute");
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1w_vert::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
|
|
{
|
|
auto &propStorage = prop.tile_id;
|
|
auto attr = dict.get("tile_id");
|
|
if (attr) {
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::mlir::Attribute aarch64_sme_ld1w_vert::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) {
|
|
::mlir::SmallVector<::mlir::NamedAttribute> attrs;
|
|
::mlir::Builder odsBuilder{ctx};
|
|
|
|
{
|
|
const auto &propStorage = prop.tile_id;
|
|
if (propStorage)
|
|
attrs.push_back(odsBuilder.getNamedAttr("tile_id",
|
|
propStorage));
|
|
}
|
|
|
|
if (!attrs.empty())
|
|
return odsBuilder.getDictionaryAttr(attrs);
|
|
return {};
|
|
}
|
|
|
|
llvm::hash_code aarch64_sme_ld1w_vert::computePropertiesHash(const Properties &prop) {
|
|
using llvm::hash_value;
|
|
return llvm::hash_combine(
|
|
llvm::hash_value(prop.tile_id.getAsOpaquePointer()));
|
|
}
|
|
|
|
std::optional<mlir::Attribute> aarch64_sme_ld1w_vert::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) {
|
|
if (name == "tile_id")
|
|
return prop.tile_id;
|
|
return std::nullopt;
|
|
}
|
|
|
|
void aarch64_sme_ld1w_vert::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) {
|
|
if (name == "tile_id") {
|
|
prop.tile_id = ::llvm::dyn_cast_or_null<std::remove_reference_t<decltype(prop.tile_id)>>(value);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void aarch64_sme_ld1w_vert::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) {
|
|
if (prop.tile_id) attrs.append("tile_id", prop.tile_id);
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1w_vert::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
{
|
|
::mlir::Attribute attr = attrs.get(getTileIdAttrName(opName));
|
|
if (attr && ::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(attr, "tile_id", emitError)))
|
|
return ::mlir::failure();
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1w_vert::readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state) {
|
|
auto &prop = state.getOrAddProperties<Properties>(); (void)prop;
|
|
if (::mlir::failed(reader.readAttribute(prop.tile_id)))
|
|
return ::mlir::failure();
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_ld1w_vert::writeProperties(::mlir::DialectBytecodeWriter &writer) {
|
|
auto &prop = getProperties(); (void)prop;
|
|
writer.writeAttribute(prop.tile_id);
|
|
}
|
|
|
|
uint32_t aarch64_sme_ld1w_vert::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
void aarch64_sme_ld1w_vert::setTileId(uint32_t attrValue) {
|
|
getProperties().tile_id = ::mlir::Builder((*this)->getContext()).getIntegerAttr(::mlir::Builder((*this)->getContext()).getIntegerType(32), attrValue);
|
|
}
|
|
|
|
void aarch64_sme_ld1w_vert::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(load_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
}
|
|
|
|
aarch64_sme_ld1w_vert aarch64_sme_ld1w_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1w_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1w_vert aarch64_sme_ld1w_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_ld1w_vert::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(load_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_ld1w_vert aarch64_sme_ld1w_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1w_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1w_vert aarch64_sme_ld1w_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_ld1w_vert::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(load_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
}
|
|
|
|
aarch64_sme_ld1w_vert aarch64_sme_ld1w_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1w_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1w_vert aarch64_sme_ld1w_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_ld1w_vert::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(load_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_ld1w_vert aarch64_sme_ld1w_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1w_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1w_vert aarch64_sme_ld1w_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value load_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(load_address)>(load_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_ld1w_vert::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
assert(operands.size() == 3u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.addAttributes(attributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
|
|
if (!attributes.empty()) {
|
|
(void)odsState.getOrAddProperties<aarch64_sme_ld1w_vert::Properties>();
|
|
::mlir::PropertyRef properties = odsState.getRawProperties();
|
|
std::optional<::mlir::RegisteredOperationName> info =
|
|
odsState.name.getRegisteredInfo();
|
|
if (failed(info->setOpPropertiesFromAttribute(odsState.name, properties,
|
|
odsState.attributes.getDictionary(odsState.getContext()), nullptr)))
|
|
::llvm::report_fatal_error("Property conversion failed.");
|
|
}
|
|
}
|
|
|
|
aarch64_sme_ld1w_vert aarch64_sme_ld1w_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1w_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1w_vert aarch64_sme_ld1w_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
}
|
|
|
|
void aarch64_sme_ld1w_vert::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
assert(operands.size() == 3u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.useProperties(const_cast<Properties&>(properties));
|
|
odsState.addAttributes(discardableAttributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_ld1w_vert aarch64_sme_ld1w_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_ld1w_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_ld1w_vert aarch64_sme_ld1w_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1w_vert::verifyInvariantsImpl() {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitOpError("requires attribute 'tile_id'");
|
|
|
|
if (::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(*this, tblgen_tile_id, "tile_id")))
|
|
return ::mlir::failure();
|
|
{
|
|
unsigned index = 0; (void)index;
|
|
auto valueGroup0 = getODSOperands(0);
|
|
|
|
for (auto v : valueGroup0) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps2(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup1 = getODSOperands(1);
|
|
|
|
for (auto v : valueGroup1) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps3(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup2 = getODSOperands(2);
|
|
|
|
for (auto v : valueGroup2) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps4(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1w_vert::verifyInvariants() {
|
|
return verifyInvariantsImpl();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_ld1w_vert::setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
// keep track of used keys in the input dictionary to be able to error out
|
|
// if there are some unknown ones.
|
|
::mlir::DenseSet<::mlir::StringAttr> usedKeys;
|
|
::mlir::MLIRContext *ctx = dict.getContext();
|
|
(void)ctx;
|
|
{
|
|
|
|
auto &propStorage = prop.tile_id;
|
|
auto tile_idAttrName = ::mlir::StringAttr::get(ctx, "tile_id");
|
|
auto attr = dict.get(tile_idAttrName);
|
|
usedKeys.insert(tile_idAttrName);
|
|
if (attr || /*isRequired=*/true) {
|
|
if (!attr) {
|
|
emitError() << "expected key entry for tile_id in DictionaryAttr to set "
|
|
"Properties.";
|
|
return ::mlir::failure();
|
|
}
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
|
|
for (::mlir::NamedAttribute attr : dict) {
|
|
if (!usedKeys.contains(attr.getName()))
|
|
return emitError() << "unknown key '" << attr.getName() <<
|
|
"' when parsing properties dictionary";
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
|
|
} // namespace mlir::arm_sme
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::aarch64_sme_ld1w_vert)
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::detail::aarch64_sme_ld1w_vertGenericAdaptorBase::Properties)
|
|
|
|
namespace mlir::arm_sme {
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ::mlir::arm_sme::aarch64_sme_mopa definitions
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace detail {
|
|
|
|
aarch64_sme_mopaGenericAdaptorBase::aarch64_sme_mopaGenericAdaptorBase(aarch64_sme_mopa op) : odsAttrs(op->getRawDictionaryAttrs()), odsOpName(op->getName()), properties(op.getProperties()), odsRegions(op->getRegions()) {}
|
|
|
|
uint32_t aarch64_sme_mopaGenericAdaptorBase::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
|
|
} // namespace detail
|
|
aarch64_sme_mopaAdaptor::aarch64_sme_mopaAdaptor(aarch64_sme_mopa op) : aarch64_sme_mopaGenericAdaptor(op->getOperands(), op) {}
|
|
|
|
::llvm::LogicalResult aarch64_sme_mopaAdaptor::verify(::mlir::Location loc) {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitError(loc, "'arm_sme.intr.mopa' op requires attribute 'tile_id'");
|
|
|
|
if (tblgen_tile_id && !(((::llvm::isa<::mlir::IntegerAttr>(tblgen_tile_id))) && ((::llvm::cast<::mlir::IntegerAttr>(tblgen_tile_id).getType().isSignlessInteger(32)))))
|
|
return emitError(loc, "'arm_sme.intr.mopa' op attribute 'tile_id' failed to satisfy constraint: 32-bit signless integer attribute");
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_mopa::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
|
|
{
|
|
auto &propStorage = prop.tile_id;
|
|
auto attr = dict.get("tile_id");
|
|
if (attr) {
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::mlir::Attribute aarch64_sme_mopa::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) {
|
|
::mlir::SmallVector<::mlir::NamedAttribute> attrs;
|
|
::mlir::Builder odsBuilder{ctx};
|
|
|
|
{
|
|
const auto &propStorage = prop.tile_id;
|
|
if (propStorage)
|
|
attrs.push_back(odsBuilder.getNamedAttr("tile_id",
|
|
propStorage));
|
|
}
|
|
|
|
if (!attrs.empty())
|
|
return odsBuilder.getDictionaryAttr(attrs);
|
|
return {};
|
|
}
|
|
|
|
llvm::hash_code aarch64_sme_mopa::computePropertiesHash(const Properties &prop) {
|
|
using llvm::hash_value;
|
|
return llvm::hash_combine(
|
|
llvm::hash_value(prop.tile_id.getAsOpaquePointer()));
|
|
}
|
|
|
|
std::optional<mlir::Attribute> aarch64_sme_mopa::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) {
|
|
if (name == "tile_id")
|
|
return prop.tile_id;
|
|
return std::nullopt;
|
|
}
|
|
|
|
void aarch64_sme_mopa::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) {
|
|
if (name == "tile_id") {
|
|
prop.tile_id = ::llvm::dyn_cast_or_null<std::remove_reference_t<decltype(prop.tile_id)>>(value);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void aarch64_sme_mopa::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) {
|
|
if (prop.tile_id) attrs.append("tile_id", prop.tile_id);
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_mopa::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
{
|
|
::mlir::Attribute attr = attrs.get(getTileIdAttrName(opName));
|
|
if (attr && ::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(attr, "tile_id", emitError)))
|
|
return ::mlir::failure();
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_mopa::readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state) {
|
|
auto &prop = state.getOrAddProperties<Properties>(); (void)prop;
|
|
if (::mlir::failed(reader.readAttribute(prop.tile_id)))
|
|
return ::mlir::failure();
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_mopa::writeProperties(::mlir::DialectBytecodeWriter &writer) {
|
|
auto &prop = getProperties(); (void)prop;
|
|
writer.writeAttribute(prop.tile_id);
|
|
}
|
|
|
|
uint32_t aarch64_sme_mopa::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
void aarch64_sme_mopa::setTileId(uint32_t attrValue) {
|
|
getProperties().tile_id = ::mlir::Builder((*this)->getContext()).getIntegerAttr(::mlir::Builder((*this)->getContext()).getIntegerType(32), attrValue);
|
|
}
|
|
|
|
void aarch64_sme_mopa::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
}
|
|
|
|
aarch64_sme_mopa aarch64_sme_mopa::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_mopa>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_mopa aarch64_sme_mopa::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_mopa::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_mopa aarch64_sme_mopa::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_mopa>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_mopa aarch64_sme_mopa::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_mopa::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
}
|
|
|
|
aarch64_sme_mopa aarch64_sme_mopa::create(::mlir::OpBuilder &builder, ::mlir::Location location, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_mopa>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_mopa aarch64_sme_mopa::create(::mlir::ImplicitLocOpBuilder &builder, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_mopa::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_mopa aarch64_sme_mopa::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_mopa>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_mopa aarch64_sme_mopa::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_mopa::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
assert(operands.size() == 4u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.addAttributes(attributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
|
|
if (!attributes.empty()) {
|
|
(void)odsState.getOrAddProperties<aarch64_sme_mopa::Properties>();
|
|
::mlir::PropertyRef properties = odsState.getRawProperties();
|
|
std::optional<::mlir::RegisteredOperationName> info =
|
|
odsState.name.getRegisteredInfo();
|
|
if (failed(info->setOpPropertiesFromAttribute(odsState.name, properties,
|
|
odsState.attributes.getDictionary(odsState.getContext()), nullptr)))
|
|
::llvm::report_fatal_error("Property conversion failed.");
|
|
}
|
|
}
|
|
|
|
aarch64_sme_mopa aarch64_sme_mopa::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_mopa>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_mopa aarch64_sme_mopa::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
}
|
|
|
|
void aarch64_sme_mopa::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
assert(operands.size() == 4u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.useProperties(const_cast<Properties&>(properties));
|
|
odsState.addAttributes(discardableAttributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_mopa aarch64_sme_mopa::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_mopa>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_mopa aarch64_sme_mopa::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_mopa::verifyInvariantsImpl() {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitOpError("requires attribute 'tile_id'");
|
|
|
|
if (::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(*this, tblgen_tile_id, "tile_id")))
|
|
return ::mlir::failure();
|
|
{
|
|
unsigned index = 0; (void)index;
|
|
auto valueGroup0 = getODSOperands(0);
|
|
|
|
for (auto v : valueGroup0) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps5(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup1 = getODSOperands(1);
|
|
|
|
for (auto v : valueGroup1) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps5(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup2 = getODSOperands(2);
|
|
|
|
for (auto v : valueGroup2) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps6(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup3 = getODSOperands(3);
|
|
|
|
for (auto v : valueGroup3) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps6(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_mopa::verifyInvariants() {
|
|
return verifyInvariantsImpl();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_mopa::setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
// keep track of used keys in the input dictionary to be able to error out
|
|
// if there are some unknown ones.
|
|
::mlir::DenseSet<::mlir::StringAttr> usedKeys;
|
|
::mlir::MLIRContext *ctx = dict.getContext();
|
|
(void)ctx;
|
|
{
|
|
|
|
auto &propStorage = prop.tile_id;
|
|
auto tile_idAttrName = ::mlir::StringAttr::get(ctx, "tile_id");
|
|
auto attr = dict.get(tile_idAttrName);
|
|
usedKeys.insert(tile_idAttrName);
|
|
if (attr || /*isRequired=*/true) {
|
|
if (!attr) {
|
|
emitError() << "expected key entry for tile_id in DictionaryAttr to set "
|
|
"Properties.";
|
|
return ::mlir::failure();
|
|
}
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
|
|
for (::mlir::NamedAttribute attr : dict) {
|
|
if (!usedKeys.contains(attr.getName()))
|
|
return emitError() << "unknown key '" << attr.getName() <<
|
|
"' when parsing properties dictionary";
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
|
|
} // namespace mlir::arm_sme
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::aarch64_sme_mopa)
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::detail::aarch64_sme_mopaGenericAdaptorBase::Properties)
|
|
|
|
namespace mlir::arm_sme {
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ::mlir::arm_sme::aarch64_sme_mopa_wide definitions
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace detail {
|
|
|
|
aarch64_sme_mopa_wideGenericAdaptorBase::aarch64_sme_mopa_wideGenericAdaptorBase(aarch64_sme_mopa_wide op) : odsAttrs(op->getRawDictionaryAttrs()), odsOpName(op->getName()), properties(op.getProperties()), odsRegions(op->getRegions()) {}
|
|
|
|
uint32_t aarch64_sme_mopa_wideGenericAdaptorBase::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
|
|
} // namespace detail
|
|
aarch64_sme_mopa_wideAdaptor::aarch64_sme_mopa_wideAdaptor(aarch64_sme_mopa_wide op) : aarch64_sme_mopa_wideGenericAdaptor(op->getOperands(), op) {}
|
|
|
|
::llvm::LogicalResult aarch64_sme_mopa_wideAdaptor::verify(::mlir::Location loc) {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitError(loc, "'arm_sme.intr.mopa.wide' op requires attribute 'tile_id'");
|
|
|
|
if (tblgen_tile_id && !(((::llvm::isa<::mlir::IntegerAttr>(tblgen_tile_id))) && ((::llvm::cast<::mlir::IntegerAttr>(tblgen_tile_id).getType().isSignlessInteger(32)))))
|
|
return emitError(loc, "'arm_sme.intr.mopa.wide' op attribute 'tile_id' failed to satisfy constraint: 32-bit signless integer attribute");
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_mopa_wide::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
|
|
{
|
|
auto &propStorage = prop.tile_id;
|
|
auto attr = dict.get("tile_id");
|
|
if (attr) {
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::mlir::Attribute aarch64_sme_mopa_wide::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) {
|
|
::mlir::SmallVector<::mlir::NamedAttribute> attrs;
|
|
::mlir::Builder odsBuilder{ctx};
|
|
|
|
{
|
|
const auto &propStorage = prop.tile_id;
|
|
if (propStorage)
|
|
attrs.push_back(odsBuilder.getNamedAttr("tile_id",
|
|
propStorage));
|
|
}
|
|
|
|
if (!attrs.empty())
|
|
return odsBuilder.getDictionaryAttr(attrs);
|
|
return {};
|
|
}
|
|
|
|
llvm::hash_code aarch64_sme_mopa_wide::computePropertiesHash(const Properties &prop) {
|
|
using llvm::hash_value;
|
|
return llvm::hash_combine(
|
|
llvm::hash_value(prop.tile_id.getAsOpaquePointer()));
|
|
}
|
|
|
|
std::optional<mlir::Attribute> aarch64_sme_mopa_wide::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) {
|
|
if (name == "tile_id")
|
|
return prop.tile_id;
|
|
return std::nullopt;
|
|
}
|
|
|
|
void aarch64_sme_mopa_wide::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) {
|
|
if (name == "tile_id") {
|
|
prop.tile_id = ::llvm::dyn_cast_or_null<std::remove_reference_t<decltype(prop.tile_id)>>(value);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void aarch64_sme_mopa_wide::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) {
|
|
if (prop.tile_id) attrs.append("tile_id", prop.tile_id);
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_mopa_wide::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
{
|
|
::mlir::Attribute attr = attrs.get(getTileIdAttrName(opName));
|
|
if (attr && ::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(attr, "tile_id", emitError)))
|
|
return ::mlir::failure();
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_mopa_wide::readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state) {
|
|
auto &prop = state.getOrAddProperties<Properties>(); (void)prop;
|
|
if (::mlir::failed(reader.readAttribute(prop.tile_id)))
|
|
return ::mlir::failure();
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_mopa_wide::writeProperties(::mlir::DialectBytecodeWriter &writer) {
|
|
auto &prop = getProperties(); (void)prop;
|
|
writer.writeAttribute(prop.tile_id);
|
|
}
|
|
|
|
uint32_t aarch64_sme_mopa_wide::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
void aarch64_sme_mopa_wide::setTileId(uint32_t attrValue) {
|
|
getProperties().tile_id = ::mlir::Builder((*this)->getContext()).getIntegerAttr(::mlir::Builder((*this)->getContext()).getIntegerType(32), attrValue);
|
|
}
|
|
|
|
void aarch64_sme_mopa_wide::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
}
|
|
|
|
aarch64_sme_mopa_wide aarch64_sme_mopa_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_mopa_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_mopa_wide aarch64_sme_mopa_wide::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_mopa_wide::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_mopa_wide aarch64_sme_mopa_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_mopa_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_mopa_wide aarch64_sme_mopa_wide::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_mopa_wide::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
}
|
|
|
|
aarch64_sme_mopa_wide aarch64_sme_mopa_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_mopa_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_mopa_wide aarch64_sme_mopa_wide::create(::mlir::ImplicitLocOpBuilder &builder, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_mopa_wide::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_mopa_wide aarch64_sme_mopa_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_mopa_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_mopa_wide aarch64_sme_mopa_wide::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_mopa_wide::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
assert(operands.size() == 4u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.addAttributes(attributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
|
|
if (!attributes.empty()) {
|
|
(void)odsState.getOrAddProperties<aarch64_sme_mopa_wide::Properties>();
|
|
::mlir::PropertyRef properties = odsState.getRawProperties();
|
|
std::optional<::mlir::RegisteredOperationName> info =
|
|
odsState.name.getRegisteredInfo();
|
|
if (failed(info->setOpPropertiesFromAttribute(odsState.name, properties,
|
|
odsState.attributes.getDictionary(odsState.getContext()), nullptr)))
|
|
::llvm::report_fatal_error("Property conversion failed.");
|
|
}
|
|
}
|
|
|
|
aarch64_sme_mopa_wide aarch64_sme_mopa_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_mopa_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_mopa_wide aarch64_sme_mopa_wide::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
}
|
|
|
|
void aarch64_sme_mopa_wide::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
assert(operands.size() == 4u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.useProperties(const_cast<Properties&>(properties));
|
|
odsState.addAttributes(discardableAttributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_mopa_wide aarch64_sme_mopa_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_mopa_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_mopa_wide aarch64_sme_mopa_wide::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_mopa_wide::verifyInvariantsImpl() {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitOpError("requires attribute 'tile_id'");
|
|
|
|
if (::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(*this, tblgen_tile_id, "tile_id")))
|
|
return ::mlir::failure();
|
|
{
|
|
unsigned index = 0; (void)index;
|
|
auto valueGroup0 = getODSOperands(0);
|
|
|
|
for (auto v : valueGroup0) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps5(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup1 = getODSOperands(1);
|
|
|
|
for (auto v : valueGroup1) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps5(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup2 = getODSOperands(2);
|
|
|
|
for (auto v : valueGroup2) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps6(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup3 = getODSOperands(3);
|
|
|
|
for (auto v : valueGroup3) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps6(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_mopa_wide::verifyInvariants() {
|
|
return verifyInvariantsImpl();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_mopa_wide::setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
// keep track of used keys in the input dictionary to be able to error out
|
|
// if there are some unknown ones.
|
|
::mlir::DenseSet<::mlir::StringAttr> usedKeys;
|
|
::mlir::MLIRContext *ctx = dict.getContext();
|
|
(void)ctx;
|
|
{
|
|
|
|
auto &propStorage = prop.tile_id;
|
|
auto tile_idAttrName = ::mlir::StringAttr::get(ctx, "tile_id");
|
|
auto attr = dict.get(tile_idAttrName);
|
|
usedKeys.insert(tile_idAttrName);
|
|
if (attr || /*isRequired=*/true) {
|
|
if (!attr) {
|
|
emitError() << "expected key entry for tile_id in DictionaryAttr to set "
|
|
"Properties.";
|
|
return ::mlir::failure();
|
|
}
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
|
|
for (::mlir::NamedAttribute attr : dict) {
|
|
if (!usedKeys.contains(attr.getName()))
|
|
return emitError() << "unknown key '" << attr.getName() <<
|
|
"' when parsing properties dictionary";
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
|
|
} // namespace mlir::arm_sme
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::aarch64_sme_mopa_wide)
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::detail::aarch64_sme_mopa_wideGenericAdaptorBase::Properties)
|
|
|
|
namespace mlir::arm_sme {
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ::mlir::arm_sme::aarch64_sme_mops definitions
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace detail {
|
|
|
|
aarch64_sme_mopsGenericAdaptorBase::aarch64_sme_mopsGenericAdaptorBase(aarch64_sme_mops op) : odsAttrs(op->getRawDictionaryAttrs()), odsOpName(op->getName()), properties(op.getProperties()), odsRegions(op->getRegions()) {}
|
|
|
|
uint32_t aarch64_sme_mopsGenericAdaptorBase::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
|
|
} // namespace detail
|
|
aarch64_sme_mopsAdaptor::aarch64_sme_mopsAdaptor(aarch64_sme_mops op) : aarch64_sme_mopsGenericAdaptor(op->getOperands(), op) {}
|
|
|
|
::llvm::LogicalResult aarch64_sme_mopsAdaptor::verify(::mlir::Location loc) {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitError(loc, "'arm_sme.intr.mops' op requires attribute 'tile_id'");
|
|
|
|
if (tblgen_tile_id && !(((::llvm::isa<::mlir::IntegerAttr>(tblgen_tile_id))) && ((::llvm::cast<::mlir::IntegerAttr>(tblgen_tile_id).getType().isSignlessInteger(32)))))
|
|
return emitError(loc, "'arm_sme.intr.mops' op attribute 'tile_id' failed to satisfy constraint: 32-bit signless integer attribute");
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_mops::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
|
|
{
|
|
auto &propStorage = prop.tile_id;
|
|
auto attr = dict.get("tile_id");
|
|
if (attr) {
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::mlir::Attribute aarch64_sme_mops::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) {
|
|
::mlir::SmallVector<::mlir::NamedAttribute> attrs;
|
|
::mlir::Builder odsBuilder{ctx};
|
|
|
|
{
|
|
const auto &propStorage = prop.tile_id;
|
|
if (propStorage)
|
|
attrs.push_back(odsBuilder.getNamedAttr("tile_id",
|
|
propStorage));
|
|
}
|
|
|
|
if (!attrs.empty())
|
|
return odsBuilder.getDictionaryAttr(attrs);
|
|
return {};
|
|
}
|
|
|
|
llvm::hash_code aarch64_sme_mops::computePropertiesHash(const Properties &prop) {
|
|
using llvm::hash_value;
|
|
return llvm::hash_combine(
|
|
llvm::hash_value(prop.tile_id.getAsOpaquePointer()));
|
|
}
|
|
|
|
std::optional<mlir::Attribute> aarch64_sme_mops::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) {
|
|
if (name == "tile_id")
|
|
return prop.tile_id;
|
|
return std::nullopt;
|
|
}
|
|
|
|
void aarch64_sme_mops::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) {
|
|
if (name == "tile_id") {
|
|
prop.tile_id = ::llvm::dyn_cast_or_null<std::remove_reference_t<decltype(prop.tile_id)>>(value);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void aarch64_sme_mops::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) {
|
|
if (prop.tile_id) attrs.append("tile_id", prop.tile_id);
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_mops::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
{
|
|
::mlir::Attribute attr = attrs.get(getTileIdAttrName(opName));
|
|
if (attr && ::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(attr, "tile_id", emitError)))
|
|
return ::mlir::failure();
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_mops::readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state) {
|
|
auto &prop = state.getOrAddProperties<Properties>(); (void)prop;
|
|
if (::mlir::failed(reader.readAttribute(prop.tile_id)))
|
|
return ::mlir::failure();
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_mops::writeProperties(::mlir::DialectBytecodeWriter &writer) {
|
|
auto &prop = getProperties(); (void)prop;
|
|
writer.writeAttribute(prop.tile_id);
|
|
}
|
|
|
|
uint32_t aarch64_sme_mops::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
void aarch64_sme_mops::setTileId(uint32_t attrValue) {
|
|
getProperties().tile_id = ::mlir::Builder((*this)->getContext()).getIntegerAttr(::mlir::Builder((*this)->getContext()).getIntegerType(32), attrValue);
|
|
}
|
|
|
|
void aarch64_sme_mops::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
}
|
|
|
|
aarch64_sme_mops aarch64_sme_mops::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_mops>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_mops aarch64_sme_mops::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_mops::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_mops aarch64_sme_mops::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_mops>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_mops aarch64_sme_mops::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_mops::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
}
|
|
|
|
aarch64_sme_mops aarch64_sme_mops::create(::mlir::OpBuilder &builder, ::mlir::Location location, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_mops>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_mops aarch64_sme_mops::create(::mlir::ImplicitLocOpBuilder &builder, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_mops::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_mops aarch64_sme_mops::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_mops>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_mops aarch64_sme_mops::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_mops::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
assert(operands.size() == 4u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.addAttributes(attributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
|
|
if (!attributes.empty()) {
|
|
(void)odsState.getOrAddProperties<aarch64_sme_mops::Properties>();
|
|
::mlir::PropertyRef properties = odsState.getRawProperties();
|
|
std::optional<::mlir::RegisteredOperationName> info =
|
|
odsState.name.getRegisteredInfo();
|
|
if (failed(info->setOpPropertiesFromAttribute(odsState.name, properties,
|
|
odsState.attributes.getDictionary(odsState.getContext()), nullptr)))
|
|
::llvm::report_fatal_error("Property conversion failed.");
|
|
}
|
|
}
|
|
|
|
aarch64_sme_mops aarch64_sme_mops::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_mops>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_mops aarch64_sme_mops::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
}
|
|
|
|
void aarch64_sme_mops::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
assert(operands.size() == 4u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.useProperties(const_cast<Properties&>(properties));
|
|
odsState.addAttributes(discardableAttributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_mops aarch64_sme_mops::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_mops>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_mops aarch64_sme_mops::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_mops::verifyInvariantsImpl() {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitOpError("requires attribute 'tile_id'");
|
|
|
|
if (::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(*this, tblgen_tile_id, "tile_id")))
|
|
return ::mlir::failure();
|
|
{
|
|
unsigned index = 0; (void)index;
|
|
auto valueGroup0 = getODSOperands(0);
|
|
|
|
for (auto v : valueGroup0) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps5(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup1 = getODSOperands(1);
|
|
|
|
for (auto v : valueGroup1) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps5(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup2 = getODSOperands(2);
|
|
|
|
for (auto v : valueGroup2) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps6(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup3 = getODSOperands(3);
|
|
|
|
for (auto v : valueGroup3) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps6(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_mops::verifyInvariants() {
|
|
return verifyInvariantsImpl();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_mops::setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
// keep track of used keys in the input dictionary to be able to error out
|
|
// if there are some unknown ones.
|
|
::mlir::DenseSet<::mlir::StringAttr> usedKeys;
|
|
::mlir::MLIRContext *ctx = dict.getContext();
|
|
(void)ctx;
|
|
{
|
|
|
|
auto &propStorage = prop.tile_id;
|
|
auto tile_idAttrName = ::mlir::StringAttr::get(ctx, "tile_id");
|
|
auto attr = dict.get(tile_idAttrName);
|
|
usedKeys.insert(tile_idAttrName);
|
|
if (attr || /*isRequired=*/true) {
|
|
if (!attr) {
|
|
emitError() << "expected key entry for tile_id in DictionaryAttr to set "
|
|
"Properties.";
|
|
return ::mlir::failure();
|
|
}
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
|
|
for (::mlir::NamedAttribute attr : dict) {
|
|
if (!usedKeys.contains(attr.getName()))
|
|
return emitError() << "unknown key '" << attr.getName() <<
|
|
"' when parsing properties dictionary";
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
|
|
} // namespace mlir::arm_sme
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::aarch64_sme_mops)
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::detail::aarch64_sme_mopsGenericAdaptorBase::Properties)
|
|
|
|
namespace mlir::arm_sme {
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ::mlir::arm_sme::aarch64_sme_mops_wide definitions
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace detail {
|
|
|
|
aarch64_sme_mops_wideGenericAdaptorBase::aarch64_sme_mops_wideGenericAdaptorBase(aarch64_sme_mops_wide op) : odsAttrs(op->getRawDictionaryAttrs()), odsOpName(op->getName()), properties(op.getProperties()), odsRegions(op->getRegions()) {}
|
|
|
|
uint32_t aarch64_sme_mops_wideGenericAdaptorBase::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
|
|
} // namespace detail
|
|
aarch64_sme_mops_wideAdaptor::aarch64_sme_mops_wideAdaptor(aarch64_sme_mops_wide op) : aarch64_sme_mops_wideGenericAdaptor(op->getOperands(), op) {}
|
|
|
|
::llvm::LogicalResult aarch64_sme_mops_wideAdaptor::verify(::mlir::Location loc) {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitError(loc, "'arm_sme.intr.mops.wide' op requires attribute 'tile_id'");
|
|
|
|
if (tblgen_tile_id && !(((::llvm::isa<::mlir::IntegerAttr>(tblgen_tile_id))) && ((::llvm::cast<::mlir::IntegerAttr>(tblgen_tile_id).getType().isSignlessInteger(32)))))
|
|
return emitError(loc, "'arm_sme.intr.mops.wide' op attribute 'tile_id' failed to satisfy constraint: 32-bit signless integer attribute");
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_mops_wide::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
|
|
{
|
|
auto &propStorage = prop.tile_id;
|
|
auto attr = dict.get("tile_id");
|
|
if (attr) {
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::mlir::Attribute aarch64_sme_mops_wide::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) {
|
|
::mlir::SmallVector<::mlir::NamedAttribute> attrs;
|
|
::mlir::Builder odsBuilder{ctx};
|
|
|
|
{
|
|
const auto &propStorage = prop.tile_id;
|
|
if (propStorage)
|
|
attrs.push_back(odsBuilder.getNamedAttr("tile_id",
|
|
propStorage));
|
|
}
|
|
|
|
if (!attrs.empty())
|
|
return odsBuilder.getDictionaryAttr(attrs);
|
|
return {};
|
|
}
|
|
|
|
llvm::hash_code aarch64_sme_mops_wide::computePropertiesHash(const Properties &prop) {
|
|
using llvm::hash_value;
|
|
return llvm::hash_combine(
|
|
llvm::hash_value(prop.tile_id.getAsOpaquePointer()));
|
|
}
|
|
|
|
std::optional<mlir::Attribute> aarch64_sme_mops_wide::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) {
|
|
if (name == "tile_id")
|
|
return prop.tile_id;
|
|
return std::nullopt;
|
|
}
|
|
|
|
void aarch64_sme_mops_wide::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) {
|
|
if (name == "tile_id") {
|
|
prop.tile_id = ::llvm::dyn_cast_or_null<std::remove_reference_t<decltype(prop.tile_id)>>(value);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void aarch64_sme_mops_wide::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) {
|
|
if (prop.tile_id) attrs.append("tile_id", prop.tile_id);
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_mops_wide::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
{
|
|
::mlir::Attribute attr = attrs.get(getTileIdAttrName(opName));
|
|
if (attr && ::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(attr, "tile_id", emitError)))
|
|
return ::mlir::failure();
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_mops_wide::readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state) {
|
|
auto &prop = state.getOrAddProperties<Properties>(); (void)prop;
|
|
if (::mlir::failed(reader.readAttribute(prop.tile_id)))
|
|
return ::mlir::failure();
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_mops_wide::writeProperties(::mlir::DialectBytecodeWriter &writer) {
|
|
auto &prop = getProperties(); (void)prop;
|
|
writer.writeAttribute(prop.tile_id);
|
|
}
|
|
|
|
uint32_t aarch64_sme_mops_wide::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
void aarch64_sme_mops_wide::setTileId(uint32_t attrValue) {
|
|
getProperties().tile_id = ::mlir::Builder((*this)->getContext()).getIntegerAttr(::mlir::Builder((*this)->getContext()).getIntegerType(32), attrValue);
|
|
}
|
|
|
|
void aarch64_sme_mops_wide::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
}
|
|
|
|
aarch64_sme_mops_wide aarch64_sme_mops_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_mops_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_mops_wide aarch64_sme_mops_wide::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_mops_wide::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_mops_wide aarch64_sme_mops_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_mops_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_mops_wide aarch64_sme_mops_wide::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_mops_wide::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
}
|
|
|
|
aarch64_sme_mops_wide aarch64_sme_mops_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_mops_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_mops_wide aarch64_sme_mops_wide::create(::mlir::ImplicitLocOpBuilder &builder, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_mops_wide::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_mops_wide aarch64_sme_mops_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_mops_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_mops_wide aarch64_sme_mops_wide::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_mops_wide::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
assert(operands.size() == 4u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.addAttributes(attributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
|
|
if (!attributes.empty()) {
|
|
(void)odsState.getOrAddProperties<aarch64_sme_mops_wide::Properties>();
|
|
::mlir::PropertyRef properties = odsState.getRawProperties();
|
|
std::optional<::mlir::RegisteredOperationName> info =
|
|
odsState.name.getRegisteredInfo();
|
|
if (failed(info->setOpPropertiesFromAttribute(odsState.name, properties,
|
|
odsState.attributes.getDictionary(odsState.getContext()), nullptr)))
|
|
::llvm::report_fatal_error("Property conversion failed.");
|
|
}
|
|
}
|
|
|
|
aarch64_sme_mops_wide aarch64_sme_mops_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_mops_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_mops_wide aarch64_sme_mops_wide::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
}
|
|
|
|
void aarch64_sme_mops_wide::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
assert(operands.size() == 4u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.useProperties(const_cast<Properties&>(properties));
|
|
odsState.addAttributes(discardableAttributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_mops_wide aarch64_sme_mops_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_mops_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_mops_wide aarch64_sme_mops_wide::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_mops_wide::verifyInvariantsImpl() {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitOpError("requires attribute 'tile_id'");
|
|
|
|
if (::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(*this, tblgen_tile_id, "tile_id")))
|
|
return ::mlir::failure();
|
|
{
|
|
unsigned index = 0; (void)index;
|
|
auto valueGroup0 = getODSOperands(0);
|
|
|
|
for (auto v : valueGroup0) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps5(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup1 = getODSOperands(1);
|
|
|
|
for (auto v : valueGroup1) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps5(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup2 = getODSOperands(2);
|
|
|
|
for (auto v : valueGroup2) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps6(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup3 = getODSOperands(3);
|
|
|
|
for (auto v : valueGroup3) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps6(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_mops_wide::verifyInvariants() {
|
|
return verifyInvariantsImpl();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_mops_wide::setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
// keep track of used keys in the input dictionary to be able to error out
|
|
// if there are some unknown ones.
|
|
::mlir::DenseSet<::mlir::StringAttr> usedKeys;
|
|
::mlir::MLIRContext *ctx = dict.getContext();
|
|
(void)ctx;
|
|
{
|
|
|
|
auto &propStorage = prop.tile_id;
|
|
auto tile_idAttrName = ::mlir::StringAttr::get(ctx, "tile_id");
|
|
auto attr = dict.get(tile_idAttrName);
|
|
usedKeys.insert(tile_idAttrName);
|
|
if (attr || /*isRequired=*/true) {
|
|
if (!attr) {
|
|
emitError() << "expected key entry for tile_id in DictionaryAttr to set "
|
|
"Properties.";
|
|
return ::mlir::failure();
|
|
}
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
|
|
for (::mlir::NamedAttribute attr : dict) {
|
|
if (!usedKeys.contains(attr.getName()))
|
|
return emitError() << "unknown key '" << attr.getName() <<
|
|
"' when parsing properties dictionary";
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
|
|
} // namespace mlir::arm_sme
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::aarch64_sme_mops_wide)
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::detail::aarch64_sme_mops_wideGenericAdaptorBase::Properties)
|
|
|
|
namespace mlir::arm_sme {
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ::mlir::arm_sme::aarch64_sme_read_horiz definitions
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace detail {
|
|
|
|
aarch64_sme_read_horizGenericAdaptorBase::aarch64_sme_read_horizGenericAdaptorBase(aarch64_sme_read_horiz op) : odsAttrs(op->getRawDictionaryAttrs()), odsOpName(op->getName()), properties(op.getProperties()), odsRegions(op->getRegions()) {}
|
|
|
|
uint32_t aarch64_sme_read_horizGenericAdaptorBase::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
|
|
} // namespace detail
|
|
aarch64_sme_read_horizAdaptor::aarch64_sme_read_horizAdaptor(aarch64_sme_read_horiz op) : aarch64_sme_read_horizGenericAdaptor(op->getOperands(), op) {}
|
|
|
|
::llvm::LogicalResult aarch64_sme_read_horizAdaptor::verify(::mlir::Location loc) {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitError(loc, "'arm_sme.intr.read.horiz' op requires attribute 'tile_id'");
|
|
|
|
if (tblgen_tile_id && !(((::llvm::isa<::mlir::IntegerAttr>(tblgen_tile_id))) && ((::llvm::cast<::mlir::IntegerAttr>(tblgen_tile_id).getType().isSignlessInteger(32)))))
|
|
return emitError(loc, "'arm_sme.intr.read.horiz' op attribute 'tile_id' failed to satisfy constraint: 32-bit signless integer attribute");
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_read_horiz::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
|
|
{
|
|
auto &propStorage = prop.tile_id;
|
|
auto attr = dict.get("tile_id");
|
|
if (attr) {
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::mlir::Attribute aarch64_sme_read_horiz::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) {
|
|
::mlir::SmallVector<::mlir::NamedAttribute> attrs;
|
|
::mlir::Builder odsBuilder{ctx};
|
|
|
|
{
|
|
const auto &propStorage = prop.tile_id;
|
|
if (propStorage)
|
|
attrs.push_back(odsBuilder.getNamedAttr("tile_id",
|
|
propStorage));
|
|
}
|
|
|
|
if (!attrs.empty())
|
|
return odsBuilder.getDictionaryAttr(attrs);
|
|
return {};
|
|
}
|
|
|
|
llvm::hash_code aarch64_sme_read_horiz::computePropertiesHash(const Properties &prop) {
|
|
using llvm::hash_value;
|
|
return llvm::hash_combine(
|
|
llvm::hash_value(prop.tile_id.getAsOpaquePointer()));
|
|
}
|
|
|
|
std::optional<mlir::Attribute> aarch64_sme_read_horiz::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) {
|
|
if (name == "tile_id")
|
|
return prop.tile_id;
|
|
return std::nullopt;
|
|
}
|
|
|
|
void aarch64_sme_read_horiz::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) {
|
|
if (name == "tile_id") {
|
|
prop.tile_id = ::llvm::dyn_cast_or_null<std::remove_reference_t<decltype(prop.tile_id)>>(value);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void aarch64_sme_read_horiz::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) {
|
|
if (prop.tile_id) attrs.append("tile_id", prop.tile_id);
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_read_horiz::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
{
|
|
::mlir::Attribute attr = attrs.get(getTileIdAttrName(opName));
|
|
if (attr && ::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(attr, "tile_id", emitError)))
|
|
return ::mlir::failure();
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_read_horiz::readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state) {
|
|
auto &prop = state.getOrAddProperties<Properties>(); (void)prop;
|
|
if (::mlir::failed(reader.readAttribute(prop.tile_id)))
|
|
return ::mlir::failure();
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_read_horiz::writeProperties(::mlir::DialectBytecodeWriter &writer) {
|
|
auto &prop = getProperties(); (void)prop;
|
|
writer.writeAttribute(prop.tile_id);
|
|
}
|
|
|
|
uint32_t aarch64_sme_read_horiz::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
void aarch64_sme_read_horiz::setTileId(uint32_t attrValue) {
|
|
getProperties().tile_id = ::mlir::Builder((*this)->getContext()).getIntegerAttr(::mlir::Builder((*this)->getContext()).getIntegerType(32), attrValue);
|
|
}
|
|
|
|
void aarch64_sme_read_horiz::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value vector, ::mlir::Value predicate, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(vector);
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
odsState.addTypes(res);
|
|
}
|
|
|
|
aarch64_sme_read_horiz aarch64_sme_read_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value vector, ::mlir::Value predicate, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(res)>(res), std::forward<decltype(vector)>(vector), std::forward<decltype(predicate)>(predicate), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_read_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_read_horiz aarch64_sme_read_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value vector, ::mlir::Value predicate, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(res)>(res), std::forward<decltype(vector)>(vector), std::forward<decltype(predicate)>(predicate), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_read_horiz::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value vector, ::mlir::Value predicate, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(vector);
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
assert(resultTypes.size() == 1u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_read_horiz aarch64_sme_read_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value vector, ::mlir::Value predicate, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(vector)>(vector), std::forward<decltype(predicate)>(predicate), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_read_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_read_horiz aarch64_sme_read_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value vector, ::mlir::Value predicate, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(vector)>(vector), std::forward<decltype(predicate)>(predicate), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_read_horiz::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value vector, ::mlir::Value predicate, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(vector);
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
odsState.addTypes(res);
|
|
}
|
|
|
|
aarch64_sme_read_horiz aarch64_sme_read_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value vector, ::mlir::Value predicate, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(res)>(res), std::forward<decltype(vector)>(vector), std::forward<decltype(predicate)>(predicate), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_read_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_read_horiz aarch64_sme_read_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value vector, ::mlir::Value predicate, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(res)>(res), std::forward<decltype(vector)>(vector), std::forward<decltype(predicate)>(predicate), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_read_horiz::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value vector, ::mlir::Value predicate, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(vector);
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
assert(resultTypes.size() == 1u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_read_horiz aarch64_sme_read_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value vector, ::mlir::Value predicate, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(vector)>(vector), std::forward<decltype(predicate)>(predicate), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_read_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_read_horiz aarch64_sme_read_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value vector, ::mlir::Value predicate, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(vector)>(vector), std::forward<decltype(predicate)>(predicate), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_read_horiz::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
assert(operands.size() == 3u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.addAttributes(attributes);
|
|
assert(resultTypes.size() == 1u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
|
|
if (!attributes.empty()) {
|
|
(void)odsState.getOrAddProperties<aarch64_sme_read_horiz::Properties>();
|
|
::mlir::PropertyRef properties = odsState.getRawProperties();
|
|
std::optional<::mlir::RegisteredOperationName> info =
|
|
odsState.name.getRegisteredInfo();
|
|
if (failed(info->setOpPropertiesFromAttribute(odsState.name, properties,
|
|
odsState.attributes.getDictionary(odsState.getContext()), nullptr)))
|
|
::llvm::report_fatal_error("Property conversion failed.");
|
|
}
|
|
}
|
|
|
|
aarch64_sme_read_horiz aarch64_sme_read_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_read_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_read_horiz aarch64_sme_read_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
}
|
|
|
|
void aarch64_sme_read_horiz::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
assert(operands.size() == 3u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.useProperties(const_cast<Properties&>(properties));
|
|
odsState.addAttributes(discardableAttributes);
|
|
assert(resultTypes.size() == 1u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_read_horiz aarch64_sme_read_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_read_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_read_horiz aarch64_sme_read_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_read_horiz::verifyInvariantsImpl() {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitOpError("requires attribute 'tile_id'");
|
|
|
|
if (::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(*this, tblgen_tile_id, "tile_id")))
|
|
return ::mlir::failure();
|
|
{
|
|
unsigned index = 0; (void)index;
|
|
auto valueGroup0 = getODSOperands(0);
|
|
|
|
for (auto v : valueGroup0) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps7(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup1 = getODSOperands(1);
|
|
|
|
for (auto v : valueGroup1) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps2(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup2 = getODSOperands(2);
|
|
|
|
for (auto v : valueGroup2) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps4(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
{
|
|
unsigned index = 0; (void)index;
|
|
auto valueGroup0 = getODSResults(0);
|
|
|
|
for (auto v : valueGroup0) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps1(*this, v.getType(), "result", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
if (!(((::llvm::cast<::mlir::ShapedType>((*this->getODSOperands(0).begin()).getType()).getShape()) == (::llvm::cast<::mlir::ShapedType>((*this->getODSOperands(1).begin()).getType()).getShape()) && (::llvm::cast<::mlir::ShapedType>((*this->getODSOperands(1).begin()).getType()).getShape()) == (::llvm::cast<::mlir::ShapedType>((*this->getODSResults(0).begin()).getType()).getShape()) && (::llvm::cast<::mlir::ShapedType>((*this->getODSResults(0).begin()).getType()).getShape()) == (::llvm::cast<::mlir::ShapedType>((*this->getODSOperands(0).begin()).getType()).getShape()))))
|
|
return emitOpError("failed to verify that all of {vector, predicate, res} have same shape");
|
|
if (!(((getElementTypeOrSelf((*this->getODSOperands(0).begin()))) == (getElementTypeOrSelf((*this->getODSResults(0).begin()))) && (getElementTypeOrSelf((*this->getODSResults(0).begin()))) == (getElementTypeOrSelf((*this->getODSOperands(0).begin()))))))
|
|
return emitOpError("failed to verify that all of {vector, res} have same element type");
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_read_horiz::verifyInvariants() {
|
|
return verifyInvariantsImpl();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_read_horiz::setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
// keep track of used keys in the input dictionary to be able to error out
|
|
// if there are some unknown ones.
|
|
::mlir::DenseSet<::mlir::StringAttr> usedKeys;
|
|
::mlir::MLIRContext *ctx = dict.getContext();
|
|
(void)ctx;
|
|
{
|
|
|
|
auto &propStorage = prop.tile_id;
|
|
auto tile_idAttrName = ::mlir::StringAttr::get(ctx, "tile_id");
|
|
auto attr = dict.get(tile_idAttrName);
|
|
usedKeys.insert(tile_idAttrName);
|
|
if (attr || /*isRequired=*/true) {
|
|
if (!attr) {
|
|
emitError() << "expected key entry for tile_id in DictionaryAttr to set "
|
|
"Properties.";
|
|
return ::mlir::failure();
|
|
}
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
|
|
for (::mlir::NamedAttribute attr : dict) {
|
|
if (!usedKeys.contains(attr.getName()))
|
|
return emitError() << "unknown key '" << attr.getName() <<
|
|
"' when parsing properties dictionary";
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
|
|
} // namespace mlir::arm_sme
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::aarch64_sme_read_horiz)
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::detail::aarch64_sme_read_horizGenericAdaptorBase::Properties)
|
|
|
|
namespace mlir::arm_sme {
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ::mlir::arm_sme::aarch64_sme_read_vert definitions
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace detail {
|
|
|
|
aarch64_sme_read_vertGenericAdaptorBase::aarch64_sme_read_vertGenericAdaptorBase(aarch64_sme_read_vert op) : odsAttrs(op->getRawDictionaryAttrs()), odsOpName(op->getName()), properties(op.getProperties()), odsRegions(op->getRegions()) {}
|
|
|
|
uint32_t aarch64_sme_read_vertGenericAdaptorBase::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
|
|
} // namespace detail
|
|
aarch64_sme_read_vertAdaptor::aarch64_sme_read_vertAdaptor(aarch64_sme_read_vert op) : aarch64_sme_read_vertGenericAdaptor(op->getOperands(), op) {}
|
|
|
|
::llvm::LogicalResult aarch64_sme_read_vertAdaptor::verify(::mlir::Location loc) {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitError(loc, "'arm_sme.intr.read.vert' op requires attribute 'tile_id'");
|
|
|
|
if (tblgen_tile_id && !(((::llvm::isa<::mlir::IntegerAttr>(tblgen_tile_id))) && ((::llvm::cast<::mlir::IntegerAttr>(tblgen_tile_id).getType().isSignlessInteger(32)))))
|
|
return emitError(loc, "'arm_sme.intr.read.vert' op attribute 'tile_id' failed to satisfy constraint: 32-bit signless integer attribute");
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_read_vert::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
|
|
{
|
|
auto &propStorage = prop.tile_id;
|
|
auto attr = dict.get("tile_id");
|
|
if (attr) {
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::mlir::Attribute aarch64_sme_read_vert::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) {
|
|
::mlir::SmallVector<::mlir::NamedAttribute> attrs;
|
|
::mlir::Builder odsBuilder{ctx};
|
|
|
|
{
|
|
const auto &propStorage = prop.tile_id;
|
|
if (propStorage)
|
|
attrs.push_back(odsBuilder.getNamedAttr("tile_id",
|
|
propStorage));
|
|
}
|
|
|
|
if (!attrs.empty())
|
|
return odsBuilder.getDictionaryAttr(attrs);
|
|
return {};
|
|
}
|
|
|
|
llvm::hash_code aarch64_sme_read_vert::computePropertiesHash(const Properties &prop) {
|
|
using llvm::hash_value;
|
|
return llvm::hash_combine(
|
|
llvm::hash_value(prop.tile_id.getAsOpaquePointer()));
|
|
}
|
|
|
|
std::optional<mlir::Attribute> aarch64_sme_read_vert::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) {
|
|
if (name == "tile_id")
|
|
return prop.tile_id;
|
|
return std::nullopt;
|
|
}
|
|
|
|
void aarch64_sme_read_vert::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) {
|
|
if (name == "tile_id") {
|
|
prop.tile_id = ::llvm::dyn_cast_or_null<std::remove_reference_t<decltype(prop.tile_id)>>(value);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void aarch64_sme_read_vert::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) {
|
|
if (prop.tile_id) attrs.append("tile_id", prop.tile_id);
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_read_vert::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
{
|
|
::mlir::Attribute attr = attrs.get(getTileIdAttrName(opName));
|
|
if (attr && ::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(attr, "tile_id", emitError)))
|
|
return ::mlir::failure();
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_read_vert::readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state) {
|
|
auto &prop = state.getOrAddProperties<Properties>(); (void)prop;
|
|
if (::mlir::failed(reader.readAttribute(prop.tile_id)))
|
|
return ::mlir::failure();
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_read_vert::writeProperties(::mlir::DialectBytecodeWriter &writer) {
|
|
auto &prop = getProperties(); (void)prop;
|
|
writer.writeAttribute(prop.tile_id);
|
|
}
|
|
|
|
uint32_t aarch64_sme_read_vert::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
void aarch64_sme_read_vert::setTileId(uint32_t attrValue) {
|
|
getProperties().tile_id = ::mlir::Builder((*this)->getContext()).getIntegerAttr(::mlir::Builder((*this)->getContext()).getIntegerType(32), attrValue);
|
|
}
|
|
|
|
void aarch64_sme_read_vert::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value vector, ::mlir::Value predicate, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(vector);
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
odsState.addTypes(res);
|
|
}
|
|
|
|
aarch64_sme_read_vert aarch64_sme_read_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value vector, ::mlir::Value predicate, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(res)>(res), std::forward<decltype(vector)>(vector), std::forward<decltype(predicate)>(predicate), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_read_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_read_vert aarch64_sme_read_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value vector, ::mlir::Value predicate, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(res)>(res), std::forward<decltype(vector)>(vector), std::forward<decltype(predicate)>(predicate), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_read_vert::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value vector, ::mlir::Value predicate, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(vector);
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
assert(resultTypes.size() == 1u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_read_vert aarch64_sme_read_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value vector, ::mlir::Value predicate, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(vector)>(vector), std::forward<decltype(predicate)>(predicate), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_read_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_read_vert aarch64_sme_read_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value vector, ::mlir::Value predicate, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(vector)>(vector), std::forward<decltype(predicate)>(predicate), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_read_vert::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value vector, ::mlir::Value predicate, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(vector);
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
odsState.addTypes(res);
|
|
}
|
|
|
|
aarch64_sme_read_vert aarch64_sme_read_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value vector, ::mlir::Value predicate, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(res)>(res), std::forward<decltype(vector)>(vector), std::forward<decltype(predicate)>(predicate), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_read_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_read_vert aarch64_sme_read_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value vector, ::mlir::Value predicate, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(res)>(res), std::forward<decltype(vector)>(vector), std::forward<decltype(predicate)>(predicate), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_read_vert::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value vector, ::mlir::Value predicate, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(vector);
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
assert(resultTypes.size() == 1u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_read_vert aarch64_sme_read_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value vector, ::mlir::Value predicate, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(vector)>(vector), std::forward<decltype(predicate)>(predicate), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_read_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_read_vert aarch64_sme_read_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value vector, ::mlir::Value predicate, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(vector)>(vector), std::forward<decltype(predicate)>(predicate), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_read_vert::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
assert(operands.size() == 3u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.addAttributes(attributes);
|
|
assert(resultTypes.size() == 1u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
|
|
if (!attributes.empty()) {
|
|
(void)odsState.getOrAddProperties<aarch64_sme_read_vert::Properties>();
|
|
::mlir::PropertyRef properties = odsState.getRawProperties();
|
|
std::optional<::mlir::RegisteredOperationName> info =
|
|
odsState.name.getRegisteredInfo();
|
|
if (failed(info->setOpPropertiesFromAttribute(odsState.name, properties,
|
|
odsState.attributes.getDictionary(odsState.getContext()), nullptr)))
|
|
::llvm::report_fatal_error("Property conversion failed.");
|
|
}
|
|
}
|
|
|
|
aarch64_sme_read_vert aarch64_sme_read_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_read_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_read_vert aarch64_sme_read_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
}
|
|
|
|
void aarch64_sme_read_vert::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
assert(operands.size() == 3u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.useProperties(const_cast<Properties&>(properties));
|
|
odsState.addAttributes(discardableAttributes);
|
|
assert(resultTypes.size() == 1u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_read_vert aarch64_sme_read_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_read_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_read_vert aarch64_sme_read_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_read_vert::verifyInvariantsImpl() {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitOpError("requires attribute 'tile_id'");
|
|
|
|
if (::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(*this, tblgen_tile_id, "tile_id")))
|
|
return ::mlir::failure();
|
|
{
|
|
unsigned index = 0; (void)index;
|
|
auto valueGroup0 = getODSOperands(0);
|
|
|
|
for (auto v : valueGroup0) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps7(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup1 = getODSOperands(1);
|
|
|
|
for (auto v : valueGroup1) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps2(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup2 = getODSOperands(2);
|
|
|
|
for (auto v : valueGroup2) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps4(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
{
|
|
unsigned index = 0; (void)index;
|
|
auto valueGroup0 = getODSResults(0);
|
|
|
|
for (auto v : valueGroup0) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps1(*this, v.getType(), "result", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
if (!(((::llvm::cast<::mlir::ShapedType>((*this->getODSOperands(0).begin()).getType()).getShape()) == (::llvm::cast<::mlir::ShapedType>((*this->getODSOperands(1).begin()).getType()).getShape()) && (::llvm::cast<::mlir::ShapedType>((*this->getODSOperands(1).begin()).getType()).getShape()) == (::llvm::cast<::mlir::ShapedType>((*this->getODSResults(0).begin()).getType()).getShape()) && (::llvm::cast<::mlir::ShapedType>((*this->getODSResults(0).begin()).getType()).getShape()) == (::llvm::cast<::mlir::ShapedType>((*this->getODSOperands(0).begin()).getType()).getShape()))))
|
|
return emitOpError("failed to verify that all of {vector, predicate, res} have same shape");
|
|
if (!(((getElementTypeOrSelf((*this->getODSOperands(0).begin()))) == (getElementTypeOrSelf((*this->getODSResults(0).begin()))) && (getElementTypeOrSelf((*this->getODSResults(0).begin()))) == (getElementTypeOrSelf((*this->getODSOperands(0).begin()))))))
|
|
return emitOpError("failed to verify that all of {vector, res} have same element type");
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_read_vert::verifyInvariants() {
|
|
return verifyInvariantsImpl();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_read_vert::setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
// keep track of used keys in the input dictionary to be able to error out
|
|
// if there are some unknown ones.
|
|
::mlir::DenseSet<::mlir::StringAttr> usedKeys;
|
|
::mlir::MLIRContext *ctx = dict.getContext();
|
|
(void)ctx;
|
|
{
|
|
|
|
auto &propStorage = prop.tile_id;
|
|
auto tile_idAttrName = ::mlir::StringAttr::get(ctx, "tile_id");
|
|
auto attr = dict.get(tile_idAttrName);
|
|
usedKeys.insert(tile_idAttrName);
|
|
if (attr || /*isRequired=*/true) {
|
|
if (!attr) {
|
|
emitError() << "expected key entry for tile_id in DictionaryAttr to set "
|
|
"Properties.";
|
|
return ::mlir::failure();
|
|
}
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
|
|
for (::mlir::NamedAttribute attr : dict) {
|
|
if (!usedKeys.contains(attr.getName()))
|
|
return emitError() << "unknown key '" << attr.getName() <<
|
|
"' when parsing properties dictionary";
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
|
|
} // namespace mlir::arm_sme
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::aarch64_sme_read_vert)
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::detail::aarch64_sme_read_vertGenericAdaptorBase::Properties)
|
|
|
|
namespace mlir::arm_sme {
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ::mlir::arm_sme::aarch64_sme_smopa_wide definitions
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace detail {
|
|
|
|
aarch64_sme_smopa_wideGenericAdaptorBase::aarch64_sme_smopa_wideGenericAdaptorBase(aarch64_sme_smopa_wide op) : odsAttrs(op->getRawDictionaryAttrs()), odsOpName(op->getName()), properties(op.getProperties()), odsRegions(op->getRegions()) {}
|
|
|
|
uint32_t aarch64_sme_smopa_wideGenericAdaptorBase::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
|
|
} // namespace detail
|
|
aarch64_sme_smopa_wideAdaptor::aarch64_sme_smopa_wideAdaptor(aarch64_sme_smopa_wide op) : aarch64_sme_smopa_wideGenericAdaptor(op->getOperands(), op) {}
|
|
|
|
::llvm::LogicalResult aarch64_sme_smopa_wideAdaptor::verify(::mlir::Location loc) {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitError(loc, "'arm_sme.intr.smopa.wide' op requires attribute 'tile_id'");
|
|
|
|
if (tblgen_tile_id && !(((::llvm::isa<::mlir::IntegerAttr>(tblgen_tile_id))) && ((::llvm::cast<::mlir::IntegerAttr>(tblgen_tile_id).getType().isSignlessInteger(32)))))
|
|
return emitError(loc, "'arm_sme.intr.smopa.wide' op attribute 'tile_id' failed to satisfy constraint: 32-bit signless integer attribute");
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_smopa_wide::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
|
|
{
|
|
auto &propStorage = prop.tile_id;
|
|
auto attr = dict.get("tile_id");
|
|
if (attr) {
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::mlir::Attribute aarch64_sme_smopa_wide::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) {
|
|
::mlir::SmallVector<::mlir::NamedAttribute> attrs;
|
|
::mlir::Builder odsBuilder{ctx};
|
|
|
|
{
|
|
const auto &propStorage = prop.tile_id;
|
|
if (propStorage)
|
|
attrs.push_back(odsBuilder.getNamedAttr("tile_id",
|
|
propStorage));
|
|
}
|
|
|
|
if (!attrs.empty())
|
|
return odsBuilder.getDictionaryAttr(attrs);
|
|
return {};
|
|
}
|
|
|
|
llvm::hash_code aarch64_sme_smopa_wide::computePropertiesHash(const Properties &prop) {
|
|
using llvm::hash_value;
|
|
return llvm::hash_combine(
|
|
llvm::hash_value(prop.tile_id.getAsOpaquePointer()));
|
|
}
|
|
|
|
std::optional<mlir::Attribute> aarch64_sme_smopa_wide::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) {
|
|
if (name == "tile_id")
|
|
return prop.tile_id;
|
|
return std::nullopt;
|
|
}
|
|
|
|
void aarch64_sme_smopa_wide::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) {
|
|
if (name == "tile_id") {
|
|
prop.tile_id = ::llvm::dyn_cast_or_null<std::remove_reference_t<decltype(prop.tile_id)>>(value);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void aarch64_sme_smopa_wide::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) {
|
|
if (prop.tile_id) attrs.append("tile_id", prop.tile_id);
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_smopa_wide::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
{
|
|
::mlir::Attribute attr = attrs.get(getTileIdAttrName(opName));
|
|
if (attr && ::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(attr, "tile_id", emitError)))
|
|
return ::mlir::failure();
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_smopa_wide::readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state) {
|
|
auto &prop = state.getOrAddProperties<Properties>(); (void)prop;
|
|
if (::mlir::failed(reader.readAttribute(prop.tile_id)))
|
|
return ::mlir::failure();
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_smopa_wide::writeProperties(::mlir::DialectBytecodeWriter &writer) {
|
|
auto &prop = getProperties(); (void)prop;
|
|
writer.writeAttribute(prop.tile_id);
|
|
}
|
|
|
|
uint32_t aarch64_sme_smopa_wide::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
void aarch64_sme_smopa_wide::setTileId(uint32_t attrValue) {
|
|
getProperties().tile_id = ::mlir::Builder((*this)->getContext()).getIntegerAttr(::mlir::Builder((*this)->getContext()).getIntegerType(32), attrValue);
|
|
}
|
|
|
|
void aarch64_sme_smopa_wide::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
}
|
|
|
|
aarch64_sme_smopa_wide aarch64_sme_smopa_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_smopa_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_smopa_wide aarch64_sme_smopa_wide::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_smopa_wide::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_smopa_wide aarch64_sme_smopa_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_smopa_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_smopa_wide aarch64_sme_smopa_wide::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_smopa_wide::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
}
|
|
|
|
aarch64_sme_smopa_wide aarch64_sme_smopa_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_smopa_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_smopa_wide aarch64_sme_smopa_wide::create(::mlir::ImplicitLocOpBuilder &builder, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_smopa_wide::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_smopa_wide aarch64_sme_smopa_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_smopa_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_smopa_wide aarch64_sme_smopa_wide::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_smopa_wide::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
assert(operands.size() == 4u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.addAttributes(attributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
|
|
if (!attributes.empty()) {
|
|
(void)odsState.getOrAddProperties<aarch64_sme_smopa_wide::Properties>();
|
|
::mlir::PropertyRef properties = odsState.getRawProperties();
|
|
std::optional<::mlir::RegisteredOperationName> info =
|
|
odsState.name.getRegisteredInfo();
|
|
if (failed(info->setOpPropertiesFromAttribute(odsState.name, properties,
|
|
odsState.attributes.getDictionary(odsState.getContext()), nullptr)))
|
|
::llvm::report_fatal_error("Property conversion failed.");
|
|
}
|
|
}
|
|
|
|
aarch64_sme_smopa_wide aarch64_sme_smopa_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_smopa_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_smopa_wide aarch64_sme_smopa_wide::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
}
|
|
|
|
void aarch64_sme_smopa_wide::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
assert(operands.size() == 4u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.useProperties(const_cast<Properties&>(properties));
|
|
odsState.addAttributes(discardableAttributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_smopa_wide aarch64_sme_smopa_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_smopa_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_smopa_wide aarch64_sme_smopa_wide::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_smopa_wide::verifyInvariantsImpl() {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitOpError("requires attribute 'tile_id'");
|
|
|
|
if (::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(*this, tblgen_tile_id, "tile_id")))
|
|
return ::mlir::failure();
|
|
{
|
|
unsigned index = 0; (void)index;
|
|
auto valueGroup0 = getODSOperands(0);
|
|
|
|
for (auto v : valueGroup0) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps5(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup1 = getODSOperands(1);
|
|
|
|
for (auto v : valueGroup1) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps5(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup2 = getODSOperands(2);
|
|
|
|
for (auto v : valueGroup2) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps6(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup3 = getODSOperands(3);
|
|
|
|
for (auto v : valueGroup3) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps6(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_smopa_wide::verifyInvariants() {
|
|
return verifyInvariantsImpl();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_smopa_wide::setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
// keep track of used keys in the input dictionary to be able to error out
|
|
// if there are some unknown ones.
|
|
::mlir::DenseSet<::mlir::StringAttr> usedKeys;
|
|
::mlir::MLIRContext *ctx = dict.getContext();
|
|
(void)ctx;
|
|
{
|
|
|
|
auto &propStorage = prop.tile_id;
|
|
auto tile_idAttrName = ::mlir::StringAttr::get(ctx, "tile_id");
|
|
auto attr = dict.get(tile_idAttrName);
|
|
usedKeys.insert(tile_idAttrName);
|
|
if (attr || /*isRequired=*/true) {
|
|
if (!attr) {
|
|
emitError() << "expected key entry for tile_id in DictionaryAttr to set "
|
|
"Properties.";
|
|
return ::mlir::failure();
|
|
}
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
|
|
for (::mlir::NamedAttribute attr : dict) {
|
|
if (!usedKeys.contains(attr.getName()))
|
|
return emitError() << "unknown key '" << attr.getName() <<
|
|
"' when parsing properties dictionary";
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
|
|
} // namespace mlir::arm_sme
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::aarch64_sme_smopa_wide)
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::detail::aarch64_sme_smopa_wideGenericAdaptorBase::Properties)
|
|
|
|
namespace mlir::arm_sme {
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ::mlir::arm_sme::aarch64_sme_smopa_za32 definitions
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace detail {
|
|
|
|
aarch64_sme_smopa_za32GenericAdaptorBase::aarch64_sme_smopa_za32GenericAdaptorBase(aarch64_sme_smopa_za32 op) : odsAttrs(op->getRawDictionaryAttrs()), odsOpName(op->getName()), properties(op.getProperties()), odsRegions(op->getRegions()) {}
|
|
|
|
uint32_t aarch64_sme_smopa_za32GenericAdaptorBase::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
|
|
} // namespace detail
|
|
aarch64_sme_smopa_za32Adaptor::aarch64_sme_smopa_za32Adaptor(aarch64_sme_smopa_za32 op) : aarch64_sme_smopa_za32GenericAdaptor(op->getOperands(), op) {}
|
|
|
|
::llvm::LogicalResult aarch64_sme_smopa_za32Adaptor::verify(::mlir::Location loc) {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitError(loc, "'arm_sme.intr.smopa.za32' op requires attribute 'tile_id'");
|
|
|
|
if (tblgen_tile_id && !(((::llvm::isa<::mlir::IntegerAttr>(tblgen_tile_id))) && ((::llvm::cast<::mlir::IntegerAttr>(tblgen_tile_id).getType().isSignlessInteger(32)))))
|
|
return emitError(loc, "'arm_sme.intr.smopa.za32' op attribute 'tile_id' failed to satisfy constraint: 32-bit signless integer attribute");
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_smopa_za32::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
|
|
{
|
|
auto &propStorage = prop.tile_id;
|
|
auto attr = dict.get("tile_id");
|
|
if (attr) {
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::mlir::Attribute aarch64_sme_smopa_za32::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) {
|
|
::mlir::SmallVector<::mlir::NamedAttribute> attrs;
|
|
::mlir::Builder odsBuilder{ctx};
|
|
|
|
{
|
|
const auto &propStorage = prop.tile_id;
|
|
if (propStorage)
|
|
attrs.push_back(odsBuilder.getNamedAttr("tile_id",
|
|
propStorage));
|
|
}
|
|
|
|
if (!attrs.empty())
|
|
return odsBuilder.getDictionaryAttr(attrs);
|
|
return {};
|
|
}
|
|
|
|
llvm::hash_code aarch64_sme_smopa_za32::computePropertiesHash(const Properties &prop) {
|
|
using llvm::hash_value;
|
|
return llvm::hash_combine(
|
|
llvm::hash_value(prop.tile_id.getAsOpaquePointer()));
|
|
}
|
|
|
|
std::optional<mlir::Attribute> aarch64_sme_smopa_za32::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) {
|
|
if (name == "tile_id")
|
|
return prop.tile_id;
|
|
return std::nullopt;
|
|
}
|
|
|
|
void aarch64_sme_smopa_za32::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) {
|
|
if (name == "tile_id") {
|
|
prop.tile_id = ::llvm::dyn_cast_or_null<std::remove_reference_t<decltype(prop.tile_id)>>(value);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void aarch64_sme_smopa_za32::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) {
|
|
if (prop.tile_id) attrs.append("tile_id", prop.tile_id);
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_smopa_za32::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
{
|
|
::mlir::Attribute attr = attrs.get(getTileIdAttrName(opName));
|
|
if (attr && ::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(attr, "tile_id", emitError)))
|
|
return ::mlir::failure();
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_smopa_za32::readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state) {
|
|
auto &prop = state.getOrAddProperties<Properties>(); (void)prop;
|
|
if (::mlir::failed(reader.readAttribute(prop.tile_id)))
|
|
return ::mlir::failure();
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_smopa_za32::writeProperties(::mlir::DialectBytecodeWriter &writer) {
|
|
auto &prop = getProperties(); (void)prop;
|
|
writer.writeAttribute(prop.tile_id);
|
|
}
|
|
|
|
uint32_t aarch64_sme_smopa_za32::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
void aarch64_sme_smopa_za32::setTileId(uint32_t attrValue) {
|
|
getProperties().tile_id = ::mlir::Builder((*this)->getContext()).getIntegerAttr(::mlir::Builder((*this)->getContext()).getIntegerType(32), attrValue);
|
|
}
|
|
|
|
void aarch64_sme_smopa_za32::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
}
|
|
|
|
aarch64_sme_smopa_za32 aarch64_sme_smopa_za32::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_smopa_za32>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_smopa_za32 aarch64_sme_smopa_za32::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_smopa_za32::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_smopa_za32 aarch64_sme_smopa_za32::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_smopa_za32>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_smopa_za32 aarch64_sme_smopa_za32::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_smopa_za32::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
}
|
|
|
|
aarch64_sme_smopa_za32 aarch64_sme_smopa_za32::create(::mlir::OpBuilder &builder, ::mlir::Location location, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_smopa_za32>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_smopa_za32 aarch64_sme_smopa_za32::create(::mlir::ImplicitLocOpBuilder &builder, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_smopa_za32::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_smopa_za32 aarch64_sme_smopa_za32::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_smopa_za32>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_smopa_za32 aarch64_sme_smopa_za32::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_smopa_za32::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
assert(operands.size() == 4u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.addAttributes(attributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
|
|
if (!attributes.empty()) {
|
|
(void)odsState.getOrAddProperties<aarch64_sme_smopa_za32::Properties>();
|
|
::mlir::PropertyRef properties = odsState.getRawProperties();
|
|
std::optional<::mlir::RegisteredOperationName> info =
|
|
odsState.name.getRegisteredInfo();
|
|
if (failed(info->setOpPropertiesFromAttribute(odsState.name, properties,
|
|
odsState.attributes.getDictionary(odsState.getContext()), nullptr)))
|
|
::llvm::report_fatal_error("Property conversion failed.");
|
|
}
|
|
}
|
|
|
|
aarch64_sme_smopa_za32 aarch64_sme_smopa_za32::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_smopa_za32>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_smopa_za32 aarch64_sme_smopa_za32::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
}
|
|
|
|
void aarch64_sme_smopa_za32::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
assert(operands.size() == 4u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.useProperties(const_cast<Properties&>(properties));
|
|
odsState.addAttributes(discardableAttributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_smopa_za32 aarch64_sme_smopa_za32::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_smopa_za32>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_smopa_za32 aarch64_sme_smopa_za32::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_smopa_za32::verifyInvariantsImpl() {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitOpError("requires attribute 'tile_id'");
|
|
|
|
if (::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(*this, tblgen_tile_id, "tile_id")))
|
|
return ::mlir::failure();
|
|
{
|
|
unsigned index = 0; (void)index;
|
|
auto valueGroup0 = getODSOperands(0);
|
|
|
|
for (auto v : valueGroup0) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps5(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup1 = getODSOperands(1);
|
|
|
|
for (auto v : valueGroup1) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps5(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup2 = getODSOperands(2);
|
|
|
|
for (auto v : valueGroup2) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps6(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup3 = getODSOperands(3);
|
|
|
|
for (auto v : valueGroup3) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps6(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_smopa_za32::verifyInvariants() {
|
|
return verifyInvariantsImpl();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_smopa_za32::setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
// keep track of used keys in the input dictionary to be able to error out
|
|
// if there are some unknown ones.
|
|
::mlir::DenseSet<::mlir::StringAttr> usedKeys;
|
|
::mlir::MLIRContext *ctx = dict.getContext();
|
|
(void)ctx;
|
|
{
|
|
|
|
auto &propStorage = prop.tile_id;
|
|
auto tile_idAttrName = ::mlir::StringAttr::get(ctx, "tile_id");
|
|
auto attr = dict.get(tile_idAttrName);
|
|
usedKeys.insert(tile_idAttrName);
|
|
if (attr || /*isRequired=*/true) {
|
|
if (!attr) {
|
|
emitError() << "expected key entry for tile_id in DictionaryAttr to set "
|
|
"Properties.";
|
|
return ::mlir::failure();
|
|
}
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
|
|
for (::mlir::NamedAttribute attr : dict) {
|
|
if (!usedKeys.contains(attr.getName()))
|
|
return emitError() << "unknown key '" << attr.getName() <<
|
|
"' when parsing properties dictionary";
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
|
|
} // namespace mlir::arm_sme
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::aarch64_sme_smopa_za32)
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::detail::aarch64_sme_smopa_za32GenericAdaptorBase::Properties)
|
|
|
|
namespace mlir::arm_sme {
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ::mlir::arm_sme::aarch64_sme_smops_wide definitions
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace detail {
|
|
|
|
aarch64_sme_smops_wideGenericAdaptorBase::aarch64_sme_smops_wideGenericAdaptorBase(aarch64_sme_smops_wide op) : odsAttrs(op->getRawDictionaryAttrs()), odsOpName(op->getName()), properties(op.getProperties()), odsRegions(op->getRegions()) {}
|
|
|
|
uint32_t aarch64_sme_smops_wideGenericAdaptorBase::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
|
|
} // namespace detail
|
|
aarch64_sme_smops_wideAdaptor::aarch64_sme_smops_wideAdaptor(aarch64_sme_smops_wide op) : aarch64_sme_smops_wideGenericAdaptor(op->getOperands(), op) {}
|
|
|
|
::llvm::LogicalResult aarch64_sme_smops_wideAdaptor::verify(::mlir::Location loc) {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitError(loc, "'arm_sme.intr.smops.wide' op requires attribute 'tile_id'");
|
|
|
|
if (tblgen_tile_id && !(((::llvm::isa<::mlir::IntegerAttr>(tblgen_tile_id))) && ((::llvm::cast<::mlir::IntegerAttr>(tblgen_tile_id).getType().isSignlessInteger(32)))))
|
|
return emitError(loc, "'arm_sme.intr.smops.wide' op attribute 'tile_id' failed to satisfy constraint: 32-bit signless integer attribute");
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_smops_wide::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
|
|
{
|
|
auto &propStorage = prop.tile_id;
|
|
auto attr = dict.get("tile_id");
|
|
if (attr) {
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::mlir::Attribute aarch64_sme_smops_wide::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) {
|
|
::mlir::SmallVector<::mlir::NamedAttribute> attrs;
|
|
::mlir::Builder odsBuilder{ctx};
|
|
|
|
{
|
|
const auto &propStorage = prop.tile_id;
|
|
if (propStorage)
|
|
attrs.push_back(odsBuilder.getNamedAttr("tile_id",
|
|
propStorage));
|
|
}
|
|
|
|
if (!attrs.empty())
|
|
return odsBuilder.getDictionaryAttr(attrs);
|
|
return {};
|
|
}
|
|
|
|
llvm::hash_code aarch64_sme_smops_wide::computePropertiesHash(const Properties &prop) {
|
|
using llvm::hash_value;
|
|
return llvm::hash_combine(
|
|
llvm::hash_value(prop.tile_id.getAsOpaquePointer()));
|
|
}
|
|
|
|
std::optional<mlir::Attribute> aarch64_sme_smops_wide::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) {
|
|
if (name == "tile_id")
|
|
return prop.tile_id;
|
|
return std::nullopt;
|
|
}
|
|
|
|
void aarch64_sme_smops_wide::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) {
|
|
if (name == "tile_id") {
|
|
prop.tile_id = ::llvm::dyn_cast_or_null<std::remove_reference_t<decltype(prop.tile_id)>>(value);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void aarch64_sme_smops_wide::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) {
|
|
if (prop.tile_id) attrs.append("tile_id", prop.tile_id);
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_smops_wide::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
{
|
|
::mlir::Attribute attr = attrs.get(getTileIdAttrName(opName));
|
|
if (attr && ::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(attr, "tile_id", emitError)))
|
|
return ::mlir::failure();
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_smops_wide::readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state) {
|
|
auto &prop = state.getOrAddProperties<Properties>(); (void)prop;
|
|
if (::mlir::failed(reader.readAttribute(prop.tile_id)))
|
|
return ::mlir::failure();
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_smops_wide::writeProperties(::mlir::DialectBytecodeWriter &writer) {
|
|
auto &prop = getProperties(); (void)prop;
|
|
writer.writeAttribute(prop.tile_id);
|
|
}
|
|
|
|
uint32_t aarch64_sme_smops_wide::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
void aarch64_sme_smops_wide::setTileId(uint32_t attrValue) {
|
|
getProperties().tile_id = ::mlir::Builder((*this)->getContext()).getIntegerAttr(::mlir::Builder((*this)->getContext()).getIntegerType(32), attrValue);
|
|
}
|
|
|
|
void aarch64_sme_smops_wide::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
}
|
|
|
|
aarch64_sme_smops_wide aarch64_sme_smops_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_smops_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_smops_wide aarch64_sme_smops_wide::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_smops_wide::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_smops_wide aarch64_sme_smops_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_smops_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_smops_wide aarch64_sme_smops_wide::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_smops_wide::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
}
|
|
|
|
aarch64_sme_smops_wide aarch64_sme_smops_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_smops_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_smops_wide aarch64_sme_smops_wide::create(::mlir::ImplicitLocOpBuilder &builder, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_smops_wide::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_smops_wide aarch64_sme_smops_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_smops_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_smops_wide aarch64_sme_smops_wide::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_smops_wide::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
assert(operands.size() == 4u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.addAttributes(attributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
|
|
if (!attributes.empty()) {
|
|
(void)odsState.getOrAddProperties<aarch64_sme_smops_wide::Properties>();
|
|
::mlir::PropertyRef properties = odsState.getRawProperties();
|
|
std::optional<::mlir::RegisteredOperationName> info =
|
|
odsState.name.getRegisteredInfo();
|
|
if (failed(info->setOpPropertiesFromAttribute(odsState.name, properties,
|
|
odsState.attributes.getDictionary(odsState.getContext()), nullptr)))
|
|
::llvm::report_fatal_error("Property conversion failed.");
|
|
}
|
|
}
|
|
|
|
aarch64_sme_smops_wide aarch64_sme_smops_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_smops_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_smops_wide aarch64_sme_smops_wide::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
}
|
|
|
|
void aarch64_sme_smops_wide::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
assert(operands.size() == 4u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.useProperties(const_cast<Properties&>(properties));
|
|
odsState.addAttributes(discardableAttributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_smops_wide aarch64_sme_smops_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_smops_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_smops_wide aarch64_sme_smops_wide::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_smops_wide::verifyInvariantsImpl() {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitOpError("requires attribute 'tile_id'");
|
|
|
|
if (::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(*this, tblgen_tile_id, "tile_id")))
|
|
return ::mlir::failure();
|
|
{
|
|
unsigned index = 0; (void)index;
|
|
auto valueGroup0 = getODSOperands(0);
|
|
|
|
for (auto v : valueGroup0) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps5(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup1 = getODSOperands(1);
|
|
|
|
for (auto v : valueGroup1) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps5(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup2 = getODSOperands(2);
|
|
|
|
for (auto v : valueGroup2) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps6(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup3 = getODSOperands(3);
|
|
|
|
for (auto v : valueGroup3) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps6(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_smops_wide::verifyInvariants() {
|
|
return verifyInvariantsImpl();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_smops_wide::setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
// keep track of used keys in the input dictionary to be able to error out
|
|
// if there are some unknown ones.
|
|
::mlir::DenseSet<::mlir::StringAttr> usedKeys;
|
|
::mlir::MLIRContext *ctx = dict.getContext();
|
|
(void)ctx;
|
|
{
|
|
|
|
auto &propStorage = prop.tile_id;
|
|
auto tile_idAttrName = ::mlir::StringAttr::get(ctx, "tile_id");
|
|
auto attr = dict.get(tile_idAttrName);
|
|
usedKeys.insert(tile_idAttrName);
|
|
if (attr || /*isRequired=*/true) {
|
|
if (!attr) {
|
|
emitError() << "expected key entry for tile_id in DictionaryAttr to set "
|
|
"Properties.";
|
|
return ::mlir::failure();
|
|
}
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
|
|
for (::mlir::NamedAttribute attr : dict) {
|
|
if (!usedKeys.contains(attr.getName()))
|
|
return emitError() << "unknown key '" << attr.getName() <<
|
|
"' when parsing properties dictionary";
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
|
|
} // namespace mlir::arm_sme
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::aarch64_sme_smops_wide)
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::detail::aarch64_sme_smops_wideGenericAdaptorBase::Properties)
|
|
|
|
namespace mlir::arm_sme {
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ::mlir::arm_sme::aarch64_sme_smops_za32 definitions
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace detail {
|
|
|
|
aarch64_sme_smops_za32GenericAdaptorBase::aarch64_sme_smops_za32GenericAdaptorBase(aarch64_sme_smops_za32 op) : odsAttrs(op->getRawDictionaryAttrs()), odsOpName(op->getName()), properties(op.getProperties()), odsRegions(op->getRegions()) {}
|
|
|
|
uint32_t aarch64_sme_smops_za32GenericAdaptorBase::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
|
|
} // namespace detail
|
|
aarch64_sme_smops_za32Adaptor::aarch64_sme_smops_za32Adaptor(aarch64_sme_smops_za32 op) : aarch64_sme_smops_za32GenericAdaptor(op->getOperands(), op) {}
|
|
|
|
::llvm::LogicalResult aarch64_sme_smops_za32Adaptor::verify(::mlir::Location loc) {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitError(loc, "'arm_sme.intr.smops.za32' op requires attribute 'tile_id'");
|
|
|
|
if (tblgen_tile_id && !(((::llvm::isa<::mlir::IntegerAttr>(tblgen_tile_id))) && ((::llvm::cast<::mlir::IntegerAttr>(tblgen_tile_id).getType().isSignlessInteger(32)))))
|
|
return emitError(loc, "'arm_sme.intr.smops.za32' op attribute 'tile_id' failed to satisfy constraint: 32-bit signless integer attribute");
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_smops_za32::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
|
|
{
|
|
auto &propStorage = prop.tile_id;
|
|
auto attr = dict.get("tile_id");
|
|
if (attr) {
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::mlir::Attribute aarch64_sme_smops_za32::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) {
|
|
::mlir::SmallVector<::mlir::NamedAttribute> attrs;
|
|
::mlir::Builder odsBuilder{ctx};
|
|
|
|
{
|
|
const auto &propStorage = prop.tile_id;
|
|
if (propStorage)
|
|
attrs.push_back(odsBuilder.getNamedAttr("tile_id",
|
|
propStorage));
|
|
}
|
|
|
|
if (!attrs.empty())
|
|
return odsBuilder.getDictionaryAttr(attrs);
|
|
return {};
|
|
}
|
|
|
|
llvm::hash_code aarch64_sme_smops_za32::computePropertiesHash(const Properties &prop) {
|
|
using llvm::hash_value;
|
|
return llvm::hash_combine(
|
|
llvm::hash_value(prop.tile_id.getAsOpaquePointer()));
|
|
}
|
|
|
|
std::optional<mlir::Attribute> aarch64_sme_smops_za32::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) {
|
|
if (name == "tile_id")
|
|
return prop.tile_id;
|
|
return std::nullopt;
|
|
}
|
|
|
|
void aarch64_sme_smops_za32::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) {
|
|
if (name == "tile_id") {
|
|
prop.tile_id = ::llvm::dyn_cast_or_null<std::remove_reference_t<decltype(prop.tile_id)>>(value);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void aarch64_sme_smops_za32::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) {
|
|
if (prop.tile_id) attrs.append("tile_id", prop.tile_id);
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_smops_za32::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
{
|
|
::mlir::Attribute attr = attrs.get(getTileIdAttrName(opName));
|
|
if (attr && ::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(attr, "tile_id", emitError)))
|
|
return ::mlir::failure();
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_smops_za32::readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state) {
|
|
auto &prop = state.getOrAddProperties<Properties>(); (void)prop;
|
|
if (::mlir::failed(reader.readAttribute(prop.tile_id)))
|
|
return ::mlir::failure();
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_smops_za32::writeProperties(::mlir::DialectBytecodeWriter &writer) {
|
|
auto &prop = getProperties(); (void)prop;
|
|
writer.writeAttribute(prop.tile_id);
|
|
}
|
|
|
|
uint32_t aarch64_sme_smops_za32::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
void aarch64_sme_smops_za32::setTileId(uint32_t attrValue) {
|
|
getProperties().tile_id = ::mlir::Builder((*this)->getContext()).getIntegerAttr(::mlir::Builder((*this)->getContext()).getIntegerType(32), attrValue);
|
|
}
|
|
|
|
void aarch64_sme_smops_za32::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
}
|
|
|
|
aarch64_sme_smops_za32 aarch64_sme_smops_za32::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_smops_za32>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_smops_za32 aarch64_sme_smops_za32::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_smops_za32::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_smops_za32 aarch64_sme_smops_za32::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_smops_za32>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_smops_za32 aarch64_sme_smops_za32::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_smops_za32::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
}
|
|
|
|
aarch64_sme_smops_za32 aarch64_sme_smops_za32::create(::mlir::OpBuilder &builder, ::mlir::Location location, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_smops_za32>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_smops_za32 aarch64_sme_smops_za32::create(::mlir::ImplicitLocOpBuilder &builder, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_smops_za32::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_smops_za32 aarch64_sme_smops_za32::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_smops_za32>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_smops_za32 aarch64_sme_smops_za32::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_smops_za32::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
assert(operands.size() == 4u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.addAttributes(attributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
|
|
if (!attributes.empty()) {
|
|
(void)odsState.getOrAddProperties<aarch64_sme_smops_za32::Properties>();
|
|
::mlir::PropertyRef properties = odsState.getRawProperties();
|
|
std::optional<::mlir::RegisteredOperationName> info =
|
|
odsState.name.getRegisteredInfo();
|
|
if (failed(info->setOpPropertiesFromAttribute(odsState.name, properties,
|
|
odsState.attributes.getDictionary(odsState.getContext()), nullptr)))
|
|
::llvm::report_fatal_error("Property conversion failed.");
|
|
}
|
|
}
|
|
|
|
aarch64_sme_smops_za32 aarch64_sme_smops_za32::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_smops_za32>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_smops_za32 aarch64_sme_smops_za32::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
}
|
|
|
|
void aarch64_sme_smops_za32::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
assert(operands.size() == 4u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.useProperties(const_cast<Properties&>(properties));
|
|
odsState.addAttributes(discardableAttributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_smops_za32 aarch64_sme_smops_za32::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_smops_za32>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_smops_za32 aarch64_sme_smops_za32::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_smops_za32::verifyInvariantsImpl() {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitOpError("requires attribute 'tile_id'");
|
|
|
|
if (::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(*this, tblgen_tile_id, "tile_id")))
|
|
return ::mlir::failure();
|
|
{
|
|
unsigned index = 0; (void)index;
|
|
auto valueGroup0 = getODSOperands(0);
|
|
|
|
for (auto v : valueGroup0) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps5(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup1 = getODSOperands(1);
|
|
|
|
for (auto v : valueGroup1) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps5(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup2 = getODSOperands(2);
|
|
|
|
for (auto v : valueGroup2) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps6(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup3 = getODSOperands(3);
|
|
|
|
for (auto v : valueGroup3) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps6(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_smops_za32::verifyInvariants() {
|
|
return verifyInvariantsImpl();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_smops_za32::setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
// keep track of used keys in the input dictionary to be able to error out
|
|
// if there are some unknown ones.
|
|
::mlir::DenseSet<::mlir::StringAttr> usedKeys;
|
|
::mlir::MLIRContext *ctx = dict.getContext();
|
|
(void)ctx;
|
|
{
|
|
|
|
auto &propStorage = prop.tile_id;
|
|
auto tile_idAttrName = ::mlir::StringAttr::get(ctx, "tile_id");
|
|
auto attr = dict.get(tile_idAttrName);
|
|
usedKeys.insert(tile_idAttrName);
|
|
if (attr || /*isRequired=*/true) {
|
|
if (!attr) {
|
|
emitError() << "expected key entry for tile_id in DictionaryAttr to set "
|
|
"Properties.";
|
|
return ::mlir::failure();
|
|
}
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
|
|
for (::mlir::NamedAttribute attr : dict) {
|
|
if (!usedKeys.contains(attr.getName()))
|
|
return emitError() << "unknown key '" << attr.getName() <<
|
|
"' when parsing properties dictionary";
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
|
|
} // namespace mlir::arm_sme
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::aarch64_sme_smops_za32)
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::detail::aarch64_sme_smops_za32GenericAdaptorBase::Properties)
|
|
|
|
namespace mlir::arm_sme {
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ::mlir::arm_sme::aarch64_sme_st1b_horiz definitions
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace detail {
|
|
|
|
aarch64_sme_st1b_horizGenericAdaptorBase::aarch64_sme_st1b_horizGenericAdaptorBase(aarch64_sme_st1b_horiz op) : odsAttrs(op->getRawDictionaryAttrs()), odsOpName(op->getName()), properties(op.getProperties()), odsRegions(op->getRegions()) {}
|
|
|
|
uint32_t aarch64_sme_st1b_horizGenericAdaptorBase::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
|
|
} // namespace detail
|
|
aarch64_sme_st1b_horizAdaptor::aarch64_sme_st1b_horizAdaptor(aarch64_sme_st1b_horiz op) : aarch64_sme_st1b_horizGenericAdaptor(op->getOperands(), op) {}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1b_horizAdaptor::verify(::mlir::Location loc) {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitError(loc, "'arm_sme.intr.st1b.horiz' op requires attribute 'tile_id'");
|
|
|
|
if (tblgen_tile_id && !(((::llvm::isa<::mlir::IntegerAttr>(tblgen_tile_id))) && ((::llvm::cast<::mlir::IntegerAttr>(tblgen_tile_id).getType().isSignlessInteger(32)))))
|
|
return emitError(loc, "'arm_sme.intr.st1b.horiz' op attribute 'tile_id' failed to satisfy constraint: 32-bit signless integer attribute");
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1b_horiz::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
|
|
{
|
|
auto &propStorage = prop.tile_id;
|
|
auto attr = dict.get("tile_id");
|
|
if (attr) {
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::mlir::Attribute aarch64_sme_st1b_horiz::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) {
|
|
::mlir::SmallVector<::mlir::NamedAttribute> attrs;
|
|
::mlir::Builder odsBuilder{ctx};
|
|
|
|
{
|
|
const auto &propStorage = prop.tile_id;
|
|
if (propStorage)
|
|
attrs.push_back(odsBuilder.getNamedAttr("tile_id",
|
|
propStorage));
|
|
}
|
|
|
|
if (!attrs.empty())
|
|
return odsBuilder.getDictionaryAttr(attrs);
|
|
return {};
|
|
}
|
|
|
|
llvm::hash_code aarch64_sme_st1b_horiz::computePropertiesHash(const Properties &prop) {
|
|
using llvm::hash_value;
|
|
return llvm::hash_combine(
|
|
llvm::hash_value(prop.tile_id.getAsOpaquePointer()));
|
|
}
|
|
|
|
std::optional<mlir::Attribute> aarch64_sme_st1b_horiz::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) {
|
|
if (name == "tile_id")
|
|
return prop.tile_id;
|
|
return std::nullopt;
|
|
}
|
|
|
|
void aarch64_sme_st1b_horiz::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) {
|
|
if (name == "tile_id") {
|
|
prop.tile_id = ::llvm::dyn_cast_or_null<std::remove_reference_t<decltype(prop.tile_id)>>(value);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void aarch64_sme_st1b_horiz::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) {
|
|
if (prop.tile_id) attrs.append("tile_id", prop.tile_id);
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1b_horiz::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
{
|
|
::mlir::Attribute attr = attrs.get(getTileIdAttrName(opName));
|
|
if (attr && ::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(attr, "tile_id", emitError)))
|
|
return ::mlir::failure();
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1b_horiz::readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state) {
|
|
auto &prop = state.getOrAddProperties<Properties>(); (void)prop;
|
|
if (::mlir::failed(reader.readAttribute(prop.tile_id)))
|
|
return ::mlir::failure();
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_st1b_horiz::writeProperties(::mlir::DialectBytecodeWriter &writer) {
|
|
auto &prop = getProperties(); (void)prop;
|
|
writer.writeAttribute(prop.tile_id);
|
|
}
|
|
|
|
uint32_t aarch64_sme_st1b_horiz::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
void aarch64_sme_st1b_horiz::setTileId(uint32_t attrValue) {
|
|
getProperties().tile_id = ::mlir::Builder((*this)->getContext()).getIntegerAttr(::mlir::Builder((*this)->getContext()).getIntegerType(32), attrValue);
|
|
}
|
|
|
|
void aarch64_sme_st1b_horiz::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(store_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
}
|
|
|
|
aarch64_sme_st1b_horiz aarch64_sme_st1b_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1b_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1b_horiz aarch64_sme_st1b_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_st1b_horiz::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(store_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_st1b_horiz aarch64_sme_st1b_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1b_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1b_horiz aarch64_sme_st1b_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_st1b_horiz::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(store_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
}
|
|
|
|
aarch64_sme_st1b_horiz aarch64_sme_st1b_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1b_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1b_horiz aarch64_sme_st1b_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_st1b_horiz::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(store_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_st1b_horiz aarch64_sme_st1b_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1b_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1b_horiz aarch64_sme_st1b_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_st1b_horiz::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
assert(operands.size() == 3u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.addAttributes(attributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
|
|
if (!attributes.empty()) {
|
|
(void)odsState.getOrAddProperties<aarch64_sme_st1b_horiz::Properties>();
|
|
::mlir::PropertyRef properties = odsState.getRawProperties();
|
|
std::optional<::mlir::RegisteredOperationName> info =
|
|
odsState.name.getRegisteredInfo();
|
|
if (failed(info->setOpPropertiesFromAttribute(odsState.name, properties,
|
|
odsState.attributes.getDictionary(odsState.getContext()), nullptr)))
|
|
::llvm::report_fatal_error("Property conversion failed.");
|
|
}
|
|
}
|
|
|
|
aarch64_sme_st1b_horiz aarch64_sme_st1b_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1b_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1b_horiz aarch64_sme_st1b_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
}
|
|
|
|
void aarch64_sme_st1b_horiz::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
assert(operands.size() == 3u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.useProperties(const_cast<Properties&>(properties));
|
|
odsState.addAttributes(discardableAttributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_st1b_horiz aarch64_sme_st1b_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1b_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1b_horiz aarch64_sme_st1b_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1b_horiz::verifyInvariantsImpl() {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitOpError("requires attribute 'tile_id'");
|
|
|
|
if (::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(*this, tblgen_tile_id, "tile_id")))
|
|
return ::mlir::failure();
|
|
{
|
|
unsigned index = 0; (void)index;
|
|
auto valueGroup0 = getODSOperands(0);
|
|
|
|
for (auto v : valueGroup0) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps2(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup1 = getODSOperands(1);
|
|
|
|
for (auto v : valueGroup1) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps3(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup2 = getODSOperands(2);
|
|
|
|
for (auto v : valueGroup2) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps4(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1b_horiz::verifyInvariants() {
|
|
return verifyInvariantsImpl();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1b_horiz::setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
// keep track of used keys in the input dictionary to be able to error out
|
|
// if there are some unknown ones.
|
|
::mlir::DenseSet<::mlir::StringAttr> usedKeys;
|
|
::mlir::MLIRContext *ctx = dict.getContext();
|
|
(void)ctx;
|
|
{
|
|
|
|
auto &propStorage = prop.tile_id;
|
|
auto tile_idAttrName = ::mlir::StringAttr::get(ctx, "tile_id");
|
|
auto attr = dict.get(tile_idAttrName);
|
|
usedKeys.insert(tile_idAttrName);
|
|
if (attr || /*isRequired=*/true) {
|
|
if (!attr) {
|
|
emitError() << "expected key entry for tile_id in DictionaryAttr to set "
|
|
"Properties.";
|
|
return ::mlir::failure();
|
|
}
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
|
|
for (::mlir::NamedAttribute attr : dict) {
|
|
if (!usedKeys.contains(attr.getName()))
|
|
return emitError() << "unknown key '" << attr.getName() <<
|
|
"' when parsing properties dictionary";
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_st1b_horiz::getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
|
|
{
|
|
auto valueRange = getODSOperandIndexAndLength(1);
|
|
for (unsigned idx = valueRange.first; idx < valueRange.first + valueRange.second; idx++) {
|
|
effects.emplace_back(::mlir::MemoryEffects::Write::get(), &getOperation()->getOpOperand(idx), 0, false, ::mlir::SideEffects::DefaultResource::get());
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace mlir::arm_sme
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::aarch64_sme_st1b_horiz)
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::detail::aarch64_sme_st1b_horizGenericAdaptorBase::Properties)
|
|
|
|
namespace mlir::arm_sme {
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ::mlir::arm_sme::aarch64_sme_st1b_vert definitions
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace detail {
|
|
|
|
aarch64_sme_st1b_vertGenericAdaptorBase::aarch64_sme_st1b_vertGenericAdaptorBase(aarch64_sme_st1b_vert op) : odsAttrs(op->getRawDictionaryAttrs()), odsOpName(op->getName()), properties(op.getProperties()), odsRegions(op->getRegions()) {}
|
|
|
|
uint32_t aarch64_sme_st1b_vertGenericAdaptorBase::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
|
|
} // namespace detail
|
|
aarch64_sme_st1b_vertAdaptor::aarch64_sme_st1b_vertAdaptor(aarch64_sme_st1b_vert op) : aarch64_sme_st1b_vertGenericAdaptor(op->getOperands(), op) {}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1b_vertAdaptor::verify(::mlir::Location loc) {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitError(loc, "'arm_sme.intr.st1b.vert' op requires attribute 'tile_id'");
|
|
|
|
if (tblgen_tile_id && !(((::llvm::isa<::mlir::IntegerAttr>(tblgen_tile_id))) && ((::llvm::cast<::mlir::IntegerAttr>(tblgen_tile_id).getType().isSignlessInteger(32)))))
|
|
return emitError(loc, "'arm_sme.intr.st1b.vert' op attribute 'tile_id' failed to satisfy constraint: 32-bit signless integer attribute");
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1b_vert::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
|
|
{
|
|
auto &propStorage = prop.tile_id;
|
|
auto attr = dict.get("tile_id");
|
|
if (attr) {
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::mlir::Attribute aarch64_sme_st1b_vert::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) {
|
|
::mlir::SmallVector<::mlir::NamedAttribute> attrs;
|
|
::mlir::Builder odsBuilder{ctx};
|
|
|
|
{
|
|
const auto &propStorage = prop.tile_id;
|
|
if (propStorage)
|
|
attrs.push_back(odsBuilder.getNamedAttr("tile_id",
|
|
propStorage));
|
|
}
|
|
|
|
if (!attrs.empty())
|
|
return odsBuilder.getDictionaryAttr(attrs);
|
|
return {};
|
|
}
|
|
|
|
llvm::hash_code aarch64_sme_st1b_vert::computePropertiesHash(const Properties &prop) {
|
|
using llvm::hash_value;
|
|
return llvm::hash_combine(
|
|
llvm::hash_value(prop.tile_id.getAsOpaquePointer()));
|
|
}
|
|
|
|
std::optional<mlir::Attribute> aarch64_sme_st1b_vert::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) {
|
|
if (name == "tile_id")
|
|
return prop.tile_id;
|
|
return std::nullopt;
|
|
}
|
|
|
|
void aarch64_sme_st1b_vert::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) {
|
|
if (name == "tile_id") {
|
|
prop.tile_id = ::llvm::dyn_cast_or_null<std::remove_reference_t<decltype(prop.tile_id)>>(value);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void aarch64_sme_st1b_vert::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) {
|
|
if (prop.tile_id) attrs.append("tile_id", prop.tile_id);
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1b_vert::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
{
|
|
::mlir::Attribute attr = attrs.get(getTileIdAttrName(opName));
|
|
if (attr && ::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(attr, "tile_id", emitError)))
|
|
return ::mlir::failure();
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1b_vert::readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state) {
|
|
auto &prop = state.getOrAddProperties<Properties>(); (void)prop;
|
|
if (::mlir::failed(reader.readAttribute(prop.tile_id)))
|
|
return ::mlir::failure();
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_st1b_vert::writeProperties(::mlir::DialectBytecodeWriter &writer) {
|
|
auto &prop = getProperties(); (void)prop;
|
|
writer.writeAttribute(prop.tile_id);
|
|
}
|
|
|
|
uint32_t aarch64_sme_st1b_vert::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
void aarch64_sme_st1b_vert::setTileId(uint32_t attrValue) {
|
|
getProperties().tile_id = ::mlir::Builder((*this)->getContext()).getIntegerAttr(::mlir::Builder((*this)->getContext()).getIntegerType(32), attrValue);
|
|
}
|
|
|
|
void aarch64_sme_st1b_vert::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(store_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
}
|
|
|
|
aarch64_sme_st1b_vert aarch64_sme_st1b_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1b_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1b_vert aarch64_sme_st1b_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_st1b_vert::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(store_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_st1b_vert aarch64_sme_st1b_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1b_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1b_vert aarch64_sme_st1b_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_st1b_vert::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(store_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
}
|
|
|
|
aarch64_sme_st1b_vert aarch64_sme_st1b_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1b_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1b_vert aarch64_sme_st1b_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_st1b_vert::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(store_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_st1b_vert aarch64_sme_st1b_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1b_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1b_vert aarch64_sme_st1b_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_st1b_vert::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
assert(operands.size() == 3u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.addAttributes(attributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
|
|
if (!attributes.empty()) {
|
|
(void)odsState.getOrAddProperties<aarch64_sme_st1b_vert::Properties>();
|
|
::mlir::PropertyRef properties = odsState.getRawProperties();
|
|
std::optional<::mlir::RegisteredOperationName> info =
|
|
odsState.name.getRegisteredInfo();
|
|
if (failed(info->setOpPropertiesFromAttribute(odsState.name, properties,
|
|
odsState.attributes.getDictionary(odsState.getContext()), nullptr)))
|
|
::llvm::report_fatal_error("Property conversion failed.");
|
|
}
|
|
}
|
|
|
|
aarch64_sme_st1b_vert aarch64_sme_st1b_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1b_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1b_vert aarch64_sme_st1b_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
}
|
|
|
|
void aarch64_sme_st1b_vert::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
assert(operands.size() == 3u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.useProperties(const_cast<Properties&>(properties));
|
|
odsState.addAttributes(discardableAttributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_st1b_vert aarch64_sme_st1b_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1b_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1b_vert aarch64_sme_st1b_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1b_vert::verifyInvariantsImpl() {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitOpError("requires attribute 'tile_id'");
|
|
|
|
if (::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(*this, tblgen_tile_id, "tile_id")))
|
|
return ::mlir::failure();
|
|
{
|
|
unsigned index = 0; (void)index;
|
|
auto valueGroup0 = getODSOperands(0);
|
|
|
|
for (auto v : valueGroup0) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps2(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup1 = getODSOperands(1);
|
|
|
|
for (auto v : valueGroup1) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps3(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup2 = getODSOperands(2);
|
|
|
|
for (auto v : valueGroup2) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps4(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1b_vert::verifyInvariants() {
|
|
return verifyInvariantsImpl();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1b_vert::setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
// keep track of used keys in the input dictionary to be able to error out
|
|
// if there are some unknown ones.
|
|
::mlir::DenseSet<::mlir::StringAttr> usedKeys;
|
|
::mlir::MLIRContext *ctx = dict.getContext();
|
|
(void)ctx;
|
|
{
|
|
|
|
auto &propStorage = prop.tile_id;
|
|
auto tile_idAttrName = ::mlir::StringAttr::get(ctx, "tile_id");
|
|
auto attr = dict.get(tile_idAttrName);
|
|
usedKeys.insert(tile_idAttrName);
|
|
if (attr || /*isRequired=*/true) {
|
|
if (!attr) {
|
|
emitError() << "expected key entry for tile_id in DictionaryAttr to set "
|
|
"Properties.";
|
|
return ::mlir::failure();
|
|
}
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
|
|
for (::mlir::NamedAttribute attr : dict) {
|
|
if (!usedKeys.contains(attr.getName()))
|
|
return emitError() << "unknown key '" << attr.getName() <<
|
|
"' when parsing properties dictionary";
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_st1b_vert::getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
|
|
{
|
|
auto valueRange = getODSOperandIndexAndLength(1);
|
|
for (unsigned idx = valueRange.first; idx < valueRange.first + valueRange.second; idx++) {
|
|
effects.emplace_back(::mlir::MemoryEffects::Write::get(), &getOperation()->getOpOperand(idx), 0, false, ::mlir::SideEffects::DefaultResource::get());
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace mlir::arm_sme
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::aarch64_sme_st1b_vert)
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::detail::aarch64_sme_st1b_vertGenericAdaptorBase::Properties)
|
|
|
|
namespace mlir::arm_sme {
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ::mlir::arm_sme::aarch64_sme_st1d_horiz definitions
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace detail {
|
|
|
|
aarch64_sme_st1d_horizGenericAdaptorBase::aarch64_sme_st1d_horizGenericAdaptorBase(aarch64_sme_st1d_horiz op) : odsAttrs(op->getRawDictionaryAttrs()), odsOpName(op->getName()), properties(op.getProperties()), odsRegions(op->getRegions()) {}
|
|
|
|
uint32_t aarch64_sme_st1d_horizGenericAdaptorBase::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
|
|
} // namespace detail
|
|
aarch64_sme_st1d_horizAdaptor::aarch64_sme_st1d_horizAdaptor(aarch64_sme_st1d_horiz op) : aarch64_sme_st1d_horizGenericAdaptor(op->getOperands(), op) {}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1d_horizAdaptor::verify(::mlir::Location loc) {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitError(loc, "'arm_sme.intr.st1d.horiz' op requires attribute 'tile_id'");
|
|
|
|
if (tblgen_tile_id && !(((::llvm::isa<::mlir::IntegerAttr>(tblgen_tile_id))) && ((::llvm::cast<::mlir::IntegerAttr>(tblgen_tile_id).getType().isSignlessInteger(32)))))
|
|
return emitError(loc, "'arm_sme.intr.st1d.horiz' op attribute 'tile_id' failed to satisfy constraint: 32-bit signless integer attribute");
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1d_horiz::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
|
|
{
|
|
auto &propStorage = prop.tile_id;
|
|
auto attr = dict.get("tile_id");
|
|
if (attr) {
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::mlir::Attribute aarch64_sme_st1d_horiz::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) {
|
|
::mlir::SmallVector<::mlir::NamedAttribute> attrs;
|
|
::mlir::Builder odsBuilder{ctx};
|
|
|
|
{
|
|
const auto &propStorage = prop.tile_id;
|
|
if (propStorage)
|
|
attrs.push_back(odsBuilder.getNamedAttr("tile_id",
|
|
propStorage));
|
|
}
|
|
|
|
if (!attrs.empty())
|
|
return odsBuilder.getDictionaryAttr(attrs);
|
|
return {};
|
|
}
|
|
|
|
llvm::hash_code aarch64_sme_st1d_horiz::computePropertiesHash(const Properties &prop) {
|
|
using llvm::hash_value;
|
|
return llvm::hash_combine(
|
|
llvm::hash_value(prop.tile_id.getAsOpaquePointer()));
|
|
}
|
|
|
|
std::optional<mlir::Attribute> aarch64_sme_st1d_horiz::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) {
|
|
if (name == "tile_id")
|
|
return prop.tile_id;
|
|
return std::nullopt;
|
|
}
|
|
|
|
void aarch64_sme_st1d_horiz::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) {
|
|
if (name == "tile_id") {
|
|
prop.tile_id = ::llvm::dyn_cast_or_null<std::remove_reference_t<decltype(prop.tile_id)>>(value);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void aarch64_sme_st1d_horiz::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) {
|
|
if (prop.tile_id) attrs.append("tile_id", prop.tile_id);
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1d_horiz::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
{
|
|
::mlir::Attribute attr = attrs.get(getTileIdAttrName(opName));
|
|
if (attr && ::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(attr, "tile_id", emitError)))
|
|
return ::mlir::failure();
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1d_horiz::readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state) {
|
|
auto &prop = state.getOrAddProperties<Properties>(); (void)prop;
|
|
if (::mlir::failed(reader.readAttribute(prop.tile_id)))
|
|
return ::mlir::failure();
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_st1d_horiz::writeProperties(::mlir::DialectBytecodeWriter &writer) {
|
|
auto &prop = getProperties(); (void)prop;
|
|
writer.writeAttribute(prop.tile_id);
|
|
}
|
|
|
|
uint32_t aarch64_sme_st1d_horiz::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
void aarch64_sme_st1d_horiz::setTileId(uint32_t attrValue) {
|
|
getProperties().tile_id = ::mlir::Builder((*this)->getContext()).getIntegerAttr(::mlir::Builder((*this)->getContext()).getIntegerType(32), attrValue);
|
|
}
|
|
|
|
void aarch64_sme_st1d_horiz::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(store_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
}
|
|
|
|
aarch64_sme_st1d_horiz aarch64_sme_st1d_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1d_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1d_horiz aarch64_sme_st1d_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_st1d_horiz::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(store_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_st1d_horiz aarch64_sme_st1d_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1d_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1d_horiz aarch64_sme_st1d_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_st1d_horiz::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(store_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
}
|
|
|
|
aarch64_sme_st1d_horiz aarch64_sme_st1d_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1d_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1d_horiz aarch64_sme_st1d_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_st1d_horiz::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(store_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_st1d_horiz aarch64_sme_st1d_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1d_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1d_horiz aarch64_sme_st1d_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_st1d_horiz::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
assert(operands.size() == 3u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.addAttributes(attributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
|
|
if (!attributes.empty()) {
|
|
(void)odsState.getOrAddProperties<aarch64_sme_st1d_horiz::Properties>();
|
|
::mlir::PropertyRef properties = odsState.getRawProperties();
|
|
std::optional<::mlir::RegisteredOperationName> info =
|
|
odsState.name.getRegisteredInfo();
|
|
if (failed(info->setOpPropertiesFromAttribute(odsState.name, properties,
|
|
odsState.attributes.getDictionary(odsState.getContext()), nullptr)))
|
|
::llvm::report_fatal_error("Property conversion failed.");
|
|
}
|
|
}
|
|
|
|
aarch64_sme_st1d_horiz aarch64_sme_st1d_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1d_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1d_horiz aarch64_sme_st1d_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
}
|
|
|
|
void aarch64_sme_st1d_horiz::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
assert(operands.size() == 3u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.useProperties(const_cast<Properties&>(properties));
|
|
odsState.addAttributes(discardableAttributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_st1d_horiz aarch64_sme_st1d_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1d_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1d_horiz aarch64_sme_st1d_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1d_horiz::verifyInvariantsImpl() {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitOpError("requires attribute 'tile_id'");
|
|
|
|
if (::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(*this, tblgen_tile_id, "tile_id")))
|
|
return ::mlir::failure();
|
|
{
|
|
unsigned index = 0; (void)index;
|
|
auto valueGroup0 = getODSOperands(0);
|
|
|
|
for (auto v : valueGroup0) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps2(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup1 = getODSOperands(1);
|
|
|
|
for (auto v : valueGroup1) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps3(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup2 = getODSOperands(2);
|
|
|
|
for (auto v : valueGroup2) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps4(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1d_horiz::verifyInvariants() {
|
|
return verifyInvariantsImpl();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1d_horiz::setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
// keep track of used keys in the input dictionary to be able to error out
|
|
// if there are some unknown ones.
|
|
::mlir::DenseSet<::mlir::StringAttr> usedKeys;
|
|
::mlir::MLIRContext *ctx = dict.getContext();
|
|
(void)ctx;
|
|
{
|
|
|
|
auto &propStorage = prop.tile_id;
|
|
auto tile_idAttrName = ::mlir::StringAttr::get(ctx, "tile_id");
|
|
auto attr = dict.get(tile_idAttrName);
|
|
usedKeys.insert(tile_idAttrName);
|
|
if (attr || /*isRequired=*/true) {
|
|
if (!attr) {
|
|
emitError() << "expected key entry for tile_id in DictionaryAttr to set "
|
|
"Properties.";
|
|
return ::mlir::failure();
|
|
}
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
|
|
for (::mlir::NamedAttribute attr : dict) {
|
|
if (!usedKeys.contains(attr.getName()))
|
|
return emitError() << "unknown key '" << attr.getName() <<
|
|
"' when parsing properties dictionary";
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_st1d_horiz::getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
|
|
{
|
|
auto valueRange = getODSOperandIndexAndLength(1);
|
|
for (unsigned idx = valueRange.first; idx < valueRange.first + valueRange.second; idx++) {
|
|
effects.emplace_back(::mlir::MemoryEffects::Write::get(), &getOperation()->getOpOperand(idx), 0, false, ::mlir::SideEffects::DefaultResource::get());
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace mlir::arm_sme
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::aarch64_sme_st1d_horiz)
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::detail::aarch64_sme_st1d_horizGenericAdaptorBase::Properties)
|
|
|
|
namespace mlir::arm_sme {
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ::mlir::arm_sme::aarch64_sme_st1d_vert definitions
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace detail {
|
|
|
|
aarch64_sme_st1d_vertGenericAdaptorBase::aarch64_sme_st1d_vertGenericAdaptorBase(aarch64_sme_st1d_vert op) : odsAttrs(op->getRawDictionaryAttrs()), odsOpName(op->getName()), properties(op.getProperties()), odsRegions(op->getRegions()) {}
|
|
|
|
uint32_t aarch64_sme_st1d_vertGenericAdaptorBase::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
|
|
} // namespace detail
|
|
aarch64_sme_st1d_vertAdaptor::aarch64_sme_st1d_vertAdaptor(aarch64_sme_st1d_vert op) : aarch64_sme_st1d_vertGenericAdaptor(op->getOperands(), op) {}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1d_vertAdaptor::verify(::mlir::Location loc) {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitError(loc, "'arm_sme.intr.st1d.vert' op requires attribute 'tile_id'");
|
|
|
|
if (tblgen_tile_id && !(((::llvm::isa<::mlir::IntegerAttr>(tblgen_tile_id))) && ((::llvm::cast<::mlir::IntegerAttr>(tblgen_tile_id).getType().isSignlessInteger(32)))))
|
|
return emitError(loc, "'arm_sme.intr.st1d.vert' op attribute 'tile_id' failed to satisfy constraint: 32-bit signless integer attribute");
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1d_vert::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
|
|
{
|
|
auto &propStorage = prop.tile_id;
|
|
auto attr = dict.get("tile_id");
|
|
if (attr) {
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::mlir::Attribute aarch64_sme_st1d_vert::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) {
|
|
::mlir::SmallVector<::mlir::NamedAttribute> attrs;
|
|
::mlir::Builder odsBuilder{ctx};
|
|
|
|
{
|
|
const auto &propStorage = prop.tile_id;
|
|
if (propStorage)
|
|
attrs.push_back(odsBuilder.getNamedAttr("tile_id",
|
|
propStorage));
|
|
}
|
|
|
|
if (!attrs.empty())
|
|
return odsBuilder.getDictionaryAttr(attrs);
|
|
return {};
|
|
}
|
|
|
|
llvm::hash_code aarch64_sme_st1d_vert::computePropertiesHash(const Properties &prop) {
|
|
using llvm::hash_value;
|
|
return llvm::hash_combine(
|
|
llvm::hash_value(prop.tile_id.getAsOpaquePointer()));
|
|
}
|
|
|
|
std::optional<mlir::Attribute> aarch64_sme_st1d_vert::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) {
|
|
if (name == "tile_id")
|
|
return prop.tile_id;
|
|
return std::nullopt;
|
|
}
|
|
|
|
void aarch64_sme_st1d_vert::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) {
|
|
if (name == "tile_id") {
|
|
prop.tile_id = ::llvm::dyn_cast_or_null<std::remove_reference_t<decltype(prop.tile_id)>>(value);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void aarch64_sme_st1d_vert::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) {
|
|
if (prop.tile_id) attrs.append("tile_id", prop.tile_id);
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1d_vert::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
{
|
|
::mlir::Attribute attr = attrs.get(getTileIdAttrName(opName));
|
|
if (attr && ::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(attr, "tile_id", emitError)))
|
|
return ::mlir::failure();
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1d_vert::readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state) {
|
|
auto &prop = state.getOrAddProperties<Properties>(); (void)prop;
|
|
if (::mlir::failed(reader.readAttribute(prop.tile_id)))
|
|
return ::mlir::failure();
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_st1d_vert::writeProperties(::mlir::DialectBytecodeWriter &writer) {
|
|
auto &prop = getProperties(); (void)prop;
|
|
writer.writeAttribute(prop.tile_id);
|
|
}
|
|
|
|
uint32_t aarch64_sme_st1d_vert::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
void aarch64_sme_st1d_vert::setTileId(uint32_t attrValue) {
|
|
getProperties().tile_id = ::mlir::Builder((*this)->getContext()).getIntegerAttr(::mlir::Builder((*this)->getContext()).getIntegerType(32), attrValue);
|
|
}
|
|
|
|
void aarch64_sme_st1d_vert::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(store_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
}
|
|
|
|
aarch64_sme_st1d_vert aarch64_sme_st1d_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1d_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1d_vert aarch64_sme_st1d_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_st1d_vert::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(store_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_st1d_vert aarch64_sme_st1d_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1d_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1d_vert aarch64_sme_st1d_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_st1d_vert::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(store_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
}
|
|
|
|
aarch64_sme_st1d_vert aarch64_sme_st1d_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1d_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1d_vert aarch64_sme_st1d_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_st1d_vert::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(store_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_st1d_vert aarch64_sme_st1d_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1d_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1d_vert aarch64_sme_st1d_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_st1d_vert::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
assert(operands.size() == 3u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.addAttributes(attributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
|
|
if (!attributes.empty()) {
|
|
(void)odsState.getOrAddProperties<aarch64_sme_st1d_vert::Properties>();
|
|
::mlir::PropertyRef properties = odsState.getRawProperties();
|
|
std::optional<::mlir::RegisteredOperationName> info =
|
|
odsState.name.getRegisteredInfo();
|
|
if (failed(info->setOpPropertiesFromAttribute(odsState.name, properties,
|
|
odsState.attributes.getDictionary(odsState.getContext()), nullptr)))
|
|
::llvm::report_fatal_error("Property conversion failed.");
|
|
}
|
|
}
|
|
|
|
aarch64_sme_st1d_vert aarch64_sme_st1d_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1d_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1d_vert aarch64_sme_st1d_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
}
|
|
|
|
void aarch64_sme_st1d_vert::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
assert(operands.size() == 3u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.useProperties(const_cast<Properties&>(properties));
|
|
odsState.addAttributes(discardableAttributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_st1d_vert aarch64_sme_st1d_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1d_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1d_vert aarch64_sme_st1d_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1d_vert::verifyInvariantsImpl() {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitOpError("requires attribute 'tile_id'");
|
|
|
|
if (::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(*this, tblgen_tile_id, "tile_id")))
|
|
return ::mlir::failure();
|
|
{
|
|
unsigned index = 0; (void)index;
|
|
auto valueGroup0 = getODSOperands(0);
|
|
|
|
for (auto v : valueGroup0) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps2(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup1 = getODSOperands(1);
|
|
|
|
for (auto v : valueGroup1) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps3(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup2 = getODSOperands(2);
|
|
|
|
for (auto v : valueGroup2) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps4(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1d_vert::verifyInvariants() {
|
|
return verifyInvariantsImpl();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1d_vert::setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
// keep track of used keys in the input dictionary to be able to error out
|
|
// if there are some unknown ones.
|
|
::mlir::DenseSet<::mlir::StringAttr> usedKeys;
|
|
::mlir::MLIRContext *ctx = dict.getContext();
|
|
(void)ctx;
|
|
{
|
|
|
|
auto &propStorage = prop.tile_id;
|
|
auto tile_idAttrName = ::mlir::StringAttr::get(ctx, "tile_id");
|
|
auto attr = dict.get(tile_idAttrName);
|
|
usedKeys.insert(tile_idAttrName);
|
|
if (attr || /*isRequired=*/true) {
|
|
if (!attr) {
|
|
emitError() << "expected key entry for tile_id in DictionaryAttr to set "
|
|
"Properties.";
|
|
return ::mlir::failure();
|
|
}
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
|
|
for (::mlir::NamedAttribute attr : dict) {
|
|
if (!usedKeys.contains(attr.getName()))
|
|
return emitError() << "unknown key '" << attr.getName() <<
|
|
"' when parsing properties dictionary";
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_st1d_vert::getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
|
|
{
|
|
auto valueRange = getODSOperandIndexAndLength(1);
|
|
for (unsigned idx = valueRange.first; idx < valueRange.first + valueRange.second; idx++) {
|
|
effects.emplace_back(::mlir::MemoryEffects::Write::get(), &getOperation()->getOpOperand(idx), 0, false, ::mlir::SideEffects::DefaultResource::get());
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace mlir::arm_sme
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::aarch64_sme_st1d_vert)
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::detail::aarch64_sme_st1d_vertGenericAdaptorBase::Properties)
|
|
|
|
namespace mlir::arm_sme {
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ::mlir::arm_sme::aarch64_sme_st1h_horiz definitions
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace detail {
|
|
|
|
aarch64_sme_st1h_horizGenericAdaptorBase::aarch64_sme_st1h_horizGenericAdaptorBase(aarch64_sme_st1h_horiz op) : odsAttrs(op->getRawDictionaryAttrs()), odsOpName(op->getName()), properties(op.getProperties()), odsRegions(op->getRegions()) {}
|
|
|
|
uint32_t aarch64_sme_st1h_horizGenericAdaptorBase::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
|
|
} // namespace detail
|
|
aarch64_sme_st1h_horizAdaptor::aarch64_sme_st1h_horizAdaptor(aarch64_sme_st1h_horiz op) : aarch64_sme_st1h_horizGenericAdaptor(op->getOperands(), op) {}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1h_horizAdaptor::verify(::mlir::Location loc) {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitError(loc, "'arm_sme.intr.st1h.horiz' op requires attribute 'tile_id'");
|
|
|
|
if (tblgen_tile_id && !(((::llvm::isa<::mlir::IntegerAttr>(tblgen_tile_id))) && ((::llvm::cast<::mlir::IntegerAttr>(tblgen_tile_id).getType().isSignlessInteger(32)))))
|
|
return emitError(loc, "'arm_sme.intr.st1h.horiz' op attribute 'tile_id' failed to satisfy constraint: 32-bit signless integer attribute");
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1h_horiz::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
|
|
{
|
|
auto &propStorage = prop.tile_id;
|
|
auto attr = dict.get("tile_id");
|
|
if (attr) {
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::mlir::Attribute aarch64_sme_st1h_horiz::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) {
|
|
::mlir::SmallVector<::mlir::NamedAttribute> attrs;
|
|
::mlir::Builder odsBuilder{ctx};
|
|
|
|
{
|
|
const auto &propStorage = prop.tile_id;
|
|
if (propStorage)
|
|
attrs.push_back(odsBuilder.getNamedAttr("tile_id",
|
|
propStorage));
|
|
}
|
|
|
|
if (!attrs.empty())
|
|
return odsBuilder.getDictionaryAttr(attrs);
|
|
return {};
|
|
}
|
|
|
|
llvm::hash_code aarch64_sme_st1h_horiz::computePropertiesHash(const Properties &prop) {
|
|
using llvm::hash_value;
|
|
return llvm::hash_combine(
|
|
llvm::hash_value(prop.tile_id.getAsOpaquePointer()));
|
|
}
|
|
|
|
std::optional<mlir::Attribute> aarch64_sme_st1h_horiz::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) {
|
|
if (name == "tile_id")
|
|
return prop.tile_id;
|
|
return std::nullopt;
|
|
}
|
|
|
|
void aarch64_sme_st1h_horiz::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) {
|
|
if (name == "tile_id") {
|
|
prop.tile_id = ::llvm::dyn_cast_or_null<std::remove_reference_t<decltype(prop.tile_id)>>(value);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void aarch64_sme_st1h_horiz::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) {
|
|
if (prop.tile_id) attrs.append("tile_id", prop.tile_id);
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1h_horiz::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
{
|
|
::mlir::Attribute attr = attrs.get(getTileIdAttrName(opName));
|
|
if (attr && ::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(attr, "tile_id", emitError)))
|
|
return ::mlir::failure();
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1h_horiz::readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state) {
|
|
auto &prop = state.getOrAddProperties<Properties>(); (void)prop;
|
|
if (::mlir::failed(reader.readAttribute(prop.tile_id)))
|
|
return ::mlir::failure();
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_st1h_horiz::writeProperties(::mlir::DialectBytecodeWriter &writer) {
|
|
auto &prop = getProperties(); (void)prop;
|
|
writer.writeAttribute(prop.tile_id);
|
|
}
|
|
|
|
uint32_t aarch64_sme_st1h_horiz::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
void aarch64_sme_st1h_horiz::setTileId(uint32_t attrValue) {
|
|
getProperties().tile_id = ::mlir::Builder((*this)->getContext()).getIntegerAttr(::mlir::Builder((*this)->getContext()).getIntegerType(32), attrValue);
|
|
}
|
|
|
|
void aarch64_sme_st1h_horiz::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(store_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
}
|
|
|
|
aarch64_sme_st1h_horiz aarch64_sme_st1h_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1h_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1h_horiz aarch64_sme_st1h_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_st1h_horiz::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(store_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_st1h_horiz aarch64_sme_st1h_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1h_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1h_horiz aarch64_sme_st1h_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_st1h_horiz::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(store_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
}
|
|
|
|
aarch64_sme_st1h_horiz aarch64_sme_st1h_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1h_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1h_horiz aarch64_sme_st1h_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_st1h_horiz::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(store_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_st1h_horiz aarch64_sme_st1h_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1h_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1h_horiz aarch64_sme_st1h_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_st1h_horiz::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
assert(operands.size() == 3u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.addAttributes(attributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
|
|
if (!attributes.empty()) {
|
|
(void)odsState.getOrAddProperties<aarch64_sme_st1h_horiz::Properties>();
|
|
::mlir::PropertyRef properties = odsState.getRawProperties();
|
|
std::optional<::mlir::RegisteredOperationName> info =
|
|
odsState.name.getRegisteredInfo();
|
|
if (failed(info->setOpPropertiesFromAttribute(odsState.name, properties,
|
|
odsState.attributes.getDictionary(odsState.getContext()), nullptr)))
|
|
::llvm::report_fatal_error("Property conversion failed.");
|
|
}
|
|
}
|
|
|
|
aarch64_sme_st1h_horiz aarch64_sme_st1h_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1h_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1h_horiz aarch64_sme_st1h_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
}
|
|
|
|
void aarch64_sme_st1h_horiz::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
assert(operands.size() == 3u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.useProperties(const_cast<Properties&>(properties));
|
|
odsState.addAttributes(discardableAttributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_st1h_horiz aarch64_sme_st1h_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1h_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1h_horiz aarch64_sme_st1h_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1h_horiz::verifyInvariantsImpl() {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitOpError("requires attribute 'tile_id'");
|
|
|
|
if (::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(*this, tblgen_tile_id, "tile_id")))
|
|
return ::mlir::failure();
|
|
{
|
|
unsigned index = 0; (void)index;
|
|
auto valueGroup0 = getODSOperands(0);
|
|
|
|
for (auto v : valueGroup0) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps2(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup1 = getODSOperands(1);
|
|
|
|
for (auto v : valueGroup1) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps3(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup2 = getODSOperands(2);
|
|
|
|
for (auto v : valueGroup2) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps4(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1h_horiz::verifyInvariants() {
|
|
return verifyInvariantsImpl();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1h_horiz::setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
// keep track of used keys in the input dictionary to be able to error out
|
|
// if there are some unknown ones.
|
|
::mlir::DenseSet<::mlir::StringAttr> usedKeys;
|
|
::mlir::MLIRContext *ctx = dict.getContext();
|
|
(void)ctx;
|
|
{
|
|
|
|
auto &propStorage = prop.tile_id;
|
|
auto tile_idAttrName = ::mlir::StringAttr::get(ctx, "tile_id");
|
|
auto attr = dict.get(tile_idAttrName);
|
|
usedKeys.insert(tile_idAttrName);
|
|
if (attr || /*isRequired=*/true) {
|
|
if (!attr) {
|
|
emitError() << "expected key entry for tile_id in DictionaryAttr to set "
|
|
"Properties.";
|
|
return ::mlir::failure();
|
|
}
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
|
|
for (::mlir::NamedAttribute attr : dict) {
|
|
if (!usedKeys.contains(attr.getName()))
|
|
return emitError() << "unknown key '" << attr.getName() <<
|
|
"' when parsing properties dictionary";
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_st1h_horiz::getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
|
|
{
|
|
auto valueRange = getODSOperandIndexAndLength(1);
|
|
for (unsigned idx = valueRange.first; idx < valueRange.first + valueRange.second; idx++) {
|
|
effects.emplace_back(::mlir::MemoryEffects::Write::get(), &getOperation()->getOpOperand(idx), 0, false, ::mlir::SideEffects::DefaultResource::get());
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace mlir::arm_sme
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::aarch64_sme_st1h_horiz)
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::detail::aarch64_sme_st1h_horizGenericAdaptorBase::Properties)
|
|
|
|
namespace mlir::arm_sme {
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ::mlir::arm_sme::aarch64_sme_st1h_vert definitions
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace detail {
|
|
|
|
aarch64_sme_st1h_vertGenericAdaptorBase::aarch64_sme_st1h_vertGenericAdaptorBase(aarch64_sme_st1h_vert op) : odsAttrs(op->getRawDictionaryAttrs()), odsOpName(op->getName()), properties(op.getProperties()), odsRegions(op->getRegions()) {}
|
|
|
|
uint32_t aarch64_sme_st1h_vertGenericAdaptorBase::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
|
|
} // namespace detail
|
|
aarch64_sme_st1h_vertAdaptor::aarch64_sme_st1h_vertAdaptor(aarch64_sme_st1h_vert op) : aarch64_sme_st1h_vertGenericAdaptor(op->getOperands(), op) {}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1h_vertAdaptor::verify(::mlir::Location loc) {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitError(loc, "'arm_sme.intr.st1h.vert' op requires attribute 'tile_id'");
|
|
|
|
if (tblgen_tile_id && !(((::llvm::isa<::mlir::IntegerAttr>(tblgen_tile_id))) && ((::llvm::cast<::mlir::IntegerAttr>(tblgen_tile_id).getType().isSignlessInteger(32)))))
|
|
return emitError(loc, "'arm_sme.intr.st1h.vert' op attribute 'tile_id' failed to satisfy constraint: 32-bit signless integer attribute");
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1h_vert::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
|
|
{
|
|
auto &propStorage = prop.tile_id;
|
|
auto attr = dict.get("tile_id");
|
|
if (attr) {
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::mlir::Attribute aarch64_sme_st1h_vert::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) {
|
|
::mlir::SmallVector<::mlir::NamedAttribute> attrs;
|
|
::mlir::Builder odsBuilder{ctx};
|
|
|
|
{
|
|
const auto &propStorage = prop.tile_id;
|
|
if (propStorage)
|
|
attrs.push_back(odsBuilder.getNamedAttr("tile_id",
|
|
propStorage));
|
|
}
|
|
|
|
if (!attrs.empty())
|
|
return odsBuilder.getDictionaryAttr(attrs);
|
|
return {};
|
|
}
|
|
|
|
llvm::hash_code aarch64_sme_st1h_vert::computePropertiesHash(const Properties &prop) {
|
|
using llvm::hash_value;
|
|
return llvm::hash_combine(
|
|
llvm::hash_value(prop.tile_id.getAsOpaquePointer()));
|
|
}
|
|
|
|
std::optional<mlir::Attribute> aarch64_sme_st1h_vert::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) {
|
|
if (name == "tile_id")
|
|
return prop.tile_id;
|
|
return std::nullopt;
|
|
}
|
|
|
|
void aarch64_sme_st1h_vert::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) {
|
|
if (name == "tile_id") {
|
|
prop.tile_id = ::llvm::dyn_cast_or_null<std::remove_reference_t<decltype(prop.tile_id)>>(value);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void aarch64_sme_st1h_vert::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) {
|
|
if (prop.tile_id) attrs.append("tile_id", prop.tile_id);
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1h_vert::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
{
|
|
::mlir::Attribute attr = attrs.get(getTileIdAttrName(opName));
|
|
if (attr && ::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(attr, "tile_id", emitError)))
|
|
return ::mlir::failure();
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1h_vert::readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state) {
|
|
auto &prop = state.getOrAddProperties<Properties>(); (void)prop;
|
|
if (::mlir::failed(reader.readAttribute(prop.tile_id)))
|
|
return ::mlir::failure();
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_st1h_vert::writeProperties(::mlir::DialectBytecodeWriter &writer) {
|
|
auto &prop = getProperties(); (void)prop;
|
|
writer.writeAttribute(prop.tile_id);
|
|
}
|
|
|
|
uint32_t aarch64_sme_st1h_vert::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
void aarch64_sme_st1h_vert::setTileId(uint32_t attrValue) {
|
|
getProperties().tile_id = ::mlir::Builder((*this)->getContext()).getIntegerAttr(::mlir::Builder((*this)->getContext()).getIntegerType(32), attrValue);
|
|
}
|
|
|
|
void aarch64_sme_st1h_vert::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(store_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
}
|
|
|
|
aarch64_sme_st1h_vert aarch64_sme_st1h_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1h_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1h_vert aarch64_sme_st1h_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_st1h_vert::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(store_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_st1h_vert aarch64_sme_st1h_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1h_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1h_vert aarch64_sme_st1h_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_st1h_vert::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(store_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
}
|
|
|
|
aarch64_sme_st1h_vert aarch64_sme_st1h_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1h_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1h_vert aarch64_sme_st1h_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_st1h_vert::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(store_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_st1h_vert aarch64_sme_st1h_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1h_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1h_vert aarch64_sme_st1h_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_st1h_vert::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
assert(operands.size() == 3u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.addAttributes(attributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
|
|
if (!attributes.empty()) {
|
|
(void)odsState.getOrAddProperties<aarch64_sme_st1h_vert::Properties>();
|
|
::mlir::PropertyRef properties = odsState.getRawProperties();
|
|
std::optional<::mlir::RegisteredOperationName> info =
|
|
odsState.name.getRegisteredInfo();
|
|
if (failed(info->setOpPropertiesFromAttribute(odsState.name, properties,
|
|
odsState.attributes.getDictionary(odsState.getContext()), nullptr)))
|
|
::llvm::report_fatal_error("Property conversion failed.");
|
|
}
|
|
}
|
|
|
|
aarch64_sme_st1h_vert aarch64_sme_st1h_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1h_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1h_vert aarch64_sme_st1h_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
}
|
|
|
|
void aarch64_sme_st1h_vert::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
assert(operands.size() == 3u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.useProperties(const_cast<Properties&>(properties));
|
|
odsState.addAttributes(discardableAttributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_st1h_vert aarch64_sme_st1h_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1h_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1h_vert aarch64_sme_st1h_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1h_vert::verifyInvariantsImpl() {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitOpError("requires attribute 'tile_id'");
|
|
|
|
if (::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(*this, tblgen_tile_id, "tile_id")))
|
|
return ::mlir::failure();
|
|
{
|
|
unsigned index = 0; (void)index;
|
|
auto valueGroup0 = getODSOperands(0);
|
|
|
|
for (auto v : valueGroup0) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps2(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup1 = getODSOperands(1);
|
|
|
|
for (auto v : valueGroup1) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps3(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup2 = getODSOperands(2);
|
|
|
|
for (auto v : valueGroup2) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps4(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1h_vert::verifyInvariants() {
|
|
return verifyInvariantsImpl();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1h_vert::setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
// keep track of used keys in the input dictionary to be able to error out
|
|
// if there are some unknown ones.
|
|
::mlir::DenseSet<::mlir::StringAttr> usedKeys;
|
|
::mlir::MLIRContext *ctx = dict.getContext();
|
|
(void)ctx;
|
|
{
|
|
|
|
auto &propStorage = prop.tile_id;
|
|
auto tile_idAttrName = ::mlir::StringAttr::get(ctx, "tile_id");
|
|
auto attr = dict.get(tile_idAttrName);
|
|
usedKeys.insert(tile_idAttrName);
|
|
if (attr || /*isRequired=*/true) {
|
|
if (!attr) {
|
|
emitError() << "expected key entry for tile_id in DictionaryAttr to set "
|
|
"Properties.";
|
|
return ::mlir::failure();
|
|
}
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
|
|
for (::mlir::NamedAttribute attr : dict) {
|
|
if (!usedKeys.contains(attr.getName()))
|
|
return emitError() << "unknown key '" << attr.getName() <<
|
|
"' when parsing properties dictionary";
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_st1h_vert::getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
|
|
{
|
|
auto valueRange = getODSOperandIndexAndLength(1);
|
|
for (unsigned idx = valueRange.first; idx < valueRange.first + valueRange.second; idx++) {
|
|
effects.emplace_back(::mlir::MemoryEffects::Write::get(), &getOperation()->getOpOperand(idx), 0, false, ::mlir::SideEffects::DefaultResource::get());
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace mlir::arm_sme
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::aarch64_sme_st1h_vert)
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::detail::aarch64_sme_st1h_vertGenericAdaptorBase::Properties)
|
|
|
|
namespace mlir::arm_sme {
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ::mlir::arm_sme::aarch64_sme_st1q_horiz definitions
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace detail {
|
|
|
|
aarch64_sme_st1q_horizGenericAdaptorBase::aarch64_sme_st1q_horizGenericAdaptorBase(aarch64_sme_st1q_horiz op) : odsAttrs(op->getRawDictionaryAttrs()), odsOpName(op->getName()), properties(op.getProperties()), odsRegions(op->getRegions()) {}
|
|
|
|
uint32_t aarch64_sme_st1q_horizGenericAdaptorBase::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
|
|
} // namespace detail
|
|
aarch64_sme_st1q_horizAdaptor::aarch64_sme_st1q_horizAdaptor(aarch64_sme_st1q_horiz op) : aarch64_sme_st1q_horizGenericAdaptor(op->getOperands(), op) {}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1q_horizAdaptor::verify(::mlir::Location loc) {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitError(loc, "'arm_sme.intr.st1q.horiz' op requires attribute 'tile_id'");
|
|
|
|
if (tblgen_tile_id && !(((::llvm::isa<::mlir::IntegerAttr>(tblgen_tile_id))) && ((::llvm::cast<::mlir::IntegerAttr>(tblgen_tile_id).getType().isSignlessInteger(32)))))
|
|
return emitError(loc, "'arm_sme.intr.st1q.horiz' op attribute 'tile_id' failed to satisfy constraint: 32-bit signless integer attribute");
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1q_horiz::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
|
|
{
|
|
auto &propStorage = prop.tile_id;
|
|
auto attr = dict.get("tile_id");
|
|
if (attr) {
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::mlir::Attribute aarch64_sme_st1q_horiz::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) {
|
|
::mlir::SmallVector<::mlir::NamedAttribute> attrs;
|
|
::mlir::Builder odsBuilder{ctx};
|
|
|
|
{
|
|
const auto &propStorage = prop.tile_id;
|
|
if (propStorage)
|
|
attrs.push_back(odsBuilder.getNamedAttr("tile_id",
|
|
propStorage));
|
|
}
|
|
|
|
if (!attrs.empty())
|
|
return odsBuilder.getDictionaryAttr(attrs);
|
|
return {};
|
|
}
|
|
|
|
llvm::hash_code aarch64_sme_st1q_horiz::computePropertiesHash(const Properties &prop) {
|
|
using llvm::hash_value;
|
|
return llvm::hash_combine(
|
|
llvm::hash_value(prop.tile_id.getAsOpaquePointer()));
|
|
}
|
|
|
|
std::optional<mlir::Attribute> aarch64_sme_st1q_horiz::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) {
|
|
if (name == "tile_id")
|
|
return prop.tile_id;
|
|
return std::nullopt;
|
|
}
|
|
|
|
void aarch64_sme_st1q_horiz::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) {
|
|
if (name == "tile_id") {
|
|
prop.tile_id = ::llvm::dyn_cast_or_null<std::remove_reference_t<decltype(prop.tile_id)>>(value);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void aarch64_sme_st1q_horiz::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) {
|
|
if (prop.tile_id) attrs.append("tile_id", prop.tile_id);
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1q_horiz::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
{
|
|
::mlir::Attribute attr = attrs.get(getTileIdAttrName(opName));
|
|
if (attr && ::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(attr, "tile_id", emitError)))
|
|
return ::mlir::failure();
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1q_horiz::readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state) {
|
|
auto &prop = state.getOrAddProperties<Properties>(); (void)prop;
|
|
if (::mlir::failed(reader.readAttribute(prop.tile_id)))
|
|
return ::mlir::failure();
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_st1q_horiz::writeProperties(::mlir::DialectBytecodeWriter &writer) {
|
|
auto &prop = getProperties(); (void)prop;
|
|
writer.writeAttribute(prop.tile_id);
|
|
}
|
|
|
|
uint32_t aarch64_sme_st1q_horiz::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
void aarch64_sme_st1q_horiz::setTileId(uint32_t attrValue) {
|
|
getProperties().tile_id = ::mlir::Builder((*this)->getContext()).getIntegerAttr(::mlir::Builder((*this)->getContext()).getIntegerType(32), attrValue);
|
|
}
|
|
|
|
void aarch64_sme_st1q_horiz::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(store_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
}
|
|
|
|
aarch64_sme_st1q_horiz aarch64_sme_st1q_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1q_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1q_horiz aarch64_sme_st1q_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_st1q_horiz::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(store_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_st1q_horiz aarch64_sme_st1q_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1q_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1q_horiz aarch64_sme_st1q_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_st1q_horiz::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(store_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
}
|
|
|
|
aarch64_sme_st1q_horiz aarch64_sme_st1q_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1q_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1q_horiz aarch64_sme_st1q_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_st1q_horiz::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(store_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_st1q_horiz aarch64_sme_st1q_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1q_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1q_horiz aarch64_sme_st1q_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_st1q_horiz::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
assert(operands.size() == 3u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.addAttributes(attributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
|
|
if (!attributes.empty()) {
|
|
(void)odsState.getOrAddProperties<aarch64_sme_st1q_horiz::Properties>();
|
|
::mlir::PropertyRef properties = odsState.getRawProperties();
|
|
std::optional<::mlir::RegisteredOperationName> info =
|
|
odsState.name.getRegisteredInfo();
|
|
if (failed(info->setOpPropertiesFromAttribute(odsState.name, properties,
|
|
odsState.attributes.getDictionary(odsState.getContext()), nullptr)))
|
|
::llvm::report_fatal_error("Property conversion failed.");
|
|
}
|
|
}
|
|
|
|
aarch64_sme_st1q_horiz aarch64_sme_st1q_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1q_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1q_horiz aarch64_sme_st1q_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
}
|
|
|
|
void aarch64_sme_st1q_horiz::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
assert(operands.size() == 3u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.useProperties(const_cast<Properties&>(properties));
|
|
odsState.addAttributes(discardableAttributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_st1q_horiz aarch64_sme_st1q_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1q_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1q_horiz aarch64_sme_st1q_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1q_horiz::verifyInvariantsImpl() {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitOpError("requires attribute 'tile_id'");
|
|
|
|
if (::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(*this, tblgen_tile_id, "tile_id")))
|
|
return ::mlir::failure();
|
|
{
|
|
unsigned index = 0; (void)index;
|
|
auto valueGroup0 = getODSOperands(0);
|
|
|
|
for (auto v : valueGroup0) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps2(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup1 = getODSOperands(1);
|
|
|
|
for (auto v : valueGroup1) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps3(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup2 = getODSOperands(2);
|
|
|
|
for (auto v : valueGroup2) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps4(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1q_horiz::verifyInvariants() {
|
|
return verifyInvariantsImpl();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1q_horiz::setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
// keep track of used keys in the input dictionary to be able to error out
|
|
// if there are some unknown ones.
|
|
::mlir::DenseSet<::mlir::StringAttr> usedKeys;
|
|
::mlir::MLIRContext *ctx = dict.getContext();
|
|
(void)ctx;
|
|
{
|
|
|
|
auto &propStorage = prop.tile_id;
|
|
auto tile_idAttrName = ::mlir::StringAttr::get(ctx, "tile_id");
|
|
auto attr = dict.get(tile_idAttrName);
|
|
usedKeys.insert(tile_idAttrName);
|
|
if (attr || /*isRequired=*/true) {
|
|
if (!attr) {
|
|
emitError() << "expected key entry for tile_id in DictionaryAttr to set "
|
|
"Properties.";
|
|
return ::mlir::failure();
|
|
}
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
|
|
for (::mlir::NamedAttribute attr : dict) {
|
|
if (!usedKeys.contains(attr.getName()))
|
|
return emitError() << "unknown key '" << attr.getName() <<
|
|
"' when parsing properties dictionary";
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_st1q_horiz::getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
|
|
{
|
|
auto valueRange = getODSOperandIndexAndLength(1);
|
|
for (unsigned idx = valueRange.first; idx < valueRange.first + valueRange.second; idx++) {
|
|
effects.emplace_back(::mlir::MemoryEffects::Write::get(), &getOperation()->getOpOperand(idx), 0, false, ::mlir::SideEffects::DefaultResource::get());
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace mlir::arm_sme
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::aarch64_sme_st1q_horiz)
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::detail::aarch64_sme_st1q_horizGenericAdaptorBase::Properties)
|
|
|
|
namespace mlir::arm_sme {
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ::mlir::arm_sme::aarch64_sme_st1q_vert definitions
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace detail {
|
|
|
|
aarch64_sme_st1q_vertGenericAdaptorBase::aarch64_sme_st1q_vertGenericAdaptorBase(aarch64_sme_st1q_vert op) : odsAttrs(op->getRawDictionaryAttrs()), odsOpName(op->getName()), properties(op.getProperties()), odsRegions(op->getRegions()) {}
|
|
|
|
uint32_t aarch64_sme_st1q_vertGenericAdaptorBase::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
|
|
} // namespace detail
|
|
aarch64_sme_st1q_vertAdaptor::aarch64_sme_st1q_vertAdaptor(aarch64_sme_st1q_vert op) : aarch64_sme_st1q_vertGenericAdaptor(op->getOperands(), op) {}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1q_vertAdaptor::verify(::mlir::Location loc) {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitError(loc, "'arm_sme.intr.st1q.vert' op requires attribute 'tile_id'");
|
|
|
|
if (tblgen_tile_id && !(((::llvm::isa<::mlir::IntegerAttr>(tblgen_tile_id))) && ((::llvm::cast<::mlir::IntegerAttr>(tblgen_tile_id).getType().isSignlessInteger(32)))))
|
|
return emitError(loc, "'arm_sme.intr.st1q.vert' op attribute 'tile_id' failed to satisfy constraint: 32-bit signless integer attribute");
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1q_vert::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
|
|
{
|
|
auto &propStorage = prop.tile_id;
|
|
auto attr = dict.get("tile_id");
|
|
if (attr) {
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::mlir::Attribute aarch64_sme_st1q_vert::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) {
|
|
::mlir::SmallVector<::mlir::NamedAttribute> attrs;
|
|
::mlir::Builder odsBuilder{ctx};
|
|
|
|
{
|
|
const auto &propStorage = prop.tile_id;
|
|
if (propStorage)
|
|
attrs.push_back(odsBuilder.getNamedAttr("tile_id",
|
|
propStorage));
|
|
}
|
|
|
|
if (!attrs.empty())
|
|
return odsBuilder.getDictionaryAttr(attrs);
|
|
return {};
|
|
}
|
|
|
|
llvm::hash_code aarch64_sme_st1q_vert::computePropertiesHash(const Properties &prop) {
|
|
using llvm::hash_value;
|
|
return llvm::hash_combine(
|
|
llvm::hash_value(prop.tile_id.getAsOpaquePointer()));
|
|
}
|
|
|
|
std::optional<mlir::Attribute> aarch64_sme_st1q_vert::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) {
|
|
if (name == "tile_id")
|
|
return prop.tile_id;
|
|
return std::nullopt;
|
|
}
|
|
|
|
void aarch64_sme_st1q_vert::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) {
|
|
if (name == "tile_id") {
|
|
prop.tile_id = ::llvm::dyn_cast_or_null<std::remove_reference_t<decltype(prop.tile_id)>>(value);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void aarch64_sme_st1q_vert::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) {
|
|
if (prop.tile_id) attrs.append("tile_id", prop.tile_id);
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1q_vert::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
{
|
|
::mlir::Attribute attr = attrs.get(getTileIdAttrName(opName));
|
|
if (attr && ::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(attr, "tile_id", emitError)))
|
|
return ::mlir::failure();
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1q_vert::readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state) {
|
|
auto &prop = state.getOrAddProperties<Properties>(); (void)prop;
|
|
if (::mlir::failed(reader.readAttribute(prop.tile_id)))
|
|
return ::mlir::failure();
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_st1q_vert::writeProperties(::mlir::DialectBytecodeWriter &writer) {
|
|
auto &prop = getProperties(); (void)prop;
|
|
writer.writeAttribute(prop.tile_id);
|
|
}
|
|
|
|
uint32_t aarch64_sme_st1q_vert::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
void aarch64_sme_st1q_vert::setTileId(uint32_t attrValue) {
|
|
getProperties().tile_id = ::mlir::Builder((*this)->getContext()).getIntegerAttr(::mlir::Builder((*this)->getContext()).getIntegerType(32), attrValue);
|
|
}
|
|
|
|
void aarch64_sme_st1q_vert::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(store_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
}
|
|
|
|
aarch64_sme_st1q_vert aarch64_sme_st1q_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1q_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1q_vert aarch64_sme_st1q_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_st1q_vert::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(store_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_st1q_vert aarch64_sme_st1q_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1q_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1q_vert aarch64_sme_st1q_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_st1q_vert::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(store_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
}
|
|
|
|
aarch64_sme_st1q_vert aarch64_sme_st1q_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1q_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1q_vert aarch64_sme_st1q_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_st1q_vert::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(store_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_st1q_vert aarch64_sme_st1q_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1q_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1q_vert aarch64_sme_st1q_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_st1q_vert::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
assert(operands.size() == 3u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.addAttributes(attributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
|
|
if (!attributes.empty()) {
|
|
(void)odsState.getOrAddProperties<aarch64_sme_st1q_vert::Properties>();
|
|
::mlir::PropertyRef properties = odsState.getRawProperties();
|
|
std::optional<::mlir::RegisteredOperationName> info =
|
|
odsState.name.getRegisteredInfo();
|
|
if (failed(info->setOpPropertiesFromAttribute(odsState.name, properties,
|
|
odsState.attributes.getDictionary(odsState.getContext()), nullptr)))
|
|
::llvm::report_fatal_error("Property conversion failed.");
|
|
}
|
|
}
|
|
|
|
aarch64_sme_st1q_vert aarch64_sme_st1q_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1q_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1q_vert aarch64_sme_st1q_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
}
|
|
|
|
void aarch64_sme_st1q_vert::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
assert(operands.size() == 3u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.useProperties(const_cast<Properties&>(properties));
|
|
odsState.addAttributes(discardableAttributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_st1q_vert aarch64_sme_st1q_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1q_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1q_vert aarch64_sme_st1q_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1q_vert::verifyInvariantsImpl() {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitOpError("requires attribute 'tile_id'");
|
|
|
|
if (::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(*this, tblgen_tile_id, "tile_id")))
|
|
return ::mlir::failure();
|
|
{
|
|
unsigned index = 0; (void)index;
|
|
auto valueGroup0 = getODSOperands(0);
|
|
|
|
for (auto v : valueGroup0) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps2(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup1 = getODSOperands(1);
|
|
|
|
for (auto v : valueGroup1) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps3(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup2 = getODSOperands(2);
|
|
|
|
for (auto v : valueGroup2) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps4(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1q_vert::verifyInvariants() {
|
|
return verifyInvariantsImpl();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1q_vert::setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
// keep track of used keys in the input dictionary to be able to error out
|
|
// if there are some unknown ones.
|
|
::mlir::DenseSet<::mlir::StringAttr> usedKeys;
|
|
::mlir::MLIRContext *ctx = dict.getContext();
|
|
(void)ctx;
|
|
{
|
|
|
|
auto &propStorage = prop.tile_id;
|
|
auto tile_idAttrName = ::mlir::StringAttr::get(ctx, "tile_id");
|
|
auto attr = dict.get(tile_idAttrName);
|
|
usedKeys.insert(tile_idAttrName);
|
|
if (attr || /*isRequired=*/true) {
|
|
if (!attr) {
|
|
emitError() << "expected key entry for tile_id in DictionaryAttr to set "
|
|
"Properties.";
|
|
return ::mlir::failure();
|
|
}
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
|
|
for (::mlir::NamedAttribute attr : dict) {
|
|
if (!usedKeys.contains(attr.getName()))
|
|
return emitError() << "unknown key '" << attr.getName() <<
|
|
"' when parsing properties dictionary";
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_st1q_vert::getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
|
|
{
|
|
auto valueRange = getODSOperandIndexAndLength(1);
|
|
for (unsigned idx = valueRange.first; idx < valueRange.first + valueRange.second; idx++) {
|
|
effects.emplace_back(::mlir::MemoryEffects::Write::get(), &getOperation()->getOpOperand(idx), 0, false, ::mlir::SideEffects::DefaultResource::get());
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace mlir::arm_sme
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::aarch64_sme_st1q_vert)
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::detail::aarch64_sme_st1q_vertGenericAdaptorBase::Properties)
|
|
|
|
namespace mlir::arm_sme {
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ::mlir::arm_sme::aarch64_sme_st1w_horiz definitions
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace detail {
|
|
|
|
aarch64_sme_st1w_horizGenericAdaptorBase::aarch64_sme_st1w_horizGenericAdaptorBase(aarch64_sme_st1w_horiz op) : odsAttrs(op->getRawDictionaryAttrs()), odsOpName(op->getName()), properties(op.getProperties()), odsRegions(op->getRegions()) {}
|
|
|
|
uint32_t aarch64_sme_st1w_horizGenericAdaptorBase::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
|
|
} // namespace detail
|
|
aarch64_sme_st1w_horizAdaptor::aarch64_sme_st1w_horizAdaptor(aarch64_sme_st1w_horiz op) : aarch64_sme_st1w_horizGenericAdaptor(op->getOperands(), op) {}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1w_horizAdaptor::verify(::mlir::Location loc) {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitError(loc, "'arm_sme.intr.st1w.horiz' op requires attribute 'tile_id'");
|
|
|
|
if (tblgen_tile_id && !(((::llvm::isa<::mlir::IntegerAttr>(tblgen_tile_id))) && ((::llvm::cast<::mlir::IntegerAttr>(tblgen_tile_id).getType().isSignlessInteger(32)))))
|
|
return emitError(loc, "'arm_sme.intr.st1w.horiz' op attribute 'tile_id' failed to satisfy constraint: 32-bit signless integer attribute");
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1w_horiz::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
|
|
{
|
|
auto &propStorage = prop.tile_id;
|
|
auto attr = dict.get("tile_id");
|
|
if (attr) {
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::mlir::Attribute aarch64_sme_st1w_horiz::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) {
|
|
::mlir::SmallVector<::mlir::NamedAttribute> attrs;
|
|
::mlir::Builder odsBuilder{ctx};
|
|
|
|
{
|
|
const auto &propStorage = prop.tile_id;
|
|
if (propStorage)
|
|
attrs.push_back(odsBuilder.getNamedAttr("tile_id",
|
|
propStorage));
|
|
}
|
|
|
|
if (!attrs.empty())
|
|
return odsBuilder.getDictionaryAttr(attrs);
|
|
return {};
|
|
}
|
|
|
|
llvm::hash_code aarch64_sme_st1w_horiz::computePropertiesHash(const Properties &prop) {
|
|
using llvm::hash_value;
|
|
return llvm::hash_combine(
|
|
llvm::hash_value(prop.tile_id.getAsOpaquePointer()));
|
|
}
|
|
|
|
std::optional<mlir::Attribute> aarch64_sme_st1w_horiz::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) {
|
|
if (name == "tile_id")
|
|
return prop.tile_id;
|
|
return std::nullopt;
|
|
}
|
|
|
|
void aarch64_sme_st1w_horiz::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) {
|
|
if (name == "tile_id") {
|
|
prop.tile_id = ::llvm::dyn_cast_or_null<std::remove_reference_t<decltype(prop.tile_id)>>(value);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void aarch64_sme_st1w_horiz::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) {
|
|
if (prop.tile_id) attrs.append("tile_id", prop.tile_id);
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1w_horiz::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
{
|
|
::mlir::Attribute attr = attrs.get(getTileIdAttrName(opName));
|
|
if (attr && ::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(attr, "tile_id", emitError)))
|
|
return ::mlir::failure();
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1w_horiz::readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state) {
|
|
auto &prop = state.getOrAddProperties<Properties>(); (void)prop;
|
|
if (::mlir::failed(reader.readAttribute(prop.tile_id)))
|
|
return ::mlir::failure();
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_st1w_horiz::writeProperties(::mlir::DialectBytecodeWriter &writer) {
|
|
auto &prop = getProperties(); (void)prop;
|
|
writer.writeAttribute(prop.tile_id);
|
|
}
|
|
|
|
uint32_t aarch64_sme_st1w_horiz::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
void aarch64_sme_st1w_horiz::setTileId(uint32_t attrValue) {
|
|
getProperties().tile_id = ::mlir::Builder((*this)->getContext()).getIntegerAttr(::mlir::Builder((*this)->getContext()).getIntegerType(32), attrValue);
|
|
}
|
|
|
|
void aarch64_sme_st1w_horiz::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(store_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
}
|
|
|
|
aarch64_sme_st1w_horiz aarch64_sme_st1w_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1w_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1w_horiz aarch64_sme_st1w_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_st1w_horiz::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(store_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_st1w_horiz aarch64_sme_st1w_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1w_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1w_horiz aarch64_sme_st1w_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_st1w_horiz::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(store_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
}
|
|
|
|
aarch64_sme_st1w_horiz aarch64_sme_st1w_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1w_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1w_horiz aarch64_sme_st1w_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_st1w_horiz::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(store_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_st1w_horiz aarch64_sme_st1w_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1w_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1w_horiz aarch64_sme_st1w_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_st1w_horiz::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
assert(operands.size() == 3u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.addAttributes(attributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
|
|
if (!attributes.empty()) {
|
|
(void)odsState.getOrAddProperties<aarch64_sme_st1w_horiz::Properties>();
|
|
::mlir::PropertyRef properties = odsState.getRawProperties();
|
|
std::optional<::mlir::RegisteredOperationName> info =
|
|
odsState.name.getRegisteredInfo();
|
|
if (failed(info->setOpPropertiesFromAttribute(odsState.name, properties,
|
|
odsState.attributes.getDictionary(odsState.getContext()), nullptr)))
|
|
::llvm::report_fatal_error("Property conversion failed.");
|
|
}
|
|
}
|
|
|
|
aarch64_sme_st1w_horiz aarch64_sme_st1w_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1w_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1w_horiz aarch64_sme_st1w_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
}
|
|
|
|
void aarch64_sme_st1w_horiz::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
assert(operands.size() == 3u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.useProperties(const_cast<Properties&>(properties));
|
|
odsState.addAttributes(discardableAttributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_st1w_horiz aarch64_sme_st1w_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1w_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1w_horiz aarch64_sme_st1w_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1w_horiz::verifyInvariantsImpl() {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitOpError("requires attribute 'tile_id'");
|
|
|
|
if (::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(*this, tblgen_tile_id, "tile_id")))
|
|
return ::mlir::failure();
|
|
{
|
|
unsigned index = 0; (void)index;
|
|
auto valueGroup0 = getODSOperands(0);
|
|
|
|
for (auto v : valueGroup0) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps2(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup1 = getODSOperands(1);
|
|
|
|
for (auto v : valueGroup1) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps3(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup2 = getODSOperands(2);
|
|
|
|
for (auto v : valueGroup2) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps4(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1w_horiz::verifyInvariants() {
|
|
return verifyInvariantsImpl();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1w_horiz::setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
// keep track of used keys in the input dictionary to be able to error out
|
|
// if there are some unknown ones.
|
|
::mlir::DenseSet<::mlir::StringAttr> usedKeys;
|
|
::mlir::MLIRContext *ctx = dict.getContext();
|
|
(void)ctx;
|
|
{
|
|
|
|
auto &propStorage = prop.tile_id;
|
|
auto tile_idAttrName = ::mlir::StringAttr::get(ctx, "tile_id");
|
|
auto attr = dict.get(tile_idAttrName);
|
|
usedKeys.insert(tile_idAttrName);
|
|
if (attr || /*isRequired=*/true) {
|
|
if (!attr) {
|
|
emitError() << "expected key entry for tile_id in DictionaryAttr to set "
|
|
"Properties.";
|
|
return ::mlir::failure();
|
|
}
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
|
|
for (::mlir::NamedAttribute attr : dict) {
|
|
if (!usedKeys.contains(attr.getName()))
|
|
return emitError() << "unknown key '" << attr.getName() <<
|
|
"' when parsing properties dictionary";
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_st1w_horiz::getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
|
|
{
|
|
auto valueRange = getODSOperandIndexAndLength(1);
|
|
for (unsigned idx = valueRange.first; idx < valueRange.first + valueRange.second; idx++) {
|
|
effects.emplace_back(::mlir::MemoryEffects::Write::get(), &getOperation()->getOpOperand(idx), 0, false, ::mlir::SideEffects::DefaultResource::get());
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace mlir::arm_sme
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::aarch64_sme_st1w_horiz)
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::detail::aarch64_sme_st1w_horizGenericAdaptorBase::Properties)
|
|
|
|
namespace mlir::arm_sme {
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ::mlir::arm_sme::aarch64_sme_st1w_vert definitions
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace detail {
|
|
|
|
aarch64_sme_st1w_vertGenericAdaptorBase::aarch64_sme_st1w_vertGenericAdaptorBase(aarch64_sme_st1w_vert op) : odsAttrs(op->getRawDictionaryAttrs()), odsOpName(op->getName()), properties(op.getProperties()), odsRegions(op->getRegions()) {}
|
|
|
|
uint32_t aarch64_sme_st1w_vertGenericAdaptorBase::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
|
|
} // namespace detail
|
|
aarch64_sme_st1w_vertAdaptor::aarch64_sme_st1w_vertAdaptor(aarch64_sme_st1w_vert op) : aarch64_sme_st1w_vertGenericAdaptor(op->getOperands(), op) {}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1w_vertAdaptor::verify(::mlir::Location loc) {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitError(loc, "'arm_sme.intr.st1w.vert' op requires attribute 'tile_id'");
|
|
|
|
if (tblgen_tile_id && !(((::llvm::isa<::mlir::IntegerAttr>(tblgen_tile_id))) && ((::llvm::cast<::mlir::IntegerAttr>(tblgen_tile_id).getType().isSignlessInteger(32)))))
|
|
return emitError(loc, "'arm_sme.intr.st1w.vert' op attribute 'tile_id' failed to satisfy constraint: 32-bit signless integer attribute");
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1w_vert::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
|
|
{
|
|
auto &propStorage = prop.tile_id;
|
|
auto attr = dict.get("tile_id");
|
|
if (attr) {
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::mlir::Attribute aarch64_sme_st1w_vert::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) {
|
|
::mlir::SmallVector<::mlir::NamedAttribute> attrs;
|
|
::mlir::Builder odsBuilder{ctx};
|
|
|
|
{
|
|
const auto &propStorage = prop.tile_id;
|
|
if (propStorage)
|
|
attrs.push_back(odsBuilder.getNamedAttr("tile_id",
|
|
propStorage));
|
|
}
|
|
|
|
if (!attrs.empty())
|
|
return odsBuilder.getDictionaryAttr(attrs);
|
|
return {};
|
|
}
|
|
|
|
llvm::hash_code aarch64_sme_st1w_vert::computePropertiesHash(const Properties &prop) {
|
|
using llvm::hash_value;
|
|
return llvm::hash_combine(
|
|
llvm::hash_value(prop.tile_id.getAsOpaquePointer()));
|
|
}
|
|
|
|
std::optional<mlir::Attribute> aarch64_sme_st1w_vert::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) {
|
|
if (name == "tile_id")
|
|
return prop.tile_id;
|
|
return std::nullopt;
|
|
}
|
|
|
|
void aarch64_sme_st1w_vert::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) {
|
|
if (name == "tile_id") {
|
|
prop.tile_id = ::llvm::dyn_cast_or_null<std::remove_reference_t<decltype(prop.tile_id)>>(value);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void aarch64_sme_st1w_vert::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) {
|
|
if (prop.tile_id) attrs.append("tile_id", prop.tile_id);
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1w_vert::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
{
|
|
::mlir::Attribute attr = attrs.get(getTileIdAttrName(opName));
|
|
if (attr && ::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(attr, "tile_id", emitError)))
|
|
return ::mlir::failure();
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1w_vert::readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state) {
|
|
auto &prop = state.getOrAddProperties<Properties>(); (void)prop;
|
|
if (::mlir::failed(reader.readAttribute(prop.tile_id)))
|
|
return ::mlir::failure();
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_st1w_vert::writeProperties(::mlir::DialectBytecodeWriter &writer) {
|
|
auto &prop = getProperties(); (void)prop;
|
|
writer.writeAttribute(prop.tile_id);
|
|
}
|
|
|
|
uint32_t aarch64_sme_st1w_vert::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
void aarch64_sme_st1w_vert::setTileId(uint32_t attrValue) {
|
|
getProperties().tile_id = ::mlir::Builder((*this)->getContext()).getIntegerAttr(::mlir::Builder((*this)->getContext()).getIntegerType(32), attrValue);
|
|
}
|
|
|
|
void aarch64_sme_st1w_vert::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(store_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
}
|
|
|
|
aarch64_sme_st1w_vert aarch64_sme_st1w_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1w_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1w_vert aarch64_sme_st1w_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_st1w_vert::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(store_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_st1w_vert aarch64_sme_st1w_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1w_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1w_vert aarch64_sme_st1w_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_st1w_vert::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(store_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
}
|
|
|
|
aarch64_sme_st1w_vert aarch64_sme_st1w_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1w_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1w_vert aarch64_sme_st1w_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_st1w_vert::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(store_address);
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_st1w_vert aarch64_sme_st1w_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1w_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1w_vert aarch64_sme_st1w_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value predicate, ::mlir::Value store_address, uint32_t tile_id, ::mlir::Value tile_slice_index) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(predicate)>(predicate), std::forward<decltype(store_address)>(store_address), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index));
|
|
}
|
|
|
|
void aarch64_sme_st1w_vert::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
assert(operands.size() == 3u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.addAttributes(attributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
|
|
if (!attributes.empty()) {
|
|
(void)odsState.getOrAddProperties<aarch64_sme_st1w_vert::Properties>();
|
|
::mlir::PropertyRef properties = odsState.getRawProperties();
|
|
std::optional<::mlir::RegisteredOperationName> info =
|
|
odsState.name.getRegisteredInfo();
|
|
if (failed(info->setOpPropertiesFromAttribute(odsState.name, properties,
|
|
odsState.attributes.getDictionary(odsState.getContext()), nullptr)))
|
|
::llvm::report_fatal_error("Property conversion failed.");
|
|
}
|
|
}
|
|
|
|
aarch64_sme_st1w_vert aarch64_sme_st1w_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1w_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1w_vert aarch64_sme_st1w_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
}
|
|
|
|
void aarch64_sme_st1w_vert::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
assert(operands.size() == 3u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.useProperties(const_cast<Properties&>(properties));
|
|
odsState.addAttributes(discardableAttributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_st1w_vert aarch64_sme_st1w_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_st1w_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_st1w_vert aarch64_sme_st1w_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1w_vert::verifyInvariantsImpl() {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitOpError("requires attribute 'tile_id'");
|
|
|
|
if (::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(*this, tblgen_tile_id, "tile_id")))
|
|
return ::mlir::failure();
|
|
{
|
|
unsigned index = 0; (void)index;
|
|
auto valueGroup0 = getODSOperands(0);
|
|
|
|
for (auto v : valueGroup0) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps2(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup1 = getODSOperands(1);
|
|
|
|
for (auto v : valueGroup1) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps3(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup2 = getODSOperands(2);
|
|
|
|
for (auto v : valueGroup2) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps4(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1w_vert::verifyInvariants() {
|
|
return verifyInvariantsImpl();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_st1w_vert::setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
// keep track of used keys in the input dictionary to be able to error out
|
|
// if there are some unknown ones.
|
|
::mlir::DenseSet<::mlir::StringAttr> usedKeys;
|
|
::mlir::MLIRContext *ctx = dict.getContext();
|
|
(void)ctx;
|
|
{
|
|
|
|
auto &propStorage = prop.tile_id;
|
|
auto tile_idAttrName = ::mlir::StringAttr::get(ctx, "tile_id");
|
|
auto attr = dict.get(tile_idAttrName);
|
|
usedKeys.insert(tile_idAttrName);
|
|
if (attr || /*isRequired=*/true) {
|
|
if (!attr) {
|
|
emitError() << "expected key entry for tile_id in DictionaryAttr to set "
|
|
"Properties.";
|
|
return ::mlir::failure();
|
|
}
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
|
|
for (::mlir::NamedAttribute attr : dict) {
|
|
if (!usedKeys.contains(attr.getName()))
|
|
return emitError() << "unknown key '" << attr.getName() <<
|
|
"' when parsing properties dictionary";
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_st1w_vert::getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
|
|
{
|
|
auto valueRange = getODSOperandIndexAndLength(1);
|
|
for (unsigned idx = valueRange.first; idx < valueRange.first + valueRange.second; idx++) {
|
|
effects.emplace_back(::mlir::MemoryEffects::Write::get(), &getOperation()->getOpOperand(idx), 0, false, ::mlir::SideEffects::DefaultResource::get());
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace mlir::arm_sme
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::aarch64_sme_st1w_vert)
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::detail::aarch64_sme_st1w_vertGenericAdaptorBase::Properties)
|
|
|
|
namespace mlir::arm_sme {
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ::mlir::arm_sme::aarch64_sme_str definitions
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace detail {
|
|
|
|
aarch64_sme_strGenericAdaptorBase::aarch64_sme_strGenericAdaptorBase(aarch64_sme_str op) : odsAttrs(op->getRawDictionaryAttrs()), odsOpName(op->getName()), properties(op.getProperties()), odsRegions(op->getRegions()) {}
|
|
|
|
|
|
} // namespace detail
|
|
aarch64_sme_strAdaptor::aarch64_sme_strAdaptor(aarch64_sme_str op) : aarch64_sme_strGenericAdaptor(op->getOperands(), op) {}
|
|
|
|
::llvm::LogicalResult aarch64_sme_strAdaptor::verify(::mlir::Location loc) {
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_str::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::mlir::Attribute aarch64_sme_str::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) {
|
|
::mlir::SmallVector<::mlir::NamedAttribute> attrs;
|
|
::mlir::Builder odsBuilder{ctx};
|
|
|
|
if (!attrs.empty())
|
|
return odsBuilder.getDictionaryAttr(attrs);
|
|
return {};
|
|
}
|
|
|
|
llvm::hash_code aarch64_sme_str::computePropertiesHash(const Properties &prop) {
|
|
using llvm::hash_value;
|
|
return llvm::hash_combine();
|
|
}
|
|
|
|
std::optional<mlir::Attribute> aarch64_sme_str::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) {
|
|
return std::nullopt;
|
|
}
|
|
|
|
void aarch64_sme_str::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) {
|
|
}
|
|
|
|
void aarch64_sme_str::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) {
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_str::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_str::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value index, ::mlir::Value store_address, ::mlir::Value offset) {
|
|
odsState.addOperands(index);
|
|
odsState.addOperands(store_address);
|
|
odsState.addOperands(offset);
|
|
}
|
|
|
|
aarch64_sme_str aarch64_sme_str::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value index, ::mlir::Value store_address, ::mlir::Value offset) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(index)>(index), std::forward<decltype(store_address)>(store_address), std::forward<decltype(offset)>(offset));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_str>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_str aarch64_sme_str::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value index, ::mlir::Value store_address, ::mlir::Value offset) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(index)>(index), std::forward<decltype(store_address)>(store_address), std::forward<decltype(offset)>(offset));
|
|
}
|
|
|
|
void aarch64_sme_str::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value index, ::mlir::Value store_address, ::mlir::Value offset) {
|
|
odsState.addOperands(index);
|
|
odsState.addOperands(store_address);
|
|
odsState.addOperands(offset);
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_str aarch64_sme_str::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value index, ::mlir::Value store_address, ::mlir::Value offset) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(index)>(index), std::forward<decltype(store_address)>(store_address), std::forward<decltype(offset)>(offset));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_str>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_str aarch64_sme_str::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value index, ::mlir::Value store_address, ::mlir::Value offset) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(index)>(index), std::forward<decltype(store_address)>(store_address), std::forward<decltype(offset)>(offset));
|
|
}
|
|
|
|
void aarch64_sme_str::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
assert(operands.size() == 3u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.addAttributes(attributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_str aarch64_sme_str::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_str>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_str aarch64_sme_str::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
}
|
|
|
|
void aarch64_sme_str::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
assert(operands.size() == 3u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.useProperties(const_cast<Properties&>(properties));
|
|
odsState.addAttributes(discardableAttributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_str aarch64_sme_str::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_str>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_str aarch64_sme_str::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_str::verifyInvariantsImpl() {
|
|
{
|
|
unsigned index = 0; (void)index;
|
|
auto valueGroup0 = getODSOperands(0);
|
|
|
|
for (auto v : valueGroup0) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps4(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup1 = getODSOperands(1);
|
|
|
|
for (auto v : valueGroup1) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps3(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup2 = getODSOperands(2);
|
|
|
|
for (auto v : valueGroup2) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps4(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_str::verifyInvariants() {
|
|
return verifyInvariantsImpl();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_str::setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
// keep track of used keys in the input dictionary to be able to error out
|
|
// if there are some unknown ones.
|
|
::mlir::DenseSet<::mlir::StringAttr> usedKeys;
|
|
::mlir::MLIRContext *ctx = dict.getContext();
|
|
(void)ctx;
|
|
|
|
for (::mlir::NamedAttribute attr : dict) {
|
|
if (!usedKeys.contains(attr.getName()))
|
|
return emitError() << "unknown key '" << attr.getName() <<
|
|
"' when parsing properties dictionary";
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_str::getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
|
|
{
|
|
auto valueRange = getODSOperandIndexAndLength(1);
|
|
for (unsigned idx = valueRange.first; idx < valueRange.first + valueRange.second; idx++) {
|
|
effects.emplace_back(::mlir::MemoryEffects::Write::get(), &getOperation()->getOpOperand(idx), 0, false, ::mlir::SideEffects::DefaultResource::get());
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace mlir::arm_sme
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::aarch64_sme_str)
|
|
|
|
namespace mlir::arm_sme {
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ::mlir::arm_sme::aarch64_sme_sumopa_wide definitions
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace detail {
|
|
|
|
aarch64_sme_sumopa_wideGenericAdaptorBase::aarch64_sme_sumopa_wideGenericAdaptorBase(aarch64_sme_sumopa_wide op) : odsAttrs(op->getRawDictionaryAttrs()), odsOpName(op->getName()), properties(op.getProperties()), odsRegions(op->getRegions()) {}
|
|
|
|
uint32_t aarch64_sme_sumopa_wideGenericAdaptorBase::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
|
|
} // namespace detail
|
|
aarch64_sme_sumopa_wideAdaptor::aarch64_sme_sumopa_wideAdaptor(aarch64_sme_sumopa_wide op) : aarch64_sme_sumopa_wideGenericAdaptor(op->getOperands(), op) {}
|
|
|
|
::llvm::LogicalResult aarch64_sme_sumopa_wideAdaptor::verify(::mlir::Location loc) {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitError(loc, "'arm_sme.intr.sumopa.wide' op requires attribute 'tile_id'");
|
|
|
|
if (tblgen_tile_id && !(((::llvm::isa<::mlir::IntegerAttr>(tblgen_tile_id))) && ((::llvm::cast<::mlir::IntegerAttr>(tblgen_tile_id).getType().isSignlessInteger(32)))))
|
|
return emitError(loc, "'arm_sme.intr.sumopa.wide' op attribute 'tile_id' failed to satisfy constraint: 32-bit signless integer attribute");
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_sumopa_wide::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
|
|
{
|
|
auto &propStorage = prop.tile_id;
|
|
auto attr = dict.get("tile_id");
|
|
if (attr) {
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::mlir::Attribute aarch64_sme_sumopa_wide::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) {
|
|
::mlir::SmallVector<::mlir::NamedAttribute> attrs;
|
|
::mlir::Builder odsBuilder{ctx};
|
|
|
|
{
|
|
const auto &propStorage = prop.tile_id;
|
|
if (propStorage)
|
|
attrs.push_back(odsBuilder.getNamedAttr("tile_id",
|
|
propStorage));
|
|
}
|
|
|
|
if (!attrs.empty())
|
|
return odsBuilder.getDictionaryAttr(attrs);
|
|
return {};
|
|
}
|
|
|
|
llvm::hash_code aarch64_sme_sumopa_wide::computePropertiesHash(const Properties &prop) {
|
|
using llvm::hash_value;
|
|
return llvm::hash_combine(
|
|
llvm::hash_value(prop.tile_id.getAsOpaquePointer()));
|
|
}
|
|
|
|
std::optional<mlir::Attribute> aarch64_sme_sumopa_wide::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) {
|
|
if (name == "tile_id")
|
|
return prop.tile_id;
|
|
return std::nullopt;
|
|
}
|
|
|
|
void aarch64_sme_sumopa_wide::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) {
|
|
if (name == "tile_id") {
|
|
prop.tile_id = ::llvm::dyn_cast_or_null<std::remove_reference_t<decltype(prop.tile_id)>>(value);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void aarch64_sme_sumopa_wide::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) {
|
|
if (prop.tile_id) attrs.append("tile_id", prop.tile_id);
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_sumopa_wide::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
{
|
|
::mlir::Attribute attr = attrs.get(getTileIdAttrName(opName));
|
|
if (attr && ::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(attr, "tile_id", emitError)))
|
|
return ::mlir::failure();
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_sumopa_wide::readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state) {
|
|
auto &prop = state.getOrAddProperties<Properties>(); (void)prop;
|
|
if (::mlir::failed(reader.readAttribute(prop.tile_id)))
|
|
return ::mlir::failure();
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_sumopa_wide::writeProperties(::mlir::DialectBytecodeWriter &writer) {
|
|
auto &prop = getProperties(); (void)prop;
|
|
writer.writeAttribute(prop.tile_id);
|
|
}
|
|
|
|
uint32_t aarch64_sme_sumopa_wide::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
void aarch64_sme_sumopa_wide::setTileId(uint32_t attrValue) {
|
|
getProperties().tile_id = ::mlir::Builder((*this)->getContext()).getIntegerAttr(::mlir::Builder((*this)->getContext()).getIntegerType(32), attrValue);
|
|
}
|
|
|
|
void aarch64_sme_sumopa_wide::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
}
|
|
|
|
aarch64_sme_sumopa_wide aarch64_sme_sumopa_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_sumopa_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_sumopa_wide aarch64_sme_sumopa_wide::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_sumopa_wide::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_sumopa_wide aarch64_sme_sumopa_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_sumopa_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_sumopa_wide aarch64_sme_sumopa_wide::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_sumopa_wide::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
}
|
|
|
|
aarch64_sme_sumopa_wide aarch64_sme_sumopa_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_sumopa_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_sumopa_wide aarch64_sme_sumopa_wide::create(::mlir::ImplicitLocOpBuilder &builder, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_sumopa_wide::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_sumopa_wide aarch64_sme_sumopa_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_sumopa_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_sumopa_wide aarch64_sme_sumopa_wide::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_sumopa_wide::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
assert(operands.size() == 4u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.addAttributes(attributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
|
|
if (!attributes.empty()) {
|
|
(void)odsState.getOrAddProperties<aarch64_sme_sumopa_wide::Properties>();
|
|
::mlir::PropertyRef properties = odsState.getRawProperties();
|
|
std::optional<::mlir::RegisteredOperationName> info =
|
|
odsState.name.getRegisteredInfo();
|
|
if (failed(info->setOpPropertiesFromAttribute(odsState.name, properties,
|
|
odsState.attributes.getDictionary(odsState.getContext()), nullptr)))
|
|
::llvm::report_fatal_error("Property conversion failed.");
|
|
}
|
|
}
|
|
|
|
aarch64_sme_sumopa_wide aarch64_sme_sumopa_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_sumopa_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_sumopa_wide aarch64_sme_sumopa_wide::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
}
|
|
|
|
void aarch64_sme_sumopa_wide::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
assert(operands.size() == 4u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.useProperties(const_cast<Properties&>(properties));
|
|
odsState.addAttributes(discardableAttributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_sumopa_wide aarch64_sme_sumopa_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_sumopa_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_sumopa_wide aarch64_sme_sumopa_wide::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_sumopa_wide::verifyInvariantsImpl() {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitOpError("requires attribute 'tile_id'");
|
|
|
|
if (::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(*this, tblgen_tile_id, "tile_id")))
|
|
return ::mlir::failure();
|
|
{
|
|
unsigned index = 0; (void)index;
|
|
auto valueGroup0 = getODSOperands(0);
|
|
|
|
for (auto v : valueGroup0) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps5(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup1 = getODSOperands(1);
|
|
|
|
for (auto v : valueGroup1) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps5(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup2 = getODSOperands(2);
|
|
|
|
for (auto v : valueGroup2) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps6(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup3 = getODSOperands(3);
|
|
|
|
for (auto v : valueGroup3) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps6(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_sumopa_wide::verifyInvariants() {
|
|
return verifyInvariantsImpl();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_sumopa_wide::setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
// keep track of used keys in the input dictionary to be able to error out
|
|
// if there are some unknown ones.
|
|
::mlir::DenseSet<::mlir::StringAttr> usedKeys;
|
|
::mlir::MLIRContext *ctx = dict.getContext();
|
|
(void)ctx;
|
|
{
|
|
|
|
auto &propStorage = prop.tile_id;
|
|
auto tile_idAttrName = ::mlir::StringAttr::get(ctx, "tile_id");
|
|
auto attr = dict.get(tile_idAttrName);
|
|
usedKeys.insert(tile_idAttrName);
|
|
if (attr || /*isRequired=*/true) {
|
|
if (!attr) {
|
|
emitError() << "expected key entry for tile_id in DictionaryAttr to set "
|
|
"Properties.";
|
|
return ::mlir::failure();
|
|
}
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
|
|
for (::mlir::NamedAttribute attr : dict) {
|
|
if (!usedKeys.contains(attr.getName()))
|
|
return emitError() << "unknown key '" << attr.getName() <<
|
|
"' when parsing properties dictionary";
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
|
|
} // namespace mlir::arm_sme
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::aarch64_sme_sumopa_wide)
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::detail::aarch64_sme_sumopa_wideGenericAdaptorBase::Properties)
|
|
|
|
namespace mlir::arm_sme {
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ::mlir::arm_sme::aarch64_sme_sumops_wide definitions
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace detail {
|
|
|
|
aarch64_sme_sumops_wideGenericAdaptorBase::aarch64_sme_sumops_wideGenericAdaptorBase(aarch64_sme_sumops_wide op) : odsAttrs(op->getRawDictionaryAttrs()), odsOpName(op->getName()), properties(op.getProperties()), odsRegions(op->getRegions()) {}
|
|
|
|
uint32_t aarch64_sme_sumops_wideGenericAdaptorBase::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
|
|
} // namespace detail
|
|
aarch64_sme_sumops_wideAdaptor::aarch64_sme_sumops_wideAdaptor(aarch64_sme_sumops_wide op) : aarch64_sme_sumops_wideGenericAdaptor(op->getOperands(), op) {}
|
|
|
|
::llvm::LogicalResult aarch64_sme_sumops_wideAdaptor::verify(::mlir::Location loc) {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitError(loc, "'arm_sme.intr.sumops.wide' op requires attribute 'tile_id'");
|
|
|
|
if (tblgen_tile_id && !(((::llvm::isa<::mlir::IntegerAttr>(tblgen_tile_id))) && ((::llvm::cast<::mlir::IntegerAttr>(tblgen_tile_id).getType().isSignlessInteger(32)))))
|
|
return emitError(loc, "'arm_sme.intr.sumops.wide' op attribute 'tile_id' failed to satisfy constraint: 32-bit signless integer attribute");
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_sumops_wide::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
|
|
{
|
|
auto &propStorage = prop.tile_id;
|
|
auto attr = dict.get("tile_id");
|
|
if (attr) {
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::mlir::Attribute aarch64_sme_sumops_wide::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) {
|
|
::mlir::SmallVector<::mlir::NamedAttribute> attrs;
|
|
::mlir::Builder odsBuilder{ctx};
|
|
|
|
{
|
|
const auto &propStorage = prop.tile_id;
|
|
if (propStorage)
|
|
attrs.push_back(odsBuilder.getNamedAttr("tile_id",
|
|
propStorage));
|
|
}
|
|
|
|
if (!attrs.empty())
|
|
return odsBuilder.getDictionaryAttr(attrs);
|
|
return {};
|
|
}
|
|
|
|
llvm::hash_code aarch64_sme_sumops_wide::computePropertiesHash(const Properties &prop) {
|
|
using llvm::hash_value;
|
|
return llvm::hash_combine(
|
|
llvm::hash_value(prop.tile_id.getAsOpaquePointer()));
|
|
}
|
|
|
|
std::optional<mlir::Attribute> aarch64_sme_sumops_wide::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) {
|
|
if (name == "tile_id")
|
|
return prop.tile_id;
|
|
return std::nullopt;
|
|
}
|
|
|
|
void aarch64_sme_sumops_wide::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) {
|
|
if (name == "tile_id") {
|
|
prop.tile_id = ::llvm::dyn_cast_or_null<std::remove_reference_t<decltype(prop.tile_id)>>(value);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void aarch64_sme_sumops_wide::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) {
|
|
if (prop.tile_id) attrs.append("tile_id", prop.tile_id);
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_sumops_wide::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
{
|
|
::mlir::Attribute attr = attrs.get(getTileIdAttrName(opName));
|
|
if (attr && ::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(attr, "tile_id", emitError)))
|
|
return ::mlir::failure();
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_sumops_wide::readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state) {
|
|
auto &prop = state.getOrAddProperties<Properties>(); (void)prop;
|
|
if (::mlir::failed(reader.readAttribute(prop.tile_id)))
|
|
return ::mlir::failure();
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_sumops_wide::writeProperties(::mlir::DialectBytecodeWriter &writer) {
|
|
auto &prop = getProperties(); (void)prop;
|
|
writer.writeAttribute(prop.tile_id);
|
|
}
|
|
|
|
uint32_t aarch64_sme_sumops_wide::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
void aarch64_sme_sumops_wide::setTileId(uint32_t attrValue) {
|
|
getProperties().tile_id = ::mlir::Builder((*this)->getContext()).getIntegerAttr(::mlir::Builder((*this)->getContext()).getIntegerType(32), attrValue);
|
|
}
|
|
|
|
void aarch64_sme_sumops_wide::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
}
|
|
|
|
aarch64_sme_sumops_wide aarch64_sme_sumops_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_sumops_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_sumops_wide aarch64_sme_sumops_wide::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_sumops_wide::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_sumops_wide aarch64_sme_sumops_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_sumops_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_sumops_wide aarch64_sme_sumops_wide::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_sumops_wide::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
}
|
|
|
|
aarch64_sme_sumops_wide aarch64_sme_sumops_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_sumops_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_sumops_wide aarch64_sme_sumops_wide::create(::mlir::ImplicitLocOpBuilder &builder, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_sumops_wide::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_sumops_wide aarch64_sme_sumops_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_sumops_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_sumops_wide aarch64_sme_sumops_wide::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_sumops_wide::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
assert(operands.size() == 4u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.addAttributes(attributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
|
|
if (!attributes.empty()) {
|
|
(void)odsState.getOrAddProperties<aarch64_sme_sumops_wide::Properties>();
|
|
::mlir::PropertyRef properties = odsState.getRawProperties();
|
|
std::optional<::mlir::RegisteredOperationName> info =
|
|
odsState.name.getRegisteredInfo();
|
|
if (failed(info->setOpPropertiesFromAttribute(odsState.name, properties,
|
|
odsState.attributes.getDictionary(odsState.getContext()), nullptr)))
|
|
::llvm::report_fatal_error("Property conversion failed.");
|
|
}
|
|
}
|
|
|
|
aarch64_sme_sumops_wide aarch64_sme_sumops_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_sumops_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_sumops_wide aarch64_sme_sumops_wide::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
}
|
|
|
|
void aarch64_sme_sumops_wide::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
assert(operands.size() == 4u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.useProperties(const_cast<Properties&>(properties));
|
|
odsState.addAttributes(discardableAttributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_sumops_wide aarch64_sme_sumops_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_sumops_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_sumops_wide aarch64_sme_sumops_wide::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_sumops_wide::verifyInvariantsImpl() {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitOpError("requires attribute 'tile_id'");
|
|
|
|
if (::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(*this, tblgen_tile_id, "tile_id")))
|
|
return ::mlir::failure();
|
|
{
|
|
unsigned index = 0; (void)index;
|
|
auto valueGroup0 = getODSOperands(0);
|
|
|
|
for (auto v : valueGroup0) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps5(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup1 = getODSOperands(1);
|
|
|
|
for (auto v : valueGroup1) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps5(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup2 = getODSOperands(2);
|
|
|
|
for (auto v : valueGroup2) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps6(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup3 = getODSOperands(3);
|
|
|
|
for (auto v : valueGroup3) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps6(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_sumops_wide::verifyInvariants() {
|
|
return verifyInvariantsImpl();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_sumops_wide::setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
// keep track of used keys in the input dictionary to be able to error out
|
|
// if there are some unknown ones.
|
|
::mlir::DenseSet<::mlir::StringAttr> usedKeys;
|
|
::mlir::MLIRContext *ctx = dict.getContext();
|
|
(void)ctx;
|
|
{
|
|
|
|
auto &propStorage = prop.tile_id;
|
|
auto tile_idAttrName = ::mlir::StringAttr::get(ctx, "tile_id");
|
|
auto attr = dict.get(tile_idAttrName);
|
|
usedKeys.insert(tile_idAttrName);
|
|
if (attr || /*isRequired=*/true) {
|
|
if (!attr) {
|
|
emitError() << "expected key entry for tile_id in DictionaryAttr to set "
|
|
"Properties.";
|
|
return ::mlir::failure();
|
|
}
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
|
|
for (::mlir::NamedAttribute attr : dict) {
|
|
if (!usedKeys.contains(attr.getName()))
|
|
return emitError() << "unknown key '" << attr.getName() <<
|
|
"' when parsing properties dictionary";
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
|
|
} // namespace mlir::arm_sme
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::aarch64_sme_sumops_wide)
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::detail::aarch64_sme_sumops_wideGenericAdaptorBase::Properties)
|
|
|
|
namespace mlir::arm_sme {
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ::mlir::arm_sme::aarch64_sme_umopa_wide definitions
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace detail {
|
|
|
|
aarch64_sme_umopa_wideGenericAdaptorBase::aarch64_sme_umopa_wideGenericAdaptorBase(aarch64_sme_umopa_wide op) : odsAttrs(op->getRawDictionaryAttrs()), odsOpName(op->getName()), properties(op.getProperties()), odsRegions(op->getRegions()) {}
|
|
|
|
uint32_t aarch64_sme_umopa_wideGenericAdaptorBase::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
|
|
} // namespace detail
|
|
aarch64_sme_umopa_wideAdaptor::aarch64_sme_umopa_wideAdaptor(aarch64_sme_umopa_wide op) : aarch64_sme_umopa_wideGenericAdaptor(op->getOperands(), op) {}
|
|
|
|
::llvm::LogicalResult aarch64_sme_umopa_wideAdaptor::verify(::mlir::Location loc) {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitError(loc, "'arm_sme.intr.umopa.wide' op requires attribute 'tile_id'");
|
|
|
|
if (tblgen_tile_id && !(((::llvm::isa<::mlir::IntegerAttr>(tblgen_tile_id))) && ((::llvm::cast<::mlir::IntegerAttr>(tblgen_tile_id).getType().isSignlessInteger(32)))))
|
|
return emitError(loc, "'arm_sme.intr.umopa.wide' op attribute 'tile_id' failed to satisfy constraint: 32-bit signless integer attribute");
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_umopa_wide::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
|
|
{
|
|
auto &propStorage = prop.tile_id;
|
|
auto attr = dict.get("tile_id");
|
|
if (attr) {
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::mlir::Attribute aarch64_sme_umopa_wide::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) {
|
|
::mlir::SmallVector<::mlir::NamedAttribute> attrs;
|
|
::mlir::Builder odsBuilder{ctx};
|
|
|
|
{
|
|
const auto &propStorage = prop.tile_id;
|
|
if (propStorage)
|
|
attrs.push_back(odsBuilder.getNamedAttr("tile_id",
|
|
propStorage));
|
|
}
|
|
|
|
if (!attrs.empty())
|
|
return odsBuilder.getDictionaryAttr(attrs);
|
|
return {};
|
|
}
|
|
|
|
llvm::hash_code aarch64_sme_umopa_wide::computePropertiesHash(const Properties &prop) {
|
|
using llvm::hash_value;
|
|
return llvm::hash_combine(
|
|
llvm::hash_value(prop.tile_id.getAsOpaquePointer()));
|
|
}
|
|
|
|
std::optional<mlir::Attribute> aarch64_sme_umopa_wide::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) {
|
|
if (name == "tile_id")
|
|
return prop.tile_id;
|
|
return std::nullopt;
|
|
}
|
|
|
|
void aarch64_sme_umopa_wide::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) {
|
|
if (name == "tile_id") {
|
|
prop.tile_id = ::llvm::dyn_cast_or_null<std::remove_reference_t<decltype(prop.tile_id)>>(value);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void aarch64_sme_umopa_wide::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) {
|
|
if (prop.tile_id) attrs.append("tile_id", prop.tile_id);
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_umopa_wide::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
{
|
|
::mlir::Attribute attr = attrs.get(getTileIdAttrName(opName));
|
|
if (attr && ::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(attr, "tile_id", emitError)))
|
|
return ::mlir::failure();
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_umopa_wide::readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state) {
|
|
auto &prop = state.getOrAddProperties<Properties>(); (void)prop;
|
|
if (::mlir::failed(reader.readAttribute(prop.tile_id)))
|
|
return ::mlir::failure();
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_umopa_wide::writeProperties(::mlir::DialectBytecodeWriter &writer) {
|
|
auto &prop = getProperties(); (void)prop;
|
|
writer.writeAttribute(prop.tile_id);
|
|
}
|
|
|
|
uint32_t aarch64_sme_umopa_wide::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
void aarch64_sme_umopa_wide::setTileId(uint32_t attrValue) {
|
|
getProperties().tile_id = ::mlir::Builder((*this)->getContext()).getIntegerAttr(::mlir::Builder((*this)->getContext()).getIntegerType(32), attrValue);
|
|
}
|
|
|
|
void aarch64_sme_umopa_wide::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
}
|
|
|
|
aarch64_sme_umopa_wide aarch64_sme_umopa_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_umopa_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_umopa_wide aarch64_sme_umopa_wide::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_umopa_wide::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_umopa_wide aarch64_sme_umopa_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_umopa_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_umopa_wide aarch64_sme_umopa_wide::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_umopa_wide::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
}
|
|
|
|
aarch64_sme_umopa_wide aarch64_sme_umopa_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_umopa_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_umopa_wide aarch64_sme_umopa_wide::create(::mlir::ImplicitLocOpBuilder &builder, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_umopa_wide::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_umopa_wide aarch64_sme_umopa_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_umopa_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_umopa_wide aarch64_sme_umopa_wide::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_umopa_wide::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
assert(operands.size() == 4u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.addAttributes(attributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
|
|
if (!attributes.empty()) {
|
|
(void)odsState.getOrAddProperties<aarch64_sme_umopa_wide::Properties>();
|
|
::mlir::PropertyRef properties = odsState.getRawProperties();
|
|
std::optional<::mlir::RegisteredOperationName> info =
|
|
odsState.name.getRegisteredInfo();
|
|
if (failed(info->setOpPropertiesFromAttribute(odsState.name, properties,
|
|
odsState.attributes.getDictionary(odsState.getContext()), nullptr)))
|
|
::llvm::report_fatal_error("Property conversion failed.");
|
|
}
|
|
}
|
|
|
|
aarch64_sme_umopa_wide aarch64_sme_umopa_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_umopa_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_umopa_wide aarch64_sme_umopa_wide::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
}
|
|
|
|
void aarch64_sme_umopa_wide::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
assert(operands.size() == 4u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.useProperties(const_cast<Properties&>(properties));
|
|
odsState.addAttributes(discardableAttributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_umopa_wide aarch64_sme_umopa_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_umopa_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_umopa_wide aarch64_sme_umopa_wide::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_umopa_wide::verifyInvariantsImpl() {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitOpError("requires attribute 'tile_id'");
|
|
|
|
if (::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(*this, tblgen_tile_id, "tile_id")))
|
|
return ::mlir::failure();
|
|
{
|
|
unsigned index = 0; (void)index;
|
|
auto valueGroup0 = getODSOperands(0);
|
|
|
|
for (auto v : valueGroup0) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps5(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup1 = getODSOperands(1);
|
|
|
|
for (auto v : valueGroup1) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps5(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup2 = getODSOperands(2);
|
|
|
|
for (auto v : valueGroup2) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps6(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup3 = getODSOperands(3);
|
|
|
|
for (auto v : valueGroup3) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps6(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_umopa_wide::verifyInvariants() {
|
|
return verifyInvariantsImpl();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_umopa_wide::setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
// keep track of used keys in the input dictionary to be able to error out
|
|
// if there are some unknown ones.
|
|
::mlir::DenseSet<::mlir::StringAttr> usedKeys;
|
|
::mlir::MLIRContext *ctx = dict.getContext();
|
|
(void)ctx;
|
|
{
|
|
|
|
auto &propStorage = prop.tile_id;
|
|
auto tile_idAttrName = ::mlir::StringAttr::get(ctx, "tile_id");
|
|
auto attr = dict.get(tile_idAttrName);
|
|
usedKeys.insert(tile_idAttrName);
|
|
if (attr || /*isRequired=*/true) {
|
|
if (!attr) {
|
|
emitError() << "expected key entry for tile_id in DictionaryAttr to set "
|
|
"Properties.";
|
|
return ::mlir::failure();
|
|
}
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
|
|
for (::mlir::NamedAttribute attr : dict) {
|
|
if (!usedKeys.contains(attr.getName()))
|
|
return emitError() << "unknown key '" << attr.getName() <<
|
|
"' when parsing properties dictionary";
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
|
|
} // namespace mlir::arm_sme
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::aarch64_sme_umopa_wide)
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::detail::aarch64_sme_umopa_wideGenericAdaptorBase::Properties)
|
|
|
|
namespace mlir::arm_sme {
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ::mlir::arm_sme::aarch64_sme_umopa_za32 definitions
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace detail {
|
|
|
|
aarch64_sme_umopa_za32GenericAdaptorBase::aarch64_sme_umopa_za32GenericAdaptorBase(aarch64_sme_umopa_za32 op) : odsAttrs(op->getRawDictionaryAttrs()), odsOpName(op->getName()), properties(op.getProperties()), odsRegions(op->getRegions()) {}
|
|
|
|
uint32_t aarch64_sme_umopa_za32GenericAdaptorBase::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
|
|
} // namespace detail
|
|
aarch64_sme_umopa_za32Adaptor::aarch64_sme_umopa_za32Adaptor(aarch64_sme_umopa_za32 op) : aarch64_sme_umopa_za32GenericAdaptor(op->getOperands(), op) {}
|
|
|
|
::llvm::LogicalResult aarch64_sme_umopa_za32Adaptor::verify(::mlir::Location loc) {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitError(loc, "'arm_sme.intr.umopa.za32' op requires attribute 'tile_id'");
|
|
|
|
if (tblgen_tile_id && !(((::llvm::isa<::mlir::IntegerAttr>(tblgen_tile_id))) && ((::llvm::cast<::mlir::IntegerAttr>(tblgen_tile_id).getType().isSignlessInteger(32)))))
|
|
return emitError(loc, "'arm_sme.intr.umopa.za32' op attribute 'tile_id' failed to satisfy constraint: 32-bit signless integer attribute");
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_umopa_za32::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
|
|
{
|
|
auto &propStorage = prop.tile_id;
|
|
auto attr = dict.get("tile_id");
|
|
if (attr) {
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::mlir::Attribute aarch64_sme_umopa_za32::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) {
|
|
::mlir::SmallVector<::mlir::NamedAttribute> attrs;
|
|
::mlir::Builder odsBuilder{ctx};
|
|
|
|
{
|
|
const auto &propStorage = prop.tile_id;
|
|
if (propStorage)
|
|
attrs.push_back(odsBuilder.getNamedAttr("tile_id",
|
|
propStorage));
|
|
}
|
|
|
|
if (!attrs.empty())
|
|
return odsBuilder.getDictionaryAttr(attrs);
|
|
return {};
|
|
}
|
|
|
|
llvm::hash_code aarch64_sme_umopa_za32::computePropertiesHash(const Properties &prop) {
|
|
using llvm::hash_value;
|
|
return llvm::hash_combine(
|
|
llvm::hash_value(prop.tile_id.getAsOpaquePointer()));
|
|
}
|
|
|
|
std::optional<mlir::Attribute> aarch64_sme_umopa_za32::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) {
|
|
if (name == "tile_id")
|
|
return prop.tile_id;
|
|
return std::nullopt;
|
|
}
|
|
|
|
void aarch64_sme_umopa_za32::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) {
|
|
if (name == "tile_id") {
|
|
prop.tile_id = ::llvm::dyn_cast_or_null<std::remove_reference_t<decltype(prop.tile_id)>>(value);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void aarch64_sme_umopa_za32::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) {
|
|
if (prop.tile_id) attrs.append("tile_id", prop.tile_id);
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_umopa_za32::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
{
|
|
::mlir::Attribute attr = attrs.get(getTileIdAttrName(opName));
|
|
if (attr && ::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(attr, "tile_id", emitError)))
|
|
return ::mlir::failure();
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_umopa_za32::readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state) {
|
|
auto &prop = state.getOrAddProperties<Properties>(); (void)prop;
|
|
if (::mlir::failed(reader.readAttribute(prop.tile_id)))
|
|
return ::mlir::failure();
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_umopa_za32::writeProperties(::mlir::DialectBytecodeWriter &writer) {
|
|
auto &prop = getProperties(); (void)prop;
|
|
writer.writeAttribute(prop.tile_id);
|
|
}
|
|
|
|
uint32_t aarch64_sme_umopa_za32::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
void aarch64_sme_umopa_za32::setTileId(uint32_t attrValue) {
|
|
getProperties().tile_id = ::mlir::Builder((*this)->getContext()).getIntegerAttr(::mlir::Builder((*this)->getContext()).getIntegerType(32), attrValue);
|
|
}
|
|
|
|
void aarch64_sme_umopa_za32::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
}
|
|
|
|
aarch64_sme_umopa_za32 aarch64_sme_umopa_za32::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_umopa_za32>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_umopa_za32 aarch64_sme_umopa_za32::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_umopa_za32::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_umopa_za32 aarch64_sme_umopa_za32::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_umopa_za32>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_umopa_za32 aarch64_sme_umopa_za32::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_umopa_za32::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
}
|
|
|
|
aarch64_sme_umopa_za32 aarch64_sme_umopa_za32::create(::mlir::OpBuilder &builder, ::mlir::Location location, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_umopa_za32>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_umopa_za32 aarch64_sme_umopa_za32::create(::mlir::ImplicitLocOpBuilder &builder, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_umopa_za32::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_umopa_za32 aarch64_sme_umopa_za32::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_umopa_za32>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_umopa_za32 aarch64_sme_umopa_za32::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_umopa_za32::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
assert(operands.size() == 4u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.addAttributes(attributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
|
|
if (!attributes.empty()) {
|
|
(void)odsState.getOrAddProperties<aarch64_sme_umopa_za32::Properties>();
|
|
::mlir::PropertyRef properties = odsState.getRawProperties();
|
|
std::optional<::mlir::RegisteredOperationName> info =
|
|
odsState.name.getRegisteredInfo();
|
|
if (failed(info->setOpPropertiesFromAttribute(odsState.name, properties,
|
|
odsState.attributes.getDictionary(odsState.getContext()), nullptr)))
|
|
::llvm::report_fatal_error("Property conversion failed.");
|
|
}
|
|
}
|
|
|
|
aarch64_sme_umopa_za32 aarch64_sme_umopa_za32::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_umopa_za32>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_umopa_za32 aarch64_sme_umopa_za32::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
}
|
|
|
|
void aarch64_sme_umopa_za32::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
assert(operands.size() == 4u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.useProperties(const_cast<Properties&>(properties));
|
|
odsState.addAttributes(discardableAttributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_umopa_za32 aarch64_sme_umopa_za32::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_umopa_za32>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_umopa_za32 aarch64_sme_umopa_za32::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_umopa_za32::verifyInvariantsImpl() {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitOpError("requires attribute 'tile_id'");
|
|
|
|
if (::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(*this, tblgen_tile_id, "tile_id")))
|
|
return ::mlir::failure();
|
|
{
|
|
unsigned index = 0; (void)index;
|
|
auto valueGroup0 = getODSOperands(0);
|
|
|
|
for (auto v : valueGroup0) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps5(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup1 = getODSOperands(1);
|
|
|
|
for (auto v : valueGroup1) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps5(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup2 = getODSOperands(2);
|
|
|
|
for (auto v : valueGroup2) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps6(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup3 = getODSOperands(3);
|
|
|
|
for (auto v : valueGroup3) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps6(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_umopa_za32::verifyInvariants() {
|
|
return verifyInvariantsImpl();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_umopa_za32::setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
// keep track of used keys in the input dictionary to be able to error out
|
|
// if there are some unknown ones.
|
|
::mlir::DenseSet<::mlir::StringAttr> usedKeys;
|
|
::mlir::MLIRContext *ctx = dict.getContext();
|
|
(void)ctx;
|
|
{
|
|
|
|
auto &propStorage = prop.tile_id;
|
|
auto tile_idAttrName = ::mlir::StringAttr::get(ctx, "tile_id");
|
|
auto attr = dict.get(tile_idAttrName);
|
|
usedKeys.insert(tile_idAttrName);
|
|
if (attr || /*isRequired=*/true) {
|
|
if (!attr) {
|
|
emitError() << "expected key entry for tile_id in DictionaryAttr to set "
|
|
"Properties.";
|
|
return ::mlir::failure();
|
|
}
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
|
|
for (::mlir::NamedAttribute attr : dict) {
|
|
if (!usedKeys.contains(attr.getName()))
|
|
return emitError() << "unknown key '" << attr.getName() <<
|
|
"' when parsing properties dictionary";
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
|
|
} // namespace mlir::arm_sme
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::aarch64_sme_umopa_za32)
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::detail::aarch64_sme_umopa_za32GenericAdaptorBase::Properties)
|
|
|
|
namespace mlir::arm_sme {
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ::mlir::arm_sme::aarch64_sme_umops_wide definitions
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace detail {
|
|
|
|
aarch64_sme_umops_wideGenericAdaptorBase::aarch64_sme_umops_wideGenericAdaptorBase(aarch64_sme_umops_wide op) : odsAttrs(op->getRawDictionaryAttrs()), odsOpName(op->getName()), properties(op.getProperties()), odsRegions(op->getRegions()) {}
|
|
|
|
uint32_t aarch64_sme_umops_wideGenericAdaptorBase::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
|
|
} // namespace detail
|
|
aarch64_sme_umops_wideAdaptor::aarch64_sme_umops_wideAdaptor(aarch64_sme_umops_wide op) : aarch64_sme_umops_wideGenericAdaptor(op->getOperands(), op) {}
|
|
|
|
::llvm::LogicalResult aarch64_sme_umops_wideAdaptor::verify(::mlir::Location loc) {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitError(loc, "'arm_sme.intr.umops.wide' op requires attribute 'tile_id'");
|
|
|
|
if (tblgen_tile_id && !(((::llvm::isa<::mlir::IntegerAttr>(tblgen_tile_id))) && ((::llvm::cast<::mlir::IntegerAttr>(tblgen_tile_id).getType().isSignlessInteger(32)))))
|
|
return emitError(loc, "'arm_sme.intr.umops.wide' op attribute 'tile_id' failed to satisfy constraint: 32-bit signless integer attribute");
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_umops_wide::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
|
|
{
|
|
auto &propStorage = prop.tile_id;
|
|
auto attr = dict.get("tile_id");
|
|
if (attr) {
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::mlir::Attribute aarch64_sme_umops_wide::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) {
|
|
::mlir::SmallVector<::mlir::NamedAttribute> attrs;
|
|
::mlir::Builder odsBuilder{ctx};
|
|
|
|
{
|
|
const auto &propStorage = prop.tile_id;
|
|
if (propStorage)
|
|
attrs.push_back(odsBuilder.getNamedAttr("tile_id",
|
|
propStorage));
|
|
}
|
|
|
|
if (!attrs.empty())
|
|
return odsBuilder.getDictionaryAttr(attrs);
|
|
return {};
|
|
}
|
|
|
|
llvm::hash_code aarch64_sme_umops_wide::computePropertiesHash(const Properties &prop) {
|
|
using llvm::hash_value;
|
|
return llvm::hash_combine(
|
|
llvm::hash_value(prop.tile_id.getAsOpaquePointer()));
|
|
}
|
|
|
|
std::optional<mlir::Attribute> aarch64_sme_umops_wide::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) {
|
|
if (name == "tile_id")
|
|
return prop.tile_id;
|
|
return std::nullopt;
|
|
}
|
|
|
|
void aarch64_sme_umops_wide::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) {
|
|
if (name == "tile_id") {
|
|
prop.tile_id = ::llvm::dyn_cast_or_null<std::remove_reference_t<decltype(prop.tile_id)>>(value);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void aarch64_sme_umops_wide::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) {
|
|
if (prop.tile_id) attrs.append("tile_id", prop.tile_id);
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_umops_wide::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
{
|
|
::mlir::Attribute attr = attrs.get(getTileIdAttrName(opName));
|
|
if (attr && ::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(attr, "tile_id", emitError)))
|
|
return ::mlir::failure();
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_umops_wide::readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state) {
|
|
auto &prop = state.getOrAddProperties<Properties>(); (void)prop;
|
|
if (::mlir::failed(reader.readAttribute(prop.tile_id)))
|
|
return ::mlir::failure();
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_umops_wide::writeProperties(::mlir::DialectBytecodeWriter &writer) {
|
|
auto &prop = getProperties(); (void)prop;
|
|
writer.writeAttribute(prop.tile_id);
|
|
}
|
|
|
|
uint32_t aarch64_sme_umops_wide::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
void aarch64_sme_umops_wide::setTileId(uint32_t attrValue) {
|
|
getProperties().tile_id = ::mlir::Builder((*this)->getContext()).getIntegerAttr(::mlir::Builder((*this)->getContext()).getIntegerType(32), attrValue);
|
|
}
|
|
|
|
void aarch64_sme_umops_wide::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
}
|
|
|
|
aarch64_sme_umops_wide aarch64_sme_umops_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_umops_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_umops_wide aarch64_sme_umops_wide::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_umops_wide::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_umops_wide aarch64_sme_umops_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_umops_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_umops_wide aarch64_sme_umops_wide::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_umops_wide::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
}
|
|
|
|
aarch64_sme_umops_wide aarch64_sme_umops_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_umops_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_umops_wide aarch64_sme_umops_wide::create(::mlir::ImplicitLocOpBuilder &builder, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_umops_wide::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_umops_wide aarch64_sme_umops_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_umops_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_umops_wide aarch64_sme_umops_wide::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_umops_wide::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
assert(operands.size() == 4u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.addAttributes(attributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
|
|
if (!attributes.empty()) {
|
|
(void)odsState.getOrAddProperties<aarch64_sme_umops_wide::Properties>();
|
|
::mlir::PropertyRef properties = odsState.getRawProperties();
|
|
std::optional<::mlir::RegisteredOperationName> info =
|
|
odsState.name.getRegisteredInfo();
|
|
if (failed(info->setOpPropertiesFromAttribute(odsState.name, properties,
|
|
odsState.attributes.getDictionary(odsState.getContext()), nullptr)))
|
|
::llvm::report_fatal_error("Property conversion failed.");
|
|
}
|
|
}
|
|
|
|
aarch64_sme_umops_wide aarch64_sme_umops_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_umops_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_umops_wide aarch64_sme_umops_wide::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
}
|
|
|
|
void aarch64_sme_umops_wide::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
assert(operands.size() == 4u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.useProperties(const_cast<Properties&>(properties));
|
|
odsState.addAttributes(discardableAttributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_umops_wide aarch64_sme_umops_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_umops_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_umops_wide aarch64_sme_umops_wide::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_umops_wide::verifyInvariantsImpl() {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitOpError("requires attribute 'tile_id'");
|
|
|
|
if (::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(*this, tblgen_tile_id, "tile_id")))
|
|
return ::mlir::failure();
|
|
{
|
|
unsigned index = 0; (void)index;
|
|
auto valueGroup0 = getODSOperands(0);
|
|
|
|
for (auto v : valueGroup0) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps5(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup1 = getODSOperands(1);
|
|
|
|
for (auto v : valueGroup1) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps5(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup2 = getODSOperands(2);
|
|
|
|
for (auto v : valueGroup2) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps6(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup3 = getODSOperands(3);
|
|
|
|
for (auto v : valueGroup3) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps6(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_umops_wide::verifyInvariants() {
|
|
return verifyInvariantsImpl();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_umops_wide::setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
// keep track of used keys in the input dictionary to be able to error out
|
|
// if there are some unknown ones.
|
|
::mlir::DenseSet<::mlir::StringAttr> usedKeys;
|
|
::mlir::MLIRContext *ctx = dict.getContext();
|
|
(void)ctx;
|
|
{
|
|
|
|
auto &propStorage = prop.tile_id;
|
|
auto tile_idAttrName = ::mlir::StringAttr::get(ctx, "tile_id");
|
|
auto attr = dict.get(tile_idAttrName);
|
|
usedKeys.insert(tile_idAttrName);
|
|
if (attr || /*isRequired=*/true) {
|
|
if (!attr) {
|
|
emitError() << "expected key entry for tile_id in DictionaryAttr to set "
|
|
"Properties.";
|
|
return ::mlir::failure();
|
|
}
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
|
|
for (::mlir::NamedAttribute attr : dict) {
|
|
if (!usedKeys.contains(attr.getName()))
|
|
return emitError() << "unknown key '" << attr.getName() <<
|
|
"' when parsing properties dictionary";
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
|
|
} // namespace mlir::arm_sme
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::aarch64_sme_umops_wide)
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::detail::aarch64_sme_umops_wideGenericAdaptorBase::Properties)
|
|
|
|
namespace mlir::arm_sme {
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ::mlir::arm_sme::aarch64_sme_umops_za32 definitions
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace detail {
|
|
|
|
aarch64_sme_umops_za32GenericAdaptorBase::aarch64_sme_umops_za32GenericAdaptorBase(aarch64_sme_umops_za32 op) : odsAttrs(op->getRawDictionaryAttrs()), odsOpName(op->getName()), properties(op.getProperties()), odsRegions(op->getRegions()) {}
|
|
|
|
uint32_t aarch64_sme_umops_za32GenericAdaptorBase::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
|
|
} // namespace detail
|
|
aarch64_sme_umops_za32Adaptor::aarch64_sme_umops_za32Adaptor(aarch64_sme_umops_za32 op) : aarch64_sme_umops_za32GenericAdaptor(op->getOperands(), op) {}
|
|
|
|
::llvm::LogicalResult aarch64_sme_umops_za32Adaptor::verify(::mlir::Location loc) {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitError(loc, "'arm_sme.intr.umops.za32' op requires attribute 'tile_id'");
|
|
|
|
if (tblgen_tile_id && !(((::llvm::isa<::mlir::IntegerAttr>(tblgen_tile_id))) && ((::llvm::cast<::mlir::IntegerAttr>(tblgen_tile_id).getType().isSignlessInteger(32)))))
|
|
return emitError(loc, "'arm_sme.intr.umops.za32' op attribute 'tile_id' failed to satisfy constraint: 32-bit signless integer attribute");
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_umops_za32::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
|
|
{
|
|
auto &propStorage = prop.tile_id;
|
|
auto attr = dict.get("tile_id");
|
|
if (attr) {
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::mlir::Attribute aarch64_sme_umops_za32::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) {
|
|
::mlir::SmallVector<::mlir::NamedAttribute> attrs;
|
|
::mlir::Builder odsBuilder{ctx};
|
|
|
|
{
|
|
const auto &propStorage = prop.tile_id;
|
|
if (propStorage)
|
|
attrs.push_back(odsBuilder.getNamedAttr("tile_id",
|
|
propStorage));
|
|
}
|
|
|
|
if (!attrs.empty())
|
|
return odsBuilder.getDictionaryAttr(attrs);
|
|
return {};
|
|
}
|
|
|
|
llvm::hash_code aarch64_sme_umops_za32::computePropertiesHash(const Properties &prop) {
|
|
using llvm::hash_value;
|
|
return llvm::hash_combine(
|
|
llvm::hash_value(prop.tile_id.getAsOpaquePointer()));
|
|
}
|
|
|
|
std::optional<mlir::Attribute> aarch64_sme_umops_za32::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) {
|
|
if (name == "tile_id")
|
|
return prop.tile_id;
|
|
return std::nullopt;
|
|
}
|
|
|
|
void aarch64_sme_umops_za32::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) {
|
|
if (name == "tile_id") {
|
|
prop.tile_id = ::llvm::dyn_cast_or_null<std::remove_reference_t<decltype(prop.tile_id)>>(value);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void aarch64_sme_umops_za32::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) {
|
|
if (prop.tile_id) attrs.append("tile_id", prop.tile_id);
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_umops_za32::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
{
|
|
::mlir::Attribute attr = attrs.get(getTileIdAttrName(opName));
|
|
if (attr && ::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(attr, "tile_id", emitError)))
|
|
return ::mlir::failure();
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_umops_za32::readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state) {
|
|
auto &prop = state.getOrAddProperties<Properties>(); (void)prop;
|
|
if (::mlir::failed(reader.readAttribute(prop.tile_id)))
|
|
return ::mlir::failure();
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_umops_za32::writeProperties(::mlir::DialectBytecodeWriter &writer) {
|
|
auto &prop = getProperties(); (void)prop;
|
|
writer.writeAttribute(prop.tile_id);
|
|
}
|
|
|
|
uint32_t aarch64_sme_umops_za32::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
void aarch64_sme_umops_za32::setTileId(uint32_t attrValue) {
|
|
getProperties().tile_id = ::mlir::Builder((*this)->getContext()).getIntegerAttr(::mlir::Builder((*this)->getContext()).getIntegerType(32), attrValue);
|
|
}
|
|
|
|
void aarch64_sme_umops_za32::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
}
|
|
|
|
aarch64_sme_umops_za32 aarch64_sme_umops_za32::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_umops_za32>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_umops_za32 aarch64_sme_umops_za32::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_umops_za32::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_umops_za32 aarch64_sme_umops_za32::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_umops_za32>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_umops_za32 aarch64_sme_umops_za32::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_umops_za32::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
}
|
|
|
|
aarch64_sme_umops_za32 aarch64_sme_umops_za32::create(::mlir::OpBuilder &builder, ::mlir::Location location, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_umops_za32>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_umops_za32 aarch64_sme_umops_za32::create(::mlir::ImplicitLocOpBuilder &builder, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_umops_za32::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_umops_za32 aarch64_sme_umops_za32::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_umops_za32>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_umops_za32 aarch64_sme_umops_za32::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_umops_za32::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
assert(operands.size() == 4u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.addAttributes(attributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
|
|
if (!attributes.empty()) {
|
|
(void)odsState.getOrAddProperties<aarch64_sme_umops_za32::Properties>();
|
|
::mlir::PropertyRef properties = odsState.getRawProperties();
|
|
std::optional<::mlir::RegisteredOperationName> info =
|
|
odsState.name.getRegisteredInfo();
|
|
if (failed(info->setOpPropertiesFromAttribute(odsState.name, properties,
|
|
odsState.attributes.getDictionary(odsState.getContext()), nullptr)))
|
|
::llvm::report_fatal_error("Property conversion failed.");
|
|
}
|
|
}
|
|
|
|
aarch64_sme_umops_za32 aarch64_sme_umops_za32::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_umops_za32>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_umops_za32 aarch64_sme_umops_za32::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
}
|
|
|
|
void aarch64_sme_umops_za32::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
assert(operands.size() == 4u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.useProperties(const_cast<Properties&>(properties));
|
|
odsState.addAttributes(discardableAttributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_umops_za32 aarch64_sme_umops_za32::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_umops_za32>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_umops_za32 aarch64_sme_umops_za32::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_umops_za32::verifyInvariantsImpl() {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitOpError("requires attribute 'tile_id'");
|
|
|
|
if (::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(*this, tblgen_tile_id, "tile_id")))
|
|
return ::mlir::failure();
|
|
{
|
|
unsigned index = 0; (void)index;
|
|
auto valueGroup0 = getODSOperands(0);
|
|
|
|
for (auto v : valueGroup0) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps5(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup1 = getODSOperands(1);
|
|
|
|
for (auto v : valueGroup1) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps5(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup2 = getODSOperands(2);
|
|
|
|
for (auto v : valueGroup2) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps6(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup3 = getODSOperands(3);
|
|
|
|
for (auto v : valueGroup3) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps6(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_umops_za32::verifyInvariants() {
|
|
return verifyInvariantsImpl();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_umops_za32::setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
// keep track of used keys in the input dictionary to be able to error out
|
|
// if there are some unknown ones.
|
|
::mlir::DenseSet<::mlir::StringAttr> usedKeys;
|
|
::mlir::MLIRContext *ctx = dict.getContext();
|
|
(void)ctx;
|
|
{
|
|
|
|
auto &propStorage = prop.tile_id;
|
|
auto tile_idAttrName = ::mlir::StringAttr::get(ctx, "tile_id");
|
|
auto attr = dict.get(tile_idAttrName);
|
|
usedKeys.insert(tile_idAttrName);
|
|
if (attr || /*isRequired=*/true) {
|
|
if (!attr) {
|
|
emitError() << "expected key entry for tile_id in DictionaryAttr to set "
|
|
"Properties.";
|
|
return ::mlir::failure();
|
|
}
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
|
|
for (::mlir::NamedAttribute attr : dict) {
|
|
if (!usedKeys.contains(attr.getName()))
|
|
return emitError() << "unknown key '" << attr.getName() <<
|
|
"' when parsing properties dictionary";
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
|
|
} // namespace mlir::arm_sme
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::aarch64_sme_umops_za32)
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::detail::aarch64_sme_umops_za32GenericAdaptorBase::Properties)
|
|
|
|
namespace mlir::arm_sme {
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ::mlir::arm_sme::aarch64_sme_usmopa_wide definitions
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace detail {
|
|
|
|
aarch64_sme_usmopa_wideGenericAdaptorBase::aarch64_sme_usmopa_wideGenericAdaptorBase(aarch64_sme_usmopa_wide op) : odsAttrs(op->getRawDictionaryAttrs()), odsOpName(op->getName()), properties(op.getProperties()), odsRegions(op->getRegions()) {}
|
|
|
|
uint32_t aarch64_sme_usmopa_wideGenericAdaptorBase::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
|
|
} // namespace detail
|
|
aarch64_sme_usmopa_wideAdaptor::aarch64_sme_usmopa_wideAdaptor(aarch64_sme_usmopa_wide op) : aarch64_sme_usmopa_wideGenericAdaptor(op->getOperands(), op) {}
|
|
|
|
::llvm::LogicalResult aarch64_sme_usmopa_wideAdaptor::verify(::mlir::Location loc) {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitError(loc, "'arm_sme.intr.usmopa.wide' op requires attribute 'tile_id'");
|
|
|
|
if (tblgen_tile_id && !(((::llvm::isa<::mlir::IntegerAttr>(tblgen_tile_id))) && ((::llvm::cast<::mlir::IntegerAttr>(tblgen_tile_id).getType().isSignlessInteger(32)))))
|
|
return emitError(loc, "'arm_sme.intr.usmopa.wide' op attribute 'tile_id' failed to satisfy constraint: 32-bit signless integer attribute");
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_usmopa_wide::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
|
|
{
|
|
auto &propStorage = prop.tile_id;
|
|
auto attr = dict.get("tile_id");
|
|
if (attr) {
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::mlir::Attribute aarch64_sme_usmopa_wide::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) {
|
|
::mlir::SmallVector<::mlir::NamedAttribute> attrs;
|
|
::mlir::Builder odsBuilder{ctx};
|
|
|
|
{
|
|
const auto &propStorage = prop.tile_id;
|
|
if (propStorage)
|
|
attrs.push_back(odsBuilder.getNamedAttr("tile_id",
|
|
propStorage));
|
|
}
|
|
|
|
if (!attrs.empty())
|
|
return odsBuilder.getDictionaryAttr(attrs);
|
|
return {};
|
|
}
|
|
|
|
llvm::hash_code aarch64_sme_usmopa_wide::computePropertiesHash(const Properties &prop) {
|
|
using llvm::hash_value;
|
|
return llvm::hash_combine(
|
|
llvm::hash_value(prop.tile_id.getAsOpaquePointer()));
|
|
}
|
|
|
|
std::optional<mlir::Attribute> aarch64_sme_usmopa_wide::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) {
|
|
if (name == "tile_id")
|
|
return prop.tile_id;
|
|
return std::nullopt;
|
|
}
|
|
|
|
void aarch64_sme_usmopa_wide::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) {
|
|
if (name == "tile_id") {
|
|
prop.tile_id = ::llvm::dyn_cast_or_null<std::remove_reference_t<decltype(prop.tile_id)>>(value);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void aarch64_sme_usmopa_wide::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) {
|
|
if (prop.tile_id) attrs.append("tile_id", prop.tile_id);
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_usmopa_wide::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
{
|
|
::mlir::Attribute attr = attrs.get(getTileIdAttrName(opName));
|
|
if (attr && ::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(attr, "tile_id", emitError)))
|
|
return ::mlir::failure();
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_usmopa_wide::readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state) {
|
|
auto &prop = state.getOrAddProperties<Properties>(); (void)prop;
|
|
if (::mlir::failed(reader.readAttribute(prop.tile_id)))
|
|
return ::mlir::failure();
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_usmopa_wide::writeProperties(::mlir::DialectBytecodeWriter &writer) {
|
|
auto &prop = getProperties(); (void)prop;
|
|
writer.writeAttribute(prop.tile_id);
|
|
}
|
|
|
|
uint32_t aarch64_sme_usmopa_wide::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
void aarch64_sme_usmopa_wide::setTileId(uint32_t attrValue) {
|
|
getProperties().tile_id = ::mlir::Builder((*this)->getContext()).getIntegerAttr(::mlir::Builder((*this)->getContext()).getIntegerType(32), attrValue);
|
|
}
|
|
|
|
void aarch64_sme_usmopa_wide::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
}
|
|
|
|
aarch64_sme_usmopa_wide aarch64_sme_usmopa_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_usmopa_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_usmopa_wide aarch64_sme_usmopa_wide::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_usmopa_wide::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_usmopa_wide aarch64_sme_usmopa_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_usmopa_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_usmopa_wide aarch64_sme_usmopa_wide::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_usmopa_wide::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
}
|
|
|
|
aarch64_sme_usmopa_wide aarch64_sme_usmopa_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_usmopa_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_usmopa_wide aarch64_sme_usmopa_wide::create(::mlir::ImplicitLocOpBuilder &builder, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_usmopa_wide::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_usmopa_wide aarch64_sme_usmopa_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_usmopa_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_usmopa_wide aarch64_sme_usmopa_wide::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_usmopa_wide::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
assert(operands.size() == 4u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.addAttributes(attributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
|
|
if (!attributes.empty()) {
|
|
(void)odsState.getOrAddProperties<aarch64_sme_usmopa_wide::Properties>();
|
|
::mlir::PropertyRef properties = odsState.getRawProperties();
|
|
std::optional<::mlir::RegisteredOperationName> info =
|
|
odsState.name.getRegisteredInfo();
|
|
if (failed(info->setOpPropertiesFromAttribute(odsState.name, properties,
|
|
odsState.attributes.getDictionary(odsState.getContext()), nullptr)))
|
|
::llvm::report_fatal_error("Property conversion failed.");
|
|
}
|
|
}
|
|
|
|
aarch64_sme_usmopa_wide aarch64_sme_usmopa_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_usmopa_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_usmopa_wide aarch64_sme_usmopa_wide::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
}
|
|
|
|
void aarch64_sme_usmopa_wide::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
assert(operands.size() == 4u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.useProperties(const_cast<Properties&>(properties));
|
|
odsState.addAttributes(discardableAttributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_usmopa_wide aarch64_sme_usmopa_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_usmopa_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_usmopa_wide aarch64_sme_usmopa_wide::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_usmopa_wide::verifyInvariantsImpl() {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitOpError("requires attribute 'tile_id'");
|
|
|
|
if (::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(*this, tblgen_tile_id, "tile_id")))
|
|
return ::mlir::failure();
|
|
{
|
|
unsigned index = 0; (void)index;
|
|
auto valueGroup0 = getODSOperands(0);
|
|
|
|
for (auto v : valueGroup0) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps5(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup1 = getODSOperands(1);
|
|
|
|
for (auto v : valueGroup1) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps5(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup2 = getODSOperands(2);
|
|
|
|
for (auto v : valueGroup2) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps6(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup3 = getODSOperands(3);
|
|
|
|
for (auto v : valueGroup3) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps6(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_usmopa_wide::verifyInvariants() {
|
|
return verifyInvariantsImpl();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_usmopa_wide::setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
// keep track of used keys in the input dictionary to be able to error out
|
|
// if there are some unknown ones.
|
|
::mlir::DenseSet<::mlir::StringAttr> usedKeys;
|
|
::mlir::MLIRContext *ctx = dict.getContext();
|
|
(void)ctx;
|
|
{
|
|
|
|
auto &propStorage = prop.tile_id;
|
|
auto tile_idAttrName = ::mlir::StringAttr::get(ctx, "tile_id");
|
|
auto attr = dict.get(tile_idAttrName);
|
|
usedKeys.insert(tile_idAttrName);
|
|
if (attr || /*isRequired=*/true) {
|
|
if (!attr) {
|
|
emitError() << "expected key entry for tile_id in DictionaryAttr to set "
|
|
"Properties.";
|
|
return ::mlir::failure();
|
|
}
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
|
|
for (::mlir::NamedAttribute attr : dict) {
|
|
if (!usedKeys.contains(attr.getName()))
|
|
return emitError() << "unknown key '" << attr.getName() <<
|
|
"' when parsing properties dictionary";
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
|
|
} // namespace mlir::arm_sme
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::aarch64_sme_usmopa_wide)
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::detail::aarch64_sme_usmopa_wideGenericAdaptorBase::Properties)
|
|
|
|
namespace mlir::arm_sme {
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ::mlir::arm_sme::aarch64_sme_usmops_wide definitions
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace detail {
|
|
|
|
aarch64_sme_usmops_wideGenericAdaptorBase::aarch64_sme_usmops_wideGenericAdaptorBase(aarch64_sme_usmops_wide op) : odsAttrs(op->getRawDictionaryAttrs()), odsOpName(op->getName()), properties(op.getProperties()), odsRegions(op->getRegions()) {}
|
|
|
|
uint32_t aarch64_sme_usmops_wideGenericAdaptorBase::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
|
|
} // namespace detail
|
|
aarch64_sme_usmops_wideAdaptor::aarch64_sme_usmops_wideAdaptor(aarch64_sme_usmops_wide op) : aarch64_sme_usmops_wideGenericAdaptor(op->getOperands(), op) {}
|
|
|
|
::llvm::LogicalResult aarch64_sme_usmops_wideAdaptor::verify(::mlir::Location loc) {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitError(loc, "'arm_sme.intr.usmops.wide' op requires attribute 'tile_id'");
|
|
|
|
if (tblgen_tile_id && !(((::llvm::isa<::mlir::IntegerAttr>(tblgen_tile_id))) && ((::llvm::cast<::mlir::IntegerAttr>(tblgen_tile_id).getType().isSignlessInteger(32)))))
|
|
return emitError(loc, "'arm_sme.intr.usmops.wide' op attribute 'tile_id' failed to satisfy constraint: 32-bit signless integer attribute");
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_usmops_wide::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
|
|
{
|
|
auto &propStorage = prop.tile_id;
|
|
auto attr = dict.get("tile_id");
|
|
if (attr) {
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::mlir::Attribute aarch64_sme_usmops_wide::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) {
|
|
::mlir::SmallVector<::mlir::NamedAttribute> attrs;
|
|
::mlir::Builder odsBuilder{ctx};
|
|
|
|
{
|
|
const auto &propStorage = prop.tile_id;
|
|
if (propStorage)
|
|
attrs.push_back(odsBuilder.getNamedAttr("tile_id",
|
|
propStorage));
|
|
}
|
|
|
|
if (!attrs.empty())
|
|
return odsBuilder.getDictionaryAttr(attrs);
|
|
return {};
|
|
}
|
|
|
|
llvm::hash_code aarch64_sme_usmops_wide::computePropertiesHash(const Properties &prop) {
|
|
using llvm::hash_value;
|
|
return llvm::hash_combine(
|
|
llvm::hash_value(prop.tile_id.getAsOpaquePointer()));
|
|
}
|
|
|
|
std::optional<mlir::Attribute> aarch64_sme_usmops_wide::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) {
|
|
if (name == "tile_id")
|
|
return prop.tile_id;
|
|
return std::nullopt;
|
|
}
|
|
|
|
void aarch64_sme_usmops_wide::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) {
|
|
if (name == "tile_id") {
|
|
prop.tile_id = ::llvm::dyn_cast_or_null<std::remove_reference_t<decltype(prop.tile_id)>>(value);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void aarch64_sme_usmops_wide::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) {
|
|
if (prop.tile_id) attrs.append("tile_id", prop.tile_id);
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_usmops_wide::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
{
|
|
::mlir::Attribute attr = attrs.get(getTileIdAttrName(opName));
|
|
if (attr && ::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(attr, "tile_id", emitError)))
|
|
return ::mlir::failure();
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_usmops_wide::readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state) {
|
|
auto &prop = state.getOrAddProperties<Properties>(); (void)prop;
|
|
if (::mlir::failed(reader.readAttribute(prop.tile_id)))
|
|
return ::mlir::failure();
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_usmops_wide::writeProperties(::mlir::DialectBytecodeWriter &writer) {
|
|
auto &prop = getProperties(); (void)prop;
|
|
writer.writeAttribute(prop.tile_id);
|
|
}
|
|
|
|
uint32_t aarch64_sme_usmops_wide::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
void aarch64_sme_usmops_wide::setTileId(uint32_t attrValue) {
|
|
getProperties().tile_id = ::mlir::Builder((*this)->getContext()).getIntegerAttr(::mlir::Builder((*this)->getContext()).getIntegerType(32), attrValue);
|
|
}
|
|
|
|
void aarch64_sme_usmops_wide::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
}
|
|
|
|
aarch64_sme_usmops_wide aarch64_sme_usmops_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_usmops_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_usmops_wide aarch64_sme_usmops_wide::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_usmops_wide::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_usmops_wide aarch64_sme_usmops_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_usmops_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_usmops_wide aarch64_sme_usmops_wide::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_usmops_wide::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
}
|
|
|
|
aarch64_sme_usmops_wide aarch64_sme_usmops_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_usmops_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_usmops_wide aarch64_sme_usmops_wide::create(::mlir::ImplicitLocOpBuilder &builder, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_usmops_wide::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
odsState.addOperands(lhs_predicate);
|
|
odsState.addOperands(rhs_predicate);
|
|
odsState.addOperands(lhs_vector);
|
|
odsState.addOperands(rhs_vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_usmops_wide aarch64_sme_usmops_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_usmops_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_usmops_wide aarch64_sme_usmops_wide::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value lhs_predicate, ::mlir::Value rhs_predicate, ::mlir::Value lhs_vector, ::mlir::Value rhs_vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(lhs_predicate)>(lhs_predicate), std::forward<decltype(rhs_predicate)>(rhs_predicate), std::forward<decltype(lhs_vector)>(lhs_vector), std::forward<decltype(rhs_vector)>(rhs_vector));
|
|
}
|
|
|
|
void aarch64_sme_usmops_wide::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
assert(operands.size() == 4u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.addAttributes(attributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
|
|
if (!attributes.empty()) {
|
|
(void)odsState.getOrAddProperties<aarch64_sme_usmops_wide::Properties>();
|
|
::mlir::PropertyRef properties = odsState.getRawProperties();
|
|
std::optional<::mlir::RegisteredOperationName> info =
|
|
odsState.name.getRegisteredInfo();
|
|
if (failed(info->setOpPropertiesFromAttribute(odsState.name, properties,
|
|
odsState.attributes.getDictionary(odsState.getContext()), nullptr)))
|
|
::llvm::report_fatal_error("Property conversion failed.");
|
|
}
|
|
}
|
|
|
|
aarch64_sme_usmops_wide aarch64_sme_usmops_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_usmops_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_usmops_wide aarch64_sme_usmops_wide::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
}
|
|
|
|
void aarch64_sme_usmops_wide::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
assert(operands.size() == 4u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.useProperties(const_cast<Properties&>(properties));
|
|
odsState.addAttributes(discardableAttributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_usmops_wide aarch64_sme_usmops_wide::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_usmops_wide>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_usmops_wide aarch64_sme_usmops_wide::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_usmops_wide::verifyInvariantsImpl() {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitOpError("requires attribute 'tile_id'");
|
|
|
|
if (::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(*this, tblgen_tile_id, "tile_id")))
|
|
return ::mlir::failure();
|
|
{
|
|
unsigned index = 0; (void)index;
|
|
auto valueGroup0 = getODSOperands(0);
|
|
|
|
for (auto v : valueGroup0) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps5(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup1 = getODSOperands(1);
|
|
|
|
for (auto v : valueGroup1) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps5(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup2 = getODSOperands(2);
|
|
|
|
for (auto v : valueGroup2) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps6(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup3 = getODSOperands(3);
|
|
|
|
for (auto v : valueGroup3) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps6(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_usmops_wide::verifyInvariants() {
|
|
return verifyInvariantsImpl();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_usmops_wide::setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
// keep track of used keys in the input dictionary to be able to error out
|
|
// if there are some unknown ones.
|
|
::mlir::DenseSet<::mlir::StringAttr> usedKeys;
|
|
::mlir::MLIRContext *ctx = dict.getContext();
|
|
(void)ctx;
|
|
{
|
|
|
|
auto &propStorage = prop.tile_id;
|
|
auto tile_idAttrName = ::mlir::StringAttr::get(ctx, "tile_id");
|
|
auto attr = dict.get(tile_idAttrName);
|
|
usedKeys.insert(tile_idAttrName);
|
|
if (attr || /*isRequired=*/true) {
|
|
if (!attr) {
|
|
emitError() << "expected key entry for tile_id in DictionaryAttr to set "
|
|
"Properties.";
|
|
return ::mlir::failure();
|
|
}
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
|
|
for (::mlir::NamedAttribute attr : dict) {
|
|
if (!usedKeys.contains(attr.getName()))
|
|
return emitError() << "unknown key '" << attr.getName() <<
|
|
"' when parsing properties dictionary";
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
|
|
} // namespace mlir::arm_sme
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::aarch64_sme_usmops_wide)
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::detail::aarch64_sme_usmops_wideGenericAdaptorBase::Properties)
|
|
|
|
namespace mlir::arm_sme {
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ::mlir::arm_sme::aarch64_sme_write_horiz definitions
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace detail {
|
|
|
|
aarch64_sme_write_horizGenericAdaptorBase::aarch64_sme_write_horizGenericAdaptorBase(aarch64_sme_write_horiz op) : odsAttrs(op->getRawDictionaryAttrs()), odsOpName(op->getName()), properties(op.getProperties()), odsRegions(op->getRegions()) {}
|
|
|
|
uint32_t aarch64_sme_write_horizGenericAdaptorBase::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
|
|
} // namespace detail
|
|
aarch64_sme_write_horizAdaptor::aarch64_sme_write_horizAdaptor(aarch64_sme_write_horiz op) : aarch64_sme_write_horizGenericAdaptor(op->getOperands(), op) {}
|
|
|
|
::llvm::LogicalResult aarch64_sme_write_horizAdaptor::verify(::mlir::Location loc) {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitError(loc, "'arm_sme.intr.write.horiz' op requires attribute 'tile_id'");
|
|
|
|
if (tblgen_tile_id && !(((::llvm::isa<::mlir::IntegerAttr>(tblgen_tile_id))) && ((::llvm::cast<::mlir::IntegerAttr>(tblgen_tile_id).getType().isSignlessInteger(32)))))
|
|
return emitError(loc, "'arm_sme.intr.write.horiz' op attribute 'tile_id' failed to satisfy constraint: 32-bit signless integer attribute");
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_write_horiz::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
|
|
{
|
|
auto &propStorage = prop.tile_id;
|
|
auto attr = dict.get("tile_id");
|
|
if (attr) {
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::mlir::Attribute aarch64_sme_write_horiz::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) {
|
|
::mlir::SmallVector<::mlir::NamedAttribute> attrs;
|
|
::mlir::Builder odsBuilder{ctx};
|
|
|
|
{
|
|
const auto &propStorage = prop.tile_id;
|
|
if (propStorage)
|
|
attrs.push_back(odsBuilder.getNamedAttr("tile_id",
|
|
propStorage));
|
|
}
|
|
|
|
if (!attrs.empty())
|
|
return odsBuilder.getDictionaryAttr(attrs);
|
|
return {};
|
|
}
|
|
|
|
llvm::hash_code aarch64_sme_write_horiz::computePropertiesHash(const Properties &prop) {
|
|
using llvm::hash_value;
|
|
return llvm::hash_combine(
|
|
llvm::hash_value(prop.tile_id.getAsOpaquePointer()));
|
|
}
|
|
|
|
std::optional<mlir::Attribute> aarch64_sme_write_horiz::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) {
|
|
if (name == "tile_id")
|
|
return prop.tile_id;
|
|
return std::nullopt;
|
|
}
|
|
|
|
void aarch64_sme_write_horiz::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) {
|
|
if (name == "tile_id") {
|
|
prop.tile_id = ::llvm::dyn_cast_or_null<std::remove_reference_t<decltype(prop.tile_id)>>(value);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void aarch64_sme_write_horiz::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) {
|
|
if (prop.tile_id) attrs.append("tile_id", prop.tile_id);
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_write_horiz::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
{
|
|
::mlir::Attribute attr = attrs.get(getTileIdAttrName(opName));
|
|
if (attr && ::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(attr, "tile_id", emitError)))
|
|
return ::mlir::failure();
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_write_horiz::readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state) {
|
|
auto &prop = state.getOrAddProperties<Properties>(); (void)prop;
|
|
if (::mlir::failed(reader.readAttribute(prop.tile_id)))
|
|
return ::mlir::failure();
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_write_horiz::writeProperties(::mlir::DialectBytecodeWriter &writer) {
|
|
auto &prop = getProperties(); (void)prop;
|
|
writer.writeAttribute(prop.tile_id);
|
|
}
|
|
|
|
uint32_t aarch64_sme_write_horiz::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
void aarch64_sme_write_horiz::setTileId(uint32_t attrValue) {
|
|
getProperties().tile_id = ::mlir::Builder((*this)->getContext()).getIntegerAttr(::mlir::Builder((*this)->getContext()).getIntegerType(32), attrValue);
|
|
}
|
|
|
|
void aarch64_sme_write_horiz::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index, ::mlir::Value predicate, ::mlir::Value vector) {
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
}
|
|
|
|
aarch64_sme_write_horiz aarch64_sme_write_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index, ::mlir::Value predicate, ::mlir::Value vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index), std::forward<decltype(predicate)>(predicate), std::forward<decltype(vector)>(vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_write_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_write_horiz aarch64_sme_write_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index, ::mlir::Value predicate, ::mlir::Value vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index), std::forward<decltype(predicate)>(predicate), std::forward<decltype(vector)>(vector));
|
|
}
|
|
|
|
void aarch64_sme_write_horiz::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index, ::mlir::Value predicate, ::mlir::Value vector) {
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_write_horiz aarch64_sme_write_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index, ::mlir::Value predicate, ::mlir::Value vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index), std::forward<decltype(predicate)>(predicate), std::forward<decltype(vector)>(vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_write_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_write_horiz aarch64_sme_write_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index, ::mlir::Value predicate, ::mlir::Value vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index), std::forward<decltype(predicate)>(predicate), std::forward<decltype(vector)>(vector));
|
|
}
|
|
|
|
void aarch64_sme_write_horiz::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, uint32_t tile_id, ::mlir::Value tile_slice_index, ::mlir::Value predicate, ::mlir::Value vector) {
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
}
|
|
|
|
aarch64_sme_write_horiz aarch64_sme_write_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, uint32_t tile_id, ::mlir::Value tile_slice_index, ::mlir::Value predicate, ::mlir::Value vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index), std::forward<decltype(predicate)>(predicate), std::forward<decltype(vector)>(vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_write_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_write_horiz aarch64_sme_write_horiz::create(::mlir::ImplicitLocOpBuilder &builder, uint32_t tile_id, ::mlir::Value tile_slice_index, ::mlir::Value predicate, ::mlir::Value vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index), std::forward<decltype(predicate)>(predicate), std::forward<decltype(vector)>(vector));
|
|
}
|
|
|
|
void aarch64_sme_write_horiz::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value tile_slice_index, ::mlir::Value predicate, ::mlir::Value vector) {
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_write_horiz aarch64_sme_write_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value tile_slice_index, ::mlir::Value predicate, ::mlir::Value vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index), std::forward<decltype(predicate)>(predicate), std::forward<decltype(vector)>(vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_write_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_write_horiz aarch64_sme_write_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value tile_slice_index, ::mlir::Value predicate, ::mlir::Value vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index), std::forward<decltype(predicate)>(predicate), std::forward<decltype(vector)>(vector));
|
|
}
|
|
|
|
void aarch64_sme_write_horiz::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
assert(operands.size() == 3u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.addAttributes(attributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
|
|
if (!attributes.empty()) {
|
|
(void)odsState.getOrAddProperties<aarch64_sme_write_horiz::Properties>();
|
|
::mlir::PropertyRef properties = odsState.getRawProperties();
|
|
std::optional<::mlir::RegisteredOperationName> info =
|
|
odsState.name.getRegisteredInfo();
|
|
if (failed(info->setOpPropertiesFromAttribute(odsState.name, properties,
|
|
odsState.attributes.getDictionary(odsState.getContext()), nullptr)))
|
|
::llvm::report_fatal_error("Property conversion failed.");
|
|
}
|
|
}
|
|
|
|
aarch64_sme_write_horiz aarch64_sme_write_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_write_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_write_horiz aarch64_sme_write_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
}
|
|
|
|
void aarch64_sme_write_horiz::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
assert(operands.size() == 3u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.useProperties(const_cast<Properties&>(properties));
|
|
odsState.addAttributes(discardableAttributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_write_horiz aarch64_sme_write_horiz::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_write_horiz>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_write_horiz aarch64_sme_write_horiz::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_write_horiz::verifyInvariantsImpl() {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitOpError("requires attribute 'tile_id'");
|
|
|
|
if (::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(*this, tblgen_tile_id, "tile_id")))
|
|
return ::mlir::failure();
|
|
{
|
|
unsigned index = 0; (void)index;
|
|
auto valueGroup0 = getODSOperands(0);
|
|
|
|
for (auto v : valueGroup0) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps4(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup1 = getODSOperands(1);
|
|
|
|
for (auto v : valueGroup1) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps2(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup2 = getODSOperands(2);
|
|
|
|
for (auto v : valueGroup2) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps7(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
if (!(((::llvm::cast<::mlir::ShapedType>((*this->getODSOperands(1).begin()).getType()).getShape()) == (::llvm::cast<::mlir::ShapedType>((*this->getODSOperands(2).begin()).getType()).getShape()) && (::llvm::cast<::mlir::ShapedType>((*this->getODSOperands(2).begin()).getType()).getShape()) == (::llvm::cast<::mlir::ShapedType>((*this->getODSOperands(1).begin()).getType()).getShape()))))
|
|
return emitOpError("failed to verify that all of {predicate, vector} have same shape");
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_write_horiz::verifyInvariants() {
|
|
return verifyInvariantsImpl();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_write_horiz::setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
// keep track of used keys in the input dictionary to be able to error out
|
|
// if there are some unknown ones.
|
|
::mlir::DenseSet<::mlir::StringAttr> usedKeys;
|
|
::mlir::MLIRContext *ctx = dict.getContext();
|
|
(void)ctx;
|
|
{
|
|
|
|
auto &propStorage = prop.tile_id;
|
|
auto tile_idAttrName = ::mlir::StringAttr::get(ctx, "tile_id");
|
|
auto attr = dict.get(tile_idAttrName);
|
|
usedKeys.insert(tile_idAttrName);
|
|
if (attr || /*isRequired=*/true) {
|
|
if (!attr) {
|
|
emitError() << "expected key entry for tile_id in DictionaryAttr to set "
|
|
"Properties.";
|
|
return ::mlir::failure();
|
|
}
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
|
|
for (::mlir::NamedAttribute attr : dict) {
|
|
if (!usedKeys.contains(attr.getName()))
|
|
return emitError() << "unknown key '" << attr.getName() <<
|
|
"' when parsing properties dictionary";
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
|
|
} // namespace mlir::arm_sme
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::aarch64_sme_write_horiz)
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::detail::aarch64_sme_write_horizGenericAdaptorBase::Properties)
|
|
|
|
namespace mlir::arm_sme {
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ::mlir::arm_sme::aarch64_sme_write_vert definitions
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace detail {
|
|
|
|
aarch64_sme_write_vertGenericAdaptorBase::aarch64_sme_write_vertGenericAdaptorBase(aarch64_sme_write_vert op) : odsAttrs(op->getRawDictionaryAttrs()), odsOpName(op->getName()), properties(op.getProperties()), odsRegions(op->getRegions()) {}
|
|
|
|
uint32_t aarch64_sme_write_vertGenericAdaptorBase::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
|
|
} // namespace detail
|
|
aarch64_sme_write_vertAdaptor::aarch64_sme_write_vertAdaptor(aarch64_sme_write_vert op) : aarch64_sme_write_vertGenericAdaptor(op->getOperands(), op) {}
|
|
|
|
::llvm::LogicalResult aarch64_sme_write_vertAdaptor::verify(::mlir::Location loc) {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitError(loc, "'arm_sme.intr.write.vert' op requires attribute 'tile_id'");
|
|
|
|
if (tblgen_tile_id && !(((::llvm::isa<::mlir::IntegerAttr>(tblgen_tile_id))) && ((::llvm::cast<::mlir::IntegerAttr>(tblgen_tile_id).getType().isSignlessInteger(32)))))
|
|
return emitError(loc, "'arm_sme.intr.write.vert' op attribute 'tile_id' failed to satisfy constraint: 32-bit signless integer attribute");
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_write_vert::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
|
|
{
|
|
auto &propStorage = prop.tile_id;
|
|
auto attr = dict.get("tile_id");
|
|
if (attr) {
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::mlir::Attribute aarch64_sme_write_vert::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) {
|
|
::mlir::SmallVector<::mlir::NamedAttribute> attrs;
|
|
::mlir::Builder odsBuilder{ctx};
|
|
|
|
{
|
|
const auto &propStorage = prop.tile_id;
|
|
if (propStorage)
|
|
attrs.push_back(odsBuilder.getNamedAttr("tile_id",
|
|
propStorage));
|
|
}
|
|
|
|
if (!attrs.empty())
|
|
return odsBuilder.getDictionaryAttr(attrs);
|
|
return {};
|
|
}
|
|
|
|
llvm::hash_code aarch64_sme_write_vert::computePropertiesHash(const Properties &prop) {
|
|
using llvm::hash_value;
|
|
return llvm::hash_combine(
|
|
llvm::hash_value(prop.tile_id.getAsOpaquePointer()));
|
|
}
|
|
|
|
std::optional<mlir::Attribute> aarch64_sme_write_vert::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) {
|
|
if (name == "tile_id")
|
|
return prop.tile_id;
|
|
return std::nullopt;
|
|
}
|
|
|
|
void aarch64_sme_write_vert::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) {
|
|
if (name == "tile_id") {
|
|
prop.tile_id = ::llvm::dyn_cast_or_null<std::remove_reference_t<decltype(prop.tile_id)>>(value);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void aarch64_sme_write_vert::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) {
|
|
if (prop.tile_id) attrs.append("tile_id", prop.tile_id);
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_write_vert::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
{
|
|
::mlir::Attribute attr = attrs.get(getTileIdAttrName(opName));
|
|
if (attr && ::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(attr, "tile_id", emitError)))
|
|
return ::mlir::failure();
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_write_vert::readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state) {
|
|
auto &prop = state.getOrAddProperties<Properties>(); (void)prop;
|
|
if (::mlir::failed(reader.readAttribute(prop.tile_id)))
|
|
return ::mlir::failure();
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_write_vert::writeProperties(::mlir::DialectBytecodeWriter &writer) {
|
|
auto &prop = getProperties(); (void)prop;
|
|
writer.writeAttribute(prop.tile_id);
|
|
}
|
|
|
|
uint32_t aarch64_sme_write_vert::getTileId() {
|
|
auto attr = getTileIdAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
void aarch64_sme_write_vert::setTileId(uint32_t attrValue) {
|
|
getProperties().tile_id = ::mlir::Builder((*this)->getContext()).getIntegerAttr(::mlir::Builder((*this)->getContext()).getIntegerType(32), attrValue);
|
|
}
|
|
|
|
void aarch64_sme_write_vert::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index, ::mlir::Value predicate, ::mlir::Value vector) {
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
}
|
|
|
|
aarch64_sme_write_vert aarch64_sme_write_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index, ::mlir::Value predicate, ::mlir::Value vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index), std::forward<decltype(predicate)>(predicate), std::forward<decltype(vector)>(vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_write_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_write_vert aarch64_sme_write_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index, ::mlir::Value predicate, ::mlir::Value vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index), std::forward<decltype(predicate)>(predicate), std::forward<decltype(vector)>(vector));
|
|
}
|
|
|
|
void aarch64_sme_write_vert::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index, ::mlir::Value predicate, ::mlir::Value vector) {
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = tile_id;
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_write_vert aarch64_sme_write_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index, ::mlir::Value predicate, ::mlir::Value vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index), std::forward<decltype(predicate)>(predicate), std::forward<decltype(vector)>(vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_write_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_write_vert aarch64_sme_write_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_id, ::mlir::Value tile_slice_index, ::mlir::Value predicate, ::mlir::Value vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index), std::forward<decltype(predicate)>(predicate), std::forward<decltype(vector)>(vector));
|
|
}
|
|
|
|
void aarch64_sme_write_vert::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, uint32_t tile_id, ::mlir::Value tile_slice_index, ::mlir::Value predicate, ::mlir::Value vector) {
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
}
|
|
|
|
aarch64_sme_write_vert aarch64_sme_write_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, uint32_t tile_id, ::mlir::Value tile_slice_index, ::mlir::Value predicate, ::mlir::Value vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index), std::forward<decltype(predicate)>(predicate), std::forward<decltype(vector)>(vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_write_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_write_vert aarch64_sme_write_vert::create(::mlir::ImplicitLocOpBuilder &builder, uint32_t tile_id, ::mlir::Value tile_slice_index, ::mlir::Value predicate, ::mlir::Value vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index), std::forward<decltype(predicate)>(predicate), std::forward<decltype(vector)>(vector));
|
|
}
|
|
|
|
void aarch64_sme_write_vert::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value tile_slice_index, ::mlir::Value predicate, ::mlir::Value vector) {
|
|
odsState.addOperands(tile_slice_index);
|
|
odsState.addOperands(predicate);
|
|
odsState.addOperands(vector);
|
|
odsState.getOrAddProperties<Properties>().tile_id = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_id);
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_write_vert aarch64_sme_write_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value tile_slice_index, ::mlir::Value predicate, ::mlir::Value vector) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index), std::forward<decltype(predicate)>(predicate), std::forward<decltype(vector)>(vector));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_write_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_write_vert aarch64_sme_write_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, uint32_t tile_id, ::mlir::Value tile_slice_index, ::mlir::Value predicate, ::mlir::Value vector) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_id)>(tile_id), std::forward<decltype(tile_slice_index)>(tile_slice_index), std::forward<decltype(predicate)>(predicate), std::forward<decltype(vector)>(vector));
|
|
}
|
|
|
|
void aarch64_sme_write_vert::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
assert(operands.size() == 3u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.addAttributes(attributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
|
|
if (!attributes.empty()) {
|
|
(void)odsState.getOrAddProperties<aarch64_sme_write_vert::Properties>();
|
|
::mlir::PropertyRef properties = odsState.getRawProperties();
|
|
std::optional<::mlir::RegisteredOperationName> info =
|
|
odsState.name.getRegisteredInfo();
|
|
if (failed(info->setOpPropertiesFromAttribute(odsState.name, properties,
|
|
odsState.attributes.getDictionary(odsState.getContext()), nullptr)))
|
|
::llvm::report_fatal_error("Property conversion failed.");
|
|
}
|
|
}
|
|
|
|
aarch64_sme_write_vert aarch64_sme_write_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_write_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_write_vert aarch64_sme_write_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
}
|
|
|
|
void aarch64_sme_write_vert::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
assert(operands.size() == 3u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.useProperties(const_cast<Properties&>(properties));
|
|
odsState.addAttributes(discardableAttributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_write_vert aarch64_sme_write_vert::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_write_vert>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_write_vert aarch64_sme_write_vert::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_write_vert::verifyInvariantsImpl() {
|
|
auto tblgen_tile_id = getProperties().tile_id; (void)tblgen_tile_id;
|
|
if (!tblgen_tile_id) return emitOpError("requires attribute 'tile_id'");
|
|
|
|
if (::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(*this, tblgen_tile_id, "tile_id")))
|
|
return ::mlir::failure();
|
|
{
|
|
unsigned index = 0; (void)index;
|
|
auto valueGroup0 = getODSOperands(0);
|
|
|
|
for (auto v : valueGroup0) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps4(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup1 = getODSOperands(1);
|
|
|
|
for (auto v : valueGroup1) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps2(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
auto valueGroup2 = getODSOperands(2);
|
|
|
|
for (auto v : valueGroup2) {
|
|
if (::mlir::failed(__mlir_ods_local_type_constraint_ArmSMEIntrinsicOps7(*this, v.getType(), "operand", index++)))
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
if (!(((::llvm::cast<::mlir::ShapedType>((*this->getODSOperands(1).begin()).getType()).getShape()) == (::llvm::cast<::mlir::ShapedType>((*this->getODSOperands(2).begin()).getType()).getShape()) && (::llvm::cast<::mlir::ShapedType>((*this->getODSOperands(2).begin()).getType()).getShape()) == (::llvm::cast<::mlir::ShapedType>((*this->getODSOperands(1).begin()).getType()).getShape()))))
|
|
return emitOpError("failed to verify that all of {predicate, vector} have same shape");
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_write_vert::verifyInvariants() {
|
|
return verifyInvariantsImpl();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_write_vert::setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
// keep track of used keys in the input dictionary to be able to error out
|
|
// if there are some unknown ones.
|
|
::mlir::DenseSet<::mlir::StringAttr> usedKeys;
|
|
::mlir::MLIRContext *ctx = dict.getContext();
|
|
(void)ctx;
|
|
{
|
|
|
|
auto &propStorage = prop.tile_id;
|
|
auto tile_idAttrName = ::mlir::StringAttr::get(ctx, "tile_id");
|
|
auto attr = dict.get(tile_idAttrName);
|
|
usedKeys.insert(tile_idAttrName);
|
|
if (attr || /*isRequired=*/true) {
|
|
if (!attr) {
|
|
emitError() << "expected key entry for tile_id in DictionaryAttr to set "
|
|
"Properties.";
|
|
return ::mlir::failure();
|
|
}
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_id` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
|
|
for (::mlir::NamedAttribute attr : dict) {
|
|
if (!usedKeys.contains(attr.getName()))
|
|
return emitError() << "unknown key '" << attr.getName() <<
|
|
"' when parsing properties dictionary";
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
|
|
} // namespace mlir::arm_sme
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::aarch64_sme_write_vert)
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::detail::aarch64_sme_write_vertGenericAdaptorBase::Properties)
|
|
|
|
namespace mlir::arm_sme {
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ::mlir::arm_sme::aarch64_sme_zero definitions
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace detail {
|
|
|
|
aarch64_sme_zeroGenericAdaptorBase::aarch64_sme_zeroGenericAdaptorBase(aarch64_sme_zero op) : odsAttrs(op->getRawDictionaryAttrs()), odsOpName(op->getName()), properties(op.getProperties()), odsRegions(op->getRegions()) {}
|
|
|
|
uint32_t aarch64_sme_zeroGenericAdaptorBase::getTileMask() {
|
|
auto attr = getTileMaskAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
|
|
} // namespace detail
|
|
aarch64_sme_zeroAdaptor::aarch64_sme_zeroAdaptor(aarch64_sme_zero op) : aarch64_sme_zeroGenericAdaptor(op->getOperands(), op) {}
|
|
|
|
::llvm::LogicalResult aarch64_sme_zeroAdaptor::verify(::mlir::Location loc) {
|
|
auto tblgen_tile_mask = getProperties().tile_mask; (void)tblgen_tile_mask;
|
|
if (!tblgen_tile_mask) return emitError(loc, "'arm_sme.intr.zero' op requires attribute 'tile_mask'");
|
|
|
|
if (tblgen_tile_mask && !(((::llvm::isa<::mlir::IntegerAttr>(tblgen_tile_mask))) && ((::llvm::cast<::mlir::IntegerAttr>(tblgen_tile_mask).getType().isSignlessInteger(32)))))
|
|
return emitError(loc, "'arm_sme.intr.zero' op attribute 'tile_mask' failed to satisfy constraint: 32-bit signless integer attribute");
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_zero::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
|
|
{
|
|
auto &propStorage = prop.tile_mask;
|
|
auto attr = dict.get("tile_mask");
|
|
if (attr) {
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_mask` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::mlir::Attribute aarch64_sme_zero::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) {
|
|
::mlir::SmallVector<::mlir::NamedAttribute> attrs;
|
|
::mlir::Builder odsBuilder{ctx};
|
|
|
|
{
|
|
const auto &propStorage = prop.tile_mask;
|
|
if (propStorage)
|
|
attrs.push_back(odsBuilder.getNamedAttr("tile_mask",
|
|
propStorage));
|
|
}
|
|
|
|
if (!attrs.empty())
|
|
return odsBuilder.getDictionaryAttr(attrs);
|
|
return {};
|
|
}
|
|
|
|
llvm::hash_code aarch64_sme_zero::computePropertiesHash(const Properties &prop) {
|
|
using llvm::hash_value;
|
|
return llvm::hash_combine(
|
|
llvm::hash_value(prop.tile_mask.getAsOpaquePointer()));
|
|
}
|
|
|
|
std::optional<mlir::Attribute> aarch64_sme_zero::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) {
|
|
if (name == "tile_mask")
|
|
return prop.tile_mask;
|
|
return std::nullopt;
|
|
}
|
|
|
|
void aarch64_sme_zero::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) {
|
|
if (name == "tile_mask") {
|
|
prop.tile_mask = ::llvm::dyn_cast_or_null<std::remove_reference_t<decltype(prop.tile_mask)>>(value);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void aarch64_sme_zero::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) {
|
|
if (prop.tile_mask) attrs.append("tile_mask", prop.tile_mask);
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_zero::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
{
|
|
::mlir::Attribute attr = attrs.get(getTileMaskAttrName(opName));
|
|
if (attr && ::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(attr, "tile_mask", emitError)))
|
|
return ::mlir::failure();
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_zero::readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state) {
|
|
auto &prop = state.getOrAddProperties<Properties>(); (void)prop;
|
|
if (::mlir::failed(reader.readAttribute(prop.tile_mask)))
|
|
return ::mlir::failure();
|
|
return ::mlir::success();
|
|
}
|
|
|
|
void aarch64_sme_zero::writeProperties(::mlir::DialectBytecodeWriter &writer) {
|
|
auto &prop = getProperties(); (void)prop;
|
|
writer.writeAttribute(prop.tile_mask);
|
|
}
|
|
|
|
uint32_t aarch64_sme_zero::getTileMask() {
|
|
auto attr = getTileMaskAttr();
|
|
return attr.getValue().getZExtValue();
|
|
}
|
|
|
|
void aarch64_sme_zero::setTileMask(uint32_t attrValue) {
|
|
getProperties().tile_mask = ::mlir::Builder((*this)->getContext()).getIntegerAttr(::mlir::Builder((*this)->getContext()).getIntegerType(32), attrValue);
|
|
}
|
|
|
|
void aarch64_sme_zero::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::IntegerAttr tile_mask) {
|
|
odsState.getOrAddProperties<Properties>().tile_mask = tile_mask;
|
|
}
|
|
|
|
aarch64_sme_zero aarch64_sme_zero::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::IntegerAttr tile_mask) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(tile_mask)>(tile_mask));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_zero>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_zero aarch64_sme_zero::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::IntegerAttr tile_mask) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(tile_mask)>(tile_mask));
|
|
}
|
|
|
|
void aarch64_sme_zero::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_mask) {
|
|
odsState.getOrAddProperties<Properties>().tile_mask = tile_mask;
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_zero aarch64_sme_zero::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_mask) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_mask)>(tile_mask));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_zero>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_zero aarch64_sme_zero::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr tile_mask) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_mask)>(tile_mask));
|
|
}
|
|
|
|
void aarch64_sme_zero::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, uint32_t tile_mask) {
|
|
odsState.getOrAddProperties<Properties>().tile_mask = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_mask);
|
|
}
|
|
|
|
aarch64_sme_zero aarch64_sme_zero::create(::mlir::OpBuilder &builder, ::mlir::Location location, uint32_t tile_mask) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(tile_mask)>(tile_mask));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_zero>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_zero aarch64_sme_zero::create(::mlir::ImplicitLocOpBuilder &builder, uint32_t tile_mask) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(tile_mask)>(tile_mask));
|
|
}
|
|
|
|
void aarch64_sme_zero::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, uint32_t tile_mask) {
|
|
odsState.getOrAddProperties<Properties>().tile_mask = odsBuilder.getIntegerAttr(odsBuilder.getIntegerType(32), tile_mask);
|
|
assert(resultTypes.size() == 0u && "mismatched number of results");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_zero aarch64_sme_zero::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, uint32_t tile_mask) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_mask)>(tile_mask));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_zero>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_zero aarch64_sme_zero::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, uint32_t tile_mask) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(tile_mask)>(tile_mask));
|
|
}
|
|
|
|
void aarch64_sme_zero::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
assert(operands.size() == 0u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.addAttributes(attributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
|
|
if (!attributes.empty()) {
|
|
(void)odsState.getOrAddProperties<aarch64_sme_zero::Properties>();
|
|
::mlir::PropertyRef properties = odsState.getRawProperties();
|
|
std::optional<::mlir::RegisteredOperationName> info =
|
|
odsState.name.getRegisteredInfo();
|
|
if (failed(info->setOpPropertiesFromAttribute(odsState.name, properties,
|
|
odsState.attributes.getDictionary(odsState.getContext()), nullptr)))
|
|
::llvm::report_fatal_error("Property conversion failed.");
|
|
}
|
|
}
|
|
|
|
aarch64_sme_zero aarch64_sme_zero::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_zero>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_zero aarch64_sme_zero::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(attributes)>(attributes));
|
|
}
|
|
|
|
void aarch64_sme_zero::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
assert(operands.size() == 0u && "mismatched number of parameters");
|
|
odsState.addOperands(operands);
|
|
odsState.useProperties(const_cast<Properties&>(properties));
|
|
odsState.addAttributes(discardableAttributes);
|
|
assert(resultTypes.size() == 0u && "mismatched number of return types");
|
|
odsState.addTypes(resultTypes);
|
|
}
|
|
|
|
aarch64_sme_zero aarch64_sme_zero::create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
::mlir::OperationState __state__(location, getOperationName());
|
|
build(builder, __state__, std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
auto __res__ = ::llvm::dyn_cast<aarch64_sme_zero>(builder.create(__state__));
|
|
assert(__res__ && "builder didn't return the right type");
|
|
return __res__;
|
|
}
|
|
|
|
aarch64_sme_zero aarch64_sme_zero::create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes) {
|
|
return create(builder, builder.getLoc(), std::forward<decltype(resultTypes)>(resultTypes), std::forward<decltype(operands)>(operands), std::forward<decltype(properties)>(properties), std::forward<decltype(discardableAttributes)>(discardableAttributes));
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_zero::verifyInvariantsImpl() {
|
|
auto tblgen_tile_mask = getProperties().tile_mask; (void)tblgen_tile_mask;
|
|
if (!tblgen_tile_mask) return emitOpError("requires attribute 'tile_mask'");
|
|
|
|
if (::mlir::failed(__mlir_ods_local_attr_constraint_ArmSMEIntrinsicOps1(*this, tblgen_tile_mask, "tile_mask")))
|
|
return ::mlir::failure();
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_zero::verifyInvariants() {
|
|
return verifyInvariantsImpl();
|
|
}
|
|
|
|
::llvm::LogicalResult aarch64_sme_zero::setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) {
|
|
::mlir::DictionaryAttr dict = ::llvm::dyn_cast<::mlir::DictionaryAttr>(attr);
|
|
if (!dict) {
|
|
emitError() << "expected DictionaryAttr to set properties";
|
|
return ::mlir::failure();
|
|
}
|
|
// keep track of used keys in the input dictionary to be able to error out
|
|
// if there are some unknown ones.
|
|
::mlir::DenseSet<::mlir::StringAttr> usedKeys;
|
|
::mlir::MLIRContext *ctx = dict.getContext();
|
|
(void)ctx;
|
|
{
|
|
|
|
auto &propStorage = prop.tile_mask;
|
|
auto tile_maskAttrName = ::mlir::StringAttr::get(ctx, "tile_mask");
|
|
auto attr = dict.get(tile_maskAttrName);
|
|
usedKeys.insert(tile_maskAttrName);
|
|
if (attr || /*isRequired=*/true) {
|
|
if (!attr) {
|
|
emitError() << "expected key entry for tile_mask in DictionaryAttr to set "
|
|
"Properties.";
|
|
return ::mlir::failure();
|
|
}
|
|
auto convertedAttr = ::llvm::dyn_cast<std::remove_reference_t<decltype(propStorage)>>(attr);
|
|
if (convertedAttr) {
|
|
propStorage = convertedAttr;
|
|
} else {
|
|
emitError() << "Invalid attribute `tile_mask` in property conversion: " << attr;
|
|
return ::mlir::failure();
|
|
}
|
|
}
|
|
}
|
|
|
|
for (::mlir::NamedAttribute attr : dict) {
|
|
if (!usedKeys.contains(attr.getName()))
|
|
return emitError() << "unknown key '" << attr.getName() <<
|
|
"' when parsing properties dictionary";
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
|
|
|
|
} // namespace mlir::arm_sme
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::aarch64_sme_zero)
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arm_sme::detail::aarch64_sme_zeroGenericAdaptorBase::Properties)
|
|
|
|
|
|
#endif // GET_OP_CLASSES
|
|
|