191 lines
3 KiB
C++
191 lines
3 KiB
C++
#pragma once
|
|
|
|
#include <misc/types.h>
|
|
#include <misc/exception.h>
|
|
|
|
#include <memory/device.h>
|
|
|
|
typedef u8 opcode_t;
|
|
|
|
enum Flags {
|
|
F_ZERO = 0x8,
|
|
F_SUB = 0x4,
|
|
F_HALF = 0x2,
|
|
F_CARRY = 0x1,
|
|
};
|
|
|
|
enum AluOp : int {
|
|
ADD = 0,
|
|
ADC = 1,
|
|
SUB = 2,
|
|
SBC = 3,
|
|
AND = 4,
|
|
XOR = 5,
|
|
OR = 6,
|
|
CP = 7,
|
|
};
|
|
|
|
enum CC
|
|
{
|
|
COND_NZ = 0,
|
|
COND_Z = 1,
|
|
COND_NC = 2,
|
|
COND_C = 3,
|
|
};
|
|
|
|
enum InterruptType : u8
|
|
{
|
|
INT_VBlank = 0x1,
|
|
INT_LCDSTAT = 0x2,
|
|
INT_Timer = 0x4,
|
|
INT_Serial = 0x8,
|
|
INT_Joypad = 0x10,
|
|
|
|
INT_MASK = 0x1F,
|
|
};
|
|
|
|
|
|
/**
|
|
IME - Interrupt Master Enable
|
|
|
|
An EI instruction will enable the interrupts, but delayed. During the next instruction after EI,
|
|
interrupts are still disabled. For this to be emulated we use a small state machine. which works as follows
|
|
|
|
instruction EI - sets IME_SCHEDULED
|
|
handleInterrupts -> IME_SCHEDULED to IME_ON (but no call to isr yet)
|
|
instruction any - is IME_ON, but no chance for call to isr yet
|
|
handleInterrupts -> is IME_ON, do a call to isr if necessary
|
|
*/
|
|
enum IME_state
|
|
{
|
|
IME_OFF,
|
|
IME_SCHEDULED,
|
|
IME_ON,
|
|
};
|
|
|
|
struct opcode {
|
|
const opcode_t value;
|
|
|
|
inline operator opcode_t() const
|
|
{ return value; }
|
|
|
|
inline u8 reg8idxlo() const
|
|
{ return value & 0x7; }
|
|
|
|
inline u8 reg8idxhi() const
|
|
{ return (value >> 3) & 0x7; }
|
|
|
|
inline u8 reg16idx() const
|
|
{ return (value >> 4) & 0x3; }
|
|
|
|
inline AluOp aluop() const
|
|
{ return (AluOp)((value >> 3) & 0x7); }
|
|
|
|
inline u8 cc() const
|
|
{ return (value >> 3) & 0x3; }
|
|
|
|
inline u16 rst_addr() const
|
|
{ return (u16)(value & 0x38); }
|
|
};
|
|
|
|
class Cpu;
|
|
|
|
struct Cpu_state {
|
|
// Registers
|
|
union {
|
|
u16 BC;
|
|
struct { u8 C; u8 B; };
|
|
};
|
|
union {
|
|
u16 DE;
|
|
struct { u8 E; u8 D; };
|
|
};
|
|
union {
|
|
u16 HL;
|
|
struct { u8 L; u8 H; };
|
|
};
|
|
|
|
u8 A;
|
|
u16 SP;
|
|
u16 PC;
|
|
|
|
bool zero;
|
|
bool subtract;
|
|
bool halfcarry;
|
|
bool carry;
|
|
|
|
IME_state IME;
|
|
|
|
u8 IE;
|
|
u8 IF;
|
|
|
|
|
|
// servicable interrupts
|
|
inline u8 SI() const
|
|
{ return INT_MASK & IE & IF; }
|
|
|
|
bool halted;
|
|
bool haltbug;
|
|
bool stopped;
|
|
|
|
void setAF(u16 v);
|
|
u16 getAF();
|
|
|
|
u8& reg8(Cpu& cpu, u8 idx);
|
|
u16& reg16(Cpu& cpu, u8 idx);
|
|
};
|
|
|
|
class Cpu {
|
|
private:
|
|
u8 readPC8();
|
|
u16 readPC16();
|
|
|
|
void pushStack8(u8 data);
|
|
u8 popStack8();
|
|
|
|
void pushStack16(u16 data);
|
|
u16 popStack16();
|
|
|
|
void aluop8(AluOp op, u8 lhs, u8 rhs, u8& out, bool update_carry = true);
|
|
void add16(u16& out, u16 lhs, u16 rhs);
|
|
|
|
inline
|
|
void aluop8(AluOp op, u8 rhs, bool update_carry = true)
|
|
{
|
|
aluop8(op, state.A, rhs, state.A, update_carry);
|
|
}
|
|
|
|
void doCall(u16 target);
|
|
void doRet();
|
|
|
|
bool decodeCond(u8 cc);
|
|
|
|
bool handleInterrupts();
|
|
void executeInstruction();
|
|
|
|
void reset();
|
|
|
|
public:
|
|
Cpu(Mem_device* bus);
|
|
|
|
Cpu_state state;
|
|
Mem_device* bus;
|
|
unsigned long processed_mcycles;
|
|
u16 last_instr_addr;
|
|
|
|
void signalInterrupt(InterruptType it);
|
|
|
|
void step();
|
|
};
|
|
|
|
class CpuException : public EmulatorException {
|
|
private:
|
|
Cpu_state state;
|
|
u16 instaddr;
|
|
u8 instmem[4];
|
|
|
|
public:
|
|
CpuException(Cpu& cpu, const char* msg);
|
|
|
|
virtual const char* what() const noexcept override;
|
|
};
|