Made all address decoding, and memory reads/writes be

done with a union, in order to make it more readable.

1 files changed, 68 insertions, 66 deletions

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];
 	}
 }