1379 lines
42 KiB
Plaintext
1379 lines
42 KiB
Plaintext
// Expect retcode = 0
|
||
|
||
// IR -> VM 机器码（移植自 stage1/spl_ir2vm.c）。
|
||
// 依赖：IR（ir.spl）、IR 类型表（type_table.spl）、布局（layout.spl）、
|
||
// 属性（attr.spl）、字节码容器（mcode.spl）。
|
||
//
|
||
// extern_native 用「按函数 ref 下标的 isize 数组」代替 stage1 的 map：
|
||
// 默认 -1 表示非 extern，>=0 表示 native 索引（语义等价）。
|
||
|
||
type .{ .Vec } = @import("utils/vec.spl");
|
||
type .{ .ByteView } = @import("utils/byte_view.spl");
|
||
type .{ .ByteBuffer } = @import("utils/byte_buffer.spl");
|
||
type TypeTable = @import("./type_table.spl");
|
||
type LayoutM = @import("./layout.spl");
|
||
type .{ .Layout } = @import("./layout.spl");
|
||
type AttrM = @import("./attr.spl");
|
||
type .{ .Attr, .AttrArg } = @import("./attr.spl");
|
||
type IrM = @import("./ir.spl");
|
||
type .{ .Ir, .IrFunc, .IrEntry } = @import("./ir.spl");
|
||
type Mcode = @import("./mcode.spl");
|
||
type .{ .Prog, .Op, .VmKind, .VmIns, .VmFunc } = @import("./mcode.spl");
|
||
type Mem = @import("sys/mem.spl");
|
||
|
||
type Ir2Vm = @self;
|
||
|
||
ir: *Ir,
|
||
ty: *TypeTable,
|
||
attr: *Attr,
|
||
layout: *Layout,
|
||
extern_native: Vec, // isize
|
||
prog: Prog,
|
||
|
||
// ---- 类型/布局查询 ----
|
||
|
||
fn info_of(ctx: *Ir2Vm, tid: usize): *LayoutM.LayoutInfo {
|
||
ret LayoutM.info_of(ctx.layout, tid);
|
||
}
|
||
|
||
fn ir_type_size(ctx: *Ir2Vm, tid: usize): usize {
|
||
var info = info_of(ctx, tid);
|
||
if info == null { ret 0; }
|
||
ret (info.size_bits + 7) / 8;
|
||
}
|
||
|
||
fn ir_type_align(ctx: *Ir2Vm, tid: usize): usize {
|
||
var info = info_of(ctx, tid);
|
||
if info == null { ret 1; }
|
||
var a = info.align_bits / 8;
|
||
if a == 0 { a = 1; }
|
||
ret a;
|
||
}
|
||
|
||
fn ir_is_aggregate(ctx: *Ir2Vm, tid: usize): bool {
|
||
var te = TypeTable.node(ctx.ty, tid);
|
||
if te == null { ret false; }
|
||
match te.node {
|
||
.Array => { ret true; },
|
||
.Struct => { ret true; },
|
||
.Union => { ret true; },
|
||
.Enum => { ret true; },
|
||
.Shape => { ret true; },
|
||
_ => { ret false; },
|
||
}
|
||
ret false;
|
||
}
|
||
|
||
fn fn_ret_type(ctx: *Ir2Vm, fn_tid: usize): usize {
|
||
var te = TypeTable.node(ctx.ty, fn_tid);
|
||
if te == null { ret 0; }
|
||
match te.node {
|
||
.Fn(f) => { ret f.ret_type; },
|
||
_ => { ret 0; },
|
||
}
|
||
ret 0;
|
||
}
|
||
|
||
fn fn_nargs(ctx: *Ir2Vm, fn_tid: usize): usize {
|
||
var te = TypeTable.node(ctx.ty, fn_tid);
|
||
if te == null { ret 0; }
|
||
match te.node {
|
||
.Fn(f) => { ret f.params.len; },
|
||
_ => { ret 0; },
|
||
}
|
||
ret 0;
|
||
}
|
||
|
||
fn ir_agg_field_tid(ctx: *Ir2Vm, tid: usize, idx: usize): usize {
|
||
var te = TypeTable.node(ctx.ty, tid);
|
||
if te == null { ret 0; }
|
||
match te.node {
|
||
.Enum(agg) => {
|
||
if idx == 0 { ret agg.tag_type; }
|
||
var vidx = idx - 1;
|
||
if vidx < agg.variants.len {
|
||
var m = TypeTable.member_at(&agg.variants, vidx);
|
||
if m != null { ret m.type_id; }
|
||
}
|
||
ret 0;
|
||
},
|
||
.Struct(agg) => {
|
||
if idx < agg.variants.len {
|
||
var m = TypeTable.member_at(&agg.variants, idx);
|
||
if m != null { ret m.type_id; }
|
||
}
|
||
ret 0;
|
||
},
|
||
.Union(agg) => {
|
||
if idx < agg.variants.len {
|
||
var m = TypeTable.member_at(&agg.variants, idx);
|
||
if m != null { ret m.type_id; }
|
||
}
|
||
ret 0;
|
||
},
|
||
.Array(a) => { ret a.element; },
|
||
_ => { ret 0; },
|
||
}
|
||
ret 0;
|
||
}
|
||
|
||
fn ir_agg_field_off(ctx: *Ir2Vm, tid: usize, idx: usize): usize {
|
||
var te = TypeTable.node(ctx.ty, tid);
|
||
if te == null { ret 0; }
|
||
match te.node {
|
||
.Array(a) => { ret idx * ir_type_size(ctx, a.element); },
|
||
_ => {},
|
||
}
|
||
var info = info_of(ctx, tid);
|
||
if info == null || idx >= info.field_bit_offsets.len { ret 0; }
|
||
ret usize_at(&info.field_bit_offsets, idx) / 8;
|
||
}
|
||
|
||
fn vm_kind_of(ctx: *Ir2Vm, tid: usize): VmKind {
|
||
var te = TypeTable.node(ctx.ty, tid);
|
||
if te == null { ret .Void; }
|
||
match te.node {
|
||
.Unit => { ret .Void; },
|
||
.Bool => { ret .Bool; },
|
||
.Int(x) => {
|
||
if x.bits == 0 { ret .I32; }
|
||
if x.bits == 8 { if x.is_signed { ret .I8; } ret .U8; }
|
||
if x.bits == 16 { if x.is_signed { ret .I16; } ret .U16; }
|
||
if x.bits == 32 { if x.is_signed { ret .I32; } ret .U32; }
|
||
if x.is_signed { ret .I64; }
|
||
ret .U64;
|
||
},
|
||
.Float(x) => { if x.bits == 32 { ret .F32; } ret .F64; },
|
||
_ => { ret .Ptr; },
|
||
}
|
||
ret .Ptr;
|
||
}
|
||
|
||
fn tid_is_signed(ctx: *Ir2Vm, tid: usize): bool {
|
||
var te = TypeTable.node(ctx.ty, tid);
|
||
if te == null { ret false; }
|
||
match te.node {
|
||
.Int(x) => { ret x.is_signed; },
|
||
_ => { ret false; },
|
||
}
|
||
ret false;
|
||
}
|
||
|
||
// 节点的「值类型」；0 表示无结果（控制/存储类）。
|
||
fn ir_result_tid(ctx: *Ir2Vm, n: *IrEntry): usize {
|
||
match n.body {
|
||
.Arith(a) => { ret a.tid; },
|
||
.Cmp(c) => { ret c.tid; },
|
||
.Cast(c) => { ret c.to_tid; },
|
||
.MemAlloc(m) => { ret TypeTable.make_ptr(ctx.ty, m.tid); },
|
||
.MemGlobalAlloc(m) => { ret m.tid; },
|
||
.MemLoad(m) => { ret m.tid; },
|
||
.MemOffset(m) => { ret TypeTable.make_ptr(ctx.ty, m.tid); },
|
||
.MemFieldPtr(m) => {
|
||
var field = ir_agg_field_tid(ctx, m.tid, m.field_idx);
|
||
ret TypeTable.make_ptr(ctx.ty, field);
|
||
},
|
||
.Const(c) => { ret c.tid; },
|
||
.TypeOp(t) => { ret t.tid; },
|
||
.AggConstruct(a) => { ret a.tid; },
|
||
.AggExtract(a) => { ret a.field_tid; },
|
||
.AggInsert(a) => { ret a.tid; },
|
||
.Select(s) => { ret s.tid; },
|
||
.Call(c) => { ret c.tid; },
|
||
.Param(p) => { ret p.tid; },
|
||
_ => { ret 0; },
|
||
}
|
||
ret 0;
|
||
}
|
||
|
||
// ---- 小工具 ----
|
||
|
||
// 内部热路径：假定索引有效，直接取址（省去 Vec.get/valid）。
|
||
fn usize_at(v: *Vec, i: usize): usize {
|
||
ret (v.data as *usize)[i];
|
||
}
|
||
|
||
fn push_usize(v: *Vec, x: usize) {
|
||
ignore_bool(Vec.push_raw(v, &x as *u8));
|
||
}
|
||
|
||
fn fnode(f: *IrFunc, i: usize): *IrEntry {
|
||
ret (f.nodes.data as *IrEntry) + i;
|
||
}
|
||
|
||
fn align_up(x: usize, a: usize): usize {
|
||
if a <= 1 { ret x; }
|
||
ret (x + a - 1) / a * a;
|
||
}
|
||
|
||
fn const_usize(n: *IrEntry): usize {
|
||
if n == null { ret 0; }
|
||
match n.body {
|
||
.Const(c) => {
|
||
match c.lit {
|
||
.Int(v) => { ret v; },
|
||
.Char(v) => { ret v as usize; },
|
||
.Bool(v) => { if v { ret 1; } ret 0; },
|
||
.Ptr(v) => { ret v; },
|
||
.Fn(v) => { ret v; },
|
||
.Float(v) => { ret 0; },
|
||
}
|
||
},
|
||
_ => { ret 0; },
|
||
}
|
||
ret 0;
|
||
}
|
||
|
||
fn const_fn(n: *IrEntry): usize {
|
||
if n == null { ret 0; }
|
||
match n.body {
|
||
.Const(c) => {
|
||
match c.lit {
|
||
.Fn(v) => { ret v; },
|
||
_ => { ret 0; },
|
||
}
|
||
},
|
||
_ => { ret 0; },
|
||
}
|
||
ret 0;
|
||
}
|
||
|
||
// ---- extern ----
|
||
|
||
fn fn_check_extern(ctx: *Ir2Vm, f: *IrFunc): bool {
|
||
if ctx.attr == null || f == null { ret false; }
|
||
var i: usize = 0;
|
||
while i < f.attrs.len {
|
||
var a = AttrM.node(ctx.attr, usize_at(&f.attrs, i));
|
||
if a != null {
|
||
var info = AttrM.info_at(ctx.attr, a.info_index);
|
||
if info != null && ByteView.eq(info.name, ByteView.from_slice("extern")) {
|
||
a.consumed_mask = a.consumed_mask | (1 as u32 << 2);
|
||
ret true;
|
||
}
|
||
}
|
||
i = i + 1;
|
||
}
|
||
ret false;
|
||
}
|
||
|
||
fn extern_get(ctx: *Ir2Vm, ref: usize): isize {
|
||
if ref == 0 || ref >= ctx.extern_native.len { ret -1; }
|
||
match Vec.get(&ctx.extern_native, ref) {
|
||
.Ok(ptr) => { ret (ptr as *isize).*; },
|
||
.Err(error) => { ret -1; },
|
||
}
|
||
ret -1;
|
||
}
|
||
|
||
fn extern_set(ctx: *Ir2Vm, ref: usize, value: isize) {
|
||
if ref >= ctx.extern_native.len { ret; }
|
||
match Vec.get(&ctx.extern_native, ref) {
|
||
.Ok(ptr) => { (ptr as *isize).* = value; },
|
||
.Err(error) => {},
|
||
}
|
||
}
|
||
|
||
// ---- 帧布局 ----
|
||
|
||
type Slot = struct {
|
||
result_off: usize,
|
||
data_off: usize,
|
||
}
|
||
|
||
type FrameLayout = struct {
|
||
slots: Vec, // Slot
|
||
args_bytes: usize,
|
||
frame_bytes: usize,
|
||
}
|
||
|
||
fn slot_at(frame: *FrameLayout, i: usize): *Slot {
|
||
ret (frame.slots.data as *Slot) + i;
|
||
}
|
||
|
||
fn slot_result(frame: *FrameLayout, i: usize): usize {
|
||
var s = slot_at(frame, i);
|
||
if s == null { ret 0; }
|
||
ret s.result_off;
|
||
}
|
||
|
||
fn slot_data(frame: *FrameLayout, i: usize): usize {
|
||
var s = slot_at(frame, i);
|
||
if s == null { ret 0; }
|
||
ret s.data_off;
|
||
}
|
||
|
||
fn node_data_size(ctx: *Ir2Vm, f: *IrFunc, node: *IrEntry): usize {
|
||
match node.body {
|
||
.MemAlloc(m) => {
|
||
var count: usize = 1;
|
||
if m.count < f.nodes.len {
|
||
var cn = fnode(f, m.count);
|
||
count = const_usize(cn);
|
||
}
|
||
if count == 0 { count = 1; }
|
||
var sz = ir_type_size(ctx, m.tid);
|
||
if sz == 0 { sz = 1; }
|
||
ret sz * count;
|
||
},
|
||
.AggConstruct(a) => {
|
||
var sz = ir_type_size(ctx, a.tid);
|
||
if sz == 0 { ret 8; }
|
||
ret sz;
|
||
},
|
||
.AggInsert(a) => {
|
||
var sz = ir_type_size(ctx, a.tid);
|
||
if sz == 0 { ret 8; }
|
||
ret sz;
|
||
},
|
||
.AggExtract(a) => {
|
||
if ir_is_aggregate(ctx, a.field_tid) { ret ir_type_size(ctx, a.field_tid); }
|
||
ret 0;
|
||
},
|
||
.MemLoad(m) => {
|
||
if ir_is_aggregate(ctx, m.tid) { ret ir_type_size(ctx, m.tid); }
|
||
ret 0;
|
||
},
|
||
.Panic(p) => { ret @sizeof(usize) * 4; },
|
||
.Call(c) => {
|
||
if ir_is_aggregate(ctx, c.tid) { ret ir_type_size(ctx, c.tid); }
|
||
ret 0;
|
||
},
|
||
_ => { ret 0; },
|
||
}
|
||
ret 0;
|
||
}
|
||
|
||
fn frame_build(fl: *FrameLayout, ctx: *Ir2Vm, fid: usize) {
|
||
fl.args_bytes = 0;
|
||
fl.frame_bytes = 0;
|
||
|
||
var f = IrM.func(ctx.ir, fid);
|
||
if f == null {
|
||
fl.slots = Vec.blank(@sizeof(Slot), @alignof(Slot));
|
||
ret;
|
||
}
|
||
|
||
var n = f.nodes.len;
|
||
match Vec.with_capacity(@sizeof(Slot), @alignof(Slot), n) {
|
||
.Ok(v) => { fl.slots = v; },
|
||
.Err(error) => { fl.slots = Vec.blank(@sizeof(Slot), @alignof(Slot)); },
|
||
}
|
||
var i: usize = 0;
|
||
while i < n {
|
||
var blank: Slot = .{ .result_off = 0, .data_off = 0 };
|
||
ignore_bool(Vec.push_raw(&fl.slots, &blank as *u8));
|
||
i = i + 1;
|
||
}
|
||
|
||
var nargs = fn_nargs(ctx, f.fn_tid);
|
||
var hidden_sret: usize = 0;
|
||
if ir_is_aggregate(ctx, fn_ret_type(ctx, f.fn_tid)) { hidden_sret = 1; }
|
||
fl.args_bytes = (nargs + hidden_sret) * @sizeof(usize);
|
||
|
||
var off = fl.args_bytes;
|
||
i = 1;
|
||
while i < n {
|
||
var node = fnode(f, i);
|
||
if ir_result_tid(ctx, node) != 0 {
|
||
var s = slot_at(fl, i);
|
||
s.result_off = off;
|
||
off = off + @sizeof(usize);
|
||
}
|
||
var extra = node_data_size(ctx, f, node);
|
||
if extra != 0 {
|
||
off = align_up(off, 8);
|
||
var s2 = slot_at(fl, i);
|
||
s2.data_off = off;
|
||
off = off + align_up(extra, 8);
|
||
}
|
||
i = i + 1;
|
||
}
|
||
fl.frame_bytes = align_up(off, 8);
|
||
}
|
||
|
||
fn frame_drop(fl: *FrameLayout) {
|
||
Vec.drop(&fl.slots);
|
||
}
|
||
|
||
// ---- cgen ----
|
||
|
||
type FixKind = enum {
|
||
Jmp,
|
||
Fnaddr,
|
||
}
|
||
|
||
type Fix = struct {
|
||
kind: FixKind,
|
||
ins_idx: usize,
|
||
node_target: usize,
|
||
fn_target: usize,
|
||
}
|
||
|
||
type Cgen = @self;
|
||
|
||
ctx: *Ir2Vm,
|
||
fid: usize,
|
||
irf: *IrFunc,
|
||
frame: FrameLayout,
|
||
node_ip: Vec, // usize
|
||
fixups: *Vec,
|
||
terminated: bool,
|
||
|
||
fn emit(cg: *Cgen, op: Op, ty: VmKind, imm: usize) {
|
||
var prog = &cg.ctx.prog;
|
||
var i = prog.insns.len;
|
||
if i < prog.insns.cap {
|
||
var p = (prog.insns.data as *VmIns) + i;
|
||
p.opcode = op;
|
||
p.ty = ty;
|
||
p.imm = imm;
|
||
prog.insns.len = i + 1;
|
||
ret;
|
||
}
|
||
ignore_usize(Mcode.add_instr(prog, op, ty, imm));
|
||
}
|
||
|
||
fn ip_of(cg: *Cgen): usize {
|
||
ret cg.ctx.prog.insns.len;
|
||
}
|
||
|
||
fn ins_ptr(prog: *Prog, i: usize): *VmIns {
|
||
ret (prog.insns.data as *VmIns) + i;
|
||
}
|
||
|
||
fn func_ptr(prog: *Prog, i: usize): *VmFunc {
|
||
ret (prog.funcs.data as *VmFunc) + i;
|
||
}
|
||
|
||
fn cg_laddr(cg: *Cgen, off: usize) { emit(cg, .Laddr, .Void, off); }
|
||
fn cg_load(cg: *Cgen, k: VmKind) { emit(cg, .Load, k, 0); }
|
||
fn cg_store(cg: *Cgen, k: VmKind) { emit(cg, .Store, k, 0); }
|
||
fn cg_push(cg: *Cgen, k: VmKind, v: usize) { emit(cg, .Push, k, v); }
|
||
fn cg_op(cg: *Cgen, op: Op, k: VmKind) { emit(cg, op, k, 0); }
|
||
fn cg_swap(cg: *Cgen) { emit(cg, .Swap, .Void, 0); }
|
||
fn cg_gaddr(cg: *Cgen, idx: usize) { emit(cg, .Gaddr, .Void, idx); }
|
||
|
||
fn cg_load_slot(cg: *Cgen, ref: usize, k: VmKind) {
|
||
cg_laddr(cg, slot_result(&cg.frame, ref));
|
||
cg_load(cg, k);
|
||
}
|
||
|
||
fn cg_store_slot(cg: *Cgen, ref: usize, k: VmKind) {
|
||
cg_laddr(cg, slot_result(&cg.frame, ref));
|
||
cg_swap(cg);
|
||
cg_store(cg, k);
|
||
}
|
||
|
||
fn cg_store_at(cg: *Cgen, addr: usize, k: VmKind) {
|
||
cg_laddr(cg, addr);
|
||
cg_swap(cg);
|
||
cg_store(cg, k);
|
||
}
|
||
|
||
type DataLoc = struct {
|
||
indirect: bool,
|
||
off: usize,
|
||
base: usize,
|
||
}
|
||
|
||
fn direct_data(off: usize): DataLoc {
|
||
ret DataLoc { .indirect = false, .off = off, .base = 0 };
|
||
}
|
||
|
||
fn direct_data_base(off: usize, base: usize): DataLoc {
|
||
ret DataLoc { .indirect = false, .off = off, .base = base };
|
||
}
|
||
|
||
fn ptr_slot(slot_off: usize): DataLoc {
|
||
ret DataLoc { .indirect = true, .off = slot_off, .base = 0 };
|
||
}
|
||
|
||
fn ptr_slot_base(slot_off: usize, base: usize): DataLoc {
|
||
ret DataLoc { .indirect = true, .off = slot_off, .base = base };
|
||
}
|
||
|
||
fn cg_push_addr(cg: *Cgen, loc: DataLoc, extra: usize) {
|
||
var delta = loc.base + extra;
|
||
if loc.indirect {
|
||
cg_laddr(cg, loc.off);
|
||
cg_load(cg, .Ptr);
|
||
if delta != 0 {
|
||
cg_push(cg, .U64, delta);
|
||
cg_op(cg, .Add, .Ptr);
|
||
}
|
||
} else {
|
||
cg_laddr(cg, loc.off + delta);
|
||
}
|
||
}
|
||
|
||
fn cg_copy_agg(cg: *Cgen, src: DataLoc, dst: DataLoc, tid: usize) {
|
||
var sz = ir_type_size(cg.ctx, tid);
|
||
var done: usize = 0;
|
||
while sz - done >= 8 {
|
||
cg_push_addr(cg, dst, done);
|
||
cg_push_addr(cg, src, done);
|
||
cg_load(cg, .U64);
|
||
cg_store(cg, .U64);
|
||
done = done + 8;
|
||
}
|
||
while done < sz {
|
||
cg_push_addr(cg, dst, done);
|
||
cg_push_addr(cg, src, done);
|
||
cg_load(cg, .U8);
|
||
cg_store(cg, .U8);
|
||
done = done + 1;
|
||
}
|
||
}
|
||
|
||
fn cg_add_fix(cg: *Cgen, ins_idx: usize, kind: FixKind, node_target: usize, fn_target: usize) {
|
||
var fx = Fix {
|
||
.kind = kind,
|
||
.ins_idx = ins_idx,
|
||
.node_target = node_target,
|
||
.fn_target = fn_target,
|
||
};
|
||
match Vec.push(cg.fixups, &fx as *u8) { .Ok => {}, .Err(error) => {} }
|
||
}
|
||
|
||
fn arith_tid(n: *IrEntry): usize {
|
||
match n.body {
|
||
.Arith(a) => { ret a.tid; },
|
||
_ => { ret 0; },
|
||
}
|
||
ret 0;
|
||
}
|
||
|
||
fn cg_binop(cg: *Cgen, ref: usize, n: *IrEntry, op: Op) {
|
||
match n.body {
|
||
.Arith(a) => {
|
||
var k = vm_kind_of(cg.ctx, a.tid);
|
||
cg_load_slot(cg, a.left, k);
|
||
cg_load_slot(cg, a.right, k);
|
||
cg_op(cg, op, k);
|
||
cg_store_slot(cg, ref, k);
|
||
},
|
||
_ => {},
|
||
}
|
||
}
|
||
|
||
fn cg_unop(cg: *Cgen, ref: usize, n: *IrEntry, op: Op) {
|
||
match n.body {
|
||
.Arith(a) => {
|
||
var k = vm_kind_of(cg.ctx, a.tid);
|
||
cg_load_slot(cg, a.left, k);
|
||
cg_op(cg, op, k);
|
||
cg_store_slot(cg, ref, k);
|
||
},
|
||
_ => {},
|
||
}
|
||
}
|
||
|
||
fn cg_cmp(cg: *Cgen, ref: usize, n: *IrEntry, op: Op) {
|
||
match n.body {
|
||
.Cmp(c) => {
|
||
var k = vm_kind_of(cg.ctx, c.tid);
|
||
cg_load_slot(cg, c.a, k);
|
||
cg_load_slot(cg, c.b, k);
|
||
cg_op(cg, op, k);
|
||
cg_store_slot(cg, ref, .Bool);
|
||
},
|
||
_ => {},
|
||
}
|
||
}
|
||
|
||
fn cg_const(cg: *Cgen, ref: usize, n: *IrEntry) {
|
||
var ctx = cg.ctx;
|
||
var tid: usize = 0;
|
||
match n.body { .Const(c) => { tid = c.tid; }, _ => { ret; } }
|
||
var te = TypeTable.node(ctx.ty, tid);
|
||
if te == null { ret; }
|
||
|
||
match te.node {
|
||
.Fn(f) => {
|
||
var cref = const_fn(n);
|
||
var nat_idx: isize = -1;
|
||
if cref > 0 { nat_idx = extern_get(ctx, cref); }
|
||
if nat_idx >= 0 {
|
||
cg_push(cg, .U64, nat_idx as usize);
|
||
} else {
|
||
var idx = ip_of(cg);
|
||
cg_push(cg, .Ptr, 0);
|
||
cg_add_fix(cg, idx, .Fnaddr, 0, cref);
|
||
}
|
||
cg_store_slot(cg, ref, .Ptr);
|
||
ret;
|
||
},
|
||
.Unit => { ret; },
|
||
_ => {},
|
||
}
|
||
|
||
var k = vm_kind_of(ctx, tid);
|
||
var imm: usize = 0;
|
||
match te.node {
|
||
.Bool => {
|
||
match n.body {
|
||
.Const(c) => {
|
||
match c.lit { .Bool(v) => { if v { imm = 1; } }, _ => {} }
|
||
},
|
||
_ => {},
|
||
}
|
||
},
|
||
.Int(x) => { imm = const_usize(n); },
|
||
.Float => {
|
||
var fv: f64 = 0.0;
|
||
match n.body {
|
||
.Const(c) => {
|
||
match c.lit { .Float(v) => { fv = v; }, _ => {} }
|
||
},
|
||
_ => {},
|
||
}
|
||
Mem.copy(&imm as *any, &fv as *any, 8);
|
||
},
|
||
.Ptr => { imm = const_usize(n); },
|
||
_ => {},
|
||
}
|
||
cg_push(cg, k, imm);
|
||
cg_store_slot(cg, ref, k);
|
||
}
|
||
|
||
fn cg_cast(cg: *Cgen, ref: usize, n: *IrEntry) {
|
||
var ctx = cg.ctx;
|
||
match n.body {
|
||
.Cast(c) => {
|
||
var ft = TypeTable.node(ctx.ty, c.from_tid);
|
||
var tt = TypeTable.node(ctx.ty, c.to_tid);
|
||
if ft == null || tt == null { ret; }
|
||
|
||
var fk = vm_kind_of(ctx, c.from_tid);
|
||
var tk = vm_kind_of(ctx, c.to_tid);
|
||
cg_load_slot(cg, c.val, fk);
|
||
|
||
var f_int = false;
|
||
var f_bits: usize = 0;
|
||
var f_signed = false;
|
||
match ft.node {
|
||
.Int(x) => { f_int = true; f_bits = x.bits; f_signed = x.is_signed; },
|
||
_ => {},
|
||
}
|
||
var t_int = false;
|
||
var t_bits: usize = 0;
|
||
match tt.node {
|
||
.Int(x) => { t_int = true; t_bits = x.bits; },
|
||
_ => {},
|
||
}
|
||
var t_bool = false;
|
||
match tt.node { .Bool => { t_bool = true; }, _ => {} }
|
||
var f_bool = false;
|
||
match ft.node { .Bool => { f_bool = true; }, _ => {} }
|
||
|
||
if f_int && t_int {
|
||
if f_bits > t_bits {
|
||
emit(cg, .Trunc, .Void, t_bits);
|
||
} else if f_bits < t_bits {
|
||
if f_signed { emit(cg, .Sext, .Void, f_bits); }
|
||
else { emit(cg, .Zext, .Void, f_bits); }
|
||
}
|
||
} else if f_bool && t_int {
|
||
emit(cg, .Zext, .Void, 1);
|
||
}
|
||
ignore_bool(t_bool);
|
||
cg_store_slot(cg, ref, tk);
|
||
},
|
||
_ => {},
|
||
}
|
||
}
|
||
|
||
fn cg_mem(cg: *Cgen, ref: usize, n: *IrEntry) {
|
||
var ctx = cg.ctx;
|
||
match n.body {
|
||
.MemAlloc(m) => {
|
||
cg_laddr(cg, slot_data(&cg.frame, ref));
|
||
cg_store_slot(cg, ref, .Ptr);
|
||
},
|
||
.MemGlobalAlloc(m) => {
|
||
var idx: usize = 0;
|
||
if m.const_node < cg.irf.nodes.len {
|
||
var cn = fnode(cg.irf, m.const_node);
|
||
var pv: usize = 0;
|
||
var ctid: usize = 0;
|
||
match cn.body {
|
||
.Const(c) => {
|
||
ctid = c.tid;
|
||
match c.lit { .Ptr(v) => { pv = v; }, _ => {} }
|
||
},
|
||
_ => {},
|
||
}
|
||
if pv != 0 {
|
||
var size = ir_type_size(ctx, ctid);
|
||
idx = Mcode.add_data(&ctx.prog, pv, size);
|
||
}
|
||
}
|
||
if idx > 0 { emit(cg, .Gaddr, .Void, idx); }
|
||
else { cg_push(cg, .Ptr, 0); }
|
||
cg_store_slot(cg, ref, .Ptr);
|
||
},
|
||
.MemLoad(m) => {
|
||
var tid = m.tid;
|
||
if ir_is_aggregate(ctx, tid) {
|
||
var data = slot_data(&cg.frame, ref);
|
||
cg_copy_agg(cg, ptr_slot(slot_result(&cg.frame, m.ptr)), direct_data(data), tid);
|
||
cg_laddr(cg, data);
|
||
cg_store_slot(cg, ref, .Ptr);
|
||
} else {
|
||
var k = vm_kind_of(ctx, tid);
|
||
cg_load_slot(cg, m.ptr, .Ptr);
|
||
cg_load(cg, k);
|
||
cg_store_slot(cg, ref, k);
|
||
}
|
||
},
|
||
.MemStore(m) => {
|
||
var tid = m.tid;
|
||
if ir_is_aggregate(ctx, tid) {
|
||
cg_copy_agg(cg, ptr_slot(slot_result(&cg.frame, m.val)),
|
||
ptr_slot(slot_result(&cg.frame, m.ptr)), tid);
|
||
} else {
|
||
var k = vm_kind_of(ctx, tid);
|
||
cg_load_slot(cg, m.ptr, .Ptr);
|
||
cg_load_slot(cg, m.val, k);
|
||
cg_store(cg, k);
|
||
}
|
||
},
|
||
.MemOffset(m) => {
|
||
var elem_size = ir_type_size(ctx, m.tid);
|
||
if elem_size == 0 { elem_size = 1; }
|
||
cg_load_slot(cg, m.ptr, .Ptr);
|
||
cg_load_slot(cg, m.offset, .U64);
|
||
cg_push(cg, .U64, elem_size);
|
||
cg_op(cg, .Mul, .U64);
|
||
cg_op(cg, .Add, .Ptr);
|
||
cg_store_slot(cg, ref, .Ptr);
|
||
},
|
||
.MemFieldPtr(m) => {
|
||
var off = ir_agg_field_off(ctx, m.tid, m.field_idx);
|
||
cg_load_slot(cg, m.agg, .Ptr);
|
||
if off != 0 {
|
||
cg_push(cg, .U64, off);
|
||
cg_op(cg, .Add, .Ptr);
|
||
}
|
||
cg_store_slot(cg, ref, .Ptr);
|
||
},
|
||
_ => {},
|
||
}
|
||
}
|
||
|
||
fn cg_agg(cg: *Cgen, ref: usize, n: *IrEntry) {
|
||
var ctx = cg.ctx;
|
||
match n.body {
|
||
.AggConstruct(a) => {
|
||
var base = slot_data(&cg.frame, ref);
|
||
var agg_t = a.tid;
|
||
var i: usize = 0;
|
||
while i < a.fields.len {
|
||
var fref = usize_at(&a.fields, i);
|
||
var ftid = ir_agg_field_tid(ctx, agg_t, i);
|
||
if ftid != 0 {
|
||
var foff = ir_agg_field_off(ctx, agg_t, i);
|
||
if ir_is_aggregate(ctx, ftid) {
|
||
cg_copy_agg(cg, ptr_slot(slot_result(&cg.frame, fref)),
|
||
direct_data_base(base, foff), ftid);
|
||
} else {
|
||
var fk = vm_kind_of(ctx, ftid);
|
||
cg_load_slot(cg, fref, fk);
|
||
cg_store_at(cg, base + foff, fk);
|
||
}
|
||
}
|
||
i = i + 1;
|
||
}
|
||
cg_laddr(cg, base);
|
||
cg_store_slot(cg, ref, .Ptr);
|
||
},
|
||
.AggExtract(a) => {
|
||
var agg_t = a.tid;
|
||
var ftid = a.field_tid;
|
||
var foff = ir_agg_field_off(ctx, agg_t, a.field_idx);
|
||
if ir_is_aggregate(ctx, ftid) {
|
||
var data = slot_data(&cg.frame, ref);
|
||
cg_copy_agg(cg, ptr_slot_base(slot_result(&cg.frame, a.val), foff),
|
||
direct_data(data), ftid);
|
||
cg_laddr(cg, data);
|
||
cg_store_slot(cg, ref, .Ptr);
|
||
} else {
|
||
var fk = vm_kind_of(ctx, ftid);
|
||
cg_load_slot(cg, a.val, .Ptr);
|
||
if foff != 0 {
|
||
cg_push(cg, .U64, foff);
|
||
cg_op(cg, .Add, .Ptr);
|
||
}
|
||
cg_load(cg, fk);
|
||
cg_store_slot(cg, ref, fk);
|
||
}
|
||
},
|
||
.AggInsert(a) => {
|
||
var base = slot_data(&cg.frame, ref);
|
||
var agg_t = a.tid;
|
||
cg_copy_agg(cg, ptr_slot(slot_result(&cg.frame, a.agg)), direct_data(base), agg_t);
|
||
|
||
var foff = ir_agg_field_off(ctx, agg_t, a.field_idx);
|
||
var ftid = ir_agg_field_tid(ctx, agg_t, a.field_idx);
|
||
if ftid != 0 {
|
||
if ir_is_aggregate(ctx, ftid) {
|
||
cg_copy_agg(cg, ptr_slot(slot_result(&cg.frame, a.field)),
|
||
direct_data_base(base, foff), ftid);
|
||
} else {
|
||
var fk = vm_kind_of(ctx, ftid);
|
||
cg_load_slot(cg, a.field, fk);
|
||
cg_store_at(cg, base + foff, fk);
|
||
}
|
||
}
|
||
cg_laddr(cg, base);
|
||
cg_store_slot(cg, ref, .Ptr);
|
||
},
|
||
_ => {},
|
||
}
|
||
}
|
||
|
||
fn cg_typeop(cg: *Cgen, ref: usize, n: *IrEntry) {
|
||
var ctx = cg.ctx;
|
||
var v: usize = 0;
|
||
match n.body {
|
||
.TypeOp(t) => {
|
||
match n.kind {
|
||
.TypeSizeof => { v = ir_type_size(ctx, t.tid); },
|
||
.TypeBitsizeof => {
|
||
var info = info_of(ctx, t.tid);
|
||
if info != null { v = info.size_bits; }
|
||
},
|
||
.TypeAlignof => { v = ir_type_align(ctx, t.tid); },
|
||
.TypeOffsetof => {
|
||
var idx: usize = 0;
|
||
if t.field_idx < cg.irf.nodes.len {
|
||
idx = const_usize(fnode(cg.irf, t.field_idx));
|
||
}
|
||
v = ir_agg_field_off(ctx, t.tid, idx);
|
||
},
|
||
.TypeFieldCount => {
|
||
var te = TypeTable.node(ctx.ty, t.tid);
|
||
if te != null {
|
||
match te.node {
|
||
.Struct(agg) => { v = agg.variants.len; },
|
||
.Union(agg) => { v = agg.variants.len; },
|
||
.Enum(agg) => { v = agg.variants.len; },
|
||
.Shape(agg) => { v = agg.variants.len; },
|
||
_ => {},
|
||
}
|
||
}
|
||
},
|
||
_ => { ret; },
|
||
}
|
||
},
|
||
_ => { ret; },
|
||
}
|
||
cg_push(cg, .U64, v);
|
||
cg_store_slot(cg, ref, .U64);
|
||
}
|
||
|
||
fn cg_control(cg: *Cgen, ref: usize, n: *IrEntry) {
|
||
var ctx = cg.ctx;
|
||
match n.body {
|
||
.Param(p) => {
|
||
var k = vm_kind_of(ctx, p.tid);
|
||
var idx: usize = 0;
|
||
if p.idx < cg.irf.nodes.len {
|
||
idx = const_usize(fnode(cg.irf, p.idx));
|
||
}
|
||
var shift: usize = 0;
|
||
if ir_is_aggregate(ctx, fn_ret_type(ctx, cg.irf.fn_tid)) { shift = 1; }
|
||
cg_laddr(cg, (idx + shift) * @sizeof(usize));
|
||
cg_load(cg, k);
|
||
cg_store_slot(cg, ref, k);
|
||
},
|
||
.Ret(r) => {
|
||
var ret_tid = r.tid;
|
||
if ir_is_aggregate(ctx, ret_tid) {
|
||
if r.val != 0 {
|
||
var sz = ir_type_size(ctx, ret_tid);
|
||
cg_laddr(cg, 0);
|
||
cg_load(cg, .Ptr);
|
||
cg_load_slot(cg, r.val, .Ptr);
|
||
cg_push(cg, .U64, sz);
|
||
var nat = Mcode.get_or_add_native(&ctx.prog, ByteView.from_slice("vm_memcpy"));
|
||
cg_push(cg, .U64, nat as usize);
|
||
emit(cg, .Ncall, .Void, 3);
|
||
emit(cg, .Drop, .Void, 0);
|
||
}
|
||
emit(cg, .Ret, .Void, 0);
|
||
} else {
|
||
var k = vm_kind_of(ctx, ret_tid);
|
||
if @enum2int(k) != @enum2int(VmKind.Void) && r.val != 0 {
|
||
cg_load_slot(cg, r.val, k);
|
||
}
|
||
emit(cg, .Ret, k, 0);
|
||
}
|
||
},
|
||
.Br(b) => {
|
||
cg_load_slot(cg, b.cond, .Bool);
|
||
var bz_idx = ip_of(cg);
|
||
emit(cg, .Bz, .Void, 0);
|
||
cg_add_fix(cg, bz_idx, .Jmp, b.false_label, 0);
|
||
var jmp_idx = ip_of(cg);
|
||
emit(cg, .Jmp, .Void, 0);
|
||
cg_add_fix(cg, jmp_idx, .Jmp, b.true_label, 0);
|
||
},
|
||
.Jmp(j) => {
|
||
var idx = ip_of(cg);
|
||
emit(cg, .Jmp, .Void, 0);
|
||
cg_add_fix(cg, idx, .Jmp, j.label, 0);
|
||
},
|
||
.Call(cl) => {
|
||
var callee: usize = 0;
|
||
if cl.func < cg.irf.nodes.len {
|
||
callee = const_fn(fnode(cg.irf, cl.func));
|
||
}
|
||
var nat_idx: isize = -1;
|
||
if callee > 0 { nat_idx = extern_get(ctx, callee); }
|
||
var nargs = cl.params.len;
|
||
|
||
if nat_idx >= 0 {
|
||
var i: usize = 0;
|
||
while i < nargs {
|
||
var pref = usize_at(&cl.params, i);
|
||
var pn = fnode(cg.irf, pref);
|
||
var pk = vm_kind_of(ctx, ir_result_tid(ctx, pn));
|
||
cg_load_slot(cg, pref, pk);
|
||
i = i + 1;
|
||
}
|
||
cg_push(cg, .U64, nat_idx as usize);
|
||
emit(cg, .Ncall, .Void, nargs);
|
||
var rk = vm_kind_of(ctx, cl.tid);
|
||
if @enum2int(rk) == @enum2int(VmKind.Void) {
|
||
emit(cg, .Drop, .Void, 0);
|
||
} else {
|
||
cg_store_slot(cg, ref, rk);
|
||
}
|
||
} else {
|
||
var ret_t = cl.tid;
|
||
var ret_is_sret = ir_is_aggregate(ctx, ret_t);
|
||
var sret_off: usize = 0;
|
||
if ret_is_sret {
|
||
sret_off = slot_data(&cg.frame, ref);
|
||
cg_laddr(cg, sret_off);
|
||
}
|
||
var i: usize = 0;
|
||
while i < nargs {
|
||
var pref = usize_at(&cl.params, i);
|
||
var pn = fnode(cg.irf, pref);
|
||
var pk = vm_kind_of(ctx, ir_result_tid(ctx, pn));
|
||
cg_load_slot(cg, pref, pk);
|
||
i = i + 1;
|
||
}
|
||
cg_load_slot(cg, cl.func, .Ptr);
|
||
var actual = nargs;
|
||
if ret_is_sret { actual = actual + 1; }
|
||
emit(cg, .Call, .Void, actual);
|
||
|
||
if ret_is_sret {
|
||
cg_laddr(cg, sret_off);
|
||
cg_store_slot(cg, ref, .Ptr);
|
||
} else {
|
||
var rk = vm_kind_of(ctx, ret_t);
|
||
if @enum2int(rk) != @enum2int(VmKind.Void) {
|
||
cg_store_slot(cg, ref, rk);
|
||
}
|
||
}
|
||
}
|
||
},
|
||
_ => {},
|
||
}
|
||
}
|
||
|
||
fn cg_node(cg: *Cgen, ref: usize, n: *IrEntry) {
|
||
var ctx = cg.ctx;
|
||
match n.kind {
|
||
.TypeConst => { cg_const(cg, ref, n); },
|
||
|
||
.ArithAdd => { cg_binop(cg, ref, n, .Add); },
|
||
.ArithSub => { cg_binop(cg, ref, n, .Sub); },
|
||
.ArithMul => { cg_binop(cg, ref, n, .Mul); },
|
||
.ArithDiv => {
|
||
if tid_is_signed(ctx, arith_tid(n)) { cg_binop(cg, ref, n, .DivS); }
|
||
else { cg_binop(cg, ref, n, .DivU); }
|
||
},
|
||
.ArithRem => {
|
||
if tid_is_signed(ctx, arith_tid(n)) { cg_binop(cg, ref, n, .RemS); }
|
||
else { cg_binop(cg, ref, n, .RemU); }
|
||
},
|
||
.ArithAnd => { cg_binop(cg, ref, n, .And); },
|
||
.ArithOr => { cg_binop(cg, ref, n, .Or); },
|
||
.ArithXor => { cg_binop(cg, ref, n, .Xor); },
|
||
.ArithShl => { cg_binop(cg, ref, n, .Shl); },
|
||
.ArithShr => {
|
||
if tid_is_signed(ctx, arith_tid(n)) { cg_binop(cg, ref, n, .ShrS); }
|
||
else { cg_binop(cg, ref, n, .ShrU); }
|
||
},
|
||
.ArithNeg => { cg_unop(cg, ref, n, .Neg); },
|
||
.ArithNot => {
|
||
var tid = arith_tid(n);
|
||
var te = TypeTable.node(ctx.ty, tid);
|
||
var is_bool = false;
|
||
if te != null {
|
||
match te.node { .Bool => { is_bool = true; }, _ => {} }
|
||
}
|
||
if is_bool {
|
||
match n.body { .Arith(a) => {
|
||
cg_load_slot(cg, a.left, .Bool);
|
||
}, _ => {} }
|
||
cg_push(cg, .Bool, 0);
|
||
cg_op(cg, .Eq, .Bool);
|
||
cg_store_slot(cg, ref, .Bool);
|
||
} else {
|
||
cg_unop(cg, ref, n, .Not);
|
||
}
|
||
},
|
||
.ArithAbs => {},
|
||
|
||
.CmpEq => { cg_cmp(cg, ref, n, .Eq); },
|
||
.CmpNe => { cg_cmp(cg, ref, n, .Ne); },
|
||
.CmpLt => {
|
||
var k = cmp_tid(n);
|
||
if tid_is_signed(ctx, k) { cg_cmp(cg, ref, n, .Slt); } else { cg_cmp(cg, ref, n, .Ult); }
|
||
},
|
||
.CmpLe => {
|
||
var k = cmp_tid(n);
|
||
if tid_is_signed(ctx, k) { cg_cmp(cg, ref, n, .Sle); } else { cg_cmp(cg, ref, n, .Ule); }
|
||
},
|
||
.CmpGt => {
|
||
var k = cmp_tid(n);
|
||
if tid_is_signed(ctx, k) { cg_cmp(cg, ref, n, .Sgt); } else { cg_cmp(cg, ref, n, .Ugt); }
|
||
},
|
||
.CmpGe => {
|
||
var k = cmp_tid(n);
|
||
if tid_is_signed(ctx, k) { cg_cmp(cg, ref, n, .Sge); } else { cg_cmp(cg, ref, n, .Uge); }
|
||
},
|
||
|
||
.CastTrunc => { cg_cast(cg, ref, n); },
|
||
.CastZext => { cg_cast(cg, ref, n); },
|
||
.CastSext => { cg_cast(cg, ref, n); },
|
||
.CastFext => { cg_cast(cg, ref, n); },
|
||
.CastFtrunc => { cg_cast(cg, ref, n); },
|
||
.CastBitcast => { cg_cast(cg, ref, n); },
|
||
.CastPtr2int => { cg_cast(cg, ref, n); },
|
||
.CastInt2ptr => { cg_cast(cg, ref, n); },
|
||
.CastBool2int => { cg_cast(cg, ref, n); },
|
||
.CaseInt2float => { cg_cast(cg, ref, n); },
|
||
.CaseFloat2int => { cg_cast(cg, ref, n); },
|
||
|
||
.MemAlloca => { cg_mem(cg, ref, n); },
|
||
.MemGlobalAlloc => { cg_mem(cg, ref, n); },
|
||
.MemLoad => { cg_mem(cg, ref, n); },
|
||
.MemStore => { cg_mem(cg, ref, n); },
|
||
.MemOffset => { cg_mem(cg, ref, n); },
|
||
.MemFieldPtr => { cg_mem(cg, ref, n); },
|
||
|
||
.AggConstruct => { cg_agg(cg, ref, n); },
|
||
.AggExtract => { cg_agg(cg, ref, n); },
|
||
.AggInsert => { cg_agg(cg, ref, n); },
|
||
|
||
.TypeSizeof => { cg_typeop(cg, ref, n); },
|
||
.TypeBitsizeof => { cg_typeop(cg, ref, n); },
|
||
.TypeAlignof => { cg_typeop(cg, ref, n); },
|
||
.TypeOffsetof => { cg_typeop(cg, ref, n); },
|
||
.TypeFieldCount => { cg_typeop(cg, ref, n); },
|
||
|
||
.ControlParam => { cg_control(cg, ref, n); },
|
||
.ControlRet => { cg_control(cg, ref, n); },
|
||
.ControlBr => { cg_control(cg, ref, n); },
|
||
.ControlJmp => { cg_control(cg, ref, n); },
|
||
.ControlCall => { cg_control(cg, ref, n); },
|
||
.ControlUnreachable => { emit(cg, .Halt, .Void, 1); },
|
||
.ControlTrap => { emit(cg, .Halt, .Void, 1); },
|
||
|
||
.DbgPanic => {
|
||
var data = slot_data(&cg.frame, ref);
|
||
var msg = ByteView.empty();
|
||
match n.body { .Panic(p) => { msg = p.msg; }, _ => {} }
|
||
var msg_idx = Mcode.add_data(&ctx.prog, msg.ptr as usize, msg.len);
|
||
var fmt = ByteView.from_slice("%s");
|
||
var fmt_idx = Mcode.add_data(&ctx.prog, fmt.ptr as usize, 2);
|
||
if msg_idx <= 0 || fmt_idx <= 0 { ret; }
|
||
|
||
cg_gaddr(cg, fmt_idx);
|
||
cg_store_at(cg, data + 0, .Ptr);
|
||
cg_push(cg, .U64, 2);
|
||
cg_store_at(cg, data + 8, .U64);
|
||
|
||
cg_gaddr(cg, msg_idx);
|
||
cg_store_at(cg, data + 16, .Ptr);
|
||
cg_push(cg, .U64, msg.len);
|
||
cg_store_at(cg, data + 24, .U64);
|
||
|
||
cg_laddr(cg, data + 0);
|
||
cg_laddr(cg, data + 16);
|
||
|
||
var nat = Mcode.get_or_add_native(&ctx.prog, ByteView.from_slice("vm_printf"));
|
||
cg_push(cg, .U64, nat as usize);
|
||
emit(cg, .Ncall, .Void, 2);
|
||
emit(cg, .Drop, .Void, 0);
|
||
},
|
||
.DbgBreakpoint => { emit(cg, .Bk, .Void, 0); },
|
||
|
||
_ => {},
|
||
}
|
||
}
|
||
|
||
fn cmp_tid(n: *IrEntry): usize {
|
||
match n.body {
|
||
.Cmp(c) => { ret c.tid; },
|
||
_ => { ret 0; },
|
||
}
|
||
ret 0;
|
||
}
|
||
|
||
// ---- 翻译 ----
|
||
|
||
fn translate_function(ctx: *Ir2Vm, fid: usize, all_fixups: *Vec): usize {
|
||
var irf = IrM.func(ctx.ir, fid);
|
||
if irf == null { ret 0; }
|
||
|
||
var local_fixups = Vec.blank(@sizeof(Fix), @alignof(Fix));
|
||
var cg: Cgen = undefined;
|
||
cg.ctx = ctx;
|
||
cg.fid = fid;
|
||
cg.irf = irf;
|
||
cg.frame.slots = Vec.blank(@sizeof(Slot), @alignof(Slot));
|
||
cg.frame.args_bytes = 0;
|
||
cg.frame.frame_bytes = 0;
|
||
match Vec.with_capacity(@sizeof(usize), @alignof(usize), irf.nodes.len) {
|
||
.Ok(v) => { cg.node_ip = v; },
|
||
.Err(error) => { cg.node_ip = Vec.blank(@sizeof(usize), @alignof(usize)); },
|
||
}
|
||
cg.fixups = &local_fixups;
|
||
cg.terminated = false;
|
||
frame_build(&cg.frame, ctx, fid);
|
||
|
||
var func_ip = ip_of(&cg);
|
||
|
||
ignore_usize(Mcode.add_func(&ctx.prog, irf.name, fn_nargs(ctx, irf.fn_tid), func_ip));
|
||
|
||
var local_slots = (cg.frame.frame_bytes - cg.frame.args_bytes + 7) / 8;
|
||
emit(&cg, .Alloc, .Void, local_slots);
|
||
|
||
var nnodes = irf.nodes.len;
|
||
var i: usize = 0;
|
||
while i < nnodes {
|
||
push_usize(&cg.node_ip, 0);
|
||
i = i + 1;
|
||
}
|
||
|
||
i = 1;
|
||
while i < nnodes {
|
||
(cg.node_ip.data as *usize)[i] = ip_of(&cg);
|
||
cg_node(&cg, i, fnode(irf, i));
|
||
i = i + 1;
|
||
}
|
||
|
||
i = 0;
|
||
while i < local_fixups.len {
|
||
match Vec.get(&local_fixups, i) {
|
||
.Ok(ptr) => {
|
||
var fx = ptr as *Fix;
|
||
if @enum2int(fx.kind) == @enum2int(FixKind.Jmp) {
|
||
var ins = ins_ptr(&ctx.prog, fx.ins_idx);
|
||
if ins != null {
|
||
var target_ip: usize = 0;
|
||
if fx.node_target < nnodes {
|
||
target_ip = usize_at(&cg.node_ip, fx.node_target);
|
||
}
|
||
ins.imm = target_ip - fx.ins_idx - 1;
|
||
}
|
||
} else if @enum2int(fx.kind) == @enum2int(FixKind.Fnaddr) {
|
||
match Vec.push(all_fixups, ptr as *u8) { .Ok => {}, .Err(error) => {} }
|
||
}
|
||
},
|
||
.Err(error) => {},
|
||
}
|
||
i = i + 1;
|
||
}
|
||
|
||
Vec.drop(&cg.node_ip);
|
||
Vec.drop(&local_fixups);
|
||
frame_drop(&cg.frame);
|
||
ret func_ip;
|
||
}
|
||
|
||
// ---- 生命周期 / 入口 ----
|
||
|
||
// 就地初始化（避免返回含 Prog 的大聚合；对应 stage1 spl_ir2vm_init）。
|
||
fn init(ctx: *Ir2Vm, ir: *Ir, ty: *TypeTable, layout: *Layout, attr: *Attr) {
|
||
ctx.ir = ir;
|
||
ctx.ty = ty;
|
||
ctx.attr = attr;
|
||
ctx.layout = layout;
|
||
ctx.extern_native = Vec.blank(@sizeof(isize), @alignof(isize));
|
||
|
||
match Mcode.new() {
|
||
.Ok(v) => { ctx.prog = v; },
|
||
.Err(error) => { @assert(false, "ir2vm: prog init failed"); },
|
||
}
|
||
}
|
||
|
||
fn drop(ctx: *Ir2Vm) {
|
||
Mcode.drop(&ctx.prog);
|
||
Vec.drop(&ctx.extern_native);
|
||
}
|
||
|
||
fn run_func(ctx: *Ir2Vm, ref: usize): i32 {
|
||
var all_fixups = Vec.blank(@sizeof(Fix), @alignof(Fix));
|
||
defer { Vec.drop(&all_fixups); }
|
||
ignore_usize(translate_function(ctx, ref, &all_fixups));
|
||
ret 0;
|
||
}
|
||
|
||
fn run(ctx: *Ir2Vm): i32 {
|
||
var n = ctx.ir.funcs.len;
|
||
if n <= 1 { ret 0; }
|
||
|
||
// Pass 1：登记 extern 函数 -> native 索引。
|
||
var i: usize = 0;
|
||
while i < n {
|
||
var v: isize = -1;
|
||
match Vec.push(&ctx.extern_native, &v as *u8) { .Ok => {}, .Err(error) => {} }
|
||
i = i + 1;
|
||
}
|
||
i = 1;
|
||
while i < n {
|
||
var irf = IrM.func(ctx.ir, i);
|
||
if irf != null && fn_check_extern(ctx, irf) {
|
||
var nat = Mcode.get_or_add_native(&ctx.prog, irf.name);
|
||
extern_set(ctx, i, nat);
|
||
}
|
||
i = i + 1;
|
||
}
|
||
|
||
// 哨兵：保证真实函数入口地址非零。
|
||
ignore_usize(Mcode.add_instr(&ctx.prog, .Halt, .Void, 0));
|
||
|
||
// 预分配指令容量（按 IR 节点数粗略估计），减少逐条 append 的扩容/拷贝。
|
||
var est: usize = 16;
|
||
i = 1;
|
||
while i < n {
|
||
var irf = IrM.func(ctx.ir, i);
|
||
if irf != null { est = est + irf.nodes.len * 8 + 32; }
|
||
i = i + 1;
|
||
}
|
||
match Vec.reserve(&ctx.prog.insns, est) { .Ok => {}, .Err(error) => {} }
|
||
|
||
// Pass 2：翻译非 extern 函数。
|
||
var fid_ip = Vec.blank(@sizeof(usize), @alignof(usize));
|
||
i = 0;
|
||
while i < n {
|
||
push_usize(&fid_ip, 0);
|
||
i = i + 1;
|
||
}
|
||
var all_fixups = Vec.blank(@sizeof(Fix), @alignof(Fix));
|
||
defer { Vec.drop(&all_fixups); }
|
||
|
||
i = 1;
|
||
while i < n {
|
||
if extern_get(ctx, i) < 0 {
|
||
var ip = translate_function(ctx, i, &all_fixups);
|
||
(fid_ip.data as *usize)[i] = ip;
|
||
}
|
||
i = i + 1;
|
||
}
|
||
|
||
// FNADDR 回填。
|
||
i = 0;
|
||
while i < all_fixups.len {
|
||
match Vec.get(&all_fixups, i) {
|
||
.Ok(ptr) => {
|
||
var fx = ptr as *Fix;
|
||
if @enum2int(fx.kind) == @enum2int(FixKind.Fnaddr) {
|
||
var ins = ins_ptr(&ctx.prog, fx.ins_idx);
|
||
if ins != null {
|
||
var target: usize = 0;
|
||
if fx.fn_target > 0 && fx.fn_target < n {
|
||
target = usize_at(&fid_ip, fx.fn_target);
|
||
}
|
||
ins.imm = target;
|
||
}
|
||
}
|
||
},
|
||
.Err(error) => {},
|
||
}
|
||
i = i + 1;
|
||
}
|
||
|
||
// 每个函数的 ninsns = 下一个入口 - 本入口。
|
||
i = 0;
|
||
while i < ctx.prog.funcs.len {
|
||
var f = func_ptr(&ctx.prog, i);
|
||
if f != null {
|
||
var next = ctx.prog.insns.len;
|
||
if i + 1 < ctx.prog.funcs.len {
|
||
var nf = func_ptr(&ctx.prog, i + 1);
|
||
if nf != null { next = nf.address; }
|
||
}
|
||
f.ninsns = next - f.address;
|
||
}
|
||
i = i + 1;
|
||
}
|
||
|
||
Vec.drop(&fid_ip);
|
||
ret 0;
|
||
}
|
||
|
||
fn dump(ctx: *Ir2Vm, out: *ByteBuffer): bool {
|
||
ret Mcode.dump(&ctx.prog, out);
|
||
}
|
||
|
||
// 把翻译结果写成 .sir（二进制）。
|
||
fn store(ctx: *Ir2Vm, path: ByteView): bool {
|
||
match Mcode.store(&ctx.prog, path) {
|
||
.Ok => { ret true; },
|
||
.Err(error) => { ret false; },
|
||
}
|
||
ret false;
|
||
}
|
||
|
||
// ---- 工具 ----
|
||
|
||
fn ignore_usize(v: usize) {}
|
||
fn ignore_bool(b: bool) {}
|
||
|
||
// ---- 测试 ----
|
||
|
||
fn main() {
|
||
var ir = IrM.new();
|
||
defer { IrM.drop(&ir); }
|
||
|
||
var tt: TypeTable = undefined;
|
||
match TypeTable.new() {
|
||
.Ok(v) => { tt = v; },
|
||
.Err(error) => { @assert(false, "tt init"); ret; },
|
||
}
|
||
defer { TypeTable.drop(&tt); }
|
||
|
||
var layout: Layout = undefined;
|
||
match LayoutM.new() {
|
||
.Ok(v) => { layout = v; },
|
||
.Err(error) => { @assert(false, "layout init"); ret; },
|
||
}
|
||
defer { LayoutM.drop(&layout); }
|
||
|
||
var attr: Attr = undefined;
|
||
match AttrM.new() {
|
||
.Ok(v) => { attr = v; },
|
||
.Err(error) => { @assert(false, "attr init"); ret; },
|
||
}
|
||
defer { AttrM.drop(&attr); }
|
||
|
||
var ctx: Ir2Vm = undefined;
|
||
init(&ctx, &ir, &tt, &layout, &attr);
|
||
defer { drop(&ctx); }
|
||
var rc = run(&ctx);
|
||
@assert(rc == 0, "run empty ir");
|
||
// 只有哨兵函数：无指令。
|
||
@assert(ctx.prog.insns.len == 0, "empty ir yields no insns");
|
||
}
|