From 1c30dea63b65c7e117b3fd8ba0140dbf77a0ef73 Mon Sep 17 00:00:00 2001 From: alekseiplusplus Date: Fri, 28 Apr 2023 16:04:35 +1000 Subject: changed dirs --- headers/instructions/definitions.h | 354 ++++++++++++++++++++++++++++ headers/instructions/illegal/definitions.h | 0 headers/instructions/illegal/init.h | 0 headers/instructions/illegal/table-append.h | 0 headers/instructions/init.h | 74 ++++++ headers/instructions/table.h | 270 +++++++++++++++++++++ 6 files changed, 698 insertions(+) create mode 100644 headers/instructions/definitions.h create mode 100644 headers/instructions/illegal/definitions.h create mode 100644 headers/instructions/illegal/init.h create mode 100644 headers/instructions/illegal/table-append.h create mode 100644 headers/instructions/init.h create mode 100644 headers/instructions/table.h (limited to 'headers/instructions') diff --git a/headers/instructions/definitions.h b/headers/instructions/definitions.h new file mode 100644 index 0000000..bdeb54e --- /dev/null +++ b/headers/instructions/definitions.h @@ -0,0 +1,354 @@ +// instructions.h +// Definition of all instruction functions, handling effect of instruction and flags. + +AddData idata; + + +/* TO DO + +!!!!!!!! CHECK THAT idata.value IS USED ACROSS ALL FUNCTIONS, NOT VAL !!!!!!!!!!!!!! + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Fix all functions before performing testing + +*/ + +// Load and Store Instructions + +void fLDA(Addressing addr, address val){ idata = fAddress(addr, val); + acc = idata.value; +} + +void fLDX(Addressing addr, address val){ idata = fAddress(addr, val); + X = idata.value; +} + +void fLDY(Addressing addr, address val){ idata = fAddress(addr, val); + Y = idata.value; +} + +void fSTA(Addressing addr, address val){ idata = fAddress(addr, val); + Memory[idata.add] = acc; +} + +void fSTX(Addressing addr, address val){ idata = fAddress(addr, val); + Memory[idata.add] = X; +} + +void fSTY(Addressing addr, address val){ idata = fAddress(addr, val); + Memory[idata.add] = Y; +} + +// Arithmetic Instructions + +void fADC(Addressing addr, address val){ idata = fAddress(addr, val); + int buffer = acc + idata.value; + setFlagV(buffer, acc); + + if (buffer > 255) + flagSet(flag_C); + else + flagClear(flag_C); + + acc += idata.value; + setFlagN(acc); + setFlagZ(acc); +} + +void fSBC(Addressing addr, address val){ idata = fAddress(addr, val); + int buffer = acc - idata.value; + setFlagV(buffer, acc); + + if (buffer < 0) + flagSet(flag_C); + else + flagClear(flag_C); + + acc -= idata.value; + setFlagN(acc); + setFlagZ(acc); +} + +//Increment and Decrement Instructions + +void fINC(Addressing addr, address val){ idata = fAddress(addr, val); + Memory[idata.add]++; + setFlagN(Memory[idata.add]); + setFlagZ(Memory[idata.add]); +} + +void fINX(Addressing addr, address val){ idata = fAddress(addr, val); + X++; + setFlagN(X); + setFlagZ(X); +} + +void fINY(Addressing addr, address val){ idata = fAddress(addr, val); + Y++; + setFlagN(Y); + setFlagZ(Y); +} + +void fDEC(Addressing addr, address val){ idata = fAddress(addr, val); + Memory[idata.add]--; + setFlagN(Memory[idata.add]); + setFlagZ(Memory[idata.add]); +} + +void fDEX(Addressing addr, address val){ idata = fAddress(addr, val); + X--; + setFlagN(X); + setFlagZ(X); +} + +void fDEY(Addressing addr, address val){ idata = fAddress(addr, val); + Y--; + setFlagN(Y); + setFlagZ(Y); +} + +// Logical Instructions + +void fAND(Addressing addr, address val){ idata = fAddress(addr, val); + acc &= idata.value; + setFlagN(acc); + setFlagZ(acc); +} + +void fORA(Addressing addr, address val){ idata = fAddress(addr, val); + acc |= idata.value; + setFlagN(acc); + setFlagZ(acc); +} + +void fEOR(Addressing addr, address val){ idata = fAddress(addr, val); + acc ^= idata.value; + setFlagN(acc); + setFlagZ(acc); +} + +// Jump, Branch, Compare, and Test Bits + +void fJMP(Addressing addr, address val){ idata = fAddress(addr, val); + PC = val; +} + +void fBCC(Addressing addr, address val){ idata = fAddress(addr, val); //FINISH ALL BRANCH INSTRUCTIONS + //signed char val down to BVC + if (getFlag(flag_C) == 0) PC += val; +} + +void fBCS(Addressing addr, address val){ idata = fAddress(addr, val); + if (getFlag(flag_C) == 1) PC += val; +} + +void fBEQ(Addressing addr, address val){ idata = fAddress(addr, val); + if (getFlag(flag_Z) == 1) PC += val; +} + +void fBNE(Addressing addr, address val){ idata = fAddress(addr, val); + if (getFlag(flag_Z) == 0) PC += val; +} + +void fBMI(Addressing addr, address val){ idata = fAddress(addr, val); + if (getFlag(flag_N) == 1) PC += val; +} + +void fBPL(Addressing addr, address val){ idata = fAddress(addr, val); + if (getFlag(flag_N) == 0) PC += val; +} + +void fBVS(Addressing addr, address val){ idata = fAddress(addr, val); + if (getFlag(flag_V) == 1) PC += val; +} + +void fBVC(Addressing addr, address val){ idata = fAddress(addr, val); + if (getFlag(flag_V) == 0) PC += val; +} + +void fCMP(Addressing addr, address val){ idata = fAddress(addr, val); + if (acc < idata.value){ + flagSet(flag_N); flagClear(flag_Z); flagClear(flag_C); + }if (acc == idata.value){ + flagClear(flag_N); flagSet(flag_Z); flagClear(flag_C); + }if (acc > idata.value){ + flagClear(flag_N); flagClear(flag_Z); flagSet(flag_C); + } +} + +void fCPX(Addressing addr, address val){ idata = fAddress(addr, val); + if (X < idata.value){ + flagSet(flag_N); flagClear(flag_Z); flagClear(flag_C); + }if (X == idata.value){ + flagClear(flag_N); flagSet(flag_Z); flagClear(flag_C); + }if (X > idata.value){ + flagClear(flag_N); flagClear(flag_Z); flagSet(flag_C); + } +} + +void fCPY(Addressing addr, address val){ idata = fAddress(addr, val); + if (Y < idata.value){ + flagSet(flag_N); flagClear(flag_Z); flagClear(flag_C); + }if (Y == idata.value){ + flagClear(flag_N); flagSet(flag_Z); flagClear(flag_C); + }if (Y > idata.value){ + flagClear(flag_N); flagClear(flag_Z); flagSet(flag_C); + } +} + +//Need to double check the function of this instruction +void fBIT(Addressing addr, address val){ idata = fAddress(addr, val); + setFlag(flag_N, (Memory[val] & flag_N)); + setFlag(flag_V, (Memory[val] & flag_V)); + if (((Memory[val] & flag_N) & (Memory[val] & flag_V)) == 0) { + flagSet(flag_Z); + } else { + flagSet(flag_Z); + } +} + +// Shift and Rotate Instructions + +void fASL(Addressing addr, address val){ idata = fAddress(addr, val); + setFlag(flag_C, (idata.value & 0x80)); + acc = (idata.value << 1); + setFlagN(acc); + setFlagZ(acc); +} + +void fLSR(Addressing addr, address val){ idata = fAddress(addr, val); + setFlag(flag_C, (idata.value & 0x01)); + acc = (idata.value >> 1); + setFlagN(acc); + setFlagZ(acc); +} + +void fROL(Addressing addr, address val){ idata = fAddress(addr, val); + setFlag(flag_C, (val & 0x80)); + acc = (val << 1); + acc |= (getFlag(flag_C) * 0x01); + setFlagN(acc); + setFlagZ(acc); +} + +void fROR(Addressing addr, address val){ idata = fAddress(addr, val); + setFlag(flag_C, (val & 0x01)); + acc = (val >> 1); + acc |= (getFlag(flag_C) * 0x80); + setFlagN(acc); + setFlagZ(acc); +} + +// Transfer Instructions + +void fTAX(Addressing addr, address val){ idata = fAddress(addr, val); + X = acc; + //setFlagN(X); + //setFlagZ(X); +} + +void fTAY(Addressing addr, address val){ idata = fAddress(addr, val); + Y = acc; + //setFlagN(Y); + //setFlagZ(Y); +} + +void fTXA(Addressing addr, address val){ idata = fAddress(addr, val); + acc = X; + setFlagN(acc); + setFlagZ(acc); +} + +void fTYA(Addressing addr, address val){ idata = fAddress(addr, val); + acc = Y; + setFlagN(acc); + setFlagZ(acc); +} + +// Stack Instructions + +void fTSX(Addressing addr, address val){ idata = fAddress(addr, val); + X = S; +} + +void fTXS(Addressing addr, address val){ idata = fAddress(addr, val); + S = X; +} + +void fPHA(Addressing addr, address val){ idata = fAddress(addr, val); + Memory[0x01FF-S] = acc; + S++; +} + +void fPHP(Addressing addr, address val){ idata = fAddress(addr, val); + Memory[0x01FF-S] = P; + S++; +} + +void fPLA(Addressing addr, address val){ idata = fAddress(addr, val); + S--; + acc = Memory[0x01FF-S]; +} + +void fPLP(Addressing addr, address val){ idata = fAddress(addr, val); + S--; + P = Memory[0x01FF-S]; +} + +// Subroutine Instructions + +void fJSR(Addressing addr, address val){ idata = fAddress(addr, val); + Memory[0x01FF-S] = (idata.add-1); + S++; + PC = idata.add; +} + +void fRTS(Addressing addr, address val){ idata = fAddress(addr, val); + +} + +void fRTI(Addressing addr, address val){ idata = fAddress(addr, val); + +} + +// Set/Reset Insutrctions + +void fCLC(Addressing addr, address val){ idata = fAddress(addr, val); + flagClear(flag_C); +} + +void fCLD(Addressing addr, address val){ idata = fAddress(addr, val); + flagClear(flag_D); +} + +void fCLI(Addressing addr, address val){ idata = fAddress(addr, val); + flagClear(flag_I); +} + +void fCLV(Addressing addr, address val){ idata = fAddress(addr, val); + flagClear(flag_V); +} + +void fSEC(Addressing addr, address val){ idata = fAddress(addr, val); + flagSet(flag_C); +} + +void fSED(Addressing addr, address val){ idata = fAddress(addr, val); + flagSet(flag_D); +} + +void fSEI(Addressing addr, address val){ idata = fAddress(addr, val); + flagSet(flag_I); +} + +// NOP/BRK Instructions + +void fNOP(Addressing addr, address val){ idata = fAddress(addr, val); +} + +void fBRK(Addressing addr, address val){ idata = fAddress(addr, val); + flagSet(flag_B); +} + +#ifdef ILLEGAL +#include"illegal/definitions.h" +#endif \ No newline at end of file diff --git a/headers/instructions/illegal/definitions.h b/headers/instructions/illegal/definitions.h new file mode 100644 index 0000000..e69de29 diff --git a/headers/instructions/illegal/init.h b/headers/instructions/illegal/init.h new file mode 100644 index 0000000..e69de29 diff --git a/headers/instructions/illegal/table-append.h b/headers/instructions/illegal/table-append.h new file mode 100644 index 0000000..e69de29 diff --git a/headers/instructions/init.h b/headers/instructions/init.h new file mode 100644 index 0000000..dd2d477 --- /dev/null +++ b/headers/instructions/init.h @@ -0,0 +1,74 @@ +// instruction-init.h +// Initializes every instruction function prior to addressing.h + +// Load and Store Instructions +void fLDA(Addressing, address); +void fLDX(Addressing, address); +void fLDY(Addressing, address); +void fSTA(Addressing, address); +void fSTX(Addressing, address); +void fSTY(Addressing, address); +// Arithmetic Instructions +void fADC(Addressing, address); +void fSBC(Addressing, address); +//Increment and Decrement Instructions +void fINC(Addressing, address); +void fINX(Addressing, address); +void fINY(Addressing, address); +void fDEC(Addressing, address); +void fDEX(Addressing, address); +void fDEY(Addressing, address); +// Logical Instructions +void fAND(Addressing, address); +void fORA(Addressing, address); +void fEOR(Addressing, address); +// Jump, Branch, Compare, and Test Bits +void fJMP(Addressing, address); +void fBCC(Addressing, address); +void fBCS(Addressing, address); +void fBEQ(Addressing, address); +void fBNE(Addressing, address); +void fBMI(Addressing, address); +void fBPL(Addressing, address); +void fBVS(Addressing, address); +void fBVC(Addressing, address); +void fCMP(Addressing, address); +void fCPX(Addressing, address); +void fCPY(Addressing, address); +void fBIT(Addressing, address); +// Shift and Rotate Instructions +void fASL(Addressing, address); +void fLSR(Addressing, address); +void fROL(Addressing, address); +void fROR(Addressing, address); +// Transfer Instructions +void fTAX(Addressing, address); +void fTAY(Addressing, address); +void fTXA(Addressing, address); +void fTYA(Addressing, address); +// Stack Instructions +void fTSX(Addressing, address); +void fTXS(Addressing, address); +void fPHA(Addressing, address); +void fPHP(Addressing, address); +void fPLA(Addressing, address); +void fPLP(Addressing, address); +// Subroutine Instructions +void fJSR(Addressing, address); +void fRTS(Addressing, address); +void fRTI(Addressing, address); +// Set/Reset Insutrctions +void fCLC(Addressing, address); +void fCLD(Addressing, address); +void fCLI(Addressing, address); +void fCLV(Addressing, address); +void fSEC(Addressing, address); +void fSED(Addressing, address); +void fSEI(Addressing, address); +// NOP/BRK Instructions +void fNOP(Addressing, address); +void fBRK(Addressing, address); + +#ifdef ILLEGAL +#include"illegal/init.h" +#endif \ No newline at end of file diff --git a/headers/instructions/table.h b/headers/instructions/table.h new file mode 100644 index 0000000..f37814b --- /dev/null +++ b/headers/instructions/table.h @@ -0,0 +1,270 @@ +// instruction-table.h +// Defines the instruction table, and the functions to access it. + +void* InstructionTable; +void (*func)(Addressing, address); + +#define InstructionTableSize (256 * (sizeof(uintptr_t) + sizeof(Addressing))) + +uintptr_t* getInstructionTableFunction(int i){ //Segmentation fault is occurring here, likely in next one too + uintptr_t* r = (InstructionTable + (sizeof(uintptr_t)*i)); + return r; +} + +Addressing* getInstructionTableAddressing(int i){ + Addressing* r = (InstructionTable + (sizeof(uintptr_t)*256) + (sizeof(Addressing)*i)); + return r; +} + +void callInstructionTable(int i, address val){ + uintptr_t a = getInstructionTableFunction(i); + memcpy(&func, a, sizeof(uintptr_t)); + Addressing* r = (InstructionTable + ((sizeof(uintptr_t)*256) + (sizeof(Addressing) * i))); + func(*r, val); +} + +void setInstructionTable(int i, uintptr_t p, Addressing r){ + uintptr_t* p1 = (InstructionTable + (sizeof(uintptr_t)*i)); + *p1 = p; + + Addressing* r1 = (InstructionTable + (sizeof(uintptr_t)*256) + (sizeof(Addressing)*i)); + *r1 = r; +} + +void initInstructionTable(){ + InstructionTable = malloc(InstructionTableSize); + // Load and Store Instructions + // fLDA(Addressing, address); + setInstructionTable(0xA9, (uintptr_t)&fLDA, eImmediate); + setInstructionTable(0xA5, (uintptr_t)&fLDA, eZeroPage); + setInstructionTable(0xB5, (uintptr_t)&fLDA, eZeroPageIndexedX); + setInstructionTable(0xAD, (uintptr_t)&fLDA, eAbsolute); + setInstructionTable(0xBD, (uintptr_t)&fLDA, eAbsoluteIndexedX); + setInstructionTable(0xB9, (uintptr_t)&fLDA, eAbsoluteIndexedY); + setInstructionTable(0xA1, (uintptr_t)&fLDA, eIndexedIndirect); + setInstructionTable(0xB1, (uintptr_t)&fLDA, eIndirectIndexed); + // fLDX(Addressing, address); + setInstructionTable(0xA2, (uintptr_t)&fLDX, eImmediate); + setInstructionTable(0xA6, (uintptr_t)&fLDX, eZeroPage); + setInstructionTable(0xB6, (uintptr_t)&fLDX, eZeroPageIndexedY); + setInstructionTable(0xAE, (uintptr_t)&fLDX, eAbsolute); + setInstructionTable(0xBE, (uintptr_t)&fLDX, eAbsoluteIndexedY); + // fLDY(Addressing, address); + setInstructionTable(0xA0, (uintptr_t)&fLDY, eImmediate); + setInstructionTable(0xA4, (uintptr_t)&fLDY, eZeroPage); + setInstructionTable(0xB4, (uintptr_t)&fLDY, eZeroPageIndexedX); + setInstructionTable(0xAC, (uintptr_t)&fLDY, eAbsolute); + setInstructionTable(0xBC, (uintptr_t)&fLDY, eAbsoluteIndexedX); + // fSTA(Addressing, address); + setInstructionTable(0x85, (uintptr_t)&fSTA, eZeroPage); + setInstructionTable(0x95, (uintptr_t)&fSTA, eZeroPageIndexedX); + setInstructionTable(0x8D, (uintptr_t)&fSTA, eAbsolute); + setInstructionTable(0x9D, (uintptr_t)&fSTA, eAbsoluteIndexedX); + setInstructionTable(0x99, (uintptr_t)&fSTA, eAbsoluteIndexedY); + setInstructionTable(0x81, (uintptr_t)&fSTA, eIndexedIndirect); + setInstructionTable(0x91, (uintptr_t)&fSTA, eIndirectIndexed); + // fSTX(Addressing, address); + setInstructionTable(0x86, (uintptr_t)&fSTX, eZeroPage); + setInstructionTable(0x96, (uintptr_t)&fSTX, eZeroPageIndexedX); + setInstructionTable(0x8E, (uintptr_t)&fSTX, eAbsolute); + // fSTY(Addressing, address); + setInstructionTable(0x84, (uintptr_t)&fSTY, eZeroPage); + setInstructionTable(0x94, (uintptr_t)&fSTY, eZeroPageIndexedY); + setInstructionTable(0x8C, (uintptr_t)&fSTY, eAbsolute); + + // Arithmetic Instructions + // fADC(Addressing, address); + setInstructionTable(0x69, (uintptr_t)&fADC, eImmediate); + setInstructionTable(0x65, (uintptr_t)&fADC, eZeroPage); + setInstructionTable(0x75, (uintptr_t)&fADC, eZeroPageIndexedX); + setInstructionTable(0x6D, (uintptr_t)&fADC, eAbsolute); + setInstructionTable(0x7D, (uintptr_t)&fADC, eAbsoluteIndexedX); + setInstructionTable(0x79, (uintptr_t)&fADC, eAbsoluteIndexedY); + setInstructionTable(0x61, (uintptr_t)&fADC, eIndexedIndirect); + setInstructionTable(0x71, (uintptr_t)&fADC, eIndirectIndexed); + // fSBC(Addressing, address); + setInstructionTable(0xE9, (uintptr_t)&fSBC, eImmediate); + setInstructionTable(0xE5, (uintptr_t)&fSBC, eZeroPage); + setInstructionTable(0xF5, (uintptr_t)&fSBC, eZeroPageIndexedX); + setInstructionTable(0xED, (uintptr_t)&fSBC, eAbsolute); + setInstructionTable(0xFD, (uintptr_t)&fSBC, eAbsoluteIndexedX); + setInstructionTable(0xF9, (uintptr_t)&fSBC, eAbsoluteIndexedY); + setInstructionTable(0xE1, (uintptr_t)&fSBC, eIndexedIndirect); + setInstructionTable(0xF1, (uintptr_t)&fSBC, eIndirectIndexed); + + //Increment and Decrement Instructions + //INC(Addressing, address); + setInstructionTable(0xE6, (uintptr_t)&fINC, eZeroPage); + setInstructionTable(0xF6, (uintptr_t)&fINC, eZeroPageIndexedX); + setInstructionTable(0xEE, (uintptr_t)&fINC, eAbsolute); + setInstructionTable(0xFE, (uintptr_t)&fINC, eAbsoluteIndexedX); + //INX(Addressing, address); + setInstructionTable(0xE8, (uintptr_t)&fINX, eImplied); + //INY(Addressing, address); + setInstructionTable(0xC8, (uintptr_t)&fINY, eImplied); + //DEC(Addressing, address); + setInstructionTable(0xC6, (uintptr_t)&fDEC, eZeroPage); + setInstructionTable(0xD6, (uintptr_t)&fDEC, eZeroPageIndexedX); + setInstructionTable(0xCE, (uintptr_t)&fDEC, eAbsolute); + setInstructionTable(0xDE, (uintptr_t)&fDEC, eAbsoluteIndexedX); + //DEX(Addressing, address); + setInstructionTable(0xCA, (uintptr_t)&fDEX, eImplied); + //DEY(Addressing, address); + setInstructionTable(0x88, (uintptr_t)&fDEY, eImplied); + + // Logical Instructions + //AND(Addressing, address); + setInstructionTable(0x29, (uintptr_t)&fAND, eImmediate); + setInstructionTable(0x25, (uintptr_t)&fAND, eZeroPage); + setInstructionTable(0x35, (uintptr_t)&fAND, eZeroPageIndexedX); + setInstructionTable(0x2D, (uintptr_t)&fAND, eAbsolute); + setInstructionTable(0x3D, (uintptr_t)&fAND, eAbsoluteIndexedX); + setInstructionTable(0x39, (uintptr_t)&fAND, eAbsoluteIndexedY); + setInstructionTable(0x21, (uintptr_t)&fAND, eIndexedIndirect); + setInstructionTable(0x31, (uintptr_t)&fAND, eIndirectIndexed); + //ORA(Addressing, address); + setInstructionTable(0x09, (uintptr_t)&fORA, eImmediate); + setInstructionTable(0x05, (uintptr_t)&fORA, eZeroPage); + setInstructionTable(0x15, (uintptr_t)&fORA, eZeroPageIndexedX); + setInstructionTable(0x0D, (uintptr_t)&fORA, eAbsolute); + setInstructionTable(0x1D, (uintptr_t)&fORA, eAbsoluteIndexedX); + setInstructionTable(0x19, (uintptr_t)&fORA, eAbsoluteIndexedY); + setInstructionTable(0x01, (uintptr_t)&fORA, eIndexedIndirect); + setInstructionTable(0x11, (uintptr_t)&fORA, eIndirectIndexed); + //EOR(Addressing, address); + setInstructionTable(0x49, (uintptr_t)&fEOR, eImmediate); + setInstructionTable(0x45, (uintptr_t)&fEOR, eZeroPage); + setInstructionTable(0x55, (uintptr_t)&fEOR, eZeroPageIndexedX); + setInstructionTable(0x4D, (uintptr_t)&fEOR, eAbsolute); + setInstructionTable(0x5D, (uintptr_t)&fEOR, eAbsoluteIndexedX); + setInstructionTable(0x59, (uintptr_t)&fEOR, eAbsoluteIndexedY); + setInstructionTable(0x41, (uintptr_t)&fEOR, eIndexedIndirect); + setInstructionTable(0x51, (uintptr_t)&fEOR, eIndirectIndexed); + + // Jump, Branch, Compare, and Test Bits + //JMP(Addressing, address); + setInstructionTable(0x4C, (uintptr_t)&fJMP, eAbsolute); + setInstructionTable(0x6C, (uintptr_t)&fJMP, eIndirectAbsolute); + //BCC(Addressing, address); + setInstructionTable(0x90, (uintptr_t)&fBCC, eRelative); + //BCS(Addressing, address); + setInstructionTable(0xB0, (uintptr_t)&fBCS, eRelative); + //BEQ(Addressing, address); + setInstructionTable(0xF0, (uintptr_t)&fBEQ, eRelative); + //BNE(Addressing, address); + setInstructionTable(0xD0, (uintptr_t)&fBNE, eRelative); + //BMI(Addressing, address); + setInstructionTable(0x30, (uintptr_t)&fBMI, eRelative); + //BPL(Addressing, address); + setInstructionTable(0x10, (uintptr_t)&fBPL, eRelative); + //BVS(Addressing, address); + setInstructionTable(0x70, (uintptr_t)&fBVS, eRelative); + //BVC(Addressing, address); + setInstructionTable(0x50, (uintptr_t)&fBVC, eRelative); + //CMP(Addressing, address); + setInstructionTable(0xC9, (uintptr_t)&fCMP, eImmediate); + setInstructionTable(0xC5, (uintptr_t)&fCMP, eZeroPage); + setInstructionTable(0xD5, (uintptr_t)&fCMP, eZeroPageIndexedX); + setInstructionTable(0xCD, (uintptr_t)&fCMP, eAbsolute); + setInstructionTable(0xDD, (uintptr_t)&fCMP, eAbsoluteIndexedX); + setInstructionTable(0xD9, (uintptr_t)&fCMP, eAbsoluteIndexedY); + setInstructionTable(0xC1, (uintptr_t)&fCMP, eIndexedIndirect); + setInstructionTable(0xD1, (uintptr_t)&fCMP, eIndirectIndexed); + //CPX(Addressing, address); + setInstructionTable(0xE0, (uintptr_t)&fCPX, eImmediate); + setInstructionTable(0xE4, (uintptr_t)&fCPX, eZeroPage); + setInstructionTable(0xEC, (uintptr_t)&fCPX, eAbsolute); + //CPY(Addressing, address); + setInstructionTable(0xC0, (uintptr_t)&fCPY, eImmediate); + setInstructionTable(0xC4, (uintptr_t)&fCPY, eZeroPage); + setInstructionTable(0xCC, (uintptr_t)&fCPY, eAbsolute); + //BIT(Addressing, address); + setInstructionTable(0x4C, (uintptr_t)&fBIT, eZeroPage); + setInstructionTable(0x6C, (uintptr_t)&fBIT, eAbsolute); + + // Shift and Rotate Instructions + //ASL(Addressing, address); + setInstructionTable(0x0A, (uintptr_t)&fASL, eAccumulator); + setInstructionTable(0x06, (uintptr_t)&fASL, eZeroPage); + setInstructionTable(0x16, (uintptr_t)&fASL, eZeroPageIndexedX); + setInstructionTable(0x0E, (uintptr_t)&fASL, eAbsolute); + setInstructionTable(0x1E, (uintptr_t)&fASL, eAbsoluteIndexedX); + //LSR(Addressing, address); + setInstructionTable(0x4A, (uintptr_t)&fLSR, eAccumulator); + setInstructionTable(0x46, (uintptr_t)&fLSR, eZeroPage); + setInstructionTable(0x56, (uintptr_t)&fLSR, eZeroPageIndexedX); + setInstructionTable(0x4E, (uintptr_t)&fLSR, eAbsolute); + setInstructionTable(0x5E, (uintptr_t)&fLSR, eAbsoluteIndexedX); + //ROL(Addressing, address); + setInstructionTable(0x2A, (uintptr_t)&fROL, eAccumulator); + setInstructionTable(0x26, (uintptr_t)&fROL, eZeroPage); + setInstructionTable(0x36, (uintptr_t)&fROL, eZeroPageIndexedX); + setInstructionTable(0x2E, (uintptr_t)&fROL, eAbsolute); + setInstructionTable(0x3E, (uintptr_t)&fROL, eAbsoluteIndexedX); + //ROR(Addressing, address); + setInstructionTable(0x6A, (uintptr_t)&fROR, eAccumulator); + setInstructionTable(0x66, (uintptr_t)&fROR, eZeroPage); + setInstructionTable(0x76, (uintptr_t)&fROR, eZeroPageIndexedX); + setInstructionTable(0x6E, (uintptr_t)&fROR, eAbsolute); + setInstructionTable(0x7E, (uintptr_t)&fROR, eAbsoluteIndexedX); + + // Transfer Instructions + //TAX(Addressing, address); + setInstructionTable(0xAA, (uintptr_t)&fTAX, eImplied); + //TAY(Addressing, address); + setInstructionTable(0xA8, (uintptr_t)&fTAY, eImplied); + //TXA(Addressing, address); + setInstructionTable(0x8A, (uintptr_t)&fTXA, eImplied); + //TYA(Addressing, address); + setInstructionTable(0x98, (uintptr_t)&fTYA, eImplied); + + // Stack Instructions + //TSX(Addressing, address); + setInstructionTable(0xBA, (uintptr_t)&fTSX, eImplied); + //TXS(Addressing, address); + setInstructionTable(0x9A, (uintptr_t)&fTXS, eImplied); + //PHA(Addressing, address); + setInstructionTable(0x48, (uintptr_t)&fPHA, eImplied); + //PHP(Addressing, address); + setInstructionTable(0x08, (uintptr_t)&fPHP, eImplied); + //PLA(Addressing, address); + setInstructionTable(0x68, (uintptr_t)&fPLA, eImplied); + //PLP(Addressing, address); + setInstructionTable(0x28, (uintptr_t)&fPLP, eImplied); + + // Subroutine Instructions + //JSR(Addressing, address); + setInstructionTable(0x20, (uintptr_t)&fJSR, eAbsolute); + //RTS(Addressing, address); + setInstructionTable(0x60, (uintptr_t)&fRTS, eImplied); + //RTI(Addressing, address); + setInstructionTable(0x40, (uintptr_t)&fRTI, eImplied); + + // Set/Reset Insutrctions + //CLC(Addressing, address); + setInstructionTable(0x18, (uintptr_t)&fCLC, eImplied); + //CLD(Addressing, address); + setInstructionTable(0xD8, (uintptr_t)&fCLD, eImplied); + //CLI(Addressing, address); + setInstructionTable(0x58, (uintptr_t)&fCLI, eImplied); + //CLV(Addressing, address); + setInstructionTable(0xB8, (uintptr_t)&fCLV, eImplied); + //SEC(Addressing, address); + setInstructionTable(0x38, (uintptr_t)&fSEC, eImplied); + //SED(Addressing, address); + setInstructionTable(0xF8, (uintptr_t)&fSED, eImplied); + //SEI(Addressing, address); + setInstructionTable(0x78, (uintptr_t)&fSEI, eImplied); + + // NOP/BRK Instructions + //NOP(Addressing, address); + setInstructionTable(0xEA, (uintptr_t)&fNOP, eImplied); + //BRK(Addressing, address); + setInstructionTable(0x00, (uintptr_t)&fBRK, eImplied); + + #ifdef ILLEGAL + #include"illegal/table-append.h" + #endif + +} + -- cgit v1.2.3