Compare commits

...

10 Commits

Author SHA1 Message Date
_ 57486f7a65 🐛 bug: fma test passes with a hack
So closures are kinda working, but I'm probably missing some edge cases.
2023-09-29 17:44:54 -05:00
_ 2a0e02aec4 test: closure passing again, fma still not 2023-09-29 17:25:54 -05:00
_ 24d576879b make Debug print easier to read 2023-09-29 17:17:53 -05:00
_ 35e62027e6 🐛 bug 2023-09-29 16:58:40 -05:00
_ e499d27dfc 🚧 wip: improving debugging 2023-09-29 16:55:02 -05:00
_ a460b5a932 ♻️ refactor: hoist breakpoints out of State 2023-09-29 16:32:29 -05:00
_ a9e14d0f47 ♻️ refactor: extract a single step method for State 2023-09-29 16:27:50 -05:00
_ f0d4f25cec implement a couple more opcodes fighting the closure issue 2023-09-29 16:15:00 -05:00
_ 4da634a2aa 🚧 wip: working on closures / upvalues 2023-09-28 01:31:23 -05:00
_ 05b1d6e1f7 loading upvalue metadata 2023-09-28 00:55:16 -05:00
7 changed files with 712 additions and 483 deletions

View File

@ -251,19 +251,25 @@ pub fn parse_block <R: Read> (rdr: &mut R, blocks: &mut Vec <Block>)
}
let upvalue_count = parse_int (rdr).unwrap () as usize;
let mut upvalues = Vec::with_capacity (upvalue_count);
for _ in 0..upvalue_count {
// Just ignore these
let in_stack = parse_byte (rdr).unwrap () == 1;
let idx = parse_byte (rdr).unwrap ();
let kind = parse_byte (rdr).unwrap ();
for _ in 0..3 {
parse_byte (rdr).unwrap ();
}
let upvalue = crate::state::Upvalue {
in_stack,
idx,
kind,
};
upvalues.push (upvalue);
}
blocks.push (Block {
constants,
instructions,
upvalue_count,
upvalues,
});
// Recursion

View File

