nooc

commit 51096f5d05aaadfd855dba41bca9e497cb57cc51
parent 5ccf3fd0cc92fe6c3881e9ab609398d9a3205af8
Author: Nihal Jere <nihal@nihaljere.xyz>
Date:   Sun, 26 Dec 2021 17:50:10 -0600

add i8

Diffstat:
M
main.c
 | 
33
+++++++++++++++++++++++++++++++++
A
test/global_i8.pass.nooc
 | 
9
+++++++++
M
type.c
 | 
6
++++++
M
x64.c
 | 
77
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
M
x64.h
 | 
5
+++++

5 files changed, 130 insertions(+), 0 deletions(-)
diff --git a/main.c b/main.c
@@ -114,6 +114,9 @@ place_move(char *buf, struct place *dest, struct place *src)
 			case 2:
 				total += mov_mr16_r16(buf ? buf + total : NULL, dest->l.reg, src->l.reg);
 				break;
+			case 1:
+				total += mov_mr8_r8(buf ? buf + total : NULL, dest->l.reg, src->l.reg);
+				break;
 			default:
 				die("place_move: REG -> REGADDR: unhandled size");
 			}
@@ -129,6 +132,9 @@ place_move(char *buf, struct place *dest, struct place *src)
 			case 2:
 				total += mov_disp8_m16_r16(buf ? buf + total : NULL, RBP, -dest->l.off, src->l.reg);
 				break;
+			case 1:
+				total += mov_disp8_m8_r8(buf ? buf + total : NULL, RBP, -dest->l.off, src->l.reg);
+				break;
 			default:
 				die("place_move: REG -> REGADDR: unhandled size");
 			}
@@ -166,6 +172,15 @@ place_move(char *buf, struct place *dest, struct place *src)
 				die("place_move: unhandled dest case for PLACE_REGADDR");
 			}
 			break;
+		case 1:
+			switch (dest->kind) {
+			case PLACE_REG:
+				total += mov_r8_mr8(buf ? buf + total : NULL, dest->l.reg, src->l.reg);
+				break;
+			default:
+				die("place_move: unhandled dest case for PLACE_REGADDR");
+			}
+			break;
 		default:
 			die("place_move: REGADDR: src unhandled size");
 		}
@@ -199,6 +214,15 @@ place_move(char *buf, struct place *dest, struct place *src)
 				die("place_move: unhandled dest case for PLACE_FRAME");
 			}
 			break;
+		case 1:
+			switch (dest->kind) {
+			case PLACE_REG:
+				total += mov_disp8_r8_m8(buf ? buf + total : NULL, dest->l.reg, RBP, -src->l.off);
+				break;
+			default:
+				die("place_move: unhandled dest case for PLACE_FRAME");
+			}
+			break;
 		default:
 			die("place_move: FRAME: src unhandled size");
 		}
@@ -232,6 +256,15 @@ place_move(char *buf, struct place *dest, struct place *src)
 				die("place_move: unhandled dest case for PLACE_ABS");
 			}
 			break;
+		case 1:
+			switch (dest->kind) {
+			case PLACE_REG:
+				total += mov_r8_m8(buf ? buf + total : NULL, dest->l.reg, src->l.addr);
+				break;
+			default:
+				die("place_move: unhandled dest case for PLACE_ABS");
+			}
+			break;
 		default:
 			die("place_move: ABS: src unhandled size");
 		}
diff --git a/test/global_i8.pass.nooc b/test/global_i8.pass.nooc
@@ -0,0 +1,9 @@
+let a i8 = 1
+
+let main proc() = proc() {
+	if = a 1 {
+		syscall(60, 0)
+	} else {
+		syscall(60, 1)
+	}
+}
diff --git a/type.c b/type.c
@@ -57,6 +57,12 @@ inittypes()
 	mapkey(&key, "i16", 3);
 	mapput(typesmap, &key)->n = idx;
 
+	type.class = TYPE_INT;
+	type.size = 1;
+	idx = type_put(&type);
+	mapkey(&key, "i8", 2);
+	mapput(typesmap, &key)->n = idx;
+
 	type.class = TYPE_STR;
 	type.size = 8;
 	idx = type_put(&type);
diff --git a/x64.c b/x64.c
@@ -115,6 +115,17 @@ mov_r16_imm(char *buf, enum reg dest, uint16_t imm)
 }
 
 size_t
+mov_r8_imm(char *buf, enum reg dest, uint8_t imm)
+{
+	if (buf) {
+		*(buf++) = 0xb0 + (dest & 0x7);
+		*(buf++) = imm;
+	}
+
+	return 2;
+}
+
+size_t
 mov_r64_m64(char *buf, enum reg dest, uint64_t addr)
 {
 	uint8_t sib = 0x25;
@@ -168,6 +179,23 @@ mov_r16_m16(char *buf, enum reg dest, uint32_t addr)
 }
 
 size_t
