mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-12-18 10:31:57 +00:00
49a6a8d8f2
There was exactly one caller using this API right, the others were relying on specific behavior of the default implementation. Since it's too hard to use it right just remove it and standardize on the default behavior. Defines away PR16132. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@182636 91177308-0d34-0410-b5e6-96231b3b80d8
719 lines
21 KiB
C++
719 lines
21 KiB
C++
//===-- MBlazeDisassembler.cpp - Disassembler for MicroBlaze -------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file is part of the MBlaze Disassembler. It contains code to translate
|
|
// the data produced by the decoder into MCInsts.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "MBlazeDisassembler.h"
|
|
#include "MBlaze.h"
|
|
#include "llvm/MC/MCDisassembler.h"
|
|
#include "llvm/MC/MCInst.h"
|
|
#include "llvm/MC/MCInstrDesc.h"
|
|
#include "llvm/Support/Debug.h"
|
|
#include "llvm/Support/MemoryObject.h"
|
|
#include "llvm/Support/TargetRegistry.h"
|
|
#include "llvm/Support/raw_ostream.h"
|
|
|
|
// #include "MBlazeGenDecoderTables.inc"
|
|
// #include "MBlazeGenRegisterNames.inc"
|
|
|
|
namespace llvm {
|
|
extern const MCInstrDesc MBlazeInsts[];
|
|
}
|
|
|
|
using namespace llvm;
|
|
|
|
const uint16_t UNSUPPORTED = -1;
|
|
|
|
static const uint16_t mblazeBinary2Opcode[] = {
|
|
MBlaze::ADD, MBlaze::RSUB, MBlaze::ADDC, MBlaze::RSUBC, //00,01,02,03
|
|
MBlaze::ADDK, MBlaze::RSUBK, MBlaze::ADDKC, MBlaze::RSUBKC, //04,05,06,07
|
|
MBlaze::ADDI, MBlaze::RSUBI, MBlaze::ADDIC, MBlaze::RSUBIC, //08,09,0A,0B
|
|
MBlaze::ADDIK, MBlaze::RSUBIK, MBlaze::ADDIKC, MBlaze::RSUBIKC, //0C,0D,0E,0F
|
|
|
|
MBlaze::MUL, MBlaze::BSRL, MBlaze::IDIV, MBlaze::GETD, //10,11,12,13
|
|
UNSUPPORTED, UNSUPPORTED, MBlaze::FADD, UNSUPPORTED, //14,15,16,17
|
|
MBlaze::MULI, MBlaze::BSRLI, UNSUPPORTED, MBlaze::GET, //18,19,1A,1B
|
|
UNSUPPORTED, UNSUPPORTED, UNSUPPORTED, UNSUPPORTED, //1C,1D,1E,1F
|
|
|
|
MBlaze::OR, MBlaze::AND, MBlaze::XOR, MBlaze::ANDN, //20,21,22,23
|
|
MBlaze::SEXT8, MBlaze::MFS, MBlaze::BR, MBlaze::BEQ, //24,25,26,27
|
|
MBlaze::ORI, MBlaze::ANDI, MBlaze::XORI, MBlaze::ANDNI, //28,29,2A,2B
|
|
MBlaze::IMM, MBlaze::RTSD, MBlaze::BRI, MBlaze::BEQI, //2C,2D,2E,2F
|
|
|
|
MBlaze::LBU, MBlaze::LHU, MBlaze::LW, UNSUPPORTED, //30,31,32,33
|
|
MBlaze::SB, MBlaze::SH, MBlaze::SW, UNSUPPORTED, //34,35,36,37
|
|
MBlaze::LBUI, MBlaze::LHUI, MBlaze::LWI, UNSUPPORTED, //38,39,3A,3B
|
|
MBlaze::SBI, MBlaze::SHI, MBlaze::SWI, UNSUPPORTED, //3C,3D,3E,3F
|
|
};
|
|
|
|
static unsigned getRD(uint32_t insn) {
|
|
if (!isMBlazeRegister((insn>>21)&0x1F))
|
|
return UNSUPPORTED;
|
|
return getMBlazeRegisterFromNumbering((insn>>21)&0x1F);
|
|
}
|
|
|
|
static unsigned getRA(uint32_t insn) {
|
|
if (!getMBlazeRegisterFromNumbering((insn>>16)&0x1F))
|
|
return UNSUPPORTED;
|
|
return getMBlazeRegisterFromNumbering((insn>>16)&0x1F);
|
|
}
|
|
|
|
static unsigned getRB(uint32_t insn) {
|
|
if (!getMBlazeRegisterFromNumbering((insn>>11)&0x1F))
|
|
return UNSUPPORTED;
|
|
return getMBlazeRegisterFromNumbering((insn>>11)&0x1F);
|
|
}
|
|
|
|
static int64_t getRS(uint32_t insn) {
|
|
if (!isSpecialMBlazeRegister(insn&0x3FFF))
|
|
return UNSUPPORTED;
|
|
return getSpecialMBlazeRegisterFromNumbering(insn&0x3FFF);
|
|
}
|
|
|
|
static int64_t getIMM(uint32_t insn) {
|
|
int16_t val = (insn & 0xFFFF);
|
|
return val;
|
|
}
|
|
|
|
static int64_t getSHT(uint32_t insn) {
|
|
int16_t val = (insn & 0x1F);
|
|
return val;
|
|
}
|
|
|
|
static unsigned getFLAGS(int32_t insn) {
|
|
return (insn & 0x7FF);
|
|
}
|
|
|
|
static int64_t getFSL(uint32_t insn) {
|
|
int16_t val = (insn & 0xF);
|
|
return val;
|
|
}
|
|
|
|
static unsigned decodeMUL(uint32_t insn) {
|
|
switch (getFLAGS(insn)) {
|
|
default: return UNSUPPORTED;
|
|
case 0: return MBlaze::MUL;
|
|
case 1: return MBlaze::MULH;
|
|
case 2: return MBlaze::MULHSU;
|
|
case 3: return MBlaze::MULHU;
|
|
}
|
|
}
|
|
|
|
static unsigned decodeSEXT(uint32_t insn) {
|
|
switch (insn&0x7FF) {
|
|
default: return UNSUPPORTED;
|
|
case 0x60: return MBlaze::SEXT8;
|
|
case 0x68: return MBlaze::WIC;
|
|
case 0x64: return MBlaze::WDC;
|
|
case 0x66: return MBlaze::WDCC;
|
|
case 0x74: return MBlaze::WDCF;
|
|
case 0x61: return MBlaze::SEXT16;
|
|
case 0x41: return MBlaze::SRL;
|
|
case 0x21: return MBlaze::SRC;
|
|
case 0x01: return MBlaze::SRA;
|
|
case 0xE0: return MBlaze::CLZ;
|
|
}
|
|
}
|
|
|
|
static unsigned decodeBEQ(uint32_t insn) {
|
|
switch ((insn>>21)&0x1F) {
|
|
default: return UNSUPPORTED;
|
|
case 0x00: return MBlaze::BEQ;
|
|
case 0x10: return MBlaze::BEQD;
|
|
case 0x05: return MBlaze::BGE;
|
|
case 0x15: return MBlaze::BGED;
|
|
case 0x04: return MBlaze::BGT;
|
|
case 0x14: return MBlaze::BGTD;
|
|
case 0x03: return MBlaze::BLE;
|
|
case 0x13: return MBlaze::BLED;
|
|
case 0x02: return MBlaze::BLT;
|
|
case 0x12: return MBlaze::BLTD;
|
|
case 0x01: return MBlaze::BNE;
|
|
case 0x11: return MBlaze::BNED;
|
|
}
|
|
}
|
|
|
|
static unsigned decodeBEQI(uint32_t insn) {
|
|
switch ((insn>>21)&0x1F) {
|
|
default: return UNSUPPORTED;
|
|
case 0x00: return MBlaze::BEQI;
|
|
case 0x10: return MBlaze::BEQID;
|
|
case 0x05: return MBlaze::BGEI;
|
|
case 0x15: return MBlaze::BGEID;
|
|
case 0x04: return MBlaze::BGTI;
|
|
case 0x14: return MBlaze::BGTID;
|
|
case 0x03: return MBlaze::BLEI;
|
|
case 0x13: return MBlaze::BLEID;
|
|
case 0x02: return MBlaze::BLTI;
|
|
case 0x12: return MBlaze::BLTID;
|
|
case 0x01: return MBlaze::BNEI;
|
|
case 0x11: return MBlaze::BNEID;
|
|
}
|
|
}
|
|
|
|
static unsigned decodeBR(uint32_t insn) {
|
|
switch ((insn>>16)&0x1F) {
|
|
default: return UNSUPPORTED;
|
|
case 0x00: return MBlaze::BR;
|
|
case 0x08: return MBlaze::BRA;
|
|
case 0x0C: return MBlaze::BRK;
|
|
case 0x10: return MBlaze::BRD;
|
|
case 0x14: return MBlaze::BRLD;
|
|
case 0x18: return MBlaze::BRAD;
|
|
case 0x1C: return MBlaze::BRALD;
|
|
}
|
|
}
|
|
|
|
static unsigned decodeBRI(uint32_t insn) {
|
|
switch (insn&0x3FFFFFF) {
|
|
default: break;
|
|
case 0x0020004: return MBlaze::IDMEMBAR;
|
|
case 0x0220004: return MBlaze::DMEMBAR;
|
|
case 0x0420004: return MBlaze::IMEMBAR;
|
|
}
|
|
|
|
switch ((insn>>16)&0x1F) {
|
|
default: return UNSUPPORTED;
|
|
case 0x00: return MBlaze::BRI;
|
|
case 0x08: return MBlaze::BRAI;
|
|
case 0x0C: return MBlaze::BRKI;
|
|
case 0x10: return MBlaze::BRID;
|
|
case 0x14: return MBlaze::BRLID;
|
|
case 0x18: return MBlaze::BRAID;
|
|
case 0x1C: return MBlaze::BRALID;
|
|
}
|
|
}
|
|
|
|
static unsigned decodeBSRL(uint32_t insn) {
|
|
switch ((insn>>9)&0x3) {
|
|
default: return UNSUPPORTED;
|
|
case 0x2: return MBlaze::BSLL;
|
|
case 0x1: return MBlaze::BSRA;
|
|
case 0x0: return MBlaze::BSRL;
|
|
}
|
|
}
|
|
|
|
static unsigned decodeBSRLI(uint32_t insn) {
|
|
switch ((insn>>9)&0x3) {
|
|
default: return UNSUPPORTED;
|
|
case 0x2: return MBlaze::BSLLI;
|
|
case 0x1: return MBlaze::BSRAI;
|
|
case 0x0: return MBlaze::BSRLI;
|
|
}
|
|
}
|
|
|
|
static unsigned decodeRSUBK(uint32_t insn) {
|
|
switch (getFLAGS(insn)) {
|
|
default: return UNSUPPORTED;
|
|
case 0x0: return MBlaze::RSUBK;
|
|
case 0x1: return MBlaze::CMP;
|
|
case 0x3: return MBlaze::CMPU;
|
|
}
|
|
}
|
|
|
|
static unsigned decodeFADD(uint32_t insn) {
|
|
switch (getFLAGS(insn)) {
|
|
default: return UNSUPPORTED;
|
|
case 0x000: return MBlaze::FADD;
|
|
case 0x080: return MBlaze::FRSUB;
|
|
case 0x100: return MBlaze::FMUL;
|
|
case 0x180: return MBlaze::FDIV;
|
|
case 0x200: return MBlaze::FCMP_UN;
|
|
case 0x210: return MBlaze::FCMP_LT;
|
|
case 0x220: return MBlaze::FCMP_EQ;
|
|
case 0x230: return MBlaze::FCMP_LE;
|
|
case 0x240: return MBlaze::FCMP_GT;
|
|
case 0x250: return MBlaze::FCMP_NE;
|
|
case 0x260: return MBlaze::FCMP_GE;
|
|
case 0x280: return MBlaze::FLT;
|
|
case 0x300: return MBlaze::FINT;
|
|
case 0x380: return MBlaze::FSQRT;
|
|
}
|
|
}
|
|
|
|
static unsigned decodeGET(uint32_t insn) {
|
|
switch ((insn>>10)&0x3F) {
|
|
default: return UNSUPPORTED;
|
|
case 0x00: return MBlaze::GET;
|
|
case 0x01: return MBlaze::EGET;
|
|
case 0x02: return MBlaze::AGET;
|
|
case 0x03: return MBlaze::EAGET;
|
|
case 0x04: return MBlaze::TGET;
|
|
case 0x05: return MBlaze::TEGET;
|
|
case 0x06: return MBlaze::TAGET;
|
|
case 0x07: return MBlaze::TEAGET;
|
|
case 0x08: return MBlaze::CGET;
|
|
case 0x09: return MBlaze::ECGET;
|
|
case 0x0A: return MBlaze::CAGET;
|
|
case 0x0B: return MBlaze::ECAGET;
|
|
case 0x0C: return MBlaze::TCGET;
|
|
case 0x0D: return MBlaze::TECGET;
|
|
case 0x0E: return MBlaze::TCAGET;
|
|
case 0x0F: return MBlaze::TECAGET;
|
|
case 0x10: return MBlaze::NGET;
|
|
case 0x11: return MBlaze::NEGET;
|
|
case 0x12: return MBlaze::NAGET;
|
|
case 0x13: return MBlaze::NEAGET;
|
|
case 0x14: return MBlaze::TNGET;
|
|
case 0x15: return MBlaze::TNEGET;
|
|
case 0x16: return MBlaze::TNAGET;
|
|
case 0x17: return MBlaze::TNEAGET;
|
|
case 0x18: return MBlaze::NCGET;
|
|
case 0x19: return MBlaze::NECGET;
|
|
case 0x1A: return MBlaze::NCAGET;
|
|
case 0x1B: return MBlaze::NECAGET;
|
|
case 0x1C: return MBlaze::TNCGET;
|
|
case 0x1D: return MBlaze::TNECGET;
|
|
case 0x1E: return MBlaze::TNCAGET;
|
|
case 0x1F: return MBlaze::TNECAGET;
|
|
case 0x20: return MBlaze::PUT;
|
|
case 0x22: return MBlaze::APUT;
|
|
case 0x24: return MBlaze::TPUT;
|
|
case 0x26: return MBlaze::TAPUT;
|
|
case 0x28: return MBlaze::CPUT;
|
|
case 0x2A: return MBlaze::CAPUT;
|
|
case 0x2C: return MBlaze::TCPUT;
|
|
case 0x2E: return MBlaze::TCAPUT;
|
|
case 0x30: return MBlaze::NPUT;
|
|
case 0x32: return MBlaze::NAPUT;
|
|
case 0x34: return MBlaze::TNPUT;
|
|
case 0x36: return MBlaze::TNAPUT;
|
|
case 0x38: return MBlaze::NCPUT;
|
|
case 0x3A: return MBlaze::NCAPUT;
|
|
case 0x3C: return MBlaze::TNCPUT;
|
|
case 0x3E: return MBlaze::TNCAPUT;
|
|
}
|
|
}
|
|
|
|
static unsigned decodeGETD(uint32_t insn) {
|
|
switch ((insn>>5)&0x3F) {
|
|
default: return UNSUPPORTED;
|
|
case 0x00: return MBlaze::GETD;
|
|
case 0x01: return MBlaze::EGETD;
|
|
case 0x02: return MBlaze::AGETD;
|
|
case 0x03: return MBlaze::EAGETD;
|
|
case 0x04: return MBlaze::TGETD;
|
|
case 0x05: return MBlaze::TEGETD;
|
|
case 0x06: return MBlaze::TAGETD;
|
|
case 0x07: return MBlaze::TEAGETD;
|
|
case 0x08: return MBlaze::CGETD;
|
|
case 0x09: return MBlaze::ECGETD;
|
|
case 0x0A: return MBlaze::CAGETD;
|
|
case 0x0B: return MBlaze::ECAGETD;
|
|
case 0x0C: return MBlaze::TCGETD;
|
|
case 0x0D: return MBlaze::TECGETD;
|
|
case 0x0E: return MBlaze::TCAGETD;
|
|
case 0x0F: return MBlaze::TECAGETD;
|
|
case 0x10: return MBlaze::NGETD;
|
|
case 0x11: return MBlaze::NEGETD;
|
|
case 0x12: return MBlaze::NAGETD;
|
|
case 0x13: return MBlaze::NEAGETD;
|
|
case 0x14: return MBlaze::TNGETD;
|
|
case 0x15: return MBlaze::TNEGETD;
|
|
case 0x16: return MBlaze::TNAGETD;
|
|
case 0x17: return MBlaze::TNEAGETD;
|
|
case 0x18: return MBlaze::NCGETD;
|
|
case 0x19: return MBlaze::NECGETD;
|
|
case 0x1A: return MBlaze::NCAGETD;
|
|
case 0x1B: return MBlaze::NECAGETD;
|
|
case 0x1C: return MBlaze::TNCGETD;
|
|
case 0x1D: return MBlaze::TNECGETD;
|
|
case 0x1E: return MBlaze::TNCAGETD;
|
|
case 0x1F: return MBlaze::TNECAGETD;
|
|
case 0x20: return MBlaze::PUTD;
|
|
case 0x22: return MBlaze::APUTD;
|
|
case 0x24: return MBlaze::TPUTD;
|
|
case 0x26: return MBlaze::TAPUTD;
|
|
case 0x28: return MBlaze::CPUTD;
|
|
case 0x2A: return MBlaze::CAPUTD;
|
|
case 0x2C: return MBlaze::TCPUTD;
|
|
case 0x2E: return MBlaze::TCAPUTD;
|
|
case 0x30: return MBlaze::NPUTD;
|
|
case 0x32: return MBlaze::NAPUTD;
|
|
case 0x34: return MBlaze::TNPUTD;
|
|
case 0x36: return MBlaze::TNAPUTD;
|
|
case 0x38: return MBlaze::NCPUTD;
|
|
case 0x3A: return MBlaze::NCAPUTD;
|
|
case 0x3C: return MBlaze::TNCPUTD;
|
|
case 0x3E: return MBlaze::TNCAPUTD;
|
|
}
|
|
}
|
|
|
|
static unsigned decodeIDIV(uint32_t insn) {
|
|
switch (insn&0x3) {
|
|
default: return UNSUPPORTED;
|
|
case 0x0: return MBlaze::IDIV;
|
|
case 0x2: return MBlaze::IDIVU;
|
|
}
|
|
}
|
|
|
|
static unsigned decodeLBU(uint32_t insn) {
|
|
switch ((insn>>9)&0x1) {
|
|
default: return UNSUPPORTED;
|
|
case 0x0: return MBlaze::LBU;
|
|
case 0x1: return MBlaze::LBUR;
|
|
}
|
|
}
|
|
|
|
static unsigned decodeLHU(uint32_t insn) {
|
|
switch ((insn>>9)&0x1) {
|
|
default: return UNSUPPORTED;
|
|
case 0x0: return MBlaze::LHU;
|
|
case 0x1: return MBlaze::LHUR;
|
|
}
|
|
}
|
|
|
|
static unsigned decodeLW(uint32_t insn) {
|
|
switch ((insn>>9)&0x3) {
|
|
default: return UNSUPPORTED;
|
|
case 0x0: return MBlaze::LW;
|
|
case 0x1: return MBlaze::LWR;
|
|
case 0x2: return MBlaze::LWX;
|
|
}
|
|
}
|
|
|
|
static unsigned decodeSB(uint32_t insn) {
|
|
switch ((insn>>9)&0x1) {
|
|
default: return UNSUPPORTED;
|
|
case 0x0: return MBlaze::SB;
|
|
case 0x1: return MBlaze::SBR;
|
|
}
|
|
}
|
|
|
|
static unsigned decodeSH(uint32_t insn) {
|
|
switch ((insn>>9)&0x1) {
|
|
default: return UNSUPPORTED;
|
|
case 0x0: return MBlaze::SH;
|
|
case 0x1: return MBlaze::SHR;
|
|
}
|
|
}
|
|
|
|
static unsigned decodeSW(uint32_t insn) {
|
|
switch ((insn>>9)&0x3) {
|
|
default: return UNSUPPORTED;
|
|
case 0x0: return MBlaze::SW;
|
|
case 0x1: return MBlaze::SWR;
|
|
case 0x2: return MBlaze::SWX;
|
|
}
|
|
}
|
|
|
|
static unsigned decodeMFS(uint32_t insn) {
|
|
switch ((insn>>15)&0x1) {
|
|
default: return UNSUPPORTED;
|
|
case 0x0:
|
|
switch ((insn>>16)&0x1) {
|
|
default: return UNSUPPORTED;
|
|
case 0x0: return MBlaze::MSRSET;
|
|
case 0x1: return MBlaze::MSRCLR;
|
|
}
|
|
case 0x1:
|
|
switch ((insn>>14)&0x1) {
|
|
default: return UNSUPPORTED;
|
|
case 0x0: return MBlaze::MFS;
|
|
case 0x1: return MBlaze::MTS;
|
|
}
|
|
}
|
|
}
|
|
|
|
static unsigned decodeOR(uint32_t insn) {
|
|
switch (getFLAGS(insn)) {
|
|
default: return UNSUPPORTED;
|
|
case 0x000: return MBlaze::OR;
|
|
case 0x400: return MBlaze::PCMPBF;
|
|
}
|
|
}
|
|
|
|
static unsigned decodeXOR(uint32_t insn) {
|
|
switch (getFLAGS(insn)) {
|
|
default: return UNSUPPORTED;
|
|
case 0x000: return MBlaze::XOR;
|
|
case 0x400: return MBlaze::PCMPEQ;
|
|
}
|
|
}
|
|
|
|
static unsigned decodeANDN(uint32_t insn) {
|
|
switch (getFLAGS(insn)) {
|
|
default: return UNSUPPORTED;
|
|
case 0x000: return MBlaze::ANDN;
|
|
case 0x400: return MBlaze::PCMPNE;
|
|
}
|
|
}
|
|
|
|
static unsigned decodeRTSD(uint32_t insn) {
|
|
switch ((insn>>21)&0x1F) {
|
|
default: return UNSUPPORTED;
|
|
case 0x10: return MBlaze::RTSD;
|
|
case 0x11: return MBlaze::RTID;
|
|
case 0x12: return MBlaze::RTBD;
|
|
case 0x14: return MBlaze::RTED;
|
|
}
|
|
}
|
|
|
|
static unsigned getOPCODE(uint32_t insn) {
|
|
unsigned opcode = mblazeBinary2Opcode[ (insn>>26)&0x3F ];
|
|
switch (opcode) {
|
|
case MBlaze::MUL: return decodeMUL(insn);
|
|
case MBlaze::SEXT8: return decodeSEXT(insn);
|
|
case MBlaze::BEQ: return decodeBEQ(insn);
|
|
case MBlaze::BEQI: return decodeBEQI(insn);
|
|
case MBlaze::BR: return decodeBR(insn);
|
|
case MBlaze::BRI: return decodeBRI(insn);
|
|
case MBlaze::BSRL: return decodeBSRL(insn);
|
|
case MBlaze::BSRLI: return decodeBSRLI(insn);
|
|
case MBlaze::RSUBK: return decodeRSUBK(insn);
|
|
case MBlaze::FADD: return decodeFADD(insn);
|
|
case MBlaze::GET: return decodeGET(insn);
|
|
case MBlaze::GETD: return decodeGETD(insn);
|
|
case MBlaze::IDIV: return decodeIDIV(insn);
|
|
case MBlaze::LBU: return decodeLBU(insn);
|
|
case MBlaze::LHU: return decodeLHU(insn);
|
|
case MBlaze::LW: return decodeLW(insn);
|
|
case MBlaze::SB: return decodeSB(insn);
|
|
case MBlaze::SH: return decodeSH(insn);
|
|
case MBlaze::SW: return decodeSW(insn);
|
|
case MBlaze::MFS: return decodeMFS(insn);
|
|
case MBlaze::OR: return decodeOR(insn);
|
|
case MBlaze::XOR: return decodeXOR(insn);
|
|
case MBlaze::ANDN: return decodeANDN(insn);
|
|
case MBlaze::RTSD: return decodeRTSD(insn);
|
|
default: return opcode;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Public interface for the disassembler
|
|
//
|
|
|
|
MCDisassembler::DecodeStatus MBlazeDisassembler::getInstruction(MCInst &instr,
|
|
uint64_t &size,
|
|
const MemoryObject ®ion,
|
|
uint64_t address,
|
|
raw_ostream &vStream,
|
|
raw_ostream &cStream) const {
|
|
// The machine instruction.
|
|
uint32_t insn;
|
|
uint8_t bytes[4];
|
|
|
|
// By default we consume 1 byte on failure
|
|
size = 1;
|
|
|
|
// We want to read exactly 4 bytes of data.
|
|
if (region.readBytes(address, 4, bytes) == -1)
|
|
return Fail;
|
|
|
|
// Encoded as a big-endian 32-bit word in the stream.
|
|
insn = (bytes[0]<<24) | (bytes[1]<<16) | (bytes[2]<< 8) | (bytes[3]<<0);
|
|
|
|
// Get the MCInst opcode from the binary instruction and make sure
|
|
// that it is a valid instruction.
|
|
unsigned opcode = getOPCODE(insn);
|
|
if (opcode == UNSUPPORTED)
|
|
return Fail;
|
|
|
|
instr.setOpcode(opcode);
|
|
|
|
unsigned RD = getRD(insn);
|
|
unsigned RA = getRA(insn);
|
|
unsigned RB = getRB(insn);
|
|
unsigned RS = getRS(insn);
|
|
|
|
uint64_t tsFlags = MBlazeInsts[opcode].TSFlags;
|
|
switch ((tsFlags & MBlazeII::FormMask)) {
|
|
default:
|
|
return Fail;
|
|
|
|
case MBlazeII::FC:
|
|
break;
|
|
|
|
case MBlazeII::FRRRR:
|
|
if (RD == UNSUPPORTED || RA == UNSUPPORTED || RB == UNSUPPORTED)
|
|
return Fail;
|
|
instr.addOperand(MCOperand::CreateReg(RD));
|
|
instr.addOperand(MCOperand::CreateReg(RB));
|
|
instr.addOperand(MCOperand::CreateReg(RA));
|
|
break;
|
|
|
|
case MBlazeII::FRRR:
|
|
if (RD == UNSUPPORTED || RA == UNSUPPORTED || RB == UNSUPPORTED)
|
|
return Fail;
|
|
instr.addOperand(MCOperand::CreateReg(RD));
|
|
instr.addOperand(MCOperand::CreateReg(RA));
|
|
instr.addOperand(MCOperand::CreateReg(RB));
|
|
break;
|
|
|
|
case MBlazeII::FRR:
|
|
if (RD == UNSUPPORTED || RA == UNSUPPORTED)
|
|
return Fail;
|
|
instr.addOperand(MCOperand::CreateReg(RD));
|
|
instr.addOperand(MCOperand::CreateReg(RA));
|
|
break;
|
|
|
|
case MBlazeII::FRI:
|
|
switch (opcode) {
|
|
default:
|
|
return Fail;
|
|
case MBlaze::MFS:
|
|
if (RD == UNSUPPORTED)
|
|
return Fail;
|
|
instr.addOperand(MCOperand::CreateReg(RD));
|
|
instr.addOperand(MCOperand::CreateImm(insn&0x3FFF));
|
|
break;
|
|
case MBlaze::MTS:
|
|
if (RA == UNSUPPORTED)
|
|
return Fail;
|
|
instr.addOperand(MCOperand::CreateImm(insn&0x3FFF));
|
|
instr.addOperand(MCOperand::CreateReg(RA));
|
|
break;
|
|
case MBlaze::MSRSET:
|
|
case MBlaze::MSRCLR:
|
|
if (RD == UNSUPPORTED)
|
|
return Fail;
|
|
instr.addOperand(MCOperand::CreateReg(RD));
|
|
instr.addOperand(MCOperand::CreateImm(insn&0x7FFF));
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case MBlazeII::FRRI:
|
|
if (RD == UNSUPPORTED || RA == UNSUPPORTED)
|
|
return Fail;
|
|
instr.addOperand(MCOperand::CreateReg(RD));
|
|
instr.addOperand(MCOperand::CreateReg(RA));
|
|
switch (opcode) {
|
|
default:
|
|
instr.addOperand(MCOperand::CreateImm(getIMM(insn)));
|
|
break;
|
|
case MBlaze::BSRLI:
|
|
case MBlaze::BSRAI:
|
|
case MBlaze::BSLLI:
|
|
instr.addOperand(MCOperand::CreateImm(insn&0x1F));
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case MBlazeII::FCRR:
|
|
if (RA == UNSUPPORTED || RB == UNSUPPORTED)
|
|
return Fail;
|
|
instr.addOperand(MCOperand::CreateReg(RA));
|
|
instr.addOperand(MCOperand::CreateReg(RB));
|
|
break;
|
|
|
|
case MBlazeII::FCRI:
|
|
if (RA == UNSUPPORTED)
|
|
return Fail;
|
|
instr.addOperand(MCOperand::CreateReg(RA));
|
|
instr.addOperand(MCOperand::CreateImm(getIMM(insn)));
|
|
break;
|
|
|
|
case MBlazeII::FRCR:
|
|
if (RD == UNSUPPORTED || RB == UNSUPPORTED)
|
|
return Fail;
|
|
instr.addOperand(MCOperand::CreateReg(RD));
|
|
instr.addOperand(MCOperand::CreateReg(RB));
|
|
break;
|
|
|
|
case MBlazeII::FRCI:
|
|
if (RD == UNSUPPORTED)
|
|
return Fail;
|
|
instr.addOperand(MCOperand::CreateReg(RD));
|
|
instr.addOperand(MCOperand::CreateImm(getIMM(insn)));
|
|
break;
|
|
|
|
case MBlazeII::FCCR:
|
|
if (RB == UNSUPPORTED)
|
|
return Fail;
|
|
instr.addOperand(MCOperand::CreateReg(RB));
|
|
break;
|
|
|
|
case MBlazeII::FCCI:
|
|
instr.addOperand(MCOperand::CreateImm(getIMM(insn)));
|
|
break;
|
|
|
|
case MBlazeII::FRRCI:
|
|
if (RD == UNSUPPORTED || RA == UNSUPPORTED)
|
|
return Fail;
|
|
instr.addOperand(MCOperand::CreateReg(RD));
|
|
instr.addOperand(MCOperand::CreateReg(RA));
|
|
instr.addOperand(MCOperand::CreateImm(getSHT(insn)));
|
|
break;
|
|
|
|
case MBlazeII::FRRC:
|
|
if (RD == UNSUPPORTED || RA == UNSUPPORTED)
|
|
return Fail;
|
|
instr.addOperand(MCOperand::CreateReg(RD));
|
|
instr.addOperand(MCOperand::CreateReg(RA));
|
|
break;
|
|
|
|
case MBlazeII::FRCX:
|
|
if (RD == UNSUPPORTED)
|
|
return Fail;
|
|
instr.addOperand(MCOperand::CreateReg(RD));
|
|
instr.addOperand(MCOperand::CreateImm(getFSL(insn)));
|
|
break;
|
|
|
|
case MBlazeII::FRCS:
|
|
if (RD == UNSUPPORTED || RS == UNSUPPORTED)
|
|
return Fail;
|
|
instr.addOperand(MCOperand::CreateReg(RD));
|
|
instr.addOperand(MCOperand::CreateReg(RS));
|
|
break;
|
|
|
|
case MBlazeII::FCRCS:
|
|
if (RS == UNSUPPORTED || RA == UNSUPPORTED)
|
|
return Fail;
|
|
instr.addOperand(MCOperand::CreateReg(RS));
|
|
instr.addOperand(MCOperand::CreateReg(RA));
|
|
break;
|
|
|
|
case MBlazeII::FCRCX:
|
|
if (RA == UNSUPPORTED)
|
|
return Fail;
|
|
instr.addOperand(MCOperand::CreateReg(RA));
|
|
instr.addOperand(MCOperand::CreateImm(getFSL(insn)));
|
|
break;
|
|
|
|
case MBlazeII::FCX:
|
|
instr.addOperand(MCOperand::CreateImm(getFSL(insn)));
|
|
break;
|
|
|
|
case MBlazeII::FCR:
|
|
if (RB == UNSUPPORTED)
|
|
return Fail;
|
|
instr.addOperand(MCOperand::CreateReg(RB));
|
|
break;
|
|
|
|
case MBlazeII::FRIR:
|
|
if (RD == UNSUPPORTED || RA == UNSUPPORTED)
|
|
return Fail;
|
|
instr.addOperand(MCOperand::CreateReg(RD));
|
|
instr.addOperand(MCOperand::CreateImm(getIMM(insn)));
|
|
instr.addOperand(MCOperand::CreateReg(RA));
|
|
break;
|
|
}
|
|
|
|
// We always consume 4 bytes of data on success
|
|
size = 4;
|
|
|
|
return Success;
|
|
}
|
|
|
|
static MCDisassembler *createMBlazeDisassembler(const Target &T,
|
|
const MCSubtargetInfo &STI) {
|
|
return new MBlazeDisassembler(STI);
|
|
}
|
|
|
|
extern "C" void LLVMInitializeMBlazeDisassembler() {
|
|
// Register the disassembler.
|
|
TargetRegistry::RegisterMCDisassembler(TheMBlazeTarget,
|
|
createMBlazeDisassembler);
|
|
}
|