← Back to branch summary

~ubuntu-branches/debian/sid/mame/sid

« back to all changes in this revision

Viewing changes to mess/src/emu/cpu/z8/z8ops.c

  • Committer: Package Import Robot
  • Author(s): Jordi Mallach, Jordi Mallach, Emmanuel Kasper
  • Date: 2011-12-19 22:56:27 UTC
  • mfrom: (0.1.2)
  • Revision ID: package-import@ubuntu.com-20111219225627-ub5oga1oys4ogqzm
Tags: 0.144-1
http://bugs.debian.org/651538
[ Jordi Mallach ]
* Fix syntax errors in DEP5 copyright file (lintian).
* Use a versioned copyright Format specification field.
* Update Vcs-* URLs.
* Move transitional packages to the new metapackages section, and make
  them priority extra.
* Remove references to GNU/Linux and MESS sources from copyright.
* Add build variables for s390x.
* Use .xz tarballs as it cuts 4MB for the upstream sources.
* Add nplayers.ini as a patch. Update copyright file to add CC-BY-SA-3.0.

[ Emmanuel Kasper ]
* New upstream release. Closes: #651538.
* Add Free Desktop compliant png icons of various sizes taken from
  the hydroxygen iconset
* Mess is now built from a new source package, to avoid possible source
  incompatibilities between mame and the mess overlay.
* Mame-tools are not built from the mame source package anymore, but
  from the mess source package

Show diffs side-by-side

added added

removed removed

Lines of Context:
mess/src/emu/cpu/z8/z8ops.c
1
 
/**********************************************************************
2
 
 
3
 
    Zilog Z8 Single-Chip MCU emulation
4
 
 
5
 
    Copyright MESS Team.
6
 
    Visit http://mamedev.org for licensing and usage restrictions.
7
 
 
8
 
**********************************************************************/
9
 
 
10
 
/***************************************************************************
11
 
    MACROS
12
 
***************************************************************************/
13
 
 
14
 
#define read(_reg)              register_read(cpustate, _reg)
15
 
#define r(_data)                get_working_register(cpustate, _data)
16
 
#define Ir(_data)               get_intermediate_register(cpustate, get_working_register(cpustate, _data))
17
 
#define R                               get_register(cpustate, fetch(cpustate))
18
 
#define IR                              get_intermediate_register(cpustate, get_register(cpustate, fetch(cpustate)))
19
 
#define RR                              get_intermediate_register(cpustate, get_register(cpustate, fetch(cpustate)))
20
 
#define IM                              fetch(cpustate)
21
 
#define flag(_flag)             ((cpustate->r[Z8_REGISTER_FLAGS] & Z8_FLAGS##_##_flag) ? 1 : 0)
22
 
 
23
 
#define mode_r1_r2(_func)       \
24
 
        UINT8 dst_src = fetch(cpustate);\
25
 
        UINT8 dst = r(dst_src >> 4);\
26
 
        UINT8 src = read(r(dst_src & 0x0f));\
27
 
        _func(cpustate, dst, src);
28
 
 
29
 
#define mode_r1_Ir2(_func) \
30
 
        UINT8 dst_src = fetch(cpustate);\
31
 
        UINT8 dst = r(dst_src >> 4);\
32
 
        UINT8 src = read(Ir(dst_src & 0x0f));\
33
 
        _func(cpustate, dst, src);
34
 
 
35
 
#define mode_R2_R1(_func) \
36
 
        UINT8 src = read(R);\
37
 
        UINT8 dst = R;\
38
 
        _func(cpustate, dst, src);
39
 
 
40
 
#define mode_IR2_R1(_func) \
41
 
        UINT8 src = read(R);\
42
 
        UINT8 dst = IR;\
43
 
        _func(cpustate, dst, src);
44
 
 
45
 
#define mode_R1_IM(_func) \
46
 
        UINT8 dst = R;\
47
 
        UINT8 src = IM;\
48
 
        _func(cpustate, dst, src);
49
 
 
50
 
#define mode_IR1_IM(_func) \
51
 
        UINT8 dst = IR;\
52
 
        UINT8 src = IM;\
53
 
        _func(cpustate, dst, src);
54
 
 
55
 
#define mode_r1(_func) \
56
 
        UINT8 dst = r(opcode >> 4);\
57
 
        _func(cpustate, dst);
58
 
 
59
 
#define mode_R1(_func) \
60
 
        UINT8 dst = R;\
61
 
        _func(cpustate, dst);
62
 
 
63
 
#define mode_RR1(_func) \
64
 
        UINT8 dst = R;\
65
 
        _func(cpustate, dst);
66
 
 
67
 
#define mode_IR1(_func) \
68
 
        UINT8 dst = IR;\
69
 
        _func(cpustate, dst);
70
 
 
71
 
#define mode_r1_IM(_func) \
72
 
        UINT8 dst = r(opcode >> 4);\
73
 
        UINT8 src = IM;\
74
 
        _func(cpustate, dst, src);
75
 
 
76
 
#define mode_r1_R2(_func) \
77
 
        UINT8 dst = r(opcode >> 4);\
78
 
        UINT8 src = read(R);\
