chore: cleanup

src/eval/jit/compile.rs

@@ -0,0 +1,129 @@
+#![allow(unused_variables)]
+
+use crate::ir::*;
+
+use super::JITContext;
+
+pub trait JITCompile {
+    fn compile<'gc>(self, ctx: &JITContext<'gc>);
+}
+
+impl JITCompile for Attrs {
+    fn compile<'gc>(self, ctx: &JITContext<'gc>) {
+        todo!()
+    }
+}
+
+impl JITCompile for List  {
+    fn compile<'gc>(self, ctx: &JITContext<'gc>) {
+        todo!()
+    }
+}
+
+impl JITCompile for HasAttr {
+    fn compile<'gc>(self, ctx: &JITContext<'gc>) {
+        todo!()
+    }
+}
+
+impl JITCompile for BinOp {
+    fn compile<'gc>(self, ctx: &JITContext<'gc>) {
+        todo!()
+    }
+}
+
+impl JITCompile for UnOp  {
+    fn compile<'gc>(self, ctx: &JITContext<'gc>) {
+        todo!()
+    }
+}
+
+impl JITCompile for Select {
+    fn compile<'gc>(self, ctx: &JITContext<'gc>) {
+        todo!()
+    }
+}
+
+impl JITCompile for If {
+    fn compile<'gc>(self, ctx: &JITContext<'gc>) {
+        todo!()
+    }
+}
+
+impl JITCompile for LoadFunc {
+    fn compile<'gc>(self, ctx: &JITContext<'gc>) {
+        todo!()
+    }
+}
+
+impl JITCompile for Call {
+    fn compile<'gc>(self, ctx: &JITContext<'gc>) {
+        todo!()
+    }
+}
+
+impl JITCompile for Let {
+    fn compile<'gc>(self, ctx: &JITContext<'gc>) {
+        todo!()
+    }
+}
+
+impl JITCompile for With {
+    fn compile<'gc>(self, ctx: &JITContext<'gc>) {
+        todo!()
+    }
+}
+
+impl JITCompile for Assert {
+    fn compile<'gc>(self, ctx: &JITContext<'gc>) {
+        todo!()
+    }
+}
+
+impl JITCompile for ConcatStrings {
+    fn compile<'gc>(self, ctx: &JITContext<'gc>) {
+        todo!()
+    }
+}
+
+impl JITCompile for Const {
+    fn compile<'gc>(self, ctx: &JITContext<'gc>) {
+        todo!()
+    }
+}
+ 
+impl JITCompile for String {
+    fn compile<'gc>(self, ctx: &JITContext<'gc>) {
+        todo!()
+    }
+}
+ 
+impl JITCompile for Var {
+    fn compile<'gc>(self, ctx: &JITContext<'gc>) {
+        todo!()
+    }
+}
+
+impl JITCompile for Arg {
+    fn compile<'gc>(self, ctx: &JITContext<'gc>) {
+        todo!()
+    }
+}
+
+impl JITCompile for LetVar {
+    fn compile<'gc>(self, ctx: &JITContext<'gc>) {
+        todo!()
+    }
+}
+
+impl JITCompile for Thunk {
+    fn compile<'gc>(self, ctx: &JITContext<'gc>) {
+        todo!()
+    }
+}
+
+impl JITCompile for Path {
+    fn compile<'gc>(self, ctx: &JITContext<'gc>) {
+            todo!()
+    }
+}

src/eval/jit/helpers.rs