+mov_r8_m8(char *buf, enum reg dest, uint32_t addr)
+{
+	if (buf) {
+		if (dest >= 8) *(buf++) = REX_R;
+		*(buf++) = 0x8a;
+		*(buf++) = (MOD_INDIRECT << 6) | ((dest & 7) << 3) | 4;
+		*(buf++) = 0x25;
+		*(buf++) = addr & 0xFF;
+		*(buf++) = (addr >> 8) & 0xFF;
+		*(buf++) = (addr >> 16) & 0xFF;
+		*(buf++) = (addr >> 24) & 0xFF;
+	}
+
+	return dest >= 8 ? 8 : 7;
+}
+
+size_t
 mov_m64_r64(char *buf, uint64_t addr, enum reg src)
 {
 	if (buf) {
@@ -240,6 +268,17 @@ mov_mr16_r16(char *buf, enum reg dest, enum reg src)
 }
 
 size_t
+mov_mr8_r8(char *buf, enum reg dest, enum reg src)
+{
+	if (buf) {
+		*(buf++) = 0x8A;
+		*(buf++) = (MOD_INDIRECT << 6) | (src << 3) | dest;
+	}
+
+	return 2;
+}
+
+size_t
 mov_r64_mr64(char *buf, enum reg dest, enum reg src)
 {
 	if (buf) {
@@ -275,6 +314,17 @@ mov_r16_mr16(char *buf, enum reg dest, enum reg src)
 }
 
 size_t
+mov_r8_mr8(char *buf, enum reg dest, enum reg src)
+{
+	if (buf) {
+		*(buf++) = 0x88;
+		*(buf++) = (MOD_INDIRECT << 6) | (dest << 3) | src;
+	}
+
+	return 2;
+}
+
+size_t
 mov_r64_r64(char *buf, enum reg dest, enum reg src)
 {
 	if (buf) {
@@ -341,6 +391,20 @@ mov_disp8_m16_r16(char *buf, enum reg dest, int8_t disp, enum reg src)
 	return 4;
 }
 
+// FIXME: we don't handle r8-r15 properly in most of these
+size_t
+mov_disp8_m8_r8(char *buf, enum reg dest, int8_t disp, enum reg src)
+{
+	assert(src != 4);
+	if (buf) {
+		*(buf++) = 0x88;
+		*(buf++) = (MOD_DISP8 << 6) | (src << 3) | dest;
+		*(buf++) = disp;
+	}
+
+	return 3;
+}
+
 size_t
 mov_disp8_r64_m64(char *buf, enum reg dest, enum reg src, int8_t disp)
 {
@@ -383,6 +447,19 @@ mov_disp8_r16_m16(char *buf, enum reg dest, enum reg src, int8_t disp)
 }
 
 size_t
+mov_disp8_r8_m8(char *buf, enum reg dest, enum reg src, int8_t disp)
+{
+	assert(src != 4);
+	if (buf) {
+		*(buf++) = 0x8A;
+		*(buf++) = (MOD_DISP8 << 6) | (dest << 3) | src;
+		*(buf++) = disp;
+	}
+
+	return 3;
+}
+
+size_t
 add_r64_r64(char *buf, enum reg dest, enum reg src)
 {
 	if (buf) {
diff --git a/x64.h b/x64.h
@@ -29,22 +29,27 @@ size_t mov_r64_imm(char *buf, enum reg reg, uint64_t imm);
 size_t mov_r64_m64(char *buf, enum reg reg, uint64_t addr);
 size_t mov_r32_m32(char *buf, enum reg dest, uint32_t addr);
 size_t mov_r16_m16(char *buf, enum reg dest, uint32_t addr);
+size_t mov_r8_m8(char *buf, enum reg dest, uint32_t addr);
 size_t mov_m64_r64(char *buf, uint64_t addr, enum reg reg);
 size_t mov_m32_r32(char *buf, uint64_t addr, enum reg src);
 size_t mov_m16_r16(char *buf, uint64_t addr, enum reg src);
 size_t mov_mr64_r64(char *buf, enum reg dest, enum reg src);
 size_t mov_mr32_r32(char *buf, enum reg dest, enum reg src);
 size_t mov_mr16_r16(char *buf, enum reg dest, enum reg src);
+size_t mov_mr8_r8(char *buf, enum reg dest, enum reg src);
 size_t mov_r64_mr64(char *buf, enum reg dest, enum reg src);
 size_t mov_r32_mr32(char *buf, enum reg dest, enum reg src);
 size_t mov_r16_mr16(char *buf, enum reg dest, enum reg src);
+size_t mov_r8_mr8(char *buf, enum reg dest, enum reg src);
 size_t mov_r64_r64(char *buf, enum reg dest, enum reg src);
 size_t mov_disp8_m64_r64(char *buf, enum reg dest, int8_t disp, enum reg src);
 size_t mov_disp8_m32_r32(char *buf, enum reg dest, int8_t disp, enum reg src);
 size_t mov_disp8_m16_r16(char *buf, enum reg dest, int8_t disp, enum reg src);
+size_t mov_disp8_m8_r8(char *buf, enum reg dest, int8_t disp, enum reg src);
 size_t mov_disp8_r64_m64(char *buf, enum reg dest, enum reg src, int8_t disp);
 size_t mov_disp8_r32_m32(char *buf, enum reg dest, enum reg src, int8_t disp);
 size_t mov_disp8_r16_m16(char *buf, enum reg dest, enum reg src, int8_t disp);
+size_t mov_disp8_r8_m8(char *buf, enum reg dest, enum reg src, int8_t disp);
 size_t add_r64_r64(char *buf, enum reg reg1, enum reg reg2);
 size_t sub_r64_r64(char *buf, enum reg reg1, enum reg reg2);
 size_t sub_r64_imm(char *buf, enum reg reg1, int32_t imm);