爱特每羊队
290 lines
9.7 KiB
Rust
290 lines
9.7 KiB
Rust
//! lowering 全编码形态断言：IRFunction → CompiledModule 逐 Instr 等价。
|
|
|
|
use oxide_bytecode::module::{CompiledModule, Constant};
|
|
use oxide_bytecode::opcode::{self, OpCode};
|
|
use oxide_ir::inst::Inst;
|
|
use oxide_ir::lower::lower;
|
|
use oxide_ir::operand::Operand;
|
|
use oxide_ir::IRFunction;
|
|
|
|
fn base_module() -> IRFunction {
|
|
IRFunction::new()
|
|
}
|
|
|
|
fn lower_ok(f: &IRFunction) -> CompiledModule {
|
|
lower(f).expect("lower should succeed")
|
|
}
|
|
|
|
fn lower_err(f: &IRFunction) -> String {
|
|
match lower(f) {
|
|
Ok(_) => panic!("lower should fail"),
|
|
Err(e) => e,
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn three_operand_opcode_encodes_rd_a_b() {
|
|
let mut f = base_module();
|
|
f.insts.push(Inst::new(OpCode::ADD, Operand::Reg(0), Operand::Reg(1), Operand::Reg(2)));
|
|
let m = lower_ok(&f);
|
|
assert_eq!(m.bytecode.len(), 1);
|
|
assert_eq!(opcode::opcode(m.bytecode[0]), OpCode::ADD);
|
|
assert_eq!(opcode::rd(m.bytecode[0]), 0);
|
|
assert_eq!(opcode::a(m.bytecode[0]), 1);
|
|
assert_eq!(opcode::b(m.bytecode[0]), 2);
|
|
}
|
|
|
|
#[test]
|
|
fn load_const_splits_imm16_into_a_b() {
|
|
let mut f = base_module();
|
|
f.insts.push(Inst::load_const(Operand::Reg(4), 0x012C)); // 300
|
|
let m = lower_ok(&f);
|
|
assert_eq!(m.bytecode.len(), 1);
|
|
assert_eq!(opcode::opcode(m.bytecode[0]), OpCode::LOAD_CONST);
|
|
assert_eq!(opcode::rd(m.bytecode[0]), 4);
|
|
assert_eq!(opcode::a(m.bytecode[0]), 0x2C); // low byte
|
|
assert_eq!(opcode::b(m.bytecode[0]), 0x01); // high byte
|
|
}
|
|
|
|
#[test]
|
|
fn create_closure_splits_sub_idx_into_a_b() {
|
|
let mut f = base_module();
|
|
f.insts.push(Inst::create_closure(Operand::Reg(4), 5));
|
|
let m = lower_ok(&f);
|
|
assert_eq!(m.bytecode.len(), 1);
|
|
assert_eq!(opcode::opcode(m.bytecode[0]), OpCode::CREATE_CLOSURE);
|
|
assert_eq!(opcode::rd(m.bytecode[0]), 4);
|
|
assert_eq!(opcode::imm16(m.bytecode[0]), 5);
|
|
}
|
|
|
|
#[test]
|
|
fn forward_jump_encodes_positive_offset() {
|
|
let mut f = base_module();
|
|
f.insts.push(Inst::jmp(0));
|
|
f.insts.push(Inst::new(OpCode::NOP, Operand::None, Operand::None, Operand::None));
|
|
f.label_pos = vec![Some(1)];
|
|
f.label_count = 1;
|
|
let m = lower_ok(&f);
|
|
assert_eq!(m.bytecode.len(), 2);
|
|
assert_eq!(opcode::opcode(m.bytecode[0]), OpCode::JMP);
|
|
assert_eq!(opcode::offset16(m.bytecode[0]), 1);
|
|
}
|
|
|
|
#[test]
|
|
fn backward_jump_encodes_negative_offset() {
|
|
let mut f = base_module();
|
|
f.insts.push(Inst::new(OpCode::NOP, Operand::None, Operand::None, Operand::None));
|
|
f.insts.push(Inst::jmp(0));
|
|
f.label_pos = vec![Some(0)];
|
|
f.label_count = 1;
|
|
let m = lower_ok(&f);
|
|
assert_eq!(opcode::opcode(m.bytecode[1]), OpCode::JMP);
|
|
assert_eq!(opcode::offset16(m.bytecode[1]), -1);
|
|
}
|
|
|
|
#[test]
|
|
fn jump_offset_counts_ext_words_in_target() {
|
|
// jmp(0) -> ic_get (1 + 3 ext = 4 instr) -> ADD (instr 5)
|
|
let mut f = base_module();
|
|
f.insts.push(Inst::jmp(0));
|
|
f.insts.push(Inst::ic_get(Operand::Reg(1), Operand::Reg(2)));
|
|
f.insts.push(Inst::new(OpCode::ADD, Operand::Reg(0), Operand::Reg(1), Operand::Reg(2)));
|
|
f.label_pos = vec![Some(2)];
|
|
f.label_count = 1;
|
|
let m = lower_ok(&f);
|
|
assert_eq!(m.bytecode.len(), 1 + 4 + 1);
|
|
assert_eq!(opcode::offset16(m.bytecode[0]), 5);
|
|
}
|
|
|
|
#[test]
|
|
fn ic_get_carries_three_zero_ext_words() {
|
|
let mut f = base_module();
|
|
f.insts.push(Inst::ic_get(Operand::Reg(1), Operand::Reg(2)));
|
|
let m = lower_ok(&f);
|
|
assert_eq!(m.bytecode.len(), 4);
|
|
assert_eq!(opcode::opcode(m.bytecode[0]), OpCode::IC_GET_PROP);
|
|
assert_eq!(opcode::rd(m.bytecode[0]), 0);
|
|
assert_eq!(opcode::a(m.bytecode[0]), 1);
|
|
assert_eq!(opcode::b(m.bytecode[0]), 2);
|
|
assert_eq!(m.bytecode[1..], [0, 0, 0]);
|
|
}
|
|
|
|
#[test]
|
|
fn call_carries_nargs_ext_word() {
|
|
let mut f = base_module();
|
|
f.insts.push(Inst::call(Operand::Reg(0), Operand::Reg(1), Operand::Reg(2), 3));
|
|
let m = lower_ok(&f);
|
|
assert_eq!(m.bytecode.len(), 2);
|
|
assert_eq!(opcode::opcode(m.bytecode[0]), OpCode::CALL);
|
|
assert_eq!(opcode::rd(m.bytecode[0]), 0);
|
|
assert_eq!(opcode::a(m.bytecode[0]), 1);
|
|
assert_eq!(opcode::b(m.bytecode[0]), 2);
|
|
assert_eq!(m.bytecode[1], 3);
|
|
}
|
|
|
|
#[test]
|
|
fn define_accessor_and_rest_object_carry_single_ext_word() {
|
|
let mut f = base_module();
|
|
f.insts.push(Inst::define_accessor(Operand::Reg(0), Operand::Reg(1), Operand::Reg(2), 42));
|
|
f.insts.push(Inst::rest_object(Operand::Reg(3), Operand::Reg(4), 7));
|
|
let m = lower_ok(&f);
|
|
assert_eq!(m.bytecode.len(), 4);
|
|
assert_eq!(opcode::opcode(m.bytecode[0]), OpCode::DEFINE_ACCESSOR);
|
|
assert_eq!(m.bytecode[1], 42);
|
|
assert_eq!(opcode::opcode(m.bytecode[2]), OpCode::REST_OBJECT);
|
|
assert_eq!(opcode::rd(m.bytecode[2]), 3);
|
|
assert_eq!(opcode::a(m.bytecode[2]), 4);
|
|
assert_eq!(m.bytecode[3], 7);
|
|
}
|
|
|
|
#[test]
|
|
fn this_and_new_target_map_to_254_255() {
|
|
let mut f = base_module();
|
|
f.insts.push(Inst::new(OpCode::LOAD_VAR, Operand::Reg(1), Operand::This, Operand::None));
|
|
f.insts.push(Inst::new(OpCode::LOAD_VAR, Operand::Reg(2), Operand::NewTarget, Operand::None));
|
|
let m = lower_ok(&f);
|
|
assert_eq!(opcode::a(m.bytecode[0]), 254);
|
|
assert_eq!(opcode::a(m.bytecode[1]), 255);
|
|
}
|
|
|
|
#[test]
|
|
fn nested_ir_functions_pack_into_sub_modules() {
|
|
let mut outer = base_module();
|
|
let mut inner = base_module();
|
|
inner.insts.push(Inst::new(OpCode::ADD, Operand::Reg(0), Operand::Reg(1), Operand::Reg(2)));
|
|
inner.n_registers = 3;
|
|
outer.nested.push(inner);
|
|
let m = lower_ok(&outer);
|
|
assert_eq!(m.sub_modules.len(), 1);
|
|
assert_eq!(m.sub_modules[0].bytecode.len(), 1);
|
|
assert_eq!(opcode::opcode(m.sub_modules[0].bytecode[0]), OpCode::ADD);
|
|
assert_eq!(m.sub_modules[0].n_registers, 3);
|
|
}
|
|
|
|
#[test]
|
|
fn module_fields_are_copied_through() {
|
|
let mut f = base_module();
|
|
f.insts.push(Inst::new(OpCode::NOP, Operand::None, Operand::None, Operand::None));
|
|
f.constants.push(Constant::Int(42));
|
|
f.param_layout = oxide_ir::ParamLayout { base: 2, count: 3 };
|
|
f.n_registers = 8;
|
|
f.is_arrow = true;
|
|
f.builtin_reg_map.push(("Math".to_string(), 1));
|
|
f.upvalue_captures.push(oxide_bytecode::module::UpvalueCapture {
|
|
name: "x".to_string(),
|
|
enclosing_reg: 5,
|
|
cell_idx: 0,
|
|
});
|
|
f.cells_needed = 1;
|
|
let m = lower_ok(&f);
|
|
assert_eq!(m.constants, vec![Constant::Int(42)]);
|
|
assert_eq!(m.param_base, 2);
|
|
assert_eq!(m.n_args, 3);
|
|
assert_eq!(m.n_registers, 8);
|
|
assert!(m.is_arrow);
|
|
assert_eq!(m.builtin_reg_map, vec![("Math".to_string(), 1)]);
|
|
assert_eq!(m.upvalue_captures.len(), 1);
|
|
assert_eq!(m.cells_needed, 1);
|
|
}
|
|
|
|
#[test]
|
|
fn reg_overflow_flag_errors() {
|
|
let mut f = base_module();
|
|
f.insts.push(Inst::new(OpCode::NOP, Operand::None, Operand::None, Operand::None));
|
|
f.reg_overflow = true;
|
|
let err = lower_err(&f);
|
|
assert!(err.contains("too many registers"), "unexpected error: {err}");
|
|
}
|
|
|
|
#[test]
|
|
fn explicit_reg_254_errors() {
|
|
let mut f = base_module();
|
|
f.insts.push(Inst::new(OpCode::ADD, Operand::Reg(254), Operand::Reg(1), Operand::Reg(2)));
|
|
let err = lower_err(&f);
|
|
assert!(err.contains("too many registers"), "unexpected error: {err}");
|
|
}
|
|
|
|
#[test]
|
|
fn jump_offset_overflow_errors() {
|
|
let mut f = base_module();
|
|
f.insts.push(Inst::jmp(0));
|
|
for _ in 0..40_000 {
|
|
f.insts.push(Inst::new(OpCode::NOP, Operand::None, Operand::None, Operand::None));
|
|
}
|
|
f.label_pos = vec![Some(40_000)];
|
|
f.label_count = 1;
|
|
let err = lower_err(&f);
|
|
assert!(err.contains("jump offset"), "unexpected error: {err}");
|
|
}
|
|
|
|
#[test]
|
|
fn missing_label_errors() {
|
|
let mut f = base_module();
|
|
f.insts.push(Inst::jmp(0));
|
|
f.label_pos = vec![None];
|
|
f.label_count = 1;
|
|
let err = lower_err(&f);
|
|
assert!(err.contains("not found"), "unexpected error: {err}");
|
|
}
|
|
|
|
#[test]
|
|
fn const_overflow_errors() {
|
|
let mut f = base_module();
|
|
f.insts.push(Inst::new(OpCode::NOP, Operand::None, Operand::None, Operand::None));
|
|
f.constants = vec![Constant::Int(0); 70_000];
|
|
let err = lower_err(&f);
|
|
assert!(err.contains("too many constants"), "unexpected error: {err}");
|
|
}
|
|
|
|
#[test]
|
|
fn const_overflow_flag_errors() {
|
|
let mut f = base_module();
|
|
f.insts.push(Inst::new(OpCode::NOP, Operand::None, Operand::None, Operand::None));
|
|
f.const_overflow = true;
|
|
let err = lower_err(&f);
|
|
assert!(err.contains("too many constants"), "unexpected error: {err}");
|
|
}
|
|
|
|
#[test]
|
|
fn ir_function_domain_assemble_default_clone() {
|
|
let mut f = IRFunction::new();
|
|
f.insts.push(Inst::new(OpCode::NOP, Operand::None, Operand::None, Operand::None));
|
|
f.constants.push(Constant::Int(1));
|
|
f.param_layout = oxide_ir::ParamLayout { base: 0, count: 1 };
|
|
f.n_registers = 2;
|
|
f.is_arrow = true;
|
|
f.builtin_reg_map.push(("Math".to_string(), 1));
|
|
f.upvalue_captures.push(oxide_bytecode::module::UpvalueCapture {
|
|
name: "x".to_string(),
|
|
enclosing_reg: 0,
|
|
cell_idx: 0,
|
|
});
|
|
f.cells_needed = 1;
|
|
f.function_name = Some("f".to_string());
|
|
let mut inner = IRFunction::new();
|
|
inner.insts.push(Inst::new(OpCode::NOP, Operand::None, Operand::None, Operand::None));
|
|
f.nested.push(inner);
|
|
|
|
let d = IRFunction::new();
|
|
assert!(d.insts.is_empty());
|
|
assert!(d.nested.is_empty());
|
|
assert_eq!(d.n_registers, 0);
|
|
assert_eq!(d.label_pos.len(), 0);
|
|
|
|
let mut g = f.clone();
|
|
g.insts.clear();
|
|
g.nested.clear();
|
|
assert_eq!(f.insts.len(), 1, "clone must be deep copy for insts");
|
|
assert_eq!(f.nested.len(), 1, "clone must be deep copy for nested");
|
|
assert_eq!(f.function_name.as_deref(), Some("f"));
|
|
}
|
|
|
|
#[test]
|
|
fn operand_this_is_semantic_not_physical_index() {
|
|
assert_ne!(Operand::This, Operand::Reg(254));
|
|
assert_ne!(Operand::NewTarget, Operand::Reg(255));
|
|
assert_ne!(Operand::None, Operand::Reg(0));
|
|
assert_eq!(Operand::This, Operand::This);
|
|
assert_eq!(Operand::NewTarget, Operand::NewTarget);
|
|
}
|