Previous 15994 Revisions Next

r2857 Monday 16th June, 2008 at 18:48:13 UTC by Wilbert Pol
Renamed "Nintendo Z80GB" cpu core to "Sharp LR35902".
[src/emu]cpuexec.h cpuintrf.c
[src/emu/cpu]cpu.mak z80gb
[src/emu/cpu/lr35902]lr35902.c* lr35902.h* lr35902d.c* z80gb.c z80gb.h z80gbd.c
[src/mame]mame.mak
[src/mess]mess.mak
[src/mess/drivers]gb.c
[src/mess/machine]gb.c
[src/mess/video]gb.c

src/mame/mame.mak
r2856r2857
203203CPUS += SC61860
204204CPUS += TX0_64KW
205205CPUS += TX0_8KW
206CPUS += Z80GB
206CPUS += LR35902
207207CPUS += TMS7000
208208CPUS += TMS7000_EXL
209209CPUS += SM8500
src/emu/cpu/cpu.mak
r2856r2857
16641664
16651665
16661666#-------------------------------------------------
1667# Game Boy Z-80
1667# Sharp LR35902 (Game Boy CPU)
16681668#-------------------------------------------------
16691669
1670CPUDEFS += -DHAS_Z80GB=$(if $(filter Z80GB,$(CPUS)),1,0)
1670CPUDEFS += -DHAS_LR35902=$(if $(filter LR35902,$(CPUS)),1,0)
16711671
1672ifneq ($(filter Z80GB,$(CPUS)),)
1673OBJDIRS += $(CPUOBJ)/z80gb
1674CPUOBJS += $(CPUOBJ)/z80gb/z80gb.o
1675DBGOBJS += $(CPUOBJ)/z80gb/z80gbd.o
1672ifneq ($(filter LR35902,$(CPUS)),)
1673OBJDIRS += $(CPUOBJ)/lr35902
1674CPUOBJS += $(CPUOBJ)/lr35902/lr35902.o
1675DBGOBJS += $(CPUOBJ)/lr35902/lr35902d.o
16761676endif
16771677
1678$(CPUOBJ)/z80gb/z80gb.o:   $(CPUSRC)/z80gb/z80gb.c \
1679                     $(CPUSRC)/z80gb/z80gb.h \
1680                     $(CPUSRC)/z80gb/opc_cb.h \
1681                     $(CPUSRC)/z80gb/opc_main.h
1678$(CPUOBJ)/lr35902/lr35902.o:   $(CPUSRC)/lr35902/lr35902.c \
1679                        $(CPUSRC)/lr35902/lr35902.h \
1680                        $(CPUSRC)/lr35902/opc_cb.h \
1681                        $(CPUSRC)/lr35902/opc_main.h
16821682
16831683
16841684
src/emu/cpu/lr35902/lr35902.c
r0r2857
1/*************************************************************/
2/**                                                         **/
3/**                        lr35902.c                        **/
4/**                                                         **/
5/** This file contains implementation for the GameBoy CPU.  **/
6/** See lr35902.h for the relevant definitions. Please, note**/
7/** that this code can not be used to emulate a generic Z80 **/
8/** because the GameBoy version of it differs from Z80 in   **/
9/** many ways.                                              **/
10/**                                                         **/
11/** Orginal cpu code (PlayBoy)  Carsten Sorensen    1998    **/
12/** MESS modifications          Hans de Goede       1998    **/
13/** Adapted to new cpuintrf     Juergen Buchmueller 2000    **/
14/** Adapted to new cpuintrf     Anthony Kruize      2002    **/
15/** Changed reset function to                               **/
16/** reset all registers instead                             **/
17/** of just AF.                            Wilbert Pol 2004 **/
18/**                                                         **/
19/** 1.1:                                                    **/
20/**   Removed dependency on the mess gameboy driver         **/
21/**                                                         **/
22/** 1.2:                                                    **/
23/**   Fixed cycle count for taking an interrupt             **/
24/**   Fixed cycle count for BIT X,(HL) instructions         **/
25/**   Fixed flags in RRCA instruction                       **/
26/**   Fixed DAA instruction                                 **/
27/**   Fixed flags in ADD SP,n8 instruction                  **/
28/**   Fixed flags in LD HL,SP+n8 instruction                **/
29/**                                                         **/
30/** 1.3:                                                    **/
31/**   Improved triggering of the HALT bug                   **/
32/**   Added 4 cycle penalty when leaving HALT state for     **/
33/**   newer versions of the cpu core                        **/
34/**                                                         **/
35/** 1.4:                                                    **/
36/**   Split fetch and execute cycles.                       **/
37/**                                                         **/
38/*************************************************************/
39#include "debugger.h"
40#include "lr35902.h"
41
42#define FLAG_Z   0x80
43#define FLAG_N  0x40
44#define FLAG_H  0x20
45#define FLAG_C  0x10
46
47#define CYCLES_PASSED(X)      lr35902_ICount -= ((X) / (Regs.w.gb_speed));   \
48               if ( Regs.w.timer_fired_func ) {         \
49                  Regs.w.timer_fired_func( X );      \
50               }
51
52typedef struct {
53   UINT16 AF;
54   UINT16 BC;
55   UINT16 DE;
56   UINT16 HL;
57
58   UINT16 SP;
59   UINT16 PC;
60   /* Interrupt related */
61   UINT8   IE;
62   UINT8   IF;
63   int   irq_state;
64   int   ei_delay;
65   int   (*irq_callback)(int irqline);
66   /* Timer stuff */
67   void   (*timer_fired_func)(int cycles);
68   /* Fetch & execute related */
69   int      execution_state;
70   UINT8   op;
71   /* Others */
72   int gb_speed;
73   int gb_speed_change_pending;
74   int enable;
75   int doHALTbug;
76   int haltIFstatus;
77   UINT8   features;
78   const LR35902_CONFIG *config;
79} lr35902_16BitRegs;
80
81#ifdef LSB_FIRST
82typedef struct {
83   UINT8 F;
84   UINT8 A;
85   UINT8 C;
86   UINT8 B;
87   UINT8 E;
88   UINT8 D;
89   UINT8 L;
90   UINT8 H;
91} lr35902_8BitRegs;
92#else
93typedef struct {
94   UINT8 A;
95   UINT8 F;
96   UINT8 B;
97   UINT8 C;
98   UINT8 D;
99   UINT8 E;
100   UINT8 H;
101   UINT8 L;
102} lr35902_8BitRegs;
103#endif
104
105typedef union {
106   lr35902_16BitRegs w;
107   lr35902_8BitRegs b;
108} lr35902_regs;
109
110typedef int (*OpcodeEmulator) (void);
111
112static lr35902_regs Regs;
113
114#define IME     0x01
115#define HALTED   0x02
116
117/****************************************************************************/
118/* Memory functions                                                         */
119/****************************************************************************/
120
121#define mem_ReadByte(A)      ((UINT8)program_read_byte_8le(A))
122#define mem_WriteByte(A,V)   (program_write_byte_8le(A,V))
123
124INLINE UINT16 mem_ReadWord (UINT32 address)
125{
126   UINT16 value = (UINT16) mem_ReadByte ((address + 1) & 0xffff) << 8;
127   value |= mem_ReadByte (address);
128   return value;
129}
130
131INLINE void mem_WriteWord (UINT32 address, UINT16 value)
132{
133   mem_WriteByte (address, value & 0xFF);
134   mem_WriteByte ((address + 1) & 0xffff, value >> 8);
135}
136
137/* Nr of cycles to run */
138static int lr35902_ICount;
139
140static const int Cycles[256] =
141{
142    4,12, 8, 8, 4, 4, 8, 4,20, 8, 8, 8, 4, 4, 8, 4,
143    4,12, 8, 8, 4, 4, 8, 4,12, 8, 8, 8, 4, 4, 8, 4,
144    8,12, 8, 8, 4, 4, 8, 4, 8, 8, 8, 8, 4, 4, 8, 4,
145    8,12, 8, 8,12,12,12, 4, 8, 8, 8, 8, 4, 4, 8, 4,
146    4, 4, 4, 4, 4, 4, 8, 4, 4, 4, 4, 4, 4, 4, 8, 4,
147    4, 4, 4, 4, 4, 4, 8, 4, 4, 4, 4, 4, 4, 4, 8, 4,
148    4, 4, 4, 4, 4, 4, 8, 4, 4, 4, 4, 4, 4, 4, 8, 4,
149    8, 8, 8, 8, 8, 8, 4, 8, 4, 4, 4, 4, 4, 4, 8, 4,
150    4, 4, 4, 4, 4, 4, 8, 4, 4, 4, 4, 4, 4, 4, 8, 4,
151    4, 4, 4, 4, 4, 4, 8, 4, 4, 4, 4, 4, 4, 4, 8, 4,
152    4, 4, 4, 4, 4, 4, 8, 4, 4, 4, 4, 4, 4, 4, 8, 4,
153    4, 4, 4, 4, 4, 4, 8, 4, 4, 4, 4, 4, 4, 4, 8, 4,
154    8,12,12,16,12,16, 8,16, 8,16,12, 0,12,24, 8,16,
155    8,12,12, 4,12,16, 8,16, 8,16,12, 4,12, 4, 8,16,
156   12,12, 8, 4, 4,16, 8,16,16, 4,16, 4, 4, 4, 8,16,
157   12,12, 8, 4, 4,16, 8,16,12, 8,16, 4, 4, 4, 8,16
158};
159
160static const int CyclesCB[256] =
161{
162    8, 8, 8, 8, 8, 8,16, 8, 8, 8, 8, 8, 8, 8,16, 8,
163    8, 8, 8, 8, 8, 8,16, 8, 8, 8, 8, 8, 8, 8,16, 8,
164    8, 8, 8, 8, 8, 8,16, 8, 8, 8, 8, 8, 8, 8,16, 8,
165    8, 8, 8, 8, 8, 8,16, 8, 8, 8, 8, 8, 8, 8,16, 8,
166    8, 8, 8, 8, 8, 8,12, 8, 8, 8, 8, 8, 8, 8,12, 8,
167    8, 8, 8, 8, 8, 8,12, 8, 8, 8, 8, 8, 8, 8,12, 8,
168    8, 8, 8, 8, 8, 8,12, 8, 8, 8, 8, 8, 8, 8,12, 8,
169    8, 8, 8, 8, 8, 8,12, 8, 8, 8, 8, 8, 8, 8,12, 8,
170    8, 8, 8, 8, 8, 8,16, 8, 8, 8, 8, 8, 8, 8,16, 8,
171    8, 8, 8, 8, 8, 8,16, 8, 8, 8, 8, 8, 8, 8,16, 8,
172    8, 8, 8, 8, 8, 8,16, 8, 8, 8, 8, 8, 8, 8,16, 8,
173    8, 8, 8, 8, 8, 8,16, 8, 8, 8, 8, 8, 8, 8,16, 8,
174    8, 8, 8, 8, 8, 8,16, 8, 8, 8, 8, 8, 8, 8,16, 8,
175    8, 8, 8, 8, 8, 8,16, 8, 8, 8, 8, 8, 8, 8,16, 8,
176    8, 8, 8, 8, 8, 8,16, 8, 8, 8, 8, 8, 8, 8,16, 8,
177    8, 8, 8, 8, 8, 8,16, 8, 8, 8, 8, 8, 8, 8,16, 8
178};
179
180static void lr35902_init(int index, int clock, const void *config, int (*irqcallback)(int))
181{
182   Regs.w.config = (const LR35902_CONFIG *) config;
183   Regs.w.irq_callback = irqcallback;
184}
185
186/*** Reset lr353902 registers: ******************************/
187/*** This function can be used to reset the register      ***/
188/*** file before starting execution with lr35902_execute()***/
189/*** It sets the registers to their initial values.       ***/
190/************************************************************/
191static void lr35902_reset(void)
192{
193   Regs.w.AF = 0x0000;
194   Regs.w.BC = 0x0000;
195   Regs.w.DE = 0x0000;
196   Regs.w.HL = 0x0000;
197   Regs.w.SP = 0x0000;
198   Regs.w.PC = 0x0000;
199   Regs.w.timer_fired_func = NULL;
200   Regs.w.features = LR35902_FEATURE_HALT_BUG;
201   if (Regs.w.config)
202   {
203      if ( Regs.w.config->regs ) {
204         Regs.w.AF = Regs.w.config->regs[0];
205         Regs.w.BC = Regs.w.config->regs[1];
206         Regs.w.DE = Regs.w.config->regs[2];
207         Regs.w.HL = Regs.w.config->regs[3];
208         Regs.w.SP = Regs.w.config->regs[4];
209         Regs.w.PC = Regs.w.config->regs[5];
210      }
211      Regs.w.timer_fired_func = Regs.w.config->timer_fired_func;
212      Regs.w.features = Regs.w.config->features;
213   }
214   Regs.w.enable = 0;
215   Regs.w.IE = 0;
216   Regs.w.IF = 0;
217
218   Regs.w.execution_state = 0;
219   Regs.w.doHALTbug = 0;
220   Regs.w.ei_delay = 0;
221   Regs.w.gb_speed_change_pending = 0;
222   Regs.w.gb_speed = 1;
223}
224
225INLINE void lr35902_ProcessInterrupts (void)
226{
227   UINT8 irq = Regs.w.IE & Regs.w.IF;
228
229   /* Interrupts should be taken after the first instruction after an EI instruction */
230   if (Regs.w.ei_delay) {
231      Regs.w.ei_delay = 0;
232      return;
233   }
234
235   /*
236       logerror("Attempting to process LR35902 Interrupt IRQ $%02X\n", irq);
237       logerror("Attempting to process LR35902 Interrupt IE $%02X\n", Regs.w.IE);
238       logerror("Attempting to process LR35902 Interrupt IF $%02X\n", Regs.w.IF);
239    */
240   if (irq)
241   {
242      int irqline = 0;
243      /*
244           logerror("LR35902 Interrupt IRQ $%02X\n", irq);
245        */
246
247      for( ; irqline < 5; irqline++ )
248      {
249         if( irq & (1<<irqline) )
250         {
251            if (Regs.w.enable & HALTED)
252            {
253               Regs.w.enable &= ~HALTED;
254               Regs.w.IF &= ~(1 << irqline);
255               Regs.w.PC++;
256               if ( Regs.w.features & LR35902_FEATURE_HALT_BUG ) {
257                  if ( ! Regs.w.enable & IME ) {
258                     /* Old cpu core (dmg/mgb/sgb) */
259                     /* check if the HALT bug should be performed */
260                     if ( Regs.w.haltIFstatus ) {
261                        Regs.w.doHALTbug = 1;
262                     }
263                  }
264               } else {
265                  /* New cpu core (cgb/agb/ags) */
266                  /* Adjust for internal syncing with video core */
267                  /* This feature needs more investigation */
268                  if ( irqline < 2 ) {
269                     CYCLES_PASSED( 4 );
270                  }
271               }
272            }
273            if ( Regs.w.enable & IME ) {
274               if ( Regs.w.irq_callback )
275                  (*Regs.w.irq_callback)(irqline);
276               Regs.w.enable &= ~IME;
277               Regs.w.IF &= ~(1 << irqline);
278               CYCLES_PASSED( 20 );
279               Regs.w.SP -= 2;
280               mem_WriteWord (Regs.w.SP, Regs.w.PC);
281               Regs.w.PC = 0x40 + irqline * 8;
282               /*logerror("LR35902 Interrupt PC $%04X\n", Regs.w.PC );*/
283               return;
284            }
285         }
286      }
287   }
288}
289
290/************************************************************/
291/*** Execute lr35902 code for cycles cycles, return nr of ***/
292/*** cycles actually executed.                            ***/
293/************************************************************/
294static int lr35902_execute (int cycles)
295{
296   lr35902_ICount = cycles;
297
298   do
299   {
300      if ( Regs.w.execution_state ) {
301         UINT8   x;
302         /* Execute instruction */
303         switch( Regs.w.op ) {
304#include "opc_main.h"
305         }
306      } else {
307         /* Fetch and count cycles */
308         lr35902_ProcessInterrupts ();
309         CALL_DEBUGGER(Regs.w.PC);
310         if ( Regs.w.enable & HALTED ) {
311            CYCLES_PASSED( Cycles[0x76] );
312            Regs.w.execution_state = 1;
313         } else {
314            Regs.w.op = mem_ReadByte (Regs.w.PC++);
315            if ( Regs.w.doHALTbug ) {
316               Regs.w.PC--;
317               Regs.w.doHALTbug = 0;
318            }
319            CYCLES_PASSED( Cycles[Regs.w.op] );
320         }
321      }
322      Regs.w.execution_state ^= 1;
323   } while (lr35902_ICount > 0);
324
325   return cycles - lr35902_ICount;
326}
327
328static void lr35902_burn(int cycles)
329{
330    if( cycles > 0 )
331    {
332        /* NOP takes 4 cycles per instruction */
333        int n = (cycles + 3) / 4;
334        lr35902_ICount -= 4 * n;
335    }
336}
337
338/****************************************************************************/
339/* Set all registers to given values                                        */
340/****************************************************************************/
341static void lr35902_set_context (void *src)
342{
343   if( src )
344      Regs = *(lr35902_regs *)src;
345   change_pc(Regs.w.PC);
346}
347
348/****************************************************************************/
349/* Get all registers in given buffer                                        */
350/****************************************************************************/
351static void lr35902_get_context (void *dst)
352{
353   if( dst )
354      *(lr35902_regs *)dst = Regs;
355}
356
357
358
359static void lr35902_set_irq_line (int irqline, int state)
360{
361   /*logerror("setting irq line 0x%02x state 0x%08x\n", irqline, state);*/
362   //if( Regs.w.irq_state == state )
363   //  return;
364
365   Regs.w.irq_state = state;
366   if( state == ASSERT_LINE )
367   {
368
369      Regs.w.IF |= (0x01 << irqline);
370      /*logerror("LR35902 assert irq line %d ($%02X)\n", irqline, Regs.w.IF);*/
371
372   }
373   else
374   {
375
376      Regs.w.IF &= ~(0x01 << irqline);
377      /*logerror("LR35902 clear irq line %d ($%02X)\n", irqline, Regs.w.IF);*/
378
379     }
380}
381
382/*static void lr35902_clear_pending_interrupts (void)
383{
384    Regs.w.IF = 0;
385}*/
386
387static void lr35902_set_info(UINT32 state, cpuinfo *info)
388{
389   switch (state)
390   {
391   /* --- the following bits of info are set as 64-bit signed integers --- */
392   case CPUINFO_INT_INPUT_STATE + 0:
393   case CPUINFO_INT_INPUT_STATE + 1:
394   case CPUINFO_INT_INPUT_STATE + 2:
395   case CPUINFO_INT_INPUT_STATE + 3:
396   case CPUINFO_INT_INPUT_STATE + 4:         lr35902_set_irq_line(state-CPUINFO_INT_INPUT_STATE, info->i); break;
397
398   case CPUINFO_INT_SP:                  Regs.w.SP = info->i;                  break;
399   case CPUINFO_INT_PC:                  Regs.w.PC = info->i; change_pc(Regs.w.PC);   break;
400
401   case CPUINFO_INT_REGISTER + LR35902_PC:      Regs.w.PC = info->i; change_pc(Regs.w.PC);   break;
402   case CPUINFO_INT_REGISTER + LR35902_SP:      Regs.w.SP = info->i;                  break;
403   case CPUINFO_INT_REGISTER + LR35902_AF:      Regs.w.AF = info->i;                  break;
404   case CPUINFO_INT_REGISTER + LR35902_BC:      Regs.w.BC = info->i;                  break;
405   case CPUINFO_INT_REGISTER + LR35902_DE:      Regs.w.DE = info->i;                  break;
406   case CPUINFO_INT_REGISTER + LR35902_HL:      Regs.w.HL = info->i;                  break;
407   case CPUINFO_INT_REGISTER + LR35902_IE:      Regs.w.IE = info->i; break;
408   case CPUINFO_INT_REGISTER + LR35902_IF:      Regs.w.IF = info->i; break;
409   case CPUINFO_INT_REGISTER + LR35902_SPEED:   Regs.w.gb_speed_change_pending = info->i & 0x01; break;
410   }
411}
412
413void lr35902_get_info(UINT32 state, cpuinfo *info)
414{
415   switch (state)
416   {
417   /* --- the following bits of info are returned as 64-bit signed integers --- */
418   case CPUINFO_INT_CONTEXT_SIZE:               info->i = sizeof(Regs);               break;
419   case CPUINFO_INT_INPUT_LINES:                  info->i = 5;                     break;
420   case CPUINFO_INT_DEFAULT_IRQ_VECTOR:         info->i = 0xff;                     break;
421   case CPUINFO_INT_ENDIANNESS:               info->i = CPU_IS_LE;               break;
422   case CPUINFO_INT_CLOCK_MULTIPLIER:            info->i = 1;                     break;
423   case CPUINFO_INT_CLOCK_DIVIDER:               info->i = 1;                     break;
424   case CPUINFO_INT_MIN_INSTRUCTION_BYTES:         info->i = 1;                     break;
425   case CPUINFO_INT_MAX_INSTRUCTION_BYTES:         info->i = 4;                     break;
426   case CPUINFO_INT_MIN_CYCLES:               info->i = 1;   /* right? */         break;
427   case CPUINFO_INT_MAX_CYCLES:               info->i = 16;   /* right? */         break;
428
429   case CPUINFO_INT_DATABUS_WIDTH + ADDRESS_SPACE_PROGRAM:   info->i = 8;               break;
430   case CPUINFO_INT_ADDRBUS_WIDTH + ADDRESS_SPACE_PROGRAM: info->i = 16;               break;
431   case CPUINFO_INT_ADDRBUS_SHIFT + ADDRESS_SPACE_PROGRAM: info->i = 0;               break;
432   case CPUINFO_INT_DATABUS_WIDTH + ADDRESS_SPACE_DATA:   info->i = 0;               break;
433   case CPUINFO_INT_ADDRBUS_WIDTH + ADDRESS_SPACE_DATA:    info->i = 0;               break;
434   case CPUINFO_INT_ADDRBUS_SHIFT + ADDRESS_SPACE_DATA:    info->i = 0;               break;
435   case CPUINFO_INT_DATABUS_WIDTH + ADDRESS_SPACE_IO:      info->i = 8;               break;
436   case CPUINFO_INT_ADDRBUS_WIDTH + ADDRESS_SPACE_IO:       info->i = 16;               break;
437   case CPUINFO_INT_ADDRBUS_SHIFT + ADDRESS_SPACE_IO:       info->i = 0;               break;
438
439   case CPUINFO_INT_SP:                     info->i = Regs.w.SP;               break;
440   case CPUINFO_INT_PC:                     info->i = Regs.w.PC;               break;
441   case CPUINFO_INT_PREVIOUSPC:               info->i = 0;   /* TODO??? */         break;
442
443   case CPUINFO_INT_INPUT_STATE + 0:
444   case CPUINFO_INT_INPUT_STATE + 1:
445   case CPUINFO_INT_INPUT_STATE + 2:
446   case CPUINFO_INT_INPUT_STATE + 3:
447   case CPUINFO_INT_INPUT_STATE + 4:               info->i = Regs.w.IF & (1 << (state-CPUINFO_INT_INPUT_STATE)); break;
448
449   case CPUINFO_INT_REGISTER + LR35902_PC:         info->i = Regs.w.PC;               break;
450   case CPUINFO_INT_REGISTER + LR35902_SP:         info->i = Regs.w.SP;               break;
451   case CPUINFO_INT_REGISTER + LR35902_AF:         info->i = Regs.w.AF;               break;
452   case CPUINFO_INT_REGISTER + LR35902_BC:         info->i = Regs.w.BC;               break;
453   case CPUINFO_INT_REGISTER + LR35902_DE:         info->i = Regs.w.DE;               break;
454   case CPUINFO_INT_REGISTER + LR35902_HL:         info->i = Regs.w.HL;               break;
455   case CPUINFO_INT_REGISTER + LR35902_IE:         info->i = Regs.w.IE;               break;
456   case CPUINFO_INT_REGISTER + LR35902_IF:         info->i = Regs.w.IF;               break;
457   case CPUINFO_INT_REGISTER + LR35902_SPEED:      info->i = 0x7E | ( ( Regs.w.gb_speed - 1 ) << 7 ) | Regs.w.gb_speed_change_pending; break;
458
459   /* --- the following bits of info are returned as pointers to data or functions --- */
460   case CPUINFO_PTR_SET_INFO:                  info->setinfo = lr35902_set_info;      break;
461   case CPUINFO_PTR_GET_CONTEXT:               info->getcontext = lr35902_get_context;   break;
462   case CPUINFO_PTR_SET_CONTEXT:               info->setcontext = lr35902_set_context;   break;
463   case CPUINFO_PTR_INIT:                     info->init = lr35902_init;            break;
464   case CPUINFO_PTR_RESET:                     info->reset = lr35902_reset;         break;
465   case CPUINFO_PTR_EXECUTE:                  info->execute = lr35902_execute;      break;
466   case CPUINFO_PTR_BURN:                     info->burn = lr35902_burn;            break;
467
468#ifdef ENABLE_DEBUGGER
469   case CPUINFO_PTR_DISASSEMBLE:               info->disassemble = lr35902_dasm;      break;
470#endif
471   case CPUINFO_PTR_INSTRUCTION_COUNTER:         info->icount = &lr35902_ICount;         break;
472
473   /* --- the following bits of info are returned as NULL-terminated strings --- */
474   case CPUINFO_STR_NAME:                      strcpy(info->s, "LR35902"); break;
475   case CPUINFO_STR_CORE_FAMILY:                strcpy(info->s, "Sharp LR35902"); break;
476   case CPUINFO_STR_CORE_VERSION:                strcpy(info->s, "1.4"); break;
477   case CPUINFO_STR_CORE_FILE:                strcpy(info->s, __FILE__); break;
478   case CPUINFO_STR_CORE_CREDITS:                strcpy(info->s, "Copyright The MESS Team."); break;
479
480   case CPUINFO_STR_FLAGS:
481      sprintf(info->s, "%c%c%c%c%c%c%c%c",
482         Regs.b.F & 0x80 ? 'Z':'.',
483         Regs.b.F & 0x40 ? 'N':'.',
484         Regs.b.F & 0x20 ? 'H':'.',
485         Regs.b.F & 0x10 ? 'C':'.',
486         Regs.b.F & 0x08 ? '3':'.',
487         Regs.b.F & 0x04 ? '2':'.',
488         Regs.b.F & 0x02 ? '1':'.',
489         Regs.b.F & 0x01 ? '0':'.');
490      break;
491
492   case CPUINFO_STR_REGISTER + LR35902_PC: sprintf(info->s, "PC:%04X", Regs.w.PC); break;
493   case CPUINFO_STR_REGISTER + LR35902_SP: sprintf(info->s, "SP:%04X", Regs.w.SP); break;
494   case CPUINFO_STR_REGISTER + LR35902_AF: sprintf(info->s, "AF:%04X", Regs.w.AF); break;
495   case CPUINFO_STR_REGISTER + LR35902_BC: sprintf(info->s, "BC:%04X", Regs.w.BC); break;
496   case CPUINFO_STR_REGISTER + LR35902_DE: sprintf(info->s, "DE:%04X", Regs.w.DE); break;
497   case CPUINFO_STR_REGISTER + LR35902_HL: sprintf(info->s, "HL:%04X", Regs.w.HL); break;
498   case CPUINFO_STR_REGISTER + LR35902_IRQ_STATE: sprintf(info->s, "IRQ:%X", Regs.w.enable & IME ); break;
499   case CPUINFO_STR_REGISTER + LR35902_IE: sprintf(info->s, "IE:%02X", Regs.w.IE); break;
500   case CPUINFO_STR_REGISTER + LR35902_IF: sprintf(info->s, "IF:%02X", Regs.w.IF); break;
501   }
502}
src/emu/cpu/lr35902/lr35902d.c
r0r2857
1/*****************************************************************************
2 *
3 *   lr35902d.c
4 *   Portable Sharp LR35902 disassembler
5 *
6 *   Copyright The MESS Team.
7 *
8 *   - This source code is released as freeware for non-commercial purposes.
9 *   - You are free to use and redistribute this code in modified or
10 *     unmodified form, provided you list me in the credits.
11 *   - If you modify this source code, you must add a notice to each modified
12 *     source file that it has been changed.  If you're a nice person, you
13 *     will clearly mark each change too.  :)
14 *   - If you wish to use this for commercial purposes, please contact me at
15 *     pullmoll@t-online.de
16 *   - The author of this copywritten work reserves the right to change the
17 *     terms of its usage and license at any time, including retroactively
18 *   - This entire notice must remain in the source code.
19 *
20 *****************************************************************************/
21
22#include "debugger.h"
23#include "lr35902.h"
24
25enum e_mnemonics
26{
27   zADC,  zADD,  zAND,  zBIT,   zCALL, zCCF,  zCP,
28   zCPL,  zDAA,  zDB,    zDEC,   zDI,   zEI,   zHLT,
29   zIN,   zINC,  zJP,    zJR,   zLD,   zNOP,  zOR,
30   zPOP,  zPUSH, zRES,  zRET,   zRETI, zRL,   zRLA,
31   zRLC,  zRLCA, zRR,    zRRA,   zRRC,  zRRCA, zRST,
32   zSBC,  zSCF,  zSET,  zSLA,   zSLL,  zSRA,  zSRL,
33   zSTOP, zSUB,  zXOR,  zSWAP
34};
35
36static const char *const s_mnemonic[] =
37{
38   "adc", "add", "and", "bit", "call","ccf", "cp",
39   "cpl", "daa", "db",  "dec", "di",  "ei",  "halt",
40   "in",  "inc", "jp",  "jr",  "ld",  "nop", "or",
41   "pop", "push","res", "ret", "reti","rl",  "rla",
42   "rlc", "rlca","rr",  "rra", "rrc", "rrca","rst",
43   "sbc", "scf", "set", "sla", "sll", "sra", "srl",
44   "stop","sub", "xor", "swap"
45};
46
47#define _OVER DASMFLAG_STEP_OVER
48#define _OUT  DASMFLAG_STEP_OUT
49
50static const UINT32 s_flags[] = {
51   0    ,0    ,0    ,0    ,_OVER,0    ,0    ,
52   0    ,0    ,0    ,0    ,0    ,0    ,_OVER,
53   0    ,0    ,0    ,0    ,0    ,0    ,0    ,
54   0    ,0    ,0    ,_OUT ,_OUT ,0    ,0    ,
55   0    ,0    ,0    ,0    ,0    ,0    ,_OVER,
56   0    ,0    ,0    ,0    ,0    ,0    ,0    ,
57   _OVER,0    ,0    ,0
58};
59
60typedef struct
61{
62   UINT8   mnemonic;
63   const char *arguments;
64}   lr35902dasm;
65
66static const lr35902dasm mnemonic_cb[256] = {
67   {zRLC,"b"},     {zRLC,"c"},     {zRLC,"d"},     {zRLC,"e"},
68   {zRLC,"h"},     {zRLC,"l"},     {zRLC,"(hl)"},  {zRLC,"a"},
69   {zRRC,"b"},     {zRRC,"c"},     {zRRC,"d"},     {zRRC,"e"},
70   {zRRC,"h"},     {zRRC,"l"},     {zRRC,"(hl)"},  {zRRC,"a"},
71   {zRL,"b"},      {zRL,"c"},      {zRL,"d"},      {zRL,"e"},
72   {zRL,"h"},      {zRL,"l"},      {zRL,"(hl)"},   {zRL,"a"},
73   {zRR,"b"},      {zRR,"c"},      {zRR,"d"},      {zRR,"e"},
74   {zRR,"h"},      {zRR,"l"},      {zRR,"(hl)"},   {zRR,"a"},
75   {zSLA,"b"},     {zSLA,"c"},     {zSLA,"d"},     {zSLA,"e"},
76   {zSLA,"h"},     {zSLA,"l"},     {zSLA,"(hl)"},  {zSLA,"a"},
77   {zSRA,"b"},     {zSRA,"c"},     {zSRA,"d"},     {zSRA,"e"},
78   {zSRA,"h"},     {zSRA,"l"},     {zSRA,"(hl)"},  {zSRA,"a"},
79   {zSWAP,"b"},    {zSWAP,"c"},    {zSWAP,"d"},    {zSWAP,"e"},
80   {zSWAP,"h"},    {zSWAP,"l"},    {zSWAP,"(hl)"}, {zSWAP,"a"},
81   {zSRL,"b"},     {zSRL,"c"},     {zSRL,"d"},     {zSRL,"e"},
82   {zSRL,"h"},     {zSRL,"l"},     {zSRL,"(hl)"},  {zSRL,"a"},
83   {zBIT,"0,b"},   {zBIT,"0,c"},   {zBIT,"0,d"},   {zBIT,"0,e"},
84   {zBIT,"0,h"},   {zBIT,"0,l"},   {zBIT,"0,(hl)"},{zBIT,"0,a"},
85   {zBIT,"1,b"},   {zBIT,"1,c"},   {zBIT,"1,d"},   {zBIT,"1,e"},
86   {zBIT,"1,h"},   {zBIT,"1,l"},   {zBIT,"1,(hl)"},{zBIT,"1,a"},
87   {zBIT,"2,b"},   {zBIT,"2,c"},   {zBIT,"2,d"},   {zBIT,"2,e"},
88   {zBIT,"2,h"},   {zBIT,"2,l"},   {zBIT,"2,(hl)"},{zBIT,"2,a"},
89   {zBIT,"3,b"},   {zBIT,"3,c"},   {zBIT,"3,d"},   {zBIT,"3,e"},
90   {zBIT,"3,h"},   {zBIT,"3,l"},   {zBIT,"3,(hl)"},{zBIT,"3,a"},
91   {zBIT,"4,b"},   {zBIT,"4,c"},   {zBIT,"4,d"},   {zBIT,"4,e"},
92   {zBIT,"4,h"},   {zBIT,"4,l"},   {zBIT,"4,(hl)"},{zBIT,"4,a"},
93   {zBIT,"5,b"},   {zBIT,"5,c"},   {zBIT,"5,d"},   {zBIT,"5,e"},
94   {zBIT,"5,h"},   {zBIT,"5,l"},   {zBIT,"5,(hl)"},{zBIT,"5,a"},
95   {zBIT,"6,b"},   {zBIT,"6,c"},   {zBIT,"6,d"},   {zBIT,"6,e"},
96   {zBIT,"6,h"},   {zBIT,"6,l"},   {zBIT,"6,(hl)"},{zBIT,"6,a"},
97   {zBIT,"7,b"},   {zBIT,"7,c"},   {zBIT,"7,d"},   {zBIT,"7,e"},
98   {zBIT,"7,h"},   {zBIT,"7,l"},   {zBIT,"7,(hl)"},{zBIT,"7,a"},
99   {zRES,"0,b"},   {zRES,"0,c"},   {zRES,"0,d"},   {zRES,"0,e"},
100   {zRES,"0,h"},   {zRES,"0,l"},   {zRES,"0,(hl)"},{zRES,"0,a"},
101   {zRES,"1,b"},   {zRES,"1,c"},   {zRES,"1,d"},   {zRES,"1,e"},
102   {zRES,"1,h"},   {zRES,"1,l"},   {zRES,"1,(hl)"},{zRES,"1,a"},
103   {zRES,"2,b"},   {zRES,"2,c"},   {zRES,"2,d"},   {zRES,"2,e"},
104   {zRES,"2,h"},   {zRES,"2,l"},   {zRES,"2,(hl)"},{zRES,"2,a"},
105   {zRES,"3,b"},   {zRES,"3,c"},   {zRES,"3,d"},   {zRES,"3,e"},
106   {zRES,"3,h"},   {zRES,"3,l"},   {zRES,"3,(hl)"},{zRES,"3,a"},
107   {zRES,"4,b"},   {zRES,"4,c"},   {zRES,"4,d"},   {zRES,"4,e"},
108   {zRES,"4,h"},   {zRES,"4,l"},   {zRES,"4,(hl)"},{zRES,"4,a"},
109   {zRES,"5,b"},   {zRES,"5,c"},   {zRES,"5,d"},   {zRES,"5,e"},
110   {zRES,"5,h"},   {zRES,"5,l"},   {zRES,"5,(hl)"},{zRES,"5,a"},
111   {zRES,"6,b"},   {zRES,"6,c"},   {zRES,"6,d"},   {zRES,"6,e"},
112   {zRES,"6,h"},   {zRES,"6,l"},   {zRES,"6,(hl)"},{zRES,"6,a"},
113   {zRES,"7,b"},   {zRES,"7,c"},   {zRES,"7,d"},   {zRES,"7,e"},
114   {zRES,"7,h"},   {zRES,"7,l"},   {zRES,"7,(hl)"},{zRES,"7,a"},
115   {zSET,"0,b"},   {zSET,"0,c"},   {zSET,"0,d"},   {zSET,"0,e"},
116   {zSET,"0,h"},   {zSET,"0,l"},   {zSET,"0,(hl)"},{zSET,"0,a"},
117   {zSET,"1,b"},   {zSET,"1,c"},   {zSET,"1,d"},   {zSET,"1,e"},
118   {zSET,"1,h"},   {zSET,"1,l"},   {zSET,"1,(hl)"},{zSET,"1,a"},
119   {zSET,"2,b"},   {zSET,"2,c"},   {zSET,"2,d"},   {zSET,"2,e"},
120   {zSET,"2,h"},   {zSET,"2,l"},   {zSET,"2,(hl)"},{zSET,"2,a"},
121   {zSET,"3,b"},   {zSET,"3,c"},   {zSET,"3,d"},   {zSET,"3,e"},
122   {zSET,"3,h"},   {zSET,"3,l"},   {zSET,"3,(hl)"},{zSET,"3,a"},
123   {zSET,"4,b"},   {zSET,"4,c"},   {zSET,"4,d"},   {zSET,"4,e"},
124   {zSET,"4,h"},   {zSET,"4,l"},   {zSET,"4,(hl)"},{zSET,"4,a"},
125   {zSET,"5,b"},   {zSET,"5,c"},   {zSET,"5,d"},   {zSET,"5,e"},
126   {zSET,"5,h"},   {zSET,"5,l"},   {zSET,"5,(hl)"},{zSET,"5,a"},
127   {zSET,"6,b"},   {zSET,"6,c"},   {zSET,"6,d"},   {zSET,"6,e"},
128   {zSET,"6,h"},   {zSET,"6,l"},   {zSET,"6,(hl)"},{zSET,"6,a"},
129   {zSET,"7,b"},   {zSET,"7,c"},   {zSET,"7,d"},   {zSET,"7,e"},
130   {zSET,"7,h"},   {zSET,"7,l"},   {zSET,"7,(hl)"},{zSET,"7,a"}
131};
132
133static const lr35902dasm mnemonic_main[256]= {
134   {zNOP,0},      {zLD,"bc,N"},   {zLD,"(bc),a"}, {zINC,"bc"},
135   {zINC,"b"},     {zDEC,"b"},     {zLD,"b,B"},    {zRLCA,0},
136   {zLD,"(W),sp"}, {zADD,"hl,bc"}, {zLD,"a,(bc)"}, {zDEC,"bc"},
137   {zINC,"c"},     {zDEC,"c"},     {zLD,"c,B"},    {zRRCA,0},
138   {zSTOP,0},      {zLD,"de,N"},   {zLD,"(de),a"}, {zINC,"de"},
139   {zINC,"d"},     {zDEC,"d"},     {zLD,"d,B"},    {zRLA,0},
140   {zJR,"O"},      {zADD,"hl,de"}, {zLD,"a,(de)"}, {zDEC,"de"},
141   {zINC,"e"},     {zDEC,"e"},     {zLD,"e,B"},    {zRRA,0},
142   {zJR,"nz,O"},   {zLD,"hl,N"},   {zLD,"(hl+),a"},{zINC,"hl"},
143   {zINC,"h"},     {zDEC,"h"},     {zLD,"h,B"},    {zDAA,0},
144   {zJR,"z,O"},    {zADD,"hl,hl"}, {zLD,"a,(hl+)"},{zDEC,"hl"},
145   {zINC,"l"},     {zDEC,"l"},     {zLD,"l,B"},    {zCPL,0},
146   {zJR,"nc,O"},   {zLD,"sp,N"},   {zLD,"(hl-),a"},{zINC,"sp"},
147   {zINC,"(hl)"},  {zDEC,"(hl)"},  {zLD,"(hl),B"}, {zSCF,0},
148   {zJR,"c,O"},    {zADD,"hl,sp"}, {zLD,"a,(hl-)"},{zDEC,"sp"},
149   {zINC,"a"},     {zDEC,"a"},     {zLD,"a,B"},    {zCCF,0},
150   {zLD,"b,b"},    {zLD,"b,c"},    {zLD,"b,d"},    {zLD,"b,e"},
151   {zLD,"b,h"},    {zLD,"b,l"},    {zLD,"b,(hl)"}, {zLD,"b,a"},
152   {zLD,"c,b"},    {zLD,"c,c"},    {zLD,"c,d"},    {zLD,"c,e"},
153   {zLD,"c,h"},    {zLD,"c,l"},    {zLD,"c,(hl)"}, {zLD,"c,a"},
154   {zLD,"d,b"},    {zLD,"d,c"},    {zLD,"d,d"},    {zLD,"d,e"},
155   {zLD,"d,h"},    {zLD,"d,l"},    {zLD,"d,(hl)"}, {zLD,"d,a"},
156   {zLD,"e,b"},    {zLD,"e,c"},    {zLD,"e,d"},    {zLD,"e,e"},
157   {zLD,"e,h"},    {zLD,"e,l"},    {zLD,"e,(hl)"}, {zLD,"e,a"},
158   {zLD,"h,b"},    {zLD,"h,c"},    {zLD,"h,d"},    {zLD,"h,e"},
159   {zLD,"h,h"},    {zLD,"h,l"},    {zLD,"h,(hl)"}, {zLD,"h,a"},
160   {zLD,"l,b"},    {zLD,"l,c"},    {zLD,"l,d"},    {zLD,"l,e"},
161   {zLD,"l,h"},    {zLD,"l,l"},    {zLD,"l,(hl)"}, {zLD,"l,a"},
162   {zLD,"(hl),b"}, {zLD,"(hl),c"}, {zLD,"(hl),d"}, {zLD,"(hl),e"},
163   {zLD,"(hl),h"}, {zLD,"(hl),l"}, {zHLT,0},       {zLD,"(hl),a"},
164   {zLD,"a,b"},    {zLD,"a,c"},    {zLD,"a,d"},    {zLD,"a,e"},
165   {zLD,"a,h"},    {zLD,"a,l"},    {zLD,"a,(hl)"}, {zLD,"a,a"},
166   {zADD,"a,b"},   {zADD,"a,c"},   {zADD,"a,d"},   {zADD,"a,e"},
167   {zADD,"a,h"},   {zADD,"a,l"},   {zADD,"a,(hl)"},{zADD,"a,a"},
168   {zADC,"a,b"},   {zADC,"a,c"},   {zADC,"a,d"},   {zADC,"a,e"},
169   {zADC,"a,h"},   {zADC,"a,l"},   {zADC,"a,(hl)"},{zADC,"a,a"},
170   {zSUB,"b"},     {zSUB,"c"},     {zSUB,"d"},     {zSUB,"e"},
171   {zSUB,"h"},     {zSUB,"l"},     {zSUB,"(hl)"},  {zSUB,"a"},
172   {zSBC,"a,b"},   {zSBC,"a,c"},   {zSBC,"a,d"},   {zSBC,"a,e"},
173   {zSBC,"a,h"},   {zSBC,"a,l"},   {zSBC,"a,(hl)"},{zSBC,"a,a"},
174   {zAND,"b"},     {zAND,"c"},     {zAND,"d"},     {zAND,"e"},
175   {zAND,"h"},     {zAND,"l"},     {zAND,"(hl)"},  {zAND,"a"},
176   {zXOR,"b"},     {zXOR,"c"},     {zXOR,"d"},     {zXOR,"e"},
177   {zXOR,"h"},     {zXOR,"l"},     {zXOR,"(hl)"},  {zXOR,"a"},
178   {zOR,"b"},      {zOR,"c"},      {zOR,"d"},      {zOR,"e"},
179   {zOR,"h"},      {zOR,"l"},      {zOR,"(hl)"},   {zOR,"a"},
180   {zCP,"b"},      {zCP,"c"},      {zCP,"d"},      {zCP,"e"},
181   {zCP,"h"},      {zCP,"l"},      {zCP,"(hl)"},   {zCP,"a"},
182   {zRET,"nz"},    {zPOP,"bc"},    {zJP,"nz,A"},   {zJP,"A"},
183   {zCALL,"nz,A"}, {zPUSH,"bc"},   {zADD,"a,B"},   {zRST,"V"},
184   {zRET,"z"},     {zRET,0},       {zJP,"z,A"},    {zDB,"cb"},
185   {zCALL,"z,A"},  {zCALL,"A"},    {zADC,"a,B"},   {zRST,"V"},
186   {zRET,"nc"},    {zPOP,"de"},    {zJP,"nc,A"},   {zDB,"d3"},
187   {zCALL,"nc,A"}, {zPUSH,"de"},   {zSUB,"B"},     {zRST,"V"},
188   {zRET,"c"},     {zRETI,0},      {zJP,"c,A"},    {zDB,"db"},
189   {zCALL,"c,A"},  {zDB,"dd"},     {zSBC,"a,B"},   {zRST,"V"},
190   {zLD,"(F),a"},  {zPOP,"hl"},    {zLD,"(C),a"},  {zDB,"e3"},
191   {zDB,"e4"},     {zPUSH,"hl"},   {zAND,"B"},     {zRST,"V"},
192   {zADD,"SP,B"},  {zJP,"(hl)"},   {zLD,"(W),a"},  {zDB,"eb"},
193   {zDB,"ec"},     {zDB,"ed"},     {zXOR,"B"},     {zRST,"V"},
194   {zLD,"a,(F)"},  {zPOP,"af"},    {zLD,"a,(C)"},  {zDI,0},
195   {zDB,"f4"},     {zPUSH,"af"},   {zOR,"B"},      {zRST,"V"},
196   {zLD,"hl,sp+B"},{zLD,"sp,hl"},  {zLD,"a,(W)"},  {zEI,0},
197   {zDB,"fc"},     {zDB,"fd"},     {zCP,"B"},      {zRST,"V"}
198};
199
200/****************************************************************************
201 * Disassemble opcode at PC and return number of bytes it takes
202 ****************************************************************************/
203
204unsigned lr35902_dasm( char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram )
205{
206   const lr35902dasm *d;
207   const char *symbol, *src;
208   char *dst;
209   INT8 offset = 0;
210   UINT8 op, op1;
211   UINT16 ea = 0;
212   int pos = 0;
213
214   dst = buffer;
215   symbol = NULL;
216
217   op = oprom[pos++];
218   op1 = 0; /* keep GCC happy */
219
220   if( op == 0xcb ) {
221      op = oprom[pos++];
222      d = &mnemonic_cb[op];
223   } else {
224      d = &mnemonic_main[op];
225   }
226
227   if( d->arguments ) {
228      dst += sprintf(dst, "%-4s ", s_mnemonic[d->mnemonic]);
229      src = d->arguments;
230      while( *src ) {
231         switch( *src ) {
232         case '?':   /* illegal opcode */
233            dst += sprintf( dst, "$%02X,$%02X", op, op1);
234            break;
235         case 'A':
236            ea = opram[pos] + ( opram[pos+1] << 8);
237            pos += 2;
238            dst += sprintf( dst, "$%04X", ea );
239            break;
240         case 'B':   /* Byte op arg */
241            ea = opram[pos++];
242            dst += sprintf( dst, "$%02X", ea );
243            break;
244         case '(':   /* Memory byte at (...) */
245            *dst++ = *src;
246            if( !strncmp( src, "(bc)", 4) ) {
247            } else if( !strncmp( src, "(de)", 4) ) {
248            } else if( !strncmp( src, "(hl)", 4) ) {
249            } else if( !strncmp( src, "(sp)", 4) ) {
250            } else if( !strncmp( src, "(F)", 3) ) {
251               ea = 0xFF00 + opram[pos++];
252               dst += sprintf( dst, "$%02X", ea );
253               src++;
254            } else if( !strncmp( src, "(C)", 3) ) {
255               dst += sprintf( dst, "$FF00+c" );
256               src++;
257            }
258            break;
259         case 'N':   /* Immediate 16 bit */
260            ea = opram[pos] + ( opram[pos+1] << 8 );
261            pos += 2;
262            dst += sprintf( dst, "$%04X", ea );
263            break;
264         case 'O':   /* Offset relative to PC */
265            offset = (INT8) opram[pos++];
266            dst += sprintf( dst, "$%04X", pc + offset + 2 );
267            break;
268         case 'V':   /* Restart vector */
269            ea = op & 0x38;
270            dst += sprintf( dst, "$%02X", ea );
271            break;
272         case 'W':   /* Memory address word */
273            ea = opram[pos] + ( opram[pos+1] << 8 );
274            pos += 2;
275            dst += sprintf( dst, "$%04X", ea );
276            break;
277         default:
278            *dst++ = *src;
279         }
280         src++;
281      }
282      *dst = '\0';
283   } else {
284      dst += sprintf(dst, "%s", s_mnemonic[d->mnemonic]);
285   }
286
287   return pos | s_flags[d->mnemonic] | DASMFLAG_SUPPORTED;
288}
src/emu/cpu/lr35902/lr35902.h
r0r2857
1#ifndef lr35902_H
2#define lr35902_H
3
4#include "cpuintrf.h"
5
6typedef struct {
7   const UINT16   *regs;
8   UINT8   features;
9   void   (*timer_fired_func)(int cycles);
10} LR35902_CONFIG;
11
12enum {
13   LR35902_PC=1, LR35902_SP, LR35902_AF, LR35902_BC, LR35902_DE, LR35902_HL,
14   LR35902_IRQ_STATE,
15   /* Pseudo registers to keep track of the interrupt statuses */
16   LR35902_IE, LR35902_IF,
17   /* Pseudo register to change and check the cpu operating speed */
18   LR35902_SPEED,
19};
20
21#define LR35902_FEATURE_HALT_BUG   0x01
22
23/****************************************************************************/
24/* Return register contents                                                 */
25/****************************************************************************/
26extern void lr35902_get_info(UINT32 state, cpuinfo *info);
27
28#ifdef ENABLE_DEBUGGER
29extern unsigned lr35902_dasm( char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram );
30#endif /* ENABLE_DEBUGGER */
31
32#endif
src/emu/cpu/lr35902/opc_cb.h
r0r2857
1#define   RLC_8BIT(x)            \
2{                        \
3   register UINT8 f;         \
4   (x)=(UINT8)(((x)<<1)|((x)>>7));     \
5   if( (x)&1 )               \
6      f=FLAG_C;            \
7   else                  \
8      f=0;               \
9   if( (x)==0 )            \
10      f|=FLAG_Z;            \
11   Regs.b.F=f;         \
12}
13
14#define   RL_8BIT(x)            \
15{                        \
16   register UINT8 r;         \
17   r=((x)&0x80)?FLAG_C:0;      \
18   (x)=(UINT8)(((x)<<1)|((Regs.b.F&FLAG_C)?1:0));    \
19   if( (x)==0 )            \
20      r|=FLAG_Z;            \
21   Regs.b.F=r;         \
22}
23
24#define   RRC_8BIT(x)            \
25{                        \
26   register UINT8 f;         \
27   (x)=(UINT8)(((x)>>1)|((x)<<7));     \
28   if( (x)&0x80 )            \
29      f=FLAG_C;            \
30   else                  \
31      f=0;               \
32   if( (x)==0 )            \
33      f|=FLAG_Z;            \
34   Regs.b.F=f;         \
35}
36
37#define   RR_8BIT(x)            \
38{                        \
39   register UINT8 r;         \
40   r=((x)&1)?FLAG_C:0;         \
41   (x)=(UINT8)(((x)>>1)|((Regs.b.F&FLAG_C)?0x80:0));    \
42   if( (x)==0 )            \
43      r|=FLAG_Z;            \
44   Regs.b.F=r;         \
45}
46
47#define   SLA_8BIT(x)            \
48{                        \
49   register UINT8 f;         \
50   if( (x)&0x80 )            \
51      f=FLAG_C;            \
52   else                  \
53      f=0;               \
54   (x)<<=1;               \
55   if( (x)==0 )            \
56      f|=FLAG_Z;            \
57   Regs.b.F=f;         \
58}
59
60#define   SRA_8BIT(x)            \
61{                        \
62   register UINT8 f;         \
63   if( (x)&1 )               \
64      f=FLAG_C;            \
65   else                  \
66      f=0;               \
67   (x)=(UINT8)(((char)(x))>>1);    \
68   if( (x)==0 )            \
69      f|=FLAG_Z;            \
70   Regs.b.F=f;         \
71}
72
73#define   SWAP_8BIT(x)         \
74   (x)=(UINT8)(((x)>>4)|((x)<<4));     \
75   if( (x)==0 )            \
76      Regs.b.F=FLAG_Z;   \
77   else                  \
78      Regs.b.F=0;
79
80
81#define   SRL_8BIT(x)            \
82{                        \
83   register UINT8 f;         \
84   if( (x)&1 )               \
85      f=FLAG_C;            \
86   else                  \
87      f=0;               \
88   (x)>>=1;               \
89   if( (x)==0 )            \
90      f|=FLAG_Z;            \
91   Regs.b.F=f;         \
92}
93
94#define   BIT_8BIT(n,x)         \
95   if( (x)&(1<<(n)) )         \
96      Regs.b.F=(UINT8)(FLAG_H|(Regs.b.F&FLAG_C));  \
97   else                  \
98      Regs.b.F=(UINT8)(FLAG_Z|FLAG_H|(Regs.b.F&FLAG_C));
99
100#define   RES_8BIT(n,x)   (x)&=~(1<<(n));
101
102#define   SET_8BIT(n,x)   (x)|=(1<<(n));
103
104
105case 0x00:
106  /*      RLC B */
107
108  RLC_8BIT (Regs.b.B)
109  break;
110case 0x01:
111  /*      RLC C */
112
113  RLC_8BIT (Regs.b.C)
114  break;
115case 0x02:
116  /*      RLC D */
117
118  RLC_8BIT (Regs.b.D)
119  break;
120case 0x03:
121  /*      RLC E */
122
123  RLC_8BIT (Regs.b.E)
124  break;
125case 0x04:
126  /*      RLC H */
127
128  RLC_8BIT (Regs.b.H)
129  break;
130case 0x05:
131  /*      RLC L */
132
133  RLC_8BIT (Regs.b.L)
134  break;
135case 0x06:
136  /*      RLC (HL) */
137
138  x = mem_ReadByte (Regs.w.HL);
139  RLC_8BIT (x)
140  mem_WriteByte (Regs.w.HL, x);
141  break;
142case 0x07:
143  /*      RLC A */
144
145  RLC_8BIT (Regs.b.A)
146  break;
147case 0x08:
148  /*      RRC B */
149
150  RRC_8BIT (Regs.b.B)
151  break;
152case 0x09:
153  /*      RRC C */
154
155  RRC_8BIT (Regs.b.C)
156  break;
157case 0x0A:
158  /*      RRC D */
159
160  RRC_8BIT (Regs.b.D)
161  break;
162case 0x0B:
163  /*      RRC E */
164
165  RRC_8BIT (Regs.b.E)
166  break;
167case 0x0C:
168  /*      RRC H */
169
170  RRC_8BIT (Regs.b.H)
171  break;
172case 0x0D:
173  /*      RRC L */
174
175  RRC_8BIT (Regs.b.L)
176  break;
177case 0x0E:
178  /*      RRC (HL) */
179
180  x = mem_ReadByte (Regs.w.HL);
181  RRC_8BIT (x)
182  mem_WriteByte (Regs.w.HL, x);
183  break;
184case 0x0F:
185  /*      RRC A */
186
187  RRC_8BIT (Regs.b.A)
188  break;
189case 0x10:
190  /*      RL B */
191
192  RL_8BIT (Regs.b.B)
193  break;
194case 0x11:
195  /*      RL C */
196
197  RL_8BIT (Regs.b.C)
198  break;
199case 0x12:
200  /*      RL D */
201
202  RL_8BIT (Regs.b.D)
203  break;
204case 0x13:
205  /*      RL E */
206
207  RL_8BIT (Regs.b.E)
208  break;
209case 0x14:
210  /*      RL H */
211
212  RL_8BIT (Regs.b.H)
213  break;
214case 0x15:
215  /*      RL L */
216
217  RL_8BIT (Regs.b.L)
218  break;
219case 0x16:
220  /*      RL (HL) */
221
222  x = mem_ReadByte (Regs.w.HL);
223  RL_8BIT (x)
224  mem_WriteByte (Regs.w.HL, x);
225  break;
226case 0x17:
227  /*      RL A */
228
229  RL_8BIT (Regs.b.A)
230  break;
231case 0x18:
232  /*      RR B */
233
234  RR_8BIT (Regs.b.B)
235  break;
236case 0x19:
237  /*      RR C */
238
239  RR_8BIT (Regs.b.C)
240  break;
241case 0x1A:
242  /*      RR D */
243
244  RR_8BIT (Regs.b.D)
245  break;
246case 0x1B:
247  /*      RR E */
248
249  RR_8BIT (Regs.b.E)
250  break;
251case 0x1C:
252  /*      RR H */
253
254  RR_8BIT (Regs.b.H)
255  break;
256case 0x1D:
257  /*      RR L */
258
259  RR_8BIT (Regs.b.L)
260  break;
261case 0x1E:
262  /*      RR (HL) */
263
264  x = mem_ReadByte (Regs.w.HL);
265  RR_8BIT (x)
266  mem_WriteByte (Regs.w.HL, x);
267  break;
268case 0x1F:
269  /*      RR A */
270
271  RR_8BIT (Regs.b.A)
272  break;
273case 0x20:
274  /*      SLA B */
275
276  SLA_8BIT (Regs.b.B)
277  break;
278case 0x21:
279  /*      SLA C */
280
281  SLA_8BIT (Regs.b.C)
282  break;
283case 0x22:
284  /*      SLA D */
285
286  SLA_8BIT (Regs.b.D)
287  break;
288case 0x23:
289  /*      SLA E */
290
291  SLA_8BIT (Regs.b.E)
292  break;
293case 0x24:
294  /*      SLA H */
295
296  SLA_8BIT (Regs.b.H)
297  break;
298case 0x25:
299  /*      SLA L */
300
301  SLA_8BIT (Regs.b.L)
302  break;
303case 0x26:
304  /*      SLA (HL) */
305
306  x = mem_ReadByte (Regs.w.HL);
307  SLA_8BIT (x)
308  mem_WriteByte (Regs.w.HL, x);
309  break;
310case 0x27:
311  /*      SLA A */
312
313  SLA_8BIT (Regs.b.A)
314  break;
315case 0x28:
316  /*      SRA B */
317
318  SRA_8BIT (Regs.b.B)
319  break;
320case 0x29:
321  /*      SRA C */
322
323  SRA_8BIT (Regs.b.C)
324  break;
325case 0x2A:
326  /*      SRA D */
327
328  SRA_8BIT (Regs.b.D)
329  break;
330case 0x2B:
331  /*      SRA E */
332
333  SRA_8BIT (Regs.b.E)
334  break;
335case 0x2C:
336  /*      SRA H */
337
338  SRA_8BIT (Regs.b.H)
339  break;
340case 0x2D:
341  /*      SRA L */
342
343  SRA_8BIT (Regs.b.L)
344  break;
345case 0x2E:
346  /*      SRA (HL) */
347
348  x = mem_ReadByte (Regs.w.HL);
349  SRA_8BIT (x)
350  mem_WriteByte (Regs.w.HL, x);
351  break;
352case 0x2F:
353  /*      SRA A */
354
355  SRA_8BIT (Regs.b.A)
356  break;
357case 0x30:
358  /*      SWAP B */
359
360  SWAP_8BIT (Regs.b.B)
361  break;
362case 0x31:
363  /*      SWAP C */
364
365  SWAP_8BIT (Regs.b.C)
366  break;
367case 0x32:
368  /*      SWAP D */
369
370  SWAP_8BIT (Regs.b.D)
371  break;
372case 0x33:
373  /*      SWAP E */
374
375  SWAP_8BIT (Regs.b.E)
376  break;
377case 0x34:
378  /*      SWAP H */
379
380  SWAP_8BIT (Regs.b.H)
381  break;
382case 0x35:
383  /*      SWAP L */
384
385  SWAP_8BIT (Regs.b.L)
386  break;
387case 0x36:
388  /*      SWAP (HL) */
389
390  x = mem_ReadByte (Regs.w.HL);
391  SWAP_8BIT (x)
392  mem_WriteByte (Regs.w.HL, x);
393  break;
394case 0x37:
395  /*      SWAP A */
396
397  SWAP_8BIT (Regs.b.A)
398  break;
399case 0x38:
400  /*      SRL B */
401
402  SRL_8BIT (Regs.b.B)
403  break;
404case 0x39:
405  /*      SRL C */
406
407  SRL_8BIT (Regs.b.C)
408  break;
409case 0x3A:
410  /*      SRL D */
411
412  SRL_8BIT (Regs.b.D)
413  break;
414case 0x3B:
415  /*      SRL E */
416
417  SRL_8BIT (Regs.b.E)
418  break;
419case 0x3C:
420  /*      SRL H */
421
422  SRL_8BIT (Regs.b.H)
423  break;
424case 0x3D:
425  /*      SRL L */
426
427  SRL_8BIT (Regs.b.L)
428  break;
429case 0x3E:
430  /*      SRL (HL) */
431
432  x = mem_ReadByte (Regs.w.HL);
433  SRL_8BIT (x)
434  mem_WriteByte (Regs.w.HL, x);
435  break;
436case 0x3F:
437  /*      SRL A */
438
439  SRL_8BIT (Regs.b.A)
440  break;
441case 0x40:
442  /*      BIT 0,B */
443
444  BIT_8BIT (0, Regs.b.B)
445  break;
446case 0x41:
447  /*      BIT 0,C */
448
449  BIT_8BIT (0, Regs.b.C)
450  break;
451case 0x42:
452  /*      BIT 0,D */
453
454  BIT_8BIT (0, Regs.b.D)
455  break;
456case 0x43:
457  /*      BIT 0,E */
458
459  BIT_8BIT (0, Regs.b.E)
460  break;
461case 0x44:
462  /*      BIT 0,H */
463
464  BIT_8BIT (0, Regs.b.H)
465  break;
466case 0x45:
467  /*      BIT 0,L */
468
469  BIT_8BIT (0, Regs.b.L)
470  break;
471case 0x46:
472  /*      BIT 0,(HL) */
473
474  x = mem_ReadByte (Regs.w.HL);
475  BIT_8BIT (0, x)
476  break;
477case 0x47:
478  /*      BIT 0,A */
479
480  BIT_8BIT (0, Regs.b.A)
481  break;
482case 0x48:
483  /*      BIT 1,B */
484
485  BIT_8BIT (1, Regs.b.B)
486  break;
487case 0x49:
488  /*      BIT 1,C */
489
490  BIT_8BIT (1, Regs.b.C)
491  break;
492case 0x4A:
493  /*      BIT 1,D */
494
495  BIT_8BIT (1, Regs.b.D)
496  break;
497case 0x4B:
498  /*      BIT 1,E */
499
500  BIT_8BIT (1, Regs.b.E)
501  break;
502case 0x4C:
503  /*      BIT 1,H */
504
505  BIT_8BIT (1, Regs.b.H)
506  break;
507case 0x4D:
508  /*      BIT 1,L */
509
510  BIT_8BIT (1, Regs.b.L)
511  break;
512case 0x4E:
513  /*      BIT 1,(HL) */
514
515  x = mem_ReadByte (Regs.w.HL);
516  BIT_8BIT (1, x)
517  break;
518case 0x4F:
519  /*      BIT 1,A */
520
521  BIT_8BIT (1, Regs.b.A)
522  break;
523case 0x50:
524  /*      BIT 2,B */
525
526  BIT_8BIT (2, Regs.b.B)
527  break;
528case 0x51:
529  /*      BIT 2,C */
530
531  BIT_8BIT (2, Regs.b.C)
532  break;
533case 0x52:
534  /*      BIT 2,D */
535
536  BIT_8BIT (2, Regs.b.D)
537  break;
538case 0x53:
539  /*      BIT 2,E */
540
541  BIT_8BIT (2, Regs.b.E)
542  break;
543case 0x54:
544  /*      BIT 2,H */
545
546  BIT_8BIT (2, Regs.b.H)
547  break;
548case 0x55:
549  /*      BIT 2,L */
550
551  BIT_8BIT (2, Regs.b.L)
552  break;
553case 0x56:
554  /*      BIT 2,(HL) */
555
556  x = mem_ReadByte (Regs.w.HL);
557  BIT_8BIT (2, x)
558  break;
559case 0x57:
560  /*      BIT 2,A */
561
562  BIT_8BIT (2, Regs.b.A)
563  break;
564case 0x58:
565  /*      BIT 3,B */
566
567  BIT_8BIT (3, Regs.b.B)
568  break;
569case 0x59:
570  /*      BIT 3,C */
571
572  BIT_8BIT (3, Regs.b.C)
573  break;
574case 0x5A:
575  /*      BIT 3,D */
576
577  BIT_8BIT (3, Regs.b.D)
578  break;
579case 0x5B:
580  /*      BIT 3,E */
581
582  BIT_8BIT (3, Regs.b.E)
583  break;
584case 0x5C:
585  /*      BIT 3,H */
586
587  BIT_8BIT (3, Regs.b.H)
588  break;
589case 0x5D:
590  /*      BIT 3,L */
591
592  BIT_8BIT (3, Regs.b.L)
593  break;
594case 0x5E:
595  /*      BIT 3,(HL) */
596
597  x = mem_ReadByte (Regs.w.HL);
598  BIT_8BIT (3, x)
599  break;
600case 0x5F:
601  /*      BIT 3,A */
602
603  BIT_8BIT (3, Regs.b.A)
604  break;
605case 0x60:
606  /*      BIT 4,B */
607
608  BIT_8BIT (4, Regs.b.B)
609  break;
610case 0x61:
611  /*      BIT 4,C */
612
613  BIT_8BIT (4, Regs.b.C)
614  break;
615case 0x62:
616  /*      BIT 4,D */
617
618  BIT_8BIT (4, Regs.b.D)
619  break;
620case 0x63:
621  /*      BIT 4,E */
622
623  BIT_8BIT (4, Regs.b.E)
624  break;
625case 0x64:
626  /*      BIT 4,H */
627
628  BIT_8BIT (4, Regs.b.H)
629  break;
630case 0x65:
631  /*      BIT 4,L */
632
633  BIT_8BIT (4, Regs.b.L)
634  break;
635case 0x66:
636  /*      BIT 4,(HL) */
637
638  x = mem_ReadByte (Regs.w.HL);
639  BIT_8BIT (4, x)
640  break;
641case 0x67:
642  /*      BIT 4,A */
643
644  BIT_8BIT (4, Regs.b.A)
645  break;
646case 0x68:
647  /*      BIT 5,B */
648
649  BIT_8BIT (5, Regs.b.B)
650  break;
651case 0x69:
652  /*      BIT 5,C */
653
654  BIT_8BIT (5, Regs.b.C)
655  break;
656case 0x6A:
657  /*      BIT 5,D */
658
659  BIT_8BIT (5, Regs.b.D)
660  break;
661case 0x6B:
662  /*      BIT 5,E */
663
664  BIT_8BIT (5, Regs.b.E)
665  break;
666case 0x6C:
667  /*      BIT 5,H */
668
669  BIT_8BIT (5, Regs.b.H)
670  break;
671case 0x6D:
672  /*      BIT 5,L */
673
674  BIT_8BIT (5, Regs.b.L)
675  break;
676case 0x6E:
677  /*      BIT 5,(HL) */
678
679  x = mem_ReadByte (Regs.w.HL);
680  BIT_8BIT (5, x)
681  break;
682case 0x6F:
683  /*      BIT 5,A */
684
685  BIT_8BIT (5, Regs.b.A)
686  break;
687case 0x70:
688  /*      BIT 6,B */
689
690  BIT_8BIT (6, Regs.b.B)
691  break;
692case 0x71:
693  /*      BIT 6,C */
694
695  BIT_8BIT (6, Regs.b.C)
696  break;
697case 0x72:
698  /*      BIT 6,D */
699
700  BIT_8BIT (6, Regs.b.D)
701  break;
702case 0x73:
703  /*      BIT 6,E */
704
705  BIT_8BIT (6, Regs.b.E)
706  break;
707case 0x74:
708  /*      BIT 6,H */
709
710  BIT_8BIT (6, Regs.b.H)
711  break;
712case 0x75:
713  /*      BIT 6,L */
714
715  BIT_8BIT (6, Regs.b.L)
716  break;
717case 0x76:
718  /*      BIT 6,(HL) */
719
720  x = mem_ReadByte (Regs.w.HL);
721  BIT_8BIT (6, x)
722  break;
723case 0x77:
724  /*      BIT 6,A */
725
726  BIT_8BIT (6, Regs.b.A)
727  break;
728case 0x78:
729  /*      BIT 7,B */
730
731  BIT_8BIT (7, Regs.b.B)
732  break;
733case 0x79:
734  /*      BIT 7,C */
735
736  BIT_8BIT (7, Regs.b.C)
737  break;
738case 0x7A:
739  /*      BIT 7,D */
740
741  BIT_8BIT (7, Regs.b.D)
742  break;
743case 0x7B:
744  /*      BIT 7,E */
745
746  BIT_8BIT (7, Regs.b.E)
747  break;
748case 0x7C:
749  /*      BIT 7,H */
750
751  BIT_8BIT (7, Regs.b.H)
752  break;
753case 0x7D:
754  /*      BIT 7,L */
755
756  BIT_8BIT (7, Regs.b.L)
757  break;
758case 0x7E:
759  /*      BIT 7,(HL) */
760
761  x = mem_ReadByte (Regs.w.HL);
762  BIT_8BIT (7, x)
763  break;
764case 0x7F:
765  /*      BIT 7,A */
766
767  BIT_8BIT (7, Regs.b.A)
768  break;
769case 0x80:
770  /*      RES 0,B */
771
772  RES_8BIT (0, Regs.b.B)
773  break;
774case 0x81:
775  /*      RES 0,C */
776
777  RES_8BIT (0, Regs.b.C)
778  break;
779case 0x82:
780  /*      RES 0,D */
781
782  RES_8BIT (0, Regs.b.D)
783  break;
784case 0x83:
785  /*      RES 0,E */
786
787  RES_8BIT (0, Regs.b.E)
788  break;
789case 0x84:
790  /*      RES 0,H */
791
792  RES_8BIT (0, Regs.b.H)
793  break;
794case 0x85:
795  /*      RES 0,L */
796
797  RES_8BIT (0, Regs.b.L)
798  break;
799case 0x86:
800  /*      RES 0,(HL) */
801
802  x = mem_ReadByte (Regs.w.HL);
803  RES_8BIT (0, x)
804  mem_WriteByte (Regs.w.HL, x);
805  break;
806case 0x87:
807  /*      RES 0,A */
808
809  RES_8BIT (0, Regs.b.A)
810  break;
811case 0x88:
812  /*      RES 1,B */
813
814  RES_8BIT (1, Regs.b.B)
815  break;
816case 0x89:
817  /*      RES 1,C */
818
819  RES_8BIT (1, Regs.b.C)
820  break;
821case 0x8A:
822  /*      RES 1,D */
823
824  RES_8BIT (1, Regs.b.D)
825  break;
826case 0x8B:
827  /*      RES 1,E */
828
829  RES_8BIT (1, Regs.b.E)
830  break;
831case 0x8C:
832  /*      RES 1,H */
833
834  RES_8BIT (1, Regs.b.H)
835  break;
836case 0x8D:
837  /*      RES 1,L */
838
839  RES_8BIT (1, Regs.b.L)
840  break;
841case 0x8E:
842  /*      RES 1,(HL) */
843
844  x = mem_ReadByte (Regs.w.HL);
845  RES_8BIT (1, x)
846  mem_WriteByte (Regs.w.HL, x);
847  break;
848case 0x8F:
849  /*      RES 1,A */
850
851  RES_8BIT (1, Regs.b.A)
852  break;
853case 0x90:
854  /*      RES 2,B */
855
856  RES_8BIT (2, Regs.b.B)
857  break;
858case 0x91:
859  /*      RES 2,C */
860
861  RES_8BIT (2, Regs.b.C)
862  break;
863case 0x92:
864  /*      RES 2,D */
865
866  RES_8BIT (2, Regs.b.D)
867  break;
868case 0x93:
869  /*      RES 2,E */
870
871  RES_8BIT (2, Regs.b.E)
872  break;
873case 0x94:
874  /*      RES 2,H */
875
876  RES_8BIT (2, Regs.b.H)
877  break;
878case 0x95:
879  /*      RES 2,L */
880
881  RES_8BIT (2, Regs.b.L)
882  break;
883case 0x96:
884  /*      RES 2,(HL) */
885
886  x = mem_ReadByte (Regs.w.HL);
887  RES_8BIT (2, x)
888  mem_WriteByte (Regs.w.HL, x);
889  break;
890case 0x97:
891  /*      RES 2,A */
892
893  RES_8BIT (2, Regs.b.A)
894  break;
895case 0x98:
896  /*      RES 3,B */
897
898  RES_8BIT (3, Regs.b.B)
899  break;
900case 0x99:
901  /*      RES 3,C */
902
903  RES_8BIT (3, Regs.b.C)
904  break;
905case 0x9A:
906  /*      RES 3,D */
907
908  RES_8BIT (3, Regs.b.D)
909  break;
910case 0x9B:
911  /*      RES 3,E */
912
913  RES_8BIT (3, Regs.b.E)
914  break;
915case 0x9C:
916  /*      RES 3,H */
917
918  RES_8BIT (3, Regs.b.H)
919  break;
920case 0x9D:
921  /*      RES 3,L */
922
923  RES_8BIT (3, Regs.b.L)
924  break;
925case 0x9E:
926  /*      RES 3,(HL) */
927
928  x = mem_ReadByte (Regs.w.HL);
929  RES_8BIT (3, x)
930  mem_WriteByte (Regs.w.HL, x);
931  break;
932case 0x9F:
933  /*      RES 3,A */
934
935  RES_8BIT (3, Regs.b.A)
936  break;
937case 0xA0:
938  /*      RES 4,B */
939
940  RES_8BIT (4, Regs.b.B)
941  break;
942case 0xA1:
943  /*      RES 4,C */
944
945  RES_8BIT (4, Regs.b.C)
946  break;
947case 0xA2:
948  /*      RES 4,D */
949
950  RES_8BIT (4, Regs.b.D)
951  break;
952case 0xA3:
953  /*      RES 4,E */
954
955  RES_8BIT (4, Regs.b.E)
956  break;
957case 0xA4:
958  /*      RES 4,H */
959
960  RES_8BIT (4, Regs.b.H)
961  break;
962case 0xA5:
963  /*      RES 4,L */
964
965  RES_8BIT (4, Regs.b.L)
966  break;
967case 0xA6:
968  /*      RES 4,(HL) */
969
970  x = mem_ReadByte (Regs.w.HL);
971  RES_8BIT (4, x)
972  mem_WriteByte (Regs.w.HL, x);
973  break;
974case 0xA7:
975  /*      RES 4,A */
976
977  RES_8BIT (4, Regs.b.A)
978  break;
979case 0xA8:
980  /*      RES 5,B */
981
982  RES_8BIT (5, Regs.b.B)
983  break;
984case 0xA9:
985  /*      RES 5,C */
986
987  RES_8BIT (5, Regs.b.C)
988  break;
989case 0xAA:
990  /*      RES 5,D */
991
992  RES_8BIT (5, Regs.b.D)
993  break;
994case 0xAB:
995  /*      RES 5,E */
996
997  RES_8BIT (5, Regs.b.E)
998  break;
999case 0xAC:
1000  /*      RES 5,H */
1001
1002  RES_8BIT (5, Regs.b.H)
1003  break;
1004case 0xAD:
1005  /*      RES 5,L */
1006
1007  RES_8BIT (5, Regs.b.L)
1008  break;
1009case 0xAE:
1010  /*      RES 5,(HL) */
1011
1012  x = mem_ReadByte (Regs.w.HL);
1013  RES_8BIT (5, x)
1014  mem_WriteByte (Regs.w.HL, x);
1015  break;
1016case 0xAF:
1017  /*      RES 5,A */
1018
1019  RES_8BIT (5, Regs.b.A)
1020  break;
1021case 0xB0:
1022  /*      RES 6,B */
1023
1024  RES_8BIT (6, Regs.b.B)
1025  break;
1026case 0xB1:
1027  /*      RES 6,C */
1028
1029  RES_8BIT (6, Regs.b.C)
1030  break;
1031case 0xB2:
1032  /*      RES 6,D */
1033
1034  RES_8BIT (6, Regs.b.D)
1035  break;
1036case 0xB3:
1037  /*      RES 6,E */
1038
1039  RES_8BIT (6, Regs.b.E)
1040  break;
1041case 0xB4:
1042  /*      RES 6,H */
1043
1044  RES_8BIT (6, Regs.b.H)
1045  break;
1046case 0xB5:
1047  /*      RES 6,L */
1048
1049  RES_8BIT (6, Regs.b.L)
1050  break;
1051case 0xB6:
1052  /*      RES 6,(HL) */
1053
1054  x = mem_ReadByte (Regs.w.HL);
1055  RES_8BIT (6, x)
1056  mem_WriteByte (Regs.w.HL, x);
1057  break;
1058case 0xB7:
1059  /*      RES 6,A */
1060
1061  RES_8BIT (6, Regs.b.A)
1062  break;
1063case 0xB8:
1064  /*      RES 7,B */
1065
1066  RES_8BIT (7, Regs.b.B)
1067  break;
1068case 0xB9:
1069  /*      RES 7,C */
1070
1071  RES_8BIT (7, Regs.b.C)
1072  break;
1073case 0xBA:
1074  /*      RES 7,D */
1075
1076  RES_8BIT (7, Regs.b.D)
1077  break;
1078case 0xBB:
1079  /*      RES 7,E */
1080
1081  RES_8BIT (7, Regs.b.E)
1082  break;
1083case 0xBC:
1084  /*      RES 7,H */
1085
1086  RES_8BIT (7, Regs.b.H)
1087  break;
1088case 0xBD:
1089  /*      RES 7,L */
1090
1091  RES_8BIT (7, Regs.b.L)
1092  break;
1093case 0xBE:
1094  /*      RES 7,(HL) */
1095
1096  x = mem_ReadByte (Regs.w.HL);
1097  RES_8BIT (7, x)
1098  mem_WriteByte (Regs.w.HL, x);
1099  break;
1100case 0xBF:
1101  /*      RES 7,A */
1102
1103  RES_8BIT (7, Regs.b.A)
1104  break;
1105case 0xC0:
1106  /*      SET 0,B */
1107
1108  SET_8BIT (0, Regs.b.B)
1109  break;
1110case 0xC1:
1111  /*      SET 0,C */
1112
1113  SET_8BIT (0, Regs.b.C)
1114  break;
1115case 0xC2:
1116  /*      SET 0,D */
1117
1118  SET_8BIT (0, Regs.b.D)
1119  break;
1120case 0xC3:
1121  /*      SET 0,E */
1122
1123  SET_8BIT (0, Regs.b.E)
1124  break;
1125case 0xC4:
1126  /*      SET 0,H */
1127
1128  SET_8BIT (0, Regs.b.H)
1129  break;
1130case 0xC5:
1131  /*      SET 0,L */
1132
1133  SET_8BIT (0, Regs.b.L)
1134  break;
1135case 0xC6:
1136  /*      SET 0,(HL) */
1137
1138  x = mem_ReadByte (Regs.w.HL);
1139  SET_8BIT (0, x)
1140  mem_WriteByte (Regs.w.HL, x);
1141  break;
1142case 0xC7:
1143  /*      SET 0,A */
1144
1145  SET_8BIT (0, Regs.b.A)
1146  break;
1147case 0xC8:
1148  /*      SET 1,B */
1149
1150  SET_8BIT (1, Regs.b.B)
1151  break;
1152case 0xC9:
1153  /*      SET 1,C */
1154
1155  SET_8BIT (1, Regs.b.C)
1156  break;
1157case 0xCA:
1158  /*      SET 1,D */
1159
1160  SET_8BIT (1, Regs.b.D)
1161  break;
1162case 0xCB:
1163  /*      SET 1,E */
1164
1165  SET_8BIT (1, Regs.b.E)
1166  break;
1167case 0xCC:
1168  /*      SET 1,H */
1169
1170  SET_8BIT (1, Regs.b.H)
1171  break;
1172case 0xCD:
1173  /*      SET 1,L */
1174
1175  SET_8BIT (1, Regs.b.L)
1176  break;
1177case 0xCE:
1178  /*      SET 1,(HL) */
1179
1180  x = mem_ReadByte (Regs.w.HL);
1181  SET_8BIT (1, x)
1182  mem_WriteByte (Regs.w.HL, x);
1183  break;
1184case 0xCF:
1185  /*      SET 1,A */
1186
1187  SET_8BIT (1, Regs.b.A)
1188  break;
1189case 0xD0:
1190  /*      SET 2,B */
1191
1192  SET_8BIT (2, Regs.b.B)
1193  break;
1194case 0xD1:
1195  /*      SET 2,C */
1196
1197  SET_8BIT (2, Regs.b.C)
1198  break;
1199case 0xD2:
1200  /*      SET 2,D */
1201
1202  SET_8BIT (2, Regs.b.D)
1203  break;
1204case 0xD3:
1205  /*      SET 2,E */
1206
1207  SET_8BIT (2, Regs.b.E)
1208  break;
1209case 0xD4:
1210  /*      SET 2,H */
1211
1212  SET_8BIT (2, Regs.b.H)
1213  break;
1214case 0xD5:
1215  /*      SET 2,L */
1216
1217  SET_8BIT (2, Regs.b.L)
1218  break;
1219case 0xD6:
1220  /*      SET 2,(HL) */
1221
1222  x = mem_ReadByte (Regs.w.HL);
1223  SET_8BIT (2, x)
1224  mem_WriteByte (Regs.w.HL, x);
1225  break;
1226case 0xD7:
1227  /*      SET 2,A */
1228
1229  SET_8BIT (2, Regs.b.A)
1230  break;
1231case 0xD8:
1232  /*      SET 3,B */
1233
1234  SET_8BIT (3, Regs.b.B)
1235  break;
1236case 0xD9:
1237  /*      SET 3,C */
1238
1239  SET_8BIT (3, Regs.b.C)
1240  break;
1241case 0xDA:
1242  /*      SET 3,D */
1243
1244  SET_8BIT (3, Regs.b.D)
1245  break;
1246case 0xDB:
1247  /*      SET 3,E */
1248
1249  SET_8BIT (3, Regs.b.E)
1250  break;
1251case 0xDC:
1252  /*      SET 3,H */
1253
1254  SET_8BIT (3, Regs.b.H)
1255  break;
1256case 0xDD:
1257  /*      SET 3,L */
1258
1259  SET_8BIT (3, Regs.b.L)
1260  break;
1261case 0xDE:
1262  /*      SET 3,(HL) */
1263
1264  x = mem_ReadByte (Regs.w.HL);
1265  SET_8BIT (3, x)
1266  mem_WriteByte (Regs.w.HL, x);
1267  break;
1268case 0xDF:
1269  /*      SET 3,A */
1270
1271  SET_8BIT (3, Regs.b.A)
1272  break;
1273case 0xE0:
1274  /*      SET 4,B */
1275
1276  SET_8BIT (4, Regs.b.B)
1277  break;
1278case 0xE1:
1279  /*      SET 4,C */
1280
1281  SET_8BIT (4, Regs.b.C)
1282  break;
1283case 0xE2:
1284  /*      SET 4,D */
1285
1286  SET_8BIT (4, Regs.b.D)
1287  break;
1288case 0xE3:
1289  /*      SET 4,E */
1290
1291  SET_8BIT (4, Regs.b.E)
1292  break;
1293case 0xE4:
1294  /*      SET 4,H */
1295
1296  SET_8BIT (4, Regs.b.H)
1297  break;
1298case 0xE5:
1299  /*      SET 4,L */
1300
1301  SET_8BIT (4, Regs.b.L)
1302  break;
1303case 0xE6:
1304  /*      SET 4,(HL) */
1305
1306  x = mem_ReadByte (Regs.w.HL);
1307  SET_8BIT (4, x)
1308  mem_WriteByte (Regs.w.HL, x);
1309  break;
1310case 0xE7:
1311  /*      SET 4,A */
1312
1313  SET_8BIT (4, Regs.b.A)
1314  break;
1315case 0xE8:
1316  /*      SET 5,B */
1317
1318  SET_8BIT (5, Regs.b.B)
1319  break;
1320case 0xE9:
1321  /*      SET 5,C */
1322
1323  SET_8BIT (5, Regs.b.C)
1324  break;
1325case 0xEA:
1326  /*      SET 5,D */
1327
1328  SET_8BIT (5, Regs.b.D)
1329  break;
1330case 0xEB:
1331  /*      SET 5,E */
1332
1333  SET_8BIT (5, Regs.b.E)
1334  break;
1335case 0xEC:
1336  /*      SET 5,H */
1337
1338  SET_8BIT (5, Regs.b.H)
1339  break;
1340case 0xED:
1341  /*      SET 5,L */
1342
1343  SET_8BIT (5, Regs.b.L)
1344  break;
1345case 0xEE:
1346  /*      SET 5,(HL) */
1347
1348  x = mem_ReadByte (Regs.w.HL);
1349  SET_8BIT (5, x)
1350  mem_WriteByte (Regs.w.HL, x);
1351  break;
1352case 0xEF:
1353  /*      SET 5,A */
1354
1355  SET_8BIT (5, Regs.b.A)
1356  break;
1357case 0xF0:
1358  /*      SET 6,B */
1359
1360  SET_8BIT (6, Regs.b.B)
1361  break;
1362case 0xF1:
1363  /*      SET 6,C */
1364
1365  SET_8BIT (6, Regs.b.C)
1366  break;
1367case 0xF2:
1368  /*      SET 6,D */
1369
1370  SET_8BIT (6, Regs.b.D)
1371  break;
1372case 0xF3:
1373  /*      SET 6,E */
1374
1375  SET_8BIT (6, Regs.b.E)
1376  break;
1377case 0xF4:
1378  /*      SET 6,H */
1379
1380  SET_8BIT (6, Regs.b.H)
1381  break;
1382case 0xF5:
1383  /*      SET 6,L */
1384
1385  SET_8BIT (6, Regs.b.L)
1386  break;
1387case 0xF6:
1388  /*      SET 6,(HL) */
1389
1390  x = mem_ReadByte (Regs.w.HL);
1391  SET_8BIT (6, x)
1392  mem_WriteByte (Regs.w.HL, x);
1393  break;
1394case 0xF7:
1395  /*      SET 6,A */
1396
1397  SET_8BIT (6, Regs.b.A)
1398  break;
1399case 0xF8:
1400  /*      SET 7,B */
1401
1402  SET_8BIT (7, Regs.b.B)
1403  break;
1404case 0xF9:
1405  /*      SET 7,C */
1406
1407  SET_8BIT (7, Regs.b.C)
1408  break;
1409case 0xFA:
1410  /*      SET 7,D */
1411
1412  SET_8BIT (7, Regs.b.D)
1413  break;
1414case 0xFB:
1415  /*      SET 7,E */
1416
1417  SET_8BIT (7, Regs.b.E)
1418  break;
1419case 0xFC:
1420  /*      SET 7,H */
1421
1422  SET_8BIT (7, Regs.b.H)
1423  break;
1424case 0xFD:
1425  /*      SET 7,L */
1426
1427  SET_8BIT (7, Regs.b.L)
1428  break;
1429case 0xFE:
1430  /*      SET 7,(HL) */
1431
1432  x = mem_ReadByte (Regs.w.HL);
1433  SET_8BIT (7, x)
1434  mem_WriteByte (Regs.w.HL, x);
1435  break;
1436case 0xFF:
1437  /*      SET 7,A */
1438
1439  SET_8BIT (7, Regs.b.A)
1440  break;
src/emu/cpu/lr35902/opc_main.h
r0r2857
1#define   INC_8BIT(x) \
2{ \
3  register UINT8 r,f; \
4  x++; \
5  r=(x);  \
6  f=(UINT8)(Regs.b.F&FLAG_C); \
7  if( r==0 )       f|=FLAG_Z; \
8  if( (r&0xF)==0 ) f|=FLAG_H; \
9  Regs.b.F=f; \
10}
11
12#define   DEC_8BIT(x) \
13{ \
14  register UINT8 r,f; \
15  x--; \
16  r=(x);  \
17  f=(UINT8)((Regs.b.F&FLAG_C)|FLAG_N); \
18  if( r==0 )       f|=FLAG_Z; \
19  if( (r&0xF)==0xF ) f|=FLAG_H; \
20  Regs.b.F=f; \
21}
22
23#define   ADD_HL_RR(x) \
24{ \
25  register UINT32 r1,r2; \
26  register UINT8 f; \
27  r1=Regs.w.HL+(x); \
28  r2=(Regs.w.HL&0xFFF)+((x)&0xFFF); \
29  f=(UINT8)(Regs.b.F&FLAG_Z); \
30  if( r1>0xFFFF ) f|=FLAG_C; \
31  if( r2>0x0FFF ) f|=FLAG_H; \
32  Regs.w.HL=(UINT16)r1; \
33  Regs.b.F=f; \
34}
35
36#define   ADD_A_X(x) \
37{ \
38  register UINT16 r1,r2; \
39  register UINT8 f; \
40  r1=(UINT16)((Regs.b.A&0xF)+((x)&0xF)); \
41  r2=(UINT16)(Regs.b.A+(x)); \
42  Regs.b.A=(UINT8)r2; \
43  if( ((UINT8)r2)==0 ) f=FLAG_Z; \
44    else f=0; \
45  if( r2>0xFF ) f|=FLAG_C; \
46  if( r1>0xF )  f|=FLAG_H; \
47  Regs.b.F=f; \
48}
49
50#define   SUB_A_X(x) \
51{ \
52  register UINT16 r1,r2; \
53  register UINT8 f; \
54  r1=(UINT16)((Regs.b.A&0xF)-((x)&0xF)); \
55  r2=(UINT16)(Regs.b.A-(x)); \
56  Regs.b.A=(UINT8)r2; \
57  if( ((UINT8)r2)==0 ) f=FLAG_N|FLAG_Z; \
58    else f=FLAG_N; \
59  if( r2>0xFF ) f|=FLAG_C; \
60  if( r1>0xF )  f|=FLAG_H; \
61  Regs.b.F=f; \
62}
63
64/*
65   #define      CP_A_X(x) \
66   { \
67   register UINT16 r; \
68   register UINT8 f; \
69   r=(UINT16)(Regs.b.A-(x)); \
70   if( ((UINT8)r)==0 ) \
71   f=FLAG_N|FLAG_Z; \
72   else \
73   f=FLAG_N; \
74   f|=(UINT8)((r>>8)&FLAG_C); \
75   if( (r^Regs.b.A^(x))&0x10 ) \
76   f|=FLAG_H; \
77   Regs.b.F=f; \
78   }
79 */
80
81#define   CP_A_X(x) \
82{ \
83  register UINT16 r1,r2; \
84  register UINT8 f; \
85  r1=(UINT16)((Regs.b.A&0xF)-((x)&0xF)); \
86  r2=(UINT16)(Regs.b.A-(x)); \
87  if( ((UINT8)r2)==0 ) f=FLAG_N|FLAG_Z; \
88    else f=FLAG_N; \
89  if( r2>0xFF ) f|=FLAG_C; \
90  if( r1>0xF )  f|=FLAG_H; \
91  Regs.b.F=f; \
92}
93
94#define   SBC_A_X(x) \
95{ \
96  register UINT16 r1,r2; \
97  register UINT8 f; \
98  r1=(UINT16)((Regs.b.A&0xF)-((x)&0xF)-((Regs.b.F&FLAG_C)?1:0)); \
99  r2=(UINT16)(Regs.b.A-(x)-((Regs.b.F&FLAG_C)?1:0)); \
100  Regs.b.A=(UINT8)r2; \
101  if( ((UINT8)r2)==0 ) f=FLAG_N|FLAG_Z; \
102    else f=FLAG_N; \
103  if( r2>0xFF ) f|=FLAG_C; \
104  if( r1>0xF )  f|=FLAG_H; \
105  Regs.b.F=f; \
106}
107
108#define   ADC_A_X(x) \
109{ \
110  register UINT16 r1,r2;  \
111  register UINT8 f; \
112  r1=(UINT16)((Regs.b.A&0xF)+((x)&0xF)+((Regs.b.F&FLAG_C)?1:0));  \
113  r2=(UINT16)(Regs.b.A+(x)+((Regs.b.F&FLAG_C)?1:0)); \
114  if( (Regs.b.A=(UINT8)r2)==0 ) f=FLAG_Z; \
115    else f=0; \
116  if( r2>0xFF )   f|=FLAG_C; \
117  if( r1>0xF )   f|=FLAG_H; \
118  Regs.b.F=f; \
119}
120
121#define   AND_A_X(x) \
122  if( (Regs.b.A&=(x))==0 ) \
123    Regs.b.F=FLAG_H|FLAG_Z; \
124  else \
125    Regs.b.F=FLAG_H;
126
127#define XOR_A_X(x) \
128  if( (Regs.b.A^=(x))==0 ) \
129    Regs.b.F=FLAG_Z; \
130  else \
131    Regs.b.F=0;
132
133#define   OR_A_X(x) \
134  if( (Regs.b.A|=(x))==0 ) \
135    Regs.b.F=FLAG_Z; \
136  else \
137    Regs.b.F=0;
138
139
140case 0x00: /*      NOP */
141  break;
142case 0x01: /*      LD BC,n16 */
143  Regs.w.BC = mem_ReadWord (Regs.w.PC);
144  Regs.w.PC += 2;
145  break;
146case 0x02: /*      LD (BC),A */
147  mem_WriteByte (Regs.w.BC, Regs.b.A);
148  break;
149case 0x03: /*      INC BC */
150
151#if 0            /* FIXME ?? do we want to support this? (bug emulation) */
152  if (Regs.b.B == 0xFE)
153  {
154    trash_sprites (state);
155  }
156#endif
157  Regs.w.BC += 1;
158  break;
159case 0x04: /*      INC B */
160
161  INC_8BIT (Regs.b.B)
162  break;
163case 0x05: /*      DEC B */
164
165  DEC_8BIT (Regs.b.B)
166  break;
167case 0x06: /*      LD B,n8 */
168
169  Regs.b.B = mem_ReadByte (Regs.w.PC++);
170  break;
171case 0x07: /*      RLCA */
172
173  Regs.b.A = (UINT8) ((Regs.b.A << 1) | (Regs.b.A >> 7));
174  if (Regs.b.A & 1)
175  {
176    Regs.b.F = FLAG_C;
177  }
178  else
179  {
180    Regs.b.F = 0;
181  }
182  break;
183case 0x08: /*      LD (n16),SP */
184
185  mem_WriteWord (mem_ReadWord (Regs.w.PC), Regs.w.SP);
186  Regs.w.PC += 2;
187  break;
188case 0x09: /*      ADD HL,BC */
189
190  ADD_HL_RR (Regs.w.BC)
191  break;
192case 0x0A: /*      LD A,(BC) */
193
194  Regs.b.A = mem_ReadByte (Regs.w.BC);
195  break;
196case 0x0B: /*      DEC BC */
197
198#if 0            /* FIXME ?? do we want to support this? (bug emulation) */
199  if (Regs.b.B == 0xFE)
200  {
201    trash_sprites (state);
202  }
203#endif
204
205  Regs.w.BC -= 1;
206  break;
207case 0x0C: /*      INC C */
208
209  INC_8BIT (Regs.b.C)
210  break;
211case 0x0D: /*      DEC C */
212
213  DEC_8BIT (Regs.b.C)
214  break;
215case 0x0E: /*      LD C,n8 */
216
217  Regs.b.C = mem_ReadByte (Regs.w.PC++);
218  break;
219case 0x0F: /*      RRCA */
220
221  Regs.b.A = (UINT8) ((Regs.b.A >> 1) | (Regs.b.A << 7));
222  Regs.b.F = 0;
223  if (Regs.b.A & 0x80)
224  {
225    Regs.b.F |= FLAG_C;
226  }
227  break;
228case 0x10: /*      STOP */
229  if ( Regs.w.gb_speed_change_pending ) {
230    Regs.w.gb_speed = ( Regs.w.gb_speed == 1 ) ? 2 : 1;
231  }
232  Regs.w.gb_speed_change_pending = 0;
233  break;
234case 0x11: /*      LD DE,n16 */
235
236  Regs.w.DE = mem_ReadWord (Regs.w.PC);
237  Regs.w.PC += 2;
238  break;
239case 0x12: /*      LD (DE),A */
240  mem_WriteByte (Regs.w.DE, Regs.b.A);
241  break;
242case 0x13: /*      INC DE */
243
244#if 0            /* FIXME ?? do we want to support this? (bug emulation) */
245  if (Regs.b.D == 0xFE)
246  {
247    trash_sprites (state);
248  }
249#endif
250
251  Regs.w.DE += 1;
252  break;
253case 0x14: /*      INC D */
254
255  INC_8BIT (Regs.b.D)
256  break;
257case 0x15: /*      DEC D */
258
259  DEC_8BIT (Regs.b.D)
260  break;
261case 0x16: /*      LD D,n8 */
262
263  Regs.b.D = mem_ReadByte (Regs.w.PC++);
264  break;
265case 0x17: /*      RLA */
266
267  x = (Regs.b.A & 0x80) ? FLAG_C : 0;
268
269  Regs.b.A = (UINT8) ((Regs.b.A << 1) | ((Regs.b.F & FLAG_C) ? 1 : 0));
270  Regs.b.F = x;
271  break;
272case 0x18: /*      JR      n8 */
273  {
274   INT8 offset;
275
276    offset = mem_ReadByte (Regs.w.PC++);
277    Regs.w.PC += offset;
278  }
279  break;
280case 0x19: /*      ADD HL,DE */
281
282  ADD_HL_RR (Regs.w.DE)
283  break;
284case 0x1A: /*      LD A,(DE) */
285
286  Regs.b.A = mem_ReadByte (Regs.w.DE);
287  break;
288case 0x1B: /*      DEC DE */
289
290#if 0            /* FIXME ?? do we want to support this? (bug emulation) */
291  if (Regs.b.D == 0xFE)
292  {
293    trash_sprites (state);
294  }
295#endif
296
297  Regs.w.DE -= 1;
298  break;
299case 0x1C: /*      INC E */
300
301  INC_8BIT (Regs.b.E)
302  break;
303case 0x1D: /*      DEC E */
304
305  DEC_8BIT (Regs.b.E)
306  break;
307case 0x1E: /*      LD E,n8 */
308
309  Regs.b.E = mem_ReadByte (Regs.w.PC++);
310  break;
311case 0x1F: /*      RRA */
312
313  x = (Regs.b.A & 1) ? FLAG_C : 0;
314
315  Regs.b.A = (UINT8) ((Regs.b.A >> 1) | ((Regs.b.F & FLAG_C) ? 0x80 : 0));
316  Regs.b.F = x;
317  break;
318case 0x20: /*      JR NZ,n8 */
319
320  if (Regs.b.F & FLAG_Z)
321  {
322    Regs.w.PC++;
323  }
324  else
325  {
326   INT8 offset;
327
328    offset = mem_ReadByte (Regs.w.PC++);
329    Regs.w.PC += offset;
330    CYCLES_PASSED( 4 );
331  }
332  break;
333case 0x21: /*      LD HL,n16 */
334
335  Regs.w.HL = mem_ReadWord (Regs.w.PC);
336  Regs.w.PC += 2;
337  break;
338case 0x22: /*      LD (HL+),A */
339
340#if 0            /* FIXME ?? do we want to support this? (bug emulation) */
341  if (Regs.b.H == 0xFE)
342  {
343    trash_sprites (state);
344  }
345#endif
346
347  mem_WriteByte (Regs.w.HL, Regs.b.A);
348  Regs.w.HL += 1;
349  break;
350case 0x23: /*      INC HL */
351
352#if 0            /* FIXME ?? do we want to support this? (bug emulation) */
353  if (Regs.b.H == 0xFE)
354  {
355    trash_sprites (state);
356  }
357#endif
358
359  Regs.w.HL += 1;
360  break;
361case 0x24: /*      INC H */
362
363  INC_8BIT (Regs.b.H);
364  break;
365case 0x25: /*      DEC H */
366
367  DEC_8BIT (Regs.b.H);
368  break;
369case 0x26: /*      LD H,n8 */
370
371  Regs.b.H = mem_ReadByte (Regs.w.PC++);
372  break;
373case 0x27: /*      DAA */
374   {
375      int tmp = Regs.b.A;
376
377      if ( ! ( Regs.b.F & FLAG_N ) ) {
378         if ( ( Regs.b.F & FLAG_H ) || ( tmp & 0x0F ) > 9 )
379            tmp += 6;
380         if ( ( Regs.b.F & FLAG_C ) || tmp > 0x9F )
381            tmp += 0x60;
382      } else {
383         if ( Regs.b.F & FLAG_H ) {
384            tmp -= 6;
385            if ( ! ( Regs.b.F & FLAG_C ) )
386               tmp &= 0xFF;
387         }
388         if ( Regs.b.F & FLAG_C )
389               tmp -= 0x60;
390      }
391      Regs.b.F &= ~ ( FLAG_H | FLAG_Z );
392      if ( tmp & 0x100 )
393         Regs.b.F |= FLAG_C;
394      Regs.b.A = tmp & 0xFF;
395      if ( ! Regs.b.A )
396         Regs.b.F |= FLAG_Z;
397   }
398  break;
399case 0x28: /*      JR Z,n8 */
400
401  if (Regs.b.F & FLAG_Z)
402  {
403   INT8 offset;
404
405    offset = mem_ReadByte (Regs.w.PC++);
406    Regs.w.PC += offset;
407
408    CYCLES_PASSED( 4 );
409  }
410  else
411  {
412    Regs.w.PC += 1;
413  }
414  break;
415case 0x29: /*      ADD HL,HL */
416
417  ADD_HL_RR (Regs.w.HL)
418  break;
419case 0x2A: /*      LD A,(HL+) */
420#if 0            /* FIXME ?? do we want to support this? (bug emulation) */
421  if (Regs.b.H == 0xFE)
422  {
423    trash_sprites (state);
424  }
425#endif
426
427  Regs.b.A = mem_ReadByte (Regs.w.HL);
428  Regs.w.HL += 1;
429  break;
430case 0x2B: /*      DEC HL */
431
432#if 0            /* FIXME ?? do we want to support this? (bug emulation) */
433  if (Regs.b.H == 0xFE)
434  {
435    trash_sprites (state);
436  }
437#endif
438
439  Regs.w.HL -= 1;
440  break;
441case 0x2C: /*      INC L */
442
443  INC_8BIT (Regs.b.L);
444  break;
445case 0x2D: /*      DEC L */
446
447  DEC_8BIT (Regs.b.L);
448  break;
449case 0x2E: /*      LD L,n8 */
450
451  Regs.b.L = mem_ReadByte (Regs.w.PC++);
452  break;
453case 0x2F: /*      CPL */
454
455  Regs.b.A = ~Regs.b.A;
456  Regs.b.F |= FLAG_N | FLAG_H;
457  break;
458case 0x30: /*      JR NC,n8 */
459
460  if (Regs.b.F & FLAG_C)
461  {
462    Regs.w.PC += 1;
463  }
464  else
465  {
466   INT8 offset;
467
468    offset = mem_ReadByte (Regs.w.PC++);
469    Regs.w.PC += offset;
470    CYCLES_PASSED( 4 );
471  }
472  break;
473case 0x31: /*      LD SP,n16 */
474
475  Regs.w.SP = mem_ReadWord (Regs.w.PC);
476  Regs.w.PC += 2;
477  break;
478case 0x32: /*      LD (HL-),A */
479
480#if 0            /* FIXME ?? do we want to support this? (bug emulation) */
481  if (Regs.b.H == 0xFE)
482  {
483    trash_sprites (state);
484  }
485#endif
486
487  mem_WriteByte (Regs.w.HL, Regs.b.A);
488  Regs.w.HL -= 1;
489  break;
490case 0x33: /*      INC SP */
491
492  Regs.w.SP += 1;
493  break;
494case 0x34: /*      INC (HL) */
495
496  {
497   register UINT8 r, f;
498
499   f = (UINT8) (Regs.b.F & FLAG_C);
500   r = (UINT8) (mem_ReadByte (Regs.w.HL) + 1);
501    mem_WriteByte (Regs.w.HL, r);
502
503    if (r == 0)
504      f |= FLAG_Z;
505
506    if ((r & 0xF) == 0)
507      f |= FLAG_H;
508
509    Regs.b.F = f;
510  }
511  break;
512case 0x35: /*      DEC (HL) */
513
514  {
515   register UINT8 r, f;
516
517   f = (UINT8) ((Regs.b.F & FLAG_C) | FLAG_N);
518   r = (UINT8) (mem_ReadByte (Regs.w.HL) - 1);
519    mem_WriteByte (Regs.w.HL, r);
520
521    if (r == 0)
522      f |= FLAG_Z;
523
524    if ((r & 0xF) == 0xF)
525      f |= FLAG_H;
526
527    Regs.b.F = f;
528  }
529  break;
530case 0x36: /*      LD (HL),n8 */
531  /* FIXED / broken ? */
532  mem_WriteByte (Regs.w.HL, mem_ReadByte (Regs.w.PC++));
533  break;
534case 0x37: /*      SCF */
535
536  Regs.b.F = (UINT8) ((Regs.b.F & FLAG_Z) | FLAG_C);
537  break;
538case 0x38: /*      JR C,n8 */
539
540  if (Regs.b.F & FLAG_C)
541  {
542   INT8 offset;
543
544    offset = mem_ReadByte (Regs.w.PC++);
545    Regs.w.PC += offset;
546
547    CYCLES_PASSED( 4 );
548  }
549  else
550  {
551    Regs.w.PC += 1;
552  }
553  break;
554case 0x39: /*      ADD HL,SP */
555  ADD_HL_RR (Regs.w.SP)
556  break;
557case 0x3A: /*      LD A,(HL-) */
558#if 0            /* FIXME ?? do we want to support this? (bug emulation) */
559  if (Regs.b.H == 0xFE)
560  {
561    trash_sprites (state);
562  }
563#endif
564
565  Regs.b.A = mem_ReadByte (Regs.w.HL);
566  Regs.w.HL -= 1;
567  break;
568case 0x3B: /*      DEC SP */
569
570  Regs.w.SP -= 1;
571  break;
572case 0x3C: /*      INC     A */
573
574  INC_8BIT (Regs.b.A);
575  break;
576case 0x3D: /*      DEC     A */
577
578  DEC_8BIT (Regs.b.A);
579  break;
580case 0x3E: /*      LD A,n8 */
581
582  Regs.b.A = mem_ReadByte (Regs.w.PC++);
583  break;
584case 0x3F: /*      CCF */
585
586  Regs.b.F = (UINT8) ((Regs.b.F & FLAG_Z) | ((Regs.b.F & FLAG_C) ? 0 : FLAG_C));
587  break;
588case 0x40: /*      LD B,B */
589  break;
590case 0x41: /*      LD B,C */
591
592  Regs.b.B = Regs.b.C;
593  break;
594case 0x42: /*      LD B,D */
595
596  Regs.b.B = Regs.b.D;
597  break;
598case 0x43: /*      LD B,E */
599
600  Regs.b.B = Regs.b.E;
601  break;
602case 0x44: /*      LD B,H */
603
604  Regs.b.B = Regs.b.H;
605  break;
606case 0x45: /*      LD B,L */
607
608  Regs.b.B = Regs.b.L;
609  break;
610case 0x46: /*      LD B,(HL) */
611
612  Regs.b.B = mem_ReadByte (Regs.w.HL);
613  break;
614case 0x47: /*      LD B,A */
615
616  Regs.b.B = Regs.b.A;
617  break;
618case 0x48: /*      LD C,B */
619
620  Regs.b.C = Regs.b.B;
621  break;
622case 0x49: /*      LD C,C */
623  break;
624case 0x4A: /*      LD C,D */
625
626  Regs.b.C = Regs.b.D;
627  break;
628case 0x4B: /*      LD C,E */
629
630  Regs.b.C = Regs.b.E;
631  break;
632case 0x4C: /*      LD C,H */
633
634  Regs.b.C = Regs.b.H;
635  break;
636case 0x4D: /*      LD C,L */
637
638  Regs.b.C = Regs.b.L;
639  break;
640case 0x4E: /*      LD C,(HL) */
641
642  Regs.b.C = mem_ReadByte (Regs.w.HL);
643  break;
644case 0x4F: /*      LD C,A */
645
646  Regs.b.C = Regs.b.A;
647  break;
648case 0x50: /*      LD D,B */
649
650  Regs.b.D = Regs.b.B;
651  break;
652case 0x51: /*      LD D,C */
653
654  Regs.b.D = Regs.b.C;
655  break;
656case 0x52: /*      LD D,D */
657  break;
658case 0x53: /*      LD D,E */
659
660  Regs.b.D = Regs.b.E;
661  break;
662case 0x54: /*      LD D,H */
663
664  Regs.b.D = Regs.b.H;
665  break;
666case 0x55: /*      LD D,L */
667
668  Regs.b.D = Regs.b.L;
669  break;
670case 0x56: /*      LD D,(HL) */
671
672  Regs.b.D = mem_ReadByte (Regs.w.HL);
673  break;
674case 0x57: /*      LD D,A */
675
676  Regs.b.D = Regs.b.A;
677  break;
678case 0x58: /*      LD E,B */
679
680  Regs.b.E = Regs.b.B;
681  break;
682case 0x59: /*      LD E,C */
683
684  Regs.b.E = Regs.b.C;
685  break;
686case 0x5A: /*      LD E,D */
687
688  Regs.b.E = Regs.b.D;
689  break;
690case 0x5B: /*      LD E,E */
691  break;
692case 0x5C: /*      LD E,H */
693
694  Regs.b.E = Regs.b.H;
695  break;
696case 0x5D: /*      LD E,L */
697
698  Regs.b.E = Regs.b.L;
699  break;
700case 0x5E: /*      LD E,(HL) */
701
702  Regs.b.E = mem_ReadByte (Regs.w.HL);
703  break;
704case 0x5F: /*      LD E,A */
705
706  Regs.b.E = Regs.b.A;
707  break;
708case 0x60: /*      LD H,B */
709
710  Regs.b.H = Regs.b.B;
711  break;
712case 0x61: /*      LD H,C */
713
714  Regs.b.H = Regs.b.C;
715  break;
716case 0x62: /*      LD H,D */
717
718  Regs.b.H = Regs.b.D;
719  break;
720case 0x63: /*      LD H,E */
721
722  Regs.b.H = Regs.b.E;
723  break;
724case 0x64: /*      LD H,H */
725  break;
726case 0x65: /*      LD H,L */
727
728  Regs.b.H = Regs.b.L;
729  break;
730case 0x66: /*      LD H,(HL) */
731
732  Regs.b.H = mem_ReadByte (Regs.w.HL);
733  break;
734case 0x67: /*      LD H,A */
735
736  Regs.b.H = Regs.b.A;
737  break;
738case 0x68: /*      LD L,B */
739
740  Regs.b.L = Regs.b.B;
741  break;
742case 0x69: /*      LD L,C */
743
744  Regs.b.L = Regs.b.C;
745  break;
746case 0x6A: /*      LD L,D */
747  Regs.b.L = Regs.b.D;
748  break;
749case 0x6B: /*      LD L,E */
750
751  Regs.b.L = Regs.b.E;
752  break;
753case 0x6C: /*      LD L,H */
754
755  Regs.b.L = Regs.b.H;
756  break;
757case 0x6D: /*      LD L,L */
758  break;
759case 0x6E: /*      LD L,(HL) */
760
761  Regs.b.L = mem_ReadByte (Regs.w.HL);
762  break;
763case 0x6F: /*      LD L,A */
764
765  Regs.b.L = Regs.b.A;
766  break;
767case 0x70: /*      LD (HL),B */
768
769  mem_WriteByte (Regs.w.HL, Regs.b.B);
770  break;
771case 0x71: /*      LD (HL),C */
772
773  mem_WriteByte (Regs.w.HL, Regs.b.C);
774  break;
775case 0x72: /*      LD (HL),D */
776
777  mem_WriteByte (Regs.w.HL, Regs.b.D);
778  break;
779case 0x73: /*      LD (HL),E */
780
781  mem_WriteByte (Regs.w.HL, Regs.b.E);
782  break;
783case 0x74: /*      LD (HL),H */
784
785  mem_WriteByte (Regs.w.HL, Regs.b.H);
786  break;
787case 0x75: /*      LD (HL),L */
788
789  mem_WriteByte (Regs.w.HL, Regs.b.L);
790  break;
791case 0x76: /*      HALT */
792   Regs.w.enable |= HALTED;
793   Regs.w.haltIFstatus = Regs.w.IF & Regs.w.IE;
794   Regs.w.PC--;
795  break;
796case 0x77: /*      LD (HL),A */
797
798  mem_WriteByte (Regs.w.HL, Regs.b.A);
799  break;
800case 0x78: /*      LD A,B */
801
802  Regs.b.A = Regs.b.B;
803  break;
804case 0x79: /*      LD A,C */
805
806  Regs.b.A = Regs.b.C;
807  break;
808case 0x7A: /*      LD A,D */
809
810  Regs.b.A = Regs.b.D;
811  break;
812case 0x7B: /*      LD A,E */
813
814  Regs.b.A = Regs.b.E;
815  break;
816case 0x7C: /*      LD A,H */
817
818  Regs.b.A = Regs.b.H;
819  break;
820case 0x7D: /*      LD A,L */
821
822  Regs.b.A = Regs.b.L;
823  break;
824case 0x7E: /*      LD A,(HL) */
825
826  Regs.b.A = mem_ReadByte (Regs.w.HL);
827  break;
828case 0x7F: /*      LD A,A */
829  break;
830case 0x80: /*      ADD A,B */
831
832  ADD_A_X (Regs.b.B)
833  break;
834case 0x81: /*      ADD A,C */
835
836  ADD_A_X (Regs.b.C)
837  break;
838case 0x82: /*      ADD A,D */
839
840  ADD_A_X (Regs.b.D)
841  break;
842case 0x83: /*      ADD A,E */
843
844  ADD_A_X (Regs.b.E)
845  break;
846case 0x84: /*      ADD A,H */
847
848  ADD_A_X (Regs.b.H)
849  break;
850case 0x85: /*      ADD A,L */
851
852  ADD_A_X (Regs.b.L)
853  break;
854case 0x86: /*      ADD A,(HL) */
855
856  x = mem_ReadByte (Regs.w.HL);
857
858  ADD_A_X (x)
859  break;
860case 0x87: /*      ADD A,A */
861
862  ADD_A_X (Regs.b.A)
863  break;
864case 0x88: /*      ADC A,B */
865
866  ADC_A_X (Regs.b.B)
867  break;
868case 0x89: /*      ADC A,C */
869
870  ADC_A_X (Regs.b.C)
871  break;
872case 0x8A: /*      ADC A,D */
873
874  ADC_A_X (Regs.b.D)
875  break;
876case 0x8B: /*      ADC A,E */
877
878  ADC_A_X (Regs.b.E)
879  break;
880case 0x8C: /*      ADC A,H */
881
882  ADC_A_X (Regs.b.H)
883  break;
884case 0x8D: /*      ADC A,L */
885
886  ADC_A_X (Regs.b.L)
887  break;
888case 0x8E: /*      ADC A,(HL) */
889
890  x = mem_ReadByte (Regs.w.HL);
891
892  ADC_A_X (x)
893  break;
894case 0x8F: /*      ADC A,A */
895
896  ADC_A_X (Regs.b.A)
897  break;
898case 0x90: /*      SUB A,B */
899
900  SUB_A_X (Regs.b.B)
901  break;
902case 0x91: /*      SUB A,C */
903
904  SUB_A_X (Regs.b.C)
905  break;
906case 0x92: /*      SUB A,D */
907
908  SUB_A_X (Regs.b.D)
909  break;
910case 0x93: /*      SUB A,E */
911
912  SUB_A_X (Regs.b.E)
913  break;
914case 0x94: /*      SUB A,H */
915
916  SUB_A_X (Regs.b.H)
917  break;
918case 0x95: /*      SUB A,L */
919
920  SUB_A_X (Regs.b.L)
921  break;
922case 0x96: /*      SUB A,(HL) */
923
924
925  x = mem_ReadByte (Regs.w.HL);
926
927  SUB_A_X (x)
928  break;
929case 0x97: /*      SUB A,A */
930
931  SUB_A_X (Regs.b.A)
932  break;
933case 0x98: /*      SBC A,B */
934
935  SBC_A_X (Regs.b.B)
936  break;
937case 0x99: /*      SBC A,C */
938
939  SBC_A_X (Regs.b.C)
940  break;
941case 0x9A: /*      SBC A,D */
942
943  SBC_A_X (Regs.b.D)
944  break;
945case 0x9B: /*      SBC A,E */
946
947  SBC_A_X (Regs.b.E)
948  break;
949case 0x9C: /*      SBC A,H */
950
951  SBC_A_X (Regs.b.H)
952  break;
953case 0x9D: /*      SBC A,L */
954
955  SBC_A_X (Regs.b.L)
956  break;
957case 0x9E: /*      SBC A,(HL) */
958
959  x = mem_ReadByte (Regs.w.HL);
960
961  SBC_A_X (x)
962  break;
963case 0x9F: /*      SBC A,A */
964
965  SBC_A_X (Regs.b.A)
966  break;
967case 0xA0: /*      AND A,B */
968
969  AND_A_X (Regs.b.B)
970  break;
971case 0xA1: /*      AND A,C */
972
973  AND_A_X (Regs.b.C)
974  break;
975case 0xA2: /*      AND A,D */
976
977  AND_A_X (Regs.b.D)
978  break;
979case 0xA3: /*      AND A,E */
980
981  AND_A_X (Regs.b.E)
982  break;
983case 0xA4: /*      AND A,H */
984
985  AND_A_X (Regs.b.H)
986  break;
987case 0xA5: /*      AND A,L */
988
989  AND_A_X (Regs.b.L)
990  break;
991case 0xA6: /*      AND A,(HL) */
992
993  x = mem_ReadByte (Regs.w.HL);
994
995  AND_A_X (x)
996  break;
997case 0xA7: /*      AND A,A */
998
999  Regs.b.F = (Regs.b.A == 0) ? (FLAG_H | FLAG_Z) : FLAG_H;
1000  break;
1001case 0xA8: /*      XOR A,B */
1002
1003  XOR_A_X (Regs.b.B)
1004  break;
1005case 0xA9: /*      XOR A,C */
1006
1007  XOR_A_X (Regs.b.C)
1008  break;
1009case 0xAA: /*      XOR A,D */
1010
1011  XOR_A_X (Regs.b.D)
1012  break;
1013case 0xAB: /*      XOR A,E */
1014
1015  XOR_A_X (Regs.b.E)
1016  break;
1017case 0xAC: /*      XOR A,H */
1018
1019  XOR_A_X (Regs.b.H)
1020  break;
1021case 0xAD: /*      XOR A,L */
1022
1023  XOR_A_X (Regs.b.L)
1024  break;
1025case 0xAE: /*      XOR A,(HL) */
1026
1027  x = mem_ReadByte (Regs.w.HL);
1028
1029  XOR_A_X (x)
1030  break;
1031case 0xAF: /*      XOR A,A */
1032
1033  XOR_A_X (Regs.b.A)
1034  break;
1035case 0xB0: /*      OR A,B */
1036
1037  OR_A_X (Regs.b.B)
1038  break;
1039case 0xB1: /*      OR A,C */
1040
1041  OR_A_X (Regs.b.C)
1042  break;
1043case 0xB2: /*      OR A,D */
1044
1045  OR_A_X (Regs.b.D)
1046  break;
1047case 0xB3: /*      OR A,E */
1048
1049  OR_A_X (Regs.b.E)
1050  break;
1051case 0xB4: /*      OR A,H */
1052
1053  OR_A_X (Regs.b.H)
1054  break;
1055case 0xB5: /*      OR A,L */
1056
1057  OR_A_X (Regs.b.L)
1058  break;
1059case 0xB6: /*      OR A,(HL) */
1060
1061  x = mem_ReadByte (Regs.w.HL);
1062
1063  OR_A_X (x)
1064  break;
1065case 0xB7: /*      OR A,A */
1066
1067  OR_A_X (Regs.b.A)
1068  break;
1069case 0xB8: /*      CP A,B */
1070
1071  CP_A_X (Regs.b.B)
1072  break;
1073case 0xB9: /*      CP A,C */
1074
1075  CP_A_X (Regs.b.C)
1076  break;
1077case 0xBA: /*      CP A,D */
1078
1079  CP_A_X (Regs.b.D)
1080  break;
1081case 0xBB: /*      CP A,E */
1082
1083  CP_A_X (Regs.b.E)
1084  break;
1085case 0xBC: /*      CP A,H */
1086
1087  CP_A_X (Regs.b.H)
1088  break;
1089case 0xBD: /*      CP A,L */
1090
1091  CP_A_X (Regs.b.L)
1092  break;
1093case 0xBE: /*      CP A,(HL) */
1094
1095  x = mem_ReadByte (Regs.w.HL);
1096
1097  CP_A_X (x)
1098  break;
1099case 0xBF: /*      CP A,A */
1100
1101  CP_A_X (Regs.b.A)
1102  break;
1103case 0xC0: /*      RET NZ */
1104
1105  if (!(Regs.b.F & FLAG_Z))
1106  {
1107    Regs.w.PC = mem_ReadWord (Regs.w.SP);
1108    Regs.w.SP += 2;
1109    CYCLES_PASSED( 12 );
1110  }
1111  break;
1112case 0xC1: /*      POP BC */
1113
1114  Regs.w.BC = mem_ReadWord (Regs.w.SP);
1115  Regs.w.SP += 2;
1116  break;
1117case 0xC2: /*      JP NZ,n16 */
1118
1119  if (Regs.b.F & FLAG_Z)
1120  {
1121    Regs.w.PC += 2;
1122  }
1123  else
1124  {
1125    Regs.w.PC = mem_ReadWord (Regs.w.PC);
1126    CYCLES_PASSED( 4 );
1127  }
1128  break;
1129case 0xC3: /*      JP n16 */
1130
1131  Regs.w.PC = mem_ReadWord (Regs.w.PC);
1132  break;
1133case 0xC4: /*      CALL NZ,n16 */
1134
1135  if (Regs.b.F & FLAG_Z)
1136  {
1137    Regs.w.PC += 2;
1138  }
1139  else
1140  {
1141   register UINT16 PC;
1142    PC = mem_ReadWord (Regs.w.PC);
1143    Regs.w.PC += 2;
1144
1145    Regs.w.SP -= 2;
1146    mem_WriteWord (Regs.w.SP, Regs.w.PC);
1147    Regs.w.PC = PC;
1148    CYCLES_PASSED( 12 );
1149  }
1150  break;
1151case 0xC5: /*      PUSH BC */
1152
1153  Regs.w.SP -= 2;
1154  mem_WriteWord (Regs.w.SP, Regs.w.BC);
1155  break;
1156case 0xC6: /*      ADD A,n8 */
1157
1158  x = mem_ReadByte (Regs.w.PC++);
1159  ADD_A_X (x)
1160  break;
1161case 0xC7: /*      RST 0 */
1162
1163  {
1164   register UINT16 PC;
1165    PC = Regs.w.PC;
1166    Regs.w.PC = 0;
1167
1168    Regs.w.SP -= 2;
1169    mem_WriteWord (Regs.w.SP, PC);
1170  }
1171  break;
1172case 0xC8: /*      RET Z */
1173
1174  if (Regs.b.F & FLAG_Z)
1175  {
1176    Regs.w.PC = mem_ReadWord (Regs.w.SP);
1177    Regs.w.SP += 2;
1178    CYCLES_PASSED( 12 );
1179  }
1180  break;
1181case 0xC9: /*      RET */
1182
1183  Regs.w.PC = mem_ReadWord (Regs.w.SP);
1184  Regs.w.SP += 2;
1185  break;
1186case 0xCA: /*      JP Z,n16 */
1187
1188  if (Regs.b.F & FLAG_Z)
1189  {
1190    Regs.w.PC = mem_ReadWord (Regs.w.PC);
1191    CYCLES_PASSED( 4 );
1192  }
1193  else
1194  {
1195    Regs.w.PC += 2;
1196  }
1197  break;
1198case 0xCB: /*      PREFIX! */
1199  x = mem_ReadByte (Regs.w.PC++);
1200  CYCLES_PASSED( CyclesCB[x] );
1201  switch (x)
1202  {
1203    #include "opc_cb.h"
1204  }
1205  break;
1206case 0xCC: /*      CALL Z,n16 */
1207
1208  if (Regs.b.F & FLAG_Z)
1209  {
1210   register UINT16 PC;
1211    PC = mem_ReadWord (Regs.w.PC);
1212    Regs.w.PC += 2;
1213
1214    Regs.w.SP -= 2;
1215    mem_WriteWord (Regs.w.SP, Regs.w.PC);
1216    Regs.w.PC = PC;
1217    CYCLES_PASSED( 12 );
1218  }
1219  else
1220  {
1221    Regs.w.PC += 2;
1222  }
1223  break;
1224case 0xCD: /*      CALL n16 */
1225  {
1226   register UINT16 PC;
1227    PC = mem_ReadWord (Regs.w.PC);
1228    Regs.w.PC += 2;
1229
1230    Regs.w.SP -= 2;
1231    mem_WriteWord (Regs.w.SP, Regs.w.PC);
1232    Regs.w.PC = PC;
1233  }
1234  break;
1235case 0xCE: /*      ADC A,n8 */
1236
1237  x = mem_ReadByte (Regs.w.PC++);
1238  ADC_A_X (x)
1239  break;
1240case 0xCF: /*      RST 8 */
1241
1242  Regs.w.SP -= 2;
1243  mem_WriteWord (Regs.w.SP, Regs.w.PC);
1244  Regs.w.PC = 8;
1245  break;
1246case 0xD0: /*      RET NC */
1247
1248  if (!(Regs.b.F & FLAG_C))
1249  {
1250    Regs.w.PC = mem_ReadWord (Regs.w.SP);
1251    Regs.w.SP += 2;
1252    CYCLES_PASSED( 12 );
1253  }
1254  break;
1255case 0xD1: /*      POP DE */
1256
1257  Regs.w.DE = mem_ReadWord (Regs.w.SP);
1258  Regs.w.SP += 2;
1259  break;
1260case 0xD2: /*      JP NC,n16 */
1261
1262  if (Regs.b.F & FLAG_C)
1263  {
1264    Regs.w.PC += 2;
1265  }
1266  else
1267  {
1268    Regs.w.PC = mem_ReadWord (Regs.w.PC);
1269    CYCLES_PASSED( 4 );
1270  }
1271  break;
1272case 0xD3: /*      EH? */
1273  break;
1274case 0xD4: /*      CALL NC,n16 */
1275
1276  if (Regs.b.F & FLAG_C)
1277  {
1278    Regs.w.PC += 2;
1279  }
1280  else
1281  {
1282   register UINT16 PC;
1283    PC = mem_ReadWord (Regs.w.PC);
1284    Regs.w.PC += 2;
1285
1286    Regs.w.SP -= 2;
1287    mem_WriteWord (Regs.w.SP, Regs.w.PC);
1288    Regs.w.PC = PC;
1289    CYCLES_PASSED( 12 );
1290  }
1291  break;
1292case 0xD5: /*      PUSH DE */
1293
1294  Regs.w.SP -= 2;
1295  mem_WriteWord (Regs.w.SP, Regs.w.DE);
1296  break;
1297case 0xD6: /*      SUB A,n8 */
1298
1299  x = mem_ReadByte (Regs.w.PC++);
1300  SUB_A_X (x)
1301  break;
1302case 0xD7: /*      RST     $10 */
1303
1304  Regs.w.SP -= 2;
1305  mem_WriteWord (Regs.w.SP, Regs.w.PC);
1306  Regs.w.PC = 0x10;
1307  break;
1308case 0xD8: /*      RET C */
1309
1310  if (Regs.b.F & FLAG_C)
1311  {
1312    Regs.w.PC = mem_ReadWord (Regs.w.SP);
1313    Regs.w.SP += 2;
1314    CYCLES_PASSED( 12 );
1315  }
1316  break;
1317case 0xD9: /*      RETI */
1318
1319  Regs.w.PC = mem_ReadWord (Regs.w.SP);
1320  Regs.w.SP += 2;
1321  Regs.w.enable |= IME;
1322  break;
1323case 0xDA: /*      JP C,n16 */
1324
1325  if (Regs.b.F & FLAG_C)
1326  {
1327    Regs.w.PC = mem_ReadWord (Regs.w.PC);
1328    CYCLES_PASSED( 4 );
1329  }
1330  else
1331  {
1332    Regs.w.PC += 2;
1333  }
1334  break;
1335case 0xDB: /*      EH? */
1336  break;
1337case 0xDC: /*      CALL C,n16 */
1338
1339  if (Regs.b.F & FLAG_C)
1340  {
1341   register UINT16 PC;
1342    PC = mem_ReadWord (Regs.w.PC);
1343    Regs.w.PC += 2;
1344
1345    Regs.w.SP -= 2;
1346    mem_WriteWord (Regs.w.SP, Regs.w.PC);
1347    Regs.w.PC = PC;
1348    CYCLES_PASSED( 12 );
1349  }
1350  else
1351  {
1352    Regs.w.PC += 2;
1353  }
1354  break;
1355case 0xDD: /*      EH? */
1356  break;
1357case 0xDE: /*      SBC A,n8 */
1358
1359  x = mem_ReadByte (Regs.w.PC++);
1360  SBC_A_X (x)
1361  break;
1362case 0xDF: /*      RST     $18 */
1363
1364  Regs.w.SP -= 2;
1365  mem_WriteWord (Regs.w.SP, Regs.w.PC);
1366  Regs.w.PC = 0x18;
1367  break;
1368case 0xE0: /*      LD      ($FF00+n8),A */
1369  mem_WriteByte (mem_ReadByte (Regs.w.PC++) + 0xFF00, Regs.b.A);
1370  break;
1371case 0xE1: /*      POP HL */
1372
1373  Regs.w.HL = mem_ReadWord (Regs.w.SP);
1374  Regs.w.SP += 2;
1375  break;
1376case 0xE2: /*      LD ($FF00+C),A */
1377
1378  mem_WriteByte ((UINT16) (0xFF00 + Regs.b.C), Regs.b.A);
1379  break;
1380case 0xE3: /*      EH? */
1381  break;
1382case 0xE4: /*      EH? */
1383  break;
1384case 0xE5: /*      PUSH HL */
1385
1386  Regs.w.SP -= 2;
1387  mem_WriteWord (Regs.w.SP, Regs.w.HL);
1388  break;
1389case 0xE6: /*      AND A,n8 */
1390
1391  x = mem_ReadByte (Regs.w.PC++);
1392  AND_A_X (x)
1393  break;
1394case 0xE7: /*      RST $20 */
1395
1396  Regs.w.SP -= 2;
1397  mem_WriteWord (Regs.w.SP, Regs.w.PC);
1398  Regs.w.PC = 0x20;
1399  break;
1400case 0xE8: /*      ADD SP,n8 */
1401/*
1402 *   Z - Reset.
1403 *   N - Reset.
1404 *   H - Set or reset according to operation.
1405 *   C - Set or reset according to operation.
1406 */
1407
1408  {
1409   register INT32 n;
1410
1411   n = (INT32) ((INT8) mem_ReadByte (Regs.w.PC++));
1412
1413   if ( ( Regs.w.SP & 0xFF ) + (UINT8)(n & 0xFF) > 0xFF )
1414    {
1415      Regs.b.F = FLAG_C;
1416    }
1417    else
1418    {
1419      Regs.b.F = 0;
1420    }
1421
1422    if ( ( Regs.w.SP & 0x0F ) + ( n & 0x0F ) > 0x0F )
1423    {
1424      Regs.b.F |= FLAG_H;
1425    }
1426
1427   Regs.w.SP = (UINT16) ( Regs.w.SP + n );
1428  }
1429  break;
1430case 0xE9: /*      JP (HL) */
1431
1432  Regs.w.PC = Regs.w.HL;
1433  break;
1434case 0xEA: /*      LD (n16),A */
1435
1436  mem_WriteByte (mem_ReadWord (Regs.w.PC), Regs.b.A);
1437  Regs.w.PC += 2;
1438  break;
1439case 0xEB: /*      EH? */
1440  break;
1441case 0xEC: /*      EH? */
1442  break;
1443case 0xED: /*      EH? */
1444  break;
1445case 0xEE: /*      XOR A,n8 */
1446
1447  x = mem_ReadByte (Regs.w.PC++);
1448  XOR_A_X (x)
1449  break;
1450case 0xEF: /*      RST $28 */
1451
1452  Regs.w.SP -= 2;
1453  mem_WriteWord (Regs.w.SP, Regs.w.PC);
1454  Regs.w.PC = 0x28;
1455  break;
1456case 0xF0: /*      LD A,($FF00+n8) */
1457
1458  Regs.b.A = mem_ReadByte (0xFF00 + mem_ReadByte (Regs.w.PC++));
1459  break;
1460case 0xF1: /*      POP AF */
1461
1462  Regs.w.AF = (UINT16) (mem_ReadWord (Regs.w.SP) & 0xFFF0);
1463  Regs.w.SP += 2;
1464  break;
1465case 0xF2: /*      LD A,($FF00+C) */
1466
1467  Regs.b.A = mem_ReadByte ((UINT16) (0xFF00 + Regs.b.C));
1468  break;
1469case 0xF3: /*      DI */
1470  Regs.w.ei_delay = 0;
1471  Regs.w.enable &= ~IME;
1472  break;
1473case 0xF4: /*      EH? */
1474  break;
1475case 0xF5: /*      PUSH AF */
1476
1477  Regs.w.SP -= 2;
1478  mem_WriteWord (Regs.w.SP, (UINT16) (Regs.w.AF & 0xFFF0));
1479  break;
1480case 0xF6: /*      OR A,n8 */
1481
1482  x = mem_ReadByte (Regs.w.PC++);
1483  OR_A_X (x)
1484  break;
1485case 0xF7: /*      RST $30 */
1486
1487  Regs.w.SP -= 2;
1488  mem_WriteWord (Regs.w.SP, Regs.w.PC);
1489  Regs.w.PC = 0x30;
1490  break;
1491case 0xF8: /*      LD HL,SP+n8 */
1492/*
1493 *   n = one UINT8 signed immediate value.
1494 * Flags affected:
1495 *   Z - Reset.
1496 *   N - Reset.
1497 *   H - Set or reset according to operation.
1498 *   C - Set or reset according to operation.
1499 *
1500 */
1501
1502  {
1503   register INT32 n;
1504
1505   n = (INT32) ((INT8) mem_ReadByte (Regs.w.PC++));
1506
1507   if ( ( Regs.w.SP & 0xFF ) + (UINT8)(n & 0xFF) > 0xFF )
1508    {
1509      Regs.b.F = FLAG_C;
1510    }
1511    else
1512    {
1513      Regs.b.F = 0;
1514    }
1515
1516   if ( ( Regs.w.SP & 0x0F ) + ( n & 0x0F ) > 0x0F )
1517    {
1518      Regs.b.F |= FLAG_H;
1519    }
1520
1521   Regs.w.HL = (UINT16) ( Regs.w.SP + n );
1522  }
1523  break;
1524case 0xF9: /*      LD SP,HL */
1525
1526  Regs.w.SP = Regs.w.HL;
1527  break;
1528case 0xFA: /*      LD A,(n16) */
1529
1530  Regs.b.A = mem_ReadByte (mem_ReadWord (Regs.w.PC));
1531  Regs.w.PC += 2;
1532  break;
1533case 0xFB: /*      EI */
1534
1535  Regs.w.enable |= IME;
1536  Regs.w.ei_delay = 1;
1537  break;
1538case 0xFC: /*      EH? */
1539  break;
1540case 0xFD: /*      EH? */
1541  break;
1542case 0xFE: /*      CP A,n8 */
1543
1544  x = mem_ReadByte (Regs.w.PC++);
1545  CP_A_X (x)
1546  break;
1547case 0xFF: /*      RST $38 */
1548
1549  Regs.w.SP -= 2;
1550  mem_WriteWord (Regs.w.SP, Regs.w.PC);
1551  Regs.w.PC = 0x38;
1552  break;
src/emu/cpuintrf.c
r2856r2857
206206void sc61860_get_info(UINT32 state, cpuinfo *info);
207207void tx0_64kw_get_info(UINT32 state, cpuinfo *info);
208208void tx0_8kw_get_info(UINT32 state, cpuinfo *info);
209void z80gb_get_info(UINT32 state, cpuinfo *info);
209void lr35902_get_info(UINT32 state, cpuinfo *info);
210210void tms7000_get_info(UINT32 state, cpuinfo *info);
211211void tms7000_exl_get_info(UINT32 state, cpuinfo *info);
212212void sm8500_get_info(UINT32 state, cpuinfo *info);
r2856r2857
809809#if (HAS_TX0_8KW)
810810   { CPU_TX0_8KW, tx0_8kw_get_info },
811811#endif
812#if (HAS_Z80GB)
813   { CPU_Z80GB, z80gb_get_info },
812#if (HAS_LR35902)
813   { CPU_LR35902, lr35902_get_info },
814814#endif
815815#if (HAS_TMS7000)
816816   { CPU_TMS7000, tms7000_get_info },
src/emu/cpuexec.h
r2856r2857
234234   CPU_SC61860,
235235   CPU_TX0_64KW,
236236   CPU_TX0_8KW,
237   CPU_Z80GB,
237   CPU_LR35902,
238238   CPU_TMS7000,
239239   CPU_TMS7000_EXL,
240240   CPU_SM8500,
src/mess/video/gb.c
r2856r2857
1313
1414#include "driver.h"
1515#include "includes/gb.h"
16#include "cpu/z80gb/z80gb.h"
16#include "cpu/lr35902/lr35902.h"
1717#include "profiler.h"
1818
1919
r2856r2857
16261626            /* Check for HBLANK DMA */
16271627         if( gb_lcd.hdma_enabled ) {
16281628            gbc_hdma(0x10);
1629//            cpunum_set_reg( 0, Z80GB_DMA_CYCLES, 36 );
1629//            cpunum_set_reg( 0, LR35902_DMA_CYCLES, 36 );
16301630         } else {
16311631            gb_lcd.hdma_possible = 1;
16321632         }
r2856r2857
21142114         {
21152115            /* General DMA */
21162116            gbc_hdma( ((data & 0x7F) + 1) * 0x10 );
2117//            cpunum_set_reg( 0, Z80GB_DMA_CYCLES, 4 + ( ( ( data & 0x7F ) + 1 ) * 32 ) );
2117//            cpunum_set_reg( 0, LR35902_DMA_CYCLES, 4 + ( ( ( data & 0x7F ) + 1 ) * 32 ) );
21182118            data = 0xff;
21192119         }
21202120      }
r2856r2857
21272127         /* Check if HDMA should be immediately performed */
21282128         if ( gb_lcd.hdma_possible ) {
21292129            gbc_hdma( 0x10 );
2130//            cpunum_set_reg( 0, Z80GB_DMA_CYCLES, 36 );
2130//            cpunum_set_reg( 0, LR35902_DMA_CYCLES, 36 );
21312131            gb_lcd.hdma_possible = 0;
21322132         }
21332133      }
src/mess/machine/gb.c
r2856r2857
3838#include "driver.h"
3939#include "deprecat.h"
4040#include "includes/gb.h"
41#include "cpu/z80gb/z80gb.h"
41#include "cpu/lr35902/lr35902.h"
4242#include "image.h"
4343
4444/* Memory bank controller types */
r2856r2857
810810      break;
811811   case 0x0F:                  /* IF - Interrupt flag */
812812      data &= 0x1F;
813      cpunum_set_reg( 0, Z80GB_IF, data );
813      cpunum_set_reg( 0, LR35902_IF, data );
814814      break;
815815   }
816816
r2856r2857
13501350/* Interrupt Enable register */
13511351READ8_HANDLER( gb_ie_r )
13521352{
1353   return cpunum_get_reg( 0, Z80GB_IE );
1353   return cpunum_get_reg( 0, LR35902_IE );
13541354}
13551355
13561356WRITE8_HANDLER ( gb_ie_w )
13571357{
1358   cpunum_set_reg( 0, Z80GB_IE, data & 0x1F );
1358   cpunum_set_reg( 0, LR35902_IE, data & 0x1F );
13591359}
13601360
13611361/* IO read */
r2856r2857
13751375         return gb_io[offset];
13761376      case 0x0F:
13771377         /* Make sure the internal states are up to date */
1378         return 0xE0 | cpunum_get_reg( 0, Z80GB_IF );
1378         return 0xE0 | cpunum_get_reg( 0, LR35902_IF );
13791379      default:
13801380         /* It seems unsupported registers return 0xFF */
13811381         return 0xFF;
r2856r2857
18691869{
18701870   switch( offset ) {
18711871      case 0x0D:   /* KEY1 - Prepare speed switch */
1872         cpunum_set_reg( 0, Z80GB_SPEED, data );
1872         cpunum_set_reg( 0, LR35902_SPEED, data );
18731873         return;
18741874      case 0x16:   /* RP - Infrared port */
18751875         break;
r2856r2857
18861886READ8_HANDLER( gbc_io2_r ) {
18871887   switch( offset ) {
18881888   case 0x0D:   /* KEY1 */
1889      return cpunum_get_reg( 0, Z80GB_SPEED );
1889      return cpunum_get_reg( 0, LR35902_SPEED );
18901890   case 0x16:   /* RP - Infrared port */
18911891      break;
18921892   default:
src/mess/drivers/gb.c
r2856r2857
437437
438438#include "driver.h"
439439#include "includes/gb.h"
440#include "cpu/z80gb/z80gb.h"
440#include "cpu/lr35902/lr35902.h"
441441#include "devices/cartslot.h"
442442#include "rendlay.h"
443443#include "gb.lh"
r2856r2857
449449static const UINT16 cgb_cpu_regs[6] = { 0x11B0, 0x0013, 0x00D8, 0x014D, 0xFFFE, 0x0100 };   /* Game Boy Color  / Game Boy Advance */
450450static const UINT16 megaduck_cpu_regs[6] = { 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFE, 0x0000 };   /* Megaduck */
451451
452static const Z80GB_CONFIG dmg_cpu_reset = { NULL, Z80GB_FEATURE_HALT_BUG, gb_timer_callback };
453static const Z80GB_CONFIG sgb_cpu_reset = { sgb_cpu_regs, Z80GB_FEATURE_HALT_BUG, gb_timer_callback };
454static const Z80GB_CONFIG mgb_cpu_reset = { mgb_cpu_regs, Z80GB_FEATURE_HALT_BUG, gb_timer_callback };
455static const Z80GB_CONFIG cgb_cpu_reset = { cgb_cpu_regs, 0, gb_timer_callback };
456static const Z80GB_CONFIG megaduck_cpu_reset = { megaduck_cpu_regs, Z80GB_FEATURE_HALT_BUG, gb_timer_callback };
452static const LR35902_CONFIG dmg_cpu_reset = { NULL, LR35902_FEATURE_HALT_BUG, gb_timer_callback };
453static const LR35902_CONFIG sgb_cpu_reset = { sgb_cpu_regs, LR35902_FEATURE_HALT_BUG, gb_timer_callback };
454static const LR35902_CONFIG mgb_cpu_reset = { mgb_cpu_regs, LR35902_FEATURE_HALT_BUG, gb_timer_callback };
455static const LR35902_CONFIG cgb_cpu_reset = { cgb_cpu_regs, 0, gb_timer_callback };
456static const LR35902_CONFIG megaduck_cpu_reset = { megaduck_cpu_regs, LR35902_FEATURE_HALT_BUG, gb_timer_callback };
457457
458458static ADDRESS_MAP_START(gb_map, ADDRESS_SPACE_PROGRAM, 8)
459459   ADDRESS_MAP_UNMAP_HIGH
r2856r2857
553553
554554static MACHINE_DRIVER_START( gameboy )
555555   /* basic machine hardware */
556   MDRV_CPU_ADD_TAG("main", Z80GB, 4194304)         /* 4.194304 Mhz */
556   MDRV_CPU_ADD_TAG("main", LR35902, 4194304)         /* 4.194304 Mhz */
557557   MDRV_CPU_PROGRAM_MAP(gb_map, 0)
558558   MDRV_CPU_CONFIG(dmg_cpu_reset)
559559   MDRV_CPU_VBLANK_INT("main", gb_scanline_interrupt)   /* 1 dummy int each frame */
r2856r2857
588588
589589static MACHINE_DRIVER_START( supergb )
590590   MDRV_IMPORT_FROM(gameboy)
591   MDRV_CPU_REPLACE("main", Z80GB, 4295454)   /* 4.295454 Mhz */
591   MDRV_CPU_REPLACE("main", LR35902, 4295454)   /* 4.295454 Mhz */
592592   MDRV_CPU_PROGRAM_MAP(sgb_map, 0)
593593
594594   MDRV_CPU_MODIFY("main")
r2856r2857
671671
672672static MACHINE_DRIVER_START( megaduck )
673673   /* basic machine hardware */
674   MDRV_CPU_ADD_TAG("main", Z80GB, 4194304)         /* 4.194304 Mhz */
674   MDRV_CPU_ADD_TAG("main", LR35902, 4194304)         /* 4.194304 Mhz */
675675   MDRV_CPU_PROGRAM_MAP( megaduck_map, 0 )
676676   MDRV_CPU_VBLANK_INT("main", gb_scanline_interrupt)   /* 1 int each scanline ! */
677677   MDRV_CPU_CONFIG(megaduck_cpu_reset)
src/mess/mess.mak
r2856r2857
210210CPUS += SC61860
211211CPUS += TX0_64KW
212212CPUS += TX0_8KW
213CPUS += Z80GB
213CPUS += LR35902
214214#CPUS += TMS7000
215215CPUS += TMS7000_EXL
216216CPUS += SM8500

Previous 15994 Revisions Next


© 1998-2018 The MESS Team