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!()
     }
 }