79
 
        _func(cpustate, dst, src);
80
 
 
81
 
#define mode_r2_R1(_func) \
82
 
        UINT8 src = read(r(opcode >> 4));\
83
 
        UINT8 dst = R;\
84
 
        _func(cpustate, dst, src);
85
 
 
86
 
#define mode_Ir1_r2(_func) \
87
 
        UINT8 dst_src = fetch(cpustate);\
88
 
        UINT8 dst = Ir(dst_src >> 4);\
89
 
        UINT8 src = read(r(dst_src & 0x0f));\
90
 
        _func(cpustate, dst, src);
91
 
 
92
 
#define mode_R2_IR1(_func) \
93
 
        UINT8 src = read(R);\
94
 
        UINT8 dst = IR;\
95
 
        _func(cpustate, dst, src);
96
 
 
97
 
#define mode_r1_x_R2(_func) \
98
 
        UINT8 dst_src = fetch(cpustate);\
99
 
        UINT8 dst = r(dst_src >> 4);\
100
 
        UINT8 src = read(read(r(dst_src & 0x0f)) + R);\
101
 
        _func(cpustate, dst, src);
102
 
 
103
 
#define mode_r2_x_R1(_func) \
104
 
        UINT8 dst_src = fetch(cpustate);\
105
 
        UINT8 dst = R + read(r(dst_src & 0x0f));\
106
 
        UINT8 src = read(r(dst_src >> 4));\
107
 
        _func(cpustate, dst, src);
108
 
 
109
 
/***************************************************************************
110
 
    LOAD INSTRUCTIONS
111
 
***************************************************************************/
112
 
 
113
 
static void clear(z8_state *cpustate, UINT8 dst)
114
 
{
115
 
        /* dst <- 0 */
116
 
        register_write(cpustate, dst, 0);
117
 
}
118
 
 
119
 
INSTRUCTION( clr_R1 )                   { mode_R1(clear) }
120
 
INSTRUCTION( clr_IR1 )                  { mode_IR1(clear) }
121
 
 
122
 
static void load(z8_state *cpustate, UINT8 dst, UINT8 src)
123
 
{
124
 
        /* dst <- src */
125
 
        register_write(cpustate, dst, src);
126
 
}
127
 
 
128
 
INSTRUCTION( ld_r1_IM )                 { mode_r1_IM(load) }
129
 
INSTRUCTION( ld_r1_R2 )                 { mode_r1_R2(load) }
130
 
INSTRUCTION( ld_r2_R1 )                 { mode_r2_R1(load) }
131
 
INSTRUCTION( ld_Ir1_r2 )                { mode_Ir1_r2(load) }
132
 
INSTRUCTION( ld_R2_IR1 )                { mode_R2_IR1(load) }
133
 
INSTRUCTION( ld_r1_x_R2 )               { mode_r1_x_R2(load) }
134
 
INSTRUCTION( ld_r2_x_R1 )               { mode_r2_x_R1(load) }
135
 
 
136
 
INSTRUCTION( ld_r1_r2 )                 { mode_r1_r2(load) }
137
 
INSTRUCTION( ld_r1_Ir2 )                { mode_r1_Ir2(load) }
138
 
INSTRUCTION( ld_R2_R1 )                 { mode_R2_R1(load) }
139
 
INSTRUCTION( ld_IR2_R1 )                { mode_IR2_R1(load) }
140
 
INSTRUCTION( ld_R1_IM )                 { mode_R1_IM(load) }
141
 
INSTRUCTION( ld_IR1_IM )                { mode_IR1_IM(load) }
142
 
 
143
 
static void load_from_memory(z8_state *cpustate, address_space *space)
144
 
{
145
 
        UINT8 operands = fetch(cpustate);
146
 
        UINT8 dst = get_working_register(cpustate, operands >> 4);
147
 
        UINT8 src = get_working_register(cpustate, operands & 0x0f);
148
 
 
149
 
        UINT16 address = register_pair_read(cpustate, src);
150
 
        UINT8 data = cpustate->direct->read_decrypted_byte(address);
151
 
 
152
 
        register_write(cpustate, dst, data);
153
 
}
154
 
 
155
 
static void load_to_memory(z8_state *cpustate, address_space *space)
156
 
{
157
 
        UINT8 operands = fetch(cpustate);
158
 
        UINT8 src = get_working_register(cpustate, operands >> 4);
159
 
        UINT8 dst = get_working_register(cpustate, operands & 0x0f);
160
 
 
161
 
        UINT16 address = register_pair_read(cpustate, dst);
162
 
        UINT8 data = register_read(cpustate, src);
163
 
 
164
 
        cpustate->program->write_byte(address, data);
165
 
}
166
 
 
167
 
static void load_from_memory_autoinc(z8_state *cpustate, address_space *space)
168
 
