Part01-02: More mov instructions being handled

asm_files/01-02-39.asm

@@ -0,0 +1,35 @@
+; ========================================================================
+; LISTING 39
+; ========================================================================
+
+bits 16
+
+; Register-to-register
+mov si, bx
+mov dh, al
+
+; 8-bit immediate-to-register
+mov cl, 12
+mov ch, -12
+
+; 16-bit immediate-to-register
+mov cx, 12
+mov cx, -12
+mov dx, 3948
+mov dx, -3948
+
+; Source address calculation
+mov al, [bx + si]
+mov bx, [bp + di]
+mov dx, [bp]
+
+; Source address calculation plus 8-bit displacement
+mov ah, [bx + si + 4]
+
+; Source address calculation plus 16-bit displacement
+mov al, [bx + si + 4999]
+
+; Dest address calculation
+mov [bx + di], cx
+mov [bp + si], cl
+mov [bp], ch

asm_files/01-02-40.asm

@@ -0,0 +1,26 @@
+; ========================================================================
+; LISTING 40
+; ========================================================================
+
+bits 16
+
+; Signed displacements
+mov ax, [bx + di - 37]
+mov [si - 300], cx
+mov dx, [bx - 32]
+
+; Explicit sizes
+mov [bp + di], byte 7
+mov [di + 901], word 347
+
+; Direct address
+mov bp, [5]
+mov bx, [3458]
+
+; Memory-to-accumulator test
+mov ax, [2555]
+mov ax, [16]
+
+; Accumulator-to-memory test
+mov [2554], ax
+mov [15], ax

decode.c