@ -14,12 +14,24 @@ fn main () {
let mut list_bytecode = false;
let mut pipe_bytecode = false;
let mut script = None;
let mut breakpoints = vec![];
let mut args = std::env::args ();
let exe_name = args.next ().unwrap ();
while let Some (arg) = args.next () {
match arg.as_str () {
"--break" => {
let s = args.next ().unwrap ();
let (block_idx, program_counter) = s.split_once (":").unwrap ();
let block_idx = str::parse (block_idx).unwrap ();
let program_counter = str::parse (program_counter).unwrap ();
breakpoints.push (state::Breakpoint {
block_idx,
program_counter,
});
},
"--list-bytecode" => list_bytecode = true,
"--pipe-bytecode" => pipe_bytecode = true,
"--script" => script = Some (args.next ().unwrap ()),
@ -45,17 +57,63 @@ fn main () {
dbg! (&chunk);
}
let mut vm = State::default ();
if std::env::var("LUA_DEBUG").is_ok() {
let upvalues = State::upvalues_from_args ([exe_name].into_iter ().chain (args));
let mut vm = State::new (&chunk, &upvalues);
if std::env::var("LWVM_DEBUG").is_ok() {
vm.debug_print = true;
}
let upvalues = State::upvalues_from_args ([exe_name].into_iter ().chain (args));
let max_iters = 2000;
let mut in_break = false;
let mut last_input = String::new ();
vm.breakpoints.push (state::Breakpoint {
block_idx: 3,
program_counter: 0,
});
for _ in 0..max_iters {
if in_break || breakpoints.iter ().any (|bp| vm.at_breakpoint (bp)) {
in_break = true;
dbg! (&vm.stack);
vm.execute_chunk (&chunk, &upvalues);
let mut input = Default::default ();
std::io::stdin ().read_line (&mut input).unwrap ();
let input = if input == "" {
&last_input
}
else {
last_input = input;
&last_input
};
match input.as_str ().trim_end () {
"c" => in_break = false,
"q" => return,
"registers" => {
dbg! (&vm.registers);
continue;
}
"s" => {
match vm.step () {
None => (),
Some (state::StepOutput::ChunkReturned (x)) => {
dbg! (x);
return;
},
}
continue;
},
x => { dbg! (x); },
}
}
match vm.step () {
None => (),
Some (state::StepOutput::ChunkReturned (x)) => {
dbg! (x);
return;
},
}
}
dbg! (vm);
panic! ("Hit max iterations before block returned");
}

View File

@ -8,11 +8,18 @@ use crate::{
},
};
#[derive (Debug)]
pub struct Upvalue {
pub in_stack: bool,
pub idx: u8,
pub kind: u8,
}
#[derive (Debug)]
pub struct Block {
pub instructions: Vec <Instruction>,
pub constants: Vec <Value>,
pub upvalue_count: usize,
pub upvalues: Vec <Upvalue>,
}
#[derive (Debug)]
@ -21,7 +28,7 @@ pub struct Chunk {
}
#[derive (Clone, Debug)]
struct StackFrame {
pub struct StackFrame {
// i32 makes it a little easier to implement jumps
// Starts at 0 right after OP_CALL
@ -40,34 +47,16 @@ pub struct Breakpoint {
}
#[derive (Debug)]
pub struct State {
registers: Vec <Value>,
pub struct State <'a> {
pub registers: Vec <Value>,
// Currently only used for native function calls
top: usize,
stack: Vec <StackFrame>,
pub stack: Vec <StackFrame>,
pub debug_print: bool,
pub breakpoints: Vec <Breakpoint>,
step_count: u32,
}
impl Default for State {
fn default () -> Self {
Self {
registers: vec! [Value::Nil; 16],
top: 0,
stack: vec! [
StackFrame {
program_counter: 0,
block_idx: 0,
register_offset: 0,
},
],
debug_print: false,
breakpoints: Default::default(),
step_count: 0,
}
}
chunk: &'a Chunk,
upvalues: &'a [Value],
}
fn lw_print (l: &mut State) -> i32 {
@ -86,7 +75,34 @@ fn lw_print (l: &mut State) -> i32 {
1
}
impl State {
pub enum StepOutput {
ChunkReturned (Vec <Value>),
}
impl <'a> State <'a> {
pub fn new (chunk: &'a Chunk, upvalues: &'a [Value]) -> Self {
Self {
registers: vec! [Value::Nil; 16],
top: 0,
stack: vec! [
StackFrame {
program_counter: 0,
block_idx: 0,
register_offset: 0,
},
],
debug_print: false,
step_count: 0,
chunk,
upvalues,
}
}
pub fn at_breakpoint (&self, bp: &Breakpoint) -> bool {
let frame = self.stack.last ().unwrap ();
frame.block_idx == bp.block_idx && frame.program_counter == bp.program_counter
}
pub fn upvalues_from_args <I: Iterator <Item = String>> (args: I) -> Vec <Value>
{
let arg = args.map (|s| Value::from (s)).enumerate ();
@ -124,23 +140,13 @@ impl State {
self.top - self.stack.last ().unwrap ().register_offset
}
pub fn execute_chunk (&mut self, chunk: &Chunk, upvalues: &[Value])
-> Vec <Value> {
let max_iters = 2000;
for _ in 0..max_iters {
pub fn step (&mut self) -> Option <StepOutput> {
let chunk = self.chunk;
self.step_count += 1;
let frame = self.stack.last_mut ().unwrap ().clone ();
let block = chunk.blocks.get (frame.block_idx).unwrap ();
for bp in &self.breakpoints {
if frame.block_idx == bp.block_idx && frame.program_counter == bp.program_counter
{
dbg! (&self);
}
}
let mut next_pc = frame.program_counter;
let pc = usize::try_from (frame.program_counter).expect ("program_counter is not a valid usize");
@ -160,15 +166,17 @@ impl State {
let v_b = self.reg (*b);
let v_c = self.reg (*c);
let sum = if let (Some (v_b), Some (v_c)) = (v_b.as_int (), v_c.as_int ())
let x = if let (Some (v_b), Some (v_c)) = (v_b.as_int (), v_c.as_int ())
{
Value::from (v_b + v_c)
}
else {
Value::from (v_b.as_float ().unwrap () + v_c.as_float ().unwrap ())
let v_b = v_b.as_float ().unwrap_or_else (|| panic! ("{v_b}"));
let v_c = v_c.as_float ().unwrap_or_else (|| panic! ("{v_c}"));
Value::from (v_b + v_c)
};
*self.reg_mut (*a) = sum;
*self.reg_mut (*a) = x;
},
Instruction::Call (a, b, _c) => {
let b = usize::from (*b);
@ -188,7 +196,7 @@ impl State {
match v_a {
Value::BogusClosure (rc) => {
let idx = rc.idx;
let idx = rc.borrow ().idx;
let block_idx = frame.block_idx;
let target_block = idx;
@ -208,7 +216,7 @@ impl State {
}
// Skip the PC increment at the bottom of the loop
continue;
return None;
},
Value::RsFunc (x) => {
let current_frame = self.stack.last ().unwrap ();
@ -241,10 +249,25 @@ impl State {
Instruction::Closure (a, b) => {
let b = usize::try_from (*b).unwrap ();
*self.reg_mut (*a) = Value::BogusClosure (BogusClosure {
idx: b + frame.block_idx + 1,
upvalues: vec! [],
}.into ());
let idx = frame.block_idx + b + 1;
let block = &chunk.blocks [idx];
let mut new_upvalues = Vec::with_capacity (block.upvalues.len ());
for uv in &block.upvalues {
let val = if uv.in_stack {
self.reg (uv.idx).clone ()
}
else {
// TODO: This isn't really correct
self.upvalues [usize::from (uv.idx)].clone ()
};
new_upvalues.push (val);
}
*self.reg_mut (*a) = Value::from (BogusClosure {
idx,
upvalues: new_upvalues,
});
},
Instruction::EqI (a, sb, k_flag) => {
if (self.reg (*a).as_int ().unwrap () == *sb as i64) != *k_flag
@ -317,7 +340,24 @@ impl State {
let b = usize::try_from (*b).unwrap ();
let c = usize::try_from (*c).unwrap ();
let table = upvalues.get (b).unwrap ().as_table ().expect ("GetTabUp only works on tables").borrow ();
// If we're inside a closure, use its upvalues
// instead of the chunk's upvalues
let frame = self.stack.last ().unwrap ();
let value = if frame.register_offset == 0 {
self.upvalues.get (b).unwrap ().clone ()
}
else if let Some (cell) = self.registers [frame.register_offset - 1].as_closure ()
{
let closure = cell.borrow ();
let value = closure.upvalues.get (b).unwrap ();
value.clone ()
}
else {
self.upvalues.get (b).unwrap ().clone ()
};
let table = value.as_table ().expect ("GetTabUp only works on tables").borrow ();
let key = match k.get (c).unwrap () {
Value::String (s) => String::from (s.as_ref()),
@ -338,14 +378,21 @@ impl State {
},
Instruction::GetUpVal (a, b) => {
let this_func = self.stack.last ().unwrap ().register_offset - 1;
let upvalues = match &self.registers [this_func] {
Value::BogusClosure (rc) => &rc.upvalues,
let closure = match &self.registers [this_func] {
Value::BogusClosure (rc) => rc.clone (),
_ => panic! ("Can't do GetUpVal outside a closure"),
};
let b = usize::try_from (*b).unwrap ();
*self.reg_mut (*a) = upvalues [b].clone ();
let upvalue = match closure.borrow ().upvalues.get (b) {
Some (x) => x.clone (),
None => {
dbg! (chunk, &self);
panic! ("Missing upvalue");
}
};
*self.reg_mut (*a) = upvalue;
},
Instruction::Jmp (s_j) => next_pc += s_j,
Instruction::Len (a, b) => {
@ -397,9 +444,27 @@ impl State {
*self.reg_mut (*a) = (b % c).into ();
},
Instruction::Move (a, b) => {
// If the value in b is deleted instead of duplicated,
// a bunch of tests fail
*self.reg_mut (*a) = self.reg (*b).clone ();
},
Instruction::Mul (_a, _b, _c) => unimplemented!(),
Instruction::Mul (a, b, c) => {
let v_b = self.reg (*b);
let v_c = self.reg (*c);
let x = if let (Some (v_b), Some (v_c)) = (v_b.as_int (), v_c.as_int ())
{
Value::from (v_b * v_c)
}
else {
let v_b = v_b.as_float ().unwrap_or_else (|| panic! ("{v_b}"));
let v_c = v_c.as_float ().unwrap_or_else (|| panic! ("{v_c}"));
Value::from (v_b * v_c)
};
*self.reg_mut (*a) = x;
},
Instruction::NewTable (a) => {
*self.reg_mut (*a) = Value::Table (Default::default ());
},
@ -412,24 +477,25 @@ impl State {
let popped_frame = self.stack.pop ().unwrap ();
// Build closure if needed
if *k {
// Build closure if needed. No point building if we're
// popping the last frame and exiting the program.
if *k && ! self.stack.is_empty () {
let closure_idx = match &self.registers [popped_frame.register_offset + a] {
Value::BogusClosure (rc) => rc.idx,
Value::BogusClosure (rc) => rc.borrow ().idx,
_ => panic! ("Impossible"),
};
let upvalue_count = chunk.blocks [closure_idx].upvalue_count;
let upvalue_count = chunk.blocks [closure_idx].upvalues.len ();
let start_reg = a + popped_frame.register_offset - upvalue_count;
let upvalues = self.registers [start_reg..start_reg+upvalue_count].iter ().cloned ().collect ();
self.registers [a + popped_frame.register_offset] = Value::BogusClosure (BogusClosure {
self.registers [a + popped_frame.register_offset] = Value::from (BogusClosure {
idx: closure_idx,
upvalues,
}.into ());
});
}
if self.debug_print {
@ -457,10 +523,13 @@ impl State {
}
else {
// Return from the entire program
return self.registers [a..(a + b - 1)].to_vec();
return Some (StepOutput::ChunkReturned (self.registers [a..(a + b - 1)].to_vec()));
}
},
Instruction::Return0 => unimplemented! (),
Instruction::Return0 => {
self.stack.pop ();
next_pc = self.stack.last ().unwrap ().program_counter;
},
Instruction::Return1 (a) => {
let a = usize::try_from (*a).unwrap ();
let popped_frame = self.stack.pop ().unwrap ();
@ -534,7 +603,36 @@ impl State {
}
},
Instruction::SetTabUp (_a, _b, _c) => unimplemented! (),
Instruction::TailCall (_a, _b, _c, _k) => unimplemented! (),
Instruction::TailCall (a, b, _c, k) => {
assert! (!k, "closing over values in tail calls not implemented");
// Shift closure and inputs into place
let a = usize::from (*a);
let b = usize::from (*b);
let offset = frame.register_offset - 1;
for i in (offset)..(offset + b) {
self.registers [i] = self.registers [i + a + 1].take ();
}
let value = &self.registers [offset];
let closure = if let Some (x) = value.as_closure () {
x
}
else {
dbg! (self);
panic! ("OP_TAILCALL only implemented for closures");
};
let closure = closure.borrow ();
// Jump into the other function
let frame = self.stack.last_mut ().unwrap ();
frame.program_counter = 0;
frame.block_idx = closure.idx;
// Skip the PC increment
return None;
},
Instruction::Test (a, _k) => {
if self.reg (*a).is_truthy() {
next_pc += 1;
@ -548,8 +646,26 @@ impl State {
let frame = self.stack.last_mut ().unwrap ();
frame.program_counter = next_pc;
}
None
}
pub fn execute_chunk (&mut self, breakpoints: &[Breakpoint])
-> Vec <Value> {
let max_iters = 2000;
for _ in 0..max_iters {
if breakpoints.iter ().any (|bp| self.at_breakpoint (bp)) {
dbg! (&self);
}
match self.step () {
None => (),
Some (StepOutput::ChunkReturned (x)) => return x,
}
}
dbg! (self);
panic! ("Hit max iterations before block returned");
}
}

View File

@ -23,9 +23,9 @@ fn calculate_hash<T: Hash>(t: &T) -> u64 {
/// and returns the output
fn run_chunk (args: &[&str], chunk: &Chunk) -> Vec <Value> {
let mut vm = State::default ();
let upvalues = State::upvalues_from_args (args.into_iter ().map (|s| s.to_string ()));
vm.execute_chunk (chunk, &upvalues)
let mut vm = State::new (chunk, &upvalues);
vm.execute_chunk (&[])
}
/// Takes arguments and Lua bytecode, loads it, runs it,
@ -93,7 +93,7 @@ fn bools () {
"arg".into (),
"print".into (),
],
upvalue_count: 1,
upvalues: vec! [],
},
Block {
instructions: vec! [
@ -107,7 +107,7 @@ fn bools () {
Inst::Return0,
],
constants: vec! [],
upvalue_count: 0,
upvalues: vec! [],
},
],
};
@ -118,10 +118,9 @@ fn bools () {
] {
let expected: Vec <Value> = expected;
let mut vm = State::default ();
let upvalues = State::upvalues_from_args (arg.into_iter ().map (|s| s.to_string ()));
let actual = vm.execute_chunk (&chunk, &upvalues);
let mut vm = State::new (&chunk, &upvalues);
let actual = vm.execute_chunk (&[]);
assert_eq! (actual, expected);
}
}
@ -164,7 +163,7 @@ fn floats () {
0.5.into (),
"print".into (),
],
upvalue_count: 1,
upvalues: vec! [],
};
let chunk = Chunk {
blocks: vec! [block],
@ -175,9 +174,9 @@ fn floats () {
(vec! ["_exe_name", " "], vec! [3.5.into ()]),
] {
let expected: Vec <Value> = expected;
let mut vm = State::default ();
let upvalues = State::upvalues_from_args (arg.into_iter ().map (|s| s.to_string ()));
let actual = vm.execute_chunk (&chunk, &upvalues);
let mut vm = State::new (&chunk, &upvalues);
let actual = vm.execute_chunk (&[]);
assert_eq! (actual, expected);
}
@ -185,19 +184,21 @@ fn floats () {
#[test]
fn fma () {
let bytecode = include_bytes! ("../test_vectors/fma.luac");
let mut rdr = std::io::Cursor::new (bytecode);
let file = crate::loader::parse_chunk (&mut rdr).unwrap ();
assert_eq! (file.blocks.len (), 4);
let source = include_bytes! ("../test_vectors/fma.lua");
let bytecode = &crate::loader::compile_bytecode_from_stdin (source.to_vec ());
let chunk = crate::loader::parse_chunk_from_bytes (bytecode).unwrap ();
assert_eq! (chunk.blocks.len (), 5);
assert_eq! (chunk.blocks [3].upvalues.len (), 2);
for (arg, expected) in [
(vec! ["_exe_name"], vec! [122.into ()]),
(vec! ["_exe_name"], vec! [122.into ()]),
] {
let expected: Vec <Value> = expected;
let mut vm = State::default ();
let upvalues = State::upvalues_from_args (arg.into_iter ().map (|s| s.to_string ()));
let actual = vm.execute_chunk (&file, &upvalues);
let mut vm = State::new (&chunk, &upvalues);
let actual = vm.execute_chunk (&[]);
assert_eq! (actual, expected);
}

View File

@ -11,11 +11,12 @@ use std::{
#[derive (Debug, Eq, PartialEq)]
pub struct BogusClosure {
// I'm pretty sure this should be absolute?
pub idx: usize,
pub upvalues: Vec <Value>,
}
#[derive (Clone, Debug, PartialEq)]
#[derive (Clone, PartialEq)]
pub enum Value {
Nil,
Boolean (bool),
@ -32,7 +33,24 @@ pub enum Value {
// These are all bogus, I haven't figured out how to implement
// closures yet
BogusClosure (Rc <BogusClosure>),
BogusClosure (Rc <RefCell <BogusClosure>>),
}
impl fmt::Debug for Value {
fn fmt (&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
Value::Nil => write! (f, "nil"),
Value::Boolean (false) => write! (f, "false"),
Value::Boolean (true) => write! (f, "true"),
Value::Float (x) => write! (f, "{:?}", x),
Value::Integer (x) => write! (f, "{}", x),
Value::RsFunc (x) => write! (f, "function: {:?}", x),
Value::String (s) => write! (f, "\"{}\"", s),
Value::Table (t) => write! (f, "{:?}", t.borrow ()),
Value::BogusClosure (x) => write! (f, "{:?}", x.borrow ()),
}
}
}
impl Default for Value {
@ -53,11 +71,17 @@ impl fmt::Display for Value {
Value::String (s) => write! (f, "{}", s),
Value::Table (t) => write! (f, "table: {:?}", std::rc::Rc::as_ptr (t)),
Value::BogusClosure (_) => write! (f, "BogusClosure"),
Value::BogusClosure (x) => write! (f, "BogusClosure: {:?}", std::rc::Rc::as_ptr (x)),
}
}
}
impl From <BogusClosure> for Value {
fn from (x: BogusClosure) -> Self {
Self::BogusClosure (Rc::new (RefCell::new (x)))
}
}
impl From <bool> for Value {
fn from (x: bool) -> Self {
Self::Boolean (x)
@ -156,6 +180,13 @@ impl PartialEq <i64> for Value {
}
impl Value {
pub fn as_closure (&self) -> Option <&Rc <RefCell <BogusClosure>>> {
match self {
Self::BogusClosure (x) => Some (x),
_ => None,
}
}
/// Coerces ints to float
pub fn as_float (&self) -> Option <f64> {
@ -200,12 +231,20 @@ impl Value {
}
}
#[derive (Debug, Default, Eq, PartialEq)]
#[derive (Default, Eq, PartialEq)]
pub struct Table {
array: Vec <Value>,
hash: HashMap <Value, Value>,
}
impl fmt::Debug for Table {
fn fmt (&self, f: &mut fmt::Formatter) -> fmt::Result {
write! (f, "Table {:#?}", self.hash)?;
Ok (())
}
}
impl Table {
fn get_inner (&self, key: &Value) -> Value {
self.hash.get (key).cloned ().unwrap_or_default ()

View File

@ -1,11 +1,11 @@
local function make_closure (x)
print (x)
local function make_closure (t)
return function (y)
return x + y
return t.x + y
end
end
local f = make_closure (11)
local f = make_closure ({ x = 11 })
local t = {}
local x = f (12)
print (x)
return x

View File

@ -1,5 +1,7 @@
-- This one fails :( I haven't implemented closures properly yet.
local ii = "bogus"
local function add (aa, bb)
return aa + bb
end
@ -12,6 +14,13 @@ local function fma (ee, ff, gg)
return add (mul (ee, ff), gg)
end
local function run ()
local hh = fma (10, 11, 12)
print (hh)
return hh
end
local hh = run ()
print (ii)
return hh