imxyy1soope1/nixjit
1
0
Fork 0
Code Issues Pull Requests Actions Projects 1 Releases Activity

refactor: reduce coupling

Browse Source
This commit is contained in:
imxyy_soope_
2025-07-28 21:37:27 +08:00
parent 78e3c5a26e
commit 7afb2a7b1c
53 changed files with 2964 additions and 3444 deletions
Download Patch File Download Diff File Expand all files Collapse all files

537
evaluator/nixjit_jit/src/compile.rs Normal file
View File

@@ -0,0 +1,537 @@
use cranelift::codegen::ir::{self, StackSlot};
use cranelift::prelude::*;
use nixjit_eval::{EvalContext, Value};
use nixjit_ir::*;
use nixjit_lir::Lir;
use super::{Context, JITContext};
pub trait JITCompile<Ctx: JITContext> {
fn compile(&self, ctx: &mut Context<Ctx>, engine: ir::Value, env: ir::Value) -> StackSlot;
}
impl<Ctx: JITContext> JITCompile<Ctx> for ExprId {
fn compile(&self, ctx: &mut Context<Ctx>, engine: ir::Value, env: ir::Value) -> StackSlot {
todo!()
}
}
impl<Ctx: JITContext> JITCompile<Ctx> for Lir {
fn compile(&self, ctx: &mut Context<Ctx>, engine: ir::Value, env: ir::Value) -> StackSlot {
todo!()
}
}
impl<Ctx: JITContext> JITCompile<Ctx> for AttrSet {
fn compile(&self, ctx: &mut Context<Ctx>, engine: ir::Value, env: ir::Value) -> StackSlot {
let attrs = ctx.create_attrs();
for (k, v) in self.stcs.iter() {
let v = v.compile(ctx, engine, env);
ctx.push_attr(attrs, k, v);
}
ctx.finalize_attrs(attrs)
}
}
impl<Ctx: JITContext> JITCompile<Ctx> for List {
fn compile(&self, ctx: &mut Context<Ctx>, engine: ir::Value, env: ir::Value) -> StackSlot {
let array = ctx.alloc_array(self.items.len());
for (i, item) in self.items.iter().enumerate() {
let item = item.compile(ctx, engine, env);
let tag = ctx.builder.ins().stack_load(types::I64, item, 0);
let val0 = ctx.builder.ins().stack_load(types::I64, item, 8);
let val1 = ctx.builder.ins().stack_load(types::I64, item, 16);
let val2 = ctx.builder.ins().stack_load(types::I64, item, 24);
ctx.builder
.ins()
.store(MemFlags::new(), tag, array, i as i32 * 32);
ctx.builder
.ins()
.store(MemFlags::new(), val0, array, i as i32 * 32 + 8);
ctx.builder
.ins()
.store(MemFlags::new(), val1, array, i as i32 * 32 + 16);
ctx.builder
.ins()
.store(MemFlags::new(), val2, array, i as i32 * 32 + 24);
}
ctx.create_list(array, self.items.len())
}
}
impl<Ctx: JITContext> JITCompile<Ctx> for HasAttr {
fn compile(&self, ctx: &mut Context<Ctx>, engine: ir::Value, env: ir::Value) -> StackSlot {
todo!()
}
}
impl<Ctx: JITContext> JITCompile<Ctx> for BinOp {
fn compile(&self, ctx: &mut Context<Ctx>, engine: ir::Value, env: ir::Value) -> StackSlot {
use BinOpKind::*;
let lhs = self.lhs.compile(ctx, engine, env);
let rhs = self.rhs.compile(ctx, engine, env);
let lhs_tag = ctx.get_tag(lhs);
let rhs_tag = ctx.get_tag(rhs);
let eq = ctx.builder.ins().icmp(IntCC::Equal, lhs_tag, rhs_tag);
let eq_block = ctx.builder.create_block();
let neq_block = ctx.builder.create_block();
let exit_block = ctx.builder.create_block();
ctx.builder.ins().brif(eq, eq_block, [], neq_block, []);
match self.kind {
Add => {
ctx.builder.switch_to_block(eq_block);
let default_block = ctx.builder.create_block();
let int_block = ctx.builder.create_block();
let float_block = ctx.builder.create_block();
let float_check_block = ctx.builder.create_block();
let is_int =
ctx.builder
.ins()
.icmp_imm(IntCC::Equal, lhs_tag, Value::<Ctx>::INT as i64);
ctx.builder
.ins()
.brif(is_int, int_block, [], float_check_block, []);
ctx.builder.switch_to_block(int_block);
let lhs_value = ctx.get_small_value(types::I64, lhs);
let rhs_value = ctx.get_small_value(types::I64, rhs);
let result = ctx.builder.ins().iadd(lhs_value, rhs_value);
ctx.builder.ins().stack_store(lhs_tag, lhs, 0);
ctx.builder.ins().stack_store(result, lhs, 8);
ctx.builder.ins().jump(exit_block, &[]);
// FIXME: Non-float
ctx.builder.switch_to_block(float_check_block);
let is_float =
ctx.builder
.ins()
.icmp_imm(IntCC::Equal, lhs_tag, Value::<Ctx>::FLOAT as i64);
ctx.builder
.ins()
.brif(is_float, float_block, [], default_block, []);
ctx.builder.switch_to_block(float_block);
let lhs_value = ctx.get_small_value(types::F64, lhs);
let rhs_value = ctx.get_small_value(types::F64, rhs);
let result = ctx.builder.ins().fadd(lhs_value, rhs_value);
ctx.builder.ins().stack_store(lhs_tag, lhs, 0);
ctx.builder.ins().stack_store(result, lhs, 8);
ctx.builder.ins().jump(exit_block, &[]);
// FIXME: finish this
ctx.builder.switch_to_block(default_block);
ctx.builder.ins().trap(TrapCode::unwrap_user(1));
ctx.builder.switch_to_block(neq_block);
ctx.builder.ins().trap(TrapCode::unwrap_user(1));
ctx.builder.seal_block(default_block);
ctx.builder.seal_block(int_block);
ctx.builder.seal_block(float_check_block);
ctx.builder.seal_block(float_block);
}
Sub => {
ctx.builder.switch_to_block(eq_block);
let default_block = ctx.builder.create_block();
let int_block = ctx.builder.create_block();
let float_block = ctx.builder.create_block();
let float_check_block = ctx.builder.create_block();
let is_int =
ctx.builder
.ins()
.icmp_imm(IntCC::Equal, lhs_tag, Value::<Ctx>::INT as i64);
ctx.builder
.ins()
.brif(is_int, int_block, [], float_check_block, []);
ctx.builder.switch_to_block(int_block);
let lhs_value = ctx.get_small_value(types::I64, lhs);
let rhs_value = ctx.get_small_value(types::I64, rhs);
let result = ctx.builder.ins().isub(lhs_value, rhs_value);
ctx.builder.ins().stack_store(lhs_tag, lhs, 0);
ctx.builder.ins().stack_store(result, lhs, 8);
ctx.builder.ins().jump(exit_block, &[]);
// FIXME: Non-float
ctx.builder.switch_to_block(float_check_block);
let is_float =
ctx.builder
.ins()
.icmp_imm(IntCC::Equal, lhs_tag, Value::<Ctx>::FLOAT as i64);
ctx.builder
.ins()
.brif(is_float, float_block, [], default_block, []);
ctx.builder.switch_to_block(float_block);
let lhs_value = ctx.get_small_value(types::F64, lhs);
let rhs_value = ctx.get_small_value(types::F64, rhs);
let result = ctx.builder.ins().fsub(lhs_value, rhs_value);
ctx.builder.ins().stack_store(lhs_tag, lhs, 0);
ctx.builder.ins().stack_store(result, lhs, 8);
ctx.builder.ins().jump(exit_block, &[]);
// FIXME: finish this
ctx.builder.switch_to_block(default_block);
ctx.builder.ins().trap(TrapCode::unwrap_user(1));
ctx.builder.switch_to_block(neq_block);
ctx.builder.ins().trap(TrapCode::unwrap_user(1));
ctx.builder.seal_block(default_block);
ctx.builder.seal_block(int_block);
ctx.builder.seal_block(float_check_block);
ctx.builder.seal_block(float_block);
}
Div => {
ctx.builder.switch_to_block(eq_block);
let default_block = ctx.builder.create_block();
let int_block = ctx.builder.create_block();
let float_block = ctx.builder.create_block();
let float_check_block = ctx.builder.create_block();
let is_int =
ctx.builder
.ins()
.icmp_imm(IntCC::Equal, lhs_tag, Value::<Ctx>::INT as i64);
ctx.builder
.ins()
.brif(is_int, int_block, [], float_check_block, []);
ctx.builder.switch_to_block(int_block);
let lhs_value = ctx.get_small_value(types::I64, lhs);
let rhs_value = ctx.get_small_value(types::I64, rhs);
let result = ctx.builder.ins().sdiv(lhs_value, rhs_value);
ctx.builder.ins().stack_store(lhs_tag, lhs, 0);
ctx.builder.ins().stack_store(result, lhs, 8);
ctx.builder.ins().jump(exit_block, &[]);
// FIXME: Non-float
ctx.builder.switch_to_block(float_check_block);
let is_float =
ctx.builder
.ins()
.icmp_imm(IntCC::Equal, lhs_tag, Value::<Ctx>::FLOAT as i64);
ctx.builder
.ins()
.brif(is_float, float_block, [], default_block, []);
ctx.builder.switch_to_block(float_block);
let lhs_value = ctx.get_small_value(types::F64, lhs);
let rhs_value = ctx.get_small_value(types::F64, rhs);
let result = ctx.builder.ins().fdiv(lhs_value, rhs_value);
ctx.builder.ins().stack_store(lhs_tag, lhs, 0);
ctx.builder.ins().stack_store(result, lhs, 8);
ctx.builder.ins().jump(exit_block, &[]);
// FIXME: finish this
ctx.builder.switch_to_block(default_block);
ctx.builder.ins().trap(TrapCode::unwrap_user(1));
ctx.builder.switch_to_block(neq_block);
ctx.builder.ins().trap(TrapCode::unwrap_user(1));
ctx.builder.seal_block(default_block);
ctx.builder.seal_block(int_block);
ctx.builder.seal_block(float_check_block);
ctx.builder.seal_block(float_block);
}
And => {
ctx.builder.switch_to_block(eq_block);
let bool_block = ctx.builder.create_block();
let non_bool_block = ctx.builder.create_block();
let is_bool =
ctx.builder
.ins()
.icmp_imm(IntCC::Equal, lhs_tag, Value::<Ctx>::BOOL as i64);
ctx.builder
.ins()
.brif(is_bool, bool_block, [], non_bool_block, []);
ctx.builder.switch_to_block(bool_block);
let lhs_value = ctx.get_small_value(types::I64, lhs);
let rhs_value = ctx.get_small_value(types::I64, rhs);
let result = ctx.builder.ins().band(lhs_value, rhs_value);
ctx.builder.ins().stack_store(lhs_tag, lhs, 0);
ctx.builder.ins().stack_store(result, lhs, 8);
ctx.builder.ins().jump(exit_block, []);
ctx.builder.switch_to_block(non_bool_block);
ctx.builder.ins().trap(TrapCode::unwrap_user(1));
ctx.builder.switch_to_block(neq_block);
ctx.builder.ins().trap(TrapCode::unwrap_user(1));
ctx.builder.seal_block(bool_block);
ctx.builder.seal_block(non_bool_block);
}
Or => {
ctx.builder.switch_to_block(eq_block);
let bool_block = ctx.builder.create_block();
let non_bool_block = ctx.builder.create_block();
let is_bool =
ctx.builder
.ins()
.icmp_imm(IntCC::Equal, lhs_tag, Value::<Ctx>::BOOL as i64);
ctx.builder
.ins()
.brif(is_bool, bool_block, [], non_bool_block, []);
ctx.builder.switch_to_block(bool_block);
let lhs_value = ctx.get_small_value(types::I64, lhs);
let rhs_value = ctx.get_small_value(types::I64, rhs);
let result = ctx.builder.ins().bor(lhs_value, rhs_value);
ctx.builder.ins().stack_store(lhs_tag, lhs, 0);
ctx.builder.ins().stack_store(result, lhs, 8);
ctx.builder.ins().jump(exit_block, []);
ctx.builder.switch_to_block(non_bool_block);
ctx.builder.ins().trap(TrapCode::unwrap_user(1));
ctx.builder.switch_to_block(neq_block);
ctx.builder.ins().trap(TrapCode::unwrap_user(1));
ctx.builder.seal_block(bool_block);
ctx.builder.seal_block(non_bool_block);
}
Eq => {
ctx.builder.switch_to_block(eq_block);
ctx.eq(lhs, rhs);
ctx.builder.ins().jump(exit_block, []);
ctx.builder.switch_to_block(neq_block);
ctx.eq(lhs, rhs);
ctx.builder.ins().jump(exit_block, []);
}
_ => todo!(),
}
ctx.builder.seal_block(exit_block);
ctx.builder.seal_block(eq_block);
ctx.builder.seal_block(neq_block);
ctx.builder.switch_to_block(exit_block);
ctx.free_slot(rhs);
lhs
}
}
impl<Ctx: JITContext> JITCompile<Ctx> for UnOp {
fn compile(&self, ctx: &mut Context<Ctx>, engine: ir::Value, env: ir::Value) -> StackSlot {
todo!()
}
}
impl<Ctx: JITContext> JITCompile<Ctx> for Attr {
fn compile(&self, ctx: &mut Context<Ctx>, engine: ir::Value, env: ir::Value) -> StackSlot {
use Attr::*;
match self {
Str(string) => ctx.create_string(string),
Dynamic(ir) => ir.compile(ctx, engine, env),
}
}
}
impl<Ctx: JITContext> JITCompile<Ctx> for Select {
fn compile(&self, ctx: &mut Context<Ctx>, engine: ir::Value, env: ir::Value) -> StackSlot {
let val = self.expr.compile(ctx, engine, env);
let attrpath = ctx.alloc_array(self.attrpath.len());
for (i, attr) in self.attrpath.iter().enumerate() {
let arg = attr.compile(ctx, engine, env);
let tag = ctx.builder.ins().stack_load(types::I64, arg, 0);
let val0 = ctx.builder.ins().stack_load(types::I64, arg, 8);
let val1 = ctx.builder.ins().stack_load(types::I64, arg, 16);
let val2 = ctx.builder.ins().stack_load(types::I64, arg, 24);
ctx.builder
.ins()
.store(MemFlags::new(), tag, attrpath, i as i32 * 32);
ctx.builder
.ins()
.store(MemFlags::new(), val0, attrpath, i as i32 * 32 + 8);
ctx.builder
.ins()
.store(MemFlags::new(), val1, attrpath, i as i32 * 32 + 16);
ctx.builder
.ins()
.store(MemFlags::new(), val2, attrpath, i as i32 * 32 + 24);
}
ctx.select(val, attrpath, self.attrpath.len(), engine, env);
val
}
}
impl<Ctx: JITContext> JITCompile<Ctx> for If {
fn compile(&self, ctx: &mut Context<Ctx>, engine: ir::Value, env: ir::Value) -> StackSlot {
let cond = self.cond.compile(ctx, engine, env);
let cond_type = ctx.builder.ins().stack_load(types::I64, cond, 0);
let cond_value = ctx.builder.ins().stack_load(types::I64, cond, 8);
let true_block = ctx.builder.create_block();
let false_block = ctx.builder.create_block();
let exit_block = ctx.builder.create_block();
let error_block = ctx.builder.create_block();
let judge_block = ctx.builder.create_block();
let slot = ctx.alloca();
let is_bool =
ctx.builder
.ins()
.icmp_imm(IntCC::Equal, cond_type, Value::<Ctx>::BOOL as i64);
ctx.builder
.ins()
.brif(is_bool, judge_block, [], error_block, []);
ctx.builder.switch_to_block(judge_block);
ctx.builder
.ins()
.brif(cond_value, true_block, [], false_block, []);
ctx.builder.switch_to_block(true_block);
let ret = self.consq.compile(ctx, engine, env);
let tag = ctx.builder.ins().stack_load(types::I64, ret, 0);
let val0 = ctx.builder.ins().stack_load(types::I64, ret, 8);
let val1 = ctx.builder.ins().stack_load(types::I64, ret, 16);
let val2 = ctx.builder.ins().stack_load(types::I64, ret, 24);
ctx.builder.ins().stack_store(tag, slot, 0);
ctx.builder.ins().stack_store(val0, slot, 8);
ctx.builder.ins().stack_store(val1, slot, 16);
ctx.builder.ins().stack_store(val2, slot, 24);
ctx.builder.ins().jump(exit_block, []);
ctx.builder.switch_to_block(false_block);
let ret = self.alter.compile(ctx, engine, env);
let tag = ctx.builder.ins().stack_load(types::I64, ret, 0);
let val0 = ctx.builder.ins().stack_load(types::I64, ret, 8);
let val1 = ctx.builder.ins().stack_load(types::I64, ret, 16);
let val2 = ctx.builder.ins().stack_load(types::I64, ret, 24);
ctx.builder.ins().stack_store(tag, slot, 0);
ctx.builder.ins().stack_store(val0, slot, 8);
ctx.builder.ins().stack_store(val1, slot, 16);
ctx.builder.ins().stack_store(val2, slot, 24);
ctx.builder.ins().jump(exit_block, []);
ctx.builder.switch_to_block(error_block);
ctx.builder.ins().trap(TrapCode::unwrap_user(1));
ctx.builder.switch_to_block(exit_block);
slot
}
}
impl<Ctx: JITContext> JITCompile<Ctx> for Call {
fn compile(&self, ctx: &mut Context<Ctx>, engine: ir::Value, env: ir::Value) -> StackSlot {
let func = self.func.compile(ctx, engine, env);
let args = ctx.alloc_array(self.args.len());
for (i, arg) in self.args.iter().enumerate() {
let arg = arg.compile(ctx, engine, env);
let tag = ctx.builder.ins().stack_load(types::I64, arg, 0);
let val0 = ctx.builder.ins().stack_load(types::I64, arg, 8);
let val1 = ctx.builder.ins().stack_load(types::I64, arg, 16);
let val2 = ctx.builder.ins().stack_load(types::I64, arg, 24);
ctx.builder
.ins()
.store(MemFlags::new(), tag, args, i as i32 * 32);
ctx.builder
.ins()
.store(MemFlags::new(), val0, args, i as i32 * 32 + 8);
ctx.builder
.ins()
.store(MemFlags::new(), val1, args, i as i32 * 32 + 16);
ctx.builder
.ins()
.store(MemFlags::new(), val2, args, i as i32 * 32 + 24);
}
ctx.call(func, args, self.args.len(), engine, env);
func
}
}
impl<Ctx: JITContext> JITCompile<Ctx> for With {
fn compile(&self, ctx: &mut Context<Ctx>, engine: ir::Value, env: ir::Value) -> StackSlot {
let namespace = self.namespace.compile(ctx, engine, env);
ctx.enter_with(env, namespace);
let ret = self.expr.compile(ctx, engine, env);
ctx.exit_with(env);
ctx.free_slot(namespace);
ret
}
}
impl<Ctx: JITContext> JITCompile<Ctx> for Assert {
fn compile(&self, ctx: &mut Context<Ctx>, engine: ir::Value, env: ir::Value) -> StackSlot {
todo!()
}
}
impl<Ctx: JITContext> JITCompile<Ctx> for ConcatStrings {
fn compile(&self, ctx: &mut Context<Ctx>, engine: ir::Value, env: ir::Value) -> StackSlot {
todo!()
}
}
impl<Ctx: JITContext> JITCompile<Ctx> for Const {
fn compile(&self, ctx: &mut Context<Ctx>, engine: ir::Value, env: ir::Value) -> StackSlot {
use nixjit_value::Const::*;
let slot = ctx.alloca();
match self.val {
Bool(x) => {
let tag = ctx
.builder
.ins()
.iconst(types::I64, Value::<Ctx>::BOOL as i64);
let val = ctx.builder.ins().iconst(types::I64, x as i64);
ctx.builder.ins().stack_store(tag, slot, 0);
ctx.builder.ins().stack_store(val, slot, 8);
}
Int(x) => {
let tag = ctx
.builder
.ins()
.iconst(types::I64, Value::<Ctx>::INT as i64);
let val = ctx.builder.ins().iconst(types::I64, x);
ctx.builder.ins().stack_store(tag, slot, 0);
ctx.builder.ins().stack_store(val, slot, 8);
}
Float(x) => {
let tag = ctx
.builder
.ins()
.iconst(types::I64, Value::<Ctx>::FLOAT as i64);
let val = ctx.builder.ins().f64const(x);
ctx.builder.ins().stack_store(tag, slot, 0);
ctx.builder.ins().stack_store(val, slot, 8);
}
Null => {
let tag = ctx
.builder
.ins()
.iconst(types::I64, Value::<Ctx>::NULL as i64);
ctx.builder.ins().stack_store(tag, slot, 0);
}
}
slot
}
}
impl<Ctx: JITContext> JITCompile<Ctx> for Str {
fn compile(&self, ctx: &mut Context<Ctx>, engine: ir::Value, env: ir::Value) -> StackSlot {
ctx.create_string(&self.val)
}
}
impl<Ctx: JITContext> JITCompile<Ctx> for Var {
fn compile(&self, ctx: &mut Context<Ctx>, engine: ir::Value, env: ir::Value) -> StackSlot {
ctx.lookup(env, &self.sym)
}
}
impl<Ctx: JITContext> JITCompile<Ctx> for Path {
fn compile(&self, ctx: &mut Context<Ctx>, engine: ir::Value, env: ir::Value) -> StackSlot {
todo!()
}
}