ww/selfhost/cmd/w6a/main.combined.ww

// os — process and filesystem facade. The body of each call lands
// either in libwwrt.a (rt_syscall trampoline) or libc bindings,
// depending on how the program was linked.

@symbol("rt_syscall") fn syscall0(num: i64) i64;
@symbol("rt_syscall") fn syscall1(num: i64, a: i64) i64;
@symbol("rt_syscall") fn syscall2(num: i64, a: i64, b: i64) i64;
@symbol("rt_syscall") fn syscall3(num: i64, a: i64, b: i64, c: i64) i64;
@symbol("rt_syscall") fn syscall4(num: i64, a: i64, b: i64, c: i64, d: i64) i64;

@symbol("rt_alloc") fn alloc(n: u64) *void;
@symbol("rt_free")  fn free(p: *void, n: u64) void;
@symbol("rt_abort") fn abort(msg: str) void;

// Hare-style runtime check. Caller passes a message that's printed
// to stderr before exit(1).
export fn assert(cond: bool, msg: str) void = {
	if (!cond) { abort(msg); };
};

def SYS_READ:        i64 = 0;
def SYS_WRITE:       i64 = 1;
def SYS_OPEN:        i64 = 2;
def SYS_CLOSE:       i64 = 3;
def SYS_LSEEK:       i64 = 8;
def SYS_ACCESS:      i64 = 21;
def SYS_DUP2:        i64 = 33;
def SYS_GETPID:      i64 = 39;
def SYS_FORK:        i64 = 57;
def SYS_EXECVE:      i64 = 59;
def SYS_EXIT:        i64 = 60;
def SYS_WAIT4:       i64 = 61;
def SYS_UNLINK:      i64 = 87;
def SYS_GETCWD:      i64 = 79;
def SYS_GETDENTS64:  i64 = 217;

// open(2) flags. Linux values, matching <fcntl.h>.
def O_RDONLY: i32 = 0;
def O_WRONLY: i32 = 1;
def O_RDWR:   i32 = 2;
def O_CREAT:  i32 = 64;		// 0x40
def O_TRUNC:  i32 = 512;	// 0x200

// lseek(2) whence.
def SEEK_SET: i32 = 0;
def SEEK_CUR: i32 = 1;
def SEEK_END: i32 = 2;

export fn exit(code: i32) void = {
	syscall1(SYS_EXIT, code: i64);
};

// Raw, non-fallible primitives. These return Linux's int conventions
// (negative = -errno, non-negative = bytes/fd/etc). Callers wanting a
// Hare-style fallible API use the wrappers below.
export fn write(fd: i32, buf: *u8, n: u64) i64 = {
	return syscall3(SYS_WRITE, fd: i64, buf: i64, n: i64);
};

export fn read(fd: i32, buf: *u8, n: u64) i64 = {
	return syscall3(SYS_READ, fd: i64, buf: i64, n: i64);
};

export fn close(fd: i32) i32 = {
	return syscall1(SYS_CLOSE, fd: i64): i32;
};

// dup2(2): make `newfd` refer to the same description as `oldfd`,
// closing `newfd` first if open. Returns `newfd` on success or a
// negative errno. Used by w6c_ww to redirect stdout into an output
// file without changing the cgen emit path.
export fn dup2(oldfd: i32, newfd: i32) i32 = {
	return syscall2(SYS_DUP2, oldfd: i64, newfd: i64): i32;
};

// Fallible wrappers. The error variant is a plain str (Plan 9 errstr
// model, see lib/errors); the sum type makes success/failure explicit
// without overloading length-zero.
export fn tryread(fd: i32, buf: *u8, n: u64) (i64 | str) = {
	let r: i64 = read(fd, buf, n);
	if (r < 0) { return "read failed"; };
	return r;
};

export fn trywrite(fd: i32, buf: *u8, n: u64) (i64 | str) = {
	let r: i64 = write(fd, buf, n);
	if (r < 0) { return "write failed"; };
	return r;
};

// open — Linux open(2). Path must be NUL-terminated; callers using ww
// `str` must ensure the bytes are followed by a 0 byte (literals are,
// arena-copied paths usually are by construction). Returns -errno on
// failure, fd otherwise. Higher-level callers prefer `tryopen`.
export fn open(path: *u8, flags: i32, mode: i32) i32 = {
	return syscall3(SYS_OPEN, path: i64, flags: i64, mode: i64): i32;
};

export fn tryopen(path: *u8, flags: i32, mode: i32) (i32 | str) = {
	let fd: i32 = open(path, flags, mode);
	if (fd < 0) { return "open failed"; };
	return fd;
};

// lseek — set/inspect the fd's position. Returns the new offset or
// a negative errno. We use this for fstat-free file-size discovery
// (open ⇒ lseek to end ⇒ lseek back).
export fn lseek(fd: i32, off: i64, whence: i32) i64 = {
	return syscall3(SYS_LSEEK, fd: i64, off, whence: i64);
};

// filesize — convenience: returns the byte length of an open fd by
// seeking to the end and back. -1 on error.
export fn filesize(fd: i32) i64 = {
	let end: i64 = lseek(fd, 0i64, SEEK_END);
	if (end < 0) { return -1i64; };
	let r: i64 = lseek(fd, 0i64, SEEK_SET);
	if (r < 0) { return -1i64; };
	return end;
};

// readfull — keep reading until `n` bytes have arrived or the fd
// closes early. Returns bytes read (0..=n) or -1 on read error.
export fn readfull(fd: i32, buf: *u8, n: u64) i64 = {
	let got: u64 = 0u64;
	for (got < n) {
		let r: i64 = read(fd, buf + got, n - got);
		if (r < 0) { return -1i64; };
		if (r == 0) { return got: i64; };	// short read: caller decides
		got += r: u64;
	};
	return got: i64;
};

// writefull — keep writing until `n` bytes have been accepted or the
// fd refuses progress. Returns bytes written or -1.
export fn writefull(fd: i32, buf: *u8, n: u64) i64 = {
	let sent: u64 = 0u64;
	for (sent < n) {
		let r: i64 = write(fd, buf + sent, n - sent);
		if (r < 0) { return -1i64; };
		if (r == 0) { return sent: i64; };
		sent += r: u64;
	};
	return sent: i64;
};

// ---- process and filesystem helpers used by the `ww` driver ----------

// access(2): returns 0 if the file is reachable, negative errno
// otherwise. mode is the bitset described in <unistd.h> (F_OK=0).
export fn access(path: *u8, mode: i32) i32 = {
	return syscall2(SYS_ACCESS, path: i64, mode: i64): i32;
};

// unlink(2).
export fn unlink(path: *u8) i32 = {
	return syscall1(SYS_UNLINK, path: i64): i32;
};

// getpid(2). Used by the driver to mint unique scratch paths.
export fn getpid() i32 = {
	return syscall0(SYS_GETPID): i32;
};

// fork(2): 0 in the child, child pid in the parent, negative errno
// on failure.
export fn fork() i32 = {
	return syscall0(SYS_FORK): i32;
};

// execve(2): on success, does not return.
export fn execve(path: *u8, argv: **u8, envp: **u8) i32 = {
	return syscall3(SYS_EXECVE, path: i64, argv: i64, envp: i64): i32;
};

// wait4(2): wait for `pid` (or any child if -1), store status in
// `*status`, return the pid that ended (or negative errno).
export fn wait4(pid: i32, status: *i32, options: i32, rusage: *void) i32 = {
	return syscall4(SYS_WAIT4, pid: i64, status: i64,
	    options: i64, rusage: i64): i32;
};

// getcwd(2) — Linux flavour. Writes the NUL-terminated cwd into `buf`
// and returns the number of bytes written (including the NUL), or a
// negative errno. The driver uses it to expand `.` to the cwd's
// basename for `ww build` / `ww test`.
export fn getcwd(buf: *u8, n: u64) i64 = {
	return syscall2(SYS_GETCWD, buf: i64, n: i64);
};

// getdents64(2) — Linux directory enumeration. The fd must be opened
// with O_RDONLY on a directory. `buf` receives a packed sequence of
// linux_dirent64 records:
//
//   struct linux_dirent64 {
//       u64  d_ino;       // 0..7
//       i64  d_off;       // 8..15
//       u16  d_reclen;    // 16..17  — total bytes for this record
//       u8   d_type;      // 18      — DT_REG/DT_DIR/...
//       u8   d_name[];    // 19..    — NUL-terminated name + padding
//   };
//
// Returns bytes written into `buf` (advance by d_reclen to walk),
// 0 at end-of-directory, or a negative errno.
export fn getdents64(fd: i32, buf: *u8, n: u64) i64 = {
	return syscall3(SYS_GETDENTS64, fd: i64, buf: i64, n: i64);
};

// selfhost/cmd/wcc/mem.ww — port of cmd/wcc/mem.c.
//
// Bump arena allocator. Backed by the runtime page allocator
// (rt_alloc / rt_free), no libc. Each chunk is mmap'd; when the
// current chunk runs out we link a fresh one. Freeing the arena
// unmaps the chain.
//
// Memory handed out is 16-byte aligned. The C version under
// cmd/wcc/ is retained until the three-stage bootstrap diffs clean.

use os;

def ALIGN: u64       = 16u64;
def INIT_CHUNK: u64  = 65536u64;
def MAX_CHUNK: u64   = 4194304u64;
def ARENA_SZ: u64    = 48u64;	// sizeof(arena), kept in sync below

type arena = struct {
	buf:   *u8,
	off:   u64,
	cap:   u64,
	next:  *arena,
	total: u64,
};

fn roundup(n: u64, a: u64) u64 = {
	return (n + a - 1u64) & ~(a - 1u64);
};

export fn newarena() *arena = {
	let a: *arena = os.alloc(ARENA_SZ): *arena;
	a.buf = os.alloc(INIT_CHUNK): *u8;
	a.off = 0u64;
	a.cap = INIT_CHUNK;
	a.next = nil;
	a.total = 0u64;
	return a;
};

// Grow: link a fresh chunk in front of the head. We push the old
// chunk into `next` so the head always describes the current bump
// region. Chunk size doubles up to MAX_CHUNK.
fn grow(a: *arena, need: u64) bool = {
	let want: u64 = a.cap * 2u64;
	if (want < need) { want = need; };
	if (want > MAX_CHUNK) { want = MAX_CHUNK; };
	if (want < need) { return false; };	// single allocation too big

	let old: *arena = os.alloc(ARENA_SZ): *arena;
	old.buf = a.buf;
	old.off = a.off;
	old.cap = a.cap;
	old.next = a.next;
	old.total = 0u64;

	a.buf = os.alloc(want): *u8;
	a.off = 0u64;
	a.cap = want;
	a.next = old;
	return true;
};

export fn amalloc(a: *arena, n: u64) *void = {
	let need: u64 = roundup(n, ALIGN);
	if (need > a.cap - a.off) {
		if (!grow(a, need)) { return nil; };
	};
	let p: *u8 = a.buf + a.off;
	a.off += need;
	a.total += need;
	// Zero the region. Plan 9 amalloc zeroes; we mirror that here so
	// the checker can assume freshly allocated nodes start at 0.
	let i: u64 = 0u64;
	for (i < need) {
		p[i] = 0u8;
		i += 1u64;
	};
	return p: *void;
};

