169 lines
4.8 KiB
C++
169 lines
4.8 KiB
C++
#include "Interpreter.hpp"
|
|
#include <cstring>
|
|
#include <stdexcept>
|
|
|
|
namespace chocochip8 {
|
|
|
|
Interpreter::Interpreter(unsigned ticksPerSecond, Display &display, Buzzer &buzzer, Keypad &keypad):
|
|
mvMemory(scMemorySize),
|
|
mCallStack{},
|
|
mrDisplay{display},
|
|
mrBuzzer{buzzer},
|
|
mrKeypad{keypad},
|
|
mcTicksPerSecond{ticksPerSecond},
|
|
mvSpecialReg{},
|
|
mvReg{} {}
|
|
|
|
void Interpreter::tick() {
|
|
// decodes all possible machine code arithmetic opcodes
|
|
constexpr Opcode opcodeMap[16] = {
|
|
Opcode::SET, Opcode::OR, Opcode::AND, Opcode::XOR,
|
|
Opcode::ADD, Opcode::SUB, Opcode::RSH, Opcode::SUB2,
|
|
Opcode::UNIMPL, Opcode::UNIMPL, Opcode::UNIMPL, Opcode::UNIMPL,
|
|
Opcode::UNIMPL, Opcode::UNIMPL, Opcode::LSH, Opcode::UNIMPL,
|
|
};
|
|
|
|
// fetch instruction
|
|
sreg_t pc = mvSpecialReg[SR_PC];
|
|
unsigned inst = (mvMemory[pc] << 8) | mvMemory[pc + 1];
|
|
|
|
// extract fields
|
|
unsigned regDst = (inst & 0x0F00) >> 8; // destination register index
|
|
unsigned regSrc = (inst & 0x00F0) >> 4; // source register index
|
|
unsigned opcode = (inst & 0x000F); // arithmetic opcode
|
|
unsigned imm8 = (inst & 0x00FF); // 8-bit immediate
|
|
unsigned imm12 = (inst & 0x0FFF); // 12-bit immediate
|
|
|
|
switch(inst & 0xF000) {
|
|
case 0x0000: // 0NNN - call machine language routine
|
|
switch(inst) {
|
|
case 0x00E0: // clear display
|
|
for(auto &scanline : *mrDisplay.mpFramebuffer) {
|
|
scanline.reset();
|
|
}
|
|
break;
|
|
case 0x00EE: // return from subroutine
|
|
mvSpecialReg[SR_PC] = mCallStack.top();
|
|
mCallStack.pop();
|
|
break;
|
|
default:
|
|
throw std::invalid_argument("not implemented");
|
|
break;
|
|
}
|
|
break;
|
|
case 0x1000: // 1NNN - unconditional jump
|
|
mvSpecialReg[SR_PC] = imm12;
|
|
break;
|
|
case 0x2000: // 2NNN - call subroutine
|
|
mCallStack.push(pc);
|
|
mvSpecialReg[SR_PC] = imm12;
|
|
break;
|
|
case 0x3000: // 3XNN - skip if equal immediate
|
|
executeArithmetic(Opcode::JEQ, regDst, imm8);
|
|
break;
|
|
case 0x4000: // 4XNN - skip if nonequal immediate
|
|
executeArithmetic(Opcode::JNEQ, regDst, imm8);
|
|
break;
|
|
case 0x5000: // 5XY0 - skip if equal
|
|
executeArithmetic(Opcode::JEQ, regDst, mvReg[regSrc]);
|
|
break;
|
|
case 0x6000: // 6XNN - load immediate
|
|
executeArithmetic(Opcode::SET, regDst, imm8);
|
|
break;
|
|
case 0x7000: // 7XNN - increment
|
|
executeArithmetic(Opcode::ADD, regDst, imm8);
|
|
break;
|
|
case 0x8000: // 8XNN - general arithmetic
|
|
executeArithmetic(opcodeMap[opcode], regDst, mvReg[regSrc]);
|
|
break;
|
|
case 0x9000: // 9XY0 - skip if nonequal
|
|
executeArithmetic(Opcode::JNEQ, regDst, mvReg[regSrc]);
|
|
break;
|
|
case 0xA000: // ANNN - load I
|
|
mvSpecialReg[SR_I] = imm12;
|
|
break;
|
|
case 0xB000: // BNNN - jump indirect
|
|
mvSpecialReg[SR_I] = mvReg[R_V0] + imm12;
|
|
break;
|
|
case 0xC000: // CXNN - load random
|
|
executeArithmetic(Opcode::RAND, regDst, imm8);
|
|
break;
|
|
case 0xD000: // DXYN - draw
|
|
break;
|
|
case 0xE000: // EX9E, EXA1 - keypad access
|
|
break;
|
|
case 0xF000: // several unique instructions
|
|
break;
|
|
}
|
|
|
|
// increment PC
|
|
mvSpecialReg[SR_PC] += 2;
|
|
|
|
// decrement timers
|
|
if(mvSpecialReg[SR_T1] > 0) {
|
|
mvSpecialReg[SR_T1] -= 1;
|
|
}
|
|
if(mvSpecialReg[SR_T2] > 0) {
|
|
mvSpecialReg[SR_T2] -= 1;
|
|
if(mvSpecialReg[SR_T2] == 0) {
|
|
mrBuzzer.off();
|
|
}
|
|
}
|
|
}
|
|
|
|
void Interpreter::loadProgram(size_t where, char const* data, size_t count) {
|
|
if(where + count > scMemorySize) {
|
|
throw std::out_of_range("program exceeds memory bounds or capacity");
|
|
}
|
|
memcpy(mvMemory.data(), data, count);
|
|
}
|
|
|
|
void Interpreter::executeArithmetic(Opcode opcode, int iReg, reg_t operand) {
|
|
reg_t tmp;
|
|
switch(opcode) {
|
|
case Opcode::SET: mvReg[iReg] = operand; break;
|
|
case Opcode::AND: mvReg[iReg] &= operand; break;
|
|
case Opcode::OR: mvReg[iReg] |= operand; break;
|
|
case Opcode::XOR: mvReg[iReg] ^= operand; break;
|
|
case Opcode::RAND: mvReg[iReg] = rand() & operand; break;
|
|
case Opcode::LSH:
|
|
mvReg[R_VF] = (mvReg[iReg] & 0x80) ? 1 : 0;
|
|
mvReg[iReg] <<= 1;
|
|
break;
|
|
case Opcode::RSH:
|
|
mvReg[R_VF] = (mvReg[iReg] & 0x01) ? 1 : 0;
|
|
mvReg[iReg] >>= 1;
|
|
break;
|
|
case Opcode::ADD:
|
|
tmp = mvReg[iReg] + operand;
|
|
mvReg[R_VF] = (tmp < mvReg[iReg]) ? 1 : 0;
|
|
mvReg[iReg] = tmp;
|
|
break;
|
|
case Opcode::SUB:
|
|
tmp = mvReg[iReg] - operand;
|
|
mvReg[R_VF] = (tmp > mvReg[iReg]) ? 1 : 0;
|
|
mvReg[iReg] = tmp;
|
|
break;
|
|
case Opcode::SUB2:
|
|
tmp = operand - mvReg[iReg];
|
|
mvReg[R_VF] = (tmp > operand) ? 1 : 0;
|
|
mvReg[iReg] = tmp;
|
|
break;
|
|
case Opcode::JEQ:
|
|
if(mvReg[iReg] == operand) {
|
|
mvSpecialReg[SR_PC] += 2;
|
|
}
|
|
break;
|
|
case Opcode::JNEQ:
|
|
if(mvReg[iReg] != operand) {
|
|
mvSpecialReg[SR_PC] += 2;
|
|
}
|
|
break;
|
|
case Opcode::UNIMPL:
|
|
throw std::invalid_argument("invalid opcode");
|
|
break;
|
|
}
|
|
}
|
|
|
|
}; // namespace chochochip8
|