diff options
Diffstat (limited to 'sux.c')
| -rw-r--r-- | sux.c | 1230 |
1 files changed, 354 insertions, 876 deletions
@@ -1,15 +1,16 @@ #include "opcode.h" #include <assert.h> -#include <curses.h> #include <ctype.h> #include <string.h> #include <pthread.h> #define bench 0 -#define debug 1 -#define IO 0 +#define debug 0 +#define IO 1 #define keypoll 0 #if bench #include <sys/time.h> +#else +#include <curses.h> #endif #define THREADS 1 @@ -27,7 +28,9 @@ uint8_t threads_done = 0; uint8_t kbd_rdy = 0; uint8_t wai = 0; uint8_t irq = 0; +#if !bench WINDOW *scr; +#endif pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; pthread_mutex_t main_mutex = PTHREAD_MUTEX_INITIALIZER; pthread_cond_t cond = PTHREAD_COND_INITIALIZER; @@ -46,21 +49,26 @@ void *run(void *args) { struct sux *cpu = &thr->sx; uint8_t thread = thr->th; uint64_t address = 0; + uint64_t tmpaddr = 0; uint8_t prefix = 0; uint8_t opcode = 0; uint8_t end = 0; + uint8_t stksize; uint64_t sum = 0; uint64_t value = 0; + uint64_t reg = 0; uint64_t iclk = 0; uint64_t ins = 0; uint64_t sign = 0; char *s = malloc(2048); +#if !bench uint8_t lines = (6*thread)+2; uint8_t bcd[4]; uint8_t idx = 3, iscol = 0; - uint16_t tv = 0xFF50; /* Starting address of the Thread Vectors. */ int x = 0, y = 0; uint8_t esc = 0; +#endif + uint16_t tv = 0xFF50; /* Starting address of the Thread Vectors. */ #if bench gettimeofday(&str[thread], 0); #endif @@ -90,35 +98,229 @@ void *run(void *args) { kbd_rdy &= (uint8_t)~(1 << thread); } prefix = addr[cpu->pc[thread]]; - if ((prefix & 0x0F) == 0x07) + if ((prefix & 0x07) == 0x07) cpu->pc[thread]++; else prefix = 0; opcode = addr[cpu->pc[thread]]; + #if debug && !bench + if (lines > 24*(thread+1)) { + lines = (24*thread)+2; + } #if keypoll pthread_mutex_lock(&mutex); #endif mvwprintw(scr, lines, 0, "pc: $%08llx, a: $%016llx, b: $%016llx, x: $%016llx, y: $%016llx" - ", sp: $%04lx, ps: $%016llx, prefix: $%02x, opcode: $%02x, thread: %u, inst: %s \r" + ", sp: $%04lx, ps: $%016llx, prefix: $%02x, opcode: $%02x, thread: %u, inst: " , cpu->pc[thread], cpu->a[thread], cpu->b[thread], cpu->x[thread], cpu->y[thread] - , cpu->sp[thread], cpu->ps, prefix, opcode, thread, opname[opcode]); - wrefresh(scr); + , cpu->sp[thread], cpu->ps, prefix, opcode, thread); #if keypoll pthread_mutex_unlock(&mutex); #endif - lines++; - if (lines > 24*(thread+1)) - lines = (24*thread)+2; #endif + uint8_t addrsize = (prefix & 8) == 8; uint8_t rs = (prefix & 0x30) >> 4; uint8_t regsize = (1 << rs); uint8_t tmp; address = cpu->pc[thread]; cpu->pc[thread]++; iclk++; + switch (optype[opcode]) { + case IMPL: + break; + case IMM: + switch (opcode) { + case TXS: + case PHB: + case PHP: + case PHA: + case PHY: + case PHX: + case PLB: + case PLP: + case PLA: + case PLY: + case PLX: + break; + case STT: + case LSL: + case LSR: + case ROL: + case ROR: + case ASR: + case ENT: + address = cpu->pc[thread]; + cpu->pc[thread]+=1; + break; + default: + address = cpu->pc[thread]; + cpu->pc[thread]+=regsize; + break; + } + break; + case ZM: + case ZMX: + case ZMY: + address = addr[cpu->pc[thread]]; + if (addrsize) { + address |= addr[cpu->pc[thread]+1] << 8; + address |= addr[cpu->pc[thread]+2] << 16; + address |= addr[cpu->pc[thread]+3] << 24; + cpu->pc[thread]+=4; + } else { + cpu->pc[thread]+=1; + } + tmpaddr = address; + if (optype[opcode] == ZMX) + address += cpu->x[thread]; + if (optype[opcode] == ZMY) + address += cpu->y[thread]; + break; + case IND: + case INDX: + case INDY: + address = addr[cpu->pc[thread]]; + if (addrsize) { + address |= addr[cpu->pc[thread]+1] << 8; + address |= addr[cpu->pc[thread]+2] << 16; + address |= addr[cpu->pc[thread]+3] << 24; + cpu->pc[thread]+=4; + } else { + cpu->pc[thread]+=1; + } + tmpaddr = address; + if (optype[opcode] == INDX) + address += cpu->x[thread]; + value = (uint64_t)addr[address] + | (uint64_t)addr[address+1] << 8 + | (uint64_t)addr[address+2] << 16 + | (uint64_t)addr[address+3] << 24 + | (uint64_t)addr[address+4] << 32 + | (uint64_t)addr[address+5] << 40 + | (uint64_t)addr[address+6] << 48 + | (uint64_t)addr[address+7] << 56; + if (optype[opcode] == INDY) + value += cpu->y[thread]; + address = value; + value = 0; + iclk++; + break; + case ABS: + address = addr[cpu->pc[thread]]; + address |= addr[cpu->pc[thread]+1] << 8; + if (addrsize) { + address |= (uint64_t)addr[cpu->pc[thread]+2] << 16; + address |= (uint64_t)addr[cpu->pc[thread]+3] << 24; + address |= (uint64_t)addr[cpu->pc[thread]+4] << 32; + address |= (uint64_t)addr[cpu->pc[thread]+5] << 40; + address |= (uint64_t)addr[cpu->pc[thread]+6] << 48; + address |= (uint64_t)addr[cpu->pc[thread]+7] << 56; + cpu->pc[thread]+=8; + iclk++; + } else { + cpu->pc[thread]+=2; + } + + break; + + } + value = addr[address]; + if (regsize >= 2) { + value |= addr[address+1] << 8; + if (regsize >= 4) { + value |= addr[address+2] << 16; + value |= addr[address+3] << 24; + } + if (regsize >= 8) { + value |= (uint64_t)addr[address+4] << 32; + value |= (uint64_t)addr[address+5] << 40; + value |= (uint64_t)addr[address+6] << 48; + value |= (uint64_t)addr[address+7] << 56; + } + } + #if debug && !bench + int row, col; + #if keypoll + pthread_mutex_lock(&mutex); + #endif + getyx(scr,row, col); + char postfix[3]; + char op[4]; + op[0] = opname[opcode][0]; + op[1] = opname[opcode][1]; + op[2] = opname[opcode][2]; + op[3] = '\0'; + if (regsize == 1) { + postfix[0] = '\0'; + postfix[1] = '\0'; + postfix[2] = '\0'; + } else { + postfix[0] = '.'; + if (regsize == 2) + postfix[1] = 'W'; + if (regsize == 4) + postfix[1] = 'D'; + if (regsize == 8) + postfix[1] = 'Q'; + postfix[2] = '\0'; + } + switch (optype[opcode]) { + case IMPL: + mvwprintw(scr, lines, col, "%s \r" , opname[opcode]); + break; + case IMM: + if (regsize == 1) { + mvwprintw(scr, lines, col, "%s #$%02x \r" , op, value); + } + if (regsize == 2) { + mvwprintw(scr, lines, col, "%s%s #$%04x \r" , op, postfix, value); + } + if (regsize == 4) { + mvwprintw(scr, lines, col, "%s%s #$%08x \r" , op, postfix, value); + } + if (regsize == 8) { + mvwprintw(scr, lines, col, "%s%s #$%016llx\r" , op, postfix, value); + } + break; + case ZM: + case ZMX: + case ZMY: + if (optype[opcode] == ZMX) + tmpaddr = address - cpu->x[thread]; + if (optype[opcode] == ZMY) + tmpaddr = address - cpu->y[thread]; + if (addrsize) + mvwprintw(scr, lines, col, "%s%s $%08x%s \r" , op, postfix, tmpaddr, (optype[opcode] == ZM) ? "" : ((optype[opcode] == ZMX) ? ", x" : ", y")); + else + mvwprintw(scr, lines, col, "%s%s $%02x%s \r" , op, postfix, tmpaddr, (optype[opcode] == ZM) ? "" : ((optype[opcode] == ZMX) ? ", x" : ", y")); + break; + case IND: + case INDX: + case INDY: + if (addrsize) + mvwprintw(scr, lines, col, "%s%s ($%08x%s \r" , op, postfix, tmpaddr, (optype[opcode] == IND) ? ")" : ((optype[opcode] == INDX) ? ", x)" : "), y")); + else + mvwprintw(scr, lines, col, "%s%s ($%02x%s \r" , op, postfix, tmpaddr, (optype[opcode] == IND) ? ")" : ((optype[opcode] == INDX) ? ", x)" : "), y")); + break; + case ABS: + tmpaddr = address; + if (addrsize) + mvwprintw(scr, lines, col, "%s%s $%016llx\r" , op, postfix, value); + else + mvwprintw(scr, lines, col, "%s%s $%04x \r" , op, postfix, tmpaddr); + break; + + } + mvwprintw(scr, 29, 0, "address: $%016llx\r", address); + wrefresh(scr); + #if keypoll + pthread_mutex_unlock(&mutex); + #endif + lines+=1; + #endif switch(opcode) { case CPS: /* Clear Processor Status. */ for (uint8_t i = 0; i < 8; i++) { @@ -135,48 +337,8 @@ void *run(void *args) { case AAB: /* Add Accumulator with carry by B register. */ case 0x03: /* ADC Absolute. */ case 0x05: /* ADC Zero Matrix. */ - if (opcode != AAB) { - if (opcode == ADC) { - address = cpu->pc[thread]; - cpu->pc[thread]+=regsize; - } - if (opcode == 0x03) { - address = (uint64_t)addr[cpu->pc[thread]] - | (uint64_t)addr[cpu->pc[thread]+1] << 8 - | (uint64_t)addr[cpu->pc[thread]+2] << 16 - | (uint64_t)addr[cpu->pc[thread]+3] << 24 - | (uint64_t)addr[cpu->pc[thread]+4] << 32 - | (uint64_t)addr[cpu->pc[thread]+5] << 40 - | (uint64_t)addr[cpu->pc[thread]+6] << 48 - | (uint64_t)addr[cpu->pc[thread]+7] << 56; - cpu->pc[thread]+=8; - iclk++; - } - if (opcode == 0x05) { - address = addr[cpu->pc[thread]] - | addr[cpu->pc[thread]+1] << 8 - | addr[cpu->pc[thread]+2] << 16 - | addr[cpu->pc[thread]+3] << 24; - cpu->pc[thread]+=4; - iclk++; - } - value = addr[address]; - if (regsize >= 2) { - value += (uint64_t)addr[address+1] << 8; - } - if (regsize >= 4) { - value += (uint64_t)addr[address+2] << 16; - value += (uint64_t)addr[address+3] << 24; - } - if (regsize >= 8) { - value += (uint64_t)addr[address+4] << 32; - value += (uint64_t)addr[address+5] << 40; - value += (uint64_t)addr[address+6] << 48; - value += (uint64_t)addr[address+7] << 56; - } - } else { + if (opcode == AAB) value = cpu->b[thread]; - } sum = cpu->a[thread]+value+cpu->c[thread]; cpu->a[thread] = sum; cpu->z[thread] = (sum == 0); @@ -305,62 +467,13 @@ void *run(void *args) { } break; case JMP: /* JMP Absolute. */ - address = (uint64_t)addr[cpu->pc[thread]] - | (uint64_t)addr[cpu->pc[thread]+1] << 8 - | (uint64_t)addr[cpu->pc[thread]+2] << 16 - | (uint64_t)addr[cpu->pc[thread]+3] << 24 - | (uint64_t)addr[cpu->pc[thread]+4] << 32 - | (uint64_t)addr[cpu->pc[thread]+5] << 40 - | (uint64_t)addr[cpu->pc[thread]+6] << 48 - | (uint64_t)addr[cpu->pc[thread]+7] << 56; - cpu->pc[thread]+=8; - iclk++; cpu->pc[thread] = address; break; case SBC: /* SBC Immediate. */ case SAB: /* Subtract Accumulator with carry by B register. */ case 0x13: /* SBC Absolute. */ case 0x15: /* SBC Zero Matrix. */ - if (opcode != SAB) { - if (opcode == SBC) { - address = cpu->pc[thread]; - cpu->pc[thread]+=regsize; - } - if (opcode == 0x13) { - address = (uint64_t)addr[cpu->pc[thread]] - | (uint64_t)addr[cpu->pc[thread]+1] << 8 - | (uint64_t)addr[cpu->pc[thread]+2] << 16 - | (uint64_t)addr[cpu->pc[thread]+3] << 24 - | (uint64_t)addr[cpu->pc[thread]+4] << 32 - | (uint64_t)addr[cpu->pc[thread]+5] << 40 - | (uint64_t)addr[cpu->pc[thread]+6] << 48 - | (uint64_t)addr[cpu->pc[thread]+7] << 56; - cpu->pc[thread]+=8; - iclk++; - } - if (opcode == 0x15) { - address = addr[cpu->pc[thread]] - | addr[cpu->pc[thread]+1] << 8 - | addr[cpu->pc[thread]+2] << 16 - | addr[cpu->pc[thread]+3] << 24; - cpu->pc[thread]+=4; - iclk++; - } - value = addr[address]; - if (regsize >= 2) { - value += (uint64_t)addr[address+1] << 8; - } - if (regsize >= 4) { - value += (uint64_t)addr[address+2] << 16; - value += (uint64_t)addr[address+3] << 24; - } - if (regsize >= 8) { - value += (uint64_t)addr[address+4] << 32; - value += (uint64_t)addr[address+5] << 40; - value += (uint64_t)addr[address+6] << 48; - value += (uint64_t)addr[address+7] << 56; - } - } else { + if (opcode == SAB) { value = cpu->b[thread]; } sum = cpu->a[thread]-value-!cpu->c[thread]; @@ -438,25 +551,10 @@ void *run(void *args) { case 0x44: /* JSR Indexed Indirect. */ case 0x54: /* JSR Indirect Indexed. */ case JSR: /* Jump to SubRoutine. */ - address = (uint64_t)addr[cpu->pc[thread]] - | (uint64_t)addr[cpu->pc[thread]+1] << 8 - | (uint64_t)addr[cpu->pc[thread]+2] << 16 - | (uint64_t)addr[cpu->pc[thread]+3] << 24; - if (opcode == 0x34 || opcode == 0x44 || opcode == 0x54) { - address = (uint64_t)addr[address] - | (uint64_t)addr[address+1] << 8 - | (uint64_t)addr[address+2] << 16 - | (uint64_t)addr[address+3] << 24 - | (uint64_t)addr[address+4] << 32 - | (uint64_t)addr[address+5] << 40 - | (uint64_t)addr[address+6] << 48 - | (uint64_t)addr[address+7] << 56; - if (opcode == 0x44) - address += cpu->x[thread]; - if (opcode == 0x54) - address += cpu->y[thread]; - } - cpu->pc[thread]+=4; + if (addrsize) + stksize = 24; + else + stksize = 0; for (int8_t i = 24; i >= 0; i-=8) { if (i) addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] = (uint64_t)cpu->pc[thread] >> i; @@ -470,44 +568,8 @@ void *run(void *args) { case ABA: /* bitwise And with Accumulator, and B register. */ case 0x23: /* AND Absolute. */ case 0x25: /* AND Zero Matrix. */ - if (opcode != ABA) { - if (opcode == AND) { - address = cpu->pc[thread]; - cpu->pc[thread]+=regsize; - } - if (opcode == 0x23) { - address = (uint64_t)addr[cpu->pc[thread]] - | (uint64_t)addr[cpu->pc[thread]+1] << 8 - | (uint64_t)addr[cpu->pc[thread]+2] << 16 - | (uint64_t)addr[cpu->pc[thread]+3] << 24 - | (uint64_t)addr[cpu->pc[thread]+4] << 32 - | (uint64_t)addr[cpu->pc[thread]+5] << 40 - | (uint64_t)addr[cpu->pc[thread]+6] << 48 - | (uint64_t)addr[cpu->pc[thread]+7] << 56; - cpu->pc[thread]+=8; - iclk++; - } - if (opcode == 0x25) { - address = addr[cpu->pc[thread]] - | addr[cpu->pc[thread]+1] << 8 - | addr[cpu->pc[thread]+2] << 16 - | addr[cpu->pc[thread]+3] << 24; - cpu->pc[thread]+=4; - iclk++; - } - value = (uint64_t)addr[address]; - if (regsize >= 2) - value += (uint64_t)addr[address+1] << 8; - if (regsize >= 4) { - value += (uint64_t)addr[address+2] << 16; - value += (uint64_t)addr[address+3] << 24; - } - if (regsize >= 8) { - value += (uint64_t)addr[address+4] << 32; - value += (uint64_t)addr[address+5] << 40; - value += (uint64_t)addr[address+6] << 48; - value += (uint64_t)addr[address+7] << 56; - } + if (opcode == ABA) { + value = cpu->b[thread]; } cpu->a[thread] &= value; cpu->z[thread] = (value == 0); @@ -516,9 +578,6 @@ void *run(void *args) { (cpu->n[thread]) ? (cpu->ps |= (N << 8*thread)) : (cpu->ps &= ~(N << 8*thread)); break; case STT: /* STart Thread. */ - address = cpu->pc[thread]; - cpu->pc[thread]++; - value = addr[address]; cpu->crt |= value; for (uint8_t i = 0; i < 7; i++) { if ((value >> i) & 1) { @@ -536,25 +595,6 @@ void *run(void *args) { break; case BPO: /* BPO Absolute. */ case 0x64: /* BPO Zero Matrix. */ - if (opcode == BPO) { - address = (uint64_t)addr[cpu->pc[thread]] - | (uint64_t)addr[cpu->pc[thread]+1] << 8 - | (uint64_t)addr[cpu->pc[thread]+2] << 16 - | (uint64_t)addr[cpu->pc[thread]+3] << 24 - | (uint64_t)addr[cpu->pc[thread]+4] << 32 - | (uint64_t)addr[cpu->pc[thread]+5] << 40 - | (uint64_t)addr[cpu->pc[thread]+6] << 48 - | (uint64_t)addr[cpu->pc[thread]+7] << 56; - cpu->pc[thread]+=8; - iclk++; - } else { - address = addr[cpu->pc[thread]] - | addr[cpu->pc[thread]+1] << 8 - | addr[cpu->pc[thread]+2] << 16 - | addr[cpu->pc[thread]+3] << 24; - cpu->pc[thread]+=4; - iclk++; - } if (cpu->n[thread]) cpu->pc[thread] = address; break; @@ -562,45 +602,7 @@ void *run(void *args) { case OAB: /* bitwise Or with Accumulator, and B register. */ case 0x33: /* ORA Absolute. */ case 0x35: /* ORA Zero Matrix. */ - if (opcode != OAB) { - if (opcode == ORA) { - address = cpu->pc[thread]; - cpu->pc[thread]+=regsize; - } - if (opcode == 0x39) { - address = (uint64_t)addr[cpu->pc[thread]] - | (uint64_t)addr[cpu->pc[thread]+1] << 8 - | (uint64_t)addr[cpu->pc[thread]+2] << 16 - | (uint64_t)addr[cpu->pc[thread]+3] << 24 - | (uint64_t)addr[cpu->pc[thread]+4] << 32 - | (uint64_t)addr[cpu->pc[thread]+5] << 40 - | (uint64_t)addr[cpu->pc[thread]+6] << 48 - | (uint64_t)addr[cpu->pc[thread]+7] << 56; - cpu->pc[thread]+=8; - iclk++; - } - if (opcode == 0x3B) { - address = addr[cpu->pc[thread]] - | addr[cpu->pc[thread]+1] << 8 - | addr[cpu->pc[thread]+2] << 16 - | addr[cpu->pc[thread]+3] << 24; - cpu->pc[thread]+=4; - iclk++; - } - value = (uint64_t)addr[address]; - if (regsize >= 2) - value += (uint64_t)addr[address+1] << 8; - if (regsize >= 4) { - value += (uint64_t)addr[address+2] << 16; - value += (uint64_t)addr[address+3] << 24; - } - if (regsize >= 8) { - value += (uint64_t)addr[address+4] << 32; - value += (uint64_t)addr[address+5] << 40; - value += (uint64_t)addr[address+6] << 48; - value += (uint64_t)addr[address+7] << 56; - } - } else { + if (opcode == OAB) { value = cpu->b[thread]; } cpu->a[thread] |= value; @@ -615,25 +617,6 @@ void *run(void *args) { break; case BNG: /* BNG Absolute. */ case 0x74: /* BNG Zero Matrix. */ - if (opcode == BNG) { - address = (uint64_t)addr[cpu->pc[thread]] - | (uint64_t)addr[cpu->pc[thread]+1] << 8 - | (uint64_t)addr[cpu->pc[thread]+2] << 16 - | (uint64_t)addr[cpu->pc[thread]+3] << 24 - | (uint64_t)addr[cpu->pc[thread]+4] << 32 - | (uint64_t)addr[cpu->pc[thread]+5] << 40 - | (uint64_t)addr[cpu->pc[thread]+6] << 48 - | (uint64_t)addr[cpu->pc[thread]+7] << 56; - cpu->pc[thread]+=8; - iclk++; - } else { - address = addr[cpu->pc[thread]] - | addr[cpu->pc[thread]+1] << 8 - | addr[cpu->pc[thread]+2] << 16 - | addr[cpu->pc[thread]+3] << 24; - cpu->pc[thread]+=4; - iclk++; - } if (!cpu->n[thread]) cpu->pc[thread] = address; break; @@ -641,45 +624,7 @@ void *run(void *args) { case XAB: /* bitwise Xor with Accumulator, and B register. */ case 0x43: /* XOR Absolute. */ case 0x45: /* XOR Zero Matrix. */ - if (opcode != XAB) { - if (opcode == XOR) { - address = cpu->pc[thread]; - cpu->pc[thread]+=regsize; - } - if (opcode == 0x49) { - address = (uint64_t)addr[cpu->pc[thread]] - | (uint64_t)addr[cpu->pc[thread]+1] << 8 - | (uint64_t)addr[cpu->pc[thread]+2] << 16 - | (uint64_t)addr[cpu->pc[thread]+3] << 24 - | (uint64_t)addr[cpu->pc[thread]+4] << 32 - | (uint64_t)addr[cpu->pc[thread]+5] << 40 - | (uint64_t)addr[cpu->pc[thread]+6] << 48 - | (uint64_t)addr[cpu->pc[thread]+7] << 56; - cpu->pc[thread]+=8; - iclk++; - } - if (opcode == 0x4B) { - address = addr[cpu->pc[thread]] - | addr[cpu->pc[thread]+1] << 8 - | addr[cpu->pc[thread]+2] << 16 - | addr[cpu->pc[thread]+3] << 24; - cpu->pc[thread]+=4; - iclk++; - } - value = (uint64_t)addr[address]; - if (regsize >= 2) - value += (uint64_t)addr[address+1] << 8; - if (regsize >= 4) { - value += (uint64_t)addr[address+2] << 16; - value += (uint64_t)addr[address+3] << 24; - } - if (regsize >= 8) { - value += (uint64_t)addr[address+4] << 32; - value += (uint64_t)addr[address+5] << 40; - value += (uint64_t)addr[address+6] << 48; - value += (uint64_t)addr[address+7] << 56; - } - } else { + if (opcode == XAB) { value = cpu->b[thread]; } cpu->a[thread] ^= value; @@ -694,25 +639,6 @@ void *run(void *args) { break; case BCS: /* BCS Absolute. */ case 0x84: /* BCS Zero Matrix. */ - if (opcode == BCS) { - address = (uint64_t)addr[cpu->pc[thread]] - | (uint64_t)addr[cpu->pc[thread]+1] << 8 - | (uint64_t)addr[cpu->pc[thread]+2] << 16 - | (uint64_t)addr[cpu->pc[thread]+3] << 24 - | (uint64_t)addr[cpu->pc[thread]+4] << 32 - | (uint64_t)addr[cpu->pc[thread]+5] << 40 - | (uint64_t)addr[cpu->pc[thread]+6] << 48 - | (uint64_t)addr[cpu->pc[thread]+7] << 56; - cpu->pc[thread]+=8; - iclk++; - } else { - address = addr[cpu->pc[thread]] - | addr[cpu->pc[thread]+1] << 8 - | addr[cpu->pc[thread]+2] << 16 - | addr[cpu->pc[thread]+3] << 24; - cpu->pc[thread]+=4; - iclk++; - } if (cpu->c[thread]) cpu->pc[thread] = address; break; @@ -720,34 +646,7 @@ void *run(void *args) { case LLB: /* Logical shift Left accumulator by B. */ case 0x53: /* LSL Absolute. */ case 0x55: /* LSL Zero Matrix. */ - if (opcode != LLB) { - if (opcode == LSL) { - address = cpu->pc[thread]; - cpu->pc[thread]++; - } - if (opcode == 0x53) { - address = (uint64_t)addr[cpu->pc[thread]] - | (uint64_t)addr[cpu->pc[thread]+1] << 8 - | (uint64_t)addr[cpu->pc[thread]+2] << 16 - | (uint64_t)addr[cpu->pc[thread]+3] << 24 - | (uint64_t)addr[cpu->pc[thread]+4] << 32 - | (uint64_t)addr[cpu->pc[thread]+5] << 40 - | (uint64_t)addr[cpu->pc[thread]+6] << 48 - | (uint64_t)addr[cpu->pc[thread]+7] << 56; - - cpu->pc[thread]+=8; - iclk++; - } - if (opcode == 0x55) { - address = addr[cpu->pc[thread]] - | addr[cpu->pc[thread]+1] << 8 - | addr[cpu->pc[thread]+2] << 16 - | addr[cpu->pc[thread]+3] << 24; - cpu->pc[thread]+=4; - iclk++; - } - value = addr[address]; - } else { + if (opcode == LLB) { value = cpu->b[thread]; } sum = (value < 64) ? cpu->a[thread] << value : 0; @@ -767,69 +666,33 @@ void *run(void *args) { case STY: /* STY Absolute. */ case STX: /* STX Absolute. */ case STB: /* STB Absolute. */ - case 0x7B: /* STA Zero Matrix. */ - case 0x7D: /* STY Zero Matrix. */ - case 0x7E: /* STX Zero Matrix. */ - case 0x7F: /* STB Zero Matrix. */ - case 0x8B: /* STA Zero Matrix, Indexed with X. */ - case 0x8D: /* STY Zero Matrix, Indexed with X. */ - case 0x8F: /* STA Zero Matrix, Indexed with X. */ - case 0x9B: /* STA Zero Matrix, Indexed with Y. */ - case 0x9E: /* STX Zero Matrix, Indexed with Y. */ - case 0x9F: /* STA Zero Matrix, Indexed with Y. */ - case 0xAB: /* STA Indirect. */ - case 0xAD: /* STY Indirect. */ - case 0xAE: /* STX Indirect. */ - case 0xAF: /* STB Indirect. */ - case 0xBB: /* STA Indexed Indirect. */ - case 0xBD: /* STY Indexed Indirect. */ - case 0xBF: /* STB Indexed Indirect. */ - case 0xCB: /* STA Indirect Indexed. */ - case 0xCE: /* STX Indirect Indexed. */ - case 0xCF: /* STB Indirect Indexed. */ - if (opcode == STA || opcode == STY || opcode == STX || opcode == STB) { - address = (uint64_t)addr[cpu->pc[thread]] - | (uint64_t)addr[cpu->pc[thread]+1] << 8 - | (uint64_t)addr[cpu->pc[thread]+2] << 16 - | (uint64_t)addr[cpu->pc[thread]+3] << 24 - | (uint64_t)addr[cpu->pc[thread]+4] << 32 - | (uint64_t)addr[cpu->pc[thread]+5] << 40 - | (uint64_t)addr[cpu->pc[thread]+6] << 48 - | (uint64_t)addr[cpu->pc[thread]+7] << 56; - cpu->pc[thread]+=8; - iclk++; - } else { - address = addr[cpu->pc[thread]] - | addr[cpu->pc[thread]+1] << 8 - | addr[cpu->pc[thread]+2] << 16 - | addr[cpu->pc[thread]+3] << 24; - if (opcode == 0xAB || opcode == 0xAD || opcode == 0xAE || opcode == 0xAF || opcode == 0xBB || - opcode == 0xBD || opcode == 0xBF || opcode == 0xCB || opcode == 0xCE || opcode == 0xCF) { - address = (uint64_t)addr[address] - | (uint64_t)addr[address+1] << 8 - | (uint64_t)addr[address+2] << 16 - | (uint64_t)addr[address+3] << 24 - | (uint64_t)addr[address+4] << 32 - | (uint64_t)addr[address+5] << 40 - | (uint64_t)addr[address+6] << 48 - | (uint64_t)addr[address+7] << 56; - } - if (opcode == 0x8B || opcode == 0x8D || opcode == 0x8F || - opcode == 0xBB || opcode == 0xBD || opcode == 0xBF) - address += cpu->x[thread]; - if (opcode == 0x9B || opcode == 0x9E || opcode == 0x9F || - opcode == 0xCB || opcode == 0xCE || opcode == 0xCF) - address += cpu->y[thread]; - cpu->pc[thread]+=4; - iclk++; - } - if (opcode == STA || opcode == 0x7B || opcode == 0x8B || opcode == 0x9B) + case 0x49: /* STA Zero Matrix. */ + case 0x4A: /* STY Zero Matrix. */ + case 0x4B: /* STX Zero Matrix. */ + case 0x4E: /* STB Zero Matrix. */ + case 0x69: /* STA Zero Matrix, Indexed with X. */ + case 0x6A: /* STY Zero Matrix, Indexed with X. */ + case 0x6B: /* STX Zero Matrix, Indexed with Y. */ + case 0x6E: /* STB Zero Matrix, Indexed with X. */ + case 0x89: /* STA Zero Matrix, Indexed with Y. */ + case 0x8A: /* STY Indirect. */ + case 0x8B: /* STX Indirect. */ + case 0x8E: /* STB Zero Matrix, Indexed with Y. */ + case 0xA9: /* STA Indirect. */ + case 0xAA: /* STY Indexed Indirect. */ + case 0xAB: /* STX Indirect Indexed. */ + case 0xAE: /* STB Indirect. */ + case 0xC9: /* STA Indexed Indirect. */ + case 0xCE: /* STB Indexed Indirect. */ + case 0xE9: /* STA Indirect Indexed. */ + case 0xEE: /* STB Indirect Indexed. */ + if (opcode == STA || opcode == 0x49 || opcode == 0x69 || opcode == 0x89 || opcode == 0xA9 || opcode == 0xC9 || opcode == 0xE9) value = cpu->a[thread]; - if (opcode == STY || opcode == 0x7D || opcode == 0x8D) + if (opcode == STY || opcode == 0x4A || opcode == 0x6A || opcode == 0x8A || opcode == 0xAA) value = cpu->y[thread]; - if (opcode == STX || opcode == 0x7E || opcode == 0x9E) + if (opcode == STY || opcode == 0x4B || opcode == 0x6B || opcode == 0x8B || opcode == 0xAB) value = cpu->x[thread]; - if (opcode == STB || opcode == 0x7F || opcode == 0x8F || opcode == 0x9F) + if (opcode == STB || opcode == 0x4E || opcode == 0x6E || opcode == 0x8E || opcode == 0xAE || opcode == 0xCE || opcode == 0xEE) value = cpu->b[thread]; addr[address] = value & 0xFF; #if IO @@ -923,6 +786,7 @@ void *run(void *args) { #endif } #else + #if !bench if (address == TX_ADDR) { if (esc) { switch(addr[address]) { @@ -955,7 +819,8 @@ void *run(void *args) { x = 0; else x = ((bcd[1]*10) + bcd[0]); - mvwprintw(scr, getmaxy(scr)-25, 0, "x: %i, y: %i ", x, y); + mvwprintw(scr, 30, 0, "x: %i, y: %i ", x, y); + wrefresh(scr); idx = 3; bcd[0] = 0; bcd[1] = 0; @@ -997,6 +862,7 @@ void *run(void *args) { } } #endif + #endif if (regsize >= 2) addr[address+1] = value >> 8; if (regsize >= 4) { @@ -1012,25 +878,6 @@ void *run(void *args) { break; case BCC: /* BCC Absolute. */ case 0x94: /* BCC Zero Matrix. */ - if (opcode == BCC) { - address = (uint64_t)addr[cpu->pc[thread]] - | (uint64_t)addr[cpu->pc[thread]+1] << 8 - | (uint64_t)addr[cpu->pc[thread]+2] << 16 - | (uint64_t)addr[cpu->pc[thread]+3] << 24 - | (uint64_t)addr[cpu->pc[thread]+4] << 32 - | (uint64_t)addr[cpu->pc[thread]+5] << 40 - | (uint64_t)addr[cpu->pc[thread]+6] << 48 - | (uint64_t)addr[cpu->pc[thread]+7] << 56; - cpu->pc[thread]+=8; - iclk++; - } else { - address = addr[cpu->pc[thread]] - | addr[cpu->pc[thread]+1] << 8 - | addr[cpu->pc[thread]+2] << 16 - | addr[cpu->pc[thread]+3] << 24; - cpu->pc[thread]+=4; - iclk++; - } if (!cpu->c[thread]) cpu->pc[thread] = address; break; @@ -1038,46 +885,26 @@ void *run(void *args) { case LRB: /* Logical shift Right accumulator by B. */ case 0x63: /* LSR Absolute. */ case 0x65: /* LSR Zero Matrix. */ + if (opcode == LRB) { + value = cpu->b[thread]; + } + sum = (value < 64) ? cpu->a[thread] >> value : 0; + cpu->z[thread] = (sum == 0); + cpu->n[thread] = (sum >> 63); + cpu->c[thread] = cpu->a[thread] & 1; + cpu->a[thread] = sum; + (cpu->z[thread]) ? (cpu->ps |= (Z << 8*thread)) : (cpu->ps &= ~(Z << 8*thread)); + (cpu->n[thread]) ? (cpu->ps |= (N << 8*thread)) : (cpu->ps &= ~(N << 8*thread)); + (cpu->c[thread]) ? (cpu->ps |= (C << 8*thread)) : (cpu->ps &= ~(C << 8*thread)); + break; case ASR: /* ASR Immediate. */ case ARB: /* Arithmetic shift Right accumulator by B. */ case 0xE3: /* ASR Absolute. */ case 0xE5: /* ASR Zero Matrix. */ - if (opcode != LRB || opcode != ARB) { - if (opcode == LSR || opcode == ASR) { - address = cpu->pc[thread]; - cpu->pc[thread]++; - } - if (opcode == 0x63 || opcode == 0xE3) { - address = (uint64_t)addr[cpu->pc[thread]] - | (uint64_t)addr[cpu->pc[thread]+1] << 8 - | (uint64_t)addr[cpu->pc[thread]+2] << 16 - | (uint64_t)addr[cpu->pc[thread]+3] << 24 - | (uint64_t)addr[cpu->pc[thread]+4] << 32 - | (uint64_t)addr[cpu->pc[thread]+5] << 40 - | (uint64_t)addr[cpu->pc[thread]+6] << 48 - | (uint64_t)addr[cpu->pc[thread]+7] << 56; - cpu->pc[thread]+=8; - iclk++; - } - if (opcode == 0x65 || opcode == 0xE5) { - address = addr[cpu->pc[thread]] - | addr[cpu->pc[thread]+1] << 8 - | addr[cpu->pc[thread]+2] << 16 - | addr[cpu->pc[thread]+3] << 24; - cpu->pc[thread]+=4; - iclk++; - } - value = addr[address]; - } else { + if (opcode == ARB) value = cpu->b[thread]; - } - if (opcode == ASR || opcode == ARB || opcode == 0xE3 || opcode == 0xE5) { - sign = cpu->a[thread] & 0x8000000000000000; - sum = (value < 64) ? (cpu->a[thread] >> value) | sign : 0; - } - if (opcode == LSR || opcode == LRB || opcode == 0x63 || opcode == 0x65) { - sum = (value < 64) ? cpu->a[thread] >> value : 0; - } + sign = cpu->a[thread] & 0x8000000000000000; + sum = (value < 64) ? (cpu->a[thread] >> value) | sign : 0; cpu->z[thread] = (sum == 0); cpu->n[thread] = (sum >> 63); cpu->c[thread] = cpu->a[thread] & 1; @@ -1090,73 +917,34 @@ void *run(void *args) { cpu->c[thread] = 0; (cpu->ps &= ~(C << 8*thread)); break; - case 0x56: /* LDB Absolute. */ - case 0x59: /* LDA Absolute. */ - case 0x5A: /* LDY Absolute. */ - case 0x5C: /* LDX Absolute. */ case LDB: /* LDB Immediate. */ case LDA: /* LDA Immediate. */ case LDY: /* LDY Immediate. */ case LDX: /* LDX Immediate. */ - case 0x76: /* LDB Zero Matrix. */ - case 0x79: /* LDA Zero Matrix. */ - case 0x7A: /* LDY Zero Matrix. */ - case 0x7C: /* LDX Zero Matrix. */ - case 0x86: /* LDB Zero Matrix, Indexed with X. */ - case 0x89: /* LDA Zero Matrix, Indexed with X. */ - case 0x8A: /* LDY Zero Matrix, Indexed with X. */ - case 0x96: /* LDB Zero Matrix, Indexed with Y. */ - case 0x99: /* LDA Zero Matrix, Indexed with Y. */ - case 0x9C: /* LDX Zero Matrix, Indexed with Y. */ - case 0xA6: /* LDB Indirect. */ - case 0xA9: /* LDA Indirect. */ - case 0xAA: /* LDY Indirect. */ - case 0xAC: /* LDX Indirect. */ - case 0xB6: /* LDB Indexed Indirect. */ + case 0x1E: /* LDB Absolute. */ + case 0x19: /* LDA Absolute. */ + case 0x1A: /* LDY Absolute. */ + case 0x1B: /* LDX Absolute. */ + case 0x3E: /* LDB Zero Matrix. */ + case 0x39: /* LDA Zero Matrix. */ + case 0x3A: /* LDY Zero Matrix. */ + case 0x3B: /* LDX Zero Matrix. */ + case 0x5E: /* LDB Zero Matrix, Indexed with X. */ + case 0x59: /* LDA Zero Matrix, Indexed with X. */ + case 0x5A: /* LDY Zero Matrix, Indexed with X. */ + case 0x5B: /* LDX Zero Matrix, Indexed with Y. */ + case 0x7E: /* LDB Zero Matrix, Indexed with Y. */ + case 0x79: /* LDA Zero Matrix, Indexed with Y. */ + case 0x7A: /* LDY Indirect. */ + case 0x7B: /* LDX Indirect. */ + case 0x9E: /* LDB Indirect. */ + case 0x99: /* LDA Indirect. */ + case 0x9A: /* LDY Indexed Indirect. */ + case 0x9B: /* LDX Indirect Indexed. */ + case 0xBE: /* LDB Indexed Indirect. */ case 0xB9: /* LDA Indexed Indirect. */ - case 0xBA: /* LDY Indexed Indirect. */ - case 0xC6: /* LDB Indirect Indexed. */ - case 0xC9: /* LDA Indirect Indexed. */ - case 0xCC: /* LDX Indirect Indexed. */ - if (opcode == LDB || opcode == LDA || opcode == LDY || opcode == LDX) { - address = cpu->pc[thread]; - cpu->pc[thread]+=regsize; - } else if (opcode == 0x56 || opcode == 0x59 || opcode == 0x5A || opcode == 0x5C) { - address = (uint64_t)addr[cpu->pc[thread]] - | (uint64_t)addr[cpu->pc[thread]+1] << 8 - | (uint64_t)addr[cpu->pc[thread]+2] << 16 - | (uint64_t)addr[cpu->pc[thread]+3] << 24 - | (uint64_t)addr[cpu->pc[thread]+4] << 32 - | (uint64_t)addr[cpu->pc[thread]+5] << 40 - | (uint64_t)addr[cpu->pc[thread]+6] << 48 - | (uint64_t)addr[cpu->pc[thread]+7] << 56; - cpu->pc[thread]+=8; - iclk++; - } else { - address = addr[cpu->pc[thread]] - | addr[cpu->pc[thread]+1] << 8 - | addr[cpu->pc[thread]+2] << 16 - | addr[cpu->pc[thread]+3] << 24; - if (opcode == 0xA6 || opcode == 0xA9 || opcode == 0xAA || opcode == 0xAC || opcode == 0xB6 || - opcode == 0xB9 || opcode == 0xBA || opcode == 0xC6 || opcode == 0xC9 || opcode == 0xCC) { - address = (uint64_t)addr[address] - | (uint64_t)addr[address+1] << 8 - | (uint64_t)addr[address+2] << 16 - | (uint64_t)addr[address+3] << 24 - | (uint64_t)addr[address+4] << 32 - | (uint64_t)addr[address+5] << 40 - | (uint64_t)addr[address+6] << 48 - | (uint64_t)addr[address+7] << 56; - } - if (opcode == 0x86 || opcode == 0x89 || opcode == 0x8A || - opcode == 0xB6 || opcode == 0xB9 || opcode == 0xBA) - address += cpu->x[thread]; - if (opcode == 0x96 || opcode == 0x99 || opcode == 0x9C || - opcode == 0xC6 || opcode == 0xC9 || opcode == 0xCC) - address += cpu->y[thread]; - cpu->pc[thread]+=4; - iclk++; - } + case 0xDE: /* LDB Indirect Indexed. */ + case 0xD9: /* LDA Indirect Indexed. */ if (address == CTRL_ADDR) { pthread_mutex_lock(&main_mutex); pthread_cond_signal(&main_cond); @@ -1180,13 +968,13 @@ void *run(void *args) { value += (uint64_t)addr[address+6] << 48; value += (uint64_t)addr[address+7] << 56; } - if (opcode == LDB || opcode == 0x56 || opcode == 0x76 || opcode == 0x86 || opcode == 0x96) + if (opcode == LDB || opcode == 0x1E || opcode == 0x3E || opcode == 0x5E || opcode == 0x7E || opcode == 0x9E || opcode == 0xBE || opcode == 0xDE) cpu->b[thread] = value; - if (opcode == LDA || opcode == 0x59 || opcode == 0x79 || opcode == 0x89 || opcode == 0x99) + if (opcode == LDA || opcode == 0x19 || opcode == 0x39 || opcode == 0x59 || opcode == 0x79 || opcode == 0x99 || opcode == 0xB9 || opcode == 0xD9) cpu->a[thread] = value; - if (opcode == LDY || opcode == 0x5A || opcode == 0x7A || opcode == 0x8A) + if (opcode == LDY || opcode == 0x1A || opcode == 0x3A || opcode == 0x5A || opcode == 0x7A || opcode == 0x9A) cpu->y[thread] = value; - if (opcode == LDX || opcode == 0x5C || opcode == 0x7C || opcode == 0x9C) + if (opcode == LDX || opcode == 0x1B || opcode == 0x3B || opcode == 0x5B || opcode == 0x7B || opcode == 0x9B) cpu->x[thread] = value; cpu->z[thread] = (value == 0); cpu->n[thread] = (value >> 63); @@ -1195,25 +983,6 @@ void *run(void *args) { break; case BEQ: /* BEQ Absolute. */ case 0xA4: /* BEQ Zero Matrix. */ - if (opcode == BEQ) { - address = (uint64_t)addr[cpu->pc[thread]] - | (uint64_t)addr[cpu->pc[thread]+1] << 8 - | (uint64_t)addr[cpu->pc[thread]+2] << 16 - | (uint64_t)addr[cpu->pc[thread]+3] << 24 - | (uint64_t)addr[cpu->pc[thread]+4] << 32 - | (uint64_t)addr[cpu->pc[thread]+5] << 40 - | (uint64_t)addr[cpu->pc[thread]+6] << 48 - | (uint64_t)addr[cpu->pc[thread]+7] << 56; - cpu->pc[thread]+=8; - iclk++; - } else { - address = addr[cpu->pc[thread]] - | addr[cpu->pc[thread]+1] << 8 - | addr[cpu->pc[thread]+2] << 16 - | addr[cpu->pc[thread]+3] << 24; - cpu->pc[thread]+=4; - iclk++; - } if (cpu->z[thread]) cpu->pc[thread] = address; break; @@ -1221,33 +990,7 @@ void *run(void *args) { case RLB: /* Rotate Left accumulator by B. */ case 0x73: /* ROL Absolute. */ case 0x75: /* ROL Zero Matrix. */ - if (opcode != RLB) { - if (opcode == ROL) { - address = cpu->pc[thread]; - cpu->pc[thread]++; - } - if (opcode == 0x73) { - address = (uint64_t)addr[cpu->pc[thread]] - | (uint64_t)addr[cpu->pc[thread]+1] << 8 - | (uint64_t)addr[cpu->pc[thread]+2] << 16 - | (uint64_t)addr[cpu->pc[thread]+3] << 24 - | (uint64_t)addr[cpu->pc[thread]+4] << 32 - | (uint64_t)addr[cpu->pc[thread]+5] << 40 - | (uint64_t)addr[cpu->pc[thread]+6] << 48 - | (uint64_t)addr[cpu->pc[thread]+7] << 56; - cpu->pc[thread]+=8; - iclk++; - } - if (opcode == 0x75) { - address = addr[cpu->pc[thread]] - | addr[cpu->pc[thread]+1] << 8 - | addr[cpu->pc[thread]+2] << 16 - | addr[cpu->pc[thread]+3] << 24; - cpu->pc[thread]+=4; - iclk++; - } - value = addr[address]; - } else { + if (opcode == RLB) { value = cpu->b[thread]; } sum = cpu->a[thread] << value; @@ -1266,25 +1009,6 @@ void *run(void *args) { break; case BNE: /* BNE Absolute. */ case 0xB4: /* BNE Zero Matrix. */ - if (opcode == BNE) { - address = (uint64_t)addr[cpu->pc[thread]] - | (uint64_t)addr[cpu->pc[thread]+1] << 8 - | (uint64_t)addr[cpu->pc[thread]+2] << 16 - | (uint64_t)addr[cpu->pc[thread]+3] << 24 - | (uint64_t)addr[cpu->pc[thread]+4] << 32 - | (uint64_t)addr[cpu->pc[thread]+5] << 40 - | (uint64_t)addr[cpu->pc[thread]+6] << 48 - | (uint64_t)addr[cpu->pc[thread]+7] << 56; - cpu->pc[thread]+=8; - iclk++; - } else { - address = addr[cpu->pc[thread]] - | addr[cpu->pc[thread]+1] << 8 - | addr[cpu->pc[thread]+2] << 16 - | addr[cpu->pc[thread]+3] << 24; - cpu->pc[thread]+=4; - iclk++; - } if (!cpu->z[thread]) cpu->pc[thread] = address; break; @@ -1292,33 +1016,7 @@ void *run(void *args) { case RRB: /* Rotate Right accumulator by B. */ case 0x83: /* ROR Absolute. */ case 0x85: /* ROR Zero Matrix. */ - if (opcode != RRB) { - if (opcode == ROR) { - address = cpu->pc[thread]; - cpu->pc[thread]++; - } - if (opcode == 0x83) { - address = (uint64_t)addr[cpu->pc[thread]] - | (uint64_t)addr[cpu->pc[thread]+1] << 8 - | (uint64_t)addr[cpu->pc[thread]+2] << 16 - | (uint64_t)addr[cpu->pc[thread]+3] << 24 - | (uint64_t)addr[cpu->pc[thread]+4] << 32 - | (uint64_t)addr[cpu->pc[thread]+5] << 40 - | (uint64_t)addr[cpu->pc[thread]+6] << 48 - | (uint64_t)addr[cpu->pc[thread]+7] << 56; - cpu->pc[thread]+=8; - iclk++; - } - if (opcode == 0x85) { - address = addr[cpu->pc[thread]] - | addr[cpu->pc[thread]+1] << 8 - | addr[cpu->pc[thread]+2] << 16 - | addr[cpu->pc[thread]+3] << 24; - cpu->pc[thread]+=4; - iclk++; - } - value = addr[address]; - } else { + if (opcode == RRB) { value = cpu->b[thread]; } sum = cpu->a[thread] >> value; @@ -1337,25 +1035,6 @@ void *run(void *args) { break; case BVS: /* BVS Absolute. */ case 0xC4: /* BVS Zero Matrix. */ - if (opcode == BVS) { - address = (uint64_t)addr[cpu->pc[thread]] - | (uint64_t)addr[cpu->pc[thread]+1] << 8 - | (uint64_t)addr[cpu->pc[thread]+2] << 16 - | (uint64_t)addr[cpu->pc[thread]+3] << 24 - | (uint64_t)addr[cpu->pc[thread]+4] << 32 - | (uint64_t)addr[cpu->pc[thread]+5] << 40 - | (uint64_t)addr[cpu->pc[thread]+6] << 48 - | (uint64_t)addr[cpu->pc[thread]+7] << 56; - cpu->pc[thread]+=8; - iclk++; - } else { - address = addr[cpu->pc[thread]] - | addr[cpu->pc[thread]+1] << 8 - | addr[cpu->pc[thread]+2] << 16 - | addr[cpu->pc[thread]+3] << 24; - cpu->pc[thread]+=4; - iclk++; - } if (cpu->v[thread]) cpu->pc[thread] = address; break; @@ -1363,46 +1042,7 @@ void *run(void *args) { case MAB: /* Multiply Accumulator by B. */ case 0x93: /* MUL Absolute. */ case 0x95: /* MUL Zero Matrix. */ - if (opcode != MAB) { - if (opcode == MUL) { - address = cpu->pc[thread]; - cpu->pc[thread]+=regsize; - } - if (opcode == 0x93) { - address = (uint64_t)addr[cpu->pc[thread]] - | (uint64_t)addr[cpu->pc[thread]+1] << 8 - | (uint64_t)addr[cpu->pc[thread]+2] << 16 - | (uint64_t)addr[cpu->pc[thread]+3] << 24 - | (uint64_t)addr[cpu->pc[thread]+4] << 32 - | (uint64_t)addr[cpu->pc[thread]+5] << 40 - | (uint64_t)addr[cpu->pc[thread]+6] << 48 - | (uint64_t)addr[cpu->pc[thread]+7] << 56; - cpu->pc[thread]+=8; - iclk++; - } - if (opcode == 0x95) { - address = addr[cpu->pc[thread]] - | addr[cpu->pc[thread]+1] << 8 - | addr[cpu->pc[thread]+2] << 16 - | addr[cpu->pc[thread]+3] << 24; - cpu->pc[thread]+=4; - iclk++; - } - value = addr[address]; - if (regsize >= 2) { - value += (uint64_t)addr[address+1] << 8; - } - if (regsize >= 4) { - value += (uint64_t)addr[address+2] << 16; - value += (uint64_t)addr[address+3] << 24; - } - if (regsize >= 8) { - value += (uint64_t)addr[address+4] << 32; - value += (uint64_t)addr[address+5] << 40; - value += (uint64_t)addr[address+6] << 48; - value += (uint64_t)addr[address+7] << 56; - } - } else { + if (opcode == MAB) { value = cpu->b[thread]; } sum = cpu->a[thread]*value+cpu->c[thread]; @@ -1422,25 +1062,6 @@ void *run(void *args) { break; case BVC: /* BVC Absolute. */ case 0xD4: /* BVC Zero Matrix. */ - if (opcode == BVC) { - address = (uint64_t)addr[cpu->pc[thread]] - | (uint64_t)addr[cpu->pc[thread]+1] << 8 - | (uint64_t)addr[cpu->pc[thread]+2] << 16 - | (uint64_t)addr[cpu->pc[thread]+3] << 24 - | (uint64_t)addr[cpu->pc[thread]+4] << 32 - | (uint64_t)addr[cpu->pc[thread]+5] << 40 - | (uint64_t)addr[cpu->pc[thread]+6] << 48 - | (uint64_t)addr[cpu->pc[thread]+7] << 56; - cpu->pc[thread]+=8; - iclk++; - } else { - address = addr[cpu->pc[thread]] - | addr[cpu->pc[thread]+1] << 8 - | addr[cpu->pc[thread]+2] << 16 - | addr[cpu->pc[thread]+3] << 24; - cpu->pc[thread]+=4; - iclk++; - } if (!cpu->v[thread]) cpu->pc[thread] = address; break; @@ -1449,44 +1070,6 @@ void *run(void *args) { case 0xA3: /* DIV Absolute. */ case 0xA5: /* DIV Zero Matrix. */ if (opcode != DAB) { - if (opcode == DIV) { - address = cpu->pc[thread]; - cpu->pc[thread]+=regsize; - } - if (opcode == 0xA3) { - address = (uint64_t)addr[cpu->pc[thread]] - | (uint64_t)addr[cpu->pc[thread]+1] << 8 - | (uint64_t)addr[cpu->pc[thread]+2] << 16 - | (uint64_t)addr[cpu->pc[thread]+3] << 24 - | (uint64_t)addr[cpu->pc[thread]+4] << 32 - | (uint64_t)addr[cpu->pc[thread]+5] << 40 - | (uint64_t)addr[cpu->pc[thread]+6] << 48 - | (uint64_t)addr[cpu->pc[thread]+7] << 56; - cpu->pc[thread]+=8; - iclk++; - } - if (opcode == 0xA5) { - address = addr[cpu->pc[thread]] - | addr[cpu->pc[thread]+1] << 8 - | addr[cpu->pc[thread]+2] << 16 - | addr[cpu->pc[thread]+3] << 24; - cpu->pc[thread]+=4; - iclk++; - } - value = addr[address]; - if (regsize >= 2) { - value += (uint64_t)addr[address+1] << 8; - } - if (regsize >= 4) { - value += (uint64_t)addr[address+2] << 16; - value += (uint64_t)addr[address+3] << 24; - } - if (regsize >= 8) { - value += (uint64_t)addr[address+4] << 32; - value += (uint64_t)addr[address+5] << 40; - value += (uint64_t)addr[address+6] << 48; - value += (uint64_t)addr[address+7] << 56; - } cpu->b[thread] = cpu->a[thread] % value; } else { value = cpu->b[thread]; @@ -1504,7 +1087,11 @@ void *run(void *args) { (cpu->ps &= ~(V << 8*thread)); break; case RTS: /* ReTurn from Subroutine. */ - for (uint8_t i = 0; i < 32; i+=8) { + if (addrsize) + stksize = 32; + else + stksize = 8; + for (uint8_t i = 0; i < stksize; i+=8) { cpu->sp[thread]++; if (i) cpu->pc[thread] += addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] << i; @@ -1517,93 +1104,46 @@ void *run(void *args) { case CAB: /* Compare Accumulator, and B. */ case CPY: /* CPY Immediate. */ case CPX: /* CPX Immediate. */ - case 0x2B: /* CPY Absolute. */ - case 0x2D: /* CPX Absolute. */ + case 0xCA: /* CPY Absolute. */ + case 0xCB: /* CPX Absolute. */ case 0xB3: /* CMP Absolute. */ - case 0xE6: /* CPB Absolute. */ - case 0x3B: /* CPY Zero Matrix. */ - case 0x3D: /* CPX Zero Matrix. */ + case 0x36: /* CPB Absolute. */ + case 0xDA: /* CPY Zero Matrix. */ + case 0xDB: /* CPX Zero Matrix. */ case 0xB5: /* CMP Zero Matrix. */ - case 0xF6: /* CPB Zero Matrix. */ - case 0xE9: /* CMP Indirect. */ + case 0x46: /* CPB Zero Matrix. */ + case 0xF1: /* CMP Indirect. */ case 0xEA: /* CPY Indirect. */ - case 0xEC: /* CPX Indirect. */ - case 0xDF: /* CPB Indirect. */ - case 0xEB: /* CMP Indexed Indirect. */ + case 0xEB: /* CPX Indirect. */ + case 0x56: /* CPB Indirect. */ + case 0xF3: /* CMP Indexed Indirect. */ case 0xFA: /* CPY Indexed Indirect. */ - case 0xEF: /* CPB Indexed Indirect. */ - case 0xED: /* CMP Indirect Indexed. */ - case 0xFC: /* CPX Indirect Indexed. */ - case 0xFF: /* CPB Indirect Indexed. */ - if (opcode != CAB) { - if (opcode == CMP || opcode == CPY || opcode == CPX || opcode == CPB) { - address = cpu->pc[thread]; - cpu->pc[thread]+=regsize; - } else if (opcode == 0xB3 || opcode == 0x2B || opcode == 0x2D) { - address = (uint64_t)addr[cpu->pc[thread]] - | (uint64_t)addr[cpu->pc[thread]+1] << 8 - | (uint64_t)addr[cpu->pc[thread]+2] << 16 - | (uint64_t)addr[cpu->pc[thread]+3] << 24 - | (uint64_t)addr[cpu->pc[thread]+4] << 32 - | (uint64_t)addr[cpu->pc[thread]+5] << 40 - | (uint64_t)addr[cpu->pc[thread]+6] << 48 - | (uint64_t)addr[cpu->pc[thread]+7] << 56; - cpu->pc[thread]+=8; - iclk++; - } else { - address = addr[cpu->pc[thread]] - | addr[cpu->pc[thread]+1] << 8 - | addr[cpu->pc[thread]+2] << 16 - | addr[cpu->pc[thread]+3] << 24; - if (opcode == 0xDF || opcode == 0xE9 || opcode == 0xEA || opcode == 0xEB || opcode == 0xEC || - opcode == 0xED || opcode == 0xEF || opcode == 0xFA || opcode == 0xFC || opcode == 0xFF) { - address = (uint64_t)addr[address] - | (uint64_t)addr[address+1] << 8 - | (uint64_t)addr[address+2] << 16 - | (uint64_t)addr[address+3] << 24 - | (uint64_t)addr[address+4] << 32 - | (uint64_t)addr[address+5] << 40 - | (uint64_t)addr[address+6] << 48 - | (uint64_t)addr[address+7] << 56; - if (opcode == 0xEB || opcode == 0xEF || opcode == 0xFA) - address += cpu->x[thread]; - if (opcode == 0xED || opcode == 0xFC || opcode == 0xFF) - address += cpu->y[thread]; - } - cpu->pc[thread]+=4; - iclk++; - } - value = (uint64_t)addr[address]; - if (regsize >= 2) - value += (uint64_t)addr[address+1] << 8; - if (regsize >= 4) { - value += (uint64_t)addr[address+2] << 16; - value += (uint64_t)addr[address+3] << 24; - } - if (regsize >= 8) { - value += (uint64_t)addr[address+4] << 32; - value += (uint64_t)addr[address+5] << 40; - value += (uint64_t)addr[address+6] << 48; - value += (uint64_t)addr[address+7] << 56; - } - } else { + case 0x66: /* CPB Indexed Indirect. */ + case 0xF5: /* CMP Indirect Indexed. */ + case 0xFB: /* CPX Indirect Indexed. */ + case 0x76: /* CPB Indirect Indexed. */ + if (opcode == CAB) { value = cpu->b[thread]; } - if (opcode == CMP || opcode == CAB || opcode == 0xE5 || opcode == 0xF5) - sum = cpu->a[thread]-value; - if (opcode == CPY || opcode == 0xE2 || opcode == 0xF2) - sum = cpu->y[thread]-value; - if (opcode == CPX || opcode == 0xE4 || opcode == 0xF4) - sum = cpu->x[thread]-value; + if (opcode == CPB || opcode == 0x36 || opcode == 0x46 || opcode == 0x56 || opcode == 0x66 || opcode == 0x76) + reg = cpu->b[thread]; + if (opcode == CMP || opcode == CAB || opcode == 0xB3 || opcode == 0xB5 || opcode == 0xF1 || opcode == 0xF3 || opcode == 0xF5) + reg = cpu->a[thread]; + if (opcode == CPY || opcode == 0xCA || opcode == 0xDA || opcode == 0xEA || opcode == 0xFA) + reg = cpu->y[thread]; + if (opcode == CPX || opcode == 0xCB || opcode == 0xDB || opcode == 0xEB || opcode == 0xFB) + reg = cpu->x[thread]; + sum = reg-value; cpu->n[thread] = (sum & 0x8000000000000000) ? 1 : 0; + cpu->v[thread] = ((reg^value) & 0x8000000000000000) && ((reg^sum) & 0x8000000000000000); cpu->z[thread] = (sum == 0) ? 1 : 0; cpu->c[thread] = (sum > value) ? 1 : 0; - (cpu->z[thread]) ? (cpu->ps |= (Z << 8*thread)) : (cpu->ps &= ~(Z << 8*thread)); (cpu->n[thread]) ? (cpu->ps |= (N << 8*thread)) : (cpu->ps &= ~(N << 8*thread)); + (cpu->v[thread]) ? (cpu->ps |= (V << 8*thread)) : (cpu->ps &= ~(V << 8*thread)); + (cpu->z[thread]) ? (cpu->ps |= (Z << 8*thread)) : (cpu->ps &= ~(Z << 8*thread)); (cpu->c[thread]) ? (cpu->ps |= (C << 8*thread)) : (cpu->ps &= ~(C << 8*thread)); break; case ENT: /* ENd Thread. */ - value = addr[address]; cpu->crt &= ~value; for (uint8_t i = 0; i < 7; i++) if ((value >> i) & 1) @@ -1648,27 +1188,6 @@ void *run(void *args) { case 0x14: /* JMP Indexed Indirect. */ case 0x24: /* JMP Indirect Indexed. */ case 0xD0: /* JMP Zero Matrix. */ - address = (uint32_t)addr[cpu->pc[thread]] - |(uint32_t)addr[cpu->pc[thread]+1] << 8 - |(uint32_t)addr[cpu->pc[thread]+2] << 16 - |(uint32_t)addr[cpu->pc[thread]+3] << 24; - - if (opcode == 0x04 || opcode == 0x14 || opcode == 0x24) { - address = (uint64_t)addr[address] - | (uint64_t)addr[address+1] << 8 - | (uint64_t)addr[address+2] << 16 - | (uint64_t)addr[address+3] << 24 - | (uint64_t)addr[address+4] << 32 - | (uint64_t)addr[address+5] << 40 - | (uint64_t)addr[address+6] << 48 - | (uint64_t)addr[address+7] << 56; - if (opcode == 0x14) - address += cpu->x[thread]; - if (opcode == 0x24) - address += cpu->y[thread]; - } - cpu->pc[thread]+=4; - iclk++; cpu->pc[thread] = address; break; @@ -1697,16 +1216,11 @@ void *run(void *args) { (cpu->n[thread]) ? (cpu->ps |= (N << 8*thread)) : (cpu->ps &= ~(N << 8*thread)); break; case JSL: /* Jump to Subroutine Long. */ - address = (uint64_t)addr[cpu->pc[thread]] - | (uint64_t)addr[cpu->pc[thread]+1] << 8 - | (uint64_t)addr[cpu->pc[thread]+2] << 16 - | (uint64_t)addr[cpu->pc[thread]+3] << 24 - | (uint64_t)addr[cpu->pc[thread]+4] << 32 - | (uint64_t)addr[cpu->pc[thread]+5] << 40 - | (uint64_t)addr[cpu->pc[thread]+6] << 48 - | (uint64_t)addr[cpu->pc[thread]+7] << 56; - cpu->pc[thread]+=8; - for (int8_t i = 56; i >= 0; i-=8) { + if (addrsize) + stksize = 56; + else + stksize = 8; + for (int8_t i = stksize; i >= 0; i-=8) { if (i) addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] = (uint64_t)cpu->pc[thread] >> i; else @@ -1717,63 +1231,25 @@ void *run(void *args) { break; case 0xC3: /* INC Absolute. */ case 0xC5: /* INC Zero Matrix. */ - if (opcode == 0xC3) { - address = (uint64_t)addr[cpu->pc[thread]] - | (uint64_t)addr[cpu->pc[thread]+1] << 8 - | (uint64_t)addr[cpu->pc[thread]+2] << 16 - | (uint64_t)addr[cpu->pc[thread]+3] << 24 - | (uint64_t)addr[cpu->pc[thread]+4] << 32 - | (uint64_t)addr[cpu->pc[thread]+5] << 40 - | (uint64_t)addr[cpu->pc[thread]+6] << 48 - | (uint64_t)addr[cpu->pc[thread]+7] << 56; - cpu->pc[thread]+=8; - iclk++; - } - if (opcode == 0xC5) { - address = addr[cpu->pc[thread]] - | addr[cpu->pc[thread]+1] << 8 - | addr[cpu->pc[thread]+2] << 16 - | addr[cpu->pc[thread]+3] << 24; - cpu->pc[thread]+=4; - iclk++; - } addr[address]++; break; case NOP: /* No OPeration. */ break; case RTL: /* ReTurn from subroutine Long. */ - for (uint8_t i = 0; i < 64; i+=8) { + if (addrsize) + stksize = 64; + else + stksize = 16; + for (uint8_t i = 0; i < stksize; i+=8) { cpu->sp[thread]++; - if (i < 56) - cpu->pc[thread] = addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] << i; - else if (i == 56) - cpu->pc[thread] = addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] << i + 1; + if (i) + cpu->pc[thread] += addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]] << i; else cpu->pc[thread] = addr[(cpu->stk_st[thread] << 16)+cpu->sp[thread]]; } break; case 0xD3: /* DEC Absolute. */ case 0xD5: /* DEC Zero Matrix. */ - if (opcode == 0xD3) { - address = (uint64_t)addr[cpu->pc[thread]] - | (uint64_t)addr[cpu->pc[thread]+1] << 8 - | (uint64_t)addr[cpu->pc[thread]+2] << 16 - | (uint64_t)addr[cpu->pc[thread]+3] << 24 - | (uint64_t)addr[cpu->pc[thread]+4] << 32 - | (uint64_t)addr[cpu->pc[thread]+5] << 40 - | (uint64_t)addr[cpu->pc[thread]+6] << 48 - | (uint64_t)addr[cpu->pc[thread]+7] << 56; - cpu->pc[thread]+=8; - iclk++; - } - if (opcode == 0xD5) { - address = addr[cpu->pc[thread]] - | addr[cpu->pc[thread]+1] << 8 - | addr[cpu->pc[thread]+2] << 16 - | addr[cpu->pc[thread]+3] << 24; - cpu->pc[thread]+=4; - iclk++; - } addr[address]--; break; case BRK: /* BReaK. */ @@ -1810,18 +1286,17 @@ void *run(void *args) { break; } ins++; - usleep(100000); #if debug && !bench #if keypoll pthread_mutex_lock(&mutex); #endif - mvwprintw(scr, getmaxy(scr)-lines, 0, "Operand: $%llx" + /*mvwprintw(scr, getmaxy(scr)-lines, 0, "Operand: $%llx" ", $%04llx: $%02x, $%04llx: $%02x" ", $1000: $%02x, $1001: $%02x " , value , RX_ADDR, addr[RX_ADDR], TX_ADDR, addr[TX_ADDR] - , addr[0x1000], addr[0x1001]); - mvwprintw(scr, (24*thread)+1, 0, "Instructions executed: %llu, Clock cycles: %llu\r", ins, iclk); + , addr[0x1000], addr[0x1001]);*/ + mvwprintw(scr, (6*thread)+1, 0, "Instructions executed: %llu, Clock cycles: %llu\r", ins, iclk); wrefresh(scr); #if keypoll pthread_mutex_unlock(&mutex); @@ -1830,12 +1305,12 @@ void *run(void *args) { #if bench if (ins >= BENCH_INST) { end = 1; - pthread_mutex_lock(&mutex); + pthread_mutex_lock(&main_mutex); threads_done++; inst[thread] = ins; clk[thread] = iclk; pthread_cond_signal(&main_cond); - pthread_mutex_unlock(&mutex); + pthread_mutex_unlock(&main_mutex); gettimeofday(&en[thread], 0); } #endif @@ -1861,6 +1336,7 @@ int main(int argc, char **argv) { sprintf(tmp, "\033[2J\033[H"); fwrite(tmp, sizeof(char), strlen(tmp), stdout); fflush(stdout); +#if !bench if(!scr) scr = initscr(); nodelay(stdscr, 0); @@ -1876,11 +1352,13 @@ int main(int argc, char **argv) { init_pair(1, COLOR_WHITE, -1); attron(COLOR_PAIR(1) | A_BOLD); wmove(scr, 0, 0); +#endif for (int i = 0; i < THREADS; i++) { thr[i].sx.sp[i] = 0xFFFF; thr[i].sx.stk_st[i] = i+1; if (i) { thr[i].sx.a[i] = 0; + thr[i].sx.b[i] = 0; thr[i].sx.x[i] = 0; thr[i].sx.y[i] = 0; thr[i].sx.pc[i] = (uint64_t)addr[0xFF50+(8*(i-1))] @@ -1893,6 +1371,7 @@ int main(int argc, char **argv) { | (uint64_t)addr[0xFF57+(8*(i-1))] << 56; } else { thr[i].sx.a[i] = 0; + thr[i].sx.b[i] = 0; thr[i].sx.x[i] = 0; thr[i].sx.y[i] = 0; thr[i].sx.pc[i] = (uint64_t)addr[0xFFC0] @@ -1916,10 +1395,12 @@ int main(int argc, char **argv) { assert(!result); } int c = 0; +#if !bench werase(scr); +#endif while (threads_done < THREADS) { - int x, y, i = 0; #if !bench + int x, y, i = 0; if ((c != EOF && c !=-1)) { pthread_mutex_lock(&main_mutex); curs_set(0); @@ -1945,6 +1426,7 @@ int main(int argc, char **argv) { default: addr[RX_ADDR] = (uint8_t)c; addr[CTRL_ADDR] = 1; + kbd_rdy = 1; #if !keypoll pthread_mutex_lock(&mutex); pthread_cond_signal(&cond); @@ -1963,10 +1445,6 @@ int main(int argc, char **argv) { } #if bench if (threads_done == THREADS) { - #if en_nc - scr = NULL; - endwin(); - #endif double tm_sec, tm_usec, tm[THREADS], ttm; double clkspd; double mhz; |