From 0ea3406b71c2032d240996751ba62dea8ce2f40b Mon Sep 17 00:00:00 2001
From: Alek Ratzloff <alekratz@gmail.com>
Date: Mon, 10 Feb 2020 18:59:23 -0500
Subject: [PATCH] Add storeimm32 and storeimm64 syntax

These explicitly allow usage of storeimm32 and storeimm64 in the
assembler syntax. It will also warn you if you try to store a value
that's too large using the storeimm32 instruction

Signed-off-by: Alek Ratzloff <alekratz@gmail.com>
---
 src/vm/obj/assemble/mod.rs    | 16 ++++++++++++++++
 src/vm/obj/syn/ast.rs         |  4 ++++
 src/vm/obj/syn/parser.lalrpop |  2 ++
 test.asm                      | 14 +++++++-------
 4 files changed, 29 insertions(+), 7 deletions(-)

diff --git a/src/vm/obj/assemble/mod.rs b/src/vm/obj/assemble/mod.rs
index cb73def..c5f6245 100644
--- a/src/vm/obj/assemble/mod.rs
+++ b/src/vm/obj/assemble/mod.rs
@@ -203,6 +203,22 @@ impl<'a> Assemble<'a> {
                 }
             }
             .r1(*r1),
+            Inst::StoreImm32(r1, imm) => {
+                let imm = self.get_value(imm).expect("TODO : value label not found");
+                let imm_truncated = (imm & 0xFFFFFFFF) as u32;
+                // TODO compile-time warnings
+                if imm != (imm_truncated as u64) {
+                    eprintln!(
+                        "WARNING: immediate 32 bit value being truncated ({:#x} to {:#x})",
+                        imm, imm_truncated
+                    )
+                }
+                builder.op(STOREIMM32).imm32(imm_truncated).r1(*r1)
+            }
+            Inst::StoreImm64(r1, imm) => {
+                let imm = self.get_value(imm).expect("TODO : value label not found");
+                builder.op(STOREIMM64).imm64(imm).r1(*r1)
+            }
             Inst::MemCopy(r1, r2) => builder.op(MEMCOPY).r1(*r1).r2(*r2),
             Inst::RegCopy(r1, r2) => builder.op(REGCOPY).r1(*r1).r2(*r2),
             Inst::Nop => builder.op(NOP),
diff --git a/src/vm/obj/syn/ast.rs b/src/vm/obj/syn/ast.rs
index fe09b44..5874cc4 100644
--- a/src/vm/obj/syn/ast.rs
+++ b/src/vm/obj/syn/ast.rs
@@ -59,6 +59,8 @@ pub enum Inst {
     Load(Reg, Reg),
     Store(Reg, Reg),
     StoreImm(Reg, ImmValue),
+    StoreImm32(Reg, ImmValue),
+    StoreImm64(Reg, ImmValue),
     MemCopy(Reg, Reg),
     RegCopy(Reg, Reg),
 
@@ -101,6 +103,8 @@ impl Inst {
                     STOREIMM64
                 }
             }
+            Inst::StoreImm32(_, _) => STOREIMM32,
+            Inst::StoreImm64(_, _) => STOREIMM64,
             Inst::MemCopy(_, _) => MEMCOPY,
             Inst::RegCopy(_, _) => REGCOPY,
 
diff --git a/src/vm/obj/syn/parser.lalrpop b/src/vm/obj/syn/parser.lalrpop
index c3de298..6fd2648 100644
--- a/src/vm/obj/syn/parser.lalrpop
+++ b/src/vm/obj/syn/parser.lalrpop
@@ -59,6 +59,8 @@ Inst: Inst = {
     "load" <d:Reg> "," <s:Reg> => Inst::Load(d, s),
     "store" <d:Reg> "," <s:Reg> => Inst::Store(d, s),
     "storeimm" <d:Reg> "," <s:ImmValue> => Inst::StoreImm(d, s),
+    "storeimm32" <d:Reg> "," <s:ImmValue> => Inst::StoreImm32(d, s),
+    "storeimm64" <d:Reg> "," <s:ImmValue> => Inst::StoreImm64(d, s),
     "memcopy" <d:Reg> "," <s:Reg> => Inst::MemCopy(d, s),
     "regcopy" <d:Reg> "," <s:Reg> => Inst::RegCopy(d, s),
     "nop" => Inst::Nop,
diff --git a/test.asm b/test.asm
index 40db5e6..09ccb61 100644
--- a/test.asm
+++ b/test.asm
@@ -1,25 +1,25 @@
 code $0x0 {
     main:
-        storeimm %r00, $0xDEAD
-        storeimm %r01, $16
+        storeimm32 %r00, $0xDEAD
+        storeimm64 %r01, $16
 
         shl %r00, %r01
 
-        storeimm %r01, $0xBEEF
+        storeimm32 %r01, $0xBEEF
         or %r00, %r01
 
-        storeimm %r01, $0xDEADBEEF
+        storeimm64 %r01, $0xDEADBEEF
 
         cmpeq %r00, %r01
-        storeimm %r00, failure
-        storeimm %r01, ok
+        storeimm32 %r00, failure
+        storeimm64 %r01, ok
 
         jz %r00
 
         jmp %r01
 
     failure:
-        storeimm %status, $1
+        storeimm32 %status, $1
 
     ok: halt