cpu.hpp

#ifndef CPU_HPP
#define CPU_HPP
 
#include <stdint.h>
#include <map>
#include <string>
#include <queue>
 
class Bus;
 
struct Instruction
{
    uint32_t ins;
 
    Instruction() {}
 
    Instruction(uint32_t ins) : ins(ins) {}
 
    uint32_t opcode() { return ins >> 26; }
 
    uint32_t rs() { return (ins >> 21) & 0x1f; }
 
    uint32_t rt() { return (ins >> 16) & 0x1f; }
 
    uint32_t rd() { return (ins >> 11) & 0x1f; }
 
    uint32_t shamt() { return (ins >> 6) & 0x1f; }
 
    uint32_t funct() { return ins & 0x3f; }
 
    uint32_t imm() { return ins & 0xffff; } // Bits 15-0
 
    uint32_t addr() { return ins & 0x3ffffff; } // Bits 25-0
};
 
struct RegisterLoad
{
    uint32_t reg;
 
    uint32_t data;
 
    uint32_t delay;
 
    RegisterLoad() {}
 
    RegisterLoad(uint32_t reg, uint32_t data): reg(reg), data(data) { delay = 0; }
 
    RegisterLoad(uint32_t reg, uint32_t data, uint32_t delay): reg(reg), data(data), delay(delay) {}
};
 
class CPU
{
public:
    CPU();
 
    void connectBus(Bus* bus) { this->bus = bus; }
 
    void clock();
 
private:
    void load_next_ins();
    void decode_and_execute();
 
    uint32_t read32(uint32_t addr);
    void write32(uint32_t addr, uint32_t data);
    uint16_t read16(uint32_t addr);
    void write16(uint32_t addr, uint16_t data);
    uint8_t read8(uint32_t addr);
    void write8(uint32_t addr, uint8_t data);
 
private:
    Bus* bus;
 
    std::queue<RegisterLoad> load_queue;
 
    uint32_t pc = 0;
 
    uint32_t ir;
 
    uint32_t ir_next;
 
    Instruction ins;
 
    uint32_t regs[32] = {0xdeaddeed};
 
    uint32_t hi = 0;
 
    uint32_t lo = 0;
 
    uint32_t cop0_status;
 
    uint32_t cop0_bpc;
 
    uint32_t cop0_bda;
 
    uint32_t cop0_dcic;
 
    uint32_t cop0_bdam;
 
    uint32_t cop0_bpcm;
 
    uint32_t cop0_cause;
 
private:
    void branch(uint32_t offset);
    void set_reg(uint8_t reg, uint32_t data);
    uint32_t get_reg(uint8_t reg);
    void load_regs();
    void conf_ins_lookup();
    void conf_mnemonic_lookup();
 
public:
    void show_regs();
    void reset();
 
private:
    std::map<uint8_t, void (CPU::*)()> lookup_op;
 
    std::map<uint8_t, void (CPU::*)()> lookup_special;
 
    std::map<uint8_t, void (CPU::*)()> lookup_cop0;
 
    std::map<uint8_t, void (CPU::*)()> lookup_cop2;
 
    std::map<uint8_t, std::string> lookup_mnemonic_op;
 
    std::map<uint8_t, std::string> lookup_mnemonic_special;
 
    void LUI();
    void ORI();
    void SW();
    void ADDIU();
    void J();
    void BNE();
    void ADDI();
    void LW();
    void SH();
    void JAL();
    void ANDI();
    void SB();
    void LB();
    void BEQ();
    void BGTZ();
    void BLEZ();
    void LBU();
    void SLTI();
    void SLTIU();
 
    void SPECIAL();
    void SLL();
    void OR();
    void SLTU();
    void ADDU();
    void JR();
    void AND();
    void ADD();
    void JALR();
    void SRA();
    void SUBU();
    void DIV();
    void MFLO();
    void SRL();
    void DIVU();
    void MFHI();
    void SLT();
 
    void BLGE();
    void BLTZ();
    void BGEZ();
    void BGEZAL();
    void BLTZAL();
 
    void COP0();
    void MTC0();
    void MFC0();
 
    void COP1();
 
    void COP2();
 
    void COP3();
};
 
#endif