{
169
 
        UINT8 operands = fetch(cpustate);
170
 
        UINT8 dst = get_working_register(cpustate, operands >> 4);
171
 
        UINT8 real_dst = get_intermediate_register(cpustate, dst);
172
 
        UINT8 src = get_working_register(cpustate, operands & 0x0f);
173
 
 
174
 
        UINT16 address = register_pair_read(cpustate, src);
175
 
        UINT8 data = cpustate->direct->read_decrypted_byte(address);
176
 
 
177
 
        register_write(cpustate, real_dst, data);
178
 
 
179
 
        register_write(cpustate, dst, real_dst + 1);
180
 
        register_pair_write(cpustate, src, address + 1);
181
 
}
182
 
 
183
 
static void load_to_memory_autoinc(z8_state *cpustate, address_space *space)
184
 
{
185
 
        UINT8 operands = fetch(cpustate);
186
 
        UINT8 src = get_working_register(cpustate, operands >> 4);
187
 
        UINT8 dst = get_working_register(cpustate, operands & 0x0f);
188
 
        UINT8 real_src = get_intermediate_register(cpustate, src);
189
 
 
190
 
        UINT16 address = register_pair_read(cpustate, dst);
191
 
        UINT8 data = register_read(cpustate, real_src);
192
 
 
193
 
        cpustate->program->write_byte(address, data);
194
 
 
195
 
        register_pair_write(cpustate, dst, address + 1);
196
 
        register_write(cpustate, src, real_src + 1);
197
 
}
198
 
 
199
 
INSTRUCTION( ldc_r1_Irr2 )              { load_from_memory(cpustate, cpustate->program); }
200
 
INSTRUCTION( ldc_r2_Irr1 )              { load_to_memory(cpustate, cpustate->program); }
201
 
INSTRUCTION( ldci_Ir1_Irr2 )    { load_from_memory_autoinc(cpustate, cpustate->program); }
202
 
INSTRUCTION( ldci_Ir2_Irr1 )    { load_to_memory_autoinc(cpustate, cpustate->program); }
203
 
INSTRUCTION( lde_r1_Irr2 )              { load_from_memory(cpustate, cpustate->data); }
204
 
INSTRUCTION( lde_r2_Irr1 )              { load_to_memory(cpustate, cpustate->data); }
205
 
INSTRUCTION( ldei_Ir1_Irr2 )    { load_from_memory_autoinc(cpustate, cpustate->data); }
206
 
INSTRUCTION( ldei_Ir2_Irr1 )    { load_to_memory_autoinc(cpustate, cpustate->data); }
207
 
 
208
 
static void pop(z8_state *cpustate, UINT8 dst)
209
 
{
210
 
        /* dst <- @SP
211
 
       SP <- SP + 1 */
212
 
        register_write(cpustate, dst, stack_pop_byte(cpustate));
213
 
}
214
 
 
215
 
INSTRUCTION( pop_R1 )                   { mode_R1(pop) }
216
 
INSTRUCTION( pop_IR1 )                  { mode_IR1(pop) }
217
 
 
218
 
static void push(z8_state *cpustate, UINT8 src)
219
 
{
220
 
        /* SP <- SP - 1
221
 
       @SP <- src */
222
 
        stack_push_byte(cpustate, read(src));
223
 
}
224
 
 
225
 
INSTRUCTION( push_R2 )                  { mode_R1(push) }
226
 
INSTRUCTION( push_IR2 )                 { mode_IR1(push) }
227
 
 
228
 
/***************************************************************************
229
 
    ARITHMETIC INSTRUCTIONS
230
 
***************************************************************************/
231
 
 
232
 
static void add_carry(z8_state *cpustate, UINT8 dst, INT8 src)
233
 
{
234
 
        /* dst <- dst + src + C */
235
 
        UINT8 data = register_read(cpustate, dst);
236
 
        UINT16 new_data = data + src + flag(C);
237
 
 
238
 
        set_flag_c(new_data & 0x100);
239
 
        set_flag_z(new_data == 0);
240
 
        set_flag_s(new_data & 0x80);
241
 
        set_flag_v(((data & 0x80) == (src & 0x80)) && ((new_data & 0x80) != (src & 0x80)));
242
 
        set_flag_d(0);
243
 
        set_flag_h(((data & 0x1f) == 0x0f) && ((new_data & 0x1f) == 0x10));
244
 
 
245
 
        register_write(cpustate, dst, new_data & 0xff);
246
 
}
247
 
 
248
 
INSTRUCTION( adc_r1_r2 )                { mode_r1_r2(add_carry) }
249
 
INSTRUCTION( adc_r1_Ir2 )               { mode_r1_Ir2(add_carry) }
250
 
INSTRUCTION( adc_R2_R1 )                { mode_R2_R1(add_carry) }
251
 
INSTRUCTION( adc_IR2_R1 )               { mode_IR2_R1(add_carry) }
252
 
INSTRUCTION( adc_R1_IM )                { mode_R1_IM(add_carry) }
253
 
INSTRUCTION( adc_IR1_IM )               { mode_IR1_IM(add_carry) }
254
 
 
255
 
static void add(z8_state *cpustate, UINT8 dst, INT8 src)
256
 