// astrndup — copy `n` bytes into the arena and produce a NUL-terminated
// view. Returns a `str` whose ptr is arena-owned and whose len is `n`
// (the trailing NUL is past `len`, so callers reading exactly n bytes
// see no padding). Used by the lexer to capture token text.
export fn astrndup(a: *arena, src: *u8, n: u64) str = {
	let p: *u8 = amalloc(a, n + 1u64): *u8;
	let i: u64 = 0u64;
	for (i < n) {
		p[i] = src[i];
		i += 1u64;
	};
	p[n] = 0u8;
	let r: str;
	r.ptr = p;
	r.len = n: i32;
	return r;
};

export fn freearena(a: *arena) void = {
	for (a != nil) {
		let next: *arena = a.next;
		os.free(a.buf: *void, a.cap);
		os.free(a: *void, ARENA_SZ);
		a = next;
	};
};

// selfhost/cmd/w6a/types.ww — types + constants shared across the
// w6a port. Mirrors cmd/w6a/a.h and cmd/w6c/6.out.h.

use mem;

// ---- registers + operand kinds (from 6.out.h) -------------------------
// These must stay numerically aligned with the C enum so that ww-cgen
// output (which reads them via `D_AX(SB)` etc.) lands on the same
// integers when read by ww-w6a.
def D_NONE: i32 = 0;

def D_AX: i32 = 1;
def D_CX: i32 = 2;
def D_DX: i32 = 3;
def D_BX: i32 = 4;
def D_SP: i32 = 5;
def D_BP: i32 = 6;
def D_SI: i32 = 7;
def D_DI: i32 = 8;
def D_R8:  i32 = 9;
def D_R9:  i32 = 10;
def D_R10: i32 = 11;
def D_R11: i32 = 12;
def D_R12: i32 = 13;
def D_R13: i32 = 14;
def D_R14: i32 = 15;
def D_R15: i32 = 16;

def D_X0:  i32 = 17;
def D_X1:  i32 = 18;
def D_X2:  i32 = 19;
def D_X3:  i32 = 20;
def D_X4:  i32 = 21;
def D_X5:  i32 = 22;
def D_X6:  i32 = 23;
def D_X7:  i32 = 24;
def D_X8:  i32 = 25;
def D_X9:  i32 = 26;
def D_X10: i32 = 27;
def D_X11: i32 = 28;
def D_X12: i32 = 29;
def D_X13: i32 = 30;
def D_X14: i32 = 31;
def D_X15: i32 = 32;

def D_PSP: i32 = 33;
def D_PFP: i32 = 34;
def D_PSB: i32 = 35;

def D_CONST:  i32 = 36;
def D_BRANCH: i32 = 37;
def D_EXTERN: i32 = 38;
def D_INDIR:  i32 = 39;

// ---- opcodes ----------------------------------------------------------
def A_NOP: i32 = 0;
def A_TEXT: i32 = 1;
def A_DATA: i32 = 2;
def A_GLOBL: i32 = 3;
def A_END: i32 = 4;

def A_MOVQ: i32 = 5;
def A_MOVL: i32 = 6;
def A_MOVB: i32 = 7;
def A_MOVZBQ: i32 = 8;
def A_MOVSXD: i32 = 9;

def A_MOVSD: i32 = 10;
def A_ADDSD: i32 = 11;
def A_SUBSD: i32 = 12;
def A_MULSD: i32 = 13;
def A_DIVSD: i32 = 14;
def A_UCOMISD: i32 = 15;
def A_CVTTSD2SI: i32 = 16;
def A_CVTSI2SD: i32 = 17;

def A_MOVSS: i32 = 18;
def A_ADDSS: i32 = 19;
def A_SUBSS: i32 = 20;
def A_MULSS: i32 = 21;
def A_DIVSS: i32 = 22;
def A_UCOMISS: i32 = 23;
def A_CVTTSS2SI: i32 = 24;
def A_CVTSI2SS: i32 = 25;
def A_CVTSD2SS: i32 = 26;
def A_CVTSS2SD: i32 = 27;

def A_ADDQ: i32 = 28;
def A_SUBQ: i32 = 29;
def A_IMULQ: i32 = 30;
def A_IDIVQ: i32 = 31;
def A_DIVQ: i32 = 32;
def A_NEGQ: i32 = 33;
def A_NOTQ: i32 = 34;
def A_ANDQ: i32 = 35;
def A_ORQ: i32 = 36;
def A_XORQ: i32 = 37;
def A_SHLQ: i32 = 38;
def A_SHRQ: i32 = 39;
def A_CMPQ: i32 = 40;

def A_PUSHQ: i32 = 41;
def A_POPQ: i32 = 42;
def A_LEAQ: i32 = 43;

def A_CALL: i32 = 44;
def A_RET:  i32 = 45;
def A_JMP:  i32 = 46;
def A_JE:   i32 = 47;
def A_JNE:  i32 = 48;
def A_JL:   i32 = 49;
def A_JLE:  i32 = 50;
def A_JG:   i32 = 51;
def A_JGE:  i32 = 52;
def A_JB:   i32 = 53;
def A_JBE:  i32 = 54;
def A_JA:   i32 = 55;
def A_JAE:  i32 = 56;
def A_JZ:   i32 = 57;
def A_JNZ:  i32 = 58;

def A_SYSCALL: i32 = 59;

// ---- structs (mirror cmd/w6a/a.h) --------------------------------------

type aoperand = struct {
	atype:  i32,	// D_NONE / D_AX..D_R15 / D_CONST / D_INDIR / D_EXTERN / D_BRANCH
	reg:    i32,
	offset: i64,
	asym:   str,
};

// `from` and `to` are pointer-to-aoperand (rather than embedded). The
// C cgen we currently bootstrap on doesn't support chained-dot through
// embedded structs (e.g. p.to.atype where `to` is a value field), but
// it does support chained-dot through pointer fields. Allocating each
// operand once per prog lets us write `p.to.atype` straightforwardly.
type aprog = struct {
	as_:   i32,
	from:  *aoperand,
	to:    *aoperand,
	line:  i32,
	label: str,
	link:  *aprog,
	bytes: *u8,	// payload for A_DATA
	nbytes: u64,
};

type asym = struct {
	name:      str,
	defined:   i32,
	istext:    i32,
	isglobal:  i32,
	addr:      u64,
	idx:       i32,
	snext:     *asym,
};

type areloc = struct {
	off:    u64,
	kind:   i32,
	asy:    *asym,
	addend: i64,
	rnext:  *areloc,
};

type afixup = struct {
	off:    u64,	// where the rel32 lands in .text
	label:  str,
	fnext:  *afixup,
};

type asm_ = struct {
	a:       *arena,
	file:    str,
	src:     *u8,
	srclen:  u64,
	pos:     u64,
	line:    i32,

	head:    *aprog,
	tail:    *aprog,

	text:    *u8,
	textcap: u64,
	textlen: u64,

	syms:    *asym,
	relocs:  *areloc,
	fixups:  *afixup,

	errs:    i32,
};

// selfhost/cmd/w6a/lex.ww — port of cmd/w6a/lex.c.
//
// Character-level helpers for w6a's line-oriented parser. The parser
// itself is in parse.ww; here we keep tokenisers for identifiers and
// numbers so parse.ww stays focused on syntax.

export fn isidstart(c: i32) bool = {
	if (c == 95) { return true; };
	if (c >= 65) { if (c <= 90)  { return true; }; };	// A-Z
	if (c >= 97) { if (c <= 122) { return true; }; };	// a-z
	return false;
};

export fn isidcont(c: i32) bool = {
	if (isidstart(c)) { return true; };
	if (c >= 48) { if (c <= 57) { return true; }; };	// 0-9
	if (c == 46) { return true; };				// .
	return false;
};

// parsenum — read a leading [+-]?[0x|0X|0]?digits from p[0..n-1].
// Returns (value, consumed). Stops at first non-digit.
// Plain Plan 9-style: $123 / $0x1f / $-7. Decimal default; 0x prefix
// for hex; 0 prefix for octal when followed by a digit (else just 0).
export fn parsenum(p: *u8, n: u64) (i64, u64) = {
	let i: u64 = 0u64;
	let neg: bool = false;
	if (i < n) {
		if (p[i] == 45u8) { neg = true; i += 1u64; }
		else { if (p[i] == 43u8) { i += 1u64; }; };
	};
	let base: i64 = 10i64;
	if (i + 1u64 < n) {
		if (p[i] == 48u8) {
			if (p[i + 1u64] == 120u8) { base = 16i64; i += 2u64; }
			else { if (p[i + 1u64] == 88u8) { base = 16i64; i += 2u64; }
			else { if (p[i + 1u64] >= 48u8) { if (p[i + 1u64] <= 55u8) {
				base = 8i64; i += 1u64;
			};};};};
		};
	};
	let v: i64 = 0i64;
	let scan: bool = true;
	for (scan) {
		if (i >= n) { scan = false; }
		else {
			let c: u8 = p[i];
			let d: i64 = -1i64;
			if (c >= 48u8) { if (c <= 57u8) { d = (c - 48u8): i64; }; };
			if (d < 0i64) {
				if (base == 16i64) {
					if (c >= 97u8) { if (c <= 102u8) { d = (c - 97u8): i64 + 10i64; }; };
					if (c >= 65u8) { if (c <= 70u8)  { d = (c - 65u8): i64 + 10i64; }; };
				};
			};
			if (d < 0i64) { scan = false; }
			else { if (d >= base) { scan = false; }
			else {
				v = v * base + d;
				i += 1u64;
			}; };
		};
	};
	if (neg) { v = -v; };
	return v, i;
};

// selfhost/cmd/w6a/parse.ww — port of cmd/w6a/parse.c.
//
// Line-oriented parser for the asm subset emitted by w6c.
// Grammar:
//   line  := blank | comment | label | text | instr
//   blank := /^\s*$/
//   comment := /^\s*\/\/.*$/
//   label := /^IDENT:$/
//   text  := TEXT name,$framesize
//   instr := \tMNEM\t[OP1[, OP2]]
//   OP    := $NUM | REG | NUM(REG) | (REG) | name(SB) | label

use os;
use mem;
use lex;
use types;

fn streqlit(p: *u8, n: u64, lit: str) bool = {
	if (n != lit.len: u64) { return false; };
	let i: u64 = 0u64;
	for (i < n) {
		let li: i32 = i: i32;
		if (p[i] != lit[li]) { return false; };
		i += 1u64;
	};
	return true;
};

