projects / simh.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
First Commit of my working state
[simh.git] / AltairZ80 / altairz80_cpu_nommu.c
1 /* altairz80_cpu_opt.c: MITS Altair CPU (8080 and Z80)
2
3 Copyright (c) 2002-2008, Peter Schorn
4
5 Permission is hereby granted, free of charge, to any person obtaining a
6 copy of this software and associated documentation files (the "Software"),
7 to deal in the Software without restriction, including without limitation
8 the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 and/or sell copies of the Software, and to permit persons to whom the
10 Software is furnished to do so, subject to the following conditions:
11
12 The above copyright notice and this permission notice shall be included in
13 all copies or substantial portions of the Software.
14
15 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 PETER SCHORN BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
19 IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
20 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21
22 Except as contained in this notice, the name of Peter Schorn shall not
23 be used in advertising or otherwise to promote the sale, use or other dealings
24 in this Software without prior written authorization from Peter Schorn.
25
26 Based on work by Charles E Owen (c) 1997
27 Code for Z80 CPU from Frank D. Cringle ((c) 1995 under GNU license)
28 */
29
30 #include "altairz80_defs.h"
31
32 #define FLAG_C 1
33 #define FLAG_N 2
34 #define FLAG_P 4
35 #define FLAG_H 16
36 #define FLAG_Z 64
37 #define FLAG_S 128
38
39 #define SETFLAG(f,c) AF = (c) ? AF | FLAG_ ## f : AF & ~FLAG_ ## f
40 #define TSTFLAG(f) ((AF & FLAG_ ## f) != 0)
41
42 #define LOW_DIGIT(x) ((x) & 0xf)
43 #define HIGH_DIGIT(x) (((x) >> 4) & 0xf)
44 #define LOW_REGISTER(x) ((x) & 0xff)
45 #define HIGH_REGISTER(x) (((x) >> 8) & 0xff)
46
47 #define SET_LOW_REGISTER(x, v) x = (((x) & 0xff00) | ((v) & 0xff))
48 #define SET_HIGH_REGISTER(x, v) x = (((x) & 0xff) | (((v) & 0xff) << 8))
49
50 #define PARITY(x) parityTable[(x) & 0xff]
51 /* SET_PV and SET_PV2 are used to provide correct PARITY flag semantics for the 8080 in cases
52 where the Z80 uses the overflow flag
53 */
54 #define SET_PVS(s) ((chiptype == CHIP_TYPE_Z80) ? (((cbits >> 6) ^ (cbits >> 5)) & 4) : (PARITY(s)))
55 #define SET_PV (SET_PVS(sum))
56 #define SET_PV2(x) ((chiptype == CHIP_TYPE_Z80) ? (((temp == (x)) << 2)) : (PARITY(temp)))
57
58 /* CHECK_CPU_8080 must be invoked whenever a Z80 only instruction is executed
59 In case a Z80 instruction is executed on an 8080 the following two cases exist:
60 1) Trapping is enabled: execution stops
61 2) Trapping is not enabled: decoding continues with the next byte
62 */
63 #define CHECK_CPU_8080 \
64 if (chiptype == CHIP_TYPE_8080) { \
65 if (cpu_unit.flags & UNIT_CPU_OPSTOP) { \
66 reason = STOP_OPCODE; \
67 goto end_decode; \
68 } \
69 else continue; \
70 }
71
72 /* CHECK_CPU_Z80 must be invoked whenever a non Z80 instruction is executed */
73 #define CHECK_CPU_Z80 \
74 if (cpu_unit.flags & UNIT_CPU_OPSTOP) { \
75 reason = STOP_OPCODE; \
76 goto end_decode; \
77 }
78
79 #define POP(x) { \
80 register uint32 y = RAM_PP(SP); \
81 x = y + (RAM_PP(SP) << 8); \
82 }
83
84 #define JPC(cond) { \
85 if (cond) { \
86 PC = GET_WORD(PC); \
87 } \
88 else { \
89 PC += 2; \
90 } \
91 }
92
93 #define CALLC(cond) { \
94 if (cond) { \
95 register uint32 adrr = GET_WORD(PC); \
96 PUSH(PC + 2); \
97 PC = adrr; \
98 } \
99 else { \
100 PC += 2; \
101 } \
102 }
103
104 /* function prototypes */
105 t_stat sim_instr_nommu(void);
106
107 extern void out(const uint32 Port, const uint32 Value);
108 extern uint32 in(const uint32 Port);
109 extern UNIT cpu_unit;
110 extern uint32 PCX; /* external view of PC */
111 extern int32 AF_S; /* AF register */
112 extern int32 BC_S; /* BC register */
113 extern int32 DE_S; /* DE register */
114 extern int32 HL_S; /* HL register */
115 extern int32 IX_S; /* IX register */
116 extern int32 IY_S; /* IY register */
117 extern int32 PC_S; /* program counter */
118 extern int32 SP_S; /* SP register */
119 extern int32 AF1_S; /* alternate AF register */
120 extern int32 BC1_S; /* alternate BC register */
121 extern int32 DE1_S; /* alternate DE register */
122 extern int32 HL1_S; /* alternate HL register */
123 extern int32 IFF_S; /* Interrupt Flip Flop */
124 extern int32 IR_S; /* Interrupt (upper) / Refresh (lower) register */
125 extern int32 chiptype;
126
127 /* the following tables precompute some common subexpressions
128 parityTable[i] 0..255 (number of 1's in i is odd) ? 0 : 4
129 incTable[i] 0..256! (i & 0xa8) | (((i & 0xff) == 0) << 6) | (((i & 0xf) == 0) << 4)
130 decTable[i] 0..255 (i & 0xa8) | (((i & 0xff) == 0) << 6) | (((i & 0xf) == 0xf) << 4) | 2
131 cbitsTable[i] 0..511 (i & 0x10) | ((i >> 8) & 1)
132 cbitsDup8Table[i] 0..511 (i & 0x10) | ((i >> 8) & 1) | ((i & 0xff) << 8) | (i & 0xa8) |
133 (((i & 0xff) == 0) << 6)
134 cbitsDup16Table[i] 0..511 (i & 0x10) | ((i >> 8) & 1) | (i & 0x28)
135 cbits2Table[i] 0..511 (i & 0x10) | ((i >> 8) & 1) | 2
136 rrcaTable[i] 0..255 ((i & 1) << 15) | ((i >> 1) << 8) | ((i >> 1) & 0x28) | (i & 1)
137 rraTable[i] 0..255 ((i >> 1) << 8) | ((i >> 1) & 0x28) | (i & 1)
138 addTable[i] 0..511 ((i & 0xff) << 8) | (i & 0xa8) | (((i & 0xff) == 0) << 6)
139 subTable[i] 0..255 ((i & 0xff) << 8) | (i & 0xa8) | (((i & 0xff) == 0) << 6) | 2
140 andTable[i] 0..255 (i << 8) | (i & 0xa8) | ((i == 0) << 6) | 0x10 | parityTable[i]
141 xororTable[i] 0..255 (i << 8) | (i & 0xa8) | ((i == 0) << 6) | parityTable[i]
142 rotateShiftTable[i] 0..255 (i & 0xa8) | (((i & 0xff) == 0) << 6) | parityTable[i & 0xff]
143 incZ80Table[i] 0..256! (i & 0xa8) | (((i & 0xff) == 0) << 6) |
144 (((i & 0xf) == 0) << 4) | ((i == 0x80) << 2)
145 decZ80Table[i] 0..255 (i & 0xa8) | (((i & 0xff) == 0) << 6) |
146 (((i & 0xf) == 0xf) << 4) | ((i == 0x7f) << 2) | 2
147 cbitsZ80Table[i] 0..511 (i & 0x10) | (((i >> 6) ^ (i >> 5)) & 4) | ((i >> 8) & 1)
148 cbitsZ80DupTable[i] 0..511 (i & 0x10) | (((i >> 6) ^ (i >> 5)) & 4) |
149 ((i >> 8) & 1) | (i & 0xa8)
150 cbits2Z80Table[i] 0..511 (i & 0x10) | (((i >> 6) ^ (i >> 5)) & 4) | ((i >> 8) & 1) | 2
151 cbits2Z80DupTable[i] 0..511 (i & 0x10) | (((i >> 6) ^ (i >> 5)) & 4) | ((i >> 8) & 1) | 2 |
152 (i & 0xa8)
153 negTable[i] 0..255 (((i & 0x0f) != 0) << 4) | ((i == 0x80) << 2) | 2 | (i != 0)
154 rrdrldTable[i] 0..255 (i << 8) | (i & 0xa8) | (((i & 0xff) == 0) << 6) | parityTable[i]
155 cpTable[i] 0..255 (i & 0x80) | (((i & 0xff) == 0) << 6)
156 */
157
158 /* parityTable[i] = (number of 1's in i is odd) ? 0 : 4, i = 0..255 */
159 static const uint8 parityTable[256] = {
160 4,0,0,4,0,4,4,0,0,4,4,0,4,0,0,4,
161 0,4,4,0,4,0,0,4,4,0,0,4,0,4,4,0,
162 0,4,4,0,4,0,0,4,4,0,0,4,0,4,4,0,
163 4,0,0,4,0,4,4,0,0,4,4,0,4,0,0,4,
164 0,4,4,0,4,0,0,4,4,0,0,4,0,4,4,0,
165 4,0,0,4,0,4,4,0,0,4,4,0,4,0,0,4,
166 4,0,0,4,0,4,4,0,0,4,4,0,4,0,0,4,
167 0,4,4,0,4,0,0,4,4,0,0,4,0,4,4,0,
168 0,4,4,0,4,0,0,4,4,0,0,4,0,4,4,0,
169 4,0,0,4,0,4,4,0,0,4,4,0,4,0,0,4,
170 4,0,0,4,0,4,4,0,0,4,4,0,4,0,0,4,
171 0,4,4,0,4,0,0,4,4,0,0,4,0,4,4,0,
172 4,0,0,4,0,4,4,0,0,4,4,0,4,0,0,4,
173 0,4,4,0,4,0,0,4,4,0,0,4,0,4,4,0,
174 0,4,4,0,4,0,0,4,4,0,0,4,0,4,4,0,
175 4,0,0,4,0,4,4,0,0,4,4,0,4,0,0,4,
176 };
177
178 /* incTable[i] = (i & 0xa8) | (((i & 0xff) == 0) << 6) | (((i & 0xf) == 0) << 4), i = 0..256 */
179 static const uint8 incTable[257] = {
180 80, 0, 0, 0, 0, 0, 0, 0, 8, 8, 8, 8, 8, 8, 8, 8,
181 16, 0, 0, 0, 0, 0, 0, 0, 8, 8, 8, 8, 8, 8, 8, 8,
182 48, 32, 32, 32, 32, 32, 32, 32, 40, 40, 40, 40, 40, 40, 40, 40,
183 48, 32, 32, 32, 32, 32, 32, 32, 40, 40, 40, 40, 40, 40, 40, 40,
184 16, 0, 0, 0, 0, 0, 0, 0, 8, 8, 8, 8, 8, 8, 8, 8,
185 16, 0, 0, 0, 0, 0, 0, 0, 8, 8, 8, 8, 8, 8, 8, 8,
186 48, 32, 32, 32, 32, 32, 32, 32, 40, 40, 40, 40, 40, 40, 40, 40,
187 48, 32, 32, 32, 32, 32, 32, 32, 40, 40, 40, 40, 40, 40, 40, 40,
188 144,128,128,128,128,128,128,128,136,136,136,136,136,136,136,136,
189 144,128,128,128,128,128,128,128,136,136,136,136,136,136,136,136,
190 176,160,160,160,160,160,160,160,168,168,168,168,168,168,168,168,
191 176,160,160,160,160,160,160,160,168,168,168,168,168,168,168,168,
192 144,128,128,128,128,128,128,128,136,136,136,136,136,136,136,136,
193 144,128,128,128,128,128,128,128,136,136,136,136,136,136,136,136,
194 176,160,160,160,160,160,160,160,168,168,168,168,168,168,168,168,
195 176,160,160,160,160,160,160,160,168,168,168,168,168,168,168,168, 80
196 };
197
198 /* decTable[i] = (i & 0xa8) | (((i & 0xff) == 0) << 6) | (((i & 0xf) == 0xf) << 4) | 2, i = 0..255 */
199 static const uint8 decTable[256] = {
200 66, 2, 2, 2, 2, 2, 2, 2, 10, 10, 10, 10, 10, 10, 10, 26,
201 2, 2, 2, 2, 2, 2, 2, 2, 10, 10, 10, 10, 10, 10, 10, 26,
202 34, 34, 34, 34, 34, 34, 34, 34, 42, 42, 42, 42, 42, 42, 42, 58,
203 34, 34, 34, 34, 34, 34, 34, 34, 42, 42, 42, 42, 42, 42, 42, 58,
204 2, 2, 2, 2, 2, 2, 2, 2, 10, 10, 10, 10, 10, 10, 10, 26,
205 2, 2, 2, 2, 2, 2, 2, 2, 10, 10, 10, 10, 10, 10, 10, 26,
206 34, 34, 34, 34, 34, 34, 34, 34, 42, 42, 42, 42, 42, 42, 42, 58,
207 34, 34, 34, 34, 34, 34, 34, 34, 42, 42, 42, 42, 42, 42, 42, 58,
208 130,130,130,130,130,130,130,130,138,138,138,138,138,138,138,154,
209 130,130,130,130,130,130,130,130,138,138,138,138,138,138,138,154,
210 162,162,162,162,162,162,162,162,170,170,170,170,170,170,170,186,
211 162,162,162,162,162,162,162,162,170,170,170,170,170,170,170,186,
212 130,130,130,130,130,130,130,130,138,138,138,138,138,138,138,154,
213 130,130,130,130,130,130,130,130,138,138,138,138,138,138,138,154,
214 162,162,162,162,162,162,162,162,170,170,170,170,170,170,170,186,
215 162,162,162,162,162,162,162,162,170,170,170,170,170,170,170,186,
216 };
217
218 /* cbitsTable[i] = (i & 0x10) | ((i >> 8) & 1), i = 0..511 */
219 static const uint8 cbitsTable[512] = {
220 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
221 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
222 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
223 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
224 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
225 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
226 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
227 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
228 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
229 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
230 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
231 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
232 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
233 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
234 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
235 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
236 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
237 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
238 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
239 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
240 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
241 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
242 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
243 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
244 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
245 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
246 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
247 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
248 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
249 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
250 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
251 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
252 };
253
254 /* cbitsDup8Table[i] = (i & 0x10) | ((i >> 8) & 1) | ((i & 0xff) << 8) | (i & 0xa8) |
255 (((i & 0xff) == 0) << 6), i = 0..511 */
256 static const uint16 cbitsDup8Table[512] = {
257 0x0040,0x0100,0x0200,0x0300,0x0400,0x0500,0x0600,0x0700,
258 0x0808,0x0908,0x0a08,0x0b08,0x0c08,0x0d08,0x0e08,0x0f08,
259 0x1010,0x1110,0x1210,0x1310,0x1410,0x1510,0x1610,0x1710,
260 0x1818,0x1918,0x1a18,0x1b18,0x1c18,0x1d18,0x1e18,0x1f18,
261 0x2020,0x2120,0x2220,0x2320,0x2420,0x2520,0x2620,0x2720,
262 0x2828,0x2928,0x2a28,0x2b28,0x2c28,0x2d28,0x2e28,0x2f28,
263 0x3030,0x3130,0x3230,0x3330,0x3430,0x3530,0x3630,0x3730,
264 0x3838,0x3938,0x3a38,0x3b38,0x3c38,0x3d38,0x3e38,0x3f38,
265 0x4000,0x4100,0x4200,0x4300,0x4400,0x4500,0x4600,0x4700,
266 0x4808,0x4908,0x4a08,0x4b08,0x4c08,0x4d08,0x4e08,0x4f08,
267 0x5010,0x5110,0x5210,0x5310,0x5410,0x5510,0x5610,0x5710,
268 0x5818,0x5918,0x5a18,0x5b18,0x5c18,0x5d18,0x5e18,0x5f18,
269 0x6020,0x6120,0x6220,0x6320,0x6420,0x6520,0x6620,0x6720,
270 0x6828,0x6928,0x6a28,0x6b28,0x6c28,0x6d28,0x6e28,0x6f28,
271 0x7030,0x7130,0x7230,0x7330,0x7430,0x7530,0x7630,0x7730,
272 0x7838,0x7938,0x7a38,0x7b38,0x7c38,0x7d38,0x7e38,0x7f38,
273 0x8080,0x8180,0x8280,0x8380,0x8480,0x8580,0x8680,0x8780,
274 0x8888,0x8988,0x8a88,0x8b88,0x8c88,0x8d88,0x8e88,0x8f88,
275 0x9090,0x9190,0x9290,0x9390,0x9490,0x9590,0x9690,0x9790,
276 0x9898,0x9998,0x9a98,0x9b98,0x9c98,0x9d98,0x9e98,0x9f98,
277 0xa0a0,0xa1a0,0xa2a0,0xa3a0,0xa4a0,0xa5a0,0xa6a0,0xa7a0,
278 0xa8a8,0xa9a8,0xaaa8,0xaba8,0xaca8,0xada8,0xaea8,0xafa8,
279 0xb0b0,0xb1b0,0xb2b0,0xb3b0,0xb4b0,0xb5b0,0xb6b0,0xb7b0,
280 0xb8b8,0xb9b8,0xbab8,0xbbb8,0xbcb8,0xbdb8,0xbeb8,0xbfb8,
281 0xc080,0xc180,0xc280,0xc380,0xc480,0xc580,0xc680,0xc780,
282 0xc888,0xc988,0xca88,0xcb88,0xcc88,0xcd88,0xce88,0xcf88,
283 0xd090,0xd190,0xd290,0xd390,0xd490,0xd590,0xd690,0xd790,
284 0xd898,0xd998,0xda98,0xdb98,0xdc98,0xdd98,0xde98,0xdf98,
285 0xe0a0,0xe1a0,0xe2a0,0xe3a0,0xe4a0,0xe5a0,0xe6a0,0xe7a0,
286 0xe8a8,0xe9a8,0xeaa8,0xeba8,0xeca8,0xeda8,0xeea8,0xefa8,
287 0xf0b0,0xf1b0,0xf2b0,0xf3b0,0xf4b0,0xf5b0,0xf6b0,0xf7b0,
288 0xf8b8,0xf9b8,0xfab8,0xfbb8,0xfcb8,0xfdb8,0xfeb8,0xffb8,
289 0x0041,0x0101,0x0201,0x0301,0x0401,0x0501,0x0601,0x0701,
290 0x0809,0x0909,0x0a09,0x0b09,0x0c09,0x0d09,0x0e09,0x0f09,
291 0x1011,0x1111,0x1211,0x1311,0x1411,0x1511,0x1611,0x1711,
292 0x1819,0x1919,0x1a19,0x1b19,0x1c19,0x1d19,0x1e19,0x1f19,
293 0x2021,0x2121,0x2221,0x2321,0x2421,0x2521,0x2621,0x2721,
294 0x2829,0x2929,0x2a29,0x2b29,0x2c29,0x2d29,0x2e29,0x2f29,
295 0x3031,0x3131,0x3231,0x3331,0x3431,0x3531,0x3631,0x3731,
296 0x3839,0x3939,0x3a39,0x3b39,0x3c39,0x3d39,0x3e39,0x3f39,
297 0x4001,0x4101,0x4201,0x4301,0x4401,0x4501,0x4601,0x4701,
298 0x4809,0x4909,0x4a09,0x4b09,0x4c09,0x4d09,0x4e09,0x4f09,
299 0x5011,0x5111,0x5211,0x5311,0x5411,0x5511,0x5611,0x5711,
300 0x5819,0x5919,0x5a19,0x5b19,0x5c19,0x5d19,0x5e19,0x5f19,
301 0x6021,0x6121,0x6221,0x6321,0x6421,0x6521,0x6621,0x6721,
302 0x6829,0x6929,0x6a29,0x6b29,0x6c29,0x6d29,0x6e29,0x6f29,
303 0x7031,0x7131,0x7231,0x7331,0x7431,0x7531,0x7631,0x7731,
304 0x7839,0x7939,0x7a39,0x7b39,0x7c39,0x7d39,0x7e39,0x7f39,
305 0x8081,0x8181,0x8281,0x8381,0x8481,0x8581,0x8681,0x8781,
306 0x8889,0x8989,0x8a89,0x8b89,0x8c89,0x8d89,0x8e89,0x8f89,
307 0x9091,0x9191,0x9291,0x9391,0x9491,0x9591,0x9691,0x9791,
308 0x9899,0x9999,0x9a99,0x9b99,0x9c99,0x9d99,0x9e99,0x9f99,
309 0xa0a1,0xa1a1,0xa2a1,0xa3a1,0xa4a1,0xa5a1,0xa6a1,0xa7a1,
310 0xa8a9,0xa9a9,0xaaa9,0xaba9,0xaca9,0xada9,0xaea9,0xafa9,
311 0xb0b1,0xb1b1,0xb2b1,0xb3b1,0xb4b1,0xb5b1,0xb6b1,0xb7b1,
312 0xb8b9,0xb9b9,0xbab9,0xbbb9,0xbcb9,0xbdb9,0xbeb9,0xbfb9,
313 0xc081,0xc181,0xc281,0xc381,0xc481,0xc581,0xc681,0xc781,
314 0xc889,0xc989,0xca89,0xcb89,0xcc89,0xcd89,0xce89,0xcf89,
315 0xd091,0xd191,0xd291,0xd391,0xd491,0xd591,0xd691,0xd791,
316 0xd899,0xd999,0xda99,0xdb99,0xdc99,0xdd99,0xde99,0xdf99,
317 0xe0a1,0xe1a1,0xe2a1,0xe3a1,0xe4a1,0xe5a1,0xe6a1,0xe7a1,
318 0xe8a9,0xe9a9,0xeaa9,0xeba9,0xeca9,0xeda9,0xeea9,0xefa9,
319 0xf0b1,0xf1b1,0xf2b1,0xf3b1,0xf4b1,0xf5b1,0xf6b1,0xf7b1,
320 0xf8b9,0xf9b9,0xfab9,0xfbb9,0xfcb9,0xfdb9,0xfeb9,0xffb9,
321 };
322
323 /* cbitsDup16Table[i] = (i & 0x10) | ((i >> 8) & 1) | (i & 0x28), i = 0..511 */
324 static const uint8 cbitsDup16Table[512] = {
325 0, 0, 0, 0, 0, 0, 0, 0, 8, 8, 8, 8, 8, 8, 8, 8,
326 16,16,16,16,16,16,16,16,24,24,24,24,24,24,24,24,
327 32,32,32,32,32,32,32,32,40,40,40,40,40,40,40,40,
328 48,48,48,48,48,48,48,48,56,56,56,56,56,56,56,56,
329 0, 0, 0, 0, 0, 0, 0, 0, 8, 8, 8, 8, 8, 8, 8, 8,
330 16,16,16,16,16,16,16,16,24,24,24,24,24,24,24,24,
331 32,32,32,32,32,32,32,32,40,40,40,40,40,40,40,40,
332 48,48,48,48,48,48,48,48,56,56,56,56,56,56,56,56,
333 0, 0, 0, 0, 0, 0, 0, 0, 8, 8, 8, 8, 8, 8, 8, 8,
334 16,16,16,16,16,16,16,16,24,24,24,24,24,24,24,24,
335 32,32,32,32,32,32,32,32,40,40,40,40,40,40,40,40,
336 48,48,48,48,48,48,48,48,56,56,56,56,56,56,56,56,
337 0, 0, 0, 0, 0, 0, 0, 0, 8, 8, 8, 8, 8, 8, 8, 8,
338 16,16,16,16,16,16,16,16,24,24,24,24,24,24,24,24,
339 32,32,32,32,32,32,32,32,40,40,40,40,40,40,40,40,
340 48,48,48,48,48,48,48,48,56,56,56,56,56,56,56,56,
341 1, 1, 1, 1, 1, 1, 1, 1, 9, 9, 9, 9, 9, 9, 9, 9,
342 17,17,17,17,17,17,17,17,25,25,25,25,25,25,25,25,
343 33,33,33,33,33,33,33,33,41,41,41,41,41,41,41,41,
344 49,49,49,49,49,49,49,49,57,57,57,57,57,57,57,57,
345 1, 1, 1, 1, 1, 1, 1, 1, 9, 9, 9, 9, 9, 9, 9, 9,
346 17,17,17,17,17,17,17,17,25,25,25,25,25,25,25,25,
347 33,33,33,33,33,33,33,33,41,41,41,41,41,41,41,41,
348 49,49,49,49,49,49,49,49,57,57,57,57,57,57,57,57,
349 1, 1, 1, 1, 1, 1, 1, 1, 9, 9, 9, 9, 9, 9, 9, 9,
350 17,17,17,17,17,17,17,17,25,25,25,25,25,25,25,25,
351 33,33,33,33,33,33,33,33,41,41,41,41,41,41,41,41,
352 49,49,49,49,49,49,49,49,57,57,57,57,57,57,57,57,
353 1, 1, 1, 1, 1, 1, 1, 1, 9, 9, 9, 9, 9, 9, 9, 9,
354 17,17,17,17,17,17,17,17,25,25,25,25,25,25,25,25,
355 33,33,33,33,33,33,33,33,41,41,41,41,41,41,41,41,
356 49,49,49,49,49,49,49,49,57,57,57,57,57,57,57,57,
357 };
358
359 /* cbits2Table[i] = (i & 0x10) | ((i >> 8) & 1) | 2, i = 0..511 */
360 static const uint8 cbits2Table[512] = {
361 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
362 18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,
363 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
364 18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,
365 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
366 18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,
367 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
368 18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,
369 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
370 18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,
371 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
372 18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,
373 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
374 18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,
375 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
376 18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,
377 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
378 19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
379 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
380 19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
381 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
382 19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
383 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
384 19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
385 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
386 19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
387 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
388 19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
389 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
390 19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
391 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
392 19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
393 };
394
395 /* rrcaTable[i] = ((i & 1) << 15) | ((i >> 1) << 8) | ((i >> 1) & 0x28) | (i & 1), i = 0..255 */
396 static const uint16 rrcaTable[256] = {
397 0x0000,0x8001,0x0100,0x8101,0x0200,0x8201,0x0300,0x8301,
398 0x0400,0x8401,0x0500,0x8501,0x0600,0x8601,0x0700,0x8701,
399 0x0808,0x8809,0x0908,0x8909,0x0a08,0x8a09,0x0b08,0x8b09,
400 0x0c08,0x8c09,0x0d08,0x8d09,0x0e08,0x8e09,0x0f08,0x8f09,
401 0x1000,0x9001,0x1100,0x9101,0x1200,0x9201,0x1300,0x9301,
402 0x1400,0x9401,0x1500,0x9501,0x1600,0x9601,0x1700,0x9701,
403 0x1808,0x9809,0x1908,0x9909,0x1a08,0x9a09,0x1b08,0x9b09,
404 0x1c08,0x9c09,0x1d08,0x9d09,0x1e08,0x9e09,0x1f08,0x9f09,
405 0x2020,0xa021,0x2120,0xa121,0x2220,0xa221,0x2320,0xa321,
406 0x2420,0xa421,0x2520,0xa521,0x2620,0xa621,0x2720,0xa721,
407 0x2828,0xa829,0x2928,0xa929,0x2a28,0xaa29,0x2b28,0xab29,
408 0x2c28,0xac29,0x2d28,0xad29,0x2e28,0xae29,0x2f28,0xaf29,
409 0x3020,0xb021,0x3120,0xb121,0x3220,0xb221,0x3320,0xb321,
410 0x3420,0xb421,0x3520,0xb521,0x3620,0xb621,0x3720,0xb721,
411 0x3828,0xb829,0x3928,0xb929,0x3a28,0xba29,0x3b28,0xbb29,
412 0x3c28,0xbc29,0x3d28,0xbd29,0x3e28,0xbe29,0x3f28,0xbf29,
413 0x4000,0xc001,0x4100,0xc101,0x4200,0xc201,0x4300,0xc301,
414 0x4400,0xc401,0x4500,0xc501,0x4600,0xc601,0x4700,0xc701,
415 0x4808,0xc809,0x4908,0xc909,0x4a08,0xca09,0x4b08,0xcb09,
416 0x4c08,0xcc09,0x4d08,0xcd09,0x4e08,0xce09,0x4f08,0xcf09,
417 0x5000,0xd001,0x5100,0xd101,0x5200,0xd201,0x5300,0xd301,
418 0x5400,0xd401,0x5500,0xd501,0x5600,0xd601,0x5700,0xd701,
419 0x5808,0xd809,0x5908,0xd909,0x5a08,0xda09,0x5b08,0xdb09,
420 0x5c08,0xdc09,0x5d08,0xdd09,0x5e08,0xde09,0x5f08,0xdf09,
421 0x6020,0xe021,0x6120,0xe121,0x6220,0xe221,0x6320,0xe321,
422 0x6420,0xe421,0x6520,0xe521,0x6620,0xe621,0x6720,0xe721,
423 0x6828,0xe829,0x6928,0xe929,0x6a28,0xea29,0x6b28,0xeb29,
424 0x6c28,0xec29,0x6d28,0xed29,0x6e28,0xee29,0x6f28,0xef29,
425 0x7020,0xf021,0x7120,0xf121,0x7220,0xf221,0x7320,0xf321,
426 0x7420,0xf421,0x7520,0xf521,0x7620,0xf621,0x7720,0xf721,
427 0x7828,0xf829,0x7928,0xf929,0x7a28,0xfa29,0x7b28,0xfb29,
428 0x7c28,0xfc29,0x7d28,0xfd29,0x7e28,0xfe29,0x7f28,0xff29,
429 };
430
431 /* rraTable[i] = ((i >> 1) << 8) | ((i >> 1) & 0x28) | (i & 1), i = 0..255 */
432 static const uint16 rraTable[256] = {
433 0x0000,0x0001,0x0100,0x0101,0x0200,0x0201,0x0300,0x0301,
434 0x0400,0x0401,0x0500,0x0501,0x0600,0x0601,0x0700,0x0701,
435 0x0808,0x0809,0x0908,0x0909,0x0a08,0x0a09,0x0b08,0x0b09,
436 0x0c08,0x0c09,0x0d08,0x0d09,0x0e08,0x0e09,0x0f08,0x0f09,
437 0x1000,0x1001,0x1100,0x1101,0x1200,0x1201,0x1300,0x1301,
438 0x1400,0x1401,0x1500,0x1501,0x1600,0x1601,0x1700,0x1701,
439 0x1808,0x1809,0x1908,0x1909,0x1a08,0x1a09,0x1b08,0x1b09,
440 0x1c08,0x1c09,0x1d08,0x1d09,0x1e08,0x1e09,0x1f08,0x1f09,
441 0x2020,0x2021,0x2120,0x2121,0x2220,0x2221,0x2320,0x2321,
442 0x2420,0x2421,0x2520,0x2521,0x2620,0x2621,0x2720,0x2721,
443 0x2828,0x2829,0x2928,0x2929,0x2a28,0x2a29,0x2b28,0x2b29,
444 0x2c28,0x2c29,0x2d28,0x2d29,0x2e28,0x2e29,0x2f28,0x2f29,
445 0x3020,0x3021,0x3120,0x3121,0x3220,0x3221,0x3320,0x3321,
446 0x3420,0x3421,0x3520,0x3521,0x3620,0x3621,0x3720,0x3721,
447 0x3828,0x3829,0x3928,0x3929,0x3a28,0x3a29,0x3b28,0x3b29,
448 0x3c28,0x3c29,0x3d28,0x3d29,0x3e28,0x3e29,0x3f28,0x3f29,
449 0x4000,0x4001,0x4100,0x4101,0x4200,0x4201,0x4300,0x4301,
450 0x4400,0x4401,0x4500,0x4501,0x4600,0x4601,0x4700,0x4701,
451 0x4808,0x4809,0x4908,0x4909,0x4a08,0x4a09,0x4b08,0x4b09,
452 0x4c08,0x4c09,0x4d08,0x4d09,0x4e08,0x4e09,0x4f08,0x4f09,
453 0x5000,0x5001,0x5100,0x5101,0x5200,0x5201,0x5300,0x5301,
454 0x5400,0x5401,0x5500,0x5501,0x5600,0x5601,0x5700,0x5701,
455 0x5808,0x5809,0x5908,0x5909,0x5a08,0x5a09,0x5b08,0x5b09,
456 0x5c08,0x5c09,0x5d08,0x5d09,0x5e08,0x5e09,0x5f08,0x5f09,
457 0x6020,0x6021,0x6120,0x6121,0x6220,0x6221,0x6320,0x6321,
458 0x6420,0x6421,0x6520,0x6521,0x6620,0x6621,0x6720,0x6721,
459 0x6828,0x6829,0x6928,0x6929,0x6a28,0x6a29,0x6b28,0x6b29,
460 0x6c28,0x6c29,0x6d28,0x6d29,0x6e28,0x6e29,0x6f28,0x6f29,
461 0x7020,0x7021,0x7120,0x7121,0x7220,0x7221,0x7320,0x7321,
462 0x7420,0x7421,0x7520,0x7521,0x7620,0x7621,0x7720,0x7721,
463 0x7828,0x7829,0x7928,0x7929,0x7a28,0x7a29,0x7b28,0x7b29,
464 0x7c28,0x7c29,0x7d28,0x7d29,0x7e28,0x7e29,0x7f28,0x7f29,
465 };
466
467 /* addTable[i] = ((i & 0xff) << 8) | (i & 0xa8) | (((i & 0xff) == 0) << 6), i = 0..511 */
468 static const uint16 addTable[512] = {
469 0x0040,0x0100,0x0200,0x0300,0x0400,0x0500,0x0600,0x0700,
470 0x0808,0x0908,0x0a08,0x0b08,0x0c08,0x0d08,0x0e08,0x0f08,
471 0x1000,0x1100,0x1200,0x1300,0x1400,0x1500,0x1600,0x1700,
472 0x1808,0x1908,0x1a08,0x1b08,0x1c08,0x1d08,0x1e08,0x1f08,
473 0x2020,0x2120,0x2220,0x2320,0x2420,0x2520,0x2620,0x2720,
474 0x2828,0x2928,0x2a28,0x2b28,0x2c28,0x2d28,0x2e28,0x2f28,
475 0x3020,0x3120,0x3220,0x3320,0x3420,0x3520,0x3620,0x3720,
476 0x3828,0x3928,0x3a28,0x3b28,0x3c28,0x3d28,0x3e28,0x3f28,
477 0x4000,0x4100,0x4200,0x4300,0x4400,0x4500,0x4600,0x4700,
478 0x4808,0x4908,0x4a08,0x4b08,0x4c08,0x4d08,0x4e08,0x4f08,
479 0x5000,0x5100,0x5200,0x5300,0x5400,0x5500,0x5600,0x5700,
480 0x5808,0x5908,0x5a08,0x5b08,0x5c08,0x5d08,0x5e08,0x5f08,
481 0x6020,0x6120,0x6220,0x6320,0x6420,0x6520,0x6620,0x6720,
482 0x6828,0x6928,0x6a28,0x6b28,0x6c28,0x6d28,0x6e28,0x6f28,
483 0x7020,0x7120,0x7220,0x7320,0x7420,0x7520,0x7620,0x7720,
484 0x7828,0x7928,0x7a28,0x7b28,0x7c28,0x7d28,0x7e28,0x7f28,
485 0x8080,0x8180,0x8280,0x8380,0x8480,0x8580,0x8680,0x8780,
486 0x8888,0x8988,0x8a88,0x8b88,0x8c88,0x8d88,0x8e88,0x8f88,
487 0x9080,0x9180,0x9280,0x9380,0x9480,0x9580,0x9680,0x9780,
488 0x9888,0x9988,0x9a88,0x9b88,0x9c88,0x9d88,0x9e88,0x9f88,
489 0xa0a0,0xa1a0,0xa2a0,0xa3a0,0xa4a0,0xa5a0,0xa6a0,0xa7a0,
490 0xa8a8,0xa9a8,0xaaa8,0xaba8,0xaca8,0xada8,0xaea8,0xafa8,
491 0xb0a0,0xb1a0,0xb2a0,0xb3a0,0xb4a0,0xb5a0,0xb6a0,0xb7a0,
492 0xb8a8,0xb9a8,0xbaa8,0xbba8,0xbca8,0xbda8,0xbea8,0xbfa8,
493 0xc080,0xc180,0xc280,0xc380,0xc480,0xc580,0xc680,0xc780,
494 0xc888,0xc988,0xca88,0xcb88,0xcc88,0xcd88,0xce88,0xcf88,
495 0xd080,0xd180,0xd280,0xd380,0xd480,0xd580,0xd680,0xd780,
496 0xd888,0xd988,0xda88,0xdb88,0xdc88,0xdd88,0xde88,0xdf88,
497 0xe0a0,0xe1a0,0xe2a0,0xe3a0,0xe4a0,0xe5a0,0xe6a0,0xe7a0,
498 0xe8a8,0xe9a8,0xeaa8,0xeba8,0xeca8,0xeda8,0xeea8,0xefa8,
499 0xf0a0,0xf1a0,0xf2a0,0xf3a0,0xf4a0,0xf5a0,0xf6a0,0xf7a0,
500 0xf8a8,0xf9a8,0xfaa8,0xfba8,0xfca8,0xfda8,0xfea8,0xffa8,
501 0x0040,0x0100,0x0200,0x0300,0x0400,0x0500,0x0600,0x0700,
502 0x0808,0x0908,0x0a08,0x0b08,0x0c08,0x0d08,0x0e08,0x0f08,
503 0x1000,0x1100,0x1200,0x1300,0x1400,0x1500,0x1600,0x1700,
504 0x1808,0x1908,0x1a08,0x1b08,0x1c08,0x1d08,0x1e08,0x1f08,
505 0x2020,0x2120,0x2220,0x2320,0x2420,0x2520,0x2620,0x2720,
506 0x2828,0x2928,0x2a28,0x2b28,0x2c28,0x2d28,0x2e28,0x2f28,
507 0x3020,0x3120,0x3220,0x3320,0x3420,0x3520,0x3620,0x3720,
508 0x3828,0x3928,0x3a28,0x3b28,0x3c28,0x3d28,0x3e28,0x3f28,
509 0x4000,0x4100,0x4200,0x4300,0x4400,0x4500,0x4600,0x4700,
510 0x4808,0x4908,0x4a08,0x4b08,0x4c08,0x4d08,0x4e08,0x4f08,
511 0x5000,0x5100,0x5200,0x5300,0x5400,0x5500,0x5600,0x5700,
512 0x5808,0x5908,0x5a08,0x5b08,0x5c08,0x5d08,0x5e08,0x5f08,
513 0x6020,0x6120,0x6220,0x6320,0x6420,0x6520,0x6620,0x6720,
514 0x6828,0x6928,0x6a28,0x6b28,0x6c28,0x6d28,0x6e28,0x6f28,
515 0x7020,0x7120,0x7220,0x7320,0x7420,0x7520,0x7620,0x7720,
516 0x7828,0x7928,0x7a28,0x7b28,0x7c28,0x7d28,0x7e28,0x7f28,
517 0x8080,0x8180,0x8280,0x8380,0x8480,0x8580,0x8680,0x8780,
518 0x8888,0x8988,0x8a88,0x8b88,0x8c88,0x8d88,0x8e88,0x8f88,
519 0x9080,0x9180,0x9280,0x9380,0x9480,0x9580,0x9680,0x9780,
520 0x9888,0x9988,0x9a88,0x9b88,0x9c88,0x9d88,0x9e88,0x9f88,
521 0xa0a0,0xa1a0,0xa2a0,0xa3a0,0xa4a0,0xa5a0,0xa6a0,0xa7a0,
522 0xa8a8,0xa9a8,0xaaa8,0xaba8,0xaca8,0xada8,0xaea8,0xafa8,
523 0xb0a0,0xb1a0,0xb2a0,0xb3a0,0xb4a0,0xb5a0,0xb6a0,0xb7a0,
524 0xb8a8,0xb9a8,0xbaa8,0xbba8,0xbca8,0xbda8,0xbea8,0xbfa8,
525 0xc080,0xc180,0xc280,0xc380,0xc480,0xc580,0xc680,0xc780,
526 0xc888,0xc988,0xca88,0xcb88,0xcc88,0xcd88,0xce88,0xcf88,
527 0xd080,0xd180,0xd280,0xd380,0xd480,0xd580,0xd680,0xd780,
528 0xd888,0xd988,0xda88,0xdb88,0xdc88,0xdd88,0xde88,0xdf88,
529 0xe0a0,0xe1a0,0xe2a0,0xe3a0,0xe4a0,0xe5a0,0xe6a0,0xe7a0,
530 0xe8a8,0xe9a8,0xeaa8,0xeba8,0xeca8,0xeda8,0xeea8,0xefa8,
531 0xf0a0,0xf1a0,0xf2a0,0xf3a0,0xf4a0,0xf5a0,0xf6a0,0xf7a0,
532 0xf8a8,0xf9a8,0xfaa8,0xfba8,0xfca8,0xfda8,0xfea8,0xffa8,
533 };
534
535 /* subTable[i] = ((i & 0xff) << 8) | (i & 0xa8) | (((i & 0xff) == 0) << 6) | 2, i = 0..255 */
536 static const uint16 subTable[256] = {
537 0x0042,0x0102,0x0202,0x0302,0x0402,0x0502,0x0602,0x0702,
538 0x080a,0x090a,0x0a0a,0x0b0a,0x0c0a,0x0d0a,0x0e0a,0x0f0a,
539 0x1002,0x1102,0x1202,0x1302,0x1402,0x1502,0x1602,0x1702,
540 0x180a,0x190a,0x1a0a,0x1b0a,0x1c0a,0x1d0a,0x1e0a,0x1f0a,
541 0x2022,0x2122,0x2222,0x2322,0x2422,0x2522,0x2622,0x2722,
542 0x282a,0x292a,0x2a2a,0x2b2a,0x2c2a,0x2d2a,0x2e2a,0x2f2a,
543 0x3022,0x3122,0x3222,0x3322,0x3422,0x3522,0x3622,0x3722,
544 0x382a,0x392a,0x3a2a,0x3b2a,0x3c2a,0x3d2a,0x3e2a,0x3f2a,
545 0x4002,0x4102,0x4202,0x4302,0x4402,0x4502,0x4602,0x4702,
546 0x480a,0x490a,0x4a0a,0x4b0a,0x4c0a,0x4d0a,0x4e0a,0x4f0a,
547 0x5002,0x5102,0x5202,0x5302,0x5402,0x5502,0x5602,0x5702,
548 0x580a,0x590a,0x5a0a,0x5b0a,0x5c0a,0x5d0a,0x5e0a,0x5f0a,
549 0x6022,0x6122,0x6222,0x6322,0x6422,0x6522,0x6622,0x6722,
550 0x682a,0x692a,0x6a2a,0x6b2a,0x6c2a,0x6d2a,0x6e2a,0x6f2a,
551 0x7022,0x7122,0x7222,0x7322,0x7422,0x7522,0x7622,0x7722,
552 0x782a,0x792a,0x7a2a,0x7b2a,0x7c2a,0x7d2a,0x7e2a,0x7f2a,
553 0x8082,0x8182,0x8282,0x8382,0x8482,0x8582,0x8682,0x8782,
554 0x888a,0x898a,0x8a8a,0x8b8a,0x8c8a,0x8d8a,0x8e8a,0x8f8a,
555 0x9082,0x9182,0x9282,0x9382,0x9482,0x9582,0x9682,0x9782,
556 0x988a,0x998a,0x9a8a,0x9b8a,0x9c8a,0x9d8a,0x9e8a,0x9f8a,
557 0xa0a2,0xa1a2,0xa2a2,0xa3a2,0xa4a2,0xa5a2,0xa6a2,0xa7a2,
558 0xa8aa,0xa9aa,0xaaaa,0xabaa,0xacaa,0xadaa,0xaeaa,0xafaa,
559 0xb0a2,0xb1a2,0xb2a2,0xb3a2,0xb4a2,0xb5a2,0xb6a2,0xb7a2,
560 0xb8aa,0xb9aa,0xbaaa,0xbbaa,0xbcaa,0xbdaa,0xbeaa,0xbfaa,
561 0xc082,0xc182,0xc282,0xc382,0xc482,0xc582,0xc682,0xc782,
562 0xc88a,0xc98a,0xca8a,0xcb8a,0xcc8a,0xcd8a,0xce8a,0xcf8a,
563 0xd082,0xd182,0xd282,0xd382,0xd482,0xd582,0xd682,0xd782,
564 0xd88a,0xd98a,0xda8a,0xdb8a,0xdc8a,0xdd8a,0xde8a,0xdf8a,
565 0xe0a2,0xe1a2,0xe2a2,0xe3a2,0xe4a2,0xe5a2,0xe6a2,0xe7a2,
566 0xe8aa,0xe9aa,0xeaaa,0xebaa,0xecaa,0xedaa,0xeeaa,0xefaa,
567 0xf0a2,0xf1a2,0xf2a2,0xf3a2,0xf4a2,0xf5a2,0xf6a2,0xf7a2,
568 0xf8aa,0xf9aa,0xfaaa,0xfbaa,0xfcaa,0xfdaa,0xfeaa,0xffaa,
569 };
570
571 /* andTable[i] = (i << 8) | (i & 0xa8) | ((i == 0) << 6) | 0x10 | parityTable[i], i = 0..255 */
572 static const uint16 andTable[256] = {
573 0x0054,0x0110,0x0210,0x0314,0x0410,0x0514,0x0614,0x0710,
574 0x0818,0x091c,0x0a1c,0x0b18,0x0c1c,0x0d18,0x0e18,0x0f1c,
575 0x1010,0x1114,0x1214,0x1310,0x1414,0x1510,0x1610,0x1714,
576 0x181c,0x1918,0x1a18,0x1b1c,0x1c18,0x1d1c,0x1e1c,0x1f18,
577 0x2030,0x2134,0x2234,0x2330,0x2434,0x2530,0x2630,0x2734,
578 0x283c,0x2938,0x2a38,0x2b3c,0x2c38,0x2d3c,0x2e3c,0x2f38,
579 0x3034,0x3130,0x3230,0x3334,0x3430,0x3534,0x3634,0x3730,
580 0x3838,0x393c,0x3a3c,0x3b38,0x3c3c,0x3d38,0x3e38,0x3f3c,
581 0x4010,0x4114,0x4214,0x4310,0x4414,0x4510,0x4610,0x4714,
582 0x481c,0x4918,0x4a18,0x4b1c,0x4c18,0x4d1c,0x4e1c,0x4f18,
583 0x5014,0x5110,0x5210,0x5314,0x5410,0x5514,0x5614,0x5710,
584 0x5818,0x591c,0x5a1c,0x5b18,0x5c1c,0x5d18,0x5e18,0x5f1c,
585 0x6034,0x6130,0x6230,0x6334,0x6430,0x6534,0x6634,0x6730,
586 0x6838,0x693c,0x6a3c,0x6b38,0x6c3c,0x6d38,0x6e38,0x6f3c,
587 0x7030,0x7134,0x7234,0x7330,0x7434,0x7530,0x7630,0x7734,
588 0x783c,0x7938,0x7a38,0x7b3c,0x7c38,0x7d3c,0x7e3c,0x7f38,
589 0x8090,0x8194,0x8294,0x8390,0x8494,0x8590,0x8690,0x8794,
590 0x889c,0x8998,0x8a98,0x8b9c,0x8c98,0x8d9c,0x8e9c,0x8f98,
591 0x9094,0x9190,0x9290,0x9394,0x9490,0x9594,0x9694,0x9790,
592 0x9898,0x999c,0x9a9c,0x9b98,0x9c9c,0x9d98,0x9e98,0x9f9c,
593 0xa0b4,0xa1b0,0xa2b0,0xa3b4,0xa4b0,0xa5b4,0xa6b4,0xa7b0,
594 0xa8b8,0xa9bc,0xaabc,0xabb8,0xacbc,0xadb8,0xaeb8,0xafbc,
595 0xb0b0,0xb1b4,0xb2b4,0xb3b0,0xb4b4,0xb5b0,0xb6b0,0xb7b4,
596 0xb8bc,0xb9b8,0xbab8,0xbbbc,0xbcb8,0xbdbc,0xbebc,0xbfb8,
597 0xc094,0xc190,0xc290,0xc394,0xc490,0xc594,0xc694,0xc790,
598 0xc898,0xc99c,0xca9c,0xcb98,0xcc9c,0xcd98,0xce98,0xcf9c,
599 0xd090,0xd194,0xd294,0xd390,0xd494,0xd590,0xd690,0xd794,
600 0xd89c,0xd998,0xda98,0xdb9c,0xdc98,0xdd9c,0xde9c,0xdf98,
601 0xe0b0,0xe1b4,0xe2b4,0xe3b0,0xe4b4,0xe5b0,0xe6b0,0xe7b4,
602 0xe8bc,0xe9b8,0xeab8,0xebbc,0xecb8,0xedbc,0xeebc,0xefb8,
603 0xf0b4,0xf1b0,0xf2b0,0xf3b4,0xf4b0,0xf5b4,0xf6b4,0xf7b0,
604 0xf8b8,0xf9bc,0xfabc,0xfbb8,0xfcbc,0xfdb8,0xfeb8,0xffbc,
605 };
606
607 /* xororTable[i] = (i << 8) | (i & 0xa8) | ((i == 0) << 6) | parityTable[i], i = 0..255 */
608 static const uint16 xororTable[256] = {
609 0x0044,0x0100,0x0200,0x0304,0x0400,0x0504,0x0604,0x0700,
610 0x0808,0x090c,0x0a0c,0x0b08,0x0c0c,0x0d08,0x0e08,0x0f0c,
611 0x1000,0x1104,0x1204,0x1300,0x1404,0x1500,0x1600,0x1704,
612 0x180c,0x1908,0x1a08,0x1b0c,0x1c08,0x1d0c,0x1e0c,0x1f08,
613 0x2020,0x2124,0x2224,0x2320,0x2424,0x2520,0x2620,0x2724,
614 0x282c,0x2928,0x2a28,0x2b2c,0x2c28,0x2d2c,0x2e2c,0x2f28,
615 0x3024,0x3120,0x3220,0x3324,0x3420,0x3524,0x3624,0x3720,
616 0x3828,0x392c,0x3a2c,0x3b28,0x3c2c,0x3d28,0x3e28,0x3f2c,
617 0x4000,0x4104,0x4204,0x4300,0x4404,0x4500,0x4600,0x4704,
618 0x480c,0x4908,0x4a08,0x4b0c,0x4c08,0x4d0c,0x4e0c,0x4f08,
619 0x5004,0x5100,0x5200,0x5304,0x5400,0x5504,0x5604,0x5700,
620 0x5808,0x590c,0x5a0c,0x5b08,0x5c0c,0x5d08,0x5e08,0x5f0c,
621 0x6024,0x6120,0x6220,0x6324,0x6420,0x6524,0x6624,0x6720,
622 0x6828,0x692c,0x6a2c,0x6b28,0x6c2c,0x6d28,0x6e28,0x6f2c,
623 0x7020,0x7124,0x7224,0x7320,0x7424,0x7520,0x7620,0x7724,
624 0x782c,0x7928,0x7a28,0x7b2c,0x7c28,0x7d2c,0x7e2c,0x7f28,
625 0x8080,0x8184,0x8284,0x8380,0x8484,0x8580,0x8680,0x8784,
626 0x888c,0x8988,0x8a88,0x8b8c,0x8c88,0x8d8c,0x8e8c,0x8f88,
627 0x9084,0x9180,0x9280,0x9384,0x9480,0x9584,0x9684,0x9780,
628 0x9888,0x998c,0x9a8c,0x9b88,0x9c8c,0x9d88,0x9e88,0x9f8c,
629 0xa0a4,0xa1a0,0xa2a0,0xa3a4,0xa4a0,0xa5a4,0xa6a4,0xa7a0,
630 0xa8a8,0xa9ac,0xaaac,0xaba8,0xacac,0xada8,0xaea8,0xafac,
631 0xb0a0,0xb1a4,0xb2a4,0xb3a0,0xb4a4,0xb5a0,0xb6a0,0xb7a4,
632 0xb8ac,0xb9a8,0xbaa8,0xbbac,0xbca8,0xbdac,0xbeac,0xbfa8,
633 0xc084,0xc180,0xc280,0xc384,0xc480,0xc584,0xc684,0xc780,
634 0xc888,0xc98c,0xca8c,0xcb88,0xcc8c,0xcd88,0xce88,0xcf8c,
635 0xd080,0xd184,0xd284,0xd380,0xd484,0xd580,0xd680,0xd784,
636 0xd88c,0xd988,0xda88,0xdb8c,0xdc88,0xdd8c,0xde8c,0xdf88,
637 0xe0a0,0xe1a4,0xe2a4,0xe3a0,0xe4a4,0xe5a0,0xe6a0,0xe7a4,
638 0xe8ac,0xe9a8,0xeaa8,0xebac,0xeca8,0xedac,0xeeac,0xefa8,
639 0xf0a4,0xf1a0,0xf2a0,0xf3a4,0xf4a0,0xf5a4,0xf6a4,0xf7a0,
640 0xf8a8,0xf9ac,0xfaac,0xfba8,0xfcac,0xfda8,0xfea8,0xffac,
641 };
642
643 /* rotateShiftTable[i] = (i & 0xa8) | (((i & 0xff) == 0) << 6) | parityTable[i & 0xff], i = 0..255 */
644 static const uint8 rotateShiftTable[256] = {
645 68, 0, 0, 4, 0, 4, 4, 0, 8, 12, 12, 8, 12, 8, 8, 12,
646 0, 4, 4, 0, 4, 0, 0, 4, 12, 8, 8, 12, 8, 12, 12, 8,
647 32, 36, 36, 32, 36, 32, 32, 36, 44, 40, 40, 44, 40, 44, 44, 40,
648 36, 32, 32, 36, 32, 36, 36, 32, 40, 44, 44, 40, 44, 40, 40, 44,
649 0, 4, 4, 0, 4, 0, 0, 4, 12, 8, 8, 12, 8, 12, 12, 8,
650 4, 0, 0, 4, 0, 4, 4, 0, 8, 12, 12, 8, 12, 8, 8, 12,
651 36, 32, 32, 36, 32, 36, 36, 32, 40, 44, 44, 40, 44, 40, 40, 44,
652 32, 36, 36, 32, 36, 32, 32, 36, 44, 40, 40, 44, 40, 44, 44, 40,
653 128,132,132,128,132,128,128,132,140,136,136,140,136,140,140,136,
654 132,128,128,132,128,132,132,128,136,140,140,136,140,136,136,140,
655 164,160,160,164,160,164,164,160,168,172,172,168,172,168,168,172,
656 160,164,164,160,164,160,160,164,172,168,168,172,168,172,172,168,
657 132,128,128,132,128,132,132,128,136,140,140,136,140,136,136,140,
658 128,132,132,128,132,128,128,132,140,136,136,140,136,140,140,136,
659 160,164,164,160,164,160,160,164,172,168,168,172,168,172,172,168,
660 164,160,160,164,160,164,164,160,168,172,172,168,172,168,168,172,
661 };
662
663 /* incZ80Table[i] = (i & 0xa8) | (((i & 0xff) == 0) << 6) |
664 (((i & 0xf) == 0) << 4) | ((i == 0x80) << 2), i = 0..256 */
665 static const uint8 incZ80Table[257] = {
666 80, 0, 0, 0, 0, 0, 0, 0, 8, 8, 8, 8, 8, 8, 8, 8,
667 16, 0, 0, 0, 0, 0, 0, 0, 8, 8, 8, 8, 8, 8, 8, 8,
668 48, 32, 32, 32, 32, 32, 32, 32, 40, 40, 40, 40, 40, 40, 40, 40,
669 48, 32, 32, 32, 32, 32, 32, 32, 40, 40, 40, 40, 40, 40, 40, 40,
670 16, 0, 0, 0, 0, 0, 0, 0, 8, 8, 8, 8, 8, 8, 8, 8,
671 16, 0, 0, 0, 0, 0, 0, 0, 8, 8, 8, 8, 8, 8, 8, 8,
672 48, 32, 32, 32, 32, 32, 32, 32, 40, 40, 40, 40, 40, 40, 40, 40,
673 48, 32, 32, 32, 32, 32, 32, 32, 40, 40, 40, 40, 40, 40, 40, 40,
674 148,128,128,128,128,128,128,128,136,136,136,136,136,136,136,136,
675 144,128,128,128,128,128,128,128,136,136,136,136,136,136,136,136,
676 176,160,160,160,160,160,160,160,168,168,168,168,168,168,168,168,
677 176,160,160,160,160,160,160,160,168,168,168,168,168,168,168,168,
678 144,128,128,128,128,128,128,128,136,136,136,136,136,136,136,136,
679 144,128,128,128,128,128,128,128,136,136,136,136,136,136,136,136,
680 176,160,160,160,160,160,160,160,168,168,168,168,168,168,168,168,
681 176,160,160,160,160,160,160,160,168,168,168,168,168,168,168,168, 80,
682 };
683
684 /* decZ80Table[i] = (i & 0xa8) | (((i & 0xff) == 0) << 6) |
685 (((i & 0xf) == 0xf) << 4) | ((i == 0x7f) << 2) | 2, i = 0..255 */
686 static const uint8 decZ80Table[256] = {
687 66, 2, 2, 2, 2, 2, 2, 2, 10, 10, 10, 10, 10, 10, 10, 26,
688 2, 2, 2, 2, 2, 2, 2, 2, 10, 10, 10, 10, 10, 10, 10, 26,
689 34, 34, 34, 34, 34, 34, 34, 34, 42, 42, 42, 42, 42, 42, 42, 58,
690 34, 34, 34, 34, 34, 34, 34, 34, 42, 42, 42, 42, 42, 42, 42, 58,
691 2, 2, 2, 2, 2, 2, 2, 2, 10, 10, 10, 10, 10, 10, 10, 26,
692 2, 2, 2, 2, 2, 2, 2, 2, 10, 10, 10, 10, 10, 10, 10, 26,
693 34, 34, 34, 34, 34, 34, 34, 34, 42, 42, 42, 42, 42, 42, 42, 58,
694 34, 34, 34, 34, 34, 34, 34, 34, 42, 42, 42, 42, 42, 42, 42, 62,
695 130,130,130,130,130,130,130,130,138,138,138,138,138,138,138,154,
696 130,130,130,130,130,130,130,130,138,138,138,138,138,138,138,154,
697 162,162,162,162,162,162,162,162,170,170,170,170,170,170,170,186,
698 162,162,162,162,162,162,162,162,170,170,170,170,170,170,170,186,
699 130,130,130,130,130,130,130,130,138,138,138,138,138,138,138,154,
700 130,130,130,130,130,130,130,130,138,138,138,138,138,138,138,154,
701 162,162,162,162,162,162,162,162,170,170,170,170,170,170,170,186,
702 162,162,162,162,162,162,162,162,170,170,170,170,170,170,170,186,
703 };
704
705 /* cbitsZ80Table[i] = (i & 0x10) | (((i >> 6) ^ (i >> 5)) & 4) | ((i >> 8) & 1), i = 0..511 */
706 static const uint8 cbitsZ80Table[512] = {
707 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
708 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
709 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
710 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
711 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
712 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
713 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
714 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
715 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
716 20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,
717 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
718 20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,
719 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
720 20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,
721 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
722 20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,
723 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
724 21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,
725 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
726 21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,
727 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
728 21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,
729 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
730 21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,
731 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
732 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
733 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
734 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
735 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
736 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
737 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
738 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
739 };
740
741 /* cbitsZ80DupTable[i] = (i & 0x10) | (((i >> 6) ^ (i >> 5)) & 4) |
742 ((i >> 8) & 1) | (i & 0xa8), i = 0..511 */
743 static const uint8 cbitsZ80DupTable[512] = {
744 0, 0, 0, 0, 0, 0, 0, 0, 8, 8, 8, 8, 8, 8, 8, 8,
745 16, 16, 16, 16, 16, 16, 16, 16, 24, 24, 24, 24, 24, 24, 24, 24,
746 32, 32, 32, 32, 32, 32, 32, 32, 40, 40, 40, 40, 40, 40, 40, 40,
747 48, 48, 48, 48, 48, 48, 48, 48, 56, 56, 56, 56, 56, 56, 56, 56,
748 0, 0, 0, 0, 0, 0, 0, 0, 8, 8, 8, 8, 8, 8, 8, 8,
749 16, 16, 16, 16, 16, 16, 16, 16, 24, 24, 24, 24, 24, 24, 24, 24,
750 32, 32, 32, 32, 32, 32, 32, 32, 40, 40, 40, 40, 40, 40, 40, 40,
751 48, 48, 48, 48, 48, 48, 48, 48, 56, 56, 56, 56, 56, 56, 56, 56,
752 132,132,132,132,132,132,132,132,140,140,140,140,140,140,140,140,
753 148,148,148,148,148,148,148,148,156,156,156,156,156,156,156,156,
754 164,164,164,164,164,164,164,164,172,172,172,172,172,172,172,172,
755 180,180,180,180,180,180,180,180,188,188,188,188,188,188,188,188,
756 132,132,132,132,132,132,132,132,140,140,140,140,140,140,140,140,
757 148,148,148,148,148,148,148,148,156,156,156,156,156,156,156,156,
758 164,164,164,164,164,164,164,164,172,172,172,172,172,172,172,172,
759 180,180,180,180,180,180,180,180,188,188,188,188,188,188,188,188,
760 5, 5, 5, 5, 5, 5, 5, 5, 13, 13, 13, 13, 13, 13, 13, 13,
761 21, 21, 21, 21, 21, 21, 21, 21, 29, 29, 29, 29, 29, 29, 29, 29,
762 37, 37, 37, 37, 37, 37, 37, 37, 45, 45, 45, 45, 45, 45, 45, 45,
763 53, 53, 53, 53, 53, 53, 53, 53, 61, 61, 61, 61, 61, 61, 61, 61,
764 5, 5, 5, 5, 5, 5, 5, 5, 13, 13, 13, 13, 13, 13, 13, 13,
765 21, 21, 21, 21, 21, 21, 21, 21, 29, 29, 29, 29, 29, 29, 29, 29,
766 37, 37, 37, 37, 37, 37, 37, 37, 45, 45, 45, 45, 45, 45, 45, 45,
767 53, 53, 53, 53, 53, 53, 53, 53, 61, 61, 61, 61, 61, 61, 61, 61,
768 129,129,129,129,129,129,129,129,137,137,137,137,137,137,137,137,
769 145,145,145,145,145,145,145,145,153,153,153,153,153,153,153,153,
770 161,161,161,161,161,161,161,161,169,169,169,169,169,169,169,169,
771 177,177,177,177,177,177,177,177,185,185,185,185,185,185,185,185,
772 129,129,129,129,129,129,129,129,137,137,137,137,137,137,137,137,
773 145,145,145,145,145,145,145,145,153,153,153,153,153,153,153,153,
774 161,161,161,161,161,161,161,161,169,169,169,169,169,169,169,169,
775 177,177,177,177,177,177,177,177,185,185,185,185,185,185,185,185,
776 };
777
778 /* cbits2Z80Table[i] = (i & 0x10) | (((i >> 6) ^ (i >> 5)) & 4) | ((i >> 8) & 1) | 2, i = 0..511 */
779 static const uint8 cbits2Z80Table[512] = {
780 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
781 18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,
782 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
783 18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,
784 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
785 18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,
786 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
787 18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,
788 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
789 22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
790 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
791 22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
792 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
793 22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
794 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
795 22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
796 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
797 23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,
798 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
799 23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,
800 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
801 23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,
802 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
803 23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,
804 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
805 19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
806 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
807 19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
808 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
809 19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
810 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
811 19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
812 };
813
814 /* cbits2Z80DupTable[i] = (i & 0x10) | (((i >> 6) ^ (i >> 5)) & 4) | ((i >> 8) & 1) | 2 |
815 (i & 0xa8), i = 0..511 */
816 static const uint8 cbits2Z80DupTable[512] = {
817 2, 2, 2, 2, 2, 2, 2, 2, 10, 10, 10, 10, 10, 10, 10, 10,
818 18, 18, 18, 18, 18, 18, 18, 18, 26, 26, 26, 26, 26, 26, 26, 26,
819 34, 34, 34, 34, 34, 34, 34, 34, 42, 42, 42, 42, 42, 42, 42, 42,
820 50, 50, 50, 50, 50, 50, 50, 50, 58, 58, 58, 58, 58, 58, 58, 58,
821 2, 2, 2, 2, 2, 2, 2, 2, 10, 10, 10, 10, 10, 10, 10, 10,
822 18, 18, 18, 18, 18, 18, 18, 18, 26, 26, 26, 26, 26, 26, 26, 26,
823 34, 34, 34, 34, 34, 34, 34, 34, 42, 42, 42, 42, 42, 42, 42, 42,
824 50, 50, 50, 50, 50, 50, 50, 50, 58, 58, 58, 58, 58, 58, 58, 58,
825 134,134,134,134,134,134,134,134,142,142,142,142,142,142,142,142,
826 150,150,150,150,150,150,150,150,158,158,158,158,158,158,158,158,
827 166,166,166,166,166,166,166,166,174,174,174,174,174,174,174,174,
828 182,182,182,182,182,182,182,182,190,190,190,190,190,190,190,190,
829 134,134,134,134,134,134,134,134,142,142,142,142,142,142,142,142,
830 150,150,150,150,150,150,150,150,158,158,158,158,158,158,158,158,
831 166,166,166,166,166,166,166,166,174,174,174,174,174,174,174,174,
832 182,182,182,182,182,182,182,182,190,190,190,190,190,190,190,190,
833 7, 7, 7, 7, 7, 7, 7, 7, 15, 15, 15, 15, 15, 15, 15, 15,
834 23, 23, 23, 23, 23, 23, 23, 23, 31, 31, 31, 31, 31, 31, 31, 31,
835 39, 39, 39, 39, 39, 39, 39, 39, 47, 47, 47, 47, 47, 47, 47, 47,
836 55, 55, 55, 55, 55, 55, 55, 55, 63, 63, 63, 63, 63, 63, 63, 63,
837 7, 7, 7, 7, 7, 7, 7, 7, 15, 15, 15, 15, 15, 15, 15, 15,
838 23, 23, 23, 23, 23, 23, 23, 23, 31, 31, 31, 31, 31, 31, 31, 31,
839 39, 39, 39, 39, 39, 39, 39, 39, 47, 47, 47, 47, 47, 47, 47, 47,
840 55, 55, 55, 55, 55, 55, 55, 55, 63, 63, 63, 63, 63, 63, 63, 63,
841 131,131,131,131,131,131,131,131,139,139,139,139,139,139,139,139,
842 147,147,147,147,147,147,147,147,155,155,155,155,155,155,155,155,
843 163,163,163,163,163,163,163,163,171,171,171,171,171,171,171,171,
844 179,179,179,179,179,179,179,179,187,187,187,187,187,187,187,187,
845 131,131,131,131,131,131,131,131,139,139,139,139,139,139,139,139,
846 147,147,147,147,147,147,147,147,155,155,155,155,155,155,155,155,
847 163,163,163,163,163,163,163,163,171,171,171,171,171,171,171,171,
848 179,179,179,179,179,179,179,179,187,187,187,187,187,187,187,187,
849 };
850
851 /* negTable[i] = (((i & 0x0f) != 0) << 4) | ((i == 0x80) << 2) | 2 | (i != 0), i = 0..255 */
852 static const uint8 negTable[256] = {
853 2,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
854 3,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
855 3,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
856 3,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
857 3,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
858 3,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
859 3,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
860 3,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
861 7,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
862 3,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
863 3,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
864 3,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
865 3,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
866 3,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
867 3,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
868 3,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
869 };
870
871 /* rrdrldTable[i] = (i << 8) | (i & 0xa8) | (((i & 0xff) == 0) << 6) | parityTable[i], i = 0..255 */
872 static const uint16 rrdrldTable[256] = {
873 0x0044,0x0100,0x0200,0x0304,0x0400,0x0504,0x0604,0x0700,
874 0x0808,0x090c,0x0a0c,0x0b08,0x0c0c,0x0d08,0x0e08,0x0f0c,
875 0x1000,0x1104,0x1204,0x1300,0x1404,0x1500,0x1600,0x1704,
876 0x180c,0x1908,0x1a08,0x1b0c,0x1c08,0x1d0c,0x1e0c,0x1f08,
877 0x2020,0x2124,0x2224,0x2320,0x2424,0x2520,0x2620,0x2724,
878 0x282c,0x2928,0x2a28,0x2b2c,0x2c28,0x2d2c,0x2e2c,0x2f28,
879 0x3024,0x3120,0x3220,0x3324,0x3420,0x3524,0x3624,0x3720,
880 0x3828,0x392c,0x3a2c,0x3b28,0x3c2c,0x3d28,0x3e28,0x3f2c,
881 0x4000,0x4104,0x4204,0x4300,0x4404,0x4500,0x4600,0x4704,
882 0x480c,0x4908,0x4a08,0x4b0c,0x4c08,0x4d0c,0x4e0c,0x4f08,
883 0x5004,0x5100,0x5200,0x5304,0x5400,0x5504,0x5604,0x5700,
884 0x5808,0x590c,0x5a0c,0x5b08,0x5c0c,0x5d08,0x5e08,0x5f0c,
885 0x6024,0x6120,0x6220,0x6324,0x6420,0x6524,0x6624,0x6720,
886 0x6828,0x692c,0x6a2c,0x6b28,0x6c2c,0x6d28,0x6e28,0x6f2c,
887 0x7020,0x7124,0x7224,0x7320,0x7424,0x7520,0x7620,0x7724,
888 0x782c,0x7928,0x7a28,0x7b2c,0x7c28,0x7d2c,0x7e2c,0x7f28,
889 0x8080,0x8184,0x8284,0x8380,0x8484,0x8580,0x8680,0x8784,
890 0x888c,0x8988,0x8a88,0x8b8c,0x8c88,0x8d8c,0x8e8c,0x8f88,
891 0x9084,0x9180,0x9280,0x9384,0x9480,0x9584,0x9684,0x9780,
892 0x9888,0x998c,0x9a8c,0x9b88,0x9c8c,0x9d88,0x9e88,0x9f8c,
893 0xa0a4,0xa1a0,0xa2a0,0xa3a4,0xa4a0,0xa5a4,0xa6a4,0xa7a0,
894 0xa8a8,0xa9ac,0xaaac,0xaba8,0xacac,0xada8,0xaea8,0xafac,
895 0xb0a0,0xb1a4,0xb2a4,0xb3a0,0xb4a4,0xb5a0,0xb6a0,0xb7a4,
896 0xb8ac,0xb9a8,0xbaa8,0xbbac,0xbca8,0xbdac,0xbeac,0xbfa8,
897 0xc084,0xc180,0xc280,0xc384,0xc480,0xc584,0xc684,0xc780,
898 0xc888,0xc98c,0xca8c,0xcb88,0xcc8c,0xcd88,0xce88,0xcf8c,
899 0xd080,0xd184,0xd284,0xd380,0xd484,0xd580,0xd680,0xd784,
900 0xd88c,0xd988,0xda88,0xdb8c,0xdc88,0xdd8c,0xde8c,0xdf88,
901 0xe0a0,0xe1a4,0xe2a4,0xe3a0,0xe4a4,0xe5a0,0xe6a0,0xe7a4,
902 0xe8ac,0xe9a8,0xeaa8,0xebac,0xeca8,0xedac,0xeeac,0xefa8,
903 0xf0a4,0xf1a0,0xf2a0,0xf3a4,0xf4a0,0xf5a4,0xf6a4,0xf7a0,
904 0xf8a8,0xf9ac,0xfaac,0xfba8,0xfcac,0xfda8,0xfea8,0xffac,
905 };
906
907 /* cpTable[i] = (i & 0x80) | (((i & 0xff) == 0) << 6), i = 0..255 */
908 static const uint8 cpTable[256] = {
909 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
910 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
911 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
912 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
913 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
914 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
915 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
916 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
917 128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,
918 128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,
919 128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,
920 128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,
921 128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,
922 128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,
923 128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,
924 128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,
925 };
926
927 /* Memory management */
928
929 uint8 MOPT[MAXBANKSIZE]; /* RAM which is present */
930
931 static uint8 GET_BYTE(register uint32 Addr) {
932 return MOPT[Addr & ADDRMASK];
933 }
934
935 static void PUT_BYTE(register uint32 Addr, register uint32 Value) {
936 MOPT[Addr & ADDRMASK] = Value;
937 }
938
939 static void PUT_WORD(register uint32 Addr, register uint32 Value) {
940 MOPT[Addr & ADDRMASK] = Value;
941 MOPT[(Addr + 1) & ADDRMASK] = Value >> 8;
942 }
943
944 static uint16 GET_WORD(register uint32 a) {
945 return GET_BYTE(a) | (GET_BYTE(a + 1) << 8);
946 }
947
948 #define RAM_MM(a) GET_BYTE(a--)
949 #define RAM_PP(a) GET_BYTE(a++)
950
951 #define PUT_BYTE_PP(a,v) PUT_BYTE(a++, v)
952 #define PUT_BYTE_MM(a,v) PUT_BYTE(a--, v)
953 #define MM_PUT_BYTE(a,v) PUT_BYTE(--a, v)
954
955 #define PUSH(x) do { \
956 MM_PUT_BYTE(SP, (x) >> 8); \
957 MM_PUT_BYTE(SP, x); \
958 } while (0)
959
960 /* Macros for the IN/OUT instructions INI/INIR/IND/INDR/OUTI/OTIR/OUTD/OTDR
961
962 Pre condition
963 temp == value of register B at entry of the instruction
964 acu == value of transferred byte (IN or OUT)
965 Post condition
966 F is set correctly
967
968 Use INOUTFLAGS_ZERO(x) for INIR/INDR/OTIR/OTDR where
969 x == (C + 1) & 0xff for INIR
970 x == L for OTIR and OTDR
971 x == (C - 1) & 0xff for INDR
972 Use INOUTFLAGS_NONZERO(x) for INI/IND/OUTI/OUTD where
973 x == (C + 1) & 0xff for INI
974 x == L for OUTI and OUTD
975 x == (C - 1) & 0xff for IND
976 */
977 #define INOUTFLAGS(syxz, x) \
978 AF = (AF & 0xff00) | (syxz) | /* SF, YF, XF, ZF */ \
979 ((acu & 0x80) >> 6) | /* NF */ \
980 ((acu + (x)) > 0xff ? (FLAG_C | FLAG_H) : 0) | /* CF, HF */ \
981 parityTable[((acu + (x)) & 7) ^ temp] /* PF */
982
983 #define INOUTFLAGS_ZERO(x) INOUTFLAGS(FLAG_Z, x)
984 #define INOUTFLAGS_NONZERO(x) \
985 INOUTFLAGS((HIGH_REGISTER(BC) & 0xa8) | ((HIGH_REGISTER(BC) == 0) << 6), x)
986
987 t_stat sim_instr_nommu(void) {
988 extern int32 sim_interval;
989 extern uint32 sim_brk_summ;
990 int32 reason = 0;
991 register uint32 AF;
992 register uint32 BC;
993 register uint32 DE;
994 register uint32 HL;
995 register uint32 PC;
996 register uint32 SP;
997 register uint32 IX;
998 register uint32 IY;
999 register uint32 temp = 0;
1000 register uint32 acu = 0;
1001 register uint32 sum;
1002 register uint32 cbits;
1003 register uint32 op;
1004 register uint32 adr;
1005 register int32 l_sim_brk_summ;
1006
1007 AF = AF_S;
1008 BC = BC_S;
1009 DE = DE_S;
1010 HL = HL_S;
1011 PC = PC_S & ADDRMASK;
1012 SP = SP_S;
1013 IX = IX_S;
1014 IY = IY_S;
1015 l_sim_brk_summ = sim_brk_summ;
1016
1017 /* main instruction fetch/decode loop */
1018 while (TRUE) { /* loop until halted */
1019 if (sim_interval <= 0) { /* check clock queue */
1020 #if !UNIX_PLATFORM
1021 if ((reason = sim_poll_kbd()) == SCPE_STOP) break; /* poll on platforms without reliable signalling */
1022 #endif
1023 if ((reason = sim_process_event())) break;
1024 }
1025
1026 if (l_sim_brk_summ && sim_brk_test(PC, SWMASK('E'))) {/* breakpoint? */
1027 reason = STOP_IBKPT; /* stop simulation */
1028 break;
1029 }
1030
1031 PCX = PC;
1032 sim_interval--;
1033
1034 switch(RAM_PP(PC)) {
1035
1036 case 0x00: /* NOP */
1037 break;
1038
1039 case 0x01: /* LD BC,nnnn */
1040 BC = GET_WORD(PC);
1041 PC += 2;
1042 break;
1043
1044 case 0x02: /* LD (BC),A */
1045 PUT_BYTE(BC, HIGH_REGISTER(AF));
1046 break;
1047
1048 case 0x03: /* INC BC */
1049 ++BC;
1050 break;
1051
1052 case 0x04: /* INC B */
1053 BC += 0x100;
1054 temp = HIGH_REGISTER(BC);
1055 AF = (AF & ~0xfe) | incTable[temp] | SET_PV2(0x80); /* SET_PV2 uses temp */
1056 break;
1057
1058 case 0x05: /* DEC B */
1059 BC -= 0x100;
1060 temp = HIGH_REGISTER(BC);
1061 AF = (AF & ~0xfe) | decTable[temp] | SET_PV2(0x7f); /* SET_PV2 uses temp */
1062 break;
1063
1064 case 0x06: /* LD B,nn */
1065 SET_HIGH_REGISTER(BC, RAM_PP(PC));
1066 break;
1067
1068 case 0x07: /* RLCA */
1069 AF = ((AF >> 7) & 0x0128) | ((AF << 1) & ~0x1ff) |
1070 (AF & 0xc4) | ((AF >> 15) & 1);
1071 break;
1072
1073 case 0x08: /* EX AF,AF' */
1074 CHECK_CPU_8080;
1075 temp = AF;
1076 AF = AF1_S;
1077 AF1_S = temp;
1078 break;
1079
1080 case 0x09: /* ADD HL,BC */
1081 HL &= ADDRMASK;
1082 BC &= ADDRMASK;
1083 sum = HL + BC;
1084 AF = (AF & ~0x3b) | ((sum >> 8) & 0x28) | cbitsTable[(HL ^ BC ^ sum) >> 8];
1085 HL = sum;
1086 break;
1087
1088 case 0x0a: /* LD A,(BC) */
1089 SET_HIGH_REGISTER(AF, GET_BYTE(BC));
1090 break;
1091
1092 case 0x0b: /* DEC BC */
1093 --BC;
1094 break;
1095
1096 case 0x0c: /* INC C */
1097 temp = LOW_REGISTER(BC) + 1;
1098 SET_LOW_REGISTER(BC, temp);
1099 AF = (AF & ~0xfe) | incTable[temp] | SET_PV2(0x80);
1100 break;
1101
1102 case 0x0d: /* DEC C */
1103 temp = LOW_REGISTER(BC) - 1;
1104 SET_LOW_REGISTER(BC, temp);
1105 AF = (AF & ~0xfe) | decTable[temp & 0xff] | SET_PV2(0x7f);
1106 break;
1107
1108 case 0x0e: /* LD C,nn */
1109 SET_LOW_REGISTER(BC, RAM_PP(PC));
1110 break;
1111
1112 case 0x0f: /* RRCA */
1113 AF = (AF & 0xc4) | rrcaTable[HIGH_REGISTER(AF)];
1114 break;
1115
1116 case 0x10: /* DJNZ dd */
1117 CHECK_CPU_8080;
1118 if ((BC -= 0x100) & 0xff00) PC += (int8) GET_BYTE(PC) + 1;
1119 else PC++;
1120 break;
1121
1122 case 0x11: /* LD DE,nnnn */
1123 DE = GET_WORD(PC);
1124 PC += 2;
1125 break;
1126
1127 case 0x12: /* LD (DE),A */
1128 PUT_BYTE(DE, HIGH_REGISTER(AF));
1129 break;
1130
1131 case 0x13: /* INC DE */
1132 ++DE;
1133 break;
1134
1135 case 0x14: /* INC D */
1136 DE += 0x100;
1137 temp = HIGH_REGISTER(DE);
1138 AF = (AF & ~0xfe) | incTable[temp] | SET_PV2(0x80); /* SET_PV2 uses temp */
1139 break;
1140
1141 case 0x15: /* DEC D */
1142 DE -= 0x100;
1143 temp = HIGH_REGISTER(DE);
1144 AF = (AF & ~0xfe) | decTable[temp] | SET_PV2(0x7f); /* SET_PV2 uses temp */
1145 break;
1146
1147 case 0x16: /* LD D,nn */
1148 SET_HIGH_REGISTER(DE, RAM_PP(PC));
1149 break;
1150
1151 case 0x17: /* RLA */
1152 AF = ((AF << 8) & 0x0100) | ((AF >> 7) & 0x28) | ((AF << 1) & ~0x01ff) |
1153 (AF & 0xc4) | ((AF >> 15) & 1);
1154 break;
1155
1156 case 0x18: /* JR dd */
1157 CHECK_CPU_8080;
1158 PC += (int8) GET_BYTE(PC) + 1;
1159 break;
1160
1161 case 0x19: /* ADD HL,DE */
1162 HL &= ADDRMASK;
1163 DE &= ADDRMASK;
1164 sum = HL + DE;
1165 AF = (AF & ~0x3b) | ((sum >> 8) & 0x28) | cbitsTable[(HL ^ DE ^ sum) >> 8];
1166 HL = sum;
1167 break;
1168
1169 case 0x1a: /* LD A,(DE) */
1170 SET_HIGH_REGISTER(AF, GET_BYTE(DE));
1171 break;
1172
1173 case 0x1b: /* DEC DE */
1174 --DE;
1175 break;
1176
1177 case 0x1c: /* INC E */
1178 temp = LOW_REGISTER(DE) + 1;
1179 SET_LOW_REGISTER(DE, temp);
1180 AF = (AF & ~0xfe) | incTable[temp] | SET_PV2(0x80);
1181 break;
1182
1183 case 0x1d: /* DEC E */
1184 temp = LOW_REGISTER(DE) - 1;
1185 SET_LOW_REGISTER(DE, temp);
1186 AF = (AF & ~0xfe) | decTable[temp & 0xff] | SET_PV2(0x7f);
1187 break;
1188
1189 case 0x1e: /* LD E,nn */
1190 SET_LOW_REGISTER(DE, RAM_PP(PC));
1191 break;
1192
1193 case 0x1f: /* RRA */
1194 AF = ((AF & 1) << 15) | (AF & 0xc4) | rraTable[HIGH_REGISTER(AF)];
1195 break;
1196
1197 case 0x20: /* JR NZ,dd */
1198 CHECK_CPU_8080;
1199 if (TSTFLAG(Z)) PC++;
1200 else PC += (int8) GET_BYTE(PC) + 1;
1201 break;
1202
1203 case 0x21: /* LD HL,nnnn */
1204 HL = GET_WORD(PC);
1205 PC += 2;
1206 break;
1207
1208 case 0x22: /* LD (nnnn),HL */
1209 temp = GET_WORD(PC);
1210 PUT_WORD(temp, HL);
1211 PC += 2;
1212 break;
1213
1214 case 0x23: /* INC HL */
1215 ++HL;
1216 break;
1217
1218 case 0x24: /* INC H */
1219 HL += 0x100;
1220 temp = HIGH_REGISTER(HL);
1221 AF = (AF & ~0xfe) | incTable[temp] | SET_PV2(0x80); /* SET_PV2 uses temp */
1222 break;
1223
1224 case 0x25: /* DEC H */
1225 HL -= 0x100;
1226 temp = HIGH_REGISTER(HL);
1227 AF = (AF & ~0xfe) | decTable[temp] | SET_PV2(0x7f); /* SET_PV2 uses temp */
1228 break;
1229
1230 case 0x26: /* LD H,nn */
1231 SET_HIGH_REGISTER(HL, RAM_PP(PC));
1232 break;
1233
1234 case 0x27: /* DAA */
1235 acu = HIGH_REGISTER(AF);
1236 temp = LOW_DIGIT(acu);
1237 cbits = TSTFLAG(C);
1238 if (TSTFLAG(N)) { /* last operation was a subtract */
1239 int hd = cbits || acu > 0x99;
1240 if (TSTFLAG(H) || (temp > 9)) { /* adjust low digit */
1241 if (temp > 5) SETFLAG(H, 0);
1242 acu -= 6;
1243 acu &= 0xff;
1244 }
1245 if (hd) acu -= 0x160; /* adjust high digit */
1246 }
1247 else { /* last operation was an add */
1248 if (TSTFLAG(H) || (temp > 9)) { /* adjust low digit */
1249 SETFLAG(H, (temp > 9));
1250 acu += 6;
1251 }
1252 if (cbits || ((acu & 0x1f0) > 0x90)) acu += 0x60; /* adjust high digit */
1253 }
1254 AF = (AF & 0x12) | rrdrldTable[acu & 0xff] | ((acu >> 8) & 1) | cbits;
1255 break;
1256
1257 case 0x28: /* JR Z,dd */
1258 CHECK_CPU_8080;
1259 if (TSTFLAG(Z)) PC += (int8) GET_BYTE(PC) + 1;
1260 else PC++;
1261 break;
1262
1263 case 0x29: /* ADD HL,HL */
1264 HL &= ADDRMASK;
1265 sum = HL + HL;
1266 AF = (AF & ~0x3b) | cbitsDup16Table[sum >> 8];
1267 HL = sum;
1268 break;
1269
1270 case 0x2a: /* LD HL,(nnnn) */
1271 temp = GET_WORD(PC);
1272 HL = GET_WORD(temp);
1273 PC += 2;
1274 break;
1275
1276 case 0x2b: /* DEC HL */
1277 --HL;
1278 break;
1279
1280 case 0x2c: /* INC L */
1281 temp = LOW_REGISTER(HL) + 1;
1282 SET_LOW_REGISTER(HL, temp);
1283 AF = (AF & ~0xfe) | incTable[temp] | SET_PV2(0x80);
1284 break;
1285
1286 case 0x2d: /* DEC L */
1287 temp = LOW_REGISTER(HL) - 1;
1288 SET_LOW_REGISTER(HL, temp);
1289 AF = (AF & ~0xfe) | decTable[temp & 0xff] | SET_PV2(0x7f);
1290 break;
1291
1292 case 0x2e: /* LD L,nn */
1293 SET_LOW_REGISTER(HL, RAM_PP(PC));
1294 break;
1295
1296 case 0x2f: /* CPL */
1297 AF = (~AF & ~0xff) | (AF & 0xc5) | ((~AF >> 8) & 0x28) | 0x12;
1298 break;
1299
1300 case 0x30: /* JR NC,dd */
1301 CHECK_CPU_8080;
1302 if (TSTFLAG(C)) PC++;
1303 else PC += (int8) GET_BYTE(PC) + 1;
1304 break;
1305
1306 case 0x31: /* LD SP,nnnn */
1307 SP = GET_WORD(PC);
1308 PC += 2;
1309 break;
1310
1311 case 0x32: /* LD (nnnn),A */
1312 temp = GET_WORD(PC);
1313 PUT_BYTE(temp, HIGH_REGISTER(AF));
1314 PC += 2;
1315 break;
1316
1317 case 0x33: /* INC SP */
1318 ++SP;
1319 break;
1320
1321 case 0x34: /* INC (HL) */
1322 temp = GET_BYTE(HL) + 1;
1323 PUT_BYTE(HL, temp);
1324 AF = (AF & ~0xfe) | incTable[temp] | SET_PV2(0x80);
1325 break;
1326
1327 case 0x35: /* DEC (HL) */
1328 temp = GET_BYTE(HL) - 1;
1329 PUT_BYTE(HL, temp);
1330 AF = (AF & ~0xfe) | decTable[temp & 0xff] | SET_PV2(0x7f);
1331 break;
1332
1333 case 0x36: /* LD (HL),nn */
1334 PUT_BYTE(HL, RAM_PP(PC));
1335 break;
1336
1337 case 0x37: /* SCF */
1338 AF = (AF & ~0x3b) | ((AF >> 8) & 0x28) | 1;
1339 break;
1340
1341 case 0x38: /* JR C,dd */
1342 CHECK_CPU_8080;
1343 if (TSTFLAG(C)) PC += (int8) GET_BYTE(PC) + 1;
1344 else PC++;
1345 break;
1346
1347 case 0x39: /* ADD HL,SP */
1348 HL &= ADDRMASK;
1349 SP &= ADDRMASK;
1350 sum = HL + SP;
1351 AF = (AF & ~0x3b) | ((sum >> 8) & 0x28) | cbitsTable[(HL ^ SP ^ sum) >> 8];
1352 HL = sum;
1353 break;
1354
1355 case 0x3a: /* LD A,(nnnn) */
1356 temp = GET_WORD(PC);
1357 SET_HIGH_REGISTER(AF, GET_BYTE(temp));
1358 PC += 2;
1359 break;
1360
1361 case 0x3b: /* DEC SP */
1362 --SP;
1363 break;
1364
1365 case 0x3c: /* INC A */
1366 AF += 0x100;
1367 temp = HIGH_REGISTER(AF);
1368 AF = (AF & ~0xfe) | incTable[temp] | SET_PV2(0x80); /* SET_PV2 uses temp */
1369 break;
1370
1371 case 0x3d: /* DEC A */
1372 AF -= 0x100;
1373 temp = HIGH_REGISTER(AF);
1374 AF = (AF & ~0xfe) | decTable[temp] | SET_PV2(0x7f); /* SET_PV2 uses temp */
1375 break;
1376
1377 case 0x3e: /* LD A,nn */
1378 SET_HIGH_REGISTER(AF, RAM_PP(PC));
1379 break;
1380
1381 case 0x3f: /* CCF */
1382 AF = (AF & ~0x3b) | ((AF >> 8) & 0x28) | ((AF & 1) << 4) | (~AF & 1);
1383 break;
1384
1385 case 0x40: /* LD B,B */
1386 break;
1387
1388 case 0x41: /* LD B,C */
1389 BC = (BC & 0xff) | ((BC & 0xff) << 8);
1390 break;
1391
1392 case 0x42: /* LD B,D */
1393 BC = (BC & 0xff) | (DE & ~0xff);
1394 break;
1395
1396 case 0x43: /* LD B,E */
1397 BC = (BC & 0xff) | ((DE & 0xff) << 8);
1398 break;
1399
1400 case 0x44: /* LD B,H */
1401 BC = (BC & 0xff) | (HL & ~0xff);
1402 break;
1403
1404 case 0x45: /* LD B,L */
1405 BC = (BC & 0xff) | ((HL & 0xff) << 8);
1406 break;
1407
1408 case 0x46: /* LD B,(HL) */
1409 SET_HIGH_REGISTER(BC, GET_BYTE(HL));
1410 break;
1411
1412 case 0x47: /* LD B,A */
1413 BC = (BC & 0xff) | (AF & ~0xff);
1414 break;
1415
1416 case 0x48: /* LD C,B */
1417 BC = (BC & ~0xff) | ((BC >> 8) & 0xff);
1418 break;
1419
1420 case 0x49: /* LD C,C */
1421 break;
1422
1423 case 0x4a: /* LD C,D */
1424 BC = (BC & ~0xff) | ((DE >> 8) & 0xff);
1425 break;
1426
1427 case 0x4b: /* LD C,E */
1428 BC = (BC & ~0xff) | (DE & 0xff);
1429 break;
1430
1431 case 0x4c: /* LD C,H */
1432 BC = (BC & ~0xff) | ((HL >> 8) & 0xff);
1433 break;
1434
1435 case 0x4d: /* LD C,L */
1436 BC = (BC & ~0xff) | (HL & 0xff);
1437 break;
1438
1439 case 0x4e: /* LD C,(HL) */
1440 SET_LOW_REGISTER(BC, GET_BYTE(HL));
1441 break;
1442
1443 case 0x4f: /* LD C,A */
1444 BC = (BC & ~0xff) | ((AF >> 8) & 0xff);
1445 break;
1446
1447 case 0x50: /* LD D,B */
1448 DE = (DE & 0xff) | (BC & ~0xff);
1449 break;
1450
1451 case 0x51: /* LD D,C */
1452 DE = (DE & 0xff) | ((BC & 0xff) << 8);
1453 break;
1454
1455 case 0x52: /* LD D,D */
1456 break;
1457
1458 case 0x53: /* LD D,E */
1459 DE = (DE & 0xff) | ((DE & 0xff) << 8);
1460 break;
1461
1462 case 0x54: /* LD D,H */
1463 DE = (DE & 0xff) | (HL & ~0xff);
1464 break;
1465
1466 case 0x55: /* LD D,L */
1467 DE = (DE & 0xff) | ((HL & 0xff) << 8);
1468 break;
1469
1470 case 0x56: /* LD D,(HL) */
1471 SET_HIGH_REGISTER(DE, GET_BYTE(HL));
1472 break;
1473
1474 case 0x57: /* LD D,A */
1475 DE = (DE & 0xff) | (AF & ~0xff);
1476 break;
1477
1478 case 0x58: /* LD E,B */
1479 DE = (DE & ~0xff) | ((BC >> 8) & 0xff);
1480 break;
1481
1482 case 0x59: /* LD E,C */
1483 DE = (DE & ~0xff) | (BC & 0xff);
1484 break;
1485
1486 case 0x5a: /* LD E,D */
1487 DE = (DE & ~0xff) | ((DE >> 8) & 0xff);
1488 break;
1489
1490 case 0x5b: /* LD E,E */
1491 break;
1492
1493 case 0x5c: /* LD E,H */
1494 DE = (DE & ~0xff) | ((HL >> 8) & 0xff);
1495 break;
1496
1497 case 0x5d: /* LD E,L */
1498 DE = (DE & ~0xff) | (HL & 0xff);
1499 break;
1500
1501 case 0x5e: /* LD E,(HL) */
1502 SET_LOW_REGISTER(DE, GET_BYTE(HL));
1503 break;
1504
1505 case 0x5f: /* LD E,A */
1506 DE = (DE & ~0xff) | ((AF >> 8) & 0xff);
1507 break;
1508
1509 case 0x60: /* LD H,B */
1510 HL = (HL & 0xff) | (BC & ~0xff);
1511 break;
1512
1513 case 0x61: /* LD H,C */
1514 HL = (HL & 0xff) | ((BC & 0xff) << 8);
1515 break;
1516
1517 case 0x62: /* LD H,D */
1518 HL = (HL & 0xff) | (DE & ~0xff);
1519 break;
1520
1521 case 0x63: /* LD H,E */
1522 HL = (HL & 0xff) | ((DE & 0xff) << 8);
1523 break;
1524
1525 case 0x64: /* LD H,H */
1526 break;
1527
1528 case 0x65: /* LD H,L */
1529 HL = (HL & 0xff) | ((HL & 0xff) << 8);
1530 break;
1531
1532 case 0x66: /* LD H,(HL) */
1533 SET_HIGH_REGISTER(HL, GET_BYTE(HL));
1534 break;
1535
1536 case 0x67: /* LD H,A */
1537 HL = (HL & 0xff) | (AF & ~0xff);
1538 break;
1539
1540 case 0x68: /* LD L,B */
1541 HL = (HL & ~0xff) | ((BC >> 8) & 0xff);
1542 break;
1543
1544 case 0x69: /* LD L,C */
1545 HL = (HL & ~0xff) | (BC & 0xff);
1546 break;
1547
1548 case 0x6a: /* LD L,D */
1549 HL = (HL & ~0xff) | ((DE >> 8) & 0xff);
1550 break;
1551
1552 case 0x6b: /* LD L,E */
1553 HL = (HL & ~0xff) | (DE & 0xff);
1554 break;
1555
1556 case 0x6c: /* LD L,H */
1557 HL = (HL & ~0xff) | ((HL >> 8) & 0xff);
1558 break;
1559
1560 case 0x6d: /* LD L,L */
1561 break;
1562
1563 case 0x6e: /* LD L,(HL) */
1564 SET_LOW_REGISTER(HL, GET_BYTE(HL));
1565 break;
1566
1567 case 0x6f: /* LD L,A */
1568 HL = (HL & ~0xff) | ((AF >> 8) & 0xff);
1569 break;
1570
1571 case 0x70: /* LD (HL),B */
1572 PUT_BYTE(HL, HIGH_REGISTER(BC));
1573 break;
1574
1575 case 0x71: /* LD (HL),C */
1576 PUT_BYTE(HL, LOW_REGISTER(BC));
1577 break;
1578
1579 case 0x72: /* LD (HL),D */
1580 PUT_BYTE(HL, HIGH_REGISTER(DE));
1581 break;
1582
1583 case 0x73: /* LD (HL),E */
1584 PUT_BYTE(HL, LOW_REGISTER(DE));
1585 break;
1586
1587 case 0x74: /* LD (HL),H */
1588 PUT_BYTE(HL, HIGH_REGISTER(HL));
1589 break;
1590
1591 case 0x75: /* LD (HL),L */
1592 PUT_BYTE(HL, LOW_REGISTER(HL));
1593 break;
1594
1595 case 0x76: /* HALT */
1596 PC--;
1597 if (cpu_unit.flags & UNIT_CPU_STOPONHALT) {
1598 reason = STOP_HALT;
1599 goto end_decode;
1600 }
1601 sim_interval = 0;
1602 break;
1603
1604 case 0x77: /* LD (HL),A */
1605 PUT_BYTE(HL, HIGH_REGISTER(AF));
1606 break;
1607
1608 case 0x78: /* LD A,B */
1609 AF = (AF & 0xff) | (BC & ~0xff);
1610 break;
1611
1612 case 0x79: /* LD A,C */
1613 AF = (AF & 0xff) | ((BC & 0xff) << 8);
1614 break;
1615
1616 case 0x7a: /* LD A,D */
1617 AF = (AF & 0xff) | (DE & ~0xff);
1618 break;
1619
1620 case 0x7b: /* LD A,E */
1621 AF = (AF & 0xff) | ((DE & 0xff) << 8);
1622 break;
1623
1624 case 0x7c: /* LD A,H */
1625 AF = (AF & 0xff) | (HL & ~0xff);
1626 break;
1627
1628 case 0x7d: /* LD A,L */
1629 AF = (AF & 0xff) | ((HL & 0xff) << 8);
1630 break;
1631
1632 case 0x7e: /* LD A,(HL) */
1633 SET_HIGH_REGISTER(AF, GET_BYTE(HL));
1634 break;
1635
1636 case 0x7f: /* LD A,A */
1637 break;
1638
1639 case 0x80: /* ADD A,B */
1640 temp = HIGH_REGISTER(BC);
1641 acu = HIGH_REGISTER(AF);
1642 sum = acu + temp;
1643 cbits = acu ^ temp ^ sum;
1644 AF = addTable[sum] | cbitsTable[cbits] | (SET_PV);
1645 break;
1646
1647 case 0x81: /* ADD A,C */
1648 temp = LOW_REGISTER(BC);
1649 acu = HIGH_REGISTER(AF);
1650 sum = acu + temp;
1651 cbits = acu ^ temp ^ sum;
1652 AF = addTable[sum] | cbitsTable[cbits] | (SET_PV);
1653 break;
1654
1655 case 0x82: /* ADD A,D */
1656 temp = HIGH_REGISTER(DE);
1657 acu = HIGH_REGISTER(AF);
1658 sum = acu + temp;
1659 cbits = acu ^ temp ^ sum;
1660 AF = addTable[sum] | cbitsTable[cbits] | (SET_PV);
1661 break;
1662
1663 case 0x83: /* ADD A,E */
1664 temp = LOW_REGISTER(DE);
1665 acu = HIGH_REGISTER(AF);
1666 sum = acu + temp;
1667 cbits = acu ^ temp ^ sum;
1668 AF = addTable[sum] | cbitsTable[cbits] | (SET_PV);
1669 break;
1670
1671 case 0x84: /* ADD A,H */
1672 temp = HIGH_REGISTER(HL);
1673 acu = HIGH_REGISTER(AF);
1674 sum = acu + temp;
1675 cbits = acu ^ temp ^ sum;
1676 AF = addTable[sum] | cbitsTable[cbits] | (SET_PV);
1677 break;
1678
1679 case 0x85: /* ADD A,L */
1680 temp = LOW_REGISTER(HL);
1681 acu = HIGH_REGISTER(AF);
1682 sum = acu + temp;
1683 cbits = acu ^ temp ^ sum;
1684 AF = addTable[sum] | cbitsTable[cbits] | (SET_PV);
1685 break;
1686
1687 case 0x86: /* ADD A,(HL) */
1688 temp = GET_BYTE(HL);
1689 acu = HIGH_REGISTER(AF);
1690 sum = acu + temp;
1691 cbits = acu ^ temp ^ sum;
1692 AF = addTable[sum] | cbitsTable[cbits] | (SET_PV);
1693 break;
1694
1695 case 0x87: /* ADD A,A */
1696 cbits = 2 * HIGH_REGISTER(AF);
1697 AF = cbitsDup8Table[cbits] | (SET_PVS(cbits));
1698 break;
1699
1700 case 0x88: /* ADC A,B */
1701 temp = HIGH_REGISTER(BC);
1702 acu = HIGH_REGISTER(AF);
1703 sum = acu + temp + TSTFLAG(C);
1704 cbits = acu ^ temp ^ sum;
1705 AF = addTable[sum] | cbitsTable[cbits] | (SET_PV);
1706 break;
1707
1708 case 0x89: /* ADC A,C */
1709 temp = LOW_REGISTER(BC);
1710 acu = HIGH_REGISTER(AF);
1711 sum = acu + temp + TSTFLAG(C);
1712 cbits = acu ^ temp ^ sum;
1713 AF = addTable[sum] | cbitsTable[cbits] | (SET_PV);
1714 break;
1715
1716 case 0x8a: /* ADC A,D */
1717 temp = HIGH_REGISTER(DE);
1718 acu = HIGH_REGISTER(AF);
1719 sum = acu + temp + TSTFLAG(C);
1720 cbits = acu ^ temp ^ sum;
1721 AF = addTable[sum] | cbitsTable[cbits] | (SET_PV);
1722 break;
1723
1724 case 0x8b: /* ADC A,E */
1725 temp = LOW_REGISTER(DE);
1726 acu = HIGH_REGISTER(AF);
1727 sum = acu + temp + TSTFLAG(C);
1728 cbits = acu ^ temp ^ sum;
1729 AF = addTable[sum] | cbitsTable[cbits] | (SET_PV);
1730 break;
1731
1732 case 0x8c: /* ADC A,H */
1733 temp = HIGH_REGISTER(HL);
1734 acu = HIGH_REGISTER(AF);
1735 sum = acu + temp + TSTFLAG(C);
1736 cbits = acu ^ temp ^ sum;
1737 AF = addTable[sum] | cbitsTable[cbits] | (SET_PV);
1738 break;
1739
1740 case 0x8d: /* ADC A,L */
1741 temp = LOW_REGISTER(HL);
1742 acu = HIGH_REGISTER(AF);
1743 sum = acu + temp + TSTFLAG(C);
1744 cbits = acu ^ temp ^ sum;
1745 AF = addTable[sum] | cbitsTable[cbits] | (SET_PV);
1746 break;
1747
1748 case 0x8e: /* ADC A,(HL) */
1749 temp = GET_BYTE(HL);
1750 acu = HIGH_REGISTER(AF);
1751 sum = acu + temp + TSTFLAG(C);
1752 cbits = acu ^ temp ^ sum;
1753 AF = addTable[sum] | cbitsTable[cbits] | (SET_PV);
1754 break;
1755
1756 case 0x8f: /* ADC A,A */
1757 cbits = 2 * HIGH_REGISTER(AF) + TSTFLAG(C);
1758 AF = cbitsDup8Table[cbits] | (SET_PVS(cbits));
1759 break;
1760
1761 case 0x90: /* SUB B */
1762 temp = HIGH_REGISTER(BC);
1763 acu = HIGH_REGISTER(AF);
1764 sum = acu - temp;
1765 cbits = acu ^ temp ^ sum;
1766 AF = subTable[sum & 0xff] | cbitsTable[cbits & 0x1ff] | (SET_PV);
1767 break;
1768
1769 case 0x91: /* SUB C */
1770 temp = LOW_REGISTER(BC);
1771 acu = HIGH_REGISTER(AF);
1772 sum = acu - temp;
1773 cbits = acu ^ temp ^ sum;
1774 AF = subTable[sum & 0xff] | cbitsTable[cbits & 0x1ff] | (SET_PV);
1775 break;
1776
1777 case 0x92: /* SUB D */
1778 temp = HIGH_REGISTER(DE);
1779 acu = HIGH_REGISTER(AF);
1780 sum = acu - temp;
1781 cbits = acu ^ temp ^ sum;
1782 AF = subTable[sum & 0xff] | cbitsTable[cbits & 0x1ff] | (SET_PV);
1783 break;
1784
1785 case 0x93: /* SUB E */
1786 temp = LOW_REGISTER(DE);
1787 acu = HIGH_REGISTER(AF);
1788 sum = acu - temp;
1789 cbits = acu ^ temp ^ sum;
1790 AF = subTable[sum & 0xff] | cbitsTable[cbits & 0x1ff] | (SET_PV);
1791 break;
1792
1793 case 0x94: /* SUB H */
1794 temp = HIGH_REGISTER(HL);
1795 acu = HIGH_REGISTER(AF);
1796 sum = acu - temp;
1797 cbits = acu ^ temp ^ sum;
1798 AF = subTable[sum & 0xff] | cbitsTable[cbits & 0x1ff] | (SET_PV);
1799 break;
1800
1801 case 0x95: /* SUB L */
1802 temp = LOW_REGISTER(HL);
1803 acu = HIGH_REGISTER(AF);
1804 sum = acu - temp;
1805 cbits = acu ^ temp ^ sum;
1806 AF = subTable[sum & 0xff] | cbitsTable[cbits & 0x1ff] | (SET_PV);
1807 break;
1808
1809 case 0x96: /* SUB (HL) */
1810 temp = GET_BYTE(HL);
1811 acu = HIGH_REGISTER(AF);
1812 sum = acu - temp;
1813 cbits = acu ^ temp ^ sum;
1814 AF = subTable[sum & 0xff] | cbitsTable[cbits & 0x1ff] | (SET_PV);
1815 break;
1816
1817 case 0x97: /* SUB A */
1818 AF = (chiptype == CHIP_TYPE_Z80) ? 0x42 : 0x46;
1819 break;
1820
1821 case 0x98: /* SBC A,B */
1822 temp = HIGH_REGISTER(BC);
1823 acu = HIGH_REGISTER(AF);
1824 sum = acu - temp - TSTFLAG(C);
1825 cbits = acu ^ temp ^ sum;
1826 AF = subTable[sum & 0xff] | cbitsTable[cbits & 0x1ff] | (SET_PV);
1827 break;
1828
1829 case 0x99: /* SBC A,C */
1830 temp = LOW_REGISTER(BC);
1831 acu = HIGH_REGISTER(AF);
1832 sum = acu - temp - TSTFLAG(C);
1833 cbits = acu ^ temp ^ sum;
1834 AF = subTable[sum & 0xff] | cbitsTable[cbits & 0x1ff] | (SET_PV);
1835 break;
1836
1837 case 0x9a: /* SBC A,D */
1838 temp = HIGH_REGISTER(DE);
1839 acu = HIGH_REGISTER(AF);
1840 sum = acu - temp - TSTFLAG(C);
1841 cbits = acu ^ temp ^ sum;
1842 AF = subTable[sum & 0xff] | cbitsTable[cbits & 0x1ff] | (SET_PV);
1843 break;
1844
1845 case 0x9b: /* SBC A,E */
1846 temp = LOW_REGISTER(DE);
1847 acu = HIGH_REGISTER(AF);
1848 sum = acu - temp - TSTFLAG(C);
1849 cbits = acu ^ temp ^ sum;
1850 AF = subTable[sum & 0xff] | cbitsTable[cbits & 0x1ff] | (SET_PV);
1851 break;
1852
1853 case 0x9c: /* SBC A,H */
1854 temp = HIGH_REGISTER(HL);
1855 acu = HIGH_REGISTER(AF);
1856 sum = acu - temp - TSTFLAG(C);
1857 cbits = acu ^ temp ^ sum;
1858 AF = subTable[sum & 0xff] | cbitsTable[cbits & 0x1ff] | (SET_PV);
1859 break;
1860
1861 case 0x9d: /* SBC A,L */
1862 temp = LOW_REGISTER(HL);
1863 acu = HIGH_REGISTER(AF);
1864 sum = acu - temp - TSTFLAG(C);
1865 cbits = acu ^ temp ^ sum;
1866 AF = subTable[sum & 0xff] | cbitsTable[cbits & 0x1ff] | (SET_PV);
1867 break;
1868
1869 case 0x9e: /* SBC A,(HL) */
1870 temp = GET_BYTE(HL);
1871 acu = HIGH_REGISTER(AF);
1872 sum = acu - temp - TSTFLAG(C);
1873 cbits = acu ^ temp ^ sum;
1874 AF = subTable[sum & 0xff] | cbitsTable[cbits & 0x1ff] | (SET_PV);
1875 break;
1876
1877 case 0x9f: /* SBC A,A */
1878 cbits = -TSTFLAG(C);
1879 AF = subTable[cbits & 0xff] | cbitsTable[cbits & 0x1ff] | (SET_PVS(cbits));
1880 break;
1881
1882 case 0xa0: /* AND B */
1883 AF = andTable[((AF & BC) >> 8) & 0xff];
1884 break;
1885
1886 case 0xa1: /* AND C */
1887 AF = andTable[((AF >> 8) & BC) & 0xff];
1888 break;
1889
1890 case 0xa2: /* AND D */
1891 AF = andTable[((AF & DE) >> 8) & 0xff];
1892 break;
1893
1894 case 0xa3: /* AND E */
1895 AF = andTable[((AF >> 8) & DE) & 0xff];
1896 break;
1897
1898 case 0xa4: /* AND H */
1899 AF = andTable[((AF & HL) >> 8) & 0xff];
1900 break;
1901
1902 case 0xa5: /* AND L */
1903 AF = andTable[((AF >> 8) & HL) & 0xff];
1904 break;
1905
1906 case 0xa6: /* AND (HL) */
1907 AF = andTable[((AF >> 8) & GET_BYTE(HL)) & 0xff];
1908 break;
1909
1910 case 0xa7: /* AND A */
1911 AF = andTable[(AF >> 8) & 0xff];
1912 break;
1913
1914 case 0xa8: /* XOR B */
1915 AF = xororTable[((AF ^ BC) >> 8) & 0xff];
1916 break;
1917
1918 case 0xa9: /* XOR C */
1919 AF = xororTable[((AF >> 8) ^ BC) & 0xff];
1920 break;
1921
1922 case 0xaa: /* XOR D */
1923 AF = xororTable[((AF ^ DE) >> 8) & 0xff];
1924 break;
1925
1926 case 0xab: /* XOR E */
1927 AF = xororTable[((AF >> 8) ^ DE) & 0xff];
1928 break;
1929
1930 case 0xac: /* XOR H */
1931 AF = xororTable[((AF ^ HL) >> 8) & 0xff];
1932 break;
1933
1934 case 0xad: /* XOR L */
1935 AF = xororTable[((AF >> 8) ^ HL) & 0xff];
1936 break;
1937
1938 case 0xae: /* XOR (HL) */
1939 AF = xororTable[((AF >> 8) ^ GET_BYTE(HL)) & 0xff];
1940 break;
1941
1942 case 0xaf: /* XOR A */
1943 AF = 0x44;
1944 break;
1945
1946 case 0xb0: /* OR B */
1947 AF = xororTable[((AF | BC) >> 8) & 0xff];
1948 break;
1949
1950 case 0xb1: /* OR C */
1951 AF = xororTable[((AF >> 8) | BC) & 0xff];
1952 break;
1953
1954 case 0xb2: /* OR D */
1955 AF = xororTable[((AF | DE) >> 8) & 0xff];
1956 break;
1957
1958 case 0xb3: /* OR E */
1959 AF = xororTable[((AF >> 8) | DE) & 0xff];
1960 break;
1961
1962 case 0xb4: /* OR H */
1963 AF = xororTable[((AF | HL) >> 8) & 0xff];
1964 break;
1965
1966 case 0xb5: /* OR L */
1967 AF = xororTable[((AF >> 8) | HL) & 0xff];
1968 break;
1969
1970 case 0xb6: /* OR (HL) */
1971 AF = xororTable[((AF >> 8) | GET_BYTE(HL)) & 0xff];
1972 break;
1973
1974 case 0xb7: /* OR A */
1975 AF = xororTable[(AF >> 8) & 0xff];
1976 break;
1977
1978 case 0xb8: /* CP B */
1979 temp = HIGH_REGISTER(BC);
1980 AF = (AF & ~0x28) | (temp & 0x28);
1981 acu = HIGH_REGISTER(AF);
1982 sum = acu - temp;
1983 cbits = acu ^ temp ^ sum;
1984 AF = (AF & ~0xff) | cpTable[sum & 0xff] | (temp & 0x28) |
1985 (SET_PV) | cbits2Table[cbits & 0x1ff];
1986 break;
1987
1988 case 0xb9: /* CP C */
1989 temp = LOW_REGISTER(BC);
1990 AF = (AF & ~0x28) | (temp & 0x28);
1991 acu = HIGH_REGISTER(AF);
1992 sum = acu - temp;
1993 cbits = acu ^ temp ^ sum;
1994 AF = (AF & ~0xff) | cpTable[sum & 0xff] | (temp & 0x28) |
1995 (SET_PV) | cbits2Table[cbits & 0x1ff];
1996 break;
1997
1998 case 0xba: /* CP D */
1999 temp = HIGH_REGISTER(DE);
2000 AF = (AF & ~0x28) | (temp & 0x28);
2001 acu = HIGH_REGISTER(AF);
2002 sum = acu - temp;
2003 cbits = acu ^ temp ^ sum;
2004 AF = (AF & ~0xff) | cpTable[sum & 0xff] | (temp & 0x28) |
2005 (SET_PV) | cbits2Table[cbits & 0x1ff];
2006 break;
2007
2008 case 0xbb: /* CP E */
2009 temp = LOW_REGISTER(DE);
2010 AF = (AF & ~0x28) | (temp & 0x28);
2011 acu = HIGH_REGISTER(AF);
2012 sum = acu - temp;
2013 cbits = acu ^ temp ^ sum;
2014 AF = (AF & ~0xff) | cpTable[sum & 0xff] | (temp & 0x28) |
2015 (SET_PV) | cbits2Table[cbits & 0x1ff];
2016 break;
2017
2018 case 0xbc: /* CP H */
2019 temp = HIGH_REGISTER(HL);
2020 AF = (AF & ~0x28) | (temp & 0x28);
2021 acu = HIGH_REGISTER(AF);
2022 sum = acu - temp;
2023 cbits = acu ^ temp ^ sum;
2024 AF = (AF & ~0xff) | cpTable[sum & 0xff] | (temp & 0x28) |
2025 (SET_PV) | cbits2Table[cbits & 0x1ff];
2026 break;
2027
2028 case 0xbd: /* CP L */
2029 temp = LOW_REGISTER(HL);
2030 AF = (AF & ~0x28) | (temp & 0x28);
2031 acu = HIGH_REGISTER(AF);
2032 sum = acu - temp;
2033 cbits = acu ^ temp ^ sum;
2034 AF = (AF & ~0xff) | cpTable[sum & 0xff] | (temp & 0x28) |
2035 (SET_PV) | cbits2Table[cbits & 0x1ff];
2036 break;
2037
2038 case 0xbe: /* CP (HL) */
2039 temp = GET_BYTE(HL);
2040 AF = (AF & ~0x28) | (temp & 0x28);
2041 acu = HIGH_REGISTER(AF);
2042 sum = acu - temp;
2043 cbits = acu ^ temp ^ sum;
2044 AF = (AF & ~0xff) | cpTable[sum & 0xff] | (temp & 0x28) |
2045 (SET_PV) | cbits2Table[cbits & 0x1ff];
2046 break;
2047
2048 case 0xbf: /* CP A */
2049 SET_LOW_REGISTER(AF, (HIGH_REGISTER(AF) & 0x28) | (chiptype == CHIP_TYPE_Z80 ? 0x42 : 0x46));
2050 break;
2051
2052 case 0xc0: /* RET NZ */
2053 if (!(TSTFLAG(Z))) POP(PC);
2054 break;
2055
2056 case 0xc1: /* POP BC */
2057 POP(BC);
2058 break;
2059
2060 case 0xc2: /* JP NZ,nnnn */
2061 JPC(!TSTFLAG(Z));
2062 break;
2063
2064 case 0xc3: /* JP nnnn */
2065 JPC(1);
2066 break;
2067
2068 case 0xc4: /* CALL NZ,nnnn */
2069 CALLC(!TSTFLAG(Z));
2070 break;
2071
2072 case 0xc5: /* PUSH BC */
2073 PUSH(BC);
2074 break;
2075
2076 case 0xc6: /* ADD A,nn */
2077 temp = RAM_PP(PC);
2078 acu = HIGH_REGISTER(AF);
2079 sum = acu + temp;
2080 cbits = acu ^ temp ^ sum;
2081 AF = addTable[sum] | cbitsTable[cbits] | (SET_PV);
2082 break;
2083
2084 case 0xc7: /* RST 0 */
2085 PUSH(PC);
2086 PC = 0;
2087 break;
2088
2089 case 0xc8: /* RET Z */
2090 if (TSTFLAG(Z)) POP(PC);
2091 break;
2092
2093 case 0xc9: /* RET */
2094 POP(PC);
2095 break;
2096
2097 case 0xca: /* JP Z,nnnn */
2098 JPC(TSTFLAG(Z));
2099 break;
2100
2101 case 0xcb: /* CB prefix */
2102 CHECK_CPU_8080;
2103 adr = HL;
2104 switch ((op = GET_BYTE(PC)) & 7) {
2105
2106 case 0:
2107 ++PC;
2108 acu = HIGH_REGISTER(BC);
2109 break;
2110
2111 case 1:
2112 ++PC;
2113 acu = LOW_REGISTER(BC);
2114 break;
2115
2116 case 2:
2117 ++PC;
2118 acu = HIGH_REGISTER(DE);
2119 break;
2120
2121 case 3:
2122 ++PC;
2123 acu = LOW_REGISTER(DE);
2124 break;
2125
2126 case 4:
2127 ++PC;
2128 acu = HIGH_REGISTER(HL);
2129 break;
2130
2131 case 5:
2132 ++PC;
2133 acu = LOW_REGISTER(HL);
2134 break;
2135
2136 case 6:
2137 ++PC;
2138 acu = GET_BYTE(adr);
2139 break;
2140
2141 case 7:
2142 ++PC;
2143 acu = HIGH_REGISTER(AF);
2144 break;
2145 }
2146 switch (op & 0xc0) {
2147
2148 case 0x00: /* shift/rotate */
2149 switch (op & 0x38) {
2150
2151 case 0x00:/* RLC */
2152 temp = (acu << 1) | (acu >> 7);
2153 cbits = temp & 1;
2154 goto cbshflg1;
2155
2156 case 0x08:/* RRC */
2157 temp = (acu >> 1) | (acu << 7);
2158 cbits = temp & 0x80;
2159 goto cbshflg1;
2160
2161 case 0x10:/* RL */
2162 temp = (acu << 1) | TSTFLAG(C);
2163 cbits = acu & 0x80;
2164 goto cbshflg1;
2165
2166 case 0x18:/* RR */
2167 temp = (acu >> 1) | (TSTFLAG(C) << 7);
2168 cbits = acu & 1;
2169 goto cbshflg1;
2170
2171 case 0x20:/* SLA */
2172 temp = acu << 1;
2173 cbits = acu & 0x80;
2174 goto cbshflg1;
2175
2176 case 0x28:/* SRA */
2177 temp = (acu >> 1) | (acu & 0x80);
2178 cbits = acu & 1;
2179 goto cbshflg1;
2180
2181 case 0x30:/* SLIA */
2182 temp = (acu << 1) | 1;
2183 cbits = acu & 0x80;
2184 goto cbshflg1;
2185
2186 case 0x38:/* SRL */
2187 temp = acu >> 1;
2188 cbits = acu & 1;
2189 cbshflg1:
2190 AF = (AF & ~0xff) | rotateShiftTable[temp & 0xff] | !!cbits;
2191 }
2192 break;
2193
2194 case 0x40: /* BIT */
2195 if (acu & (1 << ((op >> 3) & 7)))
2196 AF = (AF & ~0xfe) | 0x10 | (((op & 0x38) == 0x38) << 7);
2197 else AF = (AF & ~0xfe) | 0x54;
2198 if ((op & 7) != 6) AF |= (acu & 0x28);
2199 temp = acu;
2200 break;
2201
2202 case 0x80: /* RES */
2203 temp = acu & ~(1 << ((op >> 3) & 7));
2204 break;
2205
2206 case 0xc0: /* SET */
2207 temp = acu | (1 << ((op >> 3) & 7));
2208 break;
2209 }
2210 switch (op & 7) {
2211
2212 case 0:
2213 SET_HIGH_REGISTER(BC, temp);
2214 break;
2215
2216 case 1:
2217 SET_LOW_REGISTER(BC, temp);
2218 break;
2219
2220 case 2:
2221 SET_HIGH_REGISTER(DE, temp);
2222 break;
2223
2224 case 3:
2225 SET_LOW_REGISTER(DE, temp);
2226 break;
2227
2228 case 4:
2229 SET_HIGH_REGISTER(HL, temp);
2230 break;
2231
2232 case 5:
2233 SET_LOW_REGISTER(HL, temp);
2234 break;
2235
2236 case 6:
2237 PUT_BYTE(adr, temp);
2238 break;
2239
2240 case 7:
2241 SET_HIGH_REGISTER(AF, temp);
2242 break;
2243 }
2244 break;
2245
2246 case 0xcc: /* CALL Z,nnnn */
2247 CALLC(TSTFLAG(Z));
2248 break;
2249
2250 case 0xcd: /* CALL nnnn */
2251 CALLC(1);
2252 break;
2253
2254 case 0xce: /* ADC A,nn */
2255 temp = RAM_PP(PC);
2256 acu = HIGH_REGISTER(AF);
2257 sum = acu + temp + TSTFLAG(C);
2258 cbits = acu ^ temp ^ sum;
2259 AF = addTable[sum] | cbitsTable[cbits] | (SET_PV);
2260 break;
2261
2262 case 0xcf: /* RST 8 */
2263 PUSH(PC);
2264 PC = 8;
2265 break;
2266
2267 case 0xd0: /* RET NC */
2268 if (!(TSTFLAG(C))) POP(PC);
2269 break;
2270
2271 case 0xd1: /* POP DE */
2272 POP(DE);
2273 break;
2274
2275 case 0xd2: /* JP NC,nnnn */
2276 JPC(!TSTFLAG(C));
2277 break;
2278
2279 case 0xd3: /* OUT (nn),A */
2280 out(RAM_PP(PC), HIGH_REGISTER(AF));
2281 break;
2282
2283 case 0xd4: /* CALL NC,nnnn */
2284 CALLC(!TSTFLAG(C));
2285 break;
2286
2287 case 0xd5: /* PUSH DE */
2288 PUSH(DE);
2289 break;
2290
2291 case 0xd6: /* SUB nn */
2292 temp = RAM_PP(PC);
2293 acu = HIGH_REGISTER(AF);
2294 sum = acu - temp;
2295 cbits = acu ^ temp ^ sum;
2296 AF = subTable[sum & 0xff] | cbitsTable[cbits & 0x1ff] | (SET_PV);
2297 break;
2298
2299 case 0xd7: /* RST 10H */
2300 PUSH(PC);
2301 PC = 0x10;
2302 break;
2303
2304 case 0xd8: /* RET C */
2305 if (TSTFLAG(C)) POP(PC);
2306 break;
2307
2308 case 0xd9: /* EXX */
2309 CHECK_CPU_8080;
2310 temp = BC;
2311 BC = BC1_S;
2312 BC1_S = temp;
2313 temp = DE;
2314 DE = DE1_S;
2315 DE1_S = temp;
2316 temp = HL;
2317 HL = HL1_S;
2318 HL1_S = temp;
2319 break;
2320
2321 case 0xda: /* JP C,nnnn */
2322 JPC(TSTFLAG(C));
2323 break;
2324
2325 case 0xdb: /* IN A,(nn) */
2326 SET_HIGH_REGISTER(AF, in(RAM_PP(PC)));
2327 break;
2328
2329 case 0xdc: /* CALL C,nnnn */
2330 CALLC(TSTFLAG(C));
2331 break;
2332
2333 case 0xdd: /* DD prefix */
2334 CHECK_CPU_8080;
2335 switch (op = RAM_PP(PC)) {
2336
2337 case 0x09: /* ADD IX,BC */
2338 IX &= ADDRMASK;
2339 BC &= ADDRMASK;
2340 sum = IX + BC;
2341 AF = (AF & ~0x3b) | ((sum >> 8) & 0x28) | cbitsTable[(IX ^ BC ^ sum) >> 8];
2342 IX = sum;
2343 break;
2344
2345 case 0x19: /* ADD IX,DE */
2346 IX &= ADDRMASK;
2347 DE &= ADDRMASK;
2348 sum = IX + DE;
2349 AF = (AF & ~0x3b) | ((sum >> 8) & 0x28) | cbitsTable[(IX ^ DE ^ sum) >> 8];
2350 IX = sum;
2351 break;
2352
2353 case 0x21: /* LD IX,nnnn */
2354 IX = GET_WORD(PC);
2355 PC += 2;
2356 break;
2357
2358 case 0x22: /* LD (nnnn),IX */
2359 temp = GET_WORD(PC);
2360 PUT_WORD(temp, IX);
2361 PC += 2;
2362 break;
2363
2364 case 0x23: /* INC IX */
2365 ++IX;
2366 break;
2367
2368 case 0x24: /* INC IXH */
2369 IX += 0x100;
2370 AF = (AF & ~0xfe) | incZ80Table[HIGH_REGISTER(IX)];
2371 break;
2372
2373 case 0x25: /* DEC IXH */
2374 IX -= 0x100;
2375 AF = (AF & ~0xfe) | decZ80Table[HIGH_REGISTER(IX)];
2376 break;
2377
2378 case 0x26: /* LD IXH,nn */
2379 SET_HIGH_REGISTER(IX, RAM_PP(PC));
2380 break;
2381
2382 case 0x29: /* ADD IX,IX */
2383 IX &= ADDRMASK;
2384 sum = IX + IX;
2385 AF = (AF & ~0x3b) | cbitsDup16Table[sum >> 8];
2386 IX = sum;
2387 break;
2388
2389 case 0x2a: /* LD IX,(nnnn) */
2390 temp = GET_WORD(PC);
2391 IX = GET_WORD(temp);
2392 PC += 2;
2393 break;
2394
2395 case 0x2b: /* DEC IX */
2396 --IX;
2397 break;
2398
2399 case 0x2c: /* INC IXL */
2400 temp = LOW_REGISTER(IX) + 1;
2401 SET_LOW_REGISTER(IX, temp);
2402 AF = (AF & ~0xfe) | incZ80Table[temp];
2403 break;
2404
2405 case 0x2d: /* DEC IXL */
2406 temp = LOW_REGISTER(IX) - 1;
2407 SET_LOW_REGISTER(IX, temp);
2408 AF = (AF & ~0xfe) | decZ80Table[temp & 0xff];
2409 break;
2410
2411 case 0x2e: /* LD IXL,nn */
2412 SET_LOW_REGISTER(IX, RAM_PP(PC));
2413 break;
2414
2415 case 0x34: /* INC (IX+dd) */
2416 adr = IX + (int8) RAM_PP(PC);
2417 temp = GET_BYTE(adr) + 1;
2418 PUT_BYTE(adr, temp);
2419 AF = (AF & ~0xfe) | incZ80Table[temp];
2420 break;
2421
2422 case 0x35: /* DEC (IX+dd) */
2423 adr = IX + (int8) RAM_PP(PC);
2424 temp = GET_BYTE(adr) - 1;
2425 PUT_BYTE(adr, temp);
2426 AF = (AF & ~0xfe) | decZ80Table[temp & 0xff];
2427 break;
2428
2429 case 0x36: /* LD (IX+dd),nn */
2430 adr = IX + (int8) RAM_PP(PC);
2431 PUT_BYTE(adr, RAM_PP(PC));
2432 break;
2433
2434 case 0x39: /* ADD IX,SP */
2435 IX &= ADDRMASK;
2436 SP &= ADDRMASK;
2437 sum = IX + SP;
2438 AF = (AF & ~0x3b) | ((sum >> 8) & 0x28) | cbitsTable[(IX ^ SP ^ sum) >> 8];
2439 IX = sum;
2440 break;
2441
2442 case 0x44: /* LD B,IXH */
2443 SET_HIGH_REGISTER(BC, HIGH_REGISTER(IX));
2444 break;
2445
2446 case 0x45: /* LD B,IXL */
2447 SET_HIGH_REGISTER(BC, LOW_REGISTER(IX));
2448 break;
2449
2450 case 0x46: /* LD B,(IX+dd) */
2451 adr = IX + (int8) RAM_PP(PC);
2452 SET_HIGH_REGISTER(BC, GET_BYTE(adr));
2453 break;
2454
2455 case 0x4c: /* LD C,IXH */
2456 SET_LOW_REGISTER(BC, HIGH_REGISTER(IX));
2457 break;
2458
2459 case 0x4d: /* LD C,IXL */
2460 SET_LOW_REGISTER(BC, LOW_REGISTER(IX));
2461 break;
2462
2463 case 0x4e: /* LD C,(IX+dd) */
2464 adr = IX + (int8) RAM_PP(PC);
2465 SET_LOW_REGISTER(BC, GET_BYTE(adr));
2466 break;
2467
2468 case 0x54: /* LD D,IXH */
2469 SET_HIGH_REGISTER(DE, HIGH_REGISTER(IX));
2470 break;
2471
2472 case 0x55: /* LD D,IXL */
2473 SET_HIGH_REGISTER(DE, LOW_REGISTER(IX));
2474 break;
2475
2476 case 0x56: /* LD D,(IX+dd) */
2477 adr = IX + (int8) RAM_PP(PC);
2478 SET_HIGH_REGISTER(DE, GET_BYTE(adr));
2479 break;
2480
2481 case 0x5c: /* LD E,IXH */
2482 SET_LOW_REGISTER(DE, HIGH_REGISTER(IX));
2483 break;
2484
2485 case 0x5d: /* LD E,IXL */
2486 SET_LOW_REGISTER(DE, LOW_REGISTER(IX));
2487 break;
2488
2489 case 0x5e: /* LD E,(IX+dd) */
2490 adr = IX + (int8) RAM_PP(PC);
2491 SET_LOW_REGISTER(DE, GET_BYTE(adr));
2492 break;
2493
2494 case 0x60: /* LD IXH,B */
2495 SET_HIGH_REGISTER(IX, HIGH_REGISTER(BC));
2496 break;
2497
2498 case 0x61: /* LD IXH,C */
2499 SET_HIGH_REGISTER(IX, LOW_REGISTER(BC));
2500 break;
2501
2502 case 0x62: /* LD IXH,D */
2503 SET_HIGH_REGISTER(IX, HIGH_REGISTER(DE));
2504 break;
2505
2506 case 0x63: /* LD IXH,E */
2507 SET_HIGH_REGISTER(IX, LOW_REGISTER(DE));
2508 break;
2509
2510 case 0x64: /* LD IXH,IXH */
2511 break;
2512
2513 case 0x65: /* LD IXH,IXL */
2514 SET_HIGH_REGISTER(IX, LOW_REGISTER(IX));
2515 break;
2516
2517 case 0x66: /* LD H,(IX+dd) */
2518 adr = IX + (int8) RAM_PP(PC);
2519 SET_HIGH_REGISTER(HL, GET_BYTE(adr));
2520 break;
2521
2522 case 0x67: /* LD IXH,A */
2523 SET_HIGH_REGISTER(IX, HIGH_REGISTER(AF));
2524 break;
2525
2526 case 0x68: /* LD IXL,B */
2527 SET_LOW_REGISTER(IX, HIGH_REGISTER(BC));
2528 break;
2529
2530 case 0x69: /* LD IXL,C */
2531 SET_LOW_REGISTER(IX, LOW_REGISTER(BC));
2532 break;
2533
2534 case 0x6a: /* LD IXL,D */
2535 SET_LOW_REGISTER(IX, HIGH_REGISTER(DE));
2536 break;
2537
2538 case 0x6b: /* LD IXL,E */
2539 SET_LOW_REGISTER(IX, LOW_REGISTER(DE));
2540 break;
2541
2542 case 0x6c: /* LD IXL,IXH */
2543 SET_LOW_REGISTER(IX, HIGH_REGISTER(IX));
2544 break;
2545
2546 case 0x6d: /* LD IXL,IXL */
2547 break;
2548
2549 case 0x6e: /* LD L,(IX+dd) */
2550 adr = IX + (int8) RAM_PP(PC);
2551 SET_LOW_REGISTER(HL, GET_BYTE(adr));
2552 break;
2553
2554 case 0x6f: /* LD IXL,A */
2555 SET_LOW_REGISTER(IX, HIGH_REGISTER(AF));
2556 break;
2557
2558 case 0x70: /* LD (IX+dd),B */
2559 adr = IX + (int8) RAM_PP(PC);
2560 PUT_BYTE(adr, HIGH_REGISTER(BC));
2561 break;
2562
2563 case 0x71: /* LD (IX+dd),C */
2564 adr = IX + (int8) RAM_PP(PC);
2565 PUT_BYTE(adr, LOW_REGISTER(BC));
2566 break;
2567
2568 case 0x72: /* LD (IX+dd),D */
2569 adr = IX + (int8) RAM_PP(PC);
2570 PUT_BYTE(adr, HIGH_REGISTER(DE));
2571 break;
2572
2573 case 0x73: /* LD (IX+dd),E */
2574 adr = IX + (int8) RAM_PP(PC);
2575 PUT_BYTE(adr, LOW_REGISTER(DE));
2576 break;
2577
2578 case 0x74: /* LD (IX+dd),H */
2579 adr = IX + (int8) RAM_PP(PC);
2580 PUT_BYTE(adr, HIGH_REGISTER(HL));
2581 break;
2582
2583 case 0x75: /* LD (IX+dd),L */
2584 adr = IX + (int8) RAM_PP(PC);
2585 PUT_BYTE(adr, LOW_REGISTER(HL));
2586 break;
2587
2588 case 0x77: /* LD (IX+dd),A */
2589 adr = IX + (int8) RAM_PP(PC);
2590 PUT_BYTE(adr, HIGH_REGISTER(AF));
2591 break;
2592
2593 case 0x7c: /* LD A,IXH */
2594 SET_HIGH_REGISTER(AF, HIGH_REGISTER(IX));
2595 break;
2596
2597 case 0x7d: /* LD A,IXL */
2598 SET_HIGH_REGISTER(AF, LOW_REGISTER(IX));
2599 break;
2600
2601 case 0x7e: /* LD A,(IX+dd) */
2602 adr = IX + (int8) RAM_PP(PC);
2603 SET_HIGH_REGISTER(AF, GET_BYTE(adr));
2604 break;
2605
2606 case 0x84: /* ADD A,IXH */
2607 temp = HIGH_REGISTER(IX);
2608 acu = HIGH_REGISTER(AF);
2609 sum = acu + temp;
2610 AF = addTable[sum] | cbitsZ80Table[acu ^ temp ^ sum];
2611 break;
2612
2613 case 0x85: /* ADD A,IXL */
2614 temp = LOW_REGISTER(IX);
2615 acu = HIGH_REGISTER(AF);
2616 sum = acu + temp;
2617 AF = addTable[sum] | cbitsZ80Table[acu ^ temp ^ sum];
2618 break;
2619
2620 case 0x86: /* ADD A,(IX+dd) */
2621 adr = IX + (int8) RAM_PP(PC);
2622 temp = GET_BYTE(adr);
2623 acu = HIGH_REGISTER(AF);
2624 sum = acu + temp;
2625 AF = addTable[sum] | cbitsZ80Table[acu ^ temp ^ sum];
2626 break;
2627
2628 case 0x8c: /* ADC A,IXH */
2629 temp = HIGH_REGISTER(IX);
2630 acu = HIGH_REGISTER(AF);
2631 sum = acu + temp + TSTFLAG(C);
2632 AF = addTable[sum] | cbitsZ80Table[acu ^ temp ^ sum];
2633 break;
2634
2635 case 0x8d: /* ADC A,IXL */
2636 temp = LOW_REGISTER(IX);
2637 acu = HIGH_REGISTER(AF);
2638 sum = acu + temp + TSTFLAG(C);
2639 AF = addTable[sum] | cbitsZ80Table[acu ^ temp ^ sum];
2640 break;
2641
2642 case 0x8e: /* ADC A,(IX+dd) */
2643 adr = IX + (int8) RAM_PP(PC);
2644 temp = GET_BYTE(adr);
2645 acu = HIGH_REGISTER(AF);
2646 sum = acu + temp + TSTFLAG(C);
2647 AF = addTable[sum] | cbitsZ80Table[acu ^ temp ^ sum];
2648 break;
2649
2650 case 0x96: /* SUB (IX+dd) */
2651 adr = IX + (int8) RAM_PP(PC);
2652 temp = GET_BYTE(adr);
2653 acu = HIGH_REGISTER(AF);
2654 sum = acu - temp;
2655 AF = addTable[sum & 0xff] | cbits2Z80Table[(acu ^ temp ^ sum) & 0x1ff];
2656 break;
2657
2658 case 0x94: /* SUB IXH */
2659 SETFLAG(C, 0);/* fall through, a bit less efficient but smaller code */
2660
2661 case 0x9c: /* SBC A,IXH */
2662 temp = HIGH_REGISTER(IX);
2663 acu = HIGH_REGISTER(AF);
2664 sum = acu - temp - TSTFLAG(C);
2665 AF = addTable[sum & 0xff] | cbits2Z80Table[(acu ^ temp ^ sum) & 0x1ff];
2666 break;
2667
2668 case 0x95: /* SUB IXL */
2669 SETFLAG(C, 0);/* fall through, a bit less efficient but smaller code */
2670
2671 case 0x9d: /* SBC A,IXL */
2672 temp = LOW_REGISTER(IX);
2673 acu = HIGH_REGISTER(AF);
2674 sum = acu - temp - TSTFLAG(C);
2675 AF = addTable[sum & 0xff] | cbits2Z80Table[(acu ^ temp ^ sum) & 0x1ff];
2676 break;
2677
2678 case 0x9e: /* SBC A,(IX+dd) */
2679 adr = IX + (int8) RAM_PP(PC);
2680 temp = GET_BYTE(adr);
2681 acu = HIGH_REGISTER(AF);
2682 sum = acu - temp - TSTFLAG(C);
2683 AF = addTable[sum & 0xff] | cbits2Z80Table[(acu ^ temp ^ sum) & 0x1ff];
2684 break;
2685
2686 case 0xa4: /* AND IXH */
2687 AF = andTable[((AF & IX) >> 8) & 0xff];
2688 break;
2689
2690 case 0xa5: /* AND IXL */
2691 AF = andTable[((AF >> 8) & IX) & 0xff];
2692 break;
2693
2694 case 0xa6: /* AND (IX+dd) */
2695 adr = IX + (int8) RAM_PP(PC);
2696 AF = andTable[((AF >> 8) & GET_BYTE(adr)) & 0xff];
2697 break;
2698
2699 case 0xac: /* XOR IXH */
2700 AF = xororTable[((AF ^ IX) >> 8) & 0xff];
2701 break;
2702
2703 case 0xad: /* XOR IXL */
2704 AF = xororTable[((AF >> 8) ^ IX) & 0xff];
2705 break;
2706
2707 case 0xae: /* XOR (IX+dd) */
2708 adr = IX + (int8) RAM_PP(PC);
2709 AF = xororTable[((AF >> 8) ^ GET_BYTE(adr)) & 0xff];
2710 break;
2711
2712 case 0xb4: /* OR IXH */
2713 AF = xororTable[((AF | IX) >> 8) & 0xff];
2714 break;
2715
2716 case 0xb5: /* OR IXL */
2717 AF = xororTable[((AF >> 8) | IX) & 0xff];
2718 break;
2719
2720 case 0xb6: /* OR (IX+dd) */
2721 adr = IX + (int8) RAM_PP(PC);
2722 AF = xororTable[((AF >> 8) | GET_BYTE(adr)) & 0xff];
2723 break;
2724
2725 case 0xbc: /* CP IXH */
2726 temp = HIGH_REGISTER(IX);
2727 AF = (AF & ~0x28) | (temp & 0x28);
2728 acu = HIGH_REGISTER(AF);
2729 sum = acu - temp;
2730 AF = (AF & ~0xff) | cpTable[sum & 0xff] | (temp & 0x28) |
2731 cbits2Z80Table[(acu ^ temp ^ sum) & 0x1ff];
2732 break;
2733
2734 case 0xbd: /* CP IXL */
2735 temp = LOW_REGISTER(IX);
2736 AF = (AF & ~0x28) | (temp & 0x28);
2737 acu = HIGH_REGISTER(AF);
2738 sum = acu - temp;
2739 AF = (AF & ~0xff) | cpTable[sum & 0xff] | (temp & 0x28) |
2740 cbits2Z80Table[(acu ^ temp ^ sum) & 0x1ff];
2741 break;
2742
2743 case 0xbe: /* CP (IX+dd) */
2744 adr = IX + (int8) RAM_PP(PC);
2745 temp = GET_BYTE(adr);
2746 AF = (AF & ~0x28) | (temp & 0x28);
2747 acu = HIGH_REGISTER(AF);
2748 sum = acu - temp;
2749 AF = (AF & ~0xff) | cpTable[sum & 0xff] | (temp & 0x28) |
2750 cbits2Z80Table[(acu ^ temp ^ sum) & 0x1ff];
2751 break;
2752
2753 case 0xcb: /* CB prefix */
2754 adr = IX + (int8) RAM_PP(PC);
2755 switch ((op = GET_BYTE(PC)) & 7) {
2756
2757 case 0:
2758 ++PC;
2759 acu = HIGH_REGISTER(BC);
2760 break;
2761
2762 case 1:
2763 ++PC;
2764 acu = LOW_REGISTER(BC);
2765 break;
2766
2767 case 2:
2768 ++PC;
2769 acu = HIGH_REGISTER(DE);
2770 break;
2771
2772 case 3:
2773 ++PC;
2774 acu = LOW_REGISTER(DE);
2775 break;
2776
2777 case 4:
2778 ++PC;
2779 acu = HIGH_REGISTER(HL);
2780 break;
2781
2782 case 5:
2783 ++PC;
2784 acu = LOW_REGISTER(HL);
2785 break;
2786
2787 case 6:
2788 ++PC;
2789 acu = GET_BYTE(adr);
2790 break;
2791
2792 case 7:
2793 ++PC;
2794 acu = HIGH_REGISTER(AF);
2795 break;
2796 }
2797 switch (op & 0xc0) {
2798
2799 case 0x00: /* shift/rotate */
2800 switch (op & 0x38) {
2801
2802 case 0x00:/* RLC */
2803 temp = (acu << 1) | (acu >> 7);
2804 cbits = temp & 1;
2805 goto cbshflg2;
2806
2807 case 0x08:/* RRC */
2808 temp = (acu >> 1) | (acu << 7);
2809 cbits = temp & 0x80;
2810 goto cbshflg2;
2811
2812 case 0x10:/* RL */
2813 temp = (acu << 1) | TSTFLAG(C);
2814 cbits = acu & 0x80;
2815 goto cbshflg2;
2816
2817 case 0x18:/* RR */
2818 temp = (acu >> 1) | (TSTFLAG(C) << 7);
2819 cbits = acu & 1;
2820 goto cbshflg2;
2821
2822 case 0x20:/* SLA */
2823 temp = acu << 1;
2824 cbits = acu & 0x80;
2825 goto cbshflg2;
2826
2827 case 0x28:/* SRA */
2828 temp = (acu >> 1) | (acu & 0x80);
2829 cbits = acu & 1;
2830 goto cbshflg2;
2831
2832 case 0x30:/* SLIA */
2833 temp = (acu << 1) | 1;
2834 cbits = acu & 0x80;
2835 goto cbshflg2;
2836
2837 case 0x38:/* SRL */
2838 temp = acu >> 1;
2839 cbits = acu & 1;
2840 cbshflg2:
2841 AF = (AF & ~0xff) | rotateShiftTable[temp & 0xff] | !!cbits;
2842 }
2843 break;
2844
2845 case 0x40: /* BIT */
2846 if (acu & (1 << ((op >> 3) & 7)))
2847 AF = (AF & ~0xfe) | 0x10 | (((op & 0x38) == 0x38) << 7);
2848 else AF = (AF & ~0xfe) | 0x54;
2849 if ((op & 7) != 6) AF |= (acu & 0x28);
2850 temp = acu;
2851 break;
2852
2853 case 0x80: /* RES */
2854 temp = acu & ~(1 << ((op >> 3) & 7));
2855 break;
2856
2857 case 0xc0: /* SET */
2858 temp = acu | (1 << ((op >> 3) & 7));
2859 break;
2860 }
2861 switch (op & 7) {
2862
2863 case 0:
2864 SET_HIGH_REGISTER(BC, temp);
2865 break;
2866
2867 case 1:
2868 SET_LOW_REGISTER(BC, temp);
2869 break;
2870
2871 case 2:
2872 SET_HIGH_REGISTER(DE, temp);
2873 break;
2874
2875 case 3:
2876 SET_LOW_REGISTER(DE, temp);
2877 break;
2878
2879 case 4:
2880 SET_HIGH_REGISTER(HL, temp);
2881 break;
2882
2883 case 5:
2884 SET_LOW_REGISTER(HL, temp);
2885 break;
2886
2887 case 6:
2888 PUT_BYTE(adr, temp);
2889 break;
2890
2891 case 7:
2892 SET_HIGH_REGISTER(AF, temp);
2893 break;
2894 }
2895 break;
2896
2897 case 0xe1: /* POP IX */
2898 POP(IX);
2899 break;
2900
2901 case 0xe3: /* EX (SP),IX */
2902 temp = IX;
2903 POP(IX);
2904 PUSH(temp);
2905 break;
2906
2907 case 0xe5: /* PUSH IX */
2908 PUSH(IX);
2909 break;
2910
2911 case 0xe9: /* JP (IX) */
2912 PC = IX;
2913 break;
2914
2915 case 0xf9: /* LD SP,IX */
2916 SP = IX;
2917 break;
2918
2919 default: /* ignore DD */
2920 CHECK_CPU_Z80;
2921 PC--;
2922 }
2923 break;
2924
2925 case 0xde: /* SBC A,nn */
2926 temp = RAM_PP(PC);
2927 acu = HIGH_REGISTER(AF);
2928 sum = acu - temp - TSTFLAG(C);
2929 cbits = acu ^ temp ^ sum;
2930 AF = subTable[sum & 0xff] | cbitsTable[cbits & 0x1ff] | (SET_PV);
2931 break;
2932
2933 case 0xdf: /* RST 18H */
2934 PUSH(PC);
2935 PC = 0x18;
2936 break;
2937
2938 case 0xe0: /* RET PO */
2939 if (!(TSTFLAG(P))) POP(PC);
2940 break;
2941
2942 case 0xe1: /* POP HL */
2943 POP(HL);
2944 break;
2945
2946 case 0xe2: /* JP PO,nnnn */
2947 JPC(!TSTFLAG(P));
2948 break;
2949
2950 case 0xe3: /* EX (SP),HL */
2951 temp = HL;
2952 POP(HL);
2953 PUSH(temp);
2954 break;
2955
2956 case 0xe4: /* CALL PO,nnnn */
2957 CALLC(!TSTFLAG(P));
2958 break;
2959
2960 case 0xe5: /* PUSH HL */
2961 PUSH(HL);
2962 break;
2963
2964 case 0xe6: /* AND nn */
2965 AF = andTable[((AF >> 8) & RAM_PP(PC)) & 0xff];
2966 break;
2967
2968 case 0xe7: /* RST 20H */
2969 PUSH(PC);
2970 PC = 0x20;
2971 break;
2972
2973 case 0xe8: /* RET PE */
2974 if (TSTFLAG(P)) POP(PC);
2975 break;
2976
2977 case 0xe9: /* JP (HL) */
2978 PC = HL;
2979 break;
2980
2981 case 0xea: /* JP PE,nnnn */
2982 JPC(TSTFLAG(P));
2983 break;
2984
2985 case 0xeb: /* EX DE,HL */
2986 temp = HL;
2987 HL = DE;
2988 DE = temp;
2989 break;
2990
2991 case 0xec: /* CALL PE,nnnn */
2992 CALLC(TSTFLAG(P));
2993 break;
2994
2995 case 0xed: /* ED prefix */
2996 CHECK_CPU_8080;
2997 switch (op = RAM_PP(PC)) {
2998
2999 case 0x40: /* IN B,(C) */
3000 temp = in(LOW_REGISTER(BC));
3001 SET_HIGH_REGISTER(BC, temp);
3002 AF = (AF & ~0xfe) | rotateShiftTable[temp & 0xff];
3003 break;
3004
3005 case 0x41: /* OUT (C),B */
3006 out(LOW_REGISTER(BC), HIGH_REGISTER(BC));
3007 break;
3008
3009 case 0x42: /* SBC HL,BC */
3010 HL &= ADDRMASK;
3011 BC &= ADDRMASK;
3012 sum = HL - BC - TSTFLAG(C);
3013 AF = (AF & ~0xff) | ((sum >> 8) & 0xa8) | (((sum & ADDRMASK) == 0) << 6) |
3014 cbits2Z80Table[((HL ^ BC ^ sum) >> 8) & 0x1ff];
3015 HL = sum;
3016 break;
3017
3018 case 0x43: /* LD (nnnn),BC */
3019 temp = GET_WORD(PC);
3020 PUT_WORD(temp, BC);
3021 PC += 2;
3022 break;
3023
3024 case 0x44: /* NEG */
3025
3026 case 0x4C: /* NEG, unofficial */
3027
3028 case 0x54: /* NEG, unofficial */
3029
3030 case 0x5C: /* NEG, unofficial */
3031
3032 case 0x64: /* NEG, unofficial */
3033
3034 case 0x6C: /* NEG, unofficial */
3035
3036 case 0x74: /* NEG, unofficial */
3037
3038 case 0x7C: /* NEG, unofficial */
3039 temp = HIGH_REGISTER(AF);
3040 AF = ((~(AF & 0xff00) + 1) & 0xff00); /* AF = (-(AF & 0xff00) & 0xff00); */
3041 AF |= ((AF >> 8) & 0xa8) | (((AF & 0xff00) == 0) << 6) | negTable[temp];
3042 break;
3043
3044 case 0x45: /* RETN */
3045
3046 case 0x55: /* RETN, unofficial */
3047
3048 case 0x5D: /* RETN, unofficial */
3049
3050 case 0x65: /* RETN, unofficial */
3051
3052 case 0x6D: /* RETN, unofficial */
3053
3054 case 0x75: /* RETN, unofficial */
3055
3056 case 0x7D: /* RETN, unofficial */
3057 IFF_S |= IFF_S >> 1;
3058 POP(PC);
3059 break;
3060
3061 case 0x46: /* IM 0 */
3062 /* interrupt mode 0 */
3063 break;
3064
3065 case 0x47: /* LD I,A */
3066 IR_S = (IR_S & 0xff) | (AF & ~0xff);
3067 break;
3068
3069 case 0x48: /* IN C,(C) */
3070 temp = in(LOW_REGISTER(BC));
3071 SET_LOW_REGISTER(BC, temp);
3072 AF = (AF & ~0xfe) | rotateShiftTable[temp & 0xff];
3073 break;
3074
3075 case 0x49: /* OUT (C),C */
3076 out(LOW_REGISTER(BC), LOW_REGISTER(BC));
3077 break;
3078
3079 case 0x4a: /* ADC HL,BC */
3080 HL &= ADDRMASK;
3081 BC &= ADDRMASK;
3082 sum = HL + BC + TSTFLAG(C);
3083 AF = (AF & ~0xff) | ((sum >> 8) & 0xa8) | (((sum & ADDRMASK) == 0) << 6) |
3084 cbitsZ80Table[(HL ^ BC ^ sum) >> 8];
3085 HL = sum;
3086 break;
3087
3088 case 0x4b: /* LD BC,(nnnn) */
3089 temp = GET_WORD(PC);
3090 BC = GET_WORD(temp);
3091 PC += 2;
3092 break;
3093
3094 case 0x4d: /* RETI */
3095 IFF_S |= IFF_S >> 1;
3096 POP(PC);
3097 break;
3098
3099 case 0x4f: /* LD R,A */
3100 IR_S = (IR_S & ~0xff) | ((AF >> 8) & 0xff);
3101 break;
3102
3103 case 0x50: /* IN D,(C) */
3104 temp = in(LOW_REGISTER(BC));
3105 SET_HIGH_REGISTER(DE, temp);
3106 AF = (AF & ~0xfe) | rotateShiftTable[temp & 0xff];
3107 break;
3108
3109 case 0x51: /* OUT (C),D */
3110 out(LOW_REGISTER(BC), HIGH_REGISTER(DE));
3111 break;
3112
3113 case 0x52: /* SBC HL,DE */
3114 HL &= ADDRMASK;
3115 DE &= ADDRMASK;
3116 sum = HL - DE - TSTFLAG(C);
3117 AF = (AF & ~0xff) | ((sum >> 8) & 0xa8) | (((sum & ADDRMASK) == 0) << 6) |
3118 cbits2Z80Table[((HL ^ DE ^ sum) >> 8) & 0x1ff];
3119 HL = sum;
3120 break;
3121
3122 case 0x53: /* LD (nnnn),DE */
3123 temp = GET_WORD(PC);
3124 PUT_WORD(temp, DE);
3125 PC += 2;
3126 break;
3127
3128 case 0x56: /* IM 1 */
3129 /* interrupt mode 1 */
3130 break;
3131
3132 case 0x57: /* LD A,I */
3133 AF = (AF & 0x29) | (IR_S & ~0xff) | ((IR_S >> 8) & 0x80) | (((IR_S & ~0xff) == 0) << 6) | ((IFF_S & 2) << 1);
3134 break;
3135
3136 case 0x58: /* IN E,(C) */
3137 temp = in(LOW_REGISTER(BC));
3138 SET_LOW_REGISTER(DE, temp);
3139 AF = (AF & ~0xfe) | rotateShiftTable[temp & 0xff];
3140 break;
3141
3142 case 0x59: /* OUT (C),E */
3143 out(LOW_REGISTER(BC), LOW_REGISTER(DE));
3144 break;
3145
3146 case 0x5a: /* ADC HL,DE */
3147 HL &= ADDRMASK;
3148 DE &= ADDRMASK;
3149 sum = HL + DE + TSTFLAG(C);
3150 AF = (AF & ~0xff) | ((sum >> 8) & 0xa8) | (((sum & ADDRMASK) == 0) << 6) |
3151 cbitsZ80Table[(HL ^ DE ^ sum) >> 8];
3152 HL = sum;
3153 break;
3154
3155 case 0x5b: /* LD DE,(nnnn) */
3156 temp = GET_WORD(PC);
3157 DE = GET_WORD(temp);
3158 PC += 2;
3159 break;
3160
3161 case 0x5e: /* IM 2 */
3162 /* interrupt mode 2 */
3163 break;
3164
3165 case 0x5f: /* LD A,R */
3166 AF = (AF & 0x29) | ((IR_S & 0xff) << 8) | (IR_S & 0x80) |
3167 (((IR_S & 0xff) == 0) << 6) | ((IFF_S & 2) << 1);
3168 break;
3169
3170 case 0x60: /* IN H,(C) */
3171 temp = in(LOW_REGISTER(BC));
3172 SET_HIGH_REGISTER(HL, temp);
3173 AF = (AF & ~0xfe) | rotateShiftTable[temp & 0xff];
3174 break;
3175
3176 case 0x61: /* OUT (C),H */
3177 out(LOW_REGISTER(BC), HIGH_REGISTER(HL));
3178 break;
3179
3180 case 0x62: /* SBC HL,HL */
3181 HL &= ADDRMASK;
3182 sum = HL - HL - TSTFLAG(C);
3183 AF = (AF & ~0xff) | (((sum & ADDRMASK) == 0) << 6) |
3184 cbits2Z80DupTable[(sum >> 8) & 0x1ff];
3185 HL = sum;
3186 break;
3187
3188 case 0x63: /* LD (nnnn),HL */
3189 temp = GET_WORD(PC);
3190 PUT_WORD(temp, HL);
3191 PC += 2;
3192 break;
3193
3194 case 0x67: /* RRD */
3195 temp = GET_BYTE(HL);
3196 acu = HIGH_REGISTER(AF);
3197 PUT_BYTE(HL, HIGH_DIGIT(temp) | (LOW_DIGIT(acu) << 4));
3198 AF = rrdrldTable[(acu & 0xf0) | LOW_DIGIT(temp)] | (AF & 1);
3199 break;
3200
3201 case 0x68: /* IN L,(C) */
3202 temp = in(LOW_REGISTER(BC));
3203 SET_LOW_REGISTER(HL, temp);
3204 AF = (AF & ~0xfe) | rotateShiftTable[temp & 0xff];
3205 break;
3206
3207 case 0x69: /* OUT (C),L */
3208 out(LOW_REGISTER(BC), LOW_REGISTER(HL));
3209 break;
3210
3211 case 0x6a: /* ADC HL,HL */
3212 HL &= ADDRMASK;
3213 sum = HL + HL + TSTFLAG(C);
3214 AF = (AF & ~0xff) | (((sum & ADDRMASK) == 0) << 6) |
3215 cbitsZ80DupTable[sum >> 8];
3216 HL = sum;
3217 break;
3218
3219 case 0x6b: /* LD HL,(nnnn) */
3220 temp = GET_WORD(PC);
3221 HL = GET_WORD(temp);
3222 PC += 2;
3223 break;
3224
3225 case 0x6f: /* RLD */
3226 temp = GET_BYTE(HL);
3227 acu = HIGH_REGISTER(AF);
3228 PUT_BYTE(HL, (LOW_DIGIT(temp) << 4) | LOW_DIGIT(acu));
3229 AF = rrdrldTable[(acu & 0xf0) | HIGH_DIGIT(temp)] | (AF & 1);
3230 break;
3231
3232 case 0x70: /* IN (C) */
3233 temp = in(LOW_REGISTER(BC));
3234 SET_LOW_REGISTER(temp, temp);
3235 AF = (AF & ~0xfe) | rotateShiftTable[temp & 0xff];
3236 break;
3237
3238 case 0x71: /* OUT (C),0 */
3239 out(LOW_REGISTER(BC), 0);
3240 break;
3241
3242 case 0x72: /* SBC HL,SP */
3243 HL &= ADDRMASK;
3244 SP &= ADDRMASK;
3245 sum = HL - SP - TSTFLAG(C);
3246 AF = (AF & ~0xff) | ((sum >> 8) & 0xa8) | (((sum & ADDRMASK) == 0) << 6) |
3247 cbits2Z80Table[((HL ^ SP ^ sum) >> 8) & 0x1ff];
3248 HL = sum;
3249 break;
3250
3251 case 0x73: /* LD (nnnn),SP */
3252 temp = GET_WORD(PC);
3253 PUT_WORD(temp, SP);
3254 PC += 2;
3255 break;
3256
3257 case 0x78: /* IN A,(C) */
3258 temp = in(LOW_REGISTER(BC));
3259 SET_HIGH_REGISTER(AF, temp);
3260 AF = (AF & ~0xfe) | rotateShiftTable[temp & 0xff];
3261 break;
3262
3263 case 0x79: /* OUT (C),A */
3264 out(LOW_REGISTER(BC), HIGH_REGISTER(AF));
3265 break;
3266
3267 case 0x7a: /* ADC HL,SP */
3268 HL &= ADDRMASK;
3269 SP &= ADDRMASK;
3270 sum = HL + SP + TSTFLAG(C);
3271 AF = (AF & ~0xff) | ((sum >> 8) & 0xa8) | (((sum & ADDRMASK) == 0) << 6) |
3272 cbitsZ80Table[(HL ^ SP ^ sum) >> 8];
3273 HL = sum;
3274 break;
3275
3276 case 0x7b: /* LD SP,(nnnn) */
3277 temp = GET_WORD(PC);
3278 SP = GET_WORD(temp);
3279 PC += 2;
3280 break;
3281
3282 case 0xa0: /* LDI */
3283 acu = RAM_PP(HL);
3284 PUT_BYTE_PP(DE, acu);
3285 acu += HIGH_REGISTER(AF);
3286 AF = (AF & ~0x3e) | (acu & 8) | ((acu & 2) << 4) |
3287 (((--BC & ADDRMASK) != 0) << 2);
3288 break;
3289
3290 case 0xa1: /* CPI */
3291 acu = HIGH_REGISTER(AF);
3292 temp = RAM_PP(HL);
3293 sum = acu - temp;
3294 cbits = acu ^ temp ^ sum;
3295 AF = (AF & ~0xfe) | (sum & 0x80) | (!(sum & 0xff) << 6) |
3296 (((sum - ((cbits & 16) >> 4)) & 2) << 4) | (cbits & 16) |
3297 ((sum - ((cbits >> 4) & 1)) & 8) |
3298 ((--BC & ADDRMASK) != 0) << 2 | 2;
3299 if ((sum & 15) == 8 && (cbits & 16) != 0) AF &= ~8;
3300 break;
3301
3302 /* SF, ZF, YF, XF flags are affected by decreasing register B, as in DEC B.
3303 NF flag A is copy of bit 7 of the value read from or written to an I/O port.
3304 INI/INIR/IND/INDR use the C flag in stead of the L register. There is a
3305 catch though, because not the value of C is used, but C + 1 if it's INI/INIR or
3306 C - 1 if it's IND/INDR. So, first of all INI/INIR:
3307 HF and CF Both set if ((HL) + ((C + 1) & 255) > 255)
3308 PF The parity of (((HL) + ((C + 1) & 255)) & 7) xor B) */
3309 case 0xa2: /* INI */
3310 acu = in(LOW_REGISTER(BC));
3311 PUT_BYTE(HL, acu);
3312 ++HL;
3313 temp = HIGH_REGISTER(BC);
3314 BC -= 0x100;
3315 INOUTFLAGS_NONZERO((LOW_REGISTER(BC) + 1) & 0xff);
3316 break;
3317
3318 /* SF, ZF, YF, XF flags are affected by decreasing register B, as in DEC B.
3319 NF flag A is copy of bit 7 of the value read from or written to an I/O port.
3320 And now the for OUTI/OTIR/OUTD/OTDR instructions. Take state of the L
3321 after the increment or decrement of HL; add the value written to the I/O port
3322 to; call that k for now. If k > 255, then the CF and HF flags are set. The PF
3323 flags is set like the parity of k bitwise and'ed with 7, bitwise xor'ed with B.
3324 HF and CF Both set if ((HL) + L > 255)
3325 PF The parity of ((((HL) + L) & 7) xor B) */
3326 case 0xa3: /* OUTI */
3327 acu = GET_BYTE(HL);
3328 out(LOW_REGISTER(BC), acu);
3329 ++HL;
3330 temp = HIGH_REGISTER(BC);
3331 BC -= 0x100;
3332 INOUTFLAGS_NONZERO(LOW_REGISTER(HL));
3333 break;
3334
3335 case 0xa8: /* LDD */
3336 acu = RAM_MM(HL);
3337 PUT_BYTE_MM(DE, acu);
3338 acu += HIGH_REGISTER(AF);
3339 AF = (AF & ~0x3e) | (acu & 8) | ((acu & 2) << 4) |
3340 (((--BC & ADDRMASK) != 0) << 2);
3341 break;
3342
3343 case 0xa9: /* CPD */
3344 acu = HIGH_REGISTER(AF);
3345 temp = RAM_MM(HL);
3346 sum = acu - temp;
3347 cbits = acu ^ temp ^ sum;
3348 AF = (AF & ~0xfe) | (sum & 0x80) | (!(sum & 0xff) << 6) |
3349 (((sum - ((cbits & 16) >> 4)) & 2) << 4) | (cbits & 16) |
3350 ((sum - ((cbits >> 4) & 1)) & 8) |
3351 ((--BC & ADDRMASK) != 0) << 2 | 2;
3352 if ((sum & 15) == 8 && (cbits & 16) != 0) AF &= ~8;
3353 break;
3354
3355 /* SF, ZF, YF, XF flags are affected by decreasing register B, as in DEC B.
3356 NF flag A is copy of bit 7 of the value read from or written to an I/O port.
3357 INI/INIR/IND/INDR use the C flag in stead of the L register. There is a
3358 catch though, because not the value of C is used, but C + 1 if it's INI/INIR or
3359 C - 1 if it's IND/INDR. And last IND/INDR:
3360 HF and CF Both set if ((HL) + ((C - 1) & 255) > 255)
3361 PF The parity of (((HL) + ((C - 1) & 255)) & 7) xor B) */
3362 case 0xaa: /* IND */
3363 acu = in(LOW_REGISTER(BC));
3364 PUT_BYTE(HL, acu);
3365 --HL;
3366 temp = HIGH_REGISTER(BC);
3367 BC -= 0x100;
3368 INOUTFLAGS_NONZERO((LOW_REGISTER(BC) - 1) & 0xff);
3369 break;
3370
3371 case 0xab: /* OUTD */
3372 acu = GET_BYTE(HL);
3373 out(LOW_REGISTER(BC), acu);
3374 --HL;
3375 temp = HIGH_REGISTER(BC);
3376 BC -= 0x100;
3377 INOUTFLAGS_NONZERO(LOW_REGISTER(HL));
3378 break;
3379
3380 case 0xb0: /* LDIR */
3381 acu = HIGH_REGISTER(AF);
3382 BC &= ADDRMASK;
3383 if (BC == 0) BC = 0x10000;
3384 do {
3385 acu = RAM_PP(HL);
3386 PUT_BYTE_PP(DE, acu);
3387 } while (--BC);
3388 acu += HIGH_REGISTER(AF);
3389 AF = (AF & ~0x3e) | (acu & 8) | ((acu & 2) << 4);
3390 break;
3391
3392 case 0xb1: /* CPIR */
3393 acu = HIGH_REGISTER(AF);
3394 BC &= ADDRMASK;
3395 if (BC == 0) BC = 0x10000;
3396 do {
3397 temp = RAM_PP(HL);
3398 op = --BC != 0;
3399 sum = acu - temp;
3400 } while (op && sum != 0);
3401 cbits = acu ^ temp ^ sum;
3402 AF = (AF & ~0xfe) | (sum & 0x80) | (!(sum & 0xff) << 6) |
3403 (((sum - ((cbits & 16) >> 4)) & 2) << 4) |
3404 (cbits & 16) | ((sum - ((cbits >> 4) & 1)) & 8) |
3405 op << 2 | 2;
3406 if ((sum & 15) == 8 && (cbits & 16) != 0) AF &= ~8;
3407 break;
3408
3409 case 0xb2: /* INIR */
3410 temp = HIGH_REGISTER(BC);
3411 if (temp == 0) temp = 0x100;
3412 do {
3413 acu = in(LOW_REGISTER(BC));
3414 PUT_BYTE(HL, acu);
3415 ++HL;
3416 } while (--temp);
3417 temp = HIGH_REGISTER(BC);
3418 SET_HIGH_REGISTER(BC, 0);
3419 INOUTFLAGS_ZERO((LOW_REGISTER(BC) + 1) & 0xff);
3420 break;
3421
3422 case 0xb3: /* OTIR */
3423 temp = HIGH_REGISTER(BC);
3424 if (temp == 0) temp = 0x100;
3425 do {
3426 acu = GET_BYTE(HL);
3427 out(LOW_REGISTER(BC), acu);
3428 ++HL;
3429 } while (--temp);
3430 temp = HIGH_REGISTER(BC);
3431 SET_HIGH_REGISTER(BC, 0);
3432 INOUTFLAGS_ZERO(LOW_REGISTER(HL));
3433 break;
3434
3435 case 0xb8: /* LDDR */
3436 BC &= ADDRMASK;
3437 if (BC == 0) BC = 0x10000;
3438 do {
3439 acu = RAM_MM(HL);
3440 PUT_BYTE_MM(DE, acu);
3441 } while (--BC);
3442 acu += HIGH_REGISTER(AF);
3443 AF = (AF & ~0x3e) | (acu & 8) | ((acu & 2) << 4);
3444 break;
3445
3446 case 0xb9: /* CPDR */
3447 acu = HIGH_REGISTER(AF);
3448 BC &= ADDRMASK;
3449 if (BC == 0) BC = 0x10000;
3450 do {
3451 temp = RAM_MM(HL);
3452 op = --BC != 0;
3453 sum = acu - temp;
3454 } while (op && sum != 0);
3455 cbits = acu ^ temp ^ sum;
3456 AF = (AF & ~0xfe) | (sum & 0x80) | (!(sum & 0xff) << 6) |
3457 (((sum - ((cbits & 16) >> 4)) & 2) << 4) |
3458 (cbits & 16) | ((sum - ((cbits >> 4) & 1)) & 8) |
3459 op << 2 | 2;
3460 if ((sum & 15) == 8 && (cbits & 16) != 0) AF &= ~8;
3461 break;
3462
3463 case 0xba: /* INDR */
3464 temp = HIGH_REGISTER(BC);
3465 if (temp == 0) temp = 0x100;
3466 do {
3467 acu = in(LOW_REGISTER(BC));
3468 PUT_BYTE(HL, acu);
3469 --HL;
3470 } while (--temp);
3471 temp = HIGH_REGISTER(BC);
3472 SET_HIGH_REGISTER(BC, 0);
3473 INOUTFLAGS_ZERO((LOW_REGISTER(BC) - 1) & 0xff);
3474 break;
3475
3476 case 0xbb: /* OTDR */
3477 temp = HIGH_REGISTER(BC);
3478 if (temp == 0) temp = 0x100;
3479 do {
3480 acu = GET_BYTE(HL);
3481 out(LOW_REGISTER(BC), acu);
3482 --HL;
3483 } while (--temp);
3484 temp = HIGH_REGISTER(BC);
3485 SET_HIGH_REGISTER(BC, 0);
3486 INOUTFLAGS_ZERO(LOW_REGISTER(HL));
3487 break;
3488
3489 default: /* ignore ED and following byte */
3490 CHECK_CPU_Z80;
3491 }
3492 break;
3493
3494 case 0xee: /* XOR nn */
3495 AF = xororTable[((AF >> 8) ^ RAM_PP(PC)) & 0xff];
3496 break;
3497
3498 case 0xef: /* RST 28H */
3499 PUSH(PC);
3500 PC = 0x28;
3501 break;
3502
3503 case 0xf0: /* RET P */
3504 if (!(TSTFLAG(S))) POP(PC);
3505 break;
3506
3507 case 0xf1: /* POP AF */
3508 POP(AF);
3509 break;
3510
3511 case 0xf2: /* JP P,nnnn */
3512 JPC(!TSTFLAG(S));
3513 break;
3514
3515 case 0xf3: /* DI */
3516 IFF_S = 0;
3517 break;
3518
3519 case 0xf4: /* CALL P,nnnn */
3520 CALLC(!TSTFLAG(S));
3521 break;
3522
3523 case 0xf5: /* PUSH AF */
3524 PUSH(AF);
3525 break;
3526
3527 case 0xf6: /* OR nn */
3528 AF = xororTable[((AF >> 8) | RAM_PP(PC)) & 0xff];
3529 break;
3530
3531 case 0xf7: /* RST 30H */
3532 PUSH(PC);
3533 PC = 0x30;
3534 break;
3535
3536 case 0xf8: /* RET M */
3537 if (TSTFLAG(S)) POP(PC);
3538 break;
3539
3540 case 0xf9: /* LD SP,HL */
3541 SP = HL;
3542 break;
3543
3544 case 0xfa: /* JP M,nnnn */
3545 JPC(TSTFLAG(S));
3546 break;
3547
3548 case 0xfb: /* EI */
3549 IFF_S = 3;
3550 break;
3551
3552 case 0xfc: /* CALL M,nnnn */
3553 CALLC(TSTFLAG(S));
3554 break;
3555
3556 case 0xfd: /* FD prefix */
3557 CHECK_CPU_8080;
3558 switch (op = RAM_PP(PC)) {
3559
3560 case 0x09: /* ADD IY,BC */
3561 IY &= ADDRMASK;
3562 BC &= ADDRMASK;
3563 sum = IY + BC;
3564 AF = (AF & ~0x3b) | ((sum >> 8) & 0x28) | cbitsTable[(IY ^ BC ^ sum) >> 8];
3565 IY = sum;
3566 break;
3567
3568 case 0x19: /* ADD IY,DE */
3569 IY &= ADDRMASK;
3570 DE &= ADDRMASK;
3571 sum = IY + DE;
3572 AF = (AF & ~0x3b) | ((sum >> 8) & 0x28) | cbitsTable[(IY ^ DE ^ sum) >> 8];
3573 IY = sum;
3574 break;
3575
3576 case 0x21: /* LD IY,nnnn */
3577 IY = GET_WORD(PC);
3578 PC += 2;
3579 break;
3580
3581 case 0x22: /* LD (nnnn),IY */
3582 temp = GET_WORD(PC);
3583 PUT_WORD(temp, IY);
3584 PC += 2;
3585 break;
3586
3587 case 0x23: /* INC IY */
3588 ++IY;
3589 break;
3590
3591 case 0x24: /* INC IYH */
3592 IY += 0x100;
3593 AF = (AF & ~0xfe) | incZ80Table[HIGH_REGISTER(IY)];
3594 break;
3595
3596 case 0x25: /* DEC IYH */
3597 IY -= 0x100;
3598 AF = (AF & ~0xfe) | decZ80Table[HIGH_REGISTER(IY)];
3599 break;
3600
3601 case 0x26: /* LD IYH,nn */
3602 SET_HIGH_REGISTER(IY, RAM_PP(PC));
3603 break;
3604
3605 case 0x29: /* ADD IY,IY */
3606 IY &= ADDRMASK;
3607 sum = IY + IY;
3608 AF = (AF & ~0x3b) | cbitsDup16Table[sum >> 8];
3609 IY = sum;
3610 break;
3611
3612 case 0x2a: /* LD IY,(nnnn) */
3613 temp = GET_WORD(PC);
3614 IY = GET_WORD(temp);
3615 PC += 2;
3616 break;
3617
3618 case 0x2b: /* DEC IY */
3619 --IY;
3620 break;
3621
3622 case 0x2c: /* INC IYL */
3623 temp = LOW_REGISTER(IY) + 1;
3624 SET_LOW_REGISTER(IY, temp);
3625 AF = (AF & ~0xfe) | incZ80Table[temp];
3626 break;
3627
3628 case 0x2d: /* DEC IYL */
3629 temp = LOW_REGISTER(IY) - 1;
3630 SET_LOW_REGISTER(IY, temp);
3631 AF = (AF & ~0xfe) | decZ80Table[temp & 0xff];
3632 break;
3633
3634 case 0x2e: /* LD IYL,nn */
3635 SET_LOW_REGISTER(IY, RAM_PP(PC));
3636 break;
3637
3638 case 0x34: /* INC (IY+dd) */
3639 adr = IY + (int8) RAM_PP(PC);
3640 temp = GET_BYTE(adr) + 1;
3641 PUT_BYTE(adr, temp);
3642 AF = (AF & ~0xfe) | incZ80Table[temp];
3643 break;
3644
3645 case 0x35: /* DEC (IY+dd) */
3646 adr = IY + (int8) RAM_PP(PC);
3647 temp = GET_BYTE(adr) - 1;
3648 PUT_BYTE(adr, temp);
3649 AF = (AF & ~0xfe) | decZ80Table[temp & 0xff];
3650 break;
3651
3652 case 0x36: /* LD (IY+dd),nn */
3653 adr = IY + (int8) RAM_PP(PC);
3654 PUT_BYTE(adr, RAM_PP(PC));
3655 break;
3656
3657 case 0x39: /* ADD IY,SP */
3658 IY &= ADDRMASK;
3659 SP &= ADDRMASK;
3660 sum = IY + SP;
3661 AF = (AF & ~0x3b) | ((sum >> 8) & 0x28) | cbitsTable[(IY ^ SP ^ sum) >> 8];
3662 IY = sum;
3663 break;
3664
3665 case 0x44: /* LD B,IYH */
3666 SET_HIGH_REGISTER(BC, HIGH_REGISTER(IY));
3667 break;
3668
3669 case 0x45: /* LD B,IYL */
3670 SET_HIGH_REGISTER(BC, LOW_REGISTER(IY));
3671 break;
3672
3673 case 0x46: /* LD B,(IY+dd) */
3674 adr = IY + (int8) RAM_PP(PC);
3675 SET_HIGH_REGISTER(BC, GET_BYTE(adr));
3676 break;
3677
3678 case 0x4c: /* LD C,IYH */
3679 SET_LOW_REGISTER(BC, HIGH_REGISTER(IY));
3680 break;
3681
3682 case 0x4d: /* LD C,IYL */
3683 SET_LOW_REGISTER(BC, LOW_REGISTER(IY));
3684 break;
3685
3686 case 0x4e: /* LD C,(IY+dd) */
3687 adr = IY + (int8) RAM_PP(PC);
3688 SET_LOW_REGISTER(BC, GET_BYTE(adr));
3689 break;
3690
3691 case 0x54: /* LD D,IYH */
3692 SET_HIGH_REGISTER(DE, HIGH_REGISTER(IY));
3693 break;
3694
3695 case 0x55: /* LD D,IYL */
3696 SET_HIGH_REGISTER(DE, LOW_REGISTER(IY));
3697 break;
3698
3699 case 0x56: /* LD D,(IY+dd) */
3700 adr = IY + (int8) RAM_PP(PC);
3701 SET_HIGH_REGISTER(DE, GET_BYTE(adr));
3702 break;
3703
3704 case 0x5c: /* LD E,IYH */
3705 SET_LOW_REGISTER(DE, HIGH_REGISTER(IY));
3706 break;
3707
3708 case 0x5d: /* LD E,IYL */
3709 SET_LOW_REGISTER(DE, LOW_REGISTER(IY));
3710 break;
3711
3712 case 0x5e: /* LD E,(IY+dd) */
3713 adr = IY + (int8) RAM_PP(PC);
3714 SET_LOW_REGISTER(DE, GET_BYTE(adr));
3715 break;
3716
3717 case 0x60: /* LD IYH,B */
3718 SET_HIGH_REGISTER(IY, HIGH_REGISTER(BC));
3719 break;
3720
3721 case 0x61: /* LD IYH,C */
3722 SET_HIGH_REGISTER(IY, LOW_REGISTER(BC));
3723 break;
3724
3725 case 0x62: /* LD IYH,D */
3726 SET_HIGH_REGISTER(IY, HIGH_REGISTER(DE));
3727 break;
3728
3729 case 0x63: /* LD IYH,E */
3730 SET_HIGH_REGISTER(IY, LOW_REGISTER(DE));
3731 break;
3732
3733 case 0x64: /* LD IYH,IYH */
3734 break;
3735
3736 case 0x65: /* LD IYH,IYL */
3737 SET_HIGH_REGISTER(IY, LOW_REGISTER(IY));
3738 break;
3739
3740 case 0x66: /* LD H,(IY+dd) */
3741 adr = IY + (int8) RAM_PP(PC);
3742 SET_HIGH_REGISTER(HL, GET_BYTE(adr));
3743 break;
3744
3745 case 0x67: /* LD IYH,A */
3746 SET_HIGH_REGISTER(IY, HIGH_REGISTER(AF));
3747 break;
3748
3749 case 0x68: /* LD IYL,B */
3750 SET_LOW_REGISTER(IY, HIGH_REGISTER(BC));
3751 break;
3752
3753 case 0x69: /* LD IYL,C */
3754 SET_LOW_REGISTER(IY, LOW_REGISTER(BC));
3755 break;
3756
3757 case 0x6a: /* LD IYL,D */
3758 SET_LOW_REGISTER(IY, HIGH_REGISTER(DE));
3759 break;
3760
3761 case 0x6b: /* LD IYL,E */
3762 SET_LOW_REGISTER(IY, LOW_REGISTER(DE));
3763 break;
3764
3765 case 0x6c: /* LD IYL,IYH */
3766 SET_LOW_REGISTER(IY, HIGH_REGISTER(IY));
3767 break;
3768
3769 case 0x6d: /* LD IYL,IYL */
3770 break;
3771
3772 case 0x6e: /* LD L,(IY+dd) */
3773 adr = IY + (int8) RAM_PP(PC);
3774 SET_LOW_REGISTER(HL, GET_BYTE(adr));
3775 break;
3776
3777 case 0x6f: /* LD IYL,A */
3778 SET_LOW_REGISTER(IY, HIGH_REGISTER(AF));
3779 break;
3780
3781 case 0x70: /* LD (IY+dd),B */
3782 adr = IY + (int8) RAM_PP(PC);
3783 PUT_BYTE(adr, HIGH_REGISTER(BC));
3784 break;
3785
3786 case 0x71: /* LD (IY+dd),C */
3787 adr = IY + (int8) RAM_PP(PC);
3788 PUT_BYTE(adr, LOW_REGISTER(BC));
3789 break;
3790
3791 case 0x72: /* LD (IY+dd),D */
3792 adr = IY + (int8) RAM_PP(PC);
3793 PUT_BYTE(adr, HIGH_REGISTER(DE));
3794 break;
3795
3796 case 0x73: /* LD (IY+dd),E */
3797 adr = IY + (int8) RAM_PP(PC);
3798 PUT_BYTE(adr, LOW_REGISTER(DE));
3799 break;
3800
3801 case 0x74: /* LD (IY+dd),H */
3802 adr = IY + (int8) RAM_PP(PC);
3803 PUT_BYTE(adr, HIGH_REGISTER(HL));
3804 break;
3805
3806 case 0x75: /* LD (IY+dd),L */
3807 adr = IY + (int8) RAM_PP(PC);
3808 PUT_BYTE(adr, LOW_REGISTER(HL));
3809 break;
3810
3811 case 0x77: /* LD (IY+dd),A */
3812 adr = IY + (int8) RAM_PP(PC);
3813 PUT_BYTE(adr, HIGH_REGISTER(AF));
3814 break;
3815
3816 case 0x7c: /* LD A,IYH */
3817 SET_HIGH_REGISTER(AF, HIGH_REGISTER(IY));
3818 break;
3819
3820 case 0x7d: /* LD A,IYL */
3821 SET_HIGH_REGISTER(AF, LOW_REGISTER(IY));
3822 break;
3823
3824 case 0x7e: /* LD A,(IY+dd) */
3825 adr = IY + (int8) RAM_PP(PC);
3826 SET_HIGH_REGISTER(AF, GET_BYTE(adr));
3827 break;
3828
3829 case 0x84: /* ADD A,IYH */
3830 temp = HIGH_REGISTER(IY);
3831 acu = HIGH_REGISTER(AF);
3832 sum = acu + temp;
3833 AF = addTable[sum] | cbitsZ80Table[acu ^ temp ^ sum];
3834 break;
3835
3836 case 0x85: /* ADD A,IYL */
3837 temp = LOW_REGISTER(IY);
3838 acu = HIGH_REGISTER(AF);
3839 sum = acu + temp;
3840 AF = addTable[sum] | cbitsZ80Table[acu ^ temp ^ sum];
3841 break;
3842
3843 case 0x86: /* ADD A,(IY+dd) */
3844 adr = IY + (int8) RAM_PP(PC);
3845 temp = GET_BYTE(adr);
3846 acu = HIGH_REGISTER(AF);
3847 sum = acu + temp;
3848 AF = addTable[sum] | cbitsZ80Table[acu ^ temp ^ sum];
3849 break;
3850
3851 case 0x8c: /* ADC A,IYH */
3852 temp = HIGH_REGISTER(IY);
3853 acu = HIGH_REGISTER(AF);
3854 sum = acu + temp + TSTFLAG(C);
3855 AF = addTable[sum] | cbitsZ80Table[acu ^ temp ^ sum];
3856 break;
3857
3858 case 0x8d: /* ADC A,IYL */
3859 temp = LOW_REGISTER(IY);
3860 acu = HIGH_REGISTER(AF);
3861 sum = acu + temp + TSTFLAG(C);
3862 AF = addTable[sum] | cbitsZ80Table[acu ^ temp ^ sum];
3863 break;
3864
3865 case 0x8e: /* ADC A,(IY+dd) */
3866 adr = IY + (int8) RAM_PP(PC);
3867 temp = GET_BYTE(adr);
3868 acu = HIGH_REGISTER(AF);
3869 sum = acu + temp + TSTFLAG(C);
3870 AF = addTable[sum] | cbitsZ80Table[acu ^ temp ^ sum];
3871 break;
3872
3873 case 0x96: /* SUB (IY+dd) */
3874 adr = IY + (int8) RAM_PP(PC);
3875 temp = GET_BYTE(adr);
3876 acu = HIGH_REGISTER(AF);
3877 sum = acu - temp;
3878 AF = addTable[sum & 0xff] | cbits2Z80Table[(acu ^ temp ^ sum) & 0x1ff];
3879 break;
3880
3881 case 0x94: /* SUB IYH */
3882 SETFLAG(C, 0);/* fall through, a bit less efficient but smaller code */
3883
3884 case 0x9c: /* SBC A,IYH */
3885 temp = HIGH_REGISTER(IY);
3886 acu = HIGH_REGISTER(AF);
3887 sum = acu - temp - TSTFLAG(C);
3888 AF = addTable[sum & 0xff] | cbits2Z80Table[(acu ^ temp ^ sum) & 0x1ff];
3889 break;
3890
3891 case 0x95: /* SUB IYL */
3892 SETFLAG(C, 0);/* fall through, a bit less efficient but smaller code */
3893
3894 case 0x9d: /* SBC A,IYL */
3895 temp = LOW_REGISTER(IY);
3896 acu = HIGH_REGISTER(AF);
3897 sum = acu - temp - TSTFLAG(C);
3898 AF = addTable[sum & 0xff] | cbits2Z80Table[(acu ^ temp ^ sum) & 0x1ff];
3899 break;
3900
3901 case 0x9e: /* SBC A,(IY+dd) */
3902 adr = IY + (int8) RAM_PP(PC);
3903 temp = GET_BYTE(adr);
3904 acu = HIGH_REGISTER(AF);
3905 sum = acu - temp - TSTFLAG(C);
3906 AF = addTable[sum & 0xff] | cbits2Z80Table[(acu ^ temp ^ sum) & 0x1ff];
3907 break;
3908
3909 case 0xa4: /* AND IYH */
3910 AF = andTable[((AF & IY) >> 8) & 0xff];
3911 break;
3912
3913 case 0xa5: /* AND IYL */
3914 AF = andTable[((AF >> 8) & IY) & 0xff];
3915 break;
3916
3917 case 0xa6: /* AND (IY+dd) */
3918 adr = IY + (int8) RAM_PP(PC);
3919 AF = andTable[((AF >> 8) & GET_BYTE(adr)) & 0xff];
3920 break;
3921
3922 case 0xac: /* XOR IYH */
3923 AF = xororTable[((AF ^ IY) >> 8) & 0xff];
3924 break;
3925
3926 case 0xad: /* XOR IYL */
3927 AF = xororTable[((AF >> 8) ^ IY) & 0xff];
3928 break;
3929
3930 case 0xae: /* XOR (IY+dd) */
3931 adr = IY + (int8) RAM_PP(PC);
3932 AF = xororTable[((AF >> 8) ^ GET_BYTE(adr)) & 0xff];
3933 break;
3934
3935 case 0xb4: /* OR IYH */
3936 AF = xororTable[((AF | IY) >> 8) & 0xff];
3937 break;
3938
3939 case 0xb5: /* OR IYL */
3940 AF = xororTable[((AF >> 8) | IY) & 0xff];
3941 break;
3942
3943 case 0xb6: /* OR (IY+dd) */
3944 adr = IY + (int8) RAM_PP(PC);
3945 AF = xororTable[((AF >> 8) | GET_BYTE(adr)) & 0xff];
3946 break;
3947
3948 case 0xbc: /* CP IYH */
3949 temp = HIGH_REGISTER(IY);
3950 AF = (AF & ~0x28) | (temp & 0x28);
3951 acu = HIGH_REGISTER(AF);
3952 sum = acu - temp;
3953 AF = (AF & ~0xff) | cpTable[sum & 0xff] | (temp & 0x28) |
3954 cbits2Z80Table[(acu ^ temp ^ sum) & 0x1ff];
3955 break;
3956
3957 case 0xbd: /* CP IYL */
3958 temp = LOW_REGISTER(IY);
3959 AF = (AF & ~0x28) | (temp & 0x28);
3960 acu = HIGH_REGISTER(AF);
3961 sum = acu - temp;
3962 AF = (AF & ~0xff) | cpTable[sum & 0xff] | (temp & 0x28) |
3963 cbits2Z80Table[(acu ^ temp ^ sum) & 0x1ff];
3964 break;
3965
3966 case 0xbe: /* CP (IY+dd) */
3967 adr = IY + (int8) RAM_PP(PC);
3968 temp = GET_BYTE(adr);
3969 AF = (AF & ~0x28) | (temp & 0x28);
3970 acu = HIGH_REGISTER(AF);
3971 sum = acu - temp;
3972 AF = (AF & ~0xff) | cpTable[sum & 0xff] | (temp & 0x28) |
3973 cbits2Z80Table[(acu ^ temp ^ sum) & 0x1ff];
3974 break;
3975
3976 case 0xcb: /* CB prefix */
3977 adr = IY + (int8) RAM_PP(PC);
3978 switch ((op = GET_BYTE(PC)) & 7) {
3979
3980 case 0:
3981 ++PC;
3982 acu = HIGH_REGISTER(BC);
3983 break;
3984
3985 case 1:
3986 ++PC;
3987 acu = LOW_REGISTER(BC);
3988 break;
3989
3990 case 2:
3991 ++PC;
3992 acu = HIGH_REGISTER(DE);
3993 break;
3994
3995 case 3:
3996 ++PC;
3997 acu = LOW_REGISTER(DE);
3998 break;
3999
4000 case 4:
4001 ++PC;
4002 acu = HIGH_REGISTER(HL);
4003 break;
4004
4005 case 5:
4006 ++PC;
4007 acu = LOW_REGISTER(HL);
4008 break;
4009
4010 case 6:
4011 ++PC;
4012 acu = GET_BYTE(adr);
4013 break;
4014
4015 case 7:
4016 ++PC;
4017 acu = HIGH_REGISTER(AF);
4018 break;
4019 }
4020 switch (op & 0xc0) {
4021
4022 case 0x00: /* shift/rotate */
4023 switch (op & 0x38) {
4024
4025 case 0x00:/* RLC */
4026 temp = (acu << 1) | (acu >> 7);
4027 cbits = temp & 1;
4028 goto cbshflg3;
4029
4030 case 0x08:/* RRC */
4031 temp = (acu >> 1) | (acu << 7);
4032 cbits = temp & 0x80;
4033 goto cbshflg3;
4034
4035 case 0x10:/* RL */
4036 temp = (acu << 1) | TSTFLAG(C);
4037 cbits = acu & 0x80;
4038 goto cbshflg3;
4039
4040 case 0x18:/* RR */
4041 temp = (acu >> 1) | (TSTFLAG(C) << 7);
4042 cbits = acu & 1;
4043 goto cbshflg3;
4044
4045 case 0x20:/* SLA */
4046 temp = acu << 1;
4047 cbits = acu & 0x80;
4048 goto cbshflg3;
4049
4050 case 0x28:/* SRA */
4051 temp = (acu >> 1) | (acu & 0x80);
4052 cbits = acu & 1;
4053 goto cbshflg3;
4054
4055 case 0x30:/* SLIA */
4056 temp = (acu << 1) | 1;
4057 cbits = acu & 0x80;
4058 goto cbshflg3;
4059
4060 case 0x38:/* SRL */
4061 temp = acu >> 1;
4062 cbits = acu & 1;
4063 cbshflg3:
4064 AF = (AF & ~0xff) | rotateShiftTable[temp & 0xff] | !!cbits;
4065 }
4066 break;
4067
4068 case 0x40: /* BIT */
4069 if (acu & (1 << ((op >> 3) & 7)))
4070 AF = (AF & ~0xfe) | 0x10 | (((op & 0x38) == 0x38) << 7);
4071 else AF = (AF & ~0xfe) | 0x54;
4072 if ((op & 7) != 6) AF |= (acu & 0x28);
4073 temp = acu;
4074 break;
4075
4076 case 0x80: /* RES */
4077 temp = acu & ~(1 << ((op >> 3) & 7));
4078 break;
4079
4080 case 0xc0: /* SET */
4081 temp = acu | (1 << ((op >> 3) & 7));
4082 break;
4083 }
4084 switch (op & 7) {
4085
4086 case 0:
4087 SET_HIGH_REGISTER(BC, temp);
4088 break;
4089
4090 case 1:
4091 SET_LOW_REGISTER(BC, temp);
4092 break;
4093
4094 case 2:
4095 SET_HIGH_REGISTER(DE, temp);
4096 break;
4097
4098 case 3:
4099 SET_LOW_REGISTER(DE, temp);
4100 break;
4101
4102 case 4:
4103 SET_HIGH_REGISTER(HL, temp);
4104 break;
4105
4106 case 5:
4107 SET_LOW_REGISTER(HL, temp);
4108 break;
4109
4110 case 6:
4111 PUT_BYTE(adr, temp);
4112 break;
4113
4114 case 7:
4115 SET_HIGH_REGISTER(AF, temp);
4116 break;
4117 }
4118 break;
4119
4120 case 0xe1: /* POP IY */
4121 POP(IY);
4122 break;
4123
4124 case 0xe3: /* EX (SP),IY */
4125 temp = IY;
4126 POP(IY);
4127 PUSH(temp);
4128 break;
4129
4130 case 0xe5: /* PUSH IY */
4131 PUSH(IY);
4132 break;
4133
4134 case 0xe9: /* JP (IY) */
4135 PC = IY;
4136 break;
4137
4138 case 0xf9: /* LD SP,IY */
4139 SP = IY;
4140 break;
4141
4142 default: /* ignore FD */
4143 CHECK_CPU_Z80;
4144 PC--;
4145 }
4146 break;
4147
4148 case 0xfe: /* CP nn */
4149 temp = RAM_PP(PC);
4150 AF = (AF & ~0x28) | (temp & 0x28);
4151 acu = HIGH_REGISTER(AF);
4152 sum = acu - temp;
4153 cbits = acu ^ temp ^ sum;
4154 AF = (AF & ~0xff) | cpTable[sum & 0xff] | (temp & 0x28) |
4155 (SET_PV) | cbits2Table[cbits & 0x1ff];
4156 break;
4157
4158 case 0xff: /* RST 38H */
4159 PUSH(PC);
4160 PC = 0x38;
4161 }
4162 }
4163 end_decode:
4164
4165 /* simulation halted */
4166 PC_S = (reason == STOP_OPCODE) ? PCX : PC;
4167 AF_S = AF;
4168 BC_S = BC;
4169 DE_S = DE;
4170 HL_S = HL;
4171 IX_S = IX;
4172 IY_S = IY;
4173 SP_S = SP;
4174 return reason;
4175 }
Magically enhanced SIMH