238 lines
5.5 KiB
C++
238 lines
5.5 KiB
C++
/*
|
|
this disassembler is courtesy of mednafen
|
|
*/
|
|
|
|
#include "psx.h"
|
|
#include "types.h"
|
|
#include <string>
|
|
#include <string.h>
|
|
|
|
//TODO - add break opcode to disassembly
|
|
|
|
namespace MDFN_IEN_PSX
|
|
{
|
|
|
|
struct OpEntry
|
|
{
|
|
u32 mask;
|
|
u32 value;
|
|
const char *mnemonic;
|
|
const char *format;
|
|
};
|
|
|
|
#define MASK_OP (0x3F << 26)
|
|
#define MASK_FUNC (0x3F)
|
|
#define MASK_RS (0x1F << 21)
|
|
#define MASK_RT (0x1F << 16)
|
|
#define MASK_RD (0x1F << 11)
|
|
#define MASK_SA (0x1F << 6)
|
|
|
|
#define MK_OP(mnemonic, format, op, func, extra_mask) { MASK_OP | (op ? 0 : MASK_FUNC) | extra_mask, (op << 26) | func, mnemonic, format }
|
|
|
|
#define MK_OP_REGIMM(mnemonic, regop) { MASK_OP | MASK_RT, (0x01 << 26) | (regop << 16), mnemonic, "s, p" }
|
|
|
|
static OpEntry ops[] =
|
|
{
|
|
MK_OP("nop", "", 0, 0, MASK_RT | MASK_RD | MASK_SA),
|
|
MK_OP("sll", "d, t, a", 0, 0, 0),
|
|
MK_OP("srl", "d, t, a", 0, 2, 0),
|
|
MK_OP("sra", "d, t, a", 0, 3, 0),
|
|
|
|
MK_OP("sllv", "d, t, s", 0, 4, 0),
|
|
MK_OP("srlv", "d, t, s", 0, 6, 0),
|
|
MK_OP("srav", "d, t, s", 0, 7, 0),
|
|
|
|
MK_OP("jr", "s", 0, 8, 0),
|
|
MK_OP("jalr", "d, s", 0, 9, 0),
|
|
|
|
MK_OP("syscall", "", 0, 12, 0), // TODO
|
|
MK_OP("break", "", 0, 13, 0), // TODO
|
|
|
|
MK_OP("mfhi", "d", 0, 16, 0),
|
|
MK_OP("mthi", "s", 0, 17, 0),
|
|
MK_OP("mflo", "d", 0, 18, 0),
|
|
MK_OP("mtlo", "s", 0, 19, 0),
|
|
|
|
MK_OP("mult", "s, t", 0, 24, 0),
|
|
MK_OP("multu", "s, t", 0, 25, 0),
|
|
MK_OP("div", "s, t", 0, 26, 0),
|
|
MK_OP("divu", "s, t", 0, 27, 0),
|
|
|
|
MK_OP("add", "d, s, t", 0, 32, 0),
|
|
MK_OP("addu", "d, s, t", 0, 33, 0),
|
|
MK_OP("sub", "d, s, t", 0, 34, 0),
|
|
MK_OP("subu", "d, s, t", 0, 35, 0),
|
|
MK_OP("and", "d, s, t", 0, 36, 0),
|
|
MK_OP("or", "d, s, t", 0, 37, 0),
|
|
MK_OP("xor", "d, s, t", 0, 38, 0),
|
|
MK_OP("nor", "d, s, t", 0, 39, 0),
|
|
MK_OP("slt", "d, s, t", 0, 42, 0),
|
|
MK_OP("sltu", "d, s, t", 0, 43, 0),
|
|
|
|
MK_OP_REGIMM("bgez", 0x01),
|
|
MK_OP_REGIMM("bgezal", 0x11),
|
|
MK_OP_REGIMM("bltz", 0x00),
|
|
MK_OP_REGIMM("bltzal", 0x10),
|
|
|
|
|
|
MK_OP("j", "P", 2, 0, 0),
|
|
MK_OP("jal", "P", 3, 0, 0),
|
|
|
|
MK_OP("beq", "s, t, p", 4, 0, 0),
|
|
MK_OP("bne", "s, t, p", 5, 0, 0),
|
|
MK_OP("blez", "s, p", 6, 0, 0),
|
|
MK_OP("bgtz", "s, p", 7, 0, 0),
|
|
|
|
MK_OP("addi", "t, s, i", 8, 0, 0),
|
|
MK_OP("addiu", "t, s, i", 9, 0, 0),
|
|
MK_OP("slti", "t, s, i", 10, 0, 0),
|
|
MK_OP("sltiu", "t, s, i", 11, 0, 0),
|
|
|
|
MK_OP("andi", "t, s, z", 12, 0, 0),
|
|
|
|
MK_OP("ori", "t, s, z", 13, 0, 0),
|
|
MK_OP("xori", "t, s, z", 14, 0, 0),
|
|
MK_OP("lui", "t, z", 15, 0, 0),
|
|
|
|
// COP0 stuff here
|
|
//#define MK_OP(mnemonic, format, op, func, extra_mask) { MASK_OP | (op ? 0 : MASK_FUNC) | extra_mask, (op << 26) | func, mnemonic, format }
|
|
#define COPMF(num) ((num)<<21)
|
|
MK_OP("mfc0", "t, D", 16, 0, 0x03E00000),
|
|
MK_OP("mfc1", "t, D", 17, 0, 0x03E00000),
|
|
MK_OP("mfc2", "t, D", 18, 0, 0x03E00000),
|
|
MK_OP("mfc3", "t, D", 19, 0, 0x03E00000),
|
|
MK_OP("mtc0", "t, D", 16, COPMF(4), 0x03E00000),
|
|
MK_OP("mtc1", "t, D", 17, COPMF(4), 0x03E00000),
|
|
MK_OP("mtc2", "t, D", 18, COPMF(4), 0x03E00000),
|
|
MK_OP("mtc3", "t, D", 19, COPMF(4), 0x03E00000),
|
|
//MK_OP("rfe", "", 19, COPMF(4), 0x03E00000), //TODO
|
|
|
|
MK_OP("lb", "t, i(s)", 32, 0, 0),
|
|
MK_OP("lh", "t, i(s)", 33, 0, 0),
|
|
MK_OP("lwl", "t, i(s)", 34, 0, 0),
|
|
MK_OP("lw", "t, i(s)", 35, 0, 0),
|
|
MK_OP("lbu", "t, i(s)", 36, 0, 0),
|
|
MK_OP("lhu", "t, i(s)", 37, 0, 0),
|
|
MK_OP("lwr", "t, i(s)", 38, 0, 0),
|
|
|
|
MK_OP("sb", "t, i(s)", 40, 0, 0),
|
|
MK_OP("sh", "t, i(s)", 41, 0, 0),
|
|
MK_OP("swl", "t, i(s)", 42, 0, 0),
|
|
MK_OP("sw", "t, i(s)", 43, 0, 0),
|
|
MK_OP("swr", "t, i(s)", 46, 0, 0),
|
|
|
|
{ 0, 0, NULL, NULL }
|
|
};
|
|
|
|
std::string DisassembleMIPS(u32 PC, u32 instr)
|
|
{
|
|
std::string ret = "UNKNOWN";
|
|
unsigned int rs = (instr >> 21) & 0x1F;
|
|
unsigned int rt = (instr >> 16) & 0x1F;
|
|
unsigned int rd = (instr >> 11) & 0x1F;
|
|
unsigned int shamt = (instr >> 6) & 0x1F;
|
|
unsigned int immediate = (s32)(s16)(instr & 0xFFFF);
|
|
unsigned int immediate_ze = (instr & 0xFFFF);
|
|
unsigned int jt = instr & ((1 << 26) - 1);
|
|
|
|
static const char *gpr_names[32] =
|
|
{
|
|
"r0", "at", "v0", "v1", "a0", "a1", "a2", "a3", "t0", "t1", "t2", "t3", "t4", "t5", "t6", "t7",
|
|
"s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7", "t8", "t9", "k0", "k1", "gp", "sp", "fp", "ra"
|
|
};
|
|
|
|
OpEntry *op = ops;
|
|
|
|
while(op->mnemonic)
|
|
{
|
|
if((instr & op->mask) == op->value)
|
|
{
|
|
// a = shift amount
|
|
// s = rs
|
|
// t = rt
|
|
// d = rd
|
|
// i = immediate
|
|
// z = immediate, zero-extended
|
|
// p = PC + 4 + immediate
|
|
// P = ((PC + 4) & 0xF0000000) | (26bitval << 2)
|
|
char s_a[16];
|
|
char s_i[16];
|
|
char s_z[16];
|
|
char s_p[16];
|
|
char s_P[16];
|
|
char s_D[16];
|
|
|
|
_snprintf(s_D, sizeof(s_D), "%d", rd);
|
|
|
|
_snprintf(s_a, sizeof(s_a), "%d", shamt);
|
|
|
|
if(immediate < 0)
|
|
_snprintf(s_i, sizeof(s_i), "%d", immediate);
|
|
else
|
|
_snprintf(s_i, sizeof(s_i), "0x%04x", (u32)immediate);
|
|
|
|
_snprintf(s_z, sizeof(s_z), "0x%04x", immediate_ze);
|
|
|
|
_snprintf(s_p, sizeof(s_p), "0x%08x", PC + 4 + (immediate << 2));
|
|
|
|
_snprintf(s_P, sizeof(s_P), "0x%08x", ((PC + 4) & 0xF0000000) | (jt << 2));
|
|
|
|
ret = std::string(op->mnemonic);
|
|
ret.append(10 - ret.size(), ' ');
|
|
|
|
for(unsigned int i = 0; i < strlen(op->format); i++)
|
|
{
|
|
switch(op->format[i])
|
|
{
|
|
case 'a':
|
|
ret.append(s_a);
|
|
break;
|
|
|
|
case 'i':
|
|
ret.append(s_i);
|
|
break;
|
|
|
|
case 'z':
|
|
ret.append(s_z);
|
|
break;
|
|
|
|
case 'p':
|
|
ret.append(s_p);
|
|
break;
|
|
|
|
case 'P':
|
|
ret.append(s_P);
|
|
break;
|
|
|
|
case 's':
|
|
ret.append(gpr_names[rs]);
|
|
break;
|
|
|
|
case 't':
|
|
ret.append(gpr_names[rt]);
|
|
break;
|
|
|
|
case 'd':
|
|
ret.append(gpr_names[rd]);
|
|
break;
|
|
|
|
case 'D':
|
|
ret.append(s_D);
|
|
break;
|
|
|
|
default:
|
|
ret.append(1, op->format[i]);
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
op++;
|
|
}
|
|
|
|
return(ret);
|
|
}
|
|
|
|
}
|
|
|