// opcodelookup — name (length-bounded *u8) → A_*. Returns 0 (A_NOP)
// if not found.
fn opcodelookup(p: *u8, n: u64) i32 = {
	if (streqlit(p, n, "MOVQ"))    { return A_MOVQ; };
	if (streqlit(p, n, "MOVL"))    { return A_MOVL; };
	if (streqlit(p, n, "MOVB"))    { return A_MOVB; };
	if (streqlit(p, n, "MOVZBQ"))  { return A_MOVZBQ; };
	if (streqlit(p, n, "MOVSXD"))  { return A_MOVSXD; };
	if (streqlit(p, n, "MOVSD"))   { return A_MOVSD; };
	if (streqlit(p, n, "ADDSD"))   { return A_ADDSD; };
	if (streqlit(p, n, "SUBSD"))   { return A_SUBSD; };
	if (streqlit(p, n, "MULSD"))   { return A_MULSD; };
	if (streqlit(p, n, "DIVSD"))   { return A_DIVSD; };
	if (streqlit(p, n, "UCOMISD")) { return A_UCOMISD; };
	if (streqlit(p, n, "CVTTSD2SI")) { return A_CVTTSD2SI; };
	if (streqlit(p, n, "CVTSI2SD")) { return A_CVTSI2SD; };
	if (streqlit(p, n, "MOVSS"))   { return A_MOVSS; };
	if (streqlit(p, n, "ADDSS"))   { return A_ADDSS; };
	if (streqlit(p, n, "SUBSS"))   { return A_SUBSS; };
	if (streqlit(p, n, "MULSS"))   { return A_MULSS; };
	if (streqlit(p, n, "DIVSS"))   { return A_DIVSS; };
	if (streqlit(p, n, "UCOMISS")) { return A_UCOMISS; };
	if (streqlit(p, n, "CVTTSS2SI")) { return A_CVTTSS2SI; };
	if (streqlit(p, n, "CVTSI2SS")) { return A_CVTSI2SS; };
	if (streqlit(p, n, "CVTSD2SS")) { return A_CVTSD2SS; };
	if (streqlit(p, n, "CVTSS2SD")) { return A_CVTSS2SD; };
	if (streqlit(p, n, "ADDQ"))    { return A_ADDQ; };
	if (streqlit(p, n, "SUBQ"))    { return A_SUBQ; };
	if (streqlit(p, n, "IMULQ"))   { return A_IMULQ; };
	if (streqlit(p, n, "IDIVQ"))   { return A_IDIVQ; };
	if (streqlit(p, n, "DIVQ"))    { return A_DIVQ; };
	if (streqlit(p, n, "NEGQ"))    { return A_NEGQ; };
	if (streqlit(p, n, "NOTQ"))    { return A_NOTQ; };
	if (streqlit(p, n, "ANDQ"))    { return A_ANDQ; };
	if (streqlit(p, n, "ORQ"))     { return A_ORQ; };
	if (streqlit(p, n, "XORQ"))    { return A_XORQ; };
	if (streqlit(p, n, "SHLQ"))    { return A_SHLQ; };
	if (streqlit(p, n, "SHRQ"))    { return A_SHRQ; };
	if (streqlit(p, n, "CMPQ"))    { return A_CMPQ; };
	if (streqlit(p, n, "PUSHQ"))   { return A_PUSHQ; };
	if (streqlit(p, n, "POPQ"))    { return A_POPQ; };
	if (streqlit(p, n, "LEAQ"))    { return A_LEAQ; };
	if (streqlit(p, n, "CALL"))    { return A_CALL; };
	if (streqlit(p, n, "RET"))     { return A_RET; };
	if (streqlit(p, n, "JMP"))     { return A_JMP; };
	if (streqlit(p, n, "JE"))      { return A_JE; };
	if (streqlit(p, n, "JNE"))     { return A_JNE; };
	if (streqlit(p, n, "JL"))      { return A_JL; };
	if (streqlit(p, n, "JLE"))     { return A_JLE; };
	if (streqlit(p, n, "JG"))      { return A_JG; };
	if (streqlit(p, n, "JGE"))     { return A_JGE; };
	if (streqlit(p, n, "JB"))      { return A_JB; };
	if (streqlit(p, n, "JBE"))     { return A_JBE; };
	if (streqlit(p, n, "JA"))      { return A_JA; };
	if (streqlit(p, n, "JAE"))     { return A_JAE; };
	if (streqlit(p, n, "JZ"))      { return A_JZ; };
	if (streqlit(p, n, "JNZ"))     { return A_JNZ; };
	if (streqlit(p, n, "SYSCALL")) { return A_SYSCALL; };
	if (streqlit(p, n, "TEXT"))    { return A_TEXT; };
	if (streqlit(p, n, "DATA"))    { return A_DATA; };
	return A_NOP;
};

// reglookup — name → D_*. Returns D_NONE if not found.
fn reglookup(p: *u8, n: u64) i32 = {
	if (streqlit(p, n, "AX")) { return D_AX; };
	if (streqlit(p, n, "BX")) { return D_BX; };
	if (streqlit(p, n, "CX")) { return D_CX; };
	if (streqlit(p, n, "DX")) { return D_DX; };
	if (streqlit(p, n, "SP")) { return D_SP; };
	if (streqlit(p, n, "BP")) { return D_BP; };
	if (streqlit(p, n, "SI")) { return D_SI; };
	if (streqlit(p, n, "DI")) { return D_DI; };
	if (streqlit(p, n, "R8"))  { return D_R8; };
	if (streqlit(p, n, "R9"))  { return D_R9; };
	if (streqlit(p, n, "R10")) { return D_R10; };
	if (streqlit(p, n, "R11")) { return D_R11; };
	if (streqlit(p, n, "R12")) { return D_R12; };
	if (streqlit(p, n, "R13")) { return D_R13; };
	if (streqlit(p, n, "R14")) { return D_R14; };
	if (streqlit(p, n, "R15")) { return D_R15; };
	if (streqlit(p, n, "X0"))  { return D_X0; };
	if (streqlit(p, n, "X1"))  { return D_X1; };
	if (streqlit(p, n, "X2"))  { return D_X2; };
	if (streqlit(p, n, "X3"))  { return D_X3; };
	if (streqlit(p, n, "X4"))  { return D_X4; };
	if (streqlit(p, n, "X5"))  { return D_X5; };
	if (streqlit(p, n, "X6"))  { return D_X6; };
	if (streqlit(p, n, "X7"))  { return D_X7; };
	if (streqlit(p, n, "X8"))  { return D_X8; };
	if (streqlit(p, n, "X9"))  { return D_X9; };
	if (streqlit(p, n, "X10")) { return D_X10; };
	if (streqlit(p, n, "X11")) { return D_X11; };
	if (streqlit(p, n, "X12")) { return D_X12; };
	if (streqlit(p, n, "X13")) { return D_X13; };
	if (streqlit(p, n, "X14")) { return D_X14; };
	if (streqlit(p, n, "X15")) { return D_X15; };
	if (streqlit(p, n, "SB"))  { return D_PSB; };
	if (streqlit(p, n, "FP"))  { return D_PFP; };
	return D_NONE;
};

export fn init(a: *asm_, ar: *arena, file: str, src: *u8, len: u64) void = {
	a.a = ar;
	a.file = file;
	a.src = src;
	a.srclen = len;
	a.pos = 0u64;
	a.line = 1;
	a.head = nil;
	a.tail = nil;
	a.text = nil;
	a.textcap = 0u64;
	a.textlen = 0u64;
	a.syms = nil;
	a.relocs = nil;
	a.fixups = nil;
	a.errs = 0;
};

// `streq(str,str)` lives in asm.ww — same bundle, single definition.

export fn intern(a: *asm_, name: str) *asym = {
	let s: *asym = a.syms;
	for (s != nil) {
		if (streq(s.name, name)) { return s; };
		s = s.snext;
	};
	let n: *asym = amalloc(a.a, 64u64): *asym;
	n.name = name;
	n.snext = a.syms;
	a.syms = n;
	return n;
};

fn perr(a: *asm_, msg: str) void = {
	os.write(2, "w6a: ".ptr, 4u64);
	let f: str = a.file;
	os.write(2, f.ptr, f.len: u64);
	os.write(2, ": ".ptr, 2u64);
	os.write(2, msg.ptr, msg.len: u64);
	os.write(2, "\n".ptr, 1u64);
	a.errs += 1;
};

// dupstr — copy n bytes from p into a fresh heap str.
fn dupstr(a: *arena, p: *u8, n: u64) str = {
	return astrndup(a, p, n);
};

// ---- line iteration & whitespace --------------------------------------

// Read next line into a fresh heap buffer; returns (ptr, len) or (nil,0)
// at EOF. Advances a.pos past the newline.
fn nextline(a: *asm_) (*u8, u64) = {
	if (a.pos >= a.srclen) { return nil, 0u64; };
	let start: u64 = a.pos;
	for (a.pos < a.srclen) {
		if (a.src[a.pos] == 10u8) { a.pos = a.pos; a.pos += 0u64; }	// no-op; explicit break via condition
		else { a.pos += 1u64; continue; };
		// hit newline
		let n: u64 = a.pos - start;
		let buf: *u8 = amalloc(a.a, n + 1u64): *u8;
		let i: u64 = 0u64;
		for (i < n) { buf[i] = a.src[start + i]; i += 1u64; };
		buf[n] = 0u8;
		a.pos += 1u64;	// skip newline
		return buf, n;
	};
	// EOF without trailing newline
	let n: u64 = a.pos - start;
	if (n == 0u64) { return nil, 0u64; };
	let buf: *u8 = amalloc(a.a, n + 1u64): *u8;
	let i: u64 = 0u64;
	for (i < n) { buf[i] = a.src[start + i]; i += 1u64; };
	buf[n] = 0u8;
	return buf, n;
};

fn skipws(p: *u8, off: u64, n: u64) u64 = {
	let i: u64 = off;
	for (i < n) {
		if (p[i] != 32u8) { if (p[i] != 9u8) { return i; }; };
		i += 1u64;
	};
	return i;
};

// parseoperand — parse one operand from p[off..n), populate out.
// Returns new offset (clamped to n on error).
fn parseoperand(a: *asm_, p: *u8, offin: u64, n: u64, out: *aoperand) u64 = {
	let off: u64 = skipws(p, offin, n);
	out.atype = D_NONE;
	out.reg = 0;
	out.offset = 0i64;
	let empty: str;
	empty.ptr = nil; empty.len = 0;
	out.asym = empty;
	if (off >= n) { return off; };
	let c0: u8 = p[off];

	// $NUM
	if (c0 == 36u8) {	// '$'
		off += 1u64;
		let v: i64;
		let used: u64;
		v, used = parsenum(p + off, n - off);
		out.atype = D_CONST;
		out.offset = v;
		return off + used;
	};

	// (REG)
	if (c0 == 40u8) {	// '('
		off += 1u64;
		let rstart: u64 = off;
		for (off < n) {
			if (p[off] == 41u8) { off = off; off += 0u64; }	// no-op marker
			else { off += 1u64; continue; };
			let rn: u64 = off - rstart;
			let r: i32 = reglookup(p + rstart, rn);
			if (r == 0) { perr(a, "bad register in indirect"); return n; };
			out.atype = D_INDIR;
			out.reg = r;
			out.offset = 0i64;
			return off + 1u64;	// past ')'
		};
		perr(a, "missing ')' in indirect");
		return n;
	};

	// number(REG) — possibly signed — or bare $NUM-less constant
	let cur: u64 = off;
	let is_num: bool = false;
	if (cur < n) {
		if (p[cur] == 45u8) { is_num = true; }
		else { if (p[cur] >= 48u8) { if (p[cur] <= 57u8) { is_num = true; }; }; };
	};
	if (is_num) {
		let v: i64;
		let used: u64;
		v, used = parsenum(p + off, n - off);
		let after: u64 = off + used;
		if (after < n) { if (p[after] == 40u8) {	// '('
			let rstart: u64 = after + 1u64;
			let cur2: u64 = rstart;
			for (cur2 < n) {
				if (p[cur2] == 41u8) { cur2 = cur2; cur2 += 0u64; }
				else { cur2 += 1u64; continue; };
				let rn: u64 = cur2 - rstart;
				let r: i32 = reglookup(p + rstart, rn);
				if (r == 0) { perr(a, "bad register"); return n; };
				out.atype = D_INDIR;
				out.reg = r;
				out.offset = v;
				return cur2 + 1u64;
			};
			perr(a, "missing ')'");
			return n;
		};};
		out.atype = D_CONST;
		out.offset = v;
		return after;
	};

	// IDENT — register, symbol(SB), or branch label
	if (isidstart(c0: i32)) {
		let istart: u64 = off;
		for (off < n) {
			if (isidcont(p[off]: i32)) { off += 1u64; continue; };
			off = off; off += 0u64;	// loop break
			let in_: u64 = off - istart;
			// IDENT(SB) — external
			if (off < n) { if (p[off] == 40u8) {	// '('
				let rstart: u64 = off + 1u64;
				let cur2: u64 = rstart;
				for (cur2 < n) {
					if (p[cur2] == 41u8) { cur2 = cur2; cur2 += 0u64; }
					else { cur2 += 1u64; continue; };
					let rn: u64 = cur2 - rstart;
					let r: i32 = reglookup(p + rstart, rn);
					if (r == D_PSB) {
						out.atype = D_EXTERN;
						out.asym = dupstr(a.a, p + istart, in_);
					} else {
						out.atype = D_INDIR;
						out.reg = r;
						out.offset = 0i64;
					};
					return cur2 + 1u64;
				};
				perr(a, "missing ')'");
				return n;
			};};
			let r: i32 = reglookup(p + istart, in_);
			if (r != D_NONE) {
				out.atype = r;
				return off;
			};
			out.atype = D_BRANCH;
			out.asym = dupstr(a.a, p + istart, in_);
			return off;
		};
		// EOF inside ident
		let in_: u64 = off - istart;
		let r: i32 = reglookup(p + istart, in_);
		if (r != D_NONE) { out.atype = r; return off; };
		out.atype = D_BRANCH;
		out.asym = dupstr(a.a, p + istart, in_);
		return off;
	};

	perr(a, "unrecognised operand");
	return n;
};