@@ -6,43 +6,53 @@
 
 enum Instruction
 {
-    INST_MOV = 0b10001000
+    INST_MOV_REG_REG = 0b10001000,
+    // INST_MOV_REG_REG = 0b10001000,
+    // INST_MOV_REG_REG = 0b10001000,
 };
 
 enum Mode
 {
-    MODE_MEM_NOD = 0b00,
+    MODE_MEM_NO_DIS = 0b00,
-    MODE_MEM_08D = 0b01,
+    MODE_MEM_DIS_08 = 0b01,
-    MODE_MEM_16D = 0b10,
+    MODE_MEM_DIS_16 = 0b10,
-    MODE_REGMODE = 0b11,
+    MODE_RGSTR_MODE = 0b11,
 };
 
 typedef struct Register
 {
     char code;
-    char *fullname;
+    char* fullname;
-    char *bytename;
+    char* bytename;
-    union {
+
-        struct {
+    union
+    {
+        struct
+        {
             char low;
             char high;
         };
+
         u16 full;
     } value;
 } Register;
 
 Register registers[8] = {
-    {.code = 0b000, .fullname = "ax", .bytename = "al" },
+    {.code = 0b000, .fullname = "ax", .bytename = "al"},
-    {.code = 0b001, .fullname = "cx", .bytename = "cl" },
+    {.code = 0b001, .fullname = "cx", .bytename = "cl"},
-    {.code = 0b010, .fullname = "dx", .bytename = "dl" },
+    {.code = 0b010, .fullname = "dx", .bytename = "dl"},
-    {.code = 0b011, .fullname = "bx", .bytename = "bl" },
+    {.code = 0b011, .fullname = "bx", .bytename = "bl"},
-    {.code = 0b100, .fullname = "sp", .bytename = "ah" },
+    {.code = 0b100, .fullname = "sp", .bytename = "ah"},
-    {.code = 0b101, .fullname = "bp", .bytename = "ch" },
+    {.code = 0b101, .fullname = "bp", .bytename = "ch"},
-    {.code = 0b110, .fullname = "si", .bytename = "dh" },
+    {.code = 0b110, .fullname = "si", .bytename = "dh"},
-    {.code = 0b111, .fullname = "di", .bytename = "bh" },
+    {.code = 0b111, .fullname = "di", .bytename = "bh"},
 };
 
-int main(int argc, char **argv)
+char* memory[65536];
+
+// void inst_mov_rgmm_reg()
+
+int main(int argc, char** argv)
 {
     if (argc < 2)
     {
@@ -56,41 +66,166 @@ int main(int argc, char **argv)
         perror("fopen\n");
         return EXIT_FAILURE;
     }
-    size_t bytes_read = fread(buf, sizeof(*buf), ARRAY_SIZE(buf), f);
+    size_t bytes_read;
 
     printf("; Decoded 8086 Assembly Instructions\n\n");
     printf("bits 16\n\n");
-    for (int i = 0; i < (int)bytes_read; i += 2)
+
+    while ((bytes_read = fread(buf, sizeof(char), 1, f)) > 0)
     {
-        char low_byte = buf[i];
+        char inst = buf[0];
-        char high_byte = buf[i+1];
+        // Instruction instruction = 0;
-        char w = low_byte & 0b00000001;
+        // Register/memory to/from register
-        char d = low_byte & 0b00000010;
+        if ((inst & ~0x3) == (char)0b10001000)
-        char mod = (high_byte & 0b11000000) >> 6;
+        {
-        char reg = (high_byte & 0b00111000) >> 3;
+            // TODO: We should add some form of error handling here
-        char r_m = (high_byte & 0b00000111);
+            bytes_read = fread(buf, sizeof(char), 1, f);
+            char next_byte = buf[0];
+            char w = inst & 0b00000001;
+            char d = inst & 0b00000010;
+            char mod = (next_byte & 0b11000000) >> 6;
+            char reg = (next_byte & 0b00111000) >> 3;
+            char rm = (next_byte & 0b00000111);
             size_t reg_idx = reg;
-        size_t r_m_idx = r_m;
+            size_t rm_idx = rm;
-        Register src_reg = d == 0 ? registers[reg_idx] : registers[r_m_idx];
+            Register src_reg = d == 0 ? registers[reg_idx] : registers[rm_idx];
-        Register dst_reg = d == 0 ? registers[r_m_idx] : registers[reg_idx];
+            Register dst_reg = d == 0 ? registers[rm_idx] : registers[reg_idx];
-        switch (low_byte & 0b11111100)
+            if (mod == MODE_RGSTR_MODE)
             {
-        case INST_MOV:
+                char* src_name = w == 1 ? src_reg.fullname : src_reg.bytename;
-            if (mod == MODE_REGMODE)
+                char* dst_name = w == 1 ? dst_reg.fullname : dst_reg.bytename;
-            {
+                printf("mov %s, %s", dst_name, src_name);
-                if (w == 1)
-                {
-                    printf("mov %s, %s", dst_reg.fullname, src_reg.fullname);
             }
             else
             {
-                    printf("mov %s, %s", dst_reg.bytename, src_reg.bytename);
+                // char* src_name = w == 1 ? src_reg.fullname : src_reg.bytename;
+                char *dst_name;
+                if (d)
+                {
+                    dst_name = w == 1 ? dst_reg.fullname : dst_reg.bytename;
                 }
+                else
+                {
+                    dst_name = w == 1 ? src_reg.fullname : src_reg.bytename;
                 }
+                char* src_name;
+                switch (rm)
+                {
+                case 0b000:
+                    src_name = "bx + si";
+                    break;
+                case 0b001:
+                    src_name = "bx + di";
+                    break;
+                case 0b010:
+                    src_name = "bp + si";
+                    break;
+                case 0b011:
+                    src_name = "bp + di";
+                    break;
+                case 0b100:
+                    src_name = "si";
+                    break;
+                case 0b101:
+                    src_name = "di";
+                    break;
+                case 0b110:
+                    src_name = "bp";
+                    break;
+                case 0b111:
+                    src_name = "bx";
                     break;
-        default:
-            perror("Unrecognized Instruction\n");
                 }
+                if (mod == MODE_MEM_DIS_16)
+                {
+                    bytes_read = fread(buf, sizeof(char), 2, f);
+                    i16 data = (i16)buf[1] << 8 | buf[0];
+                    if (d)
+                    {
+                        printf("mov %s, [%s + %d] ;(mod %d, w %d, d %d)", dst_name, src_name, data, mod, d, w);
+                    }
+                    else
+                    {
+                        printf("mov [%s], %s ;(mod %d, w %d, d %d)", src_name, dst_name, mod, d, w);
+                    }
+                    char disp_lo = buf[0];
+                    char disp_hi = buf[1];
+                    (void)disp_lo;
+                    (void)disp_hi;
+                }
+                else if (mod == MODE_MEM_DIS_08)
+                {
+                    bytes_read = fread(buf, sizeof(char), 1, f);
+                    if (d)
+                    {
+                        printf("mov %s, [%s + %d] ;(mod %d, w %d, d %d)", dst_name, src_name, buf[0], mod, d, w);
+                    }
+                    else
+                    {
+                        printf("mov [%s], %s ;(mod %d, w %d, d %d)", src_name, dst_name, mod, d, w);
+                    }
+                }
+                else if (mod == MODE_MEM_NO_DIS)
+                {
+                    if (d)
+                    {
+                        printf("mov %s, [%s] ;(mod %d, w %d, d %d)", dst_name, src_name, mod, d, w);
+                    }
+                    else
+                    {
+                        printf("mov [%s], %s ;(mod %d, w %d, d %d)", src_name, dst_name, mod, d, w);
+                    }
+                }
+            }
+        }
+        // Immediate to register/memory
+        else if ((inst & ~0x1) == (char)0b11000110)
+        {
+            printf("mov imm to reg/mem");
+        }
+        // Immediate to register
+        else if ((inst & ~0xF) == (char)0b10110000)
+        {
+            char w   = inst & 0b00001000;
+            Register reg = registers[(size_t)inst & 0b00000111];
+            char *reg_name = w == 0 ? reg.bytename : reg.fullname;
+            if (w)
+            {
+                bytes_read = fread(buf, sizeof(char), 2, f);
+                i16 data = (i16)buf[1] << 8 | buf[0];
+                printf("mov %s, %hd     ; Immediate to register", reg_name, data);
+            }
+            else
+            {
+                bytes_read = fread(buf, sizeof(char), 1, f);
+                printf("mov %s, %d     ; Immediate to register", reg_name, (sbyte)buf[0]);
+            }
+        }
+        // Memory to accumulator
+        else if ((inst & ~0x1) == (char)0b10100000)
+        {
+            printf("mov mem to acc");
+        }
+        // Accumulator to memory
+        else if ((inst & ~0x1) == (char)0b10100010)
+        {
+            printf("mov acc to mem");
+        }
+        // Register/memory to segment register
+        else if (inst == (char)0b10001110)
+        {
+            printf("mov regmem to segreg");
+        }
+        // Segment register to register/memory
+        else if (inst == (char)0b10001100)
+        {
+            printf("mov segreg to regmem");
+        }
+        else
+        {
+            fprintf(stderr, "Unrecognized Instruction");
+        }
+
         printf("\n");
     }
 }