mirror of
https://github.com/MoleskiCoder/EightBit.git
synced 2024-06-29 23:29:31 +00:00
341 lines
7.2 KiB
C++
341 lines
7.2 KiB
C++
#pragma once
|
|
|
|
#include <cstdint>
|
|
#include <string>
|
|
#include <array>
|
|
#include <functional>
|
|
#include <cassert>
|
|
|
|
#include <Bus.h>
|
|
#include <Processor.h>
|
|
#include <Signal.h>
|
|
|
|
namespace EightBit {
|
|
class MOS6502 : public Processor {
|
|
public:
|
|
enum StatusBits {
|
|
NF = Bit7, // Negative
|
|
VF = Bit6, // Overflow
|
|
RF = Bit5, // reserved
|
|
BF = Bit4, // Brk
|
|
DF = Bit3, // D (use BCD for arithmetic)
|
|
IF = Bit2, // I (IRQ disable)
|
|
ZF = Bit1, // Zero
|
|
CF = Bit0, // Carry
|
|
};
|
|
|
|
MOS6502(Bus& bus);
|
|
|
|
Signal<MOS6502> ExecutingInstruction;
|
|
Signal<MOS6502> ExecutedInstruction;
|
|
|
|
virtual int execute(uint8_t opcode) final;
|
|
virtual int step() final;
|
|
virtual void powerOn() override;
|
|
|
|
uint8_t X() const { return x; }
|
|
uint8_t& X() { return x; }
|
|
uint8_t Y() const { return y; }
|
|
uint8_t& Y() { return y; }
|
|
uint8_t A() const { return a; }
|
|
uint8_t& A() { return a; }
|
|
uint8_t S() const { return s; }
|
|
uint8_t& S() { return s; }
|
|
uint8_t P() const { return p; }
|
|
uint8_t& P() { return p; }
|
|
|
|
PinLevel SO() const { return m_soLine; } // In
|
|
PinLevel& SO() { return m_soLine; } // In
|
|
|
|
protected:
|
|
virtual void reset() final;
|
|
|
|
virtual uint8_t SUB(uint8_t operand, uint8_t data, int borrow = 0);
|
|
uint8_t SBC(uint8_t operand, uint8_t data);
|
|
uint8_t SUB_b(uint8_t operand, uint8_t data, int borrow);
|
|
uint8_t SUB_d(uint8_t operand, uint8_t data, int borrow);
|
|
|
|
virtual uint8_t ADD(uint8_t operand, uint8_t data, int carry = 0);
|
|
uint8_t ADC(uint8_t operand, uint8_t data);
|
|
uint8_t ADD_b(uint8_t operand, uint8_t data, int carry);
|
|
uint8_t ADD_d(uint8_t operand, uint8_t data, int carry);
|
|
|
|
private:
|
|
void interrupt(uint8_t vector);
|
|
|
|
void adjustZero(uint8_t datum) { clearFlag(P(), ZF, datum); }
|
|
void adjustNegative(uint8_t datum) { setFlag(P(), NF, datum & NF); }
|
|
|
|
void adjustNZ(uint8_t datum) {
|
|
adjustZero(datum);
|
|
adjustNegative(datum);
|
|
}
|
|
|
|
register16_t getWordPaged(uint8_t page, uint8_t offset);
|
|
uint8_t getBytePaged(uint8_t page, uint8_t offset);
|
|
void setBytePaged(uint8_t page, uint8_t offset, uint8_t value);
|
|
|
|
virtual void push(uint8_t value) final;
|
|
virtual uint8_t pop() final;
|
|
|
|
// Address resolution
|
|
|
|
register16_t Address_Absolute() {
|
|
return fetchWord();
|
|
}
|
|
|
|
uint8_t Address_ZeroPage() {
|
|
return fetchByte();
|
|
}
|
|
|
|
register16_t Address_ZeroPageIndirect() {
|
|
return getWordPaged(0, Address_ZeroPage());
|
|
}
|
|
|
|
register16_t Address_Indirect() {
|
|
const auto address = Address_Absolute();
|
|
return getWordPaged(address.high, address.low);
|
|
}
|
|
|
|
uint8_t Address_ZeroPageX() {
|
|
return Address_ZeroPage() + X();
|
|
}
|
|
|
|
uint8_t Address_ZeroPageY() {
|
|
return Address_ZeroPage() + Y();
|
|
}
|
|
|
|
std::tuple<register16_t, bool> Address_AbsoluteX() {
|
|
auto address = Address_Absolute();
|
|
const auto page = address.high;
|
|
address.word += X();
|
|
return std::tuple<register16_t, bool>(address, address.high != page);
|
|
}
|
|
|
|
std::tuple<register16_t, bool> Address_AbsoluteY() {
|
|
auto address = Address_Absolute();
|
|
const auto page = address.high;
|
|
address.word += Y();
|
|
return std::tuple<register16_t, bool>(address, address.high != page);
|
|
}
|
|
|
|
register16_t Address_IndexedIndirectX() {
|
|
return getWordPaged(0, Address_ZeroPageX());
|
|
}
|
|
|
|
std::tuple<register16_t, bool> Address_IndirectIndexedY() {
|
|
auto address = Address_ZeroPageIndirect();
|
|
const auto page = address.high;
|
|
address.word += Y();
|
|
return std::tuple<register16_t, bool>(address, address.high != page);
|
|
}
|
|
|
|
// Addressing modes, read
|
|
|
|
uint8_t AM_Immediate() {
|
|
return fetchByte();
|
|
}
|
|
|
|
uint8_t AM_Absolute() {
|
|
return BUS().read(Address_Absolute());
|
|
}
|
|
|
|
uint8_t AM_ZeroPage() {
|
|
return BUS().read(Address_ZeroPage());
|
|
}
|
|
|
|
uint8_t AM_AbsoluteX() {
|
|
const auto ap = Address_AbsoluteX();
|
|
if (UNLIKELY(std::get<1>(ap)))
|
|
addCycle();
|
|
return BUS().read(std::get<0>(ap));
|
|
}
|
|
|
|
uint8_t AM_AbsoluteY() {
|
|
const auto ap = Address_AbsoluteY();
|
|
if (UNLIKELY(std::get<1>(ap)))
|
|
addCycle();
|
|
return BUS().read(std::get<0>(ap));
|
|
}
|
|
|
|
uint8_t AM_ZeroPageX() {
|
|
return BUS().read(Address_ZeroPageX());
|
|
}
|
|
|
|
uint8_t AM_ZeroPageY() {
|
|
return BUS().read(Address_ZeroPageY());
|
|
}
|
|
|
|
uint8_t AM_IndexedIndirectX() {
|
|
return BUS().read(Address_IndexedIndirectX());
|
|
}
|
|
|
|
uint8_t AM_IndirectIndexedY() {
|
|
const auto ap = Address_IndirectIndexedY();
|
|
if (UNLIKELY(std::get<1>(ap)))
|
|
addCycle();
|
|
return BUS().read(std::get<0>(ap));
|
|
}
|
|
|
|
// Addressing modes, write
|
|
|
|
void AM_Absolute(uint8_t value) {
|
|
BUS().write(Address_Absolute(), value);
|
|
}
|
|
|
|
void AM_ZeroPage(uint8_t value) {
|
|
BUS().write(Address_ZeroPage(), value);
|
|
}
|
|
|
|
void AM_AbsoluteX(uint8_t value) {
|
|
BUS().write(std::get<0>(Address_AbsoluteX()), value);
|
|
}
|
|
|
|
void AM_AbsoluteY(uint8_t value) {
|
|
BUS().write(std::get<0>(Address_AbsoluteY()), value);
|
|
}
|
|
|
|
void AM_ZeroPageX(uint8_t value) {
|
|
BUS().write(Address_ZeroPageX(), value);
|
|
}
|
|
|
|
void AM_ZeroPageY(uint8_t value) {
|
|
BUS().write(Address_ZeroPageY(), value);
|
|
}
|
|
|
|
void AM_IndexedIndirectX(uint8_t value) {
|
|
BUS().write(Address_IndexedIndirectX(), value);
|
|
}
|
|
|
|
void AM_IndirectIndexedY(uint8_t value) {
|
|
BUS().write(std::get<0>(Address_IndirectIndexedY()), value);
|
|
}
|
|
|
|
// Operations
|
|
|
|
void DCP(uint8_t value) {
|
|
BUS().write(--value);
|
|
CMP(A(), value);
|
|
}
|
|
|
|
void ISB(uint8_t value) {
|
|
BUS().write(++value);
|
|
A() = SBC(A(), value);
|
|
}
|
|
|
|
void SLO(uint8_t value) {
|
|
const auto result = ASL(value);
|
|
BUS().write(result);
|
|
ORA(result);
|
|
}
|
|
|
|
void SRE(uint8_t value) {
|
|
const auto result = LSR(value);
|
|
BUS().write(result);
|
|
EORA(result);
|
|
}
|
|
|
|
void RLA(uint8_t value) {
|
|
const auto result = ROL(value);
|
|
BUS().write(result);
|
|
ANDA(result);
|
|
}
|
|
|
|
void RRA(uint8_t value) {
|
|
const auto result = ROR(value);
|
|
BUS().write(result);
|
|
A() = ADC(A(), result);
|
|
}
|
|
|
|
void LAX(uint8_t value) {
|
|
adjustNZ(X() = A() = value);
|
|
}
|
|
|
|
void AAC(uint8_t value) {
|
|
ANDA(value);
|
|
setFlag(P(), CF, A() & Bit7);
|
|
}
|
|
|
|
void ASR(uint8_t value) {
|
|
A() = LSR(A() & value);
|
|
}
|
|
|
|
void ARR(uint8_t value) {
|
|
}
|
|
|
|
void ATX(uint8_t value) {
|
|
ANDA(value);
|
|
X() = A();
|
|
}
|
|
|
|
void AXS(uint8_t value) {
|
|
}
|
|
|
|
//
|
|
|
|
uint8_t DEC(uint8_t value) {
|
|
const auto result = --value;
|
|
adjustNZ(result);
|
|
return result;
|
|
}
|
|
|
|
uint8_t INC(uint8_t value) {
|
|
const auto result = ++value;
|
|
adjustNZ(result);
|
|
return result;
|
|
}
|
|
|
|
void ORA(uint8_t value) {
|
|
adjustNZ(A() |= value);
|
|
}
|
|
|
|
void ANDA(uint8_t value) {
|
|
adjustNZ(A() &= value);
|
|
}
|
|
|
|
void EORA(uint8_t value) {
|
|
adjustNZ(A() ^= value);
|
|
}
|
|
|
|
uint8_t ROR(uint8_t value);
|
|
|
|
uint8_t LSR(uint8_t value);
|
|
|
|
void BIT(uint8_t data);
|
|
|
|
uint8_t ROL(uint8_t value);
|
|
|
|
uint8_t ASL(uint8_t value);
|
|
|
|
void CMP(uint8_t first, uint8_t second);
|
|
|
|
void Branch(int8_t displacement);
|
|
|
|
void Branch(bool flag);
|
|
|
|
void PHP();
|
|
void PLP();
|
|
|
|
void JSR_abs();
|
|
void RTI();
|
|
void RTS();
|
|
void JMP_abs();
|
|
void JMP_ind();
|
|
void BRK();
|
|
|
|
// All interrupt vectors are on the 0xFF page
|
|
const uint8_t IRQvector = 0xfe;
|
|
const uint8_t RSTvector = 0xfc;
|
|
const uint8_t NMIvector = 0xfa;
|
|
|
|
uint8_t x = 0; // index register X
|
|
uint8_t y = 0; // index register Y
|
|
uint8_t a = 0; // accumulator
|
|
uint8_t s = 0; // stack pointer
|
|
uint8_t p = 0; // processor status
|
|
|
|
PinLevel m_soLine = Low;
|
|
|
|
register16_t m_intermediate;
|
|
};
|
|
} |