// Append a fresh aprog to the list with given opcode and label.
fn addprog(a: *asm_, opc: i32, lbl: str) *aprog = {
	let pr: *aprog = amalloc(a.a, 96u64): *aprog;
	pr.as_ = opc;
	pr.line = a.line;
	pr.label = lbl;
	pr.link = nil;
	pr.bytes = nil;
	pr.nbytes = 0u64;
	pr.from = amalloc(a.a, 48u64): *aoperand;
	pr.to   = amalloc(a.a, 48u64): *aoperand;
	if (a.head == nil) { a.head = pr; }
	else {
		// `a.tail.link = pr` would be a chained-dot write through a
		// pointer field, which the C cgen we bootstrap on doesn't
		// support (silently drops the store). Bind a local first.
		let tail: *aprog = a.tail;
		tail.link = pr;
	};
	a.tail = pr;
	return pr;
};

export fn parse(a: *asm_) i32 = {
	let pending: str;
	pending.ptr = nil; pending.len = 0;

	for (true) {
		let line: *u8;
		let n: u64;
		line, n = nextline(a);
		if (line == nil) { return a.errs; };

		// skip leading ws
		let i: u64 = skipws(line, 0u64, n);
		// blank or //-comment
		if (i >= n) { a.line += 1; continue; };
		if (i + 1u64 < n) {
			if (line[i] == 47u8) { if (line[i + 1u64] == 47u8) {
				a.line += 1; continue;
			};};
		};

		// Label? IDENT: starting at column 0 (no leading tab).
		// Only if the identifier is followed by ':'. Otherwise, fall
		// through to mnemonic parsing so e.g. `TEXT foo,$0` (which
		// also starts with an idchar in column 0) gets parsed.
		if (line[0u64] != 9u8) {
			if (isidstart(line[i]: i32)) {
				let q: u64 = i;
				let scan_id: bool = true;
				for (scan_id) {
					if (q >= n) { scan_id = false; }
					else { if (isidcont(line[q]: i32)) { q += 1u64; }
					else { scan_id = false; }; };
				};
				if (q < n) { if (line[q] == 58u8) {	// ':'
					let nm: str = dupstr(a.a, line + i, q - i);
					// Pending label gets a NOP prog so addresses pin.
					if (pending.len > 0) {
						let np: *aprog = addprog(a, A_NOP, pending);
					};
					pending = nm;
					a.line += 1;
					continue;
				};};
				// not a label — fall through to mnemonic parse
			};
		};

		// MNEMONIC at the start of the rest. Scan to first ws/EOL.
		let mstart: u64 = i;
		let m: u64 = mstart;
		let scan: bool = true;
		for (scan) {
			if (m >= n)            { scan = false; }
			else { if (line[m] == 32u8) { scan = false; }
			else { if (line[m] == 9u8)  { scan = false; }
			else { m += 1u64; }; }; };
		};
		let mlen: u64 = m - mstart;
		let opc: i32 = opcodelookup(line + mstart, mlen);
		if (opc == 0) {
			if (mlen > 0u64) {
				perr(a, "unknown opcode");
			};
			pending.ptr = nil; pending.len = 0;
			a.line += 1; continue;
		};

		let pr: *aprog = addprog(a, opc, pending);
		pending.ptr = nil; pending.len = 0;

		// Skip ws after mnemonic
		let r0: u64 = skipws(line, m, n);

		if (opc == A_TEXT) {
			// TEXT name,$framesize — find first ',' as the end of name.
			let q: u64 = r0;
			let comma_pos: u64 = n;
			let scan_t: bool = true;
			for (scan_t) {
				if (q >= n) { scan_t = false; }
				else { if (line[q] == 44u8) { comma_pos = q; scan_t = false; }
				else { q += 1u64; }; };
			};
			let to_op: *aoperand = pr.to;
			to_op.atype = D_EXTERN;
			to_op.asym = dupstr(a.a, line + r0, comma_pos - r0);
			if (comma_pos < n) {
				let p2: u64 = comma_pos + 1u64;
				p2 = skipws(line, p2, n);
				if (p2 < n) { if (line[p2] == 36u8) { p2 += 1u64; }; };
				let v: i64;
				let used: u64;
				v, used = parsenum(line + p2, n - p2);
				let from_op: *aoperand = pr.from;
				from_op.atype = D_CONST;
				from_op.offset = v;
			};
			a.line += 1; continue;
		};

		if (opc == A_DATA) {
			// DATA name(SB),"escaped bytes" — find first '(' as end of name.
			let q: u64 = r0;
			let lparen: u64 = n;
			let scan_d: bool = true;
			for (scan_d) {
				if (q >= n) { scan_d = false; }
				else { if (line[q] == 40u8) { lparen = q; scan_d = false; }
				else { q += 1u64; }; };
			};
			let to_op: *aoperand = pr.to;
			to_op.atype = D_EXTERN;
			to_op.asym = dupstr(a.a, line + r0, lparen - r0);
			// Skip past `(SB)` to land just after ')'.
			let p2: u64 = lparen;
			let scan_d2: bool = true;
			for (scan_d2) {
				if (p2 >= n) { scan_d2 = false; }
				else { if (line[p2] == 41u8) { p2 += 1u64; scan_d2 = false; }
				else { p2 += 1u64; }; };
			};
			// Skip ws / ',' / tab between `)` and the `"`.
			let scan_d3: bool = true;
			for (scan_d3) {
				if (p2 >= n) { scan_d3 = false; }
				else { if (line[p2] == 32u8) { p2 += 1u64; }
				else { if (line[p2] == 44u8) { p2 += 1u64; }
				else { if (line[p2] == 9u8)  { p2 += 1u64; }
				else { scan_d3 = false; }; }; }; };
			};
			if (p2 >= n) { perr(a, "DATA missing payload"); a.line += 1; continue; };
			if (line[p2] != 34u8) { perr(a, "DATA expects \"...\""); a.line += 1; continue; };
			p2 += 1u64;	// past opening "
			// Parse escape sequence into a fresh growable buffer.
			let cap: u64 = 32u64;
			let blen: u64 = 0u64;
			let dbuf: *u8 = amalloc(a.a, cap): *u8;
			for (p2 < n) {
				if (line[p2] == 34u8) { p2 = p2; p2 += 0u64; p2 = n + 1u64; }
				else {
					let ch: u8 = line[p2];
					p2 += 1u64;
					if (ch == 92u8) {	// '\'
						if (p2 < n) {
							let e: u8 = line[p2];
							p2 += 1u64;
							if (e == 110u8) { ch = 10u8; }	// 'n'
							else { if (e == 116u8) { ch = 9u8; }
							else { if (e == 114u8) { ch = 13u8; }
							else { if (e == 92u8)  { ch = 92u8; }
							else { if (e == 34u8)  { ch = 34u8; }
							else { if (e == 48u8)  { ch = 0u8; }
							else { if (e == 120u8) {	// 'x'
								if (p2 + 1u64 < n) {
									let hi: u8 = line[p2];
									let lo: u8 = line[p2 + 1u64];
									p2 += 2u64;
									let h: u8 = 0u8;
									let l: u8 = 0u8;
									if (hi <= 57u8) { h = hi - 48u8; }
									else { h = (hi | 32u8) - 97u8 + 10u8; };
									if (lo <= 57u8) { l = lo - 48u8; }
									else { l = (lo | 32u8) - 97u8 + 10u8; };
									ch = (h << 4u8) | l;
								};
							}
							else { ch = e; };};};};};};};
						};
					};
					if (blen + 1u64 > cap) {
						let ncap: u64 = cap * 2u64;
						let nb: *u8 = amalloc(a.a, ncap): *u8;
						let bi: u64 = 0u64;
						for (bi < blen) { nb[bi] = dbuf[bi]; bi += 1u64; };
						dbuf = nb;
						cap = ncap;
					};
					dbuf[blen] = ch;
					blen += 1u64;
				};
			};
			pr.bytes = dbuf;
			pr.nbytes = blen;
			a.line += 1; continue;
		};

		// Generic instruction: 0/1/2 operands separated by ','.
		// Find top-level comma.
		let comma: i64 = -1i64;
		let q: u64 = r0;
		for (q < n) {
			if (line[q] == 44u8) {
				if (comma < 0i64) { comma = q: i64; };
			};
			q += 1u64;
		};
		if (comma >= 0i64) {
			let cu: u64 = comma: u64;
			parseoperand(a, line, r0, cu, pr.from);
			parseoperand(a, line + (cu + 1u64), 0u64, n - (cu + 1u64), pr.to);
		} else { if (r0 < n) {
			parseoperand(a, line, r0, n, pr.to);
		};};

		a.line += 1;
	};
	return a.errs;
};

// selfhost/cmd/w6a/asm.ww — port of cmd/w6a/asm.c.
//
// Encode the parsed aprog list into amd64 machine bytes, appending to
// asm_.text. Relocations for CALL/branch targets that resolve to
// externals are queued in asm_.relocs.
//
// Encoding subset matches what w6c emits — see cmd/w6a/asm.c for the
// authoritative list. Helpers (rcode/rhi/modrm/emitrex etc.) are
// fully ported; encode itself is still a stub pending the full
// switch over A_*.

use os;
use mem;
use types;

// ---- text buffer growth ------------------------------------------------

export fn emitbyte(a: *asm_, b: u8) void = {
	if (a.textlen + 1u64 > a.textcap) {
		let nc: u64 = a.textcap;
		if (nc == 0u64) { nc = 4096u64; };
		nc = nc * 2u64;
		let nb: *u8 = os.alloc(nc): *u8;
		let i: u64 = 0u64;
		for (i < a.textlen) { nb[i] = a.text[i]; i += 1u64; };
		a.text = nb;
		a.textcap = nc;
	};
	a.text[a.textlen] = b;
	a.textlen += 1u64;
};

