Mercurial > vba-clojure

comparison src/gb/gbDis.cpp @ 1:f9f4f1b99eed

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
importing src directory
author Robert McIntyre <rlm@mit.edu>
date Sat, 03 Mar 2012 10:31:27 -0600
parents
children
comparison
equal deleted inserted replaced
0:8ced16adf2e1 1:f9f4f1b99eed
1 #include <cstdio>
2 #include <cstring>
3
4 #include "gbGlobals.h"
5
6 typedef struct
7 {
8 u8 mask;
9 u8 value;
10 char *mnen;
11 } GBOPCODE;
12
13 static char *registers[] =
14 { "B", "C", "D", "E", "H", "L", "(HL)", "A" };
15
16 static char *registers16[] =
17 { "BC", "DE", "HL", "SP", // for some operations
18 "BC", "DE", "HL", "AF" }; // for push/pop
19
20 static char *cond[] =
21 { "NZ", "Z", "NC", "C" };
22
23 static char hexDigits[16] = {
24 '0', '1', '2', '3', '4', '5', '6', '7',
25 '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
26 };
27
28 static GBOPCODE opcodes[] = {
29 { 0xff, 0x00, "NOP" },
30 { 0xcf, 0x01, "LD %R4,%W" },
31 { 0xff, 0x02, "LD (BC),A" },
32 { 0xcf, 0x03, "INC %R4" },
33 { 0xc7, 0x04, "INC %r3" },
34 { 0xc7, 0x05, "DEC %r3" },
35 { 0xc7, 0x06, "LD %r3,%B" },
36 { 0xff, 0x07, "RLCA" },
37 { 0xff, 0x08, "LD (%W),SP" },
38 { 0xcf, 0x09, "ADD HL,%R4" },
39 { 0xff, 0x0a, "LD A,(BC)" },
40 { 0xcf, 0x0b, "DEC %R4" },
41 { 0xff, 0x0f, "RRCA" },
42 { 0xff, 0x10, "STOP" },
43 { 0xff, 0x12, "LD (DE),A" },
44 { 0xff, 0x17, "RLA" },
45 { 0xff, 0x18, "JR %d" },
46 { 0xff, 0x1a, "LD A,(DE)" },
47 { 0xff, 0x1f, "RRA" },
48 { 0xe7, 0x20, "JR %c3,%d" },
49 { 0xff, 0x22, "LDI (HL),A" },
50 { 0xff, 0x27, "DAA" },
51 { 0xff, 0x2a, "LDI A,(HL)" },
52 { 0xff, 0x2f, "CPL" },
53 { 0xff, 0x32, "LDD (HL),A" },
54 { 0xff, 0x37, "SCF" },
55 { 0xff, 0x3a, "LDD A,(HL)" },
56 { 0xff, 0x3f, "CCF" },
57 { 0xff, 0x76, "HALT" },
58 { 0xc0, 0x40, "LD %r3,%r0" },
59 { 0xf8, 0x80, "ADD A,%r0" },
60 { 0xf8, 0x88, "ADC A,%r0" },
61 { 0xf8, 0x90, "SUB %r0" },
62 { 0xf8, 0x98, "SBC A,%r0" },
63 { 0xf8, 0xa0, "AND %r0" },
64 { 0xf8, 0xa8, "XOR %r0" },
65 { 0xf8, 0xb0, "OR %r0" },
66 { 0xf8, 0xb8, "CP %r0" },
67 { 0xe7, 0xc0, "RET %c3" },
68 { 0xcf, 0xc1, "POP %t4" },
69 { 0xe7, 0xc2, "JP %c3,%W" },
70 { 0xff, 0xc3, "JP %W" },
71 { 0xe7, 0xc4, "CALL %c3,%W" },
72 { 0xcf, 0xc5, "PUSH %t4" },
73 { 0xff, 0xc6, "ADD A,%B" },
74 { 0xc7, 0xc7, "RST %P" },
75 { 0xff, 0xc9, "RET" },
76 { 0xff, 0xcd, "CALL %W" },
77 { 0xff, 0xce, "ADC %B" },
78 { 0xff, 0xd6, "SUB %B" },
79 { 0xff, 0xd9, "RETI" },
80 { 0xff, 0xde, "SBC %B" },
81 { 0xff, 0xe0, "LD (FF%B),A" },
82 { 0xff, 0xe2, "LD (FF00h+C),A" },
83 { 0xff, 0xe6, "AND %B" },
84 { 0xff, 0xe8, "ADD SP,%D" },
85 { 0xff, 0xe9, "LD PC,HL" },
86 { 0xff, 0xea, "LD (%W),A" },
87 { 0xff, 0xee, "XOR %B" },
88 { 0xff, 0xf0, "LD A,(FF%B)" },
89 { 0xff, 0xf2, "LD A,(FF00h+C)" },
90 { 0xff, 0xf3, "DI" },
91 { 0xff, 0xf6, "OR %B" },
92 { 0xff, 0xf8, "LD HL,SP%D" },
93 { 0xff, 0xf9, "LD SP,HL" },
94 { 0xff, 0xfa, "LD A,(%W)" },
95 { 0xff, 0xfb, "EI" },
96 { 0xff, 0xfe, "CP %B" },
97 { 0x00, 0x00, "DB %B" }
98 };
99
100 static GBOPCODE cbOpcodes[] = {
101 { 0xf8, 0x00, "RLC %r0" },
102 { 0xf8, 0x08, "RRC %r0" },
103 { 0xf8, 0x10, "RL %r0" },
104 { 0xf8, 0x18, "RR %r0" },
105 { 0xf8, 0x20, "SLA %r0" },
106 { 0xf8, 0x28, "SRA %r0" },
107 { 0xf8, 0x30, "SWAP %r0" },
108 { 0xf8, 0x38, "SRL %r0" },
109 { 0xc0, 0x40, "BIT %b,%r0" },
110 { 0xc0, 0x80, "RES %b,%r0" },
111 { 0xc0, 0xc0, "SET %b,%r0" },
112 { 0x00, 0x00, "DB CBh,%B" }
113 };
114
115 static char *addHex(char *p, u8 value)
116 {
117 *p++ = hexDigits[value >> 4];
118 *p++ = hexDigits[value & 15];
119 return p;
120 }
121
122 static char *addHex16(char *p, u16 value)
123 {
124 p = addHex(p, value>>8);
125 return addHex(p, value & 255);
126 }
127
128 static char *addStr(char *p, char *s)
129 {
130 while (*s)
131 {
132 *p++ = *s++;
133 }
134 return p;
135 }
136
137 int gbDis(char *buffer, u16 address)
138 {
139 char *p = buffer;
140 int instr = 1;
141 u16 addr = address;
142 sprintf(p, "%04x ", address);
143 p += 12;
144
145 u8 opcode = gbReadMemoryQuick(address);
146 address++;
147 char * mnen;
148 GBOPCODE *op;
149 if (opcode == 0xcb)
150 {
151 opcode = gbReadMemoryQuick(address);
152 address++;
153 instr++;
154 op = cbOpcodes;
155 }
156 else
157 {
158 op = opcodes;
159 }
160 while (op->value != (opcode & op->mask))
161 op++;
162 mnen = op->mnen;
163
164 u8 b0, b1;
165 s8 disp;
166 int shift;
167
168 while (*mnen)
169 {
170 if (*mnen == '%')
171 {
172 mnen++;
173 switch (*mnen++)
174 {
175 case 'W':
176 b0 = gbReadMemoryQuick(address);
177 address++;
178 b1 = gbReadMemoryQuick(address);
179 address++;
180 p = addHex16(p, b0|b1<<8);
181 instr += 2;
182 *p++ = 'h';
183 break;
184 case 'B':
185 p = addHex(p, gbReadMemoryQuick(address));
186 *p++ = 'h';
187 address++;
188 instr++;
189 break;
190 case 'D':
191 disp = gbReadMemoryQuick(address);
192 if (disp >= 0)
193 *p++ = '+';
194 p += sprintf(p, "%d", disp);
195 instr++;
196 break;
197 case 'd':
198 disp = gbReadMemoryQuick(address);
199 address++;
200 p = addHex16(p, address+disp);
201 *p++ = 'h';
202 instr++;
203 break;
204 case 'b':
205 // kind of a hack, but it works :-)
206 *p++ = hexDigits[(opcode >> 3) & 7];
207 break;
208 case 'r':
209 shift = *mnen++ - '0';
210 p = addStr(p, registers[(opcode >> shift) & 7]);
211 break;
212 case 'R':
213 shift = *mnen++ - '0';
214 p = addStr(p, registers16[(opcode >> shift) & 3]);
215 break;
216 case 't':
217 shift = *mnen++ - '0';
218 p = addStr(p, registers16[4+((opcode >> shift) & 3)]);
219 break;
220 case 'P':
221 p = addHex(p, ((opcode >> 3) & 7) * 8);
222 break;
223 case 'c':
224 shift = *mnen++ - '0';
225 p = addStr(p, cond[(opcode >> shift) & 3]);
226 break;
227 }
228 }
229 else
230 *p++ = *mnen++;
231 }
232 for (int i = 0; i < instr; i++)
233 {
234 u16 a = addr + i;
235 addHex(buffer+5+i*2, gbReadMemoryQuick(a));
236 }
237 *p = 0;
238 return instr;
239 }