{
257
 
        /* dst <- dst + src */
258
 
        UINT8 data = register_read(cpustate, dst);
259
 
        UINT16 new_data = data + src;
260
 
 
261
 
        set_flag_c(new_data & 0x100);
262
 
        set_flag_z(new_data == 0);
263
 
        set_flag_s(new_data & 0x80);
264
 
        set_flag_v(((data & 0x80) == (src & 0x80)) && ((new_data & 0x80) != (src & 0x80)));
265
 
        set_flag_d(0);
266
 
        set_flag_h(((data & 0x1f) == 0x0f) && ((new_data & 0x1f) == 0x10));
267
 
 
268
 
        register_write(cpustate, dst, new_data & 0xff);
269
 
}
270
 
 
271
 
INSTRUCTION( add_r1_r2 )                { mode_r1_r2(add) }
272
 
INSTRUCTION( add_r1_Ir2 )               { mode_r1_Ir2(add) }
273
 
INSTRUCTION( add_R2_R1 )                { mode_R2_R1(add) }
274
 
INSTRUCTION( add_IR2_R1 )               { mode_IR2_R1(add) }
275
 
INSTRUCTION( add_R1_IM )                { mode_R1_IM(add) }
276
 
INSTRUCTION( add_IR1_IM )               { mode_IR1_IM(add) }
277
 
 
278
 
static void compare(z8_state *cpustate, UINT8 dst, UINT8 src)
279
 
{
280
 
        /* dst - src */
281
 
        UINT8 data = register_read(cpustate, dst);
282
 
        UINT16 new_data = data - src;
283
 
 
284
 
        set_flag_c(!(new_data & 0x100));
285
 
        set_flag_z(new_data == 0);
286
 
        set_flag_s(new_data & 0x80);
287
 
        set_flag_v(((data & 0x80) != (src & 0x80)) && ((new_data & 0x80) == (src & 0x80)));
288
 
}
289
 
 
290
 
INSTRUCTION( cp_r1_r2 )                 { mode_r1_r2(compare) }
291
 
INSTRUCTION( cp_r1_Ir2 )                { mode_r1_Ir2(compare) }
292
 
INSTRUCTION( cp_R2_R1 )                 { mode_R2_R1(compare) }
293
 
INSTRUCTION( cp_IR2_R1 )                { mode_IR2_R1(compare) }
294
 
INSTRUCTION( cp_R1_IM )                 { mode_R1_IM(compare) }
295
 
INSTRUCTION( cp_IR1_IM )                { mode_IR1_IM(compare) }
296
 
 
297
 
static void decimal_adjust(z8_state *cpustate, UINT8 dst)
298
 
{
299
 
}
300
 
 
301
 
INSTRUCTION( da_R1 )                    { mode_R1(decimal_adjust) }
302
 
INSTRUCTION( da_IR1 )                   { mode_IR1(decimal_adjust) }
303
 
 
304
 
static void decrement(z8_state *cpustate, UINT8 dst)
305
 
{
306
 
        /* dst <- dst - 1 */
307
 
        UINT8 data = register_read(cpustate, dst) - 1;
308
 
 
309
 
        set_flag_z(data == 0);
310
 
        set_flag_s(data & 0x80);
311
 
        set_flag_v(data == 0x7f);
312
 
 
313
 
        register_write(cpustate, dst, data);
314
 
}
315
 
 
316
 
INSTRUCTION( dec_R1 )                   { mode_R1(decrement) }
317
 
INSTRUCTION( dec_IR1 )                  { mode_IR1(decrement) }
318
 
 
319
 
static void decrement_word(z8_state *cpustate, UINT8 dst)
320
 
{
321
 
        /* dst <- dst - 1 */
322
 
        UINT16 data = register_pair_read(cpustate, dst) - 1;
323
 
 
324
 
        set_flag_z(data == 0);
325
 
        set_flag_s(data & 0x8000);
326
 
        set_flag_v(data == 0x7fff);
327
 
 
328
 
        register_pair_write(cpustate, dst, data);
329
 
}
330
 
 
331
 
INSTRUCTION( decw_RR1 )                 { mode_RR1(decrement_word) }
332
 
INSTRUCTION( decw_IR1 )                 { mode_IR1(decrement_word) }
333
 
 
334
 
static void increment(z8_state *cpustate, UINT8 dst)
335
 
{
336
 
        /* dst <- dst + 1 */
337
 
        UINT8 data = register_read(cpustate, dst) + 1;
338
 
 
339
 
        set_flag_z(data == 0);
340
 
        set_flag_s(data & 0x80);
341
 
        set_flag_v(data == 0x80);
342
 
 
343
 
        register_write(cpustate, dst, data);
344
 
}
345
 
 
346
 
INSTRUCTION( inc_r1 )                   { mode_r1(increment) }
347
 
INSTRUCTION( inc_R1 )                   { mode_R1(increment) }
348
 
INSTRUCTION( inc_IR1 )                  { mode_IR1(increment) }
349
 
 
350
 
static void increment_word(z8_state *cpustate, UINT8 dst)
351
 
{
352
 
        /* dst <- dst + 1 */
353
 
        UINT16 data = register_pair_read(cpustate, dst) + 1;
354
 
 
355
 
        set_flag_z(data == 0);
356
 
        set_flag_s(data & 0x8000);
357
 
        set_flag_v(data == 0x8000);
358
 
 
359
 
        register_pair_write(cpustate, dst, data);
360
 
}
361
 
 
362
 