export fn emitu32(a: *asm_, v: u32) void = {
	emitbyte(a, (v & 255u32): u8);
	emitbyte(a, ((v >> 8u32) & 255u32): u8);
	emitbyte(a, ((v >> 16u32) & 255u32): u8);
	emitbyte(a, ((v >> 24u32) & 255u32): u8);
};

export fn addreloc(a: *asm_, off: u64, kind: i32, s: *asym, add: i64) void = {
	let r: *areloc = amalloc(a.a, 48u64): *areloc;
	r.off = off;
	r.kind = kind;
	r.asy = s;
	r.addend = add;
	r.rnext = a.relocs;
	a.relocs = r;
};

// ---- register codes ----------------------------------------------------

// Low 3 bits of register encoding.
fn rcode(r: i32) i32 = {
	if (r == D_AX) { return 0; };  if (r == D_CX) { return 1; };
	if (r == D_DX) { return 2; };  if (r == D_BX) { return 3; };
	if (r == D_SP) { return 4; };  if (r == D_BP) { return 5; };
	if (r == D_SI) { return 6; };  if (r == D_DI) { return 7; };
	if (r == D_R8)  { return 0; }; if (r == D_R9)  { return 1; };
	if (r == D_R10) { return 2; }; if (r == D_R11) { return 3; };
	if (r == D_R12) { return 4; }; if (r == D_R13) { return 5; };
	if (r == D_R14) { return 6; }; if (r == D_R15) { return 7; };
	if (r == D_X0) { return 0; };  if (r == D_X1) { return 1; };
	if (r == D_X2) { return 2; };  if (r == D_X3) { return 3; };
	if (r == D_X4) { return 4; };  if (r == D_X5) { return 5; };
	if (r == D_X6) { return 6; };  if (r == D_X7) { return 7; };
	if (r == D_X8)  { return 0; }; if (r == D_X9)  { return 1; };
	if (r == D_X10) { return 2; }; if (r == D_X11) { return 3; };
	if (r == D_X12) { return 4; }; if (r == D_X13) { return 5; };
	if (r == D_X14) { return 6; }; if (r == D_X15) { return 7; };
	return 0;
};

// 1 if r needs the REX high bit (R8..R15 or X8..X15).
fn rhi(r: i32) i32 = {
	if (r >= D_R8) { if (r <= D_R15) { return 1; }; };
	if (r >= D_X8) { if (r <= D_X15) { return 1; }; };
	return 0;
};

fn isxmm(r: i32) bool = {
	if (r >= D_X0) { if (r <= D_X15) { return true; }; };
	return false;
};

// ModR/M byte builder.
fn modrmbyte(mod: i32, reg: i32, rm: i32) u8 = {
	return (((mod & 3) << 6) | ((reg & 7) << 3) | (rm & 7)): u8;
};

// REX prefix; W=1 for 64-bit operand size.
fn emitrex(a: *asm_, regbit: i32, rmbit: i32, w: i32) void = {
	let b: u8 = 64u8;	// 0x40
	if (w != 0)      { b = b | 8u8; };
	if (regbit != 0) { b = b | 4u8; };
	if (rmbit != 0)  { b = b | 1u8; };
	if (b != 64u8) { emitbyte(a, b); }
	else { if (w != 0) { emitbyte(a, b); }; };
};

// ModR/M + (optional) SIB + displacement for [base+disp].
// Special-cases SP (needs SIB) and BP (forces explicit disp).
fn emitmodrmmem(a: *asm_, reg_field: i32, base: i32, disp: i64) void = {
	let rm: i32 = rcode(base);
	let needsib: bool = (rm == 4);
	let forced_disp: bool = false;
	if (rm == 5) { if (disp == 0i64) { forced_disp = true; }; };

	let mod: i32 = 2;
	if (disp == 0i64) {
		if (!forced_disp) { mod = 0; }
		else { mod = 1; };
	} else {
		if (disp >= -128i64) { if (disp <= 127i64) { mod = 1; }; };
	};

	emitbyte(a, modrmbyte(mod, reg_field, rm));
	if (needsib) {
		emitbyte(a, 36u8);	// 0x24: scale=0 idx=4(none) base=4
	};
	if (mod == 1) {
		emitbyte(a, (disp: u64 & 255u64): u8);
	} else { if (mod == 2) {
		emitu32(a, disp: u32);
	};};
};

// reg→reg "src, dst" generic encoding (89 /r, 01 /r, etc.).
fn encoderr(a: *asm_, opcode: u8, src: i32, dst: i32) void = {
	emitrex(a, rhi(src), rhi(dst), 1);
	emitbyte(a, opcode);
	emitbyte(a, modrmbyte(3, rcode(src), rcode(dst)));
};

// reg→mem(base, disp) (e.g. MOVQ src reg into mem; opcode = 0x89).
fn encoderm(a: *asm_, opcode: u8, src_reg: i32, base: i32, disp: i64) void = {
	emitrex(a, rhi(src_reg), rhi(base), 1);
	emitbyte(a, opcode);
	emitmodrmmem(a, rcode(src_reg), base, disp);
};

// mem(base, disp) → reg (e.g. MOVQ mem into reg; opcode = 0x8B).
fn encodemr(a: *asm_, opcode: u8, dst_reg: i32, base: i32, disp: i64) void = {
	emitrex(a, rhi(dst_reg), rhi(base), 1);
	emitbyte(a, opcode);
	emitmodrmmem(a, rcode(dst_reg), base, disp);
};

// OPCODE /n imm32 reg form (e.g. ADDQ $imm, reg).
fn encoderiimm32(a: *asm_, opcode: u8, subop: i32, dst: i32, imm: i32) void = {
	emitrex(a, 0, rhi(dst), 1);
	emitbyte(a, opcode);
	emitbyte(a, modrmbyte(3, subop, rcode(dst)));
	emitu32(a, imm: u32);
};

// Unary on reg: F7 /n reg, etc.
fn encodeunary(a: *asm_, opcode: u8, subop: i32, dst: i32) void = {
	emitrex(a, 0, rhi(dst), 1);
	emitbyte(a, opcode);
	emitbyte(a, modrmbyte(3, subop, rcode(dst)));
};

// SSE2 helpers. Plan 9 syntax: source first, destination second.
// For ADDSD-style ops we put dst in the reg field, src in r/m.
fn sserr(a: *asm_, prefix: u8, op2: u8, reg_op: i32, rm_op: i32) void = {
	if (prefix != 0u8) { emitbyte(a, prefix); };
	emitrex(a, rhi(reg_op), rhi(rm_op), 0);
	emitbyte(a, 15u8);	// 0x0F
	emitbyte(a, op2);
	emitbyte(a, modrmbyte(3, rcode(reg_op), rcode(rm_op)));
};

fn ssemrload(a: *asm_, prefix: u8, op2: u8, reg_op: i32, base: i32, disp: i64) void = {
	if (prefix != 0u8) { emitbyte(a, prefix); };
	emitrex(a, rhi(reg_op), rhi(base), 0);
	emitbyte(a, 15u8);
	emitbyte(a, op2);
	emitmodrmmem(a, rcode(reg_op), base, disp);
};

// REX.W variant of sse_rr (CVTTSD2SI / CVTSI2SD).
fn sserrw(a: *asm_, prefix: u8, op2: u8, reg_op: i32, rm_op: i32) void = {
	if (prefix != 0u8) { emitbyte(a, prefix); };
	emitrex(a, rhi(reg_op), rhi(rm_op), 1);
	emitbyte(a, 15u8);
	emitbyte(a, op2);
	emitbyte(a, modrmbyte(3, rcode(reg_op), rcode(rm_op)));
};

// ---- label resolution / fixups ----------------------------------------

fn streq(a: str, b: str) bool = {
	if (a.len != b.len) { return false; };
	let i: i32 = 0;
	for (i < a.len) {
		if (a[i] != b[i]) { return false; };
		i += 1;
	};
	return true;
};

fn resolvelabel(a: *asm_, name: str) u64 = {
	let s: *asym = a.syms;
	for (s != nil) {
		if (s.defined != 0) { if (streq(s.name, name)) { return s.addr; }; };
		s = s.snext;
	};
	return 0u64;
};

fn labeldefined(a: *asm_, name: str) bool = {
	let s: *asym = a.syms;
	for (s != nil) {
		if (s.defined != 0) { if (streq(s.name, name)) { return true; }; };
		s = s.snext;
	};
	return false;
};

// ---- fixup helper -----------------------------------------------------

fn addfixup(a: *asm_, off: u64, label: str) void = {
	let f: *afixup = amalloc(a.a, 48u64): *afixup;
	f.off = off;
	f.label = label;
	f.fnext = a.fixups;
	a.fixups = f;
};

fn isgpr(t: i32) bool = {
	if (t >= D_AX) { if (t <= D_R15) { return true; }; };
	return false;
};

// `intern` lives in parse.ww — flat-scope concat lets us call it
// directly without an @symbol declaration here.

// ---- encode ----------------------------------------------------------

