1014 lines
25 KiB
C++
1014 lines
25 KiB
C++
#define _XOPEN_SOURCE
|
|
|
|
#include "disassembler.h"
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <string>
|
|
#include <algorithm>
|
|
|
|
|
|
static constexpr const char opcodes[] =
|
|
"brkoracoporatsboraaslora"
|
|
"phporaaslphdtsboraaslora"
|
|
"bploraoraoratrboraaslora"
|
|
"clcorainctcstrboraaslora"
|
|
"jsrandjslandbitandroland"
|
|
"plpandrolpldbitandroland"
|
|
"bmiandandandbitandroland"
|
|
"secanddectscbitandroland"
|
|
"rtieorwdmeormvpeorlsreor"
|
|
"phaeorlsrphkjmpeorlsreor"
|
|
"bvceoreoreormvneorlsreor"
|
|
"clieorphytcdjmleorlsreor"
|
|
"rtsadcperadcstzadcroradc"
|
|
"plaadcrorrtljmpadcroradc"
|
|
"bvsadcadcadcstzadcroradc"
|
|
"seiadcplytdcjmpadcroradc"
|
|
"brastabrlstastystastxsta"
|
|
"deybittxaphbstystastxsta"
|
|
"bccstastastastystastxsta"
|
|
"tyastatxstxystzstastzsta"
|
|
"ldyldaldxldaldyldaldxlda"
|
|
"tayldataxplbldyldaldxlda"
|
|
"bcsldaldaldaldyldaldxlda"
|
|
"clvldatsxtyxldyldaldxlda"
|
|
"cpycmprepcmpcpycmpdeccmp"
|
|
"inycmpdexwaicpycmpdeccmp"
|
|
"bnecmpcmpcmppeicmpdeccmp"
|
|
"cldcmpphxstpjmlcmpdeccmp"
|
|
"cpxsbcsepsbccpxsbcincsbc"
|
|
"inxsbcnopxbacpxsbcincsbc"
|
|
"beqsbcsbcsbcpeasbcincsbc"
|
|
"sedsbcplxxcejsrsbcincsbc"
|
|
;
|
|
|
|
static constexpr const int mImplied = 0x0000;
|
|
static constexpr const int mImmediate = 0x1000;
|
|
static constexpr const int mAbsolute = 0x2000;
|
|
static constexpr const int mAbsoluteI = 0x3000;
|
|
static constexpr const int mAbsoluteIL = 0x4000;
|
|
static constexpr const int mAbsoluteLong = 0x5000;
|
|
static constexpr const int mDP = 0x6000;
|
|
static constexpr const int mDPI = 0x7000;
|
|
static constexpr const int mDPIL = 0x8000;
|
|
static constexpr const int mRelative = 0x9000;
|
|
static constexpr const int mBlockMove = 0xa000;
|
|
static constexpr const int mImpliedA = 0xb000; // inc a, dec a, etc.
|
|
|
|
static constexpr const int m_S = 0x0100;
|
|
static constexpr const int m_X = 0x0200;
|
|
static constexpr const int m_Y = 0x0400;
|
|
|
|
static constexpr const int m_M = 0x0020;
|
|
static constexpr const int m_I = 0x0010;
|
|
|
|
static constexpr const int modes[] =
|
|
{
|
|
1 | mAbsolute, // 00 brk #imm
|
|
1 | mDPI | m_X, // 01 ora (dp,x)
|
|
1 | mAbsolute, // 02 cop #imm
|
|
1 | mDP | m_S, // 03 ora ,s
|
|
1 | mDP, // 04 tsb <dp
|
|
1 | mDP, // 05 ora <dp
|
|
1 | mDP, // 06 asl <dp
|
|
1 | mDPIL, // 07 ora [dp]
|
|
0 | mImplied, // 08 php
|
|
1 | mImmediate | m_M, // 09 ora #imm
|
|
0 | mImpliedA, // 0a asl a
|
|
0 | mImplied, // 0b phd
|
|
2 | mAbsolute, // 0c tsb |abs
|
|
2 | mAbsolute, // 0d ora |abs
|
|
2 | mAbsolute, // 0e asl |abs
|
|
3 | mAbsoluteLong, // 0f ora >abs
|
|
|
|
1 | mRelative, // 10 bpl
|
|
1 | mDPI | m_Y, // 11 ora (dp),y
|
|
1 | mDPI, // 12 ora (dp)
|
|
1 | mDPI | m_S | m_Y, // 13 ora ,s,y
|
|
1 | mDP, // 14 trb <dp
|
|
1 | mDP | m_X, // 15 ora <dp,x
|
|
1 | mDP | m_X, // 16 asl <dp,x
|
|
1 | mDPIL | m_Y, // 17 ora [dp],y
|
|
0 | mImplied, // 18 clc
|
|
2 | mAbsolute | m_Y, // 19 ora |abs,y
|
|
0 | mImpliedA, // 1a inc a
|
|
0 | mImplied, // 1b tcs
|
|
2 | mAbsolute, // 1c trb |abs
|
|
2 | mAbsolute | m_X, // 1d ora |abs,x
|
|
2 | mAbsolute | m_X, // 1e asl |abs,x
|
|
3 | mAbsoluteLong | m_X, // 1f ora >abs,x
|
|
|
|
2 | mAbsolute, // 20 jsr |abs
|
|
1 | mDPI | m_X, // 21 and (dp,x)
|
|
3 | mAbsoluteLong, // 22 jsl >abs
|
|
1 | mDP | m_S, // 23 and ,s
|
|
1 | mDP, // 24 bit <dp
|
|
1 | mDP, // 25 and <dp
|
|
1 | mDP, // 26 rol <dp
|
|
1 | mDPIL, // 27 and [dp]
|
|
0 | mImplied, // 28 plp
|
|
1 | mImmediate | m_M, // 29 and #imm
|
|
0 | mImpliedA, // 2a rol a
|
|
0 | mImplied, // 2b pld
|
|
2 | mAbsolute, // 2c bit |abs
|
|
2 | mAbsolute, // 2d and |abs
|
|
2 | mAbsolute, // 2e rol |abs
|
|
3 | mAbsoluteLong, // 2f and >abs
|
|
|
|
1 | mRelative, // 30 bmi
|
|
1 | mDPI | m_Y, // 31 and (dp),y
|
|
1 | mDPI, // 32 and (dp)
|
|
1 | mDPI | m_S | m_Y, // 33 and ,s,y
|
|
1 | mDP | m_X, // 34 bit dp,x
|
|
1 | mDP | m_X, // 35 and dp,x
|
|
1 | mDP | m_X, // 36 rol <dp,x
|
|
1 | mDPIL | m_Y, // 37 and [dp],y
|
|
0 | mImplied, // 38 sec
|
|
2 | mAbsolute | m_Y, // 39 and |abs,y
|
|
0 | mImpliedA, // 3a dec a
|
|
0 | mImplied, // 3b tsc
|
|
2 | mAbsolute | m_X, // 3c bits |abs,x
|
|
2 | mAbsolute | m_X, // 3d and |abs,x
|
|
2 | mAbsolute | m_X, // 3e rol |abs,x
|
|
3 | mAbsoluteLong | m_X, // 3f and >abs,x
|
|
|
|
0 | mImplied, // 40 rti
|
|
1 | mDPI | m_X, // 41 eor (dp,x)
|
|
1 | mAbsolute, // 42 wdm #imm
|
|
1 | mDP | m_S, // 43 eor ,s
|
|
2 | mBlockMove, // 44 mvp x,x
|
|
1 | mDP, // 45 eor dp
|
|
1 | mDP, // 46 lsr dp
|
|
1 | mDPIL, // 47 eor [dp]
|
|
0 | mImplied, // 48 pha
|
|
1 | mImmediate | m_M, // 49 eor #imm
|
|
0 | mImpliedA, // 4a lsr a
|
|
0 | mImplied, // 4b phk
|
|
2 | mAbsolute, // 4c jmp |abs
|
|
2 | mAbsolute, // 4d eor |abs
|
|
2 | mAbsolute, // 4e lsr |abs
|
|
3 | mAbsoluteLong, // 4f eor >abs
|
|
|
|
1 | mRelative, // 50 bvc
|
|
1 | mDPI | m_Y, // 51 eor (dp),y
|
|
1 | mDPI, // 52 eor (dp)
|
|
1 | mDPI | m_S | m_Y, // 53 eor ,s,y
|
|
2 | mBlockMove, // 54 mvn x,x
|
|
1 | mDP | m_X, // 55 eor dp,x
|
|
1 | mDP | m_X, // 56 lsr dp,x
|
|
1 | mDPIL | m_Y, // 57 eor [dp],y
|
|
0 | mImplied, // 58 cli
|
|
2 | mAbsolute | m_Y, // 59 eor |abs,y
|
|
0 | mImplied, // 5a phy
|
|
0 | mImplied, // 5b tcd
|
|
3 | mAbsoluteLong, // 5c jml >abs
|
|
2 | mAbsolute | m_X, // 5d eor |abs,x
|
|
2 | mAbsolute | m_X, // 5e lsr |abs,x
|
|
3 | mAbsoluteLong | m_X, // 5f eor >abs,x
|
|
|
|
0 | mImplied, // 60 rts
|
|
1 | mDPI | m_X, // 61 adc (dp,x)
|
|
2 | mRelative, // 62 per |abs
|
|
1 | mDP | m_S, // 63 adc ,s
|
|
1 | mDP, // 64 stz <dp
|
|
1 | mDP, // 65 adc <dp
|
|
1 | mDP, // 66 ror <dp
|
|
1 | mDPIL, // 67 adc [dp]
|
|
0 | mImplied, // 68 pla
|
|
1 | mImmediate | m_M, // 69 adc #imm
|
|
0 | mImplied, // 6a ror a
|
|
0 | mImplied, // 6b rtl
|
|
2 | mAbsoluteI, // 6c jmp (abs)
|
|
2 | mAbsolute, // 6d adc |abs
|
|
2 | mAbsolute, // 6e ror |abs
|
|
3 | mAbsoluteLong, // 6f adc >abs
|
|
|
|
1 | mRelative, // 70 bvs
|
|
1 | mDPI | m_Y, // 71 adc (dp),y
|
|
1 | mDPI, // 72 adc (dp)
|
|
1 | mDPI | m_S | m_Y, // 73 adc ,s,y
|
|
1 | mDP | m_X, // 74 stz dp,x
|
|
1 | mDP | m_X, // 75 adc dp,x
|
|
1 | mDP | m_X, // 76 ror dp,x
|
|
1 | mDPIL | m_Y, // 77 adc [dp],y
|
|
0 | mImplied, // 78 sei
|
|
2 | mAbsolute | m_Y, // 79 adc |abs,y
|
|
0 | mImplied, // 7a ply
|
|
0 | mImplied, // 7b tdc
|
|
2 | mAbsoluteI | m_X, // 7c jmp (abs,x)
|
|
2 | mAbsolute | m_X, // 7d adc |abs,x
|
|
2 | mAbsolute | m_X, // 7e ror |abs,x
|
|
3 | mAbsoluteLong | m_X, // 7f adc >abs,x
|
|
|
|
1 | mRelative, // 80 bra
|
|
1 | mDPI | m_X, // 81 sta (dp,x)
|
|
2 | mRelative, // 82 brl |abs
|
|
1 | mDP | m_S, // 83 sta ,s
|
|
1 | mDP, // 84 sty <dp
|
|
1 | mDP, // 85 sta <dp
|
|
1 | mDP, // 86 stx <dp
|
|
1 | mDPIL, // 87 sta [dp]
|
|
0 | mImplied, // 88 dey
|
|
1 | mImmediate | m_M, // 89 bit #imm
|
|
0 | mImplied, // 8a txa
|
|
0 | mImplied, // 8b phb
|
|
2 | mAbsolute, // 8c sty |abs
|
|
2 | mAbsolute, // 8d sta |abs
|
|
2 | mAbsolute, // 8e stx |abs
|
|
3 | mAbsoluteLong, // 8f sta >abs
|
|
|
|
1 | mRelative, // 90 bcc
|
|
1 | mDPI | m_Y, // 91 sta (dp),y
|
|
1 | mDPI, // 92 sta (dp)
|
|
1 | mDPI | m_S | m_Y, // 93 sta ,s,y
|
|
1 | mDP | m_X, // 94 sty dp,x
|
|
1 | mDP | m_X, // 95 sta dp,x
|
|
1 | mDP | m_Y, // 96 stx dp,y
|
|
1 | mDPIL | m_Y, // 97 sta [dp],y
|
|
0 | mImplied, // 98 tya
|
|
2 | mAbsolute | m_Y, // 99 sta |abs,y
|
|
0 | mImplied, // 9a txs
|
|
0 | mImplied, // 9b txy
|
|
2 | mAbsolute, // 9c stz |abs
|
|
2 | mAbsolute | m_X, // 9d sta |abs,x
|
|
2 | mAbsolute | m_X, // 9e stz |abs,x
|
|
3 | mAbsoluteLong | m_X, // 9f sta >abs,x
|
|
|
|
1 | mImmediate | m_I, // a0 ldy #imm
|
|
1 | mDPI | m_X, // a1 lda (dp,x)
|
|
1 | mImmediate | m_I, // a2 ldx #imm
|
|
1 | mDP | m_S, // a3 lda ,s
|
|
1 | mDP, // a4 ldy <dp
|
|
1 | mDP, // a5 lda <dp
|
|
1 | mDP, // a6 ldx <dp
|
|
1 | mDPIL, // a7 lda [dp]
|
|
0 | mImplied, // a8 tay
|
|
1 | mImmediate | m_M, // a9 lda #imm
|
|
0 | mImplied, // aa tax
|
|
0 | mImplied, // ab plb
|
|
2 | mAbsolute, // ac ldy |abs
|
|
2 | mAbsolute, // ad lda |abs
|
|
2 | mAbsolute, // ae ldx |abs
|
|
3 | mAbsoluteLong, // af lda >abs
|
|
|
|
1 | mRelative, // b0 bcs
|
|
1 | mDPI | m_Y, // b1 lda (dp),y
|
|
1 | mDPI, // b2 lda (dp)
|
|
1 | mDPI | m_S | m_Y, // b3 lda ,s,y
|
|
1 | mDP | m_X, // b4 ldy <dp,x
|
|
1 | mDP | m_X, // b5 lda <dp,x
|
|
1 | mDP | m_Y, // b6 ldx <dp,y
|
|
1 | mDPIL | m_Y, // b7 lda [dp],y
|
|
0 | mImplied, // b8 clv
|
|
2 | mAbsolute | m_Y, // b9 lda |abs,y
|
|
0 | mImplied, // ba tsx
|
|
0 | mImplied, // bb tyx
|
|
2 | mAbsolute | m_X, // bc ldy |abs,x
|
|
2 | mAbsolute | m_X, // bd lda |abs,x
|
|
2 | mAbsolute | m_Y, // be ldx |abs,y
|
|
3 | mAbsoluteLong | m_X, // bf lda >abs,x
|
|
|
|
1 | mImmediate | m_I, // c0 cpy #imm
|
|
1 | mDPI | m_X, // c1 cmp (dp,x)
|
|
1 | mImmediate, // c2 rep #
|
|
1 | mDP | m_S, // c3 cmp ,s
|
|
1 | mDP, // c4 cpy <dp
|
|
1 | mDP, // c5 cmp <dp
|
|
1 | mDP, // c6 dec <dp
|
|
1 | mDPIL, // c7 cmp [dp]
|
|
0 | mImplied, // c8 iny
|
|
1 | mImmediate | m_M, // c9 cmp #imm
|
|
0 | mImplied, // ca dex
|
|
0 | mImplied, // cb WAI
|
|
2 | mAbsolute, // cc cpy |abs
|
|
2 | mAbsolute, // cd cmp |abs
|
|
2 | mAbsolute, // ce dec |abs
|
|
3 | mAbsoluteLong, // cf cmp >abs
|
|
|
|
1 | mRelative, // d0 bne
|
|
1 | mDPI | m_Y, // d1 cmp (dp),y
|
|
1 | mDPI, // d2 cmp (dp)
|
|
1 | mDPI | m_S | m_Y, // d3 cmp ,s,y
|
|
1 | mDP, // d4 pei (dp) --> pei <dp
|
|
1 | mDP | m_X, // d5 cmp dp,x
|
|
1 | mDP | m_X, // d6 dec dp,x
|
|
1 | mDPIL | m_Y, // d7 cmp [dp],y
|
|
0 | mImplied, // d8 cld
|
|
2 | mAbsolute | m_Y, // d9 cmp |abs,y
|
|
0 | mImplied, // da phx
|
|
0 | mImplied, // db stp
|
|
2 | mAbsoluteIL, // dc jml [abs]
|
|
2 | mAbsolute | m_X, // dd cmp |abs,x
|
|
2 | mAbsolute | m_X, // de dec |abs,x
|
|
3 | mAbsoluteLong | m_X, // df cmp >abs,x
|
|
|
|
1 | mImmediate | m_I, // e0 cpx #imm
|
|
1 | mDPI | m_X, // e1 sbc (dp,x)
|
|
1 | mImmediate, // e2 sep #imm
|
|
1 | mDP | m_S, // e3 sbc ,s
|
|
1 | mDP, // e4 cpx <dp
|
|
1 | mDP, // e5 sbc <dp
|
|
1 | mDP, // e6 inc <dp
|
|
1 | mDPIL, // e7 sbc [dp]
|
|
0 | mImplied, // e8 inx
|
|
1 | mImmediate| m_M, // e9 sbc #imm
|
|
0 | mImplied, // ea nop
|
|
0 | mImplied, // eb xba
|
|
2 | mAbsolute, // ec cpx |abs
|
|
2 | mAbsolute, // ed abc |abs
|
|
2 | mAbsolute, // ee inc |abs
|
|
3 | mAbsoluteLong, // ef sbc >abs
|
|
|
|
1 | mRelative, // f0 beq
|
|
1 | mDPI | m_Y, // f1 sbc (dp),y
|
|
1 | mDPI, // f2 sbc (dp)
|
|
1 | mDPI | m_S | m_Y, // f3 sbc ,s,y
|
|
2 | mAbsolute, // f4 pea |abs --> pea #imm
|
|
1 | mDP | m_X, // f5 sbc dp,x
|
|
1 | mDP | m_X, // f6 inc dp,x
|
|
1 | mDPIL | m_Y, // f7 sbc [dp],y
|
|
0 | mImplied, // f8 sed
|
|
2 | mAbsolute | m_Y, // f9 sbc |abs,y
|
|
0 | mImplied, // fa plx
|
|
0 | mImplied, // fb xce
|
|
2 | mAbsoluteI | m_X, // fc jsr (abs,x)
|
|
2 | mAbsolute | m_X, // fd sbc |abs,x
|
|
2 | mAbsolute | m_X, // fe inc |abs,x
|
|
3 | mAbsoluteLong | m_X, // ff sbc >abs,x
|
|
|
|
};
|
|
|
|
static bool branchlike(uint8_t op) {
|
|
|
|
switch(op) {
|
|
case 0x10: // bpl
|
|
//case 0x20: // jsr
|
|
//case 0x22: // jsl
|
|
case 0x30: // bmi
|
|
case 0x40: // rti
|
|
case 0x4c: // jmp
|
|
case 0x50: // bvc
|
|
case 0x5c: // jml
|
|
case 0x60: // rts
|
|
case 0x6b: // rtl
|
|
case 0x6c: // jmp
|
|
case 0x70: // bvs
|
|
case 0x7c: // jmp
|
|
case 0x80: // bra
|
|
case 0x82: // brl
|
|
case 0x90: // bcc
|
|
case 0xb0: // bcs
|
|
case 0xd0: // bne
|
|
case 0xdc: // jml
|
|
case 0xf0: // beq
|
|
//case 0xfc: // jsr
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
constexpr const int kOpcodeTab = 20;
|
|
constexpr const int kOperandTab = 30;
|
|
constexpr const int kCommentTab = 80;
|
|
|
|
|
|
void indent_to(std::string &line, unsigned position) {
|
|
if (line.length() < position)
|
|
line.resize(position, ' ');
|
|
}
|
|
|
|
|
|
disassembler::~disassembler() {
|
|
}
|
|
|
|
std::string disassembler::to_x(uint32_t x, unsigned bytes, char prefix) {
|
|
std::string s;
|
|
char buffer[16];
|
|
if (prefix) s.push_back(prefix);
|
|
|
|
if (x > 0xff && bytes < 4) bytes = 4;
|
|
if (x > 0xffff && bytes < 6) bytes = 6;
|
|
if (x > 0xffffff && bytes < 8) bytes = 8;
|
|
|
|
memset(buffer, '0', sizeof(buffer));
|
|
int i = 16;
|
|
while (x) {
|
|
buffer[--i] = "0123456789abcdef"[x & 0x0f];
|
|
x >>= 4;
|
|
}
|
|
|
|
s.append(buffer + 16 - bytes, buffer + 16);
|
|
|
|
return s;
|
|
}
|
|
|
|
int disassembler::operand_size(uint8_t op, bool m, bool x) {
|
|
unsigned mode = modes[op];
|
|
unsigned size = mode & 0x0f;
|
|
if ((mode & m_I) && x) size++;
|
|
if ((mode & m_M) && m) size++;
|
|
return size;
|
|
}
|
|
|
|
|
|
|
|
void disassembler::emit(const std::string &label) {
|
|
fputs(label.c_str(), stdout);
|
|
fputc('\n', stdout);
|
|
}
|
|
|
|
void disassembler::emit(const std::string &label, const std::string &opcode) {
|
|
std::string tmp;
|
|
tmp = label;
|
|
|
|
if (!opcode.empty()) {
|
|
indent_to(tmp, kOpcodeTab);
|
|
tmp += opcode;
|
|
}
|
|
|
|
tmp.push_back('\n');
|
|
fputs(tmp.c_str(), stdout);
|
|
}
|
|
|
|
|
|
|
|
void disassembler::emit(const std::string &label, const std::string &opcode, const std::string &operand) {
|
|
|
|
std::string tmp;
|
|
tmp = label;
|
|
|
|
|
|
if (!opcode.empty()) {
|
|
indent_to(tmp, kOpcodeTab);
|
|
tmp += opcode;
|
|
}
|
|
|
|
if (!operand.empty()) {
|
|
indent_to(tmp, kOperandTab);
|
|
tmp += operand;
|
|
}
|
|
|
|
tmp.push_back('\n');
|
|
fputs(tmp.c_str(), stdout);
|
|
}
|
|
|
|
|
|
void disassembler::emit(const std::string &label, const std::string &opcode, const std::string &operand, const std::string &comment) {
|
|
|
|
std::string tmp;
|
|
tmp = label;
|
|
|
|
if (!opcode.empty()) {
|
|
indent_to(tmp, kOpcodeTab);
|
|
tmp += opcode;
|
|
}
|
|
|
|
if (!operand.empty()) {
|
|
indent_to(tmp, kOperandTab);
|
|
tmp += operand;
|
|
}
|
|
|
|
if (!comment.empty()) {
|
|
indent_to(tmp, kCommentTab);
|
|
tmp += "; ";
|
|
tmp += comment;
|
|
}
|
|
|
|
tmp.push_back('\n');
|
|
fputs(tmp.c_str(), stdout);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void disassembler::reset() {
|
|
_arg = 0;
|
|
_st = 0;
|
|
}
|
|
|
|
|
|
std::pair<std::string, std::string>
|
|
disassembler::format_data(unsigned size, const uint8_t *data) {
|
|
|
|
std::string tmp;
|
|
|
|
for (unsigned i = 0; i < size; ++i) {
|
|
if (i > 0) tmp += ", ";
|
|
tmp += to_x(data[i], 2, '$');
|
|
}
|
|
|
|
return std::make_pair("db", tmp);
|
|
}
|
|
|
|
std::pair<std::string, std::string>
|
|
disassembler::format_data(unsigned size, const std::string &data) {
|
|
|
|
switch(size) {
|
|
case 1: return std::make_pair("db", data);
|
|
case 2: return std::make_pair("dw", data);
|
|
case 3: return std::make_pair("da", data);
|
|
case 4: return std::make_pair("dl", data);
|
|
|
|
default: {
|
|
std::string tmp;
|
|
tmp = std::to_string(size) + " bytes";
|
|
return std::make_pair(tmp, data);
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
void disassembler::dump() {
|
|
|
|
std::string line;
|
|
|
|
if (!_st) return;
|
|
|
|
|
|
auto p = format_data(_st, _bytes);
|
|
|
|
indent_to(line, kOpcodeTab);
|
|
line += p.first;
|
|
indent_to(line, kOperandTab);
|
|
line += p.second;
|
|
|
|
hexdump(line);
|
|
line.push_back('\n');
|
|
fputs(line.c_str(), stdout);
|
|
|
|
_pc += _st;
|
|
reset();
|
|
}
|
|
|
|
void disassembler::dump(const std::string &expr, unsigned size, uint32_t value) {
|
|
|
|
std::string line;
|
|
|
|
if (_st) dump();
|
|
|
|
for (_st = 0; _st < size; ++_st) {
|
|
_bytes[_st] = value & 0xff;
|
|
value >>= 8;
|
|
}
|
|
|
|
auto p = format_data(size, expr);
|
|
|
|
indent_to(line, kOpcodeTab);
|
|
line += p.first;
|
|
indent_to(line, kOperandTab);
|
|
line += p.second;
|
|
|
|
hexdump(line);
|
|
line.push_back('\n');
|
|
fputs(line.c_str(), stdout);
|
|
|
|
_pc += _st;
|
|
reset();
|
|
}
|
|
|
|
void disassembler::flush() {
|
|
if (_st) dump();
|
|
check_labels();
|
|
}
|
|
|
|
|
|
void disassembler::check_labels() {
|
|
|
|
if ( _next_label >= 0 && _pc + _st >= _next_label) {
|
|
//flush(); // -- too recursive. see above.
|
|
if (_st) dump();
|
|
_next_label = next_label(_pc);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
void disassembler::space(unsigned size) {
|
|
flush();
|
|
|
|
std::string line;
|
|
|
|
indent_to(line, kOpcodeTab);
|
|
line += ds();
|
|
indent_to(line, kOperandTab);
|
|
|
|
|
|
while (size) {
|
|
uint32_t chunk;
|
|
if (_next_label == -1) chunk = size;
|
|
else {
|
|
chunk = _next_label - _pc;
|
|
chunk = std::min(chunk, size);
|
|
}
|
|
|
|
line.resize(kOperandTab);
|
|
line += std::to_string(chunk);
|
|
indent_to(line, kCommentTab);
|
|
line += "; ";
|
|
|
|
line += to_x(_pc, 4);
|
|
line.push_back(':');
|
|
line.push_back('\n');
|
|
fputs(line.c_str(), stdout);
|
|
|
|
|
|
_pc += chunk;
|
|
size -= chunk;
|
|
if (_next_label == _pc) _next_label = next_label(_pc);
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
void disassembler::operator()(const std::string &expr, unsigned size, uint32_t value) {
|
|
|
|
if (_st == 0 || !_code)
|
|
check_labels();
|
|
|
|
if (!_code) {
|
|
dump(expr, size, value);
|
|
if (_inline_data) {
|
|
_inline_data -= size;
|
|
if (_inline_data <= 0) _code = true;
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (_st != 1 || size != _size) {
|
|
dump(expr, size, value);
|
|
return;
|
|
}
|
|
for (int i = 0; i < size; ++i) {
|
|
_bytes[_st++] = value & 0xff;
|
|
value >>= 8;
|
|
}
|
|
print(expr);
|
|
}
|
|
|
|
|
|
|
|
void disassembler::operator()(uint8_t byte) {
|
|
|
|
if (_st == 0 || !_code)
|
|
check_labels();
|
|
|
|
if (!_code) {
|
|
_bytes[_st++] = byte;
|
|
|
|
if (_inline_data && --_inline_data <= 0) {
|
|
dump();
|
|
_code = true;
|
|
return;
|
|
}
|
|
|
|
if (_st == 4) dump();
|
|
return;
|
|
}
|
|
|
|
_bytes[_st++] = byte;
|
|
if (_st == 1) {
|
|
_op = byte;
|
|
_mode = modes[_op];
|
|
|
|
// bit hack
|
|
if (_traits & bit_hacks && _op == 0x2c) {
|
|
if (_next_label == _pc + 1) {
|
|
dump();
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (_traits & pea_immediate && _op == 0xf4) _mode = 2 | mImmediate;
|
|
_size = _mode & 0x0f;
|
|
if (_mode & _flags & m_I) _size++;
|
|
if (_mode & _flags & m_M) _size++;
|
|
|
|
if (!_size) {
|
|
print();
|
|
|
|
if (branchlike(byte)) fputs("\n", stdout);
|
|
}
|
|
return;
|
|
}
|
|
unsigned shift = (_st - 2) * 8;
|
|
_arg = _arg + (byte << shift);
|
|
if (_st <= _size) return;
|
|
|
|
uint8_t op = _op;
|
|
uint32_t arg = _arg;
|
|
|
|
if (_traits & track_rep_sep) {
|
|
switch(_op) {
|
|
case 0xc2: // REP
|
|
_flags |= (_arg & 0x30);
|
|
break;
|
|
case 0xe2: // SEP
|
|
_flags &= ~(_arg & 0x30);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// all done... now print it.
|
|
print();
|
|
|
|
if (branchlike(op)) fputs("\n", stdout);
|
|
|
|
// todo -- subscribe to before/after events...
|
|
switch(op) {
|
|
case 0xc2:
|
|
case 0xe2:
|
|
case 0x22:
|
|
case 0x5c:
|
|
case 0xdc:
|
|
event(op, arg);
|
|
break;
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
std::string disassembler::prefix() {
|
|
|
|
std::string tmp;
|
|
|
|
switch(_mode & 0xf000) {
|
|
case mImmediate: tmp = "#"; break;
|
|
case mDP: tmp = "<"; break;
|
|
case mDPI: tmp = "(<"; break;
|
|
case mDPIL: tmp = "[<"; break;
|
|
case mAbsoluteIL: tmp = "["; break;
|
|
|
|
case mRelative:
|
|
case mBlockMove:
|
|
break;
|
|
|
|
// cop, brk are treated as absolute.
|
|
case mAbsolute:
|
|
//if (_size == 1) printf("\t");
|
|
if (_size > 1) tmp = "|";
|
|
break;
|
|
case mAbsoluteLong: tmp = ">"; break;
|
|
case mAbsoluteI: tmp = "("; break;
|
|
}
|
|
return tmp;
|
|
}
|
|
|
|
|
|
|
|
std::string disassembler::suffix() {
|
|
|
|
std::string tmp;
|
|
|
|
switch(_mode & 0x0f00) {
|
|
case m_X: tmp = ",x"; break;
|
|
case m_Y: if (!(_mode & (mDPI|mDPIL))) tmp = ",y"; break;
|
|
case m_S:
|
|
case m_S | m_Y:
|
|
tmp = ",s"; break;
|
|
}
|
|
|
|
switch(_mode & 0xf000) {
|
|
case mAbsoluteI:
|
|
case mDPI:
|
|
tmp += ")"; break;
|
|
case mAbsoluteIL:
|
|
case mDPIL:
|
|
tmp += "]"; break;
|
|
}
|
|
|
|
// (xxx,s),y
|
|
// (xxx),y
|
|
// [xxx],y
|
|
switch(_mode & 0x0f00) {
|
|
case m_Y:
|
|
if (_mode & (mDPI|mDPIL)) tmp += ",y"; break;
|
|
case m_S | m_Y:
|
|
tmp += ",y"; break;
|
|
}
|
|
return tmp;
|
|
|
|
}
|
|
|
|
|
|
void disassembler::hexdump(std::string &line) {
|
|
// print pc and hexdump...
|
|
|
|
indent_to(line, kCommentTab);
|
|
line += "; ";
|
|
|
|
line += to_x(_pc, 4);
|
|
line.push_back(':');
|
|
|
|
int i;
|
|
for (i = 0; i < _st; ++i) {
|
|
line.push_back(' ');
|
|
line += to_x(_bytes[i], 2);
|
|
}
|
|
for ( ; i < 4; ++i) {
|
|
line += " ";
|
|
}
|
|
line += " ";
|
|
for (i = 0; i < _st; ++i) {
|
|
uint8_t c = _bytes[i];
|
|
// msb flag?
|
|
if (_traits & msb_hexdump) c &= 0x7f;
|
|
if (isprint(c) && isascii(c)) line += c;
|
|
else line += '.';
|
|
}
|
|
}
|
|
|
|
|
|
std::string disassembler::label_for_address(uint32_t address) { return ""; }
|
|
std::string disassembler::label_for_zp(uint32_t address) { return ""; }
|
|
|
|
void disassembler::print() {
|
|
|
|
|
|
if (_size) {
|
|
std::string tmp;
|
|
|
|
switch(_mode & 0xf000) {
|
|
case mRelative: {
|
|
|
|
uint32_t pc = _pc + 1 + _size + _arg;
|
|
|
|
if ((_size == 1) && (_arg & 0x80))
|
|
pc += 0xff00;
|
|
pc &= 0xffff;
|
|
|
|
|
|
// it would be really fancy if it checked for a label name @pc...
|
|
tmp = label_for_address(pc);
|
|
if (tmp.empty()) tmp = to_x(pc, 4, '$');
|
|
break;
|
|
}
|
|
case mBlockMove: {
|
|
// todo -- verify order.
|
|
tmp = to_x((_arg >> 8) & 0xff, 2, '$')
|
|
+ ","
|
|
+ to_x((_arg >> 0) & 0xff, 2, '$');
|
|
break;
|
|
}
|
|
case mDP:
|
|
case mDPI:
|
|
case mDPIL:
|
|
tmp = label_for_zp(_arg);
|
|
if (tmp.empty()) tmp = to_x(_arg, _size * 2, '$');
|
|
break;
|
|
|
|
//case mImmediate:
|
|
case mAbsolute:
|
|
case mAbsoluteI:
|
|
case mAbsoluteIL:
|
|
case mAbsoluteLong:
|
|
tmp = label_for_address(_arg);
|
|
if (tmp.empty()) tmp = to_x(_arg, _size * 2, '$');
|
|
break;
|
|
|
|
default:
|
|
tmp = to_x(_arg, _size * 2, '$');
|
|
break;
|
|
}
|
|
print(tmp);
|
|
return;
|
|
|
|
}
|
|
|
|
std::string line;
|
|
|
|
|
|
|
|
|
|
indent_to(line, kOpcodeTab);
|
|
line.append(&opcodes[_op * 3], 3);
|
|
|
|
if (_mode == mImpliedA && (_traits & explicit_implied_a)) {
|
|
indent_to(line, kOperandTab);
|
|
line.append("a");
|
|
}
|
|
|
|
|
|
hexdump(line);
|
|
line.push_back('\n');
|
|
fputs(line.c_str(), stdout);
|
|
_pc += _size + 1;
|
|
reset();
|
|
}
|
|
|
|
void disassembler::print(const std::string &expr) {
|
|
|
|
|
|
std::string line;
|
|
|
|
indent_to(line, kOpcodeTab);
|
|
line.append(&opcodes[_op * 3], 3);
|
|
|
|
if (_size) {
|
|
|
|
indent_to(line, kOperandTab);
|
|
line += prefix();
|
|
line += expr;
|
|
line += suffix();
|
|
}
|
|
|
|
hexdump(line);
|
|
line.push_back('\n');
|
|
fputs(line.c_str(), stdout);
|
|
|
|
_pc += _size + 1;
|
|
reset();
|
|
}
|
|
|
|
|
|
#pragma mark -
|
|
|
|
const std::vector<uint32_t> &analyzer::finish() {
|
|
std::sort(_labels.begin(), _labels.end());
|
|
auto end = std::unique(_labels.begin(), _labels.end());
|
|
_labels.erase(end, _labels.end());
|
|
return _labels;
|
|
}
|
|
|
|
|
|
void analyzer::operator()(uint8_t byte) {
|
|
|
|
|
|
if (!_code) {
|
|
|
|
if (_inline_data && --_inline_data <= 0) {
|
|
_code = true;
|
|
reset();
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
|
|
_st++;
|
|
if (_st == 1) {
|
|
_op = byte;
|
|
_mode = modes[_op];
|
|
|
|
_size = _mode & 0x0f;
|
|
if (_mode & _flags & m_I) _size++;
|
|
if (_mode & _flags & m_M) _size++;
|
|
|
|
if (!_size) { reset(); }
|
|
return;
|
|
}
|
|
unsigned shift = (_st - 2) * 8;
|
|
_arg = _arg + (byte << shift);
|
|
if (_st <= _size) return;
|
|
|
|
|
|
// all done... now process it
|
|
process();
|
|
}
|
|
|
|
void analyzer::reset() {
|
|
_pc += _st;
|
|
_arg = 0;
|
|
_st = 0;
|
|
}
|
|
|
|
void analyzer::process() {
|
|
|
|
if (_traits & disassembler::track_rep_sep) {
|
|
switch(_op) {
|
|
case 0xc2: // REP
|
|
_flags |= (_arg & 0x30);
|
|
break;
|
|
case 0xe2: // SEP
|
|
_flags &= ~(_arg & 0x30);
|
|
break;
|
|
}
|
|
}
|
|
|
|
switch (_mode & 0xf000) {
|
|
case mRelative: {
|
|
|
|
uint32_t pc = _pc + 1 + _size + _arg;
|
|
|
|
if ((_size == 1) && (_arg & 0x80))
|
|
pc += 0xff00;
|
|
pc &= 0xffff;
|
|
|
|
_labels.push_back(pc);
|
|
break;
|
|
}
|
|
case mAbsolute:
|
|
case mAbsoluteI:
|
|
case mAbsoluteLong: {
|
|
_labels.push_back(_arg);
|
|
break;
|
|
}
|
|
}
|
|
reset();
|
|
}
|