INSTRUCTION( incw_RR1 )                 { mode_RR1(increment_word) }
363
 
INSTRUCTION( incw_IR1 )                 { mode_IR1(increment_word) }
364
 
 
365
 
static void subtract_carry(z8_state *cpustate, UINT8 dst, UINT8 src)
366
 
{
367
 
        /* dst <- dst - src - C */
368
 
        UINT8 data = register_read(cpustate, dst);
369
 
        UINT16 new_data = data - src;
370
 
 
371
 
        set_flag_c(!(new_data & 0x100));
372
 
        set_flag_z(new_data == 0);
373
 
        set_flag_s(new_data & 0x80);
374
 
        set_flag_v(((data & 0x80) != (src & 0x80)) && ((new_data & 0x80) == (src & 0x80)));
375
 
        set_flag_d(1);
376
 
        set_flag_h(!(((data & 0x1f) == 0x0f) && ((new_data & 0x1f) == 0x10)));
377
 
 
378
 
        register_write(cpustate, dst, new_data & 0xff);
379
 
}
380
 
 
381
 
INSTRUCTION( sbc_r1_r2 )                { mode_r1_r2(subtract_carry) }
382
 
INSTRUCTION( sbc_r1_Ir2 )               { mode_r1_Ir2(subtract_carry) }
383
 
INSTRUCTION( sbc_R2_R1 )                { mode_R2_R1(subtract_carry) }
384
 
INSTRUCTION( sbc_IR2_R1 )               { mode_IR2_R1(subtract_carry) }
385
 
INSTRUCTION( sbc_R1_IM )                { mode_R1_IM(subtract_carry) }
386
 
INSTRUCTION( sbc_IR1_IM )               { mode_IR1_IM(subtract_carry) }
387
 
 
388
 
static void subtract(z8_state *cpustate, UINT8 dst, UINT8 src)
389
 
{
390
 
        /* dst <- dst - src */
391
 
        UINT8 data = register_read(cpustate, dst);
392
 
        UINT16 new_data = data - src;
393
 
 
394
 
        set_flag_c(!(new_data & 0x100));
395
 
        set_flag_z(new_data == 0);
396
 
        set_flag_s(new_data & 0x80);
397
 
        set_flag_v(((data & 0x80) != (src & 0x80)) && ((new_data & 0x80) == (src & 0x80)));
398
 
        set_flag_d(1);
399
 
        set_flag_h(!(((data & 0x1f) == 0x0f) && ((new_data & 0x1f) == 0x10)));
400
 
 
401
 
        register_write(cpustate, dst, new_data & 0xff);
402
 
}
403
 
 
404
 
INSTRUCTION( sub_r1_r2 )                { mode_r1_r2(subtract) }
405
 
INSTRUCTION( sub_r1_Ir2 )               { mode_r1_Ir2(subtract) }
406
 
INSTRUCTION( sub_R2_R1 )                { mode_R2_R1(subtract) }
407
 
INSTRUCTION( sub_IR2_R1 )               { mode_IR2_R1(subtract) }
408
 
INSTRUCTION( sub_R1_IM )                { mode_R1_IM(subtract) }
409
 
INSTRUCTION( sub_IR1_IM )               { mode_IR1_IM(subtract) }
410
 
 
411
 
/***************************************************************************
412
 
    LOGICAL INSTRUCTIONS
413
 
***************************************************************************/
414
 
 
415
 
static void _and(z8_state *cpustate, UINT8 dst, UINT8 src)
416
 
{
417
 
        /* dst <- dst AND src */
418
 
        UINT8 data = register_read(cpustate, dst) & src;
419
 
        register_write(cpustate, dst, data);
420
 
 
421
 
        set_flag_z(data == 0);
422
 
        set_flag_s(data & 0x80);
423
 
        set_flag_v(0);
424
 
}
425
 
 
426
 
INSTRUCTION( and_r1_r2 )                { mode_r1_r2(_and) }
427
 
INSTRUCTION( and_r1_Ir2 )               { mode_r1_Ir2(_and) }
428
 
INSTRUCTION( and_R2_R1 )                { mode_R2_R1(_and) }
429
 
INSTRUCTION( and_IR2_R1 )               { mode_IR2_R1(_and) }
430
 
INSTRUCTION( and_R1_IM )                { mode_R1_IM(_and) }
431
 
INSTRUCTION( and_IR1_IM )               { mode_IR1_IM(_and) }
432
 
 
433
 
static void complement(z8_state *cpustate, UINT8 dst)
434
 
{
435
 
        /* dst <- NOT dst */
436
 
        UINT8 data = register_read(cpustate, dst) ^ 0xff;
437
 
        register_write(cpustate, dst, data);
438
 
 
439
 
        set_flag_z(data == 0);
440
 
        set_flag_s(data & 0x80);
441
 
        set_flag_v(0);
442
 
}
443
 
 
444
 
INSTRUCTION( com_R1 )                   { mode_R1(complement) }
445
 
INSTRUCTION( com_IR1 )                  { mode_IR1(complement) }
446
 
 
447
 