export fn encode(a: *asm_) i32 = {
	let p: *aprog = a.head;
	for (p != nil) {
		// Define any pending label at the current PC.
		if (p.label.len > 0) {
			let s: *asym = intern(a, p.label);
			s.defined = 1;
			s.istext = 1;
			s.addr = a.textlen;
		};
		let op: i32 = p.as_;

		if (op == A_NOP) {
			p = p.link; continue;
		};
		if (op == A_TEXT) {
			let s: *asym = intern(a, p.to.asym);
			s.defined = 1;
			s.istext = 1;
			s.isglobal = 1;
			s.addr = a.textlen;
			p = p.link; continue;
		};
		if (op == A_DATA) {
			let s: *asym = intern(a, p.to.asym);
			s.defined = 1;
			s.istext = 1;
			s.isglobal = 1;
			s.addr = a.textlen;
			let i: u64 = 0u64;
			for (i < p.nbytes) { emitbyte(a, p.bytes[i]); i += 1u64; };
			p = p.link; continue;
		};
		if (op == A_RET) {
			emitbyte(a, 195u8);	// 0xC3
			p = p.link; continue;
		};
		if (op == A_SYSCALL) {
			emitbyte(a, 15u8);
			emitbyte(a, 5u8);
			p = p.link; continue;
		};
		if (op == A_PUSHQ) {
			if (rhi(p.to.atype) != 0) { emitbyte(a, 65u8); };	// 0x41
			emitbyte(a, (80 + rcode(p.to.atype)): u8);	// 0x50
			p = p.link; continue;
		};
		if (op == A_POPQ) {
			if (rhi(p.to.atype) != 0) { emitbyte(a, 65u8); };
			emitbyte(a, (88 + rcode(p.to.atype)): u8);	// 0x58
			p = p.link; continue;
		};
		if (op == A_NEGQ)  { encodeunary(a, 247u8, 3, p.to.atype); p = p.link; continue; };
		if (op == A_NOTQ)  { encodeunary(a, 247u8, 2, p.to.atype); p = p.link; continue; };
		if (op == A_IDIVQ) { encodeunary(a, 247u8, 7, p.to.atype); p = p.link; continue; };
		if (op == A_DIVQ)  { encodeunary(a, 247u8, 6, p.to.atype); p = p.link; continue; };

		if (op == A_MOVQ) {
			let ft: i32 = p.from.atype;
			let tt: i32 = p.to.atype;
			if (ft == D_CONST) { if (isgpr(tt)) {
				let v: i64 = p.from.offset;
				if (v >= -2147483648i64) { if (v <= 2147483647i64) {
					encoderiimm32(a, 199u8, 0, tt, v: i32);
					p = p.link; continue;
				};};
				// movabs r64, imm64: REX.W B8+rd imm64
				emitrex(a, 0, rhi(tt), 1);
				emitbyte(a, (184 + rcode(tt)): u8);
				let k: i32 = 0;
				for (k < 8) {
					emitbyte(a, ((v: u64 >> (k: u64 * 8u64)) & 255u64): u8);
					k += 1;
				};
				p = p.link; continue;
			};};
			if (isgpr(ft)) { if (isgpr(tt)) {
				encoderr(a, 137u8, ft, tt);	// 0x89
				p = p.link; continue;
			};};
			if (ft == D_INDIR) { if (isgpr(tt)) {
				encodemr(a, 139u8, tt, p.from.reg, p.from.offset);	// 0x8B
				p = p.link; continue;
			};};
			if (isgpr(ft)) { if (tt == D_INDIR) {
				encoderm(a, 137u8, ft, p.to.reg, p.to.offset);
				p = p.link; continue;
			};};
			if (ft == D_CONST) { if (tt == D_INDIR) {
				emitrex(a, 0, rhi(p.to.reg), 1);
				emitbyte(a, 199u8);
				emitmodrmmem(a, 0, p.to.reg, p.to.offset);
				emitu32(a, p.from.offset: u32);
				p = p.link; continue;
			};};
			if (ft == D_EXTERN) { if (isgpr(tt)) {
				// RIP-relative load: 48 8B /r mod=00 rm=5 disp32
				emitrex(a, rhi(tt), 0, 1);
				emitbyte(a, 139u8);
				emitbyte(a, modrmbyte(0, rcode(tt), 5));
				let reloff: u64 = a.textlen;
				emitu32(a, 0u32);
				let s: *asym = intern(a, p.from.asym);
				addreloc(a, reloff, 2, s, -4i64);
				p = p.link; continue;
			};};
			if (isgpr(ft)) { if (tt == D_EXTERN) {
				// RIP-relative store: 48 89 /r mod=00 rm=5 disp32
				emitrex(a, rhi(ft), 0, 1);
				emitbyte(a, 137u8);
				emitbyte(a, modrmbyte(0, rcode(ft), 5));
				let reloff: u64 = a.textlen;
				emitu32(a, 0u32);
				let s: *asym = intern(a, p.to.asym);
				addreloc(a, reloff, 2, s, -4i64);
				p = p.link; continue;
			};};
			os.write(2, "w6a: unsupported MOVQ shape\n".ptr, 27u64);
			a.errs += 1;
			p = p.link; continue;
		};

		if (op == A_MOVB) {
			let ft: i32 = p.from.atype;
			let tt: i32 = p.to.atype;
			if (isgpr(ft)) { if (tt == D_INDIR) {
				emitrex(a, rhi(ft), rhi(p.to.reg), 0);
				emitbyte(a, 136u8);	// 0x88
				emitmodrmmem(a, rcode(ft), p.to.reg, p.to.offset);
				p = p.link; continue;
			};};
			if (ft == D_INDIR) { if (isgpr(tt)) {
				emitrex(a, rhi(tt), rhi(p.from.reg), 0);
				emitbyte(a, 138u8);	// 0x8A
				emitmodrmmem(a, rcode(tt), p.from.reg, p.from.offset);
				p = p.link; continue;
			};};
			os.write(2, "w6a: unsupported MOVB shape\n".ptr, 27u64);
			a.errs += 1;
			p = p.link; continue;
		};

		if (op == A_MOVZBQ) {
			let ft: i32 = p.from.atype;
			let tt: i32 = p.to.atype;
			if (ft == D_INDIR) { if (isgpr(tt)) {
				emitrex(a, rhi(tt), rhi(p.from.reg), 1);
				emitbyte(a, 15u8);
				emitbyte(a, 182u8);	// 0xB6
				emitmodrmmem(a, rcode(tt), p.from.reg, p.from.offset);
				p = p.link; continue;
			};};
			os.write(2, "w6a: unsupported MOVZBQ shape\n".ptr, 29u64);
			a.errs += 1;
			p = p.link; continue;
		};

		if (op == A_MOVL) {
			let ft: i32 = p.from.atype;
			let tt: i32 = p.to.atype;
			if (isgpr(ft)) { if (tt == D_INDIR) {
				emitrex(a, rhi(ft), rhi(p.to.reg), 0);
				emitbyte(a, 137u8);
				emitmodrmmem(a, rcode(ft), p.to.reg, p.to.offset);
				p = p.link; continue;
			};};
			if (ft == D_INDIR) { if (isgpr(tt)) {
				emitrex(a, rhi(tt), rhi(p.from.reg), 0);
				emitbyte(a, 139u8);
				emitmodrmmem(a, rcode(tt), p.from.reg, p.from.offset);
				p = p.link; continue;
			};};
			if (isgpr(ft)) { if (isgpr(tt)) {
				emitrex(a, rhi(ft), rhi(tt), 0);
				emitbyte(a, 137u8);
				emitbyte(a, modrmbyte(3, rcode(ft), rcode(tt)));
				p = p.link; continue;
			};};
			os.write(2, "w6a: unsupported MOVL shape\n".ptr, 27u64);
			a.errs += 1;
			p = p.link; continue;
		};

		if (op == A_MOVSXD) {
			let ft: i32 = p.from.atype;
			let tt: i32 = p.to.atype;
			if (ft == D_INDIR) { if (isgpr(tt)) {
				emitrex(a, rhi(tt), rhi(p.from.reg), 1);
				emitbyte(a, 99u8);	// 0x63
				emitmodrmmem(a, rcode(tt), p.from.reg, p.from.offset);
				p = p.link; continue;
			};};
			os.write(2, "w6a: unsupported MOVSXD shape\n".ptr, 29u64);
			a.errs += 1;
			p = p.link; continue;
		};

		if (op == A_MOVSD) {
			let ft: i32 = p.from.atype;
			let tt: i32 = p.to.atype;
			if (isxmm(ft)) { if (isxmm(tt)) {
				sserr(a, 242u8, 16u8, tt, ft);
				p = p.link; continue;
			};};
			if (ft == D_INDIR) { if (isxmm(tt)) {
				ssemrload(a, 242u8, 16u8, tt, p.from.reg, p.from.offset);
				p = p.link; continue;
			};};
			if (isxmm(ft)) { if (tt == D_INDIR) {
				ssemrload(a, 242u8, 17u8, ft, p.to.reg, p.to.offset);
				p = p.link; continue;
			};};
			os.write(2, "w6a: unsupported MOVSD shape\n".ptr, 28u64);
			a.errs += 1;
			p = p.link; continue;
		};

		if (op == A_ADDSD) { sserr(a, 242u8, 88u8,  p.to.atype, p.from.atype); p = p.link; continue; };
		if (op == A_SUBSD) { sserr(a, 242u8, 92u8,  p.to.atype, p.from.atype); p = p.link; continue; };
		if (op == A_MULSD) { sserr(a, 242u8, 89u8,  p.to.atype, p.from.atype); p = p.link; continue; };
		if (op == A_DIVSD) { sserr(a, 242u8, 94u8,  p.to.atype, p.from.atype); p = p.link; continue; };
		if (op == A_UCOMISD)   { sserr(a, 102u8, 46u8, p.to.atype, p.from.atype); p = p.link; continue; };
		if (op == A_CVTTSD2SI) { sserrw(a, 242u8, 44u8, p.to.atype, p.from.atype); p = p.link; continue; };
		if (op == A_CVTSI2SD)  { sserrw(a, 242u8, 42u8, p.to.atype, p.from.atype); p = p.link; continue; };

		if (op == A_MOVSS) {
			let ft: i32 = p.from.atype;
			let tt: i32 = p.to.atype;
			if (isxmm(ft)) { if (isxmm(tt)) {
				sserr(a, 243u8, 16u8, tt, ft); p = p.link; continue;
			};};
			if (ft == D_INDIR) { if (isxmm(tt)) {
				ssemrload(a, 243u8, 16u8, tt, p.from.reg, p.from.offset);
				p = p.link; continue;
			};};
			if (isxmm(ft)) { if (tt == D_INDIR) {
				ssemrload(a, 243u8, 17u8, ft, p.to.reg, p.to.offset);
				p = p.link; continue;
			};};
			os.write(2, "w6a: unsupported MOVSS shape\n".ptr, 28u64);
			a.errs += 1;
			p = p.link; continue;
		};

		if (op == A_ADDSS) { sserr(a, 243u8, 88u8, p.to.atype, p.from.atype); p = p.link; continue; };
		if (op == A_SUBSS) { sserr(a, 243u8, 92u8, p.to.atype, p.from.atype); p = p.link; continue; };
		if (op == A_MULSS) { sserr(a, 243u8, 89u8, p.to.atype, p.from.atype); p = p.link; continue; };
		if (op == A_DIVSS) { sserr(a, 243u8, 94u8, p.to.atype, p.from.atype); p = p.link; continue; };
		if (op == A_UCOMISS)   { sserr(a, 0u8,   46u8, p.to.atype, p.from.atype); p = p.link; continue; };
		if (op == A_CVTTSS2SI) { sserrw(a, 243u8, 44u8, p.to.atype, p.from.atype); p = p.link; continue; };
		if (op == A_CVTSI2SS)  { sserrw(a, 243u8, 42u8, p.to.atype, p.from.atype); p = p.link; continue; };
		if (op == A_CVTSD2SS)  { sserr(a, 242u8, 90u8, p.to.atype, p.from.atype); p = p.link; continue; };
		if (op == A_CVTSS2SD)  { sserr(a, 243u8, 90u8, p.to.atype, p.from.atype); p = p.link; continue; };

		if (op == A_ADDQ) {
			let ft: i32 = p.from.atype;
			let tt: i32 = p.to.atype;
			if (ft == D_CONST) { if (isgpr(tt)) {
				encoderiimm32(a, 129u8, 0, tt, p.from.offset: i32);	// 0x81
				p = p.link; continue;
			};};
			if (ft == D_CONST) { if (tt == D_INDIR) {
				emitrex(a, 0, rhi(p.to.reg), 1);
				emitbyte(a, 129u8);
				emitmodrmmem(a, 0, p.to.reg, p.to.offset);
				emitu32(a, p.from.offset: u32);
				p = p.link; continue;
			};};
			if (isgpr(ft)) { if (tt == D_INDIR) {
				encoderm(a, 1u8, ft, p.to.reg, p.to.offset);
				p = p.link; continue;
			};};
			if (ft == D_INDIR) { if (isgpr(tt)) {
				encodemr(a, 3u8, tt, p.from.reg, p.from.offset);
				p = p.link; continue;
			};};
			encoderr(a, 1u8, ft, tt);
			p = p.link; continue;
		};

		if (op == A_SUBQ) {
			let ft: i32 = p.from.atype;
			let tt: i32 = p.to.atype;
			if (ft == D_CONST) { if (isgpr(tt)) {
				encoderiimm32(a, 129u8, 5, tt, p.from.offset: i32);
				p = p.link; continue;
			};};
			if (ft == D_CONST) { if (tt == D_INDIR) {
				emitrex(a, 0, rhi(p.to.reg), 1);
				emitbyte(a, 129u8);
				emitmodrmmem(a, 5, p.to.reg, p.to.offset);
				emitu32(a, p.from.offset: u32);
				p = p.link; continue;
			};};
			if (isgpr(ft)) { if (tt == D_INDIR) {
				encoderm(a, 41u8, ft, p.to.reg, p.to.offset);	// 0x29
				p = p.link; continue;
			};};
			if (ft == D_INDIR) { if (isgpr(tt)) {
				encodemr(a, 43u8, tt, p.from.reg, p.from.offset);	// 0x2B
				p = p.link; continue;
			};};
			encoderr(a, 41u8, ft, tt);
			p = p.link; continue;
		};

		if (op == A_ANDQ) { encoderr(a, 33u8, p.from.atype, p.to.atype); p = p.link; continue; };	// 0x21
		if (op == A_ORQ)  { encoderr(a, 9u8,  p.from.atype, p.to.atype); p = p.link; continue; };	// 0x09
		if (op == A_XORQ) {
			let ft: i32 = p.from.atype;
			let tt: i32 = p.to.atype;
			if (ft == D_CONST) { if (isgpr(tt)) {
				encoderiimm32(a, 129u8, 6, tt, p.from.offset: i32);
				p = p.link; continue;
			};};
			encoderr(a, 49u8, ft, tt);	// 0x31
			p = p.link; continue;
		};
		if (op == A_IMULQ) {
			emitrex(a, rhi(p.to.atype), rhi(p.from.atype), 1);
			emitbyte(a, 15u8);
			emitbyte(a, 175u8);	// 0xAF
			emitbyte(a, modrmbyte(3, rcode(p.to.atype), rcode(p.from.atype)));
			p = p.link; continue;
		};
		if (op == A_SHLQ) { encodeunary(a, 211u8, 4, p.to.atype); p = p.link; continue; };	// 0xD3
		if (op == A_SHRQ) { encodeunary(a, 211u8, 5, p.to.atype); p = p.link; continue; };
		if (op == A_CMPQ) {
			let ft: i32 = p.from.atype;
			let tt: i32 = p.to.atype;
			if (ft == D_CONST) { if (isgpr(tt)) {
				encoderiimm32(a, 129u8, 7, tt, p.from.offset: i32);
				p = p.link; continue;
			};};
			encoderr(a, 57u8, ft, tt);	// 0x39
			p = p.link; continue;
		};

		if (op == A_LEAQ) {
			let ft: i32 = p.from.atype;
			let tt: i32 = p.to.atype;
			if (ft == D_INDIR) { if (isgpr(tt)) {
				encodemr(a, 141u8, tt, p.from.reg, p.from.offset);	// 0x8D
				p = p.link; continue;
			};};
			if (ft == D_EXTERN) { if (isgpr(tt)) {
				emitrex(a, rhi(tt), 0, 1);
				emitbyte(a, 141u8);
				emitbyte(a, modrmbyte(0, rcode(tt), 5));
				let reloff: u64 = a.textlen;
				emitu32(a, 0u32);
				let s: *asym = intern(a, p.from.asym);
				addreloc(a, reloff, 2, s, -4i64);
				p = p.link; continue;
			};};
			p = p.link; continue;
		};

		if (op == A_CALL) {
			let tt: i32 = p.to.atype;
			if (tt == D_EXTERN) {
				emitbyte(a, 232u8);	// 0xE8
				let reloff: u64 = a.textlen;
				emitu32(a, 0u32);
				let s: *asym = intern(a, p.to.asym);
				addreloc(a, reloff, 4, s, -4i64);
				p = p.link; continue;
			};
			if (tt == D_BRANCH) {
				emitbyte(a, 232u8);
				addfixup(a, a.textlen, p.to.asym);
				emitu32(a, 0u32);
				p = p.link; continue;
			};
			if (isgpr(tt)) {
				if (rhi(tt) != 0) { emitbyte(a, 65u8); };
				emitbyte(a, 255u8);	// 0xFF
				emitbyte(a, modrmbyte(3, 2, rcode(tt)));
				p = p.link; continue;
			};
			p = p.link; continue;
		};

		if (op == A_JMP) {
			emitbyte(a, 233u8);	// 0xE9
			addfixup(a, a.textlen, p.to.asym);
			emitu32(a, 0u32);
			p = p.link; continue;
		};

		// Conditional jumps. 0x0F + cc + rel32.
		let cc: u8 = 0u8;
		let is_jcc: bool = true;
		if (op == A_JE)       { cc = 132u8; }	// 0x84
		else { if (op == A_JZ)  { cc = 132u8; }
		else { if (op == A_JNE) { cc = 133u8; }
		else { if (op == A_JNZ) { cc = 133u8; }
		else { if (op == A_JL)  { cc = 140u8; }
		else { if (op == A_JLE) { cc = 142u8; }
		else { if (op == A_JG)  { cc = 143u8; }
		else { if (op == A_JGE) { cc = 141u8; }
		else { if (op == A_JB)  { cc = 130u8; }
		else { if (op == A_JBE) { cc = 134u8; }
		else { if (op == A_JA)  { cc = 135u8; }
		else { if (op == A_JAE) { cc = 131u8; }
		else { is_jcc = false; };};};};};};};};};};};};
		if (is_jcc) {
			emitbyte(a, 15u8);
			emitbyte(a, cc);
			addfixup(a, a.textlen, p.to.asym);
			emitu32(a, 0u32);
			p = p.link; continue;
		};

		os.write(2, "w6a: unsupported opcode\n".ptr, 23u64);
		a.errs += 1;
		p = p.link;
	};

	// Second pass: patch fixups (forward label refs).
	let f: *afixup = a.fixups;
	for (f != nil) {
		if (!labeldefined(a, f.label)) {
			os.write(2, "w6a: undefined label '".ptr, 21u64);
			let lbl: str = f.label;
			os.write(2, lbl.ptr, lbl.len: u64);
			os.write(2, "'\n".ptr, 2u64);
			a.errs += 1;
			f = f.fnext;
			continue;
		};
		let target: u64 = resolvelabel(a, f.label);
		let rel: i64 = target: i64 - (f.off: i64 + 4i64);
		let rel32: u32 = rel: u32;
		a.text[f.off]         = (rel32 & 255u32): u8;
		a.text[f.off + 1u64]  = ((rel32 >> 8u32)  & 255u32): u8;
		a.text[f.off + 2u64]  = ((rel32 >> 16u32) & 255u32): u8;
		a.text[f.off + 3u64]  = ((rel32 >> 24u32) & 255u32): u8;
		f = f.fnext;
	};
	return a.errs;
};

