#include "stdafx.h"
|
#include "stdafx.h"
|
#include "insn.h"
|
#include "insn.h"
|
#include "clsSystem.h"
|
|
#include "clsDisassem.h"
|
#include "clsDisassem.h"
|
|
|
extern clsSystem system1;
|
extern clsSystem system1;
|
|
|
std::string clsDisassem::SprName(int rg)
|
std::string clsDisassem::SprName(int rg)
|
{
|
{
|
char buf[100];
|
char buf[100];
|
|
|
buf[0] = '\0';
|
buf[0] = '\0';
|
if (rg < 16)
|
if (rg < 16)
|
sprintf(buf, "p%d", rg);
|
sprintf(buf, "p%d", rg);
|
else if (rg < 32)
|
else if (rg < 32)
|
sprintf(buf, "c%d", rg-16);
|
sprintf(buf, "c%d", rg-16);
|
else if (rg < 48) {
|
else if (rg < 64) {
|
switch(rg) {
|
switch(rg) {
|
case 32: sprintf(buf, "zs"); break;
|
case 32: sprintf(buf, "zs"); break;
|
case 33: sprintf(buf, "ds"); break;
|
case 33: sprintf(buf, "ds"); break;
|
case 34: sprintf(buf, "es"); break;
|
case 34: sprintf(buf, "es"); break;
|
case 35: sprintf(buf, "fs"); break;
|
case 35: sprintf(buf, "fs"); break;
|
case 36: sprintf(buf, "gs"); break;
|
case 36: sprintf(buf, "gs"); break;
|
case 37: sprintf(buf, "hs"); break;
|
case 37: sprintf(buf, "hs"); break;
|
case 38: sprintf(buf, "ss"); break;
|
case 38: sprintf(buf, "ss"); break;
|
case 39: sprintf(buf, "cs"); break;
|
case 39: sprintf(buf, "cs"); break;
|
case 40: sprintf(buf, "zs.lmt"); break;
|
case 40: sprintf(buf, "zs.lmt"); break;
|
case 41: sprintf(buf, "ds.lmt"); break;
|
case 41: sprintf(buf, "ds.lmt"); break;
|
case 42: sprintf(buf, "es.lmt"); break;
|
case 42: sprintf(buf, "es.lmt"); break;
|
case 43: sprintf(buf, "fs.lmt"); break;
|
case 43: sprintf(buf, "fs.lmt"); break;
|
case 44: sprintf(buf, "gs.lmt"); break;
|
case 44: sprintf(buf, "gs.lmt"); break;
|
case 45: sprintf(buf, "hs.lmt"); break;
|
case 45: sprintf(buf, "hs.lmt"); break;
|
case 46: sprintf(buf, "ss.lmt"); break;
|
case 46: sprintf(buf, "ss.lmt"); break;
|
case 47: sprintf(buf, "cs.lmt"); break;
|
case 47: sprintf(buf, "cs.lmt"); break;
|
|
case 50: sprintf(buf, "tick"); break;
|
|
case 51: sprintf(buf, "lc"); break;
|
|
case 52: sprintf(buf, "pregs"); break;
|
|
case 60: sprintf(buf, "bir"); break;
|
|
default: sprintf(buf, "???"); break;
|
}
|
}
|
}
|
}
|
return std::string(buf);
|
return std::string(buf);
|
}
|
}
|
|
|
std::string clsDisassem::PredCond(int cnd)
|
std::string clsDisassem::PredCond(int cnd)
|
{
|
{
|
switch(cnd) {
|
switch(cnd) {
|
case PF: return "PF ";
|
case PF: return "PF ";
|
case PT: return "PT ";
|
case PT: return "PT ";
|
case PEQ: return "PEQ ";
|
case PEQ: return "PEQ ";
|
case PNE: return "PNE ";
|
case PNE: return "PNE ";
|
case PLE: return "PLE ";
|
case PLE: return "PLE ";
|
case PGT: return "PGT ";
|
case PGT: return "PGT ";
|
case PGE: return "PGE ";
|
case PGE: return "PGE ";
|
case PLT: return "PLT ";
|
case PLT: return "PLT ";
|
case PLEU: return "PLEU";
|
case PLEU: return "PLEU";
|
case PGTU: return "PGTU";
|
case PGTU: return "PGTU";
|
case PGEU: return "PGEU";
|
case PGEU: return "PGEU";
|
case PLTU: return "PLTU";
|
case PLTU: return "PLTU";
|
default: return "????";
|
default: return "????";
|
}
|
}
|
}
|
}
|
|
|
|
int clsDisassem::DefaultSeg(int rg)
|
|
{
|
|
switch(rg) {
|
|
case 27:
|
|
case 28:
|
|
case 29:
|
|
case 30:
|
|
case 31: return 6;
|
|
default: return 1;
|
|
}
|
|
}
|
|
|
|
std::string clsDisassem::SegName(int sg)
|
|
{
|
|
switch(sg) {
|
|
case 0: return "zs";
|
|
case 1: return "ds";
|
|
case 2: return "es";
|
|
case 3: return "fs";
|
|
case 4: return "gs";
|
|
case 5: return "hs";
|
|
case 6: return "ss";
|
|
case 7: return "cs";
|
|
default: return "<err>";
|
|
}
|
|
}
|
|
|
|
std::string clsDisassem::TLBRegName(int rg)
|
|
{
|
|
switch(rg) {
|
|
case 0: return "Wired";
|
|
case 1: return "Index";
|
|
case 2: return "Random";
|
|
case 3: return "PageSize";
|
|
case 4: return "VirtPage";
|
|
case 5: return "PhysPage";
|
|
case 6: return "ASID";
|
|
case 7: return "DMA";
|
|
case 8: return "IMA";
|
|
case 9: return "PTA";
|
|
case 10: return "PTC";
|
|
default: return "???";
|
|
}
|
|
}
|
|
|
// Compute d[Rn] address info
|
// Compute d[Rn] address info
|
std::string clsDisassem::dRn(int b1, int b2, int b3, int *Ra, int *Sg, __int64 *disp)
|
std::string clsDisassem::dRn(int b1, int b2, int b3, int *Ra, int *Sg, __int64 *disp)
|
{
|
{
|
char buf[100];
|
char buf[100];
|
|
|
if (!Ra || !disp || !Sg)
|
if (!Ra || !disp || !Sg)
|
return "<error>";
|
return "<error>";
|
*Ra = b1 & 0x3f;
|
*Ra = b1 & 0x3f;
|
*Sg = (b3 >> 5) & 7;
|
*Sg = (b3 >> 5) & 7;
|
*disp = ((b2 >> 4) & 0xF) | ((b3 & 0x1f) << 4);
|
*disp = ((b2 >> 4) & 0xF) | ((b3 & 0x1f) << 4);
|
if (*disp & 0x100)
|
if (*disp & 0x100)
|
*disp |= 0xFFFFFFFFFFFFFE00LL;
|
*disp |= 0xFFFFFFFFFFFFFE00LL;
|
if (imm_prefix) {
|
if (imm_prefix) {
|
*disp &= 0xFF;
|
*disp &= 0xFF;
|
*disp |= imm;
|
*disp |= imm;
|
}
|
}
|
|
if (*Sg != DefaultSeg(*Ra))
|
|
sprintf(buf, "%s:$%I64X[r%d]", SegName(*Sg).c_str(), *disp, *Ra);
|
|
else
|
sprintf(buf, "$%I64X[r%d]", *disp, *Ra);
|
sprintf(buf, "$%I64X[r%d]", *disp, *Ra);
|
return std::string(buf);
|
return std::string(buf);
|
}
|
}
|
|
|
|
// Compute d[Rn] address info
|
|
std::string clsDisassem::ndx(int b1, int b2, int b3, int *Ra, int *Rb, int *Rt, int *Sg, int *Sc)
|
|
{
|
|
char buf[100];
|
|
|
|
if (!Ra || !Rb || !Rt || !Sg)
|
|
return "<error>";
|
|
*Ra = b1 & 0x3f;
|
|
*Rb = (b1 >> 6) | ((b2 & 0x0f) << 2);
|
|
*Rt = ((b2 & 0xF0) >> 4) | ((b3 & 3) << 4);
|
|
*Sg = (b3 >> 5) & 7;
|
|
*Sc = (b3 >> 2) & 3;
|
|
if (*Sg != DefaultSeg(*Ra))
|
|
sprintf(buf, "%s:[r%d+r%d", SegName(*Sg).c_str(), *Ra, *Rb);
|
|
else
|
|
sprintf(buf, "[r%d+r%d", *Ra, *Rb);
|
|
if (*Sc != 1)
|
|
sprintf(&buf[strlen(buf)], "*%d]", (1 << *Sc));
|
|
else
|
|
sprintf(&buf[strlen(buf)], "]");
|
|
return std::string(buf);
|
|
}
|
|
|
|
std::string clsDisassem::mem(std::string mne, int ad, int *nb)
|
|
{
|
|
int b1, b2, b3;
|
|
int Ra,Rt,Sg;
|
|
__int64 disp;
|
|
std::string str;
|
|
char buf[100];
|
|
|
|
buf[0] = '\0';
|
|
b1 = ReadByte(ad);
|
|
ad++;
|
|
b2 = ReadByte(ad);
|
|
ad++;
|
|
b3 = ReadByte(ad);
|
|
ad++;
|
|
Rt = ((b2 & 0xF) << 2) | (( b1 >> 6) & 3);
|
|
str = dRn(b1,b2,b3,&Ra,&Sg,&disp);
|
|
sprintf(&buf[strlen(buf)]," %s r%d,%s", mne.c_str(), Rt, str.c_str());
|
|
if (nb) *nb = 5;
|
|
imm_prefix = false;
|
|
return std::string(buf);
|
|
}
|
|
|
|
std::string clsDisassem::memndx(std::string mne, int ad, int *nb)
|
|
{
|
|
int b1, b2, b3;
|
|
int Ra,Rb,Rt,Sg,Sc;
|
|
__int64 disp;
|
|
std::string str;
|
|
char buf[100];
|
|
|
|
buf[0] = '\0';
|
|
b1 = ReadByte(ad);
|
|
ad++;
|
|
b2 = ReadByte(ad);
|
|
ad++;
|
|
b3 = ReadByte(ad);
|
|
ad++;
|
|
str = ndx(b1,b2,b3,&Ra,&Rb,&Rt,&Sg,&Sc);
|
|
sprintf(&buf[strlen(buf)]," %s r%d,%s", mne.c_str(), Rt, str.c_str());
|
|
if (nb) *nb = 5;
|
|
imm_prefix = false;
|
|
return std::string(buf);
|
|
}
|
|
|
std::string clsDisassem::Disassem(int ad, int *nb)
|
std::string clsDisassem::Disassem(int ad, int *nb)
|
{
|
{
|
int byt;
|
int byt;
|
int opcode, func;
|
int opcode, func;
|
int n;
|
int n;
|
__int64 val, disp;
|
__int64 val, disp;
|
int rv;
|
int rv;
|
int b1, b2, b3, b4;
|
int b1, b2, b3, b4;
|
int Ra,Rb,Rc,Rt,Sprn,Sg;
|
int Ra,Rb,Rc,Rt,Sprn,Sg,Sc,Sz;
|
int Cr,Ct;
|
int Cr,Ct,Tn;
|
int Pn;
|
int Pn;
|
char buf[100];
|
char buf[100];
|
std::string str;
|
std::string str;
|
|
|
buf[0] = '\0';
|
buf[0] = '\0';
|
byt = system1.ReadByte(ad);
|
byt = system1.ReadByte(ad);
|
ad++;
|
ad++;
|
if (byt==0x00) {
|
if (byt==0x00) {
|
if (nb) *nb = 1;
|
if (nb) *nb = 1;
|
return std::string(" BRK");
|
return std::string(" BRK");
|
}
|
}
|
if (byt==0x10) {
|
if (byt==0x10) {
|
if (nb) *nb = 1;
|
if (nb) *nb = 1;
|
return std::string(" NOP");
|
return std::string(" NOP");
|
}
|
}
|
if (byt==0x20) {
|
if (byt==0x20) {
|
val = system1.ReadByte(ad);
|
val = system1.ReadByte(ad);
|
ad++;
|
ad++;
|
if (val & 0x80LL)
|
if (val & 0x80LL)
|
val |= 0xFFFFFFFFFFFFFF00LL;
|
val |= 0xFFFFFFFFFFFFFF00LL;
|
sprintf(buf, " IMM %02LLX",val);
|
sprintf(buf, " IMM %02LLX",val);
|
if (nb) *nb = 2;
|
if (nb) *nb = 2;
|
imm = val << 8;
|
imm = val << 8;
|
imm_prefix = true;
|
imm_prefix = true;
|
return std::string(buf);
|
return std::string(buf);
|
}
|
}
|
if (byt==0x30) {
|
if (byt==0x30) {
|
val = system1.ReadByte(ad);
|
val = system1.ReadByte(ad);
|
ad++;
|
ad++;
|
val += (system1.ReadByte(ad) << 8);
|
val += (system1.ReadByte(ad) << 8);
|
ad++;
|
ad++;
|
if (val & 0x8000LL)
|
if (val & 0x8000LL)
|
val |= 0xFFFFFFFFFFFF0000LL;
|
val |= 0xFFFFFFFFFFFF0000LL;
|
sprintf(buf, " IMM %04LLX",val);
|
sprintf(buf, " IMM %04LLX",val);
|
if (nb) *nb = 3;
|
if (nb) *nb = 3;
|
imm = val << 8;
|
imm = val << 8;
|
imm_prefix = true;
|
imm_prefix = true;
|
return std::string(buf);
|
return std::string(buf);
|
}
|
}
|
if (byt==0x40) {
|
if (byt==0x40) {
|
val = system1.ReadByte(ad);
|
val = system1.ReadByte(ad);
|
ad++;
|
ad++;
|
val += (system1.ReadByte(ad) << 8);
|
val += (system1.ReadByte(ad) << 8);
|
ad++;
|
ad++;
|
val += (system1.ReadByte(ad) << 16);
|
val += (system1.ReadByte(ad) << 16);
|
ad++;
|
ad++;
|
if (val & 0x800000LL)
|
if (val & 0x800000LL)
|
val |= 0xFFFFFFFFFF000000LL;
|
val |= 0xFFFFFFFFFF000000LL;
|
sprintf(buf, " IMM %06LLX",val);
|
sprintf(buf, " IMM %06LLX",val);
|
imm = val << 8;
|
imm = val << 8;
|
if (nb) *nb = 4;
|
if (nb) *nb = 4;
|
imm_prefix = true;
|
imm_prefix = true;
|
return std::string(buf);
|
return std::string(buf);
|
}
|
}
|
if (byt==0x50) {
|
if (byt==0x50) {
|
val = system1.ReadByte(ad);
|
val = system1.ReadByte(ad);
|
ad++;
|
ad++;
|
val += (system1.ReadByte(ad) << 8);
|
val += (system1.ReadByte(ad) << 8);
|
ad++;
|
ad++;
|
val += (system1.ReadByte(ad) << 16);
|
val += (system1.ReadByte(ad) << 16);
|
ad++;
|
ad++;
|
val += (system1.ReadByte(ad) << 24);
|
val += (system1.ReadByte(ad) << 24);
|
ad++;
|
ad++;
|
if (val & 0x80000000LL)
|
if (val & 0x80000000LL)
|
val |= 0xFFFFFFFF00000000LL;
|
val |= 0xFFFFFFFF00000000LL;
|
sprintf(buf, " IMM %08LLX",val);
|
sprintf(buf, " IMM %08LLX",val);
|
if (nb) *nb = 5;
|
if (nb) *nb = 5;
|
imm = val << 8;
|
imm = val << 8;
|
imm_prefix = true;
|
imm_prefix = true;
|
return std::string(buf);
|
return std::string(buf);
|
}
|
}
|
if (byt==0x60) {
|
if (byt==0x60) {
|
val = system1.ReadByte(ad);
|
val = system1.ReadByte(ad);
|
ad++;
|
ad++;
|
val += (system1.ReadByte(ad) << 8);
|
val += (system1.ReadByte(ad) << 8);
|
ad++;
|
ad++;
|
val += (system1.ReadByte(ad) << 16);
|
val += (system1.ReadByte(ad) << 16);
|
ad++;
|
ad++;
|
val += (system1.ReadByte(ad) << 24);
|
val += (system1.ReadByte(ad) << 24);
|
ad++;
|
ad++;
|
val += (system1.ReadByte(ad) << 32);
|
val += (system1.ReadByte(ad) << 32);
|
ad++;
|
ad++;
|
if (val & 0x8000000000LL)
|
if (val & 0x8000000000LL)
|
val |= 0xFFFFFF0000000000LL;
|
val |= 0xFFFFFF0000000000LL;
|
sprintf(buf, " IMM %010LLX",val);
|
sprintf(buf, " IMM %010LLX",val);
|
if (nb) *nb = 6;
|
if (nb) *nb = 6;
|
imm = val << 8;
|
imm = val << 8;
|
imm_prefix = true;
|
imm_prefix = true;
|
return std::string(buf);
|
return std::string(buf);
|
}
|
}
|
if (byt==0x70) {
|
if (byt==0x70) {
|
val = system1.ReadByte(ad);
|
val = system1.ReadByte(ad);
|
ad++;
|
ad++;
|
val += (system1.ReadByte(ad) << 8);
|
val += (system1.ReadByte(ad) << 8);
|
ad++;
|
ad++;
|
val += (system1.ReadByte(ad) << 16);
|
val += (system1.ReadByte(ad) << 16);
|
ad++;
|
ad++;
|
val += (system1.ReadByte(ad) << 24);
|
val += (system1.ReadByte(ad) << 24);
|
ad++;
|
ad++;
|
val += (system1.ReadByte(ad) << 32);
|
val += (system1.ReadByte(ad) << 32);
|
ad++;
|
ad++;
|
val += (system1.ReadByte(ad) << 40);
|
val += (system1.ReadByte(ad) << 40);
|
ad++;
|
ad++;
|
if (val & 0x800000000000LL)
|
if (val & 0x800000000000LL)
|
val |= 0xFFFF000000000000LL;
|
val |= 0xFFFF000000000000LL;
|
sprintf(buf, " IMM %012LLX",val);
|
sprintf(buf, " IMM %012LLX",val);
|
if (nb) *nb = 7;
|
if (nb) *nb = 7;
|
imm = val << 8;
|
imm = val << 8;
|
imm_prefix = true;
|
imm_prefix = true;
|
return std::string(buf);
|
return std::string(buf);
|
}
|
}
|
if (byt==0x80) {
|
if (byt==0x80) {
|
val = system1.ReadByte(ad);
|
val = system1.ReadByte(ad);
|
ad++;
|
ad++;
|
val += (system1.ReadByte(ad) << 8);
|
val += (system1.ReadByte(ad) << 8);
|
ad++;
|
ad++;
|
val += (system1.ReadByte(ad) << 16);
|
val += (system1.ReadByte(ad) << 16);
|
ad++;
|
ad++;
|
val += (system1.ReadByte(ad) << 24);
|
val += (system1.ReadByte(ad) << 24);
|
ad++;
|
ad++;
|
val += (system1.ReadByte(ad) << 32);
|
val += (system1.ReadByte(ad) << 32);
|
ad++;
|
ad++;
|
val += (system1.ReadByte(ad) << 40);
|
val += (system1.ReadByte(ad) << 40);
|
ad++;
|
ad++;
|
val += (system1.ReadByte(ad) << 48);
|
val += (system1.ReadByte(ad) << 48);
|
ad++;
|
ad++;
|
if (val & 0x80000000000000LL)
|
if (val & 0x80000000000000LL)
|
val |= 0xFF00000000000000LL;
|
val |= 0xFF00000000000000LL;
|
sprintf(buf, " IMM %014LLX",val);
|
sprintf(buf, " IMM %014LLX",val);
|
if (nb) *nb = 8;
|
if (nb) *nb = 8;
|
imm = val << 8;
|
imm = val << 8;
|
imm_prefix = true;
|
imm_prefix = true;
|
return std::string(buf);
|
return std::string(buf);
|
}
|
}
|
if (byt != 0x01)
|
if (byt != 0x01)
|
sprintf(buf, "p%d.%s ", (byt & 0xF0) >> 4, PredCond(byt & 0xF).c_str());
|
sprintf(buf, "p%d.%s ", (byt & 0xF0) >> 4, PredCond(byt & 0xF).c_str());
|
opcode = system1.ReadByte(ad);
|
opcode = system1.ReadByte(ad);
|
ad++;
|
ad++;
|
if ((opcode & 0xF0)==0x00) {
|
if ((opcode & 0xF0)==0x00) {
|
b1 = system1.ReadByte(ad);
|
b1 = system1.ReadByte(ad);
|
ad++;
|
ad++;
|
Ra = b1 & 0x3f;
|
Ra = b1 & 0x3f;
|
Pn = opcode & 0x0f;
|
Pn = opcode & 0x0f;
|
sprintf(&buf[strlen(buf)], "TST p%d,r%d", Pn, Ra);
|
sprintf(&buf[strlen(buf)], "TST p%d,r%d", Pn, Ra);
|
if (nb) *nb = 3;
|
if (nb) *nb = 3;
|
imm_prefix = false;
|
imm_prefix = false;
|
return std::string(buf);
|
return std::string(buf);
|
}
|
}
|
|
if ((opcode & 0xF0)==0x10) {
|
|
b1 = system1.ReadByte(ad);
|
|
ad++;
|
|
b2 = system1.ReadByte(ad);
|
|
ad++;
|
|
Ra = b1 & 0x3f;
|
|
Rb = ((b2 << 2) | (b1 >> 6)) & 0x3f;
|
|
Pn = opcode & 0x0f;
|
|
switch(b2 >> 4) {
|
|
case 0: sprintf(&buf[strlen(buf)], " CMP p%d,r%d,r%d", Pn, Ra, Rb); break;
|
|
case 1: sprintf(&buf[strlen(buf)], " FCMP.S p%d,r%d,r%d", Pn, Ra, Rb); break;
|
|
case 2: sprintf(&buf[strlen(buf)], " FCMP.D p%d,r%d,r%d", Pn, Ra, Rb); break;
|
|
}
|
|
if (nb) *nb = 4;
|
|
imm_prefix = false;
|
|
return std::string(buf);
|
|
}
|
if ((opcode & 0xF0)==0x20) {
|
if ((opcode & 0xF0)==0x20) {
|
b1 = system1.ReadByte(ad);
|
b1 = system1.ReadByte(ad);
|
ad++;
|
ad++;
|
b2 = system1.ReadByte(ad);
|
b2 = system1.ReadByte(ad);
|
ad++;
|
ad++;
|
Ra = b1 & 0x3f;
|
Ra = b1 & 0x3f;
|
Pn = opcode & 0x0f;
|
Pn = opcode & 0x0f;
|
val = (b2 << 2) | (b1 >> 6);
|
val = (b2 << 2) | (b1 >> 6);
|
if (imm_prefix)
|
if (imm_prefix)
|
val = imm | (val & 0xFF);
|
val = imm | (val & 0xFF);
|
else {
|
else {
|
if (val & 0x200)
|
if (val & 0x200)
|
val |= 0xFFFFFFFFFFFFFE00LL;
|
val |= 0xFFFFFFFFFFFFFE00LL;
|
}
|
}
|
sprintf(&buf[strlen(buf)], " CMPI p%d,r%d,#$%LLX", Pn, Ra, val);
|
sprintf(&buf[strlen(buf)], " CMPI p%d,r%d,#$%LLX", Pn, Ra, val);
|
if (nb) *nb = 4;
|
if (nb) *nb = 4;
|
imm_prefix = false;
|
imm_prefix = false;
|
return std::string(buf);
|
return std::string(buf);
|
}
|
}
|
if ((opcode & 0xF0)==0x30) {
|
if ((opcode & 0xF0)==0x30) {
|
b1 = system1.ReadByte(ad);
|
b1 = system1.ReadByte(ad);
|
ad++;
|
ad++;
|
disp = (b1 << 4) | (opcode & 0xF);
|
disp = (b1 << 4) | (opcode & 0xF);
|
if (disp & 0x800)
|
if (disp & 0x800)
|
disp |= 0xFFFFFFFFFFFFF000LL;
|
disp |= 0xFFFFFFFFFFFFF000LL;
|
sprintf(&buf[strlen(buf)], " BR $%LLX", disp + cpu1.pc);
|
sprintf(&buf[strlen(buf)], " BR $%LLX", disp + ad);
|
if (nb) *nb = 3;
|
if (nb) *nb = 3;
|
imm_prefix = false;
|
imm_prefix = false;
|
return std::string(buf);
|
return std::string(buf);
|
}
|
}
|
|
|
switch(opcode) {
|
switch(opcode) {
|
|
|
|
case _2ADDUI:
|
|
b1 = system1.ReadByte(ad);
|
|
ad++;
|
|
b2 = system1.ReadByte(ad);
|
|
ad++;
|
|
b3 = system1.ReadByte(ad);
|
|
ad++;
|
|
Ra = b1 & 0x3f;
|
|
Rt = ((b2 & 0xf) << 2) | (b1 >> 6);
|
|
val = (b3 << 4) | (b2 >> 4);
|
|
sprintf(&buf[strlen(buf)], " _2ADDUI r%d,r%d,#$%I64X", Rt, Ra, val);
|
|
if (nb) *nb = 5;
|
|
imm_prefix = false;
|
|
return std::string(buf);
|
|
|
|
case _4ADDUI:
|
|
b1 = system1.ReadByte(ad);
|
|
ad++;
|
|
b2 = system1.ReadByte(ad);
|
|
ad++;
|
|
b3 = system1.ReadByte(ad);
|
|
ad++;
|
|
Ra = b1 & 0x3f;
|
|
Rt = ((b2 & 0xf) << 2) | (b1 >> 6);
|
|
val = (b3 << 4) | (b2 >> 4);
|
|
sprintf(&buf[strlen(buf)], " _4ADDUI r%d,r%d,#$%I64X", Rt, Ra, val);
|
|
if (nb) *nb = 5;
|
|
imm_prefix = false;
|
|
return std::string(buf);
|
|
|
|
case _8ADDUI:
|
|
b1 = system1.ReadByte(ad);
|
|
ad++;
|
|
b2 = system1.ReadByte(ad);
|
|
ad++;
|
|
b3 = system1.ReadByte(ad);
|
|
ad++;
|
|
Ra = b1 & 0x3f;
|
|
Rt = ((b2 & 0xf) << 2) | (b1 >> 6);
|
|
val = (b3 << 4) | (b2 >> 4);
|
|
sprintf(&buf[strlen(buf)], " _8ADDUI r%d,r%d,#$%I64X", Rt, Ra, val);
|
|
if (nb) *nb = 5;
|
|
imm_prefix = false;
|
|
return std::string(buf);
|
|
|
|
case _16ADDUI:
|
|
b1 = system1.ReadByte(ad);
|
|
ad++;
|
|
b2 = system1.ReadByte(ad);
|
|
ad++;
|
|
b3 = system1.ReadByte(ad);
|
|
ad++;
|
|
Ra = b1 & 0x3f;
|
|
Rt = ((b2 & 0xf) << 2) | (b1 >> 6);
|
|
val = (b3 << 4) | (b2 >> 4);
|
|
sprintf(&buf[strlen(buf)], " _16ADDUI r%d,r%d,#$%I64X", Rt, Ra, val);
|
|
if (nb) *nb = 5;
|
|
imm_prefix = false;
|
|
return std::string(buf);
|
|
|
case ADDUI:
|
case ADDUI:
|
b1 = system1.ReadByte(ad);
|
b1 = system1.ReadByte(ad);
|
ad++;
|
ad++;
|
b2 = system1.ReadByte(ad);
|
b2 = system1.ReadByte(ad);
|
ad++;
|
ad++;
|
b3 = system1.ReadByte(ad);
|
b3 = system1.ReadByte(ad);
|
ad++;
|
ad++;
|
Ra = b1 & 0x3f;
|
Ra = b1 & 0x3f;
|
Rt = ((b2 & 0xf) << 2) | (b1 >> 6);
|
Rt = ((b2 & 0xf) << 2) | (b1 >> 6);
|
val = (b3 << 4) | (b2 >> 4);
|
val = (b3 << 4) | (b2 >> 4);
|
sprintf(&buf[strlen(buf)], " ADDUI r%d,r%d,#$%08LLX", Rt, Ra, val);
|
sprintf(&buf[strlen(buf)], " ADDUI r%d,r%d,#$%I64X", Rt, Ra, val);
|
if (nb) *nb = 5;
|
if (nb) *nb = 5;
|
imm_prefix = false;
|
imm_prefix = false;
|
return std::string(buf);
|
return std::string(buf);
|
|
|
case ADDUIS:
|
case ADDUIS:
|
b1 = system1.ReadByte(ad);
|
b1 = system1.ReadByte(ad);
|
ad++;
|
ad++;
|
b2 = system1.ReadByte(ad);
|
b2 = system1.ReadByte(ad);
|
ad++;
|
ad++;
|
Ra = b1 & 0x3f;
|
Ra = b1 & 0x3f;
|
Rt = Ra;
|
Rt = Ra;
|
val = (b2 << 2) | (b1 >> 6);
|
val = (b2 << 2) | (b1 >> 6);
|
sprintf(&buf[strlen(buf)], " ADDUI r%d,r%d,#$%08LLX", Rt, Ra, val);
|
sprintf(&buf[strlen(buf)], " ADDUI r%d,r%d,#$%I64X", Rt, Ra, val);
|
if (nb) *nb = 4;
|
if (nb) *nb = 4;
|
imm_prefix = false;
|
imm_prefix = false;
|
return std::string(buf);
|
return std::string(buf);
|
|
|
|
case ANDI:
|
|
b1 = system1.ReadByte(ad);
|
|
ad++;
|
|
b2 = system1.ReadByte(ad);
|
|
ad++;
|
|
b3 = system1.ReadByte(ad);
|
|
ad++;
|
|
Ra = b1 & 0x3f;
|
|
Rt = ((b2 & 0xf) << 2) | (b1 >> 6);
|
|
val = (b3 << 4) | (b2 >> 4);
|
|
sprintf(&buf[strlen(buf)], " ANDI r%d,r%d,#$%I64X", Rt, Ra, val);
|
|
if (nb) *nb = 5;
|
|
imm_prefix = false;
|
|
return std::string(buf);
|
|
|
|
case BITI:
|
|
b1 = system1.ReadByte(ad);
|
|
ad++;
|
|
b2 = system1.ReadByte(ad);
|
|
ad++;
|
|
b3 = system1.ReadByte(ad);
|
|
ad++;
|
|
Ra = b1 & 0x3f;
|
|
Pn = ((b2 & 0x3) << 2) | (b1 >> 6);
|
|
val = (b3 << 4) | (b2 >> 4);
|
|
sprintf(&buf[strlen(buf)], " BITI p%d,r%d,#$%I64X", Pn, Ra, val);
|
|
if (nb) *nb = 5;
|
|
imm_prefix = false;
|
|
return std::string(buf);
|
|
|
|
case CLI:
|
|
sprintf(&buf[strlen(buf)], " CLI");
|
|
if (nb) *nb = 2;
|
|
imm_prefix = false;
|
|
return std::string(buf);
|
|
|
|
case DIVI:
|
|
b1 = system1.ReadByte(ad);
|
|
ad++;
|
|
b2 = system1.ReadByte(ad);
|
|
ad++;
|
|
b3 = system1.ReadByte(ad);
|
|
ad++;
|
|
Ra = b1 & 0x3f;
|
|
Rt = ((b2 & 0xf) << 2) | (b1 >> 6);
|
|
val = (b3 << 4) | (b2 >> 4);
|
|
sprintf(&buf[strlen(buf)], " DIVI r%d,r%d,#$%I64X", Rt, Ra, val);
|
|
if (nb) *nb = 5;
|
|
imm_prefix = false;
|
|
return std::string(buf);
|
|
|
|
case DIVUI:
|
|
b1 = system1.ReadByte(ad);
|
|
ad++;
|
|
b2 = system1.ReadByte(ad);
|
|
ad++;
|
|
b3 = system1.ReadByte(ad);
|
|
ad++;
|
|
Ra = b1 & 0x3f;
|
|
Rt = ((b2 & 0xf) << 2) | (b1 >> 6);
|
|
val = (b3 << 4) | (b2 >> 4);
|
|
sprintf(&buf[strlen(buf)], " DIVUI r%d,r%d,#$%I64X", Rt, Ra, val);
|
|
if (nb) *nb = 5;
|
|
imm_prefix = false;
|
|
return std::string(buf);
|
|
|
|
case EORI:
|
|
b1 = system1.ReadByte(ad);
|
|
ad++;
|
|
b2 = system1.ReadByte(ad);
|
|
ad++;
|
|
b3 = system1.ReadByte(ad);
|
|
ad++;
|
|
Ra = b1 & 0x3f;
|
|
Rt = ((b2 & 0xf) << 2) | (b1 >> 6);
|
|
val = (b3 << 4) | (b2 >> 4);
|
|
sprintf(&buf[strlen(buf)], " EORI r%d,r%d,#$%I64X", Rt, Ra, val);
|
|
if (nb) *nb = 5;
|
|
imm_prefix = false;
|
|
return std::string(buf);
|
|
|
case JSR:
|
case JSR:
|
b1 = system1.ReadByte(ad);
|
b1 = system1.ReadByte(ad);
|
ad++;
|
ad++;
|
b2 = system1.ReadByte(ad);
|
b2 = system1.ReadByte(ad);
|
ad++;
|
ad++;
|
b3 = system1.ReadByte(ad);
|
b3 = system1.ReadByte(ad);
|
ad++;
|
ad++;
|
b4 = system1.ReadByte(ad);
|
b4 = system1.ReadByte(ad);
|
ad++;
|
ad++;
|
Cr = b1 >> 4;
|
Cr = b1 >> 4;
|
Ct = b1 & 0xF;
|
Ct = b1 & 0xF;
|
if (imm_prefix)
|
if (imm_prefix)
|
disp = imm | b2;
|
disp = imm | b2;
|
else {
|
else {
|
disp = (b4 << 16) | (b3 << 8) | b2;
|
disp = (b4 << 16) | (b3 << 8) | b2;
|
if (disp & 0x800000LL)
|
if (disp & 0x800000LL)
|
disp |= 0xFFFFFFFFFF000000LL;
|
disp |= 0xFFFFFFFFFF000000LL;
|
}
|
}
|
if (nb) *nb = 6;
|
if (nb) *nb = 6;
|
imm_prefix = false;
|
imm_prefix = false;
|
sprintf(&buf[strlen(buf)], " JSR c%d,$%LLX[c%d]", Ct, disp, Cr);
|
sprintf(&buf[strlen(buf)], " JSR c%d,$%I64X[c%d]", Ct, disp, Cr);
|
|
if (Cr==15)
|
|
sprintf(&buf[strlen(buf)], " ($%I64X)", ad-6 + disp);
|
|
return std::string(buf);
|
|
|
|
case JSRI:
|
|
b1 = system1.ReadByte(ad);
|
|
ad++;
|
|
b2 = system1.ReadByte(ad);
|
|
ad++;
|
|
b3 = system1.ReadByte(ad);
|
|
ad++;
|
|
Ra = b1 & 0x3f;
|
|
Ct = (b1 >> 6) | (b2 << 2) & 0xc0;
|
|
Sz = (b2 >> 2) & 3;
|
|
Sg = b3 >> 5;
|
|
disp = ((b3 & 0x1f) << 4) | (b2 >> 4);
|
|
if (disp & 0x800LL)
|
|
disp |= 0xFFFFFFFFFFFFFE00LL;
|
|
if (imm_prefix) {
|
|
disp &= 0xFFLL;
|
|
disp = imm | disp;
|
|
}
|
|
if (nb) *nb = 5;
|
|
imm_prefix = false;
|
|
switch(Sz) {
|
|
case 1: sprintf(&buf[strlen(buf)], " JCI c%d,%s:$%I64X[r%d]", Ct, SegName(Sg).c_str(), disp, Ra); break;
|
|
case 2: sprintf(&buf[strlen(buf)], " JHI c%d,%s:$%I64X[r%d]", Ct, SegName(Sg).c_str(), disp, Ra); break;
|
|
case 3: sprintf(&buf[strlen(buf)], " JWI c%d,%s:$%I64X[r%d]", Ct, SegName(Sg).c_str(), disp, Ra); break;
|
|
}
|
return std::string(buf);
|
return std::string(buf);
|
|
|
case JSRS:
|
case JSRS:
|
b1 = system1.ReadByte(ad);
|
b1 = system1.ReadByte(ad);
|
ad++;
|
ad++;
|
b2 = system1.ReadByte(ad);
|
b2 = system1.ReadByte(ad);
|
ad++;
|
ad++;
|
b3 = system1.ReadByte(ad);
|
b3 = system1.ReadByte(ad);
|
ad++;
|
ad++;
|
Cr = b1 >> 4;
|
Cr = b1 >> 4;
|
Ct = b1 & 0xF;
|
Ct = b1 & 0xF;
|
if (imm_prefix)
|
if (imm_prefix)
|
disp = imm | b2;
|
disp = imm | b2;
|
else {
|
else {
|
disp = (b3 << 8) | b2;
|
disp = (b3 << 8) | b2;
|
if (disp & 0x8000LL)
|
if (disp & 0x8000LL)
|
disp |= 0xFFFFFFFFFFFF0000LL;
|
disp |= 0xFFFFFFFFFFFF0000LL;
|
}
|
}
|
if (nb) *nb = 5;
|
if (nb) *nb = 5;
|
imm_prefix = false;
|
imm_prefix = false;
|
sprintf(&buf[strlen(buf)], " JSR c%d,$%LLX", Ct, disp);
|
sprintf(&buf[strlen(buf)], " JSR c%d,$%LLX", Ct, disp);
|
if (Cr==15)
|
if (Cr==15)
|
sprintf(&buf[strlen(buf)], "[c%d] ($%LLX)", Cr, cpu1.pc + disp);
|
sprintf(&buf[strlen(buf)], "[c%d] ($%LLX)", Cr, ad-5 + disp);
|
else
|
else
|
sprintf(&buf[strlen(buf)], "[c%d]", Cr);
|
sprintf(&buf[strlen(buf)], "[c%d]", Cr);
|
return std::string(buf);
|
return std::string(buf);
|
|
|
|
case JSRR:
|
|
b1 = system1.ReadByte(ad);
|
|
ad++;
|
|
Cr = b1 >> 4;
|
|
Ct = b1 & 0xF;
|
|
if (nb) *nb = 3;
|
|
imm_prefix = false;
|
|
sprintf(&buf[strlen(buf)], " JSR c%d,[c%d]", Ct, Cr);
|
|
return std::string(buf);
|
|
|
case LDI:
|
case LDI:
|
b1 = system1.ReadByte(ad);
|
b1 = system1.ReadByte(ad);
|
ad++;
|
ad++;
|
b2 = system1.ReadByte(ad);
|
b2 = system1.ReadByte(ad);
|
ad++;
|
ad++;
|
Rt = b1 & 0x3f;
|
Rt = b1 & 0x3f;
|
val = (b2 << 2) | (b1 >> 6);
|
val = (b2 << 2) | (b1 >> 6);
|
if (imm_prefix)
|
if (imm_prefix)
|
val = imm | (val & 0xFF);
|
val = imm | (val & 0xFF);
|
else {
|
else {
|
if (val & 0x200)
|
if (val & 0x200)
|
val |= 0xFFFFFFFFFFFFFE00LL;
|
val |= 0xFFFFFFFFFFFFFE00LL;
|
}
|
}
|
sprintf(&buf[strlen(buf)], " LDI r%d,#$%08LLX", Rt, val);
|
sprintf(&buf[strlen(buf)], " LDI r%d,#$%08LLX", Rt, val);
|
if (nb) *nb = 4;
|
if (nb) *nb = 4;
|
imm_prefix = false;
|
imm_prefix = false;
|
return std::string(buf);
|
return std::string(buf);
|
|
|
case LDIS:
|
case LDIS:
|
b1 = system1.ReadByte(ad);
|
b1 = system1.ReadByte(ad);
|
ad++;
|
ad++;
|
b2 = system1.ReadByte(ad);
|
b2 = system1.ReadByte(ad);
|
ad++;
|
ad++;
|
Sprn = b1 & 0x3f;
|
Sprn = b1 & 0x3f;
|
val = (b2 << 2) | (b1 >> 6);
|
val = (b2 << 2) | (b1 >> 6);
|
if (imm_prefix)
|
if (imm_prefix)
|
val = imm | (val & 0xFF);
|
val = imm | (val & 0xFF);
|
else {
|
else {
|
if (val & 0x200)
|
if (val & 0x200)
|
val |= 0xFFFFFFFFFFFFFE00LL;
|
val |= 0xFFFFFFFFFFFFFE00LL;
|
}
|
}
|
sprintf(&buf[strlen(buf)], " LDIS %s,#$%08LLX", SprName(Sprn).c_str(), val);
|
sprintf(&buf[strlen(buf)], " LDIS %s,#$%08LLX", SprName(Sprn).c_str(), val);
|
if (nb) *nb = 4;
|
if (nb) *nb = 4;
|
imm_prefix = false;
|
imm_prefix = false;
|
return std::string(buf);
|
return std::string(buf);
|
|
|
case LH:
|
case LB: return mem("LB", ad, nb);
|
b1 = ReadByte(ad);
|
case LBX: return memndx("LBX", ad, nb);
|
ad++;
|
case LBUX: return memndx("LBUX", ad, nb);
|
b2 = ReadByte(ad);
|
case LVB: return mem("LVB", ad, nb);
|
ad++;
|
case LBU: return mem("LBU", ad, nb);
|
b3 = ReadByte(ad);
|
case LC: return mem("LC", ad, nb);
|
ad++;
|
case LCX: return memndx("LCX", ad, nb);
|
Rt = ((b2 & 0xF) << 2) | (( b1 >> 6) & 3);
|
case LCUX: return memndx("LCUX", ad, nb);
|
str = dRn(b1,b2,b3,&Ra,&Sg,&disp);
|
case LVC: return mem("LVC", ad, nb);
|
sprintf(&buf[strlen(buf)]," LH r%d,%s", Rt, str.c_str());
|
case LCU: return mem("LCU", ad, nb);
|
if (nb) *nb = 5;
|
case LH: return mem("LH", ad, nb);
|
imm_prefix = false;
|
case LHX: return memndx("LHX", ad, nb);
|
return std::string(buf);
|
case LHUX: return memndx("LHUX", ad, nb);
|
|
case LVH: return mem("LVH", ad, nb);
|
|
case LHU: return mem("LHU", ad, nb);
|
|
case LW: return mem("LW", ad, nb);
|
|
case LWX: return memndx("LWX", ad, nb);
|
|
case LVW: return mem("LVW", ad, nb);
|
|
case LVWAR: return mem("LVWAR", ad, nb);
|
|
|
case LLA:
|
case LLA:
|
b1 = ReadByte(ad);
|
b1 = ReadByte(ad);
|
ad++;
|
ad++;
|
b2 = ReadByte(ad);
|
b2 = ReadByte(ad);
|
ad++;
|
ad++;
|
b3 = ReadByte(ad);
|
b3 = ReadByte(ad);
|
ad++;
|
ad++;
|
Rt = ((b2 & 0xF) << 2) | (( b1 >> 6) & 3);
|
Rt = ((b2 & 0xF) << 2) | (( b1 >> 6) & 3);
|
str = dRn(b1,b2,b3,&Ra,&Sg,&disp);
|
str = dRn(b1,b2,b3,&Ra,&Sg,&disp);
|
sprintf(&buf[strlen(buf)]," LLA r%d,%s", Rt, str.c_str());
|
sprintf(&buf[strlen(buf)]," LLA r%d,%s", Rt, str.c_str());
|
if (nb) *nb = 5;
|
if (nb) *nb = 5;
|
imm_prefix = false;
|
imm_prefix = false;
|
return std::string(buf);
|
return std::string(buf);
|
|
|
case LOGIC:
|
case LOGIC:
|
b1 = system1.ReadByte(ad);
|
b1 = system1.ReadByte(ad);
|
ad++;
|
ad++;
|
b2 = system1.ReadByte(ad);
|
b2 = system1.ReadByte(ad);
|
ad++;
|
ad++;
|
b3 = system1.ReadByte(ad);
|
b3 = system1.ReadByte(ad);
|
ad++;
|
ad++;
|
Ra = b1 & 0x3f;
|
Ra = b1 & 0x3f;
|
Rb = ((b2 & 0x0f) << 2) | (b1 >> 6);
|
Rb = ((b2 & 0x0f) << 2) | (b1 >> 6);
|
Rt = ((b3 & 3) << 4) | (b2 >> 4);
|
Rt = ((b3 & 3) << 4) | (b2 >> 4);
|
func = b3 >> 2;
|
func = b3 >> 2;
|
switch(func) {
|
switch(func) {
|
case OR:
|
case AND: sprintf(&buf[strlen(buf)], " AND r%d,r%d,r%d", Rt, Ra, Rb); break;
|
sprintf(&buf[strlen(buf)], " OR r%d,r%d,r%d", Rt, Ra, Rb);
|
case OR: sprintf(&buf[strlen(buf)], " OR r%d,r%d,r%d", Rt, Ra, Rb); break;
|
break;
|
case EOR: sprintf(&buf[strlen(buf)], " EOR r%d,r%d,r%d", Rt, Ra, Rb); break;
|
|
case NAND: sprintf(&buf[strlen(buf)], " NAND r%d,r%d,r%d", Rt, Ra, Rb); break;
|
|
case NOR: sprintf(&buf[strlen(buf)], " NOR r%d,r%d,r%d", Rt, Ra, Rb); break;
|
|
case ENOR: sprintf(&buf[strlen(buf)], " ENOR r%d,r%d,r%d", Rt, Ra, Rb); break;
|
}
|
}
|
if (nb) *nb = 5;
|
if (nb) *nb = 5;
|
imm_prefix = false;
|
imm_prefix = false;
|
return std::string(buf);
|
return std::string(buf);
|
|
|
case LOOP:
|
case LOOP:
|
disp = system1.ReadByte(ad);
|
disp = system1.ReadByte(ad);
|
ad++;
|
ad++;
|
if (disp & 0x80LL)
|
if (disp & 0x80LL)
|
disp |= 0xFFFFFFFFFFFFFF00LL;
|
disp |= 0xFFFFFFFFFFFFFF00LL;
|
sprintf(&buf[strlen(buf)], " LOOP $%LLX", disp + ad);
|
sprintf(&buf[strlen(buf)], " LOOP $%LLX", disp + ad);
|
if (nb) *nb = 3;
|
if (nb) *nb = 3;
|
imm_prefix = false;
|
imm_prefix = false;
|
return std::string(buf);
|
return std::string(buf);
|
|
|
|
case LWS:
|
|
b1 = ReadByte(ad);
|
|
ad++;
|
|
b2 = ReadByte(ad);
|
|
ad++;
|
|
b3 = ReadByte(ad);
|
|
ad++;
|
|
Rb = ((b2 & 0xF) << 2) | (( b1 >> 6) & 3);
|
|
str = dRn(b1,b2,b3,&Ra,&Sg,&disp);
|
|
sprintf(&buf[strlen(buf)]," LWS %s,%s", SprName(Rb).c_str(), str.c_str());
|
|
if (nb) *nb = 5;
|
|
imm_prefix = false;
|
|
return std::string(buf);
|
|
|
|
case MEMSB:
|
|
sprintf(&buf[strlen(buf)], " MEMSB");
|
|
if (nb) *nb = 2;
|
|
imm_prefix = false;
|
|
return std::string(buf);
|
|
|
|
case MEMDB:
|
|
sprintf(&buf[strlen(buf)], " MEMDB");
|
|
if (nb) *nb = 2;
|
|
imm_prefix = false;
|
|
return std::string(buf);
|
|
|
case MFSPR:
|
case MFSPR:
|
b1 = system1.ReadByte(ad);
|
b1 = system1.ReadByte(ad);
|
ad++;
|
ad++;
|
b2 = system1.ReadByte(ad);
|
b2 = system1.ReadByte(ad);
|
ad++;
|
ad++;
|
Sprn = b1 & 0x3f;
|
Sprn = b1 & 0x3f;
|
Rt = ((b2 & 0x0f) << 2) | (b1 >> 6);
|
Rt = ((b2 & 0x0f) << 2) | (b1 >> 6);
|
sprintf(&buf[strlen(buf)], " MFSPR r%d,%s", Rt, SprName(Sprn).c_str());
|
sprintf(&buf[strlen(buf)], " MFSPR r%d,%s", Rt, SprName(Sprn).c_str());
|
if (nb) *nb = 4;
|
if (nb) *nb = 4;
|
imm_prefix = false;
|
imm_prefix = false;
|
return std::string(buf);
|
return std::string(buf);
|
|
|
case MOV:
|
case MODI:
|
|
b1 = system1.ReadByte(ad);
|
|
ad++;
|
|
b2 = system1.ReadByte(ad);
|
|
ad++;
|
|
b3 = system1.ReadByte(ad);
|
|
ad++;
|
|
Ra = b1 & 0x3f;
|
|
Rt = ((b2 & 0xf) << 2) | (b1 >> 6);
|
|
val = (b3 << 4) | (b2 >> 4);
|
|
sprintf(&buf[strlen(buf)], " MODI r%d,r%d,#$%I64X", Rt, Ra, val);
|
|
if (nb) *nb = 5;
|
|
imm_prefix = false;
|
|
return std::string(buf);
|
|
|
|
case MODUI:
|
|
b1 = system1.ReadByte(ad);
|
|
ad++;
|
|
b2 = system1.ReadByte(ad);
|
|
ad++;
|
|
b3 = system1.ReadByte(ad);
|
|
ad++;
|
|
Ra = b1 & 0x3f;
|
|
Rt = ((b2 & 0xf) << 2) | (b1 >> 6);
|
|
val = (b3 << 4) | (b2 >> 4);
|
|
sprintf(&buf[strlen(buf)], " MODUI r%d,r%d,#$%I64X", Rt, Ra, val);
|
|
if (nb) *nb = 5;
|
|
imm_prefix = false;
|
|
return std::string(buf);
|
|
|
|
case GRPA7:
|
b1 = ReadByte(ad);
|
b1 = ReadByte(ad);
|
ad++;
|
ad++;
|
b2 = ReadByte(ad);
|
b2 = ReadByte(ad);
|
ad++;
|
ad++;
|
Ra = b1 & 0x3f;
|
Ra = b1 & 0x3f;
|
Rt = ((b2 & 0xF) << 2) | (b1 >> 6);
|
Rt = ((b2 & 0xF) << 2) | (b1 >> 6);
|
sprintf(&buf[strlen(buf)]," MOV r%d,r%d", Rt, Ra);
|
switch(b2>>4) {
|
|
case MOV: sprintf(&buf[strlen(buf)]," MOV r%d,r%d", Rt, Ra); break;
|
|
case SXB: sprintf(&buf[strlen(buf)]," SXB r%d,r%d", Rt, Ra); break;
|
|
case SXC: sprintf(&buf[strlen(buf)]," SXC r%d,r%d", Rt, Ra); break;
|
|
case SXH: sprintf(&buf[strlen(buf)]," SXH r%d,r%d", Rt, Ra); break;
|
|
case ZXB: sprintf(&buf[strlen(buf)]," ZXB r%d,r%d", Rt, Ra); break;
|
|
case ZXC: sprintf(&buf[strlen(buf)]," ZXC r%d,r%d", Rt, Ra); break;
|
|
case ZXH: sprintf(&buf[strlen(buf)]," ZXH r%d,r%d", Rt, Ra); break;
|
|
}
|
if (nb) *nb = 4;
|
if (nb) *nb = 4;
|
imm_prefix = false;
|
imm_prefix = false;
|
return std::string(buf);
|
return std::string(buf);
|
|
|
case MTSPR:
|
case MTSPR:
|
b1 = system1.ReadByte(ad);
|
b1 = system1.ReadByte(ad);
|
ad++;
|
ad++;
|
b2 = system1.ReadByte(ad);
|
b2 = system1.ReadByte(ad);
|
ad++;
|
ad++;
|
Ra = b1 & 0x3f;
|
Ra = b1 & 0x3f;
|
Sprn = ((b2 & 0x0f) << 2) | (b1 >> 6);
|
Sprn = ((b2 & 0x0f) << 2) | (b1 >> 6);
|
sprintf(&buf[strlen(buf)], " MTSPR %s,r%d", SprName(Sprn).c_str(), Ra);
|
sprintf(&buf[strlen(buf)], " MTSPR %s,r%d", SprName(Sprn).c_str(), Ra);
|
if (nb) *nb = 4;
|
if (nb) *nb = 4;
|
imm_prefix = false;
|
imm_prefix = false;
|
return std::string(buf);
|
return std::string(buf);
|
|
|
|
case MULI:
|
|
b1 = system1.ReadByte(ad);
|
|
ad++;
|
|
b2 = system1.ReadByte(ad);
|
|
ad++;
|
|
b3 = system1.ReadByte(ad);
|
|
ad++;
|
|
Ra = b1 & 0x3f;
|
|
Rt = ((b2 & 0xf) << 2) | (b1 >> 6);
|
|
val = (b3 << 4) | (b2 >> 4);
|
|
sprintf(&buf[strlen(buf)], " MULI r%d,r%d,#$%I64X", Rt, Ra, val);
|
|
if (nb) *nb = 5;
|
|
imm_prefix = false;
|
|
return std::string(buf);
|
|
|
|
case MULUI:
|
|
b1 = system1.ReadByte(ad);
|
|
ad++;
|
|
b2 = system1.ReadByte(ad);
|
|
ad++;
|
|
b3 = system1.ReadByte(ad);
|
|
ad++;
|
|
Ra = b1 & 0x3f;
|
|
Rt = ((b2 & 0xf) << 2) | (b1 >> 6);
|
|
val = (b3 << 4) | (b2 >> 4);
|
|
sprintf(&buf[strlen(buf)], " MULUI r%d,r%d,#$%I64X", Rt, Ra, val);
|
|
if (nb) *nb = 5;
|
|
imm_prefix = false;
|
|
return std::string(buf);
|
|
|
|
case ORI:
|
|
b1 = system1.ReadByte(ad);
|
|
ad++;
|
|
b2 = system1.ReadByte(ad);
|
|
ad++;
|
|
b3 = system1.ReadByte(ad);
|
|
ad++;
|
|
Ra = b1 & 0x3f;
|
|
Rt = ((b2 & 0xf) << 2) | (b1 >> 6);
|
|
val = (b3 << 4) | (b2 >> 4);
|
|
sprintf(&buf[strlen(buf)], " ORI r%d,r%d,#$%I64X", Rt, Ra, val);
|
|
if (nb) *nb = 5;
|
|
imm_prefix = false;
|
|
return std::string(buf);
|
|
|
case RR:
|
case RR:
|
b1 = system1.ReadByte(ad);
|
b1 = system1.ReadByte(ad);
|
ad++;
|
ad++;
|
b2 = system1.ReadByte(ad);
|
b2 = system1.ReadByte(ad);
|
ad++;
|
ad++;
|
b3 = system1.ReadByte(ad);
|
b3 = system1.ReadByte(ad);
|
ad++;
|
ad++;
|
Ra = b1 & 0x3f;
|
Ra = b1 & 0x3f;
|
Rb = ((b2 & 0x0f) << 2) | (b1 >> 6);
|
Rb = ((b2 & 0x0f) << 2) | (b1 >> 6);
|
Rt = ((b3 & 3) << 4) | (b2 >> 4);
|
Rt = ((b3 & 3) << 4) | (b2 >> 4);
|
func = b3 >> 2;
|
func = b3 >> 2;
|
switch(func) {
|
switch(func) {
|
|
case ADD:
|
|
sprintf(&buf[strlen(buf)], " ADD r%d,r%d,r%d", Rt, Ra, Rb);
|
|
break;
|
|
case ADDU:
|
|
sprintf(&buf[strlen(buf)], " ADDU r%d,r%d,r%d", Rt, Ra, Rb);
|
|
break;
|
|
case DIV:
|
|
sprintf(&buf[strlen(buf)], " DIV r%d,r%d,r%d", Rt, Ra, Rb);
|
|
break;
|
|
case DIVU:
|
|
sprintf(&buf[strlen(buf)], " DIVU r%d,r%d,r%d", Rt, Ra, Rb);
|
|
break;
|
|
case MUL:
|
|
sprintf(&buf[strlen(buf)], " MUL r%d,r%d,r%d", Rt, Ra, Rb);
|
|
break;
|
|
case MULU:
|
|
sprintf(&buf[strlen(buf)], " MULU r%d,r%d,r%d", Rt, Ra, Rb);
|
|
break;
|
case _2ADDU:
|
case _2ADDU:
|
sprintf(&buf[strlen(buf)], " _2ADDU r%d,r%d,r%d", Rt, Ra, Rb);
|
sprintf(&buf[strlen(buf)], " _2ADDU r%d,r%d,r%d", Rt, Ra, Rb);
|
break;
|
break;
|
case _4ADDU:
|
case _4ADDU:
|
sprintf(&buf[strlen(buf)], " _4ADDU r%d,r%d,r%d", Rt, Ra, Rb);
|
sprintf(&buf[strlen(buf)], " _4ADDU r%d,r%d,r%d", Rt, Ra, Rb);
|
break;
|
break;
|
case _8ADDU:
|
case _8ADDU:
|
sprintf(&buf[strlen(buf)], " _8ADDU r%d,r%d,r%d", Rt, Ra, Rb);
|
sprintf(&buf[strlen(buf)], " _8ADDU r%d,r%d,r%d", Rt, Ra, Rb);
|
break;
|
break;
|
case _16ADDU:
|
case _16ADDU:
|
sprintf(&buf[strlen(buf)], " _16ADDU r%d,r%d,r%d", Rt, Ra, Rb);
|
sprintf(&buf[strlen(buf)], " _16ADDU r%d,r%d,r%d", Rt, Ra, Rb);
|
break;
|
break;
|
|
case MOD:
|
|
sprintf(&buf[strlen(buf)], " MOD r%d,r%d,r%d", Rt, Ra, Rb);
|
|
break;
|
|
case MODU:
|
|
sprintf(&buf[strlen(buf)], " MODU r%d,r%d,r%d", Rt, Ra, Rb);
|
|
break;
|
|
case SUB:
|
|
sprintf(&buf[strlen(buf)], " SUB r%d,r%d,r%d", Rt, Ra, Rb);
|
|
break;
|
|
case SUBU:
|
|
sprintf(&buf[strlen(buf)], " SUBU r%d,r%d,r%d", Rt, Ra, Rb);
|
|
break;
|
}
|
}
|
if (nb) *nb = 5;
|
if (nb) *nb = 5;
|
imm_prefix = false;
|
imm_prefix = false;
|
return std::string(buf);
|
return std::string(buf);
|
|
|
|
case RTD:
|
|
sprintf(&buf[strlen(buf)], " RTD");
|
|
if (nb) *nb = 2;
|
|
imm_prefix = false;
|
|
return std::string(buf);
|
|
|
|
case RTE:
|
|
sprintf(&buf[strlen(buf)], " RTE");
|
|
if (nb) *nb = 2;
|
|
imm_prefix = false;
|
|
return std::string(buf);
|
|
|
|
case RTI:
|
|
sprintf(&buf[strlen(buf)], " RTI");
|
|
if (nb) *nb = 2;
|
|
imm_prefix = false;
|
|
return std::string(buf);
|
|
|
case RTS:
|
case RTS:
|
b1 = system1.ReadByte(ad);
|
b1 = system1.ReadByte(ad);
|
ad++;
|
ad++;
|
Cr = b1 >> 4;
|
Cr = b1 >> 4;
|
sprintf(&buf[strlen(buf)], " RTS $%X[c%d]", b1 & 0xF, Cr);
|
sprintf(&buf[strlen(buf)], " RTS $%X[c%d]", b1 & 0xF, Cr);
|
if (nb) *nb = 3;
|
if (nb) *nb = 3;
|
imm_prefix = false;
|
imm_prefix = false;
|
return std::string(buf);
|
return std::string(buf);
|
|
|
case RTSQ:
|
case RTSQ:
|
sprintf(&buf[strlen(buf)], " RTS");
|
sprintf(&buf[strlen(buf)], " RTS");
|
if (nb) *nb = 2;
|
if (nb) *nb = 2;
|
imm_prefix = false;
|
imm_prefix = false;
|
return std::string(buf);
|
return std::string(buf);
|
|
|
case SB:
|
case SB:
|
b1 = ReadByte(ad);
|
b1 = ReadByte(ad);
|
ad++;
|
ad++;
|
b2 = ReadByte(ad);
|
b2 = ReadByte(ad);
|
ad++;
|
ad++;
|
b3 = ReadByte(ad);
|
b3 = ReadByte(ad);
|
ad++;
|
ad++;
|
Rb = ((b2 & 0xF) << 2) | (( b1 >> 6) & 3);
|
Rb = ((b2 & 0xF) << 2) | (( b1 >> 6) & 3);
|
str = dRn(b1,b2,b3,&Ra,&Sg,&disp);
|
str = dRn(b1,b2,b3,&Ra,&Sg,&disp);
|
sprintf(&buf[strlen(buf)]," SB r%d,%s", Rb, str.c_str());
|
sprintf(&buf[strlen(buf)]," SB r%d,%s", Rb, str.c_str());
|
if (nb) *nb = 5;
|
if (nb) *nb = 5;
|
imm_prefix = false;
|
imm_prefix = false;
|
return std::string(buf);
|
return std::string(buf);
|
|
|
|
case SBX: return memndx("SBX", ad, nb);
|
|
case SCX: return memndx("SCX", ad, nb);
|
|
case SHX: return memndx("SHX", ad, nb);
|
|
case SWX: return memndx("SWX", ad, nb);
|
|
|
case SC:
|
case SC:
|
b1 = ReadByte(ad);
|
b1 = ReadByte(ad);
|
ad++;
|
ad++;
|
b2 = ReadByte(ad);
|
b2 = ReadByte(ad);
|
ad++;
|
ad++;
|
b3 = ReadByte(ad);
|
b3 = ReadByte(ad);
|
ad++;
|
ad++;
|
Rb = ((b2 & 0xF) << 2) | (( b1 >> 6) & 3);
|
Rb = ((b2 & 0xF) << 2) | (( b1 >> 6) & 3);
|
str = dRn(b1,b2,b3,&Ra,&Sg,&disp);
|
str = dRn(b1,b2,b3,&Ra,&Sg,&disp);
|
sprintf(&buf[strlen(buf)]," SC r%d,%s", Rb, str.c_str());
|
sprintf(&buf[strlen(buf)]," SC r%d,%s", Rb, str.c_str());
|
if (nb) *nb = 5;
|
if (nb) *nb = 5;
|
imm_prefix = false;
|
imm_prefix = false;
|
return std::string(buf);
|
return std::string(buf);
|
|
|
case SH:
|
case SH:
|
b1 = ReadByte(ad);
|
b1 = ReadByte(ad);
|
ad++;
|
ad++;
|
b2 = ReadByte(ad);
|
b2 = ReadByte(ad);
|
ad++;
|
ad++;
|
b3 = ReadByte(ad);
|
b3 = ReadByte(ad);
|
ad++;
|
ad++;
|
Rb = ((b2 & 0xF) << 2) | (( b1 >> 6) & 3);
|
Rb = ((b2 & 0xF) << 2) | (( b1 >> 6) & 3);
|
str = dRn(b1,b2,b3,&Ra,&Sg,&disp);
|
str = dRn(b1,b2,b3,&Ra,&Sg,&disp);
|
sprintf(&buf[strlen(buf)]," SH r%d,%s", Rb, str.c_str());
|
sprintf(&buf[strlen(buf)]," SH r%d,%s", Rb, str.c_str());
|
if (nb) *nb = 5;
|
if (nb) *nb = 5;
|
imm_prefix = false;
|
imm_prefix = false;
|
return std::string(buf);
|
return std::string(buf);
|
|
|
case SHIFT:
|
case SHIFT:
|
b1 = system1.ReadByte(ad);
|
b1 = system1.ReadByte(ad);
|
ad++;
|
ad++;
|
b2 = system1.ReadByte(ad);
|
b2 = system1.ReadByte(ad);
|
ad++;
|
ad++;
|
b3 = system1.ReadByte(ad);
|
b3 = system1.ReadByte(ad);
|
ad++;
|
ad++;
|
Ra = b1 & 0x3f;
|
Ra = b1 & 0x3f;
|
Rb = ((b2 & 0x0f) << 2) | (b1 >> 6);
|
Rb = ((b2 & 0x0f) << 2) | (b1 >> 6);
|
Rt = ((b3 & 3) << 4) | (b2 >> 4);
|
Rt = ((b3 & 3) << 4) | (b2 >> 4);
|
func = b3 >> 2;
|
func = b3 >> 2;
|
switch(func) {
|
switch(func) {
|
case SHL:
|
case SHL:
|
sprintf(&buf[strlen(buf)], " SHL r%d,r%d,r%d", Rt, Ra, Rb);
|
sprintf(&buf[strlen(buf)], " SHL r%d,r%d,r%d", Rt, Ra, Rb);
|
break;
|
break;
|
|
case SHR:
|
|
sprintf(&buf[strlen(buf)], " SHR r%d,r%d,r%d", Rt, Ra, Rb);
|
|
break;
|
|
case SHLU:
|
|
sprintf(&buf[strlen(buf)], " SHLU r%d,r%d,r%d", Rt, Ra, Rb);
|
|
break;
|
|
case SHRU:
|
|
sprintf(&buf[strlen(buf)], " SHRU r%d,r%d,r%d", Rt, Ra, Rb);
|
|
break;
|
case SHLI:
|
case SHLI:
|
sprintf(&buf[strlen(buf)], " SHLI r%d,r%d,#$%X", Rt, Ra, Rb);
|
sprintf(&buf[strlen(buf)], " SHLI r%d,r%d,#$%X", Rt, Ra, Rb);
|
break;
|
break;
|
|
case SHRI:
|
|
sprintf(&buf[strlen(buf)], " SHRI r%d,r%d,#$%X", Rt, Ra, Rb);
|
|
break;
|
|
case SHLUI:
|
|
sprintf(&buf[strlen(buf)], " SHLUI r%d,r%d,#$%X", Rt, Ra, Rb);
|
|
break;
|
|
case SHRUI:
|
|
sprintf(&buf[strlen(buf)], " SHRUI r%d,r%d,#$%X", Rt, Ra, Rb);
|
|
break;
|
|
case ROL:
|
|
sprintf(&buf[strlen(buf)], " ROL r%d,r%d,r%d", Rt, Ra, Rb);
|
|
break;
|
|
case ROR:
|
|
sprintf(&buf[strlen(buf)], " ROR r%d,r%d,r%d", Rt, Ra, Rb);
|
|
break;
|
|
case ROLI:
|
|
sprintf(&buf[strlen(buf)], " ROLI r%d,r%d,#$%X", Rt, Ra, Rb);
|
|
break;
|
|
case RORI:
|
|
sprintf(&buf[strlen(buf)], " RORI r%d,r%d,#$%X", Rt, Ra, Rb);
|
|
break;
|
}
|
}
|
if (nb) *nb = 5;
|
if (nb) *nb = 5;
|
imm_prefix = false;
|
imm_prefix = false;
|
return std::string(buf);
|
return std::string(buf);
|
|
|
case STP:
|
case STP:
|
b1 = ReadByte(ad);
|
b1 = ReadByte(ad);
|
ad++;
|
ad++;
|
b2 = ReadByte(ad);
|
b2 = ReadByte(ad);
|
ad++;
|
ad++;
|
sprintf(&buf[strlen(buf)]," STP #$%04X", (int)((b2<<8)|b1));
|
sprintf(&buf[strlen(buf)]," STP #$%04X", (int)((b2<<8)|b1));
|
if (nb) *nb = 4;
|
if (nb) *nb = 4;
|
imm_prefix = false;
|
imm_prefix = false;
|
return std::string(buf);
|
return std::string(buf);
|
|
|
|
case STSET:
|
|
b1 = ReadByte(ad);
|
|
ad++;
|
|
b2 = ReadByte(ad);
|
|
ad++;
|
|
b3 = ReadByte(ad);
|
|
ad++;
|
|
Ra = b1 & 0x3f;
|
|
Rb = ((b2 & 0xF) << 2) | (( b1 >> 6) & 3);
|
|
Sg = b3 >> 5;
|
|
switch((b3 >> 2) & 7) {
|
|
case 0: sprintf(&buf[strlen(buf)]," STSET.BI r%d,%s:[r%d]", Rb, SegName(Sg).c_str(), Ra);
|
|
case 1: sprintf(&buf[strlen(buf)]," STSET.CI r%d,%s:[r%d]", Rb, SegName(Sg).c_str(), Ra);
|
|
case 2: sprintf(&buf[strlen(buf)]," STSET.HI r%d,%s:[r%d]", Rb, SegName(Sg).c_str(), Ra);
|
|
case 3: sprintf(&buf[strlen(buf)]," STSET.WI r%d,%s:[r%d]", Rb, SegName(Sg).c_str(), Ra);
|
|
case 4: sprintf(&buf[strlen(buf)]," STSET.BD r%d,%s:[r%d]", Rb, SegName(Sg).c_str(), Ra);
|
|
case 5: sprintf(&buf[strlen(buf)]," STSET.CD r%d,%s:[r%d]", Rb, SegName(Sg).c_str(), Ra);
|
|
case 6: sprintf(&buf[strlen(buf)]," STSET.HD r%d,%s:[r%d]", Rb, SegName(Sg).c_str(), Ra);
|
|
case 7: sprintf(&buf[strlen(buf)]," STSET.WD r%d,%s:[r%d]", Rb, SegName(Sg).c_str(), Ra);
|
|
}
|
|
if (nb) *nb = 5;
|
|
imm_prefix = false;
|
|
return std::string(buf);
|
|
|
|
case SUBUI:
|
|
b1 = system1.ReadByte(ad);
|
|
ad++;
|
|
b2 = system1.ReadByte(ad);
|
|
ad++;
|
|
b3 = system1.ReadByte(ad);
|
|
ad++;
|
|
Ra = b1 & 0x3f;
|
|
Rt = ((b2 & 0xf) << 2) | (b1 >> 6);
|
|
val = (b3 << 4) | (b2 >> 4);
|
|
sprintf(&buf[strlen(buf)], " SUBUI r%d,r%d,#$%I64X", Rt, Ra, val);
|
|
if (nb) *nb = 5;
|
|
imm_prefix = false;
|
|
return std::string(buf);
|
|
|
case SW:
|
case SW:
|
b1 = ReadByte(ad);
|
b1 = ReadByte(ad);
|
ad++;
|
ad++;
|
b2 = ReadByte(ad);
|
b2 = ReadByte(ad);
|
ad++;
|
ad++;
|
b3 = ReadByte(ad);
|
b3 = ReadByte(ad);
|
ad++;
|
ad++;
|
Rb = ((b2 & 0xF) << 2) | (( b1 >> 6) & 3);
|
Rb = ((b2 & 0xF) << 2) | (( b1 >> 6) & 3);
|
str = dRn(b1,b2,b3,&Ra,&Sg,&disp);
|
str = dRn(b1,b2,b3,&Ra,&Sg,&disp);
|
sprintf(&buf[strlen(buf)]," SW r%d,%s", Rb, str.c_str());
|
sprintf(&buf[strlen(buf)]," SW r%d,%s", Rb, str.c_str());
|
if (nb) *nb = 5;
|
if (nb) *nb = 5;
|
imm_prefix = false;
|
imm_prefix = false;
|
|
return std::string(buf);
|
|
|
|
case SWCR:
|
|
b1 = ReadByte(ad);
|
|
ad++;
|
|
b2 = ReadByte(ad);
|
|
ad++;
|
|
b3 = ReadByte(ad);
|
|
ad++;
|
|
Rb = ((b2 & 0xF) << 2) | (( b1 >> 6) & 3);
|
|
str = dRn(b1,b2,b3,&Ra,&Sg,&disp);
|
|
sprintf(&buf[strlen(buf)]," SWCR r%d,%s", Rb, str.c_str());
|
|
if (nb) *nb = 5;
|
|
imm_prefix = false;
|
|
return std::string(buf);
|
|
|
|
case SWS:
|
|
b1 = ReadByte(ad);
|
|
ad++;
|
|
b2 = ReadByte(ad);
|
|
ad++;
|
|
b3 = ReadByte(ad);
|
|
ad++;
|
|
Rb = ((b2 & 0xF) << 2) | (( b1 >> 6) & 3);
|
|
str = dRn(b1,b2,b3,&Ra,&Sg,&disp);
|
|
sprintf(&buf[strlen(buf)]," SWS %s,%s", SprName(Rb).c_str(), str.c_str());
|
|
if (nb) *nb = 5;
|
|
imm_prefix = false;
|
|
return std::string(buf);
|
|
|
|
case SYNC:
|
|
sprintf(&buf[strlen(buf)], " SYNC");
|
|
if (nb) *nb = 2;
|
|
imm_prefix = false;
|
|
return std::string(buf);
|
|
|
|
case SYS:
|
|
b1 = ReadByte(ad);
|
|
ad++;
|
|
b2 = ReadByte(ad);
|
|
ad++;
|
|
Cr = b1 >> 4;
|
|
Ct = b1 & 0xF;
|
|
sprintf(&buf[strlen(buf)], " SYS c%d,c%d,#%X", Ct, Cr, b2);
|
|
if (nb) *nb = 4;
|
|
imm_prefix = false;
|
|
return std::string(buf);
|
|
|
|
case TLB:
|
|
b1 = ReadByte(ad);
|
|
ad++;
|
|
b2 = ReadByte(ad);
|
|
ad++;
|
|
Tn = b1 >> 4;
|
|
Rt = b2 & 0x3f;
|
|
Ra = Rt;
|
|
str = "TLB";
|
|
switch(b1 & 0xF) {
|
|
case 0:
|
|
str += "NOP";
|
|
sprintf(&buf[strlen(buf)]," %s", str.c_str());
|
|
break;
|
|
case 1:
|
|
str += "PB";
|
|
sprintf(&buf[strlen(buf)]," %s r%d", str.c_str(), Ra);
|
|
break;
|
|
case 2:
|
|
str += "RD";
|
|
sprintf(&buf[strlen(buf)]," %s r%d,%s", str.c_str(), Rt, TLBRegName(Tn));
|
|
break;
|
|
case 3:
|
|
str += "WR";
|
|
sprintf(&buf[strlen(buf)]," %s %s,r%d", str.c_str(), TLBRegName(Tn), Rt);
|
|
break;
|
|
case 4:
|
|
str += "WI";
|
|
sprintf(&buf[strlen(buf)]," %s %s,r%d", str.c_str(), TLBRegName(Tn), Rt);
|
|
break;
|
|
case 5:
|
|
str += "EN";
|
|
sprintf(&buf[strlen(buf)]," %s", str.c_str());
|
|
break;
|
|
case 6:
|
|
str += "DIS";
|
|
sprintf(&buf[strlen(buf)]," %s", str.c_str());
|
|
break;
|
|
default:
|
|
str += "???";
|
|
sprintf(&buf[strlen(buf)]," %s", str.c_str());
|
|
break;
|
|
}
|
|
if (nb) *nb = 4;
|
|
imm_prefix = false;
|
return std::string(buf);
|
return std::string(buf);
|
|
|
}
|
}
|
*nb = 1;
|
*nb = 1;
|
return std::string("");
|
return std::string("");
|
}
|
}
|
|
|