Mercurial > repos > blastem

comparison mame_z80/z80.c @ 1507:2455662378ed mame_interp

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Added MAME Z80 core, re-enabled 68K tracing in Musashi core, disabled a bunch of code gen stuff when using interpreters from MAME
author Michael Pavone <pavone@retrodev.com>
date Sat, 30 Dec 2017 18:27:06 -0800
parents
children 2e57910fd641
comparison
equal deleted inserted replaced
1506:ded16f3d7eb4 1507:2455662378ed
1 // license:BSD-3-Clause
2 // copyright-holders:Juergen Buchmueller
3 /*****************************************************************************
4 *
5 * z80.c
6 * Portable Z80 emulator V3.9
7 *
8 * TODO:
9 * - Interrupt mode 0 should be able to execute arbitrary opcodes
10 * - If LD A,I or LD A,R is interrupted, P/V flag gets reset, even if IFF2
11 * was set before this instruction (implemented, but not enabled: we need
12 * document Z80 types first, see below)
13 * - WAIT only stalls between instructions now, it should stall immediately.
14 * - Ideally, the tiny differences between Z80 types should be supported,
15 * currently known differences:
16 * - LD A,I/R P/V flag reset glitch is fixed on CMOS Z80
17 * - OUT (C),0 outputs 0 on NMOS Z80, $FF on CMOS Z80
18 * - SCF/CCF X/Y flags is ((flags | A) & 0x28) on SGS/SHARP/ZiLOG NMOS Z80,
19 * (flags & A & 0x28) on NEC NMOS Z80, other models unknown.
20 * However, people from the Speccy scene mention that SCF/CCF X/Y results
21 * are inconsistant and may be influenced by I and R registers.
22 * This Z80 emulator assumes a ZiLOG NMOS model.
23 *
24 * Changes in 3.9:
25 * - Fixed cycle counts for LD IYL/IXL/IYH/IXH,n [Marshmellow]
26 * - Fixed X/Y flags in CCF/SCF/BIT, ZEXALL is happy now [hap]
27 * - Simplified DAA, renamed MEMPTR (3.8) to WZ, added TODO [hap]
28 * - Fixed IM2 interrupt cycles [eke]
29 * Changes in 3.8 [Miodrag Milanovic]:
30 * - Added MEMPTR register (according to informations provided
31 * by Vladimir Kladov
32 * - BIT n,(HL) now return valid values due to use of MEMPTR
33 * - Fixed BIT 6,(XY+o) undocumented instructions
34 * Changes in 3.7 [Aaron Giles]:
35 * - Changed NMI handling. NMIs are now latched in set_irq_state
36 * but are not taken there. Instead they are taken at the start of the
37 * execute loop.
38 * - Changed IRQ handling. IRQ state is set in set_irq_state but not taken
39 * except during the inner execute loop.
40 * - Removed x86 assembly hacks and obsolete timing loop catchers.
41 * Changes in 3.6:
42 * - Got rid of the code that would inexactly emulate a Z80, i.e. removed
43 * all the #if Z80_EXACT #else branches.
44 * - Removed leading underscores from local register name shortcuts as
45 * this violates the C99 standard.
46 * - Renamed the registers inside the Z80 context to lower case to avoid
47 * ambiguities (shortcuts would have had the same names as the fields
48 * of the structure).
49 * Changes in 3.5:
50 * - Implemented OTIR, INIR, etc. without look-up table for PF flag.
51 * [Ramsoft, Sean Young]
52 * Changes in 3.4:
53 * - Removed Z80-MSX specific code as it's not needed any more.
54 * - Implemented DAA without look-up table [Ramsoft, Sean Young]
55 * Changes in 3.3:
56 * - Fixed undocumented flags XF & YF in the non-asm versions of CP,
57 * and all the 16 bit arithmetic instructions. [Sean Young]
58 * Changes in 3.2:
59 * - Fixed undocumented flags XF & YF of RRCA, and CF and HF of
60 * INI/IND/OUTI/OUTD/INIR/INDR/OTIR/OTDR [Sean Young]
61 * Changes in 3.1:
62 * - removed the REPEAT_AT_ONCE execution of LDIR/CPIR etc. opcodes
63 * for readabilities sake and because the implementation was buggy
64 * (and i was not able to find the difference)
65 * Changes in 3.0:
66 * - 'finished' switch to dynamically overrideable cycle count tables
67 * Changes in 2.9:
68 * - added methods to access and override the cycle count tables
69 * - fixed handling and timing of multiple DD/FD prefixed opcodes
70 * Changes in 2.8:
71 * - OUTI/OUTD/OTIR/OTDR also pre-decrement the B register now.
72 * This was wrong because of a bug fix on the wrong side
73 * (astrocade sound driver).
74 * Changes in 2.7:
75 * - removed z80_vm specific code, it's not needed (and never was).
76 * Changes in 2.6:
77 * - BUSY_LOOP_HACKS needed to call change_pc() earlier, before
78 * checking the opcodes at the new address, because otherwise they
79 * might access the old (wrong or even nullptr) banked memory region.
80 * Thanks to Sean Young for finding this nasty bug.
81 * Changes in 2.5:
82 * - Burning cycles always adjusts the ICount by a multiple of 4.
83 * - In REPEAT_AT_ONCE cases the r register wasn't incremented twice
84 * per repetition as it should have been. Those repeated opcodes
85 * could also underflow the ICount.
86 * - Simplified TIME_LOOP_HACKS for BC and added two more for DE + HL
87 * timing loops. i think those hacks weren't endian safe before too.
88 * Changes in 2.4:
89 * - z80_reset zaps the entire context, sets IX and IY to 0xffff(!) and
90 * sets the Z flag. With these changes the Tehkan World Cup driver
91 * _seems_ to work again.
92 * Changes in 2.3:
93 * - External termination of the execution loop calls z80_burn() and
94 * z80_vm_burn() to burn an amount of cycles (r adjustment)
95 * - Shortcuts which burn CPU cycles (BUSY_LOOP_HACKS and TIME_LOOP_HACKS)
96 * now also adjust the r register depending on the skipped opcodes.
97 * Changes in 2.2:
98 * - Fixed bugs in CPL, SCF and CCF instructions flag handling.
99 * - Changed variable ea and arg16() function to uint32_t; this
100 * produces slightly more efficient code.
101 * - The DD/FD XY CB opcodes where XY is 40-7F and Y is not 6/E
102 * are changed to calls to the X6/XE opcodes to reduce object size.
103 * They're hardly ever used so this should not yield a speed penalty.
104 * New in 2.0:
105 * - Optional more exact Z80 emulation (#define Z80_EXACT 1) according
106 * to a detailed description by Sean Young which can be found at:
107 * http://www.msxnet.org/tech/z80-documented.pdf
108 *****************************************************************************/
109
110 #include "z80.h"
111 #include "../util.h"
112 #include <string.h>
113 #include <stdlib.h>
114 #include <limits.h>
115
116 #define VERBOSE 0
117
118 /* On an NMOS Z80, if LD A,I or LD A,R is interrupted, P/V flag gets reset,
119 even if IFF2 was set before this instruction. This issue was fixed on
120 the CMOS Z80, so until knowing (most) Z80 types on hardware, it's disabled */
121 #define HAS_LDAIR_QUIRK 0
122
123 #define LOG(x) do { if (VERBOSE) warning x; } while (0)
124
125
126 /****************************************************************************/
127 /* The Z80 registers. halt is set to 1 when the CPU is halted, the refresh */
128 /* register is calculated as follows: refresh=(r&127)|(r2&128) */
129 /****************************************************************************/
130
131 #define CF 0x01
132 #define NF 0x02
133 #define PF 0x04
134 #define VF PF
135 #define XF 0x08
136 #define HF 0x10
137 #define YF 0x20
138 #define ZF 0x40
139 #define SF 0x80
140
141 #define INT_IRQ 0x01
142 #define NMI_IRQ 0x02
143
144 #define PRVPC z80->m_prvpc.d /* previous program counter */
145
146 #define PCD z80->m_pc.d
147 #define PC z80->m_pc.w.l
148
149 #define SPD z80->m_sp.d
150 #define SP z80->m_sp.w.l
151
152 #define AFD z80->m_af.d
153 #define AF z80->m_af.w.l
154 #define A z80->m_af.b.h
155 #define F z80->m_af.b.l
156
157 #define BCD z80->m_bc.d
158 #define BC z80->m_bc.w.l
159 #define B z80->m_bc.b.h
160 #define C z80->m_bc.b.l
161
162 #define DED z80->m_de.d
163 #define DE z80->m_de.w.l
164 #define D z80->m_de.b.h
165 #define E z80->m_de.b.l
166
167 #define HLD z80->m_hl.d
168 #define HL z80->m_hl.w.l
169 #define H z80->m_hl.b.h
170 #define L z80->m_hl.b.l
171
172 #define IXD z80->m_ix.d
173 #define IX z80->m_ix.w.l
174 #define HX z80->m_ix.b.h
175 #define LX z80->m_ix.b.l
176
177 #define IYD z80->m_iy.d
178 #define IY z80->m_iy.w.l
179 #define HY z80->m_iy.b.h
180 #define LY z80->m_iy.b.l
181
182 #define WZ z80->m_wz.w.l
183 #define WZ_H z80->m_wz.b.h
184 #define WZ_L z80->m_wz.b.l
185
186
187 static uint8_t tables_initialised = 0;
188 static uint8_t SZ[256]; /* zero and sign flags */
189 static uint8_t SZ_BIT[256]; /* zero, sign and parity/overflow (=zero) flags for BIT opcode */
190 static uint8_t SZP[256]; /* zero, sign and parity flags */
191 static uint8_t SZHV_inc[256]; /* zero, sign, half carry and overflow flags INC r8 */
192 static uint8_t SZHV_dec[256]; /* zero, sign, half carry and overflow flags DEC r8 */
193
194 static uint8_t SZHVC_add[2*256*256];
195 static uint8_t SZHVC_sub[2*256*256];
196
197 static const uint8_t cc_op[0x100] = {
198 4,10, 7, 6, 4, 4, 7, 4, 4,11, 7, 6, 4, 4, 7, 4,
199 8,10, 7, 6, 4, 4, 7, 4,12,11, 7, 6, 4, 4, 7, 4,
200 7,10,16, 6, 4, 4, 7, 4, 7,11,16, 6, 4, 4, 7, 4,
201 7,10,13, 6,11,11,10, 4, 7,11,13, 6, 4, 4, 7, 4,
202 4, 4, 4, 4, 4, 4, 7, 4, 4, 4, 4, 4, 4, 4, 7, 4,
203 4, 4, 4, 4, 4, 4, 7, 4, 4, 4, 4, 4, 4, 4, 7, 4,
204 4, 4, 4, 4, 4, 4, 7, 4, 4, 4, 4, 4, 4, 4, 7, 4,
205 7, 7, 7, 7, 7, 7, 4, 7, 4, 4, 4, 4, 4, 4, 7, 4,
206 4, 4, 4, 4, 4, 4, 7, 4, 4, 4, 4, 4, 4, 4, 7, 4,
207 4, 4, 4, 4, 4, 4, 7, 4, 4, 4, 4, 4, 4, 4, 7, 4,
208 4, 4, 4, 4, 4, 4, 7, 4, 4, 4, 4, 4, 4, 4, 7, 4,
209 4, 4, 4, 4, 4, 4, 7, 4, 4, 4, 4, 4, 4, 4, 7, 4,
210 5,10,10,10,10,11, 7,11, 5,10,10, 0,10,17, 7,11, /* cb -> cc_cb */
211 5,10,10,11,10,11, 7,11, 5, 4,10,11,10, 0, 7,11, /* dd -> cc_xy */
212 5,10,10,19,10,11, 7,11, 5, 4,10, 4,10, 0, 7,11, /* ed -> cc_ed */
213 5,10,10, 4,10,11, 7,11, 5, 6,10, 4,10, 0, 7,11 /* fd -> cc_xy */
214 };
215
216 static const uint8_t cc_cb[0x100] = {
217 8, 8, 8, 8, 8, 8,15, 8, 8, 8, 8, 8, 8, 8,15, 8,
218 8, 8, 8, 8, 8, 8,15, 8, 8, 8, 8, 8, 8, 8,15, 8,
219 8, 8, 8, 8, 8, 8,15, 8, 8, 8, 8, 8, 8, 8,15, 8,
220 8, 8, 8, 8, 8, 8,15, 8, 8, 8, 8, 8, 8, 8,15, 8,
221 8, 8, 8, 8, 8, 8,12, 8, 8, 8, 8, 8, 8, 8,12, 8,
222 8, 8, 8, 8, 8, 8,12, 8, 8, 8, 8, 8, 8, 8,12, 8,
223 8, 8, 8, 8, 8, 8,12, 8, 8, 8, 8, 8, 8, 8,12, 8,
224 8, 8, 8, 8, 8, 8,12, 8, 8, 8, 8, 8, 8, 8,12, 8,
225 8, 8, 8, 8, 8, 8,15, 8, 8, 8, 8, 8, 8, 8,15, 8,
226 8, 8, 8, 8, 8, 8,15, 8, 8, 8, 8, 8, 8, 8,15, 8,
227 8, 8, 8, 8, 8, 8,15, 8, 8, 8, 8, 8, 8, 8,15, 8,
228 8, 8, 8, 8, 8, 8,15, 8, 8, 8, 8, 8, 8, 8,15, 8,
229 8, 8, 8, 8, 8, 8,15, 8, 8, 8, 8, 8, 8, 8,15, 8,
230 8, 8, 8, 8, 8, 8,15, 8, 8, 8, 8, 8, 8, 8,15, 8,
231 8, 8, 8, 8, 8, 8,15, 8, 8, 8, 8, 8, 8, 8,15, 8,
232 8, 8, 8, 8, 8, 8,15, 8, 8, 8, 8, 8, 8, 8,15, 8
233 };
234
235 static const uint8_t cc_ed[0x100] = {
236 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
237 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
238 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
239 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
240 12,12,15,20, 8,14, 8, 9,12,12,15,20, 8,14, 8, 9,
241 12,12,15,20, 8,14, 8, 9,12,12,15,20, 8,14, 8, 9,
242 12,12,15,20, 8,14, 8,18,12,12,15,20, 8,14, 8,18,
243 12,12,15,20, 8,14, 8, 8,12,12,15,20, 8,14, 8, 8,
244 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
245 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
246 16,16,16,16, 8, 8, 8, 8,16,16,16,16, 8, 8, 8, 8,
247 16,16,16,16, 8, 8, 8, 8,16,16,16,16, 8, 8, 8, 8,
248 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
249 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
250 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
251 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8
252 };
253
254 /* ix/iy: with the exception of (i+offset) opcodes, t-states are main_opcode_table + 4 */
255 static const uint8_t cc_xy[0x100] = {
256 4+4,10+4, 7+4, 6+4, 4+4, 4+4, 7+4, 4+4, 4+4,11+4, 7+4, 6+4, 4+4, 4+4, 7+4, 4+4,
257 8+4,10+4, 7+4, 6+4, 4+4, 4+4, 7+4, 4+4,12+4,11+4, 7+4, 6+4, 4+4, 4+4, 7+4, 4+4,
258 7+4,10+4,16+4, 6+4, 4+4, 4+4, 7+4, 4+4, 7+4,11+4,16+4, 6+4, 4+4, 4+4, 7+4, 4+4,
259 7+4,10+4,13+4, 6+4,23 ,23 ,19 , 4+4, 7+4,11+4,13+4, 6+4, 4+4, 4+4, 7+4, 4+4,
260 4+4, 4+4, 4+4, 4+4, 4+4, 4+4,19 , 4+4, 4+4, 4+4, 4+4, 4+4, 4+4, 4+4,19 , 4+4,
261 4+4, 4+4, 4+4, 4+4, 4+4, 4+4,19 , 4+4, 4+4, 4+4, 4+4, 4+4, 4+4, 4+4,19 , 4+4,
262 4+4, 4+4, 4+4, 4+4, 4+4, 4+4,19 , 4+4, 4+4, 4+4, 4+4, 4+4, 4+4, 4+4,19 , 4+4,
263 19 ,19 ,19 ,19 ,19 ,19 , 4+4,19 , 4+4, 4+4, 4+4, 4+4, 4+4, 4+4,19 , 4+4,
264 4+4, 4+4, 4+4, 4+4, 4+4, 4+4,19 , 4+4, 4+4, 4+4, 4+4, 4+4, 4+4, 4+4,19 , 4+4,
265 4+4, 4+4, 4+4, 4+4, 4+4, 4+4,19 , 4+4, 4+4, 4+4, 4+4, 4+4, 4+4, 4+4,19 , 4+4,
266 4+4, 4+4, 4+4, 4+4, 4+4, 4+4,19 , 4+4, 4+4, 4+4, 4+4, 4+4, 4+4, 4+4,19 , 4+4,
267 4+4, 4+4, 4+4, 4+4, 4+4, 4+4,19 , 4+4, 4+4, 4+4, 4+4, 4+4, 4+4, 4+4,19 , 4+4,
268 5+4,10+4,10+4,10+4,10+4,11+4, 7+4,11+4, 5+4,10+4,10+4, 0 ,10+4,17+4, 7+4,11+4, /* cb -> cc_xycb */
269 5+4,10+4,10+4,11+4,10+4,11+4, 7+4,11+4, 5+4, 4+4,10+4,11+4,10+4, 4 , 7+4,11+4, /* dd -> cc_xy again */
270 5+4,10+4,10+4,19+4,10+4,11+4, 7+4,11+4, 5+4, 4+4,10+4, 4+4,10+4, 4 , 7+4,11+4, /* ed -> cc_ed */
271 5+4,10+4,10+4, 4+4,10+4,11+4, 7+4,11+4, 5+4, 6+4,10+4, 4+4,10+4, 4 , 7+4,11+4 /* fd -> cc_xy again */
272 };
273
274 static const uint8_t cc_xycb[0x100] = {
275 23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,
276 23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,
277 23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,
278 23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,
279 20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,
280 20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,
281 20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,
282 20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,
283 23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,
284 23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,
285 23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,
286 23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,
287 23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,
288 23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,
289 23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,
290 23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23
291 };
292
293 /* extra cycles if jr/jp/call taken and 'interrupt latency' on rst 0-7 */
294 static const uint8_t cc_ex[0x100] = {
295 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
296 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* DJNZ */
297 5, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, /* JR NZ/JR Z */
298 5, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, /* JR NC/JR C */
299 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
300 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
301 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
302 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
303 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
304 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
305 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
306 5, 5, 5, 5, 0, 0, 0, 0, 5, 5, 5, 5, 0, 0, 0, 0, /* LDIR/CPIR/INIR/OTIR LDDR/CPDR/INDR/OTDR */
307 6, 0, 0, 0, 7, 0, 0, 2, 6, 0, 0, 0, 7, 0, 0, 2,
308 6, 0, 0, 0, 7, 0, 0, 2, 6, 0, 0, 0, 7, 0, 0, 2,
309 6, 0, 0, 0, 7, 0, 0, 2, 6, 0, 0, 0, 7, 0, 0, 2,
310 6, 0, 0, 0, 7, 0, 0, 2, 6, 0, 0, 0, 7, 0, 0, 2
311 };
312
313 #define m_cc_dd m_cc_xy
314 #define m_cc_fd m_cc_xy
315
316 /***************************************************************
317 * define an opcode function
318 ***************************************************************/
319 #define OP(prefix,opcode) static inline void prefix##_##opcode(z80_device *z80)
320
321 /***************************************************************
322 * adjust cycle count by n T-states
323 ***************************************************************/
324 #define CC(prefix,opcode) do { z80->m_icount -= z80->m_cc_##prefix[opcode]; } while (0)
325
326 #define EXEC(prefix,opcode) do { \
327 unsigned op = opcode; \
328 CC(prefix,op); \
329 switch(op) \
330 { \
331 case 0x00:prefix##_##00(z80);break; case 0x01:prefix##_##01(z80);break; case 0x02:prefix##_##02(z80);break; case 0x03:prefix##_##03(z80);break; \
332 case 0x04:prefix##_##04(z80);break; case 0x05:prefix##_##05(z80);break; case 0x06:prefix##_##06(z80);break; case 0x07:prefix##_##07(z80);break; \
333 case 0x08:prefix##_##08(z80);break; case 0x09:prefix##_##09(z80);break; case 0x0a:prefix##_##0a(z80);break; case 0x0b:prefix##_##0b(z80);break; \
334 case 0x0c:prefix##_##0c(z80);break; case 0x0d:prefix##_##0d(z80);break; case 0x0e:prefix##_##0e(z80);break; case 0x0f:prefix##_##0f(z80);break; \
335 case 0x10:prefix##_##10(z80);break; case 0x11:prefix##_##11(z80);break; case 0x12:prefix##_##12(z80);break; case 0x13:prefix##_##13(z80);break; \
336 case 0x14:prefix##_##14(z80);break; case 0x15:prefix##_##15(z80);break; case 0x16:prefix##_##16(z80);break; case 0x17:prefix##_##17(z80);break; \
337 case 0x18:prefix##_##18(z80);break; case 0x19:prefix##_##19(z80);break; case 0x1a:prefix##_##1a(z80);break; case 0x1b:prefix##_##1b(z80);break; \
338 case 0x1c:prefix##_##1c(z80);break; case 0x1d:prefix##_##1d(z80);break; case 0x1e:prefix##_##1e(z80);break; case 0x1f:prefix##_##1f(z80);break; \
339 case 0x20:prefix##_##20(z80);break; case 0x21:prefix##_##21(z80);break; case 0x22:prefix##_##22(z80);break; case 0x23:prefix##_##23(z80);break; \
340 case 0x24:prefix##_##24(z80);break; case 0x25:prefix##_##25(z80);break; case 0x26:prefix##_##26(z80);break; case 0x27:prefix##_##27(z80);break; \
341 case 0x28:prefix##_##28(z80);break; case 0x29:prefix##_##29(z80);break; case 0x2a:prefix##_##2a(z80);break; case 0x2b:prefix##_##2b(z80);break; \
342 case 0x2c:prefix##_##2c(z80);break; case 0x2d:prefix##_##2d(z80);break; case 0x2e:prefix##_##2e(z80);break; case 0x2f:prefix##_##2f(z80);break; \
343 case 0x30:prefix##_##30(z80);break; case 0x31:prefix##_##31(z80);break; case 0x32:prefix##_##32(z80);break; case 0x33:prefix##_##33(z80);break; \
344 case 0x34:prefix##_##34(z80);break; case 0x35:prefix##_##35(z80);break; case 0x36:prefix##_##36(z80);break; case 0x37:prefix##_##37(z80);break; \
345 case 0x38:prefix##_##38(z80);break; case 0x39:prefix##_##39(z80);break; case 0x3a:prefix##_##3a(z80);break; case 0x3b:prefix##_##3b(z80);break; \
346 case 0x3c:prefix##_##3c(z80);break; case 0x3d:prefix##_##3d(z80);break; case 0x3e:prefix##_##3e(z80);break; case 0x3f:prefix##_##3f(z80);break; \
347 case 0x40:prefix##_##40(z80);break; case 0x41:prefix##_##41(z80);break; case 0x42:prefix##_##42(z80);break; case 0x43:prefix##_##43(z80);break; \
348 case 0x44:prefix##_##44(z80);break; case 0x45:prefix##_##45(z80);break; case 0x46:prefix##_##46(z80);break; case 0x47:prefix##_##47(z80);break; \
349 case 0x48:prefix##_##48(z80);break; case 0x49:prefix##_##49(z80);break; case 0x4a:prefix##_##4a(z80);break; case 0x4b:prefix##_##4b(z80);break; \
350 case 0x4c:prefix##_##4c(z80);break; case 0x4d:prefix##_##4d(z80);break; case 0x4e:prefix##_##4e(z80);break; case 0x4f:prefix##_##4f(z80);break; \
351 case 0x50:prefix##_##50(z80);break; case 0x51:prefix##_##51(z80);break; case 0x52:prefix##_##52(z80);break; case 0x53:prefix##_##53(z80);break; \
352 case 0x54:prefix##_##54(z80);break; case 0x55:prefix##_##55(z80);break; case 0x56:prefix##_##56(z80);break; case 0x57:prefix##_##57(z80);break; \
353 case 0x58:prefix##_##58(z80);break; case 0x59:prefix##_##59(z80);break; case 0x5a:prefix##_##5a(z80);break; case 0x5b:prefix##_##5b(z80);break; \
354 case 0x5c:prefix##_##5c(z80);break; case 0x5d:prefix##_##5d(z80);break; case 0x5e:prefix##_##5e(z80);break; case 0x5f:prefix##_##5f(z80);break; \
355 case 0x60:prefix##_##60(z80);break; case 0x61:prefix##_##61(z80);break; case 0x62:prefix##_##62(z80);break; case 0x63:prefix##_##63(z80);break; \
356 case 0x64:prefix##_##64(z80);break; case 0x65:prefix##_##65(z80);break; case 0x66:prefix##_##66(z80);break; case 0x67:prefix##_##67(z80);break; \
357 case 0x68:prefix##_##68(z80);break; case 0x69:prefix##_##69(z80);break; case 0x6a:prefix##_##6a(z80);break; case 0x6b:prefix##_##6b(z80);break; \
358 case 0x6c:prefix##_##6c(z80);break; case 0x6d:prefix##_##6d(z80);break; case 0x6e:prefix##_##6e(z80);break; case 0x6f:prefix##_##6f(z80);break; \
359 case 0x70:prefix##_##70(z80);break; case 0x71:prefix##_##71(z80);break; case 0x72:prefix##_##72(z80);break; case 0x73:prefix##_##73(z80);break; \
360 case 0x74:prefix##_##74(z80);break; case 0x75:prefix##_##75(z80);break; case 0x76:prefix##_##76(z80);break; case 0x77:prefix##_##77(z80);break; \
361 case 0x78:prefix##_##78(z80);break; case 0x79:prefix##_##79(z80);break; case 0x7a:prefix##_##7a(z80);break; case 0x7b:prefix##_##7b(z80);break; \
362 case 0x7c:prefix##_##7c(z80);break; case 0x7d:prefix##_##7d(z80);break; case 0x7e:prefix##_##7e(z80);break; case 0x7f:prefix##_##7f(z80);break; \
363 case 0x80:prefix##_##80(z80);break; case 0x81:prefix##_##81(z80);break; case 0x82:prefix##_##82(z80);break; case 0x83:prefix##_##83(z80);break; \
364 case 0x84:prefix##_##84(z80);break; case 0x85:prefix##_##85(z80);break; case 0x86:prefix##_##86(z80);break; case 0x87:prefix##_##87(z80);break; \
365 case 0x88:prefix##_##88(z80);break; case 0x89:prefix##_##89(z80);break; case 0x8a:prefix##_##8a(z80);break; case 0x8b:prefix##_##8b(z80);break; \
366 case 0x8c:prefix##_##8c(z80);break; case 0x8d:prefix##_##8d(z80);break; case 0x8e:prefix##_##8e(z80);break; case 0x8f:prefix##_##8f(z80);break; \
367 case 0x90:prefix##_##90(z80);break; case 0x91:prefix##_##91(z80);break; case 0x92:prefix##_##92(z80);break; case 0x93:prefix##_##93(z80);break; \
368 case 0x94:prefix##_##94(z80);break; case 0x95:prefix##_##95(z80);break; case 0x96:prefix##_##96(z80);break; case 0x97:prefix##_##97(z80);break; \
369 case 0x98:prefix##_##98(z80);break; case 0x99:prefix##_##99(z80);break; case 0x9a:prefix##_##9a(z80);break; case 0x9b:prefix##_##9b(z80);break; \
370 case 0x9c:prefix##_##9c(z80);break; case 0x9d:prefix##_##9d(z80);break; case 0x9e:prefix##_##9e(z80);break; case 0x9f:prefix##_##9f(z80);break; \
371 case 0xa0:prefix##_##a0(z80);break; case 0xa1:prefix##_##a1(z80);break; case 0xa2:prefix##_##a2(z80);break; case 0xa3:prefix##_##a3(z80);break; \
372 case 0xa4:prefix##_##a4(z80);break; case 0xa5:prefix##_##a5(z80);break; case 0xa6:prefix##_##a6(z80);break; case 0xa7:prefix##_##a7(z80);break; \
373 case 0xa8:prefix##_##a8(z80);break; case 0xa9:prefix##_##a9(z80);break; case 0xaa:prefix##_##aa(z80);break; case 0xab:prefix##_##ab(z80);break; \
374 case 0xac:prefix##_##ac(z80);break; case 0xad:prefix##_##ad(z80);break; case 0xae:prefix##_##ae(z80);break; case 0xaf:prefix##_##af(z80);break; \
375 case 0xb0:prefix##_##b0(z80);break; case 0xb1:prefix##_##b1(z80);break; case 0xb2:prefix##_##b2(z80);break; case 0xb3:prefix##_##b3(z80);break; \
376 case 0xb4:prefix##_##b4(z80);break; case 0xb5:prefix##_##b5(z80);break; case 0xb6:prefix##_##b6(z80);break; case 0xb7:prefix##_##b7(z80);break; \
377 case 0xb8:prefix##_##b8(z80);break; case 0xb9:prefix##_##b9(z80);break; case 0xba:prefix##_##ba(z80);break; case 0xbb:prefix##_##bb(z80);break; \
378 case 0xbc:prefix##_##bc(z80);break; case 0xbd:prefix##_##bd(z80);break; case 0xbe:prefix##_##be(z80);break; case 0xbf:prefix##_##bf(z80);break; \
379 case 0xc0:prefix##_##c0(z80);break; case 0xc1:prefix##_##c1(z80);break; case 0xc2:prefix##_##c2(z80);break; case 0xc3:prefix##_##c3(z80);break; \
380 case 0xc4:prefix##_##c4(z80);break; case 0xc5:prefix##_##c5(z80);break; case 0xc6:prefix##_##c6(z80);break; case 0xc7:prefix##_##c7(z80);break; \
381 case 0xc8:prefix##_##c8(z80);break; case 0xc9:prefix##_##c9(z80);break; case 0xca:prefix##_##ca(z80);break; case 0xcb:prefix##_##cb(z80);break; \
382 case 0xcc:prefix##_##cc(z80);break; case 0xcd:prefix##_##cd(z80);break; case 0xce:prefix##_##ce(z80);break; case 0xcf:prefix##_##cf(z80);break; \
383 case 0xd0:prefix##_##d0(z80);break; case 0xd1:prefix##_##d1(z80);break; case 0xd2:prefix##_##d2(z80);break; case 0xd3:prefix##_##d3(z80);break; \
384 case 0xd4:prefix##_##d4(z80);break; case 0xd5:prefix##_##d5(z80);break; case 0xd6:prefix##_##d6(z80);break; case 0xd7:prefix##_##d7(z80);break; \
385 case 0xd8:prefix##_##d8(z80);break; case 0xd9:prefix##_##d9(z80);break; case 0xda:prefix##_##da(z80);break; case 0xdb:prefix##_##db(z80);break; \
386 case 0xdc:prefix##_##dc(z80);break; case 0xdd:prefix##_##dd(z80);break; case 0xde:prefix##_##de(z80);break; case 0xdf:prefix##_##df(z80);break; \
387 case 0xe0:prefix##_##e0(z80);break; case 0xe1:prefix##_##e1(z80);break; case 0xe2:prefix##_##e2(z80);break; case 0xe3:prefix##_##e3(z80);break; \
388 case 0xe4:prefix##_##e4(z80);break; case 0xe5:prefix##_##e5(z80);break; case 0xe6:prefix##_##e6(z80);break; case 0xe7:prefix##_##e7(z80);break; \
389 case 0xe8:prefix##_##e8(z80);break; case 0xe9:prefix##_##e9(z80);break; case 0xea:prefix##_##ea(z80);break; case 0xeb:prefix##_##eb(z80);break; \
390 case 0xec:prefix##_##ec(z80);break; case 0xed:prefix##_##ed(z80);break; case 0xee:prefix##_##ee(z80);break; case 0xef:prefix##_##ef(z80);break; \
391 case 0xf0:prefix##_##f0(z80);break; case 0xf1:prefix##_##f1(z80);break; case 0xf2:prefix##_##f2(z80);break; case 0xf3:prefix##_##f3(z80);break; \
392 case 0xf4:prefix##_##f4(z80);break; case 0xf5:prefix##_##f5(z80);break; case 0xf6:prefix##_##f6(z80);break; case 0xf7:prefix##_##f7(z80);break; \
393 case 0xf8:prefix##_##f8(z80);break; case 0xf9:prefix##_##f9(z80);break; case 0xfa:prefix##_##fa(z80);break; case 0xfb:prefix##_##fb(z80);break; \
394 case 0xfc:prefix##_##fc(z80);break; case 0xfd:prefix##_##fd(z80);break; case 0xfe:prefix##_##fe(z80);break; case 0xff:prefix##_##ff(z80);break; \
395 } \
396 } while (0)
397
398 /***************************************************************
399 * Enter halt state; write 1 to fake port on first execution
400 ***************************************************************/
401 static inline void halt(z80_device *z80)
402 {
403 PC--;
404 z80->m_halt = 1;
405 }
406
407 /***************************************************************
408 * Leave halt state; write 0 to fake port
409 ***************************************************************/
410 static inline void leave_halt(z80_device *z80)
411 {
412 if( z80->m_halt )
413 {
414 z80->m_halt = 0;
415 PC++;
416 }
417 }
418
419 /***************************************************************
420 * Input a byte from given I/O port
421 ***************************************************************/
422 static inline uint8_t in(z80_device *z80, uint16_t port)
423 {
424 memmap_chunk const *map_tmp = z80->options->gen.memmap;
425 uint32_t chunks_tmp = z80->options->gen.memmap_chunks;
426 z80->options->gen.memmap = z80->options->iomap;
427 z80->options->gen.memmap_chunks = z80->options->io_chunks;
428 uint8_t value = read_byte(port, (void **)z80->mem_pointers, &z80->options->gen, z80);
429 z80->options->gen.memmap = map_tmp;
430 z80->options->gen.memmap_chunks = chunks_tmp;
431 return value;
432 }
433
434 /***************************************************************
435 * Output a byte to given I/O port
436 ***************************************************************/
437 static inline void out(z80_device *z80, uint16_t port, uint8_t value)
438 {
439 memmap_chunk const *map_tmp = z80->options->gen.memmap;
440 uint32_t chunks_tmp = z80->options->gen.memmap_chunks;
441 z80->options->gen.memmap = z80->options->iomap;
442 z80->options->gen.memmap_chunks = z80->options->io_chunks;
443 write_byte(port & z80->options->io_address_mask, value, (void **)z80->mem_pointers, &z80->options->gen, z80);
444 z80->options->gen.memmap = map_tmp;
445 z80->options->gen.memmap_chunks = chunks_tmp;
446 }
447
448 /***************************************************************
449 * Read a byte from given memory location
450 ***************************************************************/
451 static inline uint8_t rm(z80_device *z80, uint16_t addr)
452 {
453 return read_byte(addr, (void **)z80->mem_pointers, &z80->options->gen, z80);
454 }
455
456 /***************************************************************
457 * Read a word from given memory location
458 ***************************************************************/
459 static inline void rm16(z80_device *z80, uint16_t addr, PAIR *r)
460 {
461 r->b.l = rm(z80, addr);
462 r->b.h = rm(z80, (addr+1));
463 }
464
465 /***************************************************************
466 * Write a byte to given memory location
467 ***************************************************************/
468 static inline void wm(z80_device *z80, uint16_t addr, uint8_t value)
469 {
470 write_byte(addr, value, (void **)z80->mem_pointers, &z80->options->gen, z80);
471 }
472
473 /***************************************************************
474 * Write a word to given memory location
475 ***************************************************************/
476 static inline void wm16(z80_device *z80, uint16_t addr, PAIR *r)
477 {
478 wm(z80, addr, r->b.l);
479 wm(z80, (addr+1), r->b.h);
480 }
481
482 /***************************************************************
483 * rop() is identical to rm() except it is used for
484 * reading opcodes. In case of system with memory mapped I/O,
485 * this function can be used to greatly speed up emulation
486 ***************************************************************/
487 static inline uint8_t rop(z80_device *z80)
488 {
489 unsigned pc = PCD;
490 PC++;
491 return rm(z80, pc);
492 }
493
494 /****************************************************************
495 * arg(z80) is identical to rop() except it is used
496 * for reading opcode arguments. This difference can be used to
497 * support systems that use different encoding mechanisms for
498 * opcodes and opcode arguments
499 ***************************************************************/
500 #define arg(Z) rop(Z)
501
502 static inline uint16_t arg16(z80_device *z80)
503 {
504 unsigned pc = PCD;
505 PC += 2;
506 return rm(z80, pc) | (rm(z80, (pc+1)&0xffff) << 8);
507 }
508
509 /***************************************************************
510 * Calculate the effective address EA of an opcode using
511 * IX+offset resp. IY+offset addressing.
512 ***************************************************************/
513 static inline void eax(z80_device *z80)
514 {
515 z80->m_ea = (uint32_t)(uint16_t)(IX + (int8_t)arg(z80));
516 WZ = z80->m_ea;
517 }
518
519 static inline void eay(z80_device *z80)
520 {
521 z80->m_ea = (uint32_t)(uint16_t)(IY + (int8_t)arg(z80));
522 WZ = z80->m_ea;
523 }
524
525 /***************************************************************
526 * POP
527 ***************************************************************/
528 static inline void pop(z80_device *z80, PAIR *r)
529 {
530 rm16(z80, SPD, r);
531 SP += 2;
532 }
533
534 /***************************************************************
535 * PUSH
536 ***************************************************************/
537 static inline void push(z80_device *z80, PAIR *r)
538 {
539 SP -= 2;
540 wm16(z80, SPD, r);
541 }
542
543 /***************************************************************
544 * JP
545 ***************************************************************/
546 static inline void jp(z80_device *z80)
547 {
548 PCD = arg16(z80);
549 WZ = PCD;
550 }
551
552 /***************************************************************
553 * JP_COND
554 ***************************************************************/
555 static inline void jp_cond(z80_device *z80, uint8_t cond)
556 {
557 if (cond)
558 {
559 PCD = arg16(z80);
560 WZ = PCD;
561 }
562 else
563 {
564 WZ = arg16(z80); /* implicit do PC += 2 */
565 }
566 }
567
568 /***************************************************************
569 * JR
570 ***************************************************************/
571 static inline void jr(z80_device *z80)
572 {
573 int8_t a = (int8_t)arg(z80); /* arg(z80) also increments PC */
574 PC += a; /* so don't do PC += arg(z80) */
575 WZ = PC;
576 }
577
578 /***************************************************************
579 * JR_COND
580 ***************************************************************/
581 static inline void jr_cond(z80_device *z80, uint8_t cond, uint8_t opcode)
582 {
583 if (cond)
584 {
585 jr(z80);
586 CC(ex, opcode);
587 }
588 else
589 PC++;
590 }
591
592 /***************************************************************
593 * CALL
594 ***************************************************************/
595 static inline void call(z80_device *z80)
596 {
597 z80->m_ea = arg16(z80);
598 WZ = z80->m_ea;
599 push(z80, &z80->m_pc);
600 PCD = z80->m_ea;
601 }
602
603 /***************************************************************
604 * CALL_COND
605 ***************************************************************/
606 static inline void call_cond(z80_device *z80, uint8_t cond, uint8_t opcode)
607 {
608 if (cond)
609 {
610 z80->m_ea = arg16(z80);
611 WZ = z80->m_ea;
612 push(z80, &z80->m_pc);
613 PCD = z80->m_ea;
614 CC(ex, opcode);
615 }
616 else
617 {
618 WZ = arg16(z80); /* implicit call PC+=2; */
619 }
620 }
621
622 /***************************************************************
623 * RET_COND
624 ***************************************************************/
625 static inline void ret_cond(z80_device *z80, uint8_t cond, uint8_t opcode)
626 {
627 if (cond)
628 {
629 pop(z80, &z80->m_pc);
630 WZ = PC;
631 CC(ex, opcode);
632 }
633 }
634
635 /***************************************************************
636 * RETN
637 ***************************************************************/
638 static inline void retn(z80_device *z80)
639 {
640 LOG(("Z80 RETN m_iff1:%d m_iff2:%d\n",
641 z80->m_iff1, z80->m_iff2));
642 pop(z80, &z80->m_pc);
643 WZ = PC;
644 z80->m_iff1 = z80->m_iff2;
645 }
646
647 /***************************************************************
648 * RETI
649 ***************************************************************/
650 static inline void reti(z80_device *z80)
651 {
652 pop(z80, &z80->m_pc);
653 WZ = PC;
654 z80->m_iff1 = z80->m_iff2;
655 //daisy_call_reti_device(z80);
656 }
657
658 /***************************************************************
659 * LD R,A
660 ***************************************************************/
661 static inline void ld_r_a(z80_device *z80)
662 {
663 z80->m_r = A;
664 z80->m_r2 = A & 0x80; /* keep bit 7 of r */
665 }
666
667 /***************************************************************
668 * LD A,R
669 ***************************************************************/
670 static inline void ld_a_r(z80_device *z80)
671 {
672 A = (z80->m_r & 0x7f) | z80->m_r2;
673 F = (F & CF) | SZ[A] | (z80->m_iff2 << 2);
674 z80->m_after_ldair = 1;
675 }
676
677 /***************************************************************
678 * LD I,A
679 ***************************************************************/
680 static inline void ld_i_a(z80_device *z80)
681 {
682 z80->m_i = A;
683 }
684
685 /***************************************************************
686 * LD A,I
687 ***************************************************************/
688 static inline void ld_a_i(z80_device *z80)
689 {
690 A = z80->m_i;
691 F = (F & CF) | SZ[A] | (z80->m_iff2 << 2);
692 z80->m_after_ldair = 1;
693 }
694
695 /***************************************************************
696 * RST
697 ***************************************************************/
698 static inline void rst(z80_device *z80, uint16_t addr)
699 {
700 push(z80, &z80->m_pc);
701 PCD = addr;
702 WZ = PC;
703 }
704
705 /***************************************************************
706 * INC r8
707 ***************************************************************/
708 static inline uint8_t inc(z80_device *z80, uint8_t value)
709 {
710 uint8_t res = value + 1;
711 F = (F & CF) | SZHV_inc[res];
712 return (uint8_t)res;
713 }
714
715 /***************************************************************
716 * DEC r8
717 ***************************************************************/
718 static inline uint8_t dec(z80_device *z80, uint8_t value)
719 {
720 uint8_t res = value - 1;
721 F = (F & CF) | SZHV_dec[res];
722 return res;
723 }
724
725 /***************************************************************
726 * RLCA
727 ***************************************************************/
728 static inline void rlca(z80_device *z80)
729 {
730 A = (A << 1) | (A >> 7);
731 F = (F & (SF | ZF | PF)) | (A & (YF | XF | CF));
732 }
733
734 /***************************************************************
735 * RRCA
736 ***************************************************************/
737 static inline void rrca(z80_device *z80)
738 {
739 F = (F & (SF | ZF | PF)) | (A & CF);
740 A = (A >> 1) | (A << 7);
741 F |= (A & (YF | XF));
742 }
743
744 /***************************************************************
745 * RLA
746 ***************************************************************/
747 static inline void rla(z80_device *z80)
748 {
749 uint8_t res = (A << 1) | (F & CF);
750 uint8_t c = (A & 0x80) ? CF : 0;
751 F = (F & (SF | ZF | PF)) | c | (res & (YF | XF));
752 A = res;
753 }
754
755 /***************************************************************
756 * RRA
757 ***************************************************************/
758 static inline void rra(z80_device *z80)
759 {
760 uint8_t res = (A >> 1) | (F << 7);
761 uint8_t c = (A & 0x01) ? CF : 0;
762 F = (F & (SF | ZF | PF)) | c | (res & (YF | XF));
763 A = res;
764 }
765
766 /***************************************************************
767 * RRD
768 ***************************************************************/
769 static inline void rrd(z80_device *z80)
770 {
771 uint8_t n = rm(z80, HL);
772 WZ = HL+1;
773 wm(z80, HL, (n >> 4) | (A << 4));
774 A = (A & 0xf0) | (n & 0x0f);
775 F = (F & CF) | SZP[A];
776 }
777
778 /***************************************************************
779 * RLD
780 ***************************************************************/
781 static inline void rld(z80_device *z80)
782 {
783 uint8_t n = rm(z80, HL);
784 WZ = HL+1;
785 wm(z80, HL, (n << 4) | (A & 0x0f));
786 A = (A & 0xf0) | (n >> 4);
787 F = (F & CF) | SZP[A];
788 }
789
790 /***************************************************************
791 * ADD A,n
792 ***************************************************************/
793 static inline void add_a(z80_device *z80, uint8_t value)
794 {
795 uint32_t ah = AFD & 0xff00;
796 uint32_t res = (uint8_t)((ah >> 8) + value);
797 F = SZHVC_add[ah | res];
798 A = res;
799 }
800
801 /***************************************************************
802 * ADC A,n
803 ***************************************************************/
804 static inline void adc_a(z80_device *z80, uint8_t value)
805 {
806 uint32_t ah = AFD & 0xff00, c = AFD & 1;
807 uint32_t res = (uint8_t)((ah >> 8) + value + c);
808 F = SZHVC_add[(c << 16) | ah | res];
809 A = res;
810 }
811
812 /***************************************************************
813 * SUB n
814 ***************************************************************/
815 static inline void sub(z80_device *z80, uint8_t value)
816 {
817 uint32_t ah = AFD & 0xff00;
818 uint32_t res = (uint8_t)((ah >> 8) - value);
819 F = SZHVC_sub[ah | res];
820 A = res;
821 }
822
823 /***************************************************************
824 * SBC A,n
825 ***************************************************************/
826 static inline void sbc_a(z80_device *z80, uint8_t value)
827 {
828 uint32_t ah = AFD & 0xff00, c = AFD & 1;
829 uint32_t res = (uint8_t)((ah >> 8) - value - c);
830 F = SZHVC_sub[(c<<16) | ah | res];
831 A = res;
832 }
833
834 /***************************************************************
835 * NEG
836 ***************************************************************/
837 static inline void neg(z80_device *z80)
838 {
839 uint8_t value = A;
840 A = 0;
841 sub(z80, value);
842 }
843
844 /***************************************************************
845 * DAA
846 ***************************************************************/
847 static inline void daa(z80_device *z80)
848 {
849 uint8_t a = A;
850 if (F & NF) {
851 if ((F&HF) | ((A&0xf)>9)) a-=6;
852 if ((F&CF) | (A>0x99)) a-=0x60;
853 }
854 else {
855 if ((F&HF) | ((A&0xf)>9)) a+=6;
856 if ((F&CF) | (A>0x99)) a+=0x60;
857 }
858
859 F = (F&(CF|NF)) | (A>0x99) | ((A^a)&HF) | SZP[a];
860 A = a;
861 }
862
863 /***************************************************************
864 * AND n
865 ***************************************************************/
866 static inline void and_a(z80_device *z80, uint8_t value)
867 {
868 A &= value;
869 F = SZP[A] | HF;
870 }
871
872 /***************************************************************
873 * OR n
874 ***************************************************************/
875 static inline void or_a(z80_device *z80, uint8_t value)
876 {
877 A |= value;
878 F = SZP[A];
879 }
880
881 /***************************************************************
882 * XOR n
883 ***************************************************************/
884 static inline void xor_a(z80_device *z80, uint8_t value)
885 {
886 A ^= value;
887 F = SZP[A];
888 }
889
890 /***************************************************************
891 * CP n
892 ***************************************************************/
893 static inline void cp(z80_device *z80, uint8_t value)
894 {
895 unsigned val = value;
896 uint32_t ah = AFD & 0xff00;
897 uint32_t res = (uint8_t)((ah >> 8) - val);
898 F = (SZHVC_sub[ah | res] & ~(YF | XF)) |
899 (val & (YF | XF));
900 }
901
902 /***************************************************************
903 * EX AF,AF'
904 ***************************************************************/
905 static inline void ex_af(z80_device *z80)
906 {
907 PAIR tmp;
908 tmp = z80->m_af; z80->m_af = z80->m_af2; z80->m_af2 = tmp;
909 }
910
911 /***************************************************************
912 * EX DE,HL
913 ***************************************************************/
914 static inline void ex_de_hl(z80_device *z80)
915 {
916 PAIR tmp;
917 tmp = z80->m_de; z80->m_de = z80->m_hl; z80->m_hl = tmp;
918 }
919
920 /***************************************************************
921 * EXX
922 ***************************************************************/
923 static inline void exx(z80_device *z80)
924 {
925 PAIR tmp;
926 tmp = z80->m_bc; z80->m_bc = z80->m_bc2; z80->m_bc2 = tmp;
927 tmp = z80->m_de; z80->m_de = z80->m_de2; z80->m_de2 = tmp;
928 tmp = z80->m_hl; z80->m_hl = z80->m_hl2; z80->m_hl2 = tmp;
929 }
930
931 /***************************************************************
932 * EX (SP),r16
933 ***************************************************************/
934 static inline void ex_sp(z80_device *z80, PAIR *r)
935 {
936 PAIR tmp = { { 0, 0, 0, 0 } };
937 rm16(z80, SPD, &tmp);
938 wm16(z80, SPD, r);
939 *r = tmp;
940 WZ = r->d;
941 }
942
943 /***************************************************************
944 * ADD16
945 ***************************************************************/
946 static inline void add16(z80_device *z80, PAIR *dr, PAIR *sr)
947 {
948 uint32_t res = dr->d + sr->d;
949 WZ = dr->d + 1;
950 F = (F & (SF | ZF | VF)) |
951 (((dr->d ^ res ^ sr->d) >> 8) & HF) |
952 ((res >> 16) & CF) | ((res >> 8) & (YF | XF));
953 dr->w.l = (uint16_t)res;
954 }
955
956 /***************************************************************
957 * ADC HL,r16
958 ***************************************************************/
959 static inline void adc_hl(z80_device *z80, PAIR *r)
960 {
961 uint32_t res = HLD + r->d + (F & CF);
962 WZ = HL + 1;
963 F = (((HLD ^ res ^ r->d) >> 8) & HF) |
964 ((res >> 16) & CF) |
965 ((res >> 8) & (SF | YF | XF)) |
966 ((res & 0xffff) ? 0 : ZF) |
967 (((r->d ^ HLD ^ 0x8000) & (r->d ^ res) & 0x8000) >> 13);
968 HL = (uint16_t)res;
969 }
970
971 /***************************************************************
972 * SBC HL,r16
973 ***************************************************************/
974 static inline void sbc_hl(z80_device *z80, PAIR *r)
975 {
976 uint32_t res = HLD - r->d - (F & CF);
977 WZ = HL + 1;
978 F = (((HLD ^ res ^ r->d) >> 8) & HF) | NF |
979 ((res >> 16) & CF) |
980 ((res >> 8) & (SF | YF | XF)) |
981 ((res & 0xffff) ? 0 : ZF) |
982 (((r->d ^ HLD) & (HLD ^ res) &0x8000) >> 13);
983 HL = (uint16_t)res;
984 }
985
986 /***************************************************************
987 * RLC r8
988 ***************************************************************/
989 static inline uint8_t rlc(z80_device *z80, uint8_t value)
990 {
991 unsigned res = value;
992 unsigned c = (res & 0x80) ? CF : 0;
993 res = ((res << 1) | (res >> 7)) & 0xff;
994 F = SZP[res] | c;
995 return res;
996 }
997
998 /***************************************************************
999 * RRC r8
1000 ***************************************************************/
1001 static inline uint8_t rrc(z80_device *z80, uint8_t value)
1002 {
1003 unsigned res = value;
1004 unsigned c = (res & 0x01) ? CF : 0;
1005 res = ((res >> 1) | (res << 7)) & 0xff;
1006 F = SZP[res] | c;
1007 return res;
1008 }
1009
1010 /***************************************************************
1011 * RL r8
1012 ***************************************************************/
1013 static inline uint8_t rl(z80_device *z80, uint8_t value)
1014 {
1015 unsigned res = value;
1016 unsigned c = (res & 0x80) ? CF : 0;
1017 res = ((res << 1) | (F & CF)) & 0xff;
1018 F = SZP[res] | c;
1019 return res;
1020 }
1021
1022 /***************************************************************
1023 * RR r8
1024 ***************************************************************/
1025 static inline uint8_t rr(z80_device *z80, uint8_t value)
1026 {
1027 unsigned res = value;
1028 unsigned c = (res & 0x01) ? CF : 0;
1029 res = ((res >> 1) | (F << 7)) & 0xff;
1030 F = SZP[res] | c;
1031 return res;
1032 }
1033
1034 /***************************************************************
1035 * SLA r8
1036 ***************************************************************/
1037 static inline uint8_t sla(z80_device *z80, uint8_t value)
1038 {
1039 unsigned res = value;
1040 unsigned c = (res & 0x80) ? CF : 0;
1041 res = (res << 1) & 0xff;
1042 F = SZP[res] | c;
1043 return res;
1044 }
1045
1046 /***************************************************************
1047 * SRA r8
1048 ***************************************************************/
1049 static inline uint8_t sra(z80_device *z80, uint8_t value)
1050 {
1051 unsigned res = value;
1052 unsigned c = (res & 0x01) ? CF : 0;
1053 res = ((res >> 1) | (res & 0x80)) & 0xff;
1054 F = SZP[res] | c;
1055 return res;
1056 }
1057
1058 /***************************************************************
1059 * SLL r8
1060 ***************************************************************/
1061 static inline uint8_t sll(z80_device *z80, uint8_t value)
1062 {
1063 unsigned res = value;
1064 unsigned c = (res & 0x80) ? CF : 0;
1065 res = ((res << 1) | 0x01) & 0xff;
1066 F = SZP[res] | c;
1067 return res;
1068 }
1069
1070 /***************************************************************
1071 * SRL r8
1072 ***************************************************************/
1073 static inline uint8_t srl(z80_device *z80, uint8_t value)
1074 {
1075 unsigned res = value;
1076 unsigned c = (res & 0x01) ? CF : 0;
1077 res = (res >> 1) & 0xff;
1078 F = SZP[res] | c;
1079 return res;
1080 }
1081
1082 /***************************************************************
1083 * BIT bit,r8
1084 ***************************************************************/
1085 static inline void bit(z80_device *z80, int bit, uint8_t value)
1086 {
1087 F = (F & CF) | HF | (SZ_BIT[value & (1<<bit)] & ~(YF|XF)) | (value & (YF|XF));
1088 }
1089
1090 /***************************************************************
1091 * BIT bit,(HL)
1092 ***************************************************************/
1093 static inline void bit_hl(z80_device *z80, int bit, uint8_t value)
1094 {
1095 F = (F & CF) | HF | (SZ_BIT[value & (1<<bit)] & ~(YF|XF)) | (WZ_H & (YF|XF));
1096 }
1097
1098 /***************************************************************
1099 * BIT bit,(IX/Y+o)
1100 ***************************************************************/
1101 static inline void bit_xy(z80_device *z80, int bit, uint8_t value)
1102 {
1103 F = (F & CF) | HF | (SZ_BIT[value & (1<<bit)] & ~(YF|XF)) | ((z80->m_ea>>8) & (YF|XF));
1104 }
1105
1106 /***************************************************************
1107 * RES bit,r8
1108 ***************************************************************/
1109 static inline uint8_t res(int bit, uint8_t value)
1110 {
1111 return value & ~(1<<bit);
1112 }
1113
1114 /***************************************************************
1115 * SET bit,r8
1116 ***************************************************************/
1117 static inline uint8_t set(int bit, uint8_t value)
1118 {
1119 return value | (1<<bit);
1120 }
1121
1122 /***************************************************************
1123 * LDI
1124 ***************************************************************/
1125 static inline void ldi(z80_device *z80)
1126 {
1127 uint8_t io = rm(z80, HL);
1128 wm(z80, DE, io);
1129 F &= SF | ZF | CF;
1130 if ((A + io) & 0x02) F |= YF; /* bit 1 -> flag 5 */
1131 if ((A + io) & 0x08) F |= XF; /* bit 3 -> flag 3 */
1132 HL++; DE++; BC--;
1133 if(BC) F |= VF;
1134 }
1135
1136 /***************************************************************
1137 * CPI
1138 ***************************************************************/
1139 static inline void cpi(z80_device *z80)
1140 {
1141 uint8_t val = rm(z80, HL);
1142 uint8_t res = A - val;
1143 WZ++;
1144 HL++; BC--;
1145 F = (F & CF) | (SZ[res]&~(YF|XF)) | ((A^val^res)&HF) | NF;
1146 if (F & HF) res -= 1;
1147 if (res & 0x02) F |= YF; /* bit 1 -> flag 5 */
1148 if (res & 0x08) F |= XF; /* bit 3 -> flag 3 */
1149 if (BC) F |= VF;
1150 }
1151
1152 /***************************************************************
1153 * INI
1154 ***************************************************************/
1155 static inline void ini(z80_device *z80)
1156 {
1157 unsigned t;
1158 uint8_t io = in(z80, BC);
1159 WZ = BC + 1;
1160 B--;
1161 wm(z80, HL, io);
1162 HL++;
1163 F = SZ[B];
1164 t = (unsigned)((C + 1) & 0xff) + (unsigned)io;
1165 if (io & SF) F |= NF;
1166 if (t & 0x100) F |= HF | CF;
1167 F |= SZP[(uint8_t)(t & 0x07) ^ B] & PF;
1168 }
1169
1170 /***************************************************************
1171 * OUTI
1172 ***************************************************************/
1173 static inline void outi(z80_device *z80)
1174 {
1175 unsigned t;
1176 uint8_t io = rm(z80, HL);
1177 B--;
1178 WZ = BC + 1;
1179 out(z80, BC, io);
1180 HL++;
1181 F = SZ[B];
1182 t = (unsigned)L + (unsigned)io;
1183 if (io & SF) F |= NF;
1184 if (t & 0x100) F |= HF | CF;
1185 F |= SZP[(uint8_t)(t & 0x07) ^ B] & PF;
1186 }
1187
1188 /***************************************************************
1189 * LDD
1190 ***************************************************************/
1191 static inline void ldd(z80_device *z80)
1192 {
1193 uint8_t io = rm(z80, HL);
1194 wm(z80, DE, io);
1195 F &= SF | ZF | CF;
1196 if ((A + io) & 0x02) F |= YF; /* bit 1 -> flag 5 */
1197 if ((A + io) & 0x08) F |= XF; /* bit 3 -> flag 3 */
1198 HL--; DE--; BC--;
1199 if (BC) F |= VF;
1200 }
1201
1202 /***************************************************************
1203 * CPD
1204 ***************************************************************/
1205 static inline void cpd(z80_device *z80)
1206 {
1207 uint8_t val = rm(z80, HL);
1208 uint8_t res = A - val;
1209 WZ--;
1210 HL--; BC--;
1211 F = (F & CF) | (SZ[res]&~(YF|XF)) | ((A^val^res)&HF) | NF;
1212 if (F & HF) res -= 1;
1213 if (res & 0x02) F |= YF; /* bit 1 -> flag 5 */
1214 if (res & 0x08) F |= XF; /* bit 3 -> flag 3 */
1215 if (BC) F |= VF;
1216 }
1217
1218 /***************************************************************
1219 * IND
1220 ***************************************************************/
1221 static inline void ind(z80_device *z80)
1222 {
1223 unsigned t;
1224 uint8_t io = in(z80, BC);
1225 WZ = BC - 1;
1226 B--;
1227 wm(z80, HL, io);
1228 HL--;
1229 F = SZ[B];
1230 t = ((unsigned)(C - 1) & 0xff) + (unsigned)io;
1231 if (io & SF) F |= NF;
1232 if (t & 0x100) F |= HF | CF;
1233 F |= SZP[(uint8_t)(t & 0x07) ^ B] & PF;
1234 }
1235
1236 /***************************************************************
1237 * OUTD
1238 ***************************************************************/
1239 static inline void outd(z80_device *z80)
1240 {
1241 unsigned t;
1242 uint8_t io = rm(z80, HL);
1243 B--;
1244 WZ = BC - 1;
1245 out(z80, BC, io);
1246 HL--;
1247 F = SZ[B];
1248 t = (unsigned)L + (unsigned)io;
1249 if (io & SF) F |= NF;
1250 if (t & 0x100) F |= HF | CF;
1251 F |= SZP[(uint8_t)(t & 0x07) ^ B] & PF;
1252 }
1253
1254 /***************************************************************
1255 * LDIR
1256 ***************************************************************/
1257 static inline void ldir(z80_device *z80)
1258 {
1259 ldi(z80);
1260 if (BC != 0)
1261 {
1262 PC -= 2;
1263 WZ = PC + 1;
1264 CC(ex, 0xb0);
1265 }
1266 }
1267
1268 /***************************************************************
1269 * CPIR
1270 ***************************************************************/
1271 static inline void cpir(z80_device *z80)
1272 {
1273 cpi(z80);
1274 if (BC != 0 && !(F & ZF))
1275 {
1276 PC -= 2;
1277 WZ = PC + 1;
1278 CC(ex, 0xb1);
1279 }
1280 }
1281
1282 /***************************************************************
1283 * INIR
1284 ***************************************************************/
1285 static inline void inir(z80_device *z80)
1286 {
1287 ini(z80);
1288 if (B != 0)
1289 {
1290 PC -= 2;
1291 CC(ex, 0xb2);
1292 }
1293 }
1294
1295 /***************************************************************
1296 * OTIR
1297 ***************************************************************/
1298 static inline void otir(z80_device *z80)
1299 {
1300 outi(z80);
1301 if (B != 0)
1302 {
1303 PC -= 2;
1304 CC(ex, 0xb3);
1305 }
1306 }
1307
1308 /***************************************************************
1309 * LDDR
1310 ***************************************************************/
1311 static inline void lddr(z80_device *z80)
1312 {
1313 ldd(z80);
1314 if (BC != 0)
1315 {
1316 PC -= 2;
1317 WZ = PC + 1;
1318 CC(ex, 0xb8);
1319 }
1320 }
1321
1322 /***************************************************************
1323 * CPDR
1324 ***************************************************************/
1325 static inline void cpdr(z80_device *z80)
1326 {
1327 cpd(z80);
1328 if (BC != 0 && !(F & ZF))
1329 {
1330 PC -= 2;
1331 WZ = PC + 1;
1332 CC(ex, 0xb9);
1333 }
1334 }
1335
1336 /***************************************************************
1337 * INDR
1338 ***************************************************************/
1339 static inline void indr(z80_device *z80)
1340 {
1341 ind(z80);
1342 if (B != 0)
1343 {
1344 PC -= 2;
1345 CC(ex, 0xba);
1346 }
1347 }
1348
1349 /***************************************************************
1350 * OTDR
1351 ***************************************************************/
1352 static inline void otdr(z80_device *z80)
1353 {
1354 outd(z80);
1355 if (B != 0)
1356 {
1357 PC -= 2;
1358 CC(ex, 0xbb);
1359 }
1360 }
1361
1362 /***************************************************************
1363 * EI
1364 ***************************************************************/
1365 static inline void ei(z80_device *z80)
1366 {
1367 z80->m_iff1 = z80->m_iff2 = 1;
1368 z80->m_after_ei = 1;
1369 }
1370
1371 #define PROTOTYPES(prefix) \
1372 static inline void prefix##_00(z80_device *z80); static inline void prefix##_01(z80_device *z80); static inline void prefix##_02(z80_device *z80); static inline void prefix##_03(z80_device *z80); \
1373 static inline void prefix##_04(z80_device *z80); static inline void prefix##_05(z80_device *z80); static inline void prefix##_06(z80_device *z80); static inline void prefix##_07(z80_device *z80); \
1374 static inline void prefix##_08(z80_device *z80); static inline void prefix##_09(z80_device *z80); static inline void prefix##_0a(z80_device *z80); static inline void prefix##_0b(z80_device *z80); \
1375 static inline void prefix##_0c(z80_device *z80); static inline void prefix##_0d(z80_device *z80); static inline void prefix##_0e(z80_device *z80); static inline void prefix##_0f(z80_device *z80); \
1376 static inline void prefix##_10(z80_device *z80); static inline void prefix##_11(z80_device *z80); static inline void prefix##_12(z80_device *z80); static inline void prefix##_13(z80_device *z80); \
1377 static inline void prefix##_14(z80_device *z80); static inline void prefix##_15(z80_device *z80); static inline void prefix##_16(z80_device *z80); static inline void prefix##_17(z80_device *z80); \
1378 static inline void prefix##_18(z80_device *z80); static inline void prefix##_19(z80_device *z80); static inline void prefix##_1a(z80_device *z80); static inline void prefix##_1b(z80_device *z80); \
1379 static inline void prefix##_1c(z80_device *z80); static inline void prefix##_1d(z80_device *z80); static inline void prefix##_1e(z80_device *z80); static inline void prefix##_1f(z80_device *z80); \
1380 static inline void prefix##_20(z80_device *z80); static inline void prefix##_21(z80_device *z80); static inline void prefix##_22(z80_device *z80); static inline void prefix##_23(z80_device *z80); \
1381 static inline void prefix##_24(z80_device *z80); static inline void prefix##_25(z80_device *z80); static inline void prefix##_26(z80_device *z80); static inline void prefix##_27(z80_device *z80); \
1382 static inline void prefix##_28(z80_device *z80); static inline void prefix##_29(z80_device *z80); static inline void prefix##_2a(z80_device *z80); static inline void prefix##_2b(z80_device *z80); \
1383 static inline void prefix##_2c(z80_device *z80); static inline void prefix##_2d(z80_device *z80); static inline void prefix##_2e(z80_device *z80); static inline void prefix##_2f(z80_device *z80); \
1384 static inline void prefix##_30(z80_device *z80); static inline void prefix##_31(z80_device *z80); static inline void prefix##_32(z80_device *z80); static inline void prefix##_33(z80_device *z80); \
1385 static inline void prefix##_34(z80_device *z80); static inline void prefix##_35(z80_device *z80); static inline void prefix##_36(z80_device *z80); static inline void prefix##_37(z80_device *z80); \
1386 static inline void prefix##_38(z80_device *z80); static inline void prefix##_39(z80_device *z80); static inline void prefix##_3a(z80_device *z80); static inline void prefix##_3b(z80_device *z80); \
1387 static inline void prefix##_3c(z80_device *z80); static inline void prefix##_3d(z80_device *z80); static inline void prefix##_3e(z80_device *z80); static inline void prefix##_3f(z80_device *z80); \
1388 static inline void prefix##_40(z80_device *z80); static inline void prefix##_41(z80_device *z80); static inline void prefix##_42(z80_device *z80); static inline void prefix##_43(z80_device *z80); \
1389 static inline void prefix##_44(z80_device *z80); static inline void prefix##_45(z80_device *z80); static inline void prefix##_46(z80_device *z80); static inline void prefix##_47(z80_device *z80); \
1390 static inline void prefix##_48(z80_device *z80); static inline void prefix##_49(z80_device *z80); static inline void prefix##_4a(z80_device *z80); static inline void prefix##_4b(z80_device *z80); \
1391 static inline void prefix##_4c(z80_device *z80); static inline void prefix##_4d(z80_device *z80); static inline void prefix##_4e(z80_device *z80); static inline void prefix##_4f(z80_device *z80); \
1392 static inline void prefix##_50(z80_device *z80); static inline void prefix##_51(z80_device *z80); static inline void prefix##_52(z80_device *z80); static inline void prefix##_53(z80_device *z80); \
1393 static inline void prefix##_54(z80_device *z80); static inline void prefix##_55(z80_device *z80); static inline void prefix##_56(z80_device *z80); static inline void prefix##_57(z80_device *z80); \
1394 static inline void prefix##_58(z80_device *z80); static inline void prefix##_59(z80_device *z80); static inline void prefix##_5a(z80_device *z80); static inline void prefix##_5b(z80_device *z80); \
1395 static inline void prefix##_5c(z80_device *z80); static inline void prefix##_5d(z80_device *z80); static inline void prefix##_5e(z80_device *z80); static inline void prefix##_5f(z80_device *z80); \
1396 static inline void prefix##_60(z80_device *z80); static inline void prefix##_61(z80_device *z80); static inline void prefix##_62(z80_device *z80); static inline void prefix##_63(z80_device *z80); \
1397 static inline void prefix##_64(z80_device *z80); static inline void prefix##_65(z80_device *z80); static inline void prefix##_66(z80_device *z80); static inline void prefix##_67(z80_device *z80); \
1398 static inline void prefix##_68(z80_device *z80); static inline void prefix##_69(z80_device *z80); static inline void prefix##_6a(z80_device *z80); static inline void prefix##_6b(z80_device *z80); \
1399 static inline void prefix##_6c(z80_device *z80); static inline void prefix##_6d(z80_device *z80); static inline void prefix##_6e(z80_device *z80); static inline void prefix##_6f(z80_device *z80); \
1400 static inline void prefix##_70(z80_device *z80); static inline void prefix##_71(z80_device *z80); static inline void prefix##_72(z80_device *z80); static inline void prefix##_73(z80_device *z80); \
1401 static inline void prefix##_74(z80_device *z80); static inline void prefix##_75(z80_device *z80); static inline void prefix##_76(z80_device *z80); static inline void prefix##_77(z80_device *z80); \
1402 static inline void prefix##_78(z80_device *z80); static inline void prefix##_79(z80_device *z80); static inline void prefix##_7a(z80_device *z80); static inline void prefix##_7b(z80_device *z80); \
1403 static inline void prefix##_7c(z80_device *z80); static inline void prefix##_7d(z80_device *z80); static inline void prefix##_7e(z80_device *z80); static inline void prefix##_7f(z80_device *z80); \
1404 static inline void prefix##_80(z80_device *z80); static inline void prefix##_81(z80_device *z80); static inline void prefix##_82(z80_device *z80); static inline void prefix##_83(z80_device *z80); \
1405 static inline void prefix##_84(z80_device *z80); static inline void prefix##_85(z80_device *z80); static inline void prefix##_86(z80_device *z80); static inline void prefix##_87(z80_device *z80); \
1406 static inline void prefix##_88(z80_device *z80); static inline void prefix##_89(z80_device *z80); static inline void prefix##_8a(z80_device *z80); static inline void prefix##_8b(z80_device *z80); \
1407 static inline void prefix##_8c(z80_device *z80); static inline void prefix##_8d(z80_device *z80); static inline void prefix##_8e(z80_device *z80); static inline void prefix##_8f(z80_device *z80); \
1408 static inline void prefix##_90(z80_device *z80); static inline void prefix##_91(z80_device *z80); static inline void prefix##_92(z80_device *z80); static inline void prefix##_93(z80_device *z80); \
1409 static inline void prefix##_94(z80_device *z80); static inline void prefix##_95(z80_device *z80); static inline void prefix##_96(z80_device *z80); static inline void prefix##_97(z80_device *z80); \
1410 static inline void prefix##_98(z80_device *z80); static inline void prefix##_99(z80_device *z80); static inline void prefix##_9a(z80_device *z80); static inline void prefix##_9b(z80_device *z80); \
1411 static inline void prefix##_9c(z80_device *z80); static inline void prefix##_9d(z80_device *z80); static inline void prefix##_9e(z80_device *z80); static inline void prefix##_9f(z80_device *z80); \
1412 static inline void prefix##_a0(z80_device *z80); static inline void prefix##_a1(z80_device *z80); static inline void prefix##_a2(z80_device *z80); static inline void prefix##_a3(z80_device *z80); \
1413 static inline void prefix##_a4(z80_device *z80); static inline void prefix##_a5(z80_device *z80); static inline void prefix##_a6(z80_device *z80); static inline void prefix##_a7(z80_device *z80); \
1414 static inline void prefix##_a8(z80_device *z80); static inline void prefix##_a9(z80_device *z80); static inline void prefix##_aa(z80_device *z80); static inline void prefix##_ab(z80_device *z80); \
1415 static inline void prefix##_ac(z80_device *z80); static inline void prefix##_ad(z80_device *z80); static inline void prefix##_ae(z80_device *z80); static inline void prefix##_af(z80_device *z80); \
1416 static inline void prefix##_b0(z80_device *z80); static inline void prefix##_b1(z80_device *z80); static inline void prefix##_b2(z80_device *z80); static inline void prefix##_b3(z80_device *z80); \
1417 static inline void prefix##_b4(z80_device *z80); static inline void prefix##_b5(z80_device *z80); static inline void prefix##_b6(z80_device *z80); static inline void prefix##_b7(z80_device *z80); \
1418 static inline void prefix##_b8(z80_device *z80); static inline void prefix##_b9(z80_device *z80); static inline void prefix##_ba(z80_device *z80); static inline void prefix##_bb(z80_device *z80); \
1419 static inline void prefix##_bc(z80_device *z80); static inline void prefix##_bd(z80_device *z80); static inline void prefix##_be(z80_device *z80); static inline void prefix##_bf(z80_device *z80); \
1420 static inline void prefix##_c0(z80_device *z80); static inline void prefix##_c1(z80_device *z80); static inline void prefix##_c2(z80_device *z80); static inline void prefix##_c3(z80_device *z80); \
1421 static inline void prefix##_c4(z80_device *z80); static inline void prefix##_c5(z80_device *z80); static inline void prefix##_c6(z80_device *z80); static inline void prefix##_c7(z80_device *z80); \
1422 static inline void prefix##_c8(z80_device *z80); static inline void prefix##_c9(z80_device *z80); static inline void prefix##_ca(z80_device *z80); static inline void prefix##_cb(z80_device *z80); \
1423 static inline void prefix##_cc(z80_device *z80); static inline void prefix##_cd(z80_device *z80); static inline void prefix##_ce(z80_device *z80); static inline void prefix##_cf(z80_device *z80); \
1424 static inline void prefix##_d0(z80_device *z80); static inline void prefix##_d1(z80_device *z80); static inline void prefix##_d2(z80_device *z80); static inline void prefix##_d3(z80_device *z80); \
1425 static inline void prefix##_d4(z80_device *z80); static inline void prefix##_d5(z80_device *z80); static inline void prefix##_d6(z80_device *z80); static inline void prefix##_d7(z80_device *z80); \
1426 static inline void prefix##_d8(z80_device *z80); static inline void prefix##_d9(z80_device *z80); static inline void prefix##_da(z80_device *z80); static inline void prefix##_db(z80_device *z80); \
1427 static inline void prefix##_dc(z80_device *z80); static inline void prefix##_dd(z80_device *z80); static inline void prefix##_de(z80_device *z80); static inline void prefix##_df(z80_device *z80); \
1428 static inline void prefix##_e0(z80_device *z80); static inline void prefix##_e1(z80_device *z80); static inline void prefix##_e2(z80_device *z80); static inline void prefix##_e3(z80_device *z80); \
1429 static inline void prefix##_e4(z80_device *z80); static inline void prefix##_e5(z80_device *z80); static inline void prefix##_e6(z80_device *z80); static inline void prefix##_e7(z80_device *z80); \
1430 static inline void prefix##_e8(z80_device *z80); static inline void prefix##_e9(z80_device *z80); static inline void prefix##_ea(z80_device *z80); static inline void prefix##_eb(z80_device *z80); \
1431 static inline void prefix##_ec(z80_device *z80); static inline void prefix##_ed(z80_device *z80); static inline void prefix##_ee(z80_device *z80); static inline void prefix##_ef(z80_device *z80); \
1432 static inline void prefix##_f0(z80_device *z80); static inline void prefix##_f1(z80_device *z80); static inline void prefix##_f2(z80_device *z80); static inline void prefix##_f3(z80_device *z80); \
1433 static inline void prefix##_f4(z80_device *z80); static inline void prefix##_f5(z80_device *z80); static inline void prefix##_f6(z80_device *z80); static inline void prefix##_f7(z80_device *z80); \
1434 static inline void prefix##_f8(z80_device *z80); static inline void prefix##_f9(z80_device *z80); static inline void prefix##_fa(z80_device *z80); static inline void prefix##_fb(z80_device *z80); \
1435 static inline void prefix##_fc(z80_device *z80); static inline void prefix##_fd(z80_device *z80); static inline void prefix##_fe(z80_device *z80); static inline void prefix##_ff(z80_device *z80);
1436
1437 PROTOTYPES(op)
1438 PROTOTYPES(cb)
1439 PROTOTYPES(dd)
1440 PROTOTYPES(ed)
1441 PROTOTYPES(fd)
1442 PROTOTYPES(xycb)
1443
1444 /**********************************************************
1445 * opcodes with CB prefix
1446 * rotate, shift and bit operations
1447 **********************************************************/
1448 OP(cb,00) { B = rlc(z80, B); } /* RLC B */
1449 OP(cb,01) { C = rlc(z80, C); } /* RLC C */
1450 OP(cb,02) { D = rlc(z80, D); } /* RLC D */
1451 OP(cb,03) { E = rlc(z80, E); } /* RLC E */
1452 OP(cb,04) { H = rlc(z80, H); } /* RLC H */
1453 OP(cb,05) { L = rlc(z80, L); } /* RLC L */
1454 OP(cb,06) { wm(z80, HL, rlc(z80, rm(z80, HL))); } /* RLC (HL) */
1455 OP(cb,07) { A = rlc(z80, A); } /* RLC A */
1456
1457 OP(cb,08) { B = rrc(z80, B); } /* RRC B */
1458 OP(cb,09) { C = rrc(z80, C); } /* RRC C */
1459 OP(cb,0a) { D = rrc(z80, D); } /* RRC D */
1460 OP(cb,0b) { E = rrc(z80, E); } /* RRC E */
1461 OP(cb,0c) { H = rrc(z80, H); } /* RRC H */
1462 OP(cb,0d) { L = rrc(z80, L); } /* RRC L */
1463 OP(cb,0e) { wm(z80, HL, rrc(z80, rm(z80, HL))); } /* RRC (HL) */
1464 OP(cb,0f) { A = rrc(z80, A); } /* RRC A */
1465
1466 OP(cb,10) { B = rl(z80, B); } /* RL B */
1467 OP(cb,11) { C = rl(z80, C); } /* RL C */
1468 OP(cb,12) { D = rl(z80, D); } /* RL D */
1469 OP(cb,13) { E = rl(z80, E); } /* RL E */
1470 OP(cb,14) { H = rl(z80, H); } /* RL H */
1471 OP(cb,15) { L = rl(z80, L); } /* RL L */
1472 OP(cb,16) { wm(z80, HL, rl(z80, rm(z80, HL))); } /* RL (HL) */
1473 OP(cb,17) { A = rl(z80, A); } /* RL A */
1474
1475 OP(cb,18) { B = rr(z80, B); } /* RR B */
1476 OP(cb,19) { C = rr(z80, C); } /* RR C */
1477 OP(cb,1a) { D = rr(z80, D); } /* RR D */
1478 OP(cb,1b) { E = rr(z80, E); } /* RR E */
1479 OP(cb,1c) { H = rr(z80, H); } /* RR H */
1480 OP(cb,1d) { L = rr(z80, L); } /* RR L */
1481 OP(cb,1e) { wm(z80, HL, rr(z80, rm(z80, HL))); } /* RR (HL) */
1482 OP(cb,1f) { A = rr(z80, A); } /* RR A */
1483
1484 OP(cb,20) { B = sla(z80, B); } /* SLA B */
1485 OP(cb,21) { C = sla(z80, C); } /* SLA C */
1486 OP(cb,22) { D = sla(z80, D); } /* SLA D */
1487 OP(cb,23) { E = sla(z80, E); } /* SLA E */
1488 OP(cb,24) { H = sla(z80, H); } /* SLA H */
1489 OP(cb,25) { L = sla(z80, L); } /* SLA L */
1490 OP(cb,26) { wm(z80, HL, sla(z80, rm(z80, HL))); } /* SLA (HL) */
1491 OP(cb,27) { A = sla(z80, A); } /* SLA A */
1492
1493 OP(cb,28) { B = sra(z80, B); } /* SRA B */
1494 OP(cb,29) { C = sra(z80, C); } /* SRA C */
1495 OP(cb,2a) { D = sra(z80, D); } /* SRA D */
1496 OP(cb,2b) { E = sra(z80, E); } /* SRA E */
1497 OP(cb,2c) { H = sra(z80, H); } /* SRA H */
1498 OP(cb,2d) { L = sra(z80, L); } /* SRA L */
1499 OP(cb,2e) { wm(z80, HL, sra(z80, rm(z80, HL))); } /* SRA (HL) */
1500 OP(cb,2f) { A = sra(z80, A); } /* SRA A */
1501
1502 OP(cb,30) { B = sll(z80, B); } /* SLL B */
1503 OP(cb,31) { C = sll(z80, C); } /* SLL C */
1504 OP(cb,32) { D = sll(z80, D); } /* SLL D */
1505 OP(cb,33) { E = sll(z80, E); } /* SLL E */
1506 OP(cb,34) { H = sll(z80, H); } /* SLL H */
1507 OP(cb,35) { L = sll(z80, L); } /* SLL L */
1508 OP(cb,36) { wm(z80, HL, sll(z80, rm(z80, HL))); } /* SLL (HL) */
1509 OP(cb,37) { A = sll(z80, A); } /* SLL A */
1510
1511 OP(cb,38) { B = srl(z80, B); } /* SRL B */
1512 OP(cb,39) { C = srl(z80, C); } /* SRL C */
1513 OP(cb,3a) { D = srl(z80, D); } /* SRL D */
1514 OP(cb,3b) { E = srl(z80, E); } /* SRL E */
1515 OP(cb,3c) { H = srl(z80, H); } /* SRL H */
1516 OP(cb,3d) { L = srl(z80, L); } /* SRL L */
1517 OP(cb,3e) { wm(z80, HL, srl(z80, rm(z80, HL))); } /* SRL (HL) */
1518 OP(cb,3f) { A = srl(z80, A); } /* SRL A */
1519
1520 OP(cb,40) { bit(z80, 0, B); } /* BIT 0,B */
1521 OP(cb,41) { bit(z80, 0, C); } /* BIT 0,C */
1522 OP(cb,42) { bit(z80, 0, D); } /* BIT 0,D */
1523 OP(cb,43) { bit(z80, 0, E); } /* BIT 0,E */
1524 OP(cb,44) { bit(z80, 0, H); } /* BIT 0,H */
1525 OP(cb,45) { bit(z80, 0, L); } /* BIT 0,L */
1526 OP(cb,46) { bit_hl(z80, 0, rm(z80, HL)); } /* BIT 0,(HL) */
1527 OP(cb,47) { bit(z80, 0, A); } /* BIT 0,A */
1528
1529 OP(cb,48) { bit(z80, 1, B); } /* BIT 1,B */
1530 OP(cb,49) { bit(z80, 1, C); } /* BIT 1,C */
1531 OP(cb,4a) { bit(z80, 1, D); } /* BIT 1,D */
1532 OP(cb,4b) { bit(z80, 1, E); } /* BIT 1,E */
1533 OP(cb,4c) { bit(z80, 1, H); } /* BIT 1,H */
1534 OP(cb,4d) { bit(z80, 1, L); } /* BIT 1,L */
1535 OP(cb,4e) { bit_hl(z80, 1, rm(z80, HL)); } /* BIT 1,(HL) */
1536 OP(cb,4f) { bit(z80, 1, A); } /* BIT 1,A */
1537
1538 OP(cb,50) { bit(z80, 2, B); } /* BIT 2,B */
1539 OP(cb,51) { bit(z80, 2, C); } /* BIT 2,C */
1540 OP(cb,52) { bit(z80, 2, D); } /* BIT 2,D */
1541 OP(cb,53) { bit(z80, 2, E); } /* BIT 2,E */
1542 OP(cb,54) { bit(z80, 2, H); } /* BIT 2,H */
1543 OP(cb,55) { bit(z80, 2, L); } /* BIT 2,L */
1544 OP(cb,56) { bit_hl(z80, 2, rm(z80, HL)); } /* BIT 2,(HL) */
1545 OP(cb,57) { bit(z80, 2, A); } /* BIT 2,A */
1546
1547 OP(cb,58) { bit(z80, 3, B); } /* BIT 3,B */
1548 OP(cb,59) { bit(z80, 3, C); } /* BIT 3,C */
1549 OP(cb,5a) { bit(z80, 3, D); } /* BIT 3,D */
1550 OP(cb,5b) { bit(z80, 3, E); } /* BIT 3,E */
1551 OP(cb,5c) { bit(z80, 3, H); } /* BIT 3,H */
1552 OP(cb,5d) { bit(z80, 3, L); } /* BIT 3,L */
1553 OP(cb,5e) { bit_hl(z80, 3, rm(z80, HL)); } /* BIT 3,(HL) */
1554 OP(cb,5f) { bit(z80, 3, A); } /* BIT 3,A */
1555
1556 OP(cb,60) { bit(z80, 4, B); } /* BIT 4,B */
1557 OP(cb,61) { bit(z80, 4, C); } /* BIT 4,C */
1558 OP(cb,62) { bit(z80, 4, D); } /* BIT 4,D */
1559 OP(cb,63) { bit(z80, 4, E); } /* BIT 4,E */
1560 OP(cb,64) { bit(z80, 4, H); } /* BIT 4,H */
1561 OP(cb,65) { bit(z80, 4, L); } /* BIT 4,L */
1562 OP(cb,66) { bit_hl(z80, 4, rm(z80, HL)); } /* BIT 4,(HL) */
1563 OP(cb,67) { bit(z80, 4, A); } /* BIT 4,A */
1564
1565 OP(cb,68) { bit(z80, 5, B); } /* BIT 5,B */
1566 OP(cb,69) { bit(z80, 5, C); } /* BIT 5,C */
1567 OP(cb,6a) { bit(z80, 5, D); } /* BIT 5,D */
1568 OP(cb,6b) { bit(z80, 5, E); } /* BIT 5,E */
1569 OP(cb,6c) { bit(z80, 5, H); } /* BIT 5,H */
1570 OP(cb,6d) { bit(z80, 5, L); } /* BIT 5,L */
1571 OP(cb,6e) { bit_hl(z80, 5, rm(z80, HL)); } /* BIT 5,(HL) */
1572 OP(cb,6f) { bit(z80, 5, A); } /* BIT 5,A */
1573
1574 OP(cb,70) { bit(z80, 6, B); } /* BIT 6,B */
1575 OP(cb,71) { bit(z80, 6, C); } /* BIT 6,C */
1576 OP(cb,72) { bit(z80, 6, D); } /* BIT 6,D */
1577 OP(cb,73) { bit(z80, 6, E); } /* BIT 6,E */
1578 OP(cb,74) { bit(z80, 6, H); } /* BIT 6,H */
1579 OP(cb,75) { bit(z80, 6, L); } /* BIT 6,L */
1580 OP(cb,76) { bit_hl(z80, 6, rm(z80, HL)); } /* BIT 6,(HL) */
1581 OP(cb,77) { bit(z80, 6, A); } /* BIT 6,A */
1582
1583 OP(cb,78) { bit(z80, 7, B); } /* BIT 7,B */
1584 OP(cb,79) { bit(z80, 7, C); } /* BIT 7,C */
1585 OP(cb,7a) { bit(z80, 7, D); } /* BIT 7,D */
1586 OP(cb,7b) { bit(z80, 7, E); } /* BIT 7,E */
1587 OP(cb,7c) { bit(z80, 7, H); } /* BIT 7,H */
1588 OP(cb,7d) { bit(z80, 7, L); } /* BIT 7,L */
1589 OP(cb,7e) { bit_hl(z80, 7, rm(z80, HL)); } /* BIT 7,(HL) */
1590 OP(cb,7f) { bit(z80, 7, A); } /* BIT 7,A */
1591
1592 OP(cb,80) { B = res(0, B); } /* RES 0,B */
1593 OP(cb,81) { C = res(0, C); } /* RES 0,C */
1594 OP(cb,82) { D = res(0, D); } /* RES 0,D */
1595 OP(cb,83) { E = res(0, E); } /* RES 0,E */
1596 OP(cb,84) { H = res(0, H); } /* RES 0,H */
1597 OP(cb,85) { L = res(0, L); } /* RES 0,L */
1598 OP(cb,86) { wm(z80, HL, res(0, rm(z80, HL))); } /* RES 0,(HL) */
1599 OP(cb,87) { A = res(0, A); } /* RES 0,A */
1600
1601 OP(cb,88) { B = res(1, B); } /* RES 1,B */
1602 OP(cb,89) { C = res(1, C); } /* RES 1,C */
1603 OP(cb,8a) { D = res(1, D); } /* RES 1,D */
1604 OP(cb,8b) { E = res(1, E); } /* RES 1,E */
1605 OP(cb,8c) { H = res(1, H); } /* RES 1,H */
1606 OP(cb,8d) { L = res(1, L); } /* RES 1,L */
1607 OP(cb,8e) { wm(z80, HL, res(1, rm(z80, HL))); } /* RES 1,(HL) */
1608 OP(cb,8f) { A = res(1, A); } /* RES 1,A */
1609
1610 OP(cb,90) { B = res(2, B); } /* RES 2,B */
1611 OP(cb,91) { C = res(2, C); } /* RES 2,C */
1612 OP(cb,92) { D = res(2, D); } /* RES 2,D */
1613 OP(cb,93) { E = res(2, E); } /* RES 2,E */
1614 OP(cb,94) { H = res(2, H); } /* RES 2,H */
1615 OP(cb,95) { L = res(2, L); } /* RES 2,L */
1616 OP(cb,96) { wm(z80, HL, res(2, rm(z80, HL))); } /* RES 2,(HL) */
1617 OP(cb,97) { A = res(2, A); } /* RES 2,A */
1618
1619 OP(cb,98) { B = res(3, B); } /* RES 3,B */
1620 OP(cb,99) { C = res(3, C); } /* RES 3,C */
1621 OP(cb,9a) { D = res(3, D); } /* RES 3,D */
1622 OP(cb,9b) { E = res(3, E); } /* RES 3,E */
1623 OP(cb,9c) { H = res(3, H); } /* RES 3,H */
1624 OP(cb,9d) { L = res(3, L); } /* RES 3,L */
1625 OP(cb,9e) { wm(z80, HL, res(3, rm(z80, HL))); } /* RES 3,(HL) */
1626 OP(cb,9f) { A = res(3, A); } /* RES 3,A */
1627
1628 OP(cb,a0) { B = res(4, B); } /* RES 4,B */
1629 OP(cb,a1) { C = res(4, C); } /* RES 4,C */
1630 OP(cb,a2) { D = res(4, D); } /* RES 4,D */
1631 OP(cb,a3) { E = res(4, E); } /* RES 4,E */
1632 OP(cb,a4) { H = res(4, H); } /* RES 4,H */
1633 OP(cb,a5) { L = res(4, L); } /* RES 4,L */
1634 OP(cb,a6) { wm(z80, HL, res(4, rm(z80, HL))); } /* RES 4,(HL) */
1635 OP(cb,a7) { A = res(4, A); } /* RES 4,A */
1636
1637 OP(cb,a8) { B = res(5, B); } /* RES 5,B */
1638 OP(cb,a9) { C = res(5, C); } /* RES 5,C */
1639 OP(cb,aa) { D = res(5, D); } /* RES 5,D */
1640 OP(cb,ab) { E = res(5, E); } /* RES 5,E */
1641 OP(cb,ac) { H = res(5, H); } /* RES 5,H */
1642 OP(cb,ad) { L = res(5, L); } /* RES 5,L */
1643 OP(cb,ae) { wm(z80, HL, res(5, rm(z80, HL))); } /* RES 5,(HL) */
1644 OP(cb,af) { A = res(5, A); } /* RES 5,A */
1645
1646 OP(cb,b0) { B = res(6, B); } /* RES 6,B */
1647 OP(cb,b1) { C = res(6, C); } /* RES 6,C */
1648 OP(cb,b2) { D = res(6, D); } /* RES 6,D */
1649 OP(cb,b3) { E = res(6, E); } /* RES 6,E */
1650 OP(cb,b4) { H = res(6, H); } /* RES 6,H */
1651 OP(cb,b5) { L = res(6, L); } /* RES 6,L */
1652 OP(cb,b6) { wm(z80, HL, res(6, rm(z80, HL))); } /* RES 6,(HL) */
1653 OP(cb,b7) { A = res(6, A); } /* RES 6,A */
1654
1655 OP(cb,b8) { B = res(7, B); } /* RES 7,B */
1656 OP(cb,b9) { C = res(7, C); } /* RES 7,C */
1657 OP(cb,ba) { D = res(7, D); } /* RES 7,D */
1658 OP(cb,bb) { E = res(7, E); } /* RES 7,E */
1659 OP(cb,bc) { H = res(7, H); } /* RES 7,H */
1660 OP(cb,bd) { L = res(7, L); } /* RES 7,L */
1661 OP(cb,be) { wm(z80, HL, res(7, rm(z80, HL))); } /* RES 7,(HL) */
1662 OP(cb,bf) { A = res(7, A); } /* RES 7,A */
1663
1664 OP(cb,c0) { B = set(0, B); } /* SET 0,B */
1665 OP(cb,c1) { C = set(0, C); } /* SET 0,C */
1666 OP(cb,c2) { D = set(0, D); } /* SET 0,D */
1667 OP(cb,c3) { E = set(0, E); } /* SET 0,E */
1668 OP(cb,c4) { H = set(0, H); } /* SET 0,H */
1669 OP(cb,c5) { L = set(0, L); } /* SET 0,L */
1670 OP(cb,c6) { wm(z80, HL, set(0, rm(z80, HL))); } /* SET 0,(HL) */
1671 OP(cb,c7) { A = set(0, A); } /* SET 0,A */
1672
1673 OP(cb,c8) { B = set(1, B); } /* SET 1,B */
1674 OP(cb,c9) { C = set(1, C); } /* SET 1,C */
1675 OP(cb,ca) { D = set(1, D); } /* SET 1,D */
1676 OP(cb,cb) { E = set(1, E); } /* SET 1,E */
1677 OP(cb,cc) { H = set(1, H); } /* SET 1,H */
1678 OP(cb,cd) { L = set(1, L); } /* SET 1,L */
1679 OP(cb,ce) { wm(z80, HL, set(1, rm(z80, HL))); } /* SET 1,(HL) */
1680 OP(cb,cf) { A = set(1, A); } /* SET 1,A */
1681
1682 OP(cb,d0) { B = set(2, B); } /* SET 2,B */
1683 OP(cb,d1) { C = set(2, C); } /* SET 2,C */
1684 OP(cb,d2) { D = set(2, D); } /* SET 2,D */
1685 OP(cb,d3) { E = set(2, E); } /* SET 2,E */
1686 OP(cb,d4) { H = set(2, H); } /* SET 2,H */
1687 OP(cb,d5) { L = set(2, L); } /* SET 2,L */
1688 OP(cb,d6) { wm(z80, HL, set(2, rm(z80, HL))); } /* SET 2,(HL) */
1689 OP(cb,d7) { A = set(2, A); } /* SET 2,A */
1690
1691 OP(cb,d8) { B = set(3, B); } /* SET 3,B */
1692 OP(cb,d9) { C = set(3, C); } /* SET 3,C */
1693 OP(cb,da) { D = set(3, D); } /* SET 3,D */
1694 OP(cb,db) { E = set(3, E); } /* SET 3,E */
1695 OP(cb,dc) { H = set(3, H); } /* SET 3,H */
1696 OP(cb,dd) { L = set(3, L); } /* SET 3,L */
1697 OP(cb,de) { wm(z80, HL, set(3, rm(z80, HL))); } /* SET 3,(HL) */
1698 OP(cb,df) { A = set(3, A); } /* SET 3,A */
1699
1700 OP(cb,e0) { B = set(4, B); } /* SET 4,B */
1701 OP(cb,e1) { C = set(4, C); } /* SET 4,C */
1702 OP(cb,e2) { D = set(4, D); } /* SET 4,D */
1703 OP(cb,e3) { E = set(4, E); } /* SET 4,E */
1704 OP(cb,e4) { H = set(4, H); } /* SET 4,H */
1705 OP(cb,e5) { L = set(4, L); } /* SET 4,L */
1706 OP(cb,e6) { wm(z80, HL, set(4, rm(z80, HL))); } /* SET 4,(HL) */
1707 OP(cb,e7) { A = set(4, A); } /* SET 4,A */
1708
1709 OP(cb,e8) { B = set(5, B); } /* SET 5,B */
1710 OP(cb,e9) { C = set(5, C); } /* SET 5,C */
1711 OP(cb,ea) { D = set(5, D); } /* SET 5,D */
1712 OP(cb,eb) { E = set(5, E); } /* SET 5,E */
1713 OP(cb,ec) { H = set(5, H); } /* SET 5,H */
1714 OP(cb,ed) { L = set(5, L); } /* SET 5,L */
1715 OP(cb,ee) { wm(z80, HL, set(5, rm(z80, HL))); } /* SET 5,(HL) */
1716 OP(cb,ef) { A = set(5, A); } /* SET 5,A */
1717
1718 OP(cb,f0) { B = set(6, B); } /* SET 6,B */
1719 OP(cb,f1) { C = set(6, C); } /* SET 6,C */
1720 OP(cb,f2) { D = set(6, D); } /* SET 6,D */
1721 OP(cb,f3) { E = set(6, E); } /* SET 6,E */
1722 OP(cb,f4) { H = set(6, H); } /* SET 6,H */
1723 OP(cb,f5) { L = set(6, L); } /* SET 6,L */
1724 OP(cb,f6) { wm(z80, HL, set(6, rm(z80, HL))); } /* SET 6,(HL) */
1725 OP(cb,f7) { A = set(6, A); } /* SET 6,A */
1726
1727 OP(cb,f8) { B = set(7, B); } /* SET 7,B */
1728 OP(cb,f9) { C = set(7, C); } /* SET 7,C */
1729 OP(cb,fa) { D = set(7, D); } /* SET 7,D */
1730 OP(cb,fb) { E = set(7, E); } /* SET 7,E */
1731 OP(cb,fc) { H = set(7, H); } /* SET 7,H */
1732 OP(cb,fd) { L = set(7, L); } /* SET 7,L */
1733 OP(cb,fe) { wm(z80, HL, set(7, rm(z80, HL))); } /* SET 7,(HL) */
1734 OP(cb,ff) { A = set(7, A); } /* SET 7,A */
1735
1736
1737 /**********************************************************
1738 * opcodes with DD/FD CB prefix
1739 * rotate, shift and bit operations with (IX+o)
1740 **********************************************************/
1741 OP(xycb,00) { B = rlc(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, B); } /* RLC B=(XY+o) */
1742 OP(xycb,01) { C = rlc(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, C); } /* RLC C=(XY+o) */
1743 OP(xycb,02) { D = rlc(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, D); } /* RLC D=(XY+o) */
1744 OP(xycb,03) { E = rlc(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, E); } /* RLC E=(XY+o) */
1745 OP(xycb,04) { H = rlc(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, H); } /* RLC H=(XY+o) */
1746 OP(xycb,05) { L = rlc(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, L); } /* RLC L=(XY+o) */
1747 OP(xycb,06) { wm(z80, z80->m_ea, rlc(z80, rm(z80, z80->m_ea))); } /* RLC (XY+o) */
1748 OP(xycb,07) { A = rlc(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, A); } /* RLC A=(XY+o) */
1749
1750 OP(xycb,08) { B = rrc(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, B); } /* RRC B=(XY+o) */
1751 OP(xycb,09) { C = rrc(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, C); } /* RRC C=(XY+o) */
1752 OP(xycb,0a) { D = rrc(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, D); } /* RRC D=(XY+o) */
1753 OP(xycb,0b) { E = rrc(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, E); } /* RRC E=(XY+o) */
1754 OP(xycb,0c) { H = rrc(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, H); } /* RRC H=(XY+o) */
1755 OP(xycb,0d) { L = rrc(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, L); } /* RRC L=(XY+o) */
1756 OP(xycb,0e) { wm(z80, z80->m_ea,rrc(z80, rm(z80, z80->m_ea))); } /* RRC (XY+o) */
1757 OP(xycb,0f) { A = rrc(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, A); } /* RRC A=(XY+o) */
1758
1759 OP(xycb,10) { B = rl(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, B); } /* RL B=(XY+o) */
1760 OP(xycb,11) { C = rl(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, C); } /* RL C=(XY+o) */
1761 OP(xycb,12) { D = rl(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, D); } /* RL D=(XY+o) */
1762 OP(xycb,13) { E = rl(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, E); } /* RL E=(XY+o) */
1763 OP(xycb,14) { H = rl(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, H); } /* RL H=(XY+o) */
1764 OP(xycb,15) { L = rl(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, L); } /* RL L=(XY+o) */
1765 OP(xycb,16) { wm(z80, z80->m_ea,rl(z80, rm(z80, z80->m_ea))); } /* RL (XY+o) */
1766 OP(xycb,17) { A = rl(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, A); } /* RL A=(XY+o) */
1767
1768 OP(xycb,18) { B = rr(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, B); } /* RR B=(XY+o) */
1769 OP(xycb,19) { C = rr(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, C); } /* RR C=(XY+o) */
1770 OP(xycb,1a) { D = rr(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, D); } /* RR D=(XY+o) */
1771 OP(xycb,1b) { E = rr(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, E); } /* RR E=(XY+o) */
1772 OP(xycb,1c) { H = rr(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, H); } /* RR H=(XY+o) */
1773 OP(xycb,1d) { L = rr(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, L); } /* RR L=(XY+o) */
1774 OP(xycb,1e) { wm(z80, z80->m_ea, rr(z80, rm(z80, z80->m_ea))); } /* RR (XY+o) */
1775 OP(xycb,1f) { A = rr(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, A); } /* RR A=(XY+o) */
1776
1777 OP(xycb,20) { B = sla(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, B); } /* SLA B=(XY+o) */
1778 OP(xycb,21) { C = sla(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, C); } /* SLA C=(XY+o) */
1779 OP(xycb,22) { D = sla(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, D); } /* SLA D=(XY+o) */
1780 OP(xycb,23) { E = sla(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, E); } /* SLA E=(XY+o) */
1781 OP(xycb,24) { H = sla(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, H); } /* SLA H=(XY+o) */
1782 OP(xycb,25) { L = sla(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, L); } /* SLA L=(XY+o) */
1783 OP(xycb,26) { wm(z80, z80->m_ea, sla(z80, rm(z80, z80->m_ea))); } /* SLA (XY+o) */
1784 OP(xycb,27) { A = sla(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, A); } /* SLA A=(XY+o) */
1785
1786 OP(xycb,28) { B = sra(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, B); } /* SRA B=(XY+o) */
1787 OP(xycb,29) { C = sra(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, C); } /* SRA C=(XY+o) */
1788 OP(xycb,2a) { D = sra(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, D); } /* SRA D=(XY+o) */
1789 OP(xycb,2b) { E = sra(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, E); } /* SRA E=(XY+o) */
1790 OP(xycb,2c) { H = sra(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, H); } /* SRA H=(XY+o) */
1791 OP(xycb,2d) { L = sra(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, L); } /* SRA L=(XY+o) */
1792 OP(xycb,2e) { wm(z80, z80->m_ea, sra(z80, rm(z80, z80->m_ea))); } /* SRA (XY+o) */
1793 OP(xycb,2f) { A = sra(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, A); } /* SRA A=(XY+o) */
1794
1795 OP(xycb,30) { B = sll(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, B); } /* SLL B=(XY+o) */
1796 OP(xycb,31) { C = sll(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, C); } /* SLL C=(XY+o) */
1797 OP(xycb,32) { D = sll(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, D); } /* SLL D=(XY+o) */
1798 OP(xycb,33) { E = sll(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, E); } /* SLL E=(XY+o) */
1799 OP(xycb,34) { H = sll(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, H); } /* SLL H=(XY+o) */
1800 OP(xycb,35) { L = sll(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, L); } /* SLL L=(XY+o) */
1801 OP(xycb,36) { wm(z80, z80->m_ea, sll(z80, rm(z80, z80->m_ea))); } /* SLL (XY+o) */
1802 OP(xycb,37) { A = sll(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, A); } /* SLL A=(XY+o) */
1803
1804 OP(xycb,38) { B = srl(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, B); } /* SRL B=(XY+o) */
1805 OP(xycb,39) { C = srl(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, C); } /* SRL C=(XY+o) */
1806 OP(xycb,3a) { D = srl(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, D); } /* SRL D=(XY+o) */
1807 OP(xycb,3b) { E = srl(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, E); } /* SRL E=(XY+o) */
1808 OP(xycb,3c) { H = srl(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, H); } /* SRL H=(XY+o) */
1809 OP(xycb,3d) { L = srl(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, L); } /* SRL L=(XY+o) */
1810 OP(xycb,3e) { wm(z80, z80->m_ea, srl(z80, rm(z80, z80->m_ea))); } /* SRL (XY+o) */
1811 OP(xycb,3f) { A = srl(z80, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, A); } /* SRL A=(XY+o) */
1812
1813 OP(xycb,40) { xycb_46(z80); } /* BIT 0,(XY+o) */
1814 OP(xycb,41) { xycb_46(z80); } /* BIT 0,(XY+o) */
1815 OP(xycb,42) { xycb_46(z80); } /* BIT 0,(XY+o) */
1816 OP(xycb,43) { xycb_46(z80); } /* BIT 0,(XY+o) */
1817 OP(xycb,44) { xycb_46(z80); } /* BIT 0,(XY+o) */
1818 OP(xycb,45) { xycb_46(z80); } /* BIT 0,(XY+o) */
1819 OP(xycb,46) { bit_xy(z80, 0, rm(z80, z80->m_ea)); } /* BIT 0,(XY+o) */
1820 OP(xycb,47) { xycb_46(z80); } /* BIT 0,(XY+o) */
1821
1822 OP(xycb,48) { xycb_4e(z80); } /* BIT 1,(XY+o) */
1823 OP(xycb,49) { xycb_4e(z80); } /* BIT 1,(XY+o) */
1824 OP(xycb,4a) { xycb_4e(z80); } /* BIT 1,(XY+o) */
1825 OP(xycb,4b) { xycb_4e(z80); } /* BIT 1,(XY+o) */
1826 OP(xycb,4c) { xycb_4e(z80); } /* BIT 1,(XY+o) */
1827 OP(xycb,4d) { xycb_4e(z80); } /* BIT 1,(XY+o) */
1828 OP(xycb,4e) { bit_xy(z80, 1, rm(z80, z80->m_ea)); } /* BIT 1,(XY+o) */
1829 OP(xycb,4f) { xycb_4e(z80); } /* BIT 1,(XY+o) */
1830
1831 OP(xycb,50) { xycb_56(z80); } /* BIT 2,(XY+o) */
1832 OP(xycb,51) { xycb_56(z80); } /* BIT 2,(XY+o) */
1833 OP(xycb,52) { xycb_56(z80); } /* BIT 2,(XY+o) */
1834 OP(xycb,53) { xycb_56(z80); } /* BIT 2,(XY+o) */
1835 OP(xycb,54) { xycb_56(z80); } /* BIT 2,(XY+o) */
1836 OP(xycb,55) { xycb_56(z80); } /* BIT 2,(XY+o) */
1837 OP(xycb,56) { bit_xy(z80, 2, rm(z80, z80->m_ea)); } /* BIT 2,(XY+o) */
1838 OP(xycb,57) { xycb_56(z80); } /* BIT 2,(XY+o) */
1839
1840 OP(xycb,58) { xycb_5e(z80); } /* BIT 3,(XY+o) */
1841 OP(xycb,59) { xycb_5e(z80); } /* BIT 3,(XY+o) */
1842 OP(xycb,5a) { xycb_5e(z80); } /* BIT 3,(XY+o) */
1843 OP(xycb,5b) { xycb_5e(z80); } /* BIT 3,(XY+o) */
1844 OP(xycb,5c) { xycb_5e(z80); } /* BIT 3,(XY+o) */
1845 OP(xycb,5d) { xycb_5e(z80); } /* BIT 3,(XY+o) */
1846 OP(xycb,5e) { bit_xy(z80, 3, rm(z80, z80->m_ea)); } /* BIT 3,(XY+o) */
1847 OP(xycb,5f) { xycb_5e(z80); } /* BIT 3,(XY+o) */
1848
1849 OP(xycb,60) { xycb_66(z80); } /* BIT 4,(XY+o) */
1850 OP(xycb,61) { xycb_66(z80); } /* BIT 4,(XY+o) */
1851 OP(xycb,62) { xycb_66(z80); } /* BIT 4,(XY+o) */
1852 OP(xycb,63) { xycb_66(z80); } /* BIT 4,(XY+o) */
1853 OP(xycb,64) { xycb_66(z80); } /* BIT 4,(XY+o) */
1854 OP(xycb,65) { xycb_66(z80); } /* BIT 4,(XY+o) */
1855 OP(xycb,66) { bit_xy(z80, 4, rm(z80, z80->m_ea)); } /* BIT 4,(XY+o) */
1856 OP(xycb,67) { xycb_66(z80); } /* BIT 4,(XY+o) */
1857
1858 OP(xycb,68) { xycb_6e(z80); } /* BIT 5,(XY+o) */
1859 OP(xycb,69) { xycb_6e(z80); } /* BIT 5,(XY+o) */
1860 OP(xycb,6a) { xycb_6e(z80); } /* BIT 5,(XY+o) */
1861 OP(xycb,6b) { xycb_6e(z80); } /* BIT 5,(XY+o) */
1862 OP(xycb,6c) { xycb_6e(z80); } /* BIT 5,(XY+o) */
1863 OP(xycb,6d) { xycb_6e(z80); } /* BIT 5,(XY+o) */
1864 OP(xycb,6e) { bit_xy(z80, 5, rm(z80, z80->m_ea)); } /* BIT 5,(XY+o) */
1865 OP(xycb,6f) { xycb_6e(z80); } /* BIT 5,(XY+o) */
1866
1867 OP(xycb,70) { xycb_76(z80); } /* BIT 6,(XY+o) */
1868 OP(xycb,71) { xycb_76(z80); } /* BIT 6,(XY+o) */
1869 OP(xycb,72) { xycb_76(z80); } /* BIT 6,(XY+o) */
1870 OP(xycb,73) { xycb_76(z80); } /* BIT 6,(XY+o) */
1871 OP(xycb,74) { xycb_76(z80); } /* BIT 6,(XY+o) */
1872 OP(xycb,75) { xycb_76(z80); } /* BIT 6,(XY+o) */
1873 OP(xycb,76) { bit_xy(z80, 6, rm(z80, z80->m_ea)); } /* BIT 6,(XY+o) */
1874 OP(xycb,77) { xycb_76(z80); } /* BIT 6,(XY+o) */
1875
1876 OP(xycb,78) { xycb_7e(z80); } /* BIT 7,(XY+o) */
1877 OP(xycb,79) { xycb_7e(z80); } /* BIT 7,(XY+o) */
1878 OP(xycb,7a) { xycb_7e(z80); } /* BIT 7,(XY+o) */
1879 OP(xycb,7b) { xycb_7e(z80); } /* BIT 7,(XY+o) */
1880 OP(xycb,7c) { xycb_7e(z80); } /* BIT 7,(XY+o) */
1881 OP(xycb,7d) { xycb_7e(z80); } /* BIT 7,(XY+o) */
1882 OP(xycb,7e) { bit_xy(z80, 7, rm(z80, z80->m_ea)); } /* BIT 7,(XY+o) */
1883 OP(xycb,7f) { xycb_7e(z80); } /* BIT 7,(XY+o) */
1884
1885 OP(xycb,80) { B = res(0, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, B); } /* RES 0,B=(XY+o) */
1886 OP(xycb,81) { C = res(0, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, C); } /* RES 0,C=(XY+o) */
1887 OP(xycb,82) { D = res(0, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, D); } /* RES 0,D=(XY+o) */
1888 OP(xycb,83) { E = res(0, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, E); } /* RES 0,E=(XY+o) */
1889 OP(xycb,84) { H = res(0, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, H); } /* RES 0,H=(XY+o) */
1890 OP(xycb,85) { L = res(0, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, L); } /* RES 0,L=(XY+o) */
1891 OP(xycb,86) { wm(z80, z80->m_ea, res(0, rm(z80, z80->m_ea))); } /* RES 0,(XY+o) */
1892 OP(xycb,87) { A = res(0, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, A); } /* RES 0,A=(XY+o) */
1893
1894 OP(xycb,88) { B = res(1, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, B); } /* RES 1,B=(XY+o) */
1895 OP(xycb,89) { C = res(1, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, C); } /* RES 1,C=(XY+o) */
1896 OP(xycb,8a) { D = res(1, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, D); } /* RES 1,D=(XY+o) */
1897 OP(xycb,8b) { E = res(1, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, E); } /* RES 1,E=(XY+o) */
1898 OP(xycb,8c) { H = res(1, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, H); } /* RES 1,H=(XY+o) */
1899 OP(xycb,8d) { L = res(1, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, L); } /* RES 1,L=(XY+o) */
1900 OP(xycb,8e) { wm(z80, z80->m_ea, res(1, rm(z80, z80->m_ea))); } /* RES 1,(XY+o) */
1901 OP(xycb,8f) { A = res(1, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, A); } /* RES 1,A=(XY+o) */
1902
1903 OP(xycb,90) { B = res(2, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, B); } /* RES 2,B=(XY+o) */
1904 OP(xycb,91) { C = res(2, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, C); } /* RES 2,C=(XY+o) */
1905 OP(xycb,92) { D = res(2, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, D); } /* RES 2,D=(XY+o) */
1906 OP(xycb,93) { E = res(2, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, E); } /* RES 2,E=(XY+o) */
1907 OP(xycb,94) { H = res(2, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, H); } /* RES 2,H=(XY+o) */
1908 OP(xycb,95) { L = res(2, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, L); } /* RES 2,L=(XY+o) */
1909 OP(xycb,96) { wm(z80, z80->m_ea, res(2, rm(z80, z80->m_ea))); } /* RES 2,(XY+o) */
1910 OP(xycb,97) { A = res(2, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, A); } /* RES 2,A=(XY+o) */
1911
1912 OP(xycb,98) { B = res(3, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, B); } /* RES 3,B=(XY+o) */
1913 OP(xycb,99) { C = res(3, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, C); } /* RES 3,C=(XY+o) */
1914 OP(xycb,9a) { D = res(3, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, D); } /* RES 3,D=(XY+o) */
1915 OP(xycb,9b) { E = res(3, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, E); } /* RES 3,E=(XY+o) */
1916 OP(xycb,9c) { H = res(3, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, H); } /* RES 3,H=(XY+o) */
1917 OP(xycb,9d) { L = res(3, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, L); } /* RES 3,L=(XY+o) */
1918 OP(xycb,9e) { wm(z80, z80->m_ea, res(3, rm(z80, z80->m_ea))); } /* RES 3,(XY+o) */
1919 OP(xycb,9f) { A = res(3, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, A); } /* RES 3,A=(XY+o) */
1920
1921 OP(xycb,a0) { B = res(4, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, B); } /* RES 4,B=(XY+o) */
1922 OP(xycb,a1) { C = res(4, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, C); } /* RES 4,C=(XY+o) */
1923 OP(xycb,a2) { D = res(4, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, D); } /* RES 4,D=(XY+o) */
1924 OP(xycb,a3) { E = res(4, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, E); } /* RES 4,E=(XY+o) */
1925 OP(xycb,a4) { H = res(4, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, H); } /* RES 4,H=(XY+o) */
1926 OP(xycb,a5) { L = res(4, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, L); } /* RES 4,L=(XY+o) */
1927 OP(xycb,a6) { wm(z80, z80->m_ea, res(4, rm(z80, z80->m_ea))); } /* RES 4,(XY+o) */
1928 OP(xycb,a7) { A = res(4, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, A); } /* RES 4,A=(XY+o) */
1929
1930 OP(xycb,a8) { B = res(5, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, B); } /* RES 5,B=(XY+o) */
1931 OP(xycb,a9) { C = res(5, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, C); } /* RES 5,C=(XY+o) */
1932 OP(xycb,aa) { D = res(5, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, D); } /* RES 5,D=(XY+o) */
1933 OP(xycb,ab) { E = res(5, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, E); } /* RES 5,E=(XY+o) */
1934 OP(xycb,ac) { H = res(5, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, H); } /* RES 5,H=(XY+o) */
1935 OP(xycb,ad) { L = res(5, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, L); } /* RES 5,L=(XY+o) */
1936 OP(xycb,ae) { wm(z80, z80->m_ea, res(5, rm(z80, z80->m_ea))); } /* RES 5,(XY+o) */
1937 OP(xycb,af) { A = res(5, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, A); } /* RES 5,A=(XY+o) */
1938
1939 OP(xycb,b0) { B = res(6, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, B); } /* RES 6,B=(XY+o) */
1940 OP(xycb,b1) { C = res(6, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, C); } /* RES 6,C=(XY+o) */
1941 OP(xycb,b2) { D = res(6, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, D); } /* RES 6,D=(XY+o) */
1942 OP(xycb,b3) { E = res(6, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, E); } /* RES 6,E=(XY+o) */
1943 OP(xycb,b4) { H = res(6, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, H); } /* RES 6,H=(XY+o) */
1944 OP(xycb,b5) { L = res(6, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, L); } /* RES 6,L=(XY+o) */
1945 OP(xycb,b6) { wm(z80, z80->m_ea, res(6, rm(z80, z80->m_ea))); } /* RES 6,(XY+o) */
1946 OP(xycb,b7) { A = res(6, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, A); } /* RES 6,A=(XY+o) */
1947
1948 OP(xycb,b8) { B = res(7, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, B); } /* RES 7,B=(XY+o) */
1949 OP(xycb,b9) { C = res(7, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, C); } /* RES 7,C=(XY+o) */
1950 OP(xycb,ba) { D = res(7, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, D); } /* RES 7,D=(XY+o) */
1951 OP(xycb,bb) { E = res(7, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, E); } /* RES 7,E=(XY+o) */
1952 OP(xycb,bc) { H = res(7, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, H); } /* RES 7,H=(XY+o) */
1953 OP(xycb,bd) { L = res(7, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, L); } /* RES 7,L=(XY+o) */
1954 OP(xycb,be) { wm(z80, z80->m_ea, res(7, rm(z80, z80->m_ea))); } /* RES 7,(XY+o) */
1955 OP(xycb,bf) { A = res(7, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, A); } /* RES 7,A=(XY+o) */
1956
1957 OP(xycb,c0) { B = set(0, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, B); } /* SET 0,B=(XY+o) */
1958 OP(xycb,c1) { C = set(0, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, C); } /* SET 0,C=(XY+o) */
1959 OP(xycb,c2) { D = set(0, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, D); } /* SET 0,D=(XY+o) */
1960 OP(xycb,c3) { E = set(0, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, E); } /* SET 0,E=(XY+o) */
1961 OP(xycb,c4) { H = set(0, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, H); } /* SET 0,H=(XY+o) */
1962 OP(xycb,c5) { L = set(0, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, L); } /* SET 0,L=(XY+o) */
1963 OP(xycb,c6) { wm(z80, z80->m_ea, set(0, rm(z80, z80->m_ea))); } /* SET 0,(XY+o) */
1964 OP(xycb,c7) { A = set(0, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, A); } /* SET 0,A=(XY+o) */
1965
1966 OP(xycb,c8) { B = set(1, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, B); } /* SET 1,B=(XY+o) */
1967 OP(xycb,c9) { C = set(1, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, C); } /* SET 1,C=(XY+o) */
1968 OP(xycb,ca) { D = set(1, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, D); } /* SET 1,D=(XY+o) */
1969 OP(xycb,cb) { E = set(1, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, E); } /* SET 1,E=(XY+o) */
1970 OP(xycb,cc) { H = set(1, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, H); } /* SET 1,H=(XY+o) */
1971 OP(xycb,cd) { L = set(1, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, L); } /* SET 1,L=(XY+o) */
1972 OP(xycb,ce) { wm(z80, z80->m_ea, set(1, rm(z80, z80->m_ea))); } /* SET 1,(XY+o) */
1973 OP(xycb,cf) { A = set(1, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, A); } /* SET 1,A=(XY+o) */
1974
1975 OP(xycb,d0) { B = set(2, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, B); } /* SET 2,B=(XY+o) */
1976 OP(xycb,d1) { C = set(2, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, C); } /* SET 2,C=(XY+o) */
1977 OP(xycb,d2) { D = set(2, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, D); } /* SET 2,D=(XY+o) */
1978 OP(xycb,d3) { E = set(2, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, E); } /* SET 2,E=(XY+o) */
1979 OP(xycb,d4) { H = set(2, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, H); } /* SET 2,H=(XY+o) */
1980 OP(xycb,d5) { L = set(2, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, L); } /* SET 2,L=(XY+o) */
1981 OP(xycb,d6) { wm(z80, z80->m_ea, set(2, rm(z80, z80->m_ea))); } /* SET 2,(XY+o) */
1982 OP(xycb,d7) { A = set(2, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, A); } /* SET 2,A=(XY+o) */
1983
1984 OP(xycb,d8) { B = set(3, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, B); } /* SET 3,B=(XY+o) */
1985 OP(xycb,d9) { C = set(3, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, C); } /* SET 3,C=(XY+o) */
1986 OP(xycb,da) { D = set(3, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, D); } /* SET 3,D=(XY+o) */
1987 OP(xycb,db) { E = set(3, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, E); } /* SET 3,E=(XY+o) */
1988 OP(xycb,dc) { H = set(3, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, H); } /* SET 3,H=(XY+o) */
1989 OP(xycb,dd) { L = set(3, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, L); } /* SET 3,L=(XY+o) */
1990 OP(xycb,de) { wm(z80, z80->m_ea, set(3, rm(z80, z80->m_ea))); } /* SET 3,(XY+o) */
1991 OP(xycb,df) { A = set(3, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, A); } /* SET 3,A=(XY+o) */
1992
1993 OP(xycb,e0) { B = set(4, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, B); } /* SET 4,B=(XY+o) */
1994 OP(xycb,e1) { C = set(4, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, C); } /* SET 4,C=(XY+o) */
1995 OP(xycb,e2) { D = set(4, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, D); } /* SET 4,D=(XY+o) */
1996 OP(xycb,e3) { E = set(4, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, E); } /* SET 4,E=(XY+o) */
1997 OP(xycb,e4) { H = set(4, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, H); } /* SET 4,H=(XY+o) */
1998 OP(xycb,e5) { L = set(4, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, L); } /* SET 4,L=(XY+o) */
1999 OP(xycb,e6) { wm(z80, z80->m_ea, set(4, rm(z80, z80->m_ea))); } /* SET 4,(XY+o) */
2000 OP(xycb,e7) { A = set(4, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, A); } /* SET 4,A=(XY+o) */
2001
2002 OP(xycb,e8) { B = set(5, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, B); } /* SET 5,B=(XY+o) */
2003 OP(xycb,e9) { C = set(5, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, C); } /* SET 5,C=(XY+o) */
2004 OP(xycb,ea) { D = set(5, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, D); } /* SET 5,D=(XY+o) */
2005 OP(xycb,eb) { E = set(5, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, E); } /* SET 5,E=(XY+o) */
2006 OP(xycb,ec) { H = set(5, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, H); } /* SET 5,H=(XY+o) */
2007 OP(xycb,ed) { L = set(5, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, L); } /* SET 5,L=(XY+o) */
2008 OP(xycb,ee) { wm(z80, z80->m_ea, set(5, rm(z80, z80->m_ea))); } /* SET 5,(XY+o) */
2009 OP(xycb,ef) { A = set(5, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, A); } /* SET 5,A=(XY+o) */
2010
2011 OP(xycb,f0) { B = set(6, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, B); } /* SET 6,B=(XY+o) */
2012 OP(xycb,f1) { C = set(6, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, C); } /* SET 6,C=(XY+o) */
2013 OP(xycb,f2) { D = set(6, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, D); } /* SET 6,D=(XY+o) */
2014 OP(xycb,f3) { E = set(6, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, E); } /* SET 6,E=(XY+o) */
2015 OP(xycb,f4) { H = set(6, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, H); } /* SET 6,H=(XY+o) */
2016 OP(xycb,f5) { L = set(6, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, L); } /* SET 6,L=(XY+o) */
2017 OP(xycb,f6) { wm(z80, z80->m_ea, set(6, rm(z80, z80->m_ea))); } /* SET 6,(XY+o) */
2018 OP(xycb,f7) { A = set(6, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, A); } /* SET 6,A=(XY+o) */
2019
2020 OP(xycb,f8) { B = set(7, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, B); } /* SET 7,B=(XY+o) */
2021 OP(xycb,f9) { C = set(7, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, C); } /* SET 7,C=(XY+o) */
2022 OP(xycb,fa) { D = set(7, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, D); } /* SET 7,D=(XY+o) */
2023 OP(xycb,fb) { E = set(7, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, E); } /* SET 7,E=(XY+o) */
2024 OP(xycb,fc) { H = set(7, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, H); } /* SET 7,H=(XY+o) */
2025 OP(xycb,fd) { L = set(7, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, L); } /* SET 7,L=(XY+o) */
2026 OP(xycb,fe) { wm(z80, z80->m_ea, set(7, rm(z80, z80->m_ea))); } /* SET 7,(XY+o) */
2027 OP(xycb,ff) { A = set(7, rm(z80, z80->m_ea)); wm(z80, z80->m_ea, A); } /* SET 7,A=(XY+o) */
2028
2029 OP(illegal,1) {
2030 warning("Z80 ill. opcode $%02x $%02x ($%04x)\n",
2031 rm(z80, (PCD-1)&0xffff), rm(z80, PCD), PCD-1);
2032 }
2033
2034 /**********************************************************
2035 * IX register related opcodes (DD prefix)
2036 **********************************************************/
2037 OP(dd,00) { illegal_1(z80); op_00(z80); } /* DB DD */
2038 OP(dd,01) { illegal_1(z80); op_01(z80); } /* DB DD */
2039 OP(dd,02) { illegal_1(z80); op_02(z80); } /* DB DD */
2040 OP(dd,03) { illegal_1(z80); op_03(z80); } /* DB DD */
2041 OP(dd,04) { illegal_1(z80); op_04(z80); } /* DB DD */
2042 OP(dd,05) { illegal_1(z80); op_05(z80); } /* DB DD */
2043 OP(dd,06) { illegal_1(z80); op_06(z80); } /* DB DD */
2044 OP(dd,07) { illegal_1(z80); op_07(z80); } /* DB DD */
2045
2046 OP(dd,08) { illegal_1(z80); op_08(z80); } /* DB DD */
2047 OP(dd,09) { add16(z80, &z80->m_ix, &z80->m_bc); } /* ADD IX,BC */
2048 OP(dd,0a) { illegal_1(z80); op_0a(z80); } /* DB DD */
2049 OP(dd,0b) { illegal_1(z80); op_0b(z80); } /* DB DD */
2050 OP(dd,0c) { illegal_1(z80); op_0c(z80); } /* DB DD */
2051 OP(dd,0d) { illegal_1(z80); op_0d(z80); } /* DB DD */
2052 OP(dd,0e) { illegal_1(z80); op_0e(z80); } /* DB DD */
2053 OP(dd,0f) { illegal_1(z80); op_0f(z80); } /* DB DD */
2054
2055 OP(dd,10) { illegal_1(z80); op_10(z80); } /* DB DD */
2056 OP(dd,11) { illegal_1(z80); op_11(z80); } /* DB DD */
2057 OP(dd,12) { illegal_1(z80); op_12(z80); } /* DB DD */
2058 OP(dd,13) { illegal_1(z80); op_13(z80); } /* DB DD */
2059 OP(dd,14) { illegal_1(z80); op_14(z80); } /* DB DD */
2060 OP(dd,15) { illegal_1(z80); op_15(z80); } /* DB DD */
2061 OP(dd,16) { illegal_1(z80); op_16(z80); } /* DB DD */
2062 OP(dd,17) { illegal_1(z80); op_17(z80); } /* DB DD */
2063
2064 OP(dd,18) { illegal_1(z80); op_18(z80); } /* DB DD */
2065 OP(dd,19) { add16(z80, &z80->m_ix, &z80->m_de); } /* ADD IX,DE */
2066 OP(dd,1a) { illegal_1(z80); op_1a(z80); } /* DB DD */
2067 OP(dd,1b) { illegal_1(z80); op_1b(z80); } /* DB DD */
2068 OP(dd,1c) { illegal_1(z80); op_1c(z80); } /* DB DD */
2069 OP(dd,1d) { illegal_1(z80); op_1d(z80); } /* DB DD */
2070 OP(dd,1e) { illegal_1(z80); op_1e(z80); } /* DB DD */
2071 OP(dd,1f) { illegal_1(z80); op_1f(z80); } /* DB DD */
2072
2073 OP(dd,20) { illegal_1(z80); op_20(z80); } /* DB DD */
2074 OP(dd,21) { IX = arg16(z80); } /* LD IX,w */
2075 OP(dd,22) { z80->m_ea = arg16(z80); wm16(z80, z80->m_ea, &z80->m_ix); WZ = z80->m_ea + 1; } /* LD (w),IX */
2076 OP(dd,23) { IX++; } /* INC IX */
2077 OP(dd,24) { HX = inc(z80, HX); } /* INC HX */
2078 OP(dd,25) { HX = dec(z80, HX); } /* DEC HX */
2079 OP(dd,26) { HX = arg(z80); } /* LD HX,n */
2080 OP(dd,27) { illegal_1(z80); op_27(z80); } /* DB DD */
2081
2082 OP(dd,28) { illegal_1(z80); op_28(z80); } /* DB DD */
2083 OP(dd,29) { add16(z80, &z80->m_ix, &z80->m_ix); } /* ADD IX,IX */
2084 OP(dd,2a) { z80->m_ea = arg16(z80); rm16(z80, z80->m_ea, &z80->m_ix); WZ = z80->m_ea + 1; } /* LD IX,(w) */
2085 OP(dd,2b) { IX--; } /* DEC IX */
2086 OP(dd,2c) { LX = inc(z80, LX); } /* INC LX */
2087 OP(dd,2d) { LX = dec(z80, LX); } /* DEC LX */
2088 OP(dd,2e) { LX = arg(z80); } /* LD LX,n */
2089 OP(dd,2f) { illegal_1(z80); op_2f(z80); } /* DB DD */
2090
2091 OP(dd,30) { illegal_1(z80); op_30(z80); } /* DB DD */
2092 OP(dd,31) { illegal_1(z80); op_31(z80); } /* DB DD */
2093 OP(dd,32) { illegal_1(z80); op_32(z80); } /* DB DD */
2094 OP(dd,33) { illegal_1(z80); op_33(z80); } /* DB DD */
2095 OP(dd,34) { eax(z80); wm(z80, z80->m_ea, inc(z80, rm(z80, z80->m_ea))); } /* INC (IX+o) */
2096 OP(dd,35) { eax(z80); wm(z80, z80->m_ea, dec(z80, rm(z80, z80->m_ea))); } /* DEC (IX+o) */
2097 OP(dd,36) { eax(z80); wm(z80, z80->m_ea, arg(z80)); } /* LD (IX+o),n */
2098 OP(dd,37) { illegal_1(z80); op_37(z80); } /* DB DD */
2099
2100 OP(dd,38) { illegal_1(z80); op_38(z80); } /* DB DD */
2101 OP(dd,39) { add16(z80, &z80->m_ix, &z80->m_sp); } /* ADD IX,SP */
2102 OP(dd,3a) { illegal_1(z80); op_3a(z80); } /* DB DD */
2103 OP(dd,3b) { illegal_1(z80); op_3b(z80); } /* DB DD */
2104 OP(dd,3c) { illegal_1(z80); op_3c(z80); } /* DB DD */
2105 OP(dd,3d) { illegal_1(z80); op_3d(z80); } /* DB DD */
2106 OP(dd,3e) { illegal_1(z80); op_3e(z80); } /* DB DD */
2107 OP(dd,3f) { illegal_1(z80); op_3f(z80); } /* DB DD */
2108
2109 OP(dd,40) { illegal_1(z80); op_40(z80); } /* DB DD */
2110 OP(dd,41) { illegal_1(z80); op_41(z80); } /* DB DD */
2111 OP(dd,42) { illegal_1(z80); op_42(z80); } /* DB DD */
2112 OP(dd,43) { illegal_1(z80); op_43(z80); } /* DB DD */
2113 OP(dd,44) { B = HX; } /* LD B,HX */
2114 OP(dd,45) { B = LX; } /* LD B,LX */
2115 OP(dd,46) { eax(z80); B = rm(z80, z80->m_ea); } /* LD B,(IX+o) */
2116 OP(dd,47) { illegal_1(z80); op_47(z80); } /* DB DD */
2117
2118 OP(dd,48) { illegal_1(z80); op_48(z80); } /* DB DD */
2119 OP(dd,49) { illegal_1(z80); op_49(z80); } /* DB DD */
2120 OP(dd,4a) { illegal_1(z80); op_4a(z80); } /* DB DD */
2121 OP(dd,4b) { illegal_1(z80); op_4b(z80); } /* DB DD */
2122 OP(dd,4c) { C = HX; } /* LD C,HX */
2123 OP(dd,4d) { C = LX; } /* LD C,LX */
2124 OP(dd,4e) { eax(z80); C = rm(z80, z80->m_ea); } /* LD C,(IX+o) */
2125 OP(dd,4f) { illegal_1(z80); op_4f(z80); } /* DB DD */
2126
2127 OP(dd,50) { illegal_1(z80); op_50(z80); } /* DB DD */
2128 OP(dd,51) { illegal_1(z80); op_51(z80); } /* DB DD */
2129 OP(dd,52) { illegal_1(z80); op_52(z80); } /* DB DD */
2130 OP(dd,53) { illegal_1(z80); op_53(z80); } /* DB DD */
2131 OP(dd,54) { D = HX; } /* LD D,HX */
2132 OP(dd,55) { D = LX; } /* LD D,LX */
2133 OP(dd,56) { eax(z80); D = rm(z80, z80->m_ea); } /* LD D,(IX+o) */
2134 OP(dd,57) { illegal_1(z80); op_57(z80); } /* DB DD */
2135
2136 OP(dd,58) { illegal_1(z80); op_58(z80); } /* DB DD */
2137 OP(dd,59) { illegal_1(z80); op_59(z80); } /* DB DD */
2138 OP(dd,5a) { illegal_1(z80); op_5a(z80); } /* DB DD */
2139 OP(dd,5b) { illegal_1(z80); op_5b(z80); } /* DB DD */
2140 OP(dd,5c) { E = HX; } /* LD E,HX */
2141 OP(dd,5d) { E = LX; } /* LD E,LX */
2142 OP(dd,5e) { eax(z80); E = rm(z80, z80->m_ea); } /* LD E,(IX+o) */
2143 OP(dd,5f) { illegal_1(z80); op_5f(z80); } /* DB DD */
2144
2145 OP(dd,60) { HX = B; } /* LD HX,B */
2146 OP(dd,61) { HX = C; } /* LD HX,C */
2147 OP(dd,62) { HX = D; } /* LD HX,D */
2148 OP(dd,63) { HX = E; } /* LD HX,E */
2149 OP(dd,64) { } /* LD HX,HX */
2150 OP(dd,65) { HX = LX; } /* LD HX,LX */
2151 OP(dd,66) { eax(z80); H = rm(z80, z80->m_ea); } /* LD H,(IX+o) */
2152 OP(dd,67) { HX = A; } /* LD HX,A */
2153
2154 OP(dd,68) { LX = B; } /* LD LX,B */
2155 OP(dd,69) { LX = C; } /* LD LX,C */
2156 OP(dd,6a) { LX = D; } /* LD LX,D */
2157 OP(dd,6b) { LX = E; } /* LD LX,E */
2158 OP(dd,6c) { LX = HX; } /* LD LX,HX */
2159 OP(dd,6d) { } /* LD LX,LX */
2160 OP(dd,6e) { eax(z80); L = rm(z80, z80->m_ea); } /* LD L,(IX+o) */
2161 OP(dd,6f) { LX = A; } /* LD LX,A */
2162
2163 OP(dd,70) { eax(z80); wm(z80, z80->m_ea, B); } /* LD (IX+o),B */
2164 OP(dd,71) { eax(z80); wm(z80, z80->m_ea, C); } /* LD (IX+o),C */
2165 OP(dd,72) { eax(z80); wm(z80, z80->m_ea, D); } /* LD (IX+o),D */
2166 OP(dd,73) { eax(z80); wm(z80, z80->m_ea, E); } /* LD (IX+o),E */
2167 OP(dd,74) { eax(z80); wm(z80, z80->m_ea, H); } /* LD (IX+o),H */
2168 OP(dd,75) { eax(z80); wm(z80, z80->m_ea, L); } /* LD (IX+o),L */
2169 OP(dd,76) { illegal_1(z80); op_76(z80); } /* DB DD */
2170 OP(dd,77) { eax(z80); wm(z80, z80->m_ea, A); } /* LD (IX+o),A */
2171
2172 OP(dd,78) { illegal_1(z80); op_78(z80); } /* DB DD */
2173 OP(dd,79) { illegal_1(z80); op_79(z80); } /* DB DD */
2174 OP(dd,7a) { illegal_1(z80); op_7a(z80); } /* DB DD */
2175 OP(dd,7b) { illegal_1(z80); op_7b(z80); } /* DB DD */
2176 OP(dd,7c) { A = HX; } /* LD A,HX */
2177 OP(dd,7d) { A = LX; } /* LD A,LX */
2178 OP(dd,7e) { eax(z80); A = rm(z80, z80->m_ea); } /* LD A,(IX+o) */
2179 OP(dd,7f) { illegal_1(z80); op_7f(z80); } /* DB DD */
2180
2181 OP(dd,80) { illegal_1(z80); op_80(z80); } /* DB DD */
2182 OP(dd,81) { illegal_1(z80); op_81(z80); } /* DB DD */
2183 OP(dd,82) { illegal_1(z80); op_82(z80); } /* DB DD */
2184 OP(dd,83) { illegal_1(z80); op_83(z80); } /* DB DD */
2185 OP(dd,84) { add_a(z80, HX); } /* ADD A,HX */
2186 OP(dd,85) { add_a(z80, LX); } /* ADD A,LX */
2187 OP(dd,86) { eax(z80); add_a(z80, rm(z80, z80->m_ea)); } /* ADD A,(IX+o) */
2188 OP(dd,87) { illegal_1(z80); op_87(z80); } /* DB DD */
2189
2190 OP(dd,88) { illegal_1(z80); op_88(z80); } /* DB DD */
2191 OP(dd,89) { illegal_1(z80); op_89(z80); } /* DB DD */
2192 OP(dd,8a) { illegal_1(z80); op_8a(z80); } /* DB DD */
2193 OP(dd,8b) { illegal_1(z80); op_8b(z80); } /* DB DD */
2194 OP(dd,8c) { adc_a(z80, HX); } /* ADC A,HX */
2195 OP(dd,8d) { adc_a(z80, LX); } /* ADC A,LX */
2196 OP(dd,8e) { eax(z80); adc_a(z80, rm(z80, z80->m_ea)); } /* ADC A,(IX+o) */
2197 OP(dd,8f) { illegal_1(z80); op_8f(z80); } /* DB DD */
2198
2199 OP(dd,90) { illegal_1(z80); op_90(z80); } /* DB DD */
2200 OP(dd,91) { illegal_1(z80); op_91(z80); } /* DB DD */
2201 OP(dd,92) { illegal_1(z80); op_92(z80); } /* DB DD */
2202 OP(dd,93) { illegal_1(z80); op_93(z80); } /* DB DD */
2203 OP(dd,94) { sub(z80, HX); } /* SUB HX */
2204 OP(dd,95) { sub(z80, LX); } /* SUB LX */
2205 OP(dd,96) { eax(z80); sub(z80, rm(z80, z80->m_ea)); } /* SUB (IX+o) */
2206 OP(dd,97) { illegal_1(z80); op_97(z80); } /* DB DD */
2207
2208 OP(dd,98) { illegal_1(z80); op_98(z80); } /* DB DD */
2209 OP(dd,99) { illegal_1(z80); op_99(z80); } /* DB DD */
2210 OP(dd,9a) { illegal_1(z80); op_9a(z80); } /* DB DD */
2211 OP(dd,9b) { illegal_1(z80); op_9b(z80); } /* DB DD */
2212 OP(dd,9c) { sbc_a(z80, HX); } /* SBC A,HX */
2213 OP(dd,9d) { sbc_a(z80, LX); } /* SBC A,LX */
2214 OP(dd,9e) { eax(z80); sbc_a(z80, rm(z80, z80->m_ea)); } /* SBC A,(IX+o) */
2215 OP(dd,9f) { illegal_1(z80); op_9f(z80); } /* DB DD */
2216
2217 OP(dd,a0) { illegal_1(z80); op_a0(z80); } /* DB DD */
2218 OP(dd,a1) { illegal_1(z80); op_a1(z80); } /* DB DD */
2219 OP(dd,a2) { illegal_1(z80); op_a2(z80); } /* DB DD */
2220 OP(dd,a3) { illegal_1(z80); op_a3(z80); } /* DB DD */
2221 OP(dd,a4) { and_a(z80, HX); } /* AND HX */
2222 OP(dd,a5) { and_a(z80, LX); } /* AND LX */
2223 OP(dd,a6) { eax(z80); and_a(z80, rm(z80, z80->m_ea)); } /* AND (IX+o) */
2224 OP(dd,a7) { illegal_1(z80); op_a7(z80); } /* DB DD */
2225
2226 OP(dd,a8) { illegal_1(z80); op_a8(z80); } /* DB DD */
2227 OP(dd,a9) { illegal_1(z80); op_a9(z80); } /* DB DD */
2228 OP(dd,aa) { illegal_1(z80); op_aa(z80); } /* DB DD */
2229 OP(dd,ab) { illegal_1(z80); op_ab(z80); } /* DB DD */
2230 OP(dd,ac) { xor_a(z80, HX); } /* XOR HX */
2231 OP(dd,ad) { xor_a(z80, LX); } /* XOR LX */
2232 OP(dd,ae) { eax(z80); xor_a(z80, rm(z80, z80->m_ea)); } /* XOR (IX+o) */
2233 OP(dd,af) { illegal_1(z80); op_af(z80); } /* DB DD */
2234
2235 OP(dd,b0) { illegal_1(z80); op_b0(z80); } /* DB DD */
2236 OP(dd,b1) { illegal_1(z80); op_b1(z80); } /* DB DD */
2237 OP(dd,b2) { illegal_1(z80); op_b2(z80); } /* DB DD */
2238 OP(dd,b3) { illegal_1(z80); op_b3(z80); } /* DB DD */
2239 OP(dd,b4) { or_a(z80, HX); } /* OR HX */
2240 OP(dd,b5) { or_a(z80, LX); } /* OR LX */
2241 OP(dd,b6) { eax(z80); or_a(z80, rm(z80, z80->m_ea)); } /* OR (IX+o) */
2242 OP(dd,b7) { illegal_1(z80); op_b7(z80); } /* DB DD */
2243
2244 OP(dd,b8) { illegal_1(z80); op_b8(z80); } /* DB DD */
2245 OP(dd,b9) { illegal_1(z80); op_b9(z80); } /* DB DD */
2246 OP(dd,ba) { illegal_1(z80); op_ba(z80); } /* DB DD */
2247 OP(dd,bb) { illegal_1(z80); op_bb(z80); } /* DB DD */
2248 OP(dd,bc) { cp(z80, HX); } /* CP HX */
2249 OP(dd,bd) { cp(z80, LX); } /* CP LX */
2250 OP(dd,be) { eax(z80); cp(z80, rm(z80, z80->m_ea)); } /* CP (IX+o) */
2251 OP(dd,bf) { illegal_1(z80); op_bf(z80); } /* DB DD */
2252
2253 OP(dd,c0) { illegal_1(z80); op_c0(z80); } /* DB DD */
2254 OP(dd,c1) { illegal_1(z80); op_c1(z80); } /* DB DD */
2255 OP(dd,c2) { illegal_1(z80); op_c2(z80); } /* DB DD */
2256 OP(dd,c3) { illegal_1(z80); op_c3(z80); } /* DB DD */
2257 OP(dd,c4) { illegal_1(z80); op_c4(z80); } /* DB DD */
2258 OP(dd,c5) { illegal_1(z80); op_c5(z80); } /* DB DD */
2259 OP(dd,c6) { illegal_1(z80); op_c6(z80); } /* DB DD */
2260 OP(dd,c7) { illegal_1(z80); op_c7(z80); } /* DB DD */
2261
2262 OP(dd,c8) { illegal_1(z80); op_c8(z80); } /* DB DD */
2263 OP(dd,c9) { illegal_1(z80); op_c9(z80); } /* DB DD */
2264 OP(dd,ca) { illegal_1(z80); op_ca(z80); } /* DB DD */
2265 OP(dd,cb) { eax(z80); EXEC(xycb,arg(z80)); } /* ** DD CB xx */
2266 OP(dd,cc) { illegal_1(z80); op_cc(z80); } /* DB DD */
2267 OP(dd,cd) { illegal_1(z80); op_cd(z80); } /* DB DD */
2268 OP(dd,ce) { illegal_1(z80); op_ce(z80); } /* DB DD */
2269 OP(dd,cf) { illegal_1(z80); op_cf(z80); } /* DB DD */
2270
2271 OP(dd,d0) { illegal_1(z80); op_d0(z80); } /* DB DD */
2272 OP(dd,d1) { illegal_1(z80); op_d1(z80); } /* DB DD */
2273 OP(dd,d2) { illegal_1(z80); op_d2(z80); } /* DB DD */
2274 OP(dd,d3) { illegal_1(z80); op_d3(z80); } /* DB DD */
2275 OP(dd,d4) { illegal_1(z80); op_d4(z80); } /* DB DD */
2276 OP(dd,d5) { illegal_1(z80); op_d5(z80); } /* DB DD */
2277 OP(dd,d6) { illegal_1(z80); op_d6(z80); } /* DB DD */
2278 OP(dd,d7) { illegal_1(z80); op_d7(z80); } /* DB DD */
2279
2280 OP(dd,d8) { illegal_1(z80); op_d8(z80); } /* DB DD */
2281 OP(dd,d9) { illegal_1(z80); op_d9(z80); } /* DB DD */
2282 OP(dd,da) { illegal_1(z80); op_da(z80); } /* DB DD */
2283 OP(dd,db) { illegal_1(z80); op_db(z80); } /* DB DD */
2284 OP(dd,dc) { illegal_1(z80); op_dc(z80); } /* DB DD */
2285 OP(dd,dd) { illegal_1(z80); op_dd(z80); } /* DB DD */
2286 OP(dd,de) { illegal_1(z80); op_de(z80); } /* DB DD */
2287 OP(dd,df) { illegal_1(z80); op_df(z80); } /* DB DD */
2288
2289 OP(dd,e0) { illegal_1(z80); op_e0(z80); } /* DB DD */
2290 OP(dd,e1) { pop(z80, &z80->m_ix); } /* POP IX */
2291 OP(dd,e2) { illegal_1(z80); op_e2(z80); } /* DB DD */
2292 OP(dd,e3) { ex_sp(z80, &z80->m_ix); } /* EX (SP),IX */
2293 OP(dd,e4) { illegal_1(z80); op_e4(z80); } /* DB DD */
2294 OP(dd,e5) { push(z80, &z80->m_ix); } /* PUSH IX */
2295 OP(dd,e6) { illegal_1(z80); op_e6(z80); } /* DB DD */
2296 OP(dd,e7) { illegal_1(z80); op_e7(z80); } /* DB DD */
2297
2298 OP(dd,e8) { illegal_1(z80); op_e8(z80); } /* DB DD */
2299 OP(dd,e9) { PC = IX; } /* JP (IX) */
2300 OP(dd,ea) { illegal_1(z80); op_ea(z80); } /* DB DD */
2301 OP(dd,eb) { illegal_1(z80); op_eb(z80); } /* DB DD */
2302 OP(dd,ec) { illegal_1(z80); op_ec(z80); } /* DB DD */
2303 OP(dd,ed) { illegal_1(z80); op_ed(z80); } /* DB DD */
2304 OP(dd,ee) { illegal_1(z80); op_ee(z80); } /* DB DD */
2305 OP(dd,ef) { illegal_1(z80); op_ef(z80); } /* DB DD */
2306
2307 OP(dd,f0) { illegal_1(z80); op_f0(z80); } /* DB DD */
2308 OP(dd,f1) { illegal_1(z80); op_f1(z80); } /* DB DD */
2309 OP(dd,f2) { illegal_1(z80); op_f2(z80); } /* DB DD */
2310 OP(dd,f3) { illegal_1(z80); op_f3(z80); } /* DB DD */
2311 OP(dd,f4) { illegal_1(z80); op_f4(z80); } /* DB DD */
2312 OP(dd,f5) { illegal_1(z80); op_f5(z80); } /* DB DD */
2313 OP(dd,f6) { illegal_1(z80); op_f6(z80); } /* DB DD */
2314 OP(dd,f7) { illegal_1(z80); op_f7(z80); } /* DB DD */
2315
2316 OP(dd,f8) { illegal_1(z80); op_f8(z80); } /* DB DD */
2317 OP(dd,f9) { SP = IX; } /* LD SP,IX */
2318 OP(dd,fa) { illegal_1(z80); op_fa(z80); } /* DB DD */
2319 OP(dd,fb) { illegal_1(z80); op_fb(z80); } /* DB DD */
2320 OP(dd,fc) { illegal_1(z80); op_fc(z80); } /* DB DD */
2321 OP(dd,fd) { illegal_1(z80); op_fd(z80); } /* DB DD */
2322 OP(dd,fe) { illegal_1(z80); op_fe(z80); } /* DB DD */
2323 OP(dd,ff) { illegal_1(z80); op_ff(z80); } /* DB DD */
2324
2325 /**********************************************************
2326 * IY register related opcodes (FD prefix)
2327 **********************************************************/
2328 OP(fd,00) { illegal_1(z80); op_00(z80); } /* DB FD */
2329 OP(fd,01) { illegal_1(z80); op_01(z80); } /* DB FD */
2330 OP(fd,02) { illegal_1(z80); op_02(z80); } /* DB FD */
2331 OP(fd,03) { illegal_1(z80); op_03(z80); } /* DB FD */
2332 OP(fd,04) { illegal_1(z80); op_04(z80); } /* DB FD */
2333 OP(fd,05) { illegal_1(z80); op_05(z80); } /* DB FD */
2334 OP(fd,06) { illegal_1(z80); op_06(z80); } /* DB FD */
2335 OP(fd,07) { illegal_1(z80); op_07(z80); } /* DB FD */
2336
2337 OP(fd,08) { illegal_1(z80); op_08(z80); } /* DB FD */
2338 OP(fd,09) { add16(z80, &z80->m_iy, &z80->m_bc); } /* ADD IY,BC */
2339 OP(fd,0a) { illegal_1(z80); op_0a(z80); } /* DB FD */
2340 OP(fd,0b) { illegal_1(z80); op_0b(z80); } /* DB FD */
2341 OP(fd,0c) { illegal_1(z80); op_0c(z80); } /* DB FD */
2342 OP(fd,0d) { illegal_1(z80); op_0d(z80); } /* DB FD */
2343 OP(fd,0e) { illegal_1(z80); op_0e(z80); } /* DB FD */
2344 OP(fd,0f) { illegal_1(z80); op_0f(z80); } /* DB FD */
2345
2346 OP(fd,10) { illegal_1(z80); op_10(z80); } /* DB FD */
2347 OP(fd,11) { illegal_1(z80); op_11(z80); } /* DB FD */
2348 OP(fd,12) { illegal_1(z80); op_12(z80); } /* DB FD */
2349 OP(fd,13) { illegal_1(z80); op_13(z80); } /* DB FD */
2350 OP(fd,14) { illegal_1(z80); op_14(z80); } /* DB FD */
2351 OP(fd,15) { illegal_1(z80); op_15(z80); } /* DB FD */
2352 OP(fd,16) { illegal_1(z80); op_16(z80); } /* DB FD */
2353 OP(fd,17) { illegal_1(z80); op_17(z80); } /* DB FD */
2354
2355 OP(fd,18) { illegal_1(z80); op_18(z80); } /* DB FD */
2356 OP(fd,19) { add16(z80, &z80->m_iy, &z80->m_de); } /* ADD IY,DE */
2357 OP(fd,1a) { illegal_1(z80); op_1a(z80); } /* DB FD */
2358 OP(fd,1b) { illegal_1(z80); op_1b(z80); } /* DB FD */
2359 OP(fd,1c) { illegal_1(z80); op_1c(z80); } /* DB FD */
2360 OP(fd,1d) { illegal_1(z80); op_1d(z80); } /* DB FD */
2361 OP(fd,1e) { illegal_1(z80); op_1e(z80); } /* DB FD */
2362 OP(fd,1f) { illegal_1(z80); op_1f(z80); } /* DB FD */
2363
2364 OP(fd,20) { illegal_1(z80); op_20(z80); } /* DB FD */
2365 OP(fd,21) { IY = arg16(z80); } /* LD IY,w */
2366 OP(fd,22) { z80->m_ea = arg16(z80); wm16(z80, z80->m_ea, &z80->m_iy); WZ = z80->m_ea + 1; } /* LD (w),IY */
2367 OP(fd,23) { IY++; } /* INC IY */
2368 OP(fd,24) { HY = inc(z80, HY); } /* INC HY */
2369 OP(fd,25) { HY = dec(z80, HY); } /* DEC HY */
2370 OP(fd,26) { HY = arg(z80); } /* LD HY,n */
2371 OP(fd,27) { illegal_1(z80); op_27(z80); } /* DB FD */
2372
2373 OP(fd,28) { illegal_1(z80); op_28(z80); } /* DB FD */
2374 OP(fd,29) { add16(z80, &z80->m_iy, &z80->m_iy); } /* ADD IY,IY */
2375 OP(fd,2a) { z80->m_ea = arg16(z80); rm16(z80, z80->m_ea, &z80->m_iy); WZ = z80->m_ea + 1; } /* LD IY,(w) */
2376 OP(fd,2b) { IY--; } /* DEC IY */
2377 OP(fd,2c) { LY = inc(z80, LY); } /* INC LY */
2378 OP(fd,2d) { LY = dec(z80, LY); } /* DEC LY */
2379 OP(fd,2e) { LY = arg(z80); } /* LD LY,n */
2380 OP(fd,2f) { illegal_1(z80); op_2f(z80); } /* DB FD */
2381
2382 OP(fd,30) { illegal_1(z80); op_30(z80); } /* DB FD */
2383 OP(fd,31) { illegal_1(z80); op_31(z80); } /* DB FD */
2384 OP(fd,32) { illegal_1(z80); op_32(z80); } /* DB FD */
2385 OP(fd,33) { illegal_1(z80); op_33(z80); } /* DB FD */
2386 OP(fd,34) { eay(z80); wm(z80, z80->m_ea, inc(z80, rm(z80, z80->m_ea))); } /* INC (IY+o) */
2387 OP(fd,35) { eay(z80); wm(z80, z80->m_ea, dec(z80, rm(z80, z80->m_ea))); } /* DEC (IY+o) */
2388 OP(fd,36) { eay(z80); wm(z80, z80->m_ea, arg(z80)); } /* LD (IY+o),n */
2389 OP(fd,37) { illegal_1(z80); op_37(z80); } /* DB FD */
2390
2391 OP(fd,38) { illegal_1(z80); op_38(z80); } /* DB FD */
2392 OP(fd,39) { add16(z80, &z80->m_iy, &z80->m_sp); } /* ADD IY,SP */
2393 OP(fd,3a) { illegal_1(z80); op_3a(z80); } /* DB FD */
2394 OP(fd,3b) { illegal_1(z80); op_3b(z80); } /* DB FD */
2395 OP(fd,3c) { illegal_1(z80); op_3c(z80); } /* DB FD */
2396 OP(fd,3d) { illegal_1(z80); op_3d(z80); } /* DB FD */
2397 OP(fd,3e) { illegal_1(z80); op_3e(z80); } /* DB FD */
2398 OP(fd,3f) { illegal_1(z80); op_3f(z80); } /* DB FD */
2399
2400 OP(fd,40) { illegal_1(z80); op_40(z80); } /* DB FD */
2401 OP(fd,41) { illegal_1(z80); op_41(z80); } /* DB FD */
2402 OP(fd,42) { illegal_1(z80); op_42(z80); } /* DB FD */
2403 OP(fd,43) { illegal_1(z80); op_43(z80); } /* DB FD */
2404 OP(fd,44) { B = HY; } /* LD B,HY */
2405 OP(fd,45) { B = LY; } /* LD B,LY */
2406 OP(fd,46) { eay(z80); B = rm(z80, z80->m_ea); } /* LD B,(IY+o) */
2407 OP(fd,47) { illegal_1(z80); op_47(z80); } /* DB FD */
2408
2409 OP(fd,48) { illegal_1(z80); op_48(z80); } /* DB FD */
2410 OP(fd,49) { illegal_1(z80); op_49(z80); } /* DB FD */
2411 OP(fd,4a) { illegal_1(z80); op_4a(z80); } /* DB FD */
2412 OP(fd,4b) { illegal_1(z80); op_4b(z80); } /* DB FD */
2413 OP(fd,4c) { C = HY; } /* LD C,HY */
2414 OP(fd,4d) { C = LY; } /* LD C,LY */
2415 OP(fd,4e) { eay(z80); C = rm(z80, z80->m_ea); } /* LD C,(IY+o) */
2416 OP(fd,4f) { illegal_1(z80); op_4f(z80); } /* DB FD */
2417
2418 OP(fd,50) { illegal_1(z80); op_50(z80); } /* DB FD */
2419 OP(fd,51) { illegal_1(z80); op_51(z80); } /* DB FD */
2420 OP(fd,52) { illegal_1(z80); op_52(z80); } /* DB FD */
2421 OP(fd,53) { illegal_1(z80); op_53(z80); } /* DB FD */
2422 OP(fd,54) { D = HY; } /* LD D,HY */
2423 OP(fd,55) { D = LY; } /* LD D,LY */
2424 OP(fd,56) { eay(z80); D = rm(z80, z80->m_ea); } /* LD D,(IY+o) */
2425 OP(fd,57) { illegal_1(z80); op_57(z80); } /* DB FD */
2426
2427 OP(fd,58) { illegal_1(z80); op_58(z80); } /* DB FD */
2428 OP(fd,59) { illegal_1(z80); op_59(z80); } /* DB FD */
2429 OP(fd,5a) { illegal_1(z80); op_5a(z80); } /* DB FD */
2430 OP(fd,5b) { illegal_1(z80); op_5b(z80); } /* DB FD */
2431 OP(fd,5c) { E = HY; } /* LD E,HY */
2432 OP(fd,5d) { E = LY; } /* LD E,LY */
2433 OP(fd,5e) { eay(z80); E = rm(z80, z80->m_ea); } /* LD E,(IY+o) */
2434 OP(fd,5f) { illegal_1(z80); op_5f(z80); } /* DB FD */
2435
2436 OP(fd,60) { HY = B; } /* LD HY,B */
2437 OP(fd,61) { HY = C; } /* LD HY,C */
2438 OP(fd,62) { HY = D; } /* LD HY,D */
2439 OP(fd,63) { HY = E; } /* LD HY,E */
2440 OP(fd,64) { } /* LD HY,HY */
2441 OP(fd,65) { HY = LY; } /* LD HY,LY */
2442 OP(fd,66) { eay(z80); H = rm(z80, z80->m_ea); } /* LD H,(IY+o) */
2443 OP(fd,67) { HY = A; } /* LD HY,A */
2444
2445 OP(fd,68) { LY = B; } /* LD LY,B */
2446 OP(fd,69) { LY = C; } /* LD LY,C */
2447 OP(fd,6a) { LY = D; } /* LD LY,D */
2448 OP(fd,6b) { LY = E; } /* LD LY,E */
2449 OP(fd,6c) { LY = HY; } /* LD LY,HY */
2450 OP(fd,6d) { } /* LD LY,LY */
2451 OP(fd,6e) { eay(z80); L = rm(z80, z80->m_ea); } /* LD L,(IY+o) */
2452 OP(fd,6f) { LY = A; } /* LD LY,A */
2453
2454 OP(fd,70) { eay(z80); wm(z80, z80->m_ea, B); } /* LD (IY+o),B */
2455 OP(fd,71) { eay(z80); wm(z80, z80->m_ea, C); } /* LD (IY+o),C */
2456 OP(fd,72) { eay(z80); wm(z80, z80->m_ea, D); } /* LD (IY+o),D */
2457 OP(fd,73) { eay(z80); wm(z80, z80->m_ea, E); } /* LD (IY+o),E */
2458 OP(fd,74) { eay(z80); wm(z80, z80->m_ea, H); } /* LD (IY+o),H */
2459 OP(fd,75) { eay(z80); wm(z80, z80->m_ea, L); } /* LD (IY+o),L */
2460 OP(fd,76) { illegal_1(z80); op_76(z80); } /* DB FD */
2461 OP(fd,77) { eay(z80); wm(z80, z80->m_ea, A); } /* LD (IY+o),A */
2462
2463 OP(fd,78) { illegal_1(z80); op_78(z80); } /* DB FD */
2464 OP(fd,79) { illegal_1(z80); op_79(z80); } /* DB FD */
2465 OP(fd,7a) { illegal_1(z80); op_7a(z80); } /* DB FD */
2466 OP(fd,7b) { illegal_1(z80); op_7b(z80); } /* DB FD */
2467 OP(fd,7c) { A = HY; } /* LD A,HY */
2468 OP(fd,7d) { A = LY; } /* LD A,LY */
2469 OP(fd,7e) { eay(z80); A = rm(z80, z80->m_ea); } /* LD A,(IY+o) */
2470 OP(fd,7f) { illegal_1(z80); op_7f(z80); } /* DB FD */
2471
2472 OP(fd,80) { illegal_1(z80); op_80(z80); } /* DB FD */
2473 OP(fd,81) { illegal_1(z80); op_81(z80); } /* DB FD */
2474 OP(fd,82) { illegal_1(z80); op_82(z80); } /* DB FD */
2475 OP(fd,83) { illegal_1(z80); op_83(z80); } /* DB FD */
2476 OP(fd,84) { add_a(z80, HY); } /* ADD A,HY */
2477 OP(fd,85) { add_a(z80, LY); } /* ADD A,LY */
2478 OP(fd,86) { eay(z80); add_a(z80, rm(z80, z80->m_ea)); } /* ADD A,(IY+o) */
2479 OP(fd,87) { illegal_1(z80); op_87(z80); } /* DB FD */
2480
2481 OP(fd,88) { illegal_1(z80); op_88(z80); } /* DB FD */
2482 OP(fd,89) { illegal_1(z80); op_89(z80); } /* DB FD */
2483 OP(fd,8a) { illegal_1(z80); op_8a(z80); } /* DB FD */
2484 OP(fd,8b) { illegal_1(z80); op_8b(z80); } /* DB FD */
2485 OP(fd,8c) { adc_a(z80, HY); } /* ADC A,HY */
2486 OP(fd,8d) { adc_a(z80, LY); } /* ADC A,LY */
2487 OP(fd,8e) { eay(z80); adc_a(z80, rm(z80, z80->m_ea)); } /* ADC A,(IY+o) */
2488 OP(fd,8f) { illegal_1(z80); op_8f(z80); } /* DB FD */
2489
2490 OP(fd,90) { illegal_1(z80); op_90(z80); } /* DB FD */
2491 OP(fd,91) { illegal_1(z80); op_91(z80); } /* DB FD */
2492 OP(fd,92) { illegal_1(z80); op_92(z80); } /* DB FD */
2493 OP(fd,93) { illegal_1(z80); op_93(z80); } /* DB FD */
2494 OP(fd,94) { sub(z80, HY); } /* SUB HY */
2495 OP(fd,95) { sub(z80, LY); } /* SUB LY */
2496 OP(fd,96) { eay(z80); sub(z80, rm(z80, z80->m_ea)); } /* SUB (IY+o) */
2497 OP(fd,97) { illegal_1(z80); op_97(z80); } /* DB FD */
2498
2499 OP(fd,98) { illegal_1(z80); op_98(z80); } /* DB FD */
2500 OP(fd,99) { illegal_1(z80); op_99(z80); } /* DB FD */
2501 OP(fd,9a) { illegal_1(z80); op_9a(z80); } /* DB FD */
2502 OP(fd,9b) { illegal_1(z80); op_9b(z80); } /* DB FD */
2503 OP(fd,9c) { sbc_a(z80, HY); } /* SBC A,HY */
2504 OP(fd,9d) { sbc_a(z80, LY); } /* SBC A,LY */
2505 OP(fd,9e) { eay(z80); sbc_a(z80, rm(z80, z80->m_ea)); } /* SBC A,(IY+o) */
2506 OP(fd,9f) { illegal_1(z80); op_9f(z80); } /* DB FD */
2507
2508 OP(fd,a0) { illegal_1(z80); op_a0(z80); } /* DB FD */
2509 OP(fd,a1) { illegal_1(z80); op_a1(z80); } /* DB FD */
2510 OP(fd,a2) { illegal_1(z80); op_a2(z80); } /* DB FD */
2511 OP(fd,a3) { illegal_1(z80); op_a3(z80); } /* DB FD */
2512 OP(fd,a4) { and_a(z80, HY); } /* AND HY */
2513 OP(fd,a5) { and_a(z80, LY); } /* AND LY */
2514 OP(fd,a6) { eay(z80); and_a(z80, rm(z80, z80->m_ea)); } /* AND (IY+o) */
2515 OP(fd,a7) { illegal_1(z80); op_a7(z80); } /* DB FD */
2516
2517 OP(fd,a8) { illegal_1(z80); op_a8(z80); } /* DB FD */
2518 OP(fd,a9) { illegal_1(z80); op_a9(z80); } /* DB FD */
2519 OP(fd,aa) { illegal_1(z80); op_aa(z80); } /* DB FD */
2520 OP(fd,ab) { illegal_1(z80); op_ab(z80); } /* DB FD */
2521 OP(fd,ac) { xor_a(z80, HY); } /* XOR HY */
2522 OP(fd,ad) { xor_a(z80, LY); } /* XOR LY */
2523 OP(fd,ae) { eay(z80); xor_a(z80, rm(z80, z80->m_ea)); } /* XOR (IY+o) */
2524 OP(fd,af) { illegal_1(z80); op_af(z80); } /* DB FD */
2525
2526 OP(fd,b0) { illegal_1(z80); op_b0(z80); } /* DB FD */
2527 OP(fd,b1) { illegal_1(z80); op_b1(z80); } /* DB FD */
2528 OP(fd,b2) { illegal_1(z80); op_b2(z80); } /* DB FD */
2529 OP(fd,b3) { illegal_1(z80); op_b3(z80); } /* DB FD */
2530 OP(fd,b4) { or_a(z80, HY); } /* OR HY */
2531 OP(fd,b5) { or_a(z80, LY); } /* OR LY */
2532 OP(fd,b6) { eay(z80); or_a(z80, rm(z80, z80->m_ea)); } /* OR (IY+o) */
2533 OP(fd,b7) { illegal_1(z80); op_b7(z80); } /* DB FD */
2534
2535 OP(fd,b8) { illegal_1(z80); op_b8(z80); } /* DB FD */
2536 OP(fd,b9) { illegal_1(z80); op_b9(z80); } /* DB FD */
2537 OP(fd,ba) { illegal_1(z80); op_ba(z80); } /* DB FD */
2538 OP(fd,bb) { illegal_1(z80); op_bb(z80); } /* DB FD */
2539 OP(fd,bc) { cp(z80, HY); } /* CP HY */
2540 OP(fd,bd) { cp(z80, LY); } /* CP LY */
2541 OP(fd,be) { eay(z80); cp(z80, rm(z80, z80->m_ea)); } /* CP (IY+o) */
2542 OP(fd,bf) { illegal_1(z80); op_bf(z80); } /* DB FD */
2543
2544 OP(fd,c0) { illegal_1(z80); op_c0(z80); } /* DB FD */
2545 OP(fd,c1) { illegal_1(z80); op_c1(z80); } /* DB FD */
2546 OP(fd,c2) { illegal_1(z80); op_c2(z80); } /* DB FD */
2547 OP(fd,c3) { illegal_1(z80); op_c3(z80); } /* DB FD */
2548 OP(fd,c4) { illegal_1(z80); op_c4(z80); } /* DB FD */
2549 OP(fd,c5) { illegal_1(z80); op_c5(z80); } /* DB FD */
2550 OP(fd,c6) { illegal_1(z80); op_c6(z80); } /* DB FD */
2551 OP(fd,c7) { illegal_1(z80); op_c7(z80); } /* DB FD */
2552
2553 OP(fd,c8) { illegal_1(z80); op_c8(z80); } /* DB FD */
2554 OP(fd,c9) { illegal_1(z80); op_c9(z80); } /* DB FD */
2555 OP(fd,ca) { illegal_1(z80); op_ca(z80); } /* DB FD */
2556 OP(fd,cb) { eay(z80); EXEC(xycb,arg(z80)); } /* ** FD CB xx */
2557 OP(fd,cc) { illegal_1(z80); op_cc(z80); } /* DB FD */
2558 OP(fd,cd) { illegal_1(z80); op_cd(z80); } /* DB FD */
2559 OP(fd,ce) { illegal_1(z80); op_ce(z80); } /* DB FD */
2560 OP(fd,cf) { illegal_1(z80); op_cf(z80); } /* DB FD */
2561
2562 OP(fd,d0) { illegal_1(z80); op_d0(z80); } /* DB FD */
2563 OP(fd,d1) { illegal_1(z80); op_d1(z80); } /* DB FD */
2564 OP(fd,d2) { illegal_1(z80); op_d2(z80); } /* DB FD */
2565 OP(fd,d3) { illegal_1(z80); op_d3(z80); } /* DB FD */
2566 OP(fd,d4) { illegal_1(z80); op_d4(z80); } /* DB FD */
2567 OP(fd,d5) { illegal_1(z80); op_d5(z80); } /* DB FD */
2568 OP(fd,d6) { illegal_1(z80); op_d6(z80); } /* DB FD */
2569 OP(fd,d7) { illegal_1(z80); op_d7(z80); } /* DB FD */
2570
2571 OP(fd,d8) { illegal_1(z80); op_d8(z80); } /* DB FD */
2572 OP(fd,d9) { illegal_1(z80); op_d9(z80); } /* DB FD */
2573 OP(fd,da) { illegal_1(z80); op_da(z80); } /* DB FD */
2574 OP(fd,db) { illegal_1(z80); op_db(z80); } /* DB FD */
2575 OP(fd,dc) { illegal_1(z80); op_dc(z80); } /* DB FD */
2576 OP(fd,dd) { illegal_1(z80); op_dd(z80); } /* DB FD */
2577 OP(fd,de) { illegal_1(z80); op_de(z80); } /* DB FD */
2578 OP(fd,df) { illegal_1(z80); op_df(z80); } /* DB FD */
2579
2580 OP(fd,e0) { illegal_1(z80); op_e0(z80); } /* DB FD */
2581 OP(fd,e1) { pop(z80, &z80->m_iy); } /* POP IY */
2582 OP(fd,e2) { illegal_1(z80); op_e2(z80); } /* DB FD */
2583 OP(fd,e3) { ex_sp(z80, &z80->m_iy); } /* EX (SP),IY */
2584 OP(fd,e4) { illegal_1(z80); op_e4(z80); } /* DB FD */
2585 OP(fd,e5) { push(z80, &z80->m_iy); } /* PUSH IY */
2586 OP(fd,e6) { illegal_1(z80); op_e6(z80); } /* DB FD */
2587 OP(fd,e7) { illegal_1(z80); op_e7(z80); } /* DB FD */
2588
2589 OP(fd,e8) { illegal_1(z80); op_e8(z80); } /* DB FD */
2590 OP(fd,e9) { PC = IY; } /* JP (IY) */
2591 OP(fd,ea) { illegal_1(z80); op_ea(z80); } /* DB FD */
2592 OP(fd,eb) { illegal_1(z80); op_eb(z80); } /* DB FD */
2593 OP(fd,ec) { illegal_1(z80); op_ec(z80); } /* DB FD */
2594 OP(fd,ed) { illegal_1(z80); op_ed(z80); } /* DB FD */
2595 OP(fd,ee) { illegal_1(z80); op_ee(z80); } /* DB FD */
2596 OP(fd,ef) { illegal_1(z80); op_ef(z80); } /* DB FD */
2597
2598 OP(fd,f0) { illegal_1(z80); op_f0(z80); } /* DB FD */
2599 OP(fd,f1) { illegal_1(z80); op_f1(z80); } /* DB FD */
2600 OP(fd,f2) { illegal_1(z80); op_f2(z80); } /* DB FD */
2601 OP(fd,f3) { illegal_1(z80); op_f3(z80); } /* DB FD */
2602 OP(fd,f4) { illegal_1(z80); op_f4(z80); } /* DB FD */
2603 OP(fd,f5) { illegal_1(z80); op_f5(z80); } /* DB FD */
2604 OP(fd,f6) { illegal_1(z80); op_f6(z80); } /* DB FD */
2605 OP(fd,f7) { illegal_1(z80); op_f7(z80); } /* DB FD */
2606
2607 OP(fd,f8) { illegal_1(z80); op_f8(z80); } /* DB FD */
2608 OP(fd,f9) { SP = IY; } /* LD SP,IY */
2609 OP(fd,fa) { illegal_1(z80); op_fa(z80); } /* DB FD */
2610 OP(fd,fb) { illegal_1(z80); op_fb(z80); } /* DB FD */
2611 OP(fd,fc) { illegal_1(z80); op_fc(z80); } /* DB FD */
2612 OP(fd,fd) { illegal_1(z80); op_fd(z80); } /* DB FD */
2613 OP(fd,fe) { illegal_1(z80); op_fe(z80); } /* DB FD */
2614 OP(fd,ff) { illegal_1(z80); op_ff(z80); } /* DB FD */
2615
2616 OP(illegal,2)
2617 {
2618 warning("Z80 ill. opcode $ed $%02x\n",
2619 rm(z80, (PCD-1)&0xffff));
2620 }
2621
2622 /**********************************************************
2623 * special opcodes (ED prefix)
2624 **********************************************************/
2625 OP(ed,00) { illegal_2(z80); } /* DB ED */
2626 OP(ed,01) { illegal_2(z80); } /* DB ED */
2627 OP(ed,02) { illegal_2(z80); } /* DB ED */
2628 OP(ed,03) { illegal_2(z80); } /* DB ED */
2629 OP(ed,04) { illegal_2(z80); } /* DB ED */
2630 OP(ed,05) { illegal_2(z80); } /* DB ED */
2631 OP(ed,06) { illegal_2(z80); } /* DB ED */
2632 OP(ed,07) { illegal_2(z80); } /* DB ED */
2633
2634 OP(ed,08) { illegal_2(z80); } /* DB ED */
2635 OP(ed,09) { illegal_2(z80); } /* DB ED */
2636 OP(ed,0a) { illegal_2(z80); } /* DB ED */
2637 OP(ed,0b) { illegal_2(z80); } /* DB ED */
2638 OP(ed,0c) { illegal_2(z80); } /* DB ED */
2639 OP(ed,0d) { illegal_2(z80); } /* DB ED */
2640 OP(ed,0e) { illegal_2(z80); } /* DB ED */
2641 OP(ed,0f) { illegal_2(z80); } /* DB ED */
2642
2643 OP(ed,10) { illegal_2(z80); } /* DB ED */
2644 OP(ed,11) { illegal_2(z80); } /* DB ED */
2645 OP(ed,12) { illegal_2(z80); } /* DB ED */
2646 OP(ed,13) { illegal_2(z80); } /* DB ED */
2647 OP(ed,14) { illegal_2(z80); } /* DB ED */
2648 OP(ed,15) { illegal_2(z80); } /* DB ED */
2649 OP(ed,16) { illegal_2(z80); } /* DB ED */
2650 OP(ed,17) { illegal_2(z80); } /* DB ED */
2651
2652 OP(ed,18) { illegal_2(z80); } /* DB ED */
2653 OP(ed,19) { illegal_2(z80); } /* DB ED */
2654 OP(ed,1a) { illegal_2(z80); } /* DB ED */
2655 OP(ed,1b) { illegal_2(z80); } /* DB ED */
2656 OP(ed,1c) { illegal_2(z80); } /* DB ED */
2657 OP(ed,1d) { illegal_2(z80); } /* DB ED */
2658 OP(ed,1e) { illegal_2(z80); } /* DB ED */
2659 OP(ed,1f) { illegal_2(z80); } /* DB ED */
2660
2661 OP(ed,20) { illegal_2(z80); } /* DB ED */
2662 OP(ed,21) { illegal_2(z80); } /* DB ED */
2663 OP(ed,22) { illegal_2(z80); } /* DB ED */
2664 OP(ed,23) { illegal_2(z80); } /* DB ED */
2665 OP(ed,24) { illegal_2(z80); } /* DB ED */
2666 OP(ed,25) { illegal_2(z80); } /* DB ED */
2667 OP(ed,26) { illegal_2(z80); } /* DB ED */
2668 OP(ed,27) { illegal_2(z80); } /* DB ED */
2669
2670 OP(ed,28) { illegal_2(z80); } /* DB ED */
2671 OP(ed,29) { illegal_2(z80); } /* DB ED */
2672 OP(ed,2a) { illegal_2(z80); } /* DB ED */
2673 OP(ed,2b) { illegal_2(z80); } /* DB ED */
2674 OP(ed,2c) { illegal_2(z80); } /* DB ED */
2675 OP(ed,2d) { illegal_2(z80); } /* DB ED */
2676 OP(ed,2e) { illegal_2(z80); } /* DB ED */
2677 OP(ed,2f) { illegal_2(z80); } /* DB ED */
2678
2679 OP(ed,30) { illegal_2(z80); } /* DB ED */
2680 OP(ed,31) { illegal_2(z80); } /* DB ED */
2681 OP(ed,32) { illegal_2(z80); } /* DB ED */
2682 OP(ed,33) { illegal_2(z80); } /* DB ED */
2683 OP(ed,34) { illegal_2(z80); } /* DB ED */
2684 OP(ed,35) { illegal_2(z80); } /* DB ED */
2685 OP(ed,36) { illegal_2(z80); } /* DB ED */
2686 OP(ed,37) { illegal_2(z80); } /* DB ED */
2687
2688 OP(ed,38) { illegal_2(z80); } /* DB ED */
2689 OP(ed,39) { illegal_2(z80); } /* DB ED */
2690 OP(ed,3a) { illegal_2(z80); } /* DB ED */
2691 OP(ed,3b) { illegal_2(z80); } /* DB ED */
2692 OP(ed,3c) { illegal_2(z80); } /* DB ED */
2693 OP(ed,3d) { illegal_2(z80); } /* DB ED */
2694 OP(ed,3e) { illegal_2(z80); } /* DB ED */
2695 OP(ed,3f) { illegal_2(z80); } /* DB ED */
2696
2697 OP(ed,40) { B = in(z80, BC); F = (F & CF) | SZP[B]; } /* IN B,(C) */
2698 OP(ed,41) { out(z80, BC, B); } /* OUT (C),B */
2699 OP(ed,42) { sbc_hl(z80, &z80->m_bc); } /* SBC HL,BC */
2700 OP(ed,43) { z80->m_ea = arg16(z80); wm16(z80, z80->m_ea, &z80->m_bc); WZ = z80->m_ea + 1; } /* LD (w),BC */
2701 OP(ed,44) { neg(z80); } /* NEG */
2702 OP(ed,45) { retn(z80); } /* RETN */
2703 OP(ed,46) { z80->m_im = 0; } /* IM 0 */
2704 OP(ed,47) { ld_i_a(z80); } /* LD i,A */
2705
2706 OP(ed,48) { C = in(z80, BC); F = (F & CF) | SZP[C]; } /* IN C,(C) */
2707 OP(ed,49) { out(z80, BC, C); } /* OUT (C),C */
2708 OP(ed,4a) { adc_hl(z80, &z80->m_bc); } /* ADC HL,BC */
2709 OP(ed,4b) { z80->m_ea = arg16(z80); rm16(z80, z80->m_ea, &z80->m_bc); WZ = z80->m_ea + 1; } /* LD BC,(w) */
2710 OP(ed,4c) { neg(z80); } /* NEG */
2711 OP(ed,4d) { reti(z80); } /* RETI */
2712 OP(ed,4e) { z80->m_im = 0; } /* IM 0 */
2713 OP(ed,4f) { ld_r_a(z80); } /* LD r,A */
2714
2715 OP(ed,50) { D = in(z80, BC); F = (F & CF) | SZP[D]; } /* IN D,(C) */
2716 OP(ed,51) { out(z80, BC, D); } /* OUT (C),D */
2717 OP(ed,52) { sbc_hl(z80, &z80->m_de); } /* SBC HL,DE */
2718 OP(ed,53) { z80->m_ea = arg16(z80); wm16(z80, z80->m_ea, &z80->m_de); WZ = z80->m_ea + 1; } /* LD (w),DE */
2719 OP(ed,54) { neg(z80); } /* NEG */
2720 OP(ed,55) { retn(z80); } /* RETN */
2721 OP(ed,56) { z80->m_im = 1; } /* IM 1 */
2722 OP(ed,57) { ld_a_i(z80); } /* LD A,i */
2723
2724 OP(ed,58) { E = in(z80, BC); F = (F & CF) | SZP[E]; } /* IN E,(C) */
2725 OP(ed,59) { out(z80, BC, E); } /* OUT (C),E */
2726 OP(ed,5a) { adc_hl(z80, &z80->m_de); } /* ADC HL,DE */
2727 OP(ed,5b) { z80->m_ea = arg16(z80); rm16(z80, z80->m_ea, &z80->m_de); WZ = z80->m_ea + 1; } /* LD DE,(w) */
2728 OP(ed,5c) { neg(z80); } /* NEG */
2729 OP(ed,5d) { reti(z80); } /* RETI */
2730 OP(ed,5e) { z80->m_im = 2; } /* IM 2 */
2731 OP(ed,5f) { ld_a_r(z80); } /* LD A,r */
2732
2733 OP(ed,60) { H = in(z80, BC); F = (F & CF) | SZP[H]; } /* IN H,(C) */
2734 OP(ed,61) { out(z80, BC, H); } /* OUT (C),H */
2735 OP(ed,62) { sbc_hl(z80, &z80->m_hl); } /* SBC HL,HL */
2736 OP(ed,63) { z80->m_ea = arg16(z80); wm16(z80, z80->m_ea, &z80->m_hl); WZ = z80->m_ea + 1; } /* LD (w),HL */
2737 OP(ed,64) { neg(z80); } /* NEG */
2738 OP(ed,65) { retn(z80); } /* RETN */
2739 OP(ed,66) { z80->m_im = 0; } /* IM 0 */
2740 OP(ed,67) { rrd(z80); } /* RRD (HL) */
2741
2742 OP(ed,68) { L = in(z80, BC); F = (F & CF) | SZP[L]; } /* IN L,(C) */
2743 OP(ed,69) { out(z80, BC, L); } /* OUT (C),L */
2744 OP(ed,6a) { adc_hl(z80, &z80->m_hl); } /* ADC HL,HL */
2745 OP(ed,6b) { z80->m_ea = arg16(z80); rm16(z80, z80->m_ea, &z80->m_hl); WZ = z80->m_ea + 1; } /* LD HL,(w) */
2746 OP(ed,6c) { neg(z80); } /* NEG */
2747 OP(ed,6d) { reti(z80); } /* RETI */
2748 OP(ed,6e) { z80->m_im = 0; } /* IM 0 */
2749 OP(ed,6f) { rld(z80); } /* RLD (HL) */
2750
2751 OP(ed,70) { uint8_t res = in(z80, BC); F = (F & CF) | SZP[res]; } /* IN 0,(C) */
2752 OP(ed,71) { out(z80, BC, 0); } /* OUT (C),0 */
2753 OP(ed,72) { sbc_hl(z80, &z80->m_sp); } /* SBC HL,SP */
2754 OP(ed,73) { z80->m_ea = arg16(z80); wm16(z80, z80->m_ea, &z80->m_sp); WZ = z80->m_ea + 1; } /* LD (w),SP */
2755 OP(ed,74) { neg(z80); } /* NEG */
2756 OP(ed,75) { retn(z80); } /* RETN */
2757 OP(ed,76) { z80->m_im = 1; } /* IM 1 */
2758 OP(ed,77) { illegal_2(z80); } /* DB ED,77 */
2759
2760 OP(ed,78) { A = in(z80, BC); F = (F & CF) | SZP[A]; WZ = BC + 1; } /* IN A,(C) */
2761 OP(ed,79) { out(z80, BC, A); WZ = BC + 1; } /* OUT (C),A */
2762 OP(ed,7a) { adc_hl(z80, &z80->m_sp); } /* ADC HL,SP */
2763 OP(ed,7b) { z80->m_ea = arg16(z80); rm16(z80, z80->m_ea, &z80->m_sp); WZ = z80->m_ea + 1; } /* LD SP,(w) */
2764 OP(ed,7c) { neg(z80); } /* NEG */
2765 OP(ed,7d) { reti(z80); } /* RETI */
2766 OP(ed,7e) { z80->m_im = 2; } /* IM 2 */
2767 OP(ed,7f) { illegal_2(z80); } /* DB ED,7F */
2768
2769 OP(ed,80) { illegal_2(z80); } /* DB ED */
2770 OP(ed,81) { illegal_2(z80); } /* DB ED */
2771 OP(ed,82) { illegal_2(z80); } /* DB ED */
2772 OP(ed,83) { illegal_2(z80); } /* DB ED */
2773 OP(ed,84) { illegal_2(z80); } /* DB ED */
2774 OP(ed,85) { illegal_2(z80); } /* DB ED */
2775 OP(ed,86) { illegal_2(z80); } /* DB ED */
2776 OP(ed,87) { illegal_2(z80); } /* DB ED */
2777
2778 OP(ed,88) { illegal_2(z80); } /* DB ED */
2779 OP(ed,89) { illegal_2(z80); } /* DB ED */
2780 OP(ed,8a) { illegal_2(z80); } /* DB ED */
2781 OP(ed,8b) { illegal_2(z80); } /* DB ED */
2782 OP(ed,8c) { illegal_2(z80); } /* DB ED */
2783 OP(ed,8d) { illegal_2(z80); } /* DB ED */
2784 OP(ed,8e) { illegal_2(z80); } /* DB ED */
2785 OP(ed,8f) { illegal_2(z80); } /* DB ED */
2786
2787 OP(ed,90) { illegal_2(z80); } /* DB ED */
2788 OP(ed,91) { illegal_2(z80); } /* DB ED */
2789 OP(ed,92) { illegal_2(z80); } /* DB ED */
2790 OP(ed,93) { illegal_2(z80); } /* DB ED */
2791 OP(ed,94) { illegal_2(z80); } /* DB ED */
2792 OP(ed,95) { illegal_2(z80); } /* DB ED */
2793 OP(ed,96) { illegal_2(z80); } /* DB ED */
2794 OP(ed,97) { illegal_2(z80); } /* DB ED */
2795
2796 OP(ed,98) { illegal_2(z80); } /* DB ED */
2797 OP(ed,99) { illegal_2(z80); } /* DB ED */
2798 OP(ed,9a) { illegal_2(z80); } /* DB ED */
2799 OP(ed,9b) { illegal_2(z80); } /* DB ED */
2800 OP(ed,9c) { illegal_2(z80); } /* DB ED */
2801 OP(ed,9d) { illegal_2(z80); } /* DB ED */
2802 OP(ed,9e) { illegal_2(z80); } /* DB ED */
2803 OP(ed,9f) { illegal_2(z80); } /* DB ED */
2804
2805 OP(ed,a0) { ldi(z80); } /* LDI */
2806 OP(ed,a1) { cpi(z80); } /* CPI */
2807 OP(ed,a2) { ini(z80); } /* INI */
2808 OP(ed,a3) { outi(z80); } /* OUTI */
2809 OP(ed,a4) { illegal_2(z80); } /* DB ED */
2810 OP(ed,a5) { illegal_2(z80); } /* DB ED */
2811 OP(ed,a6) { illegal_2(z80); } /* DB ED */
2812 OP(ed,a7) { illegal_2(z80); } /* DB ED */
2813
2814 OP(ed,a8) { ldd(z80); } /* LDD */
2815 OP(ed,a9) { cpd(z80); } /* CPD */
2816 OP(ed,aa) { ind(z80); } /* IND */
2817 OP(ed,ab) { outd(z80); } /* OUTD */
2818 OP(ed,ac) { illegal_2(z80); } /* DB ED */
2819 OP(ed,ad) { illegal_2(z80); } /* DB ED */
2820 OP(ed,ae) { illegal_2(z80); } /* DB ED */
2821 OP(ed,af) { illegal_2(z80); } /* DB ED */
2822
2823 OP(ed,b0) { ldir(z80); } /* LDIR */
2824 OP(ed,b1) { cpir(z80); } /* CPIR */
2825 OP(ed,b2) { inir(z80); } /* INIR */
2826 OP(ed,b3) { otir(z80); } /* OTIR */
2827 OP(ed,b4) { illegal_2(z80); } /* DB ED */
2828 OP(ed,b5) { illegal_2(z80); } /* DB ED */
2829 OP(ed,b6) { illegal_2(z80); } /* DB ED */
2830 OP(ed,b7) { illegal_2(z80); } /* DB ED */
2831
2832 OP(ed,b8) { lddr(z80); } /* LDDR */
2833 OP(ed,b9) { cpdr(z80); } /* CPDR */
2834 OP(ed,ba) { indr(z80); } /* INDR */
2835 OP(ed,bb) { otdr(z80); } /* OTDR */
2836 OP(ed,bc) { illegal_2(z80); } /* DB ED */
2837 OP(ed,bd) { illegal_2(z80); } /* DB ED */
2838 OP(ed,be) { illegal_2(z80); } /* DB ED */
2839 OP(ed,bf) { illegal_2(z80); } /* DB ED */
2840
2841 OP(ed,c0) { illegal_2(z80); } /* DB ED */
2842 OP(ed,c1) { illegal_2(z80); } /* DB ED */
2843 OP(ed,c2) { illegal_2(z80); } /* DB ED */
2844 OP(ed,c3) { illegal_2(z80); } /* DB ED */
2845 OP(ed,c4) { illegal_2(z80); } /* DB ED */
2846 OP(ed,c5) { illegal_2(z80); } /* DB ED */
2847 OP(ed,c6) { illegal_2(z80); } /* DB ED */
2848 OP(ed,c7) { illegal_2(z80); } /* DB ED */
2849
2850 OP(ed,c8) { illegal_2(z80); } /* DB ED */
2851 OP(ed,c9) { illegal_2(z80); } /* DB ED */
2852 OP(ed,ca) { illegal_2(z80); } /* DB ED */
2853 OP(ed,cb) { illegal_2(z80); } /* DB ED */
2854 OP(ed,cc) { illegal_2(z80); } /* DB ED */
2855 OP(ed,cd) { illegal_2(z80); } /* DB ED */
2856 OP(ed,ce) { illegal_2(z80); } /* DB ED */
2857 OP(ed,cf) { illegal_2(z80); } /* DB ED */
2858
2859 OP(ed,d0) { illegal_2(z80); } /* DB ED */
2860 OP(ed,d1) { illegal_2(z80); } /* DB ED */
2861 OP(ed,d2) { illegal_2(z80); } /* DB ED */
2862 OP(ed,d3) { illegal_2(z80); } /* DB ED */
2863 OP(ed,d4) { illegal_2(z80); } /* DB ED */
2864 OP(ed,d5) { illegal_2(z80); } /* DB ED */
2865 OP(ed,d6) { illegal_2(z80); } /* DB ED */
2866 OP(ed,d7) { illegal_2(z80); } /* DB ED */
2867
2868 OP(ed,d8) { illegal_2(z80); } /* DB ED */
2869 OP(ed,d9) { illegal_2(z80); } /* DB ED */
2870 OP(ed,da) { illegal_2(z80); } /* DB ED */
2871 OP(ed,db) { illegal_2(z80); } /* DB ED */
2872 OP(ed,dc) { illegal_2(z80); } /* DB ED */
2873 OP(ed,dd) { illegal_2(z80); } /* DB ED */
2874 OP(ed,de) { illegal_2(z80); } /* DB ED */
2875 OP(ed,df) { illegal_2(z80); } /* DB ED */
2876
2877 OP(ed,e0) { illegal_2(z80); } /* DB ED */
2878 OP(ed,e1) { illegal_2(z80); } /* DB ED */
2879 OP(ed,e2) { illegal_2(z80); } /* DB ED */
2880 OP(ed,e3) { illegal_2(z80); } /* DB ED */
2881 OP(ed,e4) { illegal_2(z80); } /* DB ED */
2882 OP(ed,e5) { illegal_2(z80); } /* DB ED */
2883 OP(ed,e6) { illegal_2(z80); } /* DB ED */
2884 OP(ed,e7) { illegal_2(z80); } /* DB ED */
2885
2886 OP(ed,e8) { illegal_2(z80); } /* DB ED */
2887 OP(ed,e9) { illegal_2(z80); } /* DB ED */
2888 OP(ed,ea) { illegal_2(z80); } /* DB ED */
2889 OP(ed,eb) { illegal_2(z80); } /* DB ED */
2890 OP(ed,ec) { illegal_2(z80); } /* DB ED */
2891 OP(ed,ed) { illegal_2(z80); } /* DB ED */
2892 OP(ed,ee) { illegal_2(z80); } /* DB ED */
2893 OP(ed,ef) { illegal_2(z80); } /* DB ED */
2894
2895 OP(ed,f0) { illegal_2(z80); } /* DB ED */
2896 OP(ed,f1) { illegal_2(z80); } /* DB ED */
2897 OP(ed,f2) { illegal_2(z80); } /* DB ED */
2898 OP(ed,f3) { illegal_2(z80); } /* DB ED */
2899 OP(ed,f4) { illegal_2(z80); } /* DB ED */
2900 OP(ed,f5) { illegal_2(z80); } /* DB ED */
2901 OP(ed,f6) { illegal_2(z80); } /* DB ED */
2902 OP(ed,f7) { illegal_2(z80); } /* DB ED */
2903
2904 OP(ed,f8) { illegal_2(z80); } /* DB ED */
2905 OP(ed,f9) { illegal_2(z80); } /* DB ED */
2906 OP(ed,fa) { illegal_2(z80); } /* DB ED */
2907 OP(ed,fb) { illegal_2(z80); } /* DB ED */
2908 OP(ed,fc) { illegal_2(z80); } /* DB ED */
2909 OP(ed,fd) { illegal_2(z80); } /* DB ED */
2910 OP(ed,fe) { illegal_2(z80); } /* DB ED */
2911 OP(ed,ff) { illegal_2(z80); } /* DB ED */
2912
2913
2914 /**********************************************************
2915 * main opcodes
2916 **********************************************************/
2917 OP(op,00) { } /* NOP */
2918 OP(op,01) { BC = arg16(z80); } /* LD BC,w */
2919 OP(op,02) { wm(z80, BC,A); WZ_L = (BC + 1) & 0xFF; WZ_H = A; } /* LD (BC),A */
2920 OP(op,03) { BC++; } /* INC BC */
2921 OP(op,04) { B = inc(z80, B); } /* INC B */
2922 OP(op,05) { B = dec(z80, B); } /* DEC B */
2923 OP(op,06) { B = arg(z80); } /* LD B,n */
2924 OP(op,07) { rlca(z80); } /* RLCA */
2925
2926 OP(op,08) { ex_af(z80); } /* EX AF,AF' */
2927 OP(op,09) { add16(z80, &z80->m_hl, &z80->m_bc); } /* ADD HL,BC */
2928 OP(op,0a) { A = rm(z80, BC); WZ=BC+1; } /* LD A,(BC) */
2929 OP(op,0b) { BC--; } /* DEC BC */
2930 OP(op,0c) { C = inc(z80, C); } /* INC C */
2931 OP(op,0d) { C = dec(z80, C); } /* DEC C */
2932 OP(op,0e) { C = arg(z80); } /* LD C,n */
2933 OP(op,0f) { rrca(z80); } /* RRCA */
2934
2935 OP(op,10) { B--; jr_cond(z80, B, 0x10); } /* DJNZ o */
2936 OP(op,11) { DE = arg16(z80); } /* LD DE,w */
2937 OP(op,12) { wm(z80, DE,A); WZ_L = (DE + 1) & 0xFF; WZ_H = A; } /* LD (DE),A */
2938 OP(op,13) { DE++; } /* INC DE */
2939 OP(op,14) { D = inc(z80, D); } /* INC D */
2940 OP(op,15) { D = dec(z80, D); } /* DEC D */
2941 OP(op,16) { D = arg(z80); } /* LD D,n */
2942 OP(op,17) { rla(z80); } /* RLA */
2943
2944 OP(op,18) { jr(z80); } /* JR o */
2945 OP(op,19) { add16(z80, &z80->m_hl, &z80->m_de); } /* ADD HL,DE */
2946 OP(op,1a) { A = rm(z80, DE); WZ = DE + 1; } /* LD A,(DE) */
2947 OP(op,1b) { DE--; } /* DEC DE */
2948 OP(op,1c) { E = inc(z80, E); } /* INC E */
2949 OP(op,1d) { E = dec(z80, E); } /* DEC E */
2950 OP(op,1e) { E = arg(z80); } /* LD E,n */
2951 OP(op,1f) { rra(z80); } /* RRA */
2952
2953 OP(op,20) { jr_cond(z80, !(F & ZF), 0x20); } /* JR NZ,o */
2954 OP(op,21) { HL = arg16(z80); } /* LD HL,w */
2955 OP(op,22) { z80->m_ea = arg16(z80); wm16(z80, z80->m_ea, &z80->m_hl); WZ = z80->m_ea + 1; } /* LD (w),HL */
2956 OP(op,23) { HL++; } /* INC HL */
2957 OP(op,24) { H = inc(z80, H); } /* INC H */
2958 OP(op,25) { H = dec(z80, H); } /* DEC H */
2959 OP(op,26) { H = arg(z80); } /* LD H,n */
2960 OP(op,27) { daa(z80); } /* DAA */
2961
2962 OP(op,28) { jr_cond(z80, F & ZF, 0x28); } /* JR Z,o */
2963 OP(op,29) { add16(z80, &z80->m_hl, &z80->m_hl); } /* ADD HL,HL */
2964 OP(op,2a) { z80->m_ea = arg16(z80); rm16(z80, z80->m_ea, &z80->m_hl); WZ = z80->m_ea+1; } /* LD HL,(w) */
2965 OP(op,2b) { HL--; } /* DEC HL */
2966 OP(op,2c) { L = inc(z80, L); } /* INC L */
2967 OP(op,2d) { L = dec(z80, L); } /* DEC L */
2968 OP(op,2e) { L = arg(z80); } /* LD L,n */
2969 OP(op,2f) { A ^= 0xff; F = (F & (SF | ZF | PF | CF)) | HF | NF | (A & (YF | XF)); } /* CPL */
2970
2971 OP(op,30) { jr_cond(z80, !(F & CF), 0x30); } /* JR NC,o */
2972 OP(op,31) { SP = arg16(z80); } /* LD SP,w */
2973 OP(op,32) { z80->m_ea = arg16(z80); wm(z80, z80->m_ea, A); WZ_L = (z80->m_ea + 1) & 0xFF; WZ_H = A; } /* LD (w),A */
2974 OP(op,33) { SP++; } /* INC SP */
2975 OP(op,34) { wm(z80, HL, inc(z80, rm(z80, HL))); } /* INC (HL) */
2976 OP(op,35) { wm(z80, HL, dec(z80, rm(z80, HL))); } /* DEC (HL) */
2977 OP(op,36) { wm(z80, HL, arg(z80)); } /* LD (HL),n */
2978 OP(op,37) { F = (F & (SF | ZF | YF | XF | PF)) | CF | (A & (YF | XF)); } /* SCF */
2979
2980 OP(op,38) { jr_cond(z80, F & CF, 0x38); } /* JR C,o */
2981 OP(op,39) { add16(z80, &z80->m_hl, &z80->m_sp); } /* ADD HL,SP */
2982 OP(op,3a) { z80->m_ea = arg16(z80); A = rm(z80, z80->m_ea); WZ = z80->m_ea + 1; } /* LD A,(w) */
2983 OP(op,3b) { SP--; } /* DEC SP */
2984 OP(op,3c) { A = inc(z80, A); } /* INC A */
2985 OP(op,3d) { A = dec(z80, A); } /* DEC A */
2986 OP(op,3e) { A = arg(z80); } /* LD A,n */
2987 OP(op,3f) { F = ((F&(SF|ZF|YF|XF|PF|CF))|((F&CF)<<4)|(A&(YF|XF)))^CF; } /* CCF */
2988
2989 OP(op,40) { } /* LD B,B */
2990 OP(op,41) { B = C; } /* LD B,C */
2991 OP(op,42) { B = D; } /* LD B,D */
2992 OP(op,43) { B = E; } /* LD B,E */
2993 OP(op,44) { B = H; } /* LD B,H */
2994 OP(op,45) { B = L; } /* LD B,L */
2995 OP(op,46) { B = rm(z80, HL); } /* LD B,(HL) */
2996 OP(op,47) { B = A; } /* LD B,A */
2997
2998 OP(op,48) { C = B; } /* LD C,B */
2999 OP(op,49) { } /* LD C,C */
3000 OP(op,4a) { C = D; } /* LD C,D */
3001 OP(op,4b) { C = E; } /* LD C,E */
3002 OP(op,4c) { C = H; } /* LD C,H */
3003 OP(op,4d) { C = L; } /* LD C,L */
3004 OP(op,4e) { C = rm(z80, HL); } /* LD C,(HL) */
3005 OP(op,4f) { C = A; } /* LD C,A */
3006
3007 OP(op,50) { D = B; } /* LD D,B */
3008 OP(op,51) { D = C; } /* LD D,C */
3009 OP(op,52) { } /* LD D,D */
3010 OP(op,53) { D = E; } /* LD D,E */
3011 OP(op,54) { D = H; } /* LD D,H */
3012 OP(op,55) { D = L; } /* LD D,L */
3013 OP(op,56) { D = rm(z80, HL); } /* LD D,(HL) */
3014 OP(op,57) { D = A; } /* LD D,A */
3015
3016 OP(op,58) { E = B; } /* LD E,B */
3017 OP(op,59) { E = C; } /* LD E,C */
3018 OP(op,5a) { E = D; } /* LD E,D */
3019 OP(op,5b) { } /* LD E,E */
3020 OP(op,5c) { E = H; } /* LD E,H */
3021 OP(op,5d) { E = L; } /* LD E,L */
3022 OP(op,5e) { E = rm(z80, HL); } /* LD E,(HL) */
3023 OP(op,5f) { E = A; } /* LD E,A */
3024
3025 OP(op,60) { H = B; } /* LD H,B */
3026 OP(op,61) { H = C; } /* LD H,C */
3027 OP(op,62) { H = D; } /* LD H,D */
3028 OP(op,63) { H = E; } /* LD H,E */
3029 OP(op,64) { } /* LD H,H */
3030 OP(op,65) { H = L; } /* LD H,L */
3031 OP(op,66) { H = rm(z80, HL); } /* LD H,(HL) */
3032 OP(op,67) { H = A; } /* LD H,A */
3033
3034 OP(op,68) { L = B; } /* LD L,B */
3035 OP(op,69) { L = C; } /* LD L,C */
3036 OP(op,6a) { L = D; } /* LD L,D */
3037 OP(op,6b) { L = E; } /* LD L,E */
3038 OP(op,6c) { L = H; } /* LD L,H */
3039 OP(op,6d) { } /* LD L,L */
3040 OP(op,6e) { L = rm(z80, HL); } /* LD L,(HL) */
3041 OP(op,6f) { L = A; } /* LD L,A */
3042
3043 OP(op,70) { wm(z80, HL, B); } /* LD (HL),B */
3044 OP(op,71) { wm(z80, HL, C); } /* LD (HL),C */
3045 OP(op,72) { wm(z80, HL, D); } /* LD (HL),D */
3046 OP(op,73) { wm(z80, HL, E); } /* LD (HL),E */
3047 OP(op,74) { wm(z80, HL, H); } /* LD (HL),H */
3048 OP(op,75) { wm(z80, HL, L); } /* LD (HL),L */
3049 OP(op,76) { halt(z80); } /* halt */
3050 OP(op,77) { wm(z80, HL, A); } /* LD (HL),A */
3051
3052 OP(op,78) { A = B; } /* LD A,B */
3053 OP(op,79) { A = C; } /* LD A,C */
3054 OP(op,7a) { A = D; } /* LD A,D */
3055 OP(op,7b) { A = E; } /* LD A,E */
3056 OP(op,7c) { A = H; } /* LD A,H */
3057 OP(op,7d) { A = L; } /* LD A,L */
3058 OP(op,7e) { A = rm(z80, HL); } /* LD A,(HL) */
3059 OP(op,7f) { } /* LD A,A */
3060
3061 OP(op,80) { add_a(z80, B); } /* ADD A,B */
3062 OP(op,81) { add_a(z80, C); } /* ADD A,C */
3063 OP(op,82) { add_a(z80, D); } /* ADD A,D */
3064 OP(op,83) { add_a(z80, E); } /* ADD A,E */
3065 OP(op,84) { add_a(z80, H); } /* ADD A,H */
3066 OP(op,85) { add_a(z80, L); } /* ADD A,L */
3067 OP(op,86) { add_a(z80, rm(z80, HL)); } /* ADD A,(HL) */
3068 OP(op,87) { add_a(z80, A); } /* ADD A,A */
3069
3070 OP(op,88) { adc_a(z80, B); } /* ADC A,B */
3071 OP(op,89) { adc_a(z80, C); } /* ADC A,C */
3072 OP(op,8a) { adc_a(z80, D); } /* ADC A,D */
3073 OP(op,8b) { adc_a(z80, E); } /* ADC A,E */
3074 OP(op,8c) { adc_a(z80, H); } /* ADC A,H */
3075 OP(op,8d) { adc_a(z80, L); } /* ADC A,L */
3076 OP(op,8e) { adc_a(z80, rm(z80, HL)); } /* ADC A,(HL) */
3077 OP(op,8f) { adc_a(z80, A); } /* ADC A,A */
3078
3079 OP(op,90) { sub(z80, B); } /* SUB B */
3080 OP(op,91) { sub(z80, C); } /* SUB C */
3081 OP(op,92) { sub(z80, D); } /* SUB D */
3082 OP(op,93) { sub(z80, E); } /* SUB E */
3083 OP(op,94) { sub(z80, H); } /* SUB H */
3084 OP(op,95) { sub(z80, L); } /* SUB L */
3085 OP(op,96) { sub(z80, rm(z80, HL)); } /* SUB (HL) */
3086 OP(op,97) { sub(z80, A); } /* SUB A */
3087
3088 OP(op,98) { sbc_a(z80, B); } /* SBC A,B */
3089 OP(op,99) { sbc_a(z80, C); } /* SBC A,C */
3090 OP(op,9a) { sbc_a(z80, D); } /* SBC A,D */
3091 OP(op,9b) { sbc_a(z80, E); } /* SBC A,E */
3092 OP(op,9c) { sbc_a(z80, H); } /* SBC A,H */
3093 OP(op,9d) { sbc_a(z80, L); } /* SBC A,L */
3094 OP(op,9e) { sbc_a(z80, rm(z80, HL)); } /* SBC A,(HL) */
3095 OP(op,9f) { sbc_a(z80, A); } /* SBC A,A */
3096
3097 OP(op,a0) { and_a(z80, B); } /* AND B */
3098 OP(op,a1) { and_a(z80, C); } /* AND C */
3099 OP(op,a2) { and_a(z80, D); } /* AND D */
3100 OP(op,a3) { and_a(z80, E); } /* AND E */
3101 OP(op,a4) { and_a(z80, H); } /* AND H */
3102 OP(op,a5) { and_a(z80, L); } /* AND L */
3103 OP(op,a6) { and_a(z80, rm(z80, HL)); } /* AND (HL) */
3104 OP(op,a7) { and_a(z80, A); } /* AND A */
3105
3106 OP(op,a8) { xor_a(z80, B); } /* XOR B */
3107 OP(op,a9) { xor_a(z80, C); } /* XOR C */
3108 OP(op,aa) { xor_a(z80, D); } /* XOR D */
3109 OP(op,ab) { xor_a(z80, E); } /* XOR E */
3110 OP(op,ac) { xor_a(z80, H); } /* XOR H */
3111 OP(op,ad) { xor_a(z80, L); } /* XOR L */
3112 OP(op,ae) { xor_a(z80, rm(z80, HL)); } /* XOR (HL) */
3113 OP(op,af) { xor_a(z80, A); } /* XOR A */
3114
3115 OP(op,b0) { or_a(z80, B); } /* OR B */
3116 OP(op,b1) { or_a(z80, C); } /* OR C */
3117 OP(op,b2) { or_a(z80, D); } /* OR D */
3118 OP(op,b3) { or_a(z80, E); } /* OR E */
3119 OP(op,b4) { or_a(z80, H); } /* OR H */
3120 OP(op,b5) { or_a(z80, L); } /* OR L */
3121 OP(op,b6) { or_a(z80, rm(z80, HL)); } /* OR (HL) */
3122 OP(op,b7) { or_a(z80, A); } /* OR A */
3123
3124 OP(op,b8) { cp(z80, B); } /* CP B */
3125 OP(op,b9) { cp(z80, C); } /* CP C */
3126 OP(op,ba) { cp(z80, D); } /* CP D */
3127 OP(op,bb) { cp(z80, E); } /* CP E */
3128 OP(op,bc) { cp(z80, H); } /* CP H */
3129 OP(op,bd) { cp(z80, L); } /* CP L */
3130 OP(op,be) { cp(z80, rm(z80, HL)); } /* CP (HL) */
3131 OP(op,bf) { cp(z80, A); } /* CP A */
3132
3133 OP(op,c0) { ret_cond(z80, !(F & ZF), 0xc0); } /* RET NZ */
3134 OP(op,c1) { pop(z80, &z80->m_bc); } /* POP BC */
3135 OP(op,c2) { jp_cond(z80, !(F & ZF)); } /* JP NZ,a */
3136 OP(op,c3) { jp(z80); } /* JP a */
3137 OP(op,c4) { call_cond(z80, !(F & ZF), 0xc4); } /* CALL NZ,a */
3138 OP(op,c5) { push(z80, &z80->m_bc); } /* PUSH BC */
3139 OP(op,c6) { add_a(z80, arg(z80)); } /* ADD A,n */
3140 OP(op,c7) { rst(z80, 0x00); } /* RST 0 */
3141
3142 OP(op,c8) { ret_cond(z80, F & ZF, 0xc8); } /* RET Z */
3143 OP(op,c9) { pop(z80, &z80->m_pc); WZ = PCD; } /* RET */
3144 OP(op,ca) { jp_cond(z80, F & ZF); } /* JP Z,a */
3145 OP(op,cb) { z80->m_r++; EXEC(cb,rop(z80)); } /* **** CB xx */
3146 OP(op,cc) { call_cond(z80, F & ZF, 0xcc); } /* CALL Z,a */
3147 OP(op,cd) { call(z80); } /* CALL a */
3148 OP(op,ce) { adc_a(z80, arg(z80)); } /* ADC A,n */
3149 OP(op,cf) { rst(z80, 0x08); } /* RST 1 */
3150
3151 OP(op,d0) { ret_cond(z80, !(F & CF), 0xd0); } /* RET NC */
3152 OP(op,d1) { pop(z80, &z80->m_de); } /* POP DE */
3153 OP(op,d2) { jp_cond(z80, !(F & CF)); } /* JP NC,a */
3154 OP(op,d3) { unsigned n = arg(z80) | (A << 8); out(z80, n, A); WZ_L = ((n & 0xff) + 1) & 0xff; WZ_H = A; } /* OUT (n),A */
3155 OP(op,d4) { call_cond(z80, !(F & CF), 0xd4); } /* CALL NC,a */
3156 OP(op,d5) { push(z80, &z80->m_de); } /* PUSH DE */
3157 OP(op,d6) { sub(z80, arg(z80)); } /* SUB n */
3158 OP(op,d7) { rst(z80, 0x10); } /* RST 2 */
3159
3160 OP(op,d8) { ret_cond(z80, F & CF, 0xd8); } /* RET C */
3161 OP(op,d9) { exx(z80); } /* EXX */
3162 OP(op,da) { jp_cond(z80, F & CF); } /* JP C,a */
3163 OP(op,db) { unsigned n = arg(z80) | (A << 8); A = in(z80, n); WZ = n + 1; } /* IN A,(n) */
3164 OP(op,dc) { call_cond(z80, F & CF, 0xdc); } /* CALL C,a */
3165 OP(op,dd) { z80->m_r++; EXEC(dd,rop(z80)); } /* **** DD xx */
3166 OP(op,de) { sbc_a(z80, arg(z80)); } /* SBC A,n */
3167 OP(op,df) { rst(z80, 0x18); } /* RST 3 */
3168
3169 OP(op,e0) { ret_cond(z80, !(F & PF), 0xe0); } /* RET PO */
3170 OP(op,e1) { pop(z80, &z80->m_hl); } /* POP HL */
3171 OP(op,e2) { jp_cond(z80, !(F & PF)); } /* JP PO,a */
3172 OP(op,e3) { ex_sp(z80, &z80->m_hl); } /* EX HL,(SP) */
3173 OP(op,e4) { call_cond(z80, !(F & PF), 0xe4); } /* CALL PO,a */
3174 OP(op,e5) { push(z80, &z80->m_hl); } /* PUSH HL */
3175 OP(op,e6) { and_a(z80, arg(z80)); } /* AND n */
3176 OP(op,e7) { rst(z80, 0x20); } /* RST 4 */
3177
3178 OP(op,e8) { ret_cond(z80, F & PF, 0xe8); } /* RET PE */
3179 OP(op,e9) { PC = HL; } /* JP (HL) */
3180 OP(op,ea) { jp_cond(z80, F & PF); } /* JP PE,a */
3181 OP(op,eb) { ex_de_hl(z80); } /* EX DE,HL */
3182 OP(op,ec) { call_cond(z80, F & PF, 0xec); } /* CALL PE,a */
3183 OP(op,ed) { z80->m_r++; EXEC(ed,rop(z80)); } /* **** ED xx */
3184 OP(op,ee) { xor_a(z80, arg(z80)); } /* XOR n */
3185 OP(op,ef) { rst(z80, 0x28); } /* RST 5 */
3186
3187 OP(op,f0) { ret_cond(z80, !(F & SF), 0xf0); } /* RET P */
3188 OP(op,f1) { pop(z80, &z80->m_af); } /* POP AF */
3189 OP(op,f2) { jp_cond(z80, !(F & SF)); } /* JP P,a */
3190 OP(op,f3) { z80->m_iff1 = z80->m_iff2 = 0; } /* DI */
3191 OP(op,f4) { call_cond(z80, !(F & SF), 0xf4); } /* CALL P,a */
3192 OP(op,f5) { push(z80, &z80->m_af); } /* PUSH AF */
3193 OP(op,f6) { or_a(z80, arg(z80)); } /* OR n */
3194 OP(op,f7) { rst(z80, 0x30); } /* RST 6 */
3195
3196 OP(op,f8) { ret_cond(z80, F & SF, 0xf8); } /* RET M */
3197 OP(op,f9) { SP = HL; } /* LD SP,HL */
3198 OP(op,fa) { jp_cond(z80, F & SF); } /* JP M,a */
3199 OP(op,fb) { ei(z80); } /* EI */
3200 OP(op,fc) { call_cond(z80, F & SF, 0xfc); } /* CALL M,a */
3201 OP(op,fd) { z80->m_r++; EXEC(fd,rop(z80)); } /* **** FD xx */
3202 OP(op,fe) { cp(z80, arg(z80)); } /* CP n */
3203 OP(op,ff) { rst(z80, 0x38); } /* RST 7 */
3204
3205 /*
3206 void z80_device::take_nmi()
3207 {
3208 PRVPC = 0xffff; // HACK: segag80r protection kludge
3209
3210 // Check if processor was halted
3211 leave_halt(z80);
3212
3213 #if HAS_LDAIR_QUIRK
3214 // reset parity flag after LD A,I or LD A,R
3215 if (m_after_ldair) F &= ~PF;
3216 #endif
3217
3218 m_iff1 = 0;
3219 push(m_pc);
3220 PCD = 0x0066;
3221 WZ=PCD;
3222 m_icount -= 11;
3223 m_nmi_pending = false;
3224 }*/
3225
3226 static void take_interrupt(z80_device *z80)
3227 {
3228 PRVPC = 0xffff; // HACK: segag80r protection kludge
3229
3230 // check if processor was halted
3231 leave_halt(z80);
3232
3233 // clear both interrupt flip flops
3234 z80->m_iff1 = z80->m_iff2 = 0;
3235
3236
3237 // fetch the IRQ vector
3238 int irq_vector = z80->im2_vector;
3239
3240 // Interrupt mode 2. Call [i:databyte]
3241 if( z80->m_im == 2 )
3242 {
3243 // Zilog's datasheet claims that "the least-significant bit must be a zero."
3244 // However, experiments have confirmed that IM 2 vectors do not have to be
3245 // even, and all 8 bits will be used; even $FF is handled normally.
3246 irq_vector = (irq_vector & 0xff) | (z80->m_i << 8);
3247 push(z80, &z80->m_pc);
3248 rm16(z80, irq_vector, &z80->m_pc);
3249 //LOG(("Z80 '%s' IM2 [$%04x] = $%04x\n", tag(), irq_vector, PCD));
3250 // CALL opcode timing + 'interrupt latency' cycles
3251 z80->m_icount -= z80->m_cc_op[0xcd] + z80->m_cc_ex[0xff];
3252 }
3253 else
3254 // Interrupt mode 1. RST 38h
3255 if( z80->m_im == 1 )
3256 {
3257 //LOG(("Z80 '%s' IM1 $0038\n", tag()));
3258 push(z80, &z80->m_pc);
3259 PCD = 0x0038;
3260 // RST $38 + 'interrupt latency' cycles
3261 z80->m_icount -= z80->m_cc_op[0xff] + cc_ex[0xff];
3262 }
3263 else
3264 {
3265 // Interrupt mode 0. We check for CALL and JP instructions,
3266 // if neither of these were found we assume a 1 byte opcode
3267 // was placed on the databus
3268 //LOG(("Z80 '%s' IM0 $%04x\n", tag(), irq_vector));
3269
3270 // check for nop
3271 if (irq_vector != 0x00)
3272 {
3273 switch (irq_vector & 0xff0000)
3274 {
3275 case 0xcd0000: // call
3276 push(z80, &z80->m_pc);
3277 PCD = irq_vector & 0xffff;
3278 // CALL $xxxx cycles
3279 z80->m_icount -= z80->m_cc_op[0xcd];
3280 break;
3281 case 0xc30000: // jump
3282 PCD = irq_vector & 0xffff;
3283 // JP $xxxx cycles
3284 z80->m_icount -= z80->m_cc_op[0xc3];
3285 break;
3286 default: // rst (or other opcodes?)
3287 push(z80, &z80->m_pc);
3288 PCD = irq_vector & 0x0038;
3289 // RST $xx cycles
3290 z80->m_icount -= z80->m_cc_op[0xff];
3291 break;
3292 }
3293 }
3294
3295 // 'interrupt latency' cycles
3296 z80->m_icount -= z80->m_cc_ex[0xff];
3297 }
3298 WZ=PCD;
3299
3300 #if HAS_LDAIR_QUIRK
3301 // reset parity flag after LD A,I or LD A,R
3302 if (m_after_ldair) F &= ~PF;
3303 #endif
3304 }
3305
3306 void init_z80_opts(z80_options * options, memmap_chunk const * chunks, uint32_t num_chunks, memmap_chunk const * io_chunks, uint32_t num_io_chunks, uint32_t clock_divider, uint32_t io_address_mask)
3307 {
3308 memset(options, 0, sizeof(*options));
3309 options->gen.clock_divider = clock_divider;
3310 options->gen.memmap = chunks;
3311 options->gen.memmap_chunks = num_chunks;
3312 options->gen.address_mask = 0xFFFF;
3313 options->iomap = io_chunks;
3314 options->io_chunks = num_io_chunks;
3315 options->io_address_mask = io_address_mask;
3316 }
3317
3318 /****************************************************************************
3319 * Processor initialization
3320 ****************************************************************************/
3321 z80_context *init_z80_context(z80_options *opts)
3322 {
3323 z80_context *z80 = calloc(1, sizeof(z80_context));
3324 if( !tables_initialised )
3325 {
3326 uint8_t *padd = &SZHVC_add[ 0*256];
3327 uint8_t *padc = &SZHVC_add[256*256];
3328 uint8_t *psub = &SZHVC_sub[ 0*256];
3329 uint8_t *psbc = &SZHVC_sub[256*256];
3330 for (int oldval = 0; oldval < 256; oldval++)
3331 {
3332 for (int newval = 0; newval < 256; newval++)
3333 {
3334 /* add or adc w/o carry set */
3335 int val = newval - oldval;
3336 *padd = (newval) ? ((newval & 0x80) ? SF : 0) : ZF;
3337 *padd |= (newval & (YF | XF)); /* undocumented flag bits 5+3 */
3338 if( (newval & 0x0f) < (oldval & 0x0f) ) *padd |= HF;
3339 if( newval < oldval ) *padd |= CF;
3340 if( (val^oldval^0x80) & (val^newval) & 0x80 ) *padd |= VF;
3341 padd++;
3342
3343 /* adc with carry set */
3344 val = newval - oldval - 1;
3345 *padc = (newval) ? ((newval & 0x80) ? SF : 0) : ZF;
3346 *padc |= (newval & (YF | XF)); /* undocumented flag bits 5+3 */
3347 if( (newval & 0x0f) <= (oldval & 0x0f) ) *padc |= HF;
3348 if( newval <= oldval ) *padc |= CF;
3349 if( (val^oldval^0x80) & (val^newval) & 0x80 ) *padc |= VF;
3350 padc++;
3351
3352 /* cp, sub or sbc w/o carry set */
3353 val = oldval - newval;
3354 *psub = NF | ((newval) ? ((newval & 0x80) ? SF : 0) : ZF);
3355 *psub |= (newval & (YF | XF)); /* undocumented flag bits 5+3 */
3356 if( (newval & 0x0f) > (oldval & 0x0f) ) *psub |= HF;
3357 if( newval > oldval ) *psub |= CF;
3358 if( (val^oldval) & (oldval^newval) & 0x80 ) *psub |= VF;
3359 psub++;
3360
3361 /* sbc with carry set */
3362 val = oldval - newval - 1;
3363 *psbc = NF | ((newval) ? ((newval & 0x80) ? SF : 0) : ZF);
3364 *psbc |= (newval & (YF | XF)); /* undocumented flag bits 5+3 */
3365 if( (newval & 0x0f) >= (oldval & 0x0f) ) *psbc |= HF;
3366 if( newval >= oldval ) *psbc |= CF;
3367 if( (val^oldval) & (oldval^newval) & 0x80 ) *psbc |= VF;
3368 psbc++;
3369 }
3370 }
3371
3372 for (int i = 0; i < 256; i++)
3373 {
3374 int p = 0;
3375 if( i&0x01 ) ++p;
3376 if( i&0x02 ) ++p;
3377 if( i&0x04 ) ++p;
3378 if( i&0x08 ) ++p;
3379 if( i&0x10 ) ++p;
3380 if( i&0x20 ) ++p;
3381 if( i&0x40 ) ++p;
3382 if( i&0x80 ) ++p;
3383 SZ[i] = i ? i & SF : ZF;
3384 SZ[i] |= (i & (YF | XF)); /* undocumented flag bits 5+3 */
3385 SZ_BIT[i] = i ? i & SF : ZF | PF;
3386 SZ_BIT[i] |= (i & (YF | XF)); /* undocumented flag bits 5+3 */
3387 SZP[i] = SZ[i] | ((p & 1) ? 0 : PF);
3388 SZHV_inc[i] = SZ[i];
3389 if( i == 0x80 ) SZHV_inc[i] |= VF;
3390 if( (i & 0x0f) == 0x00 ) SZHV_inc[i] |= HF;
3391 SZHV_dec[i] = SZ[i] | NF;
3392 if( i == 0x7f ) SZHV_dec[i] |= VF;
3393 if( (i & 0x0f) == 0x0f ) SZHV_dec[i] |= HF;
3394 }
3395
3396 tables_initialised = 1;
3397 }
3398 z80->options = opts;
3399
3400 /* Reset registers to their initial values */
3401 PRVPC = 0;
3402 PCD = 0;
3403 SPD = 0;
3404 AFD = 0;
3405 BCD = 0;
3406 DED = 0;
3407 HLD = 0;
3408 IXD = 0;
3409 IYD = 0;
3410 WZ = 0;
3411 z80->m_af2.d = 0;
3412 z80->m_bc2.d = 0;
3413 z80->m_de2.d = 0;
3414 z80->m_hl2.d = 0;
3415 z80->m_r = 0;
3416 z80->m_r2 = 0;
3417 z80->m_iff1 = 0;
3418 z80->m_iff2 = 0;
3419 z80->m_halt = 0;
3420 z80->m_im = 0;
3421 z80->m_i = 0;
3422 z80->m_nmi_state = 0;
3423 z80->m_nmi_pending = 0;
3424 z80->m_irq_state = 0;
3425 z80->m_wait_state = 0;
3426 z80->busreq = 0;
3427 z80->m_after_ei = 0;
3428 z80->m_after_ldair = 0;
3429 z80->m_ea = 0;
3430
3431 IX = IY = 0xffff; /* IX and IY are FFFF after a reset! */
3432 F = ZF; /* Zero flag is set */
3433
3434 /* setup cycle tables */
3435 z80->m_cc_op = cc_op;
3436 z80->m_cc_cb = cc_cb;
3437 z80->m_cc_ed = cc_ed;
3438 z80->m_cc_xy = cc_xy;
3439 z80->m_cc_xycb = cc_xycb;
3440 z80->m_cc_ex = cc_ex;
3441
3442 return z80;
3443 }
3444
3445 /****************************************************************************
3446 * Do a reset
3447 ****************************************************************************/
3448 void z80_assert_reset(z80_context *z80, uint32_t cycle)
3449 {
3450 z80_run(z80, cycle);
3451 z80->reset = 1;
3452 }
3453 void z80_clear_reset(z80_context *z80, uint32_t cycle)
3454 {
3455 if (!z80->reset) {
3456 return;
3457 }
3458 z80_run(z80, cycle);
3459 PC = 0x0000;
3460 z80->m_i = 0;
3461 z80->m_r = 0;
3462 z80->m_r2 = 0;
3463 //m_nmi_pending = false;
3464 z80->m_after_ei = 0;
3465 z80->m_after_ldair = 0;
3466 z80->m_iff1 = 0;
3467 z80->m_iff2 = 0;
3468 z80->reset = 0;
3469
3470 WZ=PCD;
3471 }
3472
3473 void z80_assert_busreq(z80_context *z80, uint32_t cycle)
3474 {
3475 z80->busreq = 1;
3476 }
3477
3478 void z80_clear_busreq(z80_context *z80, uint32_t cycle)
3479 {
3480 z80->busreq = 0;
3481 z80->busack = 0;
3482 }
3483
3484 uint8_t z80_get_busack(z80_context * context, uint32_t cycle)
3485 {
3486 z80_run(context, cycle);
3487 return context->busack;
3488 }
3489
3490 /****************************************************************************
3491 * Execute 'cycles' T-states.
3492 ****************************************************************************/
3493 void z80_run(z80_context *z80, uint32_t target_cycle)
3494 {
3495 if (z80->busack || z80->reset) {
3496 z80->current_cycle = target_cycle;
3497 return;
3498 }
3499 if (z80->current_cycle >= target_cycle) {
3500 return;
3501 }
3502 uint32_t sync_cycle = target_cycle;
3503 if (z80->next_int_pulse && (z80->int_pulse_end < z80->current_cycle || z80->int_pulse_end == CYCLE_NEVER)) {
3504 z80->next_int_pulse(z80);
3505 }
3506 z80->m_icount = ((target_cycle - z80->current_cycle) + z80->options->gen.clock_divider - 1) / z80->options->gen.clock_divider;
3507 int32_t int_icount = INT_MIN;
3508 if (z80->int_pulse_start < target_cycle) {
3509 int_icount = (z80->int_pulse_start < z80->current_cycle) ? z80->m_icount
3510 : ((z80->int_pulse_start - z80->current_cycle) + z80->options->gen.clock_divider - 1) / z80->options->gen.clock_divider;
3511 }
3512 do
3513 {
3514 // check for interrupts before each instruction
3515 /*
3516 //TODO: Interrupts
3517 if (m_nmi_pending)
3518 take_nmi(z80);
3519 else */
3520 if (z80->m_icount <= int_icount && z80->m_iff1 && !z80->m_after_ei) {
3521 take_interrupt(z80);
3522 z80->current_cycle = target_cycle - z80->m_icount * z80->options->gen.clock_divider;
3523 z80->next_int_pulse(z80);
3524 if (z80->int_pulse_start < target_cycle) {
3525 int_icount = (z80->int_pulse_start < z80->current_cycle) ? z80->m_icount
3526 : ((z80->int_pulse_start - z80->current_cycle) + z80->options->gen.clock_divider - 1) / z80->options->gen.clock_divider;
3527 }
3528 }
3529
3530 z80->m_after_ei = 0;
3531 z80->m_after_ldair = 0;
3532
3533 PRVPC = PCD;
3534 //debugger_instruction_hook(this, PCD);
3535 z80->m_r++;
3536 EXEC(op,rop(z80));
3537 if (z80->busreq) {
3538 z80->busack = 1;
3539 z80->m_icount = 0;
3540 }
3541 } while (z80->m_icount > 0);
3542 z80->current_cycle = target_cycle - z80->m_icount * z80->options->gen.clock_divider;
3543 }
3544
3545 /**************************************************************************
3546 * Generic set_info
3547 **************************************************************************/
3548
3549 void z80_set_cycle_tables(z80_device *z80, const uint8_t *op, const uint8_t *cb, const uint8_t *ed, const uint8_t *xy, const uint8_t *xycb, const uint8_t *ex)
3550 {
3551 z80->m_cc_op = (op != NULL) ? op : cc_op;
3552 z80->m_cc_cb = (cb != NULL) ? cb : cc_cb;
3553 z80->m_cc_ed = (ed != NULL) ? ed : cc_ed;
3554 z80->m_cc_xy = (xy != NULL) ? xy : cc_xy;
3555 z80->m_cc_xycb = (xycb != NULL) ? xycb : cc_xycb;
3556 z80->m_cc_ex = (ex != NULL) ? ex : cc_ex;
3557 }
3558
3559 void z80_serialize(z80_context *context, serialize_buffer *buf)
3560 {
3561 }
3562 void z80_deserialize(deserialize_buffer *buf, void *vcontext)
3563 {
3564 }
3565
3566 void z80_options_free(z80_options *opts)
3567 {
3568 free(opts);
3569 }
3570
3571 void z80_assert_nmi(z80_context *context, uint32_t cycle)
3572 {
3573 context->nmi_start = cycle;
3574 //check_nmi(context);
3575 }
3576
3577 void z80_adjust_cycles(z80_context * context, uint32_t deduction)
3578 {
3579 if (context->current_cycle < deduction) {
3580 fprintf(stderr, "WARNING: Deduction of %u cycles when Z80 cycle counter is only %u\n", deduction, context->current_cycle);
3581 context->current_cycle = 0;
3582 } else {
3583 context->current_cycle -= deduction;
3584 }
3585 /*if (context->int_enable_cycle != CYCLE_NEVER) {
3586 if (context->int_enable_cycle < deduction) {
3587 context->int_enable_cycle = 0;
3588 } else {
3589 context->int_enable_cycle -= deduction;
3590 }
3591 }*/
3592 if (context->int_pulse_start != CYCLE_NEVER) {
3593 if (context->int_pulse_end < deduction) {
3594 context->int_pulse_start = context->int_pulse_end = CYCLE_NEVER;
3595 } else {
3596 if (context->int_pulse_end != CYCLE_NEVER) {
3597 context->int_pulse_end -= deduction;
3598 }
3599 if (context->int_pulse_start < deduction) {
3600 context->int_pulse_start = 0;
3601 } else {
3602 context->int_pulse_start -= deduction;
3603 }
3604 }
3605 }
3606 }