// selfhost/cmd/w6a/obj.ww — port of cmd/w6a/obj.c.
//
// Emit a tiny ELF64 relocatable object. Layout (in file order):
//   [0] ELF header
//   [1] Section .text (program bytes)
//   [2] Section .rela.text (relocations)
//   [3] Section .symtab
//   [4] Section .strtab
//   [5] Section .shstrtab
//   [6] Section header table
//
// Symtab indices: 0 = STN_UNDEF, 1.. = our syms. Only GLOBAL symbols.

use os;
use mem;
use types;

// ---- ELF constants ----------------------------------------------------
def ELFCLASS64:   u8  = 2u8;
def ELFDATA2LSB:  u8  = 1u8;
def EV_CURRENT_W: u32 = 1u32;
def ET_REL_W:     u16 = 1u16;
def EM_X86_64_W:  u16 = 62u16;

def SHT_NULL_C:     u32 = 0u32;
def SHT_PROGBITS_C: u32 = 1u32;
def SHT_SYMTAB_C:   u32 = 2u32;
def SHT_STRTAB_C:   u32 = 3u32;
def SHT_RELA_C:     u32 = 4u32;

def SHF_ALLOC:      u64 = 2u64;
def SHF_EXECINSTR:  u64 = 4u64;
def SHF_INFO_LINK:  u64 = 64u64;	// 0x40

def STB_GLOBAL:     u8 = 1u8;
def STT_NOTYPE:     u8 = 0u8;
def STT_FUNC:       u8 = 2u8;

// Sizes of fixed structures.
def EHDR_SZ: u64 = 64u64;
def SHDR_SZ: u64 = 64u64;
def SYM_SZ:  u64 = 24u64;
def RELA_SZ: u64 = 24u64;

// ---- LE byte writers (own the bytes — write into a *u8 + offset) ----

fn wru8(p: *u8, off: u64, v: u8) void = { p[off] = v; };
fn wru16(p: *u8, off: u64, v: u16) void = {
	p[off]        = (v & 255u16): u8;
	p[off + 1u64] = ((v >> 8u16) & 255u16): u8;
};
fn wru32(p: *u8, off: u64, v: u32) void = {
	p[off]        = (v & 255u32): u8;
	p[off + 1u64] = ((v >> 8u32)  & 255u32): u8;
	p[off + 2u64] = ((v >> 16u32) & 255u32): u8;
	p[off + 3u64] = ((v >> 24u32) & 255u32): u8;
};
fn wru64(p: *u8, off: u64, v: u64) void = {
	wru32(p, off,        (v & 4294967295u64): u32);
	wru32(p, off + 4u64, ((v >> 32u64) & 4294967295u64): u32);
};

// ---- growable byte buffer ---------------------------------------------

type buf = struct {
	a:    *arena,
	p:    *u8,
	n:    u64,
	cap:  u64,
};

fn bufinit(b: *buf, a: *arena) void = {
	b.a = a;
	b.cap = 256u64;
	b.n = 0u64;
	b.p = amalloc(a, b.cap): *u8;
};

fn bufgrow(b: *buf, need: u64) void = {
	if (b.n + need <= b.cap) { return; };
	let nc: u64 = b.cap;
	for (nc < b.n + need) { nc = nc * 2u64; };
	let np: *u8 = amalloc(b.a, nc): *u8;
	let i: u64 = 0u64;
	for (i < b.n) { np[i] = b.p[i]; i += 1u64; };
	b.p = np;
	b.cap = nc;
};

fn bufputb(b: *buf, src: *u8, n: u64) void = {
	bufgrow(b, n);
	let i: u64 = 0u64;
	for (i < n) { b.p[b.n + i] = src[i]; i += 1u64; };
	b.n += n;
};

// Write a NUL-terminated C-string copy of `s` into b. Returns offset
// where it started (suitable for st_name / sh_name fields).
fn bufputcstr(b: *buf, s: str) u32 = {
	let off: u32 = b.n: u32;
	bufgrow(b, s.len: u64 + 1u64);
	let i: i32 = 0;
	for (i < s.len) { b.p[b.n] = s[i]; b.n += 1u64; i += 1; };
	b.p[b.n] = 0u8;
	b.n += 1u64;
	return off;
};

// ---- emitelf ---------------------------------------------------------