static void _or(z8_state *cpustate, UINT8 dst, UINT8 src)
448
 
{
449
 
        /* dst <- dst OR src */
450
 
        UINT8 data = register_read(cpustate, dst) | src;
451
 
        register_write(cpustate, dst, data);
452
 
 
453
 
        set_flag_z(data == 0);
454
 
        set_flag_s(data & 0x80);
455
 
        set_flag_v(0);
456
 
}
457
 
 
458
 
INSTRUCTION( or_r1_r2 )                 { mode_r1_r2(_or) }
459
 
INSTRUCTION( or_r1_Ir2 )                { mode_r1_Ir2(_or) }
460
 
INSTRUCTION( or_R2_R1 )                 { mode_R2_R1(_or) }
461
 
INSTRUCTION( or_IR2_R1 )                { mode_IR2_R1(_or) }
462
 
INSTRUCTION( or_R1_IM )                 { mode_R1_IM(_or) }
463
 
INSTRUCTION( or_IR1_IM )                { mode_IR1_IM(_or) }
464
 
 
465
 
static void _xor(z8_state *cpustate, UINT8 dst, UINT8 src)
466
 
{
467
 
        /* dst <- dst XOR src */
468
 
        UINT8 data = register_read(cpustate, dst) ^ src;
469
 
        register_write(cpustate, dst, data);
470
 
 
471
 
        set_flag_z(data == 0);
472
 
        set_flag_s(data & 0x80);
473
 
        set_flag_v(0);
474
 
}
475
 
 
476
 
INSTRUCTION( xor_r1_r2 )                { mode_r1_r2(_xor) }
477
 
INSTRUCTION( xor_r1_Ir2 )               { mode_r1_Ir2(_xor) }
478
 
INSTRUCTION( xor_R2_R1 )                { mode_R2_R1(_xor) }
479
 
INSTRUCTION( xor_IR2_R1 )               { mode_IR2_R1(_xor) }
480
 
INSTRUCTION( xor_R1_IM )                { mode_R1_IM(_xor) }
481
 
INSTRUCTION( xor_IR1_IM )               { mode_IR1_IM(_xor) }
482
 
 
483
 
/***************************************************************************
484
 
    PROGRAM CONTROL INSTRUCTIONS
485
 
***************************************************************************/
486
 
 
487
 
static void call(z8_state *cpustate, UINT16 dst)
488
 
{
489
 
        stack_push_word(cpustate, cpustate->pc);
490
 
        cpustate->pc = dst;
491
 
}
492
 
 
493
 
INSTRUCTION( call_IRR1 )                { UINT16 dst = register_pair_read(cpustate, get_intermediate_register(cpustate, get_register(cpustate, fetch(cpustate)))); call(cpustate, dst); }
494
 
INSTRUCTION( call_DA )                  { UINT16 dst = (fetch(cpustate) << 8) | fetch(cpustate); call(cpustate, dst); }
495
 
 
496
 
INSTRUCTION( djnz_r1_RA )
497
 
{
498
 
        INT8 ra = (INT8)fetch(cpustate);
499
 
 
500
 
        /* r <- r - 1 */
501
 
        int r = get_working_register(cpustate, opcode >> 4);
502
 
        UINT8 data = register_read(cpustate, r) - 1;
503
 
        register_write(cpustate, r, data);
504
 
 
505
 
        /* if r<>0, PC <- PC + dst */
506
 
        if (data != 0)
507
 
        {
508
 
                cpustate->pc += ra;
509
 
                *cycles += 2;
510
 
        }
511
 
}
512
 
 
513
 
INSTRUCTION( iret )
514
 
{
515
 
        /* FLAGS <- @SP
516
 
       SP <- SP + 1 */
517
 
        register_write(cpustate, Z8_REGISTER_FLAGS, stack_pop_byte(cpustate));
518
 
 
519
 
        /* PC <- @SP
520
 
       SP <- SP + 2 */
521
 
        cpustate->pc = stack_pop_word(cpustate);
522
 
 
523
 
        /* IMR (7) <- 1 */
524
 
        cpustate->r[Z8_REGISTER_IMR] |= Z8_IMR_ENABLE;
525
 
}
526
 
 
527
 
INSTRUCTION( ret )
528
 
{
529
 
        /* PC <- @SP
530
 
       SP <- SP + 2 */
531
 
        cpustate->pc = stack_pop_word(cpustate);
532
 
}
533
 
 
534
 
static void jump(z8_state *cpustate, UINT16 dst)
535
 
{
536
 
        /* PC <- dst */
537
 
        cpustate->pc = dst;
538
 
}
539
 
 
540
 
INSTRUCTION( jp_IRR1 )                  { jump(cpustate, register_pair_read(cpustate, IR)); }
541
 
 
542
 
static int check_condition_code(z8_state *cpustate, int cc)
543
 
