Non-enum opcodes

src/bytecode.rs

@@ -2,50 +2,40 @@ use std::collections::HashMap;
 
 use crate::ast::{Ast, Expr, Stmt, BinOpType};
 
-type OpcodeSize = u32;
+pub mod op {
+    type OpSize = u32;
 
-#[repr(u32)]
-#[derive(Debug, Clone, Copy)]
-pub enum OP {
-    Push,
-    Pop,
-    Load,
-    Store,
-
-    Add,
-    Subtract,
-    Multiply,
-    Divide,
-    Modulo,           
-    BOr,
-    BAnd,
-    BXor,
-    Shl,
-    Shr,
-
-    Eq,
-    Neq,
-
-    Gt,
-    Ge,
-    Lt,
-    Le,
-
-    Jump,
-
-    JumpTrue,
-
-    JumpFalse,
-
-    Print,
-
-    DbgPrint,
+    pub const PUSH: OpSize = 0;
+    pub const POP: OpSize = 1;
+    pub const LOAD: OpSize = 2;
+    pub const STORE: OpSize = 3;
+    pub const ADD: OpSize = 4;
+    pub const SUB: OpSize = 5;
+    pub const MUL: OpSize = 6;
+    pub const DIV: OpSize = 7;
+    pub const MOD: OpSize = 8;           
+    pub const BOR: OpSize = 9;
+    pub const BAND: OpSize = 10;
+    pub const BXOR: OpSize = 11;
+    pub const SHL: OpSize = 12;
+    pub const SHR: OpSize = 13;
+    pub const EQ: OpSize = 14;
+    pub const NEQ: OpSize = 15;
+    pub const GT: OpSize = 16;
+    pub const GE: OpSize = 17;
+    pub const LT: OpSize = 18;
+    pub const LE: OpSize = 19;
+    pub const JUMP: OpSize = 20;
+    pub const JUMP_TRUE: OpSize = 21;
+    pub const JUMP_FALSE: OpSize = 22;
+    pub const PRINT: OpSize = 23;
+    pub const DBG_PRINT: OpSize = 24;
 }
 
 #[derive(Debug, Default)]
 pub struct Compiler {
     ops: Vec<u32>,
-    global_vars: HashMap<String, u64>,
+    global_vars: HashMap<String, u16>,
 }
 
 impl Compiler {
@@ -58,26 +48,30 @@ impl Compiler {
             match stmt {
                 Stmt::Expr(expr) => {
                     self.compile_expr(expr);
-                    self.ops.push(OP::Pop as OpcodeSize);
+                    self.ops.push(op::POP);
                 }
                 Stmt::Let(name, rhs) => {
-                    let id = self.global_vars.len() as u64;
+                    let id = self.global_vars.len() as u16;
                     self.global_vars.insert(name.clone(), id);
 
                     self.compile_expr(rhs);
                     self.gen_store(id);
                 }
                 Stmt::While(cond, body) => {
-                    let idx_start = self.ops.len();
                     self.compile_expr(cond);
 
-                    self.ops.push(OP::JumpFalse as OpcodeSize);
+                    self.ops.push(op::JUMP_FALSE);
                     let idx_jmp = self.ops.len();
                     self.gen_i64(0);
+                    
+                    let idx_start = self.ops.len();
 
                     self.compile(body);
 
-                    self.ops.push(OP::Jump as OpcodeSize);
+                    // check condition before loop jump
+                    self.compile_expr(cond);
+
+                    self.ops.push(op::JUMP_TRUE);
                     self.gen_i64(idx_start as i64);
 
                     self.overwrite_i64(idx_jmp, self.ops.len() as i64);
@@ -86,13 +80,13 @@ impl Compiler {
                 Stmt::If(cond, if_block, else_block) => {
                     self.compile_expr(cond);
 
-                    self.ops.push(OP::JumpFalse as OpcodeSize);
+                    self.ops.push(op::JUMP_FALSE);
                     let idx_if = self.ops.len();
                     self.gen_i64(0);
 
                     self.compile(if_block);
 
-                    self.ops.push(OP::Jump as OpcodeSize);
+                    self.ops.push(op::JUMP);
                     let idx_else = self.ops.len();
                     self.gen_i64(0);
 
@@ -105,11 +99,11 @@ impl Compiler {
                 },
                 Stmt::DbgPrint(expr) => {
                     self.compile_expr(expr);
-                    self.ops.push(OP::DbgPrint as OpcodeSize);
+                    self.ops.push(op::DBG_PRINT);
                 }
                 Stmt::Print(expr) => {
                     self.compile_expr(expr);
-                    self.ops.push(OP::Print as OpcodeSize);
+                    self.ops.push(op::PRINT);
                 }
             }
         }
@@ -122,7 +116,7 @@ impl Compiler {
     pub fn compile_expr(&mut self, expr: &Expr) {
         match expr {
             Expr::I64(val) => {
-                self.ops.push(OP::Push as OpcodeSize);
+                self.ops.push(op::PUSH);
                 self.gen_i64(*val)
             }
             Expr::Ident(name) => {
@@ -155,52 +149,44 @@ impl Compiler {
         self.compile_expr(rhs);
 
         match bo {
-            BinOpType::Add => self.ops.push(OP::Add as OpcodeSize),
-            BinOpType::Sub => self.ops.push(OP::Subtract as OpcodeSize),
-            BinOpType::Mul => self.ops.push(OP::Multiply as OpcodeSize),
-            BinOpType::Div => self.ops.push(OP::Divide as OpcodeSize),
-            BinOpType::Mod => self.ops.push(OP::Modulo as OpcodeSize),
-            BinOpType::BOr => self.ops.push(OP::BOr as OpcodeSize),
-            BinOpType::BAnd => self.ops.push(OP::BAnd as OpcodeSize),
-            BinOpType::BXor => self.ops.push(OP::BXor as OpcodeSize),
-            BinOpType::Shl => self.ops.push(OP::Shl as OpcodeSize),
-            BinOpType::Shr => self.ops.push(OP::Shr as OpcodeSize),
-            BinOpType::Equ => self.ops.push(OP::Eq as OpcodeSize),
-            BinOpType::Neq => self.ops.push(OP::Neq as OpcodeSize),
-            BinOpType::Gt => self.ops.push(OP::Gt as OpcodeSize),
-            BinOpType::Ge => self.ops.push(OP::Ge as OpcodeSize),
-            BinOpType::Lt => self.ops.push(OP::Lt as OpcodeSize),
-            BinOpType::Le => self.ops.push(OP::Le as OpcodeSize),
+            BinOpType::Add => self.ops.push(op::ADD),
+            BinOpType::Sub => self.ops.push(op::SUB),
+            BinOpType::Mul => self.ops.push(op::MUL),
+            BinOpType::Div => self.ops.push(op::DIV),
+            BinOpType::Mod => self.ops.push(op::MOD),
+            BinOpType::BOr => self.ops.push(op::BOR),
+            BinOpType::BAnd => self.ops.push(op::BAND),
+            BinOpType::BXor => self.ops.push(op::BXOR),
+            BinOpType::Shl => self.ops.push(op::SHL),
+            BinOpType::Shr => self.ops.push(op::SHR),
+            BinOpType::Equ => self.ops.push(op::EQ),
+            BinOpType::Neq => self.ops.push(op::NEQ),
+            BinOpType::Gt => self.ops.push(op::GT),
+            BinOpType::Ge => self.ops.push(op::GE),
+            BinOpType::Lt => self.ops.push(op::LT),
+            BinOpType::Le => self.ops.push(op::LE),
             BinOpType::Assign => unreachable!(),
         }
     }
 
     fn gen_i64(&mut self, val: i64) {
-        // for i in 0 .. 8 {
-        //     self.ops.push(((val >> i*8) & 0xff) as OpcodeSize);
-        // }
-        for i in 0 .. 2 {
-            self.ops.push(((val >> i*32) & 0xffffffff) as OpcodeSize);
-        }
+        self.ops.push((val & u32::MAX as i64) as u32);
+        self.ops.push((val >> 32) as u32);
     }
 
     fn overwrite_i64(&mut self, idx: usize, val: i64) {
-        // for i in 0 .. 8 {
-        //     self.ops[idx+i] = ((val >> i*8) & 0xff) as OpcodeSize;
-        // }
-        for i in 0 .. 2 {
-            self.ops[idx+i] = ((val >> i*32) & 0xffffffff) as OpcodeSize;
-        }
+        self.ops[idx] = (val & u32::MAX as i64) as u32;
+        self.ops[idx+1] = (val >> 32) as u32;
     }
 
-    fn gen_load(&mut self, addr: u64) {
-        self.ops.push(OP::Load as OpcodeSize);
-        self.gen_i64(addr as i64)
+    fn gen_load(&mut self, addr: u16) {
+        self.ops.push(op::LOAD | (addr << 8) as u32);
+        // self.gen_i64(addr as i64)
     }
 
-    fn gen_store(&mut self, addr: u64) {
-        self.ops.push(OP::Store as OpcodeSize);
-        self.gen_i64(addr as i64)
+    fn gen_store(&mut self, addr: u16) {
+        self.ops.push(op::STORE | (addr << 8) as u32);
+        // self.gen_i64(addr as i64)
     }
 }
 

src/vm.rs

@@ -1,4 +1,4 @@
-use crate::{bytecode::OP, interpreter::Value};
+use crate::{bytecode::op::*, interpreter::Value};
 
 #[derive(Debug, Default)]
 pub struct Vm {
@@ -10,6 +10,19 @@ pub struct Vm {
     heap: Vec<Value>,
 }
 
+macro_rules! binop_stack {
+    ($self:ident, $op:tt) => {
+        {
+            let rhs = $self.stack.pop().unwrap();
+            let lhs = $self.stack.last_mut().unwrap();
+            match (lhs, rhs) {
+                (Value::I64(lhs), Value::I64(rhs)) => *lhs = *lhs $op rhs,
+                _ => panic!("Invalid data for add"),
+            }
+        }
+    };
+}
+
 impl Vm {
     pub fn new(prog: Vec<u32>) -> Self {
         Self {
@@ -19,19 +32,20 @@ impl Vm {
     }
 
     pub fn run(&mut self) {
-        while let Some(op) = self.prog.get(self.ip).copied().map(|op| unsafe { std::mem::transmute::<u32, OP>(op) }) {
+        while let Some(op) = self.prog.get(self.ip).copied() {
             self.ip += 1;
 
-            match op {
-                OP::Push => {
+            match op & 0xff {
+                PUSH => {
                     let val = self.read_i64();
                     self.stack.push(Value::I64(val));
                 }
-                OP::Pop => {
+                POP => {
                     self.stack.pop();
                 }
-                OP::Load => {
-                    let addr = self.read_i64() as usize;
+                LOAD => {
+                    // let addr = self.read_i64() as usize;
+                    let addr = (op >> 8) as usize;
 
                     if let Some(val) = self.heap.get(addr) {
                         self.stack.push(val.clone());
@@ -39,26 +53,28 @@ impl Vm {
                         panic!("Trying to load from uninitialized heap");
                     }
                 }
-                OP::Store => {
+                STORE => {
                     let val = self
                         .stack
                         .pop()
                         .expect("Trying to pop value from stack for storing");
-                    let addr = self.read_i64() as usize;
+                    // let addr = self.read_i64() as usize;
+                    let addr = (op >> 8) as usize;
+
                     if self.heap.len() == addr {
                         self.heap.push(val);
                     } else {
                         self.heap[addr] = val;
                     }
                 }
-                OP::Print => {
+                PRINT => {
                     let val = self
                         .stack
                         .pop()
                         .expect("Trying to pop value from stack for printing");
                     print!("{}", val);
                 }
-                OP::DbgPrint => {
+                DBG_PRINT => {
                     let val = self
                         .stack
                         .pop()
@@ -66,91 +82,96 @@ impl Vm {
                     print!("{:?}", val);
                 }
 
-                OP::Add => {
-                    let vals = self.pop2_i64();
-                    self.stack.push(Value::I64(vals.0 + vals.1))
+                ADD => {
+                    binop_stack!(self, +);
+                    // self.stack.push(Value::I64(vals.0 + vals.1))
                 }
-                OP::Subtract => {
-                    let vals = self.pop2_i64();
-                    self.stack.push(Value::I64(vals.0 - vals.1))
+                SUB => {
+                    binop_stack!(self, -);
+                    // let vals = self.pop2_i64();
+                    // self.stack.push(Value::I64(vals.0 - vals.1))
                 }
-                OP::Multiply => {
-                    let vals = self.pop2_i64();
-                    self.stack.push(Value::I64(vals.0 * vals.1))
+                MUL => {
+                    binop_stack!(self, *);
+                    // let vals = self.pop2_i64();
+                    // self.stack.push(Value::I64(vals.0 * vals.1))
                 }
-                OP::Divide => {
-                    let vals = self.pop2_i64();
-                    self.stack.push(Value::I64(vals.0 / vals.1))
+                DIV => {
+                    binop_stack!(self, /);
+                    // let vals = self.pop2_i64();
+                    // self.stack.push(Value::I64(vals.0 / vals.1))
                 }
-                OP::Modulo => {
-                    let vals = self.pop2_i64();
-                    self.stack.push(Value::I64(vals.0 % vals.1))
+                MOD => {
+                    binop_stack!(self, %);
+                    // let vals = self.pop2_i64();
+                    // self.stack.push(Value::I64(vals.0 % vals.1))
                 }
-                OP::Eq => {
+                EQ => {
                     let vals = self.pop2_i64();
                     self.stack
                         .push(Value::I64(if vals.0 == vals.1 { 1 } else { 0 }))
                 }
-                OP::Neq => {
+                NEQ => {
                     let vals = self.pop2_i64();
                     self.stack
                         .push(Value::I64(if vals.0 != vals.1 { 1 } else { 0 }))
                 }
-                OP::Gt => {
+                GT => {
                     let vals = self.pop2_i64();
                     self.stack
                         .push(Value::I64(if vals.0 > vals.1 { 1 } else { 0 }))
                 }
-                OP::Ge => {
+                GE => {
                     let vals = self.pop2_i64();
                     self.stack
                         .push(Value::I64(if vals.0 >= vals.1 { 1 } else { 0 }))
                 }
-                OP::Lt => {
+                LT => {
                     let vals = self.pop2_i64();
                     self.stack
                         .push(Value::I64(if vals.0 < vals.1 { 1 } else { 0 }))
                 }
-                OP::Le => {
+                LE => {
                     let vals = self.pop2_i64();
                     self.stack
                         .push(Value::I64(if vals.0 <= vals.1 { 1 } else { 0 }))
                 }
-                OP::BOr => {
+                BOR => {
                     let vals = self.pop2_i64();
                     self.stack.push(Value::I64(vals.0 | vals.1))
                 }
-                OP::BAnd => {
+                BAND => {
                     let vals = self.pop2_i64();
                     self.stack.push(Value::I64(vals.0 & vals.1))
                 }
-                OP::BXor => {
+                BXOR => {
                     let vals = self.pop2_i64();
                     self.stack.push(Value::I64(vals.0 ^ vals.1))
                 }
-                OP::Shl => {
+                SHL => {
                     let vals = self.pop2_i64();
                     self.stack.push(Value::I64(vals.0 << vals.1))
                 }
-                OP::Shr => {
+                SHR => {
                     let vals = self.pop2_i64();
                     self.stack.push(Value::I64(vals.0 >> vals.1))
                 }
-                OP::Jump => {
+                JUMP => {
                     self.ip = self.read_i64() as usize;
                 }
-                OP::JumpTrue => {
+                JUMP_TRUE => {
                     let jmp_target = self.read_i64() as usize;
                     if !matches!(self.stack.pop(), Some(Value::I64(0))) {
                         self.ip = jmp_target;
                     }
                 }
-                OP::JumpFalse => {
+                JUMP_FALSE => {
                     let jmp_target = self.read_i64() as usize;
                     if matches!(self.stack.pop(), Some(Value::I64(0))) {
                         self.ip = jmp_target;
                     }
                 }
+                _ => panic!("Invalid opcode")
             }
         }
     }
@@ -165,22 +186,22 @@ impl Vm {
     }
 
     fn read_i64(&mut self) -> i64 {
-        let mut val = *self.prog.get(self.ip).unwrap() as i64;
-        val |= (*self.prog.get(self.ip + 1).unwrap() as i64) << 32;
+        let mut val = if let Some(val) = self.prog.get(self.ip).copied() {
+            val
+        } else {
+            panic!("Expected Value as next OP")
+        } as i64;
 
-        // let mut bytes = [0; 8];
-        // bytes.copy_from_slice(&self.prog[self.ip..self.ip+8]);
-        // val = i64::from_le_bytes(bytes);
+        self.ip += 1;
 
-        // for i in 0 .. 8 {
-        //     if let Some(tmp) = self.prog.get(self.ip + i).copied() {
-        //         val |= ((tmp as i64) << i*8) as i64;
-        //     } else {
-        //         panic!("Expected Value as next OP")
-        //     }
-        // }
+        val |= (if let Some(val) = self.prog.get(self.ip).copied() {
+            val
+        } else {
+            panic!("Expected Value as next OP")
+        } as i64)
+            << 32;
 
-        self.ip += 2;
+        self.ip += 1;
 
         val
     }