zzy
459b6188a9
- 实现 as 类型转换运算符、修复 &&/|| 短路求值 bug。 - 在 splc1.spl 中实现 Vec/Map/Emit 基础库（~50 个方法）。 - 修复实例方法调用中 self 参数被错误丢弃的 bug。
234 lines
9.4 KiB
C
234 lines
9.4 KiB
C
/* spl_emit.c — IR emission: frame allocator + Layer 1/2 ops */
|
|
|
|
#include "spl_emit.h"
|
|
#include "spl_comp.h"
|
|
#include "spl_type.h"
|
|
#include <string.h>
|
|
|
|
/* ============================================================
|
|
* Lifecycle
|
|
* ============================================================ */
|
|
|
|
void spl_emit_init(spl_emit_t *e, spl_prog_t *prog) {
|
|
memset(e, 0, sizeof(*e));
|
|
e->prog = prog;
|
|
vec_init(e->fixups);
|
|
}
|
|
|
|
void spl_emit_drop(spl_emit_t *e) {
|
|
if (!e)
|
|
return;
|
|
vec_free(e->fixups);
|
|
}
|
|
|
|
/* ============================================================
|
|
* Frame allocator — non-inline
|
|
* ============================================================ */
|
|
|
|
int fa_alloc_type(spl_frame_alloc_t *fa, spl_type_ctx_t *tctx, int type_idx) {
|
|
return fa_alloc(fa, spl_type_size(tctx, type_idx));
|
|
}
|
|
|
|
spl_val_t emit_raw(spl_emit_t *e, uint16_t opcode, uint16_t type, spl_val_t imm) {
|
|
return spl_prog_emit(e->prog, opcode, type, imm);
|
|
}
|
|
|
|
/* ============================================================
|
|
* Layer 1 — single-instruction semantic wrappers
|
|
* ============================================================ */
|
|
|
|
void emit_drop(spl_emit_t *e) { emit_raw(e, SPL_DROP, SPL_VOID, 0); }
|
|
void emit_dup(spl_emit_t *e) { emit_raw(e, SPL_DUP, SPL_VOID, 0); }
|
|
void emit_swap(spl_emit_t *e) { emit_raw(e, SPL_SWAP, SPL_VOID, 0); }
|
|
void emit_rot(spl_emit_t *e) { emit_raw(e, SPL_ROT, SPL_VOID, 0); }
|
|
void emit_pick(spl_emit_t *e, int n) { emit_raw(e, SPL_PICK, SPL_VOID, n); }
|
|
|
|
void emit_push_i32(spl_emit_t *e, int v) { emit_raw(e, SPL_PUSH, SPL_I32, (spl_val_t)v); }
|
|
void emit_push_usize(spl_emit_t *e, usize v) { emit_raw(e, SPL_PUSH, SPL_USIZE, (spl_val_t)v); }
|
|
void emit_push_u64(spl_emit_t *e, uint64_t v) { emit_raw(e, SPL_PUSH, SPL_U64, (spl_val_t)v); }
|
|
void emit_push_f64(spl_emit_t *e, uint64_t v) { emit_raw(e, SPL_PUSH, SPL_F64, (spl_val_t)v); }
|
|
void emit_push_ptr(spl_emit_t *e, spl_val_t v) { emit_raw(e, SPL_PUSH, SPL_PTR, v); }
|
|
void emit_push_type(spl_emit_t *e, uint16_t bt, spl_val_t v) { emit_raw(e, SPL_PUSH, bt, v); }
|
|
|
|
void emit_load_ptr(spl_emit_t *e) { emit_raw(e, SPL_LOAD, SPL_PTR, 0); }
|
|
void emit_load_usize(spl_emit_t *e) { emit_raw(e, SPL_LOAD, SPL_USIZE, 0); }
|
|
void emit_load_type(spl_emit_t *e, uint16_t bt) { emit_raw(e, SPL_LOAD, bt, 0); }
|
|
|
|
void emit_store_i32(spl_emit_t *e) { emit_raw(e, SPL_STORE, SPL_I32, 0); }
|
|
void emit_store_ptr(spl_emit_t *e) { emit_raw(e, SPL_STORE, SPL_PTR, 0); }
|
|
void emit_store_usize(spl_emit_t *e) { emit_raw(e, SPL_STORE, SPL_USIZE, 0); }
|
|
void emit_store_type(spl_emit_t *e, uint16_t bt) { emit_raw(e, SPL_STORE, bt, 0); }
|
|
|
|
void emit_add_usize(spl_emit_t *e) { emit_raw(e, SPL_ADD, SPL_USIZE, 0); }
|
|
void emit_add_u64(spl_emit_t *e) { emit_raw(e, SPL_ADD, SPL_U64, 0); }
|
|
void emit_mul_u64(spl_emit_t *e) { emit_raw(e, SPL_MUL, SPL_U64, 0); }
|
|
void emit_sub_usize(spl_emit_t *e) { emit_raw(e, SPL_SUB, SPL_USIZE, 0); }
|
|
|
|
void emit_ult_usize(spl_emit_t *e) { emit_raw(e, SPL_ULT, SPL_USIZE, 0); }
|
|
|
|
void emit_jmp(spl_emit_t *e, spl_val_t offset) { emit_raw(e, SPL_JMP, SPL_VOID, offset); }
|
|
spl_val_t emit_jmp_here(spl_emit_t *e) { return emit_raw(e, SPL_JMP, SPL_VOID, 0); }
|
|
spl_val_t emit_bz_here(spl_emit_t *e) { return emit_raw(e, SPL_BZ, SPL_VOID, 0); }
|
|
spl_val_t emit_bnz_here(spl_emit_t *e) { return emit_raw(e, SPL_BNZ, SPL_VOID, 0); }
|
|
|
|
void emit_patch(spl_emit_t *e, spl_val_t addr, spl_val_t target) {
|
|
if (addr < vec_size(e->prog->insns))
|
|
vec_at(e->prog->insns, addr).imm = target;
|
|
}
|
|
|
|
void emit_patch_here(spl_emit_t *e, spl_val_t addr) {
|
|
spl_val_t here = vec_size(e->prog->insns);
|
|
emit_patch(e, addr, here - addr - 1);
|
|
}
|
|
|
|
void emit_laddr(spl_emit_t *e, int offset) { emit_raw(e, SPL_LADDR, SPL_PTR, offset); }
|
|
void emit_gaddr(spl_emit_t *e, int idx) { emit_raw(e, SPL_GADDR, SPL_PTR, idx); }
|
|
|
|
void emit_call(spl_emit_t *e, int nargs) { emit_raw(e, SPL_CALL, SPL_VOID, nargs); }
|
|
void emit_ncall(spl_emit_t *e, int nargs) { emit_raw(e, SPL_NCALL, SPL_VOID, nargs); }
|
|
|
|
void emit_alloc(spl_emit_t *e, int slots) { emit_raw(e, SPL_ALLOC, SPL_VOID, slots); }
|
|
void emit_binop(spl_emit_t *e, uint16_t op, uint16_t bt) { emit_raw(e, op, bt, 0); }
|
|
void emit_dbg_void(spl_emit_t *e) { emit_raw(e, SPL_DBG, SPL_VOID, 0); }
|
|
void emit_dbg_usize(spl_emit_t *e) { emit_raw(e, SPL_DBG, SPL_USIZE, 0); }
|
|
|
|
/* ============================================================
|
|
* Layer 2 — semantic-level helpers
|
|
* ============================================================ */
|
|
|
|
void emit_frame_copy(spl_emit_t *e, int dest_offset, usize nslots) {
|
|
for (usize i = 0; i < nslots; i++) {
|
|
if (i < nslots - 1)
|
|
emit_dup(e);
|
|
if (i > 0) {
|
|
emit_push_usize(e, i * sizeof(spl_val_t));
|
|
emit_add_usize(e);
|
|
}
|
|
emit_load_ptr(e);
|
|
emit_laddr(e, dest_offset + (int)(i * sizeof(spl_val_t)));
|
|
emit_swap(e);
|
|
emit_store_ptr(e);
|
|
}
|
|
}
|
|
|
|
void emit_copy_addr_to_addr(spl_emit_t *e, usize nslots, int depth) {
|
|
for (usize i = 0; i < nslots; i++) {
|
|
emit_dup(e);
|
|
if (i > 0) {
|
|
emit_push_usize(e, i * sizeof(spl_val_t));
|
|
emit_add_usize(e);
|
|
}
|
|
emit_load_ptr(e);
|
|
emit_pick(e, 2 + depth);
|
|
if (i > 0) {
|
|
emit_push_usize(e, i * sizeof(spl_val_t));
|
|
emit_add_usize(e);
|
|
}
|
|
emit_swap(e);
|
|
emit_store_ptr(e);
|
|
}
|
|
emit_drop(e);
|
|
emit_drop(e);
|
|
}
|
|
|
|
void emit_load_to_var(spl_emit_t *e, spl_type_ctx_t *tctx, int ptr_slot_offset, usize byte_offset,
|
|
int data_type_idx, int var_offset) {
|
|
emit_laddr(e, ptr_slot_offset);
|
|
emit_load_ptr(e);
|
|
emit_ptr_add(e, byte_offset);
|
|
if (data_type_idx >= 0 && !spl_type_is_scalar(tctx, data_type_idx) &&
|
|
spl_type_size(tctx, data_type_idx) > sizeof(spl_val_t)) {
|
|
emit_frame_copy(e, var_offset, spl_type_slot_count(tctx, data_type_idx));
|
|
} else {
|
|
uint16_t bt = spl_type_emit_type(tctx, data_type_idx);
|
|
emit_load_type(e, bt);
|
|
emit_laddr(e, var_offset);
|
|
emit_swap(e);
|
|
emit_store_type(e, bt);
|
|
}
|
|
}
|
|
|
|
void emit_store_to_laddr(spl_emit_t *e, int offset, uint16_t type) {
|
|
emit_laddr(e, offset);
|
|
emit_swap(e);
|
|
emit_store_type(e, type);
|
|
}
|
|
|
|
void emit_ptr_add(spl_emit_t *e, usize byte_off) {
|
|
if (byte_off > 0) {
|
|
emit_push_usize(e, byte_off);
|
|
emit_add_usize(e);
|
|
}
|
|
}
|
|
|
|
spl_val_t emit_call_with_fixup(spl_emit_t *e, int nargs, int func_idx) {
|
|
spl_val_t fixup_addr = emit_raw(e, SPL_PUSH, SPL_PTR, 0);
|
|
emit_call(e, nargs);
|
|
spl_fixup_entry_t fe = {fixup_addr, func_idx};
|
|
vec_push(e->fixups, fe);
|
|
return fixup_addr;
|
|
}
|
|
|
|
void emit_return(spl_emit_t *e, spl_type_ctx_t *tctx, int ret_type_idx) {
|
|
if (spl_type_needs_multi_slot(tctx, ret_type_idx)) {
|
|
emit_laddr(e, (int)sizeof(spl_val_t));
|
|
emit_raw(e, SPL_RET, SPL_PTR, 0);
|
|
} else {
|
|
uint16_t rt = spl_type_emit_type(tctx, ret_type_idx);
|
|
emit_raw(e, SPL_RET, rt, 0);
|
|
}
|
|
}
|
|
|
|
void emit_patch_call_fixups(spl_emit_t *e, spl_prog_t *prog) {
|
|
for (usize i = 0; i < vec_size(e->fixups); i++) {
|
|
spl_fixup_entry_t *fe = &vec_at(e->fixups, i);
|
|
if (fe->func_idx >= 0 && fe->func_idx < (int)vec_size(prog->funcs)) {
|
|
spl_val_t addr = vec_at(prog->funcs, fe->func_idx).address;
|
|
vec_at(prog->insns, fe->insn_idx).imm = addr;
|
|
}
|
|
}
|
|
}
|
|
|
|
void spl_emit_ret(spl_comp_t *ctx, int ret_type_idx) {
|
|
if (spl_type_needs_multi_slot(&ctx->tctx, ret_type_idx)) {
|
|
emit_laddr(&ctx->emit, (int)sizeof(spl_val_t));
|
|
emit_swap(&ctx->emit);
|
|
emit_copy_addr_to_addr(&ctx->emit, spl_type_slot_count(&ctx->tctx, ret_type_idx), 0);
|
|
}
|
|
emit_return(&ctx->emit, &ctx->tctx, ret_type_idx);
|
|
}
|
|
|
|
void spl_emit_store_init(spl_comp_t *ctx, int var_offset, int var_type_idx) {
|
|
if (var_type_idx >= 0 && (spl_type_kind(&ctx->tctx, var_type_idx) == TYPE_STRUCT ||
|
|
spl_type_kind(&ctx->tctx, var_type_idx) == TYPE_ENUM)) {
|
|
usize sz = spl_type_size(&ctx->tctx, var_type_idx);
|
|
if (sz <= sizeof(spl_val_t)) {
|
|
emit_store_to_laddr(&ctx->emit, var_offset,
|
|
spl_type_emit_type(&ctx->tctx, var_type_idx));
|
|
} else {
|
|
usize nslots = (sz + sizeof(spl_val_t) - 1) / sizeof(spl_val_t);
|
|
emit_frame_copy(&ctx->emit, var_offset, nslots);
|
|
}
|
|
} else if (var_type_idx >= 0 && spl_type_kind(&ctx->tctx, var_type_idx) == TYPE_ARRAY) {
|
|
int elem_idx = spl_type_elem_type(&ctx->tctx, var_type_idx);
|
|
spl_type_t bt = spl_type_emit_type(&ctx->tctx, elem_idx);
|
|
usize stride = spl_type_elem_stride(&ctx->tctx, elem_idx);
|
|
int arr_len = (int)spl_type_array_len(&ctx->tctx, var_type_idx);
|
|
for (int i = arr_len - 1; i >= 0; i--) {
|
|
emit_laddr(&ctx->emit, var_offset + (int)(i * stride));
|
|
emit_swap(&ctx->emit);
|
|
if (elem_idx >= 0 && !spl_type_is_scalar(&ctx->tctx, elem_idx)) {
|
|
emit_copy_addr_to_addr(&ctx->emit, spl_type_slot_count(&ctx->tctx, elem_idx), 0);
|
|
} else {
|
|
emit_store_type(&ctx->emit, bt);
|
|
}
|
|
}
|
|
} else if (var_type_idx >= 0 && spl_type_kind(&ctx->tctx, var_type_idx) == TYPE_SLICE) {
|
|
emit_store_to_laddr(&ctx->emit, var_offset + (int)sizeof(spl_val_t), SPL_USIZE);
|
|
emit_store_to_laddr(&ctx->emit, var_offset, SPL_PTR);
|
|
} else {
|
|
spl_type_t bt = spl_type_emit_type(&ctx->tctx, var_type_idx);
|
|
emit_store_to_laddr(&ctx->emit, var_offset, bt);
|
|
}
|
|
}
|