1413 lines
52 KiB
C++
1413 lines
52 KiB
C++
/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
|
|
|* *|
|
|
|* AttrDef Definitions *|
|
|
|* *|
|
|
|* Automatically generated file, do not edit! *|
|
|
|* *|
|
|
\*===----------------------------------------------------------------------===*/
|
|
|
|
#ifdef GET_ATTRDEF_LIST
|
|
#undef GET_ATTRDEF_LIST
|
|
|
|
::mlir::ROCDL::BufferOOBModeAttr,
|
|
::mlir::ROCDL::BufferOOBModeModuleFlagAttr,
|
|
::mlir::ROCDL::TBufferOOBModeModuleFlagAttr,
|
|
::mlir::ROCDL::MFMAPermBAttr,
|
|
::mlir::ROCDL::MFMANegModifierAttr,
|
|
::mlir::ROCDL::MatrixFormatAttr,
|
|
::mlir::ROCDL::WMMAMatrixScaleAttr,
|
|
::mlir::ROCDL::WMMAMatrixScaleFormatAttr,
|
|
::mlir::ROCDL::WMMACModifierAttr,
|
|
::mlir::ROCDL::SchedGroupMaskAttr,
|
|
::mlir::ROCDL::PreGfx12CachePolicyAttr,
|
|
::mlir::ROCDL::Gfx942CachePolicyAttr,
|
|
::mlir::ROCDL::Gfx12CachePolicyAttr,
|
|
::mlir::ROCDL::Gfx12AtomicCachePolicyAttr,
|
|
::mlir::ROCDL::ROCDLTargetAttr
|
|
|
|
#endif // GET_ATTRDEF_LIST
|
|
|
|
#ifdef GET_ATTRDEF_CLASSES
|
|
#undef GET_ATTRDEF_CLASSES
|
|
|
|
static ::mlir::OptionalParseResult generatedAttributeParser(::mlir::AsmParser &parser, ::llvm::StringRef *mnemonic, ::mlir::Type type, ::mlir::Attribute &value) {
|
|
return ::mlir::AsmParser::KeywordSwitch<::mlir::OptionalParseResult>(parser)
|
|
.Case(::mlir::ROCDL::BufferOOBModeAttr::getMnemonic(), [&](llvm::StringRef, llvm::SMLoc) {
|
|
value = ::mlir::ROCDL::BufferOOBModeAttr::parse(parser, type);
|
|
return ::mlir::success(!!value);
|
|
})
|
|
.Case(::mlir::ROCDL::BufferOOBModeModuleFlagAttr::getMnemonic(), [&](llvm::StringRef, llvm::SMLoc) {
|
|
value = ::mlir::ROCDL::BufferOOBModeModuleFlagAttr::parse(parser, type);
|
|
return ::mlir::success(!!value);
|
|
})
|
|
.Case(::mlir::ROCDL::TBufferOOBModeModuleFlagAttr::getMnemonic(), [&](llvm::StringRef, llvm::SMLoc) {
|
|
value = ::mlir::ROCDL::TBufferOOBModeModuleFlagAttr::parse(parser, type);
|
|
return ::mlir::success(!!value);
|
|
})
|
|
.Case(::mlir::ROCDL::MFMAPermBAttr::getMnemonic(), [&](llvm::StringRef, llvm::SMLoc) {
|
|
value = ::mlir::ROCDL::MFMAPermBAttr::parse(parser, type);
|
|
return ::mlir::success(!!value);
|
|
})
|
|
.Case(::mlir::ROCDL::MFMANegModifierAttr::getMnemonic(), [&](llvm::StringRef, llvm::SMLoc) {
|
|
value = ::mlir::ROCDL::MFMANegModifierAttr::parse(parser, type);
|
|
return ::mlir::success(!!value);
|
|
})
|
|
.Case(::mlir::ROCDL::MatrixFormatAttr::getMnemonic(), [&](llvm::StringRef, llvm::SMLoc) {
|
|
value = ::mlir::ROCDL::MatrixFormatAttr::parse(parser, type);
|
|
return ::mlir::success(!!value);
|
|
})
|
|
.Case(::mlir::ROCDL::WMMAMatrixScaleAttr::getMnemonic(), [&](llvm::StringRef, llvm::SMLoc) {
|
|
value = ::mlir::ROCDL::WMMAMatrixScaleAttr::parse(parser, type);
|
|
return ::mlir::success(!!value);
|
|
})
|
|
.Case(::mlir::ROCDL::WMMAMatrixScaleFormatAttr::getMnemonic(), [&](llvm::StringRef, llvm::SMLoc) {
|
|
value = ::mlir::ROCDL::WMMAMatrixScaleFormatAttr::parse(parser, type);
|
|
return ::mlir::success(!!value);
|
|
})
|
|
.Case(::mlir::ROCDL::WMMACModifierAttr::getMnemonic(), [&](llvm::StringRef, llvm::SMLoc) {
|
|
value = ::mlir::ROCDL::WMMACModifierAttr::parse(parser, type);
|
|
return ::mlir::success(!!value);
|
|
})
|
|
.Case(::mlir::ROCDL::SchedGroupMaskAttr::getMnemonic(), [&](llvm::StringRef, llvm::SMLoc) {
|
|
value = ::mlir::ROCDL::SchedGroupMaskAttr::parse(parser, type);
|
|
return ::mlir::success(!!value);
|
|
})
|
|
.Case(::mlir::ROCDL::PreGfx12CachePolicyAttr::getMnemonic(), [&](llvm::StringRef, llvm::SMLoc) {
|
|
value = ::mlir::ROCDL::PreGfx12CachePolicyAttr::parse(parser, type);
|
|
return ::mlir::success(!!value);
|
|
})
|
|
.Case(::mlir::ROCDL::Gfx942CachePolicyAttr::getMnemonic(), [&](llvm::StringRef, llvm::SMLoc) {
|
|
value = ::mlir::ROCDL::Gfx942CachePolicyAttr::parse(parser, type);
|
|
return ::mlir::success(!!value);
|
|
})
|
|
.Case(::mlir::ROCDL::Gfx12CachePolicyAttr::getMnemonic(), [&](llvm::StringRef, llvm::SMLoc) {
|
|
value = ::mlir::ROCDL::Gfx12CachePolicyAttr::parse(parser, type);
|
|
return ::mlir::success(!!value);
|
|
})
|
|
.Case(::mlir::ROCDL::Gfx12AtomicCachePolicyAttr::getMnemonic(), [&](llvm::StringRef, llvm::SMLoc) {
|
|
value = ::mlir::ROCDL::Gfx12AtomicCachePolicyAttr::parse(parser, type);
|
|
return ::mlir::success(!!value);
|
|
})
|
|
.Case(::mlir::ROCDL::ROCDLTargetAttr::getMnemonic(), [&](llvm::StringRef, llvm::SMLoc) {
|
|
value = ::mlir::ROCDL::ROCDLTargetAttr::parse(parser, type);
|
|
return ::mlir::success(!!value);
|
|
})
|
|
.Default([&](llvm::StringRef keyword, llvm::SMLoc) {
|
|
*mnemonic = keyword;
|
|
return std::nullopt;
|
|
});
|
|
}
|
|
|
|
static ::llvm::LogicalResult generatedAttributePrinter(::mlir::Attribute def, ::mlir::AsmPrinter &printer) {
|
|
return ::llvm::TypeSwitch<::mlir::Attribute, ::llvm::LogicalResult>(def) .Case<::mlir::ROCDL::BufferOOBModeAttr>([&](auto t) {
|
|
printer << ::mlir::ROCDL::BufferOOBModeAttr::getMnemonic();
|
|
t.print(printer);
|
|
return ::mlir::success();
|
|
})
|
|
.Case<::mlir::ROCDL::BufferOOBModeModuleFlagAttr>([&](auto t) {
|
|
printer << ::mlir::ROCDL::BufferOOBModeModuleFlagAttr::getMnemonic();
|
|
t.print(printer);
|
|
return ::mlir::success();
|
|
})
|
|
.Case<::mlir::ROCDL::TBufferOOBModeModuleFlagAttr>([&](auto t) {
|
|
printer << ::mlir::ROCDL::TBufferOOBModeModuleFlagAttr::getMnemonic();
|
|
t.print(printer);
|
|
return ::mlir::success();
|
|
})
|
|
.Case<::mlir::ROCDL::MFMAPermBAttr>([&](auto t) {
|
|
printer << ::mlir::ROCDL::MFMAPermBAttr::getMnemonic();
|
|
printer << ' ';
|
|
t.print(printer);
|
|
return ::mlir::success();
|
|
})
|
|
.Case<::mlir::ROCDL::MFMANegModifierAttr>([&](auto t) {
|
|
printer << ::mlir::ROCDL::MFMANegModifierAttr::getMnemonic();
|
|
printer << ' ';
|
|
t.print(printer);
|
|
return ::mlir::success();
|
|
})
|
|
.Case<::mlir::ROCDL::MatrixFormatAttr>([&](auto t) {
|
|
printer << ::mlir::ROCDL::MatrixFormatAttr::getMnemonic();
|
|
printer << ' ';
|
|
t.print(printer);
|
|
return ::mlir::success();
|
|
})
|
|
.Case<::mlir::ROCDL::WMMAMatrixScaleAttr>([&](auto t) {
|
|
printer << ::mlir::ROCDL::WMMAMatrixScaleAttr::getMnemonic();
|
|
printer << ' ';
|
|
t.print(printer);
|
|
return ::mlir::success();
|
|
})
|
|
.Case<::mlir::ROCDL::WMMAMatrixScaleFormatAttr>([&](auto t) {
|
|
printer << ::mlir::ROCDL::WMMAMatrixScaleFormatAttr::getMnemonic();
|
|
printer << ' ';
|
|
t.print(printer);
|
|
return ::mlir::success();
|
|
})
|
|
.Case<::mlir::ROCDL::WMMACModifierAttr>([&](auto t) {
|
|
printer << ::mlir::ROCDL::WMMACModifierAttr::getMnemonic();
|
|
printer << ' ';
|
|
t.print(printer);
|
|
return ::mlir::success();
|
|
})
|
|
.Case<::mlir::ROCDL::SchedGroupMaskAttr>([&](auto t) {
|
|
printer << ::mlir::ROCDL::SchedGroupMaskAttr::getMnemonic();
|
|
printer << ' ';
|
|
t.print(printer);
|
|
return ::mlir::success();
|
|
})
|
|
.Case<::mlir::ROCDL::PreGfx12CachePolicyAttr>([&](auto t) {
|
|
printer << ::mlir::ROCDL::PreGfx12CachePolicyAttr::getMnemonic();
|
|
printer << ' ';
|
|
t.print(printer);
|
|
return ::mlir::success();
|
|
})
|
|
.Case<::mlir::ROCDL::Gfx942CachePolicyAttr>([&](auto t) {
|
|
printer << ::mlir::ROCDL::Gfx942CachePolicyAttr::getMnemonic();
|
|
printer << ' ';
|
|
t.print(printer);
|
|
return ::mlir::success();
|
|
})
|
|
.Case<::mlir::ROCDL::Gfx12CachePolicyAttr>([&](auto t) {
|
|
printer << ::mlir::ROCDL::Gfx12CachePolicyAttr::getMnemonic();
|
|
printer << ' ';
|
|
t.print(printer);
|
|
return ::mlir::success();
|
|
})
|
|
.Case<::mlir::ROCDL::Gfx12AtomicCachePolicyAttr>([&](auto t) {
|
|
printer << ::mlir::ROCDL::Gfx12AtomicCachePolicyAttr::getMnemonic();
|
|
printer << ' ';
|
|
t.print(printer);
|
|
return ::mlir::success();
|
|
})
|
|
.Case<::mlir::ROCDL::ROCDLTargetAttr>([&](auto t) {
|
|
printer << ::mlir::ROCDL::ROCDLTargetAttr::getMnemonic();
|
|
t.print(printer);
|
|
return ::mlir::success();
|
|
})
|
|
.Default([](auto) { return ::mlir::failure(); });
|
|
}
|
|
|
|
namespace mlir::ROCDL {
|
|
|
|
namespace detail {
|
|
|
|
struct BufferOOBModeAttrStorage : public ::mlir::AttributeStorage {
|
|
using KeyTy = std::tuple<::mlir::ROCDL::BufferOOBMode>;
|
|
BufferOOBModeAttrStorage(::mlir::ROCDL::BufferOOBMode value) : value(std::move(value)) {}
|
|
|
|
KeyTy getAsKey() const {
|
|
return KeyTy(value);
|
|
}
|
|
|
|
bool operator==(const KeyTy &tblgenKey) const {
|
|
return (value == std::get<0>(tblgenKey));
|
|
}
|
|
|
|
static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
|
|
return ::llvm::hash_combine(std::get<0>(tblgenKey));
|
|
}
|
|
|
|
static BufferOOBModeAttrStorage *construct(::mlir::AttributeStorageAllocator &allocator, KeyTy &&tblgenKey) {
|
|
auto value = std::move(std::get<0>(tblgenKey));
|
|
return new (allocator.allocate<BufferOOBModeAttrStorage>()) BufferOOBModeAttrStorage(std::move(value));
|
|
}
|
|
|
|
::mlir::ROCDL::BufferOOBMode value;
|
|
};
|
|
|
|
} // namespace detail
|
|
BufferOOBModeAttr BufferOOBModeAttr::get(::mlir::MLIRContext *context, ::mlir::ROCDL::BufferOOBMode value) {
|
|
return Base::get(context, std::move(value));
|
|
}
|
|
|
|
::mlir::Attribute BufferOOBModeAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {
|
|
::mlir::Builder odsBuilder(odsParser.getContext());
|
|
::llvm::SMLoc odsLoc = odsParser.getCurrentLocation();
|
|
(void) odsLoc;
|
|
::mlir::FailureOr<::mlir::ROCDL::BufferOOBMode> _result_value;
|
|
// Parse literal '<'
|
|
if (odsParser.parseLess()) return {};
|
|
|
|
// Parse variable 'value'
|
|
_result_value = ::mlir::FieldParser<::mlir::ROCDL::BufferOOBMode>::parse(odsParser);
|
|
if (::mlir::failed(_result_value)) {
|
|
odsParser.emitError(odsParser.getCurrentLocation(), "failed to parse ROCDL_BufferOOBModeAttr parameter 'value' which is to be a `::mlir::ROCDL::BufferOOBMode`");
|
|
return {};
|
|
}
|
|
// Parse literal '>'
|
|
if (odsParser.parseGreater()) return {};
|
|
assert(::mlir::succeeded(_result_value));
|
|
return BufferOOBModeAttr::get(odsParser.getContext(),
|
|
::mlir::ROCDL::BufferOOBMode((*_result_value)));
|
|
}
|
|
|
|
void BufferOOBModeAttr::print(::mlir::AsmPrinter &odsPrinter) const {
|
|
::mlir::Builder odsBuilder(getContext());
|
|
odsPrinter << "<";
|
|
odsPrinter.printStrippedAttrOrType(getValue());
|
|
odsPrinter << ">";
|
|
}
|
|
|
|
::mlir::ROCDL::BufferOOBMode BufferOOBModeAttr::getValue() const {
|
|
return getImpl()->value;
|
|
}
|
|
|
|
|
|
} // namespace mlir::ROCDL
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::ROCDL::BufferOOBModeAttr)
|
|
namespace mlir::ROCDL {
|
|
|
|
namespace detail {
|
|
|
|
struct BufferOOBModeModuleFlagAttrStorage : public ::mlir::AttributeStorage {
|
|
using KeyTy = std::tuple<::mlir::ROCDL::BufferOOBMode>;
|
|
BufferOOBModeModuleFlagAttrStorage(::mlir::ROCDL::BufferOOBMode value) : value(std::move(value)) {}
|
|
|
|
KeyTy getAsKey() const {
|
|
return KeyTy(value);
|
|
}
|
|
|
|
bool operator==(const KeyTy &tblgenKey) const {
|
|
return (value == std::get<0>(tblgenKey));
|
|
}
|
|
|
|
static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
|
|
return ::llvm::hash_combine(std::get<0>(tblgenKey));
|
|
}
|
|
|
|
static BufferOOBModeModuleFlagAttrStorage *construct(::mlir::AttributeStorageAllocator &allocator, KeyTy &&tblgenKey) {
|
|
auto value = std::move(std::get<0>(tblgenKey));
|
|
return new (allocator.allocate<BufferOOBModeModuleFlagAttrStorage>()) BufferOOBModeModuleFlagAttrStorage(std::move(value));
|
|
}
|
|
|
|
::mlir::ROCDL::BufferOOBMode value;
|
|
};
|
|
|
|
} // namespace detail
|
|
BufferOOBModeModuleFlagAttr BufferOOBModeModuleFlagAttr::get(::mlir::MLIRContext *context, ::mlir::ROCDL::BufferOOBMode value) {
|
|
return Base::get(context, std::move(value));
|
|
}
|
|
|
|
::mlir::Attribute BufferOOBModeModuleFlagAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {
|
|
::mlir::Builder odsBuilder(odsParser.getContext());
|
|
::llvm::SMLoc odsLoc = odsParser.getCurrentLocation();
|
|
(void) odsLoc;
|
|
::mlir::FailureOr<::mlir::ROCDL::BufferOOBMode> _result_value;
|
|
// Parse literal '<'
|
|
if (odsParser.parseLess()) return {};
|
|
|
|
// Parse variable 'value'
|
|
_result_value = ::mlir::FieldParser<::mlir::ROCDL::BufferOOBMode>::parse(odsParser);
|
|
if (::mlir::failed(_result_value)) {
|
|
odsParser.emitError(odsParser.getCurrentLocation(), "failed to parse ROCDL_BufferOOBModeModuleFlagAttr parameter 'value' which is to be a `::mlir::ROCDL::BufferOOBMode`");
|
|
return {};
|
|
}
|
|
// Parse literal '>'
|
|
if (odsParser.parseGreater()) return {};
|
|
assert(::mlir::succeeded(_result_value));
|
|
return BufferOOBModeModuleFlagAttr::get(odsParser.getContext(),
|
|
::mlir::ROCDL::BufferOOBMode((*_result_value)));
|
|
}
|
|
|
|
void BufferOOBModeModuleFlagAttr::print(::mlir::AsmPrinter &odsPrinter) const {
|
|
::mlir::Builder odsBuilder(getContext());
|
|
odsPrinter << "<";
|
|
odsPrinter.printStrippedAttrOrType(getValue());
|
|
odsPrinter << ">";
|
|
}
|
|
|
|
::mlir::ROCDL::BufferOOBMode BufferOOBModeModuleFlagAttr::getValue() const {
|
|
return getImpl()->value;
|
|
}
|
|
|
|
|
|
} // namespace mlir::ROCDL
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::ROCDL::BufferOOBModeModuleFlagAttr)
|
|
namespace mlir::ROCDL {
|
|
|
|
namespace detail {
|
|
|
|
struct TBufferOOBModeModuleFlagAttrStorage : public ::mlir::AttributeStorage {
|
|
using KeyTy = std::tuple<::mlir::ROCDL::BufferOOBMode>;
|
|
TBufferOOBModeModuleFlagAttrStorage(::mlir::ROCDL::BufferOOBMode value) : value(std::move(value)) {}
|
|
|
|
KeyTy getAsKey() const {
|
|
return KeyTy(value);
|
|
}
|
|
|
|
bool operator==(const KeyTy &tblgenKey) const {
|
|
return (value == std::get<0>(tblgenKey));
|
|
}
|
|
|
|
static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
|
|
return ::llvm::hash_combine(std::get<0>(tblgenKey));
|
|
}
|
|
|
|
static TBufferOOBModeModuleFlagAttrStorage *construct(::mlir::AttributeStorageAllocator &allocator, KeyTy &&tblgenKey) {
|
|
auto value = std::move(std::get<0>(tblgenKey));
|
|
return new (allocator.allocate<TBufferOOBModeModuleFlagAttrStorage>()) TBufferOOBModeModuleFlagAttrStorage(std::move(value));
|
|
}
|
|
|
|
::mlir::ROCDL::BufferOOBMode value;
|
|
};
|
|
|
|
} // namespace detail
|
|
TBufferOOBModeModuleFlagAttr TBufferOOBModeModuleFlagAttr::get(::mlir::MLIRContext *context, ::mlir::ROCDL::BufferOOBMode value) {
|
|
return Base::get(context, std::move(value));
|
|
}
|
|
|
|
::mlir::Attribute TBufferOOBModeModuleFlagAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {
|
|
::mlir::Builder odsBuilder(odsParser.getContext());
|
|
::llvm::SMLoc odsLoc = odsParser.getCurrentLocation();
|
|
(void) odsLoc;
|
|
::mlir::FailureOr<::mlir::ROCDL::BufferOOBMode> _result_value;
|
|
// Parse literal '<'
|
|
if (odsParser.parseLess()) return {};
|
|
|
|
// Parse variable 'value'
|
|
_result_value = ::mlir::FieldParser<::mlir::ROCDL::BufferOOBMode>::parse(odsParser);
|
|
if (::mlir::failed(_result_value)) {
|
|
odsParser.emitError(odsParser.getCurrentLocation(), "failed to parse ROCDL_TBufferOOBModeModuleFlagAttr parameter 'value' which is to be a `::mlir::ROCDL::BufferOOBMode`");
|
|
return {};
|
|
}
|
|
// Parse literal '>'
|
|
if (odsParser.parseGreater()) return {};
|
|
assert(::mlir::succeeded(_result_value));
|
|
return TBufferOOBModeModuleFlagAttr::get(odsParser.getContext(),
|
|
::mlir::ROCDL::BufferOOBMode((*_result_value)));
|
|
}
|
|
|
|
void TBufferOOBModeModuleFlagAttr::print(::mlir::AsmPrinter &odsPrinter) const {
|
|
::mlir::Builder odsBuilder(getContext());
|
|
odsPrinter << "<";
|
|
odsPrinter.printStrippedAttrOrType(getValue());
|
|
odsPrinter << ">";
|
|
}
|
|
|
|
::mlir::ROCDL::BufferOOBMode TBufferOOBModeModuleFlagAttr::getValue() const {
|
|
return getImpl()->value;
|
|
}
|
|
|
|
|
|
} // namespace mlir::ROCDL
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::ROCDL::TBufferOOBModeModuleFlagAttr)
|
|
namespace mlir::ROCDL {
|
|
|
|
namespace detail {
|
|
|
|
struct MFMAPermBAttrStorage : public ::mlir::AttributeStorage {
|
|
using KeyTy = std::tuple<::mlir::ROCDL::MFMAPermB>;
|
|
MFMAPermBAttrStorage(::mlir::ROCDL::MFMAPermB value) : value(std::move(value)) {}
|
|
|
|
KeyTy getAsKey() const {
|
|
return KeyTy(value);
|
|
}
|
|
|
|
bool operator==(const KeyTy &tblgenKey) const {
|
|
return (value == std::get<0>(tblgenKey));
|
|
}
|
|
|
|
static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
|
|
return ::llvm::hash_combine(std::get<0>(tblgenKey));
|
|
}
|
|
|
|
static MFMAPermBAttrStorage *construct(::mlir::AttributeStorageAllocator &allocator, KeyTy &&tblgenKey) {
|
|
auto value = std::move(std::get<0>(tblgenKey));
|
|
return new (allocator.allocate<MFMAPermBAttrStorage>()) MFMAPermBAttrStorage(std::move(value));
|
|
}
|
|
|
|
::mlir::ROCDL::MFMAPermB value;
|
|
};
|
|
|
|
} // namespace detail
|
|
MFMAPermBAttr MFMAPermBAttr::get(::mlir::MLIRContext *context, ::mlir::ROCDL::MFMAPermB value) {
|
|
return Base::get(context, std::move(value));
|
|
}
|
|
|
|
::mlir::Attribute MFMAPermBAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {
|
|
::mlir::Builder odsBuilder(odsParser.getContext());
|
|
::llvm::SMLoc odsLoc = odsParser.getCurrentLocation();
|
|
(void) odsLoc;
|
|
::mlir::FailureOr<::mlir::ROCDL::MFMAPermB> _result_value;
|
|
|
|
// Parse variable 'value'
|
|
_result_value = ::mlir::FieldParser<::mlir::ROCDL::MFMAPermB>::parse(odsParser);
|
|
if (::mlir::failed(_result_value)) {
|
|
odsParser.emitError(odsParser.getCurrentLocation(), "failed to parse ROCDL_MFMAPermBAttr parameter 'value' which is to be a `::mlir::ROCDL::MFMAPermB`");
|
|
return {};
|
|
}
|
|
assert(::mlir::succeeded(_result_value));
|
|
return MFMAPermBAttr::get(odsParser.getContext(),
|
|
::mlir::ROCDL::MFMAPermB((*_result_value)));
|
|
}
|
|
|
|
void MFMAPermBAttr::print(::mlir::AsmPrinter &odsPrinter) const {
|
|
::mlir::Builder odsBuilder(getContext());
|
|
odsPrinter.printStrippedAttrOrType(getValue());
|
|
}
|
|
|
|
::mlir::ROCDL::MFMAPermB MFMAPermBAttr::getValue() const {
|
|
return getImpl()->value;
|
|
}
|
|
|
|
|
|
} // namespace mlir::ROCDL
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::ROCDL::MFMAPermBAttr)
|
|
namespace mlir::ROCDL {
|
|
|
|
namespace detail {
|
|
|
|
struct MFMANegModifierAttrStorage : public ::mlir::AttributeStorage {
|
|
using KeyTy = std::tuple<::mlir::ROCDL::MFMANegModifier>;
|
|
MFMANegModifierAttrStorage(::mlir::ROCDL::MFMANegModifier value) : value(std::move(value)) {}
|
|
|
|
KeyTy getAsKey() const {
|
|
return KeyTy(value);
|
|
}
|
|
|
|
bool operator==(const KeyTy &tblgenKey) const {
|
|
return (value == std::get<0>(tblgenKey));
|
|
}
|
|
|
|
static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
|
|
return ::llvm::hash_combine(std::get<0>(tblgenKey));
|
|
}
|
|
|
|
static MFMANegModifierAttrStorage *construct(::mlir::AttributeStorageAllocator &allocator, KeyTy &&tblgenKey) {
|
|
auto value = std::move(std::get<0>(tblgenKey));
|
|
return new (allocator.allocate<MFMANegModifierAttrStorage>()) MFMANegModifierAttrStorage(std::move(value));
|
|
}
|
|
|
|
::mlir::ROCDL::MFMANegModifier value;
|
|
};
|
|
|
|
} // namespace detail
|
|
MFMANegModifierAttr MFMANegModifierAttr::get(::mlir::MLIRContext *context, ::mlir::ROCDL::MFMANegModifier value) {
|
|
return Base::get(context, std::move(value));
|
|
}
|
|
|
|
::mlir::Attribute MFMANegModifierAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {
|
|
::mlir::Builder odsBuilder(odsParser.getContext());
|
|
::llvm::SMLoc odsLoc = odsParser.getCurrentLocation();
|
|
(void) odsLoc;
|
|
::mlir::FailureOr<::mlir::ROCDL::MFMANegModifier> _result_value;
|
|
|
|
// Parse variable 'value'
|
|
_result_value = ::mlir::FieldParser<::mlir::ROCDL::MFMANegModifier>::parse(odsParser);
|
|
if (::mlir::failed(_result_value)) {
|
|
odsParser.emitError(odsParser.getCurrentLocation(), "failed to parse ROCDL_MFMANegModifierAttr parameter 'value' which is to be a `::mlir::ROCDL::MFMANegModifier`");
|
|
return {};
|
|
}
|
|
assert(::mlir::succeeded(_result_value));
|
|
return MFMANegModifierAttr::get(odsParser.getContext(),
|
|
::mlir::ROCDL::MFMANegModifier((*_result_value)));
|
|
}
|
|
|
|
void MFMANegModifierAttr::print(::mlir::AsmPrinter &odsPrinter) const {
|
|
::mlir::Builder odsBuilder(getContext());
|
|
odsPrinter.printStrippedAttrOrType(getValue());
|
|
}
|
|
|
|
::mlir::ROCDL::MFMANegModifier MFMANegModifierAttr::getValue() const {
|
|
return getImpl()->value;
|
|
}
|
|
|
|
|
|
} // namespace mlir::ROCDL
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::ROCDL::MFMANegModifierAttr)
|
|
namespace mlir::ROCDL {
|
|
|
|
namespace detail {
|
|
|
|
struct MatrixFormatAttrStorage : public ::mlir::AttributeStorage {
|
|
using KeyTy = std::tuple<::mlir::ROCDL::MatrixFormat>;
|
|
MatrixFormatAttrStorage(::mlir::ROCDL::MatrixFormat value) : value(std::move(value)) {}
|
|
|
|
KeyTy getAsKey() const {
|
|
return KeyTy(value);
|
|
}
|
|
|
|
bool operator==(const KeyTy &tblgenKey) const {
|
|
return (value == std::get<0>(tblgenKey));
|
|
}
|
|
|
|
static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
|
|
return ::llvm::hash_combine(std::get<0>(tblgenKey));
|
|
}
|
|
|
|
static MatrixFormatAttrStorage *construct(::mlir::AttributeStorageAllocator &allocator, KeyTy &&tblgenKey) {
|
|
auto value = std::move(std::get<0>(tblgenKey));
|
|
return new (allocator.allocate<MatrixFormatAttrStorage>()) MatrixFormatAttrStorage(std::move(value));
|
|
}
|
|
|
|
::mlir::ROCDL::MatrixFormat value;
|
|
};
|
|
|
|
} // namespace detail
|
|
MatrixFormatAttr MatrixFormatAttr::get(::mlir::MLIRContext *context, ::mlir::ROCDL::MatrixFormat value) {
|
|
return Base::get(context, std::move(value));
|
|
}
|
|
|
|
::mlir::Attribute MatrixFormatAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {
|
|
::mlir::Builder odsBuilder(odsParser.getContext());
|
|
::llvm::SMLoc odsLoc = odsParser.getCurrentLocation();
|
|
(void) odsLoc;
|
|
::mlir::FailureOr<::mlir::ROCDL::MatrixFormat> _result_value;
|
|
|
|
// Parse variable 'value'
|
|
_result_value = ::mlir::FieldParser<::mlir::ROCDL::MatrixFormat>::parse(odsParser);
|
|
if (::mlir::failed(_result_value)) {
|
|
odsParser.emitError(odsParser.getCurrentLocation(), "failed to parse ROCDL_MatrixFormatAttr parameter 'value' which is to be a `::mlir::ROCDL::MatrixFormat`");
|
|
return {};
|
|
}
|
|
assert(::mlir::succeeded(_result_value));
|
|
return MatrixFormatAttr::get(odsParser.getContext(),
|
|
::mlir::ROCDL::MatrixFormat((*_result_value)));
|
|
}
|
|
|
|
void MatrixFormatAttr::print(::mlir::AsmPrinter &odsPrinter) const {
|
|
::mlir::Builder odsBuilder(getContext());
|
|
odsPrinter.printStrippedAttrOrType(getValue());
|
|
}
|
|
|
|
::mlir::ROCDL::MatrixFormat MatrixFormatAttr::getValue() const {
|
|
return getImpl()->value;
|
|
}
|
|
|
|
|
|
} // namespace mlir::ROCDL
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::ROCDL::MatrixFormatAttr)
|
|
namespace mlir::ROCDL {
|
|
|
|
namespace detail {
|
|
|
|
struct WMMAMatrixScaleAttrStorage : public ::mlir::AttributeStorage {
|
|
using KeyTy = std::tuple<::mlir::ROCDL::WMMAMatrixScale>;
|
|
WMMAMatrixScaleAttrStorage(::mlir::ROCDL::WMMAMatrixScale value) : value(std::move(value)) {}
|
|
|
|
KeyTy getAsKey() const {
|
|
return KeyTy(value);
|
|
}
|
|
|
|
bool operator==(const KeyTy &tblgenKey) const {
|
|
return (value == std::get<0>(tblgenKey));
|
|
}
|
|
|
|
static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
|
|
return ::llvm::hash_combine(std::get<0>(tblgenKey));
|
|
}
|
|
|
|
static WMMAMatrixScaleAttrStorage *construct(::mlir::AttributeStorageAllocator &allocator, KeyTy &&tblgenKey) {
|
|
auto value = std::move(std::get<0>(tblgenKey));
|
|
return new (allocator.allocate<WMMAMatrixScaleAttrStorage>()) WMMAMatrixScaleAttrStorage(std::move(value));
|
|
}
|
|
|
|
::mlir::ROCDL::WMMAMatrixScale value;
|
|
};
|
|
|
|
} // namespace detail
|
|
WMMAMatrixScaleAttr WMMAMatrixScaleAttr::get(::mlir::MLIRContext *context, ::mlir::ROCDL::WMMAMatrixScale value) {
|
|
return Base::get(context, std::move(value));
|
|
}
|
|
|
|
::mlir::Attribute WMMAMatrixScaleAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {
|
|
::mlir::Builder odsBuilder(odsParser.getContext());
|
|
::llvm::SMLoc odsLoc = odsParser.getCurrentLocation();
|
|
(void) odsLoc;
|
|
::mlir::FailureOr<::mlir::ROCDL::WMMAMatrixScale> _result_value;
|
|
|
|
// Parse variable 'value'
|
|
_result_value = ::mlir::FieldParser<::mlir::ROCDL::WMMAMatrixScale>::parse(odsParser);
|
|
if (::mlir::failed(_result_value)) {
|
|
odsParser.emitError(odsParser.getCurrentLocation(), "failed to parse ROCDL_WMMAMatrixScaleAttr parameter 'value' which is to be a `::mlir::ROCDL::WMMAMatrixScale`");
|
|
return {};
|
|
}
|
|
assert(::mlir::succeeded(_result_value));
|
|
return WMMAMatrixScaleAttr::get(odsParser.getContext(),
|
|
::mlir::ROCDL::WMMAMatrixScale((*_result_value)));
|
|
}
|
|
|
|
void WMMAMatrixScaleAttr::print(::mlir::AsmPrinter &odsPrinter) const {
|
|
::mlir::Builder odsBuilder(getContext());
|
|
odsPrinter.printStrippedAttrOrType(getValue());
|
|
}
|
|
|
|
::mlir::ROCDL::WMMAMatrixScale WMMAMatrixScaleAttr::getValue() const {
|
|
return getImpl()->value;
|
|
}
|
|
|
|
|
|
} // namespace mlir::ROCDL
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::ROCDL::WMMAMatrixScaleAttr)
|
|
namespace mlir::ROCDL {
|
|
|
|
namespace detail {
|
|
|
|
struct WMMAMatrixScaleFormatAttrStorage : public ::mlir::AttributeStorage {
|
|
using KeyTy = std::tuple<::mlir::ROCDL::WMMAMatrixScaleFormat>;
|
|
WMMAMatrixScaleFormatAttrStorage(::mlir::ROCDL::WMMAMatrixScaleFormat value) : value(std::move(value)) {}
|
|
|
|
KeyTy getAsKey() const {
|
|
return KeyTy(value);
|
|
}
|
|
|
|
bool operator==(const KeyTy &tblgenKey) const {
|
|
return (value == std::get<0>(tblgenKey));
|
|
}
|
|
|
|
static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
|
|
return ::llvm::hash_combine(std::get<0>(tblgenKey));
|
|
}
|
|
|
|
static WMMAMatrixScaleFormatAttrStorage *construct(::mlir::AttributeStorageAllocator &allocator, KeyTy &&tblgenKey) {
|
|
auto value = std::move(std::get<0>(tblgenKey));
|
|
return new (allocator.allocate<WMMAMatrixScaleFormatAttrStorage>()) WMMAMatrixScaleFormatAttrStorage(std::move(value));
|
|
}
|
|
|
|
::mlir::ROCDL::WMMAMatrixScaleFormat value;
|
|
};
|
|
|
|
} // namespace detail
|
|
WMMAMatrixScaleFormatAttr WMMAMatrixScaleFormatAttr::get(::mlir::MLIRContext *context, ::mlir::ROCDL::WMMAMatrixScaleFormat value) {
|
|
return Base::get(context, std::move(value));
|
|
}
|
|
|
|
::mlir::Attribute WMMAMatrixScaleFormatAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {
|
|
::mlir::Builder odsBuilder(odsParser.getContext());
|
|
::llvm::SMLoc odsLoc = odsParser.getCurrentLocation();
|
|
(void) odsLoc;
|
|
::mlir::FailureOr<::mlir::ROCDL::WMMAMatrixScaleFormat> _result_value;
|
|
|
|
// Parse variable 'value'
|
|
_result_value = ::mlir::FieldParser<::mlir::ROCDL::WMMAMatrixScaleFormat>::parse(odsParser);
|
|
if (::mlir::failed(_result_value)) {
|
|
odsParser.emitError(odsParser.getCurrentLocation(), "failed to parse ROCDL_WMMAMatrixScaleFormatAttr parameter 'value' which is to be a `::mlir::ROCDL::WMMAMatrixScaleFormat`");
|
|
return {};
|
|
}
|
|
assert(::mlir::succeeded(_result_value));
|
|
return WMMAMatrixScaleFormatAttr::get(odsParser.getContext(),
|
|
::mlir::ROCDL::WMMAMatrixScaleFormat((*_result_value)));
|
|
}
|
|
|
|
void WMMAMatrixScaleFormatAttr::print(::mlir::AsmPrinter &odsPrinter) const {
|
|
::mlir::Builder odsBuilder(getContext());
|
|
odsPrinter.printStrippedAttrOrType(getValue());
|
|
}
|
|
|
|
::mlir::ROCDL::WMMAMatrixScaleFormat WMMAMatrixScaleFormatAttr::getValue() const {
|
|
return getImpl()->value;
|
|
}
|
|
|
|
|
|
} // namespace mlir::ROCDL
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::ROCDL::WMMAMatrixScaleFormatAttr)
|
|
namespace mlir::ROCDL {
|
|
|
|
namespace detail {
|
|
|
|
struct WMMACModifierAttrStorage : public ::mlir::AttributeStorage {
|
|
using KeyTy = std::tuple<::mlir::ROCDL::WMMACModifier>;
|
|
WMMACModifierAttrStorage(::mlir::ROCDL::WMMACModifier value) : value(std::move(value)) {}
|
|
|
|
KeyTy getAsKey() const {
|
|
return KeyTy(value);
|
|
}
|
|
|
|
bool operator==(const KeyTy &tblgenKey) const {
|
|
return (value == std::get<0>(tblgenKey));
|
|
}
|
|
|
|
static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
|
|
return ::llvm::hash_combine(std::get<0>(tblgenKey));
|
|
}
|
|
|
|
static WMMACModifierAttrStorage *construct(::mlir::AttributeStorageAllocator &allocator, KeyTy &&tblgenKey) {
|
|
auto value = std::move(std::get<0>(tblgenKey));
|
|
return new (allocator.allocate<WMMACModifierAttrStorage>()) WMMACModifierAttrStorage(std::move(value));
|
|
}
|
|
|
|
::mlir::ROCDL::WMMACModifier value;
|
|
};
|
|
|
|
} // namespace detail
|
|
WMMACModifierAttr WMMACModifierAttr::get(::mlir::MLIRContext *context, ::mlir::ROCDL::WMMACModifier value) {
|
|
return Base::get(context, std::move(value));
|
|
}
|
|
|
|
::mlir::Attribute WMMACModifierAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {
|
|
::mlir::Builder odsBuilder(odsParser.getContext());
|
|
::llvm::SMLoc odsLoc = odsParser.getCurrentLocation();
|
|
(void) odsLoc;
|
|
::mlir::FailureOr<::mlir::ROCDL::WMMACModifier> _result_value;
|
|
|
|
// Parse variable 'value'
|
|
_result_value = ::mlir::FieldParser<::mlir::ROCDL::WMMACModifier>::parse(odsParser);
|
|
if (::mlir::failed(_result_value)) {
|
|
odsParser.emitError(odsParser.getCurrentLocation(), "failed to parse ROCDL_WMMACModifierAttr parameter 'value' which is to be a `::mlir::ROCDL::WMMACModifier`");
|
|
return {};
|
|
}
|
|
assert(::mlir::succeeded(_result_value));
|
|
return WMMACModifierAttr::get(odsParser.getContext(),
|
|
::mlir::ROCDL::WMMACModifier((*_result_value)));
|
|
}
|
|
|
|
void WMMACModifierAttr::print(::mlir::AsmPrinter &odsPrinter) const {
|
|
::mlir::Builder odsBuilder(getContext());
|
|
odsPrinter.printStrippedAttrOrType(getValue());
|
|
}
|
|
|
|
::mlir::ROCDL::WMMACModifier WMMACModifierAttr::getValue() const {
|
|
return getImpl()->value;
|
|
}
|
|
|
|
|
|
} // namespace mlir::ROCDL
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::ROCDL::WMMACModifierAttr)
|
|
namespace mlir::ROCDL {
|
|
|
|
namespace detail {
|
|
|
|
struct SchedGroupMaskAttrStorage : public ::mlir::AttributeStorage {
|
|
using KeyTy = std::tuple<::mlir::ROCDL::SchedGroupMask>;
|
|
SchedGroupMaskAttrStorage(::mlir::ROCDL::SchedGroupMask value) : value(std::move(value)) {}
|
|
|
|
KeyTy getAsKey() const {
|
|
return KeyTy(value);
|
|
}
|
|
|
|
bool operator==(const KeyTy &tblgenKey) const {
|
|
return (value == std::get<0>(tblgenKey));
|
|
}
|
|
|
|
static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
|
|
return ::llvm::hash_combine(std::get<0>(tblgenKey));
|
|
}
|
|
|
|
static SchedGroupMaskAttrStorage *construct(::mlir::AttributeStorageAllocator &allocator, KeyTy &&tblgenKey) {
|
|
auto value = std::move(std::get<0>(tblgenKey));
|
|
return new (allocator.allocate<SchedGroupMaskAttrStorage>()) SchedGroupMaskAttrStorage(std::move(value));
|
|
}
|
|
|
|
::mlir::ROCDL::SchedGroupMask value;
|
|
};
|
|
|
|
} // namespace detail
|
|
SchedGroupMaskAttr SchedGroupMaskAttr::get(::mlir::MLIRContext *context, ::mlir::ROCDL::SchedGroupMask value) {
|
|
return Base::get(context, std::move(value));
|
|
}
|
|
|
|
::mlir::Attribute SchedGroupMaskAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {
|
|
::mlir::Builder odsBuilder(odsParser.getContext());
|
|
::llvm::SMLoc odsLoc = odsParser.getCurrentLocation();
|
|
(void) odsLoc;
|
|
::mlir::FailureOr<::mlir::ROCDL::SchedGroupMask> _result_value;
|
|
|
|
// Parse variable 'value'
|
|
_result_value = ::mlir::FieldParser<::mlir::ROCDL::SchedGroupMask>::parse(odsParser);
|
|
if (::mlir::failed(_result_value)) {
|
|
odsParser.emitError(odsParser.getCurrentLocation(), "failed to parse ROCDL_SchedGroupMaskAttr parameter 'value' which is to be a `::mlir::ROCDL::SchedGroupMask`");
|
|
return {};
|
|
}
|
|
assert(::mlir::succeeded(_result_value));
|
|
return SchedGroupMaskAttr::get(odsParser.getContext(),
|
|
::mlir::ROCDL::SchedGroupMask((*_result_value)));
|
|
}
|
|
|
|
void SchedGroupMaskAttr::print(::mlir::AsmPrinter &odsPrinter) const {
|
|
::mlir::Builder odsBuilder(getContext());
|
|
odsPrinter.printStrippedAttrOrType(getValue());
|
|
}
|
|
|
|
::mlir::ROCDL::SchedGroupMask SchedGroupMaskAttr::getValue() const {
|
|
return getImpl()->value;
|
|
}
|
|
|
|
|
|
} // namespace mlir::ROCDL
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::ROCDL::SchedGroupMaskAttr)
|
|
namespace mlir::ROCDL {
|
|
|
|
namespace detail {
|
|
|
|
struct PreGfx12CachePolicyAttrStorage : public ::mlir::AttributeStorage {
|
|
using KeyTy = std::tuple<::mlir::ROCDL::PreGfx12CachePolicy>;
|
|
PreGfx12CachePolicyAttrStorage(::mlir::ROCDL::PreGfx12CachePolicy value) : value(std::move(value)) {}
|
|
|
|
KeyTy getAsKey() const {
|
|
return KeyTy(value);
|
|
}
|
|
|
|
bool operator==(const KeyTy &tblgenKey) const {
|
|
return (value == std::get<0>(tblgenKey));
|
|
}
|
|
|
|
static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
|
|
return ::llvm::hash_combine(std::get<0>(tblgenKey));
|
|
}
|
|
|
|
static PreGfx12CachePolicyAttrStorage *construct(::mlir::AttributeStorageAllocator &allocator, KeyTy &&tblgenKey) {
|
|
auto value = std::move(std::get<0>(tblgenKey));
|
|
return new (allocator.allocate<PreGfx12CachePolicyAttrStorage>()) PreGfx12CachePolicyAttrStorage(std::move(value));
|
|
}
|
|
|
|
::mlir::ROCDL::PreGfx12CachePolicy value;
|
|
};
|
|
|
|
} // namespace detail
|
|
PreGfx12CachePolicyAttr PreGfx12CachePolicyAttr::get(::mlir::MLIRContext *context, ::mlir::ROCDL::PreGfx12CachePolicy value) {
|
|
return Base::get(context, std::move(value));
|
|
}
|
|
|
|
::mlir::Attribute PreGfx12CachePolicyAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {
|
|
::mlir::Builder odsBuilder(odsParser.getContext());
|
|
::llvm::SMLoc odsLoc = odsParser.getCurrentLocation();
|
|
(void) odsLoc;
|
|
::mlir::FailureOr<::mlir::ROCDL::PreGfx12CachePolicy> _result_value;
|
|
|
|
// Parse variable 'value'
|
|
_result_value = ::mlir::FieldParser<::mlir::ROCDL::PreGfx12CachePolicy>::parse(odsParser);
|
|
if (::mlir::failed(_result_value)) {
|
|
odsParser.emitError(odsParser.getCurrentLocation(), "failed to parse ROCDL_PreGfx12CachePolicyAttr parameter 'value' which is to be a `::mlir::ROCDL::PreGfx12CachePolicy`");
|
|
return {};
|
|
}
|
|
assert(::mlir::succeeded(_result_value));
|
|
return PreGfx12CachePolicyAttr::get(odsParser.getContext(),
|
|
::mlir::ROCDL::PreGfx12CachePolicy((*_result_value)));
|
|
}
|
|
|
|
void PreGfx12CachePolicyAttr::print(::mlir::AsmPrinter &odsPrinter) const {
|
|
::mlir::Builder odsBuilder(getContext());
|
|
odsPrinter.printStrippedAttrOrType(getValue());
|
|
}
|
|
|
|
::mlir::ROCDL::PreGfx12CachePolicy PreGfx12CachePolicyAttr::getValue() const {
|
|
return getImpl()->value;
|
|
}
|
|
|
|
|
|
} // namespace mlir::ROCDL
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::ROCDL::PreGfx12CachePolicyAttr)
|
|
namespace mlir::ROCDL {
|
|
|
|
namespace detail {
|
|
|
|
struct Gfx942CachePolicyAttrStorage : public ::mlir::AttributeStorage {
|
|
using KeyTy = std::tuple<::mlir::ROCDL::Gfx942CachePolicy>;
|
|
Gfx942CachePolicyAttrStorage(::mlir::ROCDL::Gfx942CachePolicy value) : value(std::move(value)) {}
|
|
|
|
KeyTy getAsKey() const {
|
|
return KeyTy(value);
|
|
}
|
|
|
|
bool operator==(const KeyTy &tblgenKey) const {
|
|
return (value == std::get<0>(tblgenKey));
|
|
}
|
|
|
|
static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
|
|
return ::llvm::hash_combine(std::get<0>(tblgenKey));
|
|
}
|
|
|
|
static Gfx942CachePolicyAttrStorage *construct(::mlir::AttributeStorageAllocator &allocator, KeyTy &&tblgenKey) {
|
|
auto value = std::move(std::get<0>(tblgenKey));
|
|
return new (allocator.allocate<Gfx942CachePolicyAttrStorage>()) Gfx942CachePolicyAttrStorage(std::move(value));
|
|
}
|
|
|
|
::mlir::ROCDL::Gfx942CachePolicy value;
|
|
};
|
|
|
|
} // namespace detail
|
|
Gfx942CachePolicyAttr Gfx942CachePolicyAttr::get(::mlir::MLIRContext *context, ::mlir::ROCDL::Gfx942CachePolicy value) {
|
|
return Base::get(context, std::move(value));
|
|
}
|
|
|
|
::mlir::Attribute Gfx942CachePolicyAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {
|
|
::mlir::Builder odsBuilder(odsParser.getContext());
|
|
::llvm::SMLoc odsLoc = odsParser.getCurrentLocation();
|
|
(void) odsLoc;
|
|
::mlir::FailureOr<::mlir::ROCDL::Gfx942CachePolicy> _result_value;
|
|
|
|
// Parse variable 'value'
|
|
_result_value = ::mlir::FieldParser<::mlir::ROCDL::Gfx942CachePolicy>::parse(odsParser);
|
|
if (::mlir::failed(_result_value)) {
|
|
odsParser.emitError(odsParser.getCurrentLocation(), "failed to parse ROCDL_Gfx942CachePolicyAttr parameter 'value' which is to be a `::mlir::ROCDL::Gfx942CachePolicy`");
|
|
return {};
|
|
}
|
|
assert(::mlir::succeeded(_result_value));
|
|
return Gfx942CachePolicyAttr::get(odsParser.getContext(),
|
|
::mlir::ROCDL::Gfx942CachePolicy((*_result_value)));
|
|
}
|
|
|
|
void Gfx942CachePolicyAttr::print(::mlir::AsmPrinter &odsPrinter) const {
|
|
::mlir::Builder odsBuilder(getContext());
|
|
odsPrinter.printStrippedAttrOrType(getValue());
|
|
}
|
|
|
|
::mlir::ROCDL::Gfx942CachePolicy Gfx942CachePolicyAttr::getValue() const {
|
|
return getImpl()->value;
|
|
}
|
|
|
|
|
|
} // namespace mlir::ROCDL
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::ROCDL::Gfx942CachePolicyAttr)
|
|
namespace mlir::ROCDL {
|
|
|
|
namespace detail {
|
|
|
|
struct Gfx12CachePolicyAttrStorage : public ::mlir::AttributeStorage {
|
|
using KeyTy = std::tuple<::mlir::ROCDL::Gfx12CachePolicy>;
|
|
Gfx12CachePolicyAttrStorage(::mlir::ROCDL::Gfx12CachePolicy value) : value(std::move(value)) {}
|
|
|
|
KeyTy getAsKey() const {
|
|
return KeyTy(value);
|
|
}
|
|
|
|
bool operator==(const KeyTy &tblgenKey) const {
|
|
return (value == std::get<0>(tblgenKey));
|
|
}
|
|
|
|
static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
|
|
return ::llvm::hash_combine(std::get<0>(tblgenKey));
|
|
}
|
|
|
|
static Gfx12CachePolicyAttrStorage *construct(::mlir::AttributeStorageAllocator &allocator, KeyTy &&tblgenKey) {
|
|
auto value = std::move(std::get<0>(tblgenKey));
|
|
return new (allocator.allocate<Gfx12CachePolicyAttrStorage>()) Gfx12CachePolicyAttrStorage(std::move(value));
|
|
}
|
|
|
|
::mlir::ROCDL::Gfx12CachePolicy value;
|
|
};
|
|
|
|
} // namespace detail
|
|
Gfx12CachePolicyAttr Gfx12CachePolicyAttr::get(::mlir::MLIRContext *context, ::mlir::ROCDL::Gfx12CachePolicy value) {
|
|
return Base::get(context, std::move(value));
|
|
}
|
|
|
|
::mlir::Attribute Gfx12CachePolicyAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {
|
|
::mlir::Builder odsBuilder(odsParser.getContext());
|
|
::llvm::SMLoc odsLoc = odsParser.getCurrentLocation();
|
|
(void) odsLoc;
|
|
::mlir::FailureOr<::mlir::ROCDL::Gfx12CachePolicy> _result_value;
|
|
|
|
// Parse variable 'value'
|
|
_result_value = ::mlir::FieldParser<::mlir::ROCDL::Gfx12CachePolicy>::parse(odsParser);
|
|
if (::mlir::failed(_result_value)) {
|
|
odsParser.emitError(odsParser.getCurrentLocation(), "failed to parse ROCDL_Gfx12CachePolicyAttr parameter 'value' which is to be a `::mlir::ROCDL::Gfx12CachePolicy`");
|
|
return {};
|
|
}
|
|
assert(::mlir::succeeded(_result_value));
|
|
return Gfx12CachePolicyAttr::get(odsParser.getContext(),
|
|
::mlir::ROCDL::Gfx12CachePolicy((*_result_value)));
|
|
}
|
|
|
|
void Gfx12CachePolicyAttr::print(::mlir::AsmPrinter &odsPrinter) const {
|
|
::mlir::Builder odsBuilder(getContext());
|
|
odsPrinter.printStrippedAttrOrType(getValue());
|
|
}
|
|
|
|
::mlir::ROCDL::Gfx12CachePolicy Gfx12CachePolicyAttr::getValue() const {
|
|
return getImpl()->value;
|
|
}
|
|
|
|
|
|
} // namespace mlir::ROCDL
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::ROCDL::Gfx12CachePolicyAttr)
|
|
namespace mlir::ROCDL {
|
|
|
|
namespace detail {
|
|
|
|
struct Gfx12AtomicCachePolicyAttrStorage : public ::mlir::AttributeStorage {
|
|
using KeyTy = std::tuple<::mlir::ROCDL::Gfx12AtomicCachePolicy>;
|
|
Gfx12AtomicCachePolicyAttrStorage(::mlir::ROCDL::Gfx12AtomicCachePolicy value) : value(std::move(value)) {}
|
|
|
|
KeyTy getAsKey() const {
|
|
return KeyTy(value);
|
|
}
|
|
|
|
bool operator==(const KeyTy &tblgenKey) const {
|
|
return (value == std::get<0>(tblgenKey));
|
|
}
|
|
|
|
static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
|
|
return ::llvm::hash_combine(std::get<0>(tblgenKey));
|
|
}
|
|
|
|
static Gfx12AtomicCachePolicyAttrStorage *construct(::mlir::AttributeStorageAllocator &allocator, KeyTy &&tblgenKey) {
|
|
auto value = std::move(std::get<0>(tblgenKey));
|
|
return new (allocator.allocate<Gfx12AtomicCachePolicyAttrStorage>()) Gfx12AtomicCachePolicyAttrStorage(std::move(value));
|
|
}
|
|
|
|
::mlir::ROCDL::Gfx12AtomicCachePolicy value;
|
|
};
|
|
|
|
} // namespace detail
|
|
Gfx12AtomicCachePolicyAttr Gfx12AtomicCachePolicyAttr::get(::mlir::MLIRContext *context, ::mlir::ROCDL::Gfx12AtomicCachePolicy value) {
|
|
return Base::get(context, std::move(value));
|
|
}
|
|
|
|
::mlir::Attribute Gfx12AtomicCachePolicyAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {
|
|
::mlir::Builder odsBuilder(odsParser.getContext());
|
|
::llvm::SMLoc odsLoc = odsParser.getCurrentLocation();
|
|
(void) odsLoc;
|
|
::mlir::FailureOr<::mlir::ROCDL::Gfx12AtomicCachePolicy> _result_value;
|
|
|
|
// Parse variable 'value'
|
|
_result_value = ::mlir::FieldParser<::mlir::ROCDL::Gfx12AtomicCachePolicy>::parse(odsParser);
|
|
if (::mlir::failed(_result_value)) {
|
|
odsParser.emitError(odsParser.getCurrentLocation(), "failed to parse ROCDL_Gfx12AtomicCachePolicyAttr parameter 'value' which is to be a `::mlir::ROCDL::Gfx12AtomicCachePolicy`");
|
|
return {};
|
|
}
|
|
assert(::mlir::succeeded(_result_value));
|
|
return Gfx12AtomicCachePolicyAttr::get(odsParser.getContext(),
|
|
::mlir::ROCDL::Gfx12AtomicCachePolicy((*_result_value)));
|
|
}
|
|
|
|
void Gfx12AtomicCachePolicyAttr::print(::mlir::AsmPrinter &odsPrinter) const {
|
|
::mlir::Builder odsBuilder(getContext());
|
|
odsPrinter.printStrippedAttrOrType(getValue());
|
|
}
|
|
|
|
::mlir::ROCDL::Gfx12AtomicCachePolicy Gfx12AtomicCachePolicyAttr::getValue() const {
|
|
return getImpl()->value;
|
|
}
|
|
|
|
|
|
} // namespace mlir::ROCDL
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::ROCDL::Gfx12AtomicCachePolicyAttr)
|
|
namespace mlir::ROCDL {
|
|
|
|
namespace detail {
|
|
|
|
struct ROCDLTargetAttrStorage : public ::mlir::AttributeStorage {
|
|
using KeyTy = std::tuple<int, ::llvm::StringRef, ::llvm::StringRef, ::llvm::StringRef, ::llvm::StringRef, DictionaryAttr, ArrayAttr>;
|
|
ROCDLTargetAttrStorage(int O, ::llvm::StringRef triple, ::llvm::StringRef chip, ::llvm::StringRef features, ::llvm::StringRef abi, DictionaryAttr flags, ArrayAttr link) : O(std::move(O)), triple(std::move(triple)), chip(std::move(chip)), features(std::move(features)), abi(std::move(abi)), flags(std::move(flags)), link(std::move(link)) {}
|
|
|
|
KeyTy getAsKey() const {
|
|
return KeyTy(O, triple, chip, features, abi, flags, link);
|
|
}
|
|
|
|
bool operator==(const KeyTy &tblgenKey) const {
|
|
return (O == std::get<0>(tblgenKey)) && (triple == std::get<1>(tblgenKey)) && (chip == std::get<2>(tblgenKey)) && (features == std::get<3>(tblgenKey)) && (abi == std::get<4>(tblgenKey)) && (flags == std::get<5>(tblgenKey)) && (link == std::get<6>(tblgenKey));
|
|
}
|
|
|
|
static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
|
|
return ::llvm::hash_combine(std::get<0>(tblgenKey), std::get<1>(tblgenKey), std::get<2>(tblgenKey), std::get<3>(tblgenKey), std::get<4>(tblgenKey), std::get<5>(tblgenKey), std::get<6>(tblgenKey));
|
|
}
|
|
|
|
static ROCDLTargetAttrStorage *construct(::mlir::AttributeStorageAllocator &allocator, KeyTy &&tblgenKey) {
|
|
auto O = std::move(std::get<0>(tblgenKey));
|
|
auto triple = std::move(std::get<1>(tblgenKey));
|
|
auto chip = std::move(std::get<2>(tblgenKey));
|
|
auto features = std::move(std::get<3>(tblgenKey));
|
|
auto abi = std::move(std::get<4>(tblgenKey));
|
|
auto flags = std::move(std::get<5>(tblgenKey));
|
|
auto link = std::move(std::get<6>(tblgenKey));
|
|
triple = allocator.copyInto(triple);
|
|
chip = allocator.copyInto(chip);
|
|
features = allocator.copyInto(features);
|
|
abi = allocator.copyInto(abi);
|
|
return new (allocator.allocate<ROCDLTargetAttrStorage>()) ROCDLTargetAttrStorage(std::move(O), std::move(triple), std::move(chip), std::move(features), std::move(abi), std::move(flags), std::move(link));
|
|
}
|
|
|
|
int O;
|
|
::llvm::StringRef triple;
|
|
::llvm::StringRef chip;
|
|
::llvm::StringRef features;
|
|
::llvm::StringRef abi;
|
|
DictionaryAttr flags;
|
|
ArrayAttr link;
|
|
};
|
|
|
|
} // namespace detail
|
|
bool ROCDLTargetAttr::hasFlag(StringRef flag) const {
|
|
if (DictionaryAttr flags = getFlags())
|
|
return flags.get(flag) != nullptr;
|
|
return false;
|
|
}
|
|
bool ROCDLTargetAttr::hasWave64() const {
|
|
return hasFlag("wave64") || !hasFlag("no_wave64");
|
|
}
|
|
bool ROCDLTargetAttr::hasFastMath() const {
|
|
return hasFlag("fast");
|
|
}
|
|
bool ROCDLTargetAttr::hasDaz() const {
|
|
return hasFlag("daz");
|
|
}
|
|
bool ROCDLTargetAttr::hasFiniteOnly() const {
|
|
return hasFlag("finite_only");
|
|
}
|
|
bool ROCDLTargetAttr::hasUnsafeMath() const {
|
|
return hasFlag("unsafe_math");
|
|
}
|
|
bool ROCDLTargetAttr::hasCorrectSqrt() const {
|
|
return !hasFlag("unsafe_sqrt");
|
|
}
|
|
ROCDLTargetAttr ROCDLTargetAttr::get(::mlir::MLIRContext *context, int optLevel, StringRef triple, StringRef chip, StringRef features, StringRef abiVersion, DictionaryAttr targetFlags, ArrayAttr linkFiles) {
|
|
return Base::get(context, optLevel, triple, chip, features, abiVersion,
|
|
targetFlags, linkFiles);
|
|
}
|
|
|
|
ROCDLTargetAttr ROCDLTargetAttr::getChecked(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::mlir::MLIRContext *context, int optLevel, StringRef triple, StringRef chip, StringRef features, StringRef abiVersion, DictionaryAttr targetFlags, ArrayAttr linkFiles) {
|
|
return Base::get(context, optLevel, triple, chip, features, abiVersion,
|
|
targetFlags, linkFiles);
|
|
}
|
|
|
|
::llvm::LogicalResult ROCDLTargetAttr::verifyInvariants(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, int O, ::llvm::StringRef triple, ::llvm::StringRef chip, ::llvm::StringRef features, ::llvm::StringRef abi, DictionaryAttr flags, ArrayAttr link) {
|
|
if (::mlir::failed(verify(emitError, O, triple, chip, features, abi, flags, link)))
|
|
return ::mlir::failure();
|
|
return ::mlir::success();
|
|
}
|
|
|
|
::mlir::Attribute ROCDLTargetAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {
|
|
::mlir::Builder odsBuilder(odsParser.getContext());
|
|
::llvm::SMLoc odsLoc = odsParser.getCurrentLocation();
|
|
(void) odsLoc;
|
|
::mlir::FailureOr<int> _result_O;
|
|
::mlir::FailureOr<std::string> _result_triple;
|
|
::mlir::FailureOr<std::string> _result_chip;
|
|
::mlir::FailureOr<std::string> _result_features;
|
|
::mlir::FailureOr<std::string> _result_abi;
|
|
::mlir::FailureOr<DictionaryAttr> _result_flags;
|
|
::mlir::FailureOr<ArrayAttr> _result_link;
|
|
// Parse literal '<'
|
|
if (odsParser.parseOptionalLess()) {
|
|
} else {
|
|
// Parse parameter struct
|
|
bool _seen_O = false;
|
|
bool _seen_triple = false;
|
|
bool _seen_chip = false;
|
|
bool _seen_features = false;
|
|
bool _seen_abi = false;
|
|
bool _seen_flags = false;
|
|
bool _seen_link = false;
|
|
{
|
|
const auto _loop_body = [&](::llvm::StringRef _paramKey) -> bool {
|
|
// Parse literal '='
|
|
if (odsParser.parseEqual()) return {};
|
|
if (!_seen_O && _paramKey == "O") {
|
|
_seen_O = true;
|
|
|
|
// Parse variable 'O'
|
|
_result_O = ::mlir::FieldParser<int>::parse(odsParser);
|
|
if (::mlir::failed(_result_O)) {
|
|
odsParser.emitError(odsParser.getCurrentLocation(), "failed to parse ROCDL_TargetAttr parameter 'O' which is to be a `int`");
|
|
return {};
|
|
}
|
|
} else if (!_seen_triple && _paramKey == "triple") {
|
|
_seen_triple = true;
|
|
|
|
// Parse variable 'triple'
|
|
_result_triple = ::mlir::FieldParser<std::string>::parse(odsParser);
|
|
if (::mlir::failed(_result_triple)) {
|
|
odsParser.emitError(odsParser.getCurrentLocation(), "failed to parse ROCDL_TargetAttr parameter 'triple' which is to be a `::llvm::StringRef`");
|
|
return {};
|
|
}
|
|
} else if (!_seen_chip && _paramKey == "chip") {
|
|
_seen_chip = true;
|
|
|
|
// Parse variable 'chip'
|
|
_result_chip = ::mlir::FieldParser<std::string>::parse(odsParser);
|
|
if (::mlir::failed(_result_chip)) {
|
|
odsParser.emitError(odsParser.getCurrentLocation(), "failed to parse ROCDL_TargetAttr parameter 'chip' which is to be a `::llvm::StringRef`");
|
|
return {};
|
|
}
|
|
} else if (!_seen_features && _paramKey == "features") {
|
|
_seen_features = true;
|
|
|
|
// Parse variable 'features'
|
|
_result_features = ::mlir::FieldParser<std::string>::parse(odsParser);
|
|
if (::mlir::failed(_result_features)) {
|
|
odsParser.emitError(odsParser.getCurrentLocation(), "failed to parse ROCDL_TargetAttr parameter 'features' which is to be a `::llvm::StringRef`");
|
|
return {};
|
|
}
|
|
} else if (!_seen_abi && _paramKey == "abi") {
|
|
_seen_abi = true;
|
|
|
|
// Parse variable 'abi'
|
|
_result_abi = ::mlir::FieldParser<std::string>::parse(odsParser);
|
|
if (::mlir::failed(_result_abi)) {
|
|
odsParser.emitError(odsParser.getCurrentLocation(), "failed to parse ROCDL_TargetAttr parameter 'abi' which is to be a `::llvm::StringRef`");
|
|
return {};
|
|
}
|
|
} else if (!_seen_flags && _paramKey == "flags") {
|
|
_seen_flags = true;
|
|
|
|
// Parse variable 'flags'
|
|
_result_flags = ::mlir::FieldParser<DictionaryAttr>::parse(odsParser);
|
|
if (::mlir::failed(_result_flags)) {
|
|
odsParser.emitError(odsParser.getCurrentLocation(), "failed to parse ROCDL_TargetAttr parameter 'flags' which is to be a `DictionaryAttr`");
|
|
return {};
|
|
}
|
|
} else if (!_seen_link && _paramKey == "link") {
|
|
_seen_link = true;
|
|
|
|
// Parse variable 'link'
|
|
_result_link = ::mlir::FieldParser<ArrayAttr>::parse(odsParser);
|
|
if (::mlir::failed(_result_link)) {
|
|
odsParser.emitError(odsParser.getCurrentLocation(), "failed to parse ROCDL_TargetAttr parameter 'link' which is to be a `ArrayAttr`");
|
|
return {};
|
|
}
|
|
} else {
|
|
odsParser.emitError(odsParser.getCurrentLocation(), "duplicate or unknown struct parameter name: ") << _paramKey;
|
|
return {};
|
|
}
|
|
return true;
|
|
};
|
|
::llvm::StringRef _paramKey;
|
|
if (!odsParser.parseOptionalKeyword(&_paramKey)) {
|
|
if (!_loop_body(_paramKey)) return {};
|
|
while (!odsParser.parseOptionalComma()) {
|
|
::llvm::StringRef _paramKey;
|
|
if (odsParser.parseKeyword(&_paramKey)) {
|
|
odsParser.emitError(odsParser.getCurrentLocation(),
|
|
"expected a parameter name in struct");
|
|
return {};
|
|
}
|
|
if (!_loop_body(_paramKey)) return {};
|
|
}
|
|
}
|
|
}
|
|
// Parse literal '>'
|
|
if (odsParser.parseGreater()) return {};
|
|
}
|
|
return odsParser.getChecked<ROCDLTargetAttr>(odsLoc, odsParser.getContext(),
|
|
int((_result_O.value_or(2))),
|
|
::llvm::StringRef((_result_triple.value_or("amdgcn-amd-amdhsa"))),
|
|
::llvm::StringRef((_result_chip.value_or("gfx900"))),
|
|
::llvm::StringRef((_result_features.value_or(""))),
|
|
::llvm::StringRef((_result_abi.value_or("600"))),
|
|
DictionaryAttr((_result_flags.value_or(DictionaryAttr()))),
|
|
ArrayAttr((_result_link.value_or(ArrayAttr()))));
|
|
}
|
|
|
|
void ROCDLTargetAttr::print(::mlir::AsmPrinter &odsPrinter) const {
|
|
::mlir::Builder odsBuilder(getContext());
|
|
if (!(getO() == 2) || !(getTriple() == "amdgcn-amd-amdhsa") || !(getChip() == "gfx900") || !(getFeatures() == "") || !(getAbi() == "600") || !(getFlags() == DictionaryAttr()) || !(getLink() == ArrayAttr())) {
|
|
odsPrinter << "<";
|
|
{
|
|
bool _firstPrinted = true;
|
|
if (!(getO() == 2)) {
|
|
if (!_firstPrinted) odsPrinter << ", ";
|
|
_firstPrinted = false;
|
|
odsPrinter << "O = ";
|
|
if (!(getO() == 2)) {
|
|
odsPrinter.printStrippedAttrOrType(getO());
|
|
}
|
|
}
|
|
if (!(getTriple() == "amdgcn-amd-amdhsa")) {
|
|
if (!_firstPrinted) odsPrinter << ", ";
|
|
_firstPrinted = false;
|
|
odsPrinter << "triple = ";
|
|
if (!(getTriple() == "amdgcn-amd-amdhsa")) {
|
|
odsPrinter.printString(getTriple());;
|
|
}
|
|
}
|
|
if (!(getChip() == "gfx900")) {
|
|
if (!_firstPrinted) odsPrinter << ", ";
|
|
_firstPrinted = false;
|
|
odsPrinter << "chip = ";
|
|
if (!(getChip() == "gfx900")) {
|
|
odsPrinter.printString(getChip());;
|
|
}
|
|
}
|
|
if (!(getFeatures() == "")) {
|
|
if (!_firstPrinted) odsPrinter << ", ";
|
|
_firstPrinted = false;
|
|
odsPrinter << "features = ";
|
|
if (!(getFeatures() == "")) {
|
|
odsPrinter.printString(getFeatures());;
|
|
}
|
|
}
|
|
if (!(getAbi() == "600")) {
|
|
if (!_firstPrinted) odsPrinter << ", ";
|
|
_firstPrinted = false;
|
|
odsPrinter << "abi = ";
|
|
if (!(getAbi() == "600")) {
|
|
odsPrinter.printString(getAbi());;
|
|
}
|
|
}
|
|
if (!(getFlags() == DictionaryAttr())) {
|
|
if (!_firstPrinted) odsPrinter << ", ";
|
|
_firstPrinted = false;
|
|
odsPrinter << "flags = ";
|
|
if (!(getFlags() == DictionaryAttr())) {
|
|
odsPrinter.printStrippedAttrOrType(getFlags());
|
|
}
|
|
}
|
|
if (!(getLink() == ArrayAttr())) {
|
|
if (!_firstPrinted) odsPrinter << ", ";
|
|
_firstPrinted = false;
|
|
odsPrinter << "link = ";
|
|
if (!(getLink() == ArrayAttr())) {
|
|
odsPrinter.printStrippedAttrOrType(getLink());
|
|
}
|
|
}
|
|
}
|
|
odsPrinter << ">";
|
|
} else {
|
|
}
|
|
}
|
|
|
|
int ROCDLTargetAttr::getO() const {
|
|
return getImpl()->O;
|
|
}
|
|
|
|
::llvm::StringRef ROCDLTargetAttr::getTriple() const {
|
|
return getImpl()->triple;
|
|
}
|
|
|
|
::llvm::StringRef ROCDLTargetAttr::getChip() const {
|
|
return getImpl()->chip;
|
|
}
|
|
|
|
::llvm::StringRef ROCDLTargetAttr::getFeatures() const {
|
|
return getImpl()->features;
|
|
}
|
|
|
|
::llvm::StringRef ROCDLTargetAttr::getAbi() const {
|
|
return getImpl()->abi;
|
|
}
|
|
|
|
DictionaryAttr ROCDLTargetAttr::getFlags() const {
|
|
return getImpl()->flags;
|
|
}
|
|
|
|
ArrayAttr ROCDLTargetAttr::getLink() const {
|
|
return getImpl()->link;
|
|
}
|
|
|
|
|
|
} // namespace mlir::ROCDL
|
|
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::ROCDL::ROCDLTargetAttr)
|
|
namespace mlir::ROCDL {
|
|
|
|
|
|
/// Parse an attribute registered to this dialect.
|
|
::mlir::Attribute ROCDLDialect::parseAttribute(::mlir::DialectAsmParser &parser,
|
|
::mlir::Type type) const {
|
|
::llvm::SMLoc typeLoc = parser.getCurrentLocation();
|
|
::llvm::StringRef attrTag;
|
|
{
|
|
::mlir::Attribute attr;
|
|
auto parseResult = generatedAttributeParser(parser, &attrTag, type, attr);
|
|
if (parseResult.has_value())
|
|
return attr;
|
|
}
|
|
|
|
parser.emitError(typeLoc) << "unknown attribute `"
|
|
<< attrTag << "` in dialect `" << getNamespace() << "`";
|
|
return {};
|
|
}
|
|
/// Print an attribute registered to this dialect.
|
|
void ROCDLDialect::printAttribute(::mlir::Attribute attr,
|
|
::mlir::DialectAsmPrinter &printer) const {
|
|
if (::mlir::succeeded(generatedAttributePrinter(attr, printer)))
|
|
return;
|
|
|
|
}
|
|
|
|
} // namespace mlir::ROCDL
|
|
|
|
#endif // GET_ATTRDEF_CLASSES
|
|
|