264 lines
8.7 KiB
Rust
264 lines
8.7 KiB
Rust
use hashbrown::{HashMap, HashSet};
|
|
use inkwell::execution_engine::JitFunction;
|
|
use std::cell::{Cell, OnceCell, RefCell};
|
|
use std::rc::Rc;
|
|
|
|
use crate::builtins::env;
|
|
use crate::bytecode::{BinOp, Func as F, OpCode, OpCodes, Program, UnOp};
|
|
use crate::error::*;
|
|
use crate::jit::{JITContext, JITFunc};
|
|
use crate::stack::Stack;
|
|
use crate::ty::common::Const;
|
|
use crate::ty::internal::*;
|
|
use crate::ty::public::{self as p, Symbol};
|
|
|
|
use derive_more::Constructor;
|
|
use ecow::EcoString;
|
|
pub use env::VmEnv;
|
|
|
|
mod env;
|
|
|
|
#[cfg(test)]
|
|
mod test;
|
|
|
|
const STACK_SIZE: usize = 8 * 1024 / size_of::<Value>();
|
|
|
|
pub fn run(prog: Program, jit: JITContext<'_>) -> Result<p::Value> {
|
|
let vm = VM {
|
|
thunks: prog.thunks,
|
|
funcs: prog.funcs,
|
|
symbols: RefCell::new(prog.symbols),
|
|
symmap: RefCell::new(prog.symmap),
|
|
consts: prog.consts,
|
|
jit,
|
|
};
|
|
let env = env(&vm);
|
|
let mut seen = HashSet::new();
|
|
let value = vm
|
|
.eval(prog.top_level.into_iter(), env.into())?
|
|
.to_public(&vm, &mut seen);
|
|
Ok(value)
|
|
}
|
|
|
|
#[derive(Constructor)]
|
|
pub struct VM<'jit> {
|
|
thunks: Box<[OpCodes]>,
|
|
funcs: Box<[F]>,
|
|
symbols: RefCell<Vec<EcoString>>,
|
|
symmap: RefCell<HashMap<EcoString, usize>>,
|
|
consts: Box<[Const]>,
|
|
jit: JITContext<'jit>,
|
|
}
|
|
|
|
impl<'vm, 'jit: 'vm> VM<'jit> {
|
|
pub fn get_thunk(&self, idx: usize) -> &OpCodes {
|
|
&self.thunks[idx]
|
|
}
|
|
|
|
pub fn get_func(&self, idx: usize) -> &F {
|
|
&self.funcs[idx]
|
|
}
|
|
|
|
pub fn get_sym(&self, idx: usize) -> Symbol {
|
|
self.symbols.borrow()[idx].clone().into()
|
|
}
|
|
|
|
pub fn new_sym(&self, sym: impl Into<EcoString>) -> usize {
|
|
let sym = sym.into();
|
|
if let Some(&idx) = self.symmap.borrow().get(&sym) {
|
|
idx
|
|
} else {
|
|
self.symmap
|
|
.borrow_mut()
|
|
.insert(sym.clone(), self.symbols.borrow().len());
|
|
self.symbols.borrow_mut().push(sym);
|
|
self.symbols.borrow().len() - 1
|
|
}
|
|
}
|
|
|
|
pub fn get_const(&self, idx: usize) -> Const {
|
|
self.consts[idx].clone()
|
|
}
|
|
|
|
pub fn eval(
|
|
&'vm self,
|
|
opcodes: impl Iterator<Item = OpCode>,
|
|
mut env: Rc<VmEnv<'jit, 'vm>>,
|
|
) -> Result<Value<'jit, 'vm>> {
|
|
let mut stack = Stack::<_, STACK_SIZE>::new();
|
|
let mut iter = opcodes.into_iter();
|
|
while let Some(opcode) = iter.next() {
|
|
let jmp = self.single_op(opcode, &mut stack, &mut env)?;
|
|
for _ in 0..jmp {
|
|
iter.next().unwrap();
|
|
}
|
|
}
|
|
assert_eq!(stack.len(), 1);
|
|
let mut ret = stack.pop();
|
|
ret.force(self)?;
|
|
Ok(ret)
|
|
}
|
|
|
|
#[inline(always)]
|
|
fn single_op<'s, const CAP: usize>(
|
|
&'vm self,
|
|
opcode: OpCode,
|
|
stack: &'s mut Stack<Value<'jit, 'vm>, CAP>,
|
|
env: &mut Rc<VmEnv<'jit, 'vm>>,
|
|
) -> Result<usize> {
|
|
match opcode {
|
|
OpCode::Illegal => panic!("illegal opcode"),
|
|
OpCode::Const { idx } => stack.push(Value::Const(self.get_const(idx)))?,
|
|
OpCode::LoadThunk { idx } => {
|
|
stack.push(Value::Thunk(Thunk::new(self.get_thunk(idx)).into()))?
|
|
}
|
|
OpCode::CaptureEnv => stack.tos().as_ref().unwrap_thunk().capture(env.clone()),
|
|
OpCode::ForceValue => {
|
|
stack.tos_mut().force(self)?;
|
|
}
|
|
OpCode::Jmp { step } => return Ok(step),
|
|
OpCode::JmpIfFalse { step } => {
|
|
if let Value::Const(Const::Bool(false)) = stack.pop() {
|
|
return Ok(step);
|
|
}
|
|
}
|
|
OpCode::Call => {
|
|
let arg = stack.pop();
|
|
let func = stack.tos_mut();
|
|
func.force(self)?;
|
|
func.call(self, arg)?;
|
|
}
|
|
OpCode::Func { idx } => {
|
|
let func = self.get_func(idx);
|
|
stack.push(Value::Func(
|
|
Func::new(func, env.clone(), OnceCell::new(), Cell::new(0)).into(),
|
|
))?;
|
|
}
|
|
OpCode::UnOp { op } => {
|
|
use UnOp::*;
|
|
let value = stack.tos_mut();
|
|
value.force(self)?;
|
|
match op {
|
|
Neg => value.neg(),
|
|
Not => value.not(),
|
|
}
|
|
}
|
|
OpCode::BinOp { op } => {
|
|
use BinOp::*;
|
|
let mut rhs = stack.pop();
|
|
let lhs = stack.tos_mut();
|
|
lhs.force(self)?;
|
|
rhs.force(self)?;
|
|
match op {
|
|
Add => lhs.add(rhs),
|
|
Sub => {
|
|
rhs.neg();
|
|
lhs.add(rhs);
|
|
},
|
|
Mul => lhs.mul(rhs),
|
|
Div => lhs.div(rhs)?,
|
|
And => lhs.and(rhs),
|
|
Or => lhs.or(rhs),
|
|
Eq => Value::eq(lhs, rhs),
|
|
Lt => lhs.lt(rhs),
|
|
Con => lhs.concat(rhs),
|
|
Upd => lhs.update(rhs),
|
|
}
|
|
}
|
|
OpCode::ConcatString => {
|
|
let mut rhs = stack.pop();
|
|
rhs.force(self)?;
|
|
stack.tos_mut().concat_string(rhs);
|
|
}
|
|
OpCode::Path => {
|
|
todo!()
|
|
}
|
|
OpCode::List => {
|
|
stack.push(Value::List(List::empty().into()))?;
|
|
}
|
|
OpCode::PushElem => {
|
|
let elem = stack.pop();
|
|
stack.tos_mut().push(elem);
|
|
}
|
|
OpCode::AttrSet { cap } => {
|
|
stack.push(Value::AttrSet(AttrSet::with_capacity(cap).into()))?;
|
|
}
|
|
OpCode::FinalizeRec => {
|
|
env.enter_let(stack.tos().clone().unwrap_attr_set().into_inner());
|
|
stack.tos_mut().as_mut().unwrap_attr_set().capture(env);
|
|
}
|
|
OpCode::PushStaticAttr { name } => {
|
|
let val = stack.pop();
|
|
stack.tos_mut().push_attr(name, val);
|
|
}
|
|
OpCode::PushDynamicAttr => {
|
|
let val = stack.pop();
|
|
let mut sym = stack.pop();
|
|
sym.force(self)?.coerce_to_string();
|
|
let sym = self.new_sym(sym.unwrap_const().unwrap_string());
|
|
stack.tos_mut().push_attr(sym, val);
|
|
}
|
|
OpCode::Select { sym } => {
|
|
stack.tos_mut().force(self)?.select(sym, self)?;
|
|
}
|
|
OpCode::SelectOrDefault { sym } => {
|
|
let default = stack.pop();
|
|
stack
|
|
.tos_mut()
|
|
.force(self)?
|
|
.select_with_default(sym, default)?;
|
|
}
|
|
OpCode::SelectDynamic => {
|
|
let mut val = stack.pop();
|
|
val.force(self)?;
|
|
val.coerce_to_string();
|
|
let sym = self.new_sym(val.unwrap_const().unwrap_string());
|
|
stack.tos_mut().force(self)?.select(sym, self)?;
|
|
}
|
|
OpCode::SelectDynamicOrDefault => {
|
|
let default = stack.pop();
|
|
let mut val = stack.pop();
|
|
val.force(self)?;
|
|
val.coerce_to_string();
|
|
let sym = self.new_sym(val.unwrap_const().unwrap_string());
|
|
stack
|
|
.tos_mut()
|
|
.force(self)?
|
|
.select_with_default(sym, default)?;
|
|
}
|
|
OpCode::HasAttr { sym } => {
|
|
stack.tos_mut().force(self)?.has_attr(sym);
|
|
}
|
|
OpCode::HasDynamicAttr => {
|
|
let mut val = stack.pop();
|
|
val.coerce_to_string();
|
|
let sym = self.new_sym(val.unwrap_const().unwrap_string());
|
|
stack.tos_mut().force(self)?.has_attr(sym);
|
|
}
|
|
OpCode::LookUp { sym } => {
|
|
stack.push(
|
|
env.lookup(&sym)
|
|
.ok_or_else(|| {
|
|
Error::EvalError(format!("{} not found", self.get_sym(sym)))
|
|
})?
|
|
.clone(),
|
|
)?;
|
|
}
|
|
OpCode::EnterLetEnv => env.enter_let(stack.pop().unwrap_attr_set().into_inner()),
|
|
OpCode::LeaveLetEnv => env.leave_let(),
|
|
OpCode::EnterWithEnv => env.enter_with(stack.pop().unwrap_attr_set().into_inner()),
|
|
OpCode::LeaveWithEnv => env.leave_with(),
|
|
OpCode::Assert => {
|
|
if !stack.pop().unwrap_const().unwrap_bool() {
|
|
todo!()
|
|
}
|
|
}
|
|
}
|
|
Ok(0)
|
|
}
|
|
|
|
pub fn compile_func(&'vm self, func: &'vm F) -> JitFunction<'jit, JITFunc<'jit, 'vm>> {
|
|
self.jit.compile_function(func, self).unwrap()
|
|
}
|
|
}
|