1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <bitops.h>
4 #include <clock.h>
5 #include <cpu.h>
6 #include <log.h>
7 #include <memory.h>
8 #include <port.h>
9 #include <util.h>
10
11 #define DEFINE_AF_PAIR \
12 union { \
13 struct { \
14 union { \
15 uint8_t F; \
16 struct z80_flags flags; \
17 }; \
18 uint8_t A; \
19 }; \
20 uint16_t AF; \
21 };
22
23 #define DEFINE_REGISTER_PAIR(X, Y) \
24 union { \
25 struct { \
26 uint8_t Y; \
27 uint8_t X; \
28 }; \
29 uint16_t X##Y; \
30 };
31
32 #define DEFINE_IXY_REGISTER_PAIR(IXY) \
33 union { \
34 struct { \
35 uint8_t l##IXY; \
36 uint8_t h##IXY; \
37 }; \
38 uint16_t IXY; \
39 };
40
41 #define IRQ_N 0
42 #define NMI_N 1
43 #define IRQ_VECTOR 0x0038
44 #define NMI_VECTOR 0x0066
45
46 struct z80_flags {
47 uint8_t C:1;
48 uint8_t N:1;
49 uint8_t PV:1;
50 uint8_t X:1;
51 uint8_t H:1;
52 uint8_t Y:1;
53 uint8_t Z:1;
54 uint8_t S:1;
55 };
56
57 struct z80 {
58 DEFINE_AF_PAIR
59 DEFINE_REGISTER_PAIR(A2, F2)
60 DEFINE_REGISTER_PAIR(B, C)
61 DEFINE_REGISTER_PAIR(B2, C2)
62 DEFINE_REGISTER_PAIR(D, E)
63 DEFINE_REGISTER_PAIR(D2, E2)
64 DEFINE_REGISTER_PAIR(H, L)
65 DEFINE_REGISTER_PAIR(H2, L2)
66 DEFINE_IXY_REGISTER_PAIR(IX)
67 DEFINE_IXY_REGISTER_PAIR(IY)
68 uint16_t PC;
69 uint16_t SP;
70 uint8_t I;
71 uint8_t R;
72 bool IFF1;
73 bool IFF2;
74 bool irq_delay;
75 uint8_t interrupt_mode;
76 bool irq_pending;
77 bool nmi_pending;
78 bool halted;
79 int bus_id;
80 struct clock clock;
81 };
82
83 static bool z80_init(struct cpu_instance *instance);
84 static void z80_reset(struct cpu_instance *instance);
85 static void z80_interrupt(struct cpu_instance *instance, int irq);
86 static void z80_deinit(struct cpu_instance *instance);
87 static bool z80_handle_irq(struct z80 *cpu);
88 static bool z80_handle_nmi(struct z80 *cpu);
89 static void z80_tick(struct z80 *cpu);
90 static void z80_opcode_CB(struct z80 *cpu);
91 static void z80_opcode_DDFD(struct z80 *cpu, uint8_t prefix);
92 static void z80_opcode_DDFD_CB(struct z80 *cpu, uint16_t *reg);
93 static void z80_opcode_ED(struct z80 *cpu);
94 static inline void LD_r_r(uint8_t *r1, uint8_t *r2);
95 static inline void LD_r_n(struct z80 *cpu, uint8_t *r);
96 static inline void LD_r_cHL(struct z80 *cpu, uint8_t *r);
97 static inline void LD_r_cIXYpd(struct z80 *cpu, uint8_t *r, uint16_t *reg);
98 static inline void LD_cHL_r(struct z80 *cpu, uint8_t *r);
99 static inline void LD_cIXYpd_r(struct z80 *cpu, uint8_t *r, uint16_t *reg);
100 static inline void LD_cHL_n(struct z80 *cpu);
101 static inline void LD_cIXYpd_n(struct z80 *cpu, uint16_t *reg);
102 static inline void LD_A_cBC(struct z80 *cpu);
103 static inline void LD_A_cDE(struct z80 *cpu);
104 static inline void LD_A_cnn(struct z80 *cpu);
105 static inline void LD_cBC_A(struct z80 *cpu);
106 static inline void LD_cDE_A(struct z80 *cpu);
107 static inline void LD_cnn_A(struct z80 *cpu);
108 static inline void LD_A_I(struct z80 *cpu);
109 static inline void LD_A_R(struct z80 *cpu);
110 static inline void LD_I_A(struct z80 *cpu);
111 static inline void LD_R_A(struct z80 *cpu);
112 static inline void LD_dd_nn(struct z80 *cpu, uint16_t *dd);
113 static inline void LD_IXY_nn(struct z80 *cpu, uint16_t *reg);
114 static inline void LD_HL_cnn(struct z80 *cpu);
115 static inline void LD_dd_cnn(struct z80 *cpu, uint16_t *dd);
116 static inline void LD_IXY_cnn(struct z80 *cpu, uint16_t *reg);
117 static inline void LD_cnn_HL(struct z80 *cpu);
118 static inline void LD_cnn_dd(struct z80 *cpu, uint16_t *dd);
119 static inline void LD_cnn_IXY(struct z80 *cpu, uint16_t *reg);
120 static inline void LD_SP_HL(struct z80 *cpu);
121 static inline void LD_SP_IXY(struct z80 *cpu, uint16_t *reg);
122 static inline void PUSH_qq(struct z80 *cpu, uint16_t *qq);
123 static inline void PUSH_IXY(struct z80 *cpu, uint16_t *reg);
124 static inline void POP_qq(struct z80 *cpu, uint16_t *qq);
125 static inline void POP_IXY(struct z80 *cpu, uint16_t *reg);
126 static inline void EX_DE_HL(struct z80 *cpu);
127 static inline void EX_AF_A2F2(struct z80 *cpu);
128 static inline void EXX(struct z80 *cpu);
129 static inline void EX_cSP_HL(struct z80 *cpu);
130 static inline void EX_cSP_IXY(struct z80 *cpu, uint16_t *reg);
131 static inline void LDI(struct z80 *cpu);
132 static inline void LDIR(struct z80 *cpu);
133 static inline void LDD(struct z80 *cpu);
134 static inline void LDDR(struct z80 *cpu);
135 static inline void CPI(struct z80 *cpu);
136 static inline void CPIR(struct z80 *cpu);
137 static inline void CPD(struct z80 *cpu);
138 static inline void CPDR(struct z80 *cpu);
139 static inline void ADD_A_r(struct z80 *cpu, uint8_t *r);
140 static inline void ADD_A_n(struct z80 *cpu);
141 static inline void ADD_A_cHL(struct z80 *cpu);
142 static inline void ADD_A_cIXYpd(struct z80 *cpu, uint16_t *reg);
143 static inline void ADC_A_r(struct z80 *cpu, uint8_t *r);
144 static inline void ADC_A_n(struct z80 *cpu);
145 static inline void ADC_A_cHL(struct z80 *cpu);
146 static inline void ADC_A_cIXYpd(struct z80 *cpu, uint16_t *reg);
147 static inline void SUB_A_r(struct z80 *cpu, uint8_t *r);
148 static inline void SUB_A_n(struct z80 *cpu);
149 static inline void SUB_A_cHL(struct z80 *cpu);
150 static inline void SUB_A_cIXYpd(struct z80 *cpu, uint16_t *reg);
151 static inline void SBC_A_r(struct z80 *cpu, uint8_t *r);
152 static inline void SBC_A_n(struct z80 *cpu);
153 static inline void SBC_A_cHL(struct z80 *cpu);
154 static inline void SBC_A_cIXYpd(struct z80 *cpu, uint16_t *reg);
155 static inline void AND_r(struct z80 *cpu, uint8_t *r);
156 static inline void AND_n(struct z80 *cpu);
157 static inline void AND_cHL(struct z80 *cpu);
158 static inline void AND_cIXYpd(struct z80 *cpu, uint16_t *reg);
159 static inline void OR_r(struct z80 *cpu, uint8_t *r);
160 static inline void OR_n(struct z80 *cpu);
161 static inline void OR_cHL(struct z80 *cpu);
162 static inline void OR_cIXYpd(struct z80 *cpu, uint16_t *reg);
163 static inline void XOR_r(struct z80 *cpu, uint8_t *r);
164 static inline void XOR_n(struct z80 *cpu);
165 static inline void XOR_cHL(struct z80 *cpu);
166 static inline void XOR_cIXYpd(struct z80 *cpu, uint16_t *reg);
167 static inline void CP_r(struct z80 *cpu, uint8_t *r);
168 static inline void CP_n(struct z80 *cpu);
169 static inline void CP_cHL(struct z80 *cpu);
170 static inline void CP_IXYpd(struct z80 *cpu, uint16_t *reg);
171 static inline void INC_r(struct z80 *cpu, uint8_t *r);
172 static inline void INC_cHL(struct z80 *cpu);
173 static inline void INC_cIXYpd(struct z80 *cpu, uint16_t *reg);
174 static inline void DEC_r(struct z80 *cpu, uint8_t *r);
175 static inline void DEC_cHL(struct z80 *cpu);
176 static inline void DEC_cIXYpd(struct z80 *cpu, uint16_t *reg);
177 static inline void DAA(struct z80 *cpu);
178 static inline void CPL(struct z80 *cpu);
179 static inline void NEG(struct z80 *cpu);
180 static inline void CCF(struct z80 *cpu);
181 static inline void SCF(struct z80 *cpu);
182 static inline void NOP(struct z80 *UNUSED(cpu));
183 static inline void HALT(struct z80 *cpu);
184 static inline void DI(struct z80 *cpu);
185 static inline void EI(struct z80 *cpu);
186 static inline void IM_0(struct z80 *cpu);
187 static inline void IM_1(struct z80 *cpu);
188 static inline void IM_2(struct z80 *cpu);
189 static inline void ADD_HL_ss(struct z80 *cpu, uint16_t *ss);
190 static inline void ADC_HL_rr(struct z80 *cpu, uint16_t *rr);
191 static inline void SBC_HL_rr(struct z80 *cpu, uint16_t *rr);
192 static inline void ADD_IXY_pp(struct z80 *cpu, uint16_t *rr, uint16_t *reg);
193 static inline void INC_ss(uint16_t *ss);
194 static inline void DEC_ss(uint16_t *rr);
195 static inline void DEC_IXY(uint16_t *reg);
196 static inline void RLCA(struct z80 *cpu);
197 static inline void RLA(struct z80 *cpu);
198 static inline void RRCA(struct z80 *cpu);
199 static inline void RRA(struct z80 *cpu);
200 static inline void RLC_r(struct z80 *cpu, uint8_t *r);
201 static inline void RLC_cHL(struct z80 *cpu);
202 static inline void RLC_cIXYpd(struct z80 *cpu, uint16_t *reg);
203 static inline void RL_r(struct z80 *cpu, uint8_t *r);
204 static inline void RL_cHL(struct z80 *cpu);
205 static inline void RL_cIXYpd(struct z80 *cpu, uint16_t *reg);
206 static inline void RRC_r(struct z80 *cpu, uint8_t *r);
207 static inline void RRC_cHL(struct z80 *cpu);
208 static inline void RRC_cIXYpd(struct z80 *cpu, uint16_t *reg);
209 static inline void RR_r(struct z80 *cpu, uint8_t *r);
210 static inline void RR_cHL(struct z80 *cpu);
211 static inline void RR_cIXYpd(struct z80 *cpu, uint16_t *reg);
212 static inline void SLA_r(struct z80 *cpu, uint8_t *r);
213 static inline void SLA_cHL(struct z80 *cpu);
214 static inline void SLA_cIXYpd(struct z80 *cpu, uint16_t *reg);
215 static inline void SRA_r(struct z80 *cpu, uint8_t *r);
216 static inline void SRA_cHL(struct z80 *cpu);
217 static inline void SRA_cIXYpd(struct z80 *cpu, uint16_t *reg);
218 static inline void SL1_r(struct z80 *cpu, uint8_t *r);
219 static inline void SL1_cHL(struct z80 *cpu);
220 static inline void SL1_cIXYpd(struct z80 *cpu, uint16_t *reg);
221 static inline void SRL_r(struct z80 *cpu, uint8_t *r);
222 static inline void SRL_cHL(struct z80 *cpu);
223 static inline void SRL_cIXYpd(struct z80 *cpu, uint16_t *reg);
224 static inline void RLD(struct z80 *cpu);
225 static inline void RRD(struct z80 *cpu);
226 static inline void BIT_b_r(struct z80 *cpu, uint8_t b, uint8_t *r);
227 static inline void BIT_b_cHL(struct z80 *cpu, uint8_t b);
228 static inline void BIT_b_cIXYpd(struct z80 *cpu, uint8_t b, uint16_t *reg);
229 static inline void SET_b_r(uint8_t b, uint8_t *r);
230 static inline void SET_b_cHL(struct z80 *cpu, uint8_t b);
231 static inline void SET_b_cIXYpd(struct z80 *cpu, uint8_t b, uint16_t *reg);
232 static inline void RES_b_r(uint8_t b, uint8_t *r);
233 static inline void RES_b_cHL(struct z80 *cpu, uint8_t b);
234 static inline void RES_b_cIXYpd(struct z80 *cpu, uint8_t b, uint16_t *reg);
235 static inline void JP_nn(struct z80 *cpu);
236 static inline void JP_cc_nn(struct z80 *cpu, bool condition);
237 static inline void JR_e(struct z80 *cpu);
238 static inline void JR_cc_e(struct z80 *cpu, bool condition);
239 static inline void JP_HL(struct z80 *cpu);
240 static inline void JP_IXY(struct z80 *cpu, uint16_t *reg);
241 static inline void DJNZ_e(struct z80 *cpu);
242 static inline void CALL_nn(struct z80 *cpu);
243 static inline void CALL_cc_nn(struct z80 *cpu, bool condition);
244 static inline void RET(struct z80 *cpu);
245 static inline void RET_cc(struct z80 *cpu, bool condition);
246 static inline void RETI(struct z80 *cpu);
247 static inline void RETN(struct z80 *cpu);
248 static inline void RST_p(struct z80 *cpu, uint8_t p);
249 static inline void IN_A_cn(struct z80 *cpu);
250 static inline void IN_r_cC(struct z80 *cpu, uint8_t *r);
251 static inline void INI(struct z80 *cpu);
252 static inline void INIR(struct z80 *cpu);
253 static inline void IND(struct z80 *cpu);
254 static inline void INDR(struct z80 *cpu);
255 static inline void OUT_cn_A(struct z80 *cpu);
256 static inline void OUT_cC_r(struct z80 *cpu, uint8_t *r);
257 static inline void OUTI(struct z80 *cpu);
258 static inline void OTIR(struct z80 *cpu);
259 static inline void OUTD(struct z80 *cpu);
260 static inline void OTDR(struct z80 *cpu);
261
LD_r_r(uint8_t * r1,uint8_t * r2)262 void LD_r_r(uint8_t *r1, uint8_t *r2)
263 {
264 *r1 = *r2;
265 clock_consume(4);
266 }
267
LD_r_n(struct z80 * cpu,uint8_t * r)268 void LD_r_n(struct z80 *cpu, uint8_t *r)
269 {
270 *r = memory_readb(cpu->bus_id, cpu->PC++);
271 clock_consume(7);
272 }
273
LD_r_cHL(struct z80 * cpu,uint8_t * r)274 void LD_r_cHL(struct z80 *cpu, uint8_t *r)
275 {
276 *r = memory_readb(cpu->bus_id, cpu->HL);
277 clock_consume(7);
278 }
279
LD_r_cIXYpd(struct z80 * cpu,uint8_t * r,uint16_t * reg)280 void LD_r_cIXYpd(struct z80 *cpu, uint8_t *r, uint16_t *reg)
281 {
282 int8_t d = memory_readb(cpu->bus_id, cpu->PC++);
283 uint16_t address = *reg + d;
284 *r = memory_readb(cpu->bus_id, address);
285 clock_consume(19);
286 }
287
LD_cHL_r(struct z80 * cpu,uint8_t * r)288 void LD_cHL_r(struct z80 *cpu, uint8_t *r)
289 {
290 memory_writeb(cpu->bus_id, *r, cpu->HL);
291 clock_consume(7);
292 }
293
LD_cIXYpd_r(struct z80 * cpu,uint8_t * r,uint16_t * reg)294 void LD_cIXYpd_r(struct z80 *cpu, uint8_t *r, uint16_t *reg)
295 {
296 int8_t d = memory_readb(cpu->bus_id, cpu->PC++);
297 uint16_t address = *reg + d;
298 memory_writeb(cpu->bus_id, *r, address);
299 clock_consume(19);
300 }
301
LD_cHL_n(struct z80 * cpu)302 void LD_cHL_n(struct z80 *cpu)
303 {
304 uint8_t b = memory_readb(cpu->bus_id, cpu->PC++);
305 memory_writeb(cpu->bus_id, b, cpu->HL);
306 clock_consume(10);
307 }
308
LD_cIXYpd_n(struct z80 * cpu,uint16_t * reg)309 void LD_cIXYpd_n(struct z80 *cpu, uint16_t *reg)
310 {
311 int8_t d = memory_readb(cpu->bus_id, cpu->PC++);
312 uint8_t n = memory_readb(cpu->bus_id, cpu->PC++);
313 uint16_t address = *reg + d;
314 memory_writeb(cpu->bus_id, n, address);
315 clock_consume(19);
316 }
317
LD_A_cBC(struct z80 * cpu)318 void LD_A_cBC(struct z80 *cpu)
319 {
320 cpu->A = memory_readb(cpu->bus_id, cpu->BC);
321 clock_consume(7);
322 }
323
LD_A_cDE(struct z80 * cpu)324 void LD_A_cDE(struct z80 *cpu)
325 {
326 cpu->A = memory_readb(cpu->bus_id, cpu->DE);
327 clock_consume(7);
328 }
329
LD_A_cnn(struct z80 * cpu)330 void LD_A_cnn(struct z80 *cpu)
331 {
332 uint16_t address = memory_readb(cpu->bus_id, cpu->PC++);
333 address |= memory_readb(cpu->bus_id, cpu->PC++) << 8;
334 cpu->A = memory_readb(cpu->bus_id, address);
335 clock_consume(13);
336 }
337
LD_cBC_A(struct z80 * cpu)338 void LD_cBC_A(struct z80 *cpu)
339 {
340 memory_writeb(cpu->bus_id, cpu->A, cpu->BC);
341 clock_consume(7);
342 }
343
LD_cDE_A(struct z80 * cpu)344 void LD_cDE_A(struct z80 *cpu)
345 {
346 memory_writeb(cpu->bus_id, cpu->A, cpu->DE);
347 clock_consume(7);
348 }
349
LD_cnn_A(struct z80 * cpu)350 void LD_cnn_A(struct z80 *cpu)
351 {
352 uint16_t address = memory_readb(cpu->bus_id, cpu->PC++);
353 address |= memory_readb(cpu->bus_id, cpu->PC++) << 8;
354 memory_writeb(cpu->bus_id, cpu->A, address);
355 clock_consume(13);
356 }
357
LD_A_I(struct z80 * cpu)358 void LD_A_I(struct z80 *cpu)
359 {
360 cpu->A = cpu->I;
361 cpu->flags.S = ((int8_t)cpu->I < 0);
362 cpu->flags.Z = (cpu->I == 0);
363 cpu->flags.H = 0;
364 cpu->flags.PV = cpu->IFF2;
365 cpu->flags.N = 0;
366 clock_consume(9);
367 }
368
LD_A_R(struct z80 * cpu)369 void LD_A_R(struct z80 *cpu)
370 {
371 cpu->A = cpu->R;
372 cpu->flags.S = ((int8_t)cpu->R < 0);
373 cpu->flags.Z = (cpu->R == 0);
374 cpu->flags.H = 0;
375 cpu->flags.PV = cpu->IFF2;
376 cpu->flags.N = 0;
377 clock_consume(9);
378 }
379
LD_I_A(struct z80 * cpu)380 void LD_I_A(struct z80 *cpu)
381 {
382 cpu->I = cpu->A;
383 clock_consume(9);
384 }
385
LD_R_A(struct z80 * cpu)386 void LD_R_A(struct z80 *cpu)
387 {
388 cpu->R = cpu->A;
389 clock_consume(9);
390 }
391
LD_dd_nn(struct z80 * cpu,uint16_t * dd)392 void LD_dd_nn(struct z80 *cpu, uint16_t *dd)
393 {
394 uint16_t nn = memory_readb(cpu->bus_id, cpu->PC++);
395 nn |= memory_readb(cpu->bus_id, cpu->PC++) << 8;
396 *dd = nn;
397 clock_consume(10);
398 }
399
LD_IXY_nn(struct z80 * cpu,uint16_t * reg)400 void LD_IXY_nn(struct z80 *cpu, uint16_t *reg)
401 {
402 uint16_t nn = memory_readb(cpu->bus_id, cpu->PC++);
403 nn |= memory_readb(cpu->bus_id, cpu->PC++) << 8;
404 *reg = nn;
405 clock_consume(14);
406 }
407
LD_HL_cnn(struct z80 * cpu)408 void LD_HL_cnn(struct z80 *cpu)
409 {
410 uint16_t address = memory_readb(cpu->bus_id, cpu->PC++);
411 address |= memory_readb(cpu->bus_id, cpu->PC++) << 8;
412 cpu->L = memory_readb(cpu->bus_id, address);
413 cpu->H = memory_readb(cpu->bus_id, address + 1);
414 clock_consume(16);
415 }
416
LD_dd_cnn(struct z80 * cpu,uint16_t * dd)417 void LD_dd_cnn(struct z80 *cpu, uint16_t *dd)
418 {
419 uint16_t address = memory_readb(cpu->bus_id, cpu->PC++);
420 address |= memory_readb(cpu->bus_id, cpu->PC++) << 8;
421 *dd = memory_readb(cpu->bus_id, address);
422 *dd |= memory_readb(cpu->bus_id, address + 1) << 8;
423 clock_consume(20);
424 }
425
LD_IXY_cnn(struct z80 * cpu,uint16_t * reg)426 void LD_IXY_cnn(struct z80 *cpu, uint16_t *reg)
427 {
428 uint16_t address = memory_readb(cpu->bus_id, cpu->PC++);
429 address |= memory_readb(cpu->bus_id, cpu->PC++) << 8;
430 *reg = memory_readb(cpu->bus_id, address);
431 *reg |= memory_readb(cpu->bus_id, address + 1) << 8;
432 clock_consume(20);
433 }
434
LD_cnn_HL(struct z80 * cpu)435 void LD_cnn_HL(struct z80 *cpu)
436 {
437 uint16_t nn = memory_readb(cpu->bus_id, cpu->PC++);
438 nn |= memory_readb(cpu->bus_id, cpu->PC++) << 8;
439 memory_writeb(cpu->bus_id, cpu->HL, nn);
440 memory_writeb(cpu->bus_id, cpu->HL >> 8, nn + 1);
441 clock_consume(16);
442 }
443
LD_cnn_dd(struct z80 * cpu,uint16_t * dd)444 void LD_cnn_dd(struct z80 *cpu, uint16_t *dd)
445 {
446 uint16_t nn = memory_readb(cpu->bus_id, cpu->PC++);
447 nn |= memory_readb(cpu->bus_id, cpu->PC++) << 8;
448 memory_writeb(cpu->bus_id, *dd, nn);
449 memory_writeb(cpu->bus_id, *dd >> 8, nn + 1);
450 clock_consume(20);
451 }
452
LD_cnn_IXY(struct z80 * cpu,uint16_t * reg)453 void LD_cnn_IXY(struct z80 *cpu, uint16_t *reg)
454 {
455 uint16_t nn = memory_readb(cpu->bus_id, cpu->PC++);
456 nn |= memory_readb(cpu->bus_id, cpu->PC++) << 8;
457 memory_writeb(cpu->bus_id, *reg, nn);
458 memory_writeb(cpu->bus_id, *reg >> 8, nn + 1);
459 clock_consume(20);
460 }
461
LD_SP_HL(struct z80 * cpu)462 void LD_SP_HL(struct z80 *cpu)
463 {
464 cpu->SP = cpu->HL;
465 clock_consume(6);
466 }
467
LD_SP_IXY(struct z80 * cpu,uint16_t * reg)468 void LD_SP_IXY(struct z80 *cpu, uint16_t *reg)
469 {
470 cpu->SP = *reg;
471 clock_consume(10);
472 }
473
PUSH_qq(struct z80 * cpu,uint16_t * qq)474 void PUSH_qq(struct z80 *cpu, uint16_t *qq)
475 {
476 memory_writeb(cpu->bus_id, *qq >> 8, --cpu->SP);
477 memory_writeb(cpu->bus_id, *qq, --cpu->SP);
478 clock_consume(11);
479 }
480
PUSH_IXY(struct z80 * cpu,uint16_t * reg)481 void PUSH_IXY(struct z80 *cpu, uint16_t *reg)
482 {
483 memory_writeb(cpu->bus_id, *reg >> 8, --cpu->SP);
484 memory_writeb(cpu->bus_id, *reg, --cpu->SP);
485 clock_consume(15);
486 }
487
POP_qq(struct z80 * cpu,uint16_t * qq)488 void POP_qq(struct z80 *cpu, uint16_t *qq)
489 {
490 *qq = memory_readb(cpu->bus_id, cpu->SP++);
491 *qq |= memory_readb(cpu->bus_id, cpu->SP++) << 8;
492 clock_consume(10);
493 }
494
POP_IXY(struct z80 * cpu,uint16_t * reg)495 void POP_IXY(struct z80 *cpu, uint16_t *reg)
496 {
497 *reg = memory_readb(cpu->bus_id, cpu->SP++);
498 *reg |= memory_readb(cpu->bus_id, cpu->SP++) << 8;
499 clock_consume(14);
500 }
501
EX_DE_HL(struct z80 * cpu)502 void EX_DE_HL(struct z80 *cpu)
503 {
504 uint16_t DE = cpu->DE;
505 cpu->DE = cpu->HL;
506 cpu->HL = DE;
507 clock_consume(4);
508 }
509
EX_AF_A2F2(struct z80 * cpu)510 void EX_AF_A2F2(struct z80 *cpu)
511 {
512 uint16_t AF = cpu->AF;
513 cpu->AF = cpu->A2F2;
514 cpu->A2F2 = AF;
515 clock_consume(4);
516 }
517
EXX(struct z80 * cpu)518 void EXX(struct z80 *cpu)
519 {
520 uint16_t BC = cpu->BC;
521 uint16_t DE = cpu->DE;
522 uint16_t HL = cpu->HL;
523 cpu->BC = cpu->B2C2;
524 cpu->DE = cpu->D2E2;
525 cpu->HL = cpu->H2L2;
526 cpu->B2C2 = BC;
527 cpu->D2E2 = DE;
528 cpu->H2L2 = HL;
529 clock_consume(4);
530 }
531
EX_cSP_HL(struct z80 * cpu)532 void EX_cSP_HL(struct z80 *cpu)
533 {
534 uint8_t b1 = memory_readb(cpu->bus_id, cpu->SP);
535 uint8_t b2 = memory_readb(cpu->bus_id, cpu->SP + 1);
536 memory_writeb(cpu->bus_id, cpu->L, cpu->SP);
537 memory_writeb(cpu->bus_id, cpu->H, cpu->SP + 1);
538 cpu->HL = b1 | (b2 << 8);
539 clock_consume(19);
540 }
541
EX_cSP_IXY(struct z80 * cpu,uint16_t * reg)542 void EX_cSP_IXY(struct z80 *cpu, uint16_t *reg)
543 {
544 uint8_t b1 = memory_readb(cpu->bus_id, cpu->SP);
545 uint8_t b2 = memory_readb(cpu->bus_id, cpu->SP + 1);
546 memory_writeb(cpu->bus_id, *reg, cpu->SP);
547 memory_writeb(cpu->bus_id, *reg >> 8, cpu->SP + 1);
548 *reg = b1 | (b2 << 8);
549 clock_consume(23);
550 }
551
LDI(struct z80 * cpu)552 void LDI(struct z80 *cpu)
553 {
554 uint8_t b = memory_readb(cpu->bus_id, cpu->HL++);
555 memory_writeb(cpu->bus_id, b, cpu->DE++);
556 cpu->BC--;
557 cpu->flags.H = 0;
558 cpu->flags.PV = (cpu->BC != 0);
559 cpu->flags.N = 0;
560 clock_consume(16);
561 }
562
LDIR(struct z80 * cpu)563 void LDIR(struct z80 *cpu)
564 {
565 uint8_t b = memory_readb(cpu->bus_id, cpu->HL++);
566 memory_writeb(cpu->bus_id, b, cpu->DE++);
567 if (--cpu->BC != 0) {
568 cpu->PC -= 2;
569 clock_consume(5);
570 }
571 cpu->flags.H = 0;
572 cpu->flags.PV = (cpu->BC != 0);
573 cpu->flags.N = 0;
574 clock_consume(16);
575 }
576
LDD(struct z80 * cpu)577 void LDD(struct z80 *cpu)
578 {
579 uint8_t b = memory_readb(cpu->bus_id, cpu->HL--);
580 memory_writeb(cpu->bus_id, b, cpu->DE--);
581 cpu->BC--;
582 cpu->flags.H = 0;
583 cpu->flags.PV = (cpu->BC != 0);
584 cpu->flags.N = 0;
585 clock_consume(16);
586 }
587
LDDR(struct z80 * cpu)588 void LDDR(struct z80 *cpu)
589 {
590 uint8_t b = memory_readb(cpu->bus_id, cpu->HL--);
591 memory_writeb(cpu->bus_id, b, cpu->DE--);
592 if (--cpu->BC != 0) {
593 cpu->PC -= 2;
594 clock_consume(5);
595 }
596 cpu->flags.H = 0;
597 cpu->flags.PV = (cpu->BC != 0);
598 cpu->flags.N = 0;
599 clock_consume(16);
600 }
601
CPI(struct z80 * cpu)602 void CPI(struct z80 *cpu)
603 {
604 uint8_t b = memory_readb(cpu->bus_id, cpu->HL++);
605 int8_t result = cpu->A - b;
606 cpu->BC--;
607 cpu->flags.S = (result < 0);
608 cpu->flags.Z = (result == 0);
609 cpu->flags.H = ((cpu->A & 0x0F) - (b & 0x0F) < 0);
610 cpu->flags.PV = (cpu->BC == 0);
611 cpu->flags.N = 1;
612 clock_consume(16);
613 }
614
CPIR(struct z80 * cpu)615 void CPIR(struct z80 *cpu)
616 {
617 uint8_t b = memory_readb(cpu->bus_id, cpu->HL++);
618 int8_t result = cpu->A - b;
619 cpu->BC--;
620 if ((cpu->BC != 0) && (result != 0)) {
621 cpu->PC -= 2;
622 clock_consume(5);
623 }
624 cpu->flags.S = (result < 0);
625 cpu->flags.Z = (result == 0);
626 cpu->flags.H = ((cpu->A & 0x0F) - (b & 0x0F) < 0);
627 cpu->flags.PV = (cpu->BC == 0);
628 cpu->flags.N = 1;
629 clock_consume(16);
630 }
631
CPD(struct z80 * cpu)632 void CPD(struct z80 *cpu)
633 {
634 uint8_t b = memory_readb(cpu->bus_id, cpu->HL--);
635 int8_t result = cpu->A - b;
636 cpu->BC--;
637 cpu->flags.S = (result < 0);
638 cpu->flags.Z = (result == 0);
639 cpu->flags.H = ((cpu->A & 0x0F) - (b & 0x0F) < 0);
640 cpu->flags.PV = (cpu->BC == 0);
641 cpu->flags.N = 1;
642 clock_consume(16);
643 }
644
CPDR(struct z80 * cpu)645 void CPDR(struct z80 *cpu)
646 {
647 uint8_t b = memory_readb(cpu->bus_id, cpu->HL--);
648 int8_t result = cpu->A - b;
649 cpu->BC--;
650 if ((cpu->BC != 0) && (result != 0)) {
651 cpu->PC -= 2;
652 clock_consume(5);
653 }
654 cpu->flags.S = (result < 0);
655 cpu->flags.Z = (result == 0);
656 cpu->flags.H = ((cpu->A & 0x0F) - (b & 0x0F) < 0);
657 cpu->flags.PV = (cpu->BC == 0);
658 cpu->flags.N = 1;
659 clock_consume(16);
660 }
661
ADD_A_r(struct z80 * cpu,uint8_t * r)662 void ADD_A_r(struct z80 *cpu, uint8_t *r)
663 {
664 int16_t result = cpu->A + *r;
665 cpu->flags.S = ((int8_t)result < 0);
666 cpu->flags.Z = ((uint8_t)result == 0);
667 cpu->flags.H = ((cpu->A & 0x0F) + (*r & 0x0F) > 0x0F);
668 cpu->flags.PV = ((uint16_t)result > 0xFF);
669 cpu->flags.N = 0;
670 cpu->flags.C = result >> 8;
671 cpu->A = result;
672 clock_consume(4);
673 }
674
ADD_A_n(struct z80 * cpu)675 void ADD_A_n(struct z80 *cpu)
676 {
677 uint8_t n = memory_readb(cpu->bus_id, cpu->PC++);
678 int16_t result = cpu->A + n;
679 cpu->flags.S = ((int8_t)result < 0);
680 cpu->flags.Z = ((uint8_t)result == 0);
681 cpu->flags.H = ((cpu->A & 0x0F) + (n & 0x0F) > 0x0F);
682 cpu->flags.PV = ((uint16_t)result > 0xFF);
683 cpu->flags.N = 0;
684 cpu->flags.C = result >> 8;
685 cpu->A = result;
686 clock_consume(7);
687 }
688
ADD_A_cHL(struct z80 * cpu)689 void ADD_A_cHL(struct z80 *cpu)
690 {
691 uint8_t b = memory_readb(cpu->bus_id, cpu->HL);
692 int16_t result = cpu->A + b;
693 cpu->flags.S = ((int8_t)result < 0);
694 cpu->flags.Z = ((uint8_t)result == 0);
695 cpu->flags.H = ((cpu->A & 0x0F) + (b & 0x0F) > 0x0F);
696 cpu->flags.PV = ((uint16_t)result > 0xFF);
697 cpu->flags.N = 0;
698 cpu->flags.C = result >> 8;
699 cpu->A = result;
700 clock_consume(7);
701 }
702
ADD_A_cIXYpd(struct z80 * cpu,uint16_t * reg)703 void ADD_A_cIXYpd(struct z80 *cpu, uint16_t *reg)
704 {
705 int8_t d = memory_readb(cpu->bus_id, cpu->PC++);
706 uint16_t address = *reg + d;
707 uint8_t b = memory_readb(cpu->bus_id, address);
708 int16_t result = cpu->A + b;
709 cpu->flags.S = ((int8_t)result < 0);
710 cpu->flags.Z = ((uint8_t)result == 0);
711 cpu->flags.H = ((cpu->A & 0x0F) + (b & 0x0F) > 0x0F);
712 cpu->flags.PV = ((uint16_t)result > 0xFF);
713 cpu->flags.N = 0;
714 cpu->flags.C = result >> 8;
715 cpu->A = result;
716 clock_consume(19);
717 }
718
ADC_A_r(struct z80 * cpu,uint8_t * r)719 void ADC_A_r(struct z80 *cpu, uint8_t *r)
720 {
721 int16_t result = cpu->A + *r + cpu->flags.C;
722 cpu->flags.S = ((int8_t)result < 0);
723 cpu->flags.Z = ((uint8_t)result == 0);
724 cpu->flags.H = ((cpu->A & 0x0F) + (*r & 0x0F) + cpu->flags.C > 0x0F);
725 cpu->flags.PV = ((uint16_t)result > 0xFF);
726 cpu->flags.N = 0;
727 cpu->flags.C = result >> 8;
728 cpu->A = result;
729 clock_consume(4);
730 }
731
ADC_A_n(struct z80 * cpu)732 void ADC_A_n(struct z80 *cpu)
733 {
734 uint8_t n = memory_readb(cpu->bus_id, cpu->PC++);
735 int16_t result = cpu->A + n + cpu->flags.C;
736 cpu->flags.S = ((int8_t)result < 0);
737 cpu->flags.Z = ((uint8_t)result == 0);
738 cpu->flags.H = ((cpu->A & 0x0F) + (n & 0x0F) + cpu->flags.C > 0x0F);
739 cpu->flags.PV = ((uint16_t)result > 0xFF);
740 cpu->flags.N = 0;
741 cpu->flags.C = result >> 8;
742 cpu->A = result;
743 clock_consume(7);
744 }
745
ADC_A_cHL(struct z80 * cpu)746 void ADC_A_cHL(struct z80 *cpu)
747 {
748 uint8_t b = memory_readb(cpu->bus_id, cpu->HL);
749 int16_t result = cpu->A + b + cpu->flags.C;
750 cpu->flags.S = ((int8_t)result < 0);
751 cpu->flags.Z = ((uint8_t)result == 0);
752 cpu->flags.H = ((cpu->A & 0x0F) + (b & 0x0F) + cpu->flags.C > 0x0F);
753 cpu->flags.PV = ((uint16_t)result > 0xFF);
754 cpu->flags.N = 0;
755 cpu->flags.C = result >> 8;
756 cpu->A = result;
757 clock_consume(7);
758 }
759
ADC_A_cIXYpd(struct z80 * cpu,uint16_t * reg)760 void ADC_A_cIXYpd(struct z80 *cpu, uint16_t *reg)
761 {
762 int8_t d = memory_readb(cpu->bus_id, cpu->PC++);
763 uint16_t address = *reg + d;
764 uint8_t b = memory_readb(cpu->bus_id, address);
765 int16_t result = cpu->A + b + cpu->flags.C;
766 cpu->flags.S = ((int8_t)result < 0);
767 cpu->flags.Z = ((uint8_t)result == 0);
768 cpu->flags.H = ((cpu->A & 0x0F) + (b & 0x0F) + cpu->flags.C > 0x0F);
769 cpu->flags.PV = ((uint16_t)result > 0xFF);
770 cpu->flags.N = 0;
771 cpu->flags.C = result >> 8;
772 cpu->A = result;
773 clock_consume(19);
774 }
775
SUB_A_r(struct z80 * cpu,uint8_t * r)776 void SUB_A_r(struct z80 *cpu, uint8_t *r)
777 {
778 int16_t result = cpu->A - *r;
779 cpu->flags.S = ((int8_t)result < 0);
780 cpu->flags.Z = ((uint8_t)result == 0);
781 cpu->flags.H = ((cpu->A & 0x0F) - (*r & 0x0F) < 0);
782 cpu->flags.PV = ((uint16_t)result > 0xFF);
783 cpu->flags.N = 1;
784 cpu->flags.C = result >> 8;
785 cpu->A = result;
786 clock_consume(4);
787 }
788
SUB_A_n(struct z80 * cpu)789 void SUB_A_n(struct z80 *cpu)
790 {
791 uint8_t n = memory_readb(cpu->bus_id, cpu->PC++);
792 int16_t result = cpu->A - n;
793 cpu->flags.S = ((int8_t)result < 0);
794 cpu->flags.Z = ((uint8_t)result == 0);
795 cpu->flags.H = ((cpu->A & 0x0F) - (n & 0x0F) < 0);
796 cpu->flags.PV = ((uint16_t)result > 0xFF);
797 cpu->flags.N = 1;
798 cpu->flags.C = result >> 8;
799 cpu->A = result;
800 clock_consume(7);
801 }
802
SUB_A_cHL(struct z80 * cpu)803 void SUB_A_cHL(struct z80 *cpu)
804 {
805 uint8_t b = memory_readb(cpu->bus_id, cpu->HL);
806 int16_t result = cpu->A - memory_readb(cpu->bus_id, cpu->HL);
807 cpu->flags.S = ((int8_t)result < 0);
808 cpu->flags.Z = ((uint8_t)result == 0);
809 cpu->flags.H = ((cpu->A & 0x0F) - (b & 0x0F) < 0);
810 cpu->flags.PV = ((uint16_t)result > 0xFF);
811 cpu->flags.N = 1;
812 cpu->flags.C = result >> 8;
813 cpu->A = result;
814 clock_consume(7);
815 }
816
SUB_A_cIXYpd(struct z80 * cpu,uint16_t * reg)817 void SUB_A_cIXYpd(struct z80 *cpu, uint16_t *reg)
818 {
819 int8_t d = memory_readb(cpu->bus_id, cpu->PC++);
820 uint16_t address = *reg + d;
821 uint8_t b = memory_readb(cpu->bus_id, address);
822 int16_t result = cpu->A - b;
823 cpu->flags.S = ((int8_t)result < 0);
824 cpu->flags.Z = ((uint8_t)result == 0);
825 cpu->flags.H = ((cpu->A & 0x0F) - (b & 0x0F) < 0);
826 cpu->flags.PV = ((uint16_t)result > 0xFF);
827 cpu->flags.N = 1;
828 cpu->flags.C = result >> 8;
829 cpu->A = result;
830 clock_consume(19);
831 }
832
SBC_A_r(struct z80 * cpu,uint8_t * r)833 void SBC_A_r(struct z80 *cpu, uint8_t *r)
834 {
835 int16_t result = cpu->A - *r - cpu->flags.C;
836 cpu->flags.S = ((int8_t)result < 0);
837 cpu->flags.Z = ((uint8_t)result == 0);
838 cpu->flags.H = ((cpu->A & 0x0F) - (*r & 0x0F) - cpu->flags.C < 0);
839 cpu->flags.PV = ((uint16_t)result > 0xFF);
840 cpu->flags.N = 1;
841 cpu->flags.C = result >> 8;
842 cpu->A = result;
843 clock_consume(4);
844 }
845
SBC_A_n(struct z80 * cpu)846 void SBC_A_n(struct z80 *cpu)
847 {
848 uint8_t n = memory_readb(cpu->bus_id, cpu->PC++);
849 int16_t result = cpu->A - n - cpu->flags.C;
850 cpu->flags.S = ((int8_t)result < 0);
851 cpu->flags.Z = ((uint8_t)result == 0);
852 cpu->flags.H = ((cpu->A & 0x0F) - (n & 0x0F) - cpu->flags.C < 0);
853 cpu->flags.PV = ((uint16_t)result > 0xFF);
854 cpu->flags.N = 1;
855 cpu->flags.C = result >> 8;
856 cpu->A = result;
857 clock_consume(7);
858 }
859
SBC_A_cHL(struct z80 * cpu)860 void SBC_A_cHL(struct z80 *cpu)
861 {
862 uint8_t b = memory_readb(cpu->bus_id, cpu->HL);
863 int16_t result = cpu->A - b - cpu->flags.C;
864 cpu->flags.S = (result < 0);
865 cpu->flags.Z = ((uint8_t)result == 0);
866 cpu->flags.H = ((cpu->A & 0x0F) - b - cpu->flags.C < 0);
867 cpu->flags.PV = ((uint16_t)result > 0xFF);
868 cpu->flags.N = 1;
869 cpu->flags.C = result >> 8;
870 cpu->A = result;
871 clock_consume(7);
872 }
873
SBC_A_cIXYpd(struct z80 * cpu,uint16_t * reg)874 void SBC_A_cIXYpd(struct z80 *cpu, uint16_t *reg)
875 {
876 int8_t d = memory_readb(cpu->bus_id, cpu->PC++);
877 uint16_t address = *reg + d;
878 uint8_t b = memory_readb(cpu->bus_id, address);
879 int16_t result = cpu->A - b - cpu->flags.C;
880 cpu->flags.S = (result < 0);
881 cpu->flags.Z = ((uint8_t)result == 0);
882 cpu->flags.H = ((cpu->A & 0x0F) - b - cpu->flags.C < 0);
883 cpu->flags.PV = ((uint16_t)result > 0xFF);
884 cpu->flags.N = 1;
885 cpu->flags.C = result >> 8;
886 cpu->A = result;
887 clock_consume(19);
888 }
889
AND_r(struct z80 * cpu,uint8_t * r)890 void AND_r(struct z80 *cpu, uint8_t *r)
891 {
892 cpu->A &= *r;
893 cpu->flags.S = ((int8_t)cpu->A < 0);
894 cpu->flags.Z = (cpu->A == 0);
895 cpu->flags.H = 1;
896 cpu->flags.PV = !bitops_parity(cpu->A);
897 cpu->flags.N = 0;
898 cpu->flags.C = 0;
899 clock_consume(4);
900 }
901
AND_n(struct z80 * cpu)902 void AND_n(struct z80 *cpu)
903 {
904 cpu->A &= memory_readb(cpu->bus_id, cpu->PC++);
905 cpu->flags.S = ((int8_t)cpu->A < 0);
906 cpu->flags.Z = (cpu->A == 0);
907 cpu->flags.H = 1;
908 cpu->flags.PV = !bitops_parity(cpu->A);
909 cpu->flags.N = 0;
910 cpu->flags.C = 0;
911 clock_consume(7);
912 }
913
AND_cHL(struct z80 * cpu)914 void AND_cHL(struct z80 *cpu)
915 {
916 cpu->A &= memory_readb(cpu->bus_id, cpu->HL);
917 cpu->flags.S = ((int8_t)cpu->A < 0);
918 cpu->flags.Z = (cpu->A == 0);
919 cpu->flags.H = 1;
920 cpu->flags.PV = !bitops_parity(cpu->A);
921 cpu->flags.N = 0;
922 cpu->flags.C = 0;
923 clock_consume(7);
924 }
925
AND_cIXYpd(struct z80 * cpu,uint16_t * reg)926 void AND_cIXYpd(struct z80 *cpu, uint16_t *reg)
927 {
928 int8_t d = memory_readb(cpu->bus_id, cpu->PC++);
929 cpu->A &= memory_readb(cpu->bus_id, *reg + d);
930 cpu->flags.S = ((int8_t)cpu->A < 0);
931 cpu->flags.Z = (cpu->A == 0);
932 cpu->flags.H = 1;
933 cpu->flags.PV = !bitops_parity(cpu->A);
934 cpu->flags.N = 0;
935 cpu->flags.C = 0;
936 clock_consume(19);
937 }
938
OR_r(struct z80 * cpu,uint8_t * r)939 void OR_r(struct z80 *cpu, uint8_t *r)
940 {
941 cpu->A |= *r;
942 cpu->flags.S = ((int8_t)cpu->A < 0);
943 cpu->flags.Z = (cpu->A == 0);
944 cpu->flags.H = 0;
945 cpu->flags.PV = !bitops_parity(cpu->A);
946 cpu->flags.N = 0;
947 cpu->flags.C = 0;
948 clock_consume(4);
949 }
950
OR_n(struct z80 * cpu)951 void OR_n(struct z80 *cpu)
952 {
953 cpu->A |= memory_readb(cpu->bus_id, cpu->PC++);
954 cpu->flags.S = ((int8_t)cpu->A < 0);
955 cpu->flags.Z = (cpu->A == 0);
956 cpu->flags.H = 0;
957 cpu->flags.PV = !bitops_parity(cpu->A);
958 cpu->flags.N = 0;
959 cpu->flags.C = 0;
960 clock_consume(7);
961 }
962
OR_cHL(struct z80 * cpu)963 void OR_cHL(struct z80 *cpu)
964 {
965 cpu->A |= memory_readb(cpu->bus_id, cpu->HL);
966 cpu->flags.S = ((int8_t)cpu->A < 0);
967 cpu->flags.Z = (cpu->A == 0);
968 cpu->flags.H = 0;
969 cpu->flags.PV = !bitops_parity(cpu->A);
970 cpu->flags.N = 0;
971 cpu->flags.C = 0;
972 clock_consume(7);
973 }
974
OR_cIXYpd(struct z80 * cpu,uint16_t * reg)975 void OR_cIXYpd(struct z80 *cpu, uint16_t *reg)
976 {
977 int8_t d = memory_readb(cpu->bus_id, cpu->PC++);
978 cpu->A |= memory_readb(cpu->bus_id, *reg + d);
979 cpu->flags.S = ((int8_t)cpu->A < 0);
980 cpu->flags.Z = (cpu->A == 0);
981 cpu->flags.H = 0;
982 cpu->flags.PV = !bitops_parity(cpu->A);
983 cpu->flags.N = 0;
984 cpu->flags.C = 0;
985 clock_consume(19);
986 }
987
XOR_r(struct z80 * cpu,uint8_t * r)988 void XOR_r(struct z80 *cpu, uint8_t *r)
989 {
990 cpu->A ^= *r;
991 cpu->flags.S = ((int8_t)cpu->A < 0);
992 cpu->flags.Z = (cpu->A == 0);
993 cpu->flags.H = 0;
994 cpu->flags.PV = !bitops_parity(cpu->A);
995 cpu->flags.N = 0;
996 cpu->flags.C = 0;
997 clock_consume(4);
998 }
999
XOR_n(struct z80 * cpu)1000 void XOR_n(struct z80 *cpu)
1001 {
1002 cpu->A ^= memory_readb(cpu->bus_id, cpu->PC++);
1003 cpu->flags.S = ((int8_t)cpu->A < 0);
1004 cpu->flags.Z = (cpu->A == 0);
1005 cpu->flags.H = 0;
1006 cpu->flags.PV = !bitops_parity(cpu->A);
1007 cpu->flags.N = 0;
1008 cpu->flags.C = 0;
1009 clock_consume(7);
1010 }
1011
XOR_cHL(struct z80 * cpu)1012 void XOR_cHL(struct z80 *cpu)
1013 {
1014 cpu->A ^= memory_readb(cpu->bus_id, cpu->HL);
1015 cpu->flags.S = ((int8_t)cpu->A < 0);
1016 cpu->flags.Z = (cpu->A == 0);
1017 cpu->flags.H = 0;
1018 cpu->flags.PV = !bitops_parity(cpu->A);
1019 cpu->flags.N = 0;
1020 cpu->flags.C = 0;
1021 clock_consume(7);
1022 }
1023
XOR_cIXYpd(struct z80 * cpu,uint16_t * reg)1024 void XOR_cIXYpd(struct z80 *cpu, uint16_t *reg)
1025 {
1026 int8_t d = memory_readb(cpu->bus_id, cpu->PC++);
1027 cpu->A ^= memory_readb(cpu->bus_id, *reg + d);
1028 cpu->flags.S = ((int8_t)cpu->A < 0);
1029 cpu->flags.Z = (cpu->A == 0);
1030 cpu->flags.H = 0;
1031 cpu->flags.PV = !bitops_parity(cpu->A);
1032 cpu->flags.N = 0;
1033 cpu->flags.C = 0;
1034 clock_consume(19);
1035 }
1036
CP_r(struct z80 * cpu,uint8_t * r)1037 void CP_r(struct z80 *cpu, uint8_t *r)
1038 {
1039 int16_t result = cpu->A - *r;
1040 cpu->flags.S = ((int8_t)result < 0);
1041 cpu->flags.Z = ((uint8_t)result == 0);
1042 cpu->flags.H = ((cpu->A & 0x0F) - (*r & 0x0F) < 0);
1043 cpu->flags.PV = ((uint16_t)result > 0xFF);
1044 cpu->flags.N = 1;
1045 cpu->flags.C = result >> 8;
1046 clock_consume(4);
1047 }
1048
CP_n(struct z80 * cpu)1049 void CP_n(struct z80 *cpu)
1050 {
1051 uint8_t n = memory_readb(cpu->bus_id, cpu->PC++);
1052 int16_t result = cpu->A - n;
1053 cpu->flags.S = ((int8_t)result < 0);
1054 cpu->flags.Z = ((uint8_t)result == 0);
1055 cpu->flags.H = ((cpu->A & 0x0F) - (n & 0x0F) < 0);
1056 cpu->flags.PV = ((uint16_t)result > 0xFF);
1057 cpu->flags.N = 1;
1058 cpu->flags.C = result >> 8;
1059 clock_consume(7);
1060 }
1061
CP_cHL(struct z80 * cpu)1062 void CP_cHL(struct z80 *cpu)
1063 {
1064 uint8_t b = memory_readb(cpu->bus_id, cpu->HL);
1065 int16_t result = cpu->A - b;
1066 cpu->flags.S = ((int8_t)result < 0);
1067 cpu->flags.Z = ((uint8_t)result == 0);
1068 cpu->flags.H = ((cpu->A & 0x0F) - (b & 0x0F) < 0);
1069 cpu->flags.PV = ((uint16_t)result > 0xFF);
1070 cpu->flags.N = 1;
1071 cpu->flags.C = result >> 8;
1072 clock_consume(7);
1073 }
1074
CP_IXYpd(struct z80 * cpu,uint16_t * reg)1075 void CP_IXYpd(struct z80 *cpu, uint16_t *reg)
1076 {
1077 int8_t d = memory_readb(cpu->bus_id, cpu->PC++);
1078 uint16_t address = *reg + d;
1079 uint8_t b = memory_readb(cpu->bus_id, address);
1080 int16_t result = cpu->A - b;
1081 cpu->flags.S = ((int8_t)result < 0);
1082 cpu->flags.Z = ((uint8_t)result == 0);
1083 cpu->flags.H = ((cpu->A & 0x0F) - (b & 0x0F) < 0);
1084 cpu->flags.PV = ((uint16_t)result > 0xFF);
1085 cpu->flags.N = 1;
1086 cpu->flags.C = result >> 8;
1087 clock_consume(19);
1088 }
1089
INC_r(struct z80 * cpu,uint8_t * r)1090 void INC_r(struct z80 *cpu, uint8_t *r)
1091 {
1092 cpu->flags.S = ((int8_t)(*r + 1) < 0);
1093 cpu->flags.Z = (*r == 0xFF);
1094 cpu->flags.H = ((*r & 0x0F) == 0x0F);
1095 cpu->flags.PV = (*r == 0x7F);
1096 cpu->flags.N = 0;
1097 (*r)++;
1098 clock_consume(4);
1099 }
1100
INC_cHL(struct z80 * cpu)1101 void INC_cHL(struct z80 *cpu)
1102 {
1103 uint8_t b = memory_readb(cpu->bus_id, cpu->HL);
1104 cpu->flags.S = ((int8_t)(b + 1) < 0);
1105 cpu->flags.Z = (b == 0xFF);
1106 cpu->flags.H = ((b & 0x0F) == 0x0F);
1107 cpu->flags.PV = (b == 0x7F);
1108 cpu->flags.N = 0;
1109 memory_writeb(cpu->bus_id, b + 1, cpu->HL);
1110 clock_consume(11);
1111 }
1112
INC_cIXYpd(struct z80 * cpu,uint16_t * reg)1113 void INC_cIXYpd(struct z80 *cpu, uint16_t *reg)
1114 {
1115 int8_t d = memory_readb(cpu->bus_id, cpu->PC++);
1116 uint16_t address = *reg + d;
1117 uint8_t b = memory_readb(cpu->bus_id, address);
1118 cpu->flags.S = ((int8_t)(b + 1) < 0);
1119 cpu->flags.Z = (b == 0xFF);
1120 cpu->flags.H = ((b & 0x0F) == 0x0F);
1121 cpu->flags.PV = (b == 0x7F);
1122 cpu->flags.N = 0;
1123 memory_writeb(cpu->bus_id, b + 1, address);
1124 clock_consume(23);
1125 }
1126
DEC_r(struct z80 * cpu,uint8_t * r)1127 void DEC_r(struct z80 *cpu, uint8_t *r)
1128 {
1129 (*r)--;
1130 cpu->flags.S = ((int8_t)*r < 0);
1131 cpu->flags.Z = (*r == 0);
1132 cpu->flags.H = ((*r & 0x0F) == 0x0F);
1133 cpu->flags.PV = (*r == 0x7F);
1134 cpu->flags.N = 1;
1135 clock_consume(4);
1136 }
1137
DEC_cHL(struct z80 * cpu)1138 void DEC_cHL(struct z80 *cpu)
1139 {
1140 int8_t result = memory_readb(cpu->bus_id, cpu->HL) - 1;
1141 memory_writeb(cpu->bus_id, result, cpu->HL);
1142 cpu->flags.S = (result < 0);
1143 cpu->flags.Z = (result == 0);
1144 cpu->flags.H = ((result & 0x0F) == 0x0F);
1145 cpu->flags.PV = (result == 0x7F);
1146 cpu->flags.N = 1;
1147 clock_consume(11);
1148 }
1149
DEC_cIXYpd(struct z80 * cpu,uint16_t * reg)1150 void DEC_cIXYpd(struct z80 *cpu, uint16_t *reg)
1151 {
1152 int8_t d = memory_readb(cpu->bus_id, cpu->PC++);
1153 uint16_t address = *reg + d;
1154 uint8_t b = memory_readb(cpu->bus_id, address);
1155 int8_t result = b - 1;
1156 memory_writeb(cpu->bus_id, result, address);
1157 cpu->flags.S = (result < 0);
1158 cpu->flags.Z = (result == 0);
1159 cpu->flags.H = ((b & 0x0F) - 1 == 0x0F);
1160 cpu->flags.PV = (b == 0x80);
1161 cpu->flags.N = 0;
1162 clock_consume(23);
1163 }
1164
DAA(struct z80 * cpu)1165 void DAA(struct z80 *cpu)
1166 {
1167 int a = cpu->A;
1168
1169 /* Update A based on N/H/C flags */
1170 if (!cpu->flags.N) {
1171 if (cpu->flags.H || ((a & 0x0F) > 9))
1172 a += 6;
1173 if (cpu->flags.C || (a > 0x9F))
1174 a += 0x60;
1175 } else {
1176 if (cpu->flags.H)
1177 a = (cpu->A - 6) & 0xFF;
1178 if (cpu->flags.C)
1179 a -= 0x60;
1180 }
1181 cpu->A = a & 0xFF;
1182
1183 /* Set flags */
1184 cpu->flags.S = ((cpu->A & 0x80) != 0);
1185 cpu->flags.Z = (cpu->A == 0);
1186 cpu->flags.H = 0;
1187
1188 /* Set carry flag if needed */
1189 if (a & 0x100)
1190 cpu->flags.C = 1;
1191
1192 /* Consume cycles */
1193 clock_consume(4);
1194 }
1195
CPL(struct z80 * cpu)1196 void CPL(struct z80 *cpu)
1197 {
1198 cpu->A = ~cpu->A;
1199 cpu->flags.H = 1;
1200 cpu->flags.N = 1;
1201 clock_consume(4);
1202 }
1203
NEG(struct z80 * cpu)1204 void NEG(struct z80 *cpu)
1205 {
1206 int8_t result = -cpu->A;
1207 cpu->flags.S = (result < 0);
1208 cpu->flags.Z = (result == 0);
1209 cpu->flags.H = ((result & 0x0F) < 0);
1210 cpu->flags.PV = (cpu->A != 0x80);
1211 cpu->flags.N = 1;
1212 cpu->flags.C = (cpu->A != 0);
1213 cpu->A = result;
1214 clock_consume(8);
1215 }
1216
CCF(struct z80 * cpu)1217 void CCF(struct z80 *cpu)
1218 {
1219 cpu->flags.H = cpu->flags.C;
1220 cpu->flags.N = 0;
1221 cpu->flags.C = !cpu->flags.C;
1222 clock_consume(4);
1223 }
1224
SCF(struct z80 * cpu)1225 void SCF(struct z80 *cpu)
1226 {
1227 cpu->flags.H = 0;
1228 cpu->flags.N = 0;
1229 cpu->flags.C = 1;
1230 clock_consume(4);
1231 }
1232
NOP(struct z80 * UNUSED (cpu))1233 void NOP(struct z80 *UNUSED(cpu))
1234 {
1235 clock_consume(4);
1236 }
1237
HALT(struct z80 * cpu)1238 void HALT(struct z80 *cpu)
1239 {
1240 cpu->halted = true;
1241 cpu->PC--;
1242 clock_consume(4);
1243 }
1244
DI(struct z80 * cpu)1245 void DI(struct z80 *cpu)
1246 {
1247 cpu->IFF1 = false;
1248 cpu->IFF2 = false;
1249 clock_consume(4);
1250 }
1251
EI(struct z80 * cpu)1252 void EI(struct z80 *cpu)
1253 {
1254 cpu->IFF1 = true;
1255 cpu->IFF2 = true;
1256 cpu->irq_delay = true;
1257 clock_consume(4);
1258 }
1259
IM_0(struct z80 * cpu)1260 void IM_0(struct z80 *cpu)
1261 {
1262 LOG_W("IM 0: unsupported interrupt mode!\n");
1263 cpu->interrupt_mode = 0;
1264 clock_consume(8);
1265 }
1266
IM_1(struct z80 * cpu)1267 void IM_1(struct z80 *cpu)
1268 {
1269 cpu->interrupt_mode = 1;
1270 clock_consume(8);
1271 }
1272
IM_2(struct z80 * cpu)1273 void IM_2(struct z80 *cpu)
1274 {
1275 LOG_W("IM 2: unsupported interrupt mode!\n");
1276 cpu->interrupt_mode = 2;
1277 clock_consume(8);
1278 }
1279
ADD_HL_ss(struct z80 * cpu,uint16_t * ss)1280 void ADD_HL_ss(struct z80 *cpu, uint16_t *ss)
1281 {
1282 uint32_t result = cpu->HL + *ss;
1283 cpu->flags.H = ((cpu->HL & 0x0FFF) + (*ss & 0x0FFF) > 0x0FFF);
1284 cpu->flags.N = 0;
1285 cpu->flags.C = result >> 16;
1286 cpu->HL = result;
1287 clock_consume(11);
1288 }
1289
ADC_HL_rr(struct z80 * cpu,uint16_t * rr)1290 void ADC_HL_rr(struct z80 *cpu, uint16_t *rr)
1291 {
1292 int32_t result = cpu->HL + *rr + cpu->flags.C;
1293 uint16_t h_result = (cpu->HL & 0x0FFF) + (*rr & 0x0FFF) + cpu->flags.C;
1294 cpu->flags.S = ((int16_t)result < 0);
1295 cpu->flags.Z = ((uint16_t)result == 0);
1296 cpu->flags.H = (h_result > 0x0FFF);
1297 cpu->flags.PV = ((uint16_t)result > 0xFF);
1298 cpu->flags.N = 0;
1299 cpu->flags.C = result >> 16;
1300 cpu->HL = result;
1301 clock_consume(15);
1302 }
1303
SBC_HL_rr(struct z80 * cpu,uint16_t * rr)1304 void SBC_HL_rr(struct z80 *cpu, uint16_t *rr)
1305 {
1306 int32_t result = cpu->HL - *rr - cpu->flags.C;
1307 int16_t h_result = (cpu->HL & 0x0FFF) - (*rr & 0x0FFF) - cpu->flags.C;
1308 cpu->flags.S = ((int16_t)result < 0);
1309 cpu->flags.Z = ((uint16_t)result == 0);
1310 cpu->flags.H = (h_result < 0);
1311 cpu->flags.PV = ((uint16_t)result > 0xFF);
1312 cpu->flags.N = 1;
1313 cpu->flags.C = result >> 16;
1314 cpu->HL = result;
1315 clock_consume(15);
1316 }
1317
ADD_IXY_pp(struct z80 * cpu,uint16_t * rr,uint16_t * reg)1318 void ADD_IXY_pp(struct z80 *cpu, uint16_t *rr, uint16_t *reg)
1319 {
1320 uint32_t result = *reg + *rr;
1321 cpu->flags.H = ((*reg & 0x0FFF) + (*rr & 0x0FFF) > 0x0FFF);
1322 cpu->flags.N = 0;
1323 cpu->flags.C = result >> 16;
1324 *reg = result;
1325 clock_consume(15);
1326 }
1327
INC_ss(uint16_t * ss)1328 void INC_ss(uint16_t *ss)
1329 {
1330 (*ss)++;
1331 clock_consume(6);
1332 }
1333
DEC_ss(uint16_t * rr)1334 void DEC_ss(uint16_t *rr)
1335 {
1336 (*rr)--;
1337 clock_consume(6);
1338 }
1339
DEC_IXY(uint16_t * reg)1340 void DEC_IXY(uint16_t *reg)
1341 {
1342 (*reg)--;
1343 clock_consume(10);
1344 }
1345
RLCA(struct z80 * cpu)1346 void RLCA(struct z80 *cpu)
1347 {
1348 cpu->flags.Z = 0;
1349 cpu->flags.H = 0;
1350 cpu->flags.N = 0;
1351 cpu->flags.C = ((cpu->A & 0x80) != 0);
1352 cpu->A = (cpu->A << 1) | cpu->flags.C;
1353 clock_consume(4);
1354 }
1355
RLA(struct z80 * cpu)1356 void RLA(struct z80 *cpu)
1357 {
1358 int old_carry = cpu->flags.C;
1359 cpu->flags.Z = 0;
1360 cpu->flags.H = 0;
1361 cpu->flags.N = 0;
1362 cpu->flags.C = ((cpu->A & 0x80) != 0);
1363 cpu->A = (cpu->A << 1) | old_carry;
1364 clock_consume(4);
1365 }
1366
RRCA(struct z80 * cpu)1367 void RRCA(struct z80 *cpu)
1368 {
1369 cpu->flags.Z = 0;
1370 cpu->flags.H = 0;
1371 cpu->flags.N = 0;
1372 cpu->flags.C = ((cpu->A & 0x01) != 0);
1373 cpu->A = (cpu->A >> 1) | (cpu->flags.C << 7);
1374 clock_consume(4);
1375 }
1376
RRA(struct z80 * cpu)1377 void RRA(struct z80 *cpu)
1378 {
1379 int old_carry = cpu->flags.C;
1380 cpu->flags.Z = 0;
1381 cpu->flags.H = 0;
1382 cpu->flags.N = 0;
1383 cpu->flags.C = ((cpu->A & 0x01) != 0);
1384 cpu->A = (cpu->A >> 1) | (old_carry << 7);
1385 clock_consume(4);
1386 }
1387
RLC_r(struct z80 * cpu,uint8_t * r)1388 void RLC_r(struct z80 *cpu, uint8_t *r)
1389 {
1390 uint8_t b = *r;
1391 b = (*r << 1) | (*r >> 7);
1392 cpu->flags.S = ((int8_t)b < 0);
1393 cpu->flags.Z = (b == 0);
1394 cpu->flags.H = 0;
1395 cpu->flags.N = 0;
1396 cpu->flags.C = ((*r & 0x80) != 0);
1397 *r = b;
1398 clock_consume(8);
1399 }
1400
RLC_cHL(struct z80 * cpu)1401 void RLC_cHL(struct z80 *cpu)
1402 {
1403 uint8_t cHL = memory_readb(cpu->bus_id, cpu->HL);
1404 uint8_t b = ((cHL << 1) | (cHL >> 7));
1405 cpu->flags.S = ((int8_t)b < 0);
1406 cpu->flags.Z = (b == 0);
1407 cpu->flags.H = 0;
1408 cpu->flags.N = 0;
1409 cpu->flags.C = ((cHL & 0x80) != 0);
1410 memory_writeb(cpu->bus_id, b, cpu->HL);
1411 clock_consume(15);
1412 }
1413
RLC_cIXYpd(struct z80 * cpu,uint16_t * reg)1414 void RLC_cIXYpd(struct z80 *cpu, uint16_t *reg)
1415 {
1416 int8_t d = memory_readb(cpu->bus_id, cpu->PC++);
1417 uint16_t address = *reg + d;
1418 uint8_t cIXYpd = memory_readb(cpu->bus_id, address);
1419 uint8_t b = ((cIXYpd << 1) | (cIXYpd >> 7));
1420 cpu->flags.S = ((int8_t)b < 0);
1421 cpu->flags.Z = (b == 0);
1422 cpu->flags.H = 0;
1423 cpu->flags.N = 0;
1424 cpu->flags.C = ((cIXYpd & 0x80) != 0);
1425 memory_writeb(cpu->bus_id, (b << 1) | cpu->flags.C, address);
1426 clock_consume(23);
1427 }
1428
RL_r(struct z80 * cpu,uint8_t * r)1429 void RL_r(struct z80 *cpu, uint8_t *r)
1430 {
1431 int old_carry = cpu->flags.C;
1432 uint8_t b = (*r << 1) | old_carry;
1433 cpu->flags.S = ((int8_t)b < 0);
1434 cpu->flags.Z = (b == 0);
1435 cpu->flags.H = 0;
1436 cpu->flags.N = 0;
1437 cpu->flags.C = ((*r & 0x80) != 0);
1438 *r = (*r << 1) | old_carry;
1439 clock_consume(8);
1440 }
1441
RL_cHL(struct z80 * cpu)1442 void RL_cHL(struct z80 *cpu)
1443 {
1444 uint8_t cHL = memory_readb(cpu->bus_id, cpu->HL);
1445 int old_carry = cpu->flags.C;
1446 uint8_t b = (cHL << 1) | old_carry;
1447 cpu->flags.S = ((int8_t)b < 0);
1448 cpu->flags.Z = (b == 0);
1449 cpu->flags.H = 0;
1450 cpu->flags.N = 0;
1451 cpu->flags.C = ((cHL & 0x80) != 0);
1452 memory_writeb(cpu->bus_id, b, cpu->HL);
1453 clock_consume(15);
1454 }
1455
RL_cIXYpd(struct z80 * cpu,uint16_t * reg)1456 void RL_cIXYpd(struct z80 *cpu, uint16_t *reg)
1457 {
1458 int8_t d = memory_readb(cpu->bus_id, cpu->PC++);
1459 uint16_t address = *reg + d;
1460 uint8_t cIXYpd = memory_readb(cpu->bus_id, address);
1461 int old_carry = cpu->flags.C;
1462 uint8_t b = (cIXYpd << 1) | old_carry;
1463 cpu->flags.Z = (b == 0);
1464 cpu->flags.H = 0;
1465 cpu->flags.N = 0;
1466 cpu->flags.C = ((cIXYpd & 0x80) != 0);
1467 memory_writeb(cpu->bus_id, b, address);
1468 clock_consume(23);
1469 }
1470
RRC_r(struct z80 * cpu,uint8_t * r)1471 void RRC_r(struct z80 *cpu, uint8_t *r)
1472 {
1473 uint8_t result = (*r >> 1) | (cpu->flags.C << 7);
1474 cpu->flags.S = ((int8_t)result < 0);
1475 cpu->flags.Z = (result == 0);
1476 cpu->flags.H = 0;
1477 cpu->flags.N = 0;
1478 cpu->flags.C = ((*r & 0x01) != 0);
1479 *r = result;
1480 clock_consume(8);
1481 }
1482
RRC_cHL(struct z80 * cpu)1483 void RRC_cHL(struct z80 *cpu)
1484 {
1485 uint8_t b = memory_readb(cpu->bus_id, cpu->HL);
1486 uint8_t result = (b >> 1) | (cpu->flags.C << 7);
1487 cpu->flags.S = ((int8_t)result < 0);
1488 cpu->flags.Z = (result == 0);
1489 cpu->flags.H = 0;
1490 cpu->flags.N = 0;
1491 cpu->flags.C = ((b & 0x01) != 0);
1492 memory_writeb(cpu->bus_id, result, cpu->HL);
1493 clock_consume(15);
1494 }
1495
RRC_cIXYpd(struct z80 * cpu,uint16_t * reg)1496 void RRC_cIXYpd(struct z80 *cpu, uint16_t *reg)
1497 {
1498 int8_t d = memory_readb(cpu->bus_id, cpu->PC++);
1499 uint16_t address = *reg + d;
1500 uint8_t b = memory_readb(cpu->bus_id, address);
1501 uint8_t result = (b >> 1) | (cpu->flags.C << 7);
1502 cpu->flags.S = ((int8_t)result < 0);
1503 cpu->flags.Z = (result == 0);
1504 cpu->flags.H = 0;
1505 cpu->flags.N = 0;
1506 cpu->flags.C = ((b & 0x01) != 0);
1507 memory_writeb(cpu->bus_id, result, address);
1508 clock_consume(23);
1509 }
1510
RR_r(struct z80 * cpu,uint8_t * r)1511 void RR_r(struct z80 *cpu, uint8_t *r)
1512 {
1513 int old_carry = cpu->flags.C;
1514 uint8_t b = (*r >> 1) | (old_carry << 7);
1515 cpu->flags.S = ((int8_t)b < 0);
1516 cpu->flags.Z = (b == 0);
1517 cpu->flags.H = 0;
1518 cpu->flags.N = 0;
1519 cpu->flags.C = ((*r & 0x01) != 0);
1520 *r = b;
1521 clock_consume(8);
1522 }
1523
RR_cHL(struct z80 * cpu)1524 void RR_cHL(struct z80 *cpu)
1525 {
1526 uint8_t cHL = memory_readb(cpu->bus_id, cpu->HL);
1527 int old_carry = cpu->flags.C;
1528 uint8_t b = (cHL >> 1) | (old_carry << 7);
1529 cpu->flags.S = ((int8_t)b < 0);
1530 cpu->flags.Z = (b == 0);
1531 cpu->flags.H = 0;
1532 cpu->flags.N = 0;
1533 cpu->flags.C = ((cHL & 0x01) != 0);
1534 memory_writeb(cpu->bus_id, b, cpu->HL);
1535 clock_consume(15);
1536 }
1537
RR_cIXYpd(struct z80 * cpu,uint16_t * reg)1538 void RR_cIXYpd(struct z80 *cpu, uint16_t *reg)
1539 {
1540 int8_t d = memory_readb(cpu->bus_id, cpu->PC++);
1541 uint16_t address = *reg + d;
1542 uint8_t cIXYpd = memory_readb(cpu->bus_id, address);
1543 int old_carry = cpu->flags.C;
1544 uint8_t b = (cIXYpd >> 1) | (old_carry << 7);
1545 cpu->flags.S = ((int8_t)b < 0);
1546 cpu->flags.Z = (b == 0);
1547 cpu->flags.H = 0;
1548 cpu->flags.N = 0;
1549 cpu->flags.C = ((cIXYpd & 0x01) != 0);
1550 memory_writeb(cpu->bus_id, b, address);
1551 clock_consume(23);
1552 }
1553
SLA_r(struct z80 * cpu,uint8_t * r)1554 void SLA_r(struct z80 *cpu, uint8_t *r)
1555 {
1556 uint8_t b = *r << 1;
1557 cpu->flags.S = ((int8_t)b < 0);
1558 cpu->flags.Z = (b == 0);
1559 cpu->flags.H = 0;
1560 cpu->flags.PV = bitops_parity(b);
1561 cpu->flags.N = 0;
1562 cpu->flags.C = ((*r & 0x80) != 0);
1563 *r = b;
1564 clock_consume(8);
1565 }
1566
SLA_cHL(struct z80 * cpu)1567 void SLA_cHL(struct z80 *cpu)
1568 {
1569 uint8_t cHL = memory_readb(cpu->bus_id, cpu->HL);
1570 uint8_t b = cHL << 1;
1571 cpu->flags.S = ((int8_t)b < 0);
1572 cpu->flags.Z = (b == 0);
1573 cpu->flags.H = 0;
1574 cpu->flags.PV = bitops_parity(b);
1575 cpu->flags.N = 0;
1576 cpu->flags.C = ((cHL & 0x80) != 0);
1577 memory_writeb(cpu->bus_id, b, cpu->HL);
1578 clock_consume(15);
1579 }
1580
SLA_cIXYpd(struct z80 * cpu,uint16_t * reg)1581 void SLA_cIXYpd(struct z80 *cpu, uint16_t *reg)
1582 {
1583 int8_t d = memory_readb(cpu->bus_id, cpu->PC++);
1584 uint16_t address = *reg + d;
1585 uint8_t cIXYpd = memory_readb(cpu->bus_id, address);
1586 uint8_t b = cIXYpd << 1;
1587 cpu->flags.S = ((int8_t)b < 0);
1588 cpu->flags.Z = ((b << 1) == 0);
1589 cpu->flags.H = 0;
1590 cpu->flags.PV = bitops_parity(b);
1591 cpu->flags.N = 0;
1592 cpu->flags.C = ((cIXYpd & 0x80) != 0);
1593 memory_writeb(cpu->bus_id, b, address);
1594 clock_consume(23);
1595 }
1596
SRA_r(struct z80 * cpu,uint8_t * r)1597 void SRA_r(struct z80 *cpu, uint8_t *r)
1598 {
1599 uint8_t b = (*r >> 1) | (*r & 0x80);
1600 cpu->flags.S = ((int8_t)b < 0);
1601 cpu->flags.Z = (b == 0);
1602 cpu->flags.H = 0;
1603 cpu->flags.PV = bitops_parity(b);
1604 cpu->flags.N = 0;
1605 cpu->flags.C = ((*r & 0x01) != 0);
1606 *r = b;
1607 clock_consume(8);
1608 }
1609
SRA_cHL(struct z80 * cpu)1610 void SRA_cHL(struct z80 *cpu)
1611 {
1612 uint8_t cHL = memory_readb(cpu->bus_id, cpu->HL);
1613 uint8_t b = (cHL >> 1) | (cHL & 0x80);
1614 cpu->flags.S = ((int8_t)b < 0);
1615 cpu->flags.Z = (b == 0);
1616 cpu->flags.H = 0;
1617 cpu->flags.PV = bitops_parity(b);
1618 cpu->flags.N = 0;
1619 cpu->flags.C = ((cHL & 0x01) != 0);
1620 memory_writeb(cpu->bus_id, b, cpu->HL);
1621 clock_consume(15);
1622 }
1623
SRA_cIXYpd(struct z80 * cpu,uint16_t * reg)1624 void SRA_cIXYpd(struct z80 *cpu, uint16_t *reg)
1625 {
1626 int8_t d = memory_readb(cpu->bus_id, cpu->PC++);
1627 uint16_t address = *reg + d;
1628 uint8_t cIXYpd = memory_readb(cpu->bus_id, address);
1629 uint8_t b = (cIXYpd >> 1) | (cIXYpd & 0x80);
1630 cpu->flags.S = ((int8_t)b < 0);
1631 cpu->flags.Z = (b == 0);
1632 cpu->flags.H = 0;
1633 cpu->flags.PV = bitops_parity(b);
1634 cpu->flags.N = 0;
1635 cpu->flags.C = ((cIXYpd & 0x01) != 0);
1636 memory_writeb(cpu->bus_id, b, address);
1637 clock_consume(23);
1638 }
1639
SL1_r(struct z80 * cpu,uint8_t * r)1640 void SL1_r(struct z80 *cpu, uint8_t *r)
1641 {
1642 uint8_t b = (*r << 1) | 0x01;
1643 cpu->flags.S = ((int8_t)b < 0);
1644 cpu->flags.Z = 0;
1645 cpu->flags.H = 0;
1646 cpu->flags.PV = bitops_parity(b);
1647 cpu->flags.N = 0;
1648 cpu->flags.C = ((*r & 0x80) != 0);
1649 *r = b;
1650 clock_consume(8);
1651 }
1652
SL1_cHL(struct z80 * cpu)1653 void SL1_cHL(struct z80 *cpu)
1654 {
1655 uint8_t cHL = memory_readb(cpu->bus_id, cpu->HL);
1656 uint8_t b = (cHL << 1) | 0x01;
1657 cpu->flags.S = ((int8_t)b < 0);
1658 cpu->flags.Z = 0;
1659 cpu->flags.H = 0;
1660 cpu->flags.PV = bitops_parity(b);
1661 cpu->flags.N = 0;
1662 cpu->flags.C = ((cHL & 0x80) != 0);
1663 memory_writeb(cpu->bus_id, b, cpu->HL);
1664 clock_consume(15);
1665 }
1666
SL1_cIXYpd(struct z80 * cpu,uint16_t * reg)1667 void SL1_cIXYpd(struct z80 *cpu, uint16_t *reg)
1668 {
1669 int8_t d = memory_readb(cpu->bus_id, cpu->PC++);
1670 uint16_t address = *reg + d;
1671 uint8_t cIXYpd = memory_readb(cpu->bus_id, address);
1672 uint8_t b = (cIXYpd << 1) | 0x01;
1673 cpu->flags.S = ((int8_t)b < 0);
1674 cpu->flags.Z = 0;
1675 cpu->flags.H = 0;
1676 cpu->flags.PV = bitops_parity(b);
1677 cpu->flags.N = 0;
1678 cpu->flags.C = ((cIXYpd & 0x80) != 0);
1679 memory_writeb(cpu->bus_id, b, address);
1680 clock_consume(23);
1681 }
1682
SRL_r(struct z80 * cpu,uint8_t * r)1683 void SRL_r(struct z80 *cpu, uint8_t *r)
1684 {
1685 uint8_t b = *r >> 1;
1686 cpu->flags.S = ((int8_t)b < 0);
1687 cpu->flags.Z = (b == 0);
1688 cpu->flags.H = 0;
1689 cpu->flags.PV = bitops_parity(b);
1690 cpu->flags.N = 0;
1691 cpu->flags.C = ((*r & 0x01) != 0);
1692 *r = b;
1693 clock_consume(8);
1694 }
1695
SRL_cHL(struct z80 * cpu)1696 void SRL_cHL(struct z80 *cpu)
1697 {
1698 uint8_t cHL = memory_readb(cpu->bus_id, cpu->HL);
1699 uint8_t b = cHL >> 1;
1700 cpu->flags.S = ((int8_t)b < 0);
1701 cpu->flags.Z = (b == 0);
1702 cpu->flags.H = 0;
1703 cpu->flags.PV = bitops_parity(b);
1704 cpu->flags.N = 0;
1705 cpu->flags.C = ((cHL & 0x01) != 0);
1706 memory_writeb(cpu->bus_id, b, cpu->HL);
1707 clock_consume(15);
1708 }
1709
SRL_cIXYpd(struct z80 * cpu,uint16_t * reg)1710 void SRL_cIXYpd(struct z80 *cpu, uint16_t *reg)
1711 {
1712 int8_t d = memory_readb(cpu->bus_id, cpu->PC++);
1713 uint16_t address = *reg + d;
1714 uint8_t cIXYpd = memory_readb(cpu->bus_id, address);
1715 uint8_t b = cIXYpd >> 1;
1716 cpu->flags.S = ((int8_t)b < 0);
1717 cpu->flags.Z = (b == 0);
1718 cpu->flags.H = 0;
1719 cpu->flags.PV = bitops_parity(b);
1720 cpu->flags.N = 0;
1721 cpu->flags.C = ((cIXYpd & 0x01) != 0);
1722 memory_writeb(cpu->bus_id, b, address);
1723 clock_consume(23);
1724 }
1725
RLD(struct z80 * cpu)1726 void RLD(struct z80 *cpu)
1727 {
1728 uint8_t b = memory_readb(cpu->bus_id, cpu->HL);
1729 memory_writeb(cpu->bus_id, (b << 4) | (cpu->A & 0x0F), cpu->HL);
1730 cpu->A = (cpu->A & 0xF0) | (b >> 4);
1731 cpu->flags.S = ((int8_t)cpu->A < 0);
1732 cpu->flags.Z = (cpu->A == 0);
1733 cpu->flags.H = 0;
1734 cpu->flags.PV = !bitops_parity(cpu->A);
1735 cpu->flags.N = 0;
1736 clock_consume(18);
1737 }
1738
RRD(struct z80 * cpu)1739 void RRD(struct z80 *cpu)
1740 {
1741 uint8_t b = memory_readb(cpu->bus_id, cpu->HL);
1742 memory_writeb(cpu->bus_id, (b >> 4) | ((cpu->A & 0x0F) << 4), cpu->HL);
1743 cpu->A = (cpu->A & 0xF0) | (b & 0x0F);
1744 cpu->flags.S = ((int8_t)cpu->A < 0);
1745 cpu->flags.Z = (cpu->A == 0);
1746 cpu->flags.H = 0;
1747 cpu->flags.PV = !bitops_parity(cpu->A);
1748 cpu->flags.N = 0;
1749 clock_consume(18);
1750 }
1751
BIT_b_r(struct z80 * cpu,uint8_t b,uint8_t * r)1752 void BIT_b_r(struct z80 *cpu, uint8_t b, uint8_t *r)
1753 {
1754 cpu->flags.Z = ((*r & (1 << b)) == 0);
1755 cpu->flags.H = 1;
1756 cpu->flags.N = 0;
1757 clock_consume(8);
1758 }
1759
BIT_b_cHL(struct z80 * cpu,uint8_t b)1760 void BIT_b_cHL(struct z80 *cpu, uint8_t b)
1761 {
1762 cpu->flags.Z = ((memory_readb(cpu->bus_id, cpu->HL) & (1 << b)) == 0);
1763 cpu->flags.H = 1;
1764 cpu->flags.N = 0;
1765 clock_consume(12);
1766 }
1767
BIT_b_cIXYpd(struct z80 * cpu,uint8_t b,uint16_t * reg)1768 void BIT_b_cIXYpd(struct z80 *cpu, uint8_t b, uint16_t *reg)
1769 {
1770 int8_t d;
1771 uint16_t address;
1772 uint8_t cIXYpd;
1773 d = memory_readb(cpu->bus_id, cpu->PC++);
1774 address = *reg + d;
1775 cIXYpd = memory_readb(cpu->bus_id, address);
1776 cpu->flags.Z = ((cIXYpd & (1 << b)) == 0);
1777 cpu->flags.H = 1;
1778 cpu->flags.N = 0;
1779 clock_consume(20);
1780 }
1781
SET_b_r(uint8_t b,uint8_t * r)1782 void SET_b_r(uint8_t b, uint8_t *r)
1783 {
1784 *r |= (1 << b);
1785 clock_consume(8);
1786 }
1787
SET_b_cHL(struct z80 * cpu,uint8_t b)1788 void SET_b_cHL(struct z80 *cpu, uint8_t b)
1789 {
1790 uint8_t cHL = memory_readb(cpu->bus_id, cpu->HL);
1791 memory_writeb(cpu->bus_id, cHL | (1 << b), cpu->HL);
1792 clock_consume(15);
1793 }
1794
SET_b_cIXYpd(struct z80 * cpu,uint8_t b,uint16_t * reg)1795 void SET_b_cIXYpd(struct z80 *cpu, uint8_t b, uint16_t *reg)
1796 {
1797 int8_t d = memory_readb(cpu->bus_id, cpu->PC++);
1798 uint16_t address = *reg + d;
1799 uint8_t cIXYpd = memory_readb(cpu->bus_id, address);
1800 memory_writeb(cpu->bus_id, cIXYpd | (1 << b), address);
1801 clock_consume(23);
1802 }
1803
RES_b_r(uint8_t b,uint8_t * r)1804 void RES_b_r(uint8_t b, uint8_t *r)
1805 {
1806 *r &= ~(1 << b);
1807 clock_consume(8);
1808 }
1809
RES_b_cHL(struct z80 * cpu,uint8_t b)1810 void RES_b_cHL(struct z80 *cpu, uint8_t b)
1811 {
1812 uint8_t cHL = memory_readb(cpu->bus_id, cpu->HL);
1813 memory_writeb(cpu->bus_id, cHL & ~(1 << b), cpu->HL);
1814 clock_consume(15);
1815 }
1816
RES_b_cIXYpd(struct z80 * cpu,uint8_t b,uint16_t * reg)1817 void RES_b_cIXYpd(struct z80 *cpu, uint8_t b, uint16_t *reg)
1818 {
1819 int8_t d = memory_readb(cpu->bus_id, cpu->PC++);
1820 uint16_t address = *reg + d;
1821 uint8_t cIXYpd = memory_readb(cpu->bus_id, address);
1822 memory_writeb(cpu->bus_id, cIXYpd & ~(1 << b), address);
1823 clock_consume(23);
1824 }
1825
JP_nn(struct z80 * cpu)1826 void JP_nn(struct z80 *cpu)
1827 {
1828 uint8_t n1 = memory_readb(cpu->bus_id, cpu->PC++);
1829 uint8_t n2 = memory_readb(cpu->bus_id, cpu->PC++);
1830 cpu->PC = n1 | (n2 << 8);
1831 clock_consume(10);
1832 }
1833
JP_cc_nn(struct z80 * cpu,bool condition)1834 void JP_cc_nn(struct z80 *cpu, bool condition)
1835 {
1836 uint8_t n1 = memory_readb(cpu->bus_id, cpu->PC++);
1837 uint8_t n2 = memory_readb(cpu->bus_id, cpu->PC++);
1838 if (condition)
1839 cpu->PC = n1 | (n2 << 8);
1840 clock_consume(10);
1841 }
1842
JR_e(struct z80 * cpu)1843 void JR_e(struct z80 *cpu)
1844 {
1845 int8_t e = memory_readb(cpu->bus_id, cpu->PC++);
1846 cpu->PC += e;
1847 clock_consume(12);
1848 }
1849
JR_cc_e(struct z80 * cpu,bool condition)1850 void JR_cc_e(struct z80 *cpu, bool condition)
1851 {
1852 int8_t d = memory_readb(cpu->bus_id, cpu->PC++);
1853 if (condition) {
1854 cpu->PC += d;
1855 clock_consume(5);
1856 }
1857 clock_consume(7);
1858 }
1859
JP_HL(struct z80 * cpu)1860 void JP_HL(struct z80 *cpu)
1861 {
1862 cpu->PC = cpu->HL;
1863 clock_consume(4);
1864 }
1865
JP_IXY(struct z80 * cpu,uint16_t * reg)1866 void JP_IXY(struct z80 *cpu, uint16_t *reg)
1867 {
1868 cpu->PC = *reg;
1869 clock_consume(8);
1870 }
1871
DJNZ_e(struct z80 * cpu)1872 void DJNZ_e(struct z80 *cpu)
1873 {
1874 int8_t e = memory_readb(cpu->bus_id, cpu->PC++);
1875 if (--cpu->B != 0) {
1876 cpu->PC += e;
1877 clock_consume(5);
1878 }
1879 clock_consume(8);
1880 }
1881
CALL_nn(struct z80 * cpu)1882 void CALL_nn(struct z80 *cpu)
1883 {
1884 uint8_t n1 = memory_readb(cpu->bus_id, cpu->PC++);
1885 uint8_t n2 = memory_readb(cpu->bus_id, cpu->PC++);
1886 memory_writeb(cpu->bus_id, cpu->PC >> 8, --cpu->SP);
1887 memory_writeb(cpu->bus_id, cpu->PC, --cpu->SP);
1888 cpu->PC = n1 | (n2 << 8);
1889 clock_consume(17);
1890 }
1891
CALL_cc_nn(struct z80 * cpu,bool condition)1892 void CALL_cc_nn(struct z80 *cpu, bool condition)
1893 {
1894 uint8_t n1 = memory_readb(cpu->bus_id, cpu->PC++);
1895 uint8_t n2 = memory_readb(cpu->bus_id, cpu->PC++);
1896 if (condition) {
1897 memory_writeb(cpu->bus_id, cpu->PC >> 8, --cpu->SP);
1898 memory_writeb(cpu->bus_id, cpu->PC, --cpu->SP);
1899 cpu->PC = n1 | (n2 << 8);
1900 clock_consume(12);
1901 }
1902 clock_consume(12);
1903 }
1904
RET(struct z80 * cpu)1905 void RET(struct z80 *cpu)
1906 {
1907 cpu->PC = memory_readb(cpu->bus_id, cpu->SP++);
1908 cpu->PC |= memory_readb(cpu->bus_id, cpu->SP++) << 8;
1909 clock_consume(10);
1910 }
1911
RET_cc(struct z80 * cpu,bool condition)1912 void RET_cc(struct z80 *cpu, bool condition)
1913 {
1914 if (condition) {
1915 cpu->PC = memory_readb(cpu->bus_id, cpu->SP++);
1916 cpu->PC |= memory_readb(cpu->bus_id, cpu->SP++) << 8;
1917 clock_consume(6);
1918 }
1919 clock_consume(5);
1920 }
1921
RETI(struct z80 * cpu)1922 void RETI(struct z80 *cpu)
1923 {
1924 cpu->PC = memory_readb(cpu->bus_id, cpu->SP++);
1925 cpu->PC |= memory_readb(cpu->bus_id, cpu->SP++) << 8;
1926 cpu->IFF1 = cpu->IFF2;
1927 clock_consume(14);
1928 }
1929
RETN(struct z80 * cpu)1930 void RETN(struct z80 *cpu)
1931 {
1932 cpu->PC = memory_readb(cpu->bus_id, cpu->SP++);
1933 cpu->PC |= memory_readb(cpu->bus_id, cpu->SP++) << 8;
1934 cpu->IFF1 = cpu->IFF2;
1935 clock_consume(14);
1936 }
1937
RST_p(struct z80 * cpu,uint8_t p)1938 void RST_p(struct z80 *cpu, uint8_t p)
1939 {
1940 memory_writeb(cpu->bus_id, cpu->PC >> 8, --cpu->SP);
1941 memory_writeb(cpu->bus_id, cpu->PC, --cpu->SP);
1942 cpu->PC = p;
1943 clock_consume(11);
1944 }
1945
IN_A_cn(struct z80 * cpu)1946 void IN_A_cn(struct z80 *cpu)
1947 {
1948 uint8_t n = memory_readb(cpu->bus_id, cpu->PC++);
1949 cpu->A = port_read(n);
1950 clock_consume(11);
1951 }
1952
IN_r_cC(struct z80 * cpu,uint8_t * r)1953 void IN_r_cC(struct z80 *cpu, uint8_t *r)
1954 {
1955 *r = port_read(cpu->C);
1956 cpu->flags.S = ((int8_t)*r < 0);
1957 cpu->flags.Z = (*r == 0);
1958 cpu->flags.H = 0;
1959 cpu->flags.PV = bitops_parity(*r);
1960 cpu->flags.N = 0;
1961 clock_consume(12);
1962 }
1963
INI(struct z80 * cpu)1964 void INI(struct z80 *cpu)
1965 {
1966 uint8_t b = port_read(cpu->C);
1967 memory_writeb(cpu->bus_id, b, cpu->HL++);
1968 cpu->B--;
1969 cpu->flags.Z = (cpu->B == 0);
1970 cpu->flags.N = 1;
1971 clock_consume(16);
1972 }
1973
INIR(struct z80 * cpu)1974 void INIR(struct z80 *cpu)
1975 {
1976 uint8_t b = port_read(cpu->C);
1977 memory_writeb(cpu->bus_id, b, cpu->HL++);
1978 if (--cpu->B != 0) {
1979 cpu->PC -= 2;
1980 clock_consume(5);
1981 }
1982 cpu->flags.Z = (cpu->B == 0);
1983 cpu->flags.N = 1;
1984 clock_consume(16);
1985 }
1986
IND(struct z80 * cpu)1987 void IND(struct z80 *cpu)
1988 {
1989 uint8_t b = port_read(cpu->C);
1990 memory_writeb(cpu->bus_id, b, cpu->HL--);
1991 cpu->B--;
1992 cpu->flags.Z = (cpu->B == 0);
1993 cpu->flags.N = 1;
1994 clock_consume(16);
1995 }
1996
INDR(struct z80 * cpu)1997 void INDR(struct z80 *cpu)
1998 {
1999 uint8_t b = port_read(cpu->C);
2000 memory_writeb(cpu->bus_id, b, cpu->HL--);
2001 if (--cpu->B != 0) {
2002 cpu->PC -= 2;
2003 clock_consume(5);
2004 }
2005 cpu->flags.Z = (cpu->B == 0);
2006 cpu->flags.N = 1;
2007 clock_consume(16);
2008 }
2009
OUT_cn_A(struct z80 * cpu)2010 void OUT_cn_A(struct z80 *cpu)
2011 {
2012 uint8_t n = memory_readb(cpu->bus_id, cpu->PC++);
2013 port_write(cpu->A, n);
2014 clock_consume(11);
2015 }
2016
OUT_cC_r(struct z80 * cpu,uint8_t * r)2017 void OUT_cC_r(struct z80 *cpu, uint8_t *r)
2018 {
2019 port_write(*r, cpu->C);
2020 clock_consume(12);
2021 }
2022
OUTI(struct z80 * cpu)2023 void OUTI(struct z80 *cpu)
2024 {
2025 uint8_t b = memory_readb(cpu->bus_id, cpu->HL++);
2026 port_write(b, cpu->C);
2027 cpu->B--;
2028 cpu->flags.Z = (cpu->B == 0);
2029 cpu->flags.N = 1;
2030 clock_consume(16);
2031 }
2032
OTIR(struct z80 * cpu)2033 void OTIR(struct z80 *cpu)
2034 {
2035 uint8_t b = memory_readb(cpu->bus_id, cpu->HL++);
2036 port_write(b, cpu->C);
2037 if (--cpu->B != 0) {
2038 cpu->PC -= 2;
2039 clock_consume(5);
2040 }
2041 cpu->flags.Z = (cpu->B == 0);
2042 cpu->flags.N = 1;
2043 clock_consume(16);
2044 }
2045
OUTD(struct z80 * cpu)2046 void OUTD(struct z80 *cpu)
2047 {
2048 uint8_t b = memory_readb(cpu->bus_id, cpu->HL--);
2049 port_write(b, cpu->C);
2050 cpu->B--;
2051 cpu->flags.Z = (cpu->B == 0);
2052 cpu->flags.N = 1;
2053 clock_consume(16);
2054 }
2055
OTDR(struct z80 * cpu)2056 void OTDR(struct z80 *cpu)
2057 {
2058 uint8_t b = memory_readb(cpu->bus_id, cpu->HL--);
2059 port_write(b, cpu->C);
2060 if (--cpu->B != 0) {
2061 cpu->PC -= 2;
2062 clock_consume(5);
2063 }
2064 cpu->flags.Z = (cpu->B == 0);
2065 cpu->flags.N = 1;
2066 clock_consume(16);
2067 }
2068
z80_handle_irq(struct z80 * cpu)2069 bool z80_handle_irq(struct z80 *cpu)
2070 {
2071 /* Reset IRQ delay and exit if needed */
2072 if (cpu->irq_delay) {
2073 cpu->irq_delay = false;
2074 return false;
2075 }
2076
2077 /* Leave if no IRQ is pending */
2078 if (!cpu->irq_pending)
2079 return false;
2080
2081 /* Any interrupt should resume CPU */
2082 if (cpu->halted) {
2083 cpu->PC++;
2084 cpu->halted = false;
2085 }
2086
2087 /* Check if interrupts are enabled */
2088 if (!cpu->IFF1)
2089 return false;
2090
2091 /* Clear flip-flops */
2092 cpu->IFF1 = 0;
2093 cpu->IFF2 = 0;
2094
2095 /* Push PC on stack */
2096 memory_writeb(cpu->bus_id, cpu->PC >> 8, --cpu->SP);
2097 memory_writeb(cpu->bus_id, cpu->PC, --cpu->SP);
2098
2099 /* Jump to IRQ address */
2100 cpu->PC = IRQ_VECTOR;
2101
2102 /* Interrupt handler should consume 20 cycles */
2103 clock_consume(20);
2104
2105 /* Reset IRQ pending flag */
2106 cpu->irq_pending = false;
2107 return true;
2108 }
2109
z80_handle_nmi(struct z80 * cpu)2110 bool z80_handle_nmi(struct z80 *cpu)
2111 {
2112 /* Leave if no NMI is pending */
2113 if (!cpu->nmi_pending)
2114 return false;
2115
2116 /* Push PC on stack */
2117 memory_writeb(cpu->bus_id, cpu->PC >> 8, --cpu->SP);
2118 memory_writeb(cpu->bus_id, cpu->PC, --cpu->SP);
2119
2120 /* Jump to NMI address */
2121 cpu->PC = NMI_VECTOR;
2122
2123 /* Interrupt handler should consume 20 cycles */
2124 clock_consume(20);
2125
2126 /* Reset NMI pending flag */
2127 cpu->nmi_pending = false;
2128 return true;
2129 }
2130
z80_tick(struct z80 * cpu)2131 void z80_tick(struct z80 *cpu)
2132 {
2133 uint8_t opcode;
2134
2135 /* Check for interrupt requests (IRQ or NMI) */
2136 if (z80_handle_irq(cpu) || z80_handle_nmi(cpu))
2137 return;
2138
2139 /* Fetch opcode */
2140 opcode = memory_readb(cpu->bus_id, cpu->PC++);
2141
2142 /* Execute opcode */
2143 switch (opcode) {
2144 case 0x00:
2145 NOP(cpu);
2146 break;
2147 case 0x01:
2148 LD_dd_nn(cpu, &cpu->BC);
2149 break;
2150 case 0x02:
2151 LD_cBC_A(cpu);
2152 break;
2153 case 0x03:
2154 INC_ss(&cpu->BC);
2155 break;
2156 case 0x04:
2157 INC_r(cpu, &cpu->B);
2158 break;
2159 case 0x05:
2160 DEC_r(cpu, &cpu->B);
2161 break;
2162 case 0x06:
2163 LD_r_n(cpu, &cpu->B);
2164 break;
2165 case 0x07:
2166 RLCA(cpu);
2167 break;
2168 case 0x08:
2169 EX_AF_A2F2(cpu);
2170 break;
2171 case 0x09:
2172 ADD_HL_ss(cpu, &cpu->BC);
2173 break;
2174 case 0x0A:
2175 LD_A_cBC(cpu);
2176 break;
2177 case 0x0B:
2178 DEC_ss(&cpu->BC);
2179 break;
2180 case 0x0C:
2181 INC_r(cpu, &cpu->C);
2182 break;
2183 case 0x0D:
2184 DEC_r(cpu, &cpu->C);
2185 break;
2186 case 0x0E:
2187 LD_r_n(cpu, &cpu->C);
2188 break;
2189 case 0x0F:
2190 RRCA(cpu);
2191 break;
2192 case 0x10:
2193 DJNZ_e(cpu);
2194 break;
2195 case 0x11:
2196 LD_dd_nn(cpu, &cpu->DE);
2197 break;
2198 case 0x12:
2199 LD_cDE_A(cpu);
2200 break;
2201 case 0x13:
2202 INC_ss(&cpu->DE);
2203 break;
2204 case 0x14:
2205 INC_r(cpu, &cpu->D);
2206 break;
2207 case 0x15:
2208 DEC_r(cpu, &cpu->D);
2209 break;
2210 case 0x16:
2211 LD_r_n(cpu, &cpu->D);
2212 break;
2213 case 0x17:
2214 RLA(cpu);
2215 break;
2216 case 0x18:
2217 JR_e(cpu);
2218 break;
2219 case 0x19:
2220 ADD_HL_ss(cpu, &cpu->DE);
2221 break;
2222 case 0x1A:
2223 LD_A_cDE(cpu);
2224 break;
2225 case 0x1B:
2226 DEC_ss(&cpu->DE);
2227 break;
2228 case 0x1C:
2229 INC_r(cpu, &cpu->E);
2230 break;
2231 case 0x1D:
2232 DEC_r(cpu, &cpu->E);
2233 break;
2234 case 0x1E:
2235 LD_r_n(cpu, &cpu->E);
2236 break;
2237 case 0x1F:
2238 RRA(cpu);
2239 break;
2240 case 0x20:
2241 JR_cc_e(cpu, !cpu->flags.Z);
2242 break;
2243 case 0x21:
2244 LD_dd_nn(cpu, &cpu->HL);
2245 break;
2246 case 0x22:
2247 LD_cnn_HL(cpu);
2248 break;
2249 case 0x23:
2250 INC_ss(&cpu->HL);
2251 break;
2252 case 0x24:
2253 INC_r(cpu, &cpu->H);
2254 break;
2255 case 0x25:
2256 DEC_r(cpu, &cpu->H);
2257 break;
2258 case 0x26:
2259 LD_r_n(cpu, &cpu->H);
2260 break;
2261 case 0x27:
2262 DAA(cpu);
2263 break;
2264 case 0x28:
2265 JR_cc_e(cpu, cpu->flags.Z);
2266 break;
2267 case 0x29:
2268 ADD_HL_ss(cpu, &cpu->HL);
2269 break;
2270 case 0x2A:
2271 LD_HL_cnn(cpu);
2272 break;
2273 case 0x2B:
2274 DEC_ss(&cpu->HL);
2275 break;
2276 case 0x2C:
2277 INC_r(cpu, &cpu->L);
2278 break;
2279 case 0x2D:
2280 DEC_r(cpu, &cpu->L);
2281 break;
2282 case 0x2E:
2283 LD_r_n(cpu, &cpu->L);
2284 break;
2285 case 0x2F:
2286 CPL(cpu);
2287 break;
2288 case 0x30:
2289 JR_cc_e(cpu, !cpu->flags.C);
2290 break;
2291 case 0x31:
2292 LD_dd_nn(cpu, &cpu->SP);
2293 break;
2294 case 0x32:
2295 LD_cnn_A(cpu);
2296 break;
2297 case 0x33:
2298 INC_ss(&cpu->SP);
2299 break;
2300 case 0x34:
2301 INC_cHL(cpu);
2302 break;
2303 case 0x35:
2304 DEC_cHL(cpu);
2305 break;
2306 case 0x36:
2307 LD_cHL_n(cpu);
2308 break;
2309 case 0x37:
2310 SCF(cpu);
2311 break;
2312 case 0x38:
2313 JR_cc_e(cpu, cpu->flags.C);
2314 break;
2315 case 0x39:
2316 ADD_HL_ss(cpu, &cpu->SP);
2317 break;
2318 case 0x3A:
2319 LD_A_cnn(cpu);
2320 break;
2321 case 0x3B:
2322 DEC_ss(&cpu->SP);
2323 break;
2324 case 0x3C:
2325 INC_r(cpu, &cpu->A);
2326 break;
2327 case 0x3D:
2328 DEC_r(cpu, &cpu->A);
2329 break;
2330 case 0x3E:
2331 LD_r_n(cpu, &cpu->A);
2332 break;
2333 case 0x3F:
2334 CCF(cpu);
2335 break;
2336 case 0x40:
2337 LD_r_r(&cpu->B, &cpu->B);
2338 break;
2339 case 0x41:
2340 LD_r_r(&cpu->B, &cpu->C);
2341 break;
2342 case 0x42:
2343 LD_r_r(&cpu->B, &cpu->D);
2344 break;
2345 case 0x43:
2346 LD_r_r(&cpu->B, &cpu->E);
2347 break;
2348 case 0x44:
2349 LD_r_r(&cpu->B, &cpu->H);
2350 break;
2351 case 0x45:
2352 LD_r_r(&cpu->B, &cpu->L);
2353 break;
2354 case 0x46:
2355 LD_r_cHL(cpu, &cpu->B);
2356 break;
2357 case 0x47:
2358 LD_r_r(&cpu->B, &cpu->A);
2359 break;
2360 case 0x48:
2361 LD_r_r(&cpu->C, &cpu->B);
2362 break;
2363 case 0x49:
2364 LD_r_r(&cpu->C, &cpu->C);
2365 break;
2366 case 0x4A:
2367 LD_r_r(&cpu->C, &cpu->D);
2368 break;
2369 case 0x4B:
2370 LD_r_r(&cpu->C, &cpu->E);
2371 break;
2372 case 0x4C:
2373 LD_r_r(&cpu->C, &cpu->H);
2374 break;
2375 case 0x4D:
2376 LD_r_r(&cpu->C, &cpu->L);
2377 break;
2378 case 0x4E:
2379 LD_r_cHL(cpu, &cpu->C);
2380 break;
2381 case 0x4F:
2382 LD_r_r(&cpu->C, &cpu->A);
2383 break;
2384 case 0x50:
2385 LD_r_r(&cpu->D, &cpu->B);
2386 break;
2387 case 0x51:
2388 LD_r_r(&cpu->D, &cpu->C);
2389 break;
2390 case 0x52:
2391 LD_r_r(&cpu->D, &cpu->D);
2392 break;
2393 case 0x53:
2394 LD_r_r(&cpu->D, &cpu->E);
2395 break;
2396 case 0x54:
2397 LD_r_r(&cpu->D, &cpu->H);
2398 break;
2399 case 0x55:
2400 LD_r_r(&cpu->D, &cpu->L);
2401 break;
2402 case 0x56:
2403 LD_r_cHL(cpu, &cpu->D);
2404 break;
2405 case 0x57:
2406 LD_r_r(&cpu->D, &cpu->A);
2407 break;
2408 case 0x58:
2409 LD_r_r(&cpu->E, &cpu->B);
2410 break;
2411 case 0x59:
2412 LD_r_r(&cpu->E, &cpu->C);
2413 break;
2414 case 0x5A:
2415 LD_r_r(&cpu->E, &cpu->D);
2416 break;
2417 case 0x5B:
2418 LD_r_r(&cpu->E, &cpu->E);
2419 break;
2420 case 0x5C:
2421 LD_r_r(&cpu->E, &cpu->H);
2422 break;
2423 case 0x5D:
2424 LD_r_r(&cpu->E, &cpu->L);
2425 break;
2426 case 0x5E:
2427 LD_r_cHL(cpu, &cpu->E);
2428 break;
2429 case 0x5F:
2430 LD_r_r(&cpu->E, &cpu->A);
2431 break;
2432 case 0x60:
2433 LD_r_r(&cpu->H, &cpu->B);
2434 break;
2435 case 0x61:
2436 LD_r_r(&cpu->H, &cpu->C);
2437 break;
2438 case 0x62:
2439 LD_r_r(&cpu->H, &cpu->D);
2440 break;
2441 case 0x63:
2442 LD_r_r(&cpu->H, &cpu->E);
2443 break;
2444 case 0x64:
2445 LD_r_r(&cpu->H, &cpu->H);
2446 break;
2447 case 0x65:
2448 LD_r_r(&cpu->H, &cpu->L);
2449 break;
2450 case 0x66:
2451 LD_r_cHL(cpu, &cpu->H);
2452 break;
2453 case 0x67:
2454 LD_r_r(&cpu->H, &cpu->A);
2455 break;
2456 case 0x68:
2457 LD_r_r(&cpu->L, &cpu->B);
2458 break;
2459 case 0x69:
2460 LD_r_r(&cpu->L, &cpu->C);
2461 break;
2462 case 0x6A:
2463 LD_r_r(&cpu->L, &cpu->D);
2464 break;
2465 case 0x6B:
2466 LD_r_r(&cpu->L, &cpu->E);
2467 break;
2468 case 0x6C:
2469 LD_r_r(&cpu->L, &cpu->H);
2470 break;
2471 case 0x6D:
2472 LD_r_r(&cpu->L, &cpu->L);
2473 break;
2474 case 0x6E:
2475 LD_r_cHL(cpu, &cpu->L);
2476 break;
2477 case 0x6F:
2478 LD_r_r(&cpu->L, &cpu->A);
2479 break;
2480 case 0x70:
2481 LD_cHL_r(cpu, &cpu->B);
2482 break;
2483 case 0x71:
2484 LD_cHL_r(cpu, &cpu->C);
2485 break;
2486 case 0x72:
2487 LD_cHL_r(cpu, &cpu->D);
2488 break;
2489 case 0x73:
2490 LD_cHL_r(cpu, &cpu->E);
2491 break;
2492 case 0x74:
2493 LD_cHL_r(cpu, &cpu->H);
2494 break;
2495 case 0x75:
2496 LD_cHL_r(cpu, &cpu->L);
2497 break;
2498 case 0x76:
2499 HALT(cpu);
2500 break;
2501 case 0x77:
2502 LD_cHL_r(cpu, &cpu->A);
2503 break;
2504 case 0x78:
2505 LD_r_r(&cpu->A, &cpu->B);
2506 break;
2507 case 0x79:
2508 LD_r_r(&cpu->A, &cpu->C);
2509 break;
2510 case 0x7A:
2511 LD_r_r(&cpu->A, &cpu->D);
2512 break;
2513 case 0x7B:
2514 LD_r_r(&cpu->A, &cpu->E);
2515 break;
2516 case 0x7C:
2517 LD_r_r(&cpu->A, &cpu->H);
2518 break;
2519 case 0x7D:
2520 LD_r_r(&cpu->A, &cpu->L);
2521 break;
2522 case 0x7E:
2523 LD_r_cHL(cpu, &cpu->A);
2524 break;
2525 case 0x7F:
2526 LD_r_r(&cpu->A, &cpu->A);
2527 break;
2528 case 0x80:
2529 ADD_A_r(cpu, &cpu->B);
2530 break;
2531 case 0x81:
2532 ADD_A_r(cpu, &cpu->C);
2533 break;
2534 case 0x82:
2535 ADD_A_r(cpu, &cpu->D);
2536 break;
2537 case 0x83:
2538 ADD_A_r(cpu, &cpu->E);
2539 break;
2540 case 0x84:
2541 ADD_A_r(cpu, &cpu->H);
2542 break;
2543 case 0x85:
2544 ADD_A_r(cpu, &cpu->L);
2545 break;
2546 case 0x86:
2547 ADD_A_cHL(cpu);
2548 break;
2549 case 0x87:
2550 ADD_A_r(cpu, &cpu->A);
2551 break;
2552 case 0x88:
2553 ADC_A_r(cpu, &cpu->B);
2554 break;
2555 case 0x89:
2556 ADC_A_r(cpu, &cpu->C);
2557 break;
2558 case 0x8A:
2559 ADC_A_r(cpu, &cpu->D);
2560 break;
2561 case 0x8B:
2562 ADC_A_r(cpu, &cpu->E);
2563 break;
2564 case 0x8C:
2565 ADC_A_r(cpu, &cpu->H);
2566 break;
2567 case 0x8D:
2568 ADC_A_r(cpu, &cpu->L);
2569 break;
2570 case 0x8E:
2571 ADC_A_cHL(cpu);
2572 break;
2573 case 0x8F:
2574 ADC_A_r(cpu, &cpu->A);
2575 break;
2576 case 0x90:
2577 SUB_A_r(cpu, &cpu->B);
2578 break;
2579 case 0x91:
2580 SUB_A_r(cpu, &cpu->C);
2581 break;
2582 case 0x92:
2583 SUB_A_r(cpu, &cpu->D);
2584 break;
2585 case 0x93:
2586 SUB_A_r(cpu, &cpu->E);
2587 break;
2588 case 0x94:
2589 SUB_A_r(cpu, &cpu->H);
2590 break;
2591 case 0x95:
2592 SUB_A_r(cpu, &cpu->L);
2593 break;
2594 case 0x96:
2595 SUB_A_cHL(cpu);
2596 break;
2597 case 0x97:
2598 SUB_A_r(cpu, &cpu->A);
2599 break;
2600 case 0x98:
2601 SBC_A_r(cpu, &cpu->B);
2602 break;
2603 case 0x99:
2604 SBC_A_r(cpu, &cpu->C);
2605 break;
2606 case 0x9A:
2607 SBC_A_r(cpu, &cpu->D);
2608 break;
2609 case 0x9B:
2610 SBC_A_r(cpu, &cpu->E);
2611 break;
2612 case 0x9C:
2613 SBC_A_r(cpu, &cpu->H);
2614 break;
2615 case 0x9D:
2616 SBC_A_r(cpu, &cpu->L);
2617 break;
2618 case 0x9E:
2619 SBC_A_cHL(cpu);
2620 break;
2621 case 0x9F:
2622 SBC_A_r(cpu, &cpu->A);
2623 break;
2624 case 0xA0:
2625 AND_r(cpu, &cpu->B);
2626 break;
2627 case 0xA1:
2628 AND_r(cpu, &cpu->C);
2629 break;
2630 case 0xA2:
2631 AND_r(cpu, &cpu->D);
2632 break;
2633 case 0xA3:
2634 AND_r(cpu, &cpu->E);
2635 break;
2636 case 0xA4:
2637 AND_r(cpu, &cpu->H);
2638 break;
2639 case 0xA5:
2640 AND_r(cpu, &cpu->L);
2641 break;
2642 case 0xA6:
2643 AND_cHL(cpu);
2644 break;
2645 case 0xA7:
2646 AND_r(cpu, &cpu->A);
2647 break;
2648 case 0xA8:
2649 XOR_r(cpu, &cpu->B);
2650 break;
2651 case 0xA9:
2652 XOR_r(cpu, &cpu->C);
2653 break;
2654 case 0xAA:
2655 XOR_r(cpu, &cpu->D);
2656 break;
2657 case 0xAB:
2658 XOR_r(cpu, &cpu->E);
2659 break;
2660 case 0xAC:
2661 XOR_r(cpu, &cpu->H);
2662 break;
2663 case 0xAD:
2664 XOR_r(cpu, &cpu->L);
2665 break;
2666 case 0xAE:
2667 XOR_cHL(cpu);
2668 break;
2669 case 0xAF:
2670 XOR_r(cpu, &cpu->A);
2671 break;
2672 case 0xB0:
2673 OR_r(cpu, &cpu->B);
2674 break;
2675 case 0xB1:
2676 OR_r(cpu, &cpu->C);
2677 break;
2678 case 0xB2:
2679 OR_r(cpu, &cpu->D);
2680 break;
2681 case 0xB3:
2682 OR_r(cpu, &cpu->E);
2683 break;
2684 case 0xB4:
2685 OR_r(cpu, &cpu->H);
2686 break;
2687 case 0xB5:
2688 OR_r(cpu, &cpu->L);
2689 break;
2690 case 0xB6:
2691 OR_cHL(cpu);
2692 break;
2693 case 0xB7:
2694 OR_r(cpu, &cpu->A);
2695 break;
2696 case 0xB8:
2697 CP_r(cpu, &cpu->B);
2698 break;
2699 case 0xB9:
2700 CP_r(cpu, &cpu->C);
2701 break;
2702 case 0xBA:
2703 CP_r(cpu, &cpu->D);
2704 break;
2705 case 0xBB:
2706 CP_r(cpu, &cpu->E);
2707 break;
2708 case 0xBC:
2709 CP_r(cpu, &cpu->H);
2710 break;
2711 case 0xBD:
2712 CP_r(cpu, &cpu->L);
2713 break;
2714 case 0xBE:
2715 CP_cHL(cpu);
2716 break;
2717 case 0xBF:
2718 CP_r(cpu, &cpu->A);
2719 break;
2720 case 0xC0:
2721 RET_cc(cpu, !cpu->flags.Z);
2722 break;
2723 case 0xC1:
2724 POP_qq(cpu, &cpu->BC);
2725 break;
2726 case 0xC2:
2727 JP_cc_nn(cpu, !cpu->flags.Z);
2728 break;
2729 case 0xC3:
2730 JP_nn(cpu);
2731 break;
2732 case 0xC4:
2733 CALL_cc_nn(cpu, !cpu->flags.Z);
2734 break;
2735 case 0xC5:
2736 PUSH_qq(cpu, &cpu->BC);
2737 break;
2738 case 0xC6:
2739 ADD_A_n(cpu);
2740 break;
2741 case 0xC7:
2742 RST_p(cpu, 0x00);
2743 break;
2744 case 0xC8:
2745 RET_cc(cpu, cpu->flags.Z);
2746 break;
2747 case 0xC9:
2748 RET(cpu);
2749 break;
2750 case 0xCA:
2751 JP_cc_nn(cpu, cpu->flags.Z);
2752 break;
2753 case 0xCB:
2754 z80_opcode_CB(cpu);
2755 break;
2756 case 0xCC:
2757 CALL_cc_nn(cpu, cpu->flags.Z);
2758 break;
2759 case 0xCD:
2760 CALL_nn(cpu);
2761 break;
2762 case 0xCE:
2763 ADC_A_n(cpu);
2764 break;
2765 case 0xCF:
2766 RST_p(cpu, 0x08);
2767 break;
2768 case 0xD0:
2769 RET_cc(cpu, !cpu->flags.C);
2770 break;
2771 case 0xD1:
2772 POP_qq(cpu, &cpu->DE);
2773 break;
2774 case 0xD2:
2775 JP_cc_nn(cpu, !cpu->flags.C);
2776 break;
2777 case 0xD3:
2778 OUT_cn_A(cpu);
2779 break;
2780 case 0xD4:
2781 CALL_cc_nn(cpu, !cpu->flags.C);
2782 break;
2783 case 0xD5:
2784 PUSH_qq(cpu, &cpu->DE);
2785 break;
2786 case 0xD6:
2787 SUB_A_n(cpu);
2788 break;
2789 case 0xD7:
2790 RST_p(cpu, 0x10);
2791 break;
2792 case 0xD8:
2793 RET_cc(cpu, cpu->flags.C);
2794 break;
2795 case 0xD9:
2796 EXX(cpu);
2797 break;
2798 case 0xDA:
2799 JP_cc_nn(cpu, cpu->flags.C);
2800 break;
2801 case 0xDB:
2802 IN_A_cn(cpu);
2803 break;
2804 case 0xDC:
2805 CALL_cc_nn(cpu, cpu->flags.C);
2806 break;
2807 case 0xDD:
2808 z80_opcode_DDFD(cpu, opcode);
2809 break;
2810 case 0xDE:
2811 SBC_A_n(cpu);
2812 break;
2813 case 0xDF:
2814 RST_p(cpu, 0x18);
2815 break;
2816 case 0xE0:
2817 RET_cc(cpu, !cpu->flags.PV);
2818 break;
2819 case 0xE1:
2820 POP_qq(cpu, &cpu->HL);
2821 break;
2822 case 0xE2:
2823 JP_cc_nn(cpu, !cpu->flags.PV);
2824 break;
2825 case 0xE3:
2826 EX_cSP_HL(cpu);
2827 break;
2828 case 0xE5:
2829 PUSH_qq(cpu, &cpu->HL);
2830 break;
2831 case 0xE6:
2832 AND_n(cpu);
2833 break;
2834 case 0xE7:
2835 RST_p(cpu, 0x20);
2836 break;
2837 case 0xE8:
2838 RET_cc(cpu, cpu->flags.PV);
2839 break;
2840 case 0xE9:
2841 JP_HL(cpu);
2842 break;
2843 case 0xEA:
2844 JP_cc_nn(cpu, cpu->flags.PV);
2845 break;
2846 case 0xEB:
2847 EX_DE_HL(cpu);
2848 break;
2849 case 0xED:
2850 z80_opcode_ED(cpu);
2851 break;
2852 case 0xEE:
2853 XOR_n(cpu);
2854 break;
2855 case 0xEF:
2856 RST_p(cpu, 0x28);
2857 break;
2858 case 0xF0:
2859 RET_cc(cpu, !cpu->flags.S);
2860 break;
2861 case 0xF1:
2862 POP_qq(cpu, &cpu->AF);
2863 break;
2864 case 0xF2:
2865 JP_cc_nn(cpu, !cpu->flags.S);
2866 break;
2867 case 0xF3:
2868 DI(cpu);
2869 break;
2870 case 0xF4:
2871 CALL_cc_nn(cpu, !cpu->flags.S);
2872 break;
2873 case 0xF5:
2874 PUSH_qq(cpu, &cpu->AF);
2875 break;
2876 case 0xF6:
2877 OR_n(cpu);
2878 break;
2879 case 0xF7:
2880 RST_p(cpu, 0x30);
2881 break;
2882 case 0xF8:
2883 RET_cc(cpu, cpu->flags.S);
2884 break;
2885 case 0xF9:
2886 LD_SP_HL(cpu);
2887 break;
2888 case 0xFA:
2889 JP_cc_nn(cpu, cpu->flags.S);
2890 break;
2891 case 0xFB:
2892 EI(cpu);
2893 break;
2894 case 0xFC:
2895 CALL_cc_nn(cpu, cpu->flags.S);
2896 break;
2897 case 0xFD:
2898 z80_opcode_DDFD(cpu, opcode);
2899 break;
2900 case 0xFE:
2901 CP_n(cpu);
2902 break;
2903 case 0xFF:
2904 RST_p(cpu, 0x38);
2905 break;
2906 default:
2907 LOG_W("z80: unknown opcode (%02x)!\n", opcode);
2908 clock_consume(1);
2909 break;
2910 }
2911 }
2912
z80_opcode_CB(struct z80 * cpu)2913 void z80_opcode_CB(struct z80 *cpu)
2914 {
2915 uint8_t opcode;
2916
2917 /* Fetch CB opcode */
2918 opcode = memory_readb(cpu->bus_id, cpu->PC++);
2919
2920 /* Execute CB opcode */
2921 switch (opcode) {
2922 case 0x00:
2923 RLC_r(cpu, &cpu->B);
2924 break;
2925 case 0x01:
2926 RLC_r(cpu, &cpu->C);
2927 break;
2928 case 0x02:
2929 RLC_r(cpu, &cpu->D);
2930 break;
2931 case 0x03:
2932 RLC_r(cpu, &cpu->E);
2933 break;
2934 case 0x04:
2935 RLC_r(cpu, &cpu->H);
2936 break;
2937 case 0x05:
2938 RLC_r(cpu, &cpu->L);
2939 break;
2940 case 0x06:
2941 RLC_cHL(cpu);
2942 break;
2943 case 0x07:
2944 RLC_r(cpu, &cpu->A);
2945 break;
2946 case 0x08:
2947 RRC_r(cpu, &cpu->B);
2948 break;
2949 case 0x09:
2950 RRC_r(cpu, &cpu->C);
2951 break;
2952 case 0x0A:
2953 RRC_r(cpu, &cpu->D);
2954 break;
2955 case 0x0B:
2956 RRC_r(cpu, &cpu->E);
2957 break;
2958 case 0x0C:
2959 RRC_r(cpu, &cpu->H);
2960 break;
2961 case 0x0D:
2962 RRC_r(cpu, &cpu->L);
2963 break;
2964 case 0x0E:
2965 RRC_cHL(cpu);
2966 break;
2967 case 0x0F:
2968 RRC_r(cpu, &cpu->A);
2969 break;
2970 case 0x10:
2971 RL_r(cpu, &cpu->B);
2972 break;
2973 case 0x11:
2974 RL_r(cpu, &cpu->C);
2975 break;
2976 case 0x12:
2977 RL_r(cpu, &cpu->D);
2978 break;
2979 case 0x13:
2980 RL_r(cpu, &cpu->E);
2981 break;
2982 case 0x14:
2983 RL_r(cpu, &cpu->H);
2984 break;
2985 case 0x15:
2986 RL_r(cpu, &cpu->L);
2987 break;
2988 case 0x16:
2989 RL_cHL(cpu);
2990 break;
2991 case 0x17:
2992 RL_r(cpu, &cpu->A);
2993 break;
2994 case 0x18:
2995 RR_r(cpu, &cpu->B);
2996 break;
2997 case 0x19:
2998 RR_r(cpu, &cpu->C);
2999 break;
3000 case 0x1A:
3001 RR_r(cpu, &cpu->D);
3002 break;
3003 case 0x1B:
3004 RR_r(cpu, &cpu->E);
3005 break;
3006 case 0x1C:
3007 RR_r(cpu, &cpu->H);
3008 break;
3009 case 0x1D:
3010 RR_r(cpu, &cpu->L);
3011 break;
3012 case 0x1E:
3013 RR_cHL(cpu);
3014 break;
3015 case 0x1F:
3016 RR_r(cpu, &cpu->A);
3017 break;
3018 case 0x20:
3019 SLA_r(cpu, &cpu->B);
3020 break;
3021 case 0x21:
3022 SLA_r(cpu, &cpu->C);
3023 break;
3024 case 0x22:
3025 SLA_r(cpu, &cpu->D);
3026 break;
3027 case 0x23:
3028 SLA_r(cpu, &cpu->E);
3029 break;
3030 case 0x24:
3031 SLA_r(cpu, &cpu->H);
3032 break;
3033 case 0x25:
3034 SLA_r(cpu, &cpu->L);
3035 break;
3036 case 0x26:
3037 SLA_cHL(cpu);
3038 break;
3039 case 0x27:
3040 SLA_r(cpu, &cpu->A);
3041 break;
3042 case 0x28:
3043 SRA_r(cpu, &cpu->B);
3044 break;
3045 case 0x29:
3046 SRA_r(cpu, &cpu->C);
3047 break;
3048 case 0x2A:
3049 SRA_r(cpu, &cpu->D);
3050 break;
3051 case 0x2B:
3052 SRA_r(cpu, &cpu->E);
3053 break;
3054 case 0x2C:
3055 SRA_r(cpu, &cpu->H);
3056 break;
3057 case 0x2D:
3058 SRA_r(cpu, &cpu->L);
3059 break;
3060 case 0x2E:
3061 SRA_cHL(cpu);
3062 break;
3063 case 0x2F:
3064 SRA_r(cpu, &cpu->A);
3065 break;
3066 case 0x30:
3067 SL1_r(cpu, &cpu->B);
3068 break;
3069 case 0x31:
3070 SL1_r(cpu, &cpu->C);
3071 break;
3072 case 0x32:
3073 SL1_r(cpu, &cpu->D);
3074 break;
3075 case 0x33:
3076 SL1_r(cpu, &cpu->E);
3077 break;
3078 case 0x34:
3079 SL1_r(cpu, &cpu->H);
3080 break;
3081 case 0x35:
3082 SL1_r(cpu, &cpu->L);
3083 break;
3084 case 0x36:
3085 SL1_cHL(cpu);
3086 break;
3087 case 0x37:
3088 SL1_r(cpu, &cpu->A);
3089 break;
3090 case 0x38:
3091 SRL_r(cpu, &cpu->B);
3092 break;
3093 case 0x39:
3094 SRL_r(cpu, &cpu->C);
3095 break;
3096 case 0x3A:
3097 SRL_r(cpu, &cpu->D);
3098 break;
3099 case 0x3B:
3100 SRL_r(cpu, &cpu->E);
3101 break;
3102 case 0x3C:
3103 SRL_r(cpu, &cpu->H);
3104 break;
3105 case 0x3D:
3106 SRL_r(cpu, &cpu->L);
3107 break;
3108 case 0x3E:
3109 SRL_cHL(cpu);
3110 break;
3111 case 0x3F:
3112 SRL_r(cpu, &cpu->A);
3113 break;
3114 case 0x40:
3115 BIT_b_r(cpu, 0, &cpu->B);
3116 break;
3117 case 0x41:
3118 BIT_b_r(cpu, 0, &cpu->C);
3119 break;
3120 case 0x42:
3121 BIT_b_r(cpu, 0, &cpu->D);
3122 break;
3123 case 0x43:
3124 BIT_b_r(cpu, 0, &cpu->E);
3125 break;
3126 case 0x44:
3127 BIT_b_r(cpu, 0, &cpu->H);
3128 break;
3129 case 0x45:
3130 BIT_b_r(cpu, 0, &cpu->L);
3131 break;
3132 case 0x46:
3133 BIT_b_cHL(cpu, 0);
3134 break;
3135 case 0x47:
3136 BIT_b_r(cpu, 0, &cpu->A);
3137 break;
3138 case 0x48:
3139 BIT_b_r(cpu, 1, &cpu->B);
3140 break;
3141 case 0x49:
3142 BIT_b_r(cpu, 1, &cpu->C);
3143 break;
3144 case 0x4A:
3145 BIT_b_r(cpu, 1, &cpu->D);
3146 break;
3147 case 0x4B:
3148 BIT_b_r(cpu, 1, &cpu->E);
3149 break;
3150 case 0x4C:
3151 BIT_b_r(cpu, 1, &cpu->H);
3152 break;
3153 case 0x4D:
3154 BIT_b_r(cpu, 1, &cpu->L);
3155 break;
3156 case 0x4E:
3157 BIT_b_cHL(cpu, 1);
3158 break;
3159 case 0x4F:
3160 BIT_b_r(cpu, 1, &cpu->A);
3161 break;
3162 case 0x50:
3163 BIT_b_r(cpu, 2, &cpu->B);
3164 break;
3165 case 0x51:
3166 BIT_b_r(cpu, 2, &cpu->C);
3167 break;
3168 case 0x52:
3169 BIT_b_r(cpu, 2, &cpu->D);
3170 break;
3171 case 0x53:
3172 BIT_b_r(cpu, 2, &cpu->E);
3173 break;
3174 case 0x54:
3175 BIT_b_r(cpu, 2, &cpu->H);
3176 break;
3177 case 0x55:
3178 BIT_b_r(cpu, 2, &cpu->L);
3179 break;
3180 case 0x56:
3181 BIT_b_cHL(cpu, 2);
3182 break;
3183 case 0x57:
3184 BIT_b_r(cpu, 2, &cpu->A);
3185 break;
3186 case 0x58:
3187 BIT_b_r(cpu, 3, &cpu->B);
3188 break;
3189 case 0x59:
3190 BIT_b_r(cpu, 3, &cpu->C);
3191 break;
3192 case 0x5A:
3193 BIT_b_r(cpu, 3, &cpu->D);
3194 break;
3195 case 0x5B:
3196 BIT_b_r(cpu, 3, &cpu->E);
3197 break;
3198 case 0x5C:
3199 BIT_b_r(cpu, 3, &cpu->H);
3200 break;
3201 case 0x5D:
3202 BIT_b_r(cpu, 3, &cpu->L);
3203 break;
3204 case 0x5E:
3205 BIT_b_cHL(cpu, 3);
3206 break;
3207 case 0x5F:
3208 BIT_b_r(cpu, 3, &cpu->A);
3209 break;
3210 case 0x60:
3211 BIT_b_r(cpu, 4, &cpu->B);
3212 break;
3213 case 0x61:
3214 BIT_b_r(cpu, 4, &cpu->C);
3215 break;
3216 case 0x62:
3217 BIT_b_r(cpu, 4, &cpu->D);
3218 break;
3219 case 0x63:
3220 BIT_b_r(cpu, 4, &cpu->E);
3221 break;
3222 case 0x64:
3223 BIT_b_r(cpu, 4, &cpu->H);
3224 break;
3225 case 0x65:
3226 BIT_b_r(cpu, 4, &cpu->L);
3227 break;
3228 case 0x66:
3229 BIT_b_cHL(cpu, 4);
3230 break;
3231 case 0x67:
3232 BIT_b_r(cpu, 4, &cpu->A);
3233 break;
3234 case 0x68:
3235 BIT_b_r(cpu, 5, &cpu->B);
3236 break;
3237 case 0x69:
3238 BIT_b_r(cpu, 5, &cpu->C);
3239 break;
3240 case 0x6A:
3241 BIT_b_r(cpu, 5, &cpu->D);
3242 break;
3243 case 0x6B:
3244 BIT_b_r(cpu, 5, &cpu->E);
3245 break;
3246 case 0x6C:
3247 BIT_b_r(cpu, 5, &cpu->H);
3248 break;
3249 case 0x6D:
3250 BIT_b_r(cpu, 5, &cpu->L);
3251 break;
3252 case 0x6E:
3253 BIT_b_cHL(cpu, 5);
3254 break;
3255 case 0x6F:
3256 BIT_b_r(cpu, 5, &cpu->A);
3257 break;
3258 case 0x70:
3259 BIT_b_r(cpu, 6, &cpu->B);
3260 break;
3261 case 0x71:
3262 BIT_b_r(cpu, 6, &cpu->C);
3263 break;
3264 case 0x72:
3265 BIT_b_r(cpu, 6, &cpu->D);
3266 break;
3267 case 0x73:
3268 BIT_b_r(cpu, 6, &cpu->E);
3269 break;
3270 case 0x74:
3271 BIT_b_r(cpu, 6, &cpu->H);
3272 break;
3273 case 0x75:
3274 BIT_b_r(cpu, 6, &cpu->L);
3275 break;
3276 case 0x76:
3277 BIT_b_cHL(cpu, 6);
3278 break;
3279 case 0x77:
3280 BIT_b_r(cpu, 6, &cpu->A);
3281 break;
3282 case 0x78:
3283 BIT_b_r(cpu, 7, &cpu->B);
3284 break;
3285 case 0x79:
3286 BIT_b_r(cpu, 7, &cpu->C);
3287 break;
3288 case 0x7A:
3289 BIT_b_r(cpu, 7, &cpu->D);
3290 break;
3291 case 0x7B:
3292 BIT_b_r(cpu, 7, &cpu->E);
3293 break;
3294 case 0x7C:
3295 BIT_b_r(cpu, 7, &cpu->H);
3296 break;
3297 case 0x7D:
3298 BIT_b_r(cpu, 7, &cpu->L);
3299 break;
3300 case 0x7E:
3301 BIT_b_cHL(cpu, 7);
3302 break;
3303 case 0x7F:
3304 BIT_b_r(cpu, 7, &cpu->A);
3305 break;
3306 case 0x80:
3307 RES_b_r(0, &cpu->B);
3308 break;
3309 case 0x81:
3310 RES_b_r(0, &cpu->C);
3311 break;
3312 case 0x82:
3313 RES_b_r(0, &cpu->D);
3314 break;
3315 case 0x83:
3316 RES_b_r(0, &cpu->E);
3317 break;
3318 case 0x84:
3319 RES_b_r(0, &cpu->H);
3320 break;
3321 case 0x85:
3322 RES_b_r(0, &cpu->L);
3323 break;
3324 case 0x86:
3325 RES_b_cHL(cpu, 0);
3326 break;
3327 case 0x87:
3328 RES_b_r(0, &cpu->A);
3329 break;
3330 case 0x88:
3331 RES_b_r(1, &cpu->B);
3332 break;
3333 case 0x89:
3334 RES_b_r(1, &cpu->C);
3335 break;
3336 case 0x8A:
3337 RES_b_r(1, &cpu->D);
3338 break;
3339 case 0x8B:
3340 RES_b_r(1, &cpu->E);
3341 break;
3342 case 0x8C:
3343 RES_b_r(1, &cpu->H);
3344 break;
3345 case 0x8D:
3346 RES_b_r(1, &cpu->L);
3347 break;
3348 case 0x8E:
3349 RES_b_cHL(cpu, 1);
3350 break;
3351 case 0x8F:
3352 RES_b_r(1, &cpu->A);
3353 break;
3354 case 0x90:
3355 RES_b_r(2, &cpu->B);
3356 break;
3357 case 0x91:
3358 RES_b_r(2, &cpu->C);
3359 break;
3360 case 0x92:
3361 RES_b_r(2, &cpu->D);
3362 break;
3363 case 0x93:
3364 RES_b_r(2, &cpu->E);
3365 break;
3366 case 0x94:
3367 RES_b_r(2, &cpu->H);
3368 break;
3369 case 0x95:
3370 RES_b_r(2, &cpu->L);
3371 break;
3372 case 0x96:
3373 RES_b_cHL(cpu, 2);
3374 break;
3375 case 0x97:
3376 RES_b_r(2, &cpu->A);
3377 break;
3378 case 0x98:
3379 RES_b_r(3, &cpu->B);
3380 break;
3381 case 0x99:
3382 RES_b_r(3, &cpu->C);
3383 break;
3384 case 0x9A:
3385 RES_b_r(3, &cpu->D);
3386 break;
3387 case 0x9B:
3388 RES_b_r(3, &cpu->E);
3389 break;
3390 case 0x9C:
3391 RES_b_r(3, &cpu->H);
3392 break;
3393 case 0x9D:
3394 RES_b_r(3, &cpu->L);
3395 break;
3396 case 0x9E:
3397 RES_b_cHL(cpu, 3);
3398 break;
3399 case 0x9F:
3400 RES_b_r(3, &cpu->A);
3401 break;
3402 case 0xA0:
3403 RES_b_r(4, &cpu->B);
3404 break;
3405 case 0xA1:
3406 RES_b_r(4, &cpu->C);
3407 break;
3408 case 0xA2:
3409 RES_b_r(4, &cpu->D);
3410 break;
3411 case 0xA3:
3412 RES_b_r(4, &cpu->E);
3413 break;
3414 case 0xA4:
3415 RES_b_r(4, &cpu->H);
3416 break;
3417 case 0xA5:
3418 RES_b_r(4, &cpu->L);
3419 break;
3420 case 0xA6:
3421 RES_b_cHL(cpu, 4);
3422 break;
3423 case 0xA7:
3424 RES_b_r(4, &cpu->A);
3425 break;
3426 case 0xA8:
3427 RES_b_r(5, &cpu->B);
3428 break;
3429 case 0xA9:
3430 RES_b_r(5, &cpu->C);
3431 break;
3432 case 0xAA:
3433 RES_b_r(5, &cpu->D);
3434 break;
3435 case 0xAB:
3436 RES_b_r(5, &cpu->E);
3437 break;
3438 case 0xAC:
3439 RES_b_r(5, &cpu->H);
3440 break;
3441 case 0xAD:
3442 RES_b_r(5, &cpu->L);
3443 break;
3444 case 0xAE:
3445 RES_b_cHL(cpu, 5);
3446 break;
3447 case 0xAF:
3448 RES_b_r(5, &cpu->A);
3449 break;
3450 case 0xB0:
3451 RES_b_r(6, &cpu->B);
3452 break;
3453 case 0xB1:
3454 RES_b_r(6, &cpu->C);
3455 break;
3456 case 0xB2:
3457 RES_b_r(6, &cpu->D);
3458 break;
3459 case 0xB3:
3460 RES_b_r(6, &cpu->E);
3461 break;
3462 case 0xB4:
3463 RES_b_r(6, &cpu->H);
3464 break;
3465 case 0xB5:
3466 RES_b_r(6, &cpu->L);
3467 break;
3468 case 0xB6:
3469 RES_b_cHL(cpu, 6);
3470 break;
3471 case 0xB7:
3472 RES_b_r(6, &cpu->A);
3473 break;
3474 case 0xB8:
3475 RES_b_r(7, &cpu->B);
3476 break;
3477 case 0xB9:
3478 RES_b_r(7, &cpu->C);
3479 break;
3480 case 0xBA:
3481 RES_b_r(7, &cpu->D);
3482 break;
3483 case 0xBB:
3484 RES_b_r(7, &cpu->E);
3485 break;
3486 case 0xBC:
3487 RES_b_r(7, &cpu->H);
3488 break;
3489 case 0xBD:
3490 RES_b_r(7, &cpu->L);
3491 break;
3492 case 0xBE:
3493 RES_b_cHL(cpu, 7);
3494 break;
3495 case 0xBF:
3496 RES_b_r(7, &cpu->A);
3497 break;
3498 case 0xC0:
3499 SET_b_r(0, &cpu->B);
3500 break;
3501 case 0xC1:
3502 SET_b_r(0, &cpu->C);
3503 break;
3504 case 0xC2:
3505 SET_b_r(0, &cpu->D);
3506 break;
3507 case 0xC3:
3508 SET_b_r(0, &cpu->E);
3509 break;
3510 case 0xC4:
3511 SET_b_r(0, &cpu->H);
3512 break;
3513 case 0xC5:
3514 SET_b_r(0, &cpu->L);
3515 break;
3516 case 0xC6:
3517 SET_b_cHL(cpu, 0);
3518 break;
3519 case 0xC7:
3520 SET_b_r(0, &cpu->A);
3521 break;
3522 case 0xC8:
3523 SET_b_r(1, &cpu->B);
3524 break;
3525 case 0xC9:
3526 SET_b_r(1, &cpu->C);
3527 break;
3528 case 0xCA:
3529 SET_b_r(1, &cpu->D);
3530 break;
3531 case 0xCB:
3532 SET_b_r(1, &cpu->E);
3533 break;
3534 case 0xCC:
3535 SET_b_r(1, &cpu->H);
3536 break;
3537 case 0xCD:
3538 SET_b_r(1, &cpu->L);
3539 break;
3540 case 0xCE:
3541 SET_b_cHL(cpu, 1);
3542 break;
3543 case 0xCF:
3544 SET_b_r(1, &cpu->A);
3545 break;
3546 case 0xD0:
3547 SET_b_r(2, &cpu->B);
3548 break;
3549 case 0xD1:
3550 SET_b_r(2, &cpu->C);
3551 break;
3552 case 0xD2:
3553 SET_b_r(2, &cpu->D);
3554 break;
3555 case 0xD3:
3556 SET_b_r(2, &cpu->E);
3557 break;
3558 case 0xD4:
3559 SET_b_r(2, &cpu->H);
3560 break;
3561 case 0xD5:
3562 SET_b_r(2, &cpu->L);
3563 break;
3564 case 0xD6:
3565 SET_b_cHL(cpu, 2);
3566 break;
3567 case 0xD7:
3568 SET_b_r(2, &cpu->A);
3569 break;
3570 case 0xD8:
3571 SET_b_r(3, &cpu->B);
3572 break;
3573 case 0xD9:
3574 SET_b_r(3, &cpu->C);
3575 break;
3576 case 0xDA:
3577 SET_b_r(3, &cpu->D);
3578 break;
3579 case 0xDB:
3580 SET_b_r(3, &cpu->E);
3581 break;
3582 case 0xDC:
3583 SET_b_r(3, &cpu->H);
3584 break;
3585 case 0xDD:
3586 SET_b_r(3, &cpu->L);
3587 break;
3588 case 0xDE:
3589 SET_b_cHL(cpu, 3);
3590 break;
3591 case 0xDF:
3592 SET_b_r(3, &cpu->A);
3593 break;
3594 case 0xE0:
3595 SET_b_r(4, &cpu->B);
3596 break;
3597 case 0xE1:
3598 SET_b_r(4, &cpu->C);
3599 break;
3600 case 0xE2:
3601 SET_b_r(4, &cpu->D);
3602 break;
3603 case 0xE3:
3604 SET_b_r(4, &cpu->E);
3605 break;
3606 case 0xE4:
3607 SET_b_r(4, &cpu->H);
3608 break;
3609 case 0xE5:
3610 SET_b_r(4, &cpu->L);
3611 break;
3612 case 0xE6:
3613 SET_b_cHL(cpu, 4);
3614 break;
3615 case 0xE7:
3616 SET_b_r(4, &cpu->A);
3617 break;
3618 case 0xE8:
3619 SET_b_r(5, &cpu->B);
3620 break;
3621 case 0xE9:
3622 SET_b_r(5, &cpu->C);
3623 break;
3624 case 0xEA:
3625 SET_b_r(5, &cpu->D);
3626 break;
3627 case 0xEB:
3628 SET_b_r(5, &cpu->E);
3629 break;
3630 case 0xEC:
3631 SET_b_r(5, &cpu->H);
3632 break;
3633 case 0xED:
3634 SET_b_r(5, &cpu->L);
3635 break;
3636 case 0xEE:
3637 SET_b_cHL(cpu, 5);
3638 break;
3639 case 0xEF:
3640 SET_b_r(5, &cpu->A);
3641 break;
3642 case 0xF0:
3643 SET_b_r(6, &cpu->B);
3644 break;
3645 case 0xF1:
3646 SET_b_r(6, &cpu->C);
3647 break;
3648 case 0xF2:
3649 SET_b_r(6, &cpu->D);
3650 break;
3651 case 0xF3:
3652 SET_b_r(6, &cpu->E);
3653 break;
3654 case 0xF4:
3655 SET_b_r(6, &cpu->H);
3656 break;
3657 case 0xF5:
3658 SET_b_r(6, &cpu->L);
3659 break;
3660 case 0xF6:
3661 SET_b_cHL(cpu, 6);
3662 break;
3663 case 0xF7:
3664 SET_b_r(6, &cpu->A);
3665 break;
3666 case 0xF8:
3667 SET_b_r(7, &cpu->B);
3668 break;
3669 case 0xF9:
3670 SET_b_r(7, &cpu->C);
3671 break;
3672 case 0xFA:
3673 SET_b_r(7, &cpu->D);
3674 break;
3675 case 0xFB:
3676 SET_b_r(7, &cpu->E);
3677 break;
3678 case 0xFC:
3679 SET_b_r(7, &cpu->H);
3680 break;
3681 case 0xFD:
3682 SET_b_r(7, &cpu->L);
3683 break;
3684 case 0xFE:
3685 SET_b_cHL(cpu, 7);
3686 break;
3687 case 0xFF:
3688 SET_b_r(7, &cpu->A);
3689 break;
3690 default:
3691 LOG_W("z80: unknown CB opcode (%02x)!\n", opcode);
3692 clock_consume(1);
3693 break;
3694 }
3695 }
3696
z80_opcode_DDFD(struct z80 * cpu,uint8_t prefix)3697 void z80_opcode_DDFD(struct z80 *cpu, uint8_t prefix)
3698 {
3699 uint16_t *reg = (prefix == 0xDD) ? &cpu->IX : &cpu->IY;
3700 uint8_t *low = (prefix == 0xDD) ? &cpu->lIX : &cpu->lIY;
3701 uint8_t *high = (prefix == 0xDD) ? &cpu->hIX : &cpu->hIY;
3702 uint8_t opcode;
3703
3704 /* Fetch DD/FD opcode */
3705 opcode = memory_readb(cpu->bus_id, cpu->PC++);
3706
3707 /* Execute DD/FD opcode */
3708 switch (opcode) {
3709 case 0x09:
3710 ADD_IXY_pp(cpu, &cpu->BC, reg);
3711 break;
3712 case 0x19:
3713 ADD_IXY_pp(cpu, &cpu->DE, reg);
3714 break;
3715 case 0x21:
3716 LD_IXY_nn(cpu, reg);
3717 break;
3718 case 0x22:
3719 LD_cnn_IXY(cpu, reg);
3720 break;
3721 case 0x23:
3722 INC_ss(reg);
3723 break;
3724 case 0x24:
3725 INC_r(cpu, high);
3726 break;
3727 case 0x25:
3728 DEC_r(cpu, high);
3729 break;
3730 case 0x26:
3731 LD_r_n(cpu, high);
3732 break;
3733 case 0x29:
3734 ADD_IXY_pp(cpu, reg, reg);
3735 break;
3736 case 0x2A:
3737 LD_IXY_cnn(cpu, reg);
3738 break;
3739 case 0x2B:
3740 DEC_IXY(reg);
3741 break;
3742 case 0x2C:
3743 INC_r(cpu, low);
3744 break;
3745 case 0x2D:
3746 DEC_r(cpu, low);
3747 break;
3748 case 0x2E:
3749 LD_r_n(cpu, low);
3750 break;
3751 case 0x34:
3752 INC_cIXYpd(cpu, reg);
3753 break;
3754 case 0x35:
3755 DEC_cIXYpd(cpu, reg);
3756 break;
3757 case 0x36:
3758 LD_cIXYpd_n(cpu, reg);
3759 break;
3760 case 0x39:
3761 ADD_IXY_pp(cpu, &cpu->SP, reg);
3762 break;
3763 case 0x46:
3764 LD_r_cIXYpd(cpu, &cpu->B, reg);
3765 break;
3766 case 0x4E:
3767 LD_r_cIXYpd(cpu, &cpu->C, reg);
3768 break;
3769 case 0x56:
3770 LD_r_cIXYpd(cpu, &cpu->D, reg);
3771 break;
3772 case 0x5E:
3773 LD_r_cIXYpd(cpu, &cpu->E, reg);
3774 break;
3775 case 0x66:
3776 LD_r_cIXYpd(cpu, &cpu->H, reg);
3777 break;
3778 case 0x67:
3779 LD_r_r(high, &cpu->A);
3780 break;
3781 case 0x6E:
3782 LD_r_cIXYpd(cpu, &cpu->L, reg);
3783 break;
3784 case 0x6F:
3785 LD_r_r(low, &cpu->A);
3786 break;
3787 case 0x70:
3788 LD_cIXYpd_r(cpu, &cpu->B, reg);
3789 break;
3790 case 0x71:
3791 LD_cIXYpd_r(cpu, &cpu->C, reg);
3792 break;
3793 case 0x72:
3794 LD_cIXYpd_r(cpu, &cpu->D, reg);
3795 break;
3796 case 0x73:
3797 LD_cIXYpd_r(cpu, &cpu->E, reg);
3798 break;
3799 case 0x74:
3800 LD_cIXYpd_r(cpu, &cpu->H, reg);
3801 break;
3802 case 0x75:
3803 LD_cIXYpd_r(cpu, &cpu->L, reg);
3804 break;
3805 case 0x77:
3806 LD_cIXYpd_r(cpu, &cpu->A, reg);
3807 break;
3808 case 0x7C:
3809 LD_r_r(&cpu->A, high);
3810 break;
3811 case 0x7D:
3812 LD_r_r(&cpu->A, low);
3813 break;
3814 case 0x7E:
3815 LD_r_cIXYpd(cpu, &cpu->A, reg);
3816 break;
3817 case 0x86:
3818 ADD_A_cIXYpd(cpu, reg);
3819 break;
3820 case 0x8E:
3821 ADC_A_cIXYpd(cpu, reg);
3822 break;
3823 case 0x96:
3824 SUB_A_cIXYpd(cpu, reg);
3825 break;
3826 case 0x9E:
3827 SBC_A_cIXYpd(cpu, reg);
3828 break;
3829 case 0xA6:
3830 AND_cIXYpd(cpu, reg);
3831 break;
3832 case 0xAE:
3833 XOR_cIXYpd(cpu, reg);
3834 break;
3835 case 0xB6:
3836 OR_cIXYpd(cpu, reg);
3837 break;
3838 case 0xBE:
3839 CP_IXYpd(cpu, reg);
3840 break;
3841 case 0xCB:
3842 z80_opcode_DDFD_CB(cpu, reg);
3843 break;
3844 case 0xE1:
3845 POP_IXY(cpu, reg);
3846 break;
3847 case 0xE3:
3848 EX_cSP_IXY(cpu, reg);
3849 break;
3850 case 0xE5:
3851 PUSH_IXY(cpu, reg);
3852 break;
3853 case 0xE9:
3854 JP_IXY(cpu, reg);
3855 break;
3856 case 0xF9:
3857 LD_SP_IXY(cpu, reg);
3858 break;
3859 case 0xFD:
3860 POP_IXY(cpu, reg);
3861 break;
3862 default:
3863 LOG_W("z80: unknown DD/FD opcode (%02x)!\n", opcode);
3864 clock_consume(1);
3865 break;
3866 }
3867 }
3868
z80_opcode_DDFD_CB(struct z80 * cpu,uint16_t * reg)3869 void z80_opcode_DDFD_CB(struct z80 *cpu, uint16_t *reg)
3870 {
3871 uint8_t opcode;
3872
3873 /* Fetch DD/FD CB opcode */
3874 opcode = memory_readb(cpu->bus_id, cpu->PC + 1);
3875
3876 /* Execute DD/FD CB opcode */
3877 switch (opcode) {
3878 case 0x06:
3879 RLC_cIXYpd(cpu, reg);
3880 break;
3881 case 0x0E:
3882 RRC_cIXYpd(cpu, reg);
3883 break;
3884 case 0x16:
3885 RL_cIXYpd(cpu, reg);
3886 break;
3887 case 0x1E:
3888 RR_cIXYpd(cpu, reg);
3889 break;
3890 case 0x26:
3891 SLA_cIXYpd(cpu, reg);
3892 break;
3893 case 0x2E:
3894 SRA_cIXYpd(cpu, reg);
3895 break;
3896 case 0x36:
3897 SL1_cIXYpd(cpu, reg);
3898 break;
3899 case 0x3E:
3900 SRL_cIXYpd(cpu, reg);
3901 break;
3902 case 0x46:
3903 BIT_b_cIXYpd(cpu, 0, reg);
3904 break;
3905 case 0x4E:
3906 BIT_b_cIXYpd(cpu, 1, reg);
3907 break;
3908 case 0x56:
3909 BIT_b_cIXYpd(cpu, 2, reg);
3910 break;
3911 case 0x5E:
3912 BIT_b_cIXYpd(cpu, 3, reg);
3913 break;
3914 case 0x66:
3915 BIT_b_cIXYpd(cpu, 4, reg);
3916 break;
3917 case 0x6E:
3918 BIT_b_cIXYpd(cpu, 5, reg);
3919 break;
3920 case 0x76:
3921 BIT_b_cIXYpd(cpu, 6, reg);
3922 break;
3923 case 0x7E:
3924 BIT_b_cIXYpd(cpu, 7, reg);
3925 break;
3926 case 0x86:
3927 RES_b_cIXYpd(cpu, 0, reg);
3928 break;
3929 case 0x8E:
3930 RES_b_cIXYpd(cpu, 1, reg);
3931 break;
3932 case 0x96:
3933 RES_b_cIXYpd(cpu, 2, reg);
3934 break;
3935 case 0x9E:
3936 RES_b_cIXYpd(cpu, 3, reg);
3937 break;
3938 case 0xA6:
3939 RES_b_cIXYpd(cpu, 4, reg);
3940 break;
3941 case 0xAE:
3942 RES_b_cIXYpd(cpu, 5, reg);
3943 break;
3944 case 0xB6:
3945 RES_b_cIXYpd(cpu, 6, reg);
3946 break;
3947 case 0xBE:
3948 RES_b_cIXYpd(cpu, 7, reg);
3949 break;
3950 case 0xC6:
3951 SET_b_cIXYpd(cpu, 0, reg);
3952 break;
3953 case 0xCE:
3954 SET_b_cIXYpd(cpu, 1, reg);
3955 break;
3956 case 0xD6:
3957 SET_b_cIXYpd(cpu, 2, reg);
3958 break;
3959 case 0xDE:
3960 SET_b_cIXYpd(cpu, 3, reg);
3961 break;
3962 case 0xE6:
3963 SET_b_cIXYpd(cpu, 4, reg);
3964 break;
3965 case 0xEE:
3966 SET_b_cIXYpd(cpu, 5, reg);
3967 break;
3968 case 0xF6:
3969 SET_b_cIXYpd(cpu, 6, reg);
3970 break;
3971 case 0xFE:
3972 SET_b_cIXYpd(cpu, 7, reg);
3973 break;
3974 default:
3975 LOG_W("z80: unknown DD/FD CB opcode (%02x)!\n", opcode);
3976 clock_consume(1);
3977 break;
3978 }
3979
3980 /* Increment PC */
3981 cpu->PC++;
3982 }
3983
z80_opcode_ED(struct z80 * cpu)3984 void z80_opcode_ED(struct z80 *cpu)
3985 {
3986 uint8_t opcode;
3987
3988 /* Fetch ED opcode */
3989 opcode = memory_readb(cpu->bus_id, cpu->PC++);
3990
3991 /* Execute ED opcode */
3992 switch (opcode) {
3993 case 0x40:
3994 IN_r_cC(cpu, &cpu->B);
3995 break;
3996 case 0x41:
3997 OUT_cC_r(cpu, &cpu->B);
3998 break;
3999 case 0x42:
4000 SBC_HL_rr(cpu, &cpu->BC);
4001 break;
4002 case 0x43:
4003 LD_cnn_dd(cpu, &cpu->BC);
4004 break;
4005 case 0x44:
4006 NEG(cpu);
4007 break;
4008 case 0x45:
4009 RETN(cpu);
4010 break;
4011 case 0x46:
4012 IM_0(cpu);
4013 break;
4014 case 0x47:
4015 LD_I_A(cpu);
4016 break;
4017 case 0x48:
4018 IN_r_cC(cpu, &cpu->C);
4019 break;
4020 case 0x49:
4021 OUT_cC_r(cpu, &cpu->C);
4022 break;
4023 case 0x4A:
4024 ADC_HL_rr(cpu, &cpu->BC);
4025 break;
4026 case 0x4B:
4027 LD_dd_cnn(cpu, &cpu->BC);
4028 break;
4029 case 0x4D:
4030 RETI(cpu);
4031 break;
4032 case 0x4F:
4033 LD_R_A(cpu);
4034 break;
4035 case 0x50:
4036 IN_r_cC(cpu, &cpu->D);
4037 break;
4038 case 0x51:
4039 OUT_cC_r(cpu, &cpu->D);
4040 break;
4041 case 0x52:
4042 SBC_HL_rr(cpu, &cpu->DE);
4043 break;
4044 case 0x53:
4045 LD_cnn_dd(cpu, &cpu->DE);
4046 break;
4047 case 0x56:
4048 IM_1(cpu);
4049 break;
4050 case 0x57:
4051 LD_A_I(cpu);
4052 break;
4053 case 0x58:
4054 IN_r_cC(cpu, &cpu->E);
4055 break;
4056 case 0x59:
4057 OUT_cC_r(cpu, &cpu->E);
4058 break;
4059 case 0x5A:
4060 ADC_HL_rr(cpu, &cpu->DE);
4061 break;
4062 case 0x5B:
4063 LD_dd_cnn(cpu, &cpu->DE);
4064 break;
4065 case 0x5E:
4066 IM_2(cpu);
4067 break;
4068 case 0x5F:
4069 LD_A_R(cpu);
4070 break;
4071 case 0x60:
4072 IN_r_cC(cpu, &cpu->H);
4073 break;
4074 case 0x61:
4075 OUT_cC_r(cpu, &cpu->H);
4076 break;
4077 case 0x67:
4078 RRD(cpu);
4079 break;
4080 case 0x68:
4081 IN_r_cC(cpu, &cpu->L);
4082 break;
4083 case 0x69:
4084 OUT_cC_r(cpu, &cpu->L);
4085 break;
4086 case 0x6A:
4087 ADC_HL_rr(cpu, &cpu->HL);
4088 break;
4089 case 0x6F:
4090 RLD(cpu);
4091 break;
4092 case 0x73:
4093 LD_cnn_dd(cpu, &cpu->SP);
4094 break;
4095 case 0x78:
4096 IN_r_cC(cpu, &cpu->A);
4097 break;
4098 case 0x79:
4099 OUT_cC_r(cpu, &cpu->A);
4100 break;
4101 case 0x7B:
4102 LD_dd_cnn(cpu, &cpu->SP);
4103 break;
4104 case 0xA0:
4105 LDI(cpu);
4106 break;
4107 case 0xA1:
4108 CPI(cpu);
4109 break;
4110 case 0xA2:
4111 INI(cpu);
4112 break;
4113 case 0xA3:
4114 OUTI(cpu);
4115 break;
4116 case 0xA8:
4117 LDD(cpu);
4118 break;
4119 case 0xA9:
4120 CPD(cpu);
4121 break;
4122 case 0xAB:
4123 OUTD(cpu);
4124 break;
4125 case 0xAA:
4126 IND(cpu);
4127 break;
4128 case 0xB0:
4129 LDIR(cpu);
4130 break;
4131 case 0xB1:
4132 CPIR(cpu);
4133 break;
4134 case 0xB2:
4135 INIR(cpu);
4136 break;
4137 case 0xB3:
4138 OTIR(cpu);
4139 break;
4140 case 0xB8:
4141 LDDR(cpu);
4142 break;
4143 case 0xB9:
4144 CPDR(cpu);
4145 break;
4146 case 0xBA:
4147 INDR(cpu);
4148 break;
4149 case 0xBB:
4150 OTDR(cpu);
4151 break;
4152 default:
4153 LOG_W("z80: unknown ED opcode (%02x)!\n", opcode);
4154 clock_consume(1);
4155 break;
4156 }
4157 }
4158
z80_init(struct cpu_instance * instance)4159 bool z80_init(struct cpu_instance *instance)
4160 {
4161 struct z80 *cpu;
4162 struct resource *res;
4163
4164 /* Allocate z80 structure and set private data */
4165 cpu = calloc(1, sizeof(struct z80));
4166 instance->priv_data = cpu;
4167
4168 /* Save bus ID */
4169 cpu->bus_id = instance->bus_id;
4170
4171 /* Add CPU clock */
4172 res = resource_get("clk",
4173 RESOURCE_CLK,
4174 instance->resources,
4175 instance->num_resources);
4176 cpu->clock.rate = res->data.clk;
4177 cpu->clock.data = cpu;
4178 cpu->clock.tick = (clock_tick_t)z80_tick;
4179 clock_add(&cpu->clock);
4180
4181 return true;
4182 }
4183
z80_reset(struct cpu_instance * instance)4184 void z80_reset(struct cpu_instance *instance)
4185 {
4186 struct z80 *cpu = instance->priv_data;
4187
4188 /* Initialize processor data */
4189 cpu->AF = 0;
4190 cpu->BC = 0;
4191 cpu->DE = 0;
4192 cpu->HL = 0;
4193 cpu->A2F2 = 0;
4194 cpu->B2C2 = 0;
4195 cpu->D2E2 = 0;
4196 cpu->H2L2 = 0;
4197 cpu->PC = 0;
4198 cpu->SP = 0xDFF0;
4199 cpu->IX = 0xFFFF;
4200 cpu->IY = 0xFFFF;
4201 cpu->IFF1 = false;
4202 cpu->IFF2 = false;
4203 cpu->irq_delay = false;
4204 cpu->interrupt_mode = 0;
4205 cpu->irq_pending = false;
4206 cpu->nmi_pending = false;
4207 cpu->halted = false;
4208
4209 /* Enable clock */
4210 cpu->clock.enabled = true;
4211 }
4212
z80_interrupt(struct cpu_instance * instance,int irq)4213 void z80_interrupt(struct cpu_instance *instance, int irq)
4214 {
4215 struct z80 *cpu = instance->priv_data;
4216
4217 /* Handle IRQ or NMI */
4218 if (irq == IRQ_N)
4219 cpu->irq_pending = true;
4220 else if (irq == NMI_N)
4221 cpu->nmi_pending = true;
4222 }
4223
z80_deinit(struct cpu_instance * instance)4224 void z80_deinit(struct cpu_instance *instance)
4225 {
4226 struct z80 *cpu = instance->priv_data;
4227 free(cpu);
4228 }
4229
4230 CPU_START(z80)
4231 .init = z80_init,
4232 .reset = z80_reset,
4233 .interrupt = z80_interrupt,
4234 .deinit = z80_deinit
4235 CPU_END
4236
4237