From 9ccba5e624319becd9a85822e60b15b6355f19cd Mon Sep 17 00:00:00 2001 From: mrb0nk500 Date: Mon, 4 May 2020 12:57:36 -0400 Subject: Made all address decoding, and memory reads/writes be done with a union, in order to make it more readable. --- sux.h | 134 +++++++++++++++++++++++++++++++++--------------------------------- 1 file changed, 68 insertions(+), 66 deletions(-) (limited to 'sux.h') diff --git a/sux.h b/sux.h index 9996ba6..aa0355e 100644 --- a/sux.h +++ b/sux.h @@ -37,16 +37,16 @@ extern void disasm(struct sux *cpu, uint64_t *operands, uint8_t lines, uint8_t o extern void io(uint64_t address, uint8_t *esc); static inline uint64_t get_addr(struct sux *cpu, uint64_t *tmpaddr, uint8_t opcode, uint8_t prefix, uint8_t thread) { - uint64_t address = 0; - uint64_t value = 0; + union reg address; + union reg value; uint8_t tmp = 0; + address.u64 = 0; + value.u64 = 0; switch (optype[opcode]) { case IMPL: break; case IMM: switch (opcode) { - case TXS: - break; case PHB: case PHP: case PHA: @@ -64,12 +64,13 @@ static inline uint64_t get_addr(struct sux *cpu, uint64_t *tmpaddr, uint8_t opco case ROR: case ASR: case ENT: - address = cpu->pc[thread]; + address.u64 = cpu->pc[thread]; ++cpu->pc[thread]; break; default: - address = cpu->pc[thread]; + address.u64 = cpu->pc[thread]; cpu->pc[thread]+=(1 << (prefix >> 4)); + case TXS: break; } break; @@ -80,23 +81,23 @@ static inline uint64_t get_addr(struct sux *cpu, uint64_t *tmpaddr, uint8_t opco case INDX: case INDY: tmp = 0; - address = addr[cpu->pc[thread]]; + address.u8[0] = addr[cpu->pc[thread]]; /* Unroll Loop by implementing Duff's Device. */ switch ((prefix & 0x0C) >> 2) { case 2: - address |= (uint64_t)addr[cpu->pc[thread]+5] << 40;++tmp; - address |= (uint64_t)addr[cpu->pc[thread]+4] << 32;++tmp; + address.u8[5] = addr[cpu->pc[thread]+5];++tmp; + address.u8[4] = addr[cpu->pc[thread]+4];++tmp; case 3: - address |= addr[cpu->pc[thread]+3] << 24;++tmp; + address.u8[3] = addr[cpu->pc[thread]+3];++tmp; case 1: - address |= addr[cpu->pc[thread]+2] << 16;++tmp; - address |= addr[cpu->pc[thread]+1] << 8;++tmp; + address.u8[2] = addr[cpu->pc[thread]+2];++tmp; + address.u8[1] = addr[cpu->pc[thread]+1];++tmp; case 0: ++tmp; } cpu->pc[thread]+=tmp; #if debug && !bench - *tmpaddr = address; + *tmpaddr = address.u64; #endif #if getclk iclk++; @@ -104,19 +105,19 @@ static inline uint64_t get_addr(struct sux *cpu, uint64_t *tmpaddr, uint8_t opco uint64_t reg = 0; switch (optype[opcode]) { case ZMX: - address += cpu->x[thread]; + address.u64 += cpu->x[thread]; #if getclk iclk++; #endif break; case ZMY: - address += cpu->y[thread]; + address.u64 += cpu->y[thread]; #if getclk iclk++; #endif break; case INDX: - address += cpu->x[thread]; + address.u64 += cpu->x[thread]; #if getclk iclk++; #endif @@ -133,49 +134,47 @@ static inline uint64_t get_addr(struct sux *cpu, uint64_t *tmpaddr, uint8_t opco } /* Falls Through. */ case IND: - value = addr[address]; - value |= addr[address+1] << 8; - value |= addr[address+2] << 16; - value |= addr[address+3] << 24; - 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; + value.u8[0] = addr[address.u64 ]; + value.u8[1] = addr[address.u64+1]; + value.u8[2] = addr[address.u64+2]; + value.u8[3] = addr[address.u64+3]; + value.u8[4] = addr[address.u64+4]; + value.u8[5] = addr[address.u64+5]; + value.u8[6] = addr[address.u64+6]; + value.u8[7] = addr[address.u64+7]; #if getclk iclk++; #endif - value += reg; - address = value; - value = 0; - reg = 0; + value.u64 += reg; + address.u64 = value.u64; break; } break; case ABS: tmp = 0; - address = addr[cpu->pc[thread]];++tmp; + address.u8[0] = addr[cpu->pc[thread]];++tmp; /* Unroll Loop by implementing Duff's Device. */ switch ((prefix & 0x0C) >> 2) { case 3: - address |= (uint64_t)addr[cpu->pc[thread]+7] << 56;++tmp; + address.u8[7] = addr[cpu->pc[thread]+7];++tmp; case 2: - address |= (uint64_t)addr[cpu->pc[thread]+6] << 48;++tmp; - address |= (uint64_t)addr[cpu->pc[thread]+5] << 40;++tmp; + address.u8[6] = addr[cpu->pc[thread]+6];++tmp; + address.u8[5] = addr[cpu->pc[thread]+5];++tmp; #if getclk iclk++; #endif case 1: - address |= (uint64_t)addr[cpu->pc[thread]+4] << 32;++tmp; - address |= addr[cpu->pc[thread]+3] << 24;++tmp; - address |= addr[cpu->pc[thread]+2] << 16;++tmp; + address.u8[4] = addr[cpu->pc[thread]+4];++tmp; + address.u8[3] = addr[cpu->pc[thread]+3];++tmp; + address.u8[2] = addr[cpu->pc[thread]+2];++tmp; case 0: - address |= addr[cpu->pc[thread]+1] << 8;++tmp; + address.u8[1] = addr[cpu->pc[thread]+1];++tmp; } cpu->pc[thread]+=tmp; break; } - return address; + return address.u64; } inline void adc(struct sux *cpu, uint64_t value, uint8_t thread) { @@ -395,7 +394,7 @@ inline void cmp(struct sux *cpu, uint64_t value, uint8_t opcode, uint8_t thread) setflag(reg >= value, C); } -inline void incr(struct sux *cpu, uint64_t value, uint8_t opcode, uint8_t thread) { +inline void incr(struct sux *cpu, uint8_t opcode, uint8_t thread) { uint64_t reg; switch (opcode) { case INC: cpu->a[thread]+=1; reg = cpu->a[thread]; break; @@ -407,7 +406,7 @@ inline void incr(struct sux *cpu, uint64_t value, uint8_t opcode, uint8_t thread setflag(reg >> 63, N); } -inline void decr(struct sux *cpu, uint64_t value, uint8_t opcode, uint8_t thread) { +inline void decr(struct sux *cpu, uint8_t opcode, uint8_t thread) { uint64_t reg; switch (opcode) { case DEC: cpu->a[thread]-=1; reg = cpu->a[thread]; break; @@ -435,19 +434,21 @@ inline void load(struct sux *cpu, uint64_t address, uint8_t *esc, uint8_t opcode if (address == CTRL_ADDR) { io(address, esc); } - uint64_t value = addr[address]; + union reg value; + value.u64 = 0; /* Unroll Loop by implementing Duff's Device. */ + value.u8[0] = addr[address]; switch (1 << (prefix >> 4)) { case 8: - value |= (uint64_t)addr[address+7] << 56; - value |= (uint64_t)addr[address+6] << 48; - value |= (uint64_t)addr[address+5] << 40; - value |= (uint64_t)addr[address+4] << 32; + value.u8[7] = addr[address+7]; + value.u8[6] = addr[address+6]; + value.u8[5] = addr[address+5]; + value.u8[4] = addr[address+4]; case 4: - value |= addr[address+3] << 24; - value |= addr[address+2] << 16; + value.u8[3] = addr[address+3]; + value.u8[2] = addr[address+2]; case 2: - value |= addr[address+1] << 8; + value.u8[1] = addr[address+1]; } switch (opcode) { case LDB: @@ -458,7 +459,7 @@ inline void load(struct sux *cpu, uint64_t address, uint8_t *esc, uint8_t opcode case LDB_IN: case LDB_IX: case LDB_IY: - cpu->b[thread] = value; + cpu->b[thread] = value.u64; break; case LDA: case LDA_AB: @@ -468,14 +469,14 @@ inline void load(struct sux *cpu, uint64_t address, uint8_t *esc, uint8_t opcode case LDA_IN: case LDA_IX: case LDA_IY: - cpu->a[thread] = value; + cpu->a[thread] = value.u64; break; case LDY: case LDY_AB: case LDY_Z: case LDY_ZX: case LDY_IN: - cpu->y[thread] = value; + cpu->y[thread] = value.u64; break; case LDX: @@ -483,15 +484,16 @@ inline void load(struct sux *cpu, uint64_t address, uint8_t *esc, uint8_t opcode case LDX_Z: case LDX_ZY: case LDX_IN: - cpu->x[thread] = value; + cpu->x[thread] = value.u64; break; } - setflag(value == 0, Z); - setflag(value >> 63, N); + setflag(value.u64 == 0, Z); + setflag(value.u64 >> 63, N); } inline void store(struct sux *cpu, uint64_t address, uint8_t *esc, uint8_t opcode, uint8_t prefix, uint8_t thread) { - uint64_t value; + union reg value; + value.u64 = 0; switch (opcode) { case STB: case STB_Z: @@ -500,7 +502,7 @@ inline void store(struct sux *cpu, uint64_t address, uint8_t *esc, uint8_t opcod case STB_IN: case STB_IX: case STB_IY: - value = cpu->b[thread]; + value.u64 = cpu->b[thread]; break; case STA: case STA_Z: @@ -509,23 +511,23 @@ inline void store(struct sux *cpu, uint64_t address, uint8_t *esc, uint8_t opcod case STA_IN: case STA_IX: case STA_IY: - value = cpu->a[thread]; + value.u64 = cpu->a[thread]; break; case STY: case STY_Z: case STY_ZX: case STY_IN: - value = cpu->y[thread]; + value.u64 = cpu->y[thread]; break; case STX: case STX_Z: case STX_ZY: case STX_IN: - value = cpu->x[thread]; + value.u64 = cpu->x[thread]; break; } - addr[address] = value & 0xFF; + addr[address] = value.u8[0]; #if (IO || debug) && !branch #if keypoll pthread_mutex_lock(&mutex); @@ -540,15 +542,15 @@ inline void store(struct sux *cpu, uint64_t address, uint8_t *esc, uint8_t opcod /* Unroll Loop by implementing Duff's Device. */ switch (1 << (prefix >> 4)) { case 8: - addr[address+7] = value >> 56; - addr[address+6] = value >> 48; - addr[address+5] = value >> 40; - addr[address+4] = value >> 32; + addr[address+7] = value.u8[7]; + addr[address+6] = value.u8[6]; + addr[address+5] = value.u8[5]; + addr[address+4] = value.u8[4]; case 4: - addr[address+3] = value >> 24; - addr[address+2] = value >> 16; + addr[address+3] = value.u8[3]; + addr[address+2] = value.u8[2]; case 2: - addr[address+1] = value >> 8; + addr[address+1] = value.u8[1]; } } -- cgit v1.2.3-13-gbd6f