feat: JIT (WIP)

src/eval/jit/compile.rs

@@ -1,129 +1,146 @@
-#![allow(unused_variables)]
+use inkwell::values::{BasicValueEnum, FunctionValue};
 
 use crate::ir::*;
+use crate::ty::common as c;
+use crate::ty::internal::Value;
 
 use super::JITContext;
 
 pub trait JITCompile {
-    fn compile<'gc>(self, ctx: &JITContext<'gc>);
+    fn compile<'gc>(self, ctx: &JITContext<'gc>, func: FunctionValue<'gc>) -> BasicValueEnum<'gc>;
 }
 
 impl JITCompile for Attrs {
-    fn compile<'gc>(self, ctx: &JITContext<'gc>) {
+    fn compile<'gc>(self, ctx: &JITContext<'gc>, func: FunctionValue<'gc>) -> BasicValueEnum<'gc> {
         todo!()
     }
 }
 
 impl JITCompile for List {
-    fn compile<'gc>(self, ctx: &JITContext<'gc>) {
+    fn compile<'gc>(self, ctx: &JITContext<'gc>, func: FunctionValue<'gc>) -> BasicValueEnum<'gc> {
         todo!()
     }
 }
 
 impl JITCompile for HasAttr {
-    fn compile<'gc>(self, ctx: &JITContext<'gc>) {
+    fn compile<'gc>(self, ctx: &JITContext<'gc>, func: FunctionValue<'gc>) -> BasicValueEnum<'gc> {
         todo!()
     }
 }
 
 impl JITCompile for BinOp {
-    fn compile<'gc>(self, ctx: &JITContext<'gc>) {
+    fn compile<'gc>(self, ctx: &JITContext<'gc>, func: FunctionValue<'gc>) -> BasicValueEnum<'gc> {
         todo!()
     }
 }
 
 impl JITCompile for UnOp {
-    fn compile<'gc>(self, ctx: &JITContext<'gc>) {
-        todo!()
+    fn compile<'gc>(self, ctx: &JITContext<'gc>, func: FunctionValue<'gc>) -> BasicValueEnum<'gc> {
+        todo!();
+        let rhs = self.rhs.compile(ctx, func);
+        let tag = ctx.get_tag(rhs);
+        let fallback = ctx.context.append_basic_block(func, "fallback");
+        let ret = ctx.context.append_basic_block(func, "fallback");
+        let res = ctx.builder.build_alloca(ctx.helpers.value_type, "res_alloca").unwrap();
+        ctx.builder.build_switch(tag, fallback, &[]).unwrap();
+        ctx.builder.position_at_end(fallback);
+        ctx.builder.position_at_end(ret);
+        ctx.builder.build_load(ctx.helpers.value_type, res, "load_res").unwrap()
     }
 }
 
 impl JITCompile for Select {
-    fn compile<'gc>(self, ctx: &JITContext<'gc>) {
+    fn compile<'gc>(self, ctx: &JITContext<'gc>, func: FunctionValue<'gc>) -> BasicValueEnum<'gc> {
         todo!()
     }
 }
 
 impl JITCompile for If {
-    fn compile<'gc>(self, ctx: &JITContext<'gc>) {
+    fn compile<'gc>(self, ctx: &JITContext<'gc>, func: FunctionValue<'gc>) -> BasicValueEnum<'gc> {
         todo!()
     }
 }
 
 impl JITCompile for LoadFunc {
-    fn compile<'gc>(self, ctx: &JITContext<'gc>) {
+    fn compile<'gc>(self, ctx: &JITContext<'gc>, func: FunctionValue<'gc>) -> BasicValueEnum<'gc> {
         todo!()
     }
 }
 
 impl JITCompile for Call {
-    fn compile<'gc>(self, ctx: &JITContext<'gc>) {
+    fn compile<'gc>(self, ctx: &JITContext<'gc>, func: FunctionValue<'gc>) -> BasicValueEnum<'gc> {
         todo!()
     }
 }
 
 impl JITCompile for Let {
-    fn compile<'gc>(self, ctx: &JITContext<'gc>) {
+    fn compile<'gc>(self, ctx: &JITContext<'gc>, func: FunctionValue<'gc>) -> BasicValueEnum<'gc> {
         todo!()
     }
 }
 
 impl JITCompile for With {
-    fn compile<'gc>(self, ctx: &JITContext<'gc>) {
+    fn compile<'gc>(self, ctx: &JITContext<'gc>, func: FunctionValue<'gc>) -> BasicValueEnum<'gc> {
         todo!()
     }
 }
 
 impl JITCompile for Assert {
-    fn compile<'gc>(self, ctx: &JITContext<'gc>) {
+    fn compile<'gc>(self, ctx: &JITContext<'gc>, func: FunctionValue<'gc>) -> BasicValueEnum<'gc> {
         todo!()
     }
 }
 
 impl JITCompile for ConcatStrings {
-    fn compile<'gc>(self, ctx: &JITContext<'gc>) {
+    fn compile<'gc>(self, ctx: &JITContext<'gc>, func: FunctionValue<'gc>) -> BasicValueEnum<'gc> {
         todo!()
     }
 }
 
 impl JITCompile for Const {
-    fn compile<'gc>(self, ctx: &JITContext<'gc>) {
-        todo!()
+    fn compile<'gc>(self, ctx: &JITContext<'gc>, func: FunctionValue<'gc>) -> BasicValueEnum<'gc> {
+        use c::Const::*;
+        match self.val {
+            Bool(x) => ctx.helpers.new_bool(x),
+            Int(x) => ctx.helpers.new_int(x),
+            Float(x) => ctx.helpers.new_float(x),
+            Null => ctx.helpers.new_null(),
+        }
     }
 }
 
 impl JITCompile for String {
-    fn compile<'gc>(self, ctx: &JITContext<'gc>) {
+    fn compile<'gc>(self, ctx: &JITContext<'gc>, func: FunctionValue<'gc>) -> BasicValueEnum<'gc> {
         todo!()
     }
 }
 
 impl JITCompile for Var {
-    fn compile<'gc>(self, ctx: &JITContext<'gc>) {
+    fn compile<'gc>(self, ctx: &JITContext<'gc>, func: FunctionValue<'gc>) -> BasicValueEnum<'gc> {
         todo!()
     }
 }
 
 impl JITCompile for Arg {
-    fn compile<'gc>(self, ctx: &JITContext<'gc>) {
+    fn compile<'gc>(self, ctx: &JITContext<'gc>, func: FunctionValue<'gc>) -> BasicValueEnum<'gc> {
         todo!()
     }
 }
 
 impl JITCompile for LetVar {
-    fn compile<'gc>(self, ctx: &JITContext<'gc>) {
+    fn compile<'gc>(self, ctx: &JITContext<'gc>, func: FunctionValue<'gc>) -> BasicValueEnum<'gc> {
         todo!()
     }
 }
 
 impl JITCompile for Thunk {
-    fn compile<'gc>(self, ctx: &JITContext<'gc>) {
+    fn compile<'gc>(self, ctx: &JITContext<'gc>, func: FunctionValue<'gc>) -> BasicValueEnum<'gc> {
         todo!()
     }
 }
 
 impl JITCompile for Path {
-    fn compile<'gc>(self, ctx: &JITContext<'gc>) {
+    fn compile<'gc>(self, ctx: &JITContext<'gc>, func: FunctionValue<'gc>) -> BasicValueEnum<'gc> {
         todo!()
     }
 }