@@ -0,0 +1,373 @@
+use std::ptr::NonNull;
+use std::rc::Rc;
+
+use inkwell::AddressSpace;
+use inkwell::context::Context;
+use inkwell::execution_engine::ExecutionEngine;
+use inkwell::module::Module;
+use inkwell::types::{FloatType, FunctionType, IntType, PointerType, StructType};
+use inkwell::values::{BasicValueEnum, FunctionValue};
+
+use crate::env::VmEnv;
+use crate::eval::Engine;
+use crate::ty::internal::{Thunk, Value};
+
+use super::{JITContext, JITValue, ValueTag, JITValueData};
+
+pub struct Helpers<'ctx> {
+    pub int_type: IntType<'ctx>,
+    pub float_type: FloatType<'ctx>,
+    pub bool_type: IntType<'ctx>,
+    pub ptr_int_type: IntType<'ctx>,
+    pub ptr_type: PointerType<'ctx>,
+    pub value_type: StructType<'ctx>,
+    pub func_type: FunctionType<'ctx>,
+
+    pub new_thunk: FunctionValue<'ctx>,
+
+    pub debug: FunctionValue<'ctx>,
+    pub capture_env: FunctionValue<'ctx>,
+    pub neg: FunctionValue<'ctx>,
+    pub not: FunctionValue<'ctx>,
+    pub add: FunctionValue<'ctx>,
+    pub sub: FunctionValue<'ctx>,
+    pub eq: FunctionValue<'ctx>,
+    pub or: FunctionValue<'ctx>,
+    pub call: FunctionValue<'ctx>,
+    pub arg: FunctionValue<'ctx>,
+    pub lookup_let: FunctionValue<'ctx>,
+    pub lookup: FunctionValue<'ctx>,
+    pub force: FunctionValue<'ctx>,
+}
+
+impl<'ctx> Helpers<'ctx> {
+    pub fn new(
+        context: &'ctx Context,
+        module: &Module<'ctx>,
+        execution_engine: &ExecutionEngine<'ctx>,
+    ) -> Self {
+        let int_type = context.i64_type();
+        let float_type = context.f64_type();
+        let bool_type = context.bool_type();
+        let ptr_int_type = context.ptr_sized_int_type(execution_engine.get_target_data(), None);
+        let ptr_type = context.ptr_type(AddressSpace::default());
+        let value_type = context.struct_type(&[int_type.into(), int_type.into()], false);
+        let func_type = value_type.fn_type(&[ptr_type.into()], false);
+
+        let new_thunk = module.add_function(
+            "new_thunk",
+            value_type.fn_type(&[ptr_type.into()], false),
+            None,
+        );
+        let debug = module.add_function(
+            "debug",
+            context.void_type().fn_type(&[value_type.into()], false),
+            None,
+        );
+        let capture_env = module.add_function(
+            "capture_env",
+            context
+                .void_type()
+                .fn_type(&[value_type.into(), ptr_type.into()], false),
+            None,
+        );
+        let neg = module.add_function(
+            "neg",
+            value_type.fn_type(&[value_type.into(), ptr_type.into()], false),
+            None,
+        );
+        let not = module.add_function(
+            "not",
+            value_type.fn_type(&[value_type.into(), ptr_type.into()], false),
+            None,
+        );
+        let add = module.add_function(
+            "add",
+            value_type.fn_type(&[value_type.into(), value_type.into()], false),
+            None,
+        );
+        let sub = module.add_function(
+            "sub",
+            value_type.fn_type(&[value_type.into(), value_type.into()], false),
+            None,
+        );
+        let eq = module.add_function(
+            "eq",
+            value_type.fn_type(&[value_type.into(), value_type.into()], false),
+            None,
+        );
+        let or = module.add_function(
+            "or",
+            value_type.fn_type(&[value_type.into(), value_type.into()], false),
+            None,
+        );
+        let call = module.add_function(
+            "call",
+            value_type.fn_type(
+                &[value_type.into(), value_type.into(), ptr_type.into()],
+                false,
+            ),
+            None,
+        );
+        let arg = module.add_function(
+            "arg",
+            value_type.fn_type(&[ptr_int_type.into(), ptr_type.into()], false),
+            None,
+        );
+        let lookup_let = module.add_function(
+            "lookup_let",
+            value_type.fn_type(
+                &[ptr_int_type.into(), ptr_int_type.into(), ptr_type.into()],
+                false,
+            ),
+            None,
+        );
+        let lookup = module.add_function(
+            "lookup",
+            value_type.fn_type(&[ptr_int_type.into(), ptr_type.into()], false),
+            None,
+        );
+        let force = module.add_function(
+            "force",
+            value_type.fn_type(
+                &[value_type.into(), ptr_type.into(), ptr_type.into()],
+                false,
+            ),
+            None,
+        );
+
+        execution_engine.add_global_mapping(&new_thunk, helper_new_thunk as _);
+        execution_engine.add_global_mapping(&debug, helper_debug as _);
+        execution_engine.add_global_mapping(&capture_env, helper_capture_env as _);
+        execution_engine.add_global_mapping(&neg, helper_neg as _);
+        execution_engine.add_global_mapping(&not, helper_not as _);
+        execution_engine.add_global_mapping(&add, helper_add as _);
+        execution_engine.add_global_mapping(&sub, helper_sub as _);
+        execution_engine.add_global_mapping(&eq, helper_eq as _);
+        execution_engine.add_global_mapping(&or, helper_or as _);
+        execution_engine.add_global_mapping(&call, helper_call as _);
+        execution_engine.add_global_mapping(&arg, helper_arg as _);
+        execution_engine.add_global_mapping(&lookup_let, helper_lookup_let as _);
+        execution_engine.add_global_mapping(&lookup, helper_lookup as _);
+        execution_engine.add_global_mapping(&force, helper_force as _);
+
+        Helpers {
+            int_type,
+            float_type,
+            bool_type,
+            ptr_int_type,
+            ptr_type,
+            value_type,
+            func_type,
+
+            new_thunk,
+
+            debug,
+            capture_env,
+            neg,
+            not,
+            add,
+            sub,
+            eq,
+            or,
+            call,
+            arg,
+            lookup_let,
+            lookup,
+            force,
+        }
+    }
+
+    pub fn new_int(&self, int: i64) -> BasicValueEnum<'ctx> {
+        self.value_type
+            .const_named_struct(&[
+                self.int_type.const_int(ValueTag::Int as _, false).into(),
+                self.int_type.const_int(int as _, false).into(),
+            ])
+            .into()
+    }
+
+    pub fn new_float(&self, float: f64) -> BasicValueEnum<'ctx> {
+        self.value_type
+            .const_named_struct(&[
+                self.int_type.const_int(ValueTag::Float as _, false).into(),
+                self.float_type.const_float(float).into(),
+            ])
+            .into()
+    }
+
+    pub fn new_bool(&self, bool: bool) -> BasicValueEnum<'ctx> {
+        self.value_type
+            .const_named_struct(&[
+                self.int_type.const_int(ValueTag::Bool as _, false).into(),
+                self.bool_type.const_int(bool as _, false).into(),
+            ])
+            .into()
+    }
+
+    pub fn new_null(&self) -> BasicValueEnum<'ctx> {
+        self.value_type
+            .const_named_struct(&[
+                self.int_type.const_int(ValueTag::Null as _, false).into(),
+                self.int_type.const_zero().into(),
+            ])
+            .into()
+    }
+
+    pub fn const_string(&self, string: *const u8) -> BasicValueEnum<'ctx> {
+        self.value_type
+            .const_named_struct(&[
+                self.int_type.const_int(ValueTag::String as _, false).into(),
+                self.ptr_int_type.const_int(string as _, false).into(),
+            ])
+            .into()
+    }
+}
+
+extern "C" fn helper_debug(value: JITValue) {
+    dbg!(value.tag);
+}
+
+extern "C" fn helper_capture_env<'gc>(thunk: JITValue, env: *const VmEnv<'gc>) {
+    let thunk = unsafe { (thunk.data.ptr as *const Thunk).as_ref().unwrap() };
+    let env = unsafe { Rc::from_raw(env) };
+    thunk.capture_env(env.clone());
+    std::mem::forget(env);
+}
+
+extern "C" fn helper_neg(rhs: JITValue, _env: *const VmEnv) -> JITValue {
+    use ValueTag::*;
+    match rhs.tag {
+        Int => JITValue {
+            tag: Int,
+            data: JITValueData {
+                int: -unsafe { rhs.data.int },
+            },
+        },
+        Float => JITValue {
+            tag: Float,
+            data: JITValueData {
+                float: -unsafe { rhs.data.float },
+            },
+        },
+        _ => todo!(),
+    }
+}
+
+extern "C" fn helper_not(rhs: JITValue, _env: *const VmEnv) -> JITValue {
+    use ValueTag::*;
+    match rhs.tag {
+        Bool => JITValue {
+            tag: Bool,
+            data: JITValueData {
+                bool: !unsafe { rhs.data.bool },
+            },
+        },
+        _ => todo!(),
+    }
+}
+
+extern "C" fn helper_add(lhs: JITValue, rhs: JITValue) -> JITValue {
+    use ValueTag::*;
+    match (lhs.tag, rhs.tag) {
+        (Int, Int) => JITValue {
+            tag: Int,
+            data: JITValueData {
+                int: unsafe { lhs.data.int + rhs.data.int },
+            },
+        },
+        _ => todo!(
+            "Addition not implemented for {:?} and {:?}",
+            lhs.tag,
+            rhs.tag
+        ),
+    }
+}
+
+extern "C" fn helper_sub(lhs: JITValue, rhs: JITValue) -> JITValue {
+    use ValueTag::*;
+    match (lhs.tag, rhs.tag) {
+        (Int, Int) => JITValue {
+            tag: Int,
+            data: JITValueData {
+                int: unsafe { lhs.data.int - rhs.data.int },
+            },
+        },
+        _ => todo!(
+            "Substruction not implemented for {:?} and {:?}",
+            lhs.tag,
+            rhs.tag
+        ),
+    }
+}
+
+extern "C" fn helper_eq(lhs: JITValue, rhs: JITValue) -> JITValue {
+    use ValueTag::*;
+    match (lhs.tag, rhs.tag) {
+        (Int, Int) => JITValue {
+            tag: Bool,
+            data: JITValueData {
+                bool: unsafe { lhs.data.int == rhs.data.int },
+            },
+        },
+        _ => todo!(
+            "Equation not implemented for {:?} and {:?}",
+            lhs.tag,
+            rhs.tag
+        ),
+    }
+}
+
+extern "C" fn helper_or(lhs: JITValue, rhs: JITValue) -> JITValue {
+    use ValueTag::*;
+    match (lhs.tag, rhs.tag) {
+        (Bool, Bool) => JITValue {
+            tag: Bool,
+            data: JITValueData {
+                bool: unsafe { lhs.data.bool || rhs.data.bool },
+            },
+        },
+        _ => todo!(
+            "Substraction not implemented for {:?} and {:?}",
+            lhs.tag,
+            rhs.tag
+        ),
+    }
+}
+
+extern "C" fn helper_call<'gc>(func: JITValue, arg: JITValue, engine: *mut Engine) -> JITValue {
+    todo!()
+}
+
+extern "C" fn helper_arg(idx: usize, env: *const VmEnv) -> JITValue {
+    let env = unsafe { env.as_ref() }.unwrap();
+    let val: JITValue = env.lookup_arg(idx).clone().into();
+    val
+}
+
+extern "C" fn helper_lookup_let(level: usize, idx: usize, env: *const VmEnv) -> JITValue {
+    let env = unsafe { env.as_ref() }.unwrap();
+    let val: JITValue = env.lookup_let(level, idx).clone().into();
+    val
+}
+
+extern "C" fn helper_lookup(sym: usize, env: *const VmEnv) -> JITValue {
+    let env = unsafe { env.as_ref() }.unwrap();
+    let val: JITValue = env.lookup_with(&sym).unwrap().clone().into();
+    val
+}
+
+extern "C" fn helper_force<'gc>(
+    thunk: JITValue,
+    vm: NonNull<Engine>,
+    jit: *const JITContext<'gc>,
+) -> JITValue {
+    if !matches!(thunk.tag, ValueTag::Thunk) {
+        return thunk;
+    }
+    todo!()
+}
+
+extern "C" fn helper_new_thunk(opcodes: *const ()) -> JITValue {
+    todo!()
+}

