1 //===-- AMDGPUDisassembler.cpp - Disassembler for AMDGPU ISA --------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 //===----------------------------------------------------------------------===//
14 /// This file contains definition for AMDGPU ISA disassembler
16 //===----------------------------------------------------------------------===//
18 // ToDo: What to do with instruction suffixes (v_mov_b32 vs v_mov_b32_e32)?
20 #include "AMDGPUDisassembler.h"
22 #include "AMDGPURegisterInfo.h"
23 #include "SIDefines.h"
24 #include "Utils/AMDGPUBaseInfo.h"
25 #include "MCTargetDesc/AMDGPUMCTargetDesc.h"
27 #include "llvm/MC/MCContext.h"
28 #include "llvm/MC/MCFixedLenDisassembler.h"
29 #include "llvm/MC/MCInst.h"
30 #include "llvm/MC/MCInstrDesc.h"
31 #include "llvm/MC/MCSubtargetInfo.h"
32 #include "llvm/Support/ELF.h"
33 #include "llvm/Support/Endian.h"
34 #include "llvm/Support/Debug.h"
35 #include "llvm/Support/TargetRegistry.h"
40 #define DEBUG_TYPE "amdgpu-disassembler"
42 typedef llvm::MCDisassembler::DecodeStatus DecodeStatus;
45 inline static MCDisassembler::DecodeStatus
46 addOperand(MCInst &Inst, const MCOperand& Opnd) {
47 Inst.addOperand(Opnd);
48 return Opnd.isValid() ?
49 MCDisassembler::Success :
50 MCDisassembler::SoftFail;
53 static DecodeStatus decodeSoppBrTarget(MCInst &Inst, unsigned Imm,
54 uint64_t Addr, const void *Decoder) {
55 auto DAsm = static_cast<const AMDGPUDisassembler*>(Decoder);
57 APInt SignedOffset(18, Imm * 4, true);
58 int64_t Offset = (SignedOffset.sext(64) + 4 + Addr).getSExtValue();
60 if (DAsm->tryAddingSymbolicOperand(Inst, Offset, Addr, true, 2, 2))
61 return MCDisassembler::Success;
62 return addOperand(Inst, MCOperand::createImm(Imm));
65 #define DECODE_OPERAND(StaticDecoderName, DecoderName) \
66 static DecodeStatus StaticDecoderName(MCInst &Inst, \
69 const void *Decoder) { \
70 auto DAsm = static_cast<const AMDGPUDisassembler*>(Decoder); \
71 return addOperand(Inst, DAsm->DecoderName(Imm)); \
74 #define DECODE_OPERAND_REG(RegClass) \
75 DECODE_OPERAND(Decode##RegClass##RegisterClass, decodeOperand_##RegClass)
77 DECODE_OPERAND_REG(VGPR_32)
78 DECODE_OPERAND_REG(VS_32)
79 DECODE_OPERAND_REG(VS_64)
81 DECODE_OPERAND_REG(VReg_64)
82 DECODE_OPERAND_REG(VReg_96)
83 DECODE_OPERAND_REG(VReg_128)
85 DECODE_OPERAND_REG(SReg_32)
86 DECODE_OPERAND_REG(SReg_32_XM0_XEXEC)
87 DECODE_OPERAND_REG(SReg_64)
88 DECODE_OPERAND_REG(SReg_64_XEXEC)
89 DECODE_OPERAND_REG(SReg_128)
90 DECODE_OPERAND_REG(SReg_256)
91 DECODE_OPERAND_REG(SReg_512)
94 static DecodeStatus decodeOperand_VSrc16(MCInst &Inst,
97 const void *Decoder) {
98 auto DAsm = static_cast<const AMDGPUDisassembler*>(Decoder);
99 return addOperand(Inst, DAsm->decodeOperand_VSrc16(Imm));
102 static DecodeStatus decodeOperand_VSrcV216(MCInst &Inst,
105 const void *Decoder) {
106 auto DAsm = static_cast<const AMDGPUDisassembler*>(Decoder);
107 return addOperand(Inst, DAsm->decodeOperand_VSrcV216(Imm));
110 #define DECODE_SDWA9(DecName) \
111 DECODE_OPERAND(decodeSDWA9##DecName, decodeSDWA9##DecName)
115 DECODE_SDWA9(VopcDst)
117 #include "AMDGPUGenDisassemblerTables.inc"
119 //===----------------------------------------------------------------------===//
121 //===----------------------------------------------------------------------===//
123 template <typename T> static inline T eatBytes(ArrayRef<uint8_t>& Bytes) {
124 assert(Bytes.size() >= sizeof(T));
125 const auto Res = support::endian::read<T, support::endianness::little>(Bytes.data());
126 Bytes = Bytes.slice(sizeof(T));
130 DecodeStatus AMDGPUDisassembler::tryDecodeInst(const uint8_t* Table,
133 uint64_t Address) const {
134 assert(MI.getOpcode() == 0);
135 assert(MI.getNumOperands() == 0);
138 const auto SavedBytes = Bytes;
139 if (decodeInstruction(Table, TmpInst, Inst, Address, this, STI)) {
141 return MCDisassembler::Success;
144 return MCDisassembler::Fail;
147 DecodeStatus AMDGPUDisassembler::getInstruction(MCInst &MI, uint64_t &Size,
148 ArrayRef<uint8_t> Bytes_,
151 raw_ostream &CS) const {
154 // ToDo: AMDGPUDisassembler supports only VI ISA.
155 if (!STI.getFeatureBits()[AMDGPU::FeatureGCN3Encoding])
156 report_fatal_error("Disassembly not yet supported for subtarget");
158 const unsigned MaxInstBytesNum = (std::min)((size_t)8, Bytes_.size());
159 Bytes = Bytes_.slice(0, MaxInstBytesNum);
161 DecodeStatus Res = MCDisassembler::Fail;
163 // ToDo: better to switch encoding length using some bit predicate
164 // but it is unknown yet, so try all we can
166 // Try to decode DPP and SDWA first to solve conflict with VOP1 and VOP2
168 if (Bytes.size() >= 8) {
169 const uint64_t QW = eatBytes<uint64_t>(Bytes);
170 Res = tryDecodeInst(DecoderTableDPP64, MI, QW, Address);
173 Res = tryDecodeInst(DecoderTableSDWA64, MI, QW, Address);
176 Res = tryDecodeInst(DecoderTableSDWA964, MI, QW, Address);
180 // Reinitialize Bytes as DPP64 could have eaten too much
181 Bytes = Bytes_.slice(0, MaxInstBytesNum);
183 // Try decode 32-bit instruction
184 if (Bytes.size() < 4) break;
185 const uint32_t DW = eatBytes<uint32_t>(Bytes);
186 Res = tryDecodeInst(DecoderTableVI32, MI, DW, Address);
189 Res = tryDecodeInst(DecoderTableAMDGPU32, MI, DW, Address);
192 if (Bytes.size() < 4) break;
193 const uint64_t QW = ((uint64_t)eatBytes<uint32_t>(Bytes) << 32) | DW;
194 Res = tryDecodeInst(DecoderTableVI64, MI, QW, Address);
197 Res = tryDecodeInst(DecoderTableAMDGPU64, MI, QW, Address);
200 if (Res && (MI.getOpcode() == AMDGPU::V_MAC_F32_e64_vi ||
201 MI.getOpcode() == AMDGPU::V_MAC_F32_e64_si ||
202 MI.getOpcode() == AMDGPU::V_MAC_F16_e64_vi)) {
203 // Insert dummy unused src2_modifiers.
204 int Src2ModIdx = AMDGPU::getNamedOperandIdx(MI.getOpcode(),
205 AMDGPU::OpName::src2_modifiers);
207 std::advance(I, Src2ModIdx);
208 MI.insert(I, MCOperand::createImm(0));
211 Size = Res ? (MaxInstBytesNum - Bytes.size()) : 0;
215 const char* AMDGPUDisassembler::getRegClassName(unsigned RegClassID) const {
216 return getContext().getRegisterInfo()->
217 getRegClassName(&AMDGPUMCRegisterClasses[RegClassID]);
221 MCOperand AMDGPUDisassembler::errOperand(unsigned V,
222 const Twine& ErrMsg) const {
223 *CommentStream << "Error: " + ErrMsg;
225 // ToDo: add support for error operands to MCInst.h
226 // return MCOperand::createError(V);
231 MCOperand AMDGPUDisassembler::createRegOperand(unsigned int RegId) const {
232 return MCOperand::createReg(RegId);
236 MCOperand AMDGPUDisassembler::createRegOperand(unsigned RegClassID,
237 unsigned Val) const {
238 const auto& RegCl = AMDGPUMCRegisterClasses[RegClassID];
239 if (Val >= RegCl.getNumRegs())
240 return errOperand(Val, Twine(getRegClassName(RegClassID)) +
241 ": unknown register " + Twine(Val));
242 return createRegOperand(RegCl.getRegister(Val));
246 MCOperand AMDGPUDisassembler::createSRegOperand(unsigned SRegClassID,
247 unsigned Val) const {
248 // ToDo: SI/CI have 104 SGPRs, VI - 102
249 // Valery: here we accepting as much as we can, let assembler sort it out
251 switch (SRegClassID) {
252 case AMDGPU::SGPR_32RegClassID:
253 case AMDGPU::TTMP_32RegClassID:
255 case AMDGPU::SGPR_64RegClassID:
256 case AMDGPU::TTMP_64RegClassID:
259 case AMDGPU::SGPR_128RegClassID:
260 case AMDGPU::TTMP_128RegClassID:
261 // ToDo: unclear if s[100:104] is available on VI. Can we use VCC as SGPR in
263 case AMDGPU::SReg_256RegClassID:
264 // ToDo: unclear if s[96:104] is available on VI. Can we use VCC as SGPR in
266 case AMDGPU::SReg_512RegClassID:
269 // ToDo: unclear if s[88:104] is available on VI. Can we use VCC as SGPR in
272 llvm_unreachable("unhandled register class");
275 if (Val % (1 << shift)) {
276 *CommentStream << "Warning: " << getRegClassName(SRegClassID)
277 << ": scalar reg isn't aligned " << Val;
280 return createRegOperand(SRegClassID, Val >> shift);
283 MCOperand AMDGPUDisassembler::decodeOperand_VS_32(unsigned Val) const {
284 return decodeSrcOp(OPW32, Val);
287 MCOperand AMDGPUDisassembler::decodeOperand_VS_64(unsigned Val) const {
288 return decodeSrcOp(OPW64, Val);
291 MCOperand AMDGPUDisassembler::decodeOperand_VSrc16(unsigned Val) const {
292 return decodeSrcOp(OPW16, Val);
295 MCOperand AMDGPUDisassembler::decodeOperand_VSrcV216(unsigned Val) const {
296 return decodeSrcOp(OPWV216, Val);
299 MCOperand AMDGPUDisassembler::decodeOperand_VGPR_32(unsigned Val) const {
300 // Some instructions have operand restrictions beyond what the encoding
301 // allows. Some ordinarily VSrc_32 operands are VGPR_32, so clear the extra
305 return createRegOperand(AMDGPU::VGPR_32RegClassID, Val);
308 MCOperand AMDGPUDisassembler::decodeOperand_VReg_64(unsigned Val) const {
309 return createRegOperand(AMDGPU::VReg_64RegClassID, Val);
312 MCOperand AMDGPUDisassembler::decodeOperand_VReg_96(unsigned Val) const {
313 return createRegOperand(AMDGPU::VReg_96RegClassID, Val);
316 MCOperand AMDGPUDisassembler::decodeOperand_VReg_128(unsigned Val) const {
317 return createRegOperand(AMDGPU::VReg_128RegClassID, Val);
320 MCOperand AMDGPUDisassembler::decodeOperand_SReg_32(unsigned Val) const {
321 // table-gen generated disassembler doesn't care about operand types
322 // leaving only registry class so SSrc_32 operand turns into SReg_32
323 // and therefore we accept immediates and literals here as well
324 return decodeSrcOp(OPW32, Val);
327 MCOperand AMDGPUDisassembler::decodeOperand_SReg_32_XM0_XEXEC(
328 unsigned Val) const {
329 // SReg_32_XM0 is SReg_32 without M0 or EXEC_LO/EXEC_HI
330 return decodeOperand_SReg_32(Val);
333 MCOperand AMDGPUDisassembler::decodeOperand_SReg_64(unsigned Val) const {
334 return decodeSrcOp(OPW64, Val);
337 MCOperand AMDGPUDisassembler::decodeOperand_SReg_64_XEXEC(unsigned Val) const {
338 return decodeSrcOp(OPW64, Val);
341 MCOperand AMDGPUDisassembler::decodeOperand_SReg_128(unsigned Val) const {
342 return decodeSrcOp(OPW128, Val);
345 MCOperand AMDGPUDisassembler::decodeOperand_SReg_256(unsigned Val) const {
346 return createSRegOperand(AMDGPU::SReg_256RegClassID, Val);
349 MCOperand AMDGPUDisassembler::decodeOperand_SReg_512(unsigned Val) const {
350 return createSRegOperand(AMDGPU::SReg_512RegClassID, Val);
354 MCOperand AMDGPUDisassembler::decodeLiteralConstant() const {
355 // For now all literal constants are supposed to be unsigned integer
356 // ToDo: deal with signed/unsigned 64-bit integer constants
357 // ToDo: deal with float/double constants
359 if (Bytes.size() < 4) {
360 return errOperand(0, "cannot read literal, inst bytes left " +
361 Twine(Bytes.size()));
364 Literal = eatBytes<uint32_t>(Bytes);
366 return MCOperand::createImm(Literal);
369 MCOperand AMDGPUDisassembler::decodeIntImmed(unsigned Imm) {
370 using namespace AMDGPU::EncValues;
371 assert(Imm >= INLINE_INTEGER_C_MIN && Imm <= INLINE_INTEGER_C_MAX);
372 return MCOperand::createImm((Imm <= INLINE_INTEGER_C_POSITIVE_MAX) ?
373 (static_cast<int64_t>(Imm) - INLINE_INTEGER_C_MIN) :
374 (INLINE_INTEGER_C_POSITIVE_MAX - static_cast<int64_t>(Imm)));
375 // Cast prevents negative overflow.
378 static int64_t getInlineImmVal32(unsigned Imm) {
381 return FloatToBits(0.5f);
383 return FloatToBits(-0.5f);
385 return FloatToBits(1.0f);
387 return FloatToBits(-1.0f);
389 return FloatToBits(2.0f);
391 return FloatToBits(-2.0f);
393 return FloatToBits(4.0f);
395 return FloatToBits(-4.0f);
396 case 248: // 1 / (2 * PI)
399 llvm_unreachable("invalid fp inline imm");
403 static int64_t getInlineImmVal64(unsigned Imm) {
406 return DoubleToBits(0.5);
408 return DoubleToBits(-0.5);
410 return DoubleToBits(1.0);
412 return DoubleToBits(-1.0);
414 return DoubleToBits(2.0);
416 return DoubleToBits(-2.0);
418 return DoubleToBits(4.0);
420 return DoubleToBits(-4.0);
421 case 248: // 1 / (2 * PI)
422 return 0x3fc45f306dc9c882;
424 llvm_unreachable("invalid fp inline imm");
428 static int64_t getInlineImmVal16(unsigned Imm) {
446 case 248: // 1 / (2 * PI)
449 llvm_unreachable("invalid fp inline imm");
453 MCOperand AMDGPUDisassembler::decodeFPImmed(OpWidthTy Width, unsigned Imm) {
454 assert(Imm >= AMDGPU::EncValues::INLINE_FLOATING_C_MIN
455 && Imm <= AMDGPU::EncValues::INLINE_FLOATING_C_MAX);
457 // ToDo: case 248: 1/(2*PI) - is allowed only on VI
460 return MCOperand::createImm(getInlineImmVal32(Imm));
462 return MCOperand::createImm(getInlineImmVal64(Imm));
465 return MCOperand::createImm(getInlineImmVal16(Imm));
467 llvm_unreachable("implement me");
471 unsigned AMDGPUDisassembler::getVgprClassId(const OpWidthTy Width) const {
472 using namespace AMDGPU;
473 assert(OPW_FIRST_ <= Width && Width < OPW_LAST_);
479 return VGPR_32RegClassID;
480 case OPW64: return VReg_64RegClassID;
481 case OPW128: return VReg_128RegClassID;
485 unsigned AMDGPUDisassembler::getSgprClassId(const OpWidthTy Width) const {
486 using namespace AMDGPU;
487 assert(OPW_FIRST_ <= Width && Width < OPW_LAST_);
493 return SGPR_32RegClassID;
494 case OPW64: return SGPR_64RegClassID;
495 case OPW128: return SGPR_128RegClassID;
499 unsigned AMDGPUDisassembler::getTtmpClassId(const OpWidthTy Width) const {
500 using namespace AMDGPU;
501 assert(OPW_FIRST_ <= Width && Width < OPW_LAST_);
507 return TTMP_32RegClassID;
508 case OPW64: return TTMP_64RegClassID;
509 case OPW128: return TTMP_128RegClassID;
513 MCOperand AMDGPUDisassembler::decodeSrcOp(const OpWidthTy Width, unsigned Val) const {
514 using namespace AMDGPU::EncValues;
515 assert(Val < 512); // enum9
517 if (VGPR_MIN <= Val && Val <= VGPR_MAX) {
518 return createRegOperand(getVgprClassId(Width), Val - VGPR_MIN);
520 if (Val <= SGPR_MAX) {
521 assert(SGPR_MIN == 0); // "SGPR_MIN <= Val" is always true and causes compilation warning.
522 return createSRegOperand(getSgprClassId(Width), Val - SGPR_MIN);
524 if (TTMP_MIN <= Val && Val <= TTMP_MAX) {
525 return createSRegOperand(getTtmpClassId(Width), Val - TTMP_MIN);
528 assert(Width == OPW16 || Width == OPW32 || Width == OPW64);
530 if (INLINE_INTEGER_C_MIN <= Val && Val <= INLINE_INTEGER_C_MAX)
531 return decodeIntImmed(Val);
533 if (INLINE_FLOATING_C_MIN <= Val && Val <= INLINE_FLOATING_C_MAX)
534 return decodeFPImmed(Width, Val);
536 if (Val == LITERAL_CONST)
537 return decodeLiteralConstant();
543 return decodeSpecialReg32(Val);
545 return decodeSpecialReg64(Val);
547 llvm_unreachable("unexpected immediate type");
551 MCOperand AMDGPUDisassembler::decodeSpecialReg32(unsigned Val) const {
552 using namespace AMDGPU;
554 case 102: return createRegOperand(getMCReg(FLAT_SCR_LO, STI));
555 case 103: return createRegOperand(getMCReg(FLAT_SCR_HI, STI));
556 // ToDo: no support for xnack_mask_lo/_hi register
559 case 106: return createRegOperand(VCC_LO);
560 case 107: return createRegOperand(VCC_HI);
561 case 108: return createRegOperand(TBA_LO);
562 case 109: return createRegOperand(TBA_HI);
563 case 110: return createRegOperand(TMA_LO);
564 case 111: return createRegOperand(TMA_HI);
565 case 124: return createRegOperand(M0);
566 case 126: return createRegOperand(EXEC_LO);
567 case 127: return createRegOperand(EXEC_HI);
568 case 235: return createRegOperand(SRC_SHARED_BASE);
569 case 236: return createRegOperand(SRC_SHARED_LIMIT);
570 case 237: return createRegOperand(SRC_PRIVATE_BASE);
571 case 238: return createRegOperand(SRC_PRIVATE_LIMIT);
572 // TODO: SRC_POPS_EXITING_WAVE_ID
573 // ToDo: no support for vccz register
575 // ToDo: no support for execz register
577 case 253: return createRegOperand(SCC);
580 return errOperand(Val, "unknown operand encoding " + Twine(Val));
583 MCOperand AMDGPUDisassembler::decodeSpecialReg64(unsigned Val) const {
584 using namespace AMDGPU;
586 case 102: return createRegOperand(getMCReg(FLAT_SCR, STI));
587 case 106: return createRegOperand(VCC);
588 case 108: return createRegOperand(TBA);
589 case 110: return createRegOperand(TMA);
590 case 126: return createRegOperand(EXEC);
593 return errOperand(Val, "unknown operand encoding " + Twine(Val));
596 MCOperand AMDGPUDisassembler::decodeSDWA9Src(const OpWidthTy Width,
597 unsigned Val) const {
598 using namespace AMDGPU::SDWA;
600 if (SDWA9EncValues::SRC_VGPR_MIN <= Val &&
601 Val <= SDWA9EncValues::SRC_VGPR_MAX) {
602 return createRegOperand(getVgprClassId(Width),
603 Val - SDWA9EncValues::SRC_VGPR_MIN);
605 if (SDWA9EncValues::SRC_SGPR_MIN <= Val &&
606 Val <= SDWA9EncValues::SRC_SGPR_MAX) {
607 return createSRegOperand(getSgprClassId(Width),
608 Val - SDWA9EncValues::SRC_SGPR_MIN);
611 return decodeSpecialReg32(Val - SDWA9EncValues::SRC_SGPR_MIN);
614 MCOperand AMDGPUDisassembler::decodeSDWA9Src16(unsigned Val) const {
615 return decodeSDWA9Src(OPW16, Val);
618 MCOperand AMDGPUDisassembler::decodeSDWA9Src32(unsigned Val) const {
619 return decodeSDWA9Src(OPW32, Val);
623 MCOperand AMDGPUDisassembler::decodeSDWA9VopcDst(unsigned Val) const {
624 using namespace AMDGPU::SDWA;
626 if (Val & SDWA9EncValues::VOPC_DST_VCC_MASK) {
627 Val &= SDWA9EncValues::VOPC_DST_SGPR_MASK;
628 if (Val > AMDGPU::EncValues::SGPR_MAX) {
629 return decodeSpecialReg64(Val);
631 return createSRegOperand(getSgprClassId(OPW64), Val);
634 return createRegOperand(AMDGPU::VCC);
638 //===----------------------------------------------------------------------===//
640 //===----------------------------------------------------------------------===//
642 // Try to find symbol name for specified label
643 bool AMDGPUSymbolizer::tryAddingSymbolicOperand(MCInst &Inst,
644 raw_ostream &/*cStream*/, int64_t Value,
645 uint64_t /*Address*/, bool IsBranch,
646 uint64_t /*Offset*/, uint64_t /*InstSize*/) {
647 typedef std::tuple<uint64_t, StringRef, uint8_t> SymbolInfoTy;
648 typedef std::vector<SymbolInfoTy> SectionSymbolsTy;
654 auto *Symbols = static_cast<SectionSymbolsTy *>(DisInfo);
655 auto Result = std::find_if(Symbols->begin(), Symbols->end(),
656 [Value](const SymbolInfoTy& Val) {
657 return std::get<0>(Val) == static_cast<uint64_t>(Value)
658 && std::get<2>(Val) == ELF::STT_NOTYPE;
660 if (Result != Symbols->end()) {
661 auto *Sym = Ctx.getOrCreateSymbol(std::get<1>(*Result));
662 const auto *Add = MCSymbolRefExpr::create(Sym, Ctx);
663 Inst.addOperand(MCOperand::createExpr(Add));
669 void AMDGPUSymbolizer::tryAddingPcLoadReferenceComment(raw_ostream &cStream,
672 llvm_unreachable("unimplemented");
675 //===----------------------------------------------------------------------===//
677 //===----------------------------------------------------------------------===//
679 static MCSymbolizer *createAMDGPUSymbolizer(const Triple &/*TT*/,
680 LLVMOpInfoCallback /*GetOpInfo*/,
681 LLVMSymbolLookupCallback /*SymbolLookUp*/,
684 std::unique_ptr<MCRelocationInfo> &&RelInfo) {
685 return new AMDGPUSymbolizer(*Ctx, std::move(RelInfo), DisInfo);
688 static MCDisassembler *createAMDGPUDisassembler(const Target &T,
689 const MCSubtargetInfo &STI,
691 return new AMDGPUDisassembler(STI, Ctx);
694 extern "C" void LLVMInitializeAMDGPUDisassembler() {
695 TargetRegistry::RegisterMCDisassembler(getTheGCNTarget(),
696 createAMDGPUDisassembler);
697 TargetRegistry::RegisterMCSymbolizer(getTheGCNTarget(),
698 createAMDGPUSymbolizer);