commit 9b0fb14462d9e936f4fff83def62d5690185075b
parent 9c43c7f97c167087548403dcd17e93000c496c97
Author: Andrew Laack <andrew@laack.co>
Date: Wed, 7 Oct 2026 19:48:32 -0500
Immediate to register done
Co-authored-by: Vim
Diffstat:
7 files changed, 225 insertions(+), 53 deletions(-)
diff --git a/perf-aware-programming/8086-decoder/Makefile b/perf-aware-programming/8086-decoder/Makefile
@@ -1,5 +1,5 @@
build:
- g++ decode.c -o decode -fpermissive
+ g++ decode.c -g3 -o decode
clean:
rm decode
@@ -7,7 +7,10 @@ clean:
run: build
./decode source/ex1 > dest/ex1.asm
./decode source/ex2 > dest/ex2.asm
+ ./decode source/ex3 > dest/ex3.asm
nasm dest/ex1.asm -o dest/ex1
nasm dest/ex2.asm -o dest/ex2
+ nasm dest/ex3.asm -o dest/ex3
diff dest/ex1 source/ex1
diff dest/ex2 source/ex2
+ diff dest/ex3 source/ex3
diff --git a/perf-aware-programming/8086-decoder/decode b/perf-aware-programming/8086-decoder/decode
Binary files differ.
diff --git a/perf-aware-programming/8086-decoder/decode.c b/perf-aware-programming/8086-decoder/decode.c
@@ -1,5 +1,6 @@
#include "stdio.h"
#include "stdlib.h"
+#include <stddef.h>
typedef struct {
unsigned char opcode;
@@ -8,100 +9,124 @@ typedef struct {
unsigned char mod;
unsigned char reg;
unsigned char rm;
+ unsigned char dl;
+ unsigned char dlUnset;
+ unsigned char dh;
+ unsigned char dhUnset;
+ unsigned char immediateToRegister;
} Instruction;
char* regMapping(unsigned char reg, unsigned char w) {
char* res = (char*)malloc(2*sizeof(char));
if(w == 0) {
- switch (reg) {
+ switch (reg % 4) {
case 0:
res[0] = 'a';
- res[1] = 'l';
break;
case 1:
res[0] = 'c';
- res[1] = 'l';
break;
case 2:
res[0] = 'd';
- res[1] = 'l';
break;
case 3:
res[0] = 'b';
- res[1] = 'l';
- break;
- case 4:
- res[0] = 'a';
- res[1] = 'h';
- break;
- case 5:
- res[0] = 'c';
- res[1] = 'h';
- break;
- case 6:
- res[0] = 'd';
- res[1] = 'h';
- break;
- case 7:
- res[0] = 'b';
- res[1] = 'h';
break;
}
+ if(reg < 4) {
+ res[1] = 'l';
+ } else {
+ res[1] = 'h';
+ }
} else {
switch (reg) {
case 0:
res[0] = 'a';
- res[1] = 'x';
break;
case 1:
res[0] = 'c';
- res[1] = 'x';
break;
case 2:
res[0] = 'd';
- res[1] = 'x';
break;
case 3:
res[0] = 'b';
- res[1] = 'x';
break;
case 4:
res[0] = 's';
- res[1] = 'p';
break;
case 5:
res[0] = 'b';
- res[1] = 'p';
break;
case 6:
res[0] = 's';
- res[1] = 'i';
break;
case 7:
res[0] = 'd';
- res[1] = 'i';
break;
}
+ if(reg < 4) {
+ res[1] = 'x';
+ }
+ else if(reg < 6) {
+ res[1] = 'p';
+ } else {
+ res[1] = 'i';
+ }
}
return res;
}
-
-void printInstruction(Instruction inst) {
+// return 1 to inform caller to give us more bytes
+// return 0 if done
+unsigned char printInstruction(Instruction inst) {
if(inst.opcode == 34) {
- printf("mov ");
- if(inst.d == 1) {
- char* enc1 = regMapping(inst.reg,inst.w);
+ // register mode
+ if(inst.mod == 0b11) {
+ if(inst.d == 1) {
+ printf("mov ");
+ char* enc1 = regMapping(inst.reg,inst.w);
+ printf("%c%c,", enc1[0], enc1[1]);
+ free(enc1);
+
+ char* enc2 = regMapping(inst.rm,inst.w);
+ printf("%c%c\n,", enc2[0], enc2[1]);
+ free(enc2);
+
+ } else {
+ printf("mov ");
+ char* enc1 = regMapping(inst.rm,inst.w);
+ printf("%c%c,", enc1[0], enc1[1]);
+ free(enc1);
+ char* enc2 = regMapping(inst.reg,inst.w);
+ printf("%c%c\n", enc2[0], enc2[1]);
+ free(enc2);
+ }
+ } else if(inst.mod == 0b01){
+ // one of the bytes
+ if(inst.dlUnset) {
+ return 1;
+ }
+
+ printf("mov ");
+ char* enc1 = regMapping(inst.rm,inst.w);
printf("%c%c,", enc1[0], enc1[1]);
free(enc1);
- char* enc2 = regMapping(inst.rm,inst.w);
- printf("%c%c\n,", enc2[0], enc2[1]);
+ char* enc2 = regMapping(inst.reg,inst.w);
+ printf("%c%c\n", enc2[0], enc2[1]);
free(enc2);
- } else {
-
+ } else if(inst.mod == 0b10){
+
+ // both bytes
+ if(inst.dlUnset || inst.dhUnset) {
+ return 1;
+ }
+
+ printf("mov ");
+
char* enc1 = regMapping(inst.rm,inst.w);
printf("%c%c,", enc1[0], enc1[1]);
free(enc1);
@@ -109,8 +134,38 @@ void printInstruction(Instruction inst) {
char* enc2 = regMapping(inst.reg,inst.w);
printf("%c%c\n", enc2[0], enc2[1]);
free(enc2);
+
+ } else if(inst.mod == 0b00){
+ // memory mode, no displacement
+ return 0;
+ }
+
+ // mask then check matches 1011
+ } else if(inst.opcode == 0b1011){
+ if(inst.dlUnset) {
+ return 1;
+ }
+ if(inst.w == 1 && inst.dhUnset) {
+ return 1;
+ }
+
+ printf("mov ");
+
+ char* enc1 = regMapping(inst.reg,inst.w);
+ printf("%c%c,", enc1[0], enc1[1]);
+ if(inst.dhUnset == 0) {
+ printf("%hd\n", ((inst.dh) << 8) | inst.dl);
+ } else {
+ printf("%hhd\n", (int)inst.dl);
}
+
+ free(enc1);
+
+ } else {
+ //printf("%u\n", (inst.opcode));
+
}
+ return 0;
}
int main(int argc, char** argv) {
@@ -136,25 +191,73 @@ int main(int argc, char** argv) {
return -1;
}
- char buffer[256];
+ // TODO: Dynamic sizing
- fgets(buffer, sizeof(char)*256, fp);
+ char *buffer = NULL;
+ size_t len = 0;
- Instruction inst = (const Instruction){ 0, 0, 0};
+ Instruction inst = (const Instruction){ 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0};
+ unsigned char fl = 0;
- for(int i = 0; i < 256 && buffer[i] != '\0'; ++i) {
- if(inst.opcode == 0) {
- inst.opcode = (buffer[i] & 0b11111100) >> 2;
- inst.d = (buffer[i] & 0b00000010) >> 1;
- inst.w = buffer[i] & 0b00000001;
- } else {
- inst.mod = (buffer[i] & 0b11000000) >> 6;
- inst.reg = (buffer[i] & 0b00111000) >> 3;
- inst.rm = buffer[i] & 0b00000111;
- printInstruction(inst);
- inst = (const Instruction){ 0, 0, 0};
+ while(getline(&buffer, &len,fp) != -1) {
+ for(int i = 0; i < 100000 && i < len; ++i) {
+ if(fl == 0) {
+ if(inst.opcode == 0) {
+ unsigned char cur = buffer[i];
+ if((cur & 0b11110000) == 0b10110000) {
+ inst.opcode = 0b1011;
+ inst.w = (buffer[i] & 0b00001000) >> 3;
+ inst.reg = (buffer[i] & 0b00000111);
+ inst.immediateToRegister = 1;
+ } else {
+ inst.opcode = (buffer[i] & 0b11111100) >> 2;
+ inst.d = (buffer[i] & 0b00000010) >> 1;
+ inst.w = buffer[i] & 0b00000001;
+ }
+ } else {
+
+ if(inst.immediateToRegister == 1) {
+ if(inst.dlUnset == 1) {
+ inst.dl = buffer[i];
+ inst.dlUnset = 0;
+ } else {
+ inst.dh = buffer[i];
+ inst.dhUnset = 0;
+ }
+ } else {
+ inst.mod = (buffer[i] & 0b11000000) >> 6;
+ inst.reg = (buffer[i] & 0b00111000) >> 3;
+ inst.rm = buffer[i] & 0b00000111;
+ }
+
+ unsigned char res = printInstruction(inst);
+
+ if(res == 0) {
+ inst = (const Instruction){ 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0};
+ } else {
+ if(inst.immediateToRegister == 0) {
+ fl = 1;
+ }
+ }
+ }
+ } else {
+ if(inst.dlUnset) {
+ inst.dlUnset = 0;
+ inst.dl = buffer[i+1];
+ unsigned char res = printInstruction(inst);
+ if(res == 0) {
+ fl = 0;
+ }
+ } else {
+ inst.dhUnset = 0;
+ inst.dh = buffer[i+1];
+ fl = 0;
+ }
+ }
}
}
+ free(buffer);
+
fclose(fp);
}
diff --git a/perf-aware-programming/8086-decoder/dest/ex3 b/perf-aware-programming/8086-decoder/dest/ex3
Binary files differ.
diff --git a/perf-aware-programming/8086-decoder/dest/ex3.asm b/perf-aware-programming/8086-decoder/dest/ex3.asm
@@ -0,0 +1,19 @@
+mov si,bx
+mov dh,al
+mov cl,12
+mov ch,-12
+mov cx,12
+mov cx,-12
+mov dx,3948
+mov dx,-3948
+mov si,dx
+mov cl,cl
+mov dh,ch
+mov cl,12
+mov ch,-12
+mov cx,12
+mov cx,-12
+mov dx,3948
+mov dx,-3948
+mov si,dx
+mov cl,cl
diff --git a/perf-aware-programming/8086-decoder/source/ex3 b/perf-aware-programming/8086-decoder/source/ex3
Binary files differ.
diff --git a/perf-aware-programming/8086-decoder/source/ex3.asm b/perf-aware-programming/8086-decoder/source/ex3.asm
@@ -0,0 +1,47 @@
+; ========================================================================
+;
+; (C) Copyright 2023 by Molly Rocket, Inc., All Rights Reserved.
+;
+; This software is provided 'as-is', without any express or implied
+; warranty. In no event will the authors be held liable for any damages
+; arising from the use of this software.
+;
+; Please see https://computerenhance.com for further information
+;
+; ========================================================================
+
+; ========================================================================
+; 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