{
544
 
        int truth = 0;
545
 
 
546
 
        switch (cc)
547
 
        {
548
 
        case CC_F:              truth = 0; break;
549
 
        case CC_LT:             truth = flag(S) ^ flag(V); break;
550
 
        case CC_LE:             truth = (flag(Z) | (flag(S) ^ flag(V))); break;
551
 
        case CC_ULE:    truth = flag(C) | flag(Z); break;
552
 
        case CC_OV:             truth = flag(V); break;
553
 
        case CC_MI:             truth = flag(S); break;
554
 
        case CC_Z:              truth = flag(Z); break;
555
 
        case CC_C:              truth = flag(C); break;
556
 
        case CC_T:              truth = 1; break;
557
 
        case CC_GE:             truth = !(flag(S) ^ flag(V)); break;
558
 
        case CC_GT:             truth = !(flag(Z) | (flag(S) ^ flag(V))); break;
559
 
        case CC_UGT:    truth = ((!flag(C)) & (!flag(Z))); break;
560
 
        case CC_NOV:    truth = !flag(V); break;
561
 
        case CC_PL:             truth = !flag(S); break;
562
 
        case CC_NZ:             truth = !flag(Z); break;
563
 
        case CC_NC:             truth = !flag(C); break;
564
 
        }
565
 
 
566
 
        return truth;
567
 
}
568
 
 
569
 
INSTRUCTION( jp_cc_DA )
570
 
{
571
 
        UINT16 dst = (fetch(cpustate) << 8) | fetch(cpustate);
572
 
 
573
 
        /* if cc is true, then PC <- dst */
574
 
        if (check_condition_code(cpustate, opcode >> 4))
575
 
        {
576
 
                jump(cpustate, dst);
577
 
                *cycles += 2;
578
 
        }
579
 
}
580
 
 
581
 
INSTRUCTION( jr_cc_RA )
582
 
{
583
 
        INT8 ra = (INT8)fetch(cpustate);
584
 
        UINT16 dst = cpustate->pc + ra;
585
 
 
586
 
        /* if cc is true, then PC <- dst */
587
 
        if (check_condition_code(cpustate, opcode >> 4))
588
 
        {
589
 
                jump(cpustate, dst);
590
 
                *cycles += 2;
591
 
        }
592
 
}
593
 
 
594
 
/***************************************************************************
595
 
    BIT MANIPULATION INSTRUCTIONS
596
 
***************************************************************************/
597
 
 
598
 
static void test_complement_under_mask(z8_state *cpustate, UINT8 dst, UINT8 src)
599
 
{
600
 
        /* NOT(dst) AND src */
601
 
        UINT8 data = (register_read(cpustate, dst) ^ 0xff) & src;
602
 
 
603
 
        set_flag_z(data == 0);
604
 
        set_flag_s(data & 0x80);
605
 
        set_flag_v(0);
606
 
}
607
 
 
608
 
INSTRUCTION( tcm_r1_r2 )                { mode_r1_r2(test_complement_under_mask) }
609
 
INSTRUCTION( tcm_r1_Ir2 )               { mode_r1_Ir2(test_complement_under_mask) }
610
 
INSTRUCTION( tcm_R2_R1 )                { mode_R2_R1(test_complement_under_mask) }
611
 
INSTRUCTION( tcm_IR2_R1 )               { mode_IR2_R1(test_complement_under_mask) }
612
 
INSTRUCTION( tcm_R1_IM )                { mode_R1_IM(test_complement_under_mask) }
613
 
INSTRUCTION( tcm_IR1_IM )               { mode_IR1_IM(test_complement_under_mask) }
614
 
 
615
 
static void test_under_mask(z8_state *cpustate, UINT8 dst, UINT8 src)
616
 
{
617
 
        /* dst AND src */
618
 
        UINT8 data = register_read(cpustate, dst) & src;
619
 
 
620
 
        set_flag_z(data == 0);
621
 
        set_flag_s(data & 0x80);
622
 
        set_flag_v(0);
623
 
}
624
 
 
625
 
INSTRUCTION( tm_r1_r2 )                 { mode_r1_r2(test_under_mask) }
626
 
INSTRUCTION( tm_r1_Ir2 )                { mode_r1_Ir2(test_under_mask) }
627
 
INSTRUCTION( tm_R2_R1 )                 { mode_R2_R1(test_under_mask) }
628
 
INSTRUCTION( tm_IR2_R1 )                { mode_IR2_R1(test_under_mask) }
629
 
INSTRUCTION( tm_R1_IM )                 { mode_R1_IM(test_under_mask) }
630
 
INSTRUCTION( tm_IR1_IM )                { mode_IR1_IM(test_under_mask) }
631
 
 
632
 
/***************************************************************************
633
 
    ROTATE AND SHIFT INSTRUCTIONS
634
 
***************************************************************************/
635
 
 
636
 
static void rotate_left(z8_state *cpustate, UINT8 dst)
637
 
{
638
 
        /* << */
639
 
        UINT8 data = register_read(cpustate, dst);
640
 
        UINT8 new_data = (data << 1) | BIT(data, 7);
641
 
 
642
 
        set_flag_c(data & 0x80);
643
 
        set_flag_z(data == 0);
644
 
        set_flag_s(new_data & 0x80);
645
 
        set_flag_v((data & 0x80) != (new_data & 0x80));
646
 
 
647
 
        register_write(cpustate, dst, new_data);
648
 
}
649
 
 
650
 
INSTRUCTION( rl_R1 )                    { mode_R1(rotate_left) }
651
 
INSTRUCTION( rl_IR1 )                   { mode_IR1(rotate_left) }
652
 
 
653
 
static void rotate_left_carry(z8_state *cpustate, UINT8 dst)
654
 
{
655
 
        /* << C */
656
 
        UINT8 data = register_read(cpustate, dst);
657
 
        UINT8 new_data = (data << 1) | flag(C);
658
 
 
659
 
        set_flag_c(data & 0x80);
660
 
        set_flag_z(data == 0);
661
 
        set_flag_s(new_data & 0x80);
662
 
        set_flag_v((data & 0x80) != (new_data & 0x80));
663
 
 
664
 
        register_write(cpustate, dst, new_data);
665
 
}
666
 
 
667
 
INSTRUCTION( rlc_R1 )                   { mode_R1(rotate_left_carry) }
668
 
INSTRUCTION( rlc_IR1 )                  { mode_IR1(rotate_left_carry) }
669
 
 
670
 
static void rotate_right(z8_state *cpustate, UINT8 dst)
671
 
{
672
 
        /* >> */
673
 
        UINT8 data = register_read(cpustate, dst);
674
 
        UINT8 new_data = ((data & 0x01) << 7) | (data >> 1);
675
 
 
676
 
        set_flag_c(data & 0x01);
677
 
        set_flag_z(data == 0);
678
 
        set_flag_s(new_data & 0x80);
679
 
        set_flag_v((data & 0x80) != (new_data & 0x80));
680
 
 
681
 
        register_write(cpustate, dst, new_data);
682
 
}
683
 
 
684
 
INSTRUCTION( rr_R1 )                    { mode_R1(rotate_right) }
685
 
INSTRUCTION( rr_IR1 )                   { mode_IR1(rotate_right) }
686
 
 
687
 
static void rotate_right_carry(z8_state *cpustate, UINT8 dst)
688
 
{
689
 
        /* >> C */
690
 
        UINT8 data = register_read(cpustate, dst);
691
 
        UINT8 new_data = (flag(C) << 7) | (data >> 1);
692
 
 
693
 
        set_flag_c(data & 0x01);
694
 
        set_flag_z(data == 0);
695
 
        set_flag_s(new_data & 0x80);
696
 
        set_flag_v((data & 0x80) != (new_data & 0x80));
697
 
 
698
 
        register_write(cpustate, dst, new_data);
699
 
}
700
 
 
701
 
INSTRUCTION( rrc_R1 )                   { mode_R1(rotate_right_carry) }
702
 
INSTRUCTION( rrc_IR1 )                  { mode_IR1(rotate_right_carry) }
703
 
 
704
 
static void shift_right_arithmetic(z8_state *cpustate, UINT8 dst)
705
 
{
706
 
        /* */
707
 
        UINT8 data = register_read(cpustate, dst);
708
 
        UINT8 new_data = (data & 0x80) | ((data >> 1) & 0x7f);
709
 
 
710
 
        set_flag_c(data & 0x01);
711
 
        set_flag_z(data == 0);
712
 
        set_flag_s(new_data & 0x80);
713
 
        set_flag_v(0);
714
 
 
715
 
        register_write(cpustate, dst, new_data);
716
 
}
717
 
 
718
 
INSTRUCTION( sra_R1 )                   { mode_R1(shift_right_arithmetic) }
719
 
INSTRUCTION( sra_IR1 )                  { mode_IR1(shift_right_arithmetic) }
720
 
 
721
 
static void swap(z8_state *cpustate, UINT8 dst)
722
 
{
723
 
        /* dst(7-4) <-> dst(3-0) */
724
 
        UINT8 data = register_read(cpustate, dst);
725
 
        data = (data << 4) | (data >> 4);
726
 
        register_write(cpustate, dst, data);
727
 
 
728
 
        set_flag_z(data == 0);
729
 
        set_flag_s(data & 0x80);
730
 
//  set_flag_v(0); undefined
731
 
}
732
 
 
733
 
INSTRUCTION( swap_R1 )                  { mode_R1(swap) }
734
 
INSTRUCTION( swap_IR1 )                 { mode_IR1(swap) }
735
 
 
736
 
/***************************************************************************
737
 
    CPU CONTROL INSTRUCTIONS
738
 
***************************************************************************/
739
 
 
740
 
INSTRUCTION( ccf )                              { cpustate->r[Z8_REGISTER_FLAGS] ^= Z8_FLAGS_C; }
741
 
INSTRUCTION( di )                               { cpustate->r[Z8_REGISTER_IMR] &= ~Z8_IMR_ENABLE; }
742
 
INSTRUCTION( ei )                               { cpustate->r[Z8_REGISTER_IMR] |= Z8_IMR_ENABLE; }
743
 
INSTRUCTION( nop )                              { /* no operation */ }
744
 
INSTRUCTION( rcf )                              { set_flag_c(0); }
745
 
INSTRUCTION( scf )                              { set_flag_c(1); }
746
 
INSTRUCTION( srp_IM )                   { cpustate->r[Z8_REGISTER_RP] = fetch(cpustate); }