// MODULE: os // 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: nr) i64; @symbol("rt_syscall") fn syscall1(num: nr, a: i64) i64; @symbol("rt_syscall") fn syscall2(num: nr, a: i64, b: i64) i64; @symbol("rt_syscall") fn syscall3(num: nr, a: i64, b: i64, c: i64) i64; @symbol("rt_syscall") fn syscall4(num: nr, 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); }; }; // Linux amd64 syscall numbers. Internal to this module — passed as // the first arg of syscall0..4 via libwwrt's rt_syscall trampoline. // `nr` is the type so the call sites can't accidentally pass an // arbitrary i64 (`syscall1(0i64, ...)` no longer typechecks). type nr = enum i64 { READ = 0, WRITE = 1, OPEN = 2, CLOSE = 3, LSEEK = 8, ACCESS = 21, DUP2 = 33, GETPID = 39, FORK = 57, EXECVE = 59, EXIT = 60, WAIT4 = 61, MKDIR = 83, RMDIR = 84, UNLINK = 87, GETCWD = 79, GETDENTS64 = 217, }; // open(2) flags. Linux values, matching . Hare names them // `fs::flag::RDONLY` etc; we use the same leaf names so callers say // `os.flag.RDONLY` and `os.flag.WRONLY | os.flag.CREATE`. export type flag = enum i32 { RDONLY = 0, WRONLY = 1, RDWR = 2, CREATE = 64, // 0x40 EXCL = 128, // 0x80 — pair with CREATE to fail on existing path TRUNC = 512, // 0x200 }; // lseek(2) whence. Hare names it `io::whence`. export type whence = enum i32 { SET = 0, CUR = 1, END = 2, }; export fn exit(code: i32) void = { syscall1(nr.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(nr.WRITE, fd: i64, buf: i64, n: i64); }; export fn read(fd: i32, buf: *u8, n: u64) i64 = { return syscall3(nr.READ, fd: i64, buf: i64, n: i64); }; export fn close(fd: i32) i32 = { return syscall1(nr.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(nr.DUP2, oldfd: i64, newfd: i64): i32; }; // Fallible wrappers. The error variant is `oserror` (an i64 carrying // -errno). The sum type makes success/failure explicit and lets // callers `?` the result up the stack. export fn tryread(fd: i32, buf: *u8, n: u64) (i64 | oserror) = { let r: i64 = read(fd, buf, n); if (r < 0) { return r: oserror; }; return r; }; export fn trywrite(fd: i32, buf: *u8, n: u64) (i64 | oserror) = { let r: i64 = write(fd, buf, n); if (r < 0) { return r: oserror; }; 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: flag, mode: i32) i32 = { return syscall3(nr.OPEN, path: i64, (flags as i32): i64, mode: i64): i32; }; export fn tryopen(path: *u8, flags: flag, mode: i32) (i32 | oserror) = { let fd: i32 = open(path, flags, mode); if (fd < 0) { return fd: i64: oserror; }; 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, w: whence) i64 = { return syscall3(nr.LSEEK, fd: i64, off, (w as i32): i64); }; // oserror — the underlying errno from a failed syscall, as a // negative i64 (Linux's int convention; e.g. -2 = ENOENT). The // `!`-flagged alias makes ?-propagation pick this variant as the // error half of any (T | oserror) shape. Hare's analogue is // errors::errno carried inside io::error. export type oserror = !i64; // filesize — byte length of an open fd via lseek-to-end-and-back. export fn filesize(fd: i32) (i64 | oserror) = { let end: i64 = lseek(fd, 0i64, whence.END); if (end < 0) { return end: oserror; }; let r: i64 = lseek(fd, 0i64, whence.SET); if (r < 0) { return r: oserror; }; return end; }; // readall — keep reading until `n` bytes have arrived or the fd // closes early. Hare name (io::readall); the buffer is caller- // supplied, matching the Plan 9 subset convention. export fn readall(fd: i32, buf: *u8, n: u64) (i64 | oserror) = { let got: u64 = 0u64; for (got < n) { let r: i64 = read(fd, buf + got, n - got); if (r < 0) { return r: oserror; }; if (r == 0) { return got: i64; }; // short read: caller decides got += r: u64; }; return got: i64; }; // writeall — keep writing until `n` bytes have been accepted or the // fd refuses progress. Hare name (io::writeall). export fn writeall(fd: i32, buf: *u8, n: u64) (i64 | oserror) = { let sent: u64 = 0u64; for (sent < n) { let r: i64 = write(fd, buf + sent, n - sent); if (r < 0) { return r: oserror; }; 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 (F_OK=0). export fn access(path: *u8, mode: i32) i32 = { return syscall2(nr.ACCESS, path: i64, mode: i64): i32; }; // remove — unlink(2). Hare name; the underlying syscall is unlink(2). export fn remove(path: *u8) i32 = { return syscall1(nr.UNLINK, path: i64): i32; }; // mkdir — mkdir(2). Path must be NUL-terminated. Mode is the unix // permission bitset (e.g. 0o700). Returns 0 on success, negative // errno otherwise. Hare name (os::mkdir). export fn mkdir(path: *u8, mode: i32) i32 = { return syscall2(nr.MKDIR, path: i64, mode: i64): i32; }; // rmdir — rmdir(2). Path must be NUL-terminated. Returns 0 on // success, negative errno otherwise. Hare name (os::rmdir). export fn rmdir(path: *u8) i32 = { return syscall1(nr.RMDIR, path: i64): i32; }; // mkdirs — recursive mkdir. Creates `path` and any non-existent // parent directories with the given mode. EEXIST is silently // accepted (matches Hare's `errors::exists` skip in os::mkdirs); // any other syscall failure surfaces as `oserror`. // // `path` must be NUL-terminated AND its bytes must be writable — // mkdirs temporarily replaces '/' separators with NUL while // invoking [[mkdir]] on each prefix, then restores them. Pointing // `path` at a string literal will segfault. Callers hold the bytes // in a writable buffer (rt_alloc'd, a static `[N]u8`, etc.) — same // precedent as [[temp.named]]'s pathbuf. // // Mirrors Hare's os::mkdirs (recursive variant of os::mkdir). export fn mkdirs(path: *u8, mode: i32) (void | oserror) = { // Find the path length (excluding trailing NUL). let n: i32 = 0; for (path[n] != 0u8) { n += 1; }; if (n == 0) { return; }; // Walk forward; at each '/' boundary, NUL-terminate the prefix, // mkdir it, restore the slash, continue. Skip index 0 so a // leading '/' on absolute paths doesn't trigger an empty mkdir. let i: i32 = 1; for (i < n) { if (path[i] == 47u8) { // '/' path[i] = 0u8; let r: i32 = mkdir(path, mode); path[i] = 47u8; if (r < 0) { if (r != -17) { return r: i64: oserror; }; }; }; i += 1; }; // mkdir the full path. let r: i32 = mkdir(path, mode); if (r < 0) { if (r != -17) { return r: i64: oserror; }; }; return; }; // getpid(2). Used by the driver to mint unique scratch paths. export fn getpid() i32 = { return syscall0(nr.GETPID): i32; }; // fork(2): 0 in the child, child pid in the parent, negative errno // on failure. export fn fork() i32 = { return syscall0(nr.FORK): i32; }; // execve(2): on success, does not return. export fn execve(path: *u8, argv: **u8, envp: **u8) i32 = { return syscall3(nr.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(nr.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(nr.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(nr.GETDENTS64, fd: i64, buf: i64, n: i64); }; // ---- environment ------------------------------------------------------ // rt_envp — runtime-side getter. rt/start.s captures envp into a DATAW // slot before calling main; this binding lifts the captured pointer // into ww. Same FFI shape as rt_syscall / rt_alloc / rt_abort: a TEXT // symbol the linker resolves. The returned `**u8` is a NUL-terminated // table of `*u8` entries, each pointing at a NUL-terminated // "NAME=VALUE" byte sequence. // // We don't expose `rtenvp` directly; [[getenv]] is the only consumer. @symbol("rt_envp") fn rtenvp() **u8; // getenv — POSIX getenv. Returns a borrowed `str` view over the value // bytes of the named environment variable, or void if the name is not // present. The view is valid for the process lifetime — the bytes // live in the kernel-supplied envp table at process entry. A future // `setenv` (separate task) that grows the table behind the scenes // would invalidate prior views; v1 has no setenv, so callers can // hold the view indefinitely. // // Mirrors Hare's os::tryenv shape (returns void rather than panicking // on missing). Hare also ships os::getenv (`(str | void)`) and // os::mustenv (panic-on-missing); ww collapses to the single // `(str | void)` form for now — consumers wanting "must" semantics // abort at the call site. // // Algorithm: walk the NUL-pointer-terminated `environ` table doing a // "name=" prefix match against each entry, byte-wise. NUL inside // `name` would never match a real env var (env var names cannot // contain '\0'), so we don't filter — POSIX puts that responsibility // on the caller. export fn getenv(name: str) (str | void) = { let envp: **u8 = rtenvp(); let i: i32 = 0; for (true) { let entry: *u8 = envp[i]; if (entry == nil: *u8) { return; }; let j: i32 = 0; let matched: bool = true; for (j < name.len) { if (entry[j] == 0u8) { matched = false; break; }; if (entry[j] != name[j]) { matched = false; break; }; j += 1; }; if (matched) { if (entry[name.len] == 61u8) { // '=' let val: *u8 = entry + ((name.len + 1): u64); let n: i32 = 0; for (val[n] != 0u8) { n += 1; }; let r: str; r.ptr = val; r.len = n; return r; }; }; i += 1; }; return; }; // MODULE: wcc // 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; }; }; // MODULE: w6a // 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_MOVW: i32 = 62; def A_MOVZWQ: i32 = 63; def A_MOVSWQ: i32 = 64; def A_MOVSBQ: i32 = 65; 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; // Writable data + reloc-only data. Mirror cmd/w6c/6.out.h. // A_DATAW: bytes land in .data (RW) instead of .text. // A_DATAR: record an R_X86_64_64 reloc at a .data slot, patched // to a target symbol's runtime VA at link time. def A_DATAW: i32 = 60; def A_DATAR: i32 = 61; // ---- 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 doesn't support chained-dot through embedded value // fields, so allocating each operand once per prog lets us write // `p.to.atype` directly. 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, isdata: i32, // mutually exclusive with istext; DATAW symbols isglobal: i32, addr: u64, // offset within its section (.text or .data) idx: i32, snext: *asym, }; type areloc = struct { off: u64, section: i32, // 0 = .text, 1 = .data 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, // Writable .data. Empty unless any DATAW directive was seen; // obj.ww emits the extra section conditionally so .o output // stays byte-identical for inputs that don't use DATAW (test // 991 byte-diff invariant). data: *u8, datacap: u64, datalen: u64, syms: *asym, relocs: *areloc, fixups: *afixup, errs: i32, }; // MODULE: w6a // 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; }; // MODULE: w6a // 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, "MOVW")) { return A_MOVW; }; if (streqlit(p, n, "MOVB")) { return A_MOVB; }; if (streqlit(p, n, "MOVZBQ")) { return A_MOVZBQ; }; if (streqlit(p, n, "MOVZWQ")) { return A_MOVZWQ; }; if (streqlit(p, n, "MOVSXD")) { return A_MOVSXD; }; if (streqlit(p, n, "MOVSWQ")) { return A_MOVSWQ; }; if (streqlit(p, n, "MOVSBQ")) { return A_MOVSBQ; }; 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; }; if (streqlit(p, n, "DATAW")) { return A_DATAW; }; if (streqlit(p, n, "DATAR")) { return A_DATAR; }; 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 isnum: bool = false; if (cur < n) { if (p[cur] == 45u8) { isnum = true; } else { if (p[cur] >= 48u8) { if (p[cur] <= 57u8) { isnum = true; }; }; }; }; if (isnum) { 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), symbol+disp(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; // Optional `+disp` between the ident and `(SB)`. Used // by DATAR to address bytes within a previously-defined // .data slot (e.g. `DATAR s+8(SB),...`). let symdisp: i64 = 0i64; if (off < n) { if (p[off] == 43u8) { // '+' off += 1u64; let v: i64; let used: u64; v, used = parsenum(p + off, n - off); symdisp = v; off += used; };}; // 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_); out.offset = symdisp; } 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; }; 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 scanid: bool = true; for (scanid) { if (q >= n) { scanid = false; } else { if (isidcont(line[q]: i32)) { q += 1u64; } else { scanid = 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 commapos: u64 = n; let scant: bool = true; for (scant) { if (q >= n) { scant = false; } else { if (line[q] == 44u8) { commapos = q; scant = false; } else { q += 1u64; }; }; }; let toop: *aoperand = pr.to; toop.atype = D_EXTERN; toop.asym = dupstr(a.a, line + r0, commapos - r0); if (commapos < n) { let p2: u64 = commapos + 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 fromop: *aoperand = pr.from; fromop.atype = D_CONST; fromop.offset = v; }; a.line += 1; continue; }; if (opc == A_DATA || opc == A_DATAW) { // DATA / DATAW name(SB),"escaped bytes" — same syntax, // different destination section (.text vs .data). let q: u64 = r0; let lparen: u64 = n; let scand: bool = true; for (scand) { if (q >= n) { scand = false; } else { if (line[q] == 40u8) { lparen = q; scand = false; } else { q += 1u64; }; }; }; let toop: *aoperand = pr.to; toop.atype = D_EXTERN; toop.asym = dupstr(a.a, line + r0, lparen - r0); // Skip past `(SB)` to land just after ')'. let p2: u64 = lparen; let scand2: bool = true; for (scand2) { if (p2 >= n) { scand2 = false; } else { if (line[p2] == 41u8) { p2 += 1u64; scand2 = false; } else { p2 += 1u64; }; }; }; // Skip ws / ',' / tab between `)` and the `"`. let scand3: bool = true; for (scand3) { if (p2 >= n) { scand3 = false; } else { if (line[p2] == 32u8) { p2 += 1u64; } else { if (line[p2] == 44u8) { p2 += 1u64; } else { if (line[p2] == 9u8) { p2 += 1u64; } else { scand3 = 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; }; // MODULE: w6a // 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, 64u64): *areloc; r.off = off; r.section = 0; // .text r.kind = kind; r.asy = s; r.addend = add; r.rnext = a.relocs; a.relocs = r; }; // Record a relocation that lives in the .data section. Used by // DATAR to patch a 64-bit slot with a symbol's runtime VA. obj.ww // separates these into .rela.data when emitting the .o. export fn addrelocdata(a: *asm_, off: u64, kind: i32, s: *asym, add: i64) void = { let r: *areloc = amalloc(a.a, 64u64): *areloc; r.off = off; r.section = 1; // .data r.kind = kind; r.asy = s; r.addend = add; r.rnext = a.relocs; a.relocs = r; }; // Append one byte to the writable .data buffer. Mirrors emitbyte // but targets a.data instead of a.text. export fn emitdatabyte(a: *asm_, b: u8) void = { if (a.datalen + 1u64 > a.datacap) { let nc: u64 = a.datacap; if (nc == 0u64) { nc = 256u64; }; nc = nc * 2u64; let nb: *u8 = os.alloc(nc): *u8; let i: u64 = 0u64; for (i < a.datalen) { nb[i] = a.data[i]; i += 1u64; }; a.data = nb; a.datacap = nc; }; a.data[a.datalen] = b; a.datalen += 1u64; }; // ---- 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_, regfield: i32, base: i32, disp: i64) void = { let rm: i32 = rcode(base); let needsib: bool = (rm == 4); let forceddisp: bool = false; if (rm == 5) { if (disp == 0i64) { forceddisp = true; }; }; let mod: i32 = 2; if (disp == 0i64) { if (!forceddisp) { mod = 0; } else { mod = 1; }; } else { if (disp >= -128i64) { if (disp <= 127i64) { mod = 1; }; }; }; emitbyte(a, modrmbyte(mod, regfield, 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, srcreg: i32, base: i32, disp: i64) void = { emitrex(a, rhi(srcreg), rhi(base), 1); emitbyte(a, opcode); emitmodrmmem(a, rcode(srcreg), base, disp); }; // mem(base, disp) → reg (e.g. MOVQ mem into reg; opcode = 0x8B). fn encodemr(a: *asm_, opcode: u8, dstreg: i32, base: i32, disp: i64) void = { emitrex(a, rhi(dstreg), rhi(base), 1); emitbyte(a, opcode); emitmodrmmem(a, rcode(dstreg), 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, regop: i32, rmop: i32) void = { if (prefix != 0u8) { emitbyte(a, prefix); }; emitrex(a, rhi(regop), rhi(rmop), 0); emitbyte(a, 15u8); // 0x0F emitbyte(a, op2); emitbyte(a, modrmbyte(3, rcode(regop), rcode(rmop))); }; fn ssemrload(a: *asm_, prefix: u8, op2: u8, regop: i32, base: i32, disp: i64) void = { if (prefix != 0u8) { emitbyte(a, prefix); }; emitrex(a, rhi(regop), rhi(base), 0); emitbyte(a, 15u8); emitbyte(a, op2); emitmodrmmem(a, rcode(regop), base, disp); }; // REX.W variant of sse_rr (CVTTSD2SI / CVTSI2SD). fn sserrw(a: *asm_, prefix: u8, op2: u8, regop: i32, rmop: i32) void = { if (prefix != 0u8) { emitbyte(a, prefix); }; emitrex(a, rhi(regop), rhi(rmop), 1); emitbyte(a, 15u8); emitbyte(a, op2); emitbyte(a, modrmbyte(3, rcode(regop), rcode(rmop))); }; // ---- 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_DATAW) { // Writable variant: bytes go into .data instead of // .text. obj.ww emits the extra section conditionally // on datalen > 0 so .o output stays byte-identical // for inputs that don't use DATAW. let s: *asym = intern(a, p.to.asym); s.defined = 1; s.isdata = 1; s.isglobal = 1; s.addr = a.datalen; let i: u64 = 0u64; for (i < p.nbytes) { emitdatabyte(a, p.bytes[i]); i += 1u64; }; p = p.link; continue; }; if (op == A_DATAR) { // DATAR slot+off(SB), target(SB) — record an // R_X86_64_64 relocation at slot+off in .data // pointing at target. Slot must already be defined // by a prior DATAW. let holder: *asym = intern(a, p.from.asym); if (holder.defined == 0) { p = p.link; continue; }; if (holder.isdata == 0) { p = p.link; continue; }; let target: *asym = intern(a, p.to.asym); let reloff: u64 = holder.addr + p.from.offset: u64; addrelocdata(a, reloff, 1 /* R_X86_64_64 */, target, 0i64); 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_MOVW) { // 16-bit MOV: 0x66 operand-size prefix + the 32-bit // MOV opcodes 0x89 / 0x8B. No REX.W. let ft: i32 = p.from.atype; let tt: i32 = p.to.atype; if (isgpr(ft)) { if (tt == D_INDIR) { emitbyte(a, 102u8); // 0x66 emitrex(a, rhi(ft), rhi(p.to.reg), 0); emitbyte(a, 137u8); // 0x89 emitmodrmmem(a, rcode(ft), p.to.reg, p.to.offset); p = p.link; continue; };}; if (ft == D_INDIR) { if (isgpr(tt)) { emitbyte(a, 102u8); // 0x66 emitrex(a, rhi(tt), rhi(p.from.reg), 0); emitbyte(a, 139u8); // 0x8B emitmodrmmem(a, rcode(tt), p.from.reg, p.from.offset); p = p.link; continue; };}; os.write(2, "w6a: unsupported MOVW shape\n".ptr, 27u64); a.errs += 1; p = p.link; continue; }; if (op == A_MOVZWQ) { // MOVZX r64, r/m16 — 0F B7 /r with REX.W. 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, 183u8); // 0xB7 emitmodrmmem(a, rcode(tt), p.from.reg, p.from.offset); p = p.link; continue; };}; os.write(2, "w6a: unsupported MOVZWQ shape\n".ptr, 29u64); a.errs += 1; p = p.link; continue; }; if (op == A_MOVSWQ) { // MOVSX r64, r/m16 — 0F BF /r with REX.W. 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, 191u8); // 0xBF emitmodrmmem(a, rcode(tt), p.from.reg, p.from.offset); p = p.link; continue; };}; if (isgpr(ft)) { if (isgpr(tt)) { emitrex(a, rhi(tt), rhi(ft), 1); emitbyte(a, 15u8); emitbyte(a, 191u8); // 0xBF emitbyte(a, modrmbyte(3, rcode(tt), rcode(ft))); p = p.link; continue; };}; os.write(2, "w6a: unsupported MOVSWQ shape\n".ptr, 29u64); a.errs += 1; p = p.link; continue; }; if (op == A_MOVSBQ) { // MOVSX r64, r/m8 — 0F BE /r with REX.W. 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, 190u8); // 0xBE emitmodrmmem(a, rcode(tt), p.from.reg, p.from.offset); p = p.link; continue; };}; if (isgpr(ft)) { if (isgpr(tt)) { emitrex(a, rhi(tt), rhi(ft), 1); emitbyte(a, 15u8); emitbyte(a, 190u8); // 0xBE emitbyte(a, modrmbyte(3, rcode(tt), rcode(ft))); p = p.link; continue; };}; os.write(2, "w6a: unsupported MOVSBQ shape\n".ptr, 29u64); 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; };}; if (isgpr(ft)) { if (isgpr(tt)) { emitrex(a, rhi(tt), rhi(ft), 1); emitbyte(a, 99u8); // 0x63 emitbyte(a, modrmbyte(3, rcode(tt), rcode(ft))); 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) { // AND r/m64, imm32 — 0x81 /4 (REX.W). Without the // D_CONST path encoderr would silently emit 0x21 // with garbage reg fields. let ft: i32 = p.from.atype; let tt: i32 = p.to.atype; if (ft == D_CONST) { if (isgpr(tt)) { encoderiimm32(a, 129u8, 4, tt, p.from.offset: i32); p = p.link; continue; };}; encoderr(a, 33u8, ft, tt); // 0x21 p = p.link; continue; }; if (op == A_ORQ) { // OR r/m64, imm32 — 0x81 /1 (REX.W). Mirrors ANDQ. let ft: i32 = p.from.atype; let tt: i32 = p.to.atype; if (ft == D_CONST) { if (isgpr(tt)) { encoderiimm32(a, 129u8, 1, tt, p.from.offset: i32); p = p.link; continue; };}; encoderr(a, 9u8, ft, tt); // 0x09 p = p.link; continue; }; 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 isjcc: 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 { isjcc = false; };};};};};};};};};};};}; if (isjcc) { 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; }; // MODULE: w6a // 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; // Local wrappers around os.writeall's tagged return — collapse the // (i64 | oserror) back to a boolean / int sentinel for the // length-checked / fire-and-forget write patterns below. fn wrn(fd: i32, p: *u8, n: u64, want: i64) bool = { let r: (i64 | os.oserror) = os.writeall(fd, p, n); match (r) { case let v: i64 => return v == want; case let e: os.oserror => return false; }; return false; }; fn wrdrop(fd: i32, p: *u8, n: u64) void = { let r: (i64 | os.oserror) = os.writeall(fd, p, n); match (r) { case let v: i64 => { }; case let e: os.oserror => { }; }; }; // ---- 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_WRITE: u64 = 1u64; 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_OBJECT: u8 = 1u8; 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); let relad: buf; bufinit(&relad, a.a); // Index 0 = empty. let zero: u8 = 0u8; bufputb(&shstr, &zero, 1u64); bufputb(&str_, &zero, 1u64); let hasdata: bool = a.datalen > 0u64; let hasdatarelocs: bool = false; let rscan: *areloc = a.relocs; for (rscan != nil) { if (rscan.section == 1) { hasdatarelocs = true; }; rscan = rscan.rnext; }; // Section indices (mirror cmd/w6a/obj.c): // without data, without data-relocs: // 1=.text 2=.rela.text 3=.symtab 4=.strtab 5=.shstrtab // with data, no data-relocs: // 1=.text 2=.rela.text 3=.data 4=.symtab 5=.strtab 6=.shstrtab // with data + data-relocs: // 1=.text 2=.rela.text 3=.data 4=.rela.data 5=.symtab // 6=.strtab 7=.shstrtab let SH_TEXT: u16 = 1u16; let SH_DATA: u16 = 0u16; let SH_RELAD: u16 = 0u16; let SH_SYMTAB: u16 = 3u16; if (hasdata) { SH_DATA = 3u16; if (hasdatarelocs) { SH_RELAD = 4u16; SH_SYMTAB = 5u16; } else { SH_SYMTAB = 4u16; }; }; let SH_STRTAB: u16 = SH_SYMTAB + 1u16; let SH_SHSTR: u16 = SH_STRTAB + 1u16; // Section name offsets. Append .data / .rela.data only when // used so the .shstrtab buffer stays byte-identical for the // no-DATAW case (test 991 byte-diff invariant). let shntext: u32 = bufputcstr(&shstr, ".text"); let shnrela: u32 = bufputcstr(&shstr, ".rela.text"); let shndata: u32 = 0u32; let shnrelad: u32 = 0u32; if (hasdata) { shndata = bufputcstr(&shstr, ".data"); }; if (hasdata) { if (hasdatarelocs) { shnrelad = bufputcstr(&shstr, ".rela.data"); };}; let shnsymtab: u32 = bufputcstr(&shstr, ".symtab"); let shnstrtab: u32 = bufputcstr(&shstr, ".strtab"); let shnshstrtab: 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); // 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 stname: u32 = bufputcstr(&str_, s.name); wru32(entry.ptr, 0u64, stname); if (s.defined != 0) { if (s.isdata != 0) { wru8(entry.ptr, 4u64, ((STB_GLOBAL << 4u8) | STT_OBJECT)); wru16(entry.ptr, 6u64, SH_DATA); } else { 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 — split into text vs data buffers. let r: *areloc = a.relocs; for (r != nil) { let entry: [24]u8; wru64(entry.ptr, 0u64, r.off); let rinfo: u64 = (r.asy.idx: u64 << 32u64) | (r.kind: u64 & 4294967295u64); wru64(entry.ptr, 8u64, rinfo); wru64(entry.ptr, 16u64, r.addend: u64); if (r.section == 1) { bufputb(&relad, entry.ptr, 24u64); } else { bufputb(&rela, entry.ptr, 24u64); }; r = r.rnext; }; // File offsets. let off: u64 = EHDR_SZ; let offtext: u64 = off; off = off + a.textlen; let offrela: u64 = off; off = off + rela.n; let offdata: u64 = off; if (hasdata) { off = off + a.datalen; }; let offrelad: u64 = off; if (hasdata) { if (hasdatarelocs) { off = off + relad.n; };}; let offsym: u64 = off; off = off + sym.n; let offstr: u64 = off; off = off + str_.n; let offshstr: u64 = off; off = off + shstr.n; for ((off & 7u64) != 0u64) { off += 1u64; }; let offshdr: u64 = off; let NSECT: u16 = 6u16; if (hasdata) { if (hasdatarelocs) { NSECT = 8u16; } else { NSECT = 7u16; }; }; // ---- 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, offshdr); // 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, SH_SHSTR); // e_shstrndx if (!wrn(fd, eh.ptr, 64u64, 64i64)) { return -1; }; if (a.textlen > 0u64) { if (!wrn(fd, a.text, a.textlen, a.textlen: i64)) { return -1; }; }; if (rela.n > 0u64) { if (!wrn(fd, rela.p, rela.n, rela.n: i64)) { return -1; }; }; if (hasdata) { if (a.datalen > 0u64) { if (!wrn(fd, a.data, a.datalen, a.datalen: i64)) { return -1; }; }; if (hasdatarelocs) { if (relad.n > 0u64) { if (!wrn(fd, relad.p, relad.n, relad.n: i64)) { return -1; }; }; }; }; if (sym.n > 0u64) { if (!wrn(fd, sym.p, sym.n, sym.n: i64)) { return -1; }; }; if (str_.n > 0u64) { if (!wrn(fd, str_.p, str_.n, str_.n: i64)) { return -1; }; }; if (shstr.n > 0u64) { if (!wrn(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; if (hasdata) { written += a.datalen; if (hasdatarelocs) { written += relad.n; }; }; for ((written & 7u64) != 0u64) { wrdrop(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; }; wrdrop(fd, shbuf.ptr, 64u64); // .text sn = 0; for (sn < 64) { shbuf[sn] = 0u8; sn += 1; }; wru32(shbuf.ptr, 0u64, shntext); wru32(shbuf.ptr, 4u64, SHT_PROGBITS_C); wru64(shbuf.ptr, 8u64, SHF_ALLOC | SHF_EXECINSTR); wru64(shbuf.ptr, 24u64, offtext); wru64(shbuf.ptr, 32u64, a.textlen); wru64(shbuf.ptr, 48u64, 1u64); // sh_addralign wrdrop(fd, shbuf.ptr, 64u64); // .rela.text sn = 0; for (sn < 64) { shbuf[sn] = 0u8; sn += 1; }; wru32(shbuf.ptr, 0u64, shnrela); wru32(shbuf.ptr, 4u64, SHT_RELA_C); wru64(shbuf.ptr, 8u64, SHF_INFO_LINK); wru64(shbuf.ptr, 24u64, offrela); wru64(shbuf.ptr, 32u64, rela.n); wru32(shbuf.ptr, 40u64, SH_SYMTAB: u32); // sh_link wru32(shbuf.ptr, 44u64, 1u32); // sh_info = .text idx wru64(shbuf.ptr, 48u64, 8u64); wru64(shbuf.ptr, 56u64, RELA_SZ); wrdrop(fd, shbuf.ptr, 64u64); if (hasdata) { // .data sn = 0; for (sn < 64) { shbuf[sn] = 0u8; sn += 1; }; wru32(shbuf.ptr, 0u64, shndata); wru32(shbuf.ptr, 4u64, SHT_PROGBITS_C); wru64(shbuf.ptr, 8u64, SHF_ALLOC | SHF_WRITE); wru64(shbuf.ptr, 24u64, offdata); wru64(shbuf.ptr, 32u64, a.datalen); wru64(shbuf.ptr, 48u64, 8u64); // sh_addralign wrdrop(fd, shbuf.ptr, 64u64); if (hasdatarelocs) { // .rela.data sn = 0; for (sn < 64) { shbuf[sn] = 0u8; sn += 1; }; wru32(shbuf.ptr, 0u64, shnrelad); wru32(shbuf.ptr, 4u64, SHT_RELA_C); wru64(shbuf.ptr, 8u64, SHF_INFO_LINK); wru64(shbuf.ptr, 24u64, offrelad); wru64(shbuf.ptr, 32u64, relad.n); wru32(shbuf.ptr, 40u64, SH_SYMTAB: u32); wru32(shbuf.ptr, 44u64, SH_DATA: u32); // applies to .data wru64(shbuf.ptr, 48u64, 8u64); wru64(shbuf.ptr, 56u64, RELA_SZ); wrdrop(fd, shbuf.ptr, 64u64); }; }; // .symtab sn = 0; for (sn < 64) { shbuf[sn] = 0u8; sn += 1; }; wru32(shbuf.ptr, 0u64, shnsymtab); wru32(shbuf.ptr, 4u64, SHT_SYMTAB_C); wru64(shbuf.ptr, 24u64, offsym); wru64(shbuf.ptr, 32u64, sym.n); wru32(shbuf.ptr, 40u64, SH_STRTAB: u32); // sh_link wru32(shbuf.ptr, 44u64, 1u32); // sh_info = one local (STN_UNDEF) wru64(shbuf.ptr, 48u64, 8u64); wru64(shbuf.ptr, 56u64, SYM_SZ); wrdrop(fd, shbuf.ptr, 64u64); // .strtab sn = 0; for (sn < 64) { shbuf[sn] = 0u8; sn += 1; }; wru32(shbuf.ptr, 0u64, shnstrtab); wru32(shbuf.ptr, 4u64, SHT_STRTAB_C); wru64(shbuf.ptr, 24u64, offstr); wru64(shbuf.ptr, 32u64, str_.n); wru64(shbuf.ptr, 48u64, 1u64); wrdrop(fd, shbuf.ptr, 64u64); // .shstrtab sn = 0; for (sn < 64) { shbuf[sn] = 0u8; sn += 1; }; wru32(shbuf.ptr, 0u64, shnshstrtab); wru32(shbuf.ptr, 4u64, SHT_STRTAB_C); wru64(shbuf.ptr, 24u64, offshstr); wru64(shbuf.ptr, 32u64, shstr.n); wru64(shbuf.ptr, 48u64, 1u64); wrdrop(fd, shbuf.ptr, 64u64); return 0; }; // MODULE: w6a // 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.flag.RDONLY, 0i32); if (fd < 0) { return nil, 0u64; }; let szr: (i64 | os.oserror) = os.filesize(fd); let n: i64 = 0i64; match (szr) { case let v: i64 => n = v; case let e: os.oserror => { os.close(fd); return nil, 0u64; }; }; let nz: u64 = n: u64; let buf: *u8 = os.alloc(nz + 1u64): *u8; let rr: (i64 | os.oserror) = os.readall(fd, buf, nz); os.close(fd); let got: i64 = 0i64; match (rr) { case let v: i64 => got = v; case let e: os.oserror => return nil, 0u64; }; 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.flag.WRONLY | os.flag.CREATE | os.flag.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; };