boot2

scheme1.P1pp (19854B)

---

 # scheme1.P1pp -- Phase 1 minimal Scheme interpreter on P1.
 #
 # The full target is described in docs/LISP-C.md and docs/LISP.md. This
 # file is the spine: enough infrastructure to read a single source file,
 # parse one s-expression, and evaluate it via tag-dispatched eval/apply
 # with a single primitive (`sys-exit`). Every later piece (more
 # primitives, special forms, closures, pmatch, records, prelude, repl
 # loop) hooks onto these anchors without restructuring.
 #
 # What's wired up now:
 #   - Tag layout per LISP-C.md: fixnums, pairs, symbols, headered objects,
 #     immediate singletons. mkimm composes IMM constants at M1pp time.
 #   - Bump heap allocator (cons + alloc_hdr) over a BSS-past-ELF_end arena.
 #   - Linear-scan symbol intern table; entries store (name_ptr, name_len,
 #     global_val) borrowed directly from readbuf.
 #   - Reader: '(', ')', fixnums (decimal, optional leading `-`), bare
 #     symbols. No strings/hex/chars/quote/dotted yet, no `;` comments.
 #   - eval: tag dispatch -> self-eval / symbol lookup / pair application.
 #   - apply: HDR.PRIM dispatch only; closures/specials come later.
 #   - One primitive: sys-exit. Exits with the raw fixnum.
 #
 # Build chain (P1pp.P1pp = libp1pp must be in the catm sequence):
 #   catm P1-<arch>.M1pp P1.M1pp P1pp.P1pp scheme1/scheme1.P1pp \
 #     | m1pp -> M0 -> hex2 -> ELF
 #
 # Memory model: the ELF's ph_memsz is 8 MB (boot2 default), so all
 # zero-initialized arenas live past :ELF_end and cost zero file bytes.
 # p1_main writes their absolute addresses into pointer slots once at
 # startup; every later access goes through one extra load.
 
 # =========================================================================
 # Constants
 # =========================================================================
 
 %enum TAG { FIXNUM PAIR SYM HEAP IMM }
 %enum IMM { FALSE TRUE NIL UNSPEC UNBOUND }
 %enum HDR { BV CLOSURE PRIM TD REC }
 
 # imm_val(idx) -> integer-expression for the tagged immediate at IMM index
 # `idx`. Used both at %li sites (loaded into a register) and at $() emission
 # sites (baked into a static word).
 %macro imm_val(idx)
 (| (<< idx 3) %TAG.IMM)
 %endm
 
 # Layout helpers. %struct stride is 8 bytes per field.
 %struct PAIR    { car cdr }                          # .SIZE = 16
 %struct SYMENT  { name_ptr name_len global_val pad } # .SIZE = 32
 %struct PRIM    { hdr entry_w }                       # .SIZE = 16
 
 # BSS arena offsets from :ELF_end. Each arena is 64 KiB; the three are
 # packed back-to-back below ELF_end + 192 KiB. p1_main's startup loop
 # materializes &ELF_end + OFF_X into the matching pointer slot. The
 # offsets are emitted directly in bss_init_tbl via $().
 
 %macro SYMTAB_CAP_SLOTS()
 1024
 %endm
 
 %macro READBUF_CAP_BYTES()
 65536
 %endm
 
 # =========================================================================
 # Tag idioms
 # =========================================================================
 
 %macro tagof(rd, rs)
 %andi(rd, rs, 7)
 %endm
 
 %macro mkfix(rd, rs)
 %shli(rd, rs, 3)
 %endm
 
 %macro untag_fix(rd, rs)
 %sari(rd, rs, 3)
 %endm
 
 %macro untag_sym(rd, rs)
 %sari(rd, rs, 3)
 %endm
 
 %macro car(rd, rs)
 %ld(rd, rs, -1)
 %endm
 
 %macro cdr(rd, rs)
 %ld(rd, rs, 7)
 %endm
 
 %macro hdr_type(rd, rs)
 %lb(rd, rs, -3)
 %endm
 
 # =========================================================================
 # Scheme1-local helpers
 # =========================================================================
 
 # Load the byte at readbuf_buf[off_reg] into rd. Clobbers rd. `rd` must
 # be the destination register; the macro reuses it as a scratch pointer
 # during the la / ld / add chain before the final lb writes the byte.
 %macro readbuf_byte(rd, off_reg)
 %la(rd, &readbuf_buf_ptr)
 %ld(rd, rd, 0)
 %add(rd, rd, off_reg)
 %lb(rd, rd, 0)
 %endm
 
 # Branch to `target` if `ch_reg` holds an ASCII whitespace byte (space,
 # tab, LF, CR). `scratch` is clobbered.
 %macro is_ws_branch(scratch, ch_reg, target)
 %addi(scratch, ch_reg, -32)
 %beqz(scratch, target)
 %addi(scratch, ch_reg, -9)
 %beqz(scratch, target)
 %addi(scratch, ch_reg, -10)
 %beqz(scratch, target)
 %addi(scratch, ch_reg, -13)
 %beqz(scratch, target)
 %endm
 
 # Compute &symtab_buf + idx_reg * SYMENT.SIZE into rd. `scratch` is
 # clobbered.
 %macro symtab_entry(rd, idx_reg, scratch)
 %la(rd, &symtab_buf_ptr)
 %ld(rd, rd, 0)
 %shli(scratch, idx_reg, 5)
 %add(rd, rd, scratch)
 %endm
 
 # Print msg_label, exit with `code`. Never returns.
 %macro die(msg, code)
 %la(a0, & ## msg)
 %call(&print_cstr)
 %li(a0, code)
 %call(&sys_exit)
 %endm
 
 # =========================================================================
 # p1_main -- runtime spine
 # =========================================================================
 #
 # Frame layout (16 bytes):
 #   +0  saved argv
 
 %fn(p1_main, 16, {
     %st(a1, sp, 0)
 
     %li(t0, 2)
     %bltu(a0, t0, &::usage)
 
     # Initialize BSS pointer slots from ELF_end + OFF_*. Same idiom as
     # M1pp.P1: a tiny init table walked once.
     %la(t0, &ELF_end)
     %la(t1, &bss_init_tbl)
     %la(t2, &bss_init_tbl_end)
     ::bss_loop
     %beq(t1, t2, &::bss_done)
     %ld(a0, t1, 0)
     %ld(a2, t1, 8)
     %add(a2, a2, t0)
     %st(a2, a0, 0)
     %addi(t1, t1, 16)
     %b(&::bss_loop)
     ::bss_done
 
     # heap_next = &heap_buf, rounded up to 8-byte alignment. The BSS arena
     # starts at &ELF_end + OFF_heap, but &ELF_end's alignment depends on
     # the data section above it; cons assumes 8-byte-aligned heap_next so
     # every pair pointer's low 3 bits are exactly the PAIR tag.
     %la(t0, &heap_buf_ptr)
     %ld(t0, t0, 0)
     %alignup(t0, t0, 8, t1)
     %la(t1, &heap_next)
     %st(t0, t1, 0)
 
     # Bind built-in primitives.
     %call(&register_primitives)
 
     # argv[1] is the source path (NUL-terminated cstr from the kernel).
     %ld(a1, sp, 0)
     %ld(a0, a1, 8)
     %call(&load_source)
 
     # parse_one returns one s-expression in a0.
     %call(&parse_one)
 
     # eval(expr, NIL).
     %li(a1, %imm_val(%IMM.NIL))
     %call(&eval)
 
     # If the form did not sys-exit (e.g. evaluated to a fixnum), drop
     # cleanly with status 0. Useful while wiring up more of the runtime.
     %li(a0, 0)
     %eret
 
     ::usage
     %la(a0, &msg_usage)
     %call(&print_cstr)
     %li(a0, 2)
 })
 
 # =========================================================================
 # Source loading -- argv[1] -> readbuf, length stored in readbuf_len
 # =========================================================================
 
 %fn(load_source, 0, {
     %la(t0, &readbuf_buf_ptr)
     %ld(a1, t0, 0)
     %li(a2, %READBUF_CAP_BYTES)
     %call(&read_file)
     %bltz(a0, &::fail)
 
     %la(t0, &readbuf_len)
     %st(a0, t0, 0)
     %li(a0, 0)
     %eret
 
     ::fail
     %die(msg_load_fail, 3)
 })
 
 # =========================================================================
 # Heap: cons (leaf) and alloc_hdr (leaf)
 # =========================================================================
 #
 # Both are call-free leaves: bump heap_next, write fields, return tagged
 # pointer. Heap exhaustion crashes via a deliberate read past the arena
 # end -- runtime check arrives when error reporting does (LISP-C.md
 # milestone 3).
 
 # cons(car=a0, cdr=a1) -> tagged pair (a0)
 :cons
     %la(t2, &heap_next)
     %ld(t0, t2, 0)
     %st(a0, t0, 0)
     %st(a1, t0, 8)
     %addi(t1, t0, 16)
     %st(t1, t2, 0)
     %addi(a0, t0, 1)
     %ret
 
 # alloc_hdr(bytes=a0, hdr_word=a1) -> tagged heap obj (a0)
 # Rounds bytes up to a multiple of 8 and writes hdr_word at offset 0.
 :alloc_hdr
     %alignup(a0, a0, 8, t0)
     %la(t2, &heap_next)
     %ld(t0, t2, 0)
     %add(t1, t0, a0)
     %st(t1, t2, 0)
     %st(a1, t0, 0)
     %addi(a0, t0, 3)
     %ret
 
 # =========================================================================
 # Symbol intern -- linear scan, append on miss
 # =========================================================================
 #
 # Frame: 32 bytes
 #   +0  name_ptr      (input)
 #   +8  name_len      (input)
 #   +16 idx           (loop counter / found index)
 #   +24 entry_ptr     (spilled across memcmp)
 
 %fn(intern, 32, {
     %st(a0, sp, 0)
     %st(a1, sp, 8)
 
     %li(t0, 0)
     %st(t0, sp, 16)
 
     ::scan
     # idx >= count? -> append
     %ld(t0, sp, 16)
     %la(t1, &symtab_count)
     %ld(t1, t1, 0)
     %bltu(t0, t1, &::probe)
     %b(&::append)
 
     ::probe
     %symtab_entry(t1, t0, t2)
     %st(t1, sp, 24)
 
     # entry.name_len == name_len ?
     %ld(t2, t1, 8)
     %ld(a2, sp, 8)
     %bne(t2, a2, &::next)
 
     # memcmp(entry.name_ptr, name_ptr, len)
     %ld(a0, t1, 0)
     %ld(a1, sp, 0)
     %ld(a2, sp, 8)
     %call(&memcmp)
     %beqz(a0, &::found)
 
     ::next
     %ld(t0, sp, 16)
     %addi(t0, t0, 1)
     %st(t0, sp, 16)
     %b(&::scan)
 
     ::append
     # Bounds check; on overflow exit 5 with a message.
     %ld(t0, sp, 16)
     %li(t1, %SYMTAB_CAP_SLOTS)
     %bltu(t0, t1, &::append_ok)
     %die(msg_symtab_full, 5)
 
     ::append_ok
     %symtab_entry(t1, t0, t2)
     %ld(a0, sp, 0)
     %st(a0, t1, 0)
     %ld(a0, sp, 8)
     %st(a0, t1, 8)
     %li(a0, %imm_val(%IMM.UNBOUND))
     %st(a0, t1, 16)
     %li(a0, 0)
     %st(a0, t1, 24)
 
     # symtab_count = idx + 1
     %addi(a0, t0, 1)
     %la(t2, &symtab_count)
     %st(a0, t2, 0)
 
     # fall through with idx in t0 = sp[16]
 
     ::found
     %ld(t0, sp, 16)
     %shli(a0, t0, 3)
     %ori(a0, a0, %TAG.SYM)
 })
 
 # Lookup by sym_idx (untagged, in a0). Returns symtab[idx].global_val in a0.
 # Leaf.
 :sym_global
     %la(t0, &symtab_buf_ptr)
     %ld(t0, t0, 0)
     %shli(t1, a0, 5)
     %add(t0, t0, t1)
     %ld(a0, t0, 16)
     %ret
 
 # sym_set_global(idx=a0, val=a1). Leaf.
 :sym_set_global
     %la(t0, &symtab_buf_ptr)
     %ld(t0, t0, 0)
     %shli(t1, a0, 5)
     %add(t0, t0, t1)
     %st(a1, t0, 16)
     %ret
 
 # =========================================================================
 # Reader -- parse_one over readbuf with a single byte cursor
 # =========================================================================
 #
 # Cursor lives in &readbuf_pos; readbuf_len holds the slurped byte count.
 # The reader is called recursively from parse_list, so every state goes
 # through frame slots, not s-registers.
 
 # Skip whitespace (ASCII 32, 9, 10, 13). Leaf.
 :skip_ws
 %scope skip_ws
     %la(t2, &readbuf_pos)
     %ld(t0, t2, 0)
     %la(t1, &readbuf_len)
     %ld(t1, t1, 0)
     ::loop
     %beq(t0, t1, &::done)
     %readbuf_byte(a0, t0)
     %is_ws_branch(a1, a0, &::step)
     %b(&::done)
     ::step
     %addi(t0, t0, 1)
     %b(&::loop)
     ::done
     %st(t0, t2, 0)
     %ret
 %endscope
 
 # parse_one() -> tagged value in a0
 %fn(parse_one, 0, {
     %call(&skip_ws)
 
     %la(t0, &readbuf_pos)
     %ld(t0, t0, 0)
     %la(t1, &readbuf_len)
     %ld(t1, t1, 0)
     %beq(t0, t1, &::eof)
 
     %readbuf_byte(a0, t0)
 
     %addi(a1, a0, -40)
     %beqz(a1, &::lparen)
     %addi(a1, a0, -41)
     %beqz(a1, &::rparen)
 
     %call(&parse_atom)
     %eret
 
     ::lparen
     # Consume '(' and read items until ')'.
     %la(t0, &readbuf_pos)
     %ld(t1, t0, 0)
     %addi(t1, t1, 1)
     %st(t1, t0, 0)
     %call(&parse_list)
     %eret
 
     ::rparen
     %die(msg_unexp_rparen, 6)
 
     ::eof
     %die(msg_unexp_eof, 6)
 })
 
 # parse_list() -> tagged list value in a0. Cursor sits past '(' on entry;
 # returns once ')' is consumed.
 #
 # Frame: 16 bytes
 #   +0  head (NIL until first item)
 #   +8  tail (most recent cons; set-cdr! target)
 %fn(parse_list, 16, {
     %li(t0, %imm_val(%IMM.NIL))
     %st(t0, sp, 0)
     %st(t0, sp, 8)
 
     ::loop
     %call(&skip_ws)
     %la(t0, &readbuf_pos)
     %ld(t0, t0, 0)
     %la(t1, &readbuf_len)
     %ld(t1, t1, 0)
     %beq(t0, t1, &::eof)
 
     %readbuf_byte(a0, t0)
     %addi(a1, a0, -41)
     %beqz(a1, &::close)
 
     # Not ')': parse one item, append.
     %call(&parse_one)
     %li(a1, %imm_val(%IMM.NIL))
     %call(&cons)
 
     # If head is NIL, both head and tail = new cons; else set-cdr! tail = new.
     %ld(t0, sp, 0)
     %li(t1, %imm_val(%IMM.NIL))
     %bne(t0, t1, &::link)
     %st(a0, sp, 0)
     %st(a0, sp, 8)
     %b(&::loop)
 
     ::link
     %ld(t0, sp, 8)
     # set-cdr! tail = a0  -> store a0 at [tail + 7] (raw + 8)
     %st(a0, t0, 7)
     %st(a0, sp, 8)
     %b(&::loop)
 
     ::close
     # Consume ')' and return head.
     %la(t0, &readbuf_pos)
     %ld(t1, t0, 0)
     %addi(t1, t1, 1)
     %st(t1, t0, 0)
     %ld(a0, sp, 0)
     %eret
 
     ::eof
     %die(msg_unterm_list, 6)
 })
 
 # parse_atom() -> tagged value (fixnum or symbol) in a0.
 # Reads until whitespace or paren or EOF, then dispatches by first byte.
 #
 # Frame: 16 bytes
 #   +0  start cursor (byte offset)
 #   +8  end cursor   (byte offset)
 %fn(parse_atom, 16, {
     %la(t0, &readbuf_pos)
     %ld(t1, t0, 0)
     %st(t1, sp, 0)
 
     %la(t2, &readbuf_len)
     %ld(t2, t2, 0)
 
     ::scan
     %beq(t1, t2, &::end)
     %readbuf_byte(a0, t1)
 
     %is_ws_branch(a1, a0, &::end)
     # paren?
     %addi(a1, a0, -40)
     %beqz(a1, &::end)
     %addi(a1, a0, -41)
     %beqz(a1, &::end)
 
     %addi(t1, t1, 1)
     %b(&::scan)
 
     ::end
     %st(t1, sp, 8)
     %la(t0, &readbuf_pos)
     %st(t1, t0, 0)
 
     # Dispatch on the first byte.
     %ld(t0, sp, 0)
     %la(a0, &readbuf_buf_ptr)
     %ld(a0, a0, 0)
     %add(a0, a0, t0)
     %lb(t1, a0, 0)
 
     # '0'..'9' -> int
     %addi(a1, t1, -48)
     %li(a2, 10)
     %bltu(a1, a2, &::is_int)
     # '-' followed by digit -> int
     %addi(a1, t1, -45)
     %bnez(a1, &::is_sym)
     # there must be at least one more byte for it to be a number
     %ld(t2, sp, 8)
     %addi(t0, t0, 1)
     %beq(t0, t2, &::is_sym)
     %readbuf_byte(a0, t0)
     %addi(a1, a0, -48)
     %bltu(a1, a2, &::is_int)
     # fall through to is_sym
 
     ::is_sym
     %ld(a0, sp, 0)
     %la(t0, &readbuf_buf_ptr)
     %ld(t0, t0, 0)
     %add(a0, t0, a0)
     %ld(t1, sp, 8)
     %ld(t2, sp, 0)
     %sub(a1, t1, t2)
     %call(&intern)
     %eret
 
     ::is_int
     %ld(a0, sp, 0)
     %ld(a1, sp, 8)
     %call(&parse_int)
 })
 
 # parse_int(start_off=a0, end_off=a1) -> tagged fixnum in a0. Leaf.
 :parse_int
 %scope parse_int
     %la(t0, &readbuf_buf_ptr)
     %ld(t0, t0, 0)
     %add(t1, t0, a1)        ; t1 = end pointer = base + end_off
     %add(t0, t0, a0)        ; t0 = start pointer = base + start_off
 
     %li(a2, 0)              ; a2 = "is negative" flag (0 = positive)
     %lb(a3, t0, 0)
     %addi(a3, a3, -45)
     %bnez(a3, &::loop)
     %li(a2, 1)
     %addi(t0, t0, 1)
 
     ::loop
     %li(a0, 0)
     %li(t2, 10)
     ::step
     %beq(t0, t1, &::done)
     %lb(a3, t0, 0)
     %addi(a3, a3, -48)
     %mul(a0, a0, t2)
     %add(a0, a0, a3)
     %addi(t0, t0, 1)
     %b(&::step)
 
     ::done
     %beqz(a2, &::tag)
     %li(t2, 0)
     %sub(a0, t2, a0)
     ::tag
     %mkfix(a0, a0)
     %ret
 %endscope
 
 # =========================================================================
 # eval / apply
 # =========================================================================
 #
 # eval is the only place that touches tag bits at runtime; the table
 # below is a flat compare cascade for now (5 tags). When special-form
 # dispatch is wired up the SYM/PAIR paths split further per LISP-C.md
 # §Eval.
 
 # eval(expr=a0, env=a1) -> value (a0)
 #
 # Frame: 32 bytes
 #   +0  expr
 #   +8  env
 #   +16 fn (head value, while args are being evaluated)
 %fn(eval, 32, {
     %st(a0, sp, 0)
     %st(a1, sp, 8)
 
     %tagof(t0, a0)
     %li(t1, %TAG.PAIR)
     %beq(t0, t1, &::pair)
     %li(t1, %TAG.SYM)
     %beq(t0, t1, &::sym)
     # FIXNUM, HEAP, IMM all self-evaluate.
     %eret
 
     ::sym
     %untag_sym(a0, a0)
     %call(&sym_global)
     %li(t0, %imm_val(%IMM.UNBOUND))
     %beq(a0, t0, &::unbound)
     %eret
 
     ::unbound
     %die(msg_unbound, 7)
 
     ::pair
     # head = eval(car(expr), env)
     %ld(a0, sp, 0)
     %car(a0, a0)
     %ld(a1, sp, 8)
     %call(&eval)
     %st(a0, sp, 16)
 
     # args = eval_args(cdr(expr), env)
     %ld(a0, sp, 0)
     %cdr(a0, a0)
     %ld(a1, sp, 8)
     %call(&eval_args)
 
     # apply(fn, args)
     %mov(a1, a0)
     %ld(a0, sp, 16)
     %call(&apply)
 })
 
 # eval_args(args=a0, env=a1) -> evaluated args list (cons-built).
 # Recursion depth = arg count, so very long arg lists could blow the
 # stack. Iterative tail-build is a future tightening.
 %fn(eval_args, 24, {
     %li(t0, %imm_val(%IMM.NIL))
     %beq(a0, t0, &::nil)
 
     %st(a0, sp, 0)
     %st(a1, sp, 8)
 
     # val = eval(car(args), env)
     %car(a0, a0)
     %call(&eval)
     %st(a0, sp, 16)
 
     # rest = eval_args(cdr(args), env)
     %ld(a0, sp, 0)
     %cdr(a0, a0)
     %ld(a1, sp, 8)
     %call(&eval_args)
 
     # cons(val, rest)
     %mov(a1, a0)
     %ld(a0, sp, 16)
     %call(&cons)
     %eret
 
     ::nil
     %li(a0, %imm_val(%IMM.NIL))
 })
 
 # apply(fn=a0, args=a1) -> result (a0)
 #
 # Frame: 16 bytes
 #   +0  args
 %fn(apply, 16, {
     %st(a1, sp, 0)
 
     # Only HEAP-tagged values can be applicable. PRIM is the only header
     # type wired up here.
     %tagof(t0, a0)
     %li(t1, %TAG.HEAP)
     %bne(t0, t1, &::not_proc)
 
     %hdr_type(t0, a0)
     %li(t1, %HDR.PRIM)
     %beq(t0, t1, &::prim)
 
     ::not_proc
     %die(msg_not_proc, 8)
 
     ::prim
     %ld(t0, a0, 5)         ; t0 = entry word (offset = -3 + 8)
     %ld(a0, sp, 0)         ; args list -> a0
     %callr(t0)
 })
 
 # =========================================================================
 # Primitives
 # =========================================================================
 #
 # Each primitive sits behind a 16-byte heap object literal in the data
 # section: [hdr_word, entry_word]. The tagged value is &obj + 3.
 # register_primitives interns the surface name and writes the tagged
 # pointer into the symbol's global slot.
 
 %fn(register_primitives, 0, {
     %la(a0, &name_sys_exit)
     %li(a1, 8)
     %call(&intern)
     %untag_sym(a0, a0)          ; idx
     %la(a1, &prim_sys_exit)
     %addi(a1, a1, 3)            ; tag HEAP
     %call(&sym_set_global)
 })
 
 # prim_sys_exit_entry(args=a0). Args is a one-element list whose car is
 # the exit code as a tagged fixnum. Untag and tail-jump to libp1pp's
 # sys_exit (a %b, not a %call -- this is a leaf with no frame, and
 # sys_exit doesn't return anyway).
 :prim_sys_exit_entry
     %car(a0, a0)            ; car = fixnum
     %untag_fix(a0, a0)
     %b(&sys_exit)
 
 # =========================================================================
 # Read-only data
 # =========================================================================
 
 # Primitive object literals (16 bytes each).
 :prim_sys_exit
 $(%HDR.PRIM) &prim_sys_exit_entry %(0)
 
 # Surface names. Length is hard-coded at the call site; no NUL needed
 # because intern takes (ptr, len). Aligned padding via "\0" bytes is
 # fine -- M0 emits ASCII verbatim.
 :name_sys_exit "sys-exit"
 
 :msg_usage          "scheme1: usage: scheme1 SOURCE.scm" '0a' '00'
 :msg_load_fail      "scheme1: failed to read source" '0a' '00'
 :msg_symtab_full    "scheme1: symbol table full" '0a' '00'
 :msg_unexp_rparen   "scheme1: unexpected ')'" '0a' '00'
 :msg_unexp_eof      "scheme1: unexpected EOF in form" '0a' '00'
 :msg_unterm_list    "scheme1: unterminated list" '0a' '00'
 :msg_unbound        "scheme1: unbound variable" '0a' '00'
 :msg_not_proc       "scheme1: not a procedure" '0a' '00'
 
 # =========================================================================
 # BSS pointer-init table
 # =========================================================================
 #
 # Each entry: 8-byte slot pointer (4-byte label ref + 4 bytes pad) +
 # 8-byte offset constant. p1_main walks this once at startup.
 :bss_init_tbl
 &readbuf_buf_ptr %(0) $(0)
 &heap_buf_ptr    %(0) $(0x10000)
 &symtab_buf_ptr  %(0) $(0x20000)
 :bss_init_tbl_end
 
 # =========================================================================
 # Scalar BSS (file-resident, zero-initialized)
 # =========================================================================
 
 # heap_next: bump pointer; written once by p1_main, then by cons/alloc_hdr.
 :heap_next        $(0)
 
 # Source-buffer cursor and slurped length.
 :readbuf_pos      $(0)
 :readbuf_len      $(0)
 
 # Symbol table count (number of entries used).
 :symtab_count     $(0)
 
 # Pointer slots for the past-:ELF_end arenas.
 :readbuf_buf_ptr  $(0)
 :heap_buf_ptr     $(0)
 :symtab_buf_ptr   $(0)
 
 :ELF_end