main
z80inst.c
1/*
2 Copyright 2013 Michael Pavone
3 This file is part of BlastEm.
4 BlastEm is free software distributed under the terms of the GNU General Public License version 3 or greater. See COPYING for full license text.
5*/
6#include "z80inst.h"
7#include <string.h>
8#include <stdio.h>
9#include <stddef.h>
10
11#define NOP {Z80_NOP, Z80_UNUSED, Z80_UNUSED, Z80_UNUSED, 0}
12#define USE_MAIN {Z80_USE_MAIN, Z80_UNUSED, Z80_UNUSED, Z80_UNUSED, 0}
13
14z80inst z80_tbl_a[256] = {
15 //0
16 NOP,
17 {Z80_LD, Z80_BC, Z80_IMMED, Z80_UNUSED, 0},
18 {Z80_LD, Z80_A, Z80_REG_INDIRECT | Z80_DIR, Z80_BC, 0},
19 {Z80_INC, Z80_BC, Z80_UNUSED, Z80_UNUSED, 0},
20 {Z80_INC, Z80_B, Z80_UNUSED, Z80_UNUSED, 0},
21 {Z80_DEC, Z80_B, Z80_UNUSED, Z80_UNUSED, 0},
22 {Z80_LD, Z80_B, Z80_IMMED, Z80_UNUSED, 0},
23 {Z80_RLC, Z80_A, Z80_UNUSED, Z80_UNUSED, 0},
24 {Z80_EX, Z80_AF, Z80_REG, Z80_AF, 0},
25 {Z80_ADD, Z80_HL, Z80_REG, Z80_BC, 0},
26 {Z80_LD, Z80_A, Z80_REG_INDIRECT, Z80_BC, 0},
27 {Z80_DEC, Z80_BC, Z80_UNUSED, Z80_UNUSED, 0},
28 {Z80_INC, Z80_C, Z80_UNUSED, Z80_UNUSED, 0},
29 {Z80_DEC, Z80_C, Z80_UNUSED, Z80_UNUSED, 0},
30 {Z80_LD, Z80_C, Z80_IMMED, Z80_UNUSED, 0},
31 {Z80_RRC, Z80_A, Z80_UNUSED, Z80_UNUSED, 0},
32 //1
33 {Z80_DJNZ, Z80_UNUSED, Z80_IMMED, Z80_UNUSED, 0},
34 {Z80_LD, Z80_DE, Z80_IMMED, Z80_UNUSED, 0},
35 {Z80_LD, Z80_A, Z80_REG_INDIRECT | Z80_DIR, Z80_DE, 0},
36 {Z80_INC, Z80_DE, Z80_UNUSED, Z80_UNUSED, 0},
37 {Z80_INC, Z80_D, Z80_UNUSED, Z80_UNUSED, 0},
38 {Z80_DEC, Z80_D, Z80_UNUSED, Z80_UNUSED, 0},
39 {Z80_LD, Z80_D, Z80_IMMED, Z80_UNUSED, 0},
40 {Z80_RL, Z80_A, Z80_UNUSED, Z80_UNUSED, 0},
41 {Z80_JR, Z80_UNUSED, Z80_IMMED, Z80_UNUSED, 0},
42 {Z80_ADD, Z80_HL, Z80_REG, Z80_DE, 0},
43 {Z80_LD, Z80_A, Z80_REG_INDIRECT, Z80_DE, 0},
44 {Z80_DEC, Z80_DE, Z80_UNUSED, Z80_UNUSED, 0},
45 {Z80_INC, Z80_E, Z80_UNUSED, Z80_UNUSED, 0},
46 {Z80_DEC, Z80_E, Z80_UNUSED, Z80_UNUSED, 0},
47 {Z80_LD, Z80_E, Z80_IMMED, Z80_UNUSED, 0},
48 {Z80_RR, Z80_A, Z80_UNUSED, Z80_UNUSED, 0},
49 //2
50 {Z80_JRCC, Z80_CC_NZ, Z80_IMMED, Z80_UNUSED, 0},
51 {Z80_LD, Z80_HL, Z80_IMMED, Z80_UNUSED, 0},
52 {Z80_LD, Z80_HL, Z80_IMMED_INDIRECT | Z80_DIR, Z80_UNUSED, 0},
53 {Z80_INC, Z80_HL, Z80_UNUSED, Z80_UNUSED, 0},
54 {Z80_INC, Z80_H, Z80_UNUSED, Z80_UNUSED, 0},
55 {Z80_DEC, Z80_H, Z80_UNUSED, Z80_UNUSED, 0},
56 {Z80_LD, Z80_H, Z80_IMMED, Z80_UNUSED, 0},
57 {Z80_DAA, Z80_UNUSED, Z80_UNUSED, Z80_UNUSED, 0},
58 {Z80_JRCC, Z80_CC_Z, Z80_IMMED, Z80_UNUSED, 0},
59 {Z80_ADD, Z80_HL, Z80_REG, Z80_HL, 0},
60 {Z80_LD, Z80_HL, Z80_IMMED_INDIRECT, Z80_IMMED, 0},
61 {Z80_DEC, Z80_HL, Z80_UNUSED, Z80_UNUSED, 0},
62 {Z80_INC, Z80_L, Z80_UNUSED, Z80_UNUSED, 0},
63 {Z80_DEC, Z80_L, Z80_UNUSED, Z80_UNUSED, 0},
64 {Z80_LD, Z80_L, Z80_IMMED, Z80_UNUSED, 0},
65 {Z80_CPL, Z80_UNUSED, Z80_UNUSED, Z80_UNUSED, 0},
66 //3
67 {Z80_JRCC, Z80_CC_NC, Z80_IMMED, Z80_UNUSED, 0},
68 {Z80_LD, Z80_SP, Z80_IMMED, Z80_UNUSED, 0},
69 {Z80_LD, Z80_A, Z80_IMMED_INDIRECT | Z80_DIR, Z80_UNUSED, 0},
70 {Z80_INC, Z80_SP, Z80_UNUSED, Z80_UNUSED, 0},
71 {Z80_INC, Z80_UNUSED, Z80_REG_INDIRECT, Z80_HL, 0},
72 {Z80_DEC, Z80_UNUSED, Z80_REG_INDIRECT, Z80_HL, 0},
73 {Z80_LD, Z80_USE_IMMED, Z80_REG_INDIRECT | Z80_DIR, Z80_HL, 0},
74 {Z80_SCF, Z80_UNUSED, Z80_UNUSED, Z80_UNUSED, 0},
75 {Z80_JRCC, Z80_CC_C, Z80_IMMED, Z80_UNUSED, 0},
76 {Z80_ADD, Z80_HL, Z80_REG, Z80_SP, 0},
77 {Z80_LD, Z80_A, Z80_IMMED_INDIRECT, Z80_IMMED, 0},
78 {Z80_DEC, Z80_SP, Z80_UNUSED, Z80_UNUSED, 0},
79 {Z80_INC, Z80_A, Z80_UNUSED, Z80_UNUSED, 0},
80 {Z80_DEC, Z80_A, Z80_UNUSED, Z80_UNUSED, 0},
81 {Z80_LD, Z80_A, Z80_IMMED, Z80_UNUSED, 0},
82 {Z80_CCF, Z80_UNUSED, Z80_UNUSED, Z80_UNUSED, 0},
83 //4
84 {Z80_LD, Z80_B, Z80_REG, Z80_B, 0},
85 {Z80_LD, Z80_B, Z80_REG, Z80_C, 0},
86 {Z80_LD, Z80_B, Z80_REG, Z80_D, 0},
87 {Z80_LD, Z80_B, Z80_REG, Z80_E, 0},
88 {Z80_LD, Z80_B, Z80_REG, Z80_H, 0},
89 {Z80_LD, Z80_B, Z80_REG, Z80_L, 0},
90 {Z80_LD, Z80_B, Z80_REG_INDIRECT, Z80_HL, 0},
91 {Z80_LD, Z80_B, Z80_REG, Z80_A, 0},
92 {Z80_LD, Z80_C, Z80_REG, Z80_B, 0},
93 {Z80_LD, Z80_C, Z80_REG, Z80_C, 0},
94 {Z80_LD, Z80_C, Z80_REG, Z80_D, 0},
95 {Z80_LD, Z80_C, Z80_REG, Z80_E, 0},
96 {Z80_LD, Z80_C, Z80_REG, Z80_H, 0},
97 {Z80_LD, Z80_C, Z80_REG, Z80_L, 0},
98 {Z80_LD, Z80_C, Z80_REG_INDIRECT, Z80_HL, 0},
99 {Z80_LD, Z80_C, Z80_REG, Z80_A, 0},
100 //5
101 {Z80_LD, Z80_D, Z80_REG, Z80_B, 0},
102 {Z80_LD, Z80_D, Z80_REG, Z80_C, 0},
103 {Z80_LD, Z80_D, Z80_REG, Z80_D, 0},
104 {Z80_LD, Z80_D, Z80_REG, Z80_E, 0},
105 {Z80_LD, Z80_D, Z80_REG, Z80_H, 0},
106 {Z80_LD, Z80_D, Z80_REG, Z80_L, 0},
107 {Z80_LD, Z80_D, Z80_REG_INDIRECT, Z80_HL, 0},
108 {Z80_LD, Z80_D, Z80_REG, Z80_A, 0},
109 {Z80_LD, Z80_E, Z80_REG, Z80_B, 0},
110 {Z80_LD, Z80_E, Z80_REG, Z80_C, 0},
111 {Z80_LD, Z80_E, Z80_REG, Z80_D, 0},
112 {Z80_LD, Z80_E, Z80_REG, Z80_E, 0},
113 {Z80_LD, Z80_E, Z80_REG, Z80_H, 0},
114 {Z80_LD, Z80_E, Z80_REG, Z80_L, 0},
115 {Z80_LD, Z80_E, Z80_REG_INDIRECT, Z80_HL, 0},
116 {Z80_LD, Z80_E, Z80_REG, Z80_A, 0},
117 //6
118 {Z80_LD, Z80_H, Z80_REG, Z80_B, 0},
119 {Z80_LD, Z80_H, Z80_REG, Z80_C, 0},
120 {Z80_LD, Z80_H, Z80_REG, Z80_D, 0},
121 {Z80_LD, Z80_H, Z80_REG, Z80_E, 0},
122 {Z80_LD, Z80_H, Z80_REG, Z80_H, 0},
123 {Z80_LD, Z80_H, Z80_REG, Z80_L, 0},
124 {Z80_LD, Z80_H, Z80_REG_INDIRECT, Z80_HL, 0},
125 {Z80_LD, Z80_H, Z80_REG, Z80_A, 0},
126 {Z80_LD, Z80_L, Z80_REG, Z80_B, 0},
127 {Z80_LD, Z80_L, Z80_REG, Z80_C, 0},
128 {Z80_LD, Z80_L, Z80_REG, Z80_D, 0},
129 {Z80_LD, Z80_L, Z80_REG, Z80_E, 0},
130 {Z80_LD, Z80_L, Z80_REG, Z80_H, 0},
131 {Z80_LD, Z80_L, Z80_REG, Z80_L, 0},
132 {Z80_LD, Z80_L, Z80_REG_INDIRECT, Z80_HL, 0},
133 {Z80_LD, Z80_L, Z80_REG, Z80_A, 0},
134 //7
135 {Z80_LD, Z80_B, Z80_REG_INDIRECT | Z80_DIR, Z80_HL, 0},
136 {Z80_LD, Z80_C, Z80_REG_INDIRECT | Z80_DIR, Z80_HL, 0},
137 {Z80_LD, Z80_D, Z80_REG_INDIRECT | Z80_DIR, Z80_HL, 0},
138 {Z80_LD, Z80_E, Z80_REG_INDIRECT | Z80_DIR, Z80_HL, 0},
139 {Z80_LD, Z80_H, Z80_REG_INDIRECT | Z80_DIR, Z80_HL, 0},
140 {Z80_LD, Z80_L, Z80_REG_INDIRECT | Z80_DIR, Z80_HL, 0},
141 {Z80_HALT, Z80_UNUSED, Z80_UNUSED, Z80_UNUSED, 0},
142 {Z80_LD, Z80_A, Z80_REG_INDIRECT | Z80_DIR, Z80_HL, 0},
143 {Z80_LD, Z80_A, Z80_REG, Z80_B, 0},
144 {Z80_LD, Z80_A, Z80_REG, Z80_C, 0},
145 {Z80_LD, Z80_A, Z80_REG, Z80_D, 0},
146 {Z80_LD, Z80_A, Z80_REG, Z80_E, 0},
147 {Z80_LD, Z80_A, Z80_REG, Z80_H, 0},
148 {Z80_LD, Z80_A, Z80_REG, Z80_L, 0},
149 {Z80_LD, Z80_A, Z80_REG_INDIRECT, Z80_HL, 0},
150 {Z80_LD, Z80_A, Z80_REG, Z80_A, 0},
151 //8
152 {Z80_ADD, Z80_A, Z80_REG, Z80_B, 0},
153 {Z80_ADD, Z80_A, Z80_REG, Z80_C, 0},
154 {Z80_ADD, Z80_A, Z80_REG, Z80_D, 0},
155 {Z80_ADD, Z80_A, Z80_REG, Z80_E, 0},
156 {Z80_ADD, Z80_A, Z80_REG, Z80_H, 0},
157 {Z80_ADD, Z80_A, Z80_REG, Z80_L, 0},
158 {Z80_ADD, Z80_A, Z80_REG_INDIRECT, Z80_HL, 0},
159 {Z80_ADD, Z80_A, Z80_REG, Z80_A, 0},
160 {Z80_ADC, Z80_A, Z80_REG, Z80_B, 0},
161 {Z80_ADC, Z80_A, Z80_REG, Z80_C, 0},
162 {Z80_ADC, Z80_A, Z80_REG, Z80_D, 0},
163 {Z80_ADC, Z80_A, Z80_REG, Z80_E, 0},
164 {Z80_ADC, Z80_A, Z80_REG, Z80_H, 0},
165 {Z80_ADC, Z80_A, Z80_REG, Z80_L, 0},
166 {Z80_ADC, Z80_A, Z80_REG_INDIRECT, Z80_HL, 0},
167 {Z80_ADC, Z80_A, Z80_REG, Z80_A, 0},
168 //9
169 {Z80_SUB, Z80_A, Z80_REG, Z80_B, 0},
170 {Z80_SUB, Z80_A, Z80_REG, Z80_C, 0},
171 {Z80_SUB, Z80_A, Z80_REG, Z80_D, 0},
172 {Z80_SUB, Z80_A, Z80_REG, Z80_E, 0},
173 {Z80_SUB, Z80_A, Z80_REG, Z80_H, 0},
174 {Z80_SUB, Z80_A, Z80_REG, Z80_L, 0},
175 {Z80_SUB, Z80_A, Z80_REG_INDIRECT, Z80_HL, 0},
176 {Z80_SUB, Z80_A, Z80_REG, Z80_A, 0},
177 {Z80_SBC, Z80_A, Z80_REG, Z80_B, 0},
178 {Z80_SBC, Z80_A, Z80_REG, Z80_C, 0},
179 {Z80_SBC, Z80_A, Z80_REG, Z80_D, 0},
180 {Z80_SBC, Z80_A, Z80_REG, Z80_E, 0},
181 {Z80_SBC, Z80_A, Z80_REG, Z80_H, 0},
182 {Z80_SBC, Z80_A, Z80_REG, Z80_L, 0},
183 {Z80_SBC, Z80_A, Z80_REG_INDIRECT, Z80_HL, 0},
184 {Z80_SBC, Z80_A, Z80_REG, Z80_A, 0},
185 //A
186 {Z80_AND, Z80_A, Z80_REG, Z80_B, 0},
187 {Z80_AND, Z80_A, Z80_REG, Z80_C, 0},
188 {Z80_AND, Z80_A, Z80_REG, Z80_D, 0},
189 {Z80_AND, Z80_A, Z80_REG, Z80_E, 0},
190 {Z80_AND, Z80_A, Z80_REG, Z80_H, 0},
191 {Z80_AND, Z80_A, Z80_REG, Z80_L, 0},
192 {Z80_AND, Z80_A, Z80_REG_INDIRECT, Z80_HL, 0},
193 {Z80_AND, Z80_A, Z80_REG, Z80_A, 0},
194 {Z80_XOR, Z80_A, Z80_REG, Z80_B, 0},
195 {Z80_XOR, Z80_A, Z80_REG, Z80_C, 0},
196 {Z80_XOR, Z80_A, Z80_REG, Z80_D, 0},
197 {Z80_XOR, Z80_A, Z80_REG, Z80_E, 0},
198 {Z80_XOR, Z80_A, Z80_REG, Z80_H, 0},
199 {Z80_XOR, Z80_A, Z80_REG, Z80_L, 0},
200 {Z80_XOR, Z80_A, Z80_REG_INDIRECT, Z80_HL, 0},
201 {Z80_XOR, Z80_A, Z80_REG, Z80_A, 0},
202 //B
203 {Z80_OR, Z80_A, Z80_REG, Z80_B, 0},
204 {Z80_OR, Z80_A, Z80_REG, Z80_C, 0},
205 {Z80_OR, Z80_A, Z80_REG, Z80_D, 0},
206 {Z80_OR, Z80_A, Z80_REG, Z80_E, 0},
207 {Z80_OR, Z80_A, Z80_REG, Z80_H, 0},
208 {Z80_OR, Z80_A, Z80_REG, Z80_L, 0},
209 {Z80_OR, Z80_A, Z80_REG_INDIRECT, Z80_HL, 0},
210 {Z80_OR, Z80_A, Z80_REG, Z80_A, 0},
211 {Z80_CP, Z80_A, Z80_REG, Z80_B, 0},
212 {Z80_CP, Z80_A, Z80_REG, Z80_C, 0},
213 {Z80_CP, Z80_A, Z80_REG, Z80_D, 0},
214 {Z80_CP, Z80_A, Z80_REG, Z80_E, 0},
215 {Z80_CP, Z80_A, Z80_REG, Z80_H, 0},
216 {Z80_CP, Z80_A, Z80_REG, Z80_L, 0},
217 {Z80_CP, Z80_A, Z80_REG_INDIRECT, Z80_HL, 0},
218 {Z80_CP, Z80_A, Z80_REG, Z80_A, 0},
219 //C
220 {Z80_RETCC, Z80_CC_NZ, Z80_UNUSED, Z80_UNUSED, 0},
221 {Z80_POP, Z80_BC, Z80_UNUSED, Z80_UNUSED, 0},
222 {Z80_JPCC, Z80_CC_NZ, Z80_IMMED, Z80_UNUSED, 0},
223 {Z80_JP, Z80_UNUSED, Z80_IMMED, Z80_UNUSED, 0},
224 {Z80_CALLCC, Z80_CC_NZ, Z80_IMMED, Z80_UNUSED, 0},
225 {Z80_PUSH, Z80_BC, Z80_UNUSED, Z80_UNUSED, 0},
226 {Z80_ADD, Z80_A, Z80_IMMED, Z80_UNUSED, 0},
227 {Z80_RST, Z80_UNUSED, Z80_IMMED, Z80_UNUSED, 0x0},
228 {Z80_RETCC, Z80_CC_Z, Z80_UNUSED, Z80_UNUSED, 0},
229 {Z80_RET, Z80_UNUSED, Z80_UNUSED, Z80_UNUSED, 0},
230 {Z80_JPCC, Z80_CC_Z, Z80_IMMED, Z80_UNUSED, 0},
231 {0, 0, 0, 0, 0},//BITS Prefix
232 {Z80_CALLCC, Z80_CC_Z, Z80_IMMED, Z80_UNUSED, 0},
233 {Z80_CALL, Z80_UNUSED, Z80_IMMED, Z80_UNUSED, 0},
234 {Z80_ADC, Z80_A, Z80_IMMED, Z80_UNUSED, 0},
235 {Z80_RST, Z80_UNUSED, Z80_IMMED, Z80_UNUSED, 0x8},
236 //D
237 {Z80_RETCC, Z80_CC_NC, Z80_UNUSED, Z80_UNUSED, 0},
238 {Z80_POP, Z80_DE, Z80_UNUSED, Z80_UNUSED, 0},
239 {Z80_JPCC, Z80_CC_NC, Z80_IMMED, Z80_UNUSED, 0},
240 {Z80_OUT, Z80_A, Z80_IMMED_INDIRECT, Z80_UNUSED, 0},
241 {Z80_CALLCC, Z80_CC_NC, Z80_IMMED, Z80_UNUSED, 0},
242 {Z80_PUSH, Z80_DE, Z80_UNUSED, Z80_UNUSED, 0},
243 {Z80_SUB, Z80_A, Z80_IMMED, Z80_UNUSED, 0},
244 {Z80_RST, Z80_UNUSED, Z80_IMMED, Z80_UNUSED, 0x10},
245 {Z80_RETCC, Z80_CC_C, Z80_UNUSED, Z80_UNUSED, 0},
246 {Z80_EXX, Z80_UNUSED, Z80_UNUSED, Z80_UNUSED, 0},
247 {Z80_JPCC, Z80_CC_C, Z80_IMMED, Z80_UNUSED, 0},
248 {Z80_IN, Z80_A, Z80_IMMED_INDIRECT, Z80_UNUSED, 0},
249 {Z80_CALLCC, Z80_CC_C, Z80_IMMED, Z80_UNUSED, 0},
250 {0, 0, 0, 0, 0},//IX Prefix
251 {Z80_SBC, Z80_A, Z80_IMMED, Z80_UNUSED, 0},
252 {Z80_RST, Z80_UNUSED, Z80_IMMED, Z80_UNUSED, 0x18},
253 //E
254 {Z80_RETCC, Z80_CC_PO, Z80_UNUSED, Z80_UNUSED, 0},
255 {Z80_POP, Z80_HL, Z80_UNUSED, Z80_UNUSED, 0},
256 {Z80_JPCC, Z80_CC_PO, Z80_IMMED, Z80_UNUSED, 0},
257 {Z80_EX, Z80_HL, Z80_REG_INDIRECT | Z80_DIR, Z80_SP, 0},
258 {Z80_CALLCC, Z80_CC_PO, Z80_IMMED, Z80_UNUSED, 0},
259 {Z80_PUSH, Z80_HL, Z80_UNUSED, Z80_UNUSED, 0},
260 {Z80_AND, Z80_A, Z80_IMMED, Z80_UNUSED, 0},
261 {Z80_RST, Z80_UNUSED, Z80_IMMED, Z80_UNUSED, 0x20},
262 {Z80_RETCC, Z80_CC_PE, Z80_UNUSED, Z80_UNUSED, 0},
263 {Z80_JP, Z80_UNUSED, Z80_REG_INDIRECT, Z80_HL, 0},
264 {Z80_JPCC, Z80_CC_PE, Z80_IMMED, Z80_UNUSED, 0},
265 {Z80_EX, Z80_DE, Z80_REG, Z80_HL, 0},
266 {Z80_CALLCC, Z80_CC_PE, Z80_IMMED, Z80_UNUSED, 0},
267 {0, 0, 0, 0, 0},//EXTD Prefix
268 {Z80_XOR, Z80_A, Z80_IMMED, Z80_UNUSED, 0},
269 {Z80_RST, Z80_UNUSED, Z80_IMMED, Z80_UNUSED, 0x28},
270 //F
271 {Z80_RETCC, Z80_CC_P, Z80_UNUSED, Z80_UNUSED, 0},
272 {Z80_POP, Z80_AF, Z80_UNUSED, Z80_UNUSED, 0},
273 {Z80_JPCC, Z80_CC_P, Z80_IMMED, Z80_UNUSED, 0},
274 {Z80_DI, Z80_UNUSED, Z80_UNUSED, Z80_UNUSED, 0},
275 {Z80_CALLCC, Z80_CC_P, Z80_IMMED, Z80_UNUSED, 0},
276 {Z80_PUSH, Z80_AF, Z80_UNUSED, Z80_UNUSED, 0},
277 {Z80_OR, Z80_A, Z80_IMMED, Z80_UNUSED, 0},
278 {Z80_RST, Z80_UNUSED, Z80_IMMED, Z80_UNUSED, 0x30},
279 {Z80_RETCC, Z80_CC_M, Z80_UNUSED, Z80_UNUSED, 0},
280 {Z80_LD, Z80_SP, Z80_REG, Z80_HL, 0},
281 {Z80_JPCC, Z80_CC_M, Z80_IMMED, Z80_UNUSED, 0},
282 {Z80_EI, Z80_UNUSED, Z80_UNUSED, Z80_UNUSED, 0},
283 {Z80_CALLCC, Z80_CC_M, Z80_IMMED, Z80_UNUSED, 0},
284 {0, 0, 0, 0, 0},//IY Prefix
285 {Z80_CP, Z80_A, Z80_IMMED, Z80_UNUSED, 0},
286 {Z80_RST, Z80_UNUSED, Z80_IMMED, Z80_UNUSED, 0x38}
287};
288
289z80inst z80_tbl_extd[0xC0-0x40] = {
290 //4
291 {Z80_IN, Z80_B, Z80_REG_INDIRECT, Z80_C, 0},
292 {Z80_OUT, Z80_B, Z80_REG_INDIRECT | Z80_DIR, Z80_C, 0},
293 {Z80_SBC, Z80_HL, Z80_REG, Z80_BC, 0},
294 {Z80_LD, Z80_BC, Z80_IMMED_INDIRECT | Z80_DIR, Z80_UNUSED, 0},
295 {Z80_NEG, Z80_A, Z80_UNUSED, Z80_UNUSED, 0},
296 {Z80_RETN, Z80_UNUSED, Z80_UNUSED, Z80_UNUSED, 0},
297 {Z80_IM, Z80_UNUSED, Z80_IMMED, Z80_UNUSED, 0},
298 {Z80_LD, Z80_I, Z80_REG, Z80_A, 0},
299 {Z80_IN, Z80_C, Z80_REG_INDIRECT, Z80_C, 0},
300 {Z80_OUT, Z80_C, Z80_REG_INDIRECT | Z80_DIR, Z80_C, 0},
301 {Z80_ADC, Z80_HL, Z80_REG, Z80_BC, 0},
302 {Z80_LD, Z80_BC, Z80_IMMED_INDIRECT, Z80_UNUSED, 0},
303 {Z80_NEG, Z80_A, Z80_UNUSED, Z80_UNUSED, 0},
304 {Z80_RETI, Z80_UNUSED, Z80_UNUSED, Z80_UNUSED, 0},
305 {Z80_IM, Z80_UNUSED, Z80_IMMED, Z80_UNUSED, 3},//Set undocumented mode 0/1
306 {Z80_LD, Z80_R, Z80_REG, Z80_A, 0},
307 //5
308 {Z80_IN, Z80_D, Z80_REG_INDIRECT, Z80_C, 0},
309 {Z80_OUT, Z80_D, Z80_REG_INDIRECT | Z80_DIR, Z80_C, 0},
310 {Z80_SBC, Z80_HL, Z80_REG, Z80_DE, 0},
311 {Z80_LD, Z80_DE, Z80_IMMED_INDIRECT | Z80_DIR, Z80_UNUSED, 0},
312 {Z80_NEG, Z80_A, Z80_UNUSED, Z80_UNUSED, 0},
313 {Z80_RETN, Z80_UNUSED, Z80_UNUSED, Z80_UNUSED, 0},
314 {Z80_IM, Z80_UNUSED, Z80_IMMED, Z80_UNUSED, 1},
315 {Z80_LD, Z80_A, Z80_REG, Z80_I, 0},
316 {Z80_IN, Z80_E, Z80_REG_INDIRECT, Z80_C, 0},
317 {Z80_OUT, Z80_E, Z80_REG_INDIRECT | Z80_DIR, Z80_C, 0},
318 {Z80_ADC, Z80_HL, Z80_REG, Z80_DE, 0},
319 {Z80_LD, Z80_DE, Z80_IMMED_INDIRECT, Z80_UNUSED, 0},
320 {Z80_NEG, Z80_A, Z80_UNUSED, Z80_UNUSED, 0},
321 {Z80_RETN, Z80_UNUSED, Z80_UNUSED, Z80_UNUSED, 0},
322 {Z80_IM, Z80_UNUSED, Z80_IMMED, Z80_UNUSED, 2},
323 {Z80_LD, Z80_A, Z80_REG, Z80_R, 0},
324 //6
325 {Z80_IN, Z80_H, Z80_REG_INDIRECT, Z80_C, 0},
326 {Z80_OUT, Z80_H, Z80_REG_INDIRECT | Z80_DIR, Z80_C, 0},
327 {Z80_SBC, Z80_HL, Z80_REG, Z80_HL, 0},
328 {Z80_LD, Z80_HL, Z80_IMMED_INDIRECT | Z80_DIR, Z80_UNUSED, 0},
329 {Z80_NEG, Z80_A, Z80_UNUSED, Z80_UNUSED, 0},
330 {Z80_RETN, Z80_UNUSED, Z80_UNUSED, Z80_UNUSED, 0},
331 {Z80_IM, Z80_UNUSED, Z80_IMMED, Z80_UNUSED, 0},
332 {Z80_RRD, Z80_UNUSED, Z80_UNUSED, Z80_UNUSED, 0},
333 {Z80_IN, Z80_L, Z80_REG_INDIRECT, Z80_C, 0},
334 {Z80_OUT, Z80_L, Z80_REG_INDIRECT | Z80_DIR, Z80_C, 0},
335 {Z80_ADC, Z80_HL, Z80_REG, Z80_HL, 0},
336 {Z80_LD, Z80_HL, Z80_IMMED_INDIRECT, Z80_UNUSED, 0},
337 {Z80_NEG, Z80_A, Z80_UNUSED, Z80_UNUSED, 0},
338 {Z80_RETN, Z80_UNUSED, Z80_UNUSED, Z80_UNUSED, 0},
339 {Z80_IM, Z80_UNUSED, Z80_IMMED, Z80_UNUSED, 3},//Set undocumented mode 0/1
340 {Z80_RLD, Z80_UNUSED, Z80_UNUSED, Z80_UNUSED, 0},
341 //7
342 {Z80_IN, Z80_UNUSED, Z80_REG_INDIRECT, Z80_C, 0},
343 {Z80_OUT, Z80_USE_IMMED, Z80_REG_INDIRECT | Z80_DIR, Z80_C, 0},
344 {Z80_SBC, Z80_HL, Z80_REG, Z80_SP, 0},
345 {Z80_LD, Z80_SP, Z80_IMMED_INDIRECT | Z80_DIR, Z80_UNUSED, 0},
346 {Z80_NEG, Z80_A, Z80_UNUSED, Z80_UNUSED, 0},
347 {Z80_RETN, Z80_UNUSED, Z80_UNUSED, Z80_UNUSED, 0},
348 {Z80_IM, Z80_UNUSED, Z80_IMMED, Z80_UNUSED, 1},
349 NOP,
350 {Z80_IN, Z80_A, Z80_REG_INDIRECT, Z80_C, 0},
351 {Z80_OUT, Z80_A, Z80_REG_INDIRECT | Z80_DIR, Z80_C, 0},
352 {Z80_ADC, Z80_HL, Z80_REG, Z80_SP, 0},
353 {Z80_LD, Z80_SP, Z80_IMMED_INDIRECT, Z80_UNUSED, 0},
354 {Z80_NEG, Z80_A, Z80_UNUSED, Z80_UNUSED, 0},
355 {Z80_RETN, Z80_UNUSED, Z80_UNUSED, Z80_UNUSED, 0},
356 {Z80_IM, Z80_UNUSED, Z80_IMMED, Z80_UNUSED, 2},
357 NOP,
358 //8
359 NOP,
360 NOP,
361 NOP,
362 NOP,
363 NOP,
364 NOP,
365 NOP,
366 NOP,
367 NOP,
368 NOP,
369 NOP,
370 NOP,
371 NOP,
372 NOP,
373 NOP,
374 NOP,
375 //9
376 NOP,
377 NOP,
378 NOP,
379 NOP,
380 NOP,
381 NOP,
382 NOP,
383 NOP,
384 NOP,
385 NOP,
386 NOP,
387 NOP,
388 NOP,
389 NOP,
390 NOP,
391 NOP,
392 //A
393 {Z80_LDI, Z80_UNUSED, Z80_UNUSED, Z80_UNUSED, 0},
394 {Z80_CPI, Z80_UNUSED, Z80_UNUSED, Z80_UNUSED, 0},
395 {Z80_INI, Z80_UNUSED, Z80_UNUSED, Z80_UNUSED, 0},
396 {Z80_OUTI, Z80_UNUSED, Z80_UNUSED, Z80_UNUSED, 0},
397 NOP,
398 NOP,
399 NOP,
400 NOP,
401 {Z80_LDD, Z80_UNUSED, Z80_UNUSED, Z80_UNUSED, 0},
402 {Z80_CPD, Z80_UNUSED, Z80_UNUSED, Z80_UNUSED, 0},
403 {Z80_IND, Z80_UNUSED, Z80_UNUSED, Z80_UNUSED, 0},
404 {Z80_OUTD, Z80_UNUSED, Z80_UNUSED, Z80_UNUSED, 0},
405 NOP,
406 NOP,
407 NOP,
408 NOP,
409 //B
410 {Z80_LDIR, Z80_UNUSED, Z80_UNUSED, Z80_UNUSED, 0},
411 {Z80_CPIR, Z80_UNUSED, Z80_UNUSED, Z80_UNUSED, 0},
412 {Z80_INIR, Z80_UNUSED, Z80_UNUSED, Z80_UNUSED, 0},
413 {Z80_OTIR, Z80_UNUSED, Z80_UNUSED, Z80_UNUSED, 0},
414 NOP,
415 NOP,
416 NOP,
417 NOP,
418 {Z80_LDDR, Z80_UNUSED, Z80_UNUSED, Z80_UNUSED, 0},
419 {Z80_CPDR, Z80_UNUSED, Z80_UNUSED, Z80_UNUSED, 0},
420 {Z80_INDR, Z80_UNUSED, Z80_UNUSED, Z80_UNUSED, 0},
421 {Z80_OTDR, Z80_UNUSED, Z80_UNUSED, Z80_UNUSED, 0},
422 NOP,
423 NOP,
424 NOP,
425 NOP
426};
427
428#define SHIFT_BLOCK(op) \
429 {op, Z80_B, Z80_UNUSED, Z80_UNUSED, 1},\
430 {op, Z80_C, Z80_UNUSED, Z80_UNUSED, 1},\
431 {op, Z80_D, Z80_UNUSED, Z80_UNUSED, 1},\
432 {op, Z80_E, Z80_UNUSED, Z80_UNUSED, 1},\
433 {op, Z80_H, Z80_UNUSED, Z80_UNUSED, 1},\
434 {op, Z80_L, Z80_UNUSED, Z80_UNUSED, 1},\
435 {op, Z80_UNUSED, Z80_REG_INDIRECT, Z80_HL, 1},\
436 {op, Z80_A, Z80_UNUSED, Z80_UNUSED, 1}
437
438#define BIT_BLOCK(op, bit) \
439 {op, Z80_USE_IMMED, Z80_REG, Z80_B, bit},\
440 {op, Z80_USE_IMMED, Z80_REG, Z80_C, bit},\
441 {op, Z80_USE_IMMED, Z80_REG, Z80_D, bit},\
442 {op, Z80_USE_IMMED, Z80_REG, Z80_E, bit},\
443 {op, Z80_USE_IMMED, Z80_REG, Z80_H, bit},\
444 {op, Z80_USE_IMMED, Z80_REG, Z80_L, bit},\
445 {op, Z80_USE_IMMED, Z80_REG_INDIRECT, Z80_HL, bit},\
446 {op, Z80_USE_IMMED, Z80_REG, Z80_A, bit}
447
448z80inst z80_tbl_bit[256] = {
449 //0
450 SHIFT_BLOCK(Z80_RLC),
451 SHIFT_BLOCK(Z80_RRC),
452 //1
453 SHIFT_BLOCK(Z80_RL),
454 SHIFT_BLOCK(Z80_RR),
455 //2
456 SHIFT_BLOCK(Z80_SLA),
457 SHIFT_BLOCK(Z80_SRA),
458 //3
459 SHIFT_BLOCK(Z80_SLL),
460 SHIFT_BLOCK(Z80_SRL),
461 //4
462 BIT_BLOCK(Z80_BIT, 0),
463 BIT_BLOCK(Z80_BIT, 1),
464 //5
465 BIT_BLOCK(Z80_BIT, 2),
466 BIT_BLOCK(Z80_BIT, 3),
467 //6
468 BIT_BLOCK(Z80_BIT, 4),
469 BIT_BLOCK(Z80_BIT, 5),
470 //7
471 BIT_BLOCK(Z80_BIT, 6),
472 BIT_BLOCK(Z80_BIT, 7),
473 //8
474 BIT_BLOCK(Z80_RES, 0),
475 BIT_BLOCK(Z80_RES, 1),
476 //9
477 BIT_BLOCK(Z80_RES, 2),
478 BIT_BLOCK(Z80_RES, 3),
479 //A
480 BIT_BLOCK(Z80_RES, 4),
481 BIT_BLOCK(Z80_RES, 5),
482 //B
483 BIT_BLOCK(Z80_RES, 6),
484 BIT_BLOCK(Z80_RES, 7),
485 //C
486 BIT_BLOCK(Z80_SET, 0),
487 BIT_BLOCK(Z80_SET, 1),
488 //D
489 BIT_BLOCK(Z80_SET, 2),
490 BIT_BLOCK(Z80_SET, 3),
491 //E
492 BIT_BLOCK(Z80_SET, 4),
493 BIT_BLOCK(Z80_SET, 5),
494 //F
495 BIT_BLOCK(Z80_SET, 6),
496 BIT_BLOCK(Z80_SET, 7)
497};
498
499z80inst z80_tbl_ix[256] = {
500 //0
501 USE_MAIN,
502 USE_MAIN,
503 USE_MAIN,
504 USE_MAIN,
505 USE_MAIN,
506 USE_MAIN,
507 USE_MAIN,
508 USE_MAIN,
509 USE_MAIN,
510 {Z80_ADD, Z80_IX, Z80_REG, Z80_BC, 0},
511 USE_MAIN,
512 USE_MAIN,
513 USE_MAIN,
514 USE_MAIN,
515 USE_MAIN,
516 USE_MAIN,
517 //1
518 USE_MAIN,
519 USE_MAIN,
520 USE_MAIN,
521 USE_MAIN,
522 USE_MAIN,
523 USE_MAIN,
524 USE_MAIN,
525 USE_MAIN,
526 USE_MAIN,
527 {Z80_ADD, Z80_IX, Z80_REG, Z80_DE, 0},
528 USE_MAIN,
529 USE_MAIN,
530 USE_MAIN,
531 USE_MAIN,
532 USE_MAIN,
533 USE_MAIN,
534 //2
535 USE_MAIN,
536 {Z80_LD, Z80_IX, Z80_IMMED, Z80_UNUSED, 0},
537 {Z80_LD, Z80_IX, Z80_IMMED_INDIRECT | Z80_DIR, Z80_UNUSED, 0},
538 {Z80_INC, Z80_IX, Z80_UNUSED, Z80_UNUSED, 0},
539 {Z80_INC, Z80_IXH, Z80_UNUSED, Z80_UNUSED, 0},
540 {Z80_DEC, Z80_IXH, Z80_UNUSED, Z80_UNUSED, 0},
541 {Z80_LD, Z80_IXH, Z80_IMMED, Z80_UNUSED, 0},
542 USE_MAIN,
543 USE_MAIN,
544 {Z80_ADD, Z80_IX, Z80_REG, Z80_IX, 0},
545 {Z80_LD, Z80_IX, Z80_IMMED_INDIRECT, Z80_UNUSED, 0},
546 {Z80_DEC, Z80_IX, Z80_UNUSED, Z80_UNUSED, 0},
547 {Z80_INC, Z80_IXL, Z80_UNUSED, Z80_UNUSED, 0},
548 {Z80_DEC, Z80_IXL, Z80_UNUSED, Z80_UNUSED, 0},
549 {Z80_LD, Z80_IXL, Z80_IMMED, Z80_UNUSED, 0},
550 USE_MAIN,
551 //3
552 USE_MAIN,
553 USE_MAIN,
554 USE_MAIN,
555 USE_MAIN,
556 {Z80_INC, Z80_UNUSED, Z80_IX_DISPLACE, 0, 0},
557 {Z80_DEC, Z80_UNUSED, Z80_IX_DISPLACE, 0, 0},
558 {Z80_LD, Z80_USE_IMMED, Z80_IX_DISPLACE | Z80_DIR, 0, 0},
559 USE_MAIN,
560 USE_MAIN,
561 {Z80_ADD, Z80_IX, Z80_REG, Z80_SP, 0},
562 USE_MAIN,
563 USE_MAIN,
564 USE_MAIN,
565 USE_MAIN,
566 USE_MAIN,
567 USE_MAIN,
568 //4
569 USE_MAIN,
570 USE_MAIN,
571 USE_MAIN,
572 USE_MAIN,
573 {Z80_LD, Z80_B, Z80_REG, Z80_IXH, 0},
574 {Z80_LD, Z80_B, Z80_REG, Z80_IXL, 0},
575 {Z80_LD, Z80_B, Z80_IX_DISPLACE, 0, 0},
576 USE_MAIN,
577 USE_MAIN,
578 USE_MAIN,
579 USE_MAIN,
580 USE_MAIN,
581 {Z80_LD, Z80_C, Z80_REG, Z80_IXH, 0},
582 {Z80_LD, Z80_C, Z80_REG, Z80_IXL, 0},
583 {Z80_LD, Z80_C, Z80_IX_DISPLACE, 0, 0},
584 USE_MAIN,
585 //5
586 USE_MAIN,
587 USE_MAIN,
588 USE_MAIN,
589 USE_MAIN,
590 {Z80_LD, Z80_D, Z80_REG, Z80_IXH, 0},
591 {Z80_LD, Z80_D, Z80_REG, Z80_IXL, 0},
592 {Z80_LD, Z80_D, Z80_IX_DISPLACE, 0, 0},
593 USE_MAIN,
594 USE_MAIN,
595 USE_MAIN,
596 USE_MAIN,
597 USE_MAIN,
598 {Z80_LD, Z80_E, Z80_REG, Z80_IXH, 0},
599 {Z80_LD, Z80_E, Z80_REG, Z80_IXL, 0},
600 {Z80_LD, Z80_E, Z80_IX_DISPLACE, 0, 0},
601 USE_MAIN,
602 //6
603 {Z80_LD, Z80_IXH, Z80_REG, Z80_B, 0},
604 {Z80_LD, Z80_IXH, Z80_REG, Z80_C, 0},
605 {Z80_LD, Z80_IXH, Z80_REG, Z80_D, 0},
606 {Z80_LD, Z80_IXH, Z80_REG, Z80_E, 0},
607 {Z80_LD, Z80_IXH, Z80_REG, Z80_IXH, 0},
608 {Z80_LD, Z80_IXH, Z80_REG, Z80_IXL, 0},
609 {Z80_LD, Z80_H, Z80_IX_DISPLACE, 0, 0},
610 {Z80_LD, Z80_IXH, Z80_REG, Z80_A, 0},
611 {Z80_LD, Z80_IXL, Z80_REG, Z80_B, 0},
612 {Z80_LD, Z80_IXL, Z80_REG, Z80_C, 0},
613 {Z80_LD, Z80_IXL, Z80_REG, Z80_D, 0},
614 {Z80_LD, Z80_IXL, Z80_REG, Z80_E, 0},
615 {Z80_LD, Z80_IXL, Z80_REG, Z80_IXH, 0},
616 {Z80_LD, Z80_IXL, Z80_REG, Z80_IXL, 0},
617 {Z80_LD, Z80_L, Z80_IX_DISPLACE, 0, 0},
618 {Z80_LD, Z80_IXL, Z80_REG, Z80_A, 0},
619 //7
620 {Z80_LD, Z80_B, Z80_IX_DISPLACE | Z80_DIR, 0, 0},
621 {Z80_LD, Z80_C, Z80_IX_DISPLACE | Z80_DIR, 0, 0},
622 {Z80_LD, Z80_D, Z80_IX_DISPLACE | Z80_DIR, 0, 0},
623 {Z80_LD, Z80_E, Z80_IX_DISPLACE | Z80_DIR, 0, 0},
624 {Z80_LD, Z80_H, Z80_IX_DISPLACE | Z80_DIR, 0, 0},
625 {Z80_LD, Z80_L, Z80_IX_DISPLACE | Z80_DIR, 0, 0},
626 USE_MAIN,
627 {Z80_LD, Z80_A, Z80_IX_DISPLACE | Z80_DIR, 0, 0},
628 USE_MAIN,
629 USE_MAIN,
630 USE_MAIN,
631 USE_MAIN,
632 {Z80_LD, Z80_A, Z80_REG, Z80_IXH, 0},
633 {Z80_LD, Z80_A, Z80_REG, Z80_IXL, 0},
634 {Z80_LD, Z80_A, Z80_IX_DISPLACE, 0, 0},
635 USE_MAIN,
636 //8
637 USE_MAIN,
638 USE_MAIN,
639 USE_MAIN,
640 USE_MAIN,
641 {Z80_ADD, Z80_A, Z80_REG, Z80_IXH, 0},
642 {Z80_ADD, Z80_A, Z80_REG, Z80_IXL, 0},
643 {Z80_ADD, Z80_A, Z80_IX_DISPLACE, 0, 0},
644 USE_MAIN,
645 USE_MAIN,
646 USE_MAIN,
647 USE_MAIN,
648 USE_MAIN,
649 {Z80_ADC, Z80_A, Z80_REG, Z80_IXH, 0},
650 {Z80_ADC, Z80_A, Z80_REG, Z80_IXL, 0},
651 {Z80_ADC, Z80_A, Z80_IX_DISPLACE, 0, 0},
652 USE_MAIN,
653 //9
654 USE_MAIN,
655 USE_MAIN,
656 USE_MAIN,
657 USE_MAIN,
658 {Z80_SUB, Z80_A, Z80_REG, Z80_IXH, 0},
659 {Z80_SUB, Z80_A, Z80_REG, Z80_IXL, 0},
660 {Z80_SUB, Z80_A, Z80_IX_DISPLACE, 0, 0},
661 USE_MAIN,
662 USE_MAIN,
663 USE_MAIN,
664 USE_MAIN,
665 USE_MAIN,
666 {Z80_SBC, Z80_A, Z80_REG, Z80_IXH, 0},
667 {Z80_SBC, Z80_A, Z80_REG, Z80_IXL, 0},
668 {Z80_SBC, Z80_A, Z80_IX_DISPLACE, 0, 0},
669 USE_MAIN,
670 //A
671 USE_MAIN,
672 USE_MAIN,
673 USE_MAIN,
674 USE_MAIN,
675 {Z80_AND, Z80_A, Z80_REG, Z80_IXH, 0},
676 {Z80_AND, Z80_A, Z80_REG, Z80_IXL, 0},
677 {Z80_AND, Z80_A, Z80_IX_DISPLACE, 0, 0},
678 USE_MAIN,
679 USE_MAIN,
680 USE_MAIN,
681 USE_MAIN,
682 USE_MAIN,
683 {Z80_XOR, Z80_A, Z80_REG, Z80_IXH, 0},
684 {Z80_XOR, Z80_A, Z80_REG, Z80_IXL, 0},
685 {Z80_XOR, Z80_A, Z80_IX_DISPLACE, 0, 0},
686 USE_MAIN,
687 //B
688 USE_MAIN,
689 USE_MAIN,
690 USE_MAIN,
691 USE_MAIN,
692 {Z80_OR, Z80_A, Z80_REG, Z80_IXH, 0},
693 {Z80_OR, Z80_A, Z80_REG, Z80_IXL, 0},
694 {Z80_OR, Z80_A, Z80_IX_DISPLACE, 0, 0},
695 USE_MAIN,
696 USE_MAIN,
697 USE_MAIN,
698 USE_MAIN,
699 USE_MAIN,
700 {Z80_CP, Z80_A, Z80_REG, Z80_IXH, 0},
701 {Z80_CP, Z80_A, Z80_REG, Z80_IXL, 0},
702 {Z80_CP, Z80_A, Z80_IX_DISPLACE, 0, 0},
703 USE_MAIN,
704 //C
705 USE_MAIN,
706 USE_MAIN,
707 USE_MAIN,
708 USE_MAIN,
709 USE_MAIN,
710 USE_MAIN,
711 USE_MAIN,
712 USE_MAIN,
713 USE_MAIN,
714 USE_MAIN,
715 USE_MAIN,
716 USE_MAIN,
717 USE_MAIN,
718 USE_MAIN,
719 USE_MAIN,
720 USE_MAIN,
721 //D
722 USE_MAIN,
723 USE_MAIN,
724 USE_MAIN,
725 USE_MAIN,
726 USE_MAIN,
727 USE_MAIN,
728 USE_MAIN,
729 USE_MAIN,
730 USE_MAIN,
731 USE_MAIN,
732 USE_MAIN,
733 USE_MAIN,
734 USE_MAIN,
735 USE_MAIN,
736 USE_MAIN,
737 USE_MAIN,
738 //E
739 USE_MAIN,
740 {Z80_POP, Z80_IX, Z80_UNUSED, Z80_UNUSED, 0},
741 USE_MAIN,
742 {Z80_EX, Z80_IX, Z80_REG_INDIRECT | Z80_DIR, Z80_SP, 0},
743 USE_MAIN,
744 {Z80_PUSH, Z80_IX, Z80_UNUSED, Z80_UNUSED, 0},
745 USE_MAIN,
746 USE_MAIN,
747 USE_MAIN,
748 {Z80_JP, Z80_UNUSED, Z80_REG_INDIRECT, Z80_IX, 0},
749 USE_MAIN,
750 USE_MAIN,
751 USE_MAIN,
752 USE_MAIN,
753 USE_MAIN,
754 USE_MAIN,
755 //F
756 USE_MAIN,
757 USE_MAIN,
758 USE_MAIN,
759 USE_MAIN,
760 USE_MAIN,
761 USE_MAIN,
762 USE_MAIN,
763 USE_MAIN,
764 USE_MAIN,
765 {Z80_LD, Z80_SP, Z80_REG, Z80_IX, 0},
766 USE_MAIN,
767 USE_MAIN,
768 USE_MAIN,
769 USE_MAIN,
770 USE_MAIN,
771 USE_MAIN
772};
773
774#define SHIFT_BLOCK_IX(op) \
775 {op, Z80_B, Z80_IX_DISPLACE | Z80_DIR, 0, 1},\
776 {op, Z80_C, Z80_IX_DISPLACE | Z80_DIR, 0, 1},\
777 {op, Z80_D, Z80_IX_DISPLACE | Z80_DIR, 0, 1},\
778 {op, Z80_E, Z80_IX_DISPLACE | Z80_DIR, 0, 1},\
779 {op, Z80_H, Z80_IX_DISPLACE | Z80_DIR, 0, 1},\
780 {op, Z80_L, Z80_IX_DISPLACE | Z80_DIR, 0, 1},\
781 {op, Z80_UNUSED, Z80_IX_DISPLACE | Z80_DIR, 0, 1},\
782 {op, Z80_A, Z80_IX_DISPLACE | Z80_DIR, 0, 1}
783
784#define BIT_BLOCK_IX(bit) \
785 {Z80_BIT, Z80_USE_IMMED, Z80_IX_DISPLACE, 0, bit},\
786 {Z80_BIT, Z80_USE_IMMED, Z80_IX_DISPLACE, 0, bit},\
787 {Z80_BIT, Z80_USE_IMMED, Z80_IX_DISPLACE, 0, bit},\
788 {Z80_BIT, Z80_USE_IMMED, Z80_IX_DISPLACE, 0, bit},\
789 {Z80_BIT, Z80_USE_IMMED, Z80_IX_DISPLACE, 0, bit},\
790 {Z80_BIT, Z80_USE_IMMED, Z80_IX_DISPLACE, 0, bit},\
791 {Z80_BIT, Z80_USE_IMMED, Z80_IX_DISPLACE, 0, bit},\
792 {Z80_BIT, Z80_USE_IMMED, Z80_IX_DISPLACE, 0, bit}
793
794#define BIT_BLOCK_IX_REG(op, bit) \
795 {op, Z80_B, Z80_IX_DISPLACE | Z80_DIR, 0, bit},\
796 {op, Z80_C, Z80_IX_DISPLACE | Z80_DIR, 0, bit},\
797 {op, Z80_D, Z80_IX_DISPLACE | Z80_DIR, 0, bit},\
798 {op, Z80_E, Z80_IX_DISPLACE | Z80_DIR, 0, bit},\
799 {op, Z80_H, Z80_IX_DISPLACE | Z80_DIR, 0, bit},\
800 {op, Z80_L, Z80_IX_DISPLACE | Z80_DIR, 0, bit},\
801 {op, Z80_USE_IMMED, Z80_IX_DISPLACE, 0, bit},\
802 {op, Z80_A, Z80_IX_DISPLACE | Z80_DIR, 0, bit}
803
804z80inst z80_tbl_ix_bit[256] = {
805 //0
806 SHIFT_BLOCK_IX(Z80_RLC),
807 SHIFT_BLOCK_IX(Z80_RRC),
808 //1
809 SHIFT_BLOCK_IX(Z80_RL),
810 SHIFT_BLOCK_IX(Z80_RR),
811 //2
812 SHIFT_BLOCK_IX(Z80_SLA),
813 SHIFT_BLOCK_IX(Z80_SRA),
814 //3
815 SHIFT_BLOCK_IX(Z80_SLL),
816 SHIFT_BLOCK_IX(Z80_SRL),
817 //4
818 BIT_BLOCK_IX(0),
819 BIT_BLOCK_IX(1),
820 //5
821 BIT_BLOCK_IX(2),
822 BIT_BLOCK_IX(3),
823 //6
824 BIT_BLOCK_IX(4),
825 BIT_BLOCK_IX(5),
826 //7
827 BIT_BLOCK_IX(6),
828 BIT_BLOCK_IX(7),
829 //8
830 BIT_BLOCK_IX_REG(Z80_RES, 0),
831 BIT_BLOCK_IX_REG(Z80_RES, 1),
832 //9
833 BIT_BLOCK_IX_REG(Z80_RES, 2),
834 BIT_BLOCK_IX_REG(Z80_RES, 3),
835 //A
836 BIT_BLOCK_IX_REG(Z80_RES, 4),
837 BIT_BLOCK_IX_REG(Z80_RES, 5),
838 //B
839 BIT_BLOCK_IX_REG(Z80_RES, 6),
840 BIT_BLOCK_IX_REG(Z80_RES, 7),
841 //C
842 BIT_BLOCK_IX_REG(Z80_SET, 0),
843 BIT_BLOCK_IX_REG(Z80_SET, 1),
844 //D
845 BIT_BLOCK_IX_REG(Z80_SET, 2),
846 BIT_BLOCK_IX_REG(Z80_SET, 3),
847 //E
848 BIT_BLOCK_IX_REG(Z80_SET, 4),
849 BIT_BLOCK_IX_REG(Z80_SET, 5),
850 //F
851 BIT_BLOCK_IX_REG(Z80_SET, 6),
852 BIT_BLOCK_IX_REG(Z80_SET, 7),
853};
854
855z80inst z80_tbl_iy[256] = {
856 //0
857 USE_MAIN,
858 USE_MAIN,
859 USE_MAIN,
860 USE_MAIN,
861 USE_MAIN,
862 USE_MAIN,
863 USE_MAIN,
864 USE_MAIN,
865 USE_MAIN,
866 {Z80_ADD, Z80_IY, Z80_REG, Z80_BC, 0},
867 USE_MAIN,
868 USE_MAIN,
869 USE_MAIN,
870 USE_MAIN,
871 USE_MAIN,
872 USE_MAIN,
873 //1
874 USE_MAIN,
875 USE_MAIN,
876 USE_MAIN,
877 USE_MAIN,
878 USE_MAIN,
879 USE_MAIN,
880 USE_MAIN,
881 USE_MAIN,
882 USE_MAIN,
883 {Z80_ADD, Z80_IY, Z80_REG, Z80_DE, 0},
884 USE_MAIN,
885 USE_MAIN,
886 USE_MAIN,
887 USE_MAIN,
888 USE_MAIN,
889 USE_MAIN,
890 //2
891 USE_MAIN,
892 {Z80_LD, Z80_IY, Z80_IMMED, Z80_UNUSED, 0},
893 {Z80_LD, Z80_IY, Z80_IMMED_INDIRECT | Z80_DIR, Z80_UNUSED, 0},
894 {Z80_INC, Z80_IY, Z80_UNUSED, Z80_UNUSED, 0},
895 {Z80_INC, Z80_IYH, Z80_UNUSED, Z80_UNUSED, 0},
896 {Z80_DEC, Z80_IYH, Z80_UNUSED, Z80_UNUSED, 0},
897 {Z80_LD, Z80_IYH, Z80_IMMED, Z80_UNUSED, 0},
898 USE_MAIN,
899 USE_MAIN,
900 {Z80_ADD, Z80_IY, Z80_REG, Z80_IY, 0},
901 {Z80_LD, Z80_IY, Z80_IMMED_INDIRECT, Z80_UNUSED, 0},
902 {Z80_DEC, Z80_IY, Z80_UNUSED, Z80_UNUSED, 0},
903 {Z80_INC, Z80_IYL, Z80_UNUSED, Z80_UNUSED, 0},
904 {Z80_DEC, Z80_IYL, Z80_UNUSED, Z80_UNUSED, 0},
905 {Z80_LD, Z80_IYL, Z80_IMMED, Z80_UNUSED, 0},
906 USE_MAIN,
907 //3
908 USE_MAIN,
909 USE_MAIN,
910 USE_MAIN,
911 USE_MAIN,
912 {Z80_INC, Z80_UNUSED, Z80_IY_DISPLACE, 0, 0},
913 {Z80_DEC, Z80_UNUSED, Z80_IY_DISPLACE, 0, 0},
914 {Z80_LD, Z80_USE_IMMED, Z80_IY_DISPLACE | Z80_DIR, 0, 0},
915 USE_MAIN,
916 USE_MAIN,
917 {Z80_ADD, Z80_IY, Z80_REG, Z80_SP, 0},
918 USE_MAIN,
919 USE_MAIN,
920 USE_MAIN,
921 USE_MAIN,
922 USE_MAIN,
923 USE_MAIN,
924 //4
925 USE_MAIN,
926 USE_MAIN,
927 USE_MAIN,
928 USE_MAIN,
929 {Z80_LD, Z80_B, Z80_REG, Z80_IYH, 0},
930 {Z80_LD, Z80_B, Z80_REG, Z80_IYL, 0},
931 {Z80_LD, Z80_B, Z80_IY_DISPLACE, 0, 0},
932 USE_MAIN,
933 USE_MAIN,
934 USE_MAIN,
935 USE_MAIN,
936 USE_MAIN,
937 {Z80_LD, Z80_C, Z80_REG, Z80_IYH, 0},
938 {Z80_LD, Z80_C, Z80_REG, Z80_IYL, 0},
939 {Z80_LD, Z80_C, Z80_IY_DISPLACE, 0, 0},
940 USE_MAIN,
941 //5
942 USE_MAIN,
943 USE_MAIN,
944 USE_MAIN,
945 USE_MAIN,
946 {Z80_LD, Z80_D, Z80_REG, Z80_IYH, 0},
947 {Z80_LD, Z80_D, Z80_REG, Z80_IYL, 0},
948 {Z80_LD, Z80_D, Z80_IY_DISPLACE, 0, 0},
949 USE_MAIN,
950 USE_MAIN,
951 USE_MAIN,
952 USE_MAIN,
953 USE_MAIN,
954 {Z80_LD, Z80_E, Z80_REG, Z80_IYH, 0},
955 {Z80_LD, Z80_E, Z80_REG, Z80_IYL, 0},
956 {Z80_LD, Z80_E, Z80_IY_DISPLACE, 0, 0},
957 USE_MAIN,
958 //6
959 {Z80_LD, Z80_IYH, Z80_REG, Z80_B, 0},
960 {Z80_LD, Z80_IYH, Z80_REG, Z80_C, 0},
961 {Z80_LD, Z80_IYH, Z80_REG, Z80_D, 0},
962 {Z80_LD, Z80_IYH, Z80_REG, Z80_E, 0},
963 {Z80_LD, Z80_IYH, Z80_REG, Z80_IYH, 0},
964 {Z80_LD, Z80_IYH, Z80_REG, Z80_IYL, 0},
965 {Z80_LD, Z80_H, Z80_IY_DISPLACE, 0, 0},
966 {Z80_LD, Z80_IYH, Z80_REG, Z80_A, 0},
967 {Z80_LD, Z80_IYL, Z80_REG, Z80_B, 0},
968 {Z80_LD, Z80_IYL, Z80_REG, Z80_C, 0},
969 {Z80_LD, Z80_IYL, Z80_REG, Z80_D, 0},
970 {Z80_LD, Z80_IYL, Z80_REG, Z80_E, 0},
971 {Z80_LD, Z80_IYL, Z80_REG, Z80_IYH, 0},
972 {Z80_LD, Z80_IYL, Z80_REG, Z80_IYL, 0},
973 {Z80_LD, Z80_L, Z80_IY_DISPLACE, 0, 0},
974 {Z80_LD, Z80_IYL, Z80_REG, Z80_A, 0},
975 //7
976 {Z80_LD, Z80_B, Z80_IY_DISPLACE | Z80_DIR, 0, 0},
977 {Z80_LD, Z80_C, Z80_IY_DISPLACE | Z80_DIR, 0, 0},
978 {Z80_LD, Z80_D, Z80_IY_DISPLACE | Z80_DIR, 0, 0},
979 {Z80_LD, Z80_E, Z80_IY_DISPLACE | Z80_DIR, 0, 0},
980 {Z80_LD, Z80_H, Z80_IY_DISPLACE | Z80_DIR, 0, 0},
981 {Z80_LD, Z80_L, Z80_IY_DISPLACE | Z80_DIR, 0, 0},
982 USE_MAIN,
983 {Z80_LD, Z80_A, Z80_IY_DISPLACE | Z80_DIR, 0, 0},
984 USE_MAIN,
985 USE_MAIN,
986 USE_MAIN,
987 USE_MAIN,
988 {Z80_LD, Z80_A, Z80_REG, Z80_IYH, 0},
989 {Z80_LD, Z80_A, Z80_REG, Z80_IYL, 0},
990 {Z80_LD, Z80_A, Z80_IY_DISPLACE, 0, 0},
991 USE_MAIN,
992 //8
993 USE_MAIN,
994 USE_MAIN,
995 USE_MAIN,
996 USE_MAIN,
997 {Z80_ADD, Z80_A, Z80_REG, Z80_IYH, 0},
998 {Z80_ADD, Z80_A, Z80_REG, Z80_IYL, 0},
999 {Z80_ADD, Z80_A, Z80_IY_DISPLACE, 0, 0},
1000 USE_MAIN,
1001 USE_MAIN,
1002 USE_MAIN,
1003 USE_MAIN,
1004 USE_MAIN,
1005 {Z80_ADC, Z80_A, Z80_REG, Z80_IYH, 0},
1006 {Z80_ADC, Z80_A, Z80_REG, Z80_IYL, 0},
1007 {Z80_ADC, Z80_A, Z80_IY_DISPLACE, 0, 0},
1008 USE_MAIN,
1009 //9
1010 USE_MAIN,
1011 USE_MAIN,
1012 USE_MAIN,
1013 USE_MAIN,
1014 {Z80_SUB, Z80_A, Z80_REG, Z80_IYH, 0},
1015 {Z80_SUB, Z80_A, Z80_REG, Z80_IYL, 0},
1016 {Z80_SUB, Z80_A, Z80_IY_DISPLACE, 0, 0},
1017 USE_MAIN,
1018 USE_MAIN,
1019 USE_MAIN,
1020 USE_MAIN,
1021 USE_MAIN,
1022 {Z80_SBC, Z80_A, Z80_REG, Z80_IYH, 0},
1023 {Z80_SBC, Z80_A, Z80_REG, Z80_IYL, 0},
1024 {Z80_SBC, Z80_A, Z80_IY_DISPLACE, 0, 0},
1025 USE_MAIN,
1026 //A
1027 USE_MAIN,
1028 USE_MAIN,
1029 USE_MAIN,
1030 USE_MAIN,
1031 {Z80_AND, Z80_A, Z80_REG, Z80_IYH, 0},
1032 {Z80_AND, Z80_A, Z80_REG, Z80_IYL, 0},
1033 {Z80_AND, Z80_A, Z80_IY_DISPLACE, 0, 0},
1034 USE_MAIN,
1035 USE_MAIN,
1036 USE_MAIN,
1037 USE_MAIN,
1038 USE_MAIN,
1039 {Z80_XOR, Z80_A, Z80_REG, Z80_IYH, 0},
1040 {Z80_XOR, Z80_A, Z80_REG, Z80_IYL, 0},
1041 {Z80_XOR, Z80_A, Z80_IY_DISPLACE, 0, 0},
1042 USE_MAIN,
1043 //B
1044 USE_MAIN,
1045 USE_MAIN,
1046 USE_MAIN,
1047 USE_MAIN,
1048 {Z80_OR, Z80_A, Z80_REG, Z80_IYH, 0},
1049 {Z80_OR, Z80_A, Z80_REG, Z80_IYL, 0},
1050 {Z80_OR, Z80_A, Z80_IY_DISPLACE, 0, 0},
1051 USE_MAIN,
1052 USE_MAIN,
1053 USE_MAIN,
1054 USE_MAIN,
1055 USE_MAIN,
1056 {Z80_CP, Z80_A, Z80_REG, Z80_IYH, 0},
1057 {Z80_CP, Z80_A, Z80_REG, Z80_IYL, 0},
1058 {Z80_CP, Z80_A, Z80_IY_DISPLACE, 0, 0},
1059 USE_MAIN,
1060 //C
1061 USE_MAIN,
1062 USE_MAIN,
1063 USE_MAIN,
1064 USE_MAIN,
1065 USE_MAIN,
1066 USE_MAIN,
1067 USE_MAIN,
1068 USE_MAIN,
1069 USE_MAIN,
1070 USE_MAIN,
1071 USE_MAIN,
1072 USE_MAIN,
1073 USE_MAIN,
1074 USE_MAIN,
1075 USE_MAIN,
1076 USE_MAIN,
1077 //D
1078 USE_MAIN,
1079 USE_MAIN,
1080 USE_MAIN,
1081 USE_MAIN,
1082 USE_MAIN,
1083 USE_MAIN,
1084 USE_MAIN,
1085 USE_MAIN,
1086 USE_MAIN,
1087 USE_MAIN,
1088 USE_MAIN,
1089 USE_MAIN,
1090 USE_MAIN,
1091 USE_MAIN,
1092 USE_MAIN,
1093 USE_MAIN,
1094 //E
1095 USE_MAIN,
1096 {Z80_POP, Z80_IY, Z80_UNUSED, Z80_UNUSED, 0},
1097 USE_MAIN,
1098 {Z80_EX, Z80_IY, Z80_REG_INDIRECT | Z80_DIR, Z80_SP, 0},
1099 USE_MAIN,
1100 {Z80_PUSH, Z80_IY, Z80_UNUSED, Z80_UNUSED, 0},
1101 USE_MAIN,
1102 USE_MAIN,
1103 USE_MAIN,
1104 {Z80_JP, Z80_UNUSED, Z80_REG_INDIRECT, Z80_IY, 0},
1105 USE_MAIN,
1106 USE_MAIN,
1107 USE_MAIN,
1108 USE_MAIN,
1109 USE_MAIN,
1110 USE_MAIN,
1111 //F
1112 USE_MAIN,
1113 USE_MAIN,
1114 USE_MAIN,
1115 USE_MAIN,
1116 USE_MAIN,
1117 USE_MAIN,
1118 USE_MAIN,
1119 USE_MAIN,
1120 USE_MAIN,
1121 {Z80_LD, Z80_SP, Z80_REG, Z80_IY, 0},
1122 USE_MAIN,
1123 USE_MAIN,
1124 USE_MAIN,
1125 USE_MAIN,
1126 USE_MAIN,
1127 USE_MAIN
1128};
1129
1130#define SHIFT_BLOCK_IY(op) \
1131 {op, Z80_B, Z80_IY_DISPLACE | Z80_DIR, 0, 1},\
1132 {op, Z80_C, Z80_IY_DISPLACE | Z80_DIR, 0, 1},\
1133 {op, Z80_D, Z80_IY_DISPLACE | Z80_DIR, 0, 1},\
1134 {op, Z80_E, Z80_IY_DISPLACE | Z80_DIR, 0, 1},\
1135 {op, Z80_H, Z80_IY_DISPLACE | Z80_DIR, 0, 1},\
1136 {op, Z80_L, Z80_IY_DISPLACE | Z80_DIR, 0, 1},\
1137 {op, Z80_UNUSED, Z80_IY_DISPLACE | Z80_DIR, 0, 1},\
1138 {op, Z80_A, Z80_IY_DISPLACE | Z80_DIR, 0, 1}
1139
1140#define BIT_BLOCK_IY(bit) \
1141 {Z80_BIT, Z80_USE_IMMED, Z80_IY_DISPLACE, 0, bit},\
1142 {Z80_BIT, Z80_USE_IMMED, Z80_IY_DISPLACE, 0, bit},\
1143 {Z80_BIT, Z80_USE_IMMED, Z80_IY_DISPLACE, 0, bit},\
1144 {Z80_BIT, Z80_USE_IMMED, Z80_IY_DISPLACE, 0, bit},\
1145 {Z80_BIT, Z80_USE_IMMED, Z80_IY_DISPLACE, 0, bit},\
1146 {Z80_BIT, Z80_USE_IMMED, Z80_IY_DISPLACE, 0, bit},\
1147 {Z80_BIT, Z80_USE_IMMED, Z80_IY_DISPLACE, 0, bit},\
1148 {Z80_BIT, Z80_USE_IMMED, Z80_IY_DISPLACE, 0, bit}
1149
1150#define BIT_BLOCK_IY_REG(op, bit) \
1151 {op, Z80_B, Z80_IY_DISPLACE | Z80_DIR, 0, bit},\
1152 {op, Z80_C, Z80_IY_DISPLACE | Z80_DIR, 0, bit},\
1153 {op, Z80_D, Z80_IY_DISPLACE | Z80_DIR, 0, bit},\
1154 {op, Z80_E, Z80_IY_DISPLACE | Z80_DIR, 0, bit},\
1155 {op, Z80_H, Z80_IY_DISPLACE | Z80_DIR, 0, bit},\
1156 {op, Z80_L, Z80_IY_DISPLACE | Z80_DIR, 0, bit},\
1157 {op, Z80_USE_IMMED, Z80_IY_DISPLACE, 0, bit},\
1158 {op, Z80_A, Z80_IY_DISPLACE | Z80_DIR, 0, bit}
1159
1160z80inst z80_tbl_iy_bit[256] = {
1161 //0
1162 SHIFT_BLOCK_IY(Z80_RLC),
1163 SHIFT_BLOCK_IY(Z80_RRC),
1164 //1
1165 SHIFT_BLOCK_IY(Z80_RL),
1166 SHIFT_BLOCK_IY(Z80_RR),
1167 //2
1168 SHIFT_BLOCK_IY(Z80_SLA),
1169 SHIFT_BLOCK_IY(Z80_SRA),
1170 //3
1171 SHIFT_BLOCK_IY(Z80_SLL),
1172 SHIFT_BLOCK_IY(Z80_SRL),
1173 //4
1174 BIT_BLOCK_IY(0),
1175 BIT_BLOCK_IY(1),
1176 //5
1177 BIT_BLOCK_IY(2),
1178 BIT_BLOCK_IY(3),
1179 //6
1180 BIT_BLOCK_IY(4),
1181 BIT_BLOCK_IY(5),
1182 //7
1183 BIT_BLOCK_IY(6),
1184 BIT_BLOCK_IY(7),
1185 //8
1186 BIT_BLOCK_IY_REG(Z80_RES, 0),
1187 BIT_BLOCK_IY_REG(Z80_RES, 1),
1188 //9
1189 BIT_BLOCK_IY_REG(Z80_RES, 2),
1190 BIT_BLOCK_IY_REG(Z80_RES, 3),
1191 //A
1192 BIT_BLOCK_IY_REG(Z80_RES, 4),
1193 BIT_BLOCK_IY_REG(Z80_RES, 5),
1194 //B
1195 BIT_BLOCK_IY_REG(Z80_RES, 6),
1196 BIT_BLOCK_IY_REG(Z80_RES, 7),
1197 //C
1198 BIT_BLOCK_IY_REG(Z80_SET, 0),
1199 BIT_BLOCK_IY_REG(Z80_SET, 1),
1200 //D
1201 BIT_BLOCK_IY_REG(Z80_SET, 2),
1202 BIT_BLOCK_IY_REG(Z80_SET, 3),
1203 //E
1204 BIT_BLOCK_IY_REG(Z80_SET, 4),
1205 BIT_BLOCK_IY_REG(Z80_SET, 5),
1206 //F
1207 BIT_BLOCK_IY_REG(Z80_SET, 6),
1208 BIT_BLOCK_IY_REG(Z80_SET, 7),
1209};
1210
1211enum {
1212 NORMAL,
1213 USE_IX,
1214 USE_IY
1215};
1216
1217uint8_t * z80_decode(uint8_t * istream, z80inst * decoded)
1218{
1219 uint8_t tmp;
1220 uint8_t *start = istream;
1221 uint8_t ixiy = NORMAL;
1222 uint16_t ixiy_disp = 0x100;
1223 z80inst *base = NULL;
1224 while(!base)
1225 {
1226 switch (*istream)
1227 {
1228 case 0xCB:
1229 istream++;
1230 if (ixiy == NORMAL) {
1231 base = z80_tbl_bit + *istream;
1232 } else if (ixiy == USE_IX) {
1233 ixiy_disp = *(istream++);
1234 base = z80_tbl_ix_bit + *istream;
1235 } else {
1236 ixiy_disp = *(istream++);
1237 base = z80_tbl_iy_bit + *istream;
1238 }
1239 break;
1240 case 0xED:
1241 istream++;
1242 ixiy = NORMAL;
1243 if (*istream < 0x40 || *istream >= 0xC0) {
1244 base = z80_tbl_extd + 0xBF;
1245 } else {
1246 base = z80_tbl_extd + *istream - 0x40;
1247 }
1248 break;
1249 case 0xDD:
1250 istream++;
1251 ixiy = USE_IX;
1252 break;
1253 case 0xFD:
1254 istream++;
1255 ixiy = USE_IY;
1256 break;
1257 default:
1258 if (ixiy == NORMAL) {
1259 base = z80_tbl_a + *istream;
1260 } else if (ixiy == USE_IX) {
1261 base = z80_tbl_ix + *istream;
1262 } else {
1263 base = z80_tbl_iy + *istream;
1264 }
1265 }
1266 }
1267 if (base->op == Z80_USE_MAIN) {
1268 base = z80_tbl_a + *istream;
1269 ixiy = NORMAL;
1270 }
1271 memcpy(decoded, base, offsetof(z80inst, opcode_bytes));
1272 decoded->opcode_bytes = istream - start + 1;
1273 if (ixiy != NORMAL) {
1274 if (ixiy_disp < 0x100) {
1275 decoded->ea_reg = ixiy_disp;
1276 //don't count displacement byte as an opcode byte
1277 decoded->opcode_bytes--;
1278 } else if ((decoded->addr_mode & 0x1F) == Z80_IX_DISPLACE || (decoded->addr_mode & 0x1F) == Z80_IY_DISPLACE) {
1279 decoded->ea_reg = *(++istream);
1280 }
1281 }
1282
1283 if ((decoded->addr_mode & 0x1F) == Z80_IMMED && decoded->op != Z80_RST && decoded->op != Z80_IM) {
1284 decoded->immed = *(++istream);
1285 if ((decoded->reg >= Z80_BC && decoded->reg < Z80_UNUSED) || decoded->op == Z80_CALL || decoded->op == Z80_CALLCC || decoded->op == Z80_JP || decoded->op == Z80_JPCC) {
1286 decoded->immed |= *(++istream) << 8;
1287 } else if (decoded->immed & 0x80) {
1288 decoded->immed |= 0xFF00;
1289 }
1290 } else if ((decoded->addr_mode & 0x1F) == Z80_IMMED_INDIRECT) {
1291 decoded->immed = *(++istream);
1292 if (decoded->op != Z80_OUT && decoded->op != Z80_IN) {
1293 decoded->immed |= *(++istream) << 8;
1294 }
1295 }
1296 if (decoded->reg == Z80_USE_IMMED && decoded->op != Z80_BIT && decoded->op != Z80_RES && decoded->op != Z80_SET && decoded->op != Z80_OUT) {
1297 decoded->immed = *(++istream);
1298 }
1299 return istream+1;
1300}
1301
1302char *z80_mnemonics[Z80_OTDR+1] = {
1303 "ld",
1304 "push",
1305 "pop",
1306 "ex",
1307 "exx",
1308 "ldi",
1309 "ldir",
1310 "ldd",
1311 "lddr",
1312 "cpi",
1313 "cpir",
1314 "cpd",
1315 "cpdr",
1316 "add",
1317 "adc",
1318 "sub",
1319 "sbc",
1320 "and",
1321 "or",
1322 "xor",
1323 "cp",
1324 "inc",
1325 "dec",
1326 "daa",
1327 "cpl",
1328 "neg",
1329 "ccf",
1330 "scf",
1331 "nop",
1332 "halt",
1333 "di",
1334 "ei",
1335 "im",
1336 "rlc",
1337 "rl",
1338 "rrc",
1339 "rr",
1340 "sla",
1341 "sra",
1342 "sll",
1343 "srl",
1344 "rld",
1345 "rrd",
1346 "bit",
1347 "set",
1348 "res",
1349 "jp",
1350 "jp",
1351 "jr",
1352 "jr",
1353 "djnz",
1354 "call",
1355 "call",
1356 "ret",
1357 "ret",
1358 "reti",
1359 "retn",
1360 "rst",
1361 "in",
1362 "ini",
1363 "inir",
1364 "ind",
1365 "indr",
1366 "out",
1367 "outi",
1368 "otir",
1369 "outd",
1370 "otdr"
1371};
1372
1373char * z80_regs[Z80_USE_IMMED] = {
1374 "c",
1375 "b",
1376 "e",
1377 "d",
1378 "l",
1379 "h",
1380 "ixl",
1381 "ixh",
1382 "iyl",
1383 "iyh",
1384 "i",
1385 "r",
1386 "a",
1387 "bc",
1388 "de",
1389 "hl",
1390 "sp",
1391 "af",
1392 "ix",
1393 "iy",
1394};
1395
1396char * z80_conditions[Z80_CC_M+1] = {
1397 "nz",
1398 "z",
1399 "nc",
1400 "c",
1401 "po",
1402 "pe",
1403 "p",
1404 "m"
1405};
1406
1407int z80_disasm(z80inst * decoded, char * dst, uint16_t address)
1408{
1409 int len = sprintf(dst, "%s", z80_mnemonics[decoded->op]);
1410 uint8_t needcomma;
1411 if (decoded->addr_mode & Z80_DIR) {
1412 needcomma = 1;
1413 switch (decoded->addr_mode & 0x1F)
1414 {
1415 case Z80_REG:
1416 len += sprintf(dst+len, " %s", z80_regs[decoded->ea_reg]);
1417 break;
1418 case Z80_REG_INDIRECT:
1419 len += sprintf(dst+len, " (%s)", z80_regs[decoded->ea_reg]);
1420 break;
1421 case Z80_IMMED:
1422 if (decoded->immed >= 63 || decoded->op == Z80_JP || decoded->op == Z80_JPCC || decoded->op == Z80_CALL || decoded->op == Z80_CALLCC || decoded->op == Z80_RST)
1423 {
1424 len += sprintf(dst+len, " $%X", decoded->immed);
1425 } else {
1426 len += sprintf(dst+len, " %d", decoded->immed);
1427 }
1428 break;
1429 case Z80_IMMED_INDIRECT:
1430 len += sprintf(dst+len, " ($%X)", decoded->immed);
1431 break;
1432 case Z80_IX_DISPLACE:
1433 len += sprintf(dst+len, " (ix+%d)", decoded->ea_reg & 0x80 ? decoded->ea_reg - 256 : decoded->ea_reg);
1434 break;
1435 case Z80_IY_DISPLACE:
1436 len += sprintf(dst+len, " (iy+%d)", decoded->ea_reg & 0x80 ? decoded->ea_reg - 256 : decoded->ea_reg);
1437 break;
1438 default:
1439 needcomma = 0;
1440 }
1441 if (decoded->reg & Z80_IMMED_FLAG) {
1442 len += sprintf(dst+len, "%s %d", needcomma ? "," : "", decoded->immed);
1443 }
1444 if ((decoded->reg & 0x1F) != Z80_UNUSED) {
1445 if (decoded->op == Z80_JRCC || decoded->op == Z80_JPCC || decoded->op == Z80_CALLCC || decoded->op == Z80_RETCC) {
1446 len += sprintf(dst+len, "%s %s", needcomma ? "," : "", z80_conditions[decoded->reg & 0x1F]);
1447 } else {
1448 len += sprintf(dst+len, "%s %s", needcomma ? "," : "", z80_regs[decoded->reg & 0x1F]);
1449 }
1450 }
1451 } else {
1452 needcomma = 0;
1453 if (decoded->reg & Z80_IMMED_FLAG) {
1454 len += sprintf(dst+len, " %d", decoded->immed);
1455 needcomma = 1;
1456 }
1457 if ((decoded->reg & 0x1F) != Z80_UNUSED) {
1458 if (decoded->op == Z80_JRCC || decoded->op == Z80_JPCC || decoded->op == Z80_CALLCC || decoded->op == Z80_RETCC) {
1459 len += sprintf(dst+len, " %s", z80_conditions[decoded->reg & 0x1F]);
1460 } else {
1461 len += sprintf(dst+len, " %s", z80_regs[decoded->reg & 0x1F]);
1462 }
1463 needcomma = 1;
1464 }
1465 switch (decoded->addr_mode)
1466 {
1467 case Z80_REG:
1468 len += sprintf(dst+len, "%s %s", needcomma ? "," : "" , z80_regs[decoded->ea_reg]);
1469 break;
1470 case Z80_REG_INDIRECT:
1471 len += sprintf(dst+len, "%s (%s)", needcomma ? "," : "" , z80_regs[decoded->ea_reg]);
1472 break;
1473 case Z80_IMMED:
1474 if (decoded->op == Z80_JR || decoded->op == Z80_JRCC || decoded->op == Z80_DJNZ) {
1475 address += 2 + decoded->immed;
1476 len += sprintf(dst+len, "%s %X", needcomma ? "," : "" , address);
1477 } else if (decoded->immed >= 63 || decoded->op == Z80_JP || decoded->op == Z80_JPCC || decoded->op == Z80_CALL || decoded->op == Z80_CALLCC || decoded->op == Z80_RST)
1478 {
1479 len += sprintf(dst+len, "%s $%X", needcomma ? "," : "" , decoded->immed);
1480 } else {
1481 len += sprintf(dst+len, "%s %d", needcomma ? "," : "" , decoded->immed);
1482 }
1483 break;
1484 case Z80_IMMED_INDIRECT:
1485 len += sprintf(dst+len, "%s ($%X)", needcomma ? "," : "" , decoded->immed);
1486 break;
1487 case Z80_IX_DISPLACE:
1488 len += sprintf(dst+len, "%s (ix+%d)", needcomma ? "," : "" , decoded->ea_reg & 0x80 ? decoded->ea_reg - 256 : decoded->ea_reg);
1489 break;
1490 case Z80_IY_DISPLACE:
1491 len += sprintf(dst+len, "%s (iy+%d)", needcomma ? "," : "" , decoded->ea_reg & 0x80 ? decoded->ea_reg - 256 : decoded->ea_reg);
1492 break;
1493 }
1494 }
1495 return len;
1496}
1497
1498uint8_t z80_high_reg(uint8_t reg)
1499{
1500 switch(reg)
1501 {
1502 case Z80_C:
1503 case Z80_BC:
1504 return Z80_B;
1505 case Z80_E:
1506 case Z80_DE:
1507 return Z80_D;
1508 case Z80_L:
1509 case Z80_HL:
1510 return Z80_H;
1511 case Z80_IXL:
1512 case Z80_IX:
1513 return Z80_IXH;
1514 case Z80_IYL:
1515 case Z80_IY:
1516 return Z80_IYH;
1517 default:
1518 return Z80_UNUSED;
1519 }
1520}
1521
1522uint8_t z80_low_reg(uint8_t reg)
1523{
1524 switch(reg)
1525 {
1526 case Z80_B:
1527 case Z80_BC:
1528 return Z80_C;
1529 case Z80_D:
1530 case Z80_DE:
1531 return Z80_E;
1532 case Z80_H:
1533 case Z80_HL:
1534 return Z80_L;
1535 case Z80_IXH:
1536 case Z80_IX:
1537 return Z80_IXL;
1538 case Z80_IYH:
1539 case Z80_IY:
1540 return Z80_IYL;
1541 default:
1542 return Z80_UNUSED;
1543 }
1544}
1545
1546uint8_t z80_word_reg(uint8_t reg)
1547{
1548 switch(reg)
1549 {
1550 case Z80_B:
1551 case Z80_C:
1552 return Z80_BC;
1553 case Z80_D:
1554 case Z80_E:
1555 return Z80_DE;
1556 case Z80_H:
1557 case Z80_L:
1558 return Z80_HL;
1559 case Z80_IXH:
1560 case Z80_IXL:
1561 return Z80_IX;
1562 case Z80_IYH:
1563 case Z80_IYL:
1564 return Z80_IY;
1565 default:
1566 return Z80_UNUSED;
1567 }
1568}
1569
1570uint8_t z80_is_terminal(z80inst * inst)
1571{
1572 return inst->op == Z80_RET || inst->op == Z80_RETI || inst->op == Z80_RETN || inst->op == Z80_JP
1573 || inst->op == Z80_JR || inst->op == Z80_HALT || (inst->op == Z80_NOP && inst->immed == 42);
1574}
1575
1576
1577