src/eval/jit/mod.rs

@@ -0,0 +1,140 @@
+use std::ops::Deref;
+use std::rc::Rc;
+use std::marker::PhantomData;
+
+use inkwell::OptimizationLevel;
+use inkwell::builder::Builder;
+use inkwell::context::Context;
+use inkwell::execution_engine::ExecutionEngine;
+use inkwell::module::Module;
+
+use crate::env::VmEnv;
+use crate::ty::internal::{Value, Thunk};
+
+mod helpers;
+mod compile;
+
+pub use compile::JITCompile;
+use helpers::Helpers;
+
+#[cfg(test)]
+mod test;
+
+#[repr(u64)]
+#[derive(Debug, Clone, Copy)]
+pub enum ValueTag {
+    Null,
+    Int,
+    Float,
+    String,
+    Bool,
+    AttrSet,
+    List,
+    Function,
+    Thunk,
+    Path,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct JITValue {
+    tag: ValueTag,
+    data: JITValueData,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub union JITValueData {
+    int: i64,
+    float: f64,
+    bool: bool,
+    ptr: *const (),
+}
+
+impl<'gc> From<JITValue> for Value<'gc> {
+    fn from(value: JITValue) -> Self {
+        use ValueTag::*;
+        match value.tag {
+            Int => Value::Int(unsafe { value.data.int }),
+            Null => Value::Null,
+            Function => Value::Func(unsafe { Rc::from_raw(value.data.ptr as *const _) }),
+            Thunk => Value::Thunk(self::Thunk {
+                thunk: unsafe { Rc::from_raw(value.data.ptr as *const _) },
+            }),
+            _ => todo!("not implemented for {:?}", value.tag),
+        }
+    }
+}
+
+impl From<Value<'_>> for JITValue {
+    fn from(value: Value) -> Self {
+        match value {
+            Value::Int(int) => JITValue {
+                tag: ValueTag::Int,
+                data: JITValueData { int },
+            },
+            Value::Func(func) => JITValue {
+                tag: ValueTag::Function,
+                data: JITValueData {
+                    ptr: Rc::into_raw(func) as *const _,
+                },
+            },
+            Value::Thunk(thunk) => JITValue {
+                tag: ValueTag::Thunk,
+                data: JITValueData {
+                    ptr: Rc::into_raw(thunk.thunk) as *const _,
+                },
+            },
+            _ => todo!(),
+        }
+    }
+}
+
+pub struct JITFunc<'gc>(F<'gc>, PhantomData<&'gc mut ()>);
+type F<'gc> = unsafe extern "C" fn(*const VmEnv<'gc>) -> JITValue;
+
+impl<'gc> From<F<'gc>> for JITFunc<'gc> {
+    fn from(value: F<'gc>) -> Self {
+        Self(value, PhantomData)
+    }
+}
+
+impl<'gc> Deref for JITFunc<'gc> {
+    type Target = F<'gc>;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+
+pub struct JITContext<'ctx> {
+    context: &'ctx Context,
+    module: Module<'ctx>,
+    builder: Builder<'ctx>,
+    execution_engine: ExecutionEngine<'ctx>,
+
+    helpers: Helpers<'ctx>,
+}
+
+impl<'ctx> JITContext<'ctx> {
+    pub fn new(context: &'ctx Context) -> Self {
+        // force linker to link JIT engine
+        unsafe {
+            inkwell::llvm_sys::execution_engine::LLVMLinkInMCJIT();
+        }
+        let module = context.create_module("nixjit");
+        let execution_engine = module
+            .create_jit_execution_engine(OptimizationLevel::Aggressive)
+            .unwrap();
+        let helpers = Helpers::new(context, &module, &execution_engine);
+
+        JITContext {
+            execution_engine,
+            builder: context.create_builder(),
+            context,
+            module,
+
+            helpers,
+        }
+    }
+}