export fn emitelf(a: *asm_, fd: i32) i32 = {
	let shstr: buf;  bufinit(&shstr, a.a);
	let str_:  buf;  bufinit(&str_,  a.a);
	let sym:   buf;  bufinit(&sym,   a.a);
	let rela:  buf;  bufinit(&rela,  a.a);

	// Index 0 = empty.
	let zero: u8 = 0u8;
	bufputb(&shstr, &zero, 1u64);
	bufputb(&str_,  &zero, 1u64);

	// Section name offsets.
	let shn_text:     u32 = bufputcstr(&shstr, ".text");
	let shn_rela:     u32 = bufputcstr(&shstr, ".rela.text");
	let shn_symtab:   u32 = bufputcstr(&shstr, ".symtab");
	let shn_strtab:   u32 = bufputcstr(&shstr, ".strtab");
	let shn_shstrtab: u32 = bufputcstr(&shstr, ".shstrtab");

	// Symbol 0 — STN_UNDEF (24 zero bytes).
	let zsym: [24]u8;
	let zi: i32 = 0;
	for (zi < 24) { zsym[zi] = 0u8; zi += 1; };
	bufputb(&sym, zsym.ptr, 24u64);

	let SH_TEXT: u16 = 1u16;

	// Build symbols.
	let idx: i32 = 1;
	let s: *asym = a.syms;
	for (s != nil) {
		let entry: [24]u8;
		let ei: i32 = 0;
		for (ei < 24) { entry[ei] = 0u8; ei += 1; };
		let st_name: u32 = bufputcstr(&str_, s.name);
		wru32(entry.ptr, 0u64, st_name);
		if (s.defined != 0) {
			wru8(entry.ptr,  4u64, ((STB_GLOBAL << 4u8) | STT_FUNC));
			wru16(entry.ptr, 6u64, SH_TEXT);
			wru64(entry.ptr, 8u64, s.addr);
		} else {
			wru8(entry.ptr,  4u64, ((STB_GLOBAL << 4u8) | STT_NOTYPE));
			wru16(entry.ptr, 6u64, 0u16);
		};
		bufputb(&sym, entry.ptr, 24u64);
		s.idx = idx;
		idx += 1;
		s = s.snext;
	};

	// Build relocations.
	let r: *areloc = a.relocs;
	for (r != nil) {
		let entry: [24]u8;
		wru64(entry.ptr,  0u64, r.off);
		let r_info: u64 = (r.asy.idx: u64 << 32u64) | (r.kind: u64 & 4294967295u64);
		wru64(entry.ptr,  8u64, r_info);
		wru64(entry.ptr, 16u64, r.addend: u64);
		bufputb(&rela, entry.ptr, 24u64);
		r = r.rnext;
	};

	// File offsets.
	let off:      u64 = EHDR_SZ;
	let off_text: u64 = off;  off = off + a.textlen;
	let off_rela: u64 = off;  off = off + rela.n;
	let off_sym:  u64 = off;  off = off + sym.n;
	let off_str:  u64 = off;  off = off + str_.n;
	let off_shstr: u64 = off; off = off + shstr.n;
	for ((off & 7u64) != 0u64) { off += 1u64; };
	let off_shdr: u64 = off;
	let NSECT: u16 = 6u16;

	// ---- Ehdr ----
	let eh: [64]u8;
	let i: i32 = 0;
	for (i < 64) { eh[i] = 0u8; i += 1; };
	eh[0] = 127u8;	// 0x7f
	eh[1] = 69u8;	// 'E'
	eh[2] = 76u8;	// 'L'
	eh[3] = 70u8;	// 'F'
	eh[4] = ELFCLASS64;
	eh[5] = ELFDATA2LSB;
	eh[6] = EV_CURRENT_W: u8;
	wru16(eh.ptr, 16u64, ET_REL_W);
	wru16(eh.ptr, 18u64, EM_X86_64_W);
	wru32(eh.ptr, 20u64, EV_CURRENT_W);
	wru64(eh.ptr, 24u64, 0u64);		// e_entry
	wru64(eh.ptr, 32u64, 0u64);		// e_phoff
	wru64(eh.ptr, 40u64, off_shdr);	// e_shoff
	wru32(eh.ptr, 48u64, 0u32);		// e_flags
	wru16(eh.ptr, 52u64, 64u16);		// e_ehsize
	wru16(eh.ptr, 54u64, 0u16);		// e_phentsize
	wru16(eh.ptr, 56u64, 0u16);		// e_phnum
	wru16(eh.ptr, 58u64, 64u16);		// e_shentsize
	wru16(eh.ptr, 60u64, NSECT);		// e_shnum
	wru16(eh.ptr, 62u64, 5u16);		// e_shstrndx

	if (os.writefull(fd, eh.ptr, 64u64) != 64i64) { return -1; };
	if (a.textlen > 0u64) {
		if (os.writefull(fd, a.text, a.textlen) != a.textlen: i64) { return -1; };
	};
	if (rela.n > 0u64) {
		if (os.writefull(fd, rela.p, rela.n) != rela.n: i64) { return -1; };
	};
	if (sym.n > 0u64) {
		if (os.writefull(fd, sym.p, sym.n) != sym.n: i64) { return -1; };
	};
	if (str_.n > 0u64) {
		if (os.writefull(fd, str_.p, str_.n) != str_.n: i64) { return -1; };
	};
	if (shstr.n > 0u64) {
		if (os.writefull(fd, shstr.p, shstr.n) != shstr.n: i64) { return -1; };
	};

	// Pad to 8 before shdrs.
	let written: u64 = EHDR_SZ + a.textlen + rela.n + sym.n + str_.n + shstr.n;
	for ((written & 7u64) != 0u64) {
		os.writefull(fd, &zero, 1u64);
		written += 1u64;
	};

	// Section header table — 6 headers of 64 bytes each = 384 bytes.
	let shbuf: [64]u8;
	// SHT_NULL
	let sn: i32 = 0;
	for (sn < 64) { shbuf[sn] = 0u8; sn += 1; };
	os.writefull(fd, shbuf.ptr, 64u64);
	// .text
	sn = 0;
	for (sn < 64) { shbuf[sn] = 0u8; sn += 1; };
	wru32(shbuf.ptr,  0u64, shn_text);
	wru32(shbuf.ptr,  4u64, SHT_PROGBITS_C);
	wru64(shbuf.ptr,  8u64, SHF_ALLOC | SHF_EXECINSTR);
	wru64(shbuf.ptr, 24u64, off_text);
	wru64(shbuf.ptr, 32u64, a.textlen);
	wru64(shbuf.ptr, 48u64, 1u64);	// sh_addralign
	os.writefull(fd, shbuf.ptr, 64u64);
	// .rela.text
	sn = 0;
	for (sn < 64) { shbuf[sn] = 0u8; sn += 1; };
	wru32(shbuf.ptr,  0u64, shn_rela);
	wru32(shbuf.ptr,  4u64, SHT_RELA_C);
	wru64(shbuf.ptr,  8u64, SHF_INFO_LINK);
	wru64(shbuf.ptr, 24u64, off_rela);
	wru64(shbuf.ptr, 32u64, rela.n);
	wru32(shbuf.ptr, 40u64, 3u32);	// sh_link = symtab idx
	wru32(shbuf.ptr, 44u64, 1u32);	// sh_info = .text idx
	wru64(shbuf.ptr, 48u64, 8u64);
	wru64(shbuf.ptr, 56u64, RELA_SZ);
	os.writefull(fd, shbuf.ptr, 64u64);
	// .symtab
	sn = 0;
	for (sn < 64) { shbuf[sn] = 0u8; sn += 1; };
	wru32(shbuf.ptr,  0u64, shn_symtab);
	wru32(shbuf.ptr,  4u64, SHT_SYMTAB_C);
	wru64(shbuf.ptr, 24u64, off_sym);
	wru64(shbuf.ptr, 32u64, sym.n);
	wru32(shbuf.ptr, 40u64, 4u32);	// sh_link = strtab
	wru32(shbuf.ptr, 44u64, 1u32);	// sh_info = one local (STN_UNDEF)
	wru64(shbuf.ptr, 48u64, 8u64);
	wru64(shbuf.ptr, 56u64, SYM_SZ);
	os.writefull(fd, shbuf.ptr, 64u64);
	// .strtab
	sn = 0;
	for (sn < 64) { shbuf[sn] = 0u8; sn += 1; };
	wru32(shbuf.ptr,  0u64, shn_strtab);
	wru32(shbuf.ptr,  4u64, SHT_STRTAB_C);
	wru64(shbuf.ptr, 24u64, off_str);
	wru64(shbuf.ptr, 32u64, str_.n);
	wru64(shbuf.ptr, 48u64, 1u64);
	os.writefull(fd, shbuf.ptr, 64u64);
	// .shstrtab
	sn = 0;
	for (sn < 64) { shbuf[sn] = 0u8; sn += 1; };
	wru32(shbuf.ptr,  0u64, shn_shstrtab);
	wru32(shbuf.ptr,  4u64, SHT_STRTAB_C);
	wru64(shbuf.ptr, 24u64, off_shstr);
	wru64(shbuf.ptr, 32u64, shstr.n);
	wru64(shbuf.ptr, 48u64, 1u64);
	os.writefull(fd, shbuf.ptr, 64u64);

	return 0;
};

// selfhost/cmd/w6a/main.ww — port of cmd/w6a/main.c.
//
// w6a = amd64 assembler. Read .s, parse, encode, emit ELF .o.
//
//   w6a_ww -o file.o file.s

use os;
use mem;
use types;
use lex;
use parse;
use asm;
use obj;

fn cstreq(a: *u8, lit: str) bool = {
	let n: u64 = lit.len: u64;
	let i: u64 = 0u64;
	for (i < n) {
		let li: i32 = i: i32;
		if (a[i] != lit[li]) { return false; };
		i += 1u64;
	};
	if (a[i] != 0u8) { return false; };
	return true;
};

fn cstrlen(p: *u8) u64 = {
	let n: u64 = 0u64;
	for (p[n] != 0u8) { n += 1u64; };
	return n;
};

// Slurp the whole file into a fresh buffer.
fn slurp(path: *u8) (*u8, u64) = {
	let fd: i32 = os.open(path, os.O_RDONLY, 0i32);
	if (fd < 0) { return nil, 0u64; };
	let n: i64 = os.filesize(fd);
	if (n < 0i64) { os.close(fd); return nil, 0u64; };
	let nz: u64 = n: u64;
	let buf: *u8 = os.alloc(nz + 1u64): *u8;
	let got: i64 = os.readfull(fd, buf, nz);
	os.close(fd);
	if (got != n) { return nil, 0u64; };
	buf[nz] = 0u8;
	return buf, nz;
};

export fn main(argc: i32, argv: **u8) i32 = {
	let src: *u8 = nil;
	let out: *u8 = nil;

	let i: i32 = 1;
	for (i < argc) {
		let a: *u8 = argv[i];
		if (cstreq(a, "-o")) {
			i += 1;
			if (i >= argc) {
				os.write(2, "w6a: -o requires arg\n".ptr, 20u64);
				return 2;
			};
			out = argv[i];
		} else { if (a[0u64] == 45u8) {
			os.write(2, "w6a: unknown flag\n".ptr, 17u64);
			return 2;
		} else {
			if (src != nil) {
				os.write(2, "w6a: only one input\n".ptr, 19u64);
				return 2;
			};
			src = a;
		}; };
		i += 1;
	};

	if (src == nil) {
		os.write(2, "usage: w6a_ww -o file.o file.s\n".ptr, 30u64);
		return 2;
	};
	if (out == nil) {
		os.write(2, "w6a: missing -o\n".ptr, 15u64);
		return 2;
	};

	let buf: *u8;
	let blen: u64;
	buf, blen = slurp(src);
	if (buf == nil) {
		os.write(2, "w6a: cannot read input\n".ptr, 22u64);
		return 1;
	};

	let ar: *arena = newarena();
	let asm: asm_;
	let nlen: u64 = cstrlen(src);
	let fname: str = astrndup(ar, src, nlen);
	init(&asm, ar, fname, buf, blen);

	if (parse(&asm) != 0) { return 1; };
	if (encode(&asm) != 0) { return 1; };

	// Open output for write.
	let fd: i32 = os.open(out, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 420i32);	// 0o644
	if (fd < 0) {
		os.write(2, "w6a: cannot open output\n".ptr, 23u64);
		return 1;
	};
	let rc: i32 = emitelf(&asm, fd);
	os.close(fd);
	return rc;
};