panzone/panzgb
1
0
Fork 0
Code Activity
Files
main
panzgb/lib/gb-opcodes.c
panzone d08fbfe1aa public release of panzgb
2025-11-24 13:37:49 +01:00

1805 lines
43 KiB
C
Executable File
Raw Permalink Blame History

#include <stdio.h>
#include "gb-impl.h"
#include "gb-opcode.h"
BYTE executeOpcode(gb *cpu, BYTE opcode) {
BYTE val = 0;
SIGNED_BYTE s_val = 0;
WORD val_16 = 0;
switch (opcode) {
case 0x00:
return 4;
case 0x76:
cpu->cpuHalted = 0;
return 4;
case 0x06:
GET_BYTE_PC(cpu, val)
LOAD_8BIT(&(cpu->B), val);
return 8;
case 0x0E:
GET_BYTE_PC(cpu, val)
LOAD_8BIT(&(cpu->C), val);
return 8;
case 0x16:
GET_BYTE_PC(cpu, val)
LOAD_8BIT(&(cpu->D), val);
return 8;
case 0x1E:
GET_BYTE_PC(cpu, val)
LOAD_8BIT(&(cpu->E), val);
return 8;
case 0x26:
GET_BYTE_PC(cpu, val)
LOAD_8BIT(&(cpu->H), val);
return 8;
case 0x2E:
GET_BYTE_PC(cpu, val)
LOAD_8BIT(&(cpu->L), val);
return 8;
case 0x7F:
LOAD_8BIT(&(cpu->A), cpu->A);
return 4;
case 0x78:
LOAD_8BIT(&(cpu->A), cpu->B);
return 4;
case 0x79:
LOAD_8BIT(&(cpu->A), cpu->C);
return 4;
case 0x7A:
LOAD_8BIT(&(cpu->A), cpu->D);
return 4;
case 0x7B:
LOAD_8BIT(&(cpu->A), cpu->E);
return 4;
case 0x7C:
LOAD_8BIT(&(cpu->A), cpu->H);
return 4;
case 0x7D:
LOAD_8BIT(&(cpu->A), cpu->L);
return 4;
case 0x7E:
val = readMemory(cpu, getHL(cpu));
LOAD_8BIT(&(cpu->A), val);
return 8;
case 0x40:
LOAD_8BIT(&(cpu->B), cpu->B);
return 4;
case 0x41:
LOAD_8BIT(&(cpu->B), cpu->C);
return 4;
case 0x42:
LOAD_8BIT(&(cpu->B), cpu->D);
return 4;
case 0x43:
LOAD_8BIT(&(cpu->B), cpu->E);
return 4;
case 0x44:
LOAD_8BIT(&(cpu->B), cpu->H);
return 4;
case 0x45:
LOAD_8BIT(&(cpu->B), cpu->L);
return 4;
case 0x46:
val = readMemory(cpu, getHL(cpu));
LOAD_8BIT(&(cpu->B), val);
return 8;
case 0x48:
LOAD_8BIT(&(cpu->C), cpu->B);
return 4;
case 0x49:
LOAD_8BIT(&(cpu->C), cpu->C);
return 4;
case 0x4A:
LOAD_8BIT(&(cpu->C), cpu->D);
return 4;
case 0x4B:
LOAD_8BIT(&(cpu->C), cpu->E);
return 4;
case 0x4C:
LOAD_8BIT(&(cpu->C), cpu->H);
return 4;
case 0x4D:
LOAD_8BIT(&(cpu->C), cpu->L);
return 4;
case 0x4E:
val = readMemory(cpu, getHL(cpu));
LOAD_8BIT(&(cpu->C), val);
return 8;
case 0x50:
LOAD_8BIT(&(cpu->D), cpu->B);
return 4;
case 0x51:
LOAD_8BIT(&(cpu->D), cpu->C);
return 4;
case 0x52:
LOAD_8BIT(&(cpu->D), cpu->D);
return 4;
case 0x53:
LOAD_8BIT(&(cpu->D), cpu->E);
return 4;
case 0x54:
LOAD_8BIT(&(cpu->D), cpu->H);
return 4;
case 0x55:
LOAD_8BIT(&(cpu->D), cpu->L);
return 4;
case 0x56:
val = readMemory(cpu, getHL(cpu));
LOAD_8BIT(&(cpu->D), val);
return 8;
case 0x58:
LOAD_8BIT(&(cpu->E), cpu->B);
return 4;
case 0x59:
LOAD_8BIT(&(cpu->E), cpu->C);
return 4;
case 0x5A:
LOAD_8BIT(&(cpu->E), cpu->D);
return 4;
case 0x5B:
LOAD_8BIT(&(cpu->E), cpu->E);
return 4;
case 0x5C:
LOAD_8BIT(&(cpu->E), cpu->H);
return 4;
case 0x5D:
LOAD_8BIT(&(cpu->E), cpu->L);
return 4;
case 0x5E:
val = readMemory(cpu, getHL(cpu));
LOAD_8BIT(&(cpu->E), val);
return 8;
case 0x60:
LOAD_8BIT(&(cpu->H), cpu->B);
return 4;
case 0x61:
LOAD_8BIT(&(cpu->H), cpu->C);
return 4;
case 0x62:
LOAD_8BIT(&(cpu->H), cpu->D);
return 4;
case 0x63:
LOAD_8BIT(&(cpu->H), cpu->E);
return 4;
case 0x64:
LOAD_8BIT(&(cpu->H), cpu->H);
return 4;
case 0x65:
LOAD_8BIT(&(cpu->H), cpu->L);
return 4;
case 0x66:
val = readMemory(cpu, getHL(cpu));
LOAD_8BIT(&(cpu->H), val);
return 8;
case 0x68:
LOAD_8BIT(&(cpu->L), cpu->B);
return 4;
case 0x69:
LOAD_8BIT(&(cpu->L), cpu->C);
return 4;
case 0x6A:
LOAD_8BIT(&(cpu->L), cpu->D);
return 4;
case 0x6B:
LOAD_8BIT(&(cpu->L), cpu->E);
return 4;
case 0x6C:
LOAD_8BIT(&(cpu->L), cpu->H);
return 4;
case 0x6D:
LOAD_8BIT(&(cpu->L), cpu->L);
return 4;
case 0x6E:
val = readMemory(cpu, getHL(cpu));
LOAD_8BIT(&(cpu->L), val);
return 8;
case 0x70:
writeMemory(cpu, getHL(cpu), cpu->B);
return 8;
case 0x71:
writeMemory(cpu, getHL(cpu), cpu->C);
return 8;
case 0x72:
writeMemory(cpu, getHL(cpu), cpu->D);
return 8;
case 0x73:
writeMemory(cpu, getHL(cpu), cpu->E);
return 8;
case 0x74:
writeMemory(cpu, getHL(cpu), cpu->H);
return 8;
case 0x75:
writeMemory(cpu, getHL(cpu), cpu->L);
return 8;
case 0x36:
GET_BYTE_PC(cpu, val);
writeMemory(cpu, getHL(cpu), val);
return 12;
case 0x0A:
val = readMemory(cpu, getBC(cpu));
LOAD_8BIT(&(cpu->A), val);
return 8;
case 0x1A:
val = readMemory(cpu, getDE(cpu));
cpu->A = val;
return 8;
case 0xFA:
GET_WORD_PC(cpu, val_16);
val = readMemory(cpu, val_16);
LOAD_8BIT(&(cpu->A), val);
return 16;
case 0x3E:
GET_BYTE_PC(cpu, val);
LOAD_8BIT(&(cpu->A), val);
return 8;
case 0x47:
LOAD_8BIT(&(cpu->B), cpu->A);
return 4;
case 0x4F:
LOAD_8BIT(&(cpu->C), cpu->A);
return 4;
case 0x57:
LOAD_8BIT(&(cpu->D), cpu->A);
return 4;
case 0x5F:
LOAD_8BIT(&(cpu->E), cpu->A);
return 4;
case 0x67:
LOAD_8BIT(&(cpu->H), cpu->A);
return 4;
case 0x6F:
LOAD_8BIT(&(cpu->L), cpu->A);
return 4;
case 0x02:
writeMemory(cpu, getBC(cpu), cpu->A);
return 8;
case 0x12:
writeMemory(cpu, getDE(cpu), cpu->A);
return 8;
case 0x77:
writeMemory(cpu, getHL(cpu), cpu->A);
return 8;
case 0xEA:
GET_WORD_PC(cpu, val_16);
writeMemory(cpu, val_16, cpu->A);
return 16;
case 0xF2:
val = readMemory(cpu, 0xFF00 + cpu->C);
LOAD_8BIT(&(cpu->A), val);
return 8;
case 0xE2:
writeMemory(cpu, 0xFF00 + cpu->C, cpu->A);
return 8;
case 0x3A:
val = readMemory(cpu, getHL(cpu));
LOAD_8BIT(&(cpu->A), val);
DEC_16BIT(&(cpu->H), &(cpu->L));
return 8;
case 0x32:
writeMemory(cpu, getHL(cpu), cpu->A);
DEC_16BIT(&(cpu->H), &(cpu->L));
return 8;
case 0x2A:
val = readMemory(cpu, getHL(cpu));
LOAD_8BIT(&(cpu->A), val);
INC_16BIT(&(cpu->H), &(cpu->L));
return 8;
case 0x22:
writeMemory(cpu, getHL(cpu), cpu->A);
INC_16BIT(&(cpu->H), &(cpu->L));
return 8;
case 0xE0:
GET_BYTE_PC(cpu, val);
writeMemory(cpu, 0xFF00 + val, cpu->A);
return 12;
case 0xF0:
GET_BYTE_PC(cpu, val);
val = readMemory(cpu, 0xFF00 + val);
LOAD_8BIT(&(cpu->A), val);
return 12;
case 0x01:
GET_WORD_PC(cpu, val_16);
LOAD_16BIT(&(cpu->B), &(cpu->C), val_16);
return 12;
case 0x11:
GET_WORD_PC(cpu, val_16);
LOAD_16BIT(&(cpu->D), &(cpu->E), val_16);
return 12;
case 0x21:
GET_WORD_PC(cpu, val_16);
LOAD_16BIT(&(cpu->H), &(cpu->L), val_16);
return 12;
case 0x31:
GET_WORD_PC(cpu, val_16);
cpu->stack = val_16;
return 12;
case 0xF9:
cpu->stack = getHL(cpu);
return 8;
case 0xF8:
GET_BYTE_PC(cpu, s_val);
val_16 = cpu->stack + s_val;
RESET_ZFLAG(cpu);
RESET_NFLAG(cpu);
if ((uint32_t)(cpu->stack + s_val) > 0xFFFF)
SET_CFLAG(cpu);
else
RESET_CFLAG(cpu);
if ((uint32_t)(cpu->stack + s_val) > 0x8FF)
SET_HFLAG(cpu);
else
RESET_HFLAG(cpu);
cpu->L = val_16 & 0xFF;
cpu->H = ((val_16 >> 8) & 0xFF);
return 12;
case 0x08:
GET_WORD_PC(cpu, val_16);
writeMemory(cpu, val_16, cpu->stack & 0xFF);
writeMemory(cpu, val_16 + 1, (cpu->stack >> 8) & 0xFF);
return 20;
case 0xF5:
PUSH(cpu, cpu->stack, getAF(cpu));
return 16;
case 0xC5:
PUSH(cpu, cpu->stack, getBC(cpu));
return 16;
case 0xD5:
PUSH(cpu, cpu->stack, getDE(cpu));
return 16;
case 0xE5:
PUSH(cpu, cpu->stack, getHL(cpu));
return 16;
case 0xF1:
POP(cpu, cpu->stack, val_16);
cpu->A = (val_16 >> 8) & 0xFF;
cpu->F = val_16 & 0xFF;
cpu->F &= ~0xF;
return 12;
case 0xC1:
POP(cpu, cpu->stack, val_16);
cpu->B = (val_16 >> 8) & 0xFF;
cpu->C = val_16 & 0xFF;
return 12;
case 0xD1:
POP(cpu, cpu->stack, val_16);
cpu->D = (val_16 >> 8) & 0xFF;
cpu->E = val_16 & 0xFF;
return 12;
case 0xE1:
POP(cpu, cpu->stack, val_16);
cpu->H = (val_16 >> 8) & 0xFF;
cpu->L = val_16 & 0xFF;
return 12;
case 0x87:
ADD_8BIT(cpu, &(cpu->A), cpu->A);
return 4;
case 0x80:
ADD_8BIT(cpu, &(cpu->A), cpu->B);
return 4;
case 0x81:
ADD_8BIT(cpu, &(cpu->A), cpu->C);
return 4;
case 0x82:
ADD_8BIT(cpu, &(cpu->A), cpu->D);
return 4;
case 0x83:
ADD_8BIT(cpu, &(cpu->A), cpu->E);
return 4;
case 0x84:
ADD_8BIT(cpu, &(cpu->A), cpu->H);
return 4;
case 0x85:
ADD_8BIT(cpu, &(cpu->A), cpu->L);
return 4;
case 0x86:
val = readMemory(cpu, getHL(cpu));
ADD_8BIT(cpu, &(cpu->A), val);
return 8;
case 0xC6:
GET_BYTE_PC(cpu, val);
ADD_8BIT(cpu, &(cpu->A), val);
return 8;
case 0x8F:
ADDC_8BIT(cpu, &(cpu->A), cpu->A);
return 4;
case 0x88:
ADDC_8BIT(cpu, &(cpu->A), cpu->B);
return 4;
case 0x89:
ADDC_8BIT(cpu, &(cpu->A), cpu->C);
return 4;
case 0x8A:
ADDC_8BIT(cpu, &(cpu->A), cpu->D);
return 4;
case 0x8B:
ADDC_8BIT(cpu, &(cpu->A), cpu->E);
return 4;
case 0x8C:
ADDC_8BIT(cpu, &(cpu->A), cpu->H);
return 4;
case 0x8D:
ADDC_8BIT(cpu, &(cpu->A), cpu->L);
return 4;
case 0x8E:
val = readMemory(cpu, getHL(cpu));
ADDC_8BIT(cpu, &(cpu->A), val);
return 8;
case 0xCE:
GET_BYTE_PC(cpu, val);
ADDC_8BIT(cpu, &(cpu->A), val);
return 8;
case 0x97:
SUB_8BIT(cpu, &(cpu->A), cpu->A);
return 4;
case 0x90:
SUB_8BIT(cpu, &(cpu->A), cpu->B);
return 4;
case 0x91:
SUB_8BIT(cpu, &(cpu->A), cpu->C);
return 4;
case 0x92:
SUB_8BIT(cpu, &(cpu->A), cpu->D);
return 4;
case 0x93:
SUB_8BIT(cpu, &(cpu->A), cpu->E);
return 4;
case 0x94:
SUB_8BIT(cpu, &(cpu->A), cpu->H);
return 4;
case 0x95:
SUB_8BIT(cpu, &(cpu->A), cpu->L);
return 4;
case 0x96:
val = readMemory(cpu, getHL(cpu));
SUB_8BIT(cpu, &(cpu->A), val);
return 8;
case 0x9F:
SUBC_8BIT(cpu, &(cpu->A), cpu->A);
return 4;
case 0x98:
SUBC_8BIT(cpu, &(cpu->A), cpu->B);
return 4;
case 0x99:
SUBC_8BIT(cpu, &(cpu->A), cpu->C);
return 4;
case 0x9A:
SUBC_8BIT(cpu, &(cpu->A), cpu->D);
return 4;
case 0x9B:
SUBC_8BIT(cpu, &(cpu->A), cpu->E);
return 4;
case 0x9C:
SUBC_8BIT(cpu, &(cpu->A), cpu->H);
return 4;
case 0x9D:
SUBC_8BIT(cpu, &(cpu->A), cpu->L);
return 4;
case 0x9E:
val = readMemory(cpu, getHL(cpu));
SUBC_8BIT(cpu, &(cpu->A), val);
return 8;
case 0xD6:
GET_BYTE_PC(cpu, val);
SUB_8BIT(cpu, &(cpu->A), val);
return 8;
case 0xDE:
GET_BYTE_PC(cpu, val);
SUBC_8BIT(cpu, &(cpu->A), val);
return 8;
case 0xA7:
AND_8BIT(cpu, &(cpu->A), cpu->A);
return 4;
case 0xA0:
AND_8BIT(cpu, &(cpu->A), cpu->B);
return 4;
case 0xA1:
AND_8BIT(cpu, &(cpu->A), cpu->C);
return 4;
case 0xA2:
AND_8BIT(cpu, &(cpu->A), cpu->D);
return 4;
case 0xA3:
AND_8BIT(cpu, &(cpu->A), cpu->E);
return 4;
case 0xA4:
AND_8BIT(cpu, &(cpu->A), cpu->H);
return 4;
case 0xA5:
AND_8BIT(cpu, &(cpu->A), cpu->L);
return 4;
case 0xA6:
val = readMemory(cpu, getHL(cpu));
AND_8BIT(cpu, &(cpu->A), val);
return 8;
case 0xE6:
GET_BYTE_PC(cpu, val);
AND_8BIT(cpu, &(cpu->A), val);
return 8;
case 0xB7:
OR_8BIT(cpu, &(cpu->A), cpu->A);
return 4;
case 0xB0:
OR_8BIT(cpu, &(cpu->A), cpu->B);
return 4;
case 0xB1:
OR_8BIT(cpu, &(cpu->A), cpu->C);
return 4;
case 0xB2:
OR_8BIT(cpu, &(cpu->A), cpu->D);
return 4;
case 0xB3:
OR_8BIT(cpu, &(cpu->A), cpu->E);
return 4;
case 0xB4:
OR_8BIT(cpu, &(cpu->A), cpu->H);
return 4;
case 0xB5:
OR_8BIT(cpu, &(cpu->A), cpu->L);
return 4;
case 0xB6:
val = readMemory(cpu, getHL(cpu));
OR_8BIT(cpu, &(cpu->A), val);
return 8;
case 0xF6:
val = readMemory(cpu, cpu->progCounter);
cpu->progCounter++;
OR_8BIT(cpu, &(cpu->A), val);
return 8;
case 0xAF:
XOR_8BIT(cpu, &(cpu->A), cpu->A);
return 4;
case 0xA8:
XOR_8BIT(cpu, &(cpu->A), cpu->B);
return 4;
case 0xA9:
XOR_8BIT(cpu, &(cpu->A), cpu->C);
return 4;
case 0xAA:
XOR_8BIT(cpu, &(cpu->A), cpu->D);
return 4;
case 0xAB:
XOR_8BIT(cpu, &(cpu->A), cpu->E);
return 4;
case 0xAC:
XOR_8BIT(cpu, &(cpu->A), cpu->H);
return 4;
case 0xAD:
XOR_8BIT(cpu, &(cpu->A), cpu->L);
return 4;
case 0xAE:
val = readMemory(cpu, getHL(cpu));
XOR_8BIT(cpu, &(cpu->A), val);
return 8;
case 0xEE:
val = readMemory(cpu, cpu->progCounter);
cpu->progCounter++;
XOR_8BIT(cpu, &(cpu->A), val);
return 8;
case 0xBF:
CP_8BIT(cpu, cpu->A);
return 4;
case 0xB8:
CP_8BIT(cpu, cpu->B);
return 4;
case 0xB9:
CP_8BIT(cpu, cpu->C);
return 4;
case 0xBA:
CP_8BIT(cpu, cpu->D);
return 4;
case 0xBB:
CP_8BIT(cpu, cpu->E);
return 4;
case 0xBC:
CP_8BIT(cpu, cpu->H);
return 4;
case 0xBD:
CP_8BIT(cpu, cpu->L);
return 4;
case 0xBE:
val = readMemory(cpu, getHL(cpu));
CP_8BIT(cpu, val);
return 8;
case 0xFE:
GET_BYTE_PC(cpu, val)
CP_8BIT(cpu, val);
return 8;
case 0x3C:
INC_8BIT(cpu, &(cpu->A));
return 4;
case 0x04:
INC_8BIT(cpu, &(cpu->B));
return 4;
case 0x0C:
INC_8BIT(cpu, &(cpu->C));
return 4;
case 0x14:
INC_8BIT(cpu, &(cpu->D));
return 4;
case 0x1C:
INC_8BIT(cpu, &(cpu->E));
return 4;
case 0x24:
INC_8BIT(cpu, &(cpu->H));
return 4;
case 0x2C:
INC_8BIT(cpu, &(cpu->L));
return 4;
case 0x34:
val = readMemory(cpu, getHL(cpu));
INC_8BIT(cpu, &val);
writeMemory(cpu, getHL(cpu), val);
return 12;
case 0x3D:
DEC_8BIT(cpu, &(cpu->A));
return 4;
case 0x05:
DEC_8BIT(cpu, &(cpu->B));
return 4;
case 0x0D:
DEC_8BIT(cpu, &(cpu->C));
return 4;
case 0x15:
DEC_8BIT(cpu, &(cpu->D));
return 4;
case 0x1D:
DEC_8BIT(cpu, &(cpu->E));
return 4;
case 0x25:
DEC_8BIT(cpu, &(cpu->H));
return 4;
case 0x2D:
DEC_8BIT(cpu, &(cpu->L));
return 4;
case 0x35:
val = readMemory(cpu, getHL(cpu));
DEC_8BIT(cpu, &val);
writeMemory(cpu, getHL(cpu), val);
return 12;
/*16BIT operations*/
case 0x09:
ADD_16BIT(cpu, &(cpu->H), &(cpu->L), getBC(cpu));
return 8;
case 0x19:
ADD_16BIT(cpu, &(cpu->H), &(cpu->L), getDE(cpu));
return 8;
case 0x29:
ADD_16BIT(cpu, &(cpu->H), &(cpu->L), getHL(cpu));
return 8;
case 0x39:
ADD_16BIT(cpu, &(cpu->H), &(cpu->L), cpu->stack);
return 8;
case 0x03:
INC_16BIT(&(cpu->B), &(cpu->C));
return 8;
case 0x13:
INC_16BIT(&(cpu->D), &(cpu->E));
return 8;
case 0x23:
INC_16BIT(&(cpu->H), &(cpu->L));
return 8;
case 0x33:
cpu->stack++;
return 8;
case 0x0B:
DEC_16BIT(&(cpu->B), &(cpu->C));
return 8;
case 0x1B:
DEC_16BIT(&(cpu->D), &(cpu->E));
return 8;
case 0x2B:
DEC_16BIT(&(cpu->H), &(cpu->L));
return 8;
case 0x3B:
cpu->stack--;
return 8;
case 0xE8:
GET_BYTE_PC(cpu, s_val);
val_16 = cpu->stack + s_val;
RESET_ZFLAG(cpu);
RESET_NFLAG(cpu);
if ((uint32_t)(cpu->stack + s_val) > 0xFFFF)
SET_CFLAG(cpu);
else
RESET_CFLAG(cpu);
if (((cpu->stack) & 0x8ff + (s_val)) > 0x8FF)
SET_HFLAG(cpu);
else
RESET_HFLAG(cpu);
cpu->stack = val_16;
return 16;
case 0xCB:
GET_BYTE_PC(cpu, val);
return extendedOpcodes(cpu, val);
case 0x27:
DAA(cpu);
return 4;
case 0x2F:
SET_NFLAG(cpu);
SET_HFLAG(cpu);
cpu->A = ~cpu->A;
return 4;
case 0x3F:
RESET_NFLAG(cpu);
RESET_HFLAG(cpu);
val = (cpu->F & 0x10) >> 4;
if (val == 0)
cpu->F |= 0x10;
else
cpu->F &= ~(0x10);
return 4;
case 0x37:
RESET_NFLAG(cpu);
RESET_HFLAG(cpu);
SET_CFLAG(cpu);
return 4;
case 0x07:
ROTATE_LEFT(cpu, &(cpu->A));
SET_ZFLAG(cpu);
return 4;
case 0x0F:
ROTATE_RIGHT(cpu, &(cpu->A));
SET_ZFLAG(cpu);
return 4;
case 0x17:
ROTATE_LEFT_CARRY(cpu, &(cpu->A));
SET_ZFLAG(cpu);
return 4;
case 0x1f:
ROTATE_RIGHT_CARRY(cpu, &(cpu->A));
SET_ZFLAG(cpu);
return 4;
case 0xF3:
cpu->whenDisableInterrupts = 2;
cpu->enable_interr = 0;
return 4;
case 0xFB:
cpu->whenDisableInterrupts = 2;
cpu->enable_interr = 1;
return 4;
case 0xC3:
GET_WORD_PC(cpu, val_16);
JMP(cpu, val_16);
return 12;
case 0xC2:
val = cpu->F & 0x80;
GET_WORD_PC(cpu, val_16);
if (val == 0)
JMP(cpu, val_16);
return 12;
case 0xCA:
val = cpu->F & 0x80;
GET_WORD_PC(cpu, val_16);
if (val != 0)
JMP(cpu, val_16);
return 12;
case 0xD2:
val = cpu->F & 0x10;
GET_WORD_PC(cpu, val_16);
if (val == 0)
JMP(cpu, val_16);
return 12;
case 0xDA:
val = cpu->F & 0x10;
GET_WORD_PC(cpu, val_16);
if (val != 0)
JMP(cpu, val_16);
return 12;
case 0xE9:
cpu->progCounter = getHL(cpu);
return 4;
case 0x18:
GET_BYTE_PC(cpu, s_val);
cpu->progCounter += s_val;
return 8;
case 0x20:
GET_BYTE_PC(cpu, s_val);
val = cpu->F & 0x80;
if (val == 0)
cpu->progCounter += s_val;
return 8;
case 0x28:
GET_BYTE_PC(cpu, s_val);
val = cpu->F & 0x80;
if (val != 0) {
cpu->progCounter += s_val;
}
return 8;
case 0x30:
GET_BYTE_PC(cpu, s_val);
val_16 = cpu->F & 0x10;
if (val_16 == 0)
cpu->progCounter += s_val;
return 8;
case 0x38:
GET_BYTE_PC(cpu, s_val);
val_16 = cpu->F & 0x10;
if (val_16 != 0)
cpu->progCounter += s_val;
return 8;
case 0xCD:
GET_WORD_PC(cpu, val_16);
PUSH(cpu, cpu->stack, cpu->progCounter);
cpu->progCounter = val_16;
return 24;
case 0xC4:
GET_WORD_PC(cpu, val_16);
val = cpu->F & 0x80;
if (val == 0) {
PUSH(cpu, cpu->stack, cpu->progCounter);
cpu->progCounter = val_16;
}
return 12;
case 0xCC:
GET_WORD_PC(cpu, val_16);
val = cpu->F & 0x80;
if (val != 0) {
PUSH(cpu, cpu->stack, cpu->progCounter);
cpu->progCounter = val_16;
}
return 12;
case 0xD4:
GET_WORD_PC(cpu, val_16);
val = cpu->F & 0x10;
if (val == 0) {
PUSH(cpu, cpu->stack, cpu->progCounter);
cpu->progCounter = val_16;
}
return 12;
case 0xDC:
GET_WORD_PC(cpu, val_16);
val = cpu->F & 0x10;
if (val != 0) {
PUSH(cpu, cpu->stack, cpu->progCounter);
cpu->progCounter = val_16;
}
return 12;
case 0xC7:
PUSH(cpu, cpu->stack, cpu->progCounter);
cpu->progCounter = 0x0;
return 32;
case 0xCF:
PUSH(cpu, cpu->stack, cpu->progCounter);
cpu->progCounter = 0x8;
return 32;
case 0xD7:
PUSH(cpu, cpu->stack, cpu->progCounter);
cpu->progCounter = 0x10;
return 32;
case 0xDF:
PUSH(cpu, cpu->stack, cpu->progCounter);
cpu->progCounter = 0x18;
return 32;
case 0xE7:
PUSH(cpu, cpu->stack, cpu->progCounter);
cpu->progCounter = 0x20;
return 32;
case 0xEF:
PUSH(cpu, cpu->stack, cpu->progCounter);
cpu->progCounter = 0x28;
return 32;
case 0xF7:
PUSH(cpu, cpu->stack, cpu->progCounter);
cpu->progCounter = 0x30;
return 32;
case 0xFF:
PUSH(cpu, cpu->stack, cpu->progCounter);
cpu->progCounter = 0x38;
return 32;
case 0xC9:
POP(cpu, cpu->stack, val_16);
cpu->progCounter = val_16;
return 8;
case 0xC0:
val = cpu->F & 0x80;
if (val == 0) {
POP(cpu, cpu->stack, val_16);
cpu->progCounter = val_16;
}
return 8;
case 0xC8:
val = cpu->F & 0x80;
if (val != 0) {
POP(cpu, cpu->stack, val_16);
cpu->progCounter = val_16;
}
return 8;
case 0xD0:
val = cpu->F & 0x10;
if (val == 0) {
POP(cpu, cpu->stack, val_16);
cpu->progCounter = val_16;
}
return 8;
case 0xD8:
val = cpu->F & 0x10;
if (val != 0) {
POP(cpu, cpu->stack, val_16);
cpu->progCounter = val_16;
}
return 8;
case 0xD9:
POP(cpu, cpu->stack, val_16);
cpu->progCounter = val_16;
cpu->master_interr_switch = 1;
return 8;
default:
fprintf(stderr, "Can't decode %x opcode (PC = %x)\n", opcode,
cpu->progCounter);
return 1;
}
return 1;
}
unsigned int extendedOpcodes(gb *cpu, BYTE opcode) {
BYTE val = 0;
switch (opcode) {
/*TODO You should check this*/
case 0x00:
ROTATE_LEFT(cpu, &(cpu->B));
return 8;
case 0x01:
ROTATE_LEFT(cpu, &(cpu->C));
return 8;
case 0x02:
ROTATE_LEFT(cpu, &(cpu->D));
return 8;
case 0x03:
ROTATE_LEFT(cpu, &(cpu->E));
return 8;
case 0x04:
ROTATE_LEFT(cpu, &(cpu->H));
return 8;
case 0x05:
ROTATE_LEFT(cpu, &(cpu->L));
return 8;
case 0x06:
val = readMemory(cpu, getHL(cpu));
ROTATE_LEFT(cpu, &val);
writeMemory(cpu, getHL(cpu), val);
return 16;
case 0x07:
ROTATE_LEFT(cpu, &(cpu->A));
return 8;
case 0x08:
ROTATE_RIGHT(cpu, &(cpu->B));
return 8;
case 0x09:
ROTATE_RIGHT(cpu, &(cpu->C));
return 8;
case 0x0A:
ROTATE_RIGHT(cpu, &(cpu->D));
return 8;
case 0x0B:
ROTATE_RIGHT(cpu, &(cpu->E));
return 8;
case 0x0C:
ROTATE_RIGHT(cpu, &(cpu->H));
return 8;
case 0x0D:
ROTATE_RIGHT(cpu, &(cpu->L));
return 8;
case 0x0E:
val = readMemory(cpu, getHL(cpu));
ROTATE_RIGHT(cpu, &val);
writeMemory(cpu, getHL(cpu), val);
return 16;
case 0x0F:
ROTATE_LEFT(cpu, &(cpu->A));
return 8;
case 0x10:
ROTATE_LEFT_CARRY(cpu, &(cpu->B));
return 8;
case 0x11:
ROTATE_LEFT_CARRY(cpu, &(cpu->C));
return 8;
case 0x12:
ROTATE_LEFT_CARRY(cpu, &(cpu->D));
return 8;
case 0x13:
ROTATE_LEFT_CARRY(cpu, &(cpu->E));
return 8;
case 0x14:
ROTATE_LEFT_CARRY(cpu, &(cpu->H));
return 8;
case 0x15:
ROTATE_LEFT_CARRY(cpu, &(cpu->L));
return 8;
case 0x16:
val = readMemory(cpu, getHL(cpu));
ROTATE_LEFT_CARRY(cpu, &val);
writeMemory(cpu, getHL(cpu), val);
return 16;
case 0x17:
ROTATE_LEFT_CARRY(cpu, &(cpu->A));
return 8;
case 0x18:
ROTATE_RIGHT_CARRY(cpu, &(cpu->B));
return 8;
case 0x19:
ROTATE_RIGHT_CARRY(cpu, &(cpu->C));
return 8;
case 0x1A:
ROTATE_RIGHT_CARRY(cpu, &(cpu->D));
return 8;
case 0x1B:
ROTATE_RIGHT_CARRY(cpu, &(cpu->E));
return 8;
case 0x1C:
ROTATE_RIGHT_CARRY(cpu, &(cpu->H));
return 8;
case 0x1D:
ROTATE_RIGHT_CARRY(cpu, &(cpu->L));
return 8;
case 0x1E:
val = readMemory(cpu, getHL(cpu));
ROTATE_RIGHT_CARRY(cpu, &val);
writeMemory(cpu, getHL(cpu), val);
return 16;
case 0x1F:
ROTATE_RIGHT_CARRY(cpu, &(cpu->A));
return 8;
case 0x20:
SHIFT_LEFT(cpu, &(cpu->B));
return 8;
case 0x21:
SHIFT_LEFT(cpu, &(cpu->C));
return 8;
case 0x22:
SHIFT_LEFT(cpu, &(cpu->D));
return 8;
case 0x23:
SHIFT_LEFT(cpu, &(cpu->E));
return 8;
case 0x24:
SHIFT_LEFT(cpu, &(cpu->H));
return 8;
case 0x25:
SHIFT_LEFT(cpu, &(cpu->L));
return 8;
case 0x26:
val = readMemory(cpu, getHL(cpu));
SHIFT_LEFT(cpu, &val);
writeMemory(cpu, getHL(cpu), val);
return 8;
case 0x27:
SHIFT_LEFT(cpu, &(cpu->A));
return 16;
case 0x28:
SHIFT_RIGHT_ARITH(cpu, &(cpu->B));
return 8;
case 0x29:
SHIFT_RIGHT_ARITH(cpu, &(cpu->C));
return 8;
case 0x2A:
SHIFT_RIGHT_ARITH(cpu, &(cpu->D));
return 8;
case 0x2B:
SHIFT_RIGHT_ARITH(cpu, &(cpu->E));
return 8;
case 0x2C:
SHIFT_RIGHT_ARITH(cpu, &(cpu->H));
return 8;
case 0x2D:
SHIFT_RIGHT_ARITH(cpu, &(cpu->L));
return 8;
case 0x2E:
val = readMemory(cpu, getHL(cpu));
SHIFT_RIGHT_ARITH(cpu, &val);
writeMemory(cpu, getHL(cpu), val);
return 8;
case 0x2F:
SHIFT_RIGHT_ARITH(cpu, &(cpu->A));
return 16;
case 0x30:
SWAP_NIBBLES(cpu, &(cpu->B));
return 8;
case 0x31:
SWAP_NIBBLES(cpu, &(cpu->C));
return 8;
case 0x32:
SWAP_NIBBLES(cpu, &(cpu->D));
return 8;
case 0x33:
SWAP_NIBBLES(cpu, &(cpu->E));
return 8;
case 0x34:
SWAP_NIBBLES(cpu, &(cpu->H));
return 8;
case 0x35:
SWAP_NIBBLES(cpu, &(cpu->L));
return 8;
case 0x36:
val = readMemory(cpu, getHL(cpu));
SWAP_NIBBLES(cpu, &val);
writeMemory(cpu, getHL(cpu), val);
return 16;
case 0x37:
SWAP_NIBBLES(cpu, &(cpu->A));
return 8;
case 0x38:
SHIFT_RIGHT(cpu, &(cpu->B));
return 8;
case 0x39:
SHIFT_RIGHT(cpu, &(cpu->C));
return 8;
case 0x3A:
SHIFT_RIGHT(cpu, &(cpu->D));
return 8;
case 0x3B:
SHIFT_RIGHT(cpu, &(cpu->E));
return 8;
case 0x3C:
SHIFT_RIGHT(cpu, &(cpu->H));
return 8;
case 0x3D:
SHIFT_RIGHT(cpu, &(cpu->L));
return 8;
case 0x3E:
val = readMemory(cpu, getHL(cpu));
SHIFT_RIGHT(cpu, &val);
writeMemory(cpu, getHL(cpu), val);
return 16;
case 0x3F:
SHIFT_RIGHT(cpu, &(cpu->A));
return 8;
case 0x40:
TEST_BIT(cpu, cpu->B, 0);
return 8;
case 0x41:
TEST_BIT(cpu, cpu->C, 0);
return 8;
case 0x42:
TEST_BIT(cpu, cpu->D, 0);
return 8;
case 0x43:
TEST_BIT(cpu, cpu->E, 0);
return 8;
case 0x44:
TEST_BIT(cpu, cpu->H, 0);
return 8;
case 0x45:
TEST_BIT(cpu, cpu->L, 0);
return 8;
case 0x46:
val = readMemory(cpu, getHL(cpu));
TEST_BIT(cpu, val, 0);
return 16;
case 0x47:
TEST_BIT(cpu, cpu->A, 0);
return 8;
case 0x48:
TEST_BIT(cpu, cpu->B, 1);
return 8;
case 0x49:
TEST_BIT(cpu, cpu->C, 1);
return 8;
case 0x4A:
TEST_BIT(cpu, cpu->D, 1);
return 8;
case 0x4B:
TEST_BIT(cpu, cpu->E, 1);
return 8;
case 0x4C:
TEST_BIT(cpu, cpu->H, 1);
return 8;
case 0x4D:
TEST_BIT(cpu, cpu->L, 1);
return 8;
case 0x4E:
val = readMemory(cpu, getHL(cpu));
TEST_BIT(cpu, val, 1);
return 16;
case 0x4F:
TEST_BIT(cpu, cpu->A, 1);
return 8;
case 0x50:
TEST_BIT(cpu, cpu->B, 2);
return 8;
case 0x51:
TEST_BIT(cpu, cpu->C, 2);
return 8;
case 0x52:
TEST_BIT(cpu, cpu->D, 2);
return 8;
case 0x53:
TEST_BIT(cpu, cpu->E, 2);
return 8;
case 0x54:
TEST_BIT(cpu, cpu->H, 2);
return 8;
case 0x55:
TEST_BIT(cpu, cpu->L, 2);
return 8;
case 0x56:
val = readMemory(cpu, getHL(cpu));
TEST_BIT(cpu, val, 2);
return 16;
case 0x57:
TEST_BIT(cpu, cpu->A, 2);
return 8;
case 0x58:
TEST_BIT(cpu, cpu->B, 3);
return 8;
case 0x59:
TEST_BIT(cpu, cpu->C, 3);
return 8;
case 0x5A:
TEST_BIT(cpu, cpu->D, 3);
return 8;
case 0x5B:
TEST_BIT(cpu, cpu->E, 3);
return 8;
case 0x5C:
TEST_BIT(cpu, cpu->H, 3);
return 8;
case 0x5D:
TEST_BIT(cpu, cpu->L, 3);
return 8;
case 0x5E:
val = readMemory(cpu, getHL(cpu));
TEST_BIT(cpu, val, 3);
return 16;
case 0x5F:
TEST_BIT(cpu, cpu->A, 3);
return 8;
case 0x60:
TEST_BIT(cpu, cpu->B, 4);
return 8;
case 0x61:
TEST_BIT(cpu, cpu->C, 4);
return 8;
case 0x62:
TEST_BIT(cpu, cpu->D, 4);
return 8;
case 0x63:
TEST_BIT(cpu, cpu->E, 4);
return 8;
case 0x64:
TEST_BIT(cpu, cpu->H, 4);
return 8;
case 0x65:
TEST_BIT(cpu, cpu->L, 4);
return 8;
case 0x66:
val = readMemory(cpu, getHL(cpu));
TEST_BIT(cpu, val, 4);
return 16;
case 0x67:
TEST_BIT(cpu, cpu->A, 4);
return 8;
case 0x68:
TEST_BIT(cpu, cpu->B, 5);
return 8;
case 0x69:
TEST_BIT(cpu, cpu->C, 5);
return 8;
case 0x6A:
TEST_BIT(cpu, cpu->D, 5);
return 8;
case 0x6B:
TEST_BIT(cpu, cpu->E, 5);
return 8;
case 0x6C:
TEST_BIT(cpu, cpu->H, 5);
return 8;
case 0x6D:
TEST_BIT(cpu, cpu->L, 5);
return 8;
case 0x6E:
val = readMemory(cpu, getHL(cpu));
TEST_BIT(cpu, val, 5);
return 16;
case 0x6F:
TEST_BIT(cpu, cpu->A, 5);
return 8;
case 0x70:
TEST_BIT(cpu, cpu->B, 6);
return 8;
case 0x71:
TEST_BIT(cpu, cpu->C, 6);
return 8;
case 0x72:
TEST_BIT(cpu, cpu->D, 6);
return 8;
case 0x73:
TEST_BIT(cpu, cpu->E, 6);
return 8;
case 0x74:
TEST_BIT(cpu, cpu->H, 6);
return 8;
case 0x75:
TEST_BIT(cpu, cpu->L, 6);
return 8;
case 0x76:
val = readMemory(cpu, getHL(cpu));
TEST_BIT(cpu, val, 6);
return 16;
case 0x77:
TEST_BIT(cpu, cpu->A, 6);
return 8;
case 0x78:
TEST_BIT(cpu, cpu->B, 7);
return 8;
case 0x79:
TEST_BIT(cpu, cpu->C, 7);
return 8;
case 0x7A:
TEST_BIT(cpu, cpu->D, 7);
return 8;
case 0x7B:
TEST_BIT(cpu, cpu->E, 7);
return 8;
case 0x7C:
TEST_BIT(cpu, cpu->H, 7);
return 8;
case 0x7D:
TEST_BIT(cpu, cpu->L, 7);
return 8;
case 0x7E:
val = readMemory(cpu, getHL(cpu));
TEST_BIT(cpu, val, 7);
return 16;
case 0x7F:
TEST_BIT(cpu, cpu->A, 7);
return 8;
case 0x80:
RESET_BIT(cpu, &(cpu->B), 0);
return 8;
case 0x81:
RESET_BIT(cpu, &(cpu->C), 0);
return 8;
case 0x82:
RESET_BIT(cpu, &(cpu->D), 0);
return 8;
case 0x83:
RESET_BIT(cpu, &(cpu->E), 0);
return 8;
case 0x84:
RESET_BIT(cpu, &(cpu->H), 0);
return 8;
case 0x85:
RESET_BIT(cpu, &(cpu->L), 0);
return 8;
case 0x86:
val = readMemory(cpu, getHL(cpu));
RESET_BIT(cpu, &val, 0);
writeMemory(cpu, getHL(cpu), val);
return 16;
case 0x87:
RESET_BIT(cpu, &(cpu->A), 0);
return 8;
case 0x88:
RESET_BIT(cpu, &(cpu->B), 1);
return 8;
case 0x89:
RESET_BIT(cpu, &(cpu->C), 1);
return 8;
case 0x8A:
RESET_BIT(cpu, &(cpu->D), 1);
return 8;
case 0x8B:
RESET_BIT(cpu, &(cpu->E), 1);
return 8;
case 0x8C:
RESET_BIT(cpu, &(cpu->H), 1);
return 8;
case 0x8D:
RESET_BIT(cpu, &(cpu->L), 1);
return 8;
case 0x8E:
val = readMemory(cpu, getHL(cpu));
RESET_BIT(cpu, &val, 1);
writeMemory(cpu, getHL(cpu), val);
return 16;
case 0x8F:
RESET_BIT(cpu, &(cpu->A), 1);
return 8;
case 0x90:
RESET_BIT(cpu, &(cpu->B), 2);
return 8;
case 0x91:
RESET_BIT(cpu, &(cpu->C), 2);
return 8;
case 0x92:
RESET_BIT(cpu, &(cpu->D), 2);
return 8;
case 0x93:
RESET_BIT(cpu, &(cpu->E), 2);
return 8;
case 0x94:
RESET_BIT(cpu, &(cpu->H), 2);
return 8;
case 0x95:
RESET_BIT(cpu, &(cpu->L), 2);
return 8;
case 0x96:
val = readMemory(cpu, getHL(cpu));
RESET_BIT(cpu, &val, 2);
writeMemory(cpu, getHL(cpu), val);
return 16;
case 0x97:
RESET_BIT(cpu, &(cpu->A), 2);
return 8;
case 0x98:
RESET_BIT(cpu, &(cpu->B), 3);
return 8;
case 0x99:
RESET_BIT(cpu, &(cpu->C), 3);
return 8;
case 0x9A:
RESET_BIT(cpu, &(cpu->D), 3);
return 8;
case 0x9B:
RESET_BIT(cpu, &(cpu->E), 3);
return 8;
case 0x9C:
RESET_BIT(cpu, &(cpu->H), 3);
return 8;
case 0x9D:
RESET_BIT(cpu, &(cpu->L), 3);
return 8;
case 0x9E:
val = readMemory(cpu, getHL(cpu));
RESET_BIT(cpu, &val, 3);
writeMemory(cpu, getHL(cpu), val);
return 16;
case 0x9F:
RESET_BIT(cpu, &(cpu->A), 3);
return 8;
case 0xA0:
RESET_BIT(cpu, &(cpu->B), 4);
return 8;
case 0xA1:
RESET_BIT(cpu, &(cpu->C), 4);
return 8;
case 0xA2:
RESET_BIT(cpu, &(cpu->D), 4);
return 8;
case 0xA3:
RESET_BIT(cpu, &(cpu->E), 4);
return 8;
case 0xA4:
RESET_BIT(cpu, &(cpu->H), 4);
return 8;
case 0xA5:
RESET_BIT(cpu, &(cpu->L), 4);
return 8;
case 0xA6:
val = readMemory(cpu, getHL(cpu));
RESET_BIT(cpu, &val, 4);
writeMemory(cpu, getHL(cpu), val);
return 16;
case 0xA7:
RESET_BIT(cpu, &(cpu->A), 4);
return 8;
case 0xA8:
RESET_BIT(cpu, &(cpu->B), 5);
return 8;
case 0xA9:
RESET_BIT(cpu, &(cpu->C), 5);
return 8;
case 0xAA:
RESET_BIT(cpu, &(cpu->D), 5);
return 8;
case 0xAB:
RESET_BIT(cpu, &(cpu->E), 5);
return 8;
case 0xAC:
RESET_BIT(cpu, &(cpu->H), 5);
return 8;
case 0xAD:
RESET_BIT(cpu, &(cpu->L), 5);
return 8;
case 0xAE:
val = readMemory(cpu, getHL(cpu));
RESET_BIT(cpu, &val, 5);
writeMemory(cpu, getHL(cpu), val);
return 16;
case 0xAF:
RESET_BIT(cpu, &(cpu->A), 5);
return 8;
case 0xB0:
RESET_BIT(cpu, &(cpu->B), 6);
return 8;
case 0xB1:
RESET_BIT(cpu, &(cpu->C), 6);
return 8;
case 0xB2:
RESET_BIT(cpu, &(cpu->D), 6);
return 8;
case 0xB3:
RESET_BIT(cpu, &(cpu->E), 6);
return 8;
case 0xB4:
RESET_BIT(cpu, &(cpu->H), 6);
return 8;
case 0xB5:
RESET_BIT(cpu, &(cpu->L), 6);
return 8;
case 0xB6:
val = readMemory(cpu, getHL(cpu));
RESET_BIT(cpu, &val, 6);
writeMemory(cpu, getHL(cpu), val);
return 16;
case 0xB7:
RESET_BIT(cpu, &(cpu->A), 6);
return 8;
case 0xB8:
RESET_BIT(cpu, &(cpu->B), 7);
return 8;
case 0xB9:
RESET_BIT(cpu, &(cpu->C), 7);
return 8;
case 0xBA:
RESET_BIT(cpu, &(cpu->D), 7);
return 8;
case 0xBB:
RESET_BIT(cpu, &(cpu->E), 7);
return 8;
case 0xBC:
RESET_BIT(cpu, &(cpu->H), 7);
return 8;
case 0xBD:
RESET_BIT(cpu, &(cpu->L), 7);
return 8;
case 0xBE:
val = readMemory(cpu, getHL(cpu));
RESET_BIT(cpu, &val, 7);
writeMemory(cpu, getHL(cpu), val);
return 16;
case 0xBF:
RESET_BIT(cpu, &(cpu->A), 7);
return 8;
case 0xC0:
SET_BIT(cpu, &(cpu->B), 0);
return 8;
case 0xC1:
SET_BIT(cpu, &(cpu->C), 0);
return 8;
case 0xC2:
SET_BIT(cpu, &(cpu->D), 0);
return 8;
case 0xC3:
SET_BIT(cpu, &(cpu->E), 0);
return 8;
case 0xC4:
SET_BIT(cpu, &(cpu->H), 0);
return 8;
case 0xC5:
SET_BIT(cpu, &(cpu->L), 0);
return 8;
case 0xC6:
val = readMemory(cpu, getHL(cpu));
SET_BIT(cpu, &val, 0);
writeMemory(cpu, getHL(cpu), val);
return 16;
case 0xC7:
SET_BIT(cpu, &(cpu->A), 0);
return 8;
case 0xC8:
SET_BIT(cpu, &(cpu->B), 1);
return 8;
case 0xC9:
SET_BIT(cpu, &(cpu->C), 1);
return 8;
case 0xCA:
SET_BIT(cpu, &(cpu->D), 1);
return 8;
case 0xCB:
SET_BIT(cpu, &(cpu->E), 1);
return 8;
case 0xCC:
SET_BIT(cpu, &(cpu->H), 1);
return 8;
case 0xCD:
SET_BIT(cpu, &(cpu->L), 1);
return 8;
case 0xCE:
val = readMemory(cpu, getHL(cpu));
SET_BIT(cpu, &val, 1);
writeMemory(cpu, getHL(cpu), val);
return 16;
case 0xCF:
SET_BIT(cpu, &(cpu->A), 1);
return 8;
case 0xD0:
SET_BIT(cpu, &(cpu->B), 2);
return 8;
case 0xD1:
SET_BIT(cpu, &(cpu->C), 2);
return 8;
case 0xD2:
SET_BIT(cpu, &(cpu->D), 2);
return 8;
case 0xD3:
SET_BIT(cpu, &(cpu->E), 2);
return 8;
case 0xD4:
SET_BIT(cpu, &(cpu->H), 2);
return 8;
case 0xD5:
SET_BIT(cpu, &(cpu->L), 2);
return 8;
case 0xD6:
val = readMemory(cpu, getHL(cpu));
SET_BIT(cpu, &val, 2);
writeMemory(cpu, getHL(cpu), val);
return 16;
case 0xD7:
SET_BIT(cpu, &(cpu->A), 2);
return 8;
case 0xD8:
SET_BIT(cpu, &(cpu->B), 3);
return 8;
case 0xD9:
SET_BIT(cpu, &(cpu->C), 3);
return 8;
case 0xDA:
SET_BIT(cpu, &(cpu->D), 3);
return 8;
case 0xDB:
SET_BIT(cpu, &(cpu->E), 3);
return 8;
case 0xDC:
SET_BIT(cpu, &(cpu->H), 3);
return 8;
case 0xDD:
SET_BIT(cpu, &(cpu->L), 3);
return 8;
case 0xDE:
val = readMemory(cpu, getHL(cpu));
SET_BIT(cpu, &val, 3);
writeMemory(cpu, getHL(cpu), val);
return 16;
case 0xDF:
SET_BIT(cpu, &(cpu->A), 3);
return 8;
case 0xE0:
SET_BIT(cpu, &(cpu->B), 4);
return 8;
case 0xE1:
SET_BIT(cpu, &(cpu->C), 4);
return 8;
case 0xE2:
SET_BIT(cpu, &(cpu->D), 4);
return 8;
case 0xE3:
SET_BIT(cpu, &(cpu->E), 4);
return 8;
case 0xE4:
SET_BIT(cpu, &(cpu->H), 4);
return 8;
case 0xE5:
SET_BIT(cpu, &(cpu->L), 4);
return 8;
case 0xE6:
val = readMemory(cpu, getHL(cpu));
SET_BIT(cpu, &val, 4);
writeMemory(cpu, getHL(cpu), val);
return 16;
case 0xE7:
SET_BIT(cpu, &(cpu->A), 4);
return 8;
case 0xE8:
SET_BIT(cpu, &(cpu->B), 5);
return 8;
case 0xE9:
SET_BIT(cpu, &(cpu->C), 5);
return 8;
case 0xEA:
SET_BIT(cpu, &(cpu->D), 5);
return 8;
case 0xEB:
SET_BIT(cpu, &(cpu->E), 5);
return 8;
case 0xEC:
SET_BIT(cpu, &(cpu->H), 5);
return 8;
case 0xED:
SET_BIT(cpu, &(cpu->L), 5);
return 8;
case 0xEE:
val = readMemory(cpu, getHL(cpu));
SET_BIT(cpu, &val, 5);
writeMemory(cpu, getHL(cpu), val);
return 16;
case 0xEF:
SET_BIT(cpu, &(cpu->A), 5);
return 8;
case 0xF0:
SET_BIT(cpu, &(cpu->B), 6);
return 8;
case 0xF1:
SET_BIT(cpu, &(cpu->C), 6);
return 8;
case 0xF2:
SET_BIT(cpu, &(cpu->D), 6);
return 8;
case 0xF3:
SET_BIT(cpu, &(cpu->E), 6);
return 8;
case 0xF4:
SET_BIT(cpu, &(cpu->H), 6);
return 8;
case 0xF5:
SET_BIT(cpu, &(cpu->L), 6);
return 8;
case 0xF6:
val = readMemory(cpu, getHL(cpu));
SET_BIT(cpu, &val, 6);
writeMemory(cpu, getHL(cpu), val);
return 16;
case 0xF7:
SET_BIT(cpu, &(cpu->A), 6);
return 8;
case 0xF8:
SET_BIT(cpu, &(cpu->B), 7);
return 8;
case 0xF9:
SET_BIT(cpu, &(cpu->C), 7);
return 8;
case 0xFA:
SET_BIT(cpu, &(cpu->D), 7);
return 8;
case 0xFB:
SET_BIT(cpu, &(cpu->E), 7);
return 8;
case 0xFC:
SET_BIT(cpu, &(cpu->H), 7);
return 8;
case 0xFD:
SET_BIT(cpu, &(cpu->L), 7);
return 8;
case 0xFE:
val = readMemory(cpu, getHL(cpu));
SET_BIT(cpu, &val, 7);
writeMemory(cpu, getHL(cpu), val);
return 16;
case 0xFF:
SET_BIT(cpu, &(cpu->A), 7);
return 8;
default:
fprintf(stderr, "Can't decode CB %x opcode (PC = %x)\n", opcode,
cpu->progCounter);
return 1;
}
}
View Git Blame Copy Permalink