src/eval/jit/test.rs

@@ -0,0 +1,91 @@
+#![allow(unused)]
+
+extern crate test;
+
+use hashbrown::{HashMap, HashSet};
+
+use inkwell::context::Context;
+
+use ecow::EcoString;
+
+use crate::ir::downgrade;
+use super::JITContext;
+use crate::ty::common::Const;
+use crate::ty::public::*;
+
+#[inline]
+fn test_expr(expr: &str, expected: Value) {
+    todo!()
+}
+
+macro_rules! map {
+    ($($k:expr => $v:expr),*) => {
+        {
+            #[allow(unused_mut)]
+            let mut m = HashMap::new();
+            $(
+                m.insert($k, $v);
+            )*
+            m
+        }
+    };
+}
+
+macro_rules! thunk {
+    () => {
+        Value::Thunk
+    };
+}
+
+macro_rules! int {
+    ($e:expr) => {
+        Value::Const(Const::Int($e))
+    };
+}
+
+macro_rules! float {
+    ($e:expr) => {
+        Value::Const(Const::Float($e as f64))
+    };
+}
+
+macro_rules! boolean {
+    ($e:expr) => {
+        Value::Const(Const::Bool($e))
+    };
+}
+
+macro_rules! string {
+    ($e:expr) => {
+        Value::Const(Const::String(EcoString::from($e)))
+    };
+}
+
+macro_rules! symbol {
+    ($e:expr) => {
+        Symbol::from($e.to_string())
+    };
+}
+
+macro_rules! list {
+    ($($x:tt)*) => (
+        Value::List(List::new(vec![$($x)*]))
+    );
+}
+
+macro_rules! attrs {
+    ($($x:tt)*) => (
+        Value::AttrSet(AttrSet::new(map!{$($x)*}))
+    )
+}
+
+#[test]
+fn test_jit_const() {
+    // test_expr("let f = _: 1; in (f 1) + (f 1)", int!(2));
+    test_expr("let f = _: 1; in (f 1) == (f 1)", boolean!(true));
+}
+
+#[test]
+fn test_arith() {
+    test_expr("let f = _: -(-1); in (f 1) + (f 1)", int!(2));
+}