JailDoctor/nes
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
111fe32bb91ed6271f40b1f886df991fdea3219b
nes/6502.cpp

926 lines
32 KiB
C++
Raw Blame History

#include "6502.h"
#include "mem.h"
#include "debug.h"
namespace cpu6502
{
static uint32_t clock = 0;
static uint32_t t = 0;
// P register Flags
#define fC 0b00000001 // Carry
#define fZ 0b00000010 // Zero
#define fI 0b00000100 // Interrupt disable
#define fD 0b00001000 // Decimal
#define fB 0b00010000 // Interrupt type?
#define f1 0b00100000 // -Unused-
#define fV 0b01000000 // Overflow
#define fN 0b10000000 // Negative
// Jump types
#define cUnconditional 255
#define cNZ 0
#define cZ 1
#define cNC 2
#define cC 3
#define cNN 4
#define cN 5
#define cNV 6
#define cV 7
// Addressing modes
#define aAccumulator 0
#define aImmediate 1
#define aZeroPage 2
#define aZeroPageX 3
#define aZeroPageY 4
#define aRelative 5 // Is really needed?
#define aIndirect 6
#define aIndirectX 7
#define aIndirectY 8
#define aAbsolute 9
#define aAbsoluteX 10
#define aAbsoluteY 11
#define FLAG_IS_RESET true
#define FLAG_IS_SET false
uint8_t i_reg_value = 0;
uint8_t regs[7];
uint8_t *_rA = &regs[0];
uint8_t *_rX = &regs[1];
uint8_t *_rY = &regs[2];
uint8_t *_rS = &regs[3];
uint8_t *_rP = &regs[4];
uint16_t *_rPC = (uint16_t*)&regs[5];
#define rA (*_rA)
#define rX (*_rX)
#define rY (*_rY)
#define rS (*_rS)
#define rP (*_rP)
#define rPC (*_rPC)
bool reading_m1 = false;
uint8_t READ_MEM_8(const uint16_t addr, const bool code=false)
{
if (debug::isbreak(addr, 2)) debug::stop();
//t+=1; //[TODO]
const uint8_t tag = mem::getTag(addr);
if ( !(tag&MEMTAG_IGNORE) ) {
if (!code) {
if ( tag & MEMTAG_INST ) {
} else {
mem::setTag(addr, tag | MEMTAG_DATA);
}
} else {
if ( (reading_m1) && ( tag & MEMTAG_DATA ) ) {
}
}
}
reading_m1 = false;
return mem::readMem(addr);
}
uint8_t READ_MEM_8()
{
const uint8_t data = READ_MEM_8(rPC, true);
const uint8_t tag = mem::getTag(rPC);
if ( !(tag & MEMTAG_IGNORE) ) mem::setTag(rPC, tag | MEMTAG_CODE);
rPC++;
return data;
}
uint8_t READ_M1()
{
reading_m1 = true;
return READ_MEM_8();
}
uint16_t READ_MEM_16()
{
const uint8_t L = READ_MEM_8();
const uint8_t H = READ_MEM_8();
return (H << 8) + L;
}
uint16_t READ_MEM_16(const uint16_t addr)
{
return READ_MEM_8(addr) + (READ_MEM_8(addr+1) << 8);
}
const uint8_t WRITE_MEM_8(const uint16_t addr, const uint8_t value)
{
//t+=1; // [TODO]
mem::writeMem(addr, value);
if (debug::isbreak(addr, 4)) debug::stop();
debug::setmemmodified(addr);
const uint8_t tag = mem::getTag(addr);
if ( !(tag & MEMTAG_IGNORE) ) {
if ( tag & MEMTAG_INST ) {
//printf("WARNING! WRITING DATA OVER CODE!!! $%4X\n", addr);
//z80debug::stop();
} else {
mem::setTag(addr, tag | MEMTAG_DATA | MEMTAG_TDATA);
}
}
return value;
}
void WRITE_MEM_16(const uint16_t addr, const uint16_t value)
{
WRITE_MEM_8(addr, value & 0xff);
WRITE_MEM_8(addr+1, (value>>8) & 0xff);
}
void reset()
{
mem::reset();
rPC = 0x00;
rA = rX = rY = rS = rP = 0xff;
t = 0;
}
void interrupt(uint8_t type)
{
}
void notImplemented()
{
}
uint16_t addr_mode_address = 0;
bool page_crossed = false;
uint8_t loadValue(uint8_t addr_mode)
{
page_crossed = false;
switch (addr_mode)
{
case aAccumulator:
t+=2;
return rA;
case aImmediate:
t+=2;
return READ_MEM_8();
case aZeroPage:
t+=3;
addr_mode_address = READ_MEM_8();
return READ_MEM_8(addr_mode_address);
case aZeroPageX:
t+=4;
addr_mode_address = (READ_MEM_8()+rX)&0xff;
return READ_MEM_8(addr_mode_address);
case aZeroPageY:
t+=4;
addr_mode_address = (READ_MEM_8()+rY)&0xff;
return READ_MEM_8(addr_mode_address);
case aIndirectX:
t+=6;
addr_mode_address = READ_MEM_16((READ_MEM_8()+rX)&0xff);
return READ_MEM_8(addr_mode_address);
case aIndirectY:
t+=5;
addr_mode_address = READ_MEM_16(READ_MEM_8());
if ( (addr_mode_address&0xff) + rY > 0xff ) { t++; page_crossed=true; }
addr_mode_address = (addr_mode_address+rY)&0xffff;
return READ_MEM_8(addr_mode_address);
case aAbsolute:
t+=4;
addr_mode_address = READ_MEM_16();
return READ_MEM_8(addr_mode_address);
case aAbsoluteX:
t+=4;
addr_mode_address = READ_MEM_16();
if ( (addr_mode_address&0xff) + rX > 0xff ) { t++; page_crossed=true; }
addr_mode_address = (addr_mode_address+rX) & 0xffff;
return READ_MEM_8(addr_mode_address);
case aAbsoluteY:
t+=4;
addr_mode_address = READ_MEM_16();
if ( (addr_mode_address&0xff) + rY > 0xff ) { t++; page_crossed=true; }
addr_mode_address = (addr_mode_address+rY) & 0xffff;
return READ_MEM_8(addr_mode_address);
}
}
void storeValue(uint8_t value, uint8_t addr_mode)
{
switch (addr_mode)
{
case aAccumulator:
rA = value;
break;
case aZeroPage:
case aZeroPageX:
case aZeroPageY:
t+=2;
WRITE_MEM_8(addr_mode_address, value);
break;
case aIndirectX:
WRITE_MEM_8(addr_mode_address, value);
break;
case aAbsolute:
t+=2;
WRITE_MEM_8(addr_mode_address, value);
break;
case aAbsoluteX:
t+=page_crossed?2:3;
WRITE_MEM_8(addr_mode_address, value);
break;
}
}
void PHP()
{
t+= 3;
WRITE_MEM_8(0x0100+rS, rP|f1|fB); rS--;
}
void PHA()
{
t+= 3;
WRITE_MEM_8(0x0100+rS, rA); rS--;
}
void PLP()
{
t+=4;
rS++;
rP = READ_MEM_8(0x0100+rS) & ~(f1|fB);
}
void PLA()
{
t+=4;
rS++;
rA = READ_MEM_8(0x0100+rS);
rP = ( rP & ~fN ) | ( rA & fN );
rP = ( rA ? rP & ~fZ : rP | fZ );
}
void BRK()
{
READ_MEM_8();
WRITE_MEM_16(0x0100+rS, rPC); rS-=2;
PHP(); // t+=3
rP |= fI;
rPC = READ_MEM_16(0xfffe);
t+=4;
}
void RTI()
{
PLP(); i_reg_value = rP&fI; // effect of changing fI is not delayed
rS+=2;
rPC = READ_MEM_16(0x0100+rS);
t+=2;
}
void ADC(uint8_t addr_mode)
{
uint8_t value = loadValue(addr_mode);
uint16_t result = rA + value + fC;
rA = result & 0xff;
rP = ( rP & ~fC ) | ( (result>>8) & fC );
rP = ( rP & ~fN ) | ( rA & fN );
rP = ( rA ? rP & ~fZ : rP | fZ );
rP = ( (result ^ rA) & (result ^ value) & 0x80 ) ? rP | fV : rP & ~fV;
}
void SBC(uint8_t addr_mode)
{
uint8_t value = loadValue(addr_mode);
uint16_t result = rA + ~value + fC;
rA = result & 0xff;
rP = ( rP & ~fC ) | ( (result>>8) & fC );
rP = ( rP & ~fN ) | ( rA & fN );
rP = ( rA ? rP & ~fZ : rP | fZ );
rP = ( (result ^ rA) & (result ^ value) & 0x80 ) ? rP | fV : rP & ~fV;
}
void CMP(uint8_t addr_mode)
{
uint8_t value = loadValue(addr_mode);
uint8_t result = rA + ~value;
rP = ( rP & ~fC ) | ( (result>>8) & fC );
rP = ( rP & ~fN ) | ( result & fN );
rP = ( result ? rP & ~fZ : rP | fZ );
}
void CPX(uint8_t addr_mode)
{
uint8_t value = loadValue(addr_mode);
uint8_t result = rX + ~value;
rP = ( rP & ~fC ) | ( (result>>8) & fC );
rP = ( rP & ~fN ) | ( result & fN );
rP = ( result ? rP & ~fZ : rP | fZ );
}
void CPY(uint8_t addr_mode)
{
uint8_t value = loadValue(addr_mode);
uint8_t result = rY + ~value;
rP = ( rP & ~fC ) | ( (result>>8) & fC );
rP = ( rP & ~fN ) | ( result & fN );
rP = ( result ? rP & ~fZ : rP | fZ );
}
void INC(uint8_t addr_mode)
{
uint8_t value = loadValue(addr_mode);
value++;
rP = ( rP & ~fN ) | ( value & fN );
rP = ( value ? rP & ~fZ : rP | fZ );
storeValue(value, addr_mode);
}
void DEC(uint8_t addr_mode)
{
uint8_t value = loadValue(addr_mode);
value--;
rP = ( rP & ~fN ) | ( value & fN );
rP = ( value ? rP & ~fZ : rP | fZ );
storeValue(value, addr_mode);
}
void INY()
{
rY++;
rP = ( rP & ~fN ) | ( rY & fN );
rP = ( rY ? rP & ~fZ : rP | fZ );
}
void DEY()
{
rY--;
rP = ( rP & ~fN ) | ( rY & fN );
rP = ( rY ? rP & ~fZ : rP | fZ );
}
void INX()
{
rX++;
rP = ( rP & ~fN ) | ( rX & fN );
rP = ( rX ? rP & ~fZ : rP | fZ );
}
void DEX()
{
rX--;
rP = ( rP & ~fN ) | ( rX & fN );
rP = ( rX ? rP & ~fZ : rP | fZ );
}
void ORA(uint8_t addr_mode)
{
uint8_t value = loadValue(addr_mode);
rA |= value;
rP = ( rP & ~fN ) | ( rA & fN );
rP = ( rA ? rP & ~fZ : rP | fZ );
}
void AND(uint8_t addr_mode)
{
uint8_t value = loadValue(addr_mode);
rA &= value;
rP = ( rP & ~fN ) | ( rA & fN );
rP = ( rA ? rP & ~fZ : rP | fZ );
}
void EOR(uint8_t addr_mode)
{
uint8_t value = loadValue(addr_mode);
rA = rA ^ value;
rP = ( rP & ~fN ) | ( rA & fN );
rP = ( rA ? rP & ~fZ : rP | fZ );
}
void BIT(uint8_t addr_mode)
{
uint8_t value = loadValue(addr_mode);
uint8_t result = rA & value;
rP = ( rP & ~(fN|fV) ) | ( rA & (fN|fV) );
rP = ( rA ? rP & ~fZ : rP | fZ );
}
void ASL(uint8_t addr_mode)
{
uint8_t value = loadValue(addr_mode);
rP = ( rP & ~fC ) | ( (value & 0x80)>>7 );
value = value << 1;
rP = ( rP & ~fN ) | ( value & fN );
rP = ( value ? rP & ~fZ : rP | fZ );
storeValue(value, addr_mode);
}
void LSR(uint8_t addr_mode)
{
uint8_t value = loadValue(addr_mode);
rP = ( rP & ~fC ) | ( (value & fC) );
value = value >> 1;
rP = ( rP & ~fN ) | ( value & fN );
rP = ( value ? rP & ~fZ : rP | fZ );
storeValue(value, addr_mode);
}
void ROL(uint8_t addr_mode)
{
uint8_t value = loadValue(addr_mode);
uint8_t old_fC = rP & fC;
rP = ( rP & ~fC ) | ( (value & 0x80)>>7 );
value = (value << 1) | old_fC;
rP = ( rP & ~fN ) | ( value & fN );
rP = ( value ? rP & ~fZ : rP | fZ );
storeValue(value, addr_mode);
}
void ROR(uint8_t addr_mode)
{
uint8_t value = loadValue(addr_mode);
uint8_t old_fC = (rP & fC) << 7;
rP = ( rP & ~fC ) | ( (value & fC) );
value = (value >> 1) | old_fC;
rP = ( rP & ~fN ) | ( value & fN );
rP = ( value ? rP & ~fZ : rP | fZ );
storeValue(value, addr_mode);
}
void JMP(uint8_t addr_mode)
{
t+=3;
addr_mode_address = READ_MEM_16();
if (addr_mode == aIndirect) {
t+=5;
const uint8_t L = READ_MEM_8(addr_mode_address);
const uint8_t H = READ_MEM_8( (addr_mode_address&0xff00) | ((addr_mode_address+1)&0x00ff) );
addr_mode_address = (H << 8) + L;
}
rPC = addr_mode_address;
}
void BRANCH(uint8_t flag, bool negate)
{
t+=3;
int8_t offset = (int8_t)READ_MEM_8();
bool condition = (rP & flag);
if (negate) condition = !condition;
if (condition) {
t++;
if ( (rPC&0xff) + offset > 0xff ) t++;
rPC = (rPC + offset) & 0xffff;
}
}
void BPL() { BRANCH(fN, FLAG_IS_RESET); }
void BMI() { BRANCH(fN, FLAG_IS_SET); }
void BNE() { BRANCH(fZ, FLAG_IS_RESET); }
void BEQ() { BRANCH(fZ, FLAG_IS_SET); }
void BCC() { BRANCH(fC, FLAG_IS_RESET); }
void BCS() { BRANCH(fC, FLAG_IS_SET); }
void BVC() { BRANCH(fV, FLAG_IS_RESET); }
void BVS() { BRANCH(fV, FLAG_IS_SET); }
void JSR(uint8_t addr_mode)
{
uint8_t value = loadValue(addr_mode);
t+=2;
WRITE_MEM_16(0x0100+rS, rPC-1); rS-=2;
rPC = value;
}
void RTS()
{
rS+=2;
rPC = READ_MEM_16(0x0100+rS);
rPC++;
t+=6;
}
void SET_FLAG(uint8_t flag) { t+=2; rP = rP | flag; }
void SEC() { SET_FLAG(fC); }
void SED() { SET_FLAG(fD); }
void SEI() { SET_FLAG(fI); }
void CLEAR_FLAG(uint8_t flag) { t+=2; rP = rP & ~flag; }
void CLC() { CLEAR_FLAG(fC); }
void CLD() { CLEAR_FLAG(fD); }
void CLI() { CLEAR_FLAG(fI); }
void CLV() { CLEAR_FLAG(fV); }
void STA(uint8_t addr_mode)
{
loadValue(addr_mode);
if (!page_crossed) t++;
storeValue(rA, addr_mode);
}
void STX(uint8_t addr_mode)
{
loadValue(addr_mode);
storeValue(rX, addr_mode);
}
void STY(uint8_t addr_mode)
{
loadValue(addr_mode);
storeValue(rY, addr_mode);
}
void LDA(uint8_t addr_mode)
{
uint8_t value = loadValue(addr_mode);
if (!page_crossed) t++;
rA = value;
rP = ( rP & ~fN ) | ( rA & fN );
rP = ( rA ? rP & ~fZ : rP | fZ );
}
void LDX(uint8_t addr_mode)
{
uint8_t value = loadValue(addr_mode);
if (!page_crossed) t++;
rX = value;
rP = ( rP & ~fN ) | ( rX & fN );
rP = ( rX ? rP & ~fZ : rP | fZ );
}
void LDY(uint8_t addr_mode)
{
uint8_t value = loadValue(addr_mode);
if (!page_crossed) t++;
rY = value;
rP = ( rP & ~fN ) | ( rY & fN );
rP = ( rY ? rP & ~fZ : rP | fZ );
}
void TAX()
{
t += 2;
rX = rA;
rP = ( rP & ~fN ) | ( rA & fN );
rP = ( rA ? rP & ~fZ : rP | fZ );
}
void TAY()
{
t += 2;
rY = rA;
rP = ( rP & ~fN ) | ( rA & fN );
rP = ( rA ? rP & ~fZ : rP | fZ );
}
void TSX()
{
t += 2;
rX = rS;
rP = ( rP & ~fN ) | ( rA & fN );
rP = ( rX ? rP & ~fZ : rP | fZ );
}
void TXA()
{
t += 2;
rA = rX;
rP = ( rP & ~fN ) | ( rA & fN );
rP = ( rA ? rP & ~fZ : rP | fZ );
}
void TXS()
{
t += 2;
rS = rX;
}
void TYA()
{
t += 2;
rA = rY;
rP = ( rP & ~fN ) | ( rA & fN );
rP = ( rA ? rP & ~fZ : rP | fZ );
}
void NOP()
{
t+=2;
}
uint32_t step()
{
t = 0;
i_reg_value = rP & fI;
uint16_t current_opcode_address = rPC;
const uint8_t opcode = READ_M1();
uint8_t tag = mem::getTag(current_opcode_address);
if ( !(tag & MEMTAG_IGNORE) ) tag = tag | MEMTAG_INST;
mem::setTag(current_opcode_address, tag | (!(tag&MEMTAG_TOUCHED) ? MEMTAG_TREPEAT : MEMTAG_TINST) );
uint16_t tmp;
switch (opcode)
{
case 0x00: BRK(); break;
case 0x01: ORA(aIndirectX); break;
case 0x02: notImplemented(); break;
case 0x03: notImplemented(); break;
case 0x04: notImplemented(); break;
case 0x05: ORA(aZeroPage); break;
case 0x06: ASL(aZeroPage); break;
case 0x07: notImplemented(); break;
case 0x08: PHP(); break;
case 0x09: ORA(aImmediate); break;
case 0x0a: ASL(aAccumulator); break;
case 0x0b: notImplemented(); break;
case 0x0c: notImplemented(); break;
case 0x0d: ORA(aAbsolute); break;
case 0x0e: ASL(aAbsolute); break;
case 0x0f: notImplemented(); break;
case 0x10: BPL(); break;
case 0x11: ORA(aIndirectY); break;
case 0x12: notImplemented(); break;
case 0x13: notImplemented(); break;
case 0x14: notImplemented(); break;
case 0x15: ORA(aZeroPageX); break;
case 0x16: ASL(aZeroPageX); break;
case 0x17: notImplemented(); break;
case 0x18: CLC(); break;
case 0x19: ORA(aAbsoluteY); break;
case 0x1a: notImplemented(); break;
case 0x1b: notImplemented(); break;
case 0x1c: notImplemented(); break;
case 0x1d: ORA(aAbsoluteX); break;
case 0x1e: ASL(aAbsoluteX); break;
case 0x1f: notImplemented(); break;
case 0x20: JSR(aAbsolute); break;
case 0x21: AND(aIndirectX); break;
case 0x22: notImplemented(); break;
case 0x23: notImplemented(); break;
case 0x24: BIT(aZeroPage); break;
case 0x25: AND(aZeroPage); break;
case 0x26: ROL(aZeroPage); break;
case 0x27: notImplemented(); break;
case 0x28: PLP(); break;
case 0x29: AND(aImmediate); break;
case 0x2a: ROL(aAccumulator); break;
case 0x2b: notImplemented(); break;
case 0x2c: BIT(aAbsolute); break;
case 0x2d: AND(aAbsolute); break;
case 0x2e: ROL(aAbsolute); break;
case 0x2f: notImplemented(); break;
case 0x30: BMI(); break;
case 0x31: AND(aIndirectY); break;
case 0x32: notImplemented(); break;
case 0x33: notImplemented(); break;
case 0x34: notImplemented(); break;
case 0x35: AND(aZeroPageX); break;
case 0x36: ROL(aZeroPageX); break;
case 0x37: notImplemented(); break;
case 0x38: SEC(); break;
case 0x39: AND(aAbsoluteY); break;
case 0x3a: notImplemented(); break;
case 0x3b: notImplemented(); break;
case 0x3c: notImplemented(); break;
case 0x3d: AND(aAbsoluteX); break;
case 0x3e: ROL(aAbsoluteX); break;
case 0x3f: notImplemented(); break;
case 0x40: RTI(); break;
case 0x41: EOR(aIndirectX); break;
case 0x42: notImplemented(); break;
case 0x43: notImplemented(); break;
case 0x44: notImplemented(); break;
case 0x45: EOR(aZeroPage); break;
case 0x46: LSR(aZeroPage); break;
case 0x47: notImplemented(); break;
case 0x48: PHA(); break;
case 0x49: EOR(aImmediate); break;
case 0x4a: LSR(aAccumulator); break;
case 0x4b: notImplemented(); break;
case 0x4c: JMP(aAbsolute); break;
case 0x4d: EOR(aAbsolute); break;
case 0x4e: LSR(aAbsolute); break;
case 0x4f: notImplemented(); break;
case 0x50: BVC(); break;
case 0x51: EOR(aIndirectY); break;
case 0x52: notImplemented(); break;
case 0x53: notImplemented(); break;
case 0x54: notImplemented(); break;
case 0x55: EOR(aZeroPageX); break;
case 0x56: LSR(aZeroPageX); break;
case 0x57: notImplemented(); break;
case 0x58: CLI(); break;
case 0x59: EOR(aAbsoluteY); break;
case 0x5a: notImplemented(); break;
case 0x5b: notImplemented(); break;
case 0x5c: notImplemented(); break;
case 0x5d: EOR(aAbsoluteX); break;
case 0x5e: LSR(aAbsoluteX); break;
case 0x5f: notImplemented(); break;
case 0x60: RTS(); break;
case 0x61: ADC(aIndirectX); break;
case 0x62: notImplemented(); break;
case 0x63: notImplemented(); break;
case 0x64: notImplemented(); break;
case 0x65: ADC(aZeroPage); break;
case 0x66: ROR(aZeroPage); break;
case 0x67: notImplemented(); break;
case 0x68: PLA(); break;
case 0x69: ADC(aImmediate); break;
case 0x6a: ROR(aAccumulator); break;
case 0x6b: notImplemented(); break;
case 0x6c: JMP(aIndirect); break;
case 0x6d: ADC(aAbsolute); break;
case 0x6e: ROR(aAbsolute); break;
case 0x6f: notImplemented(); break;
case 0x70: BVS(); break;
case 0x71: ADC(aIndirectY); break;
case 0x72: notImplemented(); break;
case 0x73: notImplemented(); break;
case 0x74: notImplemented(); break;
case 0x75: ADC(aZeroPageX); break;
case 0x76: ROR(aZeroPageX); break;
case 0x77: notImplemented(); break;
case 0x78: SEI(); break;
case 0x79: ADC(aAbsoluteY); break;
case 0x7a: notImplemented(); break;
case 0x7b: notImplemented(); break;
case 0x7c: notImplemented(); break;
case 0x7d: ADC(aAbsoluteX); break;
case 0x7e: ROR(aAbsoluteX); break;
case 0x7f: notImplemented(); break;
case 0x80: notImplemented(); break;
case 0x81: STA(aIndirectX); break;
case 0x82: notImplemented(); break;
case 0x83: notImplemented(); break;
case 0x84: STY(aZeroPage); break;
case 0x85: STA(aZeroPage); break;
case 0x86: STX(aZeroPage); break;
case 0x87: notImplemented(); break;
case 0x88: DEY(); break;
case 0x89: notImplemented(); break;
case 0x8a: TXA(); break;
case 0x8b: notImplemented(); break;
case 0x8c: STY(aAbsolute); break;
case 0x8d: STA(aAbsolute); break;
case 0x8e: STX(aAbsolute); break;
case 0x8f: notImplemented(); break;
case 0x90: BCC(); break;
case 0x91: STA(aIndirectY); break;
case 0x92: notImplemented(); break;
case 0x93: notImplemented(); break;
case 0x94: STY(aZeroPageX); break;
case 0x95: STA(aZeroPageX); break;
case 0x96: STX(aZeroPageY); break;
case 0x97: notImplemented(); break;
case 0x98: TYA(); break;
case 0x99: STA(aAbsoluteY); break;
case 0x9a: TXS(); break;
case 0x9b: notImplemented(); break;
case 0x9c: notImplemented(); break;
case 0x9d: STA(aAbsolute); break;
case 0x9e: notImplemented(); break;
case 0x9f: notImplemented(); break;
case 0xa0: LDY(aImmediate); break;
case 0xa1: LDA(aIndirectX); break;
case 0xa2: LDX(aImmediate); break;
case 0xa3: notImplemented(); break;
case 0xa4: LDY(aZeroPage); break;
case 0xa5: LDA(aZeroPage); break;
case 0xa6: LDX(aZeroPage); break;
case 0xa7: notImplemented(); break;
case 0xa8: TAY(); break;
case 0xa9: LDA(aImmediate); break;
case 0xaa: TAX(); break;
case 0xab: notImplemented(); break;
case 0xac: LDY(aAbsolute); break;
case 0xad: LDA(aAbsolute); break;
case 0xae: LDX(aAbsolute); break;
case 0xaf: notImplemented(); break;
case 0xb0: BCS(); break;
case 0xb1: LDA(aIndirectY); break;
case 0xb2: notImplemented(); break;
case 0xb3: notImplemented(); break;
case 0xb4: LDY(aZeroPageX); break;
case 0xb5: LDA(aZeroPageX); break;
case 0xb6: LDX(aZeroPageY); break;
case 0xb7: notImplemented(); break;
case 0xb8: CLV(); break;
case 0xb9: LDA(aAbsoluteY); break;
case 0xba: TSX(); break;
case 0xbb: notImplemented(); break;
case 0xbc: LDY(aAbsoluteX); break;
case 0xbd: LDA(aAbsoluteX); break;
case 0xbe: LDX(aAbsoluteY); break;
case 0xbf: notImplemented(); break;
case 0xc0: CPY(aImmediate); break;
case 0xc1: CMP(aIndirectX); break;
case 0xc2: notImplemented(); break;
case 0xc3: notImplemented(); break;
case 0xc4: CPY(aZeroPage); break;
case 0xc5: CMP(aZeroPage); break;
case 0xc6: DEC(aZeroPage); break;
case 0xc7: notImplemented(); break;
case 0xc8: INY(); break;
case 0xc9: CMP(aImmediate); break;
case 0xca: DEX(); break;
case 0xcb: notImplemented(); break;
case 0xcc: CPY(aAbsolute); break;
case 0xcd: CMP(aAbsolute); break;
case 0xce: DEC(aAbsolute); break;
case 0xcf: notImplemented(); break;
case 0xd0: BNE(); break;
case 0xd1: CMP(aIndirectY); break;
case 0xd2: notImplemented(); break;
case 0xd3: notImplemented(); break;
case 0xd4: notImplemented(); break;
case 0xd5: CMP(aZeroPageX); break;
case 0xd6: DEC(aZeroPageX); break;
case 0xd7: notImplemented(); break;
case 0xd8: CLD(); break;
case 0xd9: CMP(aAbsoluteY); break;
case 0xda: notImplemented(); break;
case 0xdb: notImplemented(); break;
case 0xdc: notImplemented(); break;
case 0xdd: CMP(aAbsoluteX); break;
case 0xde: DEC(aAbsoluteX); break;
case 0xdf: notImplemented(); break;
case 0xe0: CPX(aImmediate); break;
case 0xe1: SBC(aIndirectX); break;
case 0xe2: notImplemented(); break;
case 0xe3: notImplemented(); break;
case 0xe4: CPX(aZeroPage); break;
case 0xe5: SBC(aZeroPage); break;
case 0xe6: INC(aZeroPage); break;
case 0xe7: notImplemented(); break;
case 0xe8: INX(); break;
case 0xe9: SBC(aImmediate); break;
case 0xea: NOP(); break;
case 0xeb: notImplemented(); break;
case 0xec: CPX(aAbsolute); break;
case 0xed: SBC(aAbsolute); break;
case 0xee: INC(aAbsolute); break;
case 0xef: notImplemented(); break;
case 0xf0: BEQ(); break;
case 0xf1: SBC(aIndirectY); break;
case 0xf2: notImplemented(); break;
case 0xf3: notImplemented(); break;
case 0xf4: notImplemented(); break;
case 0xf5: SBC(aZeroPageX); break;
case 0xf6: INC(aZeroPageX); break;
case 0xf7: notImplemented(); break;
case 0xf8: SED(); break;
case 0xf9: SBC(aAbsoluteY); break;
case 0xfa: notImplemented(); break;
case 0xfb: notImplemented(); break;
case 0xfc: notImplemented(); break;
case 0xfd: SBC(aAbsoluteX); break;
case 0xfe: INC(aAbsoluteX); break;
case 0xff: notImplemented(); break;
};
// [TODO] Gestionar interrupcions
//if (!i_reg_value) gestionar interrupcions
//debug::setcursor(rPC);
//debug::history::store();
mem::update_mapped(t);
return t;
}
}
Reference in New Issue View Git Blame Copy Permalink