17239 lines
635 KiB
C++
17239 lines
635 KiB
C++
/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
|
|
|* *|
|
|
|* SPIR-V Serialization Utilities/Functions *|
|
|
|* *|
|
|
|* Automatically generated file, do not edit! *|
|
|
|* From: SPIRVOps.td *|
|
|
|* *|
|
|
\*===----------------------------------------------------------------------===*/
|
|
|
|
#ifdef GET_SERIALIZATION_FNS
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::AccessChainOp>(::mlir::spirv::AccessChainOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
for (Value operand : op->getOperands()) {
|
|
auto id = getValueID(operand);
|
|
assert(id && "use before def!");
|
|
operands.push_back(id);
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpAccessChain, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::AllOp>(::mlir::spirv::AllOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpAll));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::AnyOp>(::mlir::spirv::AnyOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpAny));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::AtomicAndOp>(::mlir::spirv::AtomicAndOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("memory_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("memory_scope");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("semantics")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::MemorySemanticsAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("semantics");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpAtomicAnd, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::AtomicCompareExchangeOp>(::mlir::spirv::AtomicCompareExchangeOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("memory_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("memory_scope");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("equal_semantics")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::MemorySemanticsAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("equal_semantics");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("unequal_semantics")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::MemorySemanticsAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("unequal_semantics");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(2)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #2 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpAtomicCompareExchange, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::AtomicCompareExchangeWeakOp>(::mlir::spirv::AtomicCompareExchangeWeakOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("memory_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("memory_scope");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("equal_semantics")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::MemorySemanticsAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("equal_semantics");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("unequal_semantics")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::MemorySemanticsAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("unequal_semantics");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(2)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #2 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpAtomicCompareExchangeWeak, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::AtomicExchangeOp>(::mlir::spirv::AtomicExchangeOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("memory_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("memory_scope");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("semantics")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::MemorySemanticsAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("semantics");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpAtomicExchange, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::AtomicIAddOp>(::mlir::spirv::AtomicIAddOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("memory_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("memory_scope");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("semantics")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::MemorySemanticsAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("semantics");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpAtomicIAdd, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::AtomicIDecrementOp>(::mlir::spirv::AtomicIDecrementOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
for (Value operand : op->getOperands()) {
|
|
auto id = getValueID(operand);
|
|
assert(id && "use before def!");
|
|
operands.push_back(id);
|
|
}
|
|
if (auto attr = op->getAttr("memory_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("memory_scope");
|
|
if (auto attr = op->getAttr("semantics")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::MemorySemanticsAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("semantics");
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpAtomicIDecrement, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::AtomicIIncrementOp>(::mlir::spirv::AtomicIIncrementOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
for (Value operand : op->getOperands()) {
|
|
auto id = getValueID(operand);
|
|
assert(id && "use before def!");
|
|
operands.push_back(id);
|
|
}
|
|
if (auto attr = op->getAttr("memory_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("memory_scope");
|
|
if (auto attr = op->getAttr("semantics")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::MemorySemanticsAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("semantics");
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpAtomicIIncrement, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::AtomicISubOp>(::mlir::spirv::AtomicISubOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("memory_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("memory_scope");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("semantics")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::MemorySemanticsAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("semantics");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpAtomicISub, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::AtomicLoadOp>(::mlir::spirv::AtomicLoadOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
for (Value operand : op->getOperands()) {
|
|
auto id = getValueID(operand);
|
|
assert(id && "use before def!");
|
|
operands.push_back(id);
|
|
}
|
|
if (auto attr = op->getAttr("memory_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("memory_scope");
|
|
if (auto attr = op->getAttr("semantics")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::MemorySemanticsAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("semantics");
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpAtomicLoad, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::AtomicOrOp>(::mlir::spirv::AtomicOrOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("memory_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("memory_scope");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("semantics")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::MemorySemanticsAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("semantics");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpAtomicOr, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::AtomicSMaxOp>(::mlir::spirv::AtomicSMaxOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("memory_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("memory_scope");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("semantics")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::MemorySemanticsAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("semantics");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpAtomicSMax, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::AtomicSMinOp>(::mlir::spirv::AtomicSMinOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("memory_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("memory_scope");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("semantics")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::MemorySemanticsAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("semantics");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpAtomicSMin, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::AtomicStoreOp>(::mlir::spirv::AtomicStoreOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("memory_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("memory_scope");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("semantics")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::MemorySemanticsAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("semantics");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpAtomicStore, operands);
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::AtomicUMaxOp>(::mlir::spirv::AtomicUMaxOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("memory_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("memory_scope");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("semantics")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::MemorySemanticsAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("semantics");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpAtomicUMax, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::AtomicUMinOp>(::mlir::spirv::AtomicUMinOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("memory_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("memory_scope");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("semantics")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::MemorySemanticsAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("semantics");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpAtomicUMin, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::AtomicXorOp>(::mlir::spirv::AtomicXorOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("memory_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("memory_scope");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("semantics")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::MemorySemanticsAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("semantics");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpAtomicXor, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::BitCountOp>(::mlir::spirv::BitCountOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpBitCount));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::BitFieldInsertOp>(::mlir::spirv::BitFieldInsertOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpBitFieldInsert));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::BitFieldSExtractOp>(::mlir::spirv::BitFieldSExtractOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpBitFieldSExtract));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::BitFieldUExtractOp>(::mlir::spirv::BitFieldUExtractOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpBitFieldUExtract));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::BitReverseOp>(::mlir::spirv::BitReverseOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpBitReverse));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::BitcastOp>(::mlir::spirv::BitcastOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpBitcast));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::BitwiseAndOp>(::mlir::spirv::BitwiseAndOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpBitwiseAnd));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::BitwiseOrOp>(::mlir::spirv::BitwiseOrOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpBitwiseOr));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::BitwiseXorOp>(::mlir::spirv::BitwiseXorOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpBitwiseXor));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::CLAcosOp>(::mlir::spirv::CLAcosOp op) {
|
|
return processOpWithoutGrammarAttr(op, "OpenCL.std", 0);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::CLAcoshOp>(::mlir::spirv::CLAcoshOp op) {
|
|
return processOpWithoutGrammarAttr(op, "OpenCL.std", 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::CLAsinOp>(::mlir::spirv::CLAsinOp op) {
|
|
return processOpWithoutGrammarAttr(op, "OpenCL.std", 3);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::CLAsinhOp>(::mlir::spirv::CLAsinhOp op) {
|
|
return processOpWithoutGrammarAttr(op, "OpenCL.std", 4);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::CLAtan2Op>(::mlir::spirv::CLAtan2Op op) {
|
|
return processOpWithoutGrammarAttr(op, "OpenCL.std", 7);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::CLAtanOp>(::mlir::spirv::CLAtanOp op) {
|
|
return processOpWithoutGrammarAttr(op, "OpenCL.std", 6);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::CLAtanhOp>(::mlir::spirv::CLAtanhOp op) {
|
|
return processOpWithoutGrammarAttr(op, "OpenCL.std", 8);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::CLCbrtOp>(::mlir::spirv::CLCbrtOp op) {
|
|
return processOpWithoutGrammarAttr(op, "OpenCL.std", 11);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::CLCeilOp>(::mlir::spirv::CLCeilOp op) {
|
|
return processOpWithoutGrammarAttr(op, "OpenCL.std", 12);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::CLClzOp>(::mlir::spirv::CLClzOp op) {
|
|
return processOpWithoutGrammarAttr(op, "OpenCL.std", 151);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::CLCosOp>(::mlir::spirv::CLCosOp op) {
|
|
return processOpWithoutGrammarAttr(op, "OpenCL.std", 14);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::CLCoshOp>(::mlir::spirv::CLCoshOp op) {
|
|
return processOpWithoutGrammarAttr(op, "OpenCL.std", 15);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::CLErfOp>(::mlir::spirv::CLErfOp op) {
|
|
return processOpWithoutGrammarAttr(op, "OpenCL.std", 18);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::CLErfcOp>(::mlir::spirv::CLErfcOp op) {
|
|
return processOpWithoutGrammarAttr(op, "OpenCL.std", 17);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::CLExp2Op>(::mlir::spirv::CLExp2Op op) {
|
|
return processOpWithoutGrammarAttr(op, "OpenCL.std", 20);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::CLExp10Op>(::mlir::spirv::CLExp10Op op) {
|
|
return processOpWithoutGrammarAttr(op, "OpenCL.std", 21);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::CLExpOp>(::mlir::spirv::CLExpOp op) {
|
|
return processOpWithoutGrammarAttr(op, "OpenCL.std", 19);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::CLExpm1Op>(::mlir::spirv::CLExpm1Op op) {
|
|
return processOpWithoutGrammarAttr(op, "OpenCL.std", 22);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::CLFAbsOp>(::mlir::spirv::CLFAbsOp op) {
|
|
return processOpWithoutGrammarAttr(op, "OpenCL.std", 23);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::CLFMaxOp>(::mlir::spirv::CLFMaxOp op) {
|
|
return processOpWithoutGrammarAttr(op, "OpenCL.std", 27);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::CLFMinOp>(::mlir::spirv::CLFMinOp op) {
|
|
return processOpWithoutGrammarAttr(op, "OpenCL.std", 28);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::CLFloorOp>(::mlir::spirv::CLFloorOp op) {
|
|
return processOpWithoutGrammarAttr(op, "OpenCL.std", 25);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::CLFmaOp>(::mlir::spirv::CLFmaOp op) {
|
|
return processOpWithoutGrammarAttr(op, "OpenCL.std", 26);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::CLLdexpOp>(::mlir::spirv::CLLdexpOp op) {
|
|
return processOpWithoutGrammarAttr(op, "OpenCL.std", 34);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::CLLog1pOp>(::mlir::spirv::CLLog1pOp op) {
|
|
return processOpWithoutGrammarAttr(op, "OpenCL.std", 40);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::CLLog2Op>(::mlir::spirv::CLLog2Op op) {
|
|
return processOpWithoutGrammarAttr(op, "OpenCL.std", 38);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::CLLog10Op>(::mlir::spirv::CLLog10Op op) {
|
|
return processOpWithoutGrammarAttr(op, "OpenCL.std", 39);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::CLLogOp>(::mlir::spirv::CLLogOp op) {
|
|
return processOpWithoutGrammarAttr(op, "OpenCL.std", 37);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::CLMixOp>(::mlir::spirv::CLMixOp op) {
|
|
return processOpWithoutGrammarAttr(op, "OpenCL.std", 99);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::CLPowOp>(::mlir::spirv::CLPowOp op) {
|
|
return processOpWithoutGrammarAttr(op, "OpenCL.std", 48);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::CLPownOp>(::mlir::spirv::CLPownOp op) {
|
|
return processOpWithoutGrammarAttr(op, "OpenCL.std", 49);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::CLPrintfOp>(::mlir::spirv::CLPrintfOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
for (Value operand : op->getOperands()) {
|
|
auto id = getValueID(operand);
|
|
assert(id && "use before def!");
|
|
operands.push_back(id);
|
|
}
|
|
(void)encodeExtensionInstruction(op, "OpenCL.std", 184, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::CLRintOp>(::mlir::spirv::CLRintOp op) {
|
|
return processOpWithoutGrammarAttr(op, "OpenCL.std", 53);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::CLRootnOp>(::mlir::spirv::CLRootnOp op) {
|
|
return processOpWithoutGrammarAttr(op, "OpenCL.std", 54);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::CLRoundOp>(::mlir::spirv::CLRoundOp op) {
|
|
return processOpWithoutGrammarAttr(op, "OpenCL.std", 55);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::CLRsqrtOp>(::mlir::spirv::CLRsqrtOp op) {
|
|
return processOpWithoutGrammarAttr(op, "OpenCL.std", 56);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::CLSAbsOp>(::mlir::spirv::CLSAbsOp op) {
|
|
return processOpWithoutGrammarAttr(op, "OpenCL.std", 141);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::CLSMaxOp>(::mlir::spirv::CLSMaxOp op) {
|
|
return processOpWithoutGrammarAttr(op, "OpenCL.std", 156);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::CLSMinOp>(::mlir::spirv::CLSMinOp op) {
|
|
return processOpWithoutGrammarAttr(op, "OpenCL.std", 158);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::CLSinOp>(::mlir::spirv::CLSinOp op) {
|
|
return processOpWithoutGrammarAttr(op, "OpenCL.std", 57);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::CLSinhOp>(::mlir::spirv::CLSinhOp op) {
|
|
return processOpWithoutGrammarAttr(op, "OpenCL.std", 59);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::CLSqrtOp>(::mlir::spirv::CLSqrtOp op) {
|
|
return processOpWithoutGrammarAttr(op, "OpenCL.std", 61);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::CLTanOp>(::mlir::spirv::CLTanOp op) {
|
|
return processOpWithoutGrammarAttr(op, "OpenCL.std", 62);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::CLTanhOp>(::mlir::spirv::CLTanhOp op) {
|
|
return processOpWithoutGrammarAttr(op, "OpenCL.std", 63);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::CLTruncOp>(::mlir::spirv::CLTruncOp op) {
|
|
return processOpWithoutGrammarAttr(op, "OpenCL.std", 66);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::CLUMaxOp>(::mlir::spirv::CLUMaxOp op) {
|
|
return processOpWithoutGrammarAttr(op, "OpenCL.std", 157);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::CLUMinOp>(::mlir::spirv::CLUMinOp op) {
|
|
return processOpWithoutGrammarAttr(op, "OpenCL.std", 159);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::CompositeConstructOp>(::mlir::spirv::CompositeConstructOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
for (Value operand : op->getOperands()) {
|
|
auto id = getValueID(operand);
|
|
assert(id && "use before def!");
|
|
operands.push_back(id);
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpCompositeConstruct, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::CompositeExtractOp>(::mlir::spirv::CompositeExtractOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
for (Value operand : op->getOperands()) {
|
|
auto id = getValueID(operand);
|
|
assert(id && "use before def!");
|
|
operands.push_back(id);
|
|
}
|
|
if (auto attr = op->getAttr("indices")) {
|
|
for (auto attrElem : llvm::cast<ArrayAttr>(attr)) {
|
|
operands.push_back(static_cast<uint32_t>(llvm::cast<IntegerAttr>(attrElem).getValue().getZExtValue()));
|
|
}
|
|
}
|
|
elidedAttrs.push_back("indices");
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpCompositeExtract, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::CompositeInsertOp>(::mlir::spirv::CompositeInsertOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
for (Value operand : op->getOperands()) {
|
|
auto id = getValueID(operand);
|
|
assert(id && "use before def!");
|
|
operands.push_back(id);
|
|
}
|
|
if (auto attr = op->getAttr("indices")) {
|
|
for (auto attrElem : llvm::cast<ArrayAttr>(attr)) {
|
|
operands.push_back(static_cast<uint32_t>(llvm::cast<IntegerAttr>(attrElem).getValue().getZExtValue()));
|
|
}
|
|
}
|
|
elidedAttrs.push_back("indices");
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpCompositeInsert, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::ControlBarrierOp>(::mlir::spirv::ControlBarrierOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
if (auto attr = op->getAttr("execution_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("execution_scope");
|
|
if (auto attr = op->getAttr("memory_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("memory_scope");
|
|
if (auto attr = op->getAttr("memory_semantics")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::MemorySemanticsAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("memory_semantics");
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpControlBarrier, operands);
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::ConvertFToSOp>(::mlir::spirv::ConvertFToSOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpConvertFToS));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::ConvertFToUOp>(::mlir::spirv::ConvertFToUOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpConvertFToU));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::ConvertPtrToUOp>(::mlir::spirv::ConvertPtrToUOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpConvertPtrToU));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::ConvertSToFOp>(::mlir::spirv::ConvertSToFOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpConvertSToF));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::ConvertUToFOp>(::mlir::spirv::ConvertUToFOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpConvertUToF));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::ConvertUToPtrOp>(::mlir::spirv::ConvertUToPtrOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpConvertUToPtr));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::DotOp>(::mlir::spirv::DotOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpDot));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::EXTAtomicFAddOp>(::mlir::spirv::EXTAtomicFAddOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("memory_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("memory_scope");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("semantics")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::MemorySemanticsAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("semantics");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpAtomicFAddEXT, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::EXTEmitMeshTasksOp>(::mlir::spirv::EXTEmitMeshTasksOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
for (Value operand : op->getOperands()) {
|
|
auto id = getValueID(operand);
|
|
assert(id && "use before def!");
|
|
operands.push_back(id);
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpEmitMeshTasksEXT, operands);
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::EXTSetMeshOutputsOp>(::mlir::spirv::EXTSetMeshOutputsOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpSetMeshOutputsEXT));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::EmitVertexOp>(::mlir::spirv::EmitVertexOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpEmitVertex));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::EndPrimitiveOp>(::mlir::spirv::EndPrimitiveOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpEndPrimitive));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::ExperimentalMLCallOp>(::mlir::spirv::ExperimentalMLCallOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("opcode")) {
|
|
operands.push_back(static_cast<uint32_t>(llvm::cast<IntegerAttr>(attr).getValue().getZExtValue()));
|
|
}
|
|
elidedAttrs.push_back("opcode");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)encodeExtensionInstruction(op, "Arm.ExperimentalMLOperations.1", 0, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::FAddOp>(::mlir::spirv::FAddOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpFAdd));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::FConvertOp>(::mlir::spirv::FConvertOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpFConvert));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::FDivOp>(::mlir::spirv::FDivOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpFDiv));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::FModOp>(::mlir::spirv::FModOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpFMod));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::FMulOp>(::mlir::spirv::FMulOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpFMul));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::FNegateOp>(::mlir::spirv::FNegateOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpFNegate));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::FOrdEqualOp>(::mlir::spirv::FOrdEqualOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpFOrdEqual));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::FOrdGreaterThanEqualOp>(::mlir::spirv::FOrdGreaterThanEqualOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpFOrdGreaterThanEqual));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::FOrdGreaterThanOp>(::mlir::spirv::FOrdGreaterThanOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpFOrdGreaterThan));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::FOrdLessThanEqualOp>(::mlir::spirv::FOrdLessThanEqualOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpFOrdLessThanEqual));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::FOrdLessThanOp>(::mlir::spirv::FOrdLessThanOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpFOrdLessThan));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::FOrdNotEqualOp>(::mlir::spirv::FOrdNotEqualOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpFOrdNotEqual));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::FRemOp>(::mlir::spirv::FRemOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpFRem));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::FSubOp>(::mlir::spirv::FSubOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpFSub));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::FUnordEqualOp>(::mlir::spirv::FUnordEqualOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpFUnordEqual));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::FUnordGreaterThanEqualOp>(::mlir::spirv::FUnordGreaterThanEqualOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpFUnordGreaterThanEqual));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::FUnordGreaterThanOp>(::mlir::spirv::FUnordGreaterThanOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpFUnordGreaterThan));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::FUnordLessThanEqualOp>(::mlir::spirv::FUnordLessThanEqualOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpFUnordLessThanEqual));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::FUnordLessThanOp>(::mlir::spirv::FUnordLessThanOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpFUnordLessThan));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::FUnordNotEqualOp>(::mlir::spirv::FUnordNotEqualOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpFUnordNotEqual));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLAcosOp>(::mlir::spirv::GLAcosOp op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 17);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLAcoshOp>(::mlir::spirv::GLAcoshOp op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 23);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLAsinOp>(::mlir::spirv::GLAsinOp op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 16);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLAsinhOp>(::mlir::spirv::GLAsinhOp op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 22);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLAtan2Op>(::mlir::spirv::GLAtan2Op op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 25);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLAtanOp>(::mlir::spirv::GLAtanOp op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 18);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLAtanhOp>(::mlir::spirv::GLAtanhOp op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 24);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLCeilOp>(::mlir::spirv::GLCeilOp op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 9);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLCosOp>(::mlir::spirv::GLCosOp op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 14);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLCoshOp>(::mlir::spirv::GLCoshOp op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 20);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLCrossOp>(::mlir::spirv::GLCrossOp op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 68);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLDegreesOp>(::mlir::spirv::GLDegreesOp op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 12);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLDistanceOp>(::mlir::spirv::GLDistanceOp op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 67);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLExp2Op>(::mlir::spirv::GLExp2Op op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 29);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLExpOp>(::mlir::spirv::GLExpOp op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 27);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLFAbsOp>(::mlir::spirv::GLFAbsOp op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 4);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLFClampOp>(::mlir::spirv::GLFClampOp op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 43);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLFMaxOp>(::mlir::spirv::GLFMaxOp op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 40);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLFMinOp>(::mlir::spirv::GLFMinOp op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 37);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLFMixOp>(::mlir::spirv::GLFMixOp op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 46);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLFSignOp>(::mlir::spirv::GLFSignOp op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 6);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLFindILsbOp>(::mlir::spirv::GLFindILsbOp op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 73);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLFindSMsbOp>(::mlir::spirv::GLFindSMsbOp op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 74);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLFindUMsbOp>(::mlir::spirv::GLFindUMsbOp op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 75);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLFloorOp>(::mlir::spirv::GLFloorOp op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 8);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLFmaOp>(::mlir::spirv::GLFmaOp op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 50);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLFractOp>(::mlir::spirv::GLFractOp op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 10);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLFrexpStructOp>(::mlir::spirv::GLFrexpStructOp op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 52);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLInverseSqrtOp>(::mlir::spirv::GLInverseSqrtOp op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 32);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLLdexpOp>(::mlir::spirv::GLLdexpOp op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 53);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLLengthOp>(::mlir::spirv::GLLengthOp op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 66);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLLog2Op>(::mlir::spirv::GLLog2Op op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 30);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLLogOp>(::mlir::spirv::GLLogOp op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 28);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLNormalizeOp>(::mlir::spirv::GLNormalizeOp op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 69);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLPackHalf2x16Op>(::mlir::spirv::GLPackHalf2x16Op op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 58);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLPackSnorm4x8Op>(::mlir::spirv::GLPackSnorm4x8Op op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 54);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLPowOp>(::mlir::spirv::GLPowOp op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 26);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLRadiansOp>(::mlir::spirv::GLRadiansOp op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 11);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLReflectOp>(::mlir::spirv::GLReflectOp op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 71);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLRoundEvenOp>(::mlir::spirv::GLRoundEvenOp op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLRoundOp>(::mlir::spirv::GLRoundOp op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLSAbsOp>(::mlir::spirv::GLSAbsOp op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 5);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLSClampOp>(::mlir::spirv::GLSClampOp op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 45);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLSMaxOp>(::mlir::spirv::GLSMaxOp op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 42);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLSMinOp>(::mlir::spirv::GLSMinOp op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 39);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLSSignOp>(::mlir::spirv::GLSSignOp op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 7);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLSinOp>(::mlir::spirv::GLSinOp op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 13);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLSinhOp>(::mlir::spirv::GLSinhOp op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 19);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLSqrtOp>(::mlir::spirv::GLSqrtOp op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 31);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLTanOp>(::mlir::spirv::GLTanOp op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 15);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLTanhOp>(::mlir::spirv::GLTanhOp op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 21);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLTruncOp>(::mlir::spirv::GLTruncOp op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 3);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLUClampOp>(::mlir::spirv::GLUClampOp op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 44);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLUMaxOp>(::mlir::spirv::GLUMaxOp op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 41);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLUMinOp>(::mlir::spirv::GLUMinOp op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 38);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLUnpackHalf2x16Op>(::mlir::spirv::GLUnpackHalf2x16Op op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 62);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GLUnpackSnorm4x8Op>(::mlir::spirv::GLUnpackSnorm4x8Op op) {
|
|
return processOpWithoutGrammarAttr(op, "GLSL.std.450", 63);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GenericCastToPtrOp>(::mlir::spirv::GenericCastToPtrOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpGenericCastToPtr));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GroupBroadcastOp>(::mlir::spirv::GroupBroadcastOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("execution_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("execution_scope");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpGroupBroadcast, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GroupFAddOp>(::mlir::spirv::GroupFAddOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("execution_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("execution_scope");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("group_operation")) {
|
|
operands.push_back(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::GroupOperationAttr>(attr).getValue()));
|
|
}
|
|
elidedAttrs.push_back("group_operation");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpGroupFAdd, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GroupFMaxOp>(::mlir::spirv::GroupFMaxOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("execution_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("execution_scope");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("group_operation")) {
|
|
operands.push_back(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::GroupOperationAttr>(attr).getValue()));
|
|
}
|
|
elidedAttrs.push_back("group_operation");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpGroupFMax, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GroupFMinOp>(::mlir::spirv::GroupFMinOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("execution_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("execution_scope");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("group_operation")) {
|
|
operands.push_back(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::GroupOperationAttr>(attr).getValue()));
|
|
}
|
|
elidedAttrs.push_back("group_operation");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpGroupFMin, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GroupFMulKHROp>(::mlir::spirv::GroupFMulKHROp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("execution_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("execution_scope");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("group_operation")) {
|
|
operands.push_back(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::GroupOperationAttr>(attr).getValue()));
|
|
}
|
|
elidedAttrs.push_back("group_operation");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpGroupFMulKHR, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GroupIAddOp>(::mlir::spirv::GroupIAddOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("execution_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("execution_scope");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("group_operation")) {
|
|
operands.push_back(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::GroupOperationAttr>(attr).getValue()));
|
|
}
|
|
elidedAttrs.push_back("group_operation");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpGroupIAdd, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GroupIMulKHROp>(::mlir::spirv::GroupIMulKHROp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("execution_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("execution_scope");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("group_operation")) {
|
|
operands.push_back(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::GroupOperationAttr>(attr).getValue()));
|
|
}
|
|
elidedAttrs.push_back("group_operation");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpGroupIMulKHR, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GroupNonUniformAllEqualOp>(::mlir::spirv::GroupNonUniformAllEqualOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("execution_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("execution_scope");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpGroupNonUniformAllEqual, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GroupNonUniformAllOp>(::mlir::spirv::GroupNonUniformAllOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("execution_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("execution_scope");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpGroupNonUniformAll, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GroupNonUniformAnyOp>(::mlir::spirv::GroupNonUniformAnyOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("execution_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("execution_scope");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpGroupNonUniformAny, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GroupNonUniformBallotBitCountOp>(::mlir::spirv::GroupNonUniformBallotBitCountOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("execution_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("execution_scope");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("group_operation")) {
|
|
operands.push_back(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::GroupOperationAttr>(attr).getValue()));
|
|
}
|
|
elidedAttrs.push_back("group_operation");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpGroupNonUniformBallotBitCount, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GroupNonUniformBallotFindLSBOp>(::mlir::spirv::GroupNonUniformBallotFindLSBOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("execution_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("execution_scope");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpGroupNonUniformBallotFindLSB, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GroupNonUniformBallotFindMSBOp>(::mlir::spirv::GroupNonUniformBallotFindMSBOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("execution_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("execution_scope");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpGroupNonUniformBallotFindMSB, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GroupNonUniformBallotOp>(::mlir::spirv::GroupNonUniformBallotOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("execution_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("execution_scope");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpGroupNonUniformBallot, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GroupNonUniformBitwiseAndOp>(::mlir::spirv::GroupNonUniformBitwiseAndOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("execution_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("execution_scope");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("group_operation")) {
|
|
operands.push_back(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::GroupOperationAttr>(attr).getValue()));
|
|
}
|
|
elidedAttrs.push_back("group_operation");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpGroupNonUniformBitwiseAnd, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GroupNonUniformBitwiseOrOp>(::mlir::spirv::GroupNonUniformBitwiseOrOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("execution_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("execution_scope");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("group_operation")) {
|
|
operands.push_back(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::GroupOperationAttr>(attr).getValue()));
|
|
}
|
|
elidedAttrs.push_back("group_operation");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpGroupNonUniformBitwiseOr, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GroupNonUniformBitwiseXorOp>(::mlir::spirv::GroupNonUniformBitwiseXorOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("execution_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("execution_scope");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("group_operation")) {
|
|
operands.push_back(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::GroupOperationAttr>(attr).getValue()));
|
|
}
|
|
elidedAttrs.push_back("group_operation");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpGroupNonUniformBitwiseXor, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GroupNonUniformBroadcastFirstOp>(::mlir::spirv::GroupNonUniformBroadcastFirstOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("execution_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("execution_scope");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpGroupNonUniformBroadcastFirst, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GroupNonUniformBroadcastOp>(::mlir::spirv::GroupNonUniformBroadcastOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("execution_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("execution_scope");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpGroupNonUniformBroadcast, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GroupNonUniformElectOp>(::mlir::spirv::GroupNonUniformElectOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
if (auto attr = op->getAttr("execution_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("execution_scope");
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpGroupNonUniformElect, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GroupNonUniformFAddOp>(::mlir::spirv::GroupNonUniformFAddOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("execution_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("execution_scope");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("group_operation")) {
|
|
operands.push_back(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::GroupOperationAttr>(attr).getValue()));
|
|
}
|
|
elidedAttrs.push_back("group_operation");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpGroupNonUniformFAdd, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GroupNonUniformFMaxOp>(::mlir::spirv::GroupNonUniformFMaxOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("execution_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("execution_scope");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("group_operation")) {
|
|
operands.push_back(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::GroupOperationAttr>(attr).getValue()));
|
|
}
|
|
elidedAttrs.push_back("group_operation");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpGroupNonUniformFMax, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GroupNonUniformFMinOp>(::mlir::spirv::GroupNonUniformFMinOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("execution_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("execution_scope");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("group_operation")) {
|
|
operands.push_back(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::GroupOperationAttr>(attr).getValue()));
|
|
}
|
|
elidedAttrs.push_back("group_operation");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpGroupNonUniformFMin, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GroupNonUniformFMulOp>(::mlir::spirv::GroupNonUniformFMulOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("execution_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("execution_scope");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("group_operation")) {
|
|
operands.push_back(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::GroupOperationAttr>(attr).getValue()));
|
|
}
|
|
elidedAttrs.push_back("group_operation");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpGroupNonUniformFMul, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GroupNonUniformIAddOp>(::mlir::spirv::GroupNonUniformIAddOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("execution_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("execution_scope");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("group_operation")) {
|
|
operands.push_back(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::GroupOperationAttr>(attr).getValue()));
|
|
}
|
|
elidedAttrs.push_back("group_operation");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpGroupNonUniformIAdd, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GroupNonUniformIMulOp>(::mlir::spirv::GroupNonUniformIMulOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("execution_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("execution_scope");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("group_operation")) {
|
|
operands.push_back(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::GroupOperationAttr>(attr).getValue()));
|
|
}
|
|
elidedAttrs.push_back("group_operation");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpGroupNonUniformIMul, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GroupNonUniformLogicalAndOp>(::mlir::spirv::GroupNonUniformLogicalAndOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("execution_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("execution_scope");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("group_operation")) {
|
|
operands.push_back(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::GroupOperationAttr>(attr).getValue()));
|
|
}
|
|
elidedAttrs.push_back("group_operation");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpGroupNonUniformLogicalAnd, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GroupNonUniformLogicalOrOp>(::mlir::spirv::GroupNonUniformLogicalOrOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("execution_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("execution_scope");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("group_operation")) {
|
|
operands.push_back(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::GroupOperationAttr>(attr).getValue()));
|
|
}
|
|
elidedAttrs.push_back("group_operation");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpGroupNonUniformLogicalOr, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GroupNonUniformLogicalXorOp>(::mlir::spirv::GroupNonUniformLogicalXorOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("execution_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("execution_scope");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("group_operation")) {
|
|
operands.push_back(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::GroupOperationAttr>(attr).getValue()));
|
|
}
|
|
elidedAttrs.push_back("group_operation");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpGroupNonUniformLogicalXor, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GroupNonUniformQuadSwapOp>(::mlir::spirv::GroupNonUniformQuadSwapOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("execution_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("execution_scope");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("direction")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::QuadSwapDirectionAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("direction");
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpGroupNonUniformQuadSwap, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GroupNonUniformRotateKHROp>(::mlir::spirv::GroupNonUniformRotateKHROp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("execution_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("execution_scope");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(2)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #2 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpGroupNonUniformRotateKHR, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GroupNonUniformSMaxOp>(::mlir::spirv::GroupNonUniformSMaxOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("execution_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("execution_scope");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("group_operation")) {
|
|
operands.push_back(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::GroupOperationAttr>(attr).getValue()));
|
|
}
|
|
elidedAttrs.push_back("group_operation");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpGroupNonUniformSMax, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GroupNonUniformSMinOp>(::mlir::spirv::GroupNonUniformSMinOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("execution_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("execution_scope");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("group_operation")) {
|
|
operands.push_back(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::GroupOperationAttr>(attr).getValue()));
|
|
}
|
|
elidedAttrs.push_back("group_operation");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpGroupNonUniformSMin, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GroupNonUniformShuffleDownOp>(::mlir::spirv::GroupNonUniformShuffleDownOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("execution_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("execution_scope");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpGroupNonUniformShuffleDown, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GroupNonUniformShuffleOp>(::mlir::spirv::GroupNonUniformShuffleOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("execution_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("execution_scope");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpGroupNonUniformShuffle, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GroupNonUniformShuffleUpOp>(::mlir::spirv::GroupNonUniformShuffleUpOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("execution_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("execution_scope");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpGroupNonUniformShuffleUp, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GroupNonUniformShuffleXorOp>(::mlir::spirv::GroupNonUniformShuffleXorOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("execution_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("execution_scope");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpGroupNonUniformShuffleXor, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GroupNonUniformUMaxOp>(::mlir::spirv::GroupNonUniformUMaxOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("execution_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("execution_scope");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("group_operation")) {
|
|
operands.push_back(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::GroupOperationAttr>(attr).getValue()));
|
|
}
|
|
elidedAttrs.push_back("group_operation");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpGroupNonUniformUMax, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GroupNonUniformUMinOp>(::mlir::spirv::GroupNonUniformUMinOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("execution_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("execution_scope");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("group_operation")) {
|
|
operands.push_back(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::GroupOperationAttr>(attr).getValue()));
|
|
}
|
|
elidedAttrs.push_back("group_operation");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpGroupNonUniformUMin, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GroupSMaxOp>(::mlir::spirv::GroupSMaxOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("execution_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("execution_scope");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("group_operation")) {
|
|
operands.push_back(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::GroupOperationAttr>(attr).getValue()));
|
|
}
|
|
elidedAttrs.push_back("group_operation");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpGroupSMax, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GroupSMinOp>(::mlir::spirv::GroupSMinOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("execution_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("execution_scope");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("group_operation")) {
|
|
operands.push_back(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::GroupOperationAttr>(attr).getValue()));
|
|
}
|
|
elidedAttrs.push_back("group_operation");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpGroupSMin, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GroupUMaxOp>(::mlir::spirv::GroupUMaxOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("execution_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("execution_scope");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("group_operation")) {
|
|
operands.push_back(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::GroupOperationAttr>(attr).getValue()));
|
|
}
|
|
elidedAttrs.push_back("group_operation");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpGroupUMax, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::GroupUMinOp>(::mlir::spirv::GroupUMinOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("execution_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("execution_scope");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("group_operation")) {
|
|
operands.push_back(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::GroupOperationAttr>(attr).getValue()));
|
|
}
|
|
elidedAttrs.push_back("group_operation");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpGroupUMin, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::IAddCarryOp>(::mlir::spirv::IAddCarryOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpIAddCarry));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::IAddOp>(::mlir::spirv::IAddOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpIAdd));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::IEqualOp>(::mlir::spirv::IEqualOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpIEqual));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::IMulOp>(::mlir::spirv::IMulOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpIMul));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::INTELControlBarrierArriveOp>(::mlir::spirv::INTELControlBarrierArriveOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
if (auto attr = op->getAttr("execution_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("execution_scope");
|
|
if (auto attr = op->getAttr("memory_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("memory_scope");
|
|
if (auto attr = op->getAttr("memory_semantics")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::MemorySemanticsAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("memory_semantics");
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpControlBarrierArriveINTEL, operands);
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::INTELControlBarrierWaitOp>(::mlir::spirv::INTELControlBarrierWaitOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
if (auto attr = op->getAttr("execution_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("execution_scope");
|
|
if (auto attr = op->getAttr("memory_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("memory_scope");
|
|
if (auto attr = op->getAttr("memory_semantics")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::MemorySemanticsAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("memory_semantics");
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpControlBarrierWaitINTEL, operands);
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::INTELConvertBF16ToFOp>(::mlir::spirv::INTELConvertBF16ToFOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpConvertBF16ToFINTEL));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::INTELConvertFToBF16Op>(::mlir::spirv::INTELConvertFToBF16Op op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpConvertFToBF16INTEL));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::INTELMaskedGatherOp>(::mlir::spirv::INTELMaskedGatherOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpMaskedGatherINTEL));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::INTELMaskedScatterOp>(::mlir::spirv::INTELMaskedScatterOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpMaskedScatterINTEL));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::INTELRoundFToTF32Op>(::mlir::spirv::INTELRoundFToTF32Op op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpRoundFToTF32INTEL));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::INTELSubgroupBlockReadOp>(::mlir::spirv::INTELSubgroupBlockReadOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpSubgroupBlockReadINTEL));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::INTELSubgroupBlockWriteOp>(::mlir::spirv::INTELSubgroupBlockWriteOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpSubgroupBlockWriteINTEL));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::INotEqualOp>(::mlir::spirv::INotEqualOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpINotEqual));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::ISubBorrowOp>(::mlir::spirv::ISubBorrowOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpISubBorrow));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::ISubOp>(::mlir::spirv::ISubOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpISub));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::ImageDrefGatherOp>(::mlir::spirv::ImageDrefGatherOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(2)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #2 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("image_operands")) {
|
|
operands.push_back(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ImageOperandsAttr>(attr).getValue()));
|
|
}
|
|
elidedAttrs.push_back("image_operands");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(3)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #3 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpImageDrefGather, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::ImageFetchOp>(::mlir::spirv::ImageFetchOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("image_operands")) {
|
|
operands.push_back(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ImageOperandsAttr>(attr).getValue()));
|
|
}
|
|
elidedAttrs.push_back("image_operands");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(2)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #2 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpImageFetch, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::ImageOp>(::mlir::spirv::ImageOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpImage));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::ImageQuerySizeOp>(::mlir::spirv::ImageQuerySizeOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpImageQuerySize));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::ImageReadOp>(::mlir::spirv::ImageReadOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("image_operands")) {
|
|
operands.push_back(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ImageOperandsAttr>(attr).getValue()));
|
|
}
|
|
elidedAttrs.push_back("image_operands");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(2)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #2 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpImageRead, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::ImageSampleExplicitLodOp>(::mlir::spirv::ImageSampleExplicitLodOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("image_operands")) {
|
|
operands.push_back(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ImageOperandsAttr>(attr).getValue()));
|
|
}
|
|
elidedAttrs.push_back("image_operands");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(2)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #2 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpImageSampleExplicitLod, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::ImageSampleImplicitLodOp>(::mlir::spirv::ImageSampleImplicitLodOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("image_operands")) {
|
|
operands.push_back(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ImageOperandsAttr>(attr).getValue()));
|
|
}
|
|
elidedAttrs.push_back("image_operands");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(2)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #2 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpImageSampleImplicitLod, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::ImageSampleProjDrefImplicitLodOp>(::mlir::spirv::ImageSampleProjDrefImplicitLodOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(2)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #2 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("image_operands")) {
|
|
operands.push_back(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ImageOperandsAttr>(attr).getValue()));
|
|
}
|
|
elidedAttrs.push_back("image_operands");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(3)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #3 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpImageSampleProjDrefImplicitLod, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::ImageWriteOp>(::mlir::spirv::ImageWriteOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(2)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #2 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("image_operands")) {
|
|
operands.push_back(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ImageOperandsAttr>(attr).getValue()));
|
|
}
|
|
elidedAttrs.push_back("image_operands");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(3)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #3 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpImageWrite, operands);
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::InBoundsPtrAccessChainOp>(::mlir::spirv::InBoundsPtrAccessChainOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
for (Value operand : op->getOperands()) {
|
|
auto id = getValueID(operand);
|
|
assert(id && "use before def!");
|
|
operands.push_back(id);
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpInBoundsPtrAccessChain, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::IsFiniteOp>(::mlir::spirv::IsFiniteOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpIsFinite));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::IsInfOp>(::mlir::spirv::IsInfOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpIsInf));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::IsNanOp>(::mlir::spirv::IsNanOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpIsNan));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::IsNormalOp>(::mlir::spirv::IsNormalOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpIsNormal));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::KHRAssumeTrueOp>(::mlir::spirv::KHRAssumeTrueOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpAssumeTrueKHR));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::KHRCooperativeMatrixLengthOp>(::mlir::spirv::KHRCooperativeMatrixLengthOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
if (auto attr = op->getAttr("cooperative_matrix_type")) {
|
|
uint32_t attrTypeID = 0;
|
|
if (failed(processType(op.getLoc(), llvm::cast<TypeAttr>(attr).getValue(), attrTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(attrTypeID);
|
|
}
|
|
elidedAttrs.push_back("cooperative_matrix_type");
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpCooperativeMatrixLengthKHR, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::KHRCooperativeMatrixLoadOp>(::mlir::spirv::KHRCooperativeMatrixLoadOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("matrix_layout")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::CooperativeMatrixLayoutKHRAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("matrix_layout");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("memory_operand")) {
|
|
operands.push_back(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::MemoryAccessAttr>(attr).getValue()));
|
|
}
|
|
elidedAttrs.push_back("memory_operand");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("alignment")) {
|
|
operands.push_back(static_cast<uint32_t>(llvm::cast<IntegerAttr>(attr).getValue().getZExtValue()));
|
|
}
|
|
elidedAttrs.push_back("alignment");
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpCooperativeMatrixLoadKHR, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::KHRCooperativeMatrixMulAddOp>(::mlir::spirv::KHRCooperativeMatrixMulAddOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
for (Value operand : op->getOperands()) {
|
|
auto id = getValueID(operand);
|
|
assert(id && "use before def!");
|
|
operands.push_back(id);
|
|
}
|
|
if (auto attr = op->getAttr("matrix_operands")) {
|
|
operands.push_back(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::CooperativeMatrixOperandsKHRAttr>(attr).getValue()));
|
|
}
|
|
elidedAttrs.push_back("matrix_operands");
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpCooperativeMatrixMulAddKHR, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::KHRCooperativeMatrixStoreOp>(::mlir::spirv::KHRCooperativeMatrixStoreOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("matrix_layout")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::CooperativeMatrixLayoutKHRAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("matrix_layout");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(2)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #2 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("memory_operand")) {
|
|
operands.push_back(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::MemoryAccessAttr>(attr).getValue()));
|
|
}
|
|
elidedAttrs.push_back("memory_operand");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("alignment")) {
|
|
operands.push_back(static_cast<uint32_t>(llvm::cast<IntegerAttr>(attr).getValue().getZExtValue()));
|
|
}
|
|
elidedAttrs.push_back("alignment");
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpCooperativeMatrixStoreKHR, operands);
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::KHRExpectOp>(::mlir::spirv::KHRExpectOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpExpectKHR));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::KHRSubgroupBallotOp>(::mlir::spirv::KHRSubgroupBallotOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpSubgroupBallotKHR));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::KillOp>(::mlir::spirv::KillOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpKill));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::LoadOp>(::mlir::spirv::LoadOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
for (Value operand : op->getOperands()) {
|
|
auto id = getValueID(operand);
|
|
assert(id && "use before def!");
|
|
operands.push_back(id);
|
|
}
|
|
if (auto attr = op->getAttr("memory_access")) {
|
|
operands.push_back(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::MemoryAccessAttr>(attr).getValue()));
|
|
}
|
|
elidedAttrs.push_back("memory_access");
|
|
if (auto attr = op->getAttr("alignment")) {
|
|
operands.push_back(static_cast<uint32_t>(llvm::cast<IntegerAttr>(attr).getValue().getZExtValue()));
|
|
}
|
|
elidedAttrs.push_back("alignment");
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpLoad, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::LogicalAndOp>(::mlir::spirv::LogicalAndOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpLogicalAnd));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::LogicalEqualOp>(::mlir::spirv::LogicalEqualOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpLogicalEqual));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::LogicalNotEqualOp>(::mlir::spirv::LogicalNotEqualOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpLogicalNotEqual));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::LogicalNotOp>(::mlir::spirv::LogicalNotOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpLogicalNot));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::LogicalOrOp>(::mlir::spirv::LogicalOrOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpLogicalOr));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::MatrixTimesMatrixOp>(::mlir::spirv::MatrixTimesMatrixOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpMatrixTimesMatrix));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::MatrixTimesScalarOp>(::mlir::spirv::MatrixTimesScalarOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpMatrixTimesScalar));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::MatrixTimesVectorOp>(::mlir::spirv::MatrixTimesVectorOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpMatrixTimesVector));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::MemoryBarrierOp>(::mlir::spirv::MemoryBarrierOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
if (auto attr = op->getAttr("memory_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("memory_scope");
|
|
if (auto attr = op->getAttr("memory_semantics")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::MemorySemanticsAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("memory_semantics");
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpMemoryBarrier, operands);
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::MemoryNamedBarrierOp>(::mlir::spirv::MemoryNamedBarrierOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
for (Value operand : op->getOperands()) {
|
|
auto id = getValueID(operand);
|
|
assert(id && "use before def!");
|
|
operands.push_back(id);
|
|
}
|
|
if (auto attr = op->getAttr("memory_scope")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::ScopeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("memory_scope");
|
|
if (auto attr = op->getAttr("memory_semantics")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::MemorySemanticsAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("memory_semantics");
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpMemoryNamedBarrier, operands);
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::NamedBarrierInitializeOp>(::mlir::spirv::NamedBarrierInitializeOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpNamedBarrierInitialize));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::NotOp>(::mlir::spirv::NotOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpNot));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::OrderedOp>(::mlir::spirv::OrderedOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpOrdered));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::OuterProductOp>(::mlir::spirv::OuterProductOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpOuterProduct));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::PtrAccessChainOp>(::mlir::spirv::PtrAccessChainOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
for (Value operand : op->getOperands()) {
|
|
auto id = getValueID(operand);
|
|
assert(id && "use before def!");
|
|
operands.push_back(id);
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpPtrAccessChain, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::PtrCastToGenericOp>(::mlir::spirv::PtrCastToGenericOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpPtrCastToGeneric));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::ReturnOp>(::mlir::spirv::ReturnOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpReturn));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::ReturnValueOp>(::mlir::spirv::ReturnValueOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpReturnValue));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::SConvertOp>(::mlir::spirv::SConvertOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpSConvert));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::SDivOp>(::mlir::spirv::SDivOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpSDiv));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::SDotAccSatOp>(::mlir::spirv::SDotAccSatOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
for (Value operand : op->getOperands()) {
|
|
auto id = getValueID(operand);
|
|
assert(id && "use before def!");
|
|
operands.push_back(id);
|
|
}
|
|
if (auto attr = op->getAttr("format")) {
|
|
operands.push_back(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::PackedVectorFormatAttr>(attr).getValue()));
|
|
}
|
|
elidedAttrs.push_back("format");
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpSDotAccSat, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::SDotOp>(::mlir::spirv::SDotOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
for (Value operand : op->getOperands()) {
|
|
auto id = getValueID(operand);
|
|
assert(id && "use before def!");
|
|
operands.push_back(id);
|
|
}
|
|
if (auto attr = op->getAttr("format")) {
|
|
operands.push_back(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::PackedVectorFormatAttr>(attr).getValue()));
|
|
}
|
|
elidedAttrs.push_back("format");
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpSDot, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::SGreaterThanEqualOp>(::mlir::spirv::SGreaterThanEqualOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpSGreaterThanEqual));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::SGreaterThanOp>(::mlir::spirv::SGreaterThanOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpSGreaterThan));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::SLessThanEqualOp>(::mlir::spirv::SLessThanEqualOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpSLessThanEqual));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::SLessThanOp>(::mlir::spirv::SLessThanOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpSLessThan));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::SModOp>(::mlir::spirv::SModOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpSMod));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::SMulExtendedOp>(::mlir::spirv::SMulExtendedOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpSMulExtended));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::SNegateOp>(::mlir::spirv::SNegateOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpSNegate));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::SRemOp>(::mlir::spirv::SRemOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpSRem));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::SUDotAccSatOp>(::mlir::spirv::SUDotAccSatOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
for (Value operand : op->getOperands()) {
|
|
auto id = getValueID(operand);
|
|
assert(id && "use before def!");
|
|
operands.push_back(id);
|
|
}
|
|
if (auto attr = op->getAttr("format")) {
|
|
operands.push_back(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::PackedVectorFormatAttr>(attr).getValue()));
|
|
}
|
|
elidedAttrs.push_back("format");
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpSUDotAccSat, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::SUDotOp>(::mlir::spirv::SUDotOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
for (Value operand : op->getOperands()) {
|
|
auto id = getValueID(operand);
|
|
assert(id && "use before def!");
|
|
operands.push_back(id);
|
|
}
|
|
if (auto attr = op->getAttr("format")) {
|
|
operands.push_back(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::PackedVectorFormatAttr>(attr).getValue()));
|
|
}
|
|
elidedAttrs.push_back("format");
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpSUDot, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::SampledImageOp>(::mlir::spirv::SampledImageOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpSampledImage));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::SelectOp>(::mlir::spirv::SelectOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpSelect));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::ShiftLeftLogicalOp>(::mlir::spirv::ShiftLeftLogicalOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpShiftLeftLogical));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::ShiftRightArithmeticOp>(::mlir::spirv::ShiftRightArithmeticOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpShiftRightArithmetic));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::ShiftRightLogicalOp>(::mlir::spirv::ShiftRightLogicalOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpShiftRightLogical));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::StoreOp>(::mlir::spirv::StoreOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
for (Value operand : op->getOperands()) {
|
|
auto id = getValueID(operand);
|
|
assert(id && "use before def!");
|
|
operands.push_back(id);
|
|
}
|
|
if (auto attr = op->getAttr("memory_access")) {
|
|
operands.push_back(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::MemoryAccessAttr>(attr).getValue()));
|
|
}
|
|
elidedAttrs.push_back("memory_access");
|
|
if (auto attr = op->getAttr("alignment")) {
|
|
operands.push_back(static_cast<uint32_t>(llvm::cast<IntegerAttr>(attr).getValue().getZExtValue()));
|
|
}
|
|
elidedAttrs.push_back("alignment");
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpStore, operands);
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaAbsOp>(::mlir::spirv::TosaAbsOp op) {
|
|
return processOpWithoutGrammarAttr(op, "TOSA.001000.1", 31);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaAddOp>(::mlir::spirv::TosaAddOp op) {
|
|
return processOpWithoutGrammarAttr(op, "TOSA.001000.1", 14);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaArgMaxOp>(::mlir::spirv::TosaArgMaxOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("axis")) {
|
|
operands.push_back(prepareConstantScalar(op.getLoc(), attr));
|
|
}
|
|
elidedAttrs.push_back("axis");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("nan_mode")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::TosaExtNaNPropagationModeTypeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("nan_mode");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)encodeExtensionInstruction(op, "TOSA.001000.1", 0, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaArithmeticRightShiftOp>(::mlir::spirv::TosaArithmeticRightShiftOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("round")) {
|
|
operands.push_back(prepareConstantScalar(op.getLoc(), attr));
|
|
}
|
|
elidedAttrs.push_back("round");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)encodeExtensionInstruction(op, "TOSA.001000.1", 15, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaAvgPool2DOp>(::mlir::spirv::TosaAvgPool2DOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("kernel")) {
|
|
operands.push_back(prepareConstant(op.getLoc(), llvm::cast<DenseElementsAttr>(attr).getType(), attr));
|
|
}
|
|
elidedAttrs.push_back("kernel");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("stride")) {
|
|
operands.push_back(prepareConstant(op.getLoc(), llvm::cast<DenseElementsAttr>(attr).getType(), attr));
|
|
}
|
|
elidedAttrs.push_back("stride");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("pad")) {
|
|
operands.push_back(prepareConstant(op.getLoc(), llvm::cast<DenseElementsAttr>(attr).getType(), attr));
|
|
}
|
|
elidedAttrs.push_back("pad");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("acc_type")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::TosaExtAccTypeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("acc_type");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(2)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #2 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)encodeExtensionInstruction(op, "TOSA.001000.1", 1, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaBitwiseAndOp>(::mlir::spirv::TosaBitwiseAndOp op) {
|
|
return processOpWithoutGrammarAttr(op, "TOSA.001000.1", 16);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaBitwiseNotOp>(::mlir::spirv::TosaBitwiseNotOp op) {
|
|
return processOpWithoutGrammarAttr(op, "TOSA.001000.1", 32);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaBitwiseOrOp>(::mlir::spirv::TosaBitwiseOrOp op) {
|
|
return processOpWithoutGrammarAttr(op, "TOSA.001000.1", 17);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaBitwiseXorOp>(::mlir::spirv::TosaBitwiseXorOp op) {
|
|
return processOpWithoutGrammarAttr(op, "TOSA.001000.1", 18);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaCastOp>(::mlir::spirv::TosaCastOp op) {
|
|
return processOpWithoutGrammarAttr(op, "TOSA.001000.1", 64);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaCeilOp>(::mlir::spirv::TosaCeilOp op) {
|
|
return processOpWithoutGrammarAttr(op, "TOSA.001000.1", 33);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaClampOp>(::mlir::spirv::TosaClampOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("min_val")) {
|
|
operands.push_back(prepareConstantScalar(op.getLoc(), attr));
|
|
}
|
|
elidedAttrs.push_back("min_val");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("max_val")) {
|
|
operands.push_back(prepareConstantScalar(op.getLoc(), attr));
|
|
}
|
|
elidedAttrs.push_back("max_val");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("nan_mode")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::TosaExtNaNPropagationModeTypeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("nan_mode");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)encodeExtensionInstruction(op, "TOSA.001000.1", 10, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaClzOp>(::mlir::spirv::TosaClzOp op) {
|
|
return processOpWithoutGrammarAttr(op, "TOSA.001000.1", 34);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaConcatOp>(::mlir::spirv::TosaConcatOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("axis")) {
|
|
operands.push_back(prepareConstantScalar(op.getLoc(), attr));
|
|
}
|
|
elidedAttrs.push_back("axis");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)encodeExtensionInstruction(op, "TOSA.001000.1", 54, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaConv2DOp>(::mlir::spirv::TosaConv2DOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("pad")) {
|
|
operands.push_back(prepareConstant(op.getLoc(), llvm::cast<DenseElementsAttr>(attr).getType(), attr));
|
|
}
|
|
elidedAttrs.push_back("pad");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("stride")) {
|
|
operands.push_back(prepareConstant(op.getLoc(), llvm::cast<DenseElementsAttr>(attr).getType(), attr));
|
|
}
|
|
elidedAttrs.push_back("stride");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("dilation")) {
|
|
operands.push_back(prepareConstant(op.getLoc(), llvm::cast<DenseElementsAttr>(attr).getType(), attr));
|
|
}
|
|
elidedAttrs.push_back("dilation");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("acc_type")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::TosaExtAccTypeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("acc_type");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("local_bound")) {
|
|
operands.push_back(prepareConstantScalar(op.getLoc(), attr));
|
|
}
|
|
elidedAttrs.push_back("local_bound");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(2)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #2 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(3)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #3 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(4)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #4 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)encodeExtensionInstruction(op, "TOSA.001000.1", 2, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaConv3DOp>(::mlir::spirv::TosaConv3DOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("pad")) {
|
|
operands.push_back(prepareConstant(op.getLoc(), llvm::cast<DenseElementsAttr>(attr).getType(), attr));
|
|
}
|
|
elidedAttrs.push_back("pad");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("stride")) {
|
|
operands.push_back(prepareConstant(op.getLoc(), llvm::cast<DenseElementsAttr>(attr).getType(), attr));
|
|
}
|
|
elidedAttrs.push_back("stride");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("dilation")) {
|
|
operands.push_back(prepareConstant(op.getLoc(), llvm::cast<DenseElementsAttr>(attr).getType(), attr));
|
|
}
|
|
elidedAttrs.push_back("dilation");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("acc_type")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::TosaExtAccTypeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("acc_type");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("local_bound")) {
|
|
operands.push_back(prepareConstantScalar(op.getLoc(), attr));
|
|
}
|
|
elidedAttrs.push_back("local_bound");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(2)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #2 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(3)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #3 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(4)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #4 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)encodeExtensionInstruction(op, "TOSA.001000.1", 3, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaCosOp>(::mlir::spirv::TosaCosOp op) {
|
|
return processOpWithoutGrammarAttr(op, "TOSA.001000.1", 35);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaDepthwiseConv2DOp>(::mlir::spirv::TosaDepthwiseConv2DOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("pad")) {
|
|
operands.push_back(prepareConstant(op.getLoc(), llvm::cast<DenseElementsAttr>(attr).getType(), attr));
|
|
}
|
|
elidedAttrs.push_back("pad");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("stride")) {
|
|
operands.push_back(prepareConstant(op.getLoc(), llvm::cast<DenseElementsAttr>(attr).getType(), attr));
|
|
}
|
|
elidedAttrs.push_back("stride");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("dilation")) {
|
|
operands.push_back(prepareConstant(op.getLoc(), llvm::cast<DenseElementsAttr>(attr).getType(), attr));
|
|
}
|
|
elidedAttrs.push_back("dilation");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("acc_type")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::TosaExtAccTypeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("acc_type");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("local_bound")) {
|
|
operands.push_back(prepareConstantScalar(op.getLoc(), attr));
|
|
}
|
|
elidedAttrs.push_back("local_bound");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(2)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #2 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(3)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #3 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(4)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #4 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)encodeExtensionInstruction(op, "TOSA.001000.1", 4, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaEqualOp>(::mlir::spirv::TosaEqualOp op) {
|
|
return processOpWithoutGrammarAttr(op, "TOSA.001000.1", 45);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaErfOp>(::mlir::spirv::TosaErfOp op) {
|
|
return processOpWithoutGrammarAttr(op, "TOSA.001000.1", 11);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaExpOp>(::mlir::spirv::TosaExpOp op) {
|
|
return processOpWithoutGrammarAttr(op, "TOSA.001000.1", 36);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaFFT2DOp>(::mlir::spirv::TosaFFT2DOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("inverse")) {
|
|
operands.push_back(prepareConstantScalar(op.getLoc(), attr));
|
|
}
|
|
elidedAttrs.push_back("inverse");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("local_bound")) {
|
|
operands.push_back(prepareConstantScalar(op.getLoc(), attr));
|
|
}
|
|
elidedAttrs.push_back("local_bound");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)encodeExtensionInstruction(op, "TOSA.001000.1", 5, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaFloorOp>(::mlir::spirv::TosaFloorOp op) {
|
|
return processOpWithoutGrammarAttr(op, "TOSA.001000.1", 37);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaGatherOp>(::mlir::spirv::TosaGatherOp op) {
|
|
return processOpWithoutGrammarAttr(op, "TOSA.001000.1", 61);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaGreaterEqualOp>(::mlir::spirv::TosaGreaterEqualOp op) {
|
|
return processOpWithoutGrammarAttr(op, "TOSA.001000.1", 47);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaGreaterOp>(::mlir::spirv::TosaGreaterOp op) {
|
|
return processOpWithoutGrammarAttr(op, "TOSA.001000.1", 46);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaIntDivOp>(::mlir::spirv::TosaIntDivOp op) {
|
|
return processOpWithoutGrammarAttr(op, "TOSA.001000.1", 19);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaLogOp>(::mlir::spirv::TosaLogOp op) {
|
|
return processOpWithoutGrammarAttr(op, "TOSA.001000.1", 38);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaLogicalAndOp>(::mlir::spirv::TosaLogicalAndOp op) {
|
|
return processOpWithoutGrammarAttr(op, "TOSA.001000.1", 20);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaLogicalLeftShiftOp>(::mlir::spirv::TosaLogicalLeftShiftOp op) {
|
|
return processOpWithoutGrammarAttr(op, "TOSA.001000.1", 21);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaLogicalNotOp>(::mlir::spirv::TosaLogicalNotOp op) {
|
|
return processOpWithoutGrammarAttr(op, "TOSA.001000.1", 39);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaLogicalOrOp>(::mlir::spirv::TosaLogicalOrOp op) {
|
|
return processOpWithoutGrammarAttr(op, "TOSA.001000.1", 23);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaLogicalRightShiftOp>(::mlir::spirv::TosaLogicalRightShiftOp op) {
|
|
return processOpWithoutGrammarAttr(op, "TOSA.001000.1", 22);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaLogicalXorOp>(::mlir::spirv::TosaLogicalXorOp op) {
|
|
return processOpWithoutGrammarAttr(op, "TOSA.001000.1", 24);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaMatMulOp>(::mlir::spirv::TosaMatMulOp op) {
|
|
return processOpWithoutGrammarAttr(op, "TOSA.001000.1", 6);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaMaxPool2DOp>(::mlir::spirv::TosaMaxPool2DOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("kernel")) {
|
|
operands.push_back(prepareConstant(op.getLoc(), llvm::cast<DenseElementsAttr>(attr).getType(), attr));
|
|
}
|
|
elidedAttrs.push_back("kernel");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("stride")) {
|
|
operands.push_back(prepareConstant(op.getLoc(), llvm::cast<DenseElementsAttr>(attr).getType(), attr));
|
|
}
|
|
elidedAttrs.push_back("stride");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("pad")) {
|
|
operands.push_back(prepareConstant(op.getLoc(), llvm::cast<DenseElementsAttr>(attr).getType(), attr));
|
|
}
|
|
elidedAttrs.push_back("pad");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("nan_mode")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::TosaExtNaNPropagationModeTypeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("nan_mode");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)encodeExtensionInstruction(op, "TOSA.001000.1", 7, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaMaximumOp>(::mlir::spirv::TosaMaximumOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("nan_mode")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::TosaExtNaNPropagationModeTypeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("nan_mode");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)encodeExtensionInstruction(op, "TOSA.001000.1", 25, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaMinimumOp>(::mlir::spirv::TosaMinimumOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("nan_mode")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::TosaExtNaNPropagationModeTypeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("nan_mode");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)encodeExtensionInstruction(op, "TOSA.001000.1", 26, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaMulOp>(::mlir::spirv::TosaMulOp op) {
|
|
return processOpWithoutGrammarAttr(op, "TOSA.001000.1", 27);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaNegateOp>(::mlir::spirv::TosaNegateOp op) {
|
|
return processOpWithoutGrammarAttr(op, "TOSA.001000.1", 40);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaPadOp>(::mlir::spirv::TosaPadOp op) {
|
|
return processOpWithoutGrammarAttr(op, "TOSA.001000.1", 55);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaPowOp>(::mlir::spirv::TosaPowOp op) {
|
|
return processOpWithoutGrammarAttr(op, "TOSA.001000.1", 28);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaRFFT2DOp>(::mlir::spirv::TosaRFFT2DOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("local_bound")) {
|
|
operands.push_back(prepareConstantScalar(op.getLoc(), attr));
|
|
}
|
|
elidedAttrs.push_back("local_bound");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)encodeExtensionInstruction(op, "TOSA.001000.1", 8, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaReciprocalOp>(::mlir::spirv::TosaReciprocalOp op) {
|
|
return processOpWithoutGrammarAttr(op, "TOSA.001000.1", 41);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaReduceAllOp>(::mlir::spirv::TosaReduceAllOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("axis")) {
|
|
operands.push_back(prepareConstantScalar(op.getLoc(), attr));
|
|
}
|
|
elidedAttrs.push_back("axis");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)encodeExtensionInstruction(op, "TOSA.001000.1", 48, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaReduceAnyOp>(::mlir::spirv::TosaReduceAnyOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("axis")) {
|
|
operands.push_back(prepareConstantScalar(op.getLoc(), attr));
|
|
}
|
|
elidedAttrs.push_back("axis");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)encodeExtensionInstruction(op, "TOSA.001000.1", 49, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaReduceMaxOp>(::mlir::spirv::TosaReduceMaxOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("axis")) {
|
|
operands.push_back(prepareConstantScalar(op.getLoc(), attr));
|
|
}
|
|
elidedAttrs.push_back("axis");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("nan_mode")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::TosaExtNaNPropagationModeTypeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("nan_mode");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)encodeExtensionInstruction(op, "TOSA.001000.1", 50, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaReduceMinOp>(::mlir::spirv::TosaReduceMinOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("axis")) {
|
|
operands.push_back(prepareConstantScalar(op.getLoc(), attr));
|
|
}
|
|
elidedAttrs.push_back("axis");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("nan_mode")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::TosaExtNaNPropagationModeTypeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("nan_mode");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)encodeExtensionInstruction(op, "TOSA.001000.1", 51, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaReduceProductOp>(::mlir::spirv::TosaReduceProductOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("axis")) {
|
|
operands.push_back(prepareConstantScalar(op.getLoc(), attr));
|
|
}
|
|
elidedAttrs.push_back("axis");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)encodeExtensionInstruction(op, "TOSA.001000.1", 52, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaReduceSumOp>(::mlir::spirv::TosaReduceSumOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("axis")) {
|
|
operands.push_back(prepareConstantScalar(op.getLoc(), attr));
|
|
}
|
|
elidedAttrs.push_back("axis");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)encodeExtensionInstruction(op, "TOSA.001000.1", 53, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaRescaleOp>(::mlir::spirv::TosaRescaleOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("scale32")) {
|
|
operands.push_back(prepareConstantScalar(op.getLoc(), attr));
|
|
}
|
|
elidedAttrs.push_back("scale32");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("rounding_mode")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::TosaExtRoundingModeTypeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("rounding_mode");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("per_channel")) {
|
|
operands.push_back(prepareConstantScalar(op.getLoc(), attr));
|
|
}
|
|
elidedAttrs.push_back("per_channel");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("input_unsigned")) {
|
|
operands.push_back(prepareConstantScalar(op.getLoc(), attr));
|
|
}
|
|
elidedAttrs.push_back("input_unsigned");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("output_unsigned")) {
|
|
operands.push_back(prepareConstantScalar(op.getLoc(), attr));
|
|
}
|
|
elidedAttrs.push_back("output_unsigned");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(2)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #2 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(3)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #3 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(4)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #4 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)encodeExtensionInstruction(op, "TOSA.001000.1", 65, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaReshapeOp>(::mlir::spirv::TosaReshapeOp op) {
|
|
return processOpWithoutGrammarAttr(op, "TOSA.001000.1", 56);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaResizeOp>(::mlir::spirv::TosaResizeOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("mode")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::TosaExtResizeModeTypeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("mode");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(2)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #2 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(3)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #3 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)encodeExtensionInstruction(op, "TOSA.001000.1", 63, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaReverseOp>(::mlir::spirv::TosaReverseOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("axis")) {
|
|
operands.push_back(prepareConstantScalar(op.getLoc(), attr));
|
|
}
|
|
elidedAttrs.push_back("axis");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)encodeExtensionInstruction(op, "TOSA.001000.1", 57, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaRsqrtOp>(::mlir::spirv::TosaRsqrtOp op) {
|
|
return processOpWithoutGrammarAttr(op, "TOSA.001000.1", 42);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaScatterOp>(::mlir::spirv::TosaScatterOp op) {
|
|
return processOpWithoutGrammarAttr(op, "TOSA.001000.1", 62);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaSelectOp>(::mlir::spirv::TosaSelectOp op) {
|
|
return processOpWithoutGrammarAttr(op, "TOSA.001000.1", 44);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaSigmoidOp>(::mlir::spirv::TosaSigmoidOp op) {
|
|
return processOpWithoutGrammarAttr(op, "TOSA.001000.1", 12);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaSinOp>(::mlir::spirv::TosaSinOp op) {
|
|
return processOpWithoutGrammarAttr(op, "TOSA.001000.1", 43);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaSliceOp>(::mlir::spirv::TosaSliceOp op) {
|
|
return processOpWithoutGrammarAttr(op, "TOSA.001000.1", 58);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaSubOp>(::mlir::spirv::TosaSubOp op) {
|
|
return processOpWithoutGrammarAttr(op, "TOSA.001000.1", 29);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaTableOp>(::mlir::spirv::TosaTableOp op) {
|
|
return processOpWithoutGrammarAttr(op, "TOSA.001000.1", 30);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaTanhOp>(::mlir::spirv::TosaTanhOp op) {
|
|
return processOpWithoutGrammarAttr(op, "TOSA.001000.1", 13);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaTileOp>(::mlir::spirv::TosaTileOp op) {
|
|
return processOpWithoutGrammarAttr(op, "TOSA.001000.1", 59);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaTransposeConv2DOp>(::mlir::spirv::TosaTransposeConv2DOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("out_pad")) {
|
|
operands.push_back(prepareConstant(op.getLoc(), llvm::cast<DenseElementsAttr>(attr).getType(), attr));
|
|
}
|
|
elidedAttrs.push_back("out_pad");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("stride")) {
|
|
operands.push_back(prepareConstant(op.getLoc(), llvm::cast<DenseElementsAttr>(attr).getType(), attr));
|
|
}
|
|
elidedAttrs.push_back("stride");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("acc_type")) {
|
|
operands.push_back(prepareConstantInt(op.getLoc(), Builder(op).getI32IntegerAttr(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::TosaExtAccTypeAttr>(attr).getValue()))));
|
|
}
|
|
elidedAttrs.push_back("acc_type");
|
|
}
|
|
{
|
|
if (auto attr = op->getAttr("local_bound")) {
|
|
operands.push_back(prepareConstantScalar(op.getLoc(), attr));
|
|
}
|
|
elidedAttrs.push_back("local_bound");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(1)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #1 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(2)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #2 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(3)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #3 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(4)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #4 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)encodeExtensionInstruction(op, "TOSA.001000.1", 9, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TosaTransposeOp>(::mlir::spirv::TosaTransposeOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("perms")) {
|
|
operands.push_back(prepareConstant(op.getLoc(), llvm::cast<DenseElementsAttr>(attr).getType(), attr));
|
|
}
|
|
elidedAttrs.push_back("perms");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)encodeExtensionInstruction(op, "TOSA.001000.1", 60, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::TransposeOp>(::mlir::spirv::TransposeOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpTranspose));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::UConvertOp>(::mlir::spirv::UConvertOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpUConvert));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::UDivOp>(::mlir::spirv::UDivOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpUDiv));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::UDotAccSatOp>(::mlir::spirv::UDotAccSatOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
for (Value operand : op->getOperands()) {
|
|
auto id = getValueID(operand);
|
|
assert(id && "use before def!");
|
|
operands.push_back(id);
|
|
}
|
|
if (auto attr = op->getAttr("format")) {
|
|
operands.push_back(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::PackedVectorFormatAttr>(attr).getValue()));
|
|
}
|
|
elidedAttrs.push_back("format");
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpUDotAccSat, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::UDotOp>(::mlir::spirv::UDotOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
for (Value operand : op->getOperands()) {
|
|
auto id = getValueID(operand);
|
|
assert(id && "use before def!");
|
|
operands.push_back(id);
|
|
}
|
|
if (auto attr = op->getAttr("format")) {
|
|
operands.push_back(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::PackedVectorFormatAttr>(attr).getValue()));
|
|
}
|
|
elidedAttrs.push_back("format");
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpUDot, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::UGreaterThanEqualOp>(::mlir::spirv::UGreaterThanEqualOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpUGreaterThanEqual));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::UGreaterThanOp>(::mlir::spirv::UGreaterThanOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpUGreaterThan));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::ULessThanEqualOp>(::mlir::spirv::ULessThanEqualOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpULessThanEqual));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::ULessThanOp>(::mlir::spirv::ULessThanOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpULessThan));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::UModOp>(::mlir::spirv::UModOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpUMod));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::UMulExtendedOp>(::mlir::spirv::UMulExtendedOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpUMulExtended));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::UnorderedOp>(::mlir::spirv::UnorderedOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpUnordered));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::UnreachableOp>(::mlir::spirv::UnreachableOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpUnreachable));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::VariableOp>(::mlir::spirv::VariableOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
{
|
|
if (auto attr = op->getAttr("storage_class")) {
|
|
operands.push_back(static_cast<uint32_t>(::llvm::cast<::mlir::spirv::StorageClassAttr>(attr).getValue()));
|
|
}
|
|
elidedAttrs.push_back("storage_class");
|
|
}
|
|
{
|
|
for (auto arg : op.getODSOperands(0)) {
|
|
auto argID = getValueID(arg);
|
|
if (!argID) {
|
|
return emitError(op.getLoc(), "operand #0 has a use before def");
|
|
}
|
|
operands.push_back(argID);
|
|
}
|
|
}
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpVariable, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::VectorExtractDynamicOp>(::mlir::spirv::VectorExtractDynamicOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpVectorExtractDynamic));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::VectorInsertDynamicOp>(::mlir::spirv::VectorInsertDynamicOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpVectorInsertDynamic));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::VectorShuffleOp>(::mlir::spirv::VectorShuffleOp op) {
|
|
SmallVector<uint32_t, 4> operands;
|
|
SmallVector<StringRef, 2> elidedAttrs;
|
|
uint32_t resultID = 0;
|
|
uint32_t resultTypeID = 0;
|
|
if (failed(processType(op.getLoc(), op.getType(), resultTypeID))) {
|
|
return failure();
|
|
}
|
|
operands.push_back(resultTypeID);
|
|
resultID = getNextID();
|
|
valueIDMap[op.getResult()] = resultID;
|
|
operands.push_back(resultID);
|
|
for (Value operand : op->getOperands()) {
|
|
auto id = getValueID(operand);
|
|
assert(id && "use before def!");
|
|
operands.push_back(id);
|
|
}
|
|
if (auto attr = op->getAttr("components")) {
|
|
for (auto attrElem : llvm::cast<ArrayAttr>(attr)) {
|
|
operands.push_back(static_cast<uint32_t>(llvm::cast<IntegerAttr>(attrElem).getValue().getZExtValue()));
|
|
}
|
|
}
|
|
elidedAttrs.push_back("components");
|
|
(void)emitDebugLine(functionBody, op.getLoc());
|
|
(void)encodeInstructionInto(functionBody, spirv::Opcode::OpVectorShuffle, operands);
|
|
for (auto attr : op->getAttrs()) {
|
|
if (llvm::is_contained(elidedAttrs, attr.getName())) { continue;
|
|
}
|
|
if (failed(processDecoration(op.getLoc(), resultID, attr))) {
|
|
return failure();
|
|
}
|
|
}
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::VectorTimesMatrixOp>(::mlir::spirv::VectorTimesMatrixOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpVectorTimesMatrix));
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Serializer::processOp<::mlir::spirv::VectorTimesScalarOp>(::mlir::spirv::VectorTimesScalarOp op) {
|
|
return processOpWithoutGrammarAttr(op, "", static_cast<uint32_t>(spirv::Opcode::OpVectorTimesScalar));
|
|
}
|
|
|
|
LogicalResult Serializer::dispatchToAutogenSerialization(Operation *op) {
|
|
if (isa<::mlir::spirv::AccessChainOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::AccessChainOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::AllOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::AllOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::AnyOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::AnyOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::AtomicAndOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::AtomicAndOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::AtomicCompareExchangeOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::AtomicCompareExchangeOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::AtomicCompareExchangeWeakOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::AtomicCompareExchangeWeakOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::AtomicExchangeOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::AtomicExchangeOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::AtomicIAddOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::AtomicIAddOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::AtomicIDecrementOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::AtomicIDecrementOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::AtomicIIncrementOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::AtomicIIncrementOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::AtomicISubOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::AtomicISubOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::AtomicLoadOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::AtomicLoadOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::AtomicOrOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::AtomicOrOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::AtomicSMaxOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::AtomicSMaxOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::AtomicSMinOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::AtomicSMinOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::AtomicStoreOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::AtomicStoreOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::AtomicUMaxOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::AtomicUMaxOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::AtomicUMinOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::AtomicUMinOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::AtomicXorOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::AtomicXorOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::BitCountOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::BitCountOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::BitFieldInsertOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::BitFieldInsertOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::BitFieldSExtractOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::BitFieldSExtractOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::BitFieldUExtractOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::BitFieldUExtractOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::BitReverseOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::BitReverseOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::BitcastOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::BitcastOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::BitwiseAndOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::BitwiseAndOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::BitwiseOrOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::BitwiseOrOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::BitwiseXorOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::BitwiseXorOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::BranchConditionalOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::BranchConditionalOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::BranchOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::BranchOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::CLAcosOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::CLAcosOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::CLAcoshOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::CLAcoshOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::CLAsinOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::CLAsinOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::CLAsinhOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::CLAsinhOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::CLAtan2Op>(op)) {
|
|
return processOp(cast<::mlir::spirv::CLAtan2Op>(op));
|
|
}
|
|
if (isa<::mlir::spirv::CLAtanOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::CLAtanOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::CLAtanhOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::CLAtanhOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::CLCbrtOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::CLCbrtOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::CLCeilOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::CLCeilOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::CLClzOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::CLClzOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::CLCosOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::CLCosOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::CLCoshOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::CLCoshOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::CLErfOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::CLErfOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::CLErfcOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::CLErfcOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::CLExp2Op>(op)) {
|
|
return processOp(cast<::mlir::spirv::CLExp2Op>(op));
|
|
}
|
|
if (isa<::mlir::spirv::CLExp10Op>(op)) {
|
|
return processOp(cast<::mlir::spirv::CLExp10Op>(op));
|
|
}
|
|
if (isa<::mlir::spirv::CLExpOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::CLExpOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::CLExpm1Op>(op)) {
|
|
return processOp(cast<::mlir::spirv::CLExpm1Op>(op));
|
|
}
|
|
if (isa<::mlir::spirv::CLFAbsOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::CLFAbsOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::CLFMaxOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::CLFMaxOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::CLFMinOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::CLFMinOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::CLFloorOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::CLFloorOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::CLFmaOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::CLFmaOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::CLLdexpOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::CLLdexpOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::CLLog1pOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::CLLog1pOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::CLLog2Op>(op)) {
|
|
return processOp(cast<::mlir::spirv::CLLog2Op>(op));
|
|
}
|
|
if (isa<::mlir::spirv::CLLog10Op>(op)) {
|
|
return processOp(cast<::mlir::spirv::CLLog10Op>(op));
|
|
}
|
|
if (isa<::mlir::spirv::CLLogOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::CLLogOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::CLMixOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::CLMixOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::CLPowOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::CLPowOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::CLPownOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::CLPownOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::CLPrintfOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::CLPrintfOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::CLRintOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::CLRintOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::CLRootnOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::CLRootnOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::CLRoundOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::CLRoundOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::CLRsqrtOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::CLRsqrtOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::CLSAbsOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::CLSAbsOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::CLSMaxOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::CLSMaxOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::CLSMinOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::CLSMinOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::CLSinOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::CLSinOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::CLSinhOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::CLSinhOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::CLSqrtOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::CLSqrtOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::CLTanOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::CLTanOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::CLTanhOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::CLTanhOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::CLTruncOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::CLTruncOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::CLUMaxOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::CLUMaxOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::CLUMinOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::CLUMinOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::CompositeConstructOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::CompositeConstructOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::CompositeExtractOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::CompositeExtractOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::CompositeInsertOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::CompositeInsertOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::ControlBarrierOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::ControlBarrierOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::ConvertFToSOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::ConvertFToSOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::ConvertFToUOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::ConvertFToUOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::ConvertPtrToUOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::ConvertPtrToUOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::ConvertSToFOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::ConvertSToFOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::ConvertUToFOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::ConvertUToFOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::ConvertUToPtrOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::ConvertUToPtrOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::CopyMemoryOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::CopyMemoryOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::DotOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::DotOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::EXTAtomicFAddOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::EXTAtomicFAddOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::EXTConstantCompositeReplicateOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::EXTConstantCompositeReplicateOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::EXTEmitMeshTasksOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::EXTEmitMeshTasksOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::EXTSetMeshOutputsOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::EXTSetMeshOutputsOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::EXTSpecConstantCompositeReplicateOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::EXTSpecConstantCompositeReplicateOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::EmitVertexOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::EmitVertexOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::EndPrimitiveOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::EndPrimitiveOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::EntryPointOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::EntryPointOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::ExecutionModeIdOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::ExecutionModeIdOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::ExecutionModeOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::ExecutionModeOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::ExperimentalMLCallOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::ExperimentalMLCallOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::FAddOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::FAddOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::FConvertOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::FConvertOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::FDivOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::FDivOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::FModOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::FModOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::FMulOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::FMulOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::FNegateOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::FNegateOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::FOrdEqualOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::FOrdEqualOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::FOrdGreaterThanEqualOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::FOrdGreaterThanEqualOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::FOrdGreaterThanOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::FOrdGreaterThanOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::FOrdLessThanEqualOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::FOrdLessThanEqualOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::FOrdLessThanOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::FOrdLessThanOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::FOrdNotEqualOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::FOrdNotEqualOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::FRemOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::FRemOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::FSubOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::FSubOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::FUnordEqualOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::FUnordEqualOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::FUnordGreaterThanEqualOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::FUnordGreaterThanEqualOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::FUnordGreaterThanOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::FUnordGreaterThanOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::FUnordLessThanEqualOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::FUnordLessThanEqualOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::FUnordLessThanOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::FUnordLessThanOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::FUnordNotEqualOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::FUnordNotEqualOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::FunctionCallOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::FunctionCallOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLAcosOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLAcosOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLAcoshOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLAcoshOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLAsinOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLAsinOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLAsinhOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLAsinhOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLAtan2Op>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLAtan2Op>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLAtanOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLAtanOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLAtanhOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLAtanhOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLCeilOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLCeilOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLCosOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLCosOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLCoshOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLCoshOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLCrossOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLCrossOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLDegreesOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLDegreesOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLDistanceOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLDistanceOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLExp2Op>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLExp2Op>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLExpOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLExpOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLFAbsOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLFAbsOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLFClampOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLFClampOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLFMaxOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLFMaxOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLFMinOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLFMinOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLFMixOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLFMixOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLFSignOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLFSignOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLFindILsbOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLFindILsbOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLFindSMsbOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLFindSMsbOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLFindUMsbOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLFindUMsbOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLFloorOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLFloorOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLFmaOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLFmaOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLFractOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLFractOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLFrexpStructOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLFrexpStructOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLInverseSqrtOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLInverseSqrtOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLLdexpOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLLdexpOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLLengthOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLLengthOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLLog2Op>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLLog2Op>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLLogOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLLogOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLNormalizeOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLNormalizeOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLPackHalf2x16Op>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLPackHalf2x16Op>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLPackSnorm4x8Op>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLPackSnorm4x8Op>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLPowOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLPowOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLRadiansOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLRadiansOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLReflectOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLReflectOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLRoundEvenOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLRoundEvenOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLRoundOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLRoundOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLSAbsOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLSAbsOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLSClampOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLSClampOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLSMaxOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLSMaxOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLSMinOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLSMinOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLSSignOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLSSignOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLSinOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLSinOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLSinhOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLSinhOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLSqrtOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLSqrtOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLTanOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLTanOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLTanhOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLTanhOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLTruncOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLTruncOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLUClampOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLUClampOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLUMaxOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLUMaxOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLUMinOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLUMinOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLUnpackHalf2x16Op>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLUnpackHalf2x16Op>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GLUnpackSnorm4x8Op>(op)) {
|
|
return processOp(cast<::mlir::spirv::GLUnpackSnorm4x8Op>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GenericCastToPtrExplicitOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GenericCastToPtrExplicitOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GenericCastToPtrOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GenericCastToPtrOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GraphConstantARMOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GraphConstantARMOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GraphEntryPointARMOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GraphEntryPointARMOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GroupBroadcastOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GroupBroadcastOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GroupFAddOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GroupFAddOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GroupFMaxOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GroupFMaxOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GroupFMinOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GroupFMinOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GroupFMulKHROp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GroupFMulKHROp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GroupIAddOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GroupIAddOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GroupIMulKHROp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GroupIMulKHROp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GroupNonUniformAllEqualOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GroupNonUniformAllEqualOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GroupNonUniformAllOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GroupNonUniformAllOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GroupNonUniformAnyOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GroupNonUniformAnyOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GroupNonUniformBallotBitCountOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GroupNonUniformBallotBitCountOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GroupNonUniformBallotFindLSBOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GroupNonUniformBallotFindLSBOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GroupNonUniformBallotFindMSBOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GroupNonUniformBallotFindMSBOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GroupNonUniformBallotOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GroupNonUniformBallotOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GroupNonUniformBitwiseAndOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GroupNonUniformBitwiseAndOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GroupNonUniformBitwiseOrOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GroupNonUniformBitwiseOrOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GroupNonUniformBitwiseXorOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GroupNonUniformBitwiseXorOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GroupNonUniformBroadcastFirstOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GroupNonUniformBroadcastFirstOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GroupNonUniformBroadcastOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GroupNonUniformBroadcastOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GroupNonUniformElectOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GroupNonUniformElectOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GroupNonUniformFAddOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GroupNonUniformFAddOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GroupNonUniformFMaxOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GroupNonUniformFMaxOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GroupNonUniformFMinOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GroupNonUniformFMinOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GroupNonUniformFMulOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GroupNonUniformFMulOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GroupNonUniformIAddOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GroupNonUniformIAddOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GroupNonUniformIMulOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GroupNonUniformIMulOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GroupNonUniformLogicalAndOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GroupNonUniformLogicalAndOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GroupNonUniformLogicalOrOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GroupNonUniformLogicalOrOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GroupNonUniformLogicalXorOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GroupNonUniformLogicalXorOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GroupNonUniformQuadSwapOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GroupNonUniformQuadSwapOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GroupNonUniformRotateKHROp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GroupNonUniformRotateKHROp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GroupNonUniformSMaxOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GroupNonUniformSMaxOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GroupNonUniformSMinOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GroupNonUniformSMinOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GroupNonUniformShuffleDownOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GroupNonUniformShuffleDownOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GroupNonUniformShuffleOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GroupNonUniformShuffleOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GroupNonUniformShuffleUpOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GroupNonUniformShuffleUpOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GroupNonUniformShuffleXorOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GroupNonUniformShuffleXorOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GroupNonUniformUMaxOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GroupNonUniformUMaxOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GroupNonUniformUMinOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GroupNonUniformUMinOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GroupSMaxOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GroupSMaxOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GroupSMinOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GroupSMinOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GroupUMaxOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GroupUMaxOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::GroupUMinOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::GroupUMinOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::IAddCarryOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::IAddCarryOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::IAddOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::IAddOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::IEqualOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::IEqualOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::IMulOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::IMulOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::INTELControlBarrierArriveOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::INTELControlBarrierArriveOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::INTELControlBarrierWaitOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::INTELControlBarrierWaitOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::INTELConvertBF16ToFOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::INTELConvertBF16ToFOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::INTELConvertFToBF16Op>(op)) {
|
|
return processOp(cast<::mlir::spirv::INTELConvertFToBF16Op>(op));
|
|
}
|
|
if (isa<::mlir::spirv::INTELMaskedGatherOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::INTELMaskedGatherOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::INTELMaskedScatterOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::INTELMaskedScatterOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::INTELRoundFToTF32Op>(op)) {
|
|
return processOp(cast<::mlir::spirv::INTELRoundFToTF32Op>(op));
|
|
}
|
|
if (isa<::mlir::spirv::INTELSubgroupBlockReadOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::INTELSubgroupBlockReadOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::INTELSubgroupBlockWriteOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::INTELSubgroupBlockWriteOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::INotEqualOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::INotEqualOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::ISubBorrowOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::ISubBorrowOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::ISubOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::ISubOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::ImageDrefGatherOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::ImageDrefGatherOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::ImageFetchOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::ImageFetchOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::ImageOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::ImageOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::ImageQuerySizeOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::ImageQuerySizeOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::ImageReadOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::ImageReadOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::ImageSampleExplicitLodOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::ImageSampleExplicitLodOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::ImageSampleImplicitLodOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::ImageSampleImplicitLodOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::ImageSampleProjDrefImplicitLodOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::ImageSampleProjDrefImplicitLodOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::ImageWriteOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::ImageWriteOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::InBoundsPtrAccessChainOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::InBoundsPtrAccessChainOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::IsFiniteOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::IsFiniteOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::IsInfOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::IsInfOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::IsNanOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::IsNanOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::IsNormalOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::IsNormalOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::KHRAssumeTrueOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::KHRAssumeTrueOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::KHRCooperativeMatrixLengthOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::KHRCooperativeMatrixLengthOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::KHRCooperativeMatrixLoadOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::KHRCooperativeMatrixLoadOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::KHRCooperativeMatrixMulAddOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::KHRCooperativeMatrixMulAddOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::KHRCooperativeMatrixStoreOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::KHRCooperativeMatrixStoreOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::KHRExpectOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::KHRExpectOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::KHRSubgroupBallotOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::KHRSubgroupBallotOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::KillOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::KillOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::LoadOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::LoadOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::LogicalAndOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::LogicalAndOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::LogicalEqualOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::LogicalEqualOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::LogicalNotEqualOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::LogicalNotEqualOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::LogicalNotOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::LogicalNotOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::LogicalOrOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::LogicalOrOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::MatrixTimesMatrixOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::MatrixTimesMatrixOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::MatrixTimesScalarOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::MatrixTimesScalarOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::MatrixTimesVectorOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::MatrixTimesVectorOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::MemoryBarrierOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::MemoryBarrierOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::MemoryNamedBarrierOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::MemoryNamedBarrierOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::NamedBarrierInitializeOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::NamedBarrierInitializeOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::NotOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::NotOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::OrderedOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::OrderedOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::OuterProductOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::OuterProductOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::PtrAccessChainOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::PtrAccessChainOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::PtrCastToGenericOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::PtrCastToGenericOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::ReturnOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::ReturnOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::ReturnValueOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::ReturnValueOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::SConvertOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::SConvertOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::SDivOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::SDivOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::SDotAccSatOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::SDotAccSatOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::SDotOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::SDotOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::SGreaterThanEqualOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::SGreaterThanEqualOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::SGreaterThanOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::SGreaterThanOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::SLessThanEqualOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::SLessThanEqualOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::SLessThanOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::SLessThanOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::SModOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::SModOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::SMulExtendedOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::SMulExtendedOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::SNegateOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::SNegateOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::SRemOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::SRemOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::SUDotAccSatOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::SUDotAccSatOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::SUDotOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::SUDotOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::SampledImageOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::SampledImageOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::SelectOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::SelectOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::ShiftLeftLogicalOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::ShiftLeftLogicalOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::ShiftRightArithmeticOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::ShiftRightArithmeticOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::ShiftRightLogicalOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::ShiftRightLogicalOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::StoreOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::StoreOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::SwitchOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::SwitchOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaAbsOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaAbsOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaAddOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaAddOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaArgMaxOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaArgMaxOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaArithmeticRightShiftOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaArithmeticRightShiftOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaAvgPool2DOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaAvgPool2DOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaBitwiseAndOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaBitwiseAndOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaBitwiseNotOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaBitwiseNotOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaBitwiseOrOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaBitwiseOrOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaBitwiseXorOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaBitwiseXorOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaCastOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaCastOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaCeilOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaCeilOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaClampOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaClampOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaClzOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaClzOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaConcatOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaConcatOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaConv2DOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaConv2DOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaConv3DOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaConv3DOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaCosOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaCosOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaDepthwiseConv2DOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaDepthwiseConv2DOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaEqualOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaEqualOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaErfOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaErfOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaExpOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaExpOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaFFT2DOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaFFT2DOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaFloorOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaFloorOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaGatherOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaGatherOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaGreaterEqualOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaGreaterEqualOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaGreaterOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaGreaterOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaIntDivOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaIntDivOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaLogOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaLogOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaLogicalAndOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaLogicalAndOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaLogicalLeftShiftOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaLogicalLeftShiftOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaLogicalNotOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaLogicalNotOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaLogicalOrOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaLogicalOrOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaLogicalRightShiftOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaLogicalRightShiftOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaLogicalXorOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaLogicalXorOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaMatMulOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaMatMulOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaMaxPool2DOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaMaxPool2DOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaMaximumOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaMaximumOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaMinimumOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaMinimumOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaMulOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaMulOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaNegateOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaNegateOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaPadOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaPadOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaPowOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaPowOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaRFFT2DOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaRFFT2DOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaReciprocalOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaReciprocalOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaReduceAllOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaReduceAllOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaReduceAnyOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaReduceAnyOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaReduceMaxOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaReduceMaxOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaReduceMinOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaReduceMinOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaReduceProductOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaReduceProductOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaReduceSumOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaReduceSumOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaRescaleOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaRescaleOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaReshapeOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaReshapeOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaResizeOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaResizeOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaReverseOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaReverseOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaRsqrtOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaRsqrtOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaScatterOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaScatterOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaSelectOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaSelectOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaSigmoidOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaSigmoidOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaSinOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaSinOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaSliceOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaSliceOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaSubOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaSubOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaTableOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaTableOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaTanhOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaTanhOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaTileOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaTileOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaTransposeConv2DOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaTransposeConv2DOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TosaTransposeOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TosaTransposeOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::TransposeOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::TransposeOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::UConvertOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::UConvertOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::UDivOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::UDivOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::UDotAccSatOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::UDotAccSatOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::UDotOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::UDotOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::UGreaterThanEqualOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::UGreaterThanEqualOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::UGreaterThanOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::UGreaterThanOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::ULessThanEqualOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::ULessThanEqualOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::ULessThanOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::ULessThanOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::UModOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::UModOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::UMulExtendedOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::UMulExtendedOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::UnorderedOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::UnorderedOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::UnreachableOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::UnreachableOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::VariableOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::VariableOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::VectorExtractDynamicOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::VectorExtractDynamicOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::VectorInsertDynamicOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::VectorInsertDynamicOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::VectorShuffleOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::VectorShuffleOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::VectorTimesMatrixOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::VectorTimesMatrixOp>(op));
|
|
}
|
|
if (isa<::mlir::spirv::VectorTimesScalarOp>(op)) {
|
|
return processOp(cast<::mlir::spirv::VectorTimesScalarOp>(op));
|
|
}
|
|
return op->emitError("unhandled operation serialization");
|
|
}
|
|
|
|
#endif // GET_SERIALIZATION_FNS
|
|
|
|
#ifdef GET_DESERIALIZATION_FNS
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::AccessChainOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::AccessChainOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::AccessChainOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
for (; wordIndex < words.size(); ++wordIndex) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::AccessChainOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::AccessChainOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::AllOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.All", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::AnyOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Any", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::AtomicAndOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::AtomicAndOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::AtomicAndOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("memory_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("semantics", opBuilder.getAttr<::mlir::spirv::MemorySemanticsAttr>(static_cast<::mlir::spirv::MemorySemantics>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::AtomicAndOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::AtomicAndOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::AtomicCompareExchangeOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::AtomicCompareExchangeOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::AtomicCompareExchangeOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("memory_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("equal_semantics", opBuilder.getAttr<::mlir::spirv::MemorySemanticsAttr>(static_cast<::mlir::spirv::MemorySemantics>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("unequal_semantics", opBuilder.getAttr<::mlir::spirv::MemorySemanticsAttr>(static_cast<::mlir::spirv::MemorySemantics>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::AtomicCompareExchangeOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::AtomicCompareExchangeOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::AtomicCompareExchangeWeakOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::AtomicCompareExchangeWeakOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::AtomicCompareExchangeWeakOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("memory_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("equal_semantics", opBuilder.getAttr<::mlir::spirv::MemorySemanticsAttr>(static_cast<::mlir::spirv::MemorySemantics>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("unequal_semantics", opBuilder.getAttr<::mlir::spirv::MemorySemanticsAttr>(static_cast<::mlir::spirv::MemorySemantics>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::AtomicCompareExchangeWeakOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::AtomicCompareExchangeWeakOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::AtomicExchangeOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::AtomicExchangeOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::AtomicExchangeOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("memory_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("semantics", opBuilder.getAttr<::mlir::spirv::MemorySemanticsAttr>(static_cast<::mlir::spirv::MemorySemantics>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::AtomicExchangeOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::AtomicExchangeOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::AtomicIAddOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::AtomicIAddOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::AtomicIAddOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("memory_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("semantics", opBuilder.getAttr<::mlir::spirv::MemorySemanticsAttr>(static_cast<::mlir::spirv::MemorySemantics>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::AtomicIAddOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::AtomicIAddOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::AtomicIDecrementOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::AtomicIDecrementOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::AtomicIDecrementOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("memory_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("semantics", opBuilder.getAttr<::mlir::spirv::MemorySemanticsAttr>(static_cast<::mlir::spirv::MemorySemantics>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::AtomicIDecrementOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::AtomicIDecrementOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::AtomicIIncrementOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::AtomicIIncrementOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::AtomicIIncrementOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("memory_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("semantics", opBuilder.getAttr<::mlir::spirv::MemorySemanticsAttr>(static_cast<::mlir::spirv::MemorySemantics>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::AtomicIIncrementOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::AtomicIIncrementOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::AtomicISubOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::AtomicISubOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::AtomicISubOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("memory_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("semantics", opBuilder.getAttr<::mlir::spirv::MemorySemanticsAttr>(static_cast<::mlir::spirv::MemorySemantics>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::AtomicISubOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::AtomicISubOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::AtomicLoadOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::AtomicLoadOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::AtomicLoadOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("memory_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("semantics", opBuilder.getAttr<::mlir::spirv::MemorySemanticsAttr>(static_cast<::mlir::spirv::MemorySemantics>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::AtomicLoadOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::AtomicLoadOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::AtomicOrOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::AtomicOrOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::AtomicOrOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("memory_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("semantics", opBuilder.getAttr<::mlir::spirv::MemorySemanticsAttr>(static_cast<::mlir::spirv::MemorySemantics>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::AtomicOrOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::AtomicOrOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::AtomicSMaxOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::AtomicSMaxOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::AtomicSMaxOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("memory_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("semantics", opBuilder.getAttr<::mlir::spirv::MemorySemanticsAttr>(static_cast<::mlir::spirv::MemorySemantics>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::AtomicSMaxOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::AtomicSMaxOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::AtomicSMinOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::AtomicSMinOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::AtomicSMinOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("memory_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("semantics", opBuilder.getAttr<::mlir::spirv::MemorySemanticsAttr>(static_cast<::mlir::spirv::MemorySemantics>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::AtomicSMinOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::AtomicSMinOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::AtomicStoreOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("memory_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("semantics", opBuilder.getAttr<::mlir::spirv::MemorySemanticsAttr>(static_cast<::mlir::spirv::MemorySemantics>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::AtomicStoreOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::AtomicStoreOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::AtomicUMaxOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::AtomicUMaxOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::AtomicUMaxOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("memory_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("semantics", opBuilder.getAttr<::mlir::spirv::MemorySemanticsAttr>(static_cast<::mlir::spirv::MemorySemantics>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::AtomicUMaxOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::AtomicUMaxOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::AtomicUMinOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::AtomicUMinOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::AtomicUMinOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("memory_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("semantics", opBuilder.getAttr<::mlir::spirv::MemorySemanticsAttr>(static_cast<::mlir::spirv::MemorySemantics>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::AtomicUMinOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::AtomicUMinOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::AtomicXorOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::AtomicXorOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::AtomicXorOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("memory_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("semantics", opBuilder.getAttr<::mlir::spirv::MemorySemanticsAttr>(static_cast<::mlir::spirv::MemorySemantics>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::AtomicXorOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::AtomicXorOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::BitCountOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.BitCount", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::BitFieldInsertOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.BitFieldInsert", true, 4);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::BitFieldSExtractOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.BitFieldSExtract", true, 3);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::BitFieldUExtractOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.BitFieldUExtract", true, 3);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::BitReverseOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.BitReverse", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::BitcastOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Bitcast", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::BitwiseAndOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.BitwiseAnd", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::BitwiseOrOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.BitwiseOr", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::BitwiseXorOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.BitwiseXor", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::CLAcosOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.CL.acos", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::CLAcoshOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.CL.acosh", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::CLAsinOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.CL.asin", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::CLAsinhOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.CL.asinh", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::CLAtan2Op>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.CL.atan2", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::CLAtanOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.CL.atan", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::CLAtanhOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.CL.atanh", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::CLCbrtOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.CL.cbrt", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::CLCeilOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.CL.ceil", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::CLClzOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.CL.clz", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::CLCosOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.CL.cos", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::CLCoshOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.CL.cosh", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::CLErfOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.CL.erf", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::CLErfcOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.CL.erfc", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::CLExp2Op>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.CL.exp2", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::CLExp10Op>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.CL.exp10", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::CLExpOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.CL.exp", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::CLExpm1Op>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.CL.expm1", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::CLFAbsOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.CL.fabs", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::CLFMaxOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.CL.fmax", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::CLFMinOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.CL.fmin", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::CLFloorOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.CL.floor", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::CLFmaOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.CL.fma", true, 3);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::CLLdexpOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.CL.ldexp", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::CLLog1pOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.CL.log1p", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::CLLog2Op>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.CL.log2", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::CLLog10Op>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.CL.log10", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::CLLogOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.CL.log", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::CLMixOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.CL.mix", true, 3);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::CLPowOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.CL.pow", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::CLPownOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.CL.pown", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::CLPrintfOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::CLPrintfOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::CLPrintfOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
for (; wordIndex < words.size(); ++wordIndex) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::CLPrintfOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::CLPrintfOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::CLRintOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.CL.rint", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::CLRootnOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.CL.rootn", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::CLRoundOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.CL.round", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::CLRsqrtOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.CL.rsqrt", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::CLSAbsOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.CL.s_abs", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::CLSMaxOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.CL.s_max", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::CLSMinOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.CL.s_min", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::CLSinOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.CL.sin", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::CLSinhOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.CL.sinh", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::CLSqrtOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.CL.sqrt", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::CLTanOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.CL.tan", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::CLTanhOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.CL.tanh", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::CLTruncOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.CL.trunc", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::CLUMaxOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.CL.u_max", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::CLUMinOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.CL.u_min", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::CompositeConstructOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::CompositeConstructOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::CompositeConstructOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
for (; wordIndex < words.size(); ++wordIndex) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::CompositeConstructOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::CompositeConstructOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::CompositeExtractOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::CompositeExtractOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::CompositeExtractOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
SmallVector<Attribute, 4> attrListElems;
|
|
while (wordIndex < words.size()) {
|
|
attrListElems.push_back(opBuilder.getI32IntegerAttr(words[wordIndex++]));
|
|
}
|
|
attributes.push_back(opBuilder.getNamedAttr("indices", opBuilder.getArrayAttr(attrListElems)));
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::CompositeExtractOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::CompositeExtractOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::CompositeInsertOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::CompositeInsertOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::CompositeInsertOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
SmallVector<Attribute, 4> attrListElems;
|
|
while (wordIndex < words.size()) {
|
|
attrListElems.push_back(opBuilder.getI32IntegerAttr(words[wordIndex++]));
|
|
}
|
|
attributes.push_back(opBuilder.getNamedAttr("indices", opBuilder.getArrayAttr(attrListElems)));
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::CompositeInsertOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::CompositeInsertOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::ControlBarrierOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("execution_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("memory_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("memory_semantics", opBuilder.getAttr<::mlir::spirv::MemorySemanticsAttr>(static_cast<::mlir::spirv::MemorySemantics>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::ControlBarrierOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::ControlBarrierOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::ConvertFToSOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.ConvertFToS", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::ConvertFToUOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.ConvertFToU", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::ConvertPtrToUOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.ConvertPtrToU", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::ConvertSToFOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.ConvertSToF", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::ConvertUToFOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.ConvertUToF", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::ConvertUToPtrOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.ConvertUToPtr", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::DotOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Dot", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::EXTAtomicFAddOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::EXTAtomicFAddOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::EXTAtomicFAddOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("memory_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("semantics", opBuilder.getAttr<::mlir::spirv::MemorySemanticsAttr>(static_cast<::mlir::spirv::MemorySemantics>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::EXTAtomicFAddOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::EXTAtomicFAddOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::EXTEmitMeshTasksOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
for (; wordIndex < words.size(); ++wordIndex) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::EXTEmitMeshTasksOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::EXTEmitMeshTasksOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::EXTSetMeshOutputsOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.EXT.SetMeshOutputs", false, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::EmitVertexOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.EmitVertex", false, 0);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::EndPrimitiveOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.EndPrimitive", false, 0);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::ExperimentalMLCallOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::ExperimentalMLCallOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::ExperimentalMLCallOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("opcode", opBuilder.getI32IntegerAttr(words[wordIndex++])));
|
|
}
|
|
for (; wordIndex < words.size(); ++wordIndex) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::ExperimentalMLCallOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::ExperimentalMLCallOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::FAddOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.FAdd", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::FConvertOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.FConvert", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::FDivOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.FDiv", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::FModOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.FMod", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::FMulOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.FMul", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::FNegateOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.FNegate", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::FOrdEqualOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.FOrdEqual", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::FOrdGreaterThanEqualOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.FOrdGreaterThanEqual", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::FOrdGreaterThanOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.FOrdGreaterThan", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::FOrdLessThanEqualOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.FOrdLessThanEqual", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::FOrdLessThanOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.FOrdLessThan", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::FOrdNotEqualOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.FOrdNotEqual", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::FRemOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.FRem", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::FSubOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.FSub", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::FUnordEqualOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.FUnordEqual", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::FUnordGreaterThanEqualOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.FUnordGreaterThanEqual", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::FUnordGreaterThanOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.FUnordGreaterThan", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::FUnordLessThanEqualOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.FUnordLessThanEqual", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::FUnordLessThanOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.FUnordLessThan", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::FUnordNotEqualOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.FUnordNotEqual", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLAcosOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.Acos", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLAcoshOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.Acosh", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLAsinOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.Asin", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLAsinhOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.Asinh", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLAtan2Op>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.Atan2", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLAtanOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.Atan", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLAtanhOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.Atanh", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLCeilOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.Ceil", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLCosOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.Cos", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLCoshOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.Cosh", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLCrossOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.Cross", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLDegreesOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.Degrees", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLDistanceOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.Distance", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLExp2Op>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.Exp2", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLExpOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.Exp", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLFAbsOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.FAbs", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLFClampOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.FClamp", true, 3);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLFMaxOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.FMax", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLFMinOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.FMin", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLFMixOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.FMix", true, 3);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLFSignOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.FSign", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLFindILsbOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.FindILsb", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLFindSMsbOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.FindSMsb", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLFindUMsbOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.FindUMsb", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLFloorOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.Floor", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLFmaOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.Fma", true, 3);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLFractOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.Fract", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLFrexpStructOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.FrexpStruct", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLInverseSqrtOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.InverseSqrt", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLLdexpOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.Ldexp", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLLengthOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.Length", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLLog2Op>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.Log2", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLLogOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.Log", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLNormalizeOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.Normalize", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLPackHalf2x16Op>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.PackHalf2x16", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLPackSnorm4x8Op>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.PackSnorm4x8", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLPowOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.Pow", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLRadiansOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.Radians", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLReflectOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.Reflect", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLRoundEvenOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.RoundEven", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLRoundOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.Round", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLSAbsOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.SAbs", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLSClampOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.SClamp", true, 3);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLSMaxOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.SMax", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLSMinOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.SMin", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLSSignOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.SSign", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLSinOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.Sin", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLSinhOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.Sinh", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLSqrtOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.Sqrt", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLTanOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.Tan", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLTanhOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.Tanh", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLTruncOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.Trunc", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLUClampOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.UClamp", true, 3);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLUMaxOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.UMax", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLUMinOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.UMin", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLUnpackHalf2x16Op>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.UnpackHalf2x16", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GLUnpackSnorm4x8Op>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GL.UnpackSnorm4x8", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GenericCastToPtrOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.GenericCastToPtr", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GroupBroadcastOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::GroupBroadcastOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::GroupBroadcastOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("execution_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::GroupBroadcastOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::GroupBroadcastOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GroupFAddOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::GroupFAddOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::GroupFAddOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("execution_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("group_operation", opBuilder.getAttr<::mlir::spirv::GroupOperationAttr>(static_cast<::mlir::spirv::GroupOperation>(words[wordIndex++]))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::GroupFAddOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::GroupFAddOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GroupFMaxOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::GroupFMaxOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::GroupFMaxOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("execution_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("group_operation", opBuilder.getAttr<::mlir::spirv::GroupOperationAttr>(static_cast<::mlir::spirv::GroupOperation>(words[wordIndex++]))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::GroupFMaxOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::GroupFMaxOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GroupFMinOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::GroupFMinOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::GroupFMinOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("execution_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("group_operation", opBuilder.getAttr<::mlir::spirv::GroupOperationAttr>(static_cast<::mlir::spirv::GroupOperation>(words[wordIndex++]))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::GroupFMinOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::GroupFMinOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GroupFMulKHROp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::GroupFMulKHROp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::GroupFMulKHROp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("execution_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("group_operation", opBuilder.getAttr<::mlir::spirv::GroupOperationAttr>(static_cast<::mlir::spirv::GroupOperation>(words[wordIndex++]))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::GroupFMulKHROp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::GroupFMulKHROp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GroupIAddOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::GroupIAddOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::GroupIAddOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("execution_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("group_operation", opBuilder.getAttr<::mlir::spirv::GroupOperationAttr>(static_cast<::mlir::spirv::GroupOperation>(words[wordIndex++]))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::GroupIAddOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::GroupIAddOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GroupIMulKHROp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::GroupIMulKHROp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::GroupIMulKHROp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("execution_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("group_operation", opBuilder.getAttr<::mlir::spirv::GroupOperationAttr>(static_cast<::mlir::spirv::GroupOperation>(words[wordIndex++]))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::GroupIMulKHROp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::GroupIMulKHROp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GroupNonUniformAllEqualOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::GroupNonUniformAllEqualOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::GroupNonUniformAllEqualOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("execution_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::GroupNonUniformAllEqualOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::GroupNonUniformAllEqualOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GroupNonUniformAllOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::GroupNonUniformAllOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::GroupNonUniformAllOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("execution_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::GroupNonUniformAllOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::GroupNonUniformAllOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GroupNonUniformAnyOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::GroupNonUniformAnyOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::GroupNonUniformAnyOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("execution_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::GroupNonUniformAnyOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::GroupNonUniformAnyOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GroupNonUniformBallotBitCountOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::GroupNonUniformBallotBitCountOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::GroupNonUniformBallotBitCountOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("execution_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("group_operation", opBuilder.getAttr<::mlir::spirv::GroupOperationAttr>(static_cast<::mlir::spirv::GroupOperation>(words[wordIndex++]))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::GroupNonUniformBallotBitCountOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::GroupNonUniformBallotBitCountOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GroupNonUniformBallotFindLSBOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::GroupNonUniformBallotFindLSBOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::GroupNonUniformBallotFindLSBOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("execution_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::GroupNonUniformBallotFindLSBOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::GroupNonUniformBallotFindLSBOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GroupNonUniformBallotFindMSBOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::GroupNonUniformBallotFindMSBOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::GroupNonUniformBallotFindMSBOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("execution_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::GroupNonUniformBallotFindMSBOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::GroupNonUniformBallotFindMSBOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GroupNonUniformBallotOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::GroupNonUniformBallotOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::GroupNonUniformBallotOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("execution_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::GroupNonUniformBallotOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::GroupNonUniformBallotOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GroupNonUniformBitwiseAndOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::GroupNonUniformBitwiseAndOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::GroupNonUniformBitwiseAndOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("execution_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("group_operation", opBuilder.getAttr<::mlir::spirv::GroupOperationAttr>(static_cast<::mlir::spirv::GroupOperation>(words[wordIndex++]))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
for (; wordIndex < words.size(); ++wordIndex) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::GroupNonUniformBitwiseAndOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::GroupNonUniformBitwiseAndOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GroupNonUniformBitwiseOrOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::GroupNonUniformBitwiseOrOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::GroupNonUniformBitwiseOrOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("execution_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("group_operation", opBuilder.getAttr<::mlir::spirv::GroupOperationAttr>(static_cast<::mlir::spirv::GroupOperation>(words[wordIndex++]))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
for (; wordIndex < words.size(); ++wordIndex) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::GroupNonUniformBitwiseOrOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::GroupNonUniformBitwiseOrOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GroupNonUniformBitwiseXorOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::GroupNonUniformBitwiseXorOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::GroupNonUniformBitwiseXorOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("execution_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("group_operation", opBuilder.getAttr<::mlir::spirv::GroupOperationAttr>(static_cast<::mlir::spirv::GroupOperation>(words[wordIndex++]))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
for (; wordIndex < words.size(); ++wordIndex) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::GroupNonUniformBitwiseXorOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::GroupNonUniformBitwiseXorOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GroupNonUniformBroadcastFirstOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::GroupNonUniformBroadcastFirstOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::GroupNonUniformBroadcastFirstOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("execution_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::GroupNonUniformBroadcastFirstOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::GroupNonUniformBroadcastFirstOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GroupNonUniformBroadcastOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::GroupNonUniformBroadcastOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::GroupNonUniformBroadcastOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("execution_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::GroupNonUniformBroadcastOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::GroupNonUniformBroadcastOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GroupNonUniformElectOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::GroupNonUniformElectOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::GroupNonUniformElectOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("execution_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::GroupNonUniformElectOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::GroupNonUniformElectOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GroupNonUniformFAddOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::GroupNonUniformFAddOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::GroupNonUniformFAddOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("execution_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("group_operation", opBuilder.getAttr<::mlir::spirv::GroupOperationAttr>(static_cast<::mlir::spirv::GroupOperation>(words[wordIndex++]))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
for (; wordIndex < words.size(); ++wordIndex) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::GroupNonUniformFAddOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::GroupNonUniformFAddOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GroupNonUniformFMaxOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::GroupNonUniformFMaxOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::GroupNonUniformFMaxOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("execution_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("group_operation", opBuilder.getAttr<::mlir::spirv::GroupOperationAttr>(static_cast<::mlir::spirv::GroupOperation>(words[wordIndex++]))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
for (; wordIndex < words.size(); ++wordIndex) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::GroupNonUniformFMaxOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::GroupNonUniformFMaxOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GroupNonUniformFMinOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::GroupNonUniformFMinOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::GroupNonUniformFMinOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("execution_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("group_operation", opBuilder.getAttr<::mlir::spirv::GroupOperationAttr>(static_cast<::mlir::spirv::GroupOperation>(words[wordIndex++]))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
for (; wordIndex < words.size(); ++wordIndex) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::GroupNonUniformFMinOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::GroupNonUniformFMinOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GroupNonUniformFMulOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::GroupNonUniformFMulOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::GroupNonUniformFMulOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("execution_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("group_operation", opBuilder.getAttr<::mlir::spirv::GroupOperationAttr>(static_cast<::mlir::spirv::GroupOperation>(words[wordIndex++]))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
for (; wordIndex < words.size(); ++wordIndex) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::GroupNonUniformFMulOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::GroupNonUniformFMulOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GroupNonUniformIAddOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::GroupNonUniformIAddOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::GroupNonUniformIAddOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("execution_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("group_operation", opBuilder.getAttr<::mlir::spirv::GroupOperationAttr>(static_cast<::mlir::spirv::GroupOperation>(words[wordIndex++]))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
for (; wordIndex < words.size(); ++wordIndex) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::GroupNonUniformIAddOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::GroupNonUniformIAddOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GroupNonUniformIMulOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::GroupNonUniformIMulOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::GroupNonUniformIMulOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("execution_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("group_operation", opBuilder.getAttr<::mlir::spirv::GroupOperationAttr>(static_cast<::mlir::spirv::GroupOperation>(words[wordIndex++]))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
for (; wordIndex < words.size(); ++wordIndex) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::GroupNonUniformIMulOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::GroupNonUniformIMulOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GroupNonUniformLogicalAndOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::GroupNonUniformLogicalAndOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::GroupNonUniformLogicalAndOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("execution_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("group_operation", opBuilder.getAttr<::mlir::spirv::GroupOperationAttr>(static_cast<::mlir::spirv::GroupOperation>(words[wordIndex++]))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
for (; wordIndex < words.size(); ++wordIndex) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::GroupNonUniformLogicalAndOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::GroupNonUniformLogicalAndOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GroupNonUniformLogicalOrOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::GroupNonUniformLogicalOrOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::GroupNonUniformLogicalOrOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("execution_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("group_operation", opBuilder.getAttr<::mlir::spirv::GroupOperationAttr>(static_cast<::mlir::spirv::GroupOperation>(words[wordIndex++]))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
for (; wordIndex < words.size(); ++wordIndex) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::GroupNonUniformLogicalOrOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::GroupNonUniformLogicalOrOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GroupNonUniformLogicalXorOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::GroupNonUniformLogicalXorOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::GroupNonUniformLogicalXorOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("execution_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("group_operation", opBuilder.getAttr<::mlir::spirv::GroupOperationAttr>(static_cast<::mlir::spirv::GroupOperation>(words[wordIndex++]))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
for (; wordIndex < words.size(); ++wordIndex) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::GroupNonUniformLogicalXorOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::GroupNonUniformLogicalXorOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GroupNonUniformQuadSwapOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::GroupNonUniformQuadSwapOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::GroupNonUniformQuadSwapOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("execution_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("direction", opBuilder.getAttr<::mlir::spirv::QuadSwapDirectionAttr>(static_cast<::mlir::spirv::QuadSwapDirection>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::GroupNonUniformQuadSwapOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::GroupNonUniformQuadSwapOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GroupNonUniformRotateKHROp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::GroupNonUniformRotateKHROp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::GroupNonUniformRotateKHROp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("execution_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
for (; wordIndex < words.size(); ++wordIndex) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::GroupNonUniformRotateKHROp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::GroupNonUniformRotateKHROp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GroupNonUniformSMaxOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::GroupNonUniformSMaxOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::GroupNonUniformSMaxOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("execution_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("group_operation", opBuilder.getAttr<::mlir::spirv::GroupOperationAttr>(static_cast<::mlir::spirv::GroupOperation>(words[wordIndex++]))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
for (; wordIndex < words.size(); ++wordIndex) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::GroupNonUniformSMaxOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::GroupNonUniformSMaxOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GroupNonUniformSMinOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::GroupNonUniformSMinOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::GroupNonUniformSMinOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("execution_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("group_operation", opBuilder.getAttr<::mlir::spirv::GroupOperationAttr>(static_cast<::mlir::spirv::GroupOperation>(words[wordIndex++]))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
for (; wordIndex < words.size(); ++wordIndex) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::GroupNonUniformSMinOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::GroupNonUniformSMinOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GroupNonUniformShuffleDownOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::GroupNonUniformShuffleDownOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::GroupNonUniformShuffleDownOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("execution_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::GroupNonUniformShuffleDownOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::GroupNonUniformShuffleDownOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GroupNonUniformShuffleOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::GroupNonUniformShuffleOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::GroupNonUniformShuffleOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("execution_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::GroupNonUniformShuffleOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::GroupNonUniformShuffleOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GroupNonUniformShuffleUpOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::GroupNonUniformShuffleUpOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::GroupNonUniformShuffleUpOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("execution_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::GroupNonUniformShuffleUpOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::GroupNonUniformShuffleUpOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GroupNonUniformShuffleXorOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::GroupNonUniformShuffleXorOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::GroupNonUniformShuffleXorOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("execution_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::GroupNonUniformShuffleXorOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::GroupNonUniformShuffleXorOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GroupNonUniformUMaxOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::GroupNonUniformUMaxOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::GroupNonUniformUMaxOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("execution_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("group_operation", opBuilder.getAttr<::mlir::spirv::GroupOperationAttr>(static_cast<::mlir::spirv::GroupOperation>(words[wordIndex++]))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
for (; wordIndex < words.size(); ++wordIndex) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::GroupNonUniformUMaxOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::GroupNonUniformUMaxOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GroupNonUniformUMinOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::GroupNonUniformUMinOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::GroupNonUniformUMinOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("execution_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("group_operation", opBuilder.getAttr<::mlir::spirv::GroupOperationAttr>(static_cast<::mlir::spirv::GroupOperation>(words[wordIndex++]))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
for (; wordIndex < words.size(); ++wordIndex) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::GroupNonUniformUMinOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::GroupNonUniformUMinOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GroupSMaxOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::GroupSMaxOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::GroupSMaxOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("execution_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("group_operation", opBuilder.getAttr<::mlir::spirv::GroupOperationAttr>(static_cast<::mlir::spirv::GroupOperation>(words[wordIndex++]))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::GroupSMaxOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::GroupSMaxOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GroupSMinOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::GroupSMinOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::GroupSMinOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("execution_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("group_operation", opBuilder.getAttr<::mlir::spirv::GroupOperationAttr>(static_cast<::mlir::spirv::GroupOperation>(words[wordIndex++]))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::GroupSMinOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::GroupSMinOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GroupUMaxOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::GroupUMaxOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::GroupUMaxOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("execution_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("group_operation", opBuilder.getAttr<::mlir::spirv::GroupOperationAttr>(static_cast<::mlir::spirv::GroupOperation>(words[wordIndex++]))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::GroupUMaxOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::GroupUMaxOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::GroupUMinOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::GroupUMinOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::GroupUMinOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("execution_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("group_operation", opBuilder.getAttr<::mlir::spirv::GroupOperationAttr>(static_cast<::mlir::spirv::GroupOperation>(words[wordIndex++]))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::GroupUMinOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::GroupUMinOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::IAddCarryOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.IAddCarry", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::IAddOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.IAdd", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::IEqualOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.IEqual", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::IMulOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.IMul", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::INTELControlBarrierArriveOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("execution_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("memory_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("memory_semantics", opBuilder.getAttr<::mlir::spirv::MemorySemanticsAttr>(static_cast<::mlir::spirv::MemorySemantics>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::INTELControlBarrierArriveOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::INTELControlBarrierArriveOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::INTELControlBarrierWaitOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("execution_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("memory_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("memory_semantics", opBuilder.getAttr<::mlir::spirv::MemorySemanticsAttr>(static_cast<::mlir::spirv::MemorySemantics>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::INTELControlBarrierWaitOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::INTELControlBarrierWaitOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::INTELConvertBF16ToFOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.INTEL.ConvertBF16ToF", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::INTELConvertFToBF16Op>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.INTEL.ConvertFToBF16", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::INTELMaskedGatherOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.INTEL.MaskedGather", true, 4);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::INTELMaskedScatterOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.INTEL.MaskedScatter", false, 4);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::INTELRoundFToTF32Op>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.INTEL.RoundFToTF32", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::INTELSubgroupBlockReadOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.INTEL.SubgroupBlockRead", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::INTELSubgroupBlockWriteOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.INTEL.SubgroupBlockWrite", false, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::INotEqualOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.INotEqual", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::ISubBorrowOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.ISubBorrow", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::ISubOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.ISub", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::ImageDrefGatherOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::ImageDrefGatherOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::ImageDrefGatherOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("image_operands", opBuilder.getAttr<::mlir::spirv::ImageOperandsAttr>(static_cast<::mlir::spirv::ImageOperands>(words[wordIndex++]))));
|
|
}
|
|
for (; wordIndex < words.size(); ++wordIndex) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::ImageDrefGatherOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::ImageDrefGatherOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::ImageFetchOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::ImageFetchOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::ImageFetchOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("image_operands", opBuilder.getAttr<::mlir::spirv::ImageOperandsAttr>(static_cast<::mlir::spirv::ImageOperands>(words[wordIndex++]))));
|
|
}
|
|
for (; wordIndex < words.size(); ++wordIndex) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::ImageFetchOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::ImageFetchOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::ImageOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Image", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::ImageQuerySizeOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.ImageQuerySize", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::ImageReadOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::ImageReadOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::ImageReadOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("image_operands", opBuilder.getAttr<::mlir::spirv::ImageOperandsAttr>(static_cast<::mlir::spirv::ImageOperands>(words[wordIndex++]))));
|
|
}
|
|
for (; wordIndex < words.size(); ++wordIndex) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::ImageReadOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::ImageReadOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::ImageSampleExplicitLodOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::ImageSampleExplicitLodOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::ImageSampleExplicitLodOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("image_operands", opBuilder.getAttr<::mlir::spirv::ImageOperandsAttr>(static_cast<::mlir::spirv::ImageOperands>(words[wordIndex++]))));
|
|
}
|
|
for (; wordIndex < words.size(); ++wordIndex) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::ImageSampleExplicitLodOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::ImageSampleExplicitLodOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::ImageSampleImplicitLodOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::ImageSampleImplicitLodOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::ImageSampleImplicitLodOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("image_operands", opBuilder.getAttr<::mlir::spirv::ImageOperandsAttr>(static_cast<::mlir::spirv::ImageOperands>(words[wordIndex++]))));
|
|
}
|
|
for (; wordIndex < words.size(); ++wordIndex) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::ImageSampleImplicitLodOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::ImageSampleImplicitLodOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::ImageSampleProjDrefImplicitLodOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::ImageSampleProjDrefImplicitLodOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::ImageSampleProjDrefImplicitLodOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("image_operands", opBuilder.getAttr<::mlir::spirv::ImageOperandsAttr>(static_cast<::mlir::spirv::ImageOperands>(words[wordIndex++]))));
|
|
}
|
|
for (; wordIndex < words.size(); ++wordIndex) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::ImageSampleProjDrefImplicitLodOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::ImageSampleProjDrefImplicitLodOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::ImageWriteOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("image_operands", opBuilder.getAttr<::mlir::spirv::ImageOperandsAttr>(static_cast<::mlir::spirv::ImageOperands>(words[wordIndex++]))));
|
|
}
|
|
for (; wordIndex < words.size(); ++wordIndex) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::ImageWriteOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::ImageWriteOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::InBoundsPtrAccessChainOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::InBoundsPtrAccessChainOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::InBoundsPtrAccessChainOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
for (; wordIndex < words.size(); ++wordIndex) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::InBoundsPtrAccessChainOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::InBoundsPtrAccessChainOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::IsFiniteOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.IsFinite", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::IsInfOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.IsInf", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::IsNanOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.IsNan", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::IsNormalOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.IsNormal", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::KHRAssumeTrueOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.KHR.AssumeTrue", false, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::KHRCooperativeMatrixLengthOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::KHRCooperativeMatrixLengthOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::KHRCooperativeMatrixLengthOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("cooperative_matrix_type", TypeAttr::get(getType(words[wordIndex++]))));
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::KHRCooperativeMatrixLengthOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::KHRCooperativeMatrixLengthOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::KHRCooperativeMatrixLoadOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::KHRCooperativeMatrixLoadOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::KHRCooperativeMatrixLoadOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("matrix_layout", opBuilder.getAttr<::mlir::spirv::CooperativeMatrixLayoutKHRAttr>(static_cast<::mlir::spirv::CooperativeMatrixLayoutKHR>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("memory_operand", opBuilder.getAttr<::mlir::spirv::MemoryAccessAttr>(static_cast<::mlir::spirv::MemoryAccess>(words[wordIndex++]))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("alignment", opBuilder.getI32IntegerAttr(words[wordIndex++])));
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::KHRCooperativeMatrixLoadOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::KHRCooperativeMatrixLoadOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::KHRCooperativeMatrixMulAddOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::KHRCooperativeMatrixMulAddOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::KHRCooperativeMatrixMulAddOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("matrix_operands", opBuilder.getAttr<::mlir::spirv::CooperativeMatrixOperandsKHRAttr>(static_cast<::mlir::spirv::CooperativeMatrixOperandsKHR>(words[wordIndex++]))));
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::KHRCooperativeMatrixMulAddOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::KHRCooperativeMatrixMulAddOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::KHRCooperativeMatrixStoreOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("matrix_layout", opBuilder.getAttr<::mlir::spirv::CooperativeMatrixLayoutKHRAttr>(static_cast<::mlir::spirv::CooperativeMatrixLayoutKHR>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("memory_operand", opBuilder.getAttr<::mlir::spirv::MemoryAccessAttr>(static_cast<::mlir::spirv::MemoryAccess>(words[wordIndex++]))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("alignment", opBuilder.getI32IntegerAttr(words[wordIndex++])));
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::KHRCooperativeMatrixStoreOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::KHRCooperativeMatrixStoreOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::KHRExpectOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.KHR.Expect", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::KHRSubgroupBallotOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.KHR.SubgroupBallot", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::KillOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Kill", false, 0);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::LoadOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::LoadOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::LoadOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("memory_access", opBuilder.getAttr<::mlir::spirv::MemoryAccessAttr>(static_cast<::mlir::spirv::MemoryAccess>(words[wordIndex++]))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("alignment", opBuilder.getI32IntegerAttr(words[wordIndex++])));
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::LoadOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::LoadOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::LogicalAndOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.LogicalAnd", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::LogicalEqualOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.LogicalEqual", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::LogicalNotEqualOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.LogicalNotEqual", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::LogicalNotOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.LogicalNot", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::LogicalOrOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.LogicalOr", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::MatrixTimesMatrixOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.MatrixTimesMatrix", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::MatrixTimesScalarOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.MatrixTimesScalar", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::MatrixTimesVectorOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.MatrixTimesVector", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::MemoryBarrierOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("memory_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("memory_semantics", opBuilder.getAttr<::mlir::spirv::MemorySemanticsAttr>(static_cast<::mlir::spirv::MemorySemantics>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::MemoryBarrierOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::MemoryBarrierOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::MemoryNamedBarrierOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("memory_scope", opBuilder.getAttr<::mlir::spirv::ScopeAttr>(static_cast<::mlir::spirv::Scope>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("memory_semantics", opBuilder.getAttr<::mlir::spirv::MemorySemanticsAttr>(static_cast<::mlir::spirv::MemorySemantics>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::MemoryNamedBarrierOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::MemoryNamedBarrierOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::NamedBarrierInitializeOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.NamedBarrierInitialize", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::NotOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Not", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::OrderedOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Ordered", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::OuterProductOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.OuterProduct", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::PtrAccessChainOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::PtrAccessChainOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::PtrAccessChainOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
for (; wordIndex < words.size(); ++wordIndex) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::PtrAccessChainOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::PtrAccessChainOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::PtrCastToGenericOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.PtrCastToGeneric", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::ReturnOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Return", false, 0);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::ReturnValueOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.ReturnValue", false, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::SConvertOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.SConvert", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::SDivOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.SDiv", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::SDotAccSatOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::SDotAccSatOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::SDotAccSatOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("format", opBuilder.getAttr<::mlir::spirv::PackedVectorFormatAttr>(static_cast<::mlir::spirv::PackedVectorFormat>(words[wordIndex++]))));
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::SDotAccSatOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::SDotAccSatOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::SDotOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::SDotOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::SDotOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("format", opBuilder.getAttr<::mlir::spirv::PackedVectorFormatAttr>(static_cast<::mlir::spirv::PackedVectorFormat>(words[wordIndex++]))));
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::SDotOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::SDotOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::SGreaterThanEqualOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.SGreaterThanEqual", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::SGreaterThanOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.SGreaterThan", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::SLessThanEqualOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.SLessThanEqual", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::SLessThanOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.SLessThan", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::SModOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.SMod", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::SMulExtendedOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.SMulExtended", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::SNegateOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.SNegate", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::SRemOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.SRem", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::SUDotAccSatOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::SUDotAccSatOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::SUDotAccSatOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("format", opBuilder.getAttr<::mlir::spirv::PackedVectorFormatAttr>(static_cast<::mlir::spirv::PackedVectorFormat>(words[wordIndex++]))));
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::SUDotAccSatOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::SUDotAccSatOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::SUDotOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::SUDotOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::SUDotOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("format", opBuilder.getAttr<::mlir::spirv::PackedVectorFormatAttr>(static_cast<::mlir::spirv::PackedVectorFormat>(words[wordIndex++]))));
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::SUDotOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::SUDotOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::SampledImageOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.SampledImage", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::SelectOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Select", true, 3);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::ShiftLeftLogicalOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.ShiftLeftLogical", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::ShiftRightArithmeticOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.ShiftRightArithmetic", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::ShiftRightLogicalOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.ShiftRightLogical", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::StoreOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("memory_access", opBuilder.getAttr<::mlir::spirv::MemoryAccessAttr>(static_cast<::mlir::spirv::MemoryAccess>(words[wordIndex++]))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("alignment", opBuilder.getI32IntegerAttr(words[wordIndex++])));
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::StoreOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::StoreOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaAbsOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Tosa.Abs", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaAddOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Tosa.Add", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaArgMaxOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::TosaArgMaxOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::TosaArgMaxOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
std::optional<std::pair<Attribute, Type>> c = getConstant(words[wordIndex++]);
|
|
if (!c.has_value()) {
|
|
return emitError(unknownLoc, "could not fetch constant attribute for axis") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
attributes.push_back(opBuilder.getNamedAttr("axis", c.value().first));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("nan_mode", opBuilder.getAttr<::mlir::spirv::TosaExtNaNPropagationModeTypeAttr>(static_cast<::mlir::spirv::TosaExtNaNPropagationModeType>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::TosaArgMaxOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::TosaArgMaxOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaArithmeticRightShiftOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::TosaArithmeticRightShiftOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::TosaArithmeticRightShiftOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
std::optional<std::pair<Attribute, Type>> c = getConstant(words[wordIndex++]);
|
|
if (!c.has_value()) {
|
|
return emitError(unknownLoc, "could not fetch constant attribute for round") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
attributes.push_back(opBuilder.getNamedAttr("round", c.value().first));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::TosaArithmeticRightShiftOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::TosaArithmeticRightShiftOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaAvgPool2DOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::TosaAvgPool2DOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::TosaAvgPool2DOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
std::optional<std::pair<Attribute, Type>> c = getConstant(words[wordIndex++]);
|
|
if (!c.has_value()) {
|
|
return emitError(unknownLoc, "could not fetch constant attribute for kernel") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
attributes.push_back(opBuilder.getNamedAttr("kernel", c.value().first));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
std::optional<std::pair<Attribute, Type>> c = getConstant(words[wordIndex++]);
|
|
if (!c.has_value()) {
|
|
return emitError(unknownLoc, "could not fetch constant attribute for stride") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
attributes.push_back(opBuilder.getNamedAttr("stride", c.value().first));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
std::optional<std::pair<Attribute, Type>> c = getConstant(words[wordIndex++]);
|
|
if (!c.has_value()) {
|
|
return emitError(unknownLoc, "could not fetch constant attribute for pad") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
attributes.push_back(opBuilder.getNamedAttr("pad", c.value().first));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("acc_type", opBuilder.getAttr<::mlir::spirv::TosaExtAccTypeAttr>(static_cast<::mlir::spirv::TosaExtAccType>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::TosaAvgPool2DOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::TosaAvgPool2DOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaBitwiseAndOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Tosa.BitwiseAnd", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaBitwiseNotOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Tosa.BitwiseNot", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaBitwiseOrOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Tosa.BitwiseOr", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaBitwiseXorOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Tosa.BitwiseXor", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaCastOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Tosa.Cast", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaCeilOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Tosa.Ceil", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaClampOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::TosaClampOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::TosaClampOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
std::optional<std::pair<Attribute, Type>> c = getConstant(words[wordIndex++]);
|
|
if (!c.has_value()) {
|
|
return emitError(unknownLoc, "could not fetch constant attribute for min_val") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
attributes.push_back(opBuilder.getNamedAttr("min_val", c.value().first));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
std::optional<std::pair<Attribute, Type>> c = getConstant(words[wordIndex++]);
|
|
if (!c.has_value()) {
|
|
return emitError(unknownLoc, "could not fetch constant attribute for max_val") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
attributes.push_back(opBuilder.getNamedAttr("max_val", c.value().first));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("nan_mode", opBuilder.getAttr<::mlir::spirv::TosaExtNaNPropagationModeTypeAttr>(static_cast<::mlir::spirv::TosaExtNaNPropagationModeType>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::TosaClampOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::TosaClampOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaClzOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Tosa.Clz", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaConcatOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::TosaConcatOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::TosaConcatOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
std::optional<std::pair<Attribute, Type>> c = getConstant(words[wordIndex++]);
|
|
if (!c.has_value()) {
|
|
return emitError(unknownLoc, "could not fetch constant attribute for axis") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
attributes.push_back(opBuilder.getNamedAttr("axis", c.value().first));
|
|
}
|
|
for (; wordIndex < words.size(); ++wordIndex) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::TosaConcatOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::TosaConcatOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaConv2DOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::TosaConv2DOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::TosaConv2DOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
std::optional<std::pair<Attribute, Type>> c = getConstant(words[wordIndex++]);
|
|
if (!c.has_value()) {
|
|
return emitError(unknownLoc, "could not fetch constant attribute for pad") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
attributes.push_back(opBuilder.getNamedAttr("pad", c.value().first));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
std::optional<std::pair<Attribute, Type>> c = getConstant(words[wordIndex++]);
|
|
if (!c.has_value()) {
|
|
return emitError(unknownLoc, "could not fetch constant attribute for stride") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
attributes.push_back(opBuilder.getNamedAttr("stride", c.value().first));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
std::optional<std::pair<Attribute, Type>> c = getConstant(words[wordIndex++]);
|
|
if (!c.has_value()) {
|
|
return emitError(unknownLoc, "could not fetch constant attribute for dilation") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
attributes.push_back(opBuilder.getNamedAttr("dilation", c.value().first));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("acc_type", opBuilder.getAttr<::mlir::spirv::TosaExtAccTypeAttr>(static_cast<::mlir::spirv::TosaExtAccType>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
std::optional<std::pair<Attribute, Type>> c = getConstant(words[wordIndex++]);
|
|
if (!c.has_value()) {
|
|
return emitError(unknownLoc, "could not fetch constant attribute for local_bound") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
attributes.push_back(opBuilder.getNamedAttr("local_bound", c.value().first));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::TosaConv2DOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::TosaConv2DOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaConv3DOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::TosaConv3DOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::TosaConv3DOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
std::optional<std::pair<Attribute, Type>> c = getConstant(words[wordIndex++]);
|
|
if (!c.has_value()) {
|
|
return emitError(unknownLoc, "could not fetch constant attribute for pad") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
attributes.push_back(opBuilder.getNamedAttr("pad", c.value().first));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
std::optional<std::pair<Attribute, Type>> c = getConstant(words[wordIndex++]);
|
|
if (!c.has_value()) {
|
|
return emitError(unknownLoc, "could not fetch constant attribute for stride") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
attributes.push_back(opBuilder.getNamedAttr("stride", c.value().first));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
std::optional<std::pair<Attribute, Type>> c = getConstant(words[wordIndex++]);
|
|
if (!c.has_value()) {
|
|
return emitError(unknownLoc, "could not fetch constant attribute for dilation") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
attributes.push_back(opBuilder.getNamedAttr("dilation", c.value().first));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("acc_type", opBuilder.getAttr<::mlir::spirv::TosaExtAccTypeAttr>(static_cast<::mlir::spirv::TosaExtAccType>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
std::optional<std::pair<Attribute, Type>> c = getConstant(words[wordIndex++]);
|
|
if (!c.has_value()) {
|
|
return emitError(unknownLoc, "could not fetch constant attribute for local_bound") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
attributes.push_back(opBuilder.getNamedAttr("local_bound", c.value().first));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::TosaConv3DOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::TosaConv3DOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaCosOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Tosa.Cos", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaDepthwiseConv2DOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::TosaDepthwiseConv2DOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::TosaDepthwiseConv2DOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
std::optional<std::pair<Attribute, Type>> c = getConstant(words[wordIndex++]);
|
|
if (!c.has_value()) {
|
|
return emitError(unknownLoc, "could not fetch constant attribute for pad") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
attributes.push_back(opBuilder.getNamedAttr("pad", c.value().first));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
std::optional<std::pair<Attribute, Type>> c = getConstant(words[wordIndex++]);
|
|
if (!c.has_value()) {
|
|
return emitError(unknownLoc, "could not fetch constant attribute for stride") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
attributes.push_back(opBuilder.getNamedAttr("stride", c.value().first));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
std::optional<std::pair<Attribute, Type>> c = getConstant(words[wordIndex++]);
|
|
if (!c.has_value()) {
|
|
return emitError(unknownLoc, "could not fetch constant attribute for dilation") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
attributes.push_back(opBuilder.getNamedAttr("dilation", c.value().first));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("acc_type", opBuilder.getAttr<::mlir::spirv::TosaExtAccTypeAttr>(static_cast<::mlir::spirv::TosaExtAccType>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
std::optional<std::pair<Attribute, Type>> c = getConstant(words[wordIndex++]);
|
|
if (!c.has_value()) {
|
|
return emitError(unknownLoc, "could not fetch constant attribute for local_bound") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
attributes.push_back(opBuilder.getNamedAttr("local_bound", c.value().first));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::TosaDepthwiseConv2DOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::TosaDepthwiseConv2DOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaEqualOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Tosa.Equal", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaErfOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Tosa.Erf", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaExpOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Tosa.Exp", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaFFT2DOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::TosaFFT2DOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::TosaFFT2DOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
std::optional<std::pair<Attribute, Type>> c = getConstant(words[wordIndex++]);
|
|
if (!c.has_value()) {
|
|
return emitError(unknownLoc, "could not fetch constant attribute for inverse") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
attributes.push_back(opBuilder.getNamedAttr("inverse", c.value().first));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
std::optional<std::pair<Attribute, Type>> c = getConstant(words[wordIndex++]);
|
|
if (!c.has_value()) {
|
|
return emitError(unknownLoc, "could not fetch constant attribute for local_bound") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
attributes.push_back(opBuilder.getNamedAttr("local_bound", c.value().first));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::TosaFFT2DOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::TosaFFT2DOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaFloorOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Tosa.Floor", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaGatherOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Tosa.Gather", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaGreaterEqualOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Tosa.GreaterEqual", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaGreaterOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Tosa.Greater", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaIntDivOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Tosa.IntDiv", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaLogOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Tosa.Log", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaLogicalAndOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Tosa.LogicalAnd", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaLogicalLeftShiftOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Tosa.LogicalLeftShift", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaLogicalNotOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Tosa.LogicalNot", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaLogicalOrOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Tosa.LogicalOr", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaLogicalRightShiftOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Tosa.LogicalRightShift", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaLogicalXorOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Tosa.LogicalXor", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaMatMulOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Tosa.MatMul", true, 4);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaMaxPool2DOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::TosaMaxPool2DOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::TosaMaxPool2DOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
std::optional<std::pair<Attribute, Type>> c = getConstant(words[wordIndex++]);
|
|
if (!c.has_value()) {
|
|
return emitError(unknownLoc, "could not fetch constant attribute for kernel") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
attributes.push_back(opBuilder.getNamedAttr("kernel", c.value().first));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
std::optional<std::pair<Attribute, Type>> c = getConstant(words[wordIndex++]);
|
|
if (!c.has_value()) {
|
|
return emitError(unknownLoc, "could not fetch constant attribute for stride") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
attributes.push_back(opBuilder.getNamedAttr("stride", c.value().first));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
std::optional<std::pair<Attribute, Type>> c = getConstant(words[wordIndex++]);
|
|
if (!c.has_value()) {
|
|
return emitError(unknownLoc, "could not fetch constant attribute for pad") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
attributes.push_back(opBuilder.getNamedAttr("pad", c.value().first));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("nan_mode", opBuilder.getAttr<::mlir::spirv::TosaExtNaNPropagationModeTypeAttr>(static_cast<::mlir::spirv::TosaExtNaNPropagationModeType>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::TosaMaxPool2DOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::TosaMaxPool2DOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaMaximumOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::TosaMaximumOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::TosaMaximumOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("nan_mode", opBuilder.getAttr<::mlir::spirv::TosaExtNaNPropagationModeTypeAttr>(static_cast<::mlir::spirv::TosaExtNaNPropagationModeType>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::TosaMaximumOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::TosaMaximumOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaMinimumOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::TosaMinimumOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::TosaMinimumOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("nan_mode", opBuilder.getAttr<::mlir::spirv::TosaExtNaNPropagationModeTypeAttr>(static_cast<::mlir::spirv::TosaExtNaNPropagationModeType>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::TosaMinimumOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::TosaMinimumOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaMulOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Tosa.Mul", true, 3);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaNegateOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Tosa.Negate", true, 3);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaPadOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Tosa.Pad", true, 3);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaPowOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Tosa.Pow", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaRFFT2DOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::TosaRFFT2DOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::TosaRFFT2DOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
std::optional<std::pair<Attribute, Type>> c = getConstant(words[wordIndex++]);
|
|
if (!c.has_value()) {
|
|
return emitError(unknownLoc, "could not fetch constant attribute for local_bound") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
attributes.push_back(opBuilder.getNamedAttr("local_bound", c.value().first));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::TosaRFFT2DOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::TosaRFFT2DOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaReciprocalOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Tosa.Reciprocal", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaReduceAllOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::TosaReduceAllOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::TosaReduceAllOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
std::optional<std::pair<Attribute, Type>> c = getConstant(words[wordIndex++]);
|
|
if (!c.has_value()) {
|
|
return emitError(unknownLoc, "could not fetch constant attribute for axis") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
attributes.push_back(opBuilder.getNamedAttr("axis", c.value().first));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::TosaReduceAllOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::TosaReduceAllOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaReduceAnyOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::TosaReduceAnyOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::TosaReduceAnyOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
std::optional<std::pair<Attribute, Type>> c = getConstant(words[wordIndex++]);
|
|
if (!c.has_value()) {
|
|
return emitError(unknownLoc, "could not fetch constant attribute for axis") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
attributes.push_back(opBuilder.getNamedAttr("axis", c.value().first));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::TosaReduceAnyOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::TosaReduceAnyOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaReduceMaxOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::TosaReduceMaxOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::TosaReduceMaxOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
std::optional<std::pair<Attribute, Type>> c = getConstant(words[wordIndex++]);
|
|
if (!c.has_value()) {
|
|
return emitError(unknownLoc, "could not fetch constant attribute for axis") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
attributes.push_back(opBuilder.getNamedAttr("axis", c.value().first));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("nan_mode", opBuilder.getAttr<::mlir::spirv::TosaExtNaNPropagationModeTypeAttr>(static_cast<::mlir::spirv::TosaExtNaNPropagationModeType>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::TosaReduceMaxOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::TosaReduceMaxOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaReduceMinOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::TosaReduceMinOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::TosaReduceMinOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
std::optional<std::pair<Attribute, Type>> c = getConstant(words[wordIndex++]);
|
|
if (!c.has_value()) {
|
|
return emitError(unknownLoc, "could not fetch constant attribute for axis") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
attributes.push_back(opBuilder.getNamedAttr("axis", c.value().first));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("nan_mode", opBuilder.getAttr<::mlir::spirv::TosaExtNaNPropagationModeTypeAttr>(static_cast<::mlir::spirv::TosaExtNaNPropagationModeType>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::TosaReduceMinOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::TosaReduceMinOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaReduceProductOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::TosaReduceProductOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::TosaReduceProductOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
std::optional<std::pair<Attribute, Type>> c = getConstant(words[wordIndex++]);
|
|
if (!c.has_value()) {
|
|
return emitError(unknownLoc, "could not fetch constant attribute for axis") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
attributes.push_back(opBuilder.getNamedAttr("axis", c.value().first));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::TosaReduceProductOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::TosaReduceProductOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaReduceSumOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::TosaReduceSumOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::TosaReduceSumOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
std::optional<std::pair<Attribute, Type>> c = getConstant(words[wordIndex++]);
|
|
if (!c.has_value()) {
|
|
return emitError(unknownLoc, "could not fetch constant attribute for axis") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
attributes.push_back(opBuilder.getNamedAttr("axis", c.value().first));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::TosaReduceSumOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::TosaReduceSumOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaRescaleOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::TosaRescaleOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::TosaRescaleOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
std::optional<std::pair<Attribute, Type>> c = getConstant(words[wordIndex++]);
|
|
if (!c.has_value()) {
|
|
return emitError(unknownLoc, "could not fetch constant attribute for scale32") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
attributes.push_back(opBuilder.getNamedAttr("scale32", c.value().first));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("rounding_mode", opBuilder.getAttr<::mlir::spirv::TosaExtRoundingModeTypeAttr>(static_cast<::mlir::spirv::TosaExtRoundingModeType>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
std::optional<std::pair<Attribute, Type>> c = getConstant(words[wordIndex++]);
|
|
if (!c.has_value()) {
|
|
return emitError(unknownLoc, "could not fetch constant attribute for per_channel") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
attributes.push_back(opBuilder.getNamedAttr("per_channel", c.value().first));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
std::optional<std::pair<Attribute, Type>> c = getConstant(words[wordIndex++]);
|
|
if (!c.has_value()) {
|
|
return emitError(unknownLoc, "could not fetch constant attribute for input_unsigned") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
attributes.push_back(opBuilder.getNamedAttr("input_unsigned", c.value().first));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
std::optional<std::pair<Attribute, Type>> c = getConstant(words[wordIndex++]);
|
|
if (!c.has_value()) {
|
|
return emitError(unknownLoc, "could not fetch constant attribute for output_unsigned") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
attributes.push_back(opBuilder.getNamedAttr("output_unsigned", c.value().first));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::TosaRescaleOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::TosaRescaleOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaReshapeOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Tosa.Reshape", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaResizeOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::TosaResizeOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::TosaResizeOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("mode", opBuilder.getAttr<::mlir::spirv::TosaExtResizeModeTypeAttr>(static_cast<::mlir::spirv::TosaExtResizeModeType>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::TosaResizeOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::TosaResizeOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaReverseOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::TosaReverseOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::TosaReverseOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
std::optional<std::pair<Attribute, Type>> c = getConstant(words[wordIndex++]);
|
|
if (!c.has_value()) {
|
|
return emitError(unknownLoc, "could not fetch constant attribute for axis") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
attributes.push_back(opBuilder.getNamedAttr("axis", c.value().first));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::TosaReverseOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::TosaReverseOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaRsqrtOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Tosa.Rsqrt", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaScatterOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Tosa.Scatter", true, 3);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaSelectOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Tosa.Select", true, 3);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaSigmoidOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Tosa.Sigmoid", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaSinOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Tosa.Sin", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaSliceOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Tosa.Slice", true, 3);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaSubOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Tosa.Sub", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaTableOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Tosa.Table", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaTanhOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Tosa.Tanh", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaTileOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Tosa.Tile", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaTransposeConv2DOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::TosaTransposeConv2DOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::TosaTransposeConv2DOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
std::optional<std::pair<Attribute, Type>> c = getConstant(words[wordIndex++]);
|
|
if (!c.has_value()) {
|
|
return emitError(unknownLoc, "could not fetch constant attribute for out_pad") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
attributes.push_back(opBuilder.getNamedAttr("out_pad", c.value().first));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
std::optional<std::pair<Attribute, Type>> c = getConstant(words[wordIndex++]);
|
|
if (!c.has_value()) {
|
|
return emitError(unknownLoc, "could not fetch constant attribute for stride") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
attributes.push_back(opBuilder.getNamedAttr("stride", c.value().first));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("acc_type", opBuilder.getAttr<::mlir::spirv::TosaExtAccTypeAttr>(static_cast<::mlir::spirv::TosaExtAccType>(getConstantInt(words[wordIndex++]).getValue().getZExtValue()))));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
std::optional<std::pair<Attribute, Type>> c = getConstant(words[wordIndex++]);
|
|
if (!c.has_value()) {
|
|
return emitError(unknownLoc, "could not fetch constant attribute for local_bound") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
attributes.push_back(opBuilder.getNamedAttr("local_bound", c.value().first));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::TosaTransposeConv2DOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::TosaTransposeConv2DOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TosaTransposeOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::TosaTransposeOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::TosaTransposeOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
std::optional<std::pair<Attribute, Type>> c = getConstant(words[wordIndex++]);
|
|
if (!c.has_value()) {
|
|
return emitError(unknownLoc, "could not fetch constant attribute for perms") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
attributes.push_back(opBuilder.getNamedAttr("perms", c.value().first));
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::TosaTransposeOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::TosaTransposeOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::TransposeOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Transpose", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::UConvertOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.UConvert", true, 1);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::UDivOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.UDiv", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::UDotAccSatOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::UDotAccSatOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::UDotAccSatOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("format", opBuilder.getAttr<::mlir::spirv::PackedVectorFormatAttr>(static_cast<::mlir::spirv::PackedVectorFormat>(words[wordIndex++]))));
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::UDotAccSatOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::UDotAccSatOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::UDotOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::UDotOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::UDotOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("format", opBuilder.getAttr<::mlir::spirv::PackedVectorFormatAttr>(static_cast<::mlir::spirv::PackedVectorFormat>(words[wordIndex++]))));
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::UDotOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::UDotOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::UGreaterThanEqualOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.UGreaterThanEqual", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::UGreaterThanOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.UGreaterThan", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::ULessThanEqualOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.ULessThanEqual", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::ULessThanOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.ULessThan", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::UModOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.UMod", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::UMulExtendedOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.UMulExtended", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::UnorderedOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Unordered", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::UnreachableOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.Unreachable", false, 0);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::VariableOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::VariableOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::VariableOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
attributes.push_back(opBuilder.getNamedAttr("storage_class", opBuilder.getAttr<::mlir::spirv::StorageClassAttr>(static_cast<::mlir::spirv::StorageClass>(words[wordIndex++]))));
|
|
}
|
|
for (; wordIndex < words.size(); ++wordIndex) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::VariableOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::VariableOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::VectorExtractDynamicOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.VectorExtractDynamic", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::VectorInsertDynamicOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.VectorInsertDynamic", true, 3);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::VectorShuffleOp>(ArrayRef<uint32_t> words) {
|
|
SmallVector<Type, 1> resultTypes;
|
|
size_t wordIndex = 0; (void)wordIndex;
|
|
uint32_t valueID = 0; (void)valueID;
|
|
{
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result type <id> while deserializing ::mlir::spirv::VectorShuffleOp");
|
|
}
|
|
auto ty = getType(words[wordIndex]);
|
|
if (!ty) {
|
|
return emitError(unknownLoc, "unknown type result <id> : ") << words[wordIndex];
|
|
}
|
|
resultTypes.push_back(ty);
|
|
wordIndex++;
|
|
if (wordIndex >= words.size()) {
|
|
return emitError(unknownLoc, "expected result <id> while deserializing ::mlir::spirv::VectorShuffleOp");
|
|
}
|
|
}
|
|
valueID = words[wordIndex++];
|
|
SmallVector<Value, 4> operands;
|
|
SmallVector<NamedAttribute, 4> attributes;
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
auto arg = getValue(words[wordIndex]);
|
|
if (!arg) {
|
|
return emitError(unknownLoc, "unknown result <id> : ") << words[wordIndex];
|
|
}
|
|
operands.push_back(arg);
|
|
wordIndex++;
|
|
}
|
|
if (wordIndex < words.size()) {
|
|
SmallVector<Attribute, 4> attrListElems;
|
|
while (wordIndex < words.size()) {
|
|
attrListElems.push_back(opBuilder.getI32IntegerAttr(words[wordIndex++]));
|
|
}
|
|
attributes.push_back(opBuilder.getNamedAttr("components", opBuilder.getArrayAttr(attrListElems)));
|
|
}
|
|
if (wordIndex != words.size()) {
|
|
return emitError(unknownLoc, "found more operands than expected when deserializing ::mlir::spirv::VectorShuffleOp, only ") << wordIndex << " of " << words.size() << " processed";
|
|
}
|
|
|
|
if (decorations.count(valueID)) {
|
|
auto attrs = decorations[valueID].getAttrs();
|
|
attributes.append(attrs.begin(), attrs.end());
|
|
}
|
|
Location loc = createFileLineColLoc(opBuilder);
|
|
auto op = ::mlir::spirv::VectorShuffleOp::create(opBuilder, loc, resultTypes, operands, attributes); (void)op;
|
|
valueMap[valueID] = op.getResult();
|
|
|
|
if (op.hasTrait<OpTrait::IsTerminator>())
|
|
(void)clearDebugLine();
|
|
return success();
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::VectorTimesMatrixOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.VectorTimesMatrix", true, 2);
|
|
}
|
|
|
|
template <> LogicalResult
|
|
Deserializer::processOp<::mlir::spirv::VectorTimesScalarOp>(ArrayRef<uint32_t> words) {
|
|
return processOpWithoutGrammarAttr(words, "spirv.VectorTimesScalar", true, 2);
|
|
}
|
|
|
|
LogicalResult spirv::Deserializer::dispatchToAutogenDeserialization(spirv::Opcode opcode, ArrayRef<uint32_t> words) {
|
|
switch (opcode) {
|
|
case spirv::Opcode::OpAccessChain:
|
|
return processOp<::mlir::spirv::AccessChainOp>(words);
|
|
case spirv::Opcode::OpAll:
|
|
return processOp<::mlir::spirv::AllOp>(words);
|
|
case spirv::Opcode::OpAny:
|
|
return processOp<::mlir::spirv::AnyOp>(words);
|
|
case spirv::Opcode::OpAtomicAnd:
|
|
return processOp<::mlir::spirv::AtomicAndOp>(words);
|
|
case spirv::Opcode::OpAtomicCompareExchange:
|
|
return processOp<::mlir::spirv::AtomicCompareExchangeOp>(words);
|
|
case spirv::Opcode::OpAtomicCompareExchangeWeak:
|
|
return processOp<::mlir::spirv::AtomicCompareExchangeWeakOp>(words);
|
|
case spirv::Opcode::OpAtomicExchange:
|
|
return processOp<::mlir::spirv::AtomicExchangeOp>(words);
|
|
case spirv::Opcode::OpAtomicIAdd:
|
|
return processOp<::mlir::spirv::AtomicIAddOp>(words);
|
|
case spirv::Opcode::OpAtomicIDecrement:
|
|
return processOp<::mlir::spirv::AtomicIDecrementOp>(words);
|
|
case spirv::Opcode::OpAtomicIIncrement:
|
|
return processOp<::mlir::spirv::AtomicIIncrementOp>(words);
|
|
case spirv::Opcode::OpAtomicISub:
|
|
return processOp<::mlir::spirv::AtomicISubOp>(words);
|
|
case spirv::Opcode::OpAtomicLoad:
|
|
return processOp<::mlir::spirv::AtomicLoadOp>(words);
|
|
case spirv::Opcode::OpAtomicOr:
|
|
return processOp<::mlir::spirv::AtomicOrOp>(words);
|
|
case spirv::Opcode::OpAtomicSMax:
|
|
return processOp<::mlir::spirv::AtomicSMaxOp>(words);
|
|
case spirv::Opcode::OpAtomicSMin:
|
|
return processOp<::mlir::spirv::AtomicSMinOp>(words);
|
|
case spirv::Opcode::OpAtomicStore:
|
|
return processOp<::mlir::spirv::AtomicStoreOp>(words);
|
|
case spirv::Opcode::OpAtomicUMax:
|
|
return processOp<::mlir::spirv::AtomicUMaxOp>(words);
|
|
case spirv::Opcode::OpAtomicUMin:
|
|
return processOp<::mlir::spirv::AtomicUMinOp>(words);
|
|
case spirv::Opcode::OpAtomicXor:
|
|
return processOp<::mlir::spirv::AtomicXorOp>(words);
|
|
case spirv::Opcode::OpBitCount:
|
|
return processOp<::mlir::spirv::BitCountOp>(words);
|
|
case spirv::Opcode::OpBitFieldInsert:
|
|
return processOp<::mlir::spirv::BitFieldInsertOp>(words);
|
|
case spirv::Opcode::OpBitFieldSExtract:
|
|
return processOp<::mlir::spirv::BitFieldSExtractOp>(words);
|
|
case spirv::Opcode::OpBitFieldUExtract:
|
|
return processOp<::mlir::spirv::BitFieldUExtractOp>(words);
|
|
case spirv::Opcode::OpBitReverse:
|
|
return processOp<::mlir::spirv::BitReverseOp>(words);
|
|
case spirv::Opcode::OpBitcast:
|
|
return processOp<::mlir::spirv::BitcastOp>(words);
|
|
case spirv::Opcode::OpBitwiseAnd:
|
|
return processOp<::mlir::spirv::BitwiseAndOp>(words);
|
|
case spirv::Opcode::OpBitwiseOr:
|
|
return processOp<::mlir::spirv::BitwiseOrOp>(words);
|
|
case spirv::Opcode::OpBitwiseXor:
|
|
return processOp<::mlir::spirv::BitwiseXorOp>(words);
|
|
case spirv::Opcode::OpBranchConditional:
|
|
return processOp<::mlir::spirv::BranchConditionalOp>(words);
|
|
case spirv::Opcode::OpBranch:
|
|
return processOp<::mlir::spirv::BranchOp>(words);
|
|
case spirv::Opcode::OpCompositeConstruct:
|
|
return processOp<::mlir::spirv::CompositeConstructOp>(words);
|
|
case spirv::Opcode::OpCompositeExtract:
|
|
return processOp<::mlir::spirv::CompositeExtractOp>(words);
|
|
case spirv::Opcode::OpCompositeInsert:
|
|
return processOp<::mlir::spirv::CompositeInsertOp>(words);
|
|
case spirv::Opcode::OpControlBarrier:
|
|
return processOp<::mlir::spirv::ControlBarrierOp>(words);
|
|
case spirv::Opcode::OpConvertFToS:
|
|
return processOp<::mlir::spirv::ConvertFToSOp>(words);
|
|
case spirv::Opcode::OpConvertFToU:
|
|
return processOp<::mlir::spirv::ConvertFToUOp>(words);
|
|
case spirv::Opcode::OpConvertPtrToU:
|
|
return processOp<::mlir::spirv::ConvertPtrToUOp>(words);
|
|
case spirv::Opcode::OpConvertSToF:
|
|
return processOp<::mlir::spirv::ConvertSToFOp>(words);
|
|
case spirv::Opcode::OpConvertUToF:
|
|
return processOp<::mlir::spirv::ConvertUToFOp>(words);
|
|
case spirv::Opcode::OpConvertUToPtr:
|
|
return processOp<::mlir::spirv::ConvertUToPtrOp>(words);
|
|
case spirv::Opcode::OpCopyMemory:
|
|
return processOp<::mlir::spirv::CopyMemoryOp>(words);
|
|
case spirv::Opcode::OpDot:
|
|
return processOp<::mlir::spirv::DotOp>(words);
|
|
case spirv::Opcode::OpAtomicFAddEXT:
|
|
return processOp<::mlir::spirv::EXTAtomicFAddOp>(words);
|
|
case spirv::Opcode::OpConstantCompositeReplicateEXT:
|
|
return processOp<::mlir::spirv::EXTConstantCompositeReplicateOp>(words);
|
|
case spirv::Opcode::OpEmitMeshTasksEXT:
|
|
return processOp<::mlir::spirv::EXTEmitMeshTasksOp>(words);
|
|
case spirv::Opcode::OpSetMeshOutputsEXT:
|
|
return processOp<::mlir::spirv::EXTSetMeshOutputsOp>(words);
|
|
case spirv::Opcode::OpSpecConstantCompositeReplicateEXT:
|
|
return processOp<::mlir::spirv::EXTSpecConstantCompositeReplicateOp>(words);
|
|
case spirv::Opcode::OpEmitVertex:
|
|
return processOp<::mlir::spirv::EmitVertexOp>(words);
|
|
case spirv::Opcode::OpEndPrimitive:
|
|
return processOp<::mlir::spirv::EndPrimitiveOp>(words);
|
|
case spirv::Opcode::OpEntryPoint:
|
|
return processOp<::mlir::spirv::EntryPointOp>(words);
|
|
case spirv::Opcode::OpExecutionModeId:
|
|
return processOp<::mlir::spirv::ExecutionModeIdOp>(words);
|
|
case spirv::Opcode::OpExecutionMode:
|
|
return processOp<::mlir::spirv::ExecutionModeOp>(words);
|
|
case spirv::Opcode::OpFAdd:
|
|
return processOp<::mlir::spirv::FAddOp>(words);
|
|
case spirv::Opcode::OpFConvert:
|
|
return processOp<::mlir::spirv::FConvertOp>(words);
|
|
case spirv::Opcode::OpFDiv:
|
|
return processOp<::mlir::spirv::FDivOp>(words);
|
|
case spirv::Opcode::OpFMod:
|
|
return processOp<::mlir::spirv::FModOp>(words);
|
|
case spirv::Opcode::OpFMul:
|
|
return processOp<::mlir::spirv::FMulOp>(words);
|
|
case spirv::Opcode::OpFNegate:
|
|
return processOp<::mlir::spirv::FNegateOp>(words);
|
|
case spirv::Opcode::OpFOrdEqual:
|
|
return processOp<::mlir::spirv::FOrdEqualOp>(words);
|
|
case spirv::Opcode::OpFOrdGreaterThanEqual:
|
|
return processOp<::mlir::spirv::FOrdGreaterThanEqualOp>(words);
|
|
case spirv::Opcode::OpFOrdGreaterThan:
|
|
return processOp<::mlir::spirv::FOrdGreaterThanOp>(words);
|
|
case spirv::Opcode::OpFOrdLessThanEqual:
|
|
return processOp<::mlir::spirv::FOrdLessThanEqualOp>(words);
|
|
case spirv::Opcode::OpFOrdLessThan:
|
|
return processOp<::mlir::spirv::FOrdLessThanOp>(words);
|
|
case spirv::Opcode::OpFOrdNotEqual:
|
|
return processOp<::mlir::spirv::FOrdNotEqualOp>(words);
|
|
case spirv::Opcode::OpFRem:
|
|
return processOp<::mlir::spirv::FRemOp>(words);
|
|
case spirv::Opcode::OpFSub:
|
|
return processOp<::mlir::spirv::FSubOp>(words);
|
|
case spirv::Opcode::OpFUnordEqual:
|
|
return processOp<::mlir::spirv::FUnordEqualOp>(words);
|
|
case spirv::Opcode::OpFUnordGreaterThanEqual:
|
|
return processOp<::mlir::spirv::FUnordGreaterThanEqualOp>(words);
|
|
case spirv::Opcode::OpFUnordGreaterThan:
|
|
return processOp<::mlir::spirv::FUnordGreaterThanOp>(words);
|
|
case spirv::Opcode::OpFUnordLessThanEqual:
|
|
return processOp<::mlir::spirv::FUnordLessThanEqualOp>(words);
|
|
case spirv::Opcode::OpFUnordLessThan:
|
|
return processOp<::mlir::spirv::FUnordLessThanOp>(words);
|
|
case spirv::Opcode::OpFUnordNotEqual:
|
|
return processOp<::mlir::spirv::FUnordNotEqualOp>(words);
|
|
case spirv::Opcode::OpFunctionCall:
|
|
return processOp<::mlir::spirv::FunctionCallOp>(words);
|
|
case spirv::Opcode::OpGenericCastToPtrExplicit:
|
|
return processOp<::mlir::spirv::GenericCastToPtrExplicitOp>(words);
|
|
case spirv::Opcode::OpGenericCastToPtr:
|
|
return processOp<::mlir::spirv::GenericCastToPtrOp>(words);
|
|
case spirv::Opcode::OpGraphConstantARM:
|
|
return processOp<::mlir::spirv::GraphConstantARMOp>(words);
|
|
case spirv::Opcode::OpGraphEntryPointARM:
|
|
return processOp<::mlir::spirv::GraphEntryPointARMOp>(words);
|
|
case spirv::Opcode::OpGroupBroadcast:
|
|
return processOp<::mlir::spirv::GroupBroadcastOp>(words);
|
|
case spirv::Opcode::OpGroupFAdd:
|
|
return processOp<::mlir::spirv::GroupFAddOp>(words);
|
|
case spirv::Opcode::OpGroupFMax:
|
|
return processOp<::mlir::spirv::GroupFMaxOp>(words);
|
|
case spirv::Opcode::OpGroupFMin:
|
|
return processOp<::mlir::spirv::GroupFMinOp>(words);
|
|
case spirv::Opcode::OpGroupFMulKHR:
|
|
return processOp<::mlir::spirv::GroupFMulKHROp>(words);
|
|
case spirv::Opcode::OpGroupIAdd:
|
|
return processOp<::mlir::spirv::GroupIAddOp>(words);
|
|
case spirv::Opcode::OpGroupIMulKHR:
|
|
return processOp<::mlir::spirv::GroupIMulKHROp>(words);
|
|
case spirv::Opcode::OpGroupNonUniformAllEqual:
|
|
return processOp<::mlir::spirv::GroupNonUniformAllEqualOp>(words);
|
|
case spirv::Opcode::OpGroupNonUniformAll:
|
|
return processOp<::mlir::spirv::GroupNonUniformAllOp>(words);
|
|
case spirv::Opcode::OpGroupNonUniformAny:
|
|
return processOp<::mlir::spirv::GroupNonUniformAnyOp>(words);
|
|
case spirv::Opcode::OpGroupNonUniformBallotBitCount:
|
|
return processOp<::mlir::spirv::GroupNonUniformBallotBitCountOp>(words);
|
|
case spirv::Opcode::OpGroupNonUniformBallotFindLSB:
|
|
return processOp<::mlir::spirv::GroupNonUniformBallotFindLSBOp>(words);
|
|
case spirv::Opcode::OpGroupNonUniformBallotFindMSB:
|
|
return processOp<::mlir::spirv::GroupNonUniformBallotFindMSBOp>(words);
|
|
case spirv::Opcode::OpGroupNonUniformBallot:
|
|
return processOp<::mlir::spirv::GroupNonUniformBallotOp>(words);
|
|
case spirv::Opcode::OpGroupNonUniformBitwiseAnd:
|
|
return processOp<::mlir::spirv::GroupNonUniformBitwiseAndOp>(words);
|
|
case spirv::Opcode::OpGroupNonUniformBitwiseOr:
|
|
return processOp<::mlir::spirv::GroupNonUniformBitwiseOrOp>(words);
|
|
case spirv::Opcode::OpGroupNonUniformBitwiseXor:
|
|
return processOp<::mlir::spirv::GroupNonUniformBitwiseXorOp>(words);
|
|
case spirv::Opcode::OpGroupNonUniformBroadcastFirst:
|
|
return processOp<::mlir::spirv::GroupNonUniformBroadcastFirstOp>(words);
|
|
case spirv::Opcode::OpGroupNonUniformBroadcast:
|
|
return processOp<::mlir::spirv::GroupNonUniformBroadcastOp>(words);
|
|
case spirv::Opcode::OpGroupNonUniformElect:
|
|
return processOp<::mlir::spirv::GroupNonUniformElectOp>(words);
|
|
case spirv::Opcode::OpGroupNonUniformFAdd:
|
|
return processOp<::mlir::spirv::GroupNonUniformFAddOp>(words);
|
|
case spirv::Opcode::OpGroupNonUniformFMax:
|
|
return processOp<::mlir::spirv::GroupNonUniformFMaxOp>(words);
|
|
case spirv::Opcode::OpGroupNonUniformFMin:
|
|
return processOp<::mlir::spirv::GroupNonUniformFMinOp>(words);
|
|
case spirv::Opcode::OpGroupNonUniformFMul:
|
|
return processOp<::mlir::spirv::GroupNonUniformFMulOp>(words);
|
|
case spirv::Opcode::OpGroupNonUniformIAdd:
|
|
return processOp<::mlir::spirv::GroupNonUniformIAddOp>(words);
|
|
case spirv::Opcode::OpGroupNonUniformIMul:
|
|
return processOp<::mlir::spirv::GroupNonUniformIMulOp>(words);
|
|
case spirv::Opcode::OpGroupNonUniformLogicalAnd:
|
|
return processOp<::mlir::spirv::GroupNonUniformLogicalAndOp>(words);
|
|
case spirv::Opcode::OpGroupNonUniformLogicalOr:
|
|
return processOp<::mlir::spirv::GroupNonUniformLogicalOrOp>(words);
|
|
case spirv::Opcode::OpGroupNonUniformLogicalXor:
|
|
return processOp<::mlir::spirv::GroupNonUniformLogicalXorOp>(words);
|
|
case spirv::Opcode::OpGroupNonUniformQuadSwap:
|
|
return processOp<::mlir::spirv::GroupNonUniformQuadSwapOp>(words);
|
|
case spirv::Opcode::OpGroupNonUniformRotateKHR:
|
|
return processOp<::mlir::spirv::GroupNonUniformRotateKHROp>(words);
|
|
case spirv::Opcode::OpGroupNonUniformSMax:
|
|
return processOp<::mlir::spirv::GroupNonUniformSMaxOp>(words);
|
|
case spirv::Opcode::OpGroupNonUniformSMin:
|
|
return processOp<::mlir::spirv::GroupNonUniformSMinOp>(words);
|
|
case spirv::Opcode::OpGroupNonUniformShuffleDown:
|
|
return processOp<::mlir::spirv::GroupNonUniformShuffleDownOp>(words);
|
|
case spirv::Opcode::OpGroupNonUniformShuffle:
|
|
return processOp<::mlir::spirv::GroupNonUniformShuffleOp>(words);
|
|
case spirv::Opcode::OpGroupNonUniformShuffleUp:
|
|
return processOp<::mlir::spirv::GroupNonUniformShuffleUpOp>(words);
|
|
case spirv::Opcode::OpGroupNonUniformShuffleXor:
|
|
return processOp<::mlir::spirv::GroupNonUniformShuffleXorOp>(words);
|
|
case spirv::Opcode::OpGroupNonUniformUMax:
|
|
return processOp<::mlir::spirv::GroupNonUniformUMaxOp>(words);
|
|
case spirv::Opcode::OpGroupNonUniformUMin:
|
|
return processOp<::mlir::spirv::GroupNonUniformUMinOp>(words);
|
|
case spirv::Opcode::OpGroupSMax:
|
|
return processOp<::mlir::spirv::GroupSMaxOp>(words);
|
|
case spirv::Opcode::OpGroupSMin:
|
|
return processOp<::mlir::spirv::GroupSMinOp>(words);
|
|
case spirv::Opcode::OpGroupUMax:
|
|
return processOp<::mlir::spirv::GroupUMaxOp>(words);
|
|
case spirv::Opcode::OpGroupUMin:
|
|
return processOp<::mlir::spirv::GroupUMinOp>(words);
|
|
case spirv::Opcode::OpIAddCarry:
|
|
return processOp<::mlir::spirv::IAddCarryOp>(words);
|
|
case spirv::Opcode::OpIAdd:
|
|
return processOp<::mlir::spirv::IAddOp>(words);
|
|
case spirv::Opcode::OpIEqual:
|
|
return processOp<::mlir::spirv::IEqualOp>(words);
|
|
case spirv::Opcode::OpIMul:
|
|
return processOp<::mlir::spirv::IMulOp>(words);
|
|
case spirv::Opcode::OpControlBarrierArriveINTEL:
|
|
return processOp<::mlir::spirv::INTELControlBarrierArriveOp>(words);
|
|
case spirv::Opcode::OpControlBarrierWaitINTEL:
|
|
return processOp<::mlir::spirv::INTELControlBarrierWaitOp>(words);
|
|
case spirv::Opcode::OpConvertBF16ToFINTEL:
|
|
return processOp<::mlir::spirv::INTELConvertBF16ToFOp>(words);
|
|
case spirv::Opcode::OpConvertFToBF16INTEL:
|
|
return processOp<::mlir::spirv::INTELConvertFToBF16Op>(words);
|
|
case spirv::Opcode::OpMaskedGatherINTEL:
|
|
return processOp<::mlir::spirv::INTELMaskedGatherOp>(words);
|
|
case spirv::Opcode::OpMaskedScatterINTEL:
|
|
return processOp<::mlir::spirv::INTELMaskedScatterOp>(words);
|
|
case spirv::Opcode::OpRoundFToTF32INTEL:
|
|
return processOp<::mlir::spirv::INTELRoundFToTF32Op>(words);
|
|
case spirv::Opcode::OpSubgroupBlockReadINTEL:
|
|
return processOp<::mlir::spirv::INTELSubgroupBlockReadOp>(words);
|
|
case spirv::Opcode::OpSubgroupBlockWriteINTEL:
|
|
return processOp<::mlir::spirv::INTELSubgroupBlockWriteOp>(words);
|
|
case spirv::Opcode::OpINotEqual:
|
|
return processOp<::mlir::spirv::INotEqualOp>(words);
|
|
case spirv::Opcode::OpISubBorrow:
|
|
return processOp<::mlir::spirv::ISubBorrowOp>(words);
|
|
case spirv::Opcode::OpISub:
|
|
return processOp<::mlir::spirv::ISubOp>(words);
|
|
case spirv::Opcode::OpImageDrefGather:
|
|
return processOp<::mlir::spirv::ImageDrefGatherOp>(words);
|
|
case spirv::Opcode::OpImageFetch:
|
|
return processOp<::mlir::spirv::ImageFetchOp>(words);
|
|
case spirv::Opcode::OpImage:
|
|
return processOp<::mlir::spirv::ImageOp>(words);
|
|
case spirv::Opcode::OpImageQuerySize:
|
|
return processOp<::mlir::spirv::ImageQuerySizeOp>(words);
|
|
case spirv::Opcode::OpImageRead:
|
|
return processOp<::mlir::spirv::ImageReadOp>(words);
|
|
case spirv::Opcode::OpImageSampleExplicitLod:
|
|
return processOp<::mlir::spirv::ImageSampleExplicitLodOp>(words);
|
|
case spirv::Opcode::OpImageSampleImplicitLod:
|
|
return processOp<::mlir::spirv::ImageSampleImplicitLodOp>(words);
|
|
case spirv::Opcode::OpImageSampleProjDrefImplicitLod:
|
|
return processOp<::mlir::spirv::ImageSampleProjDrefImplicitLodOp>(words);
|
|
case spirv::Opcode::OpImageWrite:
|
|
return processOp<::mlir::spirv::ImageWriteOp>(words);
|
|
case spirv::Opcode::OpInBoundsPtrAccessChain:
|
|
return processOp<::mlir::spirv::InBoundsPtrAccessChainOp>(words);
|
|
case spirv::Opcode::OpIsFinite:
|
|
return processOp<::mlir::spirv::IsFiniteOp>(words);
|
|
case spirv::Opcode::OpIsInf:
|
|
return processOp<::mlir::spirv::IsInfOp>(words);
|
|
case spirv::Opcode::OpIsNan:
|
|
return processOp<::mlir::spirv::IsNanOp>(words);
|
|
case spirv::Opcode::OpIsNormal:
|
|
return processOp<::mlir::spirv::IsNormalOp>(words);
|
|
case spirv::Opcode::OpAssumeTrueKHR:
|
|
return processOp<::mlir::spirv::KHRAssumeTrueOp>(words);
|
|
case spirv::Opcode::OpCooperativeMatrixLengthKHR:
|
|
return processOp<::mlir::spirv::KHRCooperativeMatrixLengthOp>(words);
|
|
case spirv::Opcode::OpCooperativeMatrixLoadKHR:
|
|
return processOp<::mlir::spirv::KHRCooperativeMatrixLoadOp>(words);
|
|
case spirv::Opcode::OpCooperativeMatrixMulAddKHR:
|
|
return processOp<::mlir::spirv::KHRCooperativeMatrixMulAddOp>(words);
|
|
case spirv::Opcode::OpCooperativeMatrixStoreKHR:
|
|
return processOp<::mlir::spirv::KHRCooperativeMatrixStoreOp>(words);
|
|
case spirv::Opcode::OpExpectKHR:
|
|
return processOp<::mlir::spirv::KHRExpectOp>(words);
|
|
case spirv::Opcode::OpSubgroupBallotKHR:
|
|
return processOp<::mlir::spirv::KHRSubgroupBallotOp>(words);
|
|
case spirv::Opcode::OpKill:
|
|
return processOp<::mlir::spirv::KillOp>(words);
|
|
case spirv::Opcode::OpLoad:
|
|
return processOp<::mlir::spirv::LoadOp>(words);
|
|
case spirv::Opcode::OpLogicalAnd:
|
|
return processOp<::mlir::spirv::LogicalAndOp>(words);
|
|
case spirv::Opcode::OpLogicalEqual:
|
|
return processOp<::mlir::spirv::LogicalEqualOp>(words);
|
|
case spirv::Opcode::OpLogicalNotEqual:
|
|
return processOp<::mlir::spirv::LogicalNotEqualOp>(words);
|
|
case spirv::Opcode::OpLogicalNot:
|
|
return processOp<::mlir::spirv::LogicalNotOp>(words);
|
|
case spirv::Opcode::OpLogicalOr:
|
|
return processOp<::mlir::spirv::LogicalOrOp>(words);
|
|
case spirv::Opcode::OpMatrixTimesMatrix:
|
|
return processOp<::mlir::spirv::MatrixTimesMatrixOp>(words);
|
|
case spirv::Opcode::OpMatrixTimesScalar:
|
|
return processOp<::mlir::spirv::MatrixTimesScalarOp>(words);
|
|
case spirv::Opcode::OpMatrixTimesVector:
|
|
return processOp<::mlir::spirv::MatrixTimesVectorOp>(words);
|
|
case spirv::Opcode::OpMemoryBarrier:
|
|
return processOp<::mlir::spirv::MemoryBarrierOp>(words);
|
|
case spirv::Opcode::OpMemoryNamedBarrier:
|
|
return processOp<::mlir::spirv::MemoryNamedBarrierOp>(words);
|
|
case spirv::Opcode::OpNamedBarrierInitialize:
|
|
return processOp<::mlir::spirv::NamedBarrierInitializeOp>(words);
|
|
case spirv::Opcode::OpNot:
|
|
return processOp<::mlir::spirv::NotOp>(words);
|
|
case spirv::Opcode::OpOrdered:
|
|
return processOp<::mlir::spirv::OrderedOp>(words);
|
|
case spirv::Opcode::OpOuterProduct:
|
|
return processOp<::mlir::spirv::OuterProductOp>(words);
|
|
case spirv::Opcode::OpPtrAccessChain:
|
|
return processOp<::mlir::spirv::PtrAccessChainOp>(words);
|
|
case spirv::Opcode::OpPtrCastToGeneric:
|
|
return processOp<::mlir::spirv::PtrCastToGenericOp>(words);
|
|
case spirv::Opcode::OpReturn:
|
|
return processOp<::mlir::spirv::ReturnOp>(words);
|
|
case spirv::Opcode::OpReturnValue:
|
|
return processOp<::mlir::spirv::ReturnValueOp>(words);
|
|
case spirv::Opcode::OpSConvert:
|
|
return processOp<::mlir::spirv::SConvertOp>(words);
|
|
case spirv::Opcode::OpSDiv:
|
|
return processOp<::mlir::spirv::SDivOp>(words);
|
|
case spirv::Opcode::OpSDotAccSat:
|
|
return processOp<::mlir::spirv::SDotAccSatOp>(words);
|
|
case spirv::Opcode::OpSDot:
|
|
return processOp<::mlir::spirv::SDotOp>(words);
|
|
case spirv::Opcode::OpSGreaterThanEqual:
|
|
return processOp<::mlir::spirv::SGreaterThanEqualOp>(words);
|
|
case spirv::Opcode::OpSGreaterThan:
|
|
return processOp<::mlir::spirv::SGreaterThanOp>(words);
|
|
case spirv::Opcode::OpSLessThanEqual:
|
|
return processOp<::mlir::spirv::SLessThanEqualOp>(words);
|
|
case spirv::Opcode::OpSLessThan:
|
|
return processOp<::mlir::spirv::SLessThanOp>(words);
|
|
case spirv::Opcode::OpSMod:
|
|
return processOp<::mlir::spirv::SModOp>(words);
|
|
case spirv::Opcode::OpSMulExtended:
|
|
return processOp<::mlir::spirv::SMulExtendedOp>(words);
|
|
case spirv::Opcode::OpSNegate:
|
|
return processOp<::mlir::spirv::SNegateOp>(words);
|
|
case spirv::Opcode::OpSRem:
|
|
return processOp<::mlir::spirv::SRemOp>(words);
|
|
case spirv::Opcode::OpSUDotAccSat:
|
|
return processOp<::mlir::spirv::SUDotAccSatOp>(words);
|
|
case spirv::Opcode::OpSUDot:
|
|
return processOp<::mlir::spirv::SUDotOp>(words);
|
|
case spirv::Opcode::OpSampledImage:
|
|
return processOp<::mlir::spirv::SampledImageOp>(words);
|
|
case spirv::Opcode::OpSelect:
|
|
return processOp<::mlir::spirv::SelectOp>(words);
|
|
case spirv::Opcode::OpShiftLeftLogical:
|
|
return processOp<::mlir::spirv::ShiftLeftLogicalOp>(words);
|
|
case spirv::Opcode::OpShiftRightArithmetic:
|
|
return processOp<::mlir::spirv::ShiftRightArithmeticOp>(words);
|
|
case spirv::Opcode::OpShiftRightLogical:
|
|
return processOp<::mlir::spirv::ShiftRightLogicalOp>(words);
|
|
case spirv::Opcode::OpStore:
|
|
return processOp<::mlir::spirv::StoreOp>(words);
|
|
case spirv::Opcode::OpSwitch:
|
|
return processOp<::mlir::spirv::SwitchOp>(words);
|
|
case spirv::Opcode::OpTranspose:
|
|
return processOp<::mlir::spirv::TransposeOp>(words);
|
|
case spirv::Opcode::OpUConvert:
|
|
return processOp<::mlir::spirv::UConvertOp>(words);
|
|
case spirv::Opcode::OpUDiv:
|
|
return processOp<::mlir::spirv::UDivOp>(words);
|
|
case spirv::Opcode::OpUDotAccSat:
|
|
return processOp<::mlir::spirv::UDotAccSatOp>(words);
|
|
case spirv::Opcode::OpUDot:
|
|
return processOp<::mlir::spirv::UDotOp>(words);
|
|
case spirv::Opcode::OpUGreaterThanEqual:
|
|
return processOp<::mlir::spirv::UGreaterThanEqualOp>(words);
|
|
case spirv::Opcode::OpUGreaterThan:
|
|
return processOp<::mlir::spirv::UGreaterThanOp>(words);
|
|
case spirv::Opcode::OpULessThanEqual:
|
|
return processOp<::mlir::spirv::ULessThanEqualOp>(words);
|
|
case spirv::Opcode::OpULessThan:
|
|
return processOp<::mlir::spirv::ULessThanOp>(words);
|
|
case spirv::Opcode::OpUMod:
|
|
return processOp<::mlir::spirv::UModOp>(words);
|
|
case spirv::Opcode::OpUMulExtended:
|
|
return processOp<::mlir::spirv::UMulExtendedOp>(words);
|
|
case spirv::Opcode::OpUnordered:
|
|
return processOp<::mlir::spirv::UnorderedOp>(words);
|
|
case spirv::Opcode::OpUnreachable:
|
|
return processOp<::mlir::spirv::UnreachableOp>(words);
|
|
case spirv::Opcode::OpVariable:
|
|
return processOp<::mlir::spirv::VariableOp>(words);
|
|
case spirv::Opcode::OpVectorExtractDynamic:
|
|
return processOp<::mlir::spirv::VectorExtractDynamicOp>(words);
|
|
case spirv::Opcode::OpVectorInsertDynamic:
|
|
return processOp<::mlir::spirv::VectorInsertDynamicOp>(words);
|
|
case spirv::Opcode::OpVectorShuffle:
|
|
return processOp<::mlir::spirv::VectorShuffleOp>(words);
|
|
case spirv::Opcode::OpVectorTimesMatrix:
|
|
return processOp<::mlir::spirv::VectorTimesMatrixOp>(words);
|
|
case spirv::Opcode::OpVectorTimesScalar:
|
|
return processOp<::mlir::spirv::VectorTimesScalarOp>(words);
|
|
default:
|
|
;
|
|
}
|
|
auto opcodeString = spirv::stringifyOpcode(opcode);
|
|
if (!opcodeString.empty()) {
|
|
return emitError(unknownLoc, "unhandled deserialization of ") << opcodeString;
|
|
} else {
|
|
return emitError(unknownLoc, "unhandled opcode ") << static_cast<uint32_t>(opcode);
|
|
}
|
|
}
|
|
LogicalResult spirv::Deserializer::dispatchToExtensionSetAutogenDeserialization(StringRef extensionSetName, uint32_t instructionID, ArrayRef<uint32_t> words) {
|
|
if (extensionSetName == "TOSA.001000.1") {
|
|
switch (instructionID) {
|
|
case 31:
|
|
return processOp<::mlir::spirv::TosaAbsOp>(words);
|
|
case 14:
|
|
return processOp<::mlir::spirv::TosaAddOp>(words);
|
|
case 0:
|
|
return processOp<::mlir::spirv::TosaArgMaxOp>(words);
|
|
case 15:
|
|
return processOp<::mlir::spirv::TosaArithmeticRightShiftOp>(words);
|
|
case 1:
|
|
return processOp<::mlir::spirv::TosaAvgPool2DOp>(words);
|
|
case 16:
|
|
return processOp<::mlir::spirv::TosaBitwiseAndOp>(words);
|
|
case 32:
|
|
return processOp<::mlir::spirv::TosaBitwiseNotOp>(words);
|
|
case 17:
|
|
return processOp<::mlir::spirv::TosaBitwiseOrOp>(words);
|
|
case 18:
|
|
return processOp<::mlir::spirv::TosaBitwiseXorOp>(words);
|
|
case 64:
|
|
return processOp<::mlir::spirv::TosaCastOp>(words);
|
|
case 33:
|
|
return processOp<::mlir::spirv::TosaCeilOp>(words);
|
|
case 10:
|
|
return processOp<::mlir::spirv::TosaClampOp>(words);
|
|
case 34:
|
|
return processOp<::mlir::spirv::TosaClzOp>(words);
|
|
case 54:
|
|
return processOp<::mlir::spirv::TosaConcatOp>(words);
|
|
case 2:
|
|
return processOp<::mlir::spirv::TosaConv2DOp>(words);
|
|
case 3:
|
|
return processOp<::mlir::spirv::TosaConv3DOp>(words);
|
|
case 35:
|
|
return processOp<::mlir::spirv::TosaCosOp>(words);
|
|
case 4:
|
|
return processOp<::mlir::spirv::TosaDepthwiseConv2DOp>(words);
|
|
case 45:
|
|
return processOp<::mlir::spirv::TosaEqualOp>(words);
|
|
case 11:
|
|
return processOp<::mlir::spirv::TosaErfOp>(words);
|
|
case 36:
|
|
return processOp<::mlir::spirv::TosaExpOp>(words);
|
|
case 5:
|
|
return processOp<::mlir::spirv::TosaFFT2DOp>(words);
|
|
case 37:
|
|
return processOp<::mlir::spirv::TosaFloorOp>(words);
|
|
case 61:
|
|
return processOp<::mlir::spirv::TosaGatherOp>(words);
|
|
case 47:
|
|
return processOp<::mlir::spirv::TosaGreaterEqualOp>(words);
|
|
case 46:
|
|
return processOp<::mlir::spirv::TosaGreaterOp>(words);
|
|
case 19:
|
|
return processOp<::mlir::spirv::TosaIntDivOp>(words);
|
|
case 38:
|
|
return processOp<::mlir::spirv::TosaLogOp>(words);
|
|
case 20:
|
|
return processOp<::mlir::spirv::TosaLogicalAndOp>(words);
|
|
case 21:
|
|
return processOp<::mlir::spirv::TosaLogicalLeftShiftOp>(words);
|
|
case 39:
|
|
return processOp<::mlir::spirv::TosaLogicalNotOp>(words);
|
|
case 23:
|
|
return processOp<::mlir::spirv::TosaLogicalOrOp>(words);
|
|
case 22:
|
|
return processOp<::mlir::spirv::TosaLogicalRightShiftOp>(words);
|
|
case 24:
|
|
return processOp<::mlir::spirv::TosaLogicalXorOp>(words);
|
|
case 6:
|
|
return processOp<::mlir::spirv::TosaMatMulOp>(words);
|
|
case 7:
|
|
return processOp<::mlir::spirv::TosaMaxPool2DOp>(words);
|
|
case 25:
|
|
return processOp<::mlir::spirv::TosaMaximumOp>(words);
|
|
case 26:
|
|
return processOp<::mlir::spirv::TosaMinimumOp>(words);
|
|
case 27:
|
|
return processOp<::mlir::spirv::TosaMulOp>(words);
|
|
case 40:
|
|
return processOp<::mlir::spirv::TosaNegateOp>(words);
|
|
case 55:
|
|
return processOp<::mlir::spirv::TosaPadOp>(words);
|
|
case 28:
|
|
return processOp<::mlir::spirv::TosaPowOp>(words);
|
|
case 8:
|
|
return processOp<::mlir::spirv::TosaRFFT2DOp>(words);
|
|
case 41:
|
|
return processOp<::mlir::spirv::TosaReciprocalOp>(words);
|
|
case 48:
|
|
return processOp<::mlir::spirv::TosaReduceAllOp>(words);
|
|
case 49:
|
|
return processOp<::mlir::spirv::TosaReduceAnyOp>(words);
|
|
case 50:
|
|
return processOp<::mlir::spirv::TosaReduceMaxOp>(words);
|
|
case 51:
|
|
return processOp<::mlir::spirv::TosaReduceMinOp>(words);
|
|
case 52:
|
|
return processOp<::mlir::spirv::TosaReduceProductOp>(words);
|
|
case 53:
|
|
return processOp<::mlir::spirv::TosaReduceSumOp>(words);
|
|
case 65:
|
|
return processOp<::mlir::spirv::TosaRescaleOp>(words);
|
|
case 56:
|
|
return processOp<::mlir::spirv::TosaReshapeOp>(words);
|
|
case 63:
|
|
return processOp<::mlir::spirv::TosaResizeOp>(words);
|
|
case 57:
|
|
return processOp<::mlir::spirv::TosaReverseOp>(words);
|
|
case 42:
|
|
return processOp<::mlir::spirv::TosaRsqrtOp>(words);
|
|
case 62:
|
|
return processOp<::mlir::spirv::TosaScatterOp>(words);
|
|
case 44:
|
|
return processOp<::mlir::spirv::TosaSelectOp>(words);
|
|
case 12:
|
|
return processOp<::mlir::spirv::TosaSigmoidOp>(words);
|
|
case 43:
|
|
return processOp<::mlir::spirv::TosaSinOp>(words);
|
|
case 58:
|
|
return processOp<::mlir::spirv::TosaSliceOp>(words);
|
|
case 29:
|
|
return processOp<::mlir::spirv::TosaSubOp>(words);
|
|
case 30:
|
|
return processOp<::mlir::spirv::TosaTableOp>(words);
|
|
case 13:
|
|
return processOp<::mlir::spirv::TosaTanhOp>(words);
|
|
case 59:
|
|
return processOp<::mlir::spirv::TosaTileOp>(words);
|
|
case 9:
|
|
return processOp<::mlir::spirv::TosaTransposeConv2DOp>(words);
|
|
case 60:
|
|
return processOp<::mlir::spirv::TosaTransposeOp>(words);
|
|
default:
|
|
return emitError(unknownLoc, "unhandled deserializations of ") << instructionID << " from extension set " << extensionSetName;
|
|
}
|
|
}
|
|
if (extensionSetName == "Arm.ExperimentalMLOperations.1") {
|
|
switch (instructionID) {
|
|
case 0:
|
|
return processOp<::mlir::spirv::ExperimentalMLCallOp>(words);
|
|
default:
|
|
return emitError(unknownLoc, "unhandled deserializations of ") << instructionID << " from extension set " << extensionSetName;
|
|
}
|
|
}
|
|
if (extensionSetName == "GLSL.std.450") {
|
|
switch (instructionID) {
|
|
case 17:
|
|
return processOp<::mlir::spirv::GLAcosOp>(words);
|
|
case 23:
|
|
return processOp<::mlir::spirv::GLAcoshOp>(words);
|
|
case 16:
|
|
return processOp<::mlir::spirv::GLAsinOp>(words);
|
|
case 22:
|
|
return processOp<::mlir::spirv::GLAsinhOp>(words);
|
|
case 25:
|
|
return processOp<::mlir::spirv::GLAtan2Op>(words);
|
|
case 18:
|
|
return processOp<::mlir::spirv::GLAtanOp>(words);
|
|
case 24:
|
|
return processOp<::mlir::spirv::GLAtanhOp>(words);
|
|
case 9:
|
|
return processOp<::mlir::spirv::GLCeilOp>(words);
|
|
case 14:
|
|
return processOp<::mlir::spirv::GLCosOp>(words);
|
|
case 20:
|
|
return processOp<::mlir::spirv::GLCoshOp>(words);
|
|
case 68:
|
|
return processOp<::mlir::spirv::GLCrossOp>(words);
|
|
case 12:
|
|
return processOp<::mlir::spirv::GLDegreesOp>(words);
|
|
case 67:
|
|
return processOp<::mlir::spirv::GLDistanceOp>(words);
|
|
case 29:
|
|
return processOp<::mlir::spirv::GLExp2Op>(words);
|
|
case 27:
|
|
return processOp<::mlir::spirv::GLExpOp>(words);
|
|
case 4:
|
|
return processOp<::mlir::spirv::GLFAbsOp>(words);
|
|
case 43:
|
|
return processOp<::mlir::spirv::GLFClampOp>(words);
|
|
case 40:
|
|
return processOp<::mlir::spirv::GLFMaxOp>(words);
|
|
case 37:
|
|
return processOp<::mlir::spirv::GLFMinOp>(words);
|
|
case 46:
|
|
return processOp<::mlir::spirv::GLFMixOp>(words);
|
|
case 6:
|
|
return processOp<::mlir::spirv::GLFSignOp>(words);
|
|
case 73:
|
|
return processOp<::mlir::spirv::GLFindILsbOp>(words);
|
|
case 74:
|
|
return processOp<::mlir::spirv::GLFindSMsbOp>(words);
|
|
case 75:
|
|
return processOp<::mlir::spirv::GLFindUMsbOp>(words);
|
|
case 8:
|
|
return processOp<::mlir::spirv::GLFloorOp>(words);
|
|
case 50:
|
|
return processOp<::mlir::spirv::GLFmaOp>(words);
|
|
case 10:
|
|
return processOp<::mlir::spirv::GLFractOp>(words);
|
|
case 52:
|
|
return processOp<::mlir::spirv::GLFrexpStructOp>(words);
|
|
case 32:
|
|
return processOp<::mlir::spirv::GLInverseSqrtOp>(words);
|
|
case 53:
|
|
return processOp<::mlir::spirv::GLLdexpOp>(words);
|
|
case 66:
|
|
return processOp<::mlir::spirv::GLLengthOp>(words);
|
|
case 30:
|
|
return processOp<::mlir::spirv::GLLog2Op>(words);
|
|
case 28:
|
|
return processOp<::mlir::spirv::GLLogOp>(words);
|
|
case 69:
|
|
return processOp<::mlir::spirv::GLNormalizeOp>(words);
|
|
case 58:
|
|
return processOp<::mlir::spirv::GLPackHalf2x16Op>(words);
|
|
case 54:
|
|
return processOp<::mlir::spirv::GLPackSnorm4x8Op>(words);
|
|
case 26:
|
|
return processOp<::mlir::spirv::GLPowOp>(words);
|
|
case 11:
|
|
return processOp<::mlir::spirv::GLRadiansOp>(words);
|
|
case 71:
|
|
return processOp<::mlir::spirv::GLReflectOp>(words);
|
|
case 2:
|
|
return processOp<::mlir::spirv::GLRoundEvenOp>(words);
|
|
case 1:
|
|
return processOp<::mlir::spirv::GLRoundOp>(words);
|
|
case 5:
|
|
return processOp<::mlir::spirv::GLSAbsOp>(words);
|
|
case 45:
|
|
return processOp<::mlir::spirv::GLSClampOp>(words);
|
|
case 42:
|
|
return processOp<::mlir::spirv::GLSMaxOp>(words);
|
|
case 39:
|
|
return processOp<::mlir::spirv::GLSMinOp>(words);
|
|
case 7:
|
|
return processOp<::mlir::spirv::GLSSignOp>(words);
|
|
case 13:
|
|
return processOp<::mlir::spirv::GLSinOp>(words);
|
|
case 19:
|
|
return processOp<::mlir::spirv::GLSinhOp>(words);
|
|
case 31:
|
|
return processOp<::mlir::spirv::GLSqrtOp>(words);
|
|
case 15:
|
|
return processOp<::mlir::spirv::GLTanOp>(words);
|
|
case 21:
|
|
return processOp<::mlir::spirv::GLTanhOp>(words);
|
|
case 3:
|
|
return processOp<::mlir::spirv::GLTruncOp>(words);
|
|
case 44:
|
|
return processOp<::mlir::spirv::GLUClampOp>(words);
|
|
case 41:
|
|
return processOp<::mlir::spirv::GLUMaxOp>(words);
|
|
case 38:
|
|
return processOp<::mlir::spirv::GLUMinOp>(words);
|
|
case 62:
|
|
return processOp<::mlir::spirv::GLUnpackHalf2x16Op>(words);
|
|
case 63:
|
|
return processOp<::mlir::spirv::GLUnpackSnorm4x8Op>(words);
|
|
default:
|
|
return emitError(unknownLoc, "unhandled deserializations of ") << instructionID << " from extension set " << extensionSetName;
|
|
}
|
|
}
|
|
if (extensionSetName == "OpenCL.std") {
|
|
switch (instructionID) {
|
|
case 0:
|
|
return processOp<::mlir::spirv::CLAcosOp>(words);
|
|
case 1:
|
|
return processOp<::mlir::spirv::CLAcoshOp>(words);
|
|
case 3:
|
|
return processOp<::mlir::spirv::CLAsinOp>(words);
|
|
case 4:
|
|
return processOp<::mlir::spirv::CLAsinhOp>(words);
|
|
case 7:
|
|
return processOp<::mlir::spirv::CLAtan2Op>(words);
|
|
case 6:
|
|
return processOp<::mlir::spirv::CLAtanOp>(words);
|
|
case 8:
|
|
return processOp<::mlir::spirv::CLAtanhOp>(words);
|
|
case 11:
|
|
return processOp<::mlir::spirv::CLCbrtOp>(words);
|
|
case 12:
|
|
return processOp<::mlir::spirv::CLCeilOp>(words);
|
|
case 151:
|
|
return processOp<::mlir::spirv::CLClzOp>(words);
|
|
case 14:
|
|
return processOp<::mlir::spirv::CLCosOp>(words);
|
|
case 15:
|
|
return processOp<::mlir::spirv::CLCoshOp>(words);
|
|
case 18:
|
|
return processOp<::mlir::spirv::CLErfOp>(words);
|
|
case 17:
|
|
return processOp<::mlir::spirv::CLErfcOp>(words);
|
|
case 20:
|
|
return processOp<::mlir::spirv::CLExp2Op>(words);
|
|
case 21:
|
|
return processOp<::mlir::spirv::CLExp10Op>(words);
|
|
case 19:
|
|
return processOp<::mlir::spirv::CLExpOp>(words);
|
|
case 22:
|
|
return processOp<::mlir::spirv::CLExpm1Op>(words);
|
|
case 23:
|
|
return processOp<::mlir::spirv::CLFAbsOp>(words);
|
|
case 27:
|
|
return processOp<::mlir::spirv::CLFMaxOp>(words);
|
|
case 28:
|
|
return processOp<::mlir::spirv::CLFMinOp>(words);
|
|
case 25:
|
|
return processOp<::mlir::spirv::CLFloorOp>(words);
|
|
case 26:
|
|
return processOp<::mlir::spirv::CLFmaOp>(words);
|
|
case 34:
|
|
return processOp<::mlir::spirv::CLLdexpOp>(words);
|
|
case 40:
|
|
return processOp<::mlir::spirv::CLLog1pOp>(words);
|
|
case 38:
|
|
return processOp<::mlir::spirv::CLLog2Op>(words);
|
|
case 39:
|
|
return processOp<::mlir::spirv::CLLog10Op>(words);
|
|
case 37:
|
|
return processOp<::mlir::spirv::CLLogOp>(words);
|
|
case 99:
|
|
return processOp<::mlir::spirv::CLMixOp>(words);
|
|
case 48:
|
|
return processOp<::mlir::spirv::CLPowOp>(words);
|
|
case 49:
|
|
return processOp<::mlir::spirv::CLPownOp>(words);
|
|
case 184:
|
|
return processOp<::mlir::spirv::CLPrintfOp>(words);
|
|
case 53:
|
|
return processOp<::mlir::spirv::CLRintOp>(words);
|
|
case 54:
|
|
return processOp<::mlir::spirv::CLRootnOp>(words);
|
|
case 55:
|
|
return processOp<::mlir::spirv::CLRoundOp>(words);
|
|
case 56:
|
|
return processOp<::mlir::spirv::CLRsqrtOp>(words);
|
|
case 141:
|
|
return processOp<::mlir::spirv::CLSAbsOp>(words);
|
|
case 156:
|
|
return processOp<::mlir::spirv::CLSMaxOp>(words);
|
|
case 158:
|
|
return processOp<::mlir::spirv::CLSMinOp>(words);
|
|
case 57:
|
|
return processOp<::mlir::spirv::CLSinOp>(words);
|
|
case 59:
|
|
return processOp<::mlir::spirv::CLSinhOp>(words);
|
|
case 61:
|
|
return processOp<::mlir::spirv::CLSqrtOp>(words);
|
|
case 62:
|
|
return processOp<::mlir::spirv::CLTanOp>(words);
|
|
case 63:
|
|
return processOp<::mlir::spirv::CLTanhOp>(words);
|
|
case 66:
|
|
return processOp<::mlir::spirv::CLTruncOp>(words);
|
|
case 157:
|
|
return processOp<::mlir::spirv::CLUMaxOp>(words);
|
|
case 159:
|
|
return processOp<::mlir::spirv::CLUMinOp>(words);
|
|
default:
|
|
return emitError(unknownLoc, "unhandled deserializations of ") << instructionID << " from extension set " << extensionSetName;
|
|
}
|
|
}
|
|
return emitError(unknownLoc, "unhandled deserialization of extended instruction set extensionSetName");
|
|
}
|
|
#endif // GET_DESERIALIZATION_FNS
|
|
|