src/eval/jit/helpers.rs

@@ -5,7 +5,7 @@ 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 inkwell::values::{BasicValueEnum, FloatValue, FunctionValue, IntValue};
 
 use crate::env::VmEnv;
 use crate::eval::Engine;
@@ -176,20 +176,28 @@ impl<'ctx> Helpers<'ctx> {
         }
     }
 
+    pub fn const_int(&self, int: i64) -> IntValue<'ctx> {
+        self.int_type.const_int(int as _, false)
+    }
+
     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(),
+                self.const_int(int).into()
             ])
             .into()
     }
 
+    pub fn const_float(&self, float: f64) -> FloatValue<'ctx> {
+        self.float_type.const_float(float)
+    }
+
     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(),
+                self.const_float(float).into()
             ])
             .into()
     }

src/eval/jit/mod.rs

@@ -6,8 +6,10 @@ use inkwell::builder::Builder;
 use inkwell::context::Context;
 use inkwell::execution_engine::ExecutionEngine;
 use inkwell::module::Module;
+use inkwell::values::{AnyValue, AsValueRef, BasicMetadataValueEnum, BasicValueEnum, IntValue, StructValue};
 
 use crate::env::VmEnv;
+use crate::ir::{Ir, UnOpKind};
 use crate::ty::internal::Value;
 
 mod compile;
@@ -135,4 +137,30 @@ impl<'ctx> JITContext<'ctx> {
             helpers,
         }
     }
+
+    pub fn compile(&self, ir: Ir) -> JITFunc {
+        
+    }
+
+    pub fn get_tag(&self, val: BasicValueEnum<'ctx>) -> IntValue<'ctx> {
+        let alloca = self
+                    .builder
+                    .build_alloca(self.helpers.value_type, "get_tag_alloca").unwrap();
+        self.builder.build_store(alloca, val).unwrap();
+        self.builder
+            .build_load(
+                self.context.bool_type(),
+                self.builder
+                    .build_struct_gep(self.helpers.value_type, alloca, 1, "get_tag_gep").unwrap(),
+                "get_tag",
+            ).unwrap()
+            .into_int_value()
+    }
+
+    pub fn call(&self, args: &[BasicMetadataValueEnum<'ctx>]) -> StructValue<'ctx> {
+        self.builder.build_call(self.helpers.call, args, "call")
+            .unwrap()
+            .as_any_value_enum()
+            .into_struct_value()
+    }
 }