From 83e8a4494741e6257b18267a58fe8ae342e3229f Mon Sep 17 00:00:00 2001 From: alekseiplusplus Date: Fri, 21 Apr 2023 16:12:16 +1000 Subject: changed dirs, now testing instructions. --- headers/6502.h | 113 +++++++++++++++++++ headers/addressing.h | 2 +- headers/apple.h | 6 + headers/applesystem.h | 113 ------------------- headers/debug.h | 12 +- headers/include.h | 5 +- headers/instruction-bin.h | 241 --------------------------------------- headers/instruction-init.h | 97 ---------------- headers/instruction-table.h | 266 ++++++++++++++++++++++++++++++++++++++++++++ headers/instructions-init.h | 70 ++++++++++++ headers/instructions.h | 23 ++-- 11 files changed, 479 insertions(+), 469 deletions(-) create mode 100644 headers/6502.h create mode 100644 headers/apple.h delete mode 100644 headers/applesystem.h delete mode 100644 headers/instruction-bin.h delete mode 100644 headers/instruction-init.h create mode 100644 headers/instruction-table.h create mode 100644 headers/instructions-init.h (limited to 'headers') diff --git a/headers/6502.h b/headers/6502.h new file mode 100644 index 0000000..ea92479 --- /dev/null +++ b/headers/6502.h @@ -0,0 +1,113 @@ +// 6502.h +// Core elements of the 6502 CPU + +typedef unsigned char byte; +typedef unsigned short address; +byte acc, X, Y, P, S = 0x00; +address PC = 0x0000; +byte Memory[4096]; // TO DO. Add expansion capability to memory. + +// FLAGS +#define flag_N 0x80 // Negative +#define flag_V 0x40 // Overflow +#define flag_B 0x10 // BRK command +#define flag_D 0x08 // Decimal mode +#define flag_I 0x04 // IRQ disable +#define flag_Z 0x02 // Zero +#define flag_C 0x01 // Carry + +byte getFlag(byte flag) { + return ((P & flag) == flag) ? 1 : 0; +} + +void setFlag(byte flag, int x) { + if (x == 1){ + if ((P & flag) == 0x0) P += flag; + }else if (x == 0){ + if ((P & flag) == flag) P -= flag; + } + else{ + fprintf(stderr, "setFlag() passed arg neither 0 or 1"); + } +} + +void flagSet(byte flag){ + P |= flag; +} + +void flagClear(byte flag){ + P &= ~flag; +} + + +// BCD +// need to actually look into BCD on the 6502 +byte toBCD(byte x){ + if (x < 100){ + byte a = ((x / 10) << 4); + byte b = (x % 10); + return (a + b); + } + else{ + fprintf(stderr, "Number greater than 99 passed to toBCD()"); + } +} + +byte fromBCD(byte x){ + byte a = ((x >> 4) * 10); + byte b = (x & 0xF); + return (a + b); +} + + +// Functions which perform reusable routines for finding if a specific flag should be set. + +void setFlagN(byte x){ + if (x & flag_N == flag_N) + setFlag(flag_N, 1); + else + setFlag(flag_N, 0); +} + +//Perform prior to any changes +void setFlagV(byte x, byte y){ + if ((x & flag_N) == (y & flag_N)){ + if (((x + y) & (flag_N ^ 0xFF)) > 0x7F) setFlag(flag_V, 1); + else setFlag(flag_V, 0); + }else{ + if (((x - y) & (flag_N ^ 0xFF)) > 0x7F) setFlag(flag_V, 1); + else setFlag(flag_V, 0); + } +} + +/*void setFlagB(){ //WORK ON + setFlag(flag_B, 1); +}*/ //Dont really need since its dependent on the BRK insturction + +/*void setFlagD(){ + setFlag(flag_D, 1); +}*/ + +/*void setFlagI(){ //WORK ON + setFlag(flag_Z, 1); +}*/ + +void setFlagZ(int x){ + if (x == 0) + setFlag(flag_Z, 1); + else + setFlag(flag_Z, 0); +} + +//Only 6 instructions, 2 not including stack instructions, use the carry flag. +// Need to look further into implementation details for this. +/*void setFlagC(){ + setFlag(flag_Z, 1); +}*/ + + + + + + + diff --git a/headers/addressing.h b/headers/addressing.h index d9d8e98..58df3f5 100644 --- a/headers/addressing.h +++ b/headers/addressing.h @@ -28,7 +28,7 @@ struct AddData{ typedef struct AddData AddData; -#include"instruction-init.h" +#include"instructions-init.h" //Holds address of current instruction. void* current_instruction; diff --git a/headers/apple.h b/headers/apple.h new file mode 100644 index 0000000..f5cac5c --- /dev/null +++ b/headers/apple.h @@ -0,0 +1,6 @@ +#define MEMORY_SIZE 4096 + +void AppleOn(){ + //Memory = malloc(MEMORY_SIZE); + initInstructionTable(); +} \ No newline at end of file diff --git a/headers/applesystem.h b/headers/applesystem.h deleted file mode 100644 index 6b2f818..0000000 --- a/headers/applesystem.h +++ /dev/null @@ -1,113 +0,0 @@ -// applesystem.h -// Core elements of the 6502 CPU, and flag manipulation. - -typedef unsigned char byte; -typedef unsigned short address; -byte acc, X, Y, P, S = 0x00; -address PC = 0x0000; -byte Memory[4096]; // TO DO. Add expansion capability to memory. - -// FLAGS -const byte flag_N = 0x80; // Negative -const byte flag_V = 0x40; // Overflow -const byte flag_B = 0x10; // BRK command -const byte flag_D = 0x08; // Decimal mode -const byte flag_I = 0x04; // IRQ disable -const byte flag_Z = 0x02; // Zero -const byte flag_C = 0x01; // Carry - -byte getFlag(byte flag) { - return ((P & flag) == flag) ? 1 : 0; -} - -void setFlag(byte flag, int x) { //OVERLOAD TO ACCEPT INT AS WELL - if (x == 1){ - if ((P & flag) == 0x0) P += flag; - }else if (x == 0){ - if ((P & flag) == flag) P -= flag; - } - else{ - fprintf(stderr, "setFlag() passed arg neither 0 or 1"); - } -} - -void flagSet(byte flag){ - P |= flag; -} - -void flagClear(byte flag){ - P &= ~flag; -} - - -// BCD -// need to actually look into BCD on the 6502 -byte toBCD(byte x){ - if (x < 100){ - byte a = ((x / 10) << 4); - byte b = (x % 10); - return (a + b); - } - else{ - fprintf(stderr, "Number greater than 99 passed to toBCD()"); - } -} - -byte fromBCD(byte x){ - byte a = ((x >> 4) * 10); - byte b = (x & 0xF); - return (a + b); -} - - -// Functions which perform reusable routines for finding if a specific flag should be set. - -void setFlagN(byte x){ - if (x & flag_N == flag_N) - setFlag(flag_N, 1); - else - setFlag(flag_N, 0); -} - -//Perform prior to any changes -void setFlagV(byte x, byte y){ - if ((x & flag_N) == (y & flag_N)){ - if (((x + y) & (flag_N ^ 0xFF)) > 0x7F) setFlag(flag_V, 1); - else setFlag(flag_V, 0); - }else{ - if (((x - y) & (flag_N ^ 0xFF)) > 0x7F) setFlag(flag_V, 1); - else setFlag(flag_V, 0); - } -} - -/*void setFlagB(){ //WORK ON - setFlag(flag_B, 1); -}*/ //Dont really need since its dependent on the BRK insturction - -/*void setFlagD(){ - setFlag(flag_D, 1); -}*/ - -/*void setFlagI(){ //WORK ON - setFlag(flag_Z, 1); -}*/ - -void setFlagZ(int x){ - if (x == 0) - setFlag(flag_Z, 1); - else - setFlag(flag_Z, 0); -} - -//Only 6 instructions, 2 not including stack instructions, use the carry flag. -// Need to look further into implementation details for this. -/*void setFlagC(){ - setFlag(flag_Z, 1); -}*/ - - - - - - - diff --git a/headers/debug.h b/headers/debug.h index bb6ba40..cb34dac 100644 --- a/headers/debug.h +++ b/headers/debug.h @@ -33,9 +33,11 @@ void dPageDump(short m){ // Dump CPU values void dStatusDump(void){ - printf(" acc:\t%x\n X:\t%x\n Y:\t%x\nstack:\t%x\nflags:\t%x\n", acc, X, Y, S, P); +printf("\ +..acc:\t%x\tcycles:\t%d\n\ +....X:\t%x\tlength:\t%d\n\ +....Y:\t%x\t...add:\t%x\n\ +stack:\t%x\t.value:\t%x\n\ +flags:\t%x\n\ +", acc, idata.cycles, X, idata.length, Y, idata.add, S, idata.value, P); } - -void dIdataDump(void){ - printf("cycles:\t%d\nlength:\t%d\n add:\t%x\n value:\t%x\n", idata.cycles, idata.length, idata.add, idata.value); -} \ No newline at end of file diff --git a/headers/include.h b/headers/include.h index e2578de..c4a2ef8 100644 --- a/headers/include.h +++ b/headers/include.h @@ -2,7 +2,8 @@ #include"stdint.h" #include"stdlib.h" #include"string.h" -#include"applesystem.h" +#include"6502.h" #include"addressing.h" #include"instructions.h" -#include"instruction-bin.h" \ No newline at end of file +#include"instruction-table.h" +#include"apple.h" \ No newline at end of file diff --git a/headers/instruction-bin.h b/headers/instruction-bin.h deleted file mode 100644 index 0127fd7..0000000 --- a/headers/instruction-bin.h +++ /dev/null @@ -1,241 +0,0 @@ -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); -} - - diff --git a/headers/instruction-init.h b/headers/instruction-init.h deleted file mode 100644 index 68b9cf3..0000000 --- a/headers/instruction-init.h +++ /dev/null @@ -1,97 +0,0 @@ -// instruction-init.h -// Initializes every instruction function prior to addressing.h so that function addresses are accessible -// also defines the array used to refer to functions - -//InstructionTable -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){ - printf("Table:\t%x\n", InstructionTable); - uintptr_t a = getInstructionTableFunction(i); - printf("A Val:\t%x\n", a); - //printf("Before:\t%x\n", func); func = a; printf("After:\t%x\n", func); - printf("Before:\t%x\n", func); memcpy(&func, a, sizeof(uintptr_t)); printf("After:\t%x\n", func); - Addressing* r = (InstructionTable + ((sizeof(uintptr_t)*256) + (sizeof(Addressing) * i))); - func(*r, val); printf("Statement OK"); -} - -// 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); \ No newline at end of file diff --git a/headers/instruction-table.h b/headers/instruction-table.h new file mode 100644 index 0000000..bb51adb --- /dev/null +++ b/headers/instruction-table.h @@ -0,0 +1,266 @@ +// 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); +} + + diff --git a/headers/instructions-init.h b/headers/instructions-init.h new file mode 100644 index 0000000..6fddec4 --- /dev/null +++ b/headers/instructions-init.h @@ -0,0 +1,70 @@ +// instruction-init.h +// Initializes every instruction function prior to addressing.h so that function addresses are accessible + +// 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); \ No newline at end of file diff --git a/headers/instructions.h b/headers/instructions.h index 96f5719..bdcd442 100644 --- a/headers/instructions.h +++ b/headers/instructions.h @@ -1,13 +1,16 @@ -// instruction.h +// instructions.h // Definition of all instruction functions, handling effect of instruction and flags. -// array/map of pointers which all point -// to the functions which the index corresponds to. -// use that like a sort of map +AddData idata; -//Instruction Data -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 @@ -206,15 +209,15 @@ void fBIT(Addressing addr, address val){ idata = fAddress(addr, val); // Shift and Rotate Instructions void fASL(Addressing addr, address val){ idata = fAddress(addr, val); - setFlag(flag_C, (val & 0x80)); - acc = (val << 1); + 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, (val & 0x01)); - acc = (val >> 1); + setFlag(flag_C, (idata.value & 0x01)); + acc = (idata.value >> 1); setFlagN(acc); setFlagZ(acc); } -- cgit v1.2.3