mirror of
https://github.com/boykopovar/AnyPS5.git
synced 2026-10-22 16:43:05 -05:00
Dextroid17
e5b32bb429
The registered-shader decode ran before the deferral decision, so a single instruction the decoder does not implement ended the title at registration instead of deferring the shader to its first use. Give the decoder's unsupported-instruction failures their own type (UnsupportedInstructionError): the five family-scoped SOP opcode defaults and the MIMG opcode lookup (which now names the opcode) raise it, and the decode in PrepareRegistered defers the shader with that reason when it hits one. Any other exception still throws, so the corrupt-code contract is unchanged. PPSA26344 hits this: unsupported MIMG opcode 229 (0xE5), issue #1941. The failing word is reproducible offline from the title's own shader store (cache_ps5/all_shaders.xpps, code word 260), which is how the fixture was checked before it was written. Scope: this defers the scalar-family and MIMG opcode gaps. The vector (VOP*) and memory (SMEM/MUBUF/MTBUF/FLAT/DS) opcode lookups, the modifier-level "not supported" throws and the malformed/truncated throws still abort. Widening the deferral to those is a policy call for the maintainers. Stacked on #1836 (the deferral machinery); re-stacked on its current head so this diff no longer carries #1836's earlier broad catch. Once #1836 lands only the decode change remains. Written with AI assistance.
507 lines
23 KiB
C++
507 lines
23 KiB
C++
#include "RdnaDecoder/RdnaScalarOpDecoder.hpp"
|
|
#include "RdnaDecoder/RdnaInstructionDecoder.hpp"
|
|
#include <stdexcept>
|
|
#include <string>
|
|
|
|
namespace ShaderRecompiler {
|
|
|
|
namespace {
|
|
|
|
RdnaOpcode decodeSop1Opcode(std::uint32_t opcode) {
|
|
switch (opcode) {
|
|
case 0x03u: return RdnaOpcode::SMovB32;
|
|
case 0x04u: return RdnaOpcode::SMovB64;
|
|
case 0x05u: return RdnaOpcode::SCmovB32;
|
|
case 0x06u: return RdnaOpcode::SCmovB64;
|
|
case 0x07u: return RdnaOpcode::SNotB32;
|
|
case 0x08u: return RdnaOpcode::SNotB64;
|
|
case 0x09u: return RdnaOpcode::SWqmB32;
|
|
case 0x0au: return RdnaOpcode::SWqmB64;
|
|
case 0x0bu: return RdnaOpcode::SBrevB32;
|
|
case 0x0cu: return RdnaOpcode::SBrevB64;
|
|
case 0x0du: return RdnaOpcode::SBcnt0I32B32;
|
|
case 0x0eu: return RdnaOpcode::SBcnt0I32B64;
|
|
case 0x0fu: return RdnaOpcode::SBcnt1I32B32;
|
|
case 0x10u: return RdnaOpcode::SBcnt1I32B64;
|
|
case 0x11u: return RdnaOpcode::SFf0I32B32;
|
|
case 0x12u: return RdnaOpcode::SFf0I32B64;
|
|
case 0x13u: return RdnaOpcode::SFf1I32B32;
|
|
case 0x14u: return RdnaOpcode::SFf1I32B64;
|
|
case 0x15u: return RdnaOpcode::SFlbitI32B32;
|
|
case 0x16u: return RdnaOpcode::SFlbitI32B64;
|
|
case 0x17u: return RdnaOpcode::SFlbitI32;
|
|
case 0x18u: return RdnaOpcode::SFlbitI32I64;
|
|
case 0x19u: return RdnaOpcode::SSextI32I8;
|
|
case 0x1au: return RdnaOpcode::SSextI32I16;
|
|
case 0x1bu: return RdnaOpcode::SBitset0B32;
|
|
case 0x1cu: return RdnaOpcode::SBitset0B64;
|
|
case 0x1du: return RdnaOpcode::SBitset1B32;
|
|
case 0x1eu: return RdnaOpcode::SBitset1B64;
|
|
case 0x1fu: return RdnaOpcode::SGetpcB64;
|
|
case 0x20u: return RdnaOpcode::SSetpcB64;
|
|
case 0x21u: return RdnaOpcode::SSwappcB64;
|
|
case 0x22u: return RdnaOpcode::SRfeB64;
|
|
case 0x24u: return RdnaOpcode::SAndSaveexecB64;
|
|
case 0x25u: return RdnaOpcode::SOrSaveexecB64;
|
|
case 0x26u: return RdnaOpcode::SXorSaveexecB64;
|
|
case 0x27u: return RdnaOpcode::SAndn2SaveexecB64;
|
|
case 0x28u: return RdnaOpcode::SOrn2SaveexecB64;
|
|
case 0x29u: return RdnaOpcode::SNandSaveexecB64;
|
|
case 0x2au: return RdnaOpcode::SNorSaveexecB64;
|
|
case 0x2bu: return RdnaOpcode::SXnorSaveexecB64;
|
|
case 0x2cu: return RdnaOpcode::SQuadmaskB32;
|
|
case 0x2du: return RdnaOpcode::SQuadmaskB64;
|
|
case 0x2eu: return RdnaOpcode::SMovrelsB32;
|
|
case 0x2fu: return RdnaOpcode::SMovrelsB64;
|
|
case 0x30u: return RdnaOpcode::SMovreldB32;
|
|
case 0x31u: return RdnaOpcode::SMovreldB64;
|
|
case 0x34u: return RdnaOpcode::SAbsI32;
|
|
case 0x37u: return RdnaOpcode::SAndn1SaveexecB64;
|
|
case 0x38u: return RdnaOpcode::SOrn1SaveexecB64;
|
|
case 0x39u: return RdnaOpcode::SAndn1WrexecB64;
|
|
case 0x3au: return RdnaOpcode::SAndn2WrexecB64;
|
|
case 0x3bu: return RdnaOpcode::SBitreplicateB64B32;
|
|
case 0x3cu: return RdnaOpcode::SAndSaveexecB32;
|
|
case 0x3du: return RdnaOpcode::SOrSaveexecB32;
|
|
case 0x3eu: return RdnaOpcode::SXorSaveexecB32;
|
|
case 0x3fu: return RdnaOpcode::SAndn2SaveexecB32;
|
|
case 0x40u: return RdnaOpcode::SOrn2SaveexecB32;
|
|
case 0x41u: return RdnaOpcode::SNandSaveexecB32;
|
|
case 0x42u: return RdnaOpcode::SNorSaveexecB32;
|
|
case 0x43u: return RdnaOpcode::SXnorSaveexecB32;
|
|
case 0x44u: return RdnaOpcode::SAndn1SaveexecB32;
|
|
case 0x45u: return RdnaOpcode::SOrn1SaveexecB32;
|
|
case 0x46u: return RdnaOpcode::SAndn1WrexecB32;
|
|
case 0x47u: return RdnaOpcode::SAndn2WrexecB32;
|
|
case 0x49u: return RdnaOpcode::SMovrelsd2B32;
|
|
default: throw UnsupportedInstructionError("unsupported SOP1 opcode " + std::to_string(opcode));
|
|
}
|
|
}
|
|
|
|
RdnaOpcode decodeSop2Opcode(std::uint32_t opcode) {
|
|
switch (opcode) {
|
|
case 0x00u: return RdnaOpcode::SAddU32;
|
|
case 0x01u: return RdnaOpcode::SSubU32;
|
|
case 0x02u: return RdnaOpcode::SAddI32;
|
|
case 0x03u: return RdnaOpcode::SSubI32;
|
|
case 0x04u: return RdnaOpcode::SAddcU32;
|
|
case 0x05u: return RdnaOpcode::SSubbU32;
|
|
case 0x06u: return RdnaOpcode::SMinI32;
|
|
case 0x07u: return RdnaOpcode::SMinU32;
|
|
case 0x08u: return RdnaOpcode::SMaxI32;
|
|
case 0x09u: return RdnaOpcode::SMaxU32;
|
|
case 0x0au: return RdnaOpcode::SCselectB32;
|
|
case 0x0bu: return RdnaOpcode::SCselectB64;
|
|
case 0x0eu: return RdnaOpcode::SAndB32;
|
|
case 0x0fu: return RdnaOpcode::SAndB64;
|
|
case 0x10u: return RdnaOpcode::SOrB32;
|
|
case 0x11u: return RdnaOpcode::SOrB64;
|
|
case 0x12u: return RdnaOpcode::SXorB32;
|
|
case 0x13u: return RdnaOpcode::SXorB64;
|
|
case 0x14u: return RdnaOpcode::SAndn2B32;
|
|
case 0x15u: return RdnaOpcode::SAndn2B64;
|
|
case 0x16u: return RdnaOpcode::SOrn2B32;
|
|
case 0x17u: return RdnaOpcode::SOrn2B64;
|
|
case 0x18u: return RdnaOpcode::SNandB32;
|
|
case 0x19u: return RdnaOpcode::SNandB64;
|
|
case 0x1au: return RdnaOpcode::SNorB32;
|
|
case 0x1bu: return RdnaOpcode::SNorB64;
|
|
case 0x1cu: return RdnaOpcode::SXnorB32;
|
|
case 0x1du: return RdnaOpcode::SXnorB64;
|
|
case 0x1eu: return RdnaOpcode::SLshlB32;
|
|
case 0x1fu: return RdnaOpcode::SLshlB64;
|
|
case 0x20u: return RdnaOpcode::SLshrB32;
|
|
case 0x21u: return RdnaOpcode::SLshrB64;
|
|
case 0x22u: return RdnaOpcode::SAshrI32;
|
|
case 0x23u: return RdnaOpcode::SAshrI64;
|
|
case 0x24u: return RdnaOpcode::SBfmB32;
|
|
case 0x25u: return RdnaOpcode::SBfmB64;
|
|
case 0x26u: return RdnaOpcode::SMulI32;
|
|
case 0x27u: return RdnaOpcode::SBfeU32;
|
|
case 0x28u: return RdnaOpcode::SBfeI32;
|
|
case 0x29u: return RdnaOpcode::SBfeU64;
|
|
case 0x2au: return RdnaOpcode::SBfeI64;
|
|
case 0x2cu: return RdnaOpcode::SAbsdiffI32;
|
|
case 0x2eu: return RdnaOpcode::SLshl1AddU32;
|
|
case 0x2fu: return RdnaOpcode::SLshl2AddU32;
|
|
case 0x30u: return RdnaOpcode::SLshl3AddU32;
|
|
case 0x31u: return RdnaOpcode::SLshl4AddU32;
|
|
case 0x32u: return RdnaOpcode::SPackLlB32B16;
|
|
case 0x33u: return RdnaOpcode::SPackLhB32B16;
|
|
case 0x34u: return RdnaOpcode::SPackHhB32B16;
|
|
case 0x35u: return RdnaOpcode::SMulHiU32;
|
|
case 0x36u: return RdnaOpcode::SMulHiI32;
|
|
default: throw UnsupportedInstructionError("unsupported SOP2 opcode " + std::to_string(opcode));
|
|
}
|
|
}
|
|
|
|
RdnaOpcode decodeSopcOpcode(std::uint32_t opcode) {
|
|
switch (opcode) {
|
|
case 0x00u: return RdnaOpcode::SCmpEqI32;
|
|
case 0x01u: return RdnaOpcode::SCmpLgI32;
|
|
case 0x02u: return RdnaOpcode::SCmpGtI32;
|
|
case 0x03u: return RdnaOpcode::SCmpGeI32;
|
|
case 0x04u: return RdnaOpcode::SCmpLtI32;
|
|
case 0x05u: return RdnaOpcode::SCmpLeI32;
|
|
case 0x06u: return RdnaOpcode::SCmpEqU32;
|
|
case 0x07u: return RdnaOpcode::SCmpLgU32;
|
|
case 0x08u: return RdnaOpcode::SCmpGtU32;
|
|
case 0x09u: return RdnaOpcode::SCmpGeU32;
|
|
case 0x0au: return RdnaOpcode::SCmpLtU32;
|
|
case 0x0bu: return RdnaOpcode::SCmpLeU32;
|
|
case 0x0cu: return RdnaOpcode::SBitcmp0B32;
|
|
case 0x0du: return RdnaOpcode::SBitcmp1B32;
|
|
case 0x0eu: return RdnaOpcode::SBitcmp0B64;
|
|
case 0x0fu: return RdnaOpcode::SBitcmp1B64;
|
|
case 0x12u: return RdnaOpcode::SCmpEqU64;
|
|
case 0x13u: return RdnaOpcode::SCmpLgU64;
|
|
default: throw UnsupportedInstructionError("unsupported SOPC opcode " + std::to_string(opcode));
|
|
}
|
|
}
|
|
|
|
RdnaOpcode decodeSopkOpcode(std::uint32_t opcode) {
|
|
switch (opcode) {
|
|
case 0x00u: return RdnaOpcode::SMovkI32;
|
|
case 0x01u: return RdnaOpcode::SVersion;
|
|
case 0x02u: return RdnaOpcode::SCmovkI32;
|
|
case 0x03u: return RdnaOpcode::SCmpEqI32;
|
|
case 0x04u: return RdnaOpcode::SCmpLgI32;
|
|
case 0x05u: return RdnaOpcode::SCmpGtI32;
|
|
case 0x06u: return RdnaOpcode::SCmpGeI32;
|
|
case 0x07u: return RdnaOpcode::SCmpLtI32;
|
|
case 0x08u: return RdnaOpcode::SCmpLeI32;
|
|
case 0x09u: return RdnaOpcode::SCmpEqU32;
|
|
case 0x0au: return RdnaOpcode::SCmpLgU32;
|
|
case 0x0bu: return RdnaOpcode::SCmpGtU32;
|
|
case 0x0cu: return RdnaOpcode::SCmpGeU32;
|
|
case 0x0du: return RdnaOpcode::SCmpLtU32;
|
|
case 0x0eu: return RdnaOpcode::SCmpLeU32;
|
|
case 0x0fu: return RdnaOpcode::SAddI32;
|
|
case 0x10u: return RdnaOpcode::SMulkI32;
|
|
case 0x12u: return RdnaOpcode::SGetregB32;
|
|
case 0x13u: return RdnaOpcode::SSetregB32;
|
|
case 0x15u: return RdnaOpcode::SSetregImm32B32;
|
|
case 0x16u: return RdnaOpcode::SCallB64;
|
|
case 0x17u: return RdnaOpcode::SWaitcnt;
|
|
case 0x18u: return RdnaOpcode::SWaitcnt;
|
|
case 0x19u: return RdnaOpcode::SWaitcnt;
|
|
case 0x1au: return RdnaOpcode::SWaitcnt;
|
|
case 0x1bu: return RdnaOpcode::SSubvectorLoopBegin;
|
|
case 0x1cu: return RdnaOpcode::SSubvectorLoopEnd;
|
|
default: throw UnsupportedInstructionError("unsupported SOPK opcode " + std::to_string(opcode));
|
|
}
|
|
}
|
|
|
|
RdnaOpcode decodeSoppOpcode(std::uint32_t opcode) {
|
|
switch (opcode) {
|
|
case 0x00u: return RdnaOpcode::SNop;
|
|
case 0x01u: return RdnaOpcode::SEndpgm;
|
|
case 0x02u: return RdnaOpcode::SBranch;
|
|
case 0x03u: return RdnaOpcode::SWakeup;
|
|
case 0x04u: return RdnaOpcode::SCbranchScc0;
|
|
case 0x05u: return RdnaOpcode::SCbranchScc1;
|
|
case 0x06u: return RdnaOpcode::SCbranchVccz;
|
|
case 0x07u: return RdnaOpcode::SCbranchVccnz;
|
|
case 0x08u: return RdnaOpcode::SCbranchExecz;
|
|
case 0x09u: return RdnaOpcode::SCbranchExecnz;
|
|
case 0x0au: return RdnaOpcode::SBarrier;
|
|
case 0x0bu: return RdnaOpcode::SEndpgm;
|
|
case 0x0cu: return RdnaOpcode::SWaitcnt;
|
|
case 0x0du: return RdnaOpcode::SSethalt;
|
|
case 0x0eu: return RdnaOpcode::SSleep;
|
|
case 0x0fu: return RdnaOpcode::SSetprio;
|
|
case 0x10u: return RdnaOpcode::SSendmsg;
|
|
case 0x11u: return RdnaOpcode::SSendmsghalt;
|
|
case 0x12u: return RdnaOpcode::STrap;
|
|
case 0x13u: return RdnaOpcode::SIcacheInv;
|
|
case 0x14u: return RdnaOpcode::SIncperflevel;
|
|
case 0x15u: return RdnaOpcode::SDecperflevel;
|
|
case 0x16u: return RdnaOpcode::STtracedata;
|
|
case 0x17u:
|
|
case 0x18u:
|
|
case 0x19u:
|
|
case 0x1au: return RdnaOpcode::SCbranchCdbg;
|
|
case 0x1bu:
|
|
case 0x1eu: return RdnaOpcode::SEndpgm;
|
|
case 0x1fu: return RdnaOpcode::SCodeEnd;
|
|
case 0x20u: return RdnaOpcode::SInstPrefetch;
|
|
case 0x21u: return RdnaOpcode::SClause;
|
|
case 0x22u: return RdnaOpcode::SWaitIdle;
|
|
case 0x23u: return RdnaOpcode::SWaitcntDepctr;
|
|
case 0x24u: return RdnaOpcode::SRoundMode;
|
|
case 0x25u: return RdnaOpcode::SDenormMode;
|
|
case 0x28u: return RdnaOpcode::STtracedata;
|
|
default: throw UnsupportedInstructionError("unsupported SOPP opcode " + std::to_string(opcode));
|
|
}
|
|
}
|
|
|
|
void decodeScalarBinarySources(std::uint32_t programCounter, std::span<const std::uint32_t> code, std::uint32_t wordIndex, RdnaInstruction& instruction, std::uint32_t scalarSource0, std::uint32_t scalarSource1) {
|
|
instruction.source0 = DecodeRdnaScalarSource(scalarSource0, programCounter);
|
|
instruction.source1 = DecodeRdnaScalarSource(scalarSource1, programCounter);
|
|
instruction.sourceCount = 2;
|
|
ReadRdnaLiteralOperands(code, wordIndex, instruction);
|
|
}
|
|
|
|
bool isSoppWaitOpcode(RdnaOpcode opcode) {
|
|
return opcode == RdnaOpcode::SNop || opcode == RdnaOpcode::SWaitcnt || opcode == RdnaOpcode::SWaitcntDepctr ||
|
|
opcode == RdnaOpcode::SSleep || opcode == RdnaOpcode::SSetprio || opcode == RdnaOpcode::SSendmsg ||
|
|
opcode == RdnaOpcode::STrap || opcode == RdnaOpcode::STtracedata || opcode == RdnaOpcode::SInstPrefetch ||
|
|
opcode == RdnaOpcode::SClause || opcode == RdnaOpcode::SCbranchCdbg || opcode == RdnaOpcode::SIcacheInv ||
|
|
opcode == RdnaOpcode::SIncperflevel || opcode == RdnaOpcode::SDecperflevel || opcode == RdnaOpcode::SWaitIdle ||
|
|
opcode == RdnaOpcode::SRoundMode || opcode == RdnaOpcode::SDenormMode || opcode == RdnaOpcode::SSethalt ||
|
|
opcode == RdnaOpcode::SSendmsghalt;
|
|
}
|
|
|
|
std::uint32_t scalarDestinationDwordCount(RdnaOpcode opcode) {
|
|
switch (opcode) {
|
|
case RdnaOpcode::SMovB64:
|
|
case RdnaOpcode::SCmovB64:
|
|
case RdnaOpcode::SNotB64:
|
|
case RdnaOpcode::SBrevB64:
|
|
case RdnaOpcode::SAshrI64:
|
|
case RdnaOpcode::SWqmB64:
|
|
case RdnaOpcode::SBitset0B64:
|
|
case RdnaOpcode::SBitset1B64:
|
|
case RdnaOpcode::SGetpcB64:
|
|
case RdnaOpcode::SSwappcB64:
|
|
case RdnaOpcode::SAndSaveexecB64:
|
|
case RdnaOpcode::SOrSaveexecB64:
|
|
case RdnaOpcode::SXorSaveexecB64:
|
|
case RdnaOpcode::SAndn2SaveexecB64:
|
|
case RdnaOpcode::SOrn2SaveexecB64:
|
|
case RdnaOpcode::SNandSaveexecB64:
|
|
case RdnaOpcode::SNorSaveexecB64:
|
|
case RdnaOpcode::SXnorSaveexecB64:
|
|
case RdnaOpcode::SOrn1SaveexecB64:
|
|
case RdnaOpcode::SAndn1WrexecB64:
|
|
case RdnaOpcode::SAndn2WrexecB64:
|
|
case RdnaOpcode::SQuadmaskB64:
|
|
case RdnaOpcode::SMovrelsB64:
|
|
case RdnaOpcode::SMovreldB64:
|
|
case RdnaOpcode::SAndn1SaveexecB64:
|
|
case RdnaOpcode::SBitreplicateB64B32:
|
|
case RdnaOpcode::SCselectB64:
|
|
case RdnaOpcode::SAndB64:
|
|
case RdnaOpcode::SOrB64:
|
|
case RdnaOpcode::SXorB64:
|
|
case RdnaOpcode::SAndn2B64:
|
|
case RdnaOpcode::SOrn2B64:
|
|
case RdnaOpcode::SNandB64:
|
|
case RdnaOpcode::SNorB64:
|
|
case RdnaOpcode::SXnorB64:
|
|
case RdnaOpcode::SBfeI64:
|
|
case RdnaOpcode::SLshlB64:
|
|
case RdnaOpcode::SLshrB64:
|
|
case RdnaOpcode::SBfmB64:
|
|
case RdnaOpcode::SCallB64:
|
|
case RdnaOpcode::SBfeU64: return 2u;
|
|
default: return 1u;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
RdnaInstruction DecodeRdnaScalarOp(std::span<const std::uint32_t> code, std::uint32_t wordIndex) {
|
|
if (wordIndex >= code.size()) {
|
|
throw std::out_of_range("word index is out of the code span bounds");
|
|
}
|
|
|
|
const std::uint32_t word = code[wordIndex];
|
|
if ((word & 0xc0000000u) != 0x80000000u) {
|
|
throw std::invalid_argument("word at the given index is not a scalar instruction");
|
|
}
|
|
|
|
const std::uint32_t programCounter = wordIndex * static_cast<std::uint32_t>(sizeof(std::uint32_t));
|
|
const std::uint32_t subOpcode = (word >> 23u) & 0x7fu;
|
|
|
|
if (subOpcode == 0x7du) {
|
|
return DecodeRdnaSop1(programCounter, code, wordIndex);
|
|
}
|
|
if (subOpcode == 0x7eu) {
|
|
return DecodeRdnaSopc(programCounter, code, wordIndex);
|
|
}
|
|
if (subOpcode == 0x7fu) {
|
|
return DecodeRdnaSopp(programCounter, code, wordIndex);
|
|
}
|
|
if (subOpcode >= 0x60u) {
|
|
return DecodeRdnaSopk(programCounter, code, wordIndex);
|
|
}
|
|
|
|
return DecodeRdnaSop2(programCounter, code, wordIndex);
|
|
}
|
|
|
|
RdnaInstruction DecodeRdnaSop1(std::uint32_t programCounter, std::span<const std::uint32_t> code, std::uint32_t wordIndex) {
|
|
const std::uint32_t word = code[wordIndex];
|
|
const std::uint32_t opcode = (word >> 8u) & 0xffu;
|
|
const std::uint32_t scalarSource0 = word & 0xffu;
|
|
const std::uint32_t scalarDestination = (word >> 16u) & 0x7fu;
|
|
|
|
RdnaInstruction instruction;
|
|
instruction.programCounter = programCounter;
|
|
instruction.family = RdnaInstructionFamily::SOP1;
|
|
instruction.opcodeId = opcode;
|
|
instruction.op = opcode == 0x21u && scalarDestination == 125u ? RdnaOpcode::SSetpcB64 : decodeSop1Opcode(opcode);
|
|
instruction.dataDwordCount = scalarDestinationDwordCount(instruction.op);
|
|
SetRdnaRawWords(instruction, code, wordIndex, 1);
|
|
|
|
if (instruction.op == RdnaOpcode::SGetpcB64) {
|
|
instruction.sourceCount = 0;
|
|
instruction.destination = DecodeRdnaScalarDestination(scalarDestination, programCounter);
|
|
return instruction;
|
|
}
|
|
if (instruction.op == RdnaOpcode::SSetpcB64 || instruction.op == RdnaOpcode::SRfeB64) {
|
|
instruction.sourceCount = 1;
|
|
instruction.destination.kind = RdnaOperandKind::Null;
|
|
instruction.source0 = DecodeRdnaScalarSource(scalarSource0, programCounter);
|
|
ReadRdnaLiteralOperands(code, wordIndex, instruction);
|
|
return instruction;
|
|
}
|
|
|
|
instruction.source0 = DecodeRdnaScalarSource(scalarSource0, programCounter);
|
|
instruction.destination = DecodeRdnaScalarDestination(scalarDestination, programCounter);
|
|
instruction.sourceCount = 1;
|
|
ReadRdnaLiteralOperands(code, wordIndex, instruction);
|
|
return instruction;
|
|
}
|
|
|
|
RdnaInstruction DecodeRdnaSop2(std::uint32_t programCounter, std::span<const std::uint32_t> code, std::uint32_t wordIndex) {
|
|
const std::uint32_t word = code[wordIndex];
|
|
const std::uint32_t opcode = (word >> 23u) & 0x7fu;
|
|
const std::uint32_t scalarSource1 = (word >> 8u) & 0xffu;
|
|
const std::uint32_t scalarSource0 = word & 0xffu;
|
|
const std::uint32_t scalarDestination = (word >> 16u) & 0x7fu;
|
|
|
|
RdnaInstruction instruction;
|
|
instruction.programCounter = programCounter;
|
|
instruction.family = RdnaInstructionFamily::SOP2;
|
|
instruction.opcodeId = opcode;
|
|
instruction.op = decodeSop2Opcode(opcode);
|
|
instruction.dataDwordCount = scalarDestinationDwordCount(instruction.op);
|
|
SetRdnaRawWords(instruction, code, wordIndex, 1);
|
|
|
|
instruction.destination = DecodeRdnaScalarDestination(scalarDestination, programCounter);
|
|
decodeScalarBinarySources(programCounter, code, wordIndex, instruction, scalarSource0, scalarSource1);
|
|
return instruction;
|
|
}
|
|
|
|
RdnaInstruction DecodeRdnaSopk(std::uint32_t programCounter, std::span<const std::uint32_t> code, std::uint32_t wordIndex) {
|
|
const std::uint32_t word = code[wordIndex];
|
|
const std::uint32_t opcode = (word >> 23u) & 0x1fu;
|
|
const std::uint32_t scalarRegister = (word >> 16u) & 0x7fu;
|
|
const std::int32_t immediate = (opcode >= 0x09u && opcode <= 0x0eu)
|
|
? static_cast<std::int32_t>(word & 0xffffu)
|
|
: static_cast<std::int32_t>(static_cast<std::int16_t>(word & 0xffffu));
|
|
|
|
RdnaInstruction instruction;
|
|
instruction.programCounter = programCounter;
|
|
instruction.family = RdnaInstructionFamily::SOPK;
|
|
instruction.opcodeId = opcode;
|
|
instruction.op = decodeSopkOpcode(opcode);
|
|
instruction.source0.kind = RdnaOperandKind::IntegerInlineConstant;
|
|
instruction.source0.signedVal = immediate;
|
|
instruction.source0.value = static_cast<std::uint32_t>(immediate);
|
|
instruction.sourceCount = 1;
|
|
SetRdnaRawWords(instruction, code, wordIndex, 1);
|
|
|
|
if (instruction.op == RdnaOpcode::SVersion) {
|
|
instruction.destination.kind = RdnaOperandKind::Null;
|
|
instruction.sourceCount = 0;
|
|
return instruction;
|
|
}
|
|
if (instruction.op == RdnaOpcode::SSetregImm32B32) {
|
|
instruction.destination.kind = RdnaOperandKind::Null;
|
|
instruction.source1 = instruction.source0;
|
|
instruction.source0 = DecodeRdnaScalarSource(0xffu, programCounter);
|
|
instruction.sourceCount = 2;
|
|
ReadRdnaLiteralOperands(code, wordIndex, instruction);
|
|
return instruction;
|
|
}
|
|
if (instruction.op == RdnaOpcode::SMovkI32 || instruction.op == RdnaOpcode::SCmovkI32) {
|
|
instruction.destination = DecodeRdnaScalarDestination(scalarRegister, programCounter);
|
|
return instruction;
|
|
}
|
|
if (instruction.op == RdnaOpcode::SSubvectorLoopBegin || instruction.op == RdnaOpcode::SSubvectorLoopEnd || instruction.op == RdnaOpcode::SCallB64) {
|
|
instruction.destination = DecodeRdnaScalarDestination(scalarRegister, programCounter);
|
|
instruction.dataDwordCount = scalarDestinationDwordCount(instruction.op);
|
|
instruction.branchTarget = programCounter + 4u + static_cast<std::uint32_t>(immediate * 4);
|
|
return instruction;
|
|
}
|
|
if (instruction.op == RdnaOpcode::SWaitcnt) {
|
|
const std::uint32_t waitcnt = word & 0xffffu;
|
|
instruction.destination.kind = RdnaOperandKind::Null;
|
|
instruction.source0.signedVal = static_cast<std::int32_t>(waitcnt);
|
|
instruction.source0.value = waitcnt;
|
|
instruction.sourceCount = 1;
|
|
return instruction;
|
|
}
|
|
if (instruction.op == RdnaOpcode::SGetregB32) {
|
|
instruction.destination = DecodeRdnaScalarDestination(scalarRegister, programCounter);
|
|
instruction.source0.value = word & 0xffffu;
|
|
return instruction;
|
|
}
|
|
if (instruction.op == RdnaOpcode::SSetregB32) {
|
|
instruction.destination.kind = RdnaOperandKind::Null;
|
|
instruction.source1.kind = RdnaOperandKind::LiteralConstant;
|
|
instruction.source1.value = word & 0xffffu;
|
|
instruction.source1.signedVal = immediate;
|
|
instruction.sourceCount = 2;
|
|
instruction.source0 = DecodeRdnaScalarSource(scalarRegister, programCounter);
|
|
return instruction;
|
|
}
|
|
|
|
instruction.source1 = instruction.source0;
|
|
instruction.source0 = DecodeRdnaScalarSource(scalarRegister, programCounter);
|
|
if (instruction.op == RdnaOpcode::SAddI32 || instruction.op == RdnaOpcode::SMulkI32) {
|
|
instruction.sourceCount = 2;
|
|
instruction.destination = DecodeRdnaScalarDestination(scalarRegister, programCounter);
|
|
return instruction;
|
|
}
|
|
|
|
instruction.destination.kind = RdnaOperandKind::Scc;
|
|
instruction.sourceCount = 2;
|
|
return instruction;
|
|
}
|
|
|
|
RdnaInstruction DecodeRdnaSopc(std::uint32_t programCounter, std::span<const std::uint32_t> code, std::uint32_t wordIndex) {
|
|
const std::uint32_t word = code[wordIndex];
|
|
const std::uint32_t scalarSource1 = (word >> 8u) & 0xffu;
|
|
const std::uint32_t scalarSource0 = word & 0xffu;
|
|
const std::uint32_t opcode = (word >> 16u) & 0x7fu;
|
|
|
|
RdnaInstruction instruction;
|
|
instruction.programCounter = programCounter;
|
|
instruction.family = RdnaInstructionFamily::SOPC;
|
|
instruction.opcodeId = opcode;
|
|
instruction.op = decodeSopcOpcode(opcode);
|
|
instruction.destination.kind = RdnaOperandKind::Scc;
|
|
SetRdnaRawWords(instruction, code, wordIndex, 1);
|
|
|
|
decodeScalarBinarySources(programCounter, code, wordIndex, instruction, scalarSource0, scalarSource1);
|
|
return instruction;
|
|
}
|
|
|
|
RdnaInstruction DecodeRdnaSopp(std::uint32_t programCounter, std::span<const std::uint32_t> code, std::uint32_t wordIndex) {
|
|
const std::uint32_t word = code[wordIndex];
|
|
const std::uint32_t opcode = (word >> 16u) & 0x7fu;
|
|
const std::uint32_t simm = word & 0xffffu;
|
|
|
|
RdnaInstruction instruction;
|
|
instruction.programCounter = programCounter;
|
|
instruction.family = RdnaInstructionFamily::SOPP;
|
|
instruction.opcodeId = opcode;
|
|
instruction.op = decodeSoppOpcode(opcode);
|
|
instruction.source0.kind = RdnaOperandKind::LiteralConstant;
|
|
instruction.source0.value = instruction.op == RdnaOpcode::STrap ? simm & 0xffu : simm;
|
|
instruction.source0.signedVal = instruction.op == RdnaOpcode::STrap
|
|
? static_cast<std::int32_t>(instruction.source0.value)
|
|
: static_cast<std::int32_t>(static_cast<std::int16_t>(simm));
|
|
instruction.sourceCount = isSoppWaitOpcode(instruction.op) ? 1u : 0u;
|
|
|
|
const std::int32_t branchOffset = static_cast<std::int32_t>(static_cast<std::int16_t>(simm)) * 4;
|
|
instruction.branchTarget = programCounter + 4u + static_cast<std::uint32_t>(branchOffset);
|
|
SetRdnaRawWords(instruction, code, wordIndex, 1);
|
|
return instruction;
|
|
}
|
|
|
|
}
|