ref: 649e0914486b43f31c89f8d17efc16d9df120198
dir: /src/DISAM68K.c/
/*
DISAM68K.c
Copyright (C) 2010 Paul C. Pratt
You can redistribute this file and/or modify it under the terms
of version 2 of the GNU General Public License as published by
the Free Software Foundation. You should have received a copy
of the license along with this file; see the file COPYING.
This file is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
license for more details.
*/
/*
DISAssemble Motorola 68K instructions.
*/
#ifndef AllFiles
#include "SYSDEPNS.h"
#include "ENDIANAC.h"
#include "MYOSGLUE.h"
#include "EMCONFIG.h"
#include "GLOBGLUE.h"
#include "M68KITAB.h"
#endif
#include "DISAM68K.h"
LOCALVAR ui5r Disasm_pc;
/*
don't use get_vm_byte/get_vm_word/get_vm_long
so as to be sure of no side effects
(if pc points to memory mapped device)
*/
LOCALVAR ui3p Disasm_pcp;
LOCALVAR ui5r Disasm_pc_blockmask;
LOCALVAR ui3b Disasm_pcp_dummy[2] = {
0, 0
};
IMPORTFUNC ATTep FindATTel(CPTR addr);
LOCALPROC Disasm_Find_pcp(void)
{
ATTep p;
p = FindATTel(Disasm_pc);
if (0 == (p->Access & kATTA_readreadymask)) {
Disasm_pcp = Disasm_pcp_dummy;
Disasm_pc_blockmask = 0;
} else {
Disasm_pc_blockmask = p->usemask & ~ p->cmpmask;
Disasm_pc_blockmask = Disasm_pc_blockmask
& ~ (Disasm_pc_blockmask + 1);
Disasm_pcp = p->usebase + (Disasm_pc & p->usemask);
}
}
LOCALFUNC ui4r Disasm_nextiword(void)
/* NOT sign extended */
{
ui4r r = do_get_mem_word(Disasm_pcp);
Disasm_pcp += 2;
Disasm_pc += 2;
if (0 == (Disasm_pc_blockmask & Disasm_pc)) {
Disasm_Find_pcp();
}
return r;
}
LOCALINLINEFUNC ui3r Disasm_nextibyte(void)
{
return (ui3b) Disasm_nextiword();
}
LOCALFUNC ui5r Disasm_nextilong(void)
{
ui5r hi = Disasm_nextiword();
ui5r lo = Disasm_nextiword();
ui5r r = ((hi << 16) & 0xFFFF0000)
| (lo & 0x0000FFFF);
return r;
}
LOCALPROC Disasm_setpc(CPTR newpc)
{
if (newpc != Disasm_pc) {
Disasm_pc = newpc;
Disasm_Find_pcp();
}
}
LOCALVAR ui5b Disasm_opcode;
LOCALVAR ui5b Disasm_opsize;
#define Disasm_b76 ((Disasm_opcode >> 6) & 3)
#define Disasm_b8 ((Disasm_opcode >> 8) & 1)
#define Disasm_mode ((Disasm_opcode >> 3) & 7)
#define Disasm_reg (Disasm_opcode & 7)
#define Disasm_md6 ((Disasm_opcode >> 6) & 7)
#define Disasm_rg9 ((Disasm_opcode >> 9) & 7)
LOCALPROC DisasmOpSizeFromb76(void)
{
Disasm_opsize = 1 << Disasm_b76;
switch (Disasm_opsize) {
case 1 :
dbglog_writeCStr(".B");
break;
case 2 :
dbglog_writeCStr(".W");
break;
case 4 :
dbglog_writeCStr(".L");
break;
}
}
LOCALPROC DisasmModeRegister(ui5b themode, ui5b thereg)
{
switch (themode) {
case 0 :
dbglog_writeCStr("D");
dbglog_writeHex(thereg);
break;
case 1 :
dbglog_writeCStr("A");
dbglog_writeHex(thereg);
break;
case 2 :
dbglog_writeCStr("(A");
dbglog_writeHex(thereg);
dbglog_writeCStr(")");
break;
case 3 :
dbglog_writeCStr("(A");
dbglog_writeHex(thereg);
dbglog_writeCStr(")+");
break;
case 4 :
dbglog_writeCStr("-(A");
dbglog_writeHex(thereg);
dbglog_writeCStr(")");
break;
case 5 :
dbglog_writeHex(Disasm_nextiword());
dbglog_writeCStr("(A");
dbglog_writeHex(thereg);
dbglog_writeCStr(")");
break;
case 6 :
dbglog_writeCStr("???");
#if 0
ArgKind = AKMemory;
ArgAddr.mem = get_disp_ea(m68k_areg(thereg));
#endif
break;
case 7 :
switch (thereg) {
case 0 :
dbglog_writeCStr("(");
dbglog_writeHex(Disasm_nextiword());
dbglog_writeCStr(")");
break;
case 1 :
dbglog_writeCStr("(");
dbglog_writeHex(Disasm_nextilong());
dbglog_writeCStr(")");
break;
case 2 :
{
ui5r s = Disasm_pc;
s += ui5r_FromSWord(Disasm_nextiword());
dbglog_writeCStr("(");
dbglog_writeHex(s);
dbglog_writeCStr(")");
}
break;
case 3 :
dbglog_writeCStr("???");
#if 0
ArgKind = AKMemory;
s = get_disp_ea(Disasm_pc);
#endif
break;
case 4 :
dbglog_writeCStr("#");
if (Disasm_opsize == 2) {
dbglog_writeHex(Disasm_nextiword());
} else if (Disasm_opsize < 2) {
dbglog_writeHex(Disasm_nextibyte());
} else {
dbglog_writeHex(Disasm_nextilong());
}
break;
}
break;
case 8 :
dbglog_writeCStr("#");
dbglog_writeHex(thereg);
break;
}
}
LOCALPROC DisasmStartOne(char *s)
{
dbglog_writeCStr(s);
}
LOCALPROC Disasm_xxxxxxxxssmmmrrr(char *s)
{
DisasmStartOne(s);
DisasmOpSizeFromb76();
dbglog_writeCStr(" ");
DisasmModeRegister(Disasm_mode, Disasm_reg);
dbglog_writeReturn();
}
LOCALPROC DisasmEaD_xxxxdddxssmmmrrr(char *s)
{
DisasmStartOne(s);
DisasmOpSizeFromb76();
dbglog_writeCStr(" ");
DisasmModeRegister(Disasm_mode, Disasm_reg);
dbglog_writeCStr(", ");
dbglog_writeCStr("D");
dbglog_writeHex(Disasm_rg9);
dbglog_writeReturn();
}
LOCALPROC DisasmI_xxxxxxxxssmmmrrr(char *s)
{
DisasmStartOne(s);
DisasmOpSizeFromb76();
dbglog_writeCStr(" #");
if (Disasm_opsize == 2) {
dbglog_writeHex(ui5r_FromSWord(Disasm_nextiword()));
} else if (Disasm_opsize < 2) {
dbglog_writeHex(ui5r_FromSByte(Disasm_nextibyte()));
} else {
dbglog_writeHex(ui5r_FromSLong(Disasm_nextilong()));
}
dbglog_writeCStr(", ");
DisasmModeRegister(Disasm_mode, Disasm_reg);
dbglog_writeReturn();
}
LOCALPROC DisasmsAA_xxxxdddxssxxxrrr(char *s)
{
DisasmStartOne(s);
DisasmOpSizeFromb76();
DisasmModeRegister(3, Disasm_reg);
dbglog_writeCStr(", ");
DisasmModeRegister(3, Disasm_rg9);
dbglog_writeReturn();
}
LOCALFUNC ui5r Disasm_octdat(ui5r x)
{
if (x == 0) {
return 8;
} else {
return x;
}
}
LOCALPROC Disasm_xxxxnnnxssmmmrrr(char *s)
{
DisasmStartOne(s);
DisasmOpSizeFromb76();
dbglog_writeCStr(" #");
dbglog_writeHex(Disasm_octdat(Disasm_rg9));
dbglog_writeCStr(", ");
DisasmModeRegister(Disasm_mode, Disasm_reg);
dbglog_writeReturn();
}
LOCALPROC DisasmDEa_xxxxdddxssmmmrrr(char *s)
{
DisasmStartOne(s);
DisasmOpSizeFromb76();
dbglog_writeCStr(" D");
dbglog_writeHex(Disasm_rg9);
dbglog_writeCStr(", ");
DisasmModeRegister(Disasm_mode, Disasm_reg);
dbglog_writeReturn();
}
LOCALPROC DisasmEaA_xxxxdddsxxmmmrrr(char *s)
{
DisasmStartOne(s);
Disasm_opsize = Disasm_b8 * 2 + 2;
if (Disasm_opsize == 2) {
dbglog_writeCStr(".W");
} else {
dbglog_writeCStr(".L");
}
dbglog_writeCStr(" ");
DisasmModeRegister(Disasm_mode, Disasm_reg);
dbglog_writeCStr(", A");
dbglog_writeHex(Disasm_rg9);
dbglog_writeReturn();
}
LOCALPROC DisasmDD_xxxxdddxssxxxrrr(char *s)
{
DisasmStartOne(s);
DisasmOpSizeFromb76();
dbglog_writeCStr(" ");
DisasmModeRegister(0, Disasm_reg);
dbglog_writeCStr(", ");
DisasmModeRegister(0, Disasm_rg9);
dbglog_writeReturn();
}
LOCALPROC DisasmAAs_xxxxdddxssxxxrrr(char *s)
{
DisasmStartOne(s);
DisasmOpSizeFromb76();
dbglog_writeCStr(" ");
DisasmModeRegister(4, Disasm_reg);
dbglog_writeCStr(", ");
DisasmModeRegister(4, Disasm_rg9);
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmTst(void)
{
/* Tst 01001010ssmmmrrr */
Disasm_xxxxxxxxssmmmrrr("TST");
}
LOCALPROCUSEDONCE DisasmCompare(void)
{
/* Cmp 1011ddd0ssmmmrrr */
DisasmEaD_xxxxdddxssmmmrrr("CMP");
}
LOCALPROCUSEDONCE DisasmCmpI(void)
{
/* CMPI 00001100ssmmmrrr */
DisasmI_xxxxxxxxssmmmrrr("CMP");
}
LOCALPROCUSEDONCE DisasmCmpM(void)
{
/* CmpM 1011ddd1ss001rrr */
DisasmsAA_xxxxdddxssxxxrrr("CMP");
}
LOCALPROC DisasmCC(void)
{
switch ((Disasm_opcode >> 8) & 15) {
case 0: dbglog_writeCStr("T"); break;
case 1: dbglog_writeCStr("F"); break;
case 2: dbglog_writeCStr("HI"); break;
case 3: dbglog_writeCStr("LS"); break;
case 4: dbglog_writeCStr("CC"); break;
case 5: dbglog_writeCStr("CS"); break;
case 6: dbglog_writeCStr("NE"); break;
case 7: dbglog_writeCStr("EQ"); break;
case 8: dbglog_writeCStr("VC"); break;
case 9: dbglog_writeCStr("VS"); break;
case 10: dbglog_writeCStr("P"); break;
case 11: dbglog_writeCStr("MI"); break;
case 12: dbglog_writeCStr("GE"); break;
case 13: dbglog_writeCStr("LT"); break;
case 14: dbglog_writeCStr("GT"); break;
case 15: dbglog_writeCStr("LE"); break;
default: break; /* shouldn't get here */
}
}
LOCALPROCUSEDONCE DisasmBcc(void)
{
/* Bcc 0110ccccnnnnnnnn */
ui5b src = ((ui5b)Disasm_opcode) & 255;
ui5r s = Disasm_pc;
if (0 == ((Disasm_opcode >> 8) & 15)) {
DisasmStartOne("BRA");
} else {
DisasmStartOne("B");
DisasmCC();
}
dbglog_writeCStr(" ");
if (src == 0) {
s += ui5r_FromSWord(Disasm_nextiword());
} else
#if Use68020
if (src == 255) {
s += ui5r_FromSLong(Disasm_nextilong());
/* ReportAbnormal("long branch in DoCode6"); */
/* Used by various Apps */
} else
#endif
{
s += ui5r_FromSByte(src);
}
dbglog_writeHex(s);
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmDBcc(void)
{
/* DBcc 0101cccc11001ddd */
ui5r s = Disasm_pc;
DisasmStartOne("DB");
DisasmCC();
dbglog_writeCStr(" D");
dbglog_writeHex(Disasm_reg);
dbglog_writeCStr(", ");
s += (si5b)(si4b)Disasm_nextiword();
dbglog_writeHex(s);
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmSwap(void)
{
/* Swap 0100100001000rrr */
DisasmStartOne("SWAP D");
dbglog_writeHex(Disasm_reg);
dbglog_writeReturn();
}
LOCALPROC DisasmMove(void) /* MOVE */
{
DisasmModeRegister(Disasm_mode, Disasm_reg);
dbglog_writeCStr(", ");
DisasmModeRegister(Disasm_md6, Disasm_rg9);
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmMoveL(void)
{
DisasmStartOne("MOVE.L ");
Disasm_opsize = 4;
DisasmMove();
}
LOCALPROCUSEDONCE DisasmMoveW(void)
{
DisasmStartOne("MOVE.W ");
Disasm_opsize = 2;
DisasmMove();
}
LOCALPROCUSEDONCE DisasmMoveB(void)
{
DisasmStartOne("MOVE.B ");
Disasm_opsize = 1;
DisasmMove();
}
LOCALPROCUSEDONCE DisasmMoveAL(void)
{
DisasmStartOne("MOVEA.L ");
Disasm_opsize = 4;
DisasmMove();
}
LOCALPROCUSEDONCE DisasmMoveAW(void)
{
DisasmStartOne("MOVEA.W ");
Disasm_opsize = 2;
DisasmMove();
}
LOCALPROCUSEDONCE DisasmMoveQ(void)
{
/* MoveQ 0111ddd0nnnnnnnn */
DisasmStartOne("MOVEQ #");
dbglog_writeHex(ui5r_FromSByte(Disasm_opcode));
dbglog_writeCStr(", D");
dbglog_writeHex(Disasm_rg9);
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmAddEaR(void)
{
DisasmEaD_xxxxdddxssmmmrrr("ADD");
}
LOCALPROCUSEDONCE DisasmAddQ(void)
{
/* AddQ 0101nnn0ssmmmrrr */
Disasm_xxxxnnnxssmmmrrr("ADDQ");
}
LOCALPROCUSEDONCE DisasmAddI(void)
{
DisasmI_xxxxxxxxssmmmrrr("ADDI");
}
LOCALPROCUSEDONCE DisasmAddREa(void)
{
DisasmDEa_xxxxdddxssmmmrrr("ADD");
}
LOCALPROCUSEDONCE DisasmSubEaR(void)
{
DisasmEaD_xxxxdddxssmmmrrr("SUB");
}
LOCALPROCUSEDONCE DisasmSubQ(void)
{
/* SubQ 0101nnn1ssmmmrrr */
Disasm_xxxxnnnxssmmmrrr("SUBQ");
}
LOCALPROCUSEDONCE DisasmSubI(void)
{
DisasmI_xxxxxxxxssmmmrrr("SUBI");
}
LOCALPROCUSEDONCE DisasmSubREa(void)
{
DisasmDEa_xxxxdddxssmmmrrr("SUB");
}
LOCALPROCUSEDONCE DisasmLea(void)
{
/* Lea 0100aaa111mmmrrr */
DisasmStartOne("LEA ");
DisasmModeRegister(Disasm_mode, Disasm_reg);
dbglog_writeCStr(", A");
dbglog_writeHex(Disasm_rg9);
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmPEA(void)
{
/* PEA 0100100001mmmrrr */
DisasmStartOne("PEA ");
DisasmModeRegister(Disasm_mode, Disasm_reg);
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmALine(void)
{
DisasmStartOne("$");
dbglog_writeHex(Disasm_opcode);
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmBsr(void)
{
ui5b src = ((ui5b)Disasm_opcode) & 255;
ui5r s = Disasm_pc;
DisasmStartOne("BSR ");
if (src == 0) {
s += (si5b)(si4b)Disasm_nextiword();
} else
#if Use68020
if (src == 255) {
s += (si5b)Disasm_nextilong();
/* ReportAbnormal("long branch in DoCode6"); */
/* Used by various Apps */
} else
#endif
{
s += (si5b)(si3b)src;
}
dbglog_writeHex(s);
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmJsr(void)
{
/* Jsr 0100111010mmmrrr */
DisasmStartOne("JSR ");
DisasmModeRegister(Disasm_mode, Disasm_reg);
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmLinkA6(void)
{
DisasmStartOne("LINK A6, ");
dbglog_writeHex(Disasm_nextiword());
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmMOVEMRmM(void)
{
/* MOVEM reg to mem 0100100011s100rrr */
si4b z;
ui5r regmask;
DisasmStartOne("MOVEM");
if (Disasm_b76 == 2) {
dbglog_writeCStr(".W");
} else {
dbglog_writeCStr(".L");
}
dbglog_writeCStr(" ");
regmask = Disasm_nextiword();
for (z = 16; --z >= 0; ) {
if ((regmask & (1 << (15 - z))) != 0) {
if (z >= 8) {
dbglog_writeCStr("A");
dbglog_writeHex(z - 8);
} else {
dbglog_writeCStr("D");
dbglog_writeHex(z);
}
}
}
dbglog_writeCStr(", -(A");
dbglog_writeHex(Disasm_reg);
dbglog_writeCStr(")");
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmMOVEMApR(void)
{
/* MOVEM mem to reg 0100110011s011rrr */
si4b z;
ui5r regmask;
regmask = Disasm_nextiword();
DisasmStartOne("MOVEM");
if (Disasm_b76 == 2) {
dbglog_writeCStr(".W");
} else {
dbglog_writeCStr(".L");
}
dbglog_writeCStr(" (A");
dbglog_writeHex(Disasm_reg);
dbglog_writeCStr(")+, ");
for (z = 0; z < 16; ++z) {
if ((regmask & (1 << z)) != 0) {
if (z >= 8) {
dbglog_writeCStr("A");
dbglog_writeHex(z - 8);
} else {
dbglog_writeCStr("D");
dbglog_writeHex(z);
}
}
}
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmUnlkA6(void)
{
DisasmStartOne("UNLINK A6");
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmRts(void)
{
/* Rts 0100111001110101 */
DisasmStartOne("RTS");
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmJmp(void)
{
/* JMP 0100111011mmmrrr */
DisasmStartOne("JMP ");
DisasmModeRegister(Disasm_mode, Disasm_reg);
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmClr(void)
{
/* Clr 01000010ssmmmrrr */
Disasm_xxxxxxxxssmmmrrr("CLR");
}
LOCALPROCUSEDONCE DisasmAddA(void)
{
/* ADDA 1101dddm11mmmrrr */
DisasmEaA_xxxxdddsxxmmmrrr("ADDA");
}
LOCALPROCUSEDONCE DisasmAddQA(void)
{
/* 0101nnn0ss001rrr */
DisasmStartOne("ADDQA #");
dbglog_writeHex(Disasm_octdat(Disasm_rg9));
dbglog_writeCStr(", A");
dbglog_writeHex(Disasm_reg);
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmSubQA(void)
{
/* 0101nnn1ss001rrr */
DisasmStartOne("SUBQA #");
dbglog_writeHex(Disasm_octdat(Disasm_rg9));
dbglog_writeCStr(", A");
dbglog_writeHex(Disasm_reg);
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmSubA(void)
{
/* SUBA 1001dddm11mmmrrr */
DisasmEaA_xxxxdddsxxmmmrrr("SUBA");
}
LOCALPROCUSEDONCE DisasmCmpA(void)
{
DisasmStartOne("CMPA ");
Disasm_opsize = Disasm_b8 * 2 + 2;
DisasmModeRegister(Disasm_mode, Disasm_reg);
dbglog_writeCStr(", A");
dbglog_writeHex(Disasm_rg9);
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmAddXd(void)
{
DisasmDD_xxxxdddxssxxxrrr("ADDX");
}
LOCALPROCUSEDONCE DisasmAddXm(void)
{
DisasmAAs_xxxxdddxssxxxrrr("ADDX");
}
LOCALPROCUSEDONCE DisasmSubXd(void)
{
DisasmDD_xxxxdddxssxxxrrr("SUBX");
}
LOCALPROCUSEDONCE DisasmSubXm(void)
{
DisasmAAs_xxxxdddxssxxxrrr("SUBX");
}
LOCALPROC DisasmBinOp1(ui5r x)
{
if (! Disasm_b8) {
switch (x) {
case 0:
DisasmStartOne("ASR");
break;
case 1:
DisasmStartOne("LSR");
break;
case 2:
DisasmStartOne("RXR");
break;
case 3:
DisasmStartOne("ROR");
break;
default:
/* should not get here */
break;
}
} else {
switch (x) {
case 0:
DisasmStartOne("ASL");
break;
case 1:
DisasmStartOne("LSL");
break;
case 2:
DisasmStartOne("RXL");
break;
case 3:
DisasmStartOne("ROL");
break;
default:
/* should not get here */
break;
}
}
}
LOCALPROCUSEDONCE DisasmRolopNM(void)
{
DisasmBinOp1(Disasm_rg9);
dbglog_writeCStr(" ");
Disasm_opsize = 2;
DisasmModeRegister(Disasm_mode, Disasm_reg);
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmRolopND(void)
{
/* 1110cccdss0ttddd */
DisasmBinOp1(Disasm_mode & 3);
DisasmOpSizeFromb76();
dbglog_writeCStr(" #");
dbglog_writeHex(Disasm_octdat(Disasm_rg9));
dbglog_writeCStr(", ");
DisasmModeRegister(0, Disasm_reg);
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmRolopDD(void)
{
/* 1110rrrdss1ttddd */
DisasmBinOp1(Disasm_mode & 3);
DisasmOpSizeFromb76();
dbglog_writeCStr(" ");
DisasmModeRegister(0, Disasm_rg9);
dbglog_writeCStr(", ");
DisasmModeRegister(0, Disasm_reg);
dbglog_writeReturn();
}
LOCALPROC DisasmBinBitOp1(void)
{
switch (Disasm_b76) {
case 0:
DisasmStartOne("BTST");
break;
case 1:
DisasmStartOne("BCHG");
break;
case 2:
DisasmStartOne("BCLR");
break;
case 3:
DisasmStartOne("BSET");
break;
default:
/* should not get here */
break;
}
}
LOCALPROCUSEDONCE DisasmBitOpDD(void)
{
/* dynamic bit, Opcode = 0000ddd1tt000rrr */
DisasmBinBitOp1();
Disasm_opsize = 4;
dbglog_writeCStr(" ");
DisasmModeRegister(0, Disasm_rg9);
dbglog_writeCStr(", ");
DisasmModeRegister(0, Disasm_reg);
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmBitOpDM(void)
{
/* dynamic bit, Opcode = 0000ddd1ttmmmrrr */
DisasmBinBitOp1();
Disasm_opsize = 1;
dbglog_writeCStr(" ");
DisasmModeRegister(0, Disasm_rg9);
dbglog_writeCStr(", ");
DisasmModeRegister(Disasm_mode, Disasm_rg9);
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmBitOpND(void)
{
/* static bit 00001010tt000rrr */
DisasmBinBitOp1();
Disasm_opsize = 4;
dbglog_writeCStr(" #");
dbglog_writeHex(ui5r_FromSByte(Disasm_nextibyte()));
dbglog_writeCStr(", ");
DisasmModeRegister(0, Disasm_reg);
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmBitOpNM(void)
{
/* static bit 00001010ttmmmrrr */
DisasmBinBitOp1();
Disasm_opsize = 1;
dbglog_writeCStr(" #");
dbglog_writeHex(ui5r_FromSByte(Disasm_nextibyte()));
dbglog_writeCStr(", ");
DisasmModeRegister(Disasm_mode, Disasm_rg9);
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmAndI(void)
{
DisasmI_xxxxxxxxssmmmrrr("ANDI");
}
LOCALPROCUSEDONCE DisasmAndDEa(void)
{
/* And 1100ddd1ssmmmrrr */
DisasmDEa_xxxxdddxssmmmrrr("AND");
}
LOCALPROCUSEDONCE DisasmAndEaD(void)
{
/* And 1100ddd0ssmmmrrr */
DisasmEaD_xxxxdddxssmmmrrr("AND");
}
LOCALPROCUSEDONCE DisasmOrI(void)
{
DisasmI_xxxxxxxxssmmmrrr("ORI");
}
LOCALPROCUSEDONCE DisasmOrDEa(void)
{
/* OR 1000ddd1ssmmmrrr */
DisasmDEa_xxxxdddxssmmmrrr("OR");
}
LOCALPROCUSEDONCE DisasmOrEaD(void)
{
/* OR 1000ddd0ssmmmrrr */
DisasmEaD_xxxxdddxssmmmrrr("OR");
}
LOCALPROCUSEDONCE DisasmEorI(void)
{
DisasmI_xxxxxxxxssmmmrrr("EORI");
}
LOCALPROCUSEDONCE DisasmEor(void)
{
/* Eor 1011ddd1ssmmmrrr */
DisasmDEa_xxxxdddxssmmmrrr("EOR");
}
LOCALPROCUSEDONCE DisasmNot(void)
{
/* Not 01000110ssmmmrrr */
Disasm_xxxxxxxxssmmmrrr("NOT");
}
LOCALPROCUSEDONCE DisasmScc(void)
{
/* Scc 0101cccc11mmmrrr */
Disasm_opsize = 1;
DisasmStartOne("S");
DisasmCC();
dbglog_writeCStr(" ");
DisasmModeRegister(Disasm_mode, Disasm_reg);
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmEXTL(void)
{
DisasmStartOne("EXT.L D");
dbglog_writeHex(Disasm_reg);
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmEXTW(void)
{
DisasmStartOne("EXT.W D");
dbglog_writeHex(Disasm_reg);
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmNeg(void)
{
/* Neg 01000100ssmmmrrr */
Disasm_xxxxxxxxssmmmrrr("NEG");
}
LOCALPROCUSEDONCE DisasmNegX(void)
{
/* NegX 01000000ssmmmrrr */
Disasm_xxxxxxxxssmmmrrr("NEGX");
}
LOCALPROCUSEDONCE DisasmMulU(void)
{
/* MulU 1100ddd011mmmrrr */
Disasm_opsize = 2;
DisasmStartOne("MULU ");
DisasmModeRegister(Disasm_mode, Disasm_reg);
dbglog_writeCStr(", ");
DisasmModeRegister(0, Disasm_rg9);
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmMulS(void)
{
/* MulS 1100ddd111mmmrrr */
Disasm_opsize = 2;
DisasmStartOne("MULS ");
DisasmModeRegister(Disasm_mode, Disasm_reg);
dbglog_writeCStr(", ");
DisasmModeRegister(0, Disasm_rg9);
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmDivU(void)
{
/* DivU 1000ddd011mmmrrr */
Disasm_opsize = 2;
DisasmStartOne("DIVU ");
DisasmModeRegister(Disasm_mode, Disasm_reg);
dbglog_writeCStr(", ");
DisasmModeRegister(0, Disasm_rg9);
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmDivS(void)
{
/* DivS 1000ddd111mmmrrr */
Disasm_opsize = 2;
DisasmStartOne("DIVS ");
DisasmModeRegister(Disasm_mode, Disasm_reg);
dbglog_writeCStr(", ");
DisasmModeRegister(0, Disasm_rg9);
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmExgdd(void)
{
/* Exg 1100ddd101000rrr */
Disasm_opsize = 4;
DisasmStartOne("EXG ");
DisasmModeRegister(0, Disasm_rg9);
dbglog_writeCStr(", ");
DisasmModeRegister(0, Disasm_reg);
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmExgaa(void)
{
/* Exg 1100ddd101001rrr */
Disasm_opsize = 4;
DisasmStartOne("EXG ");
DisasmModeRegister(1, Disasm_rg9);
dbglog_writeCStr(", ");
DisasmModeRegister(1, Disasm_reg);
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmExgda(void)
{
/* Exg 1100ddd110001rrr */
Disasm_opsize = 4;
DisasmStartOne("EXG ");
DisasmModeRegister(0, Disasm_rg9);
dbglog_writeCStr(", ");
DisasmModeRegister(1, Disasm_reg);
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmMoveCCREa(void)
{
/* Move from CCR 0100001011mmmrrr */
Disasm_opsize = 2;
DisasmStartOne("MOVE CCR, ");
DisasmModeRegister(Disasm_mode, Disasm_reg);
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmMoveEaCR(void)
{
/* 0100010011mmmrrr */
Disasm_opsize = 2;
DisasmStartOne("MOVE ");
DisasmModeRegister(Disasm_mode, Disasm_reg);
dbglog_writeCStr(", CCR");
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmMoveSREa(void)
{
/* Move from SR 0100000011mmmrrr */
Disasm_opsize = 2;
DisasmStartOne("MOVE SR, ");
DisasmModeRegister(Disasm_mode, Disasm_reg);
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmMoveEaSR(void)
{
/* 0100011011mmmrrr */
Disasm_opsize = 2;
DisasmStartOne("MOVE ");
DisasmModeRegister(Disasm_mode, Disasm_reg);
dbglog_writeCStr(", SR");
dbglog_writeReturn();
}
LOCALPROC DisasmBinOpStatusCCR(void)
{
switch (Disasm_rg9) {
case 0 :
DisasmStartOne("OR");
break;
case 1 :
DisasmStartOne("AND");
break;
case 5 :
DisasmStartOne("EOR");
break;
default: /* should not happen */
break;
}
DisasmOpSizeFromb76();
dbglog_writeCStr(" #");
dbglog_writeHex(ui5r_FromSWord(Disasm_nextiword()));
if (Disasm_b76 != 0) {
dbglog_writeCStr(", SR");
} else {
dbglog_writeCStr(", CCR");
}
dbglog_writeReturn();
}
LOCALPROC disasmreglist(si4b direction, ui5b m1, ui5b r1)
{
si4b z;
ui5r regmask;
DisasmStartOne("MOVEM");
regmask = Disasm_nextiword();
Disasm_opsize = 2 * Disasm_b76 - 2;
if (Disasm_opsize == 2) {
dbglog_writeCStr(".W");
} else {
dbglog_writeCStr(".L");
}
dbglog_writeCStr(" ");
if (direction != 0) {
DisasmModeRegister(m1, r1);
dbglog_writeCStr(", ");
}
for (z = 0; z < 16; ++z) {
if ((regmask & (1 << z)) != 0) {
if (z >= 8) {
dbglog_writeCStr("A");
dbglog_writeHex(z - 8);
} else {
dbglog_writeCStr("D");
dbglog_writeHex(z);
}
}
}
if (direction == 0) {
dbglog_writeCStr(", ");
DisasmModeRegister(m1, r1);
}
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmMOVEMrm(void)
{
/* MOVEM reg to mem 010010001ssmmmrrr */
disasmreglist(0, Disasm_mode, Disasm_reg);
}
LOCALPROCUSEDONCE DisasmMOVEMmr(void)
{
/* MOVEM mem to reg 0100110011smmmrrr */
disasmreglist(1, Disasm_mode, Disasm_reg);
}
LOCALPROC DisasmByteBinOp(char *s, ui5b m1, ui5b r1, ui5b m2, ui5b r2)
{
DisasmStartOne(s);
dbglog_writeCStr(" ");
DisasmOpSizeFromb76();
DisasmModeRegister(m1, r1);
dbglog_writeCStr(", ");
DisasmModeRegister(m2, r2);
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmAbcdr(void)
{
/* ABCD 1100ddd100000rrr */
DisasmByteBinOp("ABCD", 0, Disasm_reg, 0, Disasm_rg9);
}
LOCALPROCUSEDONCE DisasmAbcdm(void)
{
/* ABCD 1100ddd100001rrr */
DisasmByteBinOp("ABCD", 4, Disasm_reg, 4, Disasm_rg9);
}
LOCALPROCUSEDONCE DisasmSbcdr(void)
{
/* SBCD 1000xxx100000xxx */
DisasmByteBinOp("ABCD", 0, Disasm_reg, 0, Disasm_rg9);
}
LOCALPROCUSEDONCE DisasmSbcdm(void)
{
/* SBCD 1000xxx100001xxx */
DisasmByteBinOp("ABCD", 4, Disasm_reg, 4, Disasm_rg9);
}
LOCALPROCUSEDONCE DisasmNbcd(void)
{
/* Nbcd 0100100000mmmrrr */
Disasm_xxxxxxxxssmmmrrr("NBCD");
}
LOCALPROCUSEDONCE DisasmRte(void)
{
/* Rte 0100111001110011 */
DisasmStartOne("RTE");
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmNop(void)
{
/* Nop 0100111001110001 */
DisasmStartOne("NOP");
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmMoveP(void)
{
/* MoveP 0000ddd1mm001aaa */
DisasmStartOne("MOVEP");
if (0 == (Disasm_b76 & 1)) {
Disasm_opsize = 2;
dbglog_writeCStr(".W");
} else {
Disasm_opsize = 4;
dbglog_writeCStr(".L");
}
dbglog_writeCStr(" ");
if (Disasm_b76 < 2) {
DisasmModeRegister(5, Disasm_reg);
dbglog_writeCStr(", ");
DisasmModeRegister(0, Disasm_rg9);
} else {
DisasmModeRegister(0, Disasm_rg9);
dbglog_writeCStr(", ");
DisasmModeRegister(5, Disasm_reg);
}
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmIllegal(void)
{
DisasmStartOne("ILLEGAL");
dbglog_writeReturn();
}
LOCALPROC DisasmCheck(void)
{
DisasmStartOne("CHK");
if (2 == Disasm_opsize) {
dbglog_writeCStr(".W");
} else {
dbglog_writeCStr(".L");
}
dbglog_writeCStr(" ");
DisasmModeRegister(Disasm_mode, Disasm_reg);
dbglog_writeCStr(", ");
DisasmModeRegister(0, Disasm_rg9);
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmChkW(void)
{
/* Chk.W 0100ddd110mmmrrr */
Disasm_opsize = 2;
DisasmCheck();
}
LOCALPROCUSEDONCE DisasmTrap(void)
{
/* Trap 010011100100vvvv */
DisasmStartOne("TRAP ");
dbglog_writeHex(Disasm_opcode & 15);
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmTrapV(void)
{
/* TrapV 0100111001110110 */
DisasmStartOne("TRAPV");
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmRtr(void)
{
/* Rtr 0100111001110111 */
DisasmStartOne("RTR");
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmLink(void)
{
DisasmStartOne("LINK A");
dbglog_writeHex(Disasm_reg);
dbglog_writeCStr(", ");
dbglog_writeHex(Disasm_nextiword());
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmUnlk(void)
{
DisasmStartOne("UNLINK A");
dbglog_writeHex(Disasm_reg);
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmMoveRUSP(void)
{
/* MOVE USP 0100111001100aaa */
DisasmStartOne("MOVE A");
dbglog_writeHex(Disasm_reg);
dbglog_writeCStr(", USP");
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmMoveUSPR(void)
{
/* MOVE USP 0100111001101aaa */
DisasmStartOne("MOVE USP, A");
dbglog_writeHex(Disasm_reg);
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmTas(void)
{
/* Tas 0100101011mmmrrr */
Disasm_opsize = 1;
DisasmStartOne("TAS");
dbglog_writeCStr(" ");
DisasmModeRegister(Disasm_mode, Disasm_reg);
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmFLine(void)
{
DisasmStartOne("$");
dbglog_writeHex(Disasm_opcode);
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmCallMorRtm(void)
{
DisasmStartOne("CALLM #");
dbglog_writeHex(Disasm_nextibyte());
dbglog_writeCStr(", ");
DisasmModeRegister(Disasm_mode, Disasm_reg);
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmStop(void)
{
/* Stop 0100111001110010 */
DisasmStartOne("STOP #");
dbglog_writeHex(Disasm_nextiword());
dbglog_writeReturn();
}
LOCALPROCUSEDONCE DisasmReset(void)
{
/* Reset 0100111001100000 */
DisasmStartOne("RESET");
dbglog_writeReturn();
}
#if Use68020
LOCALPROCUSEDONCE DisasmEXTBL(void)
{
/* EXTB.L */
DisasmStartOne("EXTB.L D");
dbglog_writeHex(Disasm_reg);
dbglog_writeReturn();
}
#endif
#if Use68020
LOCALPROCUSEDONCE DisasmTRAPcc(void)
{
/* TRAPcc 0101cccc11111sss */
DisasmStartOne("TRAP");
DisasmCC();
switch (Disasm_reg) {
case 2:
dbglog_writeCStr(" ");
dbglog_writeHex(Disasm_nextiword());
break;
case 3:
dbglog_writeCStr(" ");
dbglog_writeHex(Disasm_nextilong());
break;
case 4:
/* no optional data */
break;
default:
/* illegal format */
break;
}
dbglog_writeReturn();
}
#endif
#if Use68020
LOCALPROCUSEDONCE DisasmChkL(void)
{
/* Chk.L 0100ddd100mmmrrr */
Disasm_opsize = 4;
DisasmCheck();
}
#endif
#if Use68020
LOCALPROCUSEDONCE DisasmBkpt(void)
{
/* BKPT 0100100001001rrr */
DisasmStartOne("BKPT #");
dbglog_writeHex(Disasm_reg);
dbglog_writeReturn();
}
#endif
#if Use68020
LOCALPROCUSEDONCE DisasmDivL(void)
{
/* DIVU 0100110001mmmrrr 0rrr0s0000000rrr */
/* DIVS 0100110001mmmrrr 0rrr1s0000000rrr */
Disasm_opsize = 4;
DisasmStartOne("DIV");
{
ui4b extra = Disasm_nextiword();
ui5b rDr = extra & 7;
ui5b rDq = (extra >> 12) & 7;
if (extra & 0x0800) {
dbglog_writeCStr("S");
} else {
dbglog_writeCStr("U");
}
if (extra & 0x0400) {
dbglog_writeCStr("L");
}
dbglog_writeCStr(".L ");
DisasmModeRegister(Disasm_mode, Disasm_reg);
dbglog_writeCStr(", ");
if (rDr != rDq) {
dbglog_writeCStr("D");
dbglog_writeHex(rDr);
dbglog_writeCStr(":");
}
dbglog_writeCStr("D");
dbglog_writeHex(rDq);
}
dbglog_writeReturn();
}
#endif
#if Use68020
LOCALPROCUSEDONCE DisasmMulL(void)
{
/* MULU 0100110000mmmrrr 0rrr0s0000000rrr */
/* MULS 0100110000mmmrrr 0rrr1s0000000rrr */
Disasm_opsize = 4;
DisasmStartOne("MUL");
{
ui4b extra = Disasm_nextiword();
ui5b rhi = extra & 7;
ui5b rlo = (extra >> 12) & 7;
if (extra & 0x0800) {
dbglog_writeCStr("S");
} else {
dbglog_writeCStr("U");
}
dbglog_writeCStr(".L ");
DisasmModeRegister(Disasm_mode, Disasm_reg);
dbglog_writeCStr(", ");
if (extra & 0x400) {
dbglog_writeCStr("D");
dbglog_writeHex(rhi);
dbglog_writeCStr(":");
}
dbglog_writeCStr("D");
dbglog_writeHex(rlo);
}
dbglog_writeReturn();
}
#endif
#if Use68020
LOCALPROCUSEDONCE DisasmRtd(void)
{
/* Rtd 0100111001110100 */
DisasmStartOne("RTD #");
dbglog_writeHex((si5b)(si4b)Disasm_nextiword());
dbglog_writeReturn();
}
#endif
#if Use68020
LOCALPROC DisasmControlReg(ui4r i)
{
switch (i) {
case 0x0000:
dbglog_writeCStr("SFC");
break;
case 0x0001:
dbglog_writeCStr("DFC");
break;
case 0x0002:
dbglog_writeCStr("CACR");
break;
case 0x0800:
dbglog_writeCStr("USP");
break;
case 0x0801:
dbglog_writeCStr("VBR");
break;
case 0x0802:
dbglog_writeCStr("CAAR");
break;
case 0x0803:
dbglog_writeCStr("MSP");
break;
case 0x0804:
dbglog_writeCStr("ISP");
break;
default:
dbglog_writeCStr("???");
break;
}
}
#endif
#if Use68020
LOCALPROCUSEDONCE DisasmMoveC(void)
{
/* MOVEC 010011100111101m */
DisasmStartOne("MOVEC ");
{
ui4b src = Disasm_nextiword();
int regno = (src >> 12) & 0x0F;
switch (Disasm_reg) {
case 2:
DisasmControlReg(src & 0x0FFF);
dbglog_writeCStr(", ");
if (regno < 8) {
dbglog_writeCStr("D");
} else {
dbglog_writeCStr("A");
}
dbglog_writeHex(regno & 7);
break;
case 3:
if (regno < 8) {
dbglog_writeCStr("D");
} else {
dbglog_writeCStr("A");
}
dbglog_writeHex(regno & 7);
dbglog_writeCStr(", ");
DisasmControlReg(src & 0x0FFF);
break;
default:
/* illegal */
break;
}
}
dbglog_writeReturn();
}
#endif
#if Use68020
LOCALPROCUSEDONCE DisasmLinkL(void)
{
/* Link.L 0100100000001rrr */
DisasmStartOne("LINK.L A");
dbglog_writeHex(Disasm_reg);
dbglog_writeCStr(", ");
dbglog_writeHex(Disasm_nextilong());
dbglog_writeReturn();
}
#endif
#if Use68020
LOCALPROCUSEDONCE DisasmPack(void)
{
DisasmStartOne("PACK ???");
dbglog_writeReturn();
/* DoCodePack */
}
#endif
#if Use68020
LOCALPROCUSEDONCE DisasmUnpk(void)
{
DisasmStartOne("UNPK ???");
dbglog_writeReturn();
/* DoCodeUnpk */
}
#endif
#if Use68020
LOCALPROCUSEDONCE DisasmCHK2orCMP2(void)
{
DisasmStartOne("CHK2/CMP2 ???");
dbglog_writeReturn();
/* DoCHK2orCMP2 */
}
#endif
#if Use68020
LOCALPROCUSEDONCE DisasmCAS2(void)
{
DisasmStartOne("CAS2 ???");
dbglog_writeReturn();
/* DoCAS2 */
}
#endif
#if Use68020
LOCALPROCUSEDONCE DisasmCAS(void)
{
DisasmStartOne("CAS ???");
dbglog_writeReturn();
/* DoDoCAS */
}
#endif
#if Use68020
LOCALPROCUSEDONCE DisasmMOVES(void)
{
DisasmStartOne("MOVES ???");
dbglog_writeReturn();
/* DoMOVES */
}
#endif
#if Use68020
LOCALPROCUSEDONCE DisasmBitField(void)
{
DisasmStartOne("BitField ???");
dbglog_writeReturn();
/* DoBitField */
}
#endif
LOCALFUNC blnr IsValidAddrMode(void)
{
return (Disasm_mode != 7) || (Disasm_reg < 5);
}
LOCALFUNC blnr IsValidDstAddrMode(void)
{
return (Disasm_md6 != 7) || (Disasm_rg9 < 2);
}
LOCALFUNC blnr IsValidDataAltAddrMode(void)
{
blnr IsOk;
switch (Disasm_mode) {
case 1:
default: /* keep compiler happy */
IsOk = falseblnr;
break;
case 0:
case 2:
case 3:
case 4:
case 5:
case 6:
IsOk = trueblnr;
break;
case 7:
IsOk = Disasm_reg < 2;
break;
}
return IsOk;
}
LOCALFUNC blnr IsValidDataAddrMode(void)
{
blnr IsOk;
switch (Disasm_mode) {
case 1:
default: /* keep compiler happy */
IsOk = falseblnr;
break;
case 0:
case 2:
case 3:
case 4:
case 5:
case 6:
IsOk = trueblnr;
break;
case 7:
IsOk = Disasm_reg < 5;
break;
}
return IsOk;
}
LOCALFUNC blnr IsValidControlAddrMode(void)
{
blnr IsOk;
switch (Disasm_mode) {
case 0:
case 1:
case 3:
case 4:
default: /* keep compiler happy */
IsOk = falseblnr;
break;
case 2:
case 5:
case 6:
IsOk = trueblnr;
break;
case 7:
IsOk = Disasm_reg < 4;
break;
}
return IsOk;
}
LOCALFUNC blnr IsValidControlAltAddrMode(void)
{
blnr IsOk;
switch (Disasm_mode) {
case 0:
case 1:
case 3:
case 4:
default: /* keep compiler happy */
IsOk = falseblnr;
break;
case 2:
case 5:
case 6:
IsOk = trueblnr;
break;
case 7:
IsOk = Disasm_reg < 2;
break;
}
return IsOk;
}
LOCALFUNC blnr IsValidAltMemAddrMode(void)
{
blnr IsOk;
switch (Disasm_mode) {
case 0:
case 1:
default: /* keep compiler happy */
IsOk = falseblnr;
break;
case 2:
case 3:
case 4:
case 5:
case 6:
IsOk = trueblnr;
break;
case 7:
IsOk = Disasm_reg < 2;
break;
}
return IsOk;
}
LOCALPROCUSEDONCE DisasmCode0(void)
{
if (Disasm_b8 == 1) {
if (Disasm_mode == 1) {
/* MoveP 0000ddd1mm001aaa */
DisasmMoveP();
} else {
/* dynamic bit, Opcode = 0000ddd1ttmmmrrr */
if (Disasm_mode == 0) {
DisasmBitOpDD();
} else {
if (Disasm_b76 == 0) {
if (IsValidDataAddrMode()) {
DisasmBitOpDM();
} else {
DisasmIllegal();
}
} else {
if (IsValidDataAltAddrMode()) {
DisasmBitOpDM();
} else {
DisasmIllegal();
}
}
}
}
} else {
if (Disasm_rg9 == 4) {
/* static bit 00001010ssmmmrrr */
if (Disasm_mode == 0) {
DisasmBitOpND();
} else {
if (Disasm_b76 == 0) {
if ((Disasm_mode == 7) && (Disasm_reg == 4)) {
DisasmIllegal();
} else {
if (IsValidDataAddrMode()) {
DisasmBitOpNM();
} else {
DisasmIllegal();
}
}
} else {
if (IsValidDataAltAddrMode()) {
DisasmBitOpNM();
} else {
DisasmIllegal();
}
}
}
} else
if (Disasm_b76 == 3) {
#if Use68020
if (Disasm_rg9 < 3) {
/* CHK2 or CMP2 00000ss011mmmrrr */
if (IsValidControlAddrMode()) {
DisasmCHK2orCMP2();
} else {
DisasmIllegal();
}
} else
if (Disasm_rg9 >= 5) {
if ((Disasm_mode == 7) && (Disasm_reg == 4)) {
/* CAS2 00001ss011111100 */
DisasmCAS2();
} else {
/* CAS 00001ss011mmmrrr */
DisasmCAS2();
}
} else
if (Disasm_rg9 == 3) {
/* CALLM or RTM 0000011011mmmrrr */
DisasmCallMorRtm();
} else
#endif
{
DisasmIllegal();
}
} else
if (Disasm_rg9 == 6) {
/* CMPI 00001100ssmmmrrr */
if (IsValidDataAltAddrMode()) {
DisasmCmpI();
} else {
DisasmIllegal();
}
} else if (Disasm_rg9 == 7) {
#if Use68020
/* MoveS 00001110ssmmmrrr */
if (IsValidAltMemAddrMode()) {
DisasmMoveSREa();
} else {
DisasmIllegal();
}
#else
DisasmIllegal();
#endif
} else {
if ((Disasm_mode == 7) && (Disasm_reg == 4)) {
switch (Disasm_rg9) {
case 0:
case 1:
case 5:
DisasmBinOpStatusCCR();
break;
default:
DisasmIllegal();
break;
}
} else {
if (! IsValidDataAltAddrMode()) {
DisasmIllegal();
} else {
switch (Disasm_rg9) {
case 0:
DisasmOrI();
break;
case 1:
DisasmAndI();
break;
case 2:
DisasmSubI();
break;
case 3:
DisasmAddI();
break;
case 5:
DisasmEorI();
break;
default:
/*
for compiler.
should be 0, 1, 2, 3, or 5
*/
DisasmIllegal();
break;
}
}
}
}
}
}
LOCALPROCUSEDONCE DisasmCode1(void)
{
if ((Disasm_mode == 1) || ! IsValidAddrMode()) {
DisasmIllegal();
} else if (Disasm_md6 == 1) { /* MOVEA */
DisasmIllegal();
} else if (! IsValidDstAddrMode()) {
DisasmIllegal();
} else {
DisasmMoveB();
}
}
LOCALPROCUSEDONCE DisasmCode2(void)
{
if (Disasm_md6 == 1) { /* MOVEA */
if (IsValidAddrMode()) {
DisasmMoveAL();
} else {
DisasmIllegal();
}
} else if (! IsValidAddrMode()) {
DisasmIllegal();
} else if (! IsValidDstAddrMode()) {
DisasmIllegal();
} else {
DisasmMoveL();
}
}
LOCALPROCUSEDONCE DisasmCode3(void)
{
if (Disasm_md6 == 1) { /* MOVEA */
if (IsValidAddrMode()) {
DisasmMoveAW();
} else {
DisasmIllegal();
}
} else if (! IsValidAddrMode()) {
DisasmIllegal();
} else if (! IsValidDstAddrMode()) {
DisasmIllegal();
} else {
DisasmMoveW();
}
}
LOCALPROCUSEDONCE DisasmCode4(void)
{
if (Disasm_b8 != 0) {
switch (Disasm_b76) {
case 0:
#if Use68020
/* Chk.L 0100ddd100mmmrrr */
if (IsValidDataAddrMode()) {
DisasmChkL();
} else {
DisasmIllegal();
}
#else
DisasmIllegal();
#endif
break;
case 1:
DisasmIllegal();
break;
case 2:
/* Chk.W 0100ddd110mmmrrr */
if (IsValidDataAddrMode()) {
DisasmChkW();
} else {
DisasmIllegal();
}
break;
case 3:
default: /* keep compiler happy */
#if Use68020
if ((0 == Disasm_mode) && (4 == Disasm_rg9)) {
DisasmEXTBL();
} else
#endif
{
/* Lea 0100aaa111mmmrrr */
if (IsValidControlAddrMode()) {
DisasmLea();
} else {
DisasmIllegal();
}
}
break;
}
} else {
switch (Disasm_rg9) {
case 0:
if (Disasm_b76 != 3) {
/* NegX 01000000ssmmmrrr */
if (IsValidDataAltAddrMode()) {
DisasmNegX();
} else {
DisasmIllegal();
}
} else {
#if Use68020
/* reference seems incorrect to say not for 68000 */
#endif
/* Move from SR 0100000011mmmrrr */
if (IsValidDataAltAddrMode()) {
DisasmMoveSREa();
} else {
DisasmIllegal();
}
}
break;
case 1:
if (Disasm_b76 != 3) {
/* Clr 01000010ssmmmrrr */
if (IsValidDataAltAddrMode()) {
DisasmClr();
} else {
DisasmIllegal();
}
} else {
#if Use68020
/* Move from CCR 0100001011mmmrrr */
if (IsValidDataAltAddrMode()) {
DisasmMoveCCREa();
} else {
DisasmIllegal();
}
#else
DisasmIllegal();
#endif
}
break;
case 2:
if (Disasm_b76 != 3) {
/* Neg 01000100ssmmmrrr */
if (IsValidDataAltAddrMode()) {
DisasmNeg();
} else {
DisasmIllegal();
}
} else {
/* Move to CCR 0100010011mmmrrr */
if (IsValidDataAddrMode()) {
DisasmMoveEaCR();
} else {
DisasmIllegal();
}
}
break;
case 3:
if (Disasm_b76 != 3) {
/* Not 01000110ssmmmrrr */
if (IsValidDataAltAddrMode()) {
DisasmNot();
} else {
DisasmIllegal();
}
} else {
/* Move from SR 0100011011mmmrrr */
if (IsValidDataAddrMode()) {
DisasmMoveEaSR();
} else {
DisasmIllegal();
}
}
break;
case 4:
switch (Disasm_b76) {
case 0:
#if Use68020
if (Disasm_mode == 1) {
/* Link.L 0100100000001rrr */
DisasmLinkL();
} else
#endif
{
/* Nbcd 0100100000mmmrrr */
if (IsValidDataAltAddrMode()) {
DisasmNbcd();
} else {
DisasmIllegal();
}
}
break;
case 1:
if (Disasm_mode == 0) {
/* Swap 0100100001000rrr */
DisasmSwap();
} else
#if Use68020
if (Disasm_mode == 1) {
DisasmBkpt();
} else
#endif
{
/* PEA 0100100001mmmrrr */
if (IsValidControlAddrMode()) {
DisasmPEA();
} else {
DisasmIllegal();
}
}
break;
case 2:
if (Disasm_mode == 0) {
/* EXT.W */
DisasmEXTW();
} else {
/*
MOVEM Disasm_reg
to mem 01001d001ssmmmrrr
*/
if (Disasm_mode == 4) {
DisasmMOVEMRmM();
} else {
if (IsValidControlAltAddrMode()) {
DisasmMOVEMrm();
} else {
DisasmIllegal();
}
}
}
break;
case 3:
default: /* keep compiler happy */
if (Disasm_mode == 0) {
/* EXT.L */
DisasmEXTL();
} else {
/*
MOVEM Disasm_reg
to mem 01001d001ssmmmrrr
*/
if (Disasm_mode == 4) {
DisasmMOVEMRmM();
} else {
if (IsValidControlAltAddrMode()) {
DisasmMOVEMrm();
} else {
DisasmIllegal();
}
}
}
break;
}
break;
case 5:
if (Disasm_b76 == 3) {
if ((Disasm_mode == 7) && (Disasm_reg == 4)) {
/* the ILLEGAL instruction */
DisasmIllegal();
} else {
/* Tas 0100101011mmmrrr */
if (IsValidDataAltAddrMode()) {
DisasmTas();
} else {
DisasmIllegal();
}
}
} else {
/* Tst 01001010ssmmmrrr */
if (Disasm_b76 == 0) {
if (IsValidDataAltAddrMode()) {
DisasmTst();
} else {
DisasmIllegal();
}
} else {
if (IsValidAddrMode()) {
DisasmTst();
} else {
DisasmIllegal();
}
}
}
break;
case 6:
if (((Disasm_opcode >> 7) & 1) == 1) {
/* MOVEM mem to Disasm_reg 0100110011smmmrrr */
if (Disasm_mode == 3) {
DisasmMOVEMApR();
} else {
if (IsValidControlAddrMode()) {
DisasmMOVEMmr();
} else {
DisasmIllegal();
}
}
} else {
#if Use68020
if (((Disasm_opcode >> 6) & 1) == 1) {
/* DIVU 0100110001mmmrrr 0rrr0s0000000rrr */
/* DIVS 0100110001mmmrrr 0rrr1s0000000rrr */
DisasmDivL();
} else {
/* MULU 0100110000mmmrrr 0rrr0s0000000rrr */
/* MULS 0100110000mmmrrr 0rrr1s0000000rrr */
DisasmMulL();
}
#else
DisasmIllegal();
#endif
}
break;
case 7:
default: /* keep compiler happy */
switch (Disasm_b76) {
case 0:
DisasmIllegal();
break;
case 1:
switch (Disasm_mode) {
case 0:
case 1:
/* Trap 010011100100vvvv */
DisasmTrap();
break;
case 2:
/* Link */
if (Disasm_reg == 6) {
DisasmLinkA6();
} else {
DisasmLink();
}
break;
case 3:
/* Unlk */
if (Disasm_reg == 6) {
DisasmUnlkA6();
} else {
DisasmUnlk();
}
break;
case 4:
/* MOVE USP 0100111001100aaa */
DisasmMoveRUSP();
break;
case 5:
/* MOVE USP 0100111001101aaa */
DisasmMoveUSPR();
break;
case 6:
switch (Disasm_reg) {
case 0:
/* Reset 0100111001100000 */
DisasmReset();
break;
case 1:
/*
Nop Opcode
= 0100111001110001
*/
DisasmNop();
break;
case 2:
/* Stop 0100111001110010 */
DisasmStop();
break;
case 3:
/* Rte 0100111001110011 */
DisasmRte();
break;
case 4:
/* Rtd 0100111001110100 */
#if Use68020
DisasmRtd();
#else
DisasmIllegal();
#endif
break;
case 5:
/* Rts 0100111001110101 */
DisasmRts();
break;
case 6:
/* TrapV 0100111001110110 */
DisasmTrapV();
break;
case 7:
default: /* keep compiler happy */
/* Rtr 0100111001110111 */
DisasmRtr();
break;
}
break;
case 7:
default: /* keep compiler happy */
#if Use68020
/* MOVEC 010011100111101m */
DisasmMoveC();
#else
DisasmIllegal();
#endif
break;
}
break;
case 2:
/* Jsr 0100111010mmmrrr */
if (IsValidControlAddrMode()) {
DisasmJsr();
} else {
DisasmIllegal();
}
break;
case 3:
default: /* keep compiler happy */
/* JMP 0100111011mmmrrr */
if (IsValidControlAddrMode()) {
DisasmJmp();
} else {
DisasmIllegal();
}
break;
}
break;
}
}
}
LOCALPROCUSEDONCE DisasmCode5(void)
{
if (Disasm_b76 == 3) {
if (Disasm_mode == 1) {
/* DBcc 0101cccc11001ddd */
DisasmDBcc();
} else {
#if Use68020
if ((Disasm_mode == 7) && (Disasm_reg >= 2)) {
/* TRAPcc 0101cccc11111sss */
DisasmTRAPcc();
} else
#endif
{
/* Scc 0101cccc11mmmrrr */
if (IsValidDataAltAddrMode()) {
DisasmScc();
} else {
DisasmIllegal();
}
}
}
} else {
if (Disasm_mode == 1) {
if (Disasm_b8 == 0) {
DisasmAddQA(); /* AddQA 0101nnn0ss001rrr */
} else {
DisasmSubQA(); /* SubQA 0101nnn1ss001rrr */
}
} else {
if (Disasm_b8 == 0) {
/* AddQ 0101nnn0ssmmmrrr */
if (IsValidDataAltAddrMode()) {
DisasmAddQ();
} else {
DisasmIllegal();
}
} else {
/* SubQ 0101nnn1ssmmmrrr */
if (IsValidDataAltAddrMode()) {
DisasmSubQ();
} else {
DisasmIllegal();
}
}
}
}
}
LOCALPROCUSEDONCE DisasmCode6(void)
{
ui5b cond = (Disasm_opcode >> 8) & 15;
if (cond == 1) {
/* Bsr 01100001nnnnnnnn */
DisasmBsr();
} else if (cond == 0) {
/* Bra 01100000nnnnnnnn */
DisasmBcc();
} else {
/* Bcc 0110ccccnnnnnnnn */
DisasmBcc();
}
}
LOCALPROCUSEDONCE DisasmCode7(void)
{
if (Disasm_b8 == 0) {
DisasmMoveQ();
} else {
DisasmIllegal();
}
}
LOCALPROCUSEDONCE DisasmCode8(void)
{
if (Disasm_b76 == 3) {
if (Disasm_b8 == 0) {
/* DivU 1000ddd011mmmrrr */
if (IsValidDataAddrMode()) {
DisasmDivU();
} else {
DisasmIllegal();
}
} else {
/* DivS 1000ddd111mmmrrr */
if (IsValidDataAddrMode()) {
DisasmDivS();
} else {
DisasmIllegal();
}
}
} else {
if (Disasm_b8 == 0) {
/* OR 1000ddd0ssmmmrrr */
if (IsValidDataAddrMode()) {
DisasmOrEaD();
} else {
DisasmIllegal();
}
} else {
if (Disasm_mode < 2) {
switch (Disasm_b76) {
case 0:
/* SBCD 1000xxx10000mxxx */
if (Disasm_mode == 0) {
DisasmSbcdr();
} else {
DisasmSbcdm();
}
break;
#if Use68020
case 1:
/* PACK 1000rrr10100mrrr */
DisasmPack();
break;
case 2:
/* UNPK 1000rrr11000mrrr */
DisasmUnpk();
break;
#endif
default:
DisasmIllegal();
break;
}
} else {
/* OR 1000ddd1ssmmmrrr */
if (IsValidDataAltAddrMode()) {
DisasmOrDEa();
} else {
DisasmIllegal();
}
}
}
}
}
LOCALPROCUSEDONCE DisasmCode9(void)
{
if (Disasm_b76 == 3) {
/* SUBA 1001dddm11mmmrrr */
if (IsValidAddrMode()) {
DisasmSubA();
} else {
DisasmIllegal();
}
} else {
if (Disasm_b8 == 0) {
/* SUB 1001ddd0ssmmmrrr */
if (IsValidAddrMode()) {
DisasmSubEaR();
} else {
DisasmIllegal();
}
} else {
if (Disasm_mode == 0) {
/* SUBX 1001ddd1ss000rrr */
DisasmSubXd();
} else if (Disasm_mode == 1) {
/* SUBX 1001ddd1ss001rrr */
DisasmSubXm();
} else {
/* SUB 1001ddd1ssmmmrrr */
if (IsValidAltMemAddrMode()) {
DisasmSubREa();
} else {
DisasmIllegal();
}
}
}
}
}
LOCALPROCUSEDONCE DisasmCodeA(void)
{
DisasmALine();
}
LOCALPROCUSEDONCE DisasmCodeB(void)
{
if (Disasm_b76 == 3) {
/* CMPA 1011ddds11mmmrrr */
if (IsValidAddrMode()) {
DisasmCmpA();
} else {
DisasmIllegal();
}
} else if (Disasm_b8 == 1) {
if (Disasm_mode == 1) {
/* CmpM 1011ddd1ss001rrr */
DisasmCmpM();
} else {
/* Eor 1011ddd1ssmmmrrr */
if (IsValidDataAltAddrMode()) {
DisasmEor();
} else {
DisasmIllegal();
}
}
} else {
/* Cmp 1011ddd0ssmmmrrr */
if (IsValidAddrMode()) {
DisasmCompare();
} else {
DisasmIllegal();
}
}
}
LOCALPROCUSEDONCE DisasmCodeC(void)
{
if (Disasm_b76 == 3) {
if (Disasm_b8 == 0) {
/* MulU 1100ddd011mmmrrr */
if (IsValidDataAddrMode()) {
DisasmMulU();
} else {
DisasmIllegal();
}
} else {
/* MulS 1100ddd111mmmrrr */
if (IsValidDataAddrMode()) {
DisasmMulS();
} else {
DisasmIllegal();
}
}
} else {
if (Disasm_b8 == 0) {
/* And 1100ddd0ssmmmrrr */
if (IsValidDataAddrMode()) {
DisasmAndEaD();
} else {
DisasmIllegal();
}
} else {
if (Disasm_mode < 2) {
switch (Disasm_b76) {
case 0:
/* ABCD 1100ddd10000mrrr */
if (Disasm_mode == 0) {
DisasmAbcdr();
} else {
DisasmAbcdm();
}
break;
case 1:
/* Exg 1100ddd10100trrr */
if (Disasm_mode == 0) {
DisasmExgdd();
} else {
DisasmExgaa();
}
break;
case 2:
default: /* keep compiler happy */
if (Disasm_mode == 0) {
DisasmIllegal();
} else {
/* Exg 1100ddd110001rrr */
DisasmExgda();
}
break;
}
} else {
/* And 1100ddd1ssmmmrrr */
if (IsValidAltMemAddrMode()) {
DisasmAndDEa();
} else {
DisasmIllegal();
}
}
}
}
}
LOCALPROCUSEDONCE DisasmCodeD(void)
{
if (Disasm_b76 == 3) {
/* ADDA 1101dddm11mmmrrr */
if (IsValidAddrMode()) {
DisasmAddA();
} else {
DisasmIllegal();
}
} else {
if (Disasm_b8 == 0) {
/* ADD 1101ddd0ssmmmrrr */
if (IsValidAddrMode()) {
DisasmAddEaR();
} else {
DisasmIllegal();
}
} else {
if (Disasm_mode == 0) {
DisasmAddXd();
} else if (Disasm_mode == 1) {
DisasmAddXm();
} else {
/* ADD 1101ddd1ssmmmrrr */
if (IsValidAltMemAddrMode()) {
DisasmAddREa();
} else {
DisasmIllegal();
}
}
}
}
}
LOCALPROCUSEDONCE DisasmCodeE(void)
{
if (Disasm_b76 == 3) {
if ((Disasm_opcode & 0x0800) != 0) {
#if Use68020
/* 11101???11mmmrrr */
switch (Disasm_mode) {
case 1:
case 3:
case 4:
default: /* keep compiler happy */
DisasmIllegal();
break;
case 0:
case 2:
case 5:
case 6:
DisasmBitField();
break;
case 7:
switch (Disasm_reg) {
case 0:
case 1:
DisasmBitField();
break;
case 2:
case 3:
switch ((Disasm_opcode >> 8) & 7) {
case 0: /* BFTST */
case 1: /* BFEXTU */
case 3: /* BFEXTS */
case 5: /* BFFFO */
DisasmBitField();
break;
default:
DisasmIllegal();
break;
}
break;
default:
DisasmIllegal();
break;
}
break;
}
#else
DisasmIllegal();
#endif
} else {
/* 11100ttd11mmmddd */
if (IsValidAltMemAddrMode()) {
DisasmRolopNM();
} else {
DisasmIllegal();
}
}
} else {
if (Disasm_mode < 4) {
/* 1110cccdss0ttddd */
DisasmRolopND();
} else {
/* 1110rrrdss1ttddd */
DisasmRolopDD();
}
}
}
LOCALPROCUSEDONCE DisasmCodeF(void)
{
DisasmFLine();
}
LOCALPROC m68k_Disasm_one(void)
{
Disasm_opcode = Disasm_nextiword();
switch (Disasm_opcode >> 12) {
case 0x0:
DisasmCode0();
break;
case 0x1:
DisasmCode1();
break;
case 0x2:
DisasmCode2();
break;
case 0x3:
DisasmCode3();
break;
case 0x4:
DisasmCode4();
break;
case 0x5:
DisasmCode5();
break;
case 0x6:
DisasmCode6();
break;
case 0x7:
DisasmCode7();
break;
case 0x8:
DisasmCode8();
break;
case 0x9:
DisasmCode9();
break;
case 0xA:
DisasmCodeA();
break;
case 0xB:
DisasmCodeB();
break;
case 0xC:
DisasmCodeC();
break;
case 0xD:
DisasmCodeD();
break;
case 0xE:
DisasmCodeE();
break;
case 0xF:
default: /* keep compiler happy */
DisasmCodeF();
break;
}
}
#define Ln2SavedPCs 4
#define NumSavedPCs (1 << Ln2SavedPCs)
#define SavedPCsMask (NumSavedPCs - 1)
LOCALVAR ui5r SavedPCs[NumSavedPCs];
LOCALVAR ui5r SavedPCsIn = 0;
LOCALVAR ui5r SavedPCsOut = 0;
#define DisasmIncludeCycles 0
LOCALPROCUSEDONCE DisasmOneAndBack(ui5r pc)
{
#if DisasmIncludeCycles
dbglog_writeHex(GetCuriCount());
dbglog_writeCStr(" ");
#endif
dbglog_writeHex(pc);
dbglog_writeCStr(" ");
Disasm_setpc(pc);
m68k_Disasm_one();
}
LOCALPROCUSEDONCE DisasmSavedPCs(void)
{
ui5r n = SavedPCsIn - SavedPCsOut;
if (n != 0) {
ui5r pc;
#if DisasmIncludeCycles
ui5r i;
#endif
#if 0
blnr Skipped = falseblnr;
#endif
ui5r j = SavedPCsOut;
SavedPCsOut = SavedPCsIn;
/*
do first, prevent recursion
in case of error while disassembling.
(i.e. failure to read emulated memory.)
*/
#if DisasmIncludeCycles
i = GetCuriCount();
#endif
if (n > NumSavedPCs) {
n = NumSavedPCs;
j = SavedPCsIn - NumSavedPCs;
dbglog_writeReturn();
#if 0
Skipped = trueblnr;
#endif
}
do {
--n;
pc = SavedPCs[j & SavedPCsMask];
#if DisasmIncludeCycles
dbglog_writeHex(i /* - n */);
dbglog_writeCStr("-? ");
#endif
dbglog_writeHex(pc);
dbglog_writeCStr(" ");
Disasm_setpc(pc);
m68k_Disasm_one();
++j;
} while (n != 0);
#if 0
if (Skipped) {
si4b z;
for (z = 0; z < 16; ++z) {
if (z >= 8) {
dbglog_writeCStr(" A");
dbglog_writeHex(z - 8);
} else {
dbglog_writeCStr(" D");
dbglog_writeHex(z);
}
dbglog_writeCStr(" = ");
dbglog_writeHex(regs.regs[z]);
dbglog_writeReturn();
}
}
#endif
}
}
LOCALVAR ui5r DisasmCounter = 0;
GLOBALPROC DisasmOneOrSave(ui5r pc)
{
if (0 != DisasmCounter) {
DisasmOneAndBack(pc);
--DisasmCounter;
} else {
SavedPCs[SavedPCsIn & SavedPCsMask] = pc;
++SavedPCsIn;
}
}
GLOBALPROC m68k_WantDisasmContext(void)
{
DisasmSavedPCs();
DisasmCounter = /* 256 */ 128;
}