Previous 15994 Revisions Next

r5545 Monday 31st August, 2009 at 07:02:32 UTC by Curt Coder
[Z8] Added preliminary Z8 cpu core for JuTe computer.
[src/emu/cpu]cpu.mak
[src/emu/cpu/z8]z8.c* z8.h* z8dasm.c* z8ops.c*
[src/mess]mess.mak
[src/mess/drivers]jtc.c

src/emu/cpu/cpu.mak
r5544r5545
15041504
15051505
15061506#-------------------------------------------------
1507# Zilog Z8
1508#-------------------------------------------------
1509
1510ifneq ($(filter Z8,$(CPUS)),)
1511OBJDIRS += $(CPUOBJ)/z8
1512CPUOBJS += $(CPUOBJ)/z8/z8.o
1513DASMOBJS += $(CPUOBJ)/z8/z8dasm.o
1514endif
1515
1516$(CPUOBJ)/z8/z8.o:   $(CPUSRC)/z8/z8.c \
1517               $(CPUSRC)/z8/z8ops.c \
1518               $(CPUSRC)/z8/z8.h
1519
1520
1521
1522#-------------------------------------------------
15071523# Zilog Z80
15081524#-------------------------------------------------
15091525
src/emu/cpu/z8/z8.c
r0r5545
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
12   TODO:
13
14   - expose register file to disassembler
15   - arithmetic opcodes
16   - interrupts
17   - I/O ports
18   - counter/timer
19   - serial
20   - instruction pipeline
21
22*/
23
24#include "driver.h"
25#include "debugger.h"
26#include "z8.h"
27
28/***************************************************************************
29    CONSTANTS
30***************************************************************************/
31
32enum
33{
34   Z8_REGISTER_P0 = 0,
35   Z8_REGISTER_P1,
36   Z8_REGISTER_P2,
37   Z8_REGISTER_P3,
38   Z8_REGISTER_SIO = 0xf0,
39   Z8_REGISTER_TMR,
40   Z8_REGISTER_T1,
41   Z8_REGISTER_PRE1,
42   Z8_REGISTER_T0,
43   Z8_REGISTER_PRE0,
44   Z8_REGISTER_P2M,
45   Z8_REGISTER_P3M,
46   Z8_REGISTER_P01M,
47   Z8_REGISTER_IPR,
48   Z8_REGISTER_IRQ,
49   Z8_REGISTER_IMR,
50   Z8_REGISTER_FLAGS,
51   Z8_REGISTER_RP,
52   Z8_REGISTER_SPH,
53   Z8_REGISTER_SPL
54};
55
56#define Z8_P01M_P0L_MODE_MASK      0x03
57#define Z8_P01M_P0L_MODE_OUTPUT      0x00
58#define Z8_P01M_P0L_MODE_INPUT      0x01
59#define Z8_P01M_P0L_MODE_A8_A11      0x02
60#define Z8_P01M_INTERNAL_STACK      0x04
61#define Z8_P01M_P1_MODE_MASK      0x18
62#define Z8_P01M_P1_MODE_OUTPUT      0x00
63#define Z8_P01M_P1_MODE_INPUT      0x08
64#define Z8_P01M_P1_MODE_AD0_AD7      0x10
65#define Z8_P01M_P1_MODE_HI_Z      0x18
66#define Z8_P01M_EXTENDED_TIMING      0x20
67#define Z8_P01M_P1H_MODE_MASK      0xc0
68#define Z8_P01M_P1H_MODE_OUTPUT      0x00
69#define Z8_P01M_P1H_MODE_INPUT      0x40
70#define Z8_P01M_P1H_MODE_A12_A15   0x80
71
72#define Z8_IMR_ENABLE            0x80
73#define Z8_IMR_RAM_PROTECT         0x40   /* not supported */
74#define Z8_IMR_ENABLE_IRQ5         0x20
75#define Z8_IMR_ENABLE_IRQ4         0x10
76#define Z8_IMR_ENABLE_IRQ3         0x08
77#define Z8_IMR_ENABLE_IRQ2         0x04
78#define Z8_IMR_ENABLE_IRQ1         0x02
79#define Z8_IMR_ENABLE_IRQ0         0x01
80
81#define Z8_FLAGS_F1               0x01
82#define Z8_FLAGS_F2               0x02
83#define Z8_FLAGS_H               0x04
84#define Z8_FLAGS_D               0x08
85#define Z8_FLAGS_V               0x10
86#define Z8_FLAGS_S               0x20
87#define Z8_FLAGS_Z               0x40
88#define Z8_FLAGS_C               0x80
89
90enum
91{
92   CC_F = 0, CC_LT, CC_LE, CC_ULE, CC_OV, CC_MI, CC_Z, CC_C,
93   CC_T, CC_GE, CC_GT, CC_UGT, CC_NOV, CC_PL, CC_NZ, CC_NC
94};
95
96/***************************************************************************
97    TYPE DEFINITIONS
98***************************************************************************/
99
100typedef struct _z8_state z8_state;
101struct _z8_state
102{
103    const address_space *program;
104    const address_space *data;
105    const address_space *io;
106
107   /* registers */
108   UINT16 pc;            /* program counter */
109   UINT8 r[256];         /* register file */
110   UINT16 fake_sp;         /* fake stack pointer */
111   UINT8 fake_rp;         /* fake register pointer */
112   UINT8 fake_r[16];      /* fake working registers */
113
114   /* interrupts */
115   int irq[4];            /* external interrupt flip-flops */
116
117   /* execution logic */
118   int icount;            /* instruction counter */
119
120   cpu_state_table state_table;
121};
122
123/***************************************************************************
124    CPU STATE DESCRIPTION
125***************************************************************************/
126
127#define Z8_STATE_ENTRY(_name, _format, _member, _datamask, _flags) \
128   CPU_STATE_ENTRY(Z8_##_name, #_name, _format, z8_state, _member, _datamask, ~0, _flags)
129
130static const cpu_state_entry state_array[] =
131{
132   Z8_STATE_ENTRY(PC,  "%04X", pc, 0xffff, 0)
133   Z8_STATE_ENTRY(GENPC, "%04X", pc, 0xffff, CPUSTATE_NOSHOW)
134   Z8_STATE_ENTRY(SP, "%04X", fake_sp, 0xffff, CPUSTATE_IMPORT | CPUSTATE_EXPORT)
135   Z8_STATE_ENTRY(GENSP, "%04X", fake_sp, 0xffff, CPUSTATE_NOSHOW | CPUSTATE_IMPORT | CPUSTATE_EXPORT)
136   Z8_STATE_ENTRY(RP, "%02X", r[Z8_REGISTER_RP], 0xff, 0)
137
138   Z8_STATE_ENTRY(R0, "%02X", fake_r[0], 0xff, CPUSTATE_IMPORT | CPUSTATE_EXPORT)
139   Z8_STATE_ENTRY(R1, "%02X", fake_r[1], 0xff, CPUSTATE_IMPORT | CPUSTATE_EXPORT)
140   Z8_STATE_ENTRY(R2, "%02X", fake_r[2], 0xff, CPUSTATE_IMPORT | CPUSTATE_EXPORT)
141   Z8_STATE_ENTRY(R3, "%02X", fake_r[3], 0xff, CPUSTATE_IMPORT | CPUSTATE_EXPORT)
142   Z8_STATE_ENTRY(R4, "%02X", fake_r[4], 0xff, CPUSTATE_IMPORT | CPUSTATE_EXPORT)
143   Z8_STATE_ENTRY(R5, "%02X", fake_r[5], 0xff, CPUSTATE_IMPORT | CPUSTATE_EXPORT)
144   Z8_STATE_ENTRY(R6, "%02X", fake_r[6], 0xff, CPUSTATE_IMPORT | CPUSTATE_EXPORT)
145   Z8_STATE_ENTRY(R7, "%02X", fake_r[7], 0xff, CPUSTATE_IMPORT | CPUSTATE_EXPORT)
146   Z8_STATE_ENTRY(R8, "%02X", fake_r[8], 0xff, CPUSTATE_IMPORT | CPUSTATE_EXPORT)
147   Z8_STATE_ENTRY(R9, "%02X", fake_r[9], 0xff, CPUSTATE_IMPORT | CPUSTATE_EXPORT)
148   Z8_STATE_ENTRY(R10, "%02X", fake_r[10], 0xff, CPUSTATE_IMPORT | CPUSTATE_EXPORT)
149   Z8_STATE_ENTRY(R11, "%02X", fake_r[11], 0xff, CPUSTATE_IMPORT | CPUSTATE_EXPORT)
150   Z8_STATE_ENTRY(R12, "%02X", fake_r[12], 0xff, CPUSTATE_IMPORT | CPUSTATE_EXPORT)
151   Z8_STATE_ENTRY(R13, "%02X", fake_r[13], 0xff, CPUSTATE_IMPORT | CPUSTATE_EXPORT)
152   Z8_STATE_ENTRY(R14, "%02X", fake_r[14], 0xff, CPUSTATE_IMPORT | CPUSTATE_EXPORT)
153   Z8_STATE_ENTRY(R15, "%02X", fake_r[15], 0xff, CPUSTATE_IMPORT | CPUSTATE_EXPORT)
154};
155
156static const cpu_state_table state_table_template =
157{
158   NULL,                  /* pointer to the base of state (offsets are relative to this) */
159   0,                     /* subtype this table refers to */
160   ARRAY_LENGTH(state_array),   /* number of entries */
161   state_array               /* array of entries */
162};
163
164/***************************************************************************
165    INLINE FUNCTIONS
166***************************************************************************/
167
168INLINE z8_state *get_safe_token(const device_config *device)
169{
170   assert(device != NULL);
171   assert(device->token != NULL);
172   assert(device->type == CPU);
173   assert((cpu_get_type(device) == CPU_Z8601) ||
174      (cpu_get_type(device) == CPU_UB8830D) ||
175      (cpu_get_type(device) == CPU_Z8611));
176   return (z8_state *)device->token;
177}
178
179INLINE UINT8 fetch(z8_state *cpustate)
180{
181   UINT8 data = memory_decrypted_read_byte(cpustate->program, cpustate->pc);
182
183   cpustate->pc++;
184
185   return data;
186}
187
188INLINE UINT8 register_read(z8_state *cpustate, UINT8 offset)
189{
190   UINT8 data = 0xff;
191
192   switch (offset)
193   {
194   case Z8_REGISTER_P0:
195   case Z8_REGISTER_P1:
196   case Z8_REGISTER_P2:
197   case Z8_REGISTER_P3:
198      data = memory_read_byte_8be(cpustate->io, offset);
199      /* if defined as address outputs, return 1 in each address bit location */
200      break;
201
202   case Z8_REGISTER_PRE1:
203   case Z8_REGISTER_PRE0:
204   case Z8_REGISTER_P2M:
205   case Z8_REGISTER_P3M:
206   case Z8_REGISTER_P01M:
207   case Z8_REGISTER_IPR:
208      /* write only */
209      break;
210   
211   default:
212      data = cpustate->r[offset];
213      break;
214   }
215
216   return data;
217}
218
219INLINE UINT16 register_pair_read(z8_state *cpustate, UINT8 offset)
220{
221   return (register_read(cpustate, offset) << 8) | register_read(cpustate, offset + 1);
222}
223
224INLINE void register_write(z8_state *cpustate, UINT8 offset, UINT8 data)
225{
226   switch (offset)
227   {
228   case Z8_REGISTER_P0:
229   case Z8_REGISTER_P1:
230   case Z8_REGISTER_P2:
231   case Z8_REGISTER_P3:
232      memory_write_byte_8be(cpustate->io, offset, data);
233      break;
234
235   case Z8_REGISTER_SIO:
236      break;
237   case Z8_REGISTER_TMR:
238      break;
239   case Z8_REGISTER_T1:
240      break;
241   case Z8_REGISTER_PRE1:
242      break;
243   case Z8_REGISTER_T0:
244      break;
245   case Z8_REGISTER_PRE0:
246      break;
247   case Z8_REGISTER_P2M:
248      break;
249   case Z8_REGISTER_P3M:
250      break;
251   case Z8_REGISTER_P01M:
252      break;
253   case Z8_REGISTER_IPR:
254      break;
255   case Z8_REGISTER_IRQ:
256      break;
257   case Z8_REGISTER_IMR:
258      break;
259   case Z8_REGISTER_FLAGS:
260      break;
261   case Z8_REGISTER_RP:
262      break;
263   case Z8_REGISTER_SPH:
264      break;
265   case Z8_REGISTER_SPL:
266      break;
267   default:
268      // TODO ignore missing registers
269      break;
270   }
271
272   cpustate->r[offset] = data;
273}
274
275INLINE void register_pair_write(z8_state *cpustate, UINT8 offset, UINT16 data)
276{
277   register_write(cpustate, offset, data >> 8);
278   register_write(cpustate, offset + 1, data & 0xff);
279}
280
281INLINE UINT8 get_working_register(z8_state *cpustate, int offset)
282{
283   return (cpustate->r[Z8_REGISTER_RP] & 0xf0) | (offset & 0x0f);
284}
285
286INLINE UINT8 get_register(z8_state *cpustate, UINT8 offset)
287{
288   if ((offset & 0xf0) == 0xe0)
289      return get_working_register(cpustate, offset & 0x0f);
290   else
291      return offset;
292}
293
294INLINE UINT8 get_intermediate_register(z8_state *cpustate, int offset)
295{
296   return register_read(cpustate, get_register(cpustate, offset));
297}
298
299INLINE void stack_push_byte(z8_state *cpustate, UINT8 src)
300{
301   if (register_read(cpustate, Z8_REGISTER_P01M) & Z8_P01M_INTERNAL_STACK)
302   {
303      /* SP <- SP - 1 */
304      UINT8 sp = register_read(cpustate, Z8_REGISTER_SPL) - 1;
305      register_write(cpustate, Z8_REGISTER_SPL, sp);
306
307      /* @SP <- src */
308      register_write(cpustate, sp, src);
309   }
310   else
311   {
312      /* SP <- SP - 1 */
313      UINT16 sp = register_pair_read(cpustate, Z8_REGISTER_SPH) - 1;
314      register_pair_write(cpustate, Z8_REGISTER_SPH, sp);
315
316      /* @SP <- src */
317      memory_write_byte(cpustate->data, sp, src);
318   }
319}
320
321INLINE void stack_push_word(z8_state *cpustate, UINT16 src)
322{
323   if (register_read(cpustate, Z8_REGISTER_P01M) & Z8_P01M_INTERNAL_STACK)
324   {
325      /* SP <- SP - 2 */
326      UINT8 sp = register_read(cpustate, Z8_REGISTER_SPL) - 2;
327      register_write(cpustate, Z8_REGISTER_SPL, sp);
328
329      /* @SP <- src */
330      register_pair_write(cpustate, sp, src);
331   }
332   else
333   {
334      /* SP <- SP - 2 */
335      UINT16 sp = register_pair_read(cpustate, Z8_REGISTER_SPH) - 2;
336      register_pair_write(cpustate, Z8_REGISTER_SPH, sp);
337
338      /* @SP <- src */
339      memory_write_word_8le(cpustate->data, sp, src);
340   }
341}
342
343INLINE UINT8 stack_pop_byte(z8_state *cpustate)
344{
345   if (register_read(cpustate, Z8_REGISTER_P01M) & Z8_P01M_INTERNAL_STACK)
346   {
347      /* SP <- SP + 1 */
348      UINT8 sp = register_read(cpustate, Z8_REGISTER_SPL) + 1;
349      register_write(cpustate, Z8_REGISTER_SPL, sp);
350
351      /* @SP <- src */
352      return register_read(cpustate, sp);
353   }
354   else
355   {
356      /* SP <- SP + 1 */
357      UINT16 sp = register_pair_read(cpustate, Z8_REGISTER_SPH) + 1;
358      register_pair_write(cpustate, Z8_REGISTER_SPH, sp);
359
360      /* @SP <- src */
361      return memory_read_byte(cpustate->data, sp);
362   }
363}
364
365INLINE UINT16 stack_pop_word(z8_state *cpustate)
366{
367   if (register_read(cpustate, Z8_REGISTER_P01M) & Z8_P01M_INTERNAL_STACK)
368   {
369      /* SP <- SP + 2 */
370      UINT8 sp = register_read(cpustate, Z8_REGISTER_SPL) + 2;
371      register_write(cpustate, Z8_REGISTER_SPL, sp);
372
373      /* @SP <- src */
374      return register_read(cpustate, sp);
375   }
376   else
377   {
378      /* SP <- SP + 2 */
379      UINT16 sp = register_pair_read(cpustate, Z8_REGISTER_SPH) + 2;
380      register_pair_write(cpustate, Z8_REGISTER_SPH, sp);
381
382      /* @SP <- src */
383      return memory_read_word_8le(cpustate->data, sp);
384   }
385}
386
387INLINE void set_flag(z8_state *cpustate, UINT8 flag, int state)
388{
389   if (state)
390      cpustate->r[Z8_REGISTER_FLAGS] |= flag;
391   else
392      cpustate->r[Z8_REGISTER_FLAGS] &= ~flag;
393}
394
395#define set_flag_h(state)   set_flag(cpustate, Z8_FLAGS_H, state);
396#define set_flag_d(state)   set_flag(cpustate, Z8_FLAGS_D, state);
397#define set_flag_v(state)   set_flag(cpustate, Z8_FLAGS_V, state);
398#define set_flag_s(state)   set_flag(cpustate, Z8_FLAGS_S, state);
399#define set_flag_z(state)   set_flag(cpustate, Z8_FLAGS_Z, state);
400#define set_flag_c(state)   set_flag(cpustate, Z8_FLAGS_C, state);
401
402/***************************************************************************
403    OPCODE HANDLERS
404***************************************************************************/
405
406#define INSTRUCTION(mnemonic) INLINE void (mnemonic)(z8_state *cpustate, UINT8 opcode, int *cycles)
407
408INSTRUCTION( illegal )
409{
410   logerror("Z8: PC = %04x, Illegal opcode = %02x\n", cpustate->pc - 1, opcode);
411}
412
413#include "z8ops.c"
414
415/***************************************************************************
416    OPCODE TABLES
417***************************************************************************/
418
419typedef void (*z8_opcode_func) (z8_state *cpustate, UINT8 opcode, int *cycles);
420
421typedef struct _z8_opcode_map z8_opcode_map;
422struct _z8_opcode_map
423{
424   z8_opcode_func   function;
425   int            execution_cycles;
426   int            pipeline_cycles;
427};
428
429static const z8_opcode_map Z8601_OPCODE_MAP[] =
430{
431   { dec_R1, 6, 5 },   { dec_IR1, 6, 5 },   { add_r1_r2, 10, 5 },   { add_r1_Ir2, 10, 5 },   { add_R2_R1, 10, 5 },   { add_IR2_R1, 10, 5 },   { add_R1_IM, 10, 5 },   { add_IR1_IM, 10, 5 },
432   { ld_r1_R2, 6, 5 }, { ld_r2_R1, 6, 5 }, { djnz_r1_RA, 10, 5 },   { jr_cc_RA, 10, 0 },   { ld_r1_IM, 6, 5 },      { jp_cc_DA, 10, 0 },   { inc_r1, 6, 5 },      { illegal, 0, 0 },
433
434   { rlc_R1, 6, 5 },   { rlc_IR1, 6, 5 },   { adc_r1_r2, 6, 5 },   { adc_r1_Ir2, 6, 5 },   { adc_R2_R1, 10, 5 },   { adc_IR2_R1, 10, 5 },   { adc_R1_IM, 10, 5 },   { adc_IR1_IM, 10, 5 },
435   { ld_r1_R2, 6, 5 }, { ld_r2_R1, 6, 5 }, { djnz_r1_RA, 10, 5 },   { jr_cc_RA, 10, 0 },   { ld_r1_IM, 6, 5 },      { jp_cc_DA, 10, 0 },   { inc_r1, 6, 5 },      { illegal, 0, 0 },
436
437   { inc_R1, 6, 5 },   { inc_IR1, 6, 5 },   { sub_r1_r2, 6, 5 },   { sub_r1_Ir2, 6, 5 },   { sub_R2_R1, 10, 5 },   { sub_IR2_R1, 10, 5 },   { sub_R1_IM, 10, 5 },   { sub_IR1_IM, 10, 5 },
438   { ld_r1_R2, 6, 5 }, { ld_r2_R1, 6, 5 }, { djnz_r1_RA, 10, 5 },   { jr_cc_RA, 10, 0 },   { ld_r1_IM, 6, 5 },      { jp_cc_DA, 10, 0 },   { inc_r1, 6, 5 },      { illegal, 0, 0 },
439
440   { jp_IRR1, 8, 0 },   { srp_IM, 6, 1 },   { sbc_r1_r2, 6, 5 },   { sbc_r1_Ir2, 6, 5 },   { sbc_R2_R1, 10, 5 },   { sbc_IR2_R1, 10, 5 },   { sbc_R1_IM, 10, 5 },   { sbc_IR1_IM, 10, 5 },
441   { ld_r1_R2, 6, 5 }, { ld_r2_R1, 6, 5 }, { djnz_r1_RA, 10, 5 },   { jr_cc_RA, 10, 0 },   { ld_r1_IM, 6, 5 },      { jp_cc_DA, 10, 0 },   { inc_r1, 6, 5 },      { illegal, 0, 0 },
442
443   { da_R1, 8, 5 },   { da_IR1, 8, 5 },   { or_r1_r2, 6, 5 },      { or_r1_Ir2, 6, 5 },   { or_R2_R1, 10, 5 },   { or_IR2_R1, 10, 5 },   { or_R1_IM, 10, 5 },   { or_IR1_IM, 10, 5 },
444   { ld_r1_R2, 6, 5 }, { ld_r2_R1, 6, 5 }, { djnz_r1_RA, 10, 5 },   { jr_cc_RA, 10, 0 },   { ld_r1_IM, 6, 5 },      { jp_cc_DA, 10, 0 },   { inc_r1, 6, 5 },      { illegal, 0, 0 },
445
446   { pop_R1, 10, 5 },   { pop_IR1, 10, 5 },   { and_r1_r2, 6, 5 },   { and_r1_Ir2, 6, 5 },   { and_R2_R1, 10, 5 },   { and_IR2_R1, 10, 5 },   { and_R1_IM, 10, 5 },   { and_IR1_IM, 10, 5 },
447   { ld_r1_R2, 6, 5 }, { ld_r2_R1, 6, 5 }, { djnz_r1_RA, 10, 5 },   { jr_cc_RA, 10, 0 },   { ld_r1_IM, 6, 5 },      { jp_cc_DA, 10, 0 },   { inc_r1, 6, 5 },      { illegal, 0, 0 },
448
449   { com_R1, 6, 5 },   { com_IR1, 6, 5 },   { tcm_r1_r2, 6, 5 },   { tcm_r1_Ir2, 6, 5 },   { tcm_R2_R1, 10, 5 },   { tcm_IR2_R1, 10, 5 },   { tcm_R1_IM, 10, 5 },   { tcm_IR1_IM, 10, 5 },
450   { ld_r1_R2, 6, 5 }, { ld_r2_R1, 6, 5 }, { djnz_r1_RA, 10, 5 },   { jr_cc_RA, 10, 0 },   { ld_r1_IM, 6, 5 },      { jp_cc_DA, 10, 0 },   { inc_r1, 6, 5 },      { illegal, 0, 0 },
451
452   { push_R2, 10, 1 },   { push_IR2, 12, 1 },{ tm_r1_r2, 6, 5 },      { tm_r1_Ir2, 6, 5 },   { tm_R2_R1, 10, 5 },   { tm_IR2_R1, 10, 5 },   { tm_R1_IM, 10, 5 },   { tm_IR1_IM, 10, 5 },
453   { ld_r1_R2, 6, 5 }, { ld_r2_R1, 6, 5 }, { djnz_r1_RA, 10, 5 },   { jr_cc_RA, 10, 0 },   { ld_r1_IM, 6, 5 },      { jp_cc_DA, 10, 0 },   { inc_r1, 6, 5 },      { illegal, 0, 0 },
454
455   { decw_RR1, 10, 5 },{ decw_IR1, 10, 5 },{ lde_r1_Irr2, 12, 0 },   { ldei_Ir1_Irr2, 18, 0 },{ illegal, 0, 0 },      { illegal, 0, 0 },      { illegal, 0, 0 },      { illegal, 0, 0 },     
456   { ld_r1_R2, 6, 5 }, { ld_r2_R1, 6, 5 }, { djnz_r1_RA, 10, 5 },   { jr_cc_RA, 10, 0 },   { ld_r1_IM, 6, 5 },      { jp_cc_DA, 10, 0 },   { inc_r1, 6, 5 },      { illegal, 0, 0 },
457
458   { rl_R1, 6, 5 },   { rl_IR1, 6, 5 },   { lde_r2_Irr1, 12, 0 },   { ldei_Ir2_Irr1, 18, 0 },{ illegal, 0, 0 },      { illegal, 0, 0 },      { illegal, 0, 0 },      { illegal, 0, 0 },   
459   { ld_r1_R2, 6, 5 }, { ld_r2_R1, 6, 5 }, { djnz_r1_RA, 10, 5 },   { jr_cc_RA, 10, 0 },   { ld_r1_IM, 6, 5 },      { jp_cc_DA, 10, 0 },   { inc_r1, 6, 5 },      { di, 6, 1 },
460
461   { incw_RR1, 10, 5 },{ incw_IR1, 10, 5 },{ cp_r1_r2, 6, 5 },      { cp_r1_Ir2, 6, 5 },   { cp_R2_R1, 10, 5 },   { cp_IR2_R1, 10, 5 },   { cp_R1_IM, 10, 5 },   { cp_IR1_IM, 10, 5 },
462   { ld_r1_R2, 6, 5 }, { ld_r2_R1, 6, 5 }, { djnz_r1_RA, 10, 5 },   { jr_cc_RA, 10, 0 },   { ld_r1_IM, 6, 5 },      { jp_cc_DA, 10, 0 },   { inc_r1, 6, 5 },      { ei, 6, 1 },
463
464   { clr_R1, 6, 5 },   { clr_IR1, 6, 5 },   { xor_r1_r2, 6, 5 },   { xor_r1_Ir2, 6, 5 },   { xor_R2_R1, 10, 5 },   { xor_IR2_R1, 10, 5 },   { xor_R1_IM, 10, 5 },   { xor_IR1_IM, 10, 5 },
465   { ld_r1_R2, 6, 5 }, { ld_r2_R1, 6, 5 }, { djnz_r1_RA, 10, 5 },   { jr_cc_RA, 10, 0 },   { ld_r1_IM, 6, 5 },      { jp_cc_DA, 10, 0 },   { inc_r1, 6, 5 },      { ret, 14, 0 },
466
467   { rrc_R1, 6, 5 },   { rrc_IR1, 6, 5 },   { ldc_r1_Irr2, 12, 0 },   { ldci_Ir1_Irr2, 18, 0 },{ illegal, 0, 0 },      { illegal, 0, 0 },      { illegal, 0, 0 },      { ld_r1_x_R2, 10, 5 },
468   { ld_r1_R2, 6, 5 }, { ld_r2_R1, 6, 5 }, { djnz_r1_RA, 10, 5 },   { jr_cc_RA, 10, 0 },   { ld_r1_IM, 6, 5 },      { jp_cc_DA, 10, 0 },   { inc_r1, 6, 5 },      { iret, 16, 0 },
469
470   { sra_R1, 6, 5 },   { sra_IR1, 6, 5 },   { ldc_r2_Irr1, 12, 0 },   { ldci_Ir2_Irr1, 18, 0 },{ call_IRR1, 20, 0 },   { illegal, 0, 0 },      { call_DA, 20, 0 },      { ld_r2_x_R1, 10, 5 },
471   { ld_r1_R2, 6, 5 }, { ld_r2_R1, 6, 5 }, { djnz_r1_RA, 10, 5 },   { jr_cc_RA, 10, 0 },   { ld_r1_IM, 6, 5 },      { jp_cc_DA, 10, 0 },   { inc_r1, 6, 5 },      { scf, 6, 5 },
472
473   { rr_R1, 6, 5 },   { rr_IR1, 6, 5 },   { illegal, 0, 0 },      { ld_r1_Ir2, 6, 5 },   { ld_R2_R1, 10, 5 },   { ld_IR2_R1, 10, 5 },   { ld_R1_IM, 10, 5 },   { ld_IR1_IM, 10, 5 },
474   { ld_r1_R2, 6, 5 }, { ld_r2_R1, 6, 5 }, { djnz_r1_RA, 10, 5 },   { jr_cc_RA, 10, 0 },   { ld_r1_IM, 6, 5 },      { jp_cc_DA, 10, 0 },   { inc_r1, 6, 5 },      { ccf, 6, 5 },
475
476   { swap_R1, 8, 5 },   { swap_IR1, 8, 5 },   { illegal, 0, 0 },      { ld_Ir1_r2, 6, 5 },   { illegal, 0, 0 },      { ld_R2_IR1, 10, 5 },   { illegal, 0, 0 },      { illegal, 0, 0 },
477   { ld_r1_R2, 6, 5 }, { ld_r2_R1, 6, 5 }, { djnz_r1_RA, 10, 5 },   { jr_cc_RA, 10, 0 },   { ld_r1_IM, 6, 5 },      { jp_cc_DA, 10, 0 },   { inc_r1, 6, 5 },      { nop, 6, 0 },
478};
479
480/***************************************************************************
481    INITIALIZATION
482***************************************************************************/
483
484static CPU_INIT( z8 )
485{
486   z8_state *cpustate = get_safe_token(device);
487
488   /* set up the state table */
489   cpustate->state_table = state_table_template;
490   cpustate->state_table.baseptr = cpustate;
491   cpustate->state_table.subtypemask = 1;
492
493   /* find address spaces */
494   cpustate->program = memory_find_address_space(device, ADDRESS_SPACE_PROGRAM);
495   cpustate->data = memory_find_address_space(device, ADDRESS_SPACE_DATA);
496   cpustate->io = memory_find_address_space(device, ADDRESS_SPACE_IO);
497
498   /* register for state saving */
499   state_save_register_device_item(device, 0, cpustate->pc);
500   state_save_register_device_item_array(device, 0, cpustate->r);
501}
502
503/***************************************************************************
504    EXECUTION
505***************************************************************************/
506
507static CPU_EXECUTE( z8 )
508{
509   z8_state *cpustate = get_safe_token(device);
510
511   cpustate->icount = cycles;
512
513   do
514   {
515      UINT8 opcode;
516      int cycles;
517
518      debugger_instruction_hook(device, cpustate->pc);
519     
520      opcode = fetch(cpustate);
521      cycles = Z8601_OPCODE_MAP[opcode].execution_cycles;
522
523      (*(Z8601_OPCODE_MAP[opcode].function))(cpustate, opcode, &cycles);
524     
525      cpustate->icount -= cycles;
526   }
527   while (cpustate->icount > 0);
528
529   return cycles - cpustate->icount;
530}
531
532/***************************************************************************
533    RESET
534***************************************************************************/
535
536static CPU_RESET( z8 )
537{
538   z8_state *cpustate = get_safe_token(device);
539
540   cpustate->pc = 0x000c;
541
542   register_write(cpustate, Z8_REGISTER_TMR, 0x00);
543   register_write(cpustate, Z8_REGISTER_PRE1, register_read(cpustate, Z8_REGISTER_PRE1) & 0xfc);
544   register_write(cpustate, Z8_REGISTER_PRE0, register_read(cpustate, Z8_REGISTER_PRE0) & 0xfe);
545   register_write(cpustate, Z8_REGISTER_P2M, 0xff);
546   register_write(cpustate, Z8_REGISTER_P3M, 0x00);
547   register_write(cpustate, Z8_REGISTER_P01M, 0x4d);
548   register_write(cpustate, Z8_REGISTER_IRQ, 0x00);
549   register_write(cpustate, Z8_REGISTER_RP, 0x00);
550}
551
552/***************************************************************************
553    ADDRESS MAPS
554***************************************************************************/
555
556static ADDRESS_MAP_START( program_2kb, ADDRESS_SPACE_PROGRAM, 8 )
557   AM_RANGE(0x0000, 0x07ff) AM_ROM
558ADDRESS_MAP_END
559
560static ADDRESS_MAP_START( program_4kb, ADDRESS_SPACE_PROGRAM, 8 )
561   AM_RANGE(0x0000, 0x0fff) AM_ROM
562ADDRESS_MAP_END
563
564static ADDRESS_MAP_START( register_128b, ADDRESS_SPACE_DATA, 8 )
565   AM_RANGE(0x0000, 0x007f) AM_RAM
566   AM_RANGE(0x00f0, 0x00ff) AM_RAM
567ADDRESS_MAP_END
568
569/**************************************************************************
570 * STATE IMPORT/EXPORT
571 **************************************************************************/
572
573static CPU_IMPORT_STATE( z8 )
574{
575   z8_state *cpustate = get_safe_token(device);
576
577   switch (entry->index)
578   {
579      case Z8_SP:
580      case Z8_GENSP:
581         cpustate->r[Z8_REGISTER_SPH] = cpustate->fake_sp >> 8;
582         cpustate->r[Z8_REGISTER_SPL] = cpustate->fake_sp & 0xff;
583         break;
584   
585      case Z8_R0: case Z8_R1: case Z8_R2: case Z8_R3: case Z8_R4: case Z8_R5: case Z8_R6: case Z8_R7: case Z8_R8: case Z8_R9: case Z8_R10: case Z8_R11: case Z8_R12: case Z8_R13: case Z8_R14: case Z8_R15:
586         cpustate->r[cpustate->r[Z8_REGISTER_RP] + (entry->index - Z8_R0)] = cpustate->fake_r[entry->index - Z8_R0];
587         break;
588
589      default:
590         fatalerror("CPU_IMPORT_STATE(z8) called for unexpected value\n");
591         break;
592   }
593}
594
595static CPU_EXPORT_STATE( z8 )
596{
597   z8_state *cpustate = get_safe_token(device);
598
599   switch (entry->index)
600   {
601      case Z8_SP:
602      case Z8_GENSP:
603         cpustate->fake_sp = (cpustate->r[Z8_REGISTER_SPH] << 8) | cpustate->r[Z8_REGISTER_SPL];
604         break;
605
606      case Z8_R0: case Z8_R1: case Z8_R2: case Z8_R3: case Z8_R4: case Z8_R5: case Z8_R6: case Z8_R7: case Z8_R8: case Z8_R9: case Z8_R10: case Z8_R11: case Z8_R12: case Z8_R13: case Z8_R14: case Z8_R15:
607         cpustate->fake_r[entry->index - Z8_R0] = cpustate->r[cpustate->r[Z8_REGISTER_RP] + (entry->index - Z8_R0)];
608         break;
609
610      default:
611         fatalerror("CPU_EXPORT_STATE(z8) called for unexpected value\n");
612         break;
613   }
614}
615
616/***************************************************************************
617    GENERAL CONTEXT ACCESS
618***************************************************************************/
619
620static CPU_SET_INFO( z8 )
621{
622   z8_state *cpustate = get_safe_token(device);
623
624   switch (state)
625   {
626      case CPUINFO_INT_INPUT_STATE + INPUT_LINE_IRQ0:   cpustate->irq[0] = info->i;            break;
627      case CPUINFO_INT_INPUT_STATE + INPUT_LINE_IRQ1:   cpustate->irq[1] = info->i;            break;
628      case CPUINFO_INT_INPUT_STATE + INPUT_LINE_IRQ2:   cpustate->irq[2] = info->i;            break;
629      case CPUINFO_INT_INPUT_STATE + INPUT_LINE_IRQ3:   cpustate->irq[3] = info->i;            break;
630   }
631}
632
633static CPU_GET_INFO( z8 )
634{
635   z8_state *cpustate = (device != NULL && device->token != NULL) ? get_safe_token(device) : NULL;
636
637   switch (state)
638   {
639      /* --- the following bits of info are returned as 64-bit signed integers --- */
640      case CPUINFO_INT_CONTEXT_SIZE:               info->i = sizeof(z8_state);            break;
641      case CPUINFO_INT_INPUT_LINES:               info->i = 4;                     break;
642      case CPUINFO_INT_DEFAULT_IRQ_VECTOR:         info->i = 0;                     break;
643      case DEVINFO_INT_ENDIANNESS:               info->i = ENDIANNESS_LITTLE;         break;
644      case CPUINFO_INT_CLOCK_MULTIPLIER:            info->i = 1;                     break;
645      case CPUINFO_INT_CLOCK_DIVIDER:               info->i = 2;                     break;
646      case CPUINFO_INT_MIN_INSTRUCTION_BYTES:         info->i = 1;                     break;
647      case CPUINFO_INT_MAX_INSTRUCTION_BYTES:         info->i = 3;                     break;
648      case CPUINFO_INT_MIN_CYCLES:               info->i = 6;                     break;
649      case CPUINFO_INT_MAX_CYCLES:               info->i = 20;                     break;
650
651      case CPUINFO_INT_DATABUS_WIDTH_PROGRAM:         info->i = 8;                     break;
652      case CPUINFO_INT_ADDRBUS_WIDTH_PROGRAM:         info->i = 16;                     break;
653      case CPUINFO_INT_ADDRBUS_SHIFT_PROGRAM:         info->i = 0;                     break;
654      case CPUINFO_INT_DATABUS_WIDTH_DATA:         info->i = 8;                     break;
655      case CPUINFO_INT_ADDRBUS_WIDTH_DATA:         info->i = 16;                     break;
656      case CPUINFO_INT_ADDRBUS_SHIFT_DATA:          info->i = 0;                     break;
657      case CPUINFO_INT_DATABUS_WIDTH_IO:            info->i = 8;                     break;
658      case CPUINFO_INT_ADDRBUS_WIDTH_IO:             info->i = 2;                     break;
659      case CPUINFO_INT_ADDRBUS_SHIFT_IO:             info->i = 0;                     break;
660
661      /* --- the following bits of info are returned as pointers to functions --- */
662      case CPUINFO_FCT_SET_INFO:            info->setinfo = CPU_SET_INFO_NAME(z8);         break;
663      case CPUINFO_FCT_INIT:               info->init = CPU_INIT_NAME(z8);               break;
664      case CPUINFO_FCT_RESET:               info->reset = CPU_RESET_NAME(z8);            break;
665      case CPUINFO_FCT_EXECUTE:            info->execute = CPU_EXECUTE_NAME(z8);         break;
666      case CPUINFO_FCT_DISASSEMBLE:         info->disassemble = CPU_DISASSEMBLE_NAME(z8);   break;
667      case CPUINFO_FCT_IMPORT_STATE:         info->import_state = CPU_IMPORT_STATE_NAME(z8);   break;
668      case CPUINFO_FCT_EXPORT_STATE:         info->export_state = CPU_EXPORT_STATE_NAME(z8);   break;
669
670      /* --- the following bits of info are returned as pointers --- */
671      case CPUINFO_PTR_INSTRUCTION_COUNTER:   info->icount = &cpustate->icount;            break;
672      case CPUINFO_PTR_STATE_TABLE:         info->state_table = &cpustate->state_table;      break;
673
674      /* --- the following bits of info are returned as NULL-terminated strings --- */
675      case DEVINFO_STR_NAME:                     strcpy(info->s, "Z8");               break;
676      case DEVINFO_STR_FAMILY:                  strcpy(info->s, "Zilog Z8");         break;
677      case DEVINFO_STR_VERSION:                  strcpy(info->s, "1.0");               break;
678      case DEVINFO_STR_SOURCE_FILE:               strcpy(info->s, __FILE__);            break;
679      case DEVINFO_STR_CREDITS:                  strcpy(info->s, "Copyright MESS Team"); break;
680
681      case CPUINFO_STR_FLAGS: sprintf(info->s,
682                           "%c%c%c%c%c%c",
683                            cpustate->r[Z8_REGISTER_FLAGS] & Z8_FLAGS_C ? 'C' : '.',
684                            cpustate->r[Z8_REGISTER_FLAGS] & Z8_FLAGS_Z ? 'Z' : '.',
685                            cpustate->r[Z8_REGISTER_FLAGS] & Z8_FLAGS_S ? 'S' : '.',
686                            cpustate->r[Z8_REGISTER_FLAGS] & Z8_FLAGS_V ? 'V' : '.',
687                            cpustate->r[Z8_REGISTER_FLAGS] & Z8_FLAGS_D ? 'D' : '.',
688                            cpustate->r[Z8_REGISTER_FLAGS] & Z8_FLAGS_H ? 'H' : '.');   break;
689   }
690}
691
692/***************************************************************************
693    CPU-SPECIFIC CONTEXT ACCESS
694***************************************************************************/
695
696CPU_GET_INFO( z8601 )
697{
698   switch (state)
699   {
700      /* --- the following bits of info are returned as pointers --- */
701      case CPUINFO_PTR_INTERNAL_MEMORY_MAP_PROGRAM:   info->internal_map8 = ADDRESS_MAP_NAME(program_2kb);   break;
702      case CPUINFO_PTR_INTERNAL_MEMORY_MAP_DATA:      info->internal_map8 = ADDRESS_MAP_NAME(register_128b);   break;
703
704      /* --- the following bits of info are returned as NULL-terminated strings --- */
705      case DEVINFO_STR_NAME:                     strcpy(info->s, "Z8601");                        break;
706
707      default:                              CPU_GET_INFO_CALL(z8);                           break;
708   }
709}
710
711CPU_GET_INFO( ub8830d )
712{
713   switch (state)
714   {
715      /* --- the following bits of info are returned as pointers --- */
716      case CPUINFO_PTR_INTERNAL_MEMORY_MAP_PROGRAM:   info->internal_map8 = ADDRESS_MAP_NAME(program_2kb);   break;
717      case CPUINFO_PTR_INTERNAL_MEMORY_MAP_DATA:      info->internal_map8 = ADDRESS_MAP_NAME(register_128b);   break;
718
719      /* --- the following bits of info are returned as NULL-terminated strings --- */
720      case DEVINFO_STR_NAME:                     strcpy(info->s, "UB8830D");                        break;
721
722      default:                              CPU_GET_INFO_CALL(z8);                           break;
723   }
724}
725
726CPU_GET_INFO( z8611 )
727{
728   switch (state)
729   {
730      /* --- the following bits of info are returned as pointers --- */
731      case CPUINFO_PTR_INTERNAL_MEMORY_MAP_PROGRAM:   info->internal_map8 = ADDRESS_MAP_NAME(program_4kb);   break;
732      case CPUINFO_PTR_INTERNAL_MEMORY_MAP_DATA:      info->internal_map8 = ADDRESS_MAP_NAME(register_128b);   break;
733
734      /* --- the following bits of info are returned as NULL-terminated strings --- */
735      case DEVINFO_STR_NAME:                     strcpy(info->s, "Z8611");                        break;
736
737      default:                              CPU_GET_INFO_CALL(z8);                           break;
738   }
739}
src/emu/cpu/z8/z8ops.c
r0r5545
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
113static void clear(z8_state *cpustate, UINT8 dst)
114{
115   /* dst <- 0 */
116   register_write(cpustate, dst, 0);
117}
118
119INSTRUCTION( clr_R1 )         { mode_R1(clear) }
120INSTRUCTION( clr_IR1 )         { mode_IR1(clear) }
121
122static void load(z8_state *cpustate, UINT8 dst, UINT8 src)
123{
124   /* dst <- src */
125   register_write(cpustate, dst, src);
126}
127
128INSTRUCTION( ld_r1_IM )         { mode_r1_IM(load) }
129INSTRUCTION( ld_r1_R2 )         { mode_r1_R2(load) }
130INSTRUCTION( ld_r2_R1 )         { mode_r2_R1(load) }
131INSTRUCTION( ld_Ir1_r2 )      { mode_Ir1_r2(load) }
132INSTRUCTION( ld_R2_IR1 )      { mode_R2_IR1(load) }
133INSTRUCTION( ld_r1_x_R2 )      { mode_r1_x_R2(load) }
134INSTRUCTION( ld_r2_x_R1 )      { mode_r2_x_R1(load) }
135
136INSTRUCTION( ld_r1_r2 )         { mode_r1_r2(load) }
137INSTRUCTION( ld_r1_Ir2 )      { mode_r1_Ir2(load) }
138INSTRUCTION( ld_R2_R1 )         { mode_R2_R1(load) }
139INSTRUCTION( ld_IR2_R1 )      { mode_IR2_R1(load) }
140INSTRUCTION( ld_R1_IM )         { mode_R1_IM(load) }
141INSTRUCTION( ld_IR1_IM )      { mode_IR1_IM(load) }
142
143static void load_from_memory(z8_state *cpustate, const 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 = memory_decrypted_read_byte(cpustate->program, address);
151   
152   register_write(cpustate, dst, data);
153}
154
155static void load_to_memory(z8_state *cpustate, const address_space *space)
156{
157   UINT8 operands = fetch(cpustate);
158   UINT8 dst = get_working_register(cpustate, operands >> 4);
159   UINT8 src = get_working_register(cpustate, operands & 0x0f);
160
161   UINT16 address = register_pair_read(cpustate, dst);
162   UINT8 data = register_read(cpustate, src);
163
164   memory_write_byte(cpustate->program, address, data);
165}
166
167static void load_from_memory_autoinc(z8_state *cpustate, const 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 = memory_decrypted_read_byte(cpustate->program, 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
183static void load_to_memory_autoinc(z8_state *cpustate, const address_space *space)
184{
185   UINT8 operands = fetch(cpustate);
186   UINT8 dst = get_working_register(cpustate, operands >> 4);
187   UINT8 src = 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   memory_write_byte(cpustate->program, address, data);
194   
195   register_pair_write(cpustate, dst, address + 1);
196   register_write(cpustate, src, real_src + 1);
197}
198
199INSTRUCTION( ldc_r1_Irr2 )      { load_from_memory(cpustate, cpustate->program); }
200INSTRUCTION( ldc_r2_Irr1 )      { load_to_memory(cpustate, cpustate->program); }
201INSTRUCTION( ldci_Ir1_Irr2 )   { load_from_memory_autoinc(cpustate, cpustate->program); }
202INSTRUCTION( ldci_Ir2_Irr1 )   { load_to_memory_autoinc(cpustate, cpustate->program); }
203INSTRUCTION( lde_r1_Irr2 )      { load_from_memory(cpustate, cpustate->data); }
204INSTRUCTION( lde_r2_Irr1 )      { load_to_memory(cpustate, cpustate->data); }
205INSTRUCTION( ldei_Ir1_Irr2 )   { load_from_memory_autoinc(cpustate, cpustate->data); }
206INSTRUCTION( ldei_Ir2_Irr1 )   { load_to_memory_autoinc(cpustate, cpustate->data); }
207
208static 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
215INSTRUCTION( pop_R1 )         { mode_R1(pop) }
216INSTRUCTION( pop_IR1 )         { mode_IR1(pop) }
217
218static void push(z8_state *cpustate, UINT8 src)
219{
220   /* SP <- SP - 1
221      @SP <- src */
222   stack_push_byte(cpustate, read(src));
223}
224
225INSTRUCTION( push_R2 )         { mode_R1(push) }
226INSTRUCTION( push_IR2 )         { mode_IR1(push) }
227
228/***************************************************************************
229    ARITHMETIC INSTRUCTIONS
230***************************************************************************/
231
232static void add_carry(z8_state *cpustate, UINT8 dst, INT8 src)
233{
234}
235
236INSTRUCTION( adc_r1_r2 )      { mode_r1_r2(add_carry) }
237INSTRUCTION( adc_r1_Ir2 )      { mode_r1_Ir2(add_carry) }
238INSTRUCTION( adc_R2_R1 )      { mode_R2_R1(add_carry) }
239INSTRUCTION( adc_IR2_R1 )      { mode_IR2_R1(add_carry) }
240INSTRUCTION( adc_R1_IM )      { mode_R1_IM(add_carry) }
241INSTRUCTION( adc_IR1_IM )      { mode_IR1_IM(add_carry) }
242
243static void add(z8_state *cpustate, UINT8 dst, INT8 src)
244{
245   /* dst <- dst + src */
246   int data = (INT8)read(dst) + src;
247
248   set_flag_c(data & 0x100);
249   set_flag_z(data == 0);
250   set_flag_s(data < 0);
251//   set_flag_v();
252   set_flag_d(0);
253//   set_flag_h();
254}
255
256INSTRUCTION( add_r1_r2 )      { mode_r1_r2(add) }
257INSTRUCTION( add_r1_Ir2 )      { mode_r1_Ir2(add) }
258INSTRUCTION( add_R2_R1 )      { mode_R2_R1(add) }
259INSTRUCTION( add_IR2_R1 )      { mode_IR2_R1(add) }
260INSTRUCTION( add_R1_IM )      { mode_R1_IM(add) }
261INSTRUCTION( add_IR1_IM )      { mode_IR1_IM(add) }
262
263static void compare(z8_state *cpustate, UINT8 dst, UINT8 src)
264{
265}
266
267INSTRUCTION( cp_r1_r2 )         { mode_r1_r2(compare) }
268INSTRUCTION( cp_r1_Ir2 )      { mode_r1_Ir2(compare) }
269INSTRUCTION( cp_R2_R1 )         { mode_R2_R1(compare) }
270INSTRUCTION( cp_IR2_R1 )      { mode_IR2_R1(compare) }
271INSTRUCTION( cp_R1_IM )         { mode_R1_IM(compare) }
272INSTRUCTION( cp_IR1_IM )      { mode_IR1_IM(compare) }
273
274static void decimal_adjust(z8_state *cpustate, UINT8 dst)
275{
276}
277
278INSTRUCTION( da_R1 )         { mode_R1(decimal_adjust) }
279INSTRUCTION( da_IR1 )         { mode_IR1(decimal_adjust) }
280
281static void decrement(z8_state *cpustate, UINT8 dst)
282{
283}
284
285INSTRUCTION( dec_R1 )         { mode_R1(decrement) }
286INSTRUCTION( dec_IR1 )         { mode_IR1(decrement) }
287
288static void decrement_word(z8_state *cpustate, UINT8 dst)
289{
290}
291
292INSTRUCTION( decw_RR1 )         { mode_RR1(decrement_word) }
293INSTRUCTION( decw_IR1 )         { mode_IR1(decrement_word) }
294
295static void increment(z8_state *cpustate, UINT8 dst)
296{
297}
298
299INSTRUCTION( inc_r1 )         { mode_r1(increment) }
300INSTRUCTION( inc_R1 )         { mode_R1(increment) }
301INSTRUCTION( inc_IR1 )         { mode_IR1(increment) }
302
303static void increment_word(z8_state *cpustate, UINT8 dst)
304{
305}
306
307INSTRUCTION( incw_RR1 )         { mode_RR1(increment_word) }
308INSTRUCTION( incw_IR1 )         { mode_IR1(increment_word) }
309
310static void subtract_carry(z8_state *cpustate, UINT8 dst, UINT8 src)
311{
312}
313
314INSTRUCTION( sbc_r1_r2 )      { mode_r1_r2(subtract_carry) }
315INSTRUCTION( sbc_r1_Ir2 )      { mode_r1_Ir2(subtract_carry) }
316INSTRUCTION( sbc_R2_R1 )      { mode_R2_R1(subtract_carry) }
317INSTRUCTION( sbc_IR2_R1 )      { mode_IR2_R1(subtract_carry) }
318INSTRUCTION( sbc_R1_IM )      { mode_R1_IM(subtract_carry) }
319INSTRUCTION( sbc_IR1_IM )      { mode_IR1_IM(subtract_carry) }
320
321static void subtract(z8_state *cpustate, UINT8 dst, UINT8 src)
322{
323}
324
325INSTRUCTION( sub_r1_r2 )      { mode_r1_r2(subtract) }
326INSTRUCTION( sub_r1_Ir2 )      { mode_r1_Ir2(subtract) }
327INSTRUCTION( sub_R2_R1 )      { mode_R2_R1(subtract) }
328INSTRUCTION( sub_IR2_R1 )      { mode_IR2_R1(subtract) }
329INSTRUCTION( sub_R1_IM )      { mode_R1_IM(subtract) }
330INSTRUCTION( sub_IR1_IM )      { mode_IR1_IM(subtract) }
331
332/***************************************************************************
333    LOGICAL INSTRUCTIONS
334***************************************************************************/
335
336static void and(z8_state *cpustate, UINT8 dst, UINT8 src)
337{
338   /* dst <- dst AND src */
339   UINT8 data = register_read(cpustate, dst) & src;
340   register_write(cpustate, dst, data);
341
342   set_flag_z(data == 0);
343   set_flag_s(data & 0x80);
344   set_flag_v(0);
345}
346
347INSTRUCTION( and_r1_r2 )      { mode_r1_r2(and) }
348INSTRUCTION( and_r1_Ir2 )      { mode_r1_Ir2(and) }
349INSTRUCTION( and_R2_R1 )      { mode_R2_R1(and) }
350INSTRUCTION( and_IR2_R1 )      { mode_IR2_R1(and) }
351INSTRUCTION( and_R1_IM )      { mode_R1_IM(and) }
352INSTRUCTION( and_IR1_IM )      { mode_IR1_IM(and) }
353
354static void complement(z8_state *cpustate, UINT8 dst)
355{
356   /* dst <- NOT dst */
357   UINT8 data = register_read(cpustate, dst) ^ 0xff;
358   register_write(cpustate, dst, data);
359
360   set_flag_z(data == 0);
361   set_flag_s(data & 0x80);
362   set_flag_v(0);
363}
364
365INSTRUCTION( com_R1 )         { mode_R1(complement) }
366INSTRUCTION( com_IR1 )         { mode_IR1(complement) }
367
368static void or(z8_state *cpustate, UINT8 dst, UINT8 src)
369{
370   /* dst <- dst OR src */
371   UINT8 data = register_read(cpustate, dst) | src;
372   register_write(cpustate, dst, data);
373
374   set_flag_z(data == 0);
375   set_flag_s(data & 0x80);
376   set_flag_v(0);
377}
378
379INSTRUCTION( or_r1_r2 )         { mode_r1_r2(or) }
380INSTRUCTION( or_r1_Ir2 )      { mode_r1_Ir2(or) }
381INSTRUCTION( or_R2_R1 )         { mode_R2_R1(or) }
382INSTRUCTION( or_IR2_R1 )      { mode_IR2_R1(or) }
383INSTRUCTION( or_R1_IM )         { mode_R1_IM(or) }
384INSTRUCTION( or_IR1_IM )      { mode_IR1_IM(or) }
385
386static void xor(z8_state *cpustate, UINT8 dst, UINT8 src)
387{
388   /* dst <- dst XOR src */
389   UINT8 data = register_read(cpustate, dst) ^ src;
390   register_write(cpustate, dst, data);
391
392   set_flag_z(data == 0);
393   set_flag_s(data & 0x80);
394   set_flag_v(0);
395}
396
397INSTRUCTION( xor_r1_r2 )      { mode_r1_r2(xor) }
398INSTRUCTION( xor_r1_Ir2 )      { mode_r1_Ir2(xor) }
399INSTRUCTION( xor_R2_R1 )      { mode_R2_R1(xor) }
400INSTRUCTION( xor_IR2_R1 )      { mode_IR2_R1(xor) }
401INSTRUCTION( xor_R1_IM )      { mode_R1_IM(xor) }
402INSTRUCTION( xor_IR1_IM )      { mode_IR1_IM(xor) }
403
404/***************************************************************************
405    PROGRAM CONTROL INSTRUCTIONS
406***************************************************************************/
407
408static void call(z8_state *cpustate, UINT16 dst)
409{
410   stack_push_word(cpustate, cpustate->pc);
411   cpustate->pc = dst;
412}
413
414INSTRUCTION( call_IRR1 )      { UINT16 dst = register_pair_read(cpustate, get_intermediate_register(cpustate, get_register(cpustate, fetch(cpustate)))); call(cpustate, dst); }
415INSTRUCTION( call_DA )         { UINT16 dst = (fetch(cpustate) << 8) | fetch(cpustate); call(cpustate, dst); }
416
417INSTRUCTION( djnz_r1_RA )
418{
419   INT8 ra = (INT8) fetch(cpustate);
420
421   /* r <- r - 1 */
422   int r = get_working_register(cpustate, opcode >> 4);
423   UINT8 data = register_read(cpustate, r) - 1;
424   register_write(cpustate, r, data);
425
426   /* if r<>0, PC <- PC + dst */
427   if (data != 0)
428   {
429      cpustate->pc += ra;
430      *cycles += 2;
431   }
432}
433
434INSTRUCTION( iret )
435{
436   /* FLAGS <- @SP
437      SP <- SP + 1 */
438   register_write(cpustate, Z8_REGISTER_FLAGS, stack_pop_byte(cpustate));
439
440   /* PC <- @SP
441      SP <- SP + 2 */
442   cpustate->pc = stack_pop_word(cpustate);
443   
444   /* IMR (7) <- 1 */
445   cpustate->r[Z8_REGISTER_IMR] |= Z8_IMR_ENABLE;
446}
447
448INSTRUCTION( ret )
449{
450   /* PC <- @SP
451      SP <- SP + 2 */
452   cpustate->pc = stack_pop_word(cpustate);
453}
454
455static void jump(z8_state *cpustate, UINT16 dst)
456{
457   /* PC <- dst */
458   cpustate->pc = dst;
459}
460
461INSTRUCTION( jp_IRR1 )         { jump(cpustate, register_pair_read(cpustate, IR)); }
462
463static int check_condition_code(z8_state *cpustate, int cc)
464{
465   int truth = 0;
466
467   switch (cc)
468   {
469   case CC_F:      truth = 0; break;
470   case CC_LT:      truth = flag(S) ^ flag(V); break;
471   case CC_LE:      truth = (flag(Z) | (flag(S) ^ flag(V))); break;
472   case CC_ULE:   truth = flag(C) | flag(Z); break;
473   case CC_OV:      truth = flag(V); break;
474   case CC_MI:      truth = flag(S); break;
475   case CC_Z:      truth = flag(Z); break;
476   case CC_C:      truth = flag(C); break;
477   case CC_T:      truth = 1; break;
478   case CC_GE:      truth = !(flag(S) ^ flag(V)); break;
479   case CC_GT:      truth = !(flag(Z) | (flag(S) ^ flag(V))); break;
480   case CC_UGT:   truth = (!flag(C) & !flag(Z)); break;
481   case CC_NOV:   truth = !flag(V); break;
482   case CC_PL:      truth = !flag(S); break;
483   case CC_NZ:      truth = !flag(Z); break;
484   case CC_NC:      truth = !flag(C); break;
485   }
486   
487   return truth;
488}
489
490INSTRUCTION( jp_cc_DA )
491{
492   UINT16 dst = (fetch(cpustate) << 8) | fetch(cpustate);
493   
494   /* if cc is true, then PC <- dst */
495   if (check_condition_code(cpustate, opcode >> 4))
496   {
497      jump(cpustate, dst);
498      *cycles += 2;
499   }
500}
501
502INSTRUCTION( jr_cc_RA )
503{
504   UINT16 dst = cpustate->pc + (INT8)fetch(cpustate) - 1;
505   
506   /* if cc is true, then PC <- dst */
507   if (check_condition_code(cpustate, opcode >> 4))
508   {
509      jump(cpustate, dst);
510      *cycles += 2;
511   }
512}
513
514/***************************************************************************
515    BIT MANIPULATION INSTRUCTIONS
516***************************************************************************/
517
518static void test_complement_under_mask(z8_state *cpustate, UINT8 dst, UINT8 src)
519{
520   /* NOT(dst) AND src */
521   UINT8 data = (dst ^ 0xff) & src;
522   
523   set_flag_z(data == 0);
524   set_flag_s(data & 0x80);
525   set_flag_v(0);
526}
527
528INSTRUCTION( tcm_r1_r2 )      { mode_r1_r2(test_complement_under_mask) }
529INSTRUCTION( tcm_r1_Ir2 )      { mode_r1_Ir2(test_complement_under_mask) }
530INSTRUCTION( tcm_R2_R1 )      { mode_R2_R1(test_complement_under_mask) }
531INSTRUCTION( tcm_IR2_R1 )      { mode_IR2_R1(test_complement_under_mask) }
532INSTRUCTION( tcm_R1_IM )      { mode_R1_IM(test_complement_under_mask) }
533INSTRUCTION( tcm_IR1_IM )      { mode_IR1_IM(test_complement_under_mask) }
534
535static void test_under_mask(z8_state *cpustate, UINT8 dst, UINT8 src)
536{
537   /* dst AND src */
538   UINT8 data = dst & src;
539   
540   set_flag_z(data == 0);
541   set_flag_s(data & 0x80);
542   set_flag_v(0);
543}
544
545INSTRUCTION( tm_r1_r2 )         { mode_r1_r2(test_under_mask) }
546INSTRUCTION( tm_r1_Ir2 )      { mode_r1_Ir2(test_under_mask) }
547INSTRUCTION( tm_R2_R1 )         { mode_R2_R1(test_under_mask) }
548INSTRUCTION( tm_IR2_R1 )      { mode_IR2_R1(test_under_mask) }
549INSTRUCTION( tm_R1_IM )         { mode_R1_IM(test_under_mask) }
550INSTRUCTION( tm_IR1_IM )      { mode_IR1_IM(test_under_mask) }
551
552/***************************************************************************
553    ROTATE AND SHIFT INSTRUCTIONS
554***************************************************************************/
555
556static void rotate_left(z8_state *cpustate, UINT8 dst)
557{
558}
559
560INSTRUCTION( rl_R1 )         { mode_R1(rotate_left) }
561INSTRUCTION( rl_IR1 )         { mode_IR1(rotate_left) }
562
563static void rotate_left_carry(z8_state *cpustate, UINT8 dst)
564{
565}
566
567INSTRUCTION( rlc_R1 )         { mode_R1(rotate_left_carry) }
568INSTRUCTION( rlc_IR1 )         { mode_IR1(rotate_left_carry) }
569
570static void rotate_right(z8_state *cpustate, UINT8 dst)
571{
572}
573
574INSTRUCTION( rr_R1 )         { mode_R1(rotate_right) }
575INSTRUCTION( rr_IR1 )         { mode_IR1(rotate_right) }
576
577static void rotate_right_carry(z8_state *cpustate, UINT8 dst)
578{
579}
580
581INSTRUCTION( rrc_R1 )         { mode_R1(rotate_right_carry) }
582INSTRUCTION( rrc_IR1 )         { mode_IR1(rotate_right_carry) }
583
584static void shift_right_arithmetic(z8_state *cpustate, UINT8 dst)
585{
586}
587
588INSTRUCTION( sra_R1 )         { mode_R1(shift_right_arithmetic) }
589INSTRUCTION( sra_IR1 )         { mode_IR1(shift_right_arithmetic) }
590
591static void swap(z8_state *cpustate, UINT8 dst)
592{
593   /* dst(7-4) <-> dst(3-0) */
594   UINT8 data = register_read(cpustate, dst);
595   data = (data << 4) | (data >> 4);
596   register_write(cpustate, dst, data);
597
598   set_flag_z(data == 0);
599   set_flag_s(data & 0x80);
600//   set_flag_v(0); undefined
601}
602
603INSTRUCTION( swap_R1 )         { mode_R1(swap) }
604INSTRUCTION( swap_IR1 )         { mode_IR1(swap) }
605
606/***************************************************************************
607    CPU CONTROL INSTRUCTIONS
608***************************************************************************/
609
610INSTRUCTION( ccf )            { cpustate->r[Z8_REGISTER_FLAGS] ^= Z8_FLAGS_C; }
611INSTRUCTION( di )            { cpustate->r[Z8_REGISTER_IMR] &= ~Z8_IMR_ENABLE; }
612INSTRUCTION( ei )            { cpustate->r[Z8_REGISTER_IMR] |= Z8_IMR_ENABLE; }
613INSTRUCTION( nop )            { /* no operation */ }
614INSTRUCTION( rcf )            { set_flag_c(0); }
615INSTRUCTION( scf )            { set_flag_c(1); }
616INSTRUCTION( srp_IM )         { cpustate->r[Z8_REGISTER_RP] = fetch(cpustate); }
src/emu/cpu/z8/z8.h
r0r5545
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#pragma once
11
12#ifndef __Z8_H__
13#define __Z8_H__
14
15#include "cpuintrf.h"
16
17enum
18{
19   Z8_PC, Z8_SP, Z8_RP,
20
21   Z8_R0, Z8_R1, Z8_R2, Z8_R3, Z8_R4, Z8_R5, Z8_R6, Z8_R7, Z8_R8, Z8_R9, Z8_R10, Z8_R11, Z8_R12, Z8_R13, Z8_R14, Z8_R15,
22
23   Z8_GENPC = REG_GENPC,
24   Z8_GENSP = REG_GENSP
25};
26
27/* Zilog Z8601 */
28CPU_GET_INFO( z8601 );
29#define CPU_Z8601 CPU_GET_INFO_NAME( z8601 )
30
31/* VEB Mikroelektronik Erfurt UB8830D MME */
32CPU_GET_INFO( ub8830d );
33#define CPU_UB8830D CPU_GET_INFO_NAME( ub8830d )
34
35/* Zilog Z8611 */
36CPU_GET_INFO( z8611 );
37#define CPU_Z8611 CPU_GET_INFO_NAME( z8611 )
38
39CPU_DISASSEMBLE( z8 );
40
41#endif
src/emu/cpu/z8/z8dasm.c
r0r5545
1#include "cpuintrf.h"
2#include "debugger.h"
3#include "z8.h"
4
5/***************************************************************************
6    CONSTANTS
7***************************************************************************/
8
9static const char* REGISTER_NAME[256] =
10{
11   "P0", "P1", "P2", "P3", "", "", "", "", "", "", "", "", "", "", "", "",
12   "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
13   "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
14   "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
15   "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
16   "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
17   "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
18   "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
19   "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
20   "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
21   "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
22   "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
23   "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
24   "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
25   "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
26   "SIO", "TMR", "T1", "PRE1", "T0", "PRE0", "P2M", "P3M", "P01M", "IPR", "IRQ", "IMR", "FLAGS", "RP", "SPH", "SPL"
27};
28
29static const char* CONDITION_CODE[16] =
30{
31   "F", "LT", "LE", "ULE", "OV", "MI", "EQ", "ULT",
32   "", "GE", "GT", "UGT", "NOV", "PL", "NZ", "UGE"
33};
34
35/***************************************************************************
36    MACROS
37***************************************************************************/
38
39#define r      "R%u"
40#define Ir      "@R%u"
41#define R      "%02Xh"
42#define RR      "%02Xh"
43#define IR      "@%02Xh"
44#define Irr      "@RR%u"
45#define IRR      "@%02Xh"
46#define IM      "#%02Xh"
47#define X      "%02Xh(R%u)"
48#define DA      "%04Xh"
49#define RA      "%04Xh"
50
51#define B0      oprom[0]
52#define B1      oprom[1]
53#define B0H      (B0 >> 4)
54#define B0L      (B0 & 0x0f)
55#define OPH      (opcode >> 4)
56
57#define ARG(_formatting, _value)   { if (argc) dst += sprintf(dst, ", "); dst += sprintf(dst, _formatting, _value); argc++; }
58
59#define arg_name(_value)         ARG("%s", REGISTER_NAME[_value])
60#define arg_cc                  ARG("%s", CONDITION_CODE[OPH])
61#define arg_r(_value)            ARG(r, _value)
62#define arg_Ir(_value)            ARG(Ir, _value)
63#define arg_Irr(_value)            ARG(Irr, _value & 0x0f)
64#define arg_R(_value)            if ((_value & 0xf0) == 0xe0) ARG(r, _value & 0x0f) else if ((_value < 4) || (_value >= 0xf0)) arg_name(_value) else ARG(R, _value)
65#define arg_RR(_value)            if ((_value & 0xf0) == 0xe0) ARG(r, _value & 0x0f) else ARG(R, _value)
66#define arg_IR(_value)            if ((_value & 0xf0) == 0xe0) ARG(Ir, _value & 0x0f) else ARG(IR, _value)
67#define arg_IRR(_value)            if ((_value & 0xf0) == 0xe0) ARG(Irr, _value & 0x0f) else ARG(IRR, _value)
68#define arg_IM(_value)            ARG(IM, _value)
69#define arg_RA                  ARG(RA, pc + B0)
70#define arg_DA                  ARG(DA, B0 << 8 | B1)
71#define arg_X(_value1, _value2)      { if (argc) dst += sprintf(dst, ", "); dst += sprintf(dst, X, _value1, _value2); argc++; }
72
73#define illegal                  dst += sprintf(dst, "Illegal")
74#define mnemonic(_mnemonic)         dst += sprintf(dst, "%-5s", _mnemonic)
75#define bytes(_count)            oprom += (_count - 1)
76#define step_over               flags = DASMFLAG_STEP_OVER
77#define step_out               flags = DASMFLAG_STEP_OUT
78
79/***************************************************************************
80    DISASSEMBLER
81***************************************************************************/
82
83CPU_DISASSEMBLE( z8 )
84{
85   const UINT8 *startrom = oprom;
86   UINT32 flags = 0;
87   UINT8 opcode = *oprom++;
88   char *dst = buffer;
89   int argc = 0;
90
91   switch (pc)
92   {
93   case 0x0000:
94   case 0x0002:
95   case 0x0004:
96   case 0x0006:
97   case 0x0008:
98   case 0x000a:
99      sprintf(buffer, "IRQ%u Vector %04Xh", pc / 2, opcode << 8 | *oprom++); break;
100   default:
101      switch (opcode)
102      {
103         case 0x00:      mnemonic("DEC"); arg_R(B0); bytes(2);               break;
104         case 0x01:      mnemonic("DEC"); arg_IR(B0); bytes(2);               break;
105         case 0x02:      mnemonic("ADD"); arg_r(B0H); arg_r(B0L); bytes(2);      break;
106         case 0x03:      mnemonic("ADD"); arg_r(B0H); arg_Ir(B0L); bytes(2);      break;
107         case 0x04:      mnemonic("ADD"); arg_R(B0); arg_R(B1); bytes(3);      break;
108         case 0x05:      mnemonic("ADD"); arg_R(B0); arg_IR(B1); bytes(3);      break;
109         case 0x06:      mnemonic("ADD"); arg_R(B0); arg_IM(B1); bytes(3);      break;
110         case 0x07:      mnemonic("ADD"); arg_IR(B0); arg_IM(B1); bytes(3);      break;
111         case 0x08:      mnemonic("LD"); arg_r(OPH); arg_R(B0); bytes(2);      break;
112         case 0x09:      mnemonic("LD"); arg_R(B0); arg_r(OPH); bytes(2);      break;
113         case 0x0a:      mnemonic("DJNZ"); arg_r(OPH); arg_RA; bytes(2);         break;
114         case 0x0b:      mnemonic("JR"); arg_cc; arg_RA; bytes(2);            break;
115         case 0x0c:      mnemonic("LD"); arg_r(OPH); arg_IM(B0); bytes(2);      break;
116         case 0x0d:      mnemonic("JP"); arg_cc; arg_DA; bytes(3);            break;
117         case 0x0e:      mnemonic("INC"); arg_r(OPH);                     break;
118         case 0x0f:      illegal;                                    break;
119
120         case 0x10:      mnemonic("RLC"); arg_R(B0); bytes(2);               break;
121         case 0x11:      mnemonic("RLC"); arg_IR(B0); bytes(2);               break;
122         case 0x12:      mnemonic("ADC"); arg_r(B0H); arg_r(B0L); bytes(2);      break;
123         case 0x13:      mnemonic("ADC"); arg_r(B0H); arg_Ir(B0L); bytes(2);      break;
124         case 0x14:      mnemonic("ADC"); arg_R(B0); arg_R(B1); bytes(3);      break;
125         case 0x15:      mnemonic("ADC"); arg_R(B0); arg_IR(B1); bytes(3);      break;
126         case 0x16:      mnemonic("ADC"); arg_R(B0); arg_IM(B1); bytes(3);      break;
127         case 0x17:      mnemonic("ADC"); arg_IR(B0); arg_IM(B1); bytes(3);      break;
128         case 0x18:      mnemonic("LD"); arg_r(OPH); arg_R(B0); bytes(2);      break;
129         case 0x19:      mnemonic("LD"); arg_R(B0); arg_r(OPH); bytes(2);      break;
130         case 0x1a:      mnemonic("DJNZ"); arg_r(OPH); arg_RA; bytes(2);         break;
131         case 0x1b:      mnemonic("JR"); arg_cc; arg_RA; bytes(2);            break;
132         case 0x1c:      mnemonic("LD"); arg_r(OPH); arg_IM(B0); bytes(2);      break;
133         case 0x1d:      mnemonic("JP"); arg_cc; arg_DA; bytes(3);            break;
134         case 0x1e:      mnemonic("INC"); arg_r(OPH);                     break;
135         case 0x1f:      illegal;                                    break;
136
137         case 0x20:      mnemonic("INC"); arg_R(B0); bytes(2);               break;
138         case 0x21:      mnemonic("INC"); arg_IR(B0); bytes(2);               break;
139         case 0x22:      mnemonic("SUB"); arg_r(B0H); arg_r(B0L); bytes(2);      break;
140         case 0x23:      mnemonic("SUB"); arg_r(B0H); arg_Ir(B0L); bytes(2);      break;
141         case 0x24:      mnemonic("SUB"); arg_R(B0); arg_R(B1); bytes(3);      break;
142         case 0x25:      mnemonic("SUB"); arg_R(B0); arg_IR(B1); bytes(3);      break;
143         case 0x26:      mnemonic("SUB"); arg_R(B0); arg_IM(B1); bytes(3);      break;
144         case 0x27:      mnemonic("SUB"); arg_IR(B0); arg_IM(B1); bytes(3);      break;
145         case 0x28:      mnemonic("LD"); arg_r(OPH); arg_R(B0); bytes(2);      break;
146         case 0x29:      mnemonic("LD"); arg_R(B0); arg_r(OPH); bytes(2);      break;
147         case 0x2a:      mnemonic("DJNZ"); arg_r(OPH); arg_RA; bytes(2);         break;
148         case 0x2b:      mnemonic("JR"); arg_cc; arg_RA; bytes(2);            break;
149         case 0x2c:      mnemonic("LD"); arg_r(OPH); arg_IM(B0); bytes(2);      break;
150         case 0x2d:      mnemonic("JP"); arg_cc; arg_DA; bytes(3);            break;
151         case 0x2e:      mnemonic("INC"); arg_r(OPH);                     break;
152         case 0x2f:      illegal;                                    break;
153
154         case 0x30:      mnemonic("JP"); arg_IRR(B0); bytes(2);               break;
155         case 0x31:      mnemonic("SRP"); arg_IM(*oprom++);                  break;
156         case 0x32:      mnemonic("SBC"); arg_r(B0H); arg_r(B0L); bytes(2);      break;
157         case 0x33:      mnemonic("SBC"); arg_r(B0H); arg_Ir(B0L); bytes(2);      break;
158         case 0x34:      mnemonic("SBC"); arg_R(B0); arg_R(B1); bytes(3);      break;
159         case 0x35:      mnemonic("SBC"); arg_R(B0); arg_IR(B1); bytes(3);      break;
160         case 0x36:      mnemonic("SBC"); arg_R(B0); arg_IM(B1); bytes(3);      break;
161         case 0x37:      mnemonic("SBC"); arg_IR(B0); arg_IM(B1); bytes(3);      break;
162         case 0x38:      mnemonic("LD"); arg_r(OPH); arg_R(B0); bytes(2);      break;
163         case 0x39:      mnemonic("LD"); arg_R(B0); arg_r(OPH); bytes(2);      break;
164         case 0x3a:      mnemonic("DJNZ"); arg_r(OPH); arg_RA; bytes(2);         break;
165         case 0x3b:      mnemonic("JR"); arg_cc; arg_RA; bytes(2);            break;
166         case 0x3c:      mnemonic("LD"); arg_r(OPH); arg_IM(B0); bytes(2);      break;
167         case 0x3d:      mnemonic("JP"); arg_cc; arg_DA; bytes(3);            break;
168         case 0x3e:      mnemonic("INC"); arg_r(OPH);                     break;
169         case 0x3f:      illegal;                                    break;
170
171         case 0x40:      mnemonic("DA"); arg_R(B0); bytes(2);               break;
172         case 0x41:      mnemonic("DA"); arg_IR(B0); bytes(2);               break;
173         case 0x42:      mnemonic("OR"); arg_r(B0H); arg_r(B0L); bytes(2);      break;
174         case 0x43:      mnemonic("OR"); arg_r(B0H); arg_Ir(B0L); bytes(2);      break;
175         case 0x44:      mnemonic("OR"); arg_R(B0); arg_R(B1); bytes(3);         break;
176         case 0x45:      mnemonic("OR"); arg_R(B0); arg_IR(B1); bytes(3);      break;
177         case 0x46:      mnemonic("OR"); arg_R(B0); arg_IM(B1); bytes(3);      break;
178         case 0x47:      mnemonic("OR"); arg_IR(B0); arg_IM(B1); bytes(3);      break;
179         case 0x48:      mnemonic("LD"); arg_r(OPH); arg_R(B0); bytes(2);      break;
180         case 0x49:      mnemonic("LD"); arg_R(B0); arg_r(OPH); bytes(2);      break;
181         case 0x4a:      mnemonic("DJNZ"); arg_r(OPH); arg_RA; bytes(2);         break;
182         case 0x4b:      mnemonic("JR"); arg_cc; arg_RA; bytes(2);            break;
183         case 0x4c:      mnemonic("LD"); arg_r(OPH); arg_IM(B0); bytes(2);      break;
184         case 0x4d:      mnemonic("JP"); arg_cc; arg_DA; bytes(3);            break;
185         case 0x4e:      mnemonic("INC"); arg_r(OPH);                     break;
186         case 0x4f:      illegal; /* mnemonic("WDH"); */                     break;
187
188         case 0x50:      mnemonic("POP"); arg_R(B0); bytes(2);               break;
189         case 0x51:      mnemonic("POP"); arg_IR(B0); bytes(2);               break;
190         case 0x52:      mnemonic("AND"); arg_r(B0H); arg_r(B0L); bytes(2);      break;
191         case 0x53:      mnemonic("AND"); arg_r(B0H); arg_Ir(B0L); bytes(2);      break;
192         case 0x54:      mnemonic("AND"); arg_R(B0); arg_R(B1); bytes(3);      break;
193         case 0x55:      mnemonic("AND"); arg_R(B0); arg_IR(B1); bytes(3);      break;
194         case 0x56:      mnemonic("AND"); arg_R(B0); arg_IM(B1); bytes(3);      break;
195         case 0x57:      mnemonic("AND"); arg_IR(B0); arg_IM(B1); bytes(3);      break;
196         case 0x58:      mnemonic("LD"); arg_r(OPH); arg_R(B0); bytes(2);      break;
197         case 0x59:      mnemonic("LD"); arg_R(B0); arg_r(OPH); bytes(2);      break;
198         case 0x5a:      mnemonic("DJNZ"); arg_r(OPH); arg_RA; bytes(2);         break;
199         case 0x5b:      mnemonic("JR"); arg_cc; arg_RA; bytes(2);            break;
200         case 0x5c:      mnemonic("LD"); arg_r(OPH); arg_IM(B0); bytes(2);      break;
201         case 0x5d:      mnemonic("JP"); arg_cc; arg_DA; bytes(3);            break;
202         case 0x5e:      mnemonic("INC"); arg_r(OPH);                     break;
203         case 0x5f:      illegal; /* mnemonic("WDT"); */                     break;
204
205         case 0x60:      mnemonic("COM"); arg_R(B0); bytes(2);               break;
206         case 0x61:      mnemonic("COM"); arg_IR(B0); bytes(2);               break;
207         case 0x62:      mnemonic("TCM"); arg_r(B0H); arg_r(B0L); bytes(2);      break;
208         case 0x63:      mnemonic("TCM"); arg_r(B0H); arg_Ir(B0L); bytes(2);      break;
209         case 0x64:      mnemonic("TCM"); arg_R(B0); arg_R(B1); bytes(3);      break;
210         case 0x65:      mnemonic("TCM"); arg_R(B0); arg_IR(B1); bytes(3);      break;
211         case 0x66:      mnemonic("TCM"); arg_R(B0); arg_IM(B1); bytes(3);      break;
212         case 0x67:      mnemonic("TCM"); arg_IR(B0); arg_IM(B1); bytes(3);      break;
213         case 0x68:      mnemonic("LD"); arg_r(OPH); arg_R(B0); bytes(2);      break;
214         case 0x69:      mnemonic("LD"); arg_R(B0); arg_r(OPH); bytes(2);      break;
215         case 0x6a:      mnemonic("DJNZ"); arg_r(OPH); arg_RA; bytes(2);         break;
216         case 0x6b:      mnemonic("JR"); arg_cc; arg_RA; bytes(2);            break;
217         case 0x6c:      mnemonic("LD"); arg_r(OPH); arg_IM(B0); bytes(2);      break;
218         case 0x6d:      mnemonic("JP"); arg_cc; arg_DA; bytes(3);            break;
219         case 0x6e:      mnemonic("INC"); arg_r(OPH);                     break;
220         case 0x6f:      illegal; /* mnemonic("STOP"); */                  break;
221
222         case 0x70:      mnemonic("PUSH"); arg_R(B0); bytes(2);               break;
223         case 0x71:      mnemonic("PUSH"); arg_IR(B0); bytes(2);               break;
224         case 0x72:      mnemonic("TM"); arg_r(B0H); arg_r(B0L); bytes(2);      break;
225         case 0x73:      mnemonic("TM"); arg_r(B0H); arg_Ir(B0L); bytes(2);      break;
226         case 0x74:      mnemonic("TM"); arg_R(B0); arg_R(B1); bytes(3);         break;
227         case 0x75:      mnemonic("TM"); arg_R(B0); arg_IR(B1); bytes(3);      break;
228         case 0x76:      mnemonic("TM"); arg_R(B0); arg_IM(B1); bytes(3);      break;
229         case 0x77:      mnemonic("TM"); arg_IR(B0); arg_IM(B1); bytes(3);      break;
230         case 0x78:      mnemonic("LD"); arg_r(OPH); arg_R(B0); bytes(2);      break;
231         case 0x79:      mnemonic("LD"); arg_R(B0); arg_r(OPH); bytes(2);      break;
232         case 0x7a:      mnemonic("DJNZ"); arg_r(OPH); arg_RA; bytes(2);         break;
233         case 0x7b:      mnemonic("JR"); arg_cc; arg_RA; bytes(2);            break;
234         case 0x7c:      mnemonic("LD"); arg_r(OPH); arg_IM(B0); bytes(2);      break;
235         case 0x7d:      mnemonic("JP"); arg_cc; arg_DA; bytes(3);            break;
236         case 0x7e:      mnemonic("INC"); arg_r(OPH);                     break;
237         case 0x7f:      illegal; /* mnemonic("HALT"); */                  break;
238         
239         case 0x80:      mnemonic("DECW"); arg_RR(*oprom++);                  break;
240         case 0x81:      mnemonic("DECW"); arg_IR(B0); bytes(2);               break;
241         case 0x82:      mnemonic("LDE"); arg_r(B0H); arg_Irr(B0L); bytes(2);   break;
242         case 0x83:      mnemonic("LDEI"); arg_Ir(B0H); arg_Irr(B0L); bytes(2);   break;
243         case 0x84:      illegal;                                    break;
244         case 0x85:      illegal;                                    break;
245         case 0x86:      illegal;                                    break;
246         case 0x87:      illegal;                                    break;
247         case 0x88:      mnemonic("LD"); arg_r(OPH); arg_R(B0); bytes(2);      break;
248         case 0x89:      mnemonic("LD"); arg_R(B0); arg_r(OPH); bytes(2);      break;
249         case 0x8a:      mnemonic("DJNZ"); arg_r(OPH); arg_RA; bytes(2);         break;
250         case 0x8b:      mnemonic("JR"); arg_RA; bytes(2);                  break;
251         case 0x8c:      mnemonic("LD"); arg_r(OPH); arg_IM(B0); bytes(2);      break;
252         case 0x8d:      mnemonic("JP"); arg_DA; bytes(3);                  break;
253         case 0x8e:      mnemonic("INC"); arg_r(OPH);                     break;
254         case 0x8f:      mnemonic("DI");                                 break;
255         
256         case 0x90:      mnemonic("RL"); arg_R(B0); bytes(2);               break;
257         case 0x91:      mnemonic("RL"); arg_IR(B0); bytes(2);               break;
258         case 0x92:      mnemonic("LDE"); arg_r(B0L); arg_Irr(B0H); bytes(2);   break;
259         case 0x93:      mnemonic("LDEI"); arg_Ir(B0L); arg_Irr(B0H); bytes(2);   break;
260         case 0x94:      illegal;                                    break;
261         case 0x95:      illegal;                                    break;
262         case 0x96:      illegal;                                    break;
263         case 0x97:      illegal;                                    break;
264         case 0x98:      mnemonic("LD"); arg_r(OPH); arg_R(B0); bytes(2);      break;
265         case 0x99:      mnemonic("LD"); arg_R(B0); arg_r(OPH); bytes(2);      break;
266         case 0x9a:      mnemonic("DJNZ"); arg_r(OPH); arg_RA; bytes(2);         break;
267         case 0x9b:      mnemonic("JR"); arg_cc; arg_RA; bytes(2);            break;
268         case 0x9c:      mnemonic("LD"); arg_r(OPH); arg_IM(B0); bytes(2);      break;
269         case 0x9d:      mnemonic("JP"); arg_cc; arg_DA; bytes(3);            break;
270         case 0x9e:      mnemonic("INC"); arg_r(OPH);                     break;
271         case 0x9f:      mnemonic("EI");                                 break;
272         
273         case 0xa0:      mnemonic("INCW"); arg_RR(B0); bytes(2);               break;
274         case 0xa1:      mnemonic("INCW"); arg_IR(B0); bytes(2);               break;
275         case 0xa2:      mnemonic("CP"); arg_r(B0H); arg_r(B0L); bytes(2);      break;
276         case 0xa3:      mnemonic("CP"); arg_r(B0H); arg_Ir(B0L); bytes(2);      break;
277         case 0xa4:      mnemonic("CP"); arg_R(B0); arg_R(B1); bytes(3);         break;
278         case 0xa5:      mnemonic("CP"); arg_R(B0); arg_IR(B1); bytes(3);      break;
279         case 0xa6:      mnemonic("CP"); arg_R(B0); arg_IM(B1); bytes(3);      break;
280         case 0xa7:      mnemonic("CP"); arg_IR(B0); arg_IM(B1); bytes(3);      break;
281         case 0xa8:      mnemonic("LD"); arg_r(OPH); arg_R(B0); bytes(2);      break;
282         case 0xa9:      mnemonic("LD"); arg_R(B0); arg_r(OPH); bytes(2);      break;
283         case 0xaa:      mnemonic("DJNZ"); arg_r(OPH); arg_RA; bytes(2);         break;
284         case 0xab:      mnemonic("JR"); arg_cc; arg_RA; bytes(2);            break;
285         case 0xac:      mnemonic("LD"); arg_r(OPH); arg_IM(B0); bytes(2);      break;
286         case 0xad:      mnemonic("JP"); arg_cc; arg_DA; bytes(3);            break;
287         case 0xae:      mnemonic("INC"); arg_r(OPH);                     break;
288         case 0xaf:      mnemonic("RET"); step_out;                        break;
289         
290         case 0xb0:      mnemonic("CLR"); arg_R(B0); bytes(2);               break;
291         case 0xb1:      mnemonic("XOR"); arg_IR(B0); bytes(2);               break;
292         case 0xb2:      mnemonic("XOR"); arg_r(B0H); arg_r(B0L); bytes(2);      break;
293         case 0xb3:      mnemonic("XOR"); arg_r(B0H); arg_Ir(B0L); bytes(2);      break;
294         case 0xb4:      mnemonic("XOR"); arg_R(B0); arg_R(B1); bytes(3);      break;
295         case 0xb5:      mnemonic("XOR"); arg_R(B0); arg_IR(B1); bytes(3);      break;
296         case 0xb6:      mnemonic("XOR"); arg_R(B0); arg_IM(B1); bytes(3);      break;
297         case 0xb7:      mnemonic("XOR"); arg_IR(B0); arg_IM(B1); bytes(3);      break;
298         case 0xb8:      mnemonic("LD"); arg_r(OPH); arg_R(B0); bytes(2);      break;
299         case 0xb9:      mnemonic("LD"); arg_R(B0); arg_r(OPH); bytes(2);      break;
300         case 0xba:      mnemonic("DJNZ"); arg_r(OPH); arg_RA; bytes(2);         break;
301         case 0xbb:      mnemonic("JR"); arg_cc; arg_RA; bytes(2);            break;
302         case 0xbc:      mnemonic("LD"); arg_r(OPH); arg_IM(B0); bytes(2);      break;
303         case 0xbd:      mnemonic("JP"); arg_cc; arg_DA; bytes(3);            break;
304         case 0xbe:      mnemonic("INC"); arg_r(OPH);                     break;
305         case 0xbf:      mnemonic("IRET"); step_out;                        break;
306         
307         case 0xc0:      mnemonic("RRC"); arg_R(B0); bytes(2);               break;
308         case 0xc1:      mnemonic("RRC"); arg_IR(B0); bytes(2);               break;
309         case 0xc2:      mnemonic("LDC"); arg_r(B0H); arg_Irr(B0L); bytes(2);   break;
310         case 0xc3:      mnemonic("LDCI"); arg_Ir(B0H); arg_Irr(B0L); bytes(2);   break;
311         case 0xc4:      illegal;                                    break;
312         case 0xc5:      illegal;                                    break;
313         case 0xc6:      illegal;                                    break;
314         case 0xc7:      mnemonic("LD"); arg_r(B0H); arg_X(B1, B0L); bytes(3);   break;
315         case 0xc8:      mnemonic("LD"); arg_r(OPH); arg_R(B0); bytes(2);      break;
316         case 0xc9:      mnemonic("LD"); arg_R(B0); arg_r(OPH); bytes(2);      break;
317         case 0xca:      mnemonic("DJNZ"); arg_r(OPH); arg_RA; bytes(2);         break;
318         case 0xcb:      mnemonic("JR"); arg_cc; arg_RA; bytes(2);            break;
319         case 0xcc:      mnemonic("LD"); arg_r(OPH); arg_IM(B0); bytes(2);      break;
320         case 0xcd:      mnemonic("JP"); arg_cc; arg_DA; bytes(3);            break;
321         case 0xce:      mnemonic("INC"); arg_r(OPH);                     break;
322         case 0xcf:      mnemonic("RCF");                              break;
323         
324         case 0xd0:      mnemonic("SRA"); arg_R(B0); bytes(2);               break;
325         case 0xd1:      mnemonic("SRA"); arg_IR(B0); bytes(2);               break;
326         case 0xd2:      mnemonic("LDC"); arg_Irr(B0H); arg_r(B0L); bytes(2);   break;
327         case 0xd3:      mnemonic("LDCI"); arg_Irr(B0H); arg_Ir(B0L); bytes(2);   break;
328         case 0xd4:      mnemonic("CALL"); arg_IRR(B0); bytes(2); step_over;      break;
329         case 0xd5:      illegal;                                    break;
330         case 0xd6:      mnemonic("CALL"); arg_DA; bytes(3);   step_over;         break;
331         case 0xd7:      mnemonic("LD"); arg_r(B0L); arg_X(B1, B0H); bytes(3);   break;
332         case 0xd8:      mnemonic("LD"); arg_r(OPH); arg_R(B0); bytes(2);      break;
333         case 0xd9:      mnemonic("LD"); arg_R(B0); arg_r(OPH); bytes(2);      break;
334         case 0xda:      mnemonic("DJNZ"); arg_r(OPH); arg_RA; bytes(2);         break;
335         case 0xdb:      mnemonic("JR"); arg_cc; arg_RA; bytes(2);            break;
336         case 0xdc:      mnemonic("LD"); arg_r(OPH); arg_IM(B0); bytes(2);      break;
337         case 0xdd:      mnemonic("JP"); arg_cc; arg_DA; bytes(3);            break;
338         case 0xde:      mnemonic("INC"); arg_r(OPH);                     break;
339         case 0xdf:      mnemonic("SCF");                              break;
340         
341         case 0xe0:      mnemonic("RR"); arg_R(B0); bytes(2);               break;
342         case 0xe1:      mnemonic("RR"); arg_IR(B0); bytes(2);               break;
343         case 0xe2:      illegal;                                    break;
344         case 0xe3:      mnemonic("LD");   arg_r(B0H); arg_Ir(B0L); bytes(2);      break;
345         case 0xe4:      mnemonic("LD");   arg_R(B0); arg_R(B1); bytes(3);         break;
346         case 0xe5:      mnemonic("LD");   arg_R(B0); arg_IR(B1); bytes(3);      break;
347         case 0xe6:      mnemonic("LD");   arg_R(B0); arg_IM(B1); bytes(3);      break;
348         case 0xe7:      mnemonic("LD");   arg_IR(B0); arg_IM(B1); bytes(3);      break;
349         case 0xe8:      mnemonic("LD"); arg_r(OPH); arg_R(B0); bytes(2);      break;
350         case 0xe9:      mnemonic("LD"); arg_R(B0); arg_r(OPH); bytes(2);      break;
351         case 0xea:      mnemonic("DJNZ"); arg_r(OPH); arg_RA; bytes(2);         break;
352         case 0xeb:      mnemonic("JR"); arg_cc; arg_RA; bytes(2);            break;
353         case 0xec:      mnemonic("LD"); arg_r(OPH); arg_IM(B0); bytes(2);      break;
354         case 0xed:      mnemonic("JP"); arg_cc; arg_DA; bytes(3);            break;
355         case 0xee:      mnemonic("INC"); arg_r(OPH);                     break;
356         case 0xef:      mnemonic("CCF");                              break;
357         
358         case 0xf0:      mnemonic("SWAP"); arg_R(B0); bytes(2);               break;
359         case 0xf1:      mnemonic("SWAP"); arg_IR(B0); bytes(2);               break;
360         case 0xf2:      illegal;                                    break;
361         case 0xf3:      mnemonic("LD");   arg_Ir(B0H); arg_r(B0L); bytes(2);      break;
362         case 0xf4:      illegal;                                    break;
363         case 0xf5:      mnemonic("LD");   arg_IR(B0); arg_R(B1); bytes(3);      break;
364         case 0xf6:      illegal;                                    break;
365         case 0xf7:      illegal;                                    break;
366         case 0xf8:      mnemonic("LD"); arg_r(OPH); arg_R(B0); bytes(2);      break;
367         case 0xf9:      mnemonic("LD"); arg_R(B0); arg_r(OPH); bytes(2);      break;
368         case 0xfa:      mnemonic("DJNZ"); arg_r(OPH); arg_RA; bytes(2);         break;
369         case 0xfb:      mnemonic("JR"); arg_cc; arg_RA; bytes(2);            break;
370         case 0xfc:      mnemonic("LD"); arg_r(OPH); arg_IM(B0); bytes(2);      break;
371         case 0xfd:      mnemonic("JP"); arg_cc; arg_DA; bytes(3);            break;
372         case 0xfe:      mnemonic("INC"); arg_r(OPH);                     break;
373         case 0xff:      mnemonic("NOP");                              break;
374      }
375   }
376
377   return (oprom - startrom) | flags | DASMFLAG_SUPPORTED;
378}
src/mess/mess.mak
r5544r5545
124124CPUS += TMS0980
125125CPUS += I4004
126126CPUS += SUPERFX
127CPUS += Z8
127128
128129
129130
src/mess/drivers/jtc.c
r5544r5545
77****************************************************************************/
88
99#include "driver.h"
10#include "cpu/z80/z80.h"
10#include "cpu/z8/z8.h"
1111
1212static ADDRESS_MAP_START( jtc_mem, ADDRESS_SPACE_PROGRAM, 8 )
1313   ADDRESS_MAP_UNMAP_HIGH
14   AM_RANGE(0x0000, 0x07ff) AM_ROM
1514ADDRESS_MAP_END
1615
1716static ADDRESS_MAP_START( jtc_io, ADDRESS_SPACE_IO, 8)
r5544r5545
3938
4039static MACHINE_DRIVER_START( jtc )
4140    /* basic machine hardware */
42    MDRV_CPU_ADD("maincpu",Z80, XTAL_4MHz) // WRONG CPU! really a U8830D (Zilog Z8601), needs a new CPU core
41    MDRV_CPU_ADD("maincpu", UB8830D, XTAL_8MHz)
4342    MDRV_CPU_PROGRAM_MAP(jtc_mem)
4443    MDRV_CPU_IO_MAP(jtc_io)   
4544

Previous 15994 Revisions Next


© 1998-2018 The MESS Team