Orkuncakilkaya
ae0bae0457
32-bit word access is indexing now, not peek32/poke32: peek32(ui_rx, i) -> ui_rx[i] (reads an int) poke32(rt_fb, i, c) -> rt_fb[i] = c (writes an int) A buffer typed `words` (a pointer whose elements are i32) indexes with `w[i]` as a full int; a plain `ptr`/`str` keeps byte indexing. emit_index_addr picks the element type from the base's type — byte-identical IR to the old intrinsics, so the migration reproduces the compiler and every golden render exactly. The ~60 word buffers (rt_fb, tt_*/gc_* font tables, png_px/spr_px pixels, ui_* layout arrays) were retyped from `ptr` to `words` scope-aware (per-function, so the s/out/p byte-vs-word name collisions across functions stay correct), then the 254 peek32/poke32 sites migrated to indexing. A scope-analysis miss left 12 buffers (gc_*, sc_d, ui_rx/ui_ry) un-retyped — caught as a menu golden diff and fixed. No true mixed byte+word access exists on any one variable, so a per-buffer element type is sound. Reseeded (22527 lines); C-free fixpoint holds; goldens byte-identical; 18/18; vocab (byte/words types in, peek32/poke32 out) + doc-fences clean. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
92 lines
3.9 KiB
Text
92 lines
3.9 KiB
Text
# emit_intrin.ludic — the low-level intrinsics the self-host source uses, each
|
|
# lowered to the same libc/inline IR the C backend emits. Returns a Val via
|
|
# g_intrin_val and sets g_intrin_ok when `name` was an intrinsic.
|
|
|
|
var g_intrin_ok: bool = false
|
|
|
|
# is `name` a low-level intrinsic? A pure name check, so it can gate dispatch
|
|
# without evaluating arguments (which could clobber shared state).
|
|
fn is_intrinsic(name: ptr) -> bool {
|
|
if (name == "mem_alloc") or (name == "mem_realloc") { return true }
|
|
if (name == "file_open") or (name == "file_read") or (name == "file_write") { return true }
|
|
if (name == "file_seek") or (name == "file_tell") or (name == "file_close") { return true }
|
|
if (name == "os_argc") or (name == "os_arg") or (name == "os_exit") or (name == "file_stderr") { return true }
|
|
if (name == "file_stdout") { return true }
|
|
if (name == "os_system") or (name == "os_getenv") { return true }
|
|
return false
|
|
}
|
|
# emit " <r> = <rest>\n" and return r
|
|
fn emit_bind(rest: ptr) -> ptr { let r = nreg(); emit(" "); emit(r); emit(" = "); emit(rest); emit("\n"); return r }
|
|
|
|
fn arg_code(e: Node, i: int) -> ptr { let v = emit_expr(e.kids[i]); return v.code }
|
|
|
|
fn emit_intrinsic(name: ptr, e: Node) -> Val {
|
|
g_intrin_ok = true
|
|
# ptr_null / ptr_is_null are the `null` literal and `x == null` now.
|
|
if (name == "mem_alloc") {
|
|
let n = arg_code(e, 0)
|
|
let w = emit_bind(`zext i32 {n} to i64`)
|
|
return val(emit_bind(`call ptr @malloc(i64 {w})`), "ptr")
|
|
}
|
|
if (name == "mem_realloc") {
|
|
let p = arg_code(e, 0); let n = arg_code(e, 1)
|
|
let w = emit_bind(`zext i32 {n} to i64`)
|
|
return val(emit_bind(`call ptr @realloc(ptr {p}, i64 {w})`), "ptr")
|
|
}
|
|
if (name == "file_open") {
|
|
let p = arg_code(e, 0); let m = arg_code(e, 1)
|
|
return val(emit_bind(`call ptr @fopen(ptr {p}, ptr {m})`), "ptr")
|
|
}
|
|
if (name == "file_read") or (name == "file_write") {
|
|
let f = arg_code(e, 0); let b = arg_code(e, 1); let n = arg_code(e, 2)
|
|
let w = emit_bind(`zext i32 {n} to i64`)
|
|
var fn2 = "@fread"
|
|
if (name == "file_write") { fn2 = "@fwrite" }
|
|
let r = emit_bind(`call i64 {fn2}(ptr {b}, i64 1, i64 {w}, ptr {f})`)
|
|
return val(emit_bind(`trunc i64 {r} to i32`), "int")
|
|
}
|
|
if (name == "file_seek") {
|
|
let f = arg_code(e, 0); let off = arg_code(e, 1); let wh = arg_code(e, 2)
|
|
let o = emit_bind(`sext i32 {off} to i64`)
|
|
return val(emit_bind(`call i32 @fseek(ptr {f}, i64 {o}, i32 {wh})`), "int")
|
|
}
|
|
if (name == "file_tell") {
|
|
let f = arg_code(e, 0)
|
|
let r = emit_bind(`call i64 @ftell(ptr {f})`)
|
|
return val(emit_bind(`trunc i64 {r} to i32`), "int")
|
|
}
|
|
if (name == "file_close") {
|
|
let f = arg_code(e, 0)
|
|
emit(" call i32 @fclose(ptr "); emit(f); emit(")\n")
|
|
return val("0", "void")
|
|
}
|
|
# print_str / print_int are the polymorphic `print(x)` builtin now (emit_call).
|
|
if (name == "os_argc") { return val(emit_bind("load i32, ptr @L_argc"), "int") }
|
|
if (name == "os_arg") {
|
|
let i = arg_code(e, 0)
|
|
let v = emit_bind("load ptr, ptr @L_argv")
|
|
let q = emit_bind(`getelementptr ptr, ptr {v}, i32 {i}`)
|
|
return val(emit_bind(`load ptr, ptr {q}`), "str")
|
|
}
|
|
if (name == "os_exit") {
|
|
let n = arg_code(e, 0)
|
|
emit(" call void @exit(i32 "); emit(n); emit(")\n")
|
|
emit(" unreachable\n")
|
|
g_term = true
|
|
return val("0", "void")
|
|
}
|
|
if (name == "file_stderr") { return val(emit_bind("load ptr, ptr @__stderrp"), "ptr") }
|
|
if (name == "file_stdout") { return val(emit_bind("load ptr, ptr @__stdoutp"), "ptr") }
|
|
if (name == "os_system") {
|
|
let c = arg_code(e, 0)
|
|
return val(emit_bind(`call i32 @system(ptr {c})`), "int")
|
|
}
|
|
if (name == "os_getenv") {
|
|
let n = arg_code(e, 0)
|
|
return val(emit_bind(`call ptr @getenv(ptr {n})`), "str")
|
|
}
|
|
# bitwise ops are the operators & | ^ << >> ~ now (see emit_bin / p_mul).
|
|
# peek32 / poke32 are `words` indexing now: w[i] and w[i] = v (see emit_index_addr).
|
|
g_intrin_ok = false
|
|
return val("0", "void")
|
|
}
|