Join shared-slot names, capping the list so the cell stays readable.

Keep an instruction if it has side effects or its result is still read.

The kernel modules with code to compile: true stdlib + boot entry (from the stdlib list) plus the kernel modules proper. `layout` is header-only and `

The shared layout header for the program `id`, or `""` if it has none.

Build a load `AsmToken` for the given mnemonic.

Returns true if `id_ex` is a load whose result is needed by the instruction currently in the IF/ID register (identified by its raw-word rs1/rs2 fields

Lower an array literal against a known element type. Each element is lowered with the declared element type as its context, so bare struct literals an

Build a slice value from a fixed array. The array's address is &arr[0] and its length comes from the static array type. A slice-typed source is passed

Lower `place = match ...`: resolve the target address, then store each matched arm's value into it through the slot-based value match.

Lower a float-to-float cast: f32<->f64 width conversion, or a plain move when the widths match.

Lower a float-to-integer cast via the appropriate `fcvt.{w,l}.{s,d}`. Signedness is not tracked in the IR cast mode, so signed conversion is used (the

Lower an integer-to-float cast via `fcvt.{s,d}.{w,l}`. Signed source is assumed (signedness is not carried in the IR cast mode).

Desugar a `for` loop to a `while` loop, reusing the existing `while` lowering (phi/break/continue) -- no new IR.

`for var in arr { body }` over a fixed array `T[N]` becomes: __for_ptr := &arr[0] ; base element pointer, once __for_i := 0 while __

`for var in <slice> { body }` over a slice becomes: __for_len := slice.len ; length read once __for_i := 0 while __for_i < __for_len { var :

`for var in start..end { body }` becomes: var := start __for_end := end ; end evaluated once while var < __for_end { ; `<=` w

Lower a `match` in statement position: arms run for effect and any value expressions are discarded.

Lower a `match` whose arms are integer/char literals. The scrutinee is evaluated once to a value and each literal arm compares against it.

Lower `recv.method(args)` as a direct call `method(self, args)`. `recv_addr` is the receiver address, reduced to a single `Type*` for the `self` argum

Lower element-scaled pointer arithmetic, or return `None` when neither operand is a pointer (so the caller falls back to ordinary arithmetic). Semanti

Lower `base[start..end]` to a new slice value `{ &base[start], end - start }`. Open endpoints default to 0 and the base length; `..=` adds one to `end

Index a slice: load { ptr, len } from the fat pointer, bounds-check the index against len, then compute the element address.

Names never mangled by the closure build: program/runtime entry points called by name from outside the module graph (the runtime `_start`, the C-style

Map an IR label to an assembly label string.

Mark that a register's value should be computed as `sp + slot`.

Consume a compound-assign operator (`+=`, `<<=`, ...) and map it to the matching binary operator, or return None and consume nothing.