src/emu/cpu/lr35902/lr35902.c
| r0 | r2857 | |
| 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 | |
| 52 | typedef 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 |
| 82 | typedef 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 |
| 93 | typedef 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 | |
| 105 | typedef union { |
| 106 | lr35902_16BitRegs w; |
| 107 | lr35902_8BitRegs b; |
| 108 | } lr35902_regs; |
| 109 | |
| 110 | typedef int (*OpcodeEmulator) (void); |
| 111 | |
| 112 | static 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 | |
| 124 | INLINE 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 | |
| 131 | INLINE 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 */ |
| 138 | static int lr35902_ICount; |
| 139 | |
| 140 | static 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 | |
| 160 | static 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 | |
| 180 | static 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 | /************************************************************/ |
| 191 | static 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 | |
| 225 | INLINE 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 | /************************************************************/ |
| 294 | static 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 | |
| 328 | static 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 | /****************************************************************************/ |
| 341 | static 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 | /****************************************************************************/ |
| 351 | static void lr35902_get_context (void *dst) |
| 352 | { |
| 353 | if( dst ) |
| 354 | *(lr35902_regs *)dst = Regs; |
| 355 | } |
| 356 | |
| 357 | |
| 358 | |
| 359 | static 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 | |
| 387 | static 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 | |
| 413 | void 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
| r0 | r2857 | |
| 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 | |
| 25 | enum 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 | |
| 36 | static 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 | |
| 50 | static 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 | |
| 60 | typedef struct |
| 61 | { |
| 62 | UINT8 mnemonic; |
| 63 | const char *arguments; |
| 64 | } lr35902dasm; |
| 65 | |
| 66 | static 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 | |
| 133 | static 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 | |
| 204 | unsigned 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/opc_main.h
| r0 | r2857 | |
| 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 | |
| 140 | case 0x00: /* NOP */ |
| 141 | break; |
| 142 | case 0x01: /* LD BC,n16 */ |
| 143 | Regs.w.BC = mem_ReadWord (Regs.w.PC); |
| 144 | Regs.w.PC += 2; |
| 145 | break; |
| 146 | case 0x02: /* LD (BC),A */ |
| 147 | mem_WriteByte (Regs.w.BC, Regs.b.A); |
| 148 | break; |
| 149 | case 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; |
| 159 | case 0x04: /* INC B */ |
| 160 | |
| 161 | INC_8BIT (Regs.b.B) |
| 162 | break; |
| 163 | case 0x05: /* DEC B */ |
| 164 | |
| 165 | DEC_8BIT (Regs.b.B) |
| 166 | break; |
| 167 | case 0x06: /* LD B,n8 */ |
| 168 | |
| 169 | Regs.b.B = mem_ReadByte (Regs.w.PC++); |
| 170 | break; |
| 171 | case 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; |
| 183 | case 0x08: /* LD (n16),SP */ |
| 184 | |
| 185 | mem_WriteWord (mem_ReadWord (Regs.w.PC), Regs.w.SP); |
| 186 | Regs.w.PC += 2; |
| 187 | break; |
| 188 | case 0x09: /* ADD HL,BC */ |
| 189 | |
| 190 | ADD_HL_RR (Regs.w.BC) |
| 191 | break; |
| 192 | case 0x0A: /* LD A,(BC) */ |
| 193 | |
| 194 | Regs.b.A = mem_ReadByte (Regs.w.BC); |
| 195 | break; |
| 196 | case 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; |
| 207 | case 0x0C: /* INC C */ |
| 208 | |
| 209 | INC_8BIT (Regs.b.C) |
| 210 | break; |
| 211 | case 0x0D: /* DEC C */ |
| 212 | |
| 213 | DEC_8BIT (Regs.b.C) |
| 214 | break; |
| 215 | case 0x0E: /* LD C,n8 */ |
| 216 | |
| 217 | Regs.b.C = mem_ReadByte (Regs.w.PC++); |
| 218 | break; |
| 219 | case 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; |
| 228 | case 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; |
| 234 | case 0x11: /* LD DE,n16 */ |
| 235 | |
| 236 | Regs.w.DE = mem_ReadWord (Regs.w.PC); |
| 237 | Regs.w.PC += 2; |
| 238 | break; |
| 239 | case 0x12: /* LD (DE),A */ |
| 240 | mem_WriteByte (Regs.w.DE, Regs.b.A); |
| 241 | break; |
| 242 | case 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; |
| 253 | case 0x14: /* INC D */ |
| 254 | |
| 255 | INC_8BIT (Regs.b.D) |
| 256 | break; |
| 257 | case 0x15: /* DEC D */ |
| 258 | |
| 259 | DEC_8BIT (Regs.b.D) |
| 260 | break; |
| 261 | case 0x16: /* LD D,n8 */ |
| 262 | |
| 263 | Regs.b.D = mem_ReadByte (Regs.w.PC++); |
| 264 | break; |
| 265 | case 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; |
| 272 | case 0x18: /* JR n8 */ |
| 273 | { |
| 274 | INT8 offset; |
| 275 | |
| 276 | offset = mem_ReadByte (Regs.w.PC++); |
| 277 | Regs.w.PC += offset; |
| 278 | } |
| 279 | break; |
| 280 | case 0x19: /* ADD HL,DE */ |
| 281 | |
| 282 | ADD_HL_RR (Regs.w.DE) |
| 283 | break; |
| 284 | case 0x1A: /* LD A,(DE) */ |
| 285 | |
| 286 | Regs.b.A = mem_ReadByte (Regs.w.DE); |
| 287 | break; |
| 288 | case 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; |
| 299 | case 0x1C: /* INC E */ |
| 300 | |
| 301 | INC_8BIT (Regs.b.E) |
| 302 | break; |
| 303 | case 0x1D: /* DEC E */ |
| 304 | |
| 305 | DEC_8BIT (Regs.b.E) |
| 306 | break; |
| 307 | case 0x1E: /* LD E,n8 */ |
| 308 | |
| 309 | Regs.b.E = mem_ReadByte (Regs.w.PC++); |
| 310 | break; |
| 311 | case 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; |
| 318 | case 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; |
| 333 | case 0x21: /* LD HL,n16 */ |
| 334 | |
| 335 | Regs.w.HL = mem_ReadWord (Regs.w.PC); |
| 336 | Regs.w.PC += 2; |
| 337 | break; |
| 338 | case 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; |
| 350 | case 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; |
| 361 | case 0x24: /* INC H */ |
| 362 | |
| 363 | INC_8BIT (Regs.b.H); |
| 364 | break; |
| 365 | case 0x25: /* DEC H */ |
| 366 | |
| 367 | DEC_8BIT (Regs.b.H); |
| 368 | break; |
| 369 | case 0x26: /* LD H,n8 */ |
| 370 | |
| 371 | Regs.b.H = mem_ReadByte (Regs.w.PC++); |
| 372 | break; |
| 373 | case 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; |
| 399 | case 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; |
| 415 | case 0x29: /* ADD HL,HL */ |
| 416 | |
| 417 | ADD_HL_RR (Regs.w.HL) |
| 418 | break; |
| 419 | case 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; |
| 430 | case 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; |
| 441 | case 0x2C: /* INC L */ |
| 442 | |
| 443 | INC_8BIT (Regs.b.L); |
| 444 | break; |
| 445 | case 0x2D: /* DEC L */ |
| 446 | |
| 447 | DEC_8BIT (Regs.b.L); |
| 448 | break; |
| 449 | case 0x2E: /* LD L,n8 */ |
| 450 | |
| 451 | Regs.b.L = mem_ReadByte (Regs.w.PC++); |
| 452 | break; |
| 453 | case 0x2F: /* CPL */ |
| 454 | |
| 455 | Regs.b.A = ~Regs.b.A; |
| 456 | Regs.b.F |= FLAG_N | FLAG_H; |
| 457 | break; |
| 458 | case 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; |
| 473 | case 0x31: /* LD SP,n16 */ |
| 474 | |
| 475 | Regs.w.SP = mem_ReadWord (Regs.w.PC); |
| 476 | Regs.w.PC += 2; |
| 477 | break; |
| 478 | case 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; |
| 490 | case 0x33: /* INC SP */ |
| 491 | |
| 492 | Regs.w.SP += 1; |
| 493 | break; |
| 494 | case 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; |
| 512 | case 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; |
| 530 | case 0x36: /* LD (HL),n8 */ |
| 531 | /* FIXED / broken ? */ |
| 532 | mem_WriteByte (Regs.w.HL, mem_ReadByte (Regs.w.PC++)); |
| 533 | break; |
| 534 | case 0x37: /* SCF */ |
| 535 | |
| 536 | Regs.b.F = (UINT8) ((Regs.b.F & FLAG_Z) | FLAG_C); |
| 537 | break; |
| 538 | case 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; |
| 554 | case 0x39: /* ADD HL,SP */ |
| 555 | ADD_HL_RR (Regs.w.SP) |
| 556 | break; |
| 557 | case 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; |
| 568 | case 0x3B: /* DEC SP */ |
| 569 | |
| 570 | Regs.w.SP -= 1; |
| 571 | break; |
| 572 | case 0x3C: /* INC A */ |
| 573 | |
| 574 | INC_8BIT (Regs.b.A); |
| 575 | break; |
| 576 | case 0x3D: /* DEC A */ |
| 577 | |
| 578 | DEC_8BIT (Regs.b.A); |
| 579 | break; |
| 580 | case 0x3E: /* LD A,n8 */ |
| 581 | |
| 582 | Regs.b.A = mem_ReadByte (Regs.w.PC++); |
| 583 | break; |
| 584 | case 0x3F: /* CCF */ |
| 585 | |
| 586 | Regs.b.F = (UINT8) ((Regs.b.F & FLAG_Z) | ((Regs.b.F & FLAG_C) ? 0 : FLAG_C)); |
| 587 | break; |
| 588 | case 0x40: /* LD B,B */ |
| 589 | break; |
| 590 | case 0x41: /* LD B,C */ |
| 591 | |
| 592 | Regs.b.B = Regs.b.C; |
| 593 | break; |
| 594 | case 0x42: /* LD B,D */ |
| 595 | |
| 596 | Regs.b.B = Regs.b.D; |
| 597 | break; |
| 598 | case 0x43: /* LD B,E */ |
| 599 | |
| 600 | Regs.b.B = Regs.b.E; |
| 601 | break; |
| 602 | case 0x44: /* LD B,H */ |
| 603 | |
| 604 | Regs.b.B = Regs.b.H; |
| 605 | break; |
| 606 | case 0x45: /* LD B,L */ |
| 607 | |
| 608 | Regs.b.B = Regs.b.L; |
| 609 | break; |
| 610 | case 0x46: /* LD B,(HL) */ |
| 611 | |
| 612 | Regs.b.B = mem_ReadByte (Regs.w.HL); |
| 613 | break; |
| 614 | case 0x47: /* LD B,A */ |
| 615 | |
| 616 | Regs.b.B = Regs.b.A; |
| 617 | break; |
| 618 | case 0x48: /* LD C,B */ |
| 619 | |
| 620 | Regs.b.C = Regs.b.B; |
| 621 | break; |
| 622 | case 0x49: /* LD C,C */ |
| 623 | break; |
| 624 | case 0x4A: /* LD C,D */ |
| 625 | |
| 626 | Regs.b.C = Regs.b.D; |
| 627 | break; |
| 628 | case 0x4B: /* LD C,E */ |
| 629 | |
| 630 | Regs.b.C = Regs.b.E; |
| 631 | break; |
| 632 | case 0x4C: /* LD C,H */ |
| 633 | |
| 634 | Regs.b.C = Regs.b.H; |
| 635 | break; |
| 636 | case 0x4D: /* LD C,L */ |
| 637 | |
| 638 | Regs.b.C = Regs.b.L; |
| 639 | break; |
| 640 | case 0x4E: /* LD C,(HL) */ |
| 641 | |
| 642 | Regs.b.C = mem_ReadByte (Regs.w.HL); |
| 643 | break; |
| 644 | case 0x4F: /* LD C,A */ |
| 645 | |
| 646 | Regs.b.C = Regs.b.A; |
| 647 | break; |
| 648 | case 0x50: /* LD D,B */ |
| 649 | |
| 650 | Regs.b.D = Regs.b.B; |
| 651 | break; |
| 652 | case 0x51: /* LD D,C */ |
| 653 | |
| 654 | Regs.b.D = Regs.b.C; |
| 655 | break; |
| 656 | case 0x52: /* LD D,D */ |
| 657 | break; |
| 658 | case 0x53: /* LD D,E */ |
| 659 | |
| 660 | Regs.b.D = Regs.b.E; |
| 661 | break; |
| 662 | case 0x54: /* LD D,H */ |
| 663 | |
| 664 | Regs.b.D = Regs.b.H; |
| 665 | break; |
| 666 | case 0x55: /* LD D,L */ |
| 667 | |
| 668 | Regs.b.D = Regs.b.L; |
| 669 | break; |
| 670 | case 0x56: /* LD D,(HL) */ |
| 671 | |
| 672 | Regs.b.D = mem_ReadByte (Regs.w.HL); |
| 673 | break; |
| 674 | case 0x57: /* LD D,A */ |
| 675 | |
| 676 | Regs.b.D = Regs.b.A; |
| 677 | break; |
| 678 | case 0x58: /* LD E,B */ |
| 679 | |
| 680 | Regs.b.E = Regs.b.B; |
| 681 | break; |
| 682 | case 0x59: /* LD E,C */ |
| 683 | |
| 684 | Regs.b.E = Regs.b.C; |
| 685 | break; |
| 686 | case 0x5A: /* LD E,D */ |
| 687 | |
| 688 | Regs.b.E = Regs.b.D; |
| 689 | break; |
| 690 | case 0x5B: /* LD E,E */ |
| 691 | break; |
| 692 | case 0x5C: /* LD E,H */ |
| 693 | |
| 694 | Regs.b.E = Regs.b.H; |
| 695 | break; |
| 696 | case 0x5D: /* LD E,L */ |
| 697 | |
| 698 | Regs.b.E = Regs.b.L; |
| 699 | break; |
| 700 | case 0x5E: /* LD E,(HL) */ |
| 701 | |
| 702 | Regs.b.E = mem_ReadByte (Regs.w.HL); |
| 703 | break; |
| 704 | case 0x5F: /* LD E,A */ |
| 705 | |
| 706 | Regs.b.E = Regs.b.A; |
| 707 | break; |
| 708 | case 0x60: /* LD H,B */ |
| 709 | |
| 710 | Regs.b.H = Regs.b.B; |
| 711 | break; |
| 712 | case 0x61: /* LD H,C */ |
| 713 | |
| 714 | Regs.b.H = Regs.b.C; |
| 715 | break; |
| 716 | case 0x62: /* LD H,D */ |
| 717 | |
| 718 | Regs.b.H = Regs.b.D; |
| 719 | break; |
| 720 | case 0x63: /* LD H,E */ |
| 721 | |
| 722 | Regs.b.H = Regs.b.E; |
| 723 | break; |
| 724 | case 0x64: /* LD H,H */ |
| 725 | break; |
| 726 | case 0x65: /* LD H,L */ |
| 727 | |
| 728 | Regs.b.H = Regs.b.L; |
| 729 | break; |
| 730 | case 0x66: /* LD H,(HL) */ |
| 731 | |
| 732 | Regs.b.H = mem_ReadByte (Regs.w.HL); |
| 733 | break; |
| 734 | case 0x67: /* LD H,A */ |
| 735 | |
| 736 | Regs.b.H = Regs.b.A; |
| 737 | break; |
| 738 | case 0x68: /* LD L,B */ |
| 739 | |
| 740 | Regs.b.L = Regs.b.B; |
| 741 | break; |
| 742 | case 0x69: /* LD L,C */ |
| 743 | |
| 744 | Regs.b.L = Regs.b.C; |
| 745 | break; |
| 746 | case 0x6A: /* LD L,D */ |
| 747 | Regs.b.L = Regs.b.D; |
| 748 | break; |
| 749 | case 0x6B: /* LD L,E */ |
| 750 | |
| 751 | Regs.b.L = Regs.b.E; |
| 752 | break; |
| 753 | case 0x6C: /* LD L,H */ |
| 754 | |
| 755 | Regs.b.L = Regs.b.H; |
| 756 | break; |
| 757 | case 0x6D: /* LD L,L */ |
| 758 | break; |
| 759 | case 0x6E: /* LD L,(HL) */ |
| 760 | |
| 761 | Regs.b.L = mem_ReadByte (Regs.w.HL); |
| 762 | break; |
| 763 | case 0x6F: /* LD L,A */ |
| 764 | |
| 765 | Regs.b.L = Regs.b.A; |
| 766 | break; |
| 767 | case 0x70: /* LD (HL),B */ |
| 768 | |
| 769 | mem_WriteByte (Regs.w.HL, Regs.b.B); |
| 770 | break; |
| 771 | case 0x71: /* LD (HL),C */ |
| 772 | |
| 773 | mem_WriteByte (Regs.w.HL, Regs.b.C); |
| 774 | break; |
| 775 | case 0x72: /* LD (HL),D */ |
| 776 | |
| 777 | mem_WriteByte (Regs.w.HL, Regs.b.D); |
| 778 | break; |
| 779 | case 0x73: /* LD (HL),E */ |
| 780 | |
| 781 | mem_WriteByte (Regs.w.HL, Regs.b.E); |
| 782 | break; |
| 783 | case 0x74: /* LD (HL),H */ |
| 784 | |
| 785 | mem_WriteByte (Regs.w.HL, Regs.b.H); |
| 786 | break; |
| 787 | case 0x75: /* LD (HL),L */ |
| 788 | |
| 789 | mem_WriteByte (Regs.w.HL, Regs.b.L); |
| 790 | break; |
| 791 | case 0x76: /* HALT */ |
| 792 | Regs.w.enable |= HALTED; |
| 793 | Regs.w.haltIFstatus = Regs.w.IF & Regs.w.IE; |
| 794 | Regs.w.PC--; |
| 795 | break; |
| 796 | case 0x77: /* LD (HL),A */ |
| 797 | |
| 798 | mem_WriteByte (Regs.w.HL, Regs.b.A); |
| 799 | break; |
| 800 | case 0x78: /* LD A,B */ |
| 801 | |
| 802 | Regs.b.A = Regs.b.B; |
| 803 | break; |
| 804 | case 0x79: /* LD A,C */ |
| 805 | |
| 806 | Regs.b.A = Regs.b.C; |
| 807 | break; |
| 808 | case 0x7A: /* LD A,D */ |
| 809 | |
| 810 | Regs.b.A = Regs.b.D; |
| 811 | break; |
| 812 | case 0x7B: /* LD A,E */ |
| 813 | |
| 814 | Regs.b.A = Regs.b.E; |
| 815 | break; |
| 816 | case 0x7C: /* LD A,H */ |
| 817 | |
| 818 | Regs.b.A = Regs.b.H; |
| 819 | break; |
| 820 | case 0x7D: /* LD A,L */ |
| 821 | |
| 822 | Regs.b.A = Regs.b.L; |
| 823 | break; |
| 824 | case 0x7E: /* LD A,(HL) */ |
| 825 | |
| 826 | Regs.b.A = mem_ReadByte (Regs.w.HL); |
| 827 | break; |
| 828 | case 0x7F: /* LD A,A */ |
| 829 | break; |
| 830 | case 0x80: /* ADD A,B */ |
| 831 | |
| 832 | ADD_A_X (Regs.b.B) |
| 833 | break; |
| 834 | case 0x81: /* ADD A,C */ |
| 835 | |
| 836 | ADD_A_X (Regs.b.C) |
| 837 | break; |
| 838 | case 0x82: /* ADD A,D */ |
| 839 | |
| 840 | ADD_A_X (Regs.b.D) |
| 841 | break; |
| 842 | case 0x83: /* ADD A,E */ |
| 843 | |
| 844 | ADD_A_X (Regs.b.E) |
| 845 | break; |
| 846 | case 0x84: /* ADD A,H */ |
| 847 | |
| 848 | ADD_A_X (Regs.b.H) |
| 849 | break; |
| 850 | case 0x85: /* ADD A,L */ |
| 851 | |
| 852 | ADD_A_X (Regs.b.L) |
| 853 | break; |
| 854 | case 0x86: /* ADD A,(HL) */ |
| 855 | |
| 856 | x = mem_ReadByte (Regs.w.HL); |
| 857 | |
| 858 | ADD_A_X (x) |
| 859 | break; |
| 860 | case 0x87: /* ADD A,A */ |
| 861 | |
| 862 | ADD_A_X (Regs.b.A) |
| 863 | break; |
| 864 | case 0x88: /* ADC A,B */ |
| 865 | |
| 866 | ADC_A_X (Regs.b.B) |
| 867 | break; |
| 868 | case 0x89: /* ADC A,C */ |
| 869 | |
| 870 | ADC_A_X (Regs.b.C) |
| 871 | break; |
| 872 | case 0x8A: /* ADC A,D */ |
| 873 | |
| 874 | ADC_A_X (Regs.b.D) |
| 875 | break; |
| 876 | case 0x8B: /* ADC A,E */ |
| 877 | |
| 878 | ADC_A_X (Regs.b.E) |
| 879 | break; |
| 880 | case 0x8C: /* ADC A,H */ |
| 881 | |
| 882 | ADC_A_X (Regs.b.H) |
| 883 | break; |
| 884 | case 0x8D: /* ADC A,L */ |
| 885 | |
| 886 | ADC_A_X (Regs.b.L) |
| 887 | break; |
| 888 | case 0x8E: /* ADC A,(HL) */ |
| 889 | |
| 890 | x = mem_ReadByte (Regs.w.HL); |
| 891 | |
| 892 | ADC_A_X (x) |
| 893 | break; |
| 894 | case 0x8F: /* ADC A,A */ |
| 895 | |
| 896 | ADC_A_X (Regs.b.A) |
| 897 | break; |
| 898 | case 0x90: /* SUB A,B */ |
| 899 | |
| 900 | SUB_A_X (Regs.b.B) |
| 901 | break; |
| 902 | case 0x91: /* SUB A,C */ |
| 903 | |
| 904 | SUB_A_X (Regs.b.C) |
| 905 | break; |
| 906 | case 0x92: /* SUB A,D */ |
| 907 | |
| 908 | SUB_A_X (Regs.b.D) |
| 909 | break; |
| 910 | case 0x93: /* SUB A,E */ |
| 911 | |
| 912 | SUB_A_X (Regs.b.E) |
| 913 | break; |
| 914 | case 0x94: /* SUB A,H */ |
| 915 | |
| 916 | SUB_A_X (Regs.b.H) |
| 917 | break; |
| 918 | case 0x95: /* SUB A,L */ |
| 919 | |
| 920 | SUB_A_X (Regs.b.L) |
| 921 | break; |
| 922 | case 0x96: /* SUB A,(HL) */ |
| 923 | |
| 924 | |
| 925 | x = mem_ReadByte (Regs.w.HL); |
| 926 | |
| 927 | SUB_A_X (x) |
| 928 | break; |
| 929 | case 0x97: /* SUB A,A */ |
| 930 | |
| 931 | SUB_A_X (Regs.b.A) |
| 932 | break; |
| 933 | case 0x98: /* SBC A,B */ |
| 934 | |
| 935 | SBC_A_X (Regs.b.B) |
| 936 | break; |
| 937 | case 0x99: /* SBC A,C */ |
| 938 | |
| 939 | SBC_A_X (Regs.b.C) |
| 940 | break; |
| 941 | case 0x9A: /* SBC A,D */ |
| 942 | |
| 943 | SBC_A_X (Regs.b.D) |
| 944 | break; |
| 945 | case 0x9B: /* SBC A,E */ |
| 946 | |
| 947 | SBC_A_X (Regs.b.E) |
| 948 | break; |
| 949 | case 0x9C: /* SBC A,H */ |
| 950 | |
| 951 | SBC_A_X (Regs.b.H) |
| 952 | break; |
| 953 | case 0x9D: /* SBC A,L */ |
| 954 | |
| 955 | SBC_A_X (Regs.b.L) |
| 956 | break; |
| 957 | case 0x9E: /* SBC A,(HL) */ |
| 958 | |
| 959 | x = mem_ReadByte (Regs.w.HL); |
| 960 | |
| 961 | SBC_A_X (x) |
| 962 | break; |
| 963 | case 0x9F: /* SBC A,A */ |
| 964 | |
| 965 | SBC_A_X (Regs.b.A) |
| 966 | break; |
| 967 | case 0xA0: /* AND A,B */ |
| 968 | |
| 969 | AND_A_X (Regs.b.B) |
| 970 | break; |
| 971 | case 0xA1: /* AND A,C */ |
| 972 | |
| 973 | AND_A_X (Regs.b.C) |
| 974 | break; |
| 975 | case 0xA2: /* AND A,D */ |
| 976 | |
| 977 | AND_A_X (Regs.b.D) |
| 978 | break; |
| 979 | case 0xA3: /* AND A,E */ |
| 980 | |
| 981 | AND_A_X (Regs.b.E) |
| 982 | break; |
| 983 | case 0xA4: /* AND A,H */ |
| 984 | |
| 985 | AND_A_X (Regs.b.H) |
| 986 | break; |
| 987 | case 0xA5: /* AND A,L */ |
| 988 | |
| 989 | AND_A_X (Regs.b.L) |
| 990 | break; |
| 991 | case 0xA6: /* AND A,(HL) */ |
| 992 | |
| 993 | x = mem_ReadByte (Regs.w.HL); |
| 994 | |
| 995 | AND_A_X (x) |
| 996 | break; |
| 997 | case 0xA7: /* AND A,A */ |
| 998 | |
| 999 | Regs.b.F = (Regs.b.A == 0) ? (FLAG_H | FLAG_Z) : FLAG_H; |
| 1000 | break; |
| 1001 | case 0xA8: /* XOR A,B */ |
| 1002 | |
| 1003 | XOR_A_X (Regs.b.B) |
| 1004 | break; |
| 1005 | case 0xA9: /* XOR A,C */ |
| 1006 | |
| 1007 | XOR_A_X (Regs.b.C) |
| 1008 | break; |
| 1009 | case 0xAA: /* XOR A,D */ |
| 1010 | |
| 1011 | XOR_A_X (Regs.b.D) |
| 1012 | break; |
| 1013 | case 0xAB: /* XOR A,E */ |
| 1014 | |
| 1015 | XOR_A_X (Regs.b.E) |
| 1016 | break; |
| 1017 | case 0xAC: /* XOR A,H */ |
| 1018 | |
| 1019 | XOR_A_X (Regs.b.H) |
| 1020 | break; |
| 1021 | case 0xAD: /* XOR A,L */ |
| 1022 | |
| 1023 | XOR_A_X (Regs.b.L) |
| 1024 | break; |
| 1025 | case 0xAE: /* XOR A,(HL) */ |
| 1026 | |
| 1027 | x = mem_ReadByte (Regs.w.HL); |
| 1028 | |
| 1029 | XOR_A_X (x) |
| 1030 | break; |
| 1031 | case 0xAF: /* XOR A,A */ |
| 1032 | |
| 1033 | XOR_A_X (Regs.b.A) |
| 1034 | break; |
| 1035 | case 0xB0: /* OR A,B */ |
| 1036 | |
| 1037 | OR_A_X (Regs.b.B) |
| 1038 | break; |
| 1039 | case 0xB1: /* OR A,C */ |
| 1040 | |
| 1041 | OR_A_X (Regs.b.C) |
| 1042 | break; |
| 1043 | case 0xB2: /* OR A,D */ |
| 1044 | |
| 1045 | OR_A_X (Regs.b.D) |
| 1046 | break; |
| 1047 | case 0xB3: /* OR A,E */ |
| 1048 | |
| 1049 | OR_A_X (Regs.b.E) |
| 1050 | break; |
| 1051 | case 0xB4: /* OR A,H */ |
| 1052 | |
| 1053 | OR_A_X (Regs.b.H) |
| 1054 | break; |
| 1055 | case 0xB5: /* OR A,L */ |
| 1056 | |
| 1057 | OR_A_X (Regs.b.L) |
| 1058 | break; |
| 1059 | case 0xB6: /* OR A,(HL) */ |
| 1060 | |
| 1061 | x = mem_ReadByte (Regs.w.HL); |
| 1062 | |
| 1063 | OR_A_X (x) |
| 1064 | break; |
| 1065 | case 0xB7: /* OR A,A */ |
| 1066 | |
| 1067 | OR_A_X (Regs.b.A) |
| 1068 | break; |
| 1069 | case 0xB8: /* CP A,B */ |
| 1070 | |
| 1071 | CP_A_X (Regs.b.B) |
| 1072 | break; |
| 1073 | case 0xB9: /* CP A,C */ |
| 1074 | |
| 1075 | CP_A_X (Regs.b.C) |
| 1076 | break; |
| 1077 | case 0xBA: /* CP A,D */ |
| 1078 | |
| 1079 | CP_A_X (Regs.b.D) |
| 1080 | break; |
| 1081 | case 0xBB: /* CP A,E */ |
| 1082 | |
| 1083 | CP_A_X (Regs.b.E) |
| 1084 | break; |
| 1085 | case 0xBC: /* CP A,H */ |
| 1086 | |
| 1087 | CP_A_X (Regs.b.H) |
| 1088 | break; |
| 1089 | case 0xBD: /* CP A,L */ |
| 1090 | |
| 1091 | CP_A_X (Regs.b.L) |
| 1092 | break; |
| 1093 | case 0xBE: /* CP A,(HL) */ |
| 1094 | |
| 1095 | x = mem_ReadByte (Regs.w.HL); |
| 1096 | |
| 1097 | CP_A_X (x) |
| 1098 | break; |
| 1099 | case 0xBF: /* CP A,A */ |
| 1100 | |
| 1101 | CP_A_X (Regs.b.A) |
| 1102 | break; |
| 1103 | case 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; |
| 1112 | case 0xC1: /* POP BC */ |
| 1113 | |
| 1114 | Regs.w.BC = mem_ReadWord (Regs.w.SP); |
| 1115 | Regs.w.SP += 2; |
| 1116 | break; |
| 1117 | case 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; |
| 1129 | case 0xC3: /* JP n16 */ |
| 1130 | |
| 1131 | Regs.w.PC = mem_ReadWord (Regs.w.PC); |
| 1132 | break; |
| 1133 | case 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; |
| 1151 | case 0xC5: /* PUSH BC */ |
| 1152 | |
| 1153 | Regs.w.SP -= 2; |
| 1154 | mem_WriteWord (Regs.w.SP, Regs.w.BC); |
| 1155 | break; |
| 1156 | case 0xC6: /* ADD A,n8 */ |
| 1157 | |
| 1158 | x = mem_ReadByte (Regs.w.PC++); |
| 1159 | ADD_A_X (x) |
| 1160 | break; |
| 1161 | case 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; |
| 1172 | case 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; |
| 1181 | case 0xC9: /* RET */ |
| 1182 | |
| 1183 | Regs.w.PC = mem_ReadWord (Regs.w.SP); |
| 1184 | Regs.w.SP += 2; |
| 1185 | break; |
| 1186 | case 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; |
| 1198 | case 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; |
| 1206 | case 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; |
| 1224 | case 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; |
| 1235 | case 0xCE: /* ADC A,n8 */ |
| 1236 | |
| 1237 | x = mem_ReadByte (Regs.w.PC++); |
| 1238 | ADC_A_X (x) |
| 1239 | break; |
| 1240 | case 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; |
| 1246 | case 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; |
| 1255 | case 0xD1: /* POP DE */ |
| 1256 | |
| 1257 | Regs.w.DE = mem_ReadWord (Regs.w.SP); |
| 1258 | Regs.w.SP += 2; |
| 1259 | break; |
| 1260 | case 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; |
| 1272 | case 0xD3: /* EH? */ |
| 1273 | break; |
| 1274 | case 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; |
| 1292 | case 0xD5: /* PUSH DE */ |
| 1293 | |
| 1294 | Regs.w.SP -= 2; |
| 1295 | mem_WriteWord (Regs.w.SP, Regs.w.DE); |
| 1296 | break; |
| 1297 | case 0xD6: /* SUB A,n8 */ |
| 1298 | |
| 1299 | x = mem_ReadByte (Regs.w.PC++); |
| 1300 | SUB_A_X (x) |
| 1301 | break; |
| 1302 | case 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; |
| 1308 | case 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; |
| 1317 | case 0xD9: /* RETI */ |
| 1318 | |
| 1319 | Regs.w.PC = mem_ReadWord (Regs.w.SP); |
| 1320 | Regs.w.SP += 2; |
| 1321 | Regs.w.enable |= IME; |
| 1322 | break; |
| 1323 | case 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; |
| 1335 | case 0xDB: /* EH? */ |
| 1336 | break; |
| 1337 | case 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; |
| 1355 | case 0xDD: /* EH? */ |
| 1356 | break; |
| 1357 | case 0xDE: /* SBC A,n8 */ |
| 1358 | |
| 1359 | x = mem_ReadByte (Regs.w.PC++); |
| 1360 | SBC_A_X (x) |
| 1361 | break; |
| 1362 | case 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; |
| 1368 | case 0xE0: /* LD ($FF00+n8),A */ |
| 1369 | mem_WriteByte (mem_ReadByte (Regs.w.PC++) + 0xFF00, Regs.b.A); |
| 1370 | break; |
| 1371 | case 0xE1: /* POP HL */ |
| 1372 | |
| 1373 | Regs.w.HL = mem_ReadWord (Regs.w.SP); |
| 1374 | Regs.w.SP += 2; |
| 1375 | break; |
| 1376 | case 0xE2: /* LD ($FF00+C),A */ |
| 1377 | |
| 1378 | mem_WriteByte ((UINT16) (0xFF00 + Regs.b.C), Regs.b.A); |
| 1379 | break; |
| 1380 | case 0xE3: /* EH? */ |
| 1381 | break; |
| 1382 | case 0xE4: /* EH? */ |
| 1383 | break; |
| 1384 | case 0xE5: /* PUSH HL */ |
| 1385 | |
| 1386 | Regs.w.SP -= 2; |
| 1387 | mem_WriteWord (Regs.w.SP, Regs.w.HL); |
| 1388 | break; |
| 1389 | case 0xE6: /* AND A,n8 */ |
| 1390 | |
| 1391 | x = mem_ReadByte (Regs.w.PC++); |
| 1392 | AND_A_X (x) |
| 1393 | break; |
| 1394 | case 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; |
| 1400 | case 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; |
| 1430 | case 0xE9: /* JP (HL) */ |
| 1431 | |
| 1432 | Regs.w.PC = Regs.w.HL; |
| 1433 | break; |
| 1434 | case 0xEA: /* LD (n16),A */ |
| 1435 | |
| 1436 | mem_WriteByte (mem_ReadWord (Regs.w.PC), Regs.b.A); |
| 1437 | Regs.w.PC += 2; |
| 1438 | break; |
| 1439 | case 0xEB: /* EH? */ |
| 1440 | break; |
| 1441 | case 0xEC: /* EH? */ |
| 1442 | break; |
| 1443 | case 0xED: /* EH? */ |
| 1444 | break; |
| 1445 | case 0xEE: /* XOR A,n8 */ |
| 1446 | |
| 1447 | x = mem_ReadByte (Regs.w.PC++); |
| 1448 | XOR_A_X (x) |
| 1449 | break; |
| 1450 | case 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; |
| 1456 | case 0xF0: /* LD A,($FF00+n8) */ |
| 1457 | |
| 1458 | Regs.b.A = mem_ReadByte (0xFF00 + mem_ReadByte (Regs.w.PC++)); |
| 1459 | break; |
| 1460 | case 0xF1: /* POP AF */ |
| 1461 | |
| 1462 | Regs.w.AF = (UINT16) (mem_ReadWord (Regs.w.SP) & 0xFFF0); |
| 1463 | Regs.w.SP += 2; |
| 1464 | break; |
| 1465 | case 0xF2: /* LD A,($FF00+C) */ |
| 1466 | |
| 1467 | Regs.b.A = mem_ReadByte ((UINT16) (0xFF00 + Regs.b.C)); |
| 1468 | break; |
| 1469 | case 0xF3: /* DI */ |
| 1470 | Regs.w.ei_delay = 0; |
| 1471 | Regs.w.enable &= ~IME; |
| 1472 | break; |
| 1473 | case 0xF4: /* EH? */ |
| 1474 | break; |
| 1475 | case 0xF5: /* PUSH AF */ |
| 1476 | |
| 1477 | Regs.w.SP -= 2; |
| 1478 | mem_WriteWord (Regs.w.SP, (UINT16) (Regs.w.AF & 0xFFF0)); |
| 1479 | break; |
| 1480 | case 0xF6: /* OR A,n8 */ |
| 1481 | |
| 1482 | x = mem_ReadByte (Regs.w.PC++); |
| 1483 | OR_A_X (x) |
| 1484 | break; |
| 1485 | case 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; |
| 1491 | case 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; |
| 1524 | case 0xF9: /* LD SP,HL */ |
| 1525 | |
| 1526 | Regs.w.SP = Regs.w.HL; |
| 1527 | break; |
| 1528 | case 0xFA: /* LD A,(n16) */ |
| 1529 | |
| 1530 | Regs.b.A = mem_ReadByte (mem_ReadWord (Regs.w.PC)); |
| 1531 | Regs.w.PC += 2; |
| 1532 | break; |
| 1533 | case 0xFB: /* EI */ |
| 1534 | |
| 1535 | Regs.w.enable |= IME; |
| 1536 | Regs.w.ei_delay = 1; |
| 1537 | break; |
| 1538 | case 0xFC: /* EH? */ |
| 1539 | break; |
| 1540 | case 0xFD: /* EH? */ |
| 1541 | break; |
| 1542 | case 0xFE: /* CP A,n8 */ |
| 1543 | |
| 1544 | x = mem_ReadByte (Regs.w.PC++); |
| 1545 | CP_A_X (x) |
| 1546 | break; |
| 1547 | case 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; |