Expanded testsuite funcionality to disassembly

Author: MVittiS

mult4packed.s

@@ -56,7 +56,7 @@ mult4packed:
 ;  A high, RotA high, B low, and RotB low.
   and #$F
   sta multBrotlow
-  lda multBrot
+  lda multB
   and #$F
   sta multBlow
   lda multA
@@ -66,46 +66,36 @@ mult4packed:
   and #$F0
   sta multArothigh
 
-; Now, we assemble our partial products, starting with the with an
+; Now, we assemble our partial products, starting with an
 ;  element already in the accumulator - P0. The rest follows.
+; Finally, we use the partial products as arguments in a look-up
+;  multiplication table, and start building our products.
 
 ; P0
   ora multBlow
+  tax
+  lda mult44table, x
   sta p0
 ; P1
   lda multAhigh
   ora multBlow
+  tax
+  lda mult44table, x
+  tax
+  lda rot4table, x
   sta p1
 ; P2
   lda multArothigh
   ora multBrotlow
-  sta p2
-; P3
-  lda multAhigh
-  ora multBrotlow
-  sta p3
-
-; Finally, we use the partial products as arguments in a look-up
-;  multiplication table, and start building our products.
-
-; P0
-  ldx p0
-  lda mult44table, x
-  sta p0
-; P1, rotated
-  ldx p1
-  lda mult44table, x
   tax
-  lda rot4table, x
-  sta p1
-; P2, rotated
-  ldx p2
   lda mult44table, x
   tax
   lda rot4table, x
   sta p2
 ; P3
-  ldx p3
+  lda multAhigh
+  ora multBrotlow
+  tax
   lda mult44table, x
   sta p3
 
@@ -114,20 +104,20 @@ mult4packed:
   clc
 ; First we sum P1...
   lda p1
-  ora #$F0
+  and #$F0
   adc p0
   sta p0
   lda p1
-  ora #$F
+  and #$F
   adc p3
   sta p3
 ; ...and finally we sum P2. Done!
   lda p2
-  ora #$F0
+  and #$F0
   adc p0
   sta p0
   lda p2
-  ora #$F
+  and #$F
   adc p3
   sta p3
 rts

testMain.c

@@ -25,12 +25,39 @@ void write6502(uint16_t address, uint8_t value) {
     ram[address] = value;
 }
 
+const char opString[][4] = {
+/*        |  0  |  1  |  2  |  3  |  4  |  5  |  6  |  7  |  8  |  9  |  A  |  B  |  C  |  D  |  E  |  F  |      */
+/* 0 */    "brk","ora","nop","slo","nop","ora","asl","slo","php","ora","asl","nop","nop","ora","asl","slo", /* 0 */
+/* 1 */    "bpl","ora","nop","slo","nop","ora","asl","slo","clc","ora","nop","slo","nop","ora","asl","slo", /* 1 */
+/* 2 */    "jsr","and","nop","rla","bit","and","rol","rla","plp","and","rol","nop","bit","and","rol","rla", /* 2 */
+/* 3 */    "bmi","and","nop","rla","nop","and","rol","rla","sec","and","nop","rla","nop","and","rol","rla", /* 3 */
+/* 4 */    "rti","eor","nop","sre","nop","eor","lsr","sre","pha","eor","lsr","nop","jmp","eor","lsr","sre", /* 4 */
+/* 5 */    "bvc","eor","nop","sre","nop","eor","lsr","sre","cli","eor","nop","sre","nop","eor","lsr","sre", /* 5 */
+/* 6 */    "rts","adc","nop","rra","nop","adc","ror","rra","pla","adc","ror","nop","jmp","adc","ror","rra", /* 6 */
+/* 7 */    "bvs","adc","nop","rra","nop","adc","ror","rra","sei","adc","nop","rra","nop","adc","ror","rra", /* 7 */
+/* 8 */    "nop","sta","nop","sax","sty","sta","stx","sax","dey","nop","txa","nop","sty","sta","stx","sax", /* 8 */
+/* 9 */    "bcc","sta","nop","nop","sty","sta","stx","sax","tya","sta","txs","nop","nop","sta","nop","nop", /* 9 */
+/* A */    "ldy","lda","ldx","lax","ldy","lda","ldx","lax","tay","lda","tax","nop","ldy","lda","ldx","lax", /* A */
+/* B */    "bcs","lda","nop","lax","ldy","lda","ldx","lax","clv","lda","tsx","lax","ldy","lda","ldx","lax", /* B */
+/* C */    "cpy","cmp","nop","dcp","cpy","cmp","dec","dcp","iny","cmp","dex","nop","cpy","cmp","dec","dcp", /* C */
+/* D */    "bne","cmp","nop","dcp","nop","cmp","dec","dcp","cld","cmp","nop","dcp","nop","cmp","dec","dcp", /* D */
+/* E */    "cpx","sbc","nop","isb","cpx","sbc","inc","isb","inx","sbc","nop","sbc","cpx","sbc","inc","isb", /* E */
+/* F */    "beq","sbc","nop","isb","nop","sbc","inc","isb","sed","sbc","nop","isb","nop","sbc","inc","isb"  /* F */
+};
+
 int main(int argc, char **args) {
     // First, we load a binary file to memory, and wait until execution reaches the end of it.
     if (argc < 2) {
         printf("Please specify a binary file to load!\nExiting.\n");
         exit(1);
     }
+
+    if  (argc < 3) {
+        printf("Please specify how many registers are to be watched!\nExiting.\n");
+        exit(1);
+    }
+    int numRegs = atoi(args[2]);
+
     FILE *file = fopen(args[1], "rb");
     if (file == NULL) {
         printf("Error: file not found!\nExiting.\n");
@@ -47,10 +74,14 @@ int main(int argc, char **args) {
     strcat(dumpFileName, ".execLog.csv");
     FILE *output = fopen(outputFileName, "w");
     FILE *dump = fopen(dumpFileName, "w");
-    fprintf(dump, "Address,A,X,Y,P,R0,R1,R2,R3\n");
+    fprintf(dump, "Address,A,X,Y,P");
+    for (int r = 0; r < numRegs; r++) {
+        fprintf(dump, ",R%d", r);
+    }
+    fprintf(dump, ",Opcode\n");
 
-    for (int rX = 0; rX < 256; rX++) {
-        for (int rY = 0; rY < 256; rY++) {
+    for (int rX = 0xAB; rX < 256; rX++) {
+        for (int rY = 0xCD; rY < 256; rY++) {
             const int limit = 4096;
             reset6502();
             pc = 0x200;
@@ -59,10 +90,18 @@ int main(int argc, char **args) {
 
             int c;
             for (c = 0; c < limit; c++) {
-                fprintf(dump, "%04x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x\n", pc, a, x, y, status, ram[0], ram[1], ram[2], ram[3]);
+                fprintf(dump, "%04x,%02x,%02x,%02x,%02x", pc, a, x, y, status);
+                for (int r = 0; r < numRegs; r++) {
+                    fprintf(dump, ",%02x", ram[r]);
+                }
+                fprintf(dump, ",%s\n", opString[ram[pc]]);
 
                 step6502();
-                if (pc == 0x200 + binSize - 1) {
+                // The correct way of testing for termination is to see if
+                //  the PC points to an RTS instruction. But an equally
+                //  effective way is to test to see if it's pointing to any
+                //  address below our strating point.
+                if (pc < 0x200) {
                